limn-review 0.1.123

package/dist/cli.js

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+import { execFile, execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+// ── tiny ANSI helpers (degrade gracefully when not a TTY) ──────────────────
+const useColor = process.stdout.isTTY && process.env.NO_COLOR === undefined;
+const paint = (code, s) => useColor ? `[${code}m${s}` : s;
+const cyan = (s) => paint('36', s);
+const dim = (s) => paint('2', s);
+const bold = (s) => paint('1', s);
+function parseArgs(argv) {
+    const opts = { open: true, cloud: false, help: false };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case '--no-open':
+                opts.open = false;
+                break;
+            case '--cloud':
+                opts.cloud = true;
+                break;
+            case '--mode': {
+                const v = argv[++i];
+                if (v !== 'local' && v !== 'cloud') {
+                    console.error('--mode requires `local` or `cloud`');
+                    process.exit(1);
+                }
+                opts.cloud = v === 'cloud';
+                break;
+            }
+            case '--port': {
+                const v = argv[++i];
+                const n = v ? Number.parseInt(v, 10) : NaN;
+                if (!Number.isFinite(n)) {
+                    console.error('--port requires a number');
+                    process.exit(1);
+                }
+                opts.port = n;
+                break;
+            }
+            case '--db': {
+                const v = argv[++i];
+                if (!v) {
+                    console.error('--db requires a path');
+                    process.exit(1);
+                }
+                opts.db = v;
+                break;
+            }
+            case '--help':
+            case '-h':
+                opts.help = true;
+                break;
+            default:
+                console.error(`Unknown argument: ${arg}`);
+                console.error('Run `limn --help` for usage.');
+                process.exit(1);
+        }
+    }
+    return opts;
+}
+function printUsage() {
+    console.log(`limn — ${'local-only GitHub PR activity dashboard'}
+
+Usage:
+  limn [options]
+  limn status [options]
+  limn ai install
+
+Commands:
+  status           Your cross-repo "my turn" queue in the terminal, with
+                   clickable links (see \`limn status --help\`)
+  ai install       Download the AI runtime Claude Review and AI Fix run on
+                   (one time, about 110 MB). The app offers the same button.
+  ai status        Say whether the AI runtime is set up
+
+Options:
+  --no-open        Don't open the browser (also honours NO_OPEN env)
+  --port <n>       Port to listen on (also PORT env, default 4000)
+  --db <path>      SQLite DB path (also DATABASE_URL env)
+  --cloud          Run the deployed (cloud) experience: Postgres + landing page
+                   + GitHub-App OAuth. Requires cloud env (see docs). Equivalent
+                   to DEPLOYMENT_MODE=cloud. Skips the gh-auth pre-check.
+  --mode <m>       'local' (default) or 'cloud'
+  -h, --help       Show this help
+
+The old \`pierre-review\` package now only forwards to this one; it will be removed.
+
+Your data lives in ~/.limn (LIMN_DATA_DIR overrides). An existing ~/.pierre-review
+is moved there once, on first start.
+
+Prerequisite (local mode):
+  Requires the GitHub CLI (https://cli.github.com), authenticated via
+  \`gh auth login\`. The dashboard reads your activity using your gh token.
+
+Prerequisite (--cloud):
+  Postgres + a GitHub sign-in method (an OAuth App and/or a GitHub App). See
+  docs/GITHUB-AUTH-SETUP.md. Provide DATABASE_URL, APP_BASE_URL, SESSION_SECRET,
+  ENCRYPTION_KEY, and at least one of GITHUB_OAUTH_CLIENT_ID+SECRET or
+  GITHUB_APP_CLIENT_ID+SECRET.
+`);
+}
+// Cross-platform browser open — no extra dependency.
+function openBrowser(url) {
+    const platform = process.platform;
+    const cmd = platform === 'darwin' ? 'open' : platform === 'win32' ? 'cmd' : 'xdg-open';
+    const args = platform === 'win32' ? ['/c', 'start', '""', url] : [url];
+    // Swallow failures — headless / no-DE environments are fine.
+    execFile(cmd, args, () => {
+        /* ignore */
+    });
+}
+// The default local SQLite location — a user-writable home dir, never the (possibly
+// read-only) install dir. Shared by the server boot and `limn status`. The FILE keeps its
+// pre-rename name on purpose: the one-time move of ~/.pierre-review → ~/.limn carries it (and its
+// WAL files) across untouched, and renaming a live SQLite file is a second migration for nothing.
+async function defaultLocalDbPath() {
+    const { resolveDataDir } = await import('./data-dir.js');
+    return join(resolveDataDir(), 'pierre-review.sqlite');
+}
+// Move a pre-rename ~/.pierre-review to ~/.limn, once, before anything reads a path inside it.
+// Never clobbers an existing ~/.limn; never moves into an explicit LIMN_DATA_DIR.
+async function migrateDataDir() {
+    const { migrateLegacyDataDir } = await import('./data-dir.js');
+    migrateLegacyDataDir({ log: (msg) => console.log(`  ${dim(msg)}`) });
+}
+// Fail fast with a friendly message when the GitHub CLI isn't installed / authed.
+// Both the local server boot and `limn status` need a working `gh` token.
+function ghAuthPreCheck() {
+    try {
+        execFileSync('gh', ['auth', 'token'], { stdio: 'ignore' });
+    }
+    catch {
+        console.error('');
+        console.error(bold('GitHub CLI not found or not authenticated.'));
+        console.error('Install the GitHub CLI (https://cli.github.com) and run `gh auth login`.');
+        console.error('');
+        process.exit(1);
+    }
+}
+function parseStatusArgs(argv) {
+    const opts = {
+        watch: false,
+        sync: false,
+        intervalSeconds: 60,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case '--watch':
+                opts.watch = true;
+                break;
+            case '--sync':
+                opts.sync = true;
+                break;
+            case '--interval': {
+                const v = argv[++i];
+                const n = v ? Number.parseInt(v, 10) : NaN;
+                if (!Number.isFinite(n)) {
+                    console.error('--interval requires a number of seconds');
+                    process.exit(1);
+                }
+                opts.intervalSeconds = Math.max(10, n);
+                break;
+            }
+            case '--db': {
+                const v = argv[++i];
+                if (!v) {
+                    console.error('--db requires a path');
+                    process.exit(1);
+                }
+                opts.db = v;
+                break;
+            }
+            case '--help':
+            case '-h':
+                opts.help = true;
+                break;
+            default:
+                console.error(`Unknown argument: ${arg}`);
+                console.error('Run `limn status --help` for usage.');
+                process.exit(1);
+        }
+    }
+    return opts;
+}
+function printStatusUsage() {
+    console.log(`limn status — your cross-repo "my turn" queue in the terminal
+
+Usage:
+  limn status [options]
+
+Options:
+  --sync           Fetch fresh state from GitHub first (otherwise shows data as of
+                   the last sync). Under --watch, re-syncs at most every 5 minutes.
+  --watch          Repaint on an interval until you quit (Ctrl-C)
+  --interval <n>   Seconds between repaints under --watch (default 60, min 10)
+  --db <path>      SQLite DB path (also DATABASE_URL env)
+  -h, --help       Show this help
+
+Reads the local Limn database. Without --sync it shows data as of the last sync
+— run it alongside \`limn\`, or pass --sync to fetch fresh state first. Links are
+clickable in terminals that support OSC-8 hyperlinks.
+`);
+}
+async function runStatusCommand(argv) {
+    const opts = parseStatusArgs(argv);
+    if (opts.help) {
+        printStatusUsage();
+        process.exit(0);
+    }
+    // status is LOCAL-only — it reads your on-disk SQLite database directly.
+    if (process.env.DEPLOYMENT_MODE === 'cloud') {
+        console.error('`limn status` is local-only — it reads your local SQLite database.');
+        process.exit(1);
+    }
+    // Pin local BEFORE the dynamic import: config.ts loads .env files on import, and
+    // process.loadEnvFile never overrides an already-set var — so an .env-declared
+    // DEPLOYMENT_MODE=cloud can't flip status onto the Postgres driver after the guard.
+    process.env.DEPLOYMENT_MODE = 'local';
+    // ── map flags → env BEFORE any dynamic import (config/db snapshot env on load) ──
+    // resolve() the --db flag against the CWD (what the user means by a relative path);
+    // config.ts resolves relative paths against the INSTALL dir, so an unresolved value
+    // would make this guard check one file while the DB opens another.
+    process.env.NODE_ENV ??= 'production';
+    if (opts.db !== undefined)
+        process.env.DATABASE_URL = resolve(opts.db);
+    await migrateDataDir();
+    if (!process.env.DATABASE_URL)
+        process.env.DATABASE_URL = await defaultLocalDbPath();
+    try {
+        mkdirSync(dirname(process.env.DATABASE_URL), { recursive: true });
+    }
+    catch {
+        /* best-effort; client.ts also mkdirs */
+    }
+    // Friendlier than the server path: don't silently create an empty DB just to show
+    // an empty queue. --sync legitimately bootstraps a fresh DB, so skip the guard then.
+    if (!opts.sync && !existsSync(process.env.DATABASE_URL)) {
+        console.error(`No Limn database found at ${process.env.DATABASE_URL} — run \`limn\` first to sync, or pass --db.`);
+        process.exit(1);
+    }
+    // ensureLocalAccount (`gh api user`) and --sync both need a working gh token.
+    ghAuthPreCheck();
+    const { runStatus } = await import('./status.js');
+    await runStatus({
+        watch: opts.watch,
+        sync: opts.sync,
+        intervalSeconds: opts.intervalSeconds,
+    });
+}
+// ── `limn ai install` / `limn ai status` — the AI runtime, from the terminal ──────
+// The same download the app's "Set up AI" button runs (ai/runtime.ts): the pinned Agent SDK and
+// its three peers into ~/.limn/ai-runtime via `npm install --prefix`. Local only.
+async function runAiCommand(argv) {
+    const sub = argv[0];
+    if (sub !== 'install' && sub !== 'status') {
+        console.log(`limn ai — the AI runtime Claude Review and AI Fix run on
+
+Usage:
+  limn ai install   Download it (one time, about 110 MB) into ~/.limn/ai-runtime
+  limn ai status    Say whether it is set up
+
+Claude Review and AI Fix are free. They run on your own Claude Code or
+Anthropic API key: sign in to Claude Code, or set ANTHROPIC_API_KEY.
+Set LIMN_CLAUDE_PATH to use your installed \`claude\` and skip its bundled copy.
+`);
+        process.exit(sub === undefined || sub === '--help' || sub === '-h' ? 0 : 1);
+    }
+    if (process.env.DEPLOYMENT_MODE === 'cloud') {
+        console.error('AI review and fix run on your machine only: npx limn-review');
+        process.exit(1);
+    }
+    if (process.env.LIMN_AI_DISABLED === 'true') {
+        console.error('AI is turned off here (LIMN_AI_DISABLED=true).');
+        process.exit(1);
+    }
+    await migrateDataDir();
+    const { getAiRuntimeStatus, installAiRuntime, aiRuntimePins } = await import('./ai/runtime.js');
+    if (sub === 'status') {
+        const s = getAiRuntimeStatus();
+        const words = s.runtime === 'ready' ? 'AI is set up.' : 'AI is not set up. Run: limn ai install';
+        console.log(s.runtimeMessage ? `${words} ${s.runtimeMessage}` : words);
+        process.exit(s.runtime === 'ready' ? 0 : 1);
+    }
+    const pins = aiRuntimePins();
+    if (pins) {
+        console.log(bold('Setting up AI (one-time download, about 110 MB):'));
+        for (const [name, version] of Object.entries(pins))
+            console.log(`  ${dim(`${name}@${version}`)}`);
+    }
+    const result = await installAiRuntime((p) => {
+        if (p.phase === 'downloading')
+            console.log(`  ${dim(p.message)}`);
+        else if (p.phase !== 'failed')
+            console.log(`${cyan('▸')} ${p.message}`);
+    });
+    if (!result.ok) {
+        console.error(bold(result.message));
+        process.exit(1);
+    }
+}
+async function main() {
+    const argv = process.argv.slice(2);
+    // The package was renamed `pierre-review` → `limn-review` (bin `limn`). The old name survives as
+    // the forwarding stub's bin (scripts/deprecated-pierre-review/, never limn-review's own — that
+    // collides with an old global install); say so, once per start, on stderr so piped output is clean.
+    if (/^pierre(-review)?(\.(c?js|cmd|ps1))?$/.test(basename(process.argv[1] ?? ''))) {
+        console.error(dim('`pierre-review` is now `limn` (npm package: limn-review). The old name will be removed.'));
+    }
+    // `limn status` — a read-only subcommand with its own parser, usage, and env
+    // mapping. Peeled off BEFORE parseArgs (whose default case rejects any bare token),
+    // and it never reaches the server boot below.
+    if (argv[0] === 'status') {
+        await runStatusCommand(argv.slice(1));
+        return;
+    }
+    if (argv[0] === 'ai') {
+        await runAiCommand(argv.slice(1));
+        return;
+    }
+    const opts = parseArgs(argv);
+    if (opts.help) {
+        printUsage();
+        process.exit(0);
+    }
+    // ── map flags → env BEFORE importing config/app (config reads these) ──────
+    // --db is resolved against the CWD (config.ts resolves relative paths against the
+    // install dir, which is never what a user typing a relative path means).
+    if (opts.port !== undefined)
+        process.env.PORT = String(opts.port);
+    if (opts.db !== undefined)
+        process.env.DATABASE_URL = resolve(opts.db);
+    if (opts.open === false)
+        process.env.NO_OPEN = '1';
+    if (opts.cloud)
+        process.env.DEPLOYMENT_MODE = 'cloud';
+    const isCloud = process.env.DEPLOYMENT_MODE === 'cloud';
+    // Production mode: skip pino-pretty (not shipped) and enable static serving.
+    process.env.NODE_ENV ??= 'production';
+    if (!isCloud) {
+        // ── local: default the DB to a user-writable home location (mkdir -p) ────
+        // The package dir is read-only for global installs, so never write there.
+        await migrateDataDir();
+        if (!process.env.DATABASE_URL) {
+            process.env.DATABASE_URL = await defaultLocalDbPath();
+        }
+        try {
+            mkdirSync(dirname(process.env.DATABASE_URL), { recursive: true });
+        }
+        catch {
+            /* best-effort; client.ts also mkdirs */
+        }
+        // ── pre-check gh auth with a friendly message (contract §6) ─────────────
+        ghAuthPreCheck();
+    }
+    // Cloud mode: no gh pre-check (each account brings its own OAuth token) and no
+    // SQLite home default (DATABASE_URL must be a Postgres URL). config.ts /
+    // assertCloudConfig validate the required cloud env at boot.
+    const port = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : 4000;
+    const base = `http://localhost:${port}`;
+    // Local goes straight to the app; cloud opens the public landing page.
+    const url = isCloud ? `${base}/` : `${base}/app`;
+    // ── banner ────────────────────────────────────────────────────────────────
+    const { LIMN_ASCII, TAGLINE } = await import('./ascii.js');
+    console.log(cyan(LIMN_ASCII));
+    console.log(`  ${dim(isCloud ? 'cloud mode — multi-tenant' : TAGLINE)}`);
+    console.log('');
+    console.log(`  ${cyan('▸')} ${bold(url)}`);
+    console.log('');
+    // ── boot the server (migrate → account → app → scheduler → listen) ────────
+    const { start } = await import('./index.js');
+    await start();
+    // ── open the browser once we're listening ─────────────────────────────────
+    const skipOpen = opts.open === false || process.env.NO_OPEN !== undefined;
+    if (!skipOpen)
+        openBrowser(url);
+}
+main().catch((err) => {
+    // The product NAME, not the command — the banner above already says Limn. A literal rather
+    // than shared's PRODUCT_NAME on purpose: this module has no top-level imports outside
+    // `node:*` (everything else is a dynamic import, to keep `npx` startup lean) and one word is
+    // not worth loading shared before the failure can be printed.
+    console.error('Failed to start Limn:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/coding/activity.js

@@ -0,0 +1,80 @@
+// Live progress derivation for the coding agent — turns each assistant turn into a
+// few short, human-readable lines (tool labels + clipped text). Mirrors the private
+// helpers in review/agent.ts but understands the WRITE tools (Write/Edit/MultiEdit)
+// the fixer uses. Defensive throughout: the SDK content/tool-input shapes vary, so
+// every access is guarded and this never throws.
+const TEXT_SNIPPET_CAP = 120;
+const ARG_CAP = 80;
+export function describeAssistantBlocks(message) {
+    const lines = [];
+    const content = message?.message
+        ?.content;
+    if (!Array.isArray(content))
+        return lines;
+    for (const raw of content) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const block = raw;
+        if (block.type === 'tool_use') {
+            const name = typeof block.name === 'string' ? block.name : 'Tool';
+            const input = block.input && typeof block.input === 'object'
+                ? block.input
+                : {};
+            lines.push(labelToolUse(name, input));
+        }
+        else if (block.type === 'text' && typeof block.text === 'string') {
+            const snippet = clip(block.text.replace(/\s+/g, ' ').trim(), TEXT_SNIPPET_CAP);
+            if (snippet)
+                lines.push(snippet);
+        }
+    }
+    return lines;
+}
+function labelToolUse(name, input) {
+    const str = (v) => typeof v === 'string' && v.trim().length > 0 ? v.trim() : null;
+    switch (name) {
+        case 'Read': {
+            const p = str(input.file_path) ?? str(input.path);
+            return p ? `Read ${p}` : 'Read …';
+        }
+        case 'Write': {
+            const p = str(input.file_path) ?? str(input.path);
+            return p ? `Write ${p}` : 'Write …';
+        }
+        case 'Edit':
+        case 'MultiEdit': {
+            const p = str(input.file_path) ?? str(input.path);
+            return p ? `Edit ${p}` : 'Edit …';
+        }
+        case 'Glob': {
+            const p = str(input.pattern);
+            return p ? `Glob ${p}` : 'Glob …';
+        }
+        case 'Grep': {
+            const p = str(input.pattern);
+            return p ? `Grep "${clip(p, ARG_CAP)}"` : 'Grep …';
+        }
+        // Unreachable as things stand — the fixer does not allow Bash (coding/agent.ts denies it
+        // outright), so no such block arrives and the panel simply shows fewer lines. Kept because
+        // this function's contract is "label whatever the SDK hands me", and the default branch
+        // below would render this one worse.
+        case 'Bash': {
+            const c = str(input.command);
+            return c ? `Bash ${clip(c, ARG_CAP)}` : 'Bash …';
+        }
+        case 'mcp__fix__submit_fix':
+            return 'Recording fix summary…';
+        default: {
+            for (const key of Object.keys(input)) {
+                const v = str(input[key]);
+                if (v)
+                    return `${name} ${clip(v, ARG_CAP)}`;
+            }
+            return `${name} …`;
+        }
+    }
+}
+function clip(s, max) {
+    return s.length > max ? `${s.slice(0, max)}…` : s;
+}
+//# sourceMappingURL=activity.js.map