# LGTM — Looks Good To Meow > AI code review + CI/CD security for GitHub pull requests. India-built, > INR-priced (₹0 Free / ₹399 Pro). Six specialist review agents, sixteen > CI/CD security detectors. BYOK — bring your own OpenAI / Anthropic / > Gemini key. This file is the single-file documentation dump intended for LLMs and AI coding assistants. The same content is browsable at https://docs.looksgoodtomeow.in/docs. Last updated: 2026-06-29. --- ## What LGTM is LGTM is a hosted code-review service. When a developer opens a pull request on a connected GitHub repository: 1. GitHub sends LGTM a webhook. 2. LGTM fetches the PR diff via its GitHub App installation token. 3. Six LLM agents run in parallel — bugs, security, performance, readability, best-practices, documentation — each emitting structured findings. 4. A synthesizer agent merges the six reports into one verdict (`approve` / `request_changes` / `comment`) and writes inline review comments on the PR. 5. The review is persisted; users can view it on the dashboard, the CLI, or a public-share URL (`/review/:id`). Reviews run on the user's own AI provider key (BYOK). LGTM doesn't see the user's OpenAI / Anthropic / Gemini API token — it's encrypted at rest and decrypted only inside the worker process at review time. A separate "LGTM Security" feature scans GitHub Actions workflows, Dockerfiles, and IaC configs for 16 supply-chain risks; it can block merges, send Slack/email alerts, or auto-revert pushes via a watchdog GitHub Action. LGTM is hosted on Fly.io in the Singapore region. The same React bundle serves three subdomains: - `looksgoodtomeow.in` — marketing apex + public review pages - `app.looksgoodtomeow.in` — authenticated dashboard - `docs.looksgoodtomeow.in` — public docs (this file lives here) --- ## Plans and pricing ### Free — ₹0 / month - 20 PR reviews per calendar month (counter resets on the 1st, UTC) - The counter rolls over — deleting and re-signing up with the same GitHub identity does NOT reset usage (anti-abuse guard) - All six review agents (bugs, security, performance, readability, best-practices, documentation) - All sixteen LGTM Security detectors (read-only access; enrolling new repos for monitoring requires Pro) - CLI + Dashboard access - BYOK — supply your own OpenAI / Anthropic / Gemini key - Tree-sitter context indexing (best-effort) ### Pro — ₹399 / month - Unlimited PR reviews - **Auto-review**: every PR opened / synchronized / reopened on a connected repo gets reviewed automatically — no manual click - LGTM Security: enroll repos for push-time scanning, edit per-rule policies, mint runtime watchdog tokens, send alerts to Slack / email - BYOK + per-repo model overrides (you can pin gpt-4o for repo A and claude-opus for repo B) - Priority support Payments via Dodo Payments (PCI-compliant Indian Payment Aggregator). GST is handled automatically by Dodo. Cancel anytime from Settings or the Dodo customer portal — your Pro features stay on until the end of the current billing cycle. If a charge fails, LGTM enters a **3-day grace period** during which Pro features remain active and Dodo automatically retries the card. Day-1, day-2, and day-3 reminder emails are sent. If recovery doesn't happen, the account is automatically downgraded to Free on day 4 — but no data is deleted (monitors are paused, not removed; past reviews and findings stay visible). ### Refunds and chargebacks A refund issued from the Dodo portal (or by support) demotes the user to Free immediately and sends a notification email. A chargeback / dispute also demotes (we'd otherwise be giving away service we've been charged back for); if LGTM contests and wins the dispute, Pro is automatically restored. --- ## Getting started ### 1. Sign in Visit https://app.looksgoodtomeow.in/login and click "Sign in with GitHub". LGTM uses GitHub OAuth — no email/password, no separate account creation. If you're a brand-new user, you'll be routed to a one-screen consent form to accept the current Terms of Service (v1.x) and Privacy Policy (v1.x). You can optionally opt-in to marketing emails. ToS and Privacy are **required**; marketing is optional and can be toggled later under Settings → Privacy & Consents. ### 2. Install the GitHub App From the dashboard, click "Connect repository" and follow the GitHub App install flow. The app needs: - Read access to repository code, metadata, and pull requests - Write access to pull request comments and check runs (so LGTM can post review verdicts) - Webhook subscription to `pull_request` and `push` events You can install on individual repos or "All repositories"; LGTM only acts on repos you explicitly **connect** afterwards from the dashboard. ### 3. Configure an AI provider (BYOK) Settings → AI Providers → "Add provider". Paste your OpenAI / Anthropic / Gemini key. LGTM validates it against the provider's API before saving. The key is AES-encrypted at rest and decrypted only inside the review worker process; it never leaves our infrastructure unencrypted and is never logged. Set a default model under Settings → Default Model. You can override this per-repo (Pro only) under each repo's settings. ### 4. Trigger your first review Two paths: - **Dashboard**: click any PR in the list → click "Review". The review panel streams agent progress in real time via WebSocket. - **CLI**: `lgtm review` (against your local working tree) or `lgtm review --pr 42` (against an open PR). A review takes 30–90 seconds depending on diff size and model latency. --- ## Agent architecture Every review runs the same pipeline. Each box is an isolated agent that produces structured JSON findings, then the synthesizer merges them into the final verdict. ``` GitHub webhook → Diff parser → Context builder (tree-sitter index + focused snippets) → 6 agents in parallel: bugs · security · performance · readability · best-practices · documentation → Synthesizer (LLM that reads all six reports + diff) → Verdict + inline comments → POST to GitHub review API ``` ### The six agents 1. **Bugs** — null derefs, off-by-one, missing await, unhandled error paths, returning the wrong type, race conditions. 2. **Security** — SQL/NoSQL injection, XSS, broken auth, secrets in diff, weak crypto, OWASP top-10 coverage on the diff hunks. 3. **Performance** — N+1 queries, blocking I/O on the hot path, regex catastrophic backtracking, unnecessary re-renders. 4. **Readability** — naming, function length, deeply-nested conditions, dead code, unclear control flow. 5. **Best-practices** — language idioms (TS strict types, Go error wrapping, Python type hints), framework conventions (React effect deps, Express middleware order). 6. **Documentation** — missing JSDoc / docstrings on exported functions, comments that contradict code, stale TODOs. ### Focus areas A repo's connected settings include `focusAreas: string[]`. If set (e.g. `["security", "bugs"]`), only those agents run on PRs to that repo — saves tokens on small teams who only care about a subset. Defaults to all six. ### Synthesizer The synthesizer receives the diff + all six agent JSON reports + optional repo context (tree-sitter symbols, recent PR summaries). It emits: - `overallVerdict`: `approve` / `request_changes` / `comment` - `finalSummary`: 2-4 sentence executive summary - `confidenceScore`: 0-100 - inline comments mapped to `(file, line)` for GitHub's review API Inline comments are deduplicated against the original agents' findings — a finding flagged by both Bugs and Security gets one comment, not two. --- ## Context indexer For repos with the indexer enabled (under Settings → Context Indexing), LGTM parses the codebase with tree-sitter and builds a symbol index covering supported languages: - TypeScript, JavaScript, JSX/TSX - Python - Go - Rust - Java - Ruby - C, C++ - C# Plus a "convention extractor" that scans for repo idioms (preferred HTTP client, error-handling pattern, common helpers) and a "history extractor" that summarizes recent PR descriptions. The index lets the review agents look up symbol definitions outside the diff — e.g. if the PR calls `validateUser()`, the agent can see the function's signature and body for grounded reasoning. Without it, agents only see the diff hunks. Indexing runs as a background BullMQ job. A connected repo can be indexed once (manual button: "Index Codebase") and is then kept fresh incrementally on every push. Large repos may take a few minutes; the dashboard shows live progress. The indexer does NOT send full source code to the LLM — only the specific symbol bodies the agent looked up. The full tree-sitter index stays on LGTM's MongoDB. --- ## LGTM Security Separate feature from the per-PR review pipeline. Enroll a repo from the Dashboard → Security → "Enroll repo". ### What it scans 16 CI/CD-focused detectors covering supply-chain and DevOps risks: - **GitHub Actions workflows** (.github/workflows/*.yml): - Self-hosted runner on public repo (fork-pwn risk) - Untrusted input flowing into `run:` blocks (script injection) - Action pinned to mutable ref (branch / tag) instead of commit SHA - Action using deprecated workflow commands (`set-output`, `save-state`) - Missing `permissions:` block (default-permissive token leaks) - `pull_request_target` reading PR-controlled code - Secret exfil via `${{ env.SECRET }}` echo - **Dockerfiles**: - `:latest` tag in FROM - `apt-get` without `--no-install-recommends` - `ADD` instead of `COPY` for local files - `curl | sh` piping - Running as root (no USER) - **IaC** (terraform, k8s manifests): - S3 bucket world-readable - Security group `0.0.0.0/0` on sensitive ports - K8s pod without resource limits - Hardcoded creds in environment ### Three enforcement modes Per-rule policy, configurable on the Dashboard → Security → [Repo] → Policy: - `off` — finding shown in dashboard, no GitHub action - `warn` — non-blocking comment on PR - `block` — fails the GitHub check, blocks merge until resolved ### Runtime watchdog In addition to scanning PRs, LGTM Security ships a GitHub Action (`tarinagarwal/lgtm-security-watchdog@v1`) that runs on every push to your default branch. It detects pushes that bypassed PR review (force pushes, direct commits by privileged users) and either: - Posts a notification, OR - Auto-creates a revert PR Mint a watchdog token from Dashboard → Security → API Tokens. Tokens are write-only to LGTM (the Action posts findings; LGTM has no GitHub-write access via this token). ### Audit log Every scan produces an immutable `SecurityAuditLog` entry — finding + file + line + ruleId + scanId + timestamp. Past findings can be marked "resolved", "false_positive", or "won't fix" but never deleted (audit integrity). ### Read-only access for Free users Users who were Pro and downgraded keep read-only access to their existing Security data (audit log, monitor list, scan history). Writes (enroll new repo, run manual scan, edit policy, mint token) require Pro. Existing monitors are auto-paused on downgrade with a banner explaining "Upgrade to resume monitoring". --- ## AI providers LGTM supports three providers, all via BYOK: - **OpenAI** — GPT-4o, GPT-4-turbo, GPT-4o-mini, o1 - **Anthropic** — Claude Opus, Claude Sonnet, Claude Haiku - **Google Gemini** — Gemini 2.0 Pro, Gemini 2.0 Flash Each provider key is validated against a lightweight `/v1/models` fetch before saving. Saved keys are revalidated periodically; if a key starts returning 401, the user gets an in-app notification + a banner under Settings. ### Per-repo overrides (Pro) Free users have a single global default. Pro users can override provider + model per repo from each repo's settings card. Useful when one repo is a Rust monorepo (you want gpt-4o) and another is a React app (Claude Sonnet does the readability work cheaply). ### Rate limiting + retry Provider 429s are retried with exponential backoff (3 attempts: 1s → 4s → 16s + jitter). 5xx and timeouts also retry. 4xx other than 429 fail fast — invalid API key won't be fixed by retrying. --- ## Review pipeline (deep) 1. **Webhook received** — GitHub sends `pull_request`, `pull_request.synchronize`, or `pull_request.reopened`. Signature verified via `X-Hub-Signature-256` HMAC against the configured `GITHUB_WEBHOOK_SECRET`. Idempotency: every webhook is keyed by `X-GitHub-Delivery` in MongoDB; a duplicate delivery returns 200 without re-enqueuing. 2. **Auto-review gate** — webhook handler checks: - Repo is `isActive: true` - Repo has auto-review enabled (Pro) OR this is a manual trigger - Owner has billing slot available (`reserveReview()` atomic increment against `billing.reviewsUsedThisMonth`) - Owner has consent recorded for the current Terms + Privacy versions If all pass, the job is added to the BullMQ `review` queue. 3. **Diff parsing** — worker fetches the PR diff via GitHub App installation token (15s timeout, 3-attempt retry). Parses unified diff format into per-file hunks. 4. **Context building** — if the repo is indexed, tree-sitter symbols referenced in the diff are looked up and attached to the agent prompts. 5. **Agents (parallel)** — six BullMQ child jobs, one per agent. Each gets the diff + relevant context + a system prompt scoped to its role. LLM call uses the user's BYOK key with the resolved provider + model (per-repo override falls back to user default). 6. **Synthesizer** — receives all six reports + the diff + context + any per-repo "review guidelines" the user set. Outputs the final verdict + summary + dedup'd inline comments. 7. **GitHub posting** — single `POST /repos/{owner}/{repo}/pulls/ {pr}/reviews` with the verdict and inline comments. If the call returns 422 (typically: line not found in current diff because the PR was force-pushed mid-review), retry once without inline comments (just the summary). 8. **Persistence** — Review document written to MongoDB. Socket event `review:completed` broadcast to the user's room so the dashboard updates in real time. Failures at any step emit a Sentry exception + a user-visible notification (in-app + email). --- ## Configuration ### Per-user settings Under Dashboard → Settings: - AI providers (add / validate / remove keys) - Default provider + model - Notification preferences (email, in-app, marketing) - Privacy & Consents (Terms + Privacy version log, marketing toggle) - Plan + billing (Pro upgrade, customer portal, cancel) - Delete account (anonymizes PII, cancels Dodo sub, keeps audit shells for compliance) ### Per-repo settings Under Dashboard → Repositories → [Repo]: - Auto-review on/off (Pro only) - Focus areas (subset of the 6 agents) - PR-chat on/off + allowed slash commands - Daily chat reply limit (`/lgtm` mention answers per day) - AI provider + model override (Pro only) - Custom review guidelines (free-text appended to every review prompt) --- ## GitHub integration ### App permissions | Resource | Access | Used for | |----------|--------|----------| | Contents | Read | Fetching PR diffs and indexed code | | Pull requests | Read + write | Posting review comments + checks | | Issues | Read | (Future: cross-linking issues to reviews) | | Metadata | Read | Repo names + visibility | | Checks | Write | Posting the LGTM Security blocking gate | ### Webhook events subscribed - `pull_request` (opened, synchronize, reopened, closed) - `push` (default-branch only — triggers Security watchdog) - `installation` (track app install / uninstall) - `installation_repositories` (added / removed repos to existing install) ### Disconnecting Either uninstall the GitHub App from your GitHub settings, or click "Disconnect" on a repo in the Dashboard. Disconnect leaves past reviews and audit log entries intact; future PR events stop being processed. --- ## Real-time dashboard The dashboard uses Socket.io connected to the same server. Every authenticated user joins a user-scoped room; the server broadcasts events as workers progress: - `review:started` — pipeline kicked off - `agent:started` / `agent:completed` / `agent:failed` — per-agent - `synthesizer:started` / `review:completed` — final verdict ready - `context:started` / `context:progress` / `context:completed` / `context:failed` — indexer - `security:scan_started` / `security:scan_completed` - `notification:new` — new in-app notification The dashboard also shows a disconnect banner if the socket drops for more than ~2s — amber "reconnecting…" pulse, escalating to a red "realtime connection lost" pill with a reload prompt past 30s. --- ## CLI Install: `npm i -g @tarin/lgtm-cli`. The CLI talks to the same API the dashboard uses (Bearer token in `~/.lgtm/config.json`). Output mode: human-readable by default, `--json` for scriptable. ### Auth & account ``` lgtm login Authenticate via GitHub OAuth (opens browser) lgtm logout Clear local session lgtm whoami Show user, plan, AI config, grace/cancel state lgtm doctor Diagnose setup (Node, git, auth, API, AI provider key, consent, plan) lgtm consent show View current ToS + Privacy + marketing state lgtm consent accept Accept current versions (--marketing for opt-in) lgtm consent marketing on|off Toggle marketing-only lgtm account delete Delete account (type-DELETE confirm) ``` ### Code review ``` lgtm review Review working-tree diff vs detected default branch lgtm review --staged Review staged diff only lgtm review --base main Override base branch lgtm review --pr 42 Trigger a review on PR #42 of the current repo lgtm review --provider openai --model gpt-4o Override provider + model lgtm pr list List recent reviewed PRs lgtm pr view 42 Show PR #42 review lgtm pr review 42 Trigger a review (alias for `review --pr 42`) lgtm pr open 42 Open PR #42's review report in browser ``` ### Repos ``` lgtm repo connect Connect current repo (or --repo owner/name) lgtm repo status Show current repo's connection + index state lgtm repo list List all connected repos lgtm repo settings View / update per-repo settings lgtm repo index Build / refresh context index ``` ### Configuration ``` lgtm config set-key Add a provider API key (validates) lgtm config set-model Set default model lgtm config show Show config (table or --json) lgtm config remove-key Remove a provider key ``` ### LGTM Security ``` lgtm security enroll Enroll a repo (current or --repo) lgtm security list List enrolled repos + posture counts lgtm security scan Trigger a manual scan lgtm security audit View audit log lgtm security policy show Show current per-rule policy lgtm security policy set Override rule severity / mode lgtm security tokens create Mint a runtime watchdog token lgtm security tokens list List active tokens lgtm security tokens revoke Revoke a token ``` ### Billing ``` lgtm billing status Plan, quota, grace + cancellation state lgtm billing cancel Schedule cancel-at-period-end lgtm billing portal Open Dodo customer portal ``` ### Other ``` lgtm notifications list Read in-app notifications lgtm analytics overview Read-only analytics dashboard lgtm open Open a dashboard page in browser lgtm completion Shell completion script (bash/zsh/fish) ``` ### Error codes (CLI) The CLI classifies API errors into stable codes so scripts can branch: - `not_logged_in` — run `lgtm login` - `pro_required` — feature behind paywall; visit `lgtm open pricing` - `billing_limit` — Free quota exhausted (20/month) - `consent_required` — accept current ToS + Privacy: `lgtm consent accept` - `auth_expired` / `auth_failed` — re-login - `rate_limited` — slow down, retry after a few seconds - `network_error` / `timeout` — check internet, status page - `server_error` — server 5xx; usually transient --- ## FAQ **Does LGTM store our source code?** No. We only persist the parsed diff hunks the reviewers ran against, not the full repo. The tree-sitter context index stores symbol names and signatures (not source bodies) on MongoDB. The full source is fetched fresh from GitHub at review time using the installation token, held in worker memory for the duration of the review (typically 30–90s), and discarded. **How does BYOK work? Do you see our OpenAI tokens?** Your API keys are AES-256 encrypted with a server-side master key before being stored. Decryption happens only inside the worker process at the moment a review fires, in memory; never logged, never returned to the dashboard except as a redacted prefix. We can't read your key in our database without the master key, which lives in Fly secrets and rotates separately. **Which OpenAI models are supported?** GPT-4o, GPT-4-turbo, GPT-4o-mini, and o1. The list refreshes as OpenAI ships new models — we don't lock in old SKUs. **When will Anthropic Claude and Google Gemini be live?** Live now. Claude Opus / Sonnet / Haiku + Gemini 2.0 Pro / Flash are all supported. **How fast is a typical review?** 30–90 seconds end-to-end on PRs under 500 lines diff. Larger PRs scale linearly until they hit the model's context window, at which point the diff is chunked. Multi-file PRs run the six agents concurrently, so wall-clock is gated by the slowest agent (usually security on complex diffs). **What languages does tree-sitter context support?** TypeScript, JavaScript, Python, Go, Rust, Java, Ruby, C, C++, C#. Adding a language requires a tree-sitter grammar; PRs welcome. **Does LGTM support monorepos?** Yes. The context indexer treats the repo as one workspace and the review agents only look at symbols referenced by the PR diff, so a 50-package monorepo doesn't bloat any single review. We don't currently support per-package config (one set of focus areas for all packages in the monorepo). **How does LGTM Security block a bad merge?** When a repo is enrolled and a PR includes changes to a watched file, LGTM Security writes a `check_run` to GitHub with `status: in_progress`, runs the 16 detectors against the diff, then updates the check to `success` / `neutral` / `failure` depending on whether any rule is set to `block` mode. Branch protection rules on the user's side honor this check the same way they'd honor any other CI. **Which security detectors does LGTM run?** Sixteen detectors covering GitHub Actions, Docker, and IaC. Full list is in the "LGTM Security" section above. **Can I disable or downgrade individual security rules?** Yes. Dashboard → Security → [Repo] → Policy. Each rule supports `off` / `warn` / `block`. Pro only. **What's the difference between auto-review and manual review?** Auto-review fires for every PR opened / synchronized / reopened on a connected repo. Pro only. Manual review is the "Review" button on the dashboard (or `lgtm review --pr ` from the CLI) — works on Free too, but counts against the 20-per-month quota. **How does the CLI authenticate?** `lgtm login` opens a browser, runs GitHub OAuth, and writes a Bearer token to `~/.lgtm/config.json`. The token refreshes automatically; the CLI re-runs login only when the refresh token is also expired. **Where is LGTM hosted and who runs it?** Fly.io, Singapore region (lowest-latency Asia POP for Indian users). Run by a solo founder. India-based, GST-registered via Dodo Payments. **Is LGTM compliant with India's DPDP Act?** Yes. We collect only data necessary to deliver the service (GitHub identity, AI provider key, repo metadata). Consent for processing is recorded with version + timestamp + IP + user agent. Marketing consent is opt-in (you can withdraw any time from Settings without deleting your account). Withdrawal of required consents (ToS, Privacy) means deleting your account; the soft-delete keeps `githubId` for abuse prevention but anonymizes everything else. **What does Pro unlock that Free doesn't?** Two things. (1) Unlimited reviews instead of the 20-per-month Free cap. (2) Auto-review on every PR — Free users can still trigger reviews manually on the dashboard or via `lgtm review --pr `, but Pro fires reviews automatically on every `opened` / `synchronize` / `reopened` event. Both tiers get the same 6 LLM specialists, same 16 security detectors, same CLI, same dashboard, same audit log. ₹399/month, cancel anytime via Dodo Payments — no contracts, no minimums. **Can I run LGTM on a private/internal repo?** Yes. Install the GitHub App with access to private repos and connect them like any public repo. Tree-sitter indexing and review both work the same way. Your code never leaves our worker process beyond the LLM call (which goes to YOUR provider with YOUR key). **How are inline comments placed on the PR?** The synthesizer's findings include `(file, line)` tuples. LGTM deduplicates against earlier reviews on the same PR (so a re-review after a fix doesn't repeat resolved comments) and POSTs the review to GitHub with all comments in one call. If GitHub rejects with 422 (usually a line-number mismatch from a force-push), LGTM retries without inline comments, posting just the summary. **What's the LGTM Security Watchdog GitHub Action?** A small GitHub Action you install on your default branch. It runs on every push and detects pushes that bypassed PR review (force pushes, direct commits by privileged users), then notifies LGTM. LGTM either sends a Slack/email alert or auto-creates a revert PR — your choice per-repo. Auth via an LGTM-issued API token (mint from Dashboard → Security → API Tokens). --- ## Operational details ### Hosting - **Application**: Fly.io, Singapore region - **5 process groups**: api, review-worker, security-worker, index-incremental, index-backfill - **Database**: MongoDB Atlas - **Cache + queues**: Redis (Upstash); shared across BullMQ workers, rate limiters, and Socket.io adapter - **Email**: Resend / SMTP fallback - **Errors / monitoring**: Sentry - **Payments**: Dodo Payments (Indian Payment Aggregator, live mode) ### Auth model GitHub OAuth → JWT access token (24h) + refresh token (7d). Tokens are stored in localStorage on the client (with safe fallback to in-memory if localStorage is disabled). Cookies are also set, scoped to `Domain=.looksgoodtomeow.in` so they travel between apex, app, and docs subdomains. ### Webhook idempotency All inbound webhooks (Dodo, GitHub) are deduplicated by their provider-issued message ID. A duplicate retry returns 200 without running side effects. The dedup log auto-expires at 30 days. ### Subscription state machine `active` → `grace_period` (3-day dunning window after failed payment) → either `active` (recovered) or `cancelled` / `expired` / `failed`. The dunning cron runs every 6 hours behind a Redis distributed lock (single-instance across all process groups). Demotion emails are queued with retry; if SMTP is down, the demotion still happens but Sentry alerts ops. ### Data retention | Data | Retention | |------|-----------| | User account | Indefinite while active; soft-deleted on account delete (githubId kept for abuse prevention) | | AI provider keys | While account active; cleared on delete | | Reviews | Indefinite (your IP, your decision to delete) | | Indexed code symbols | Refreshed on every push; deleted on repo disconnect | | Security audit log | Indefinite (compliance) | | Webhook events | 30 days (idempotency window) | | Server logs | 14 days | | Sentry events | 90 days | ### Support - Email: tarinagarwal@gmail.com - Status: https://status.looksgoodtomeow.in (planned) - Source / issues: not currently public (closed-source SaaS) --- ## License + IP LGTM is closed-source proprietary software. The CLI (`@tarin/lgtm-cli`) is published under a permissive license on npm. The watchdog GitHub Action is published under MIT on GitHub. The trademark "LGTM — Looks Good To Meow", the lgtm.dev / looksgoodtomeow.in domains, and the cat logo are property of the founder. --- End of llms-full.txt. For browsable rendering, see https://docs.looksgoodtomeow.in/docs. For the short index, see https://docs.looksgoodtomeow.in/llms.txt.