gigarag-claude-code 0.1.0

package/cli/commands/authHeader.js

@@ -0,0 +1,22 @@
+import { authorizationHeader, loadCredential } from '../auth/credentials.js';
+import { err, out } from '../ui.js';
+/**
+ * What `headersHelper` runs. Claude Code expects one JSON object of string
+ * pairs on stdout, and gives up after 10 seconds, so nothing else may print here
+ * and nothing slow may run.
+ */
+export async function authHeader() {
+    const credential = loadCredential();
+    if (!credential) {
+        err('Not signed in to GigaRAG. Run: gigarag login');
+        return 1;
+    }
+    try {
+        out(JSON.stringify({ Authorization: await authorizationHeader(credential) }));
+        return 0;
+    }
+    catch (e) {
+        err(e.message);
+        return 1;
+    }
+}

package/cli/commands/connect.js

@@ -0,0 +1,285 @@
+import { parseArgs } from 'node:util';
+import { updateConfig, readConfig } from '../config.js';
+import { loadCredential } from '../auth/credentials.js';
+import { resolveUrl } from '../mcp/session.js';
+import { tildify } from '../paths.js';
+import { connectClient, removeClientEntry, renderConfig } from '../clients/connect.js';
+import { installCommands, planTargets, removeCommands, targetDir } from '../clients/commands.js';
+import { resolveLauncher } from '../clients/launcher.js';
+import { configPathFor, detect, findClient, hereNow, loadRegistry } from '../clients/registry.js';
+import { out, table, UsageError } from '../ui.js';
+const HELP = `Usage: gigarag connect [client...] [--print] [--remove] [--dry-run]
+
+With no client it detects what is installed and adds GigaRAG to each. Your other servers
+are left alone, and the first change to any file is copied to <file>.gigarag.bak.
+
+It also installs the /gigaindex, /gigasync, /gigasave, /gigarecall and /gigadocs commands
+where a client reads them, as skills or command files that carry a gigarag:managed marker.
+A file of yours with the same name is never replaced.
+
+  gigarag connect                  every installed client
+  gigarag connect cursor zed       just those, even if they were not detected
+  gigarag connect --print cursor   show the config instead of writing it
+  gigarag connect --remove         take GigaRAG out of every client we wrote to
+  gigarag connect --list           every client we know, and whether it is installed
+
+  --no-commands                    write the MCP config only
+  --commands-only                  write the commands only
+  --launcher node|npx|binary       how a client starts the bridge (default: this install; binary needs the standalone build)
+  --dry-run  --json`;
+export async function connect(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            print: { type: 'boolean' },
+            remove: { type: 'boolean' },
+            'dry-run': { type: 'boolean' },
+            list: { type: 'boolean' },
+            json: { type: 'boolean' },
+            'no-commands': { type: 'boolean' },
+            'commands-only': { type: 'boolean' },
+            launcher: { type: 'string' },
+            help: { type: 'boolean', short: 'h' },
+        },
+    });
+    if (values.help) {
+        out(HELP);
+        return 0;
+    }
+    if (values['no-commands'] && values['commands-only'])
+        throw new UsageError('--no-commands and --commands-only cancel each other out.');
+    const registry = loadRegistry();
+    const where = hereNow();
+    const named = positionals.map(slug => {
+        const client = findClient(registry, slug);
+        if (!client) {
+            const close = registry.clients
+                .filter(c => c.slug.includes(slug) || slug.includes(c.slug) || editDistance(c.slug, slug) <= 2)
+                .map(c => c.slug);
+            throw new UsageError(`Unknown client "${slug}".${close.length ? ` Did you mean ${close.slice(0, 3).join(', ')}?` : ''} Run: gigarag connect --list`);
+        }
+        return client;
+    });
+    const kind = values.launcher;
+    if (kind && !['node', 'npx', 'binary'].includes(kind))
+        throw new UsageError('--launcher takes node, npx or binary.');
+    const launcher = resolveLauncher(kind);
+    const url = resolveUrl();
+    if (values.list)
+        return list(registry, where, !!values.json);
+    if (values.print) {
+        if (named.length === 0)
+            throw new UsageError('Name a client to print for, e.g. gigarag connect --print cursor');
+        for (const client of named) {
+            const path = configPathFor(client, where);
+            out(`# ${client.name}${path ? `: ${tildify(path)}` : ''}`);
+            out(client.mode === 'print' ? `# ${client.hint ?? 'Set up by hand.'}` : `# ${client.note ?? 'Merge this into the file.'}`);
+            out(renderConfig(client, launcher, url));
+            const dirs = (client.commands ?? []).map(id => registry.commandTargets[id]).filter(Boolean).map(t => targetDir(t, where));
+            if (dirs.length > 0)
+                out(`# Commands go in: ${dirs.map(d => tildify(d ?? '')).join(', ')}`);
+            if (client.docs)
+                out(`# Docs: ${client.docs}`);
+            out('');
+        }
+        return 0;
+    }
+    if (values.remove)
+        return remove(registry, named, where, !!values['commands-only'], !!values['no-commands']);
+    const targets = named.length > 0
+        ? named
+        : registry.clients.filter(c => (c.mode === 'auto' || (c.commands?.length ?? 0) > 0) && detect(c, where).installed);
+    if (targets.length === 0) {
+        out('No supported clients were found on this machine.');
+        out('Run gigarag connect --list to see what is supported, or name one: gigarag connect cursor');
+        return 0;
+    }
+    if (values['dry-run']) {
+        out('Would write to:');
+        for (const c of targets) {
+            const cmds = (c.commands ?? []).map(id => tildify(targetDir(registry.commandTargets[id], where) ?? '')).join(', ');
+            out(`  ${c.slug}  ${tildify(configPathFor(c, where) ?? '(by hand)')}${cmds ? `  commands: ${cmds}` : ''}`);
+        }
+        return 0;
+    }
+    const results = [];
+    if (!values['commands-only']) {
+        for (const client of targets) {
+            if (client.mode === 'print') {
+                // A print-only client may still take commands. It only appears in the MCP table when named.
+                if (named.length > 0) {
+                    results.push({ slug: client.slug, name: client.name, status: 'skipped', reason: `${client.hint ?? 'set up by hand'} Run: gigarag connect --print ${client.slug}` });
+                }
+                continue;
+            }
+            results.push(connectClient(client, where, launcher, url));
+        }
+    }
+    const commandResults = [];
+    const planned = values['no-commands'] ? new Map() : planTargets(registry, targets);
+    for (const [id, plan] of planned)
+        commandResults.push(...installCommands(id, plan.target, where));
+    updateConfig(config => {
+        for (const r of results) {
+            const def = findClient(registry, r.slug);
+            if (!def?.config || !r.path)
+                continue;
+            if (r.status === 'written' || r.status === 'replaced' || r.status === 'unchanged') {
+                config.clients[r.slug] = { path: r.path, at: def.config.at, format: def.config.format, writtenAt: new Date().toISOString() };
+            }
+        }
+        for (const [id, plan] of planned) {
+            const wrote = commandResults.some(r => r.target === id && r.status !== 'skipped');
+            if (!wrote)
+                continue;
+            const prior = config.commands?.[id]?.clients ?? [];
+            config.commands ??= {};
+            config.commands[id] = {
+                dir: targetDir(plan.target, where) ?? '',
+                clients: [...new Set([...prior, ...plan.clients.map(c => c.slug)])],
+                writtenAt: new Date().toISOString(),
+            };
+        }
+    });
+    if (values.json) {
+        out(JSON.stringify({ launcher, results, commands: commandResults }, null, 2));
+    }
+    else {
+        if (results.length > 0) {
+            for (const line of table(results.map(r => [r.slug, r.status, r.path ? tildify(r.path) : '', r.reason && r.status !== 'failed' ? `(${r.reason})` : '']))) {
+                out(line);
+            }
+            for (const r of results)
+                if (r.status === 'failed' && r.reason)
+                    out(`\n${r.slug}: ${r.reason}`);
+            for (const r of results)
+                if (r.backup)
+                    out(`\nBacked up ${tildify(r.path ?? '')} to ${tildify(r.backup)}`);
+        }
+        if (commandResults.length > 0) {
+            out(`\n${results.length > 0 ? '' : ''}Commands:`);
+            for (const line of table(summariseCommands(commandResults, planned)))
+                out(line);
+            for (const r of commandResults)
+                if (r.status === 'skipped')
+                    out(`  ${r.name} in ${tildify(r.path)}: ${r.reason}`);
+        }
+    }
+    // With --json the output is for a program, and one stray line after the JSON would break its parser.
+    if (!values.json) {
+        if (!loadCredential()) {
+            out('\nYou are not signed in yet, so these clients cannot reach GigaRAG. Run: gigarag login');
+        }
+        if (named.length === 0) {
+            const manual = registry.clients.filter(c => c.mode === 'print').length;
+            out(`\n${manual} more clients are set up by hand. Run: gigarag connect --list`);
+        }
+        out('\nRestart each client so it picks up the change.');
+    }
+    return results.some(r => r.status === 'failed') ? 1 : 0;
+}
+/** One line per target: how many commands ended each way, where, and which clients read them. */
+function summariseCommands(results, planned) {
+    const ids = [...new Set(results.map(r => r.target))];
+    return ids.map(id => {
+        const mine = results.filter(r => r.target === id);
+        const counts = ['written', 'replaced', 'unchanged', 'skipped']
+            .map(s => [s, mine.filter(r => r.status === s).length])
+            .filter(([, n]) => n > 0)
+            .map(([s, n]) => `${n} ${s}`)
+            .join(', ');
+        const dir = mine[0] ? tildify(dirnameOf(mine[0].path, id, planned)) : '';
+        const clients = planned.get(id)?.clients.map(c => c.slug).join(', ') ?? '';
+        return [`  ${id}`, counts, dir, clients ? `(${clients})` : ''];
+    });
+}
+function dirnameOf(path, id, planned) {
+    const kind = planned.get(id)?.target.kind;
+    const parts = path.split(/[\\/]/);
+    // A skill lives one folder deeper than the directory the client reads.
+    parts.pop();
+    if (kind === 'skill')
+        parts.pop();
+    return parts.join(process.platform === 'win32' ? '\\' : '/');
+}
+function list(registry, where, json) {
+    const rows = registry.clients.map(c => {
+        const d = detect(c, where);
+        const state = c.mode === 'print' && !(c.commands?.length) ? 'by hand' : d.installed ? 'installed' : 'not found';
+        return {
+            slug: c.slug,
+            name: c.name,
+            state,
+            mcp: c.mode === 'auto' ? 'auto' : 'print',
+            commands: c.commands ?? [],
+            path: configPathFor(c, where),
+        };
+    });
+    if (json) {
+        out(JSON.stringify(rows, null, 2));
+        return 0;
+    }
+    for (const line of table(rows.map(r => [r.slug, r.state, r.mcp, r.commands.join(',') || '-', r.path ? tildify(r.path) : ''])))
+        out(line);
+    return 0;
+}
+function remove(registry, named, where, commandsOnly, keepCommands) {
+    const config = readConfig();
+    const recorded = new Set([...Object.keys(config.clients), ...Object.values(config.commands ?? {}).flatMap(c => c.clients)]);
+    const targets = named.length > 0 ? named : registry.clients.filter(c => recorded.has(c.slug));
+    if (targets.length === 0) {
+        out('Nothing to remove: gigarag has not written to any client on this machine.');
+        return 0;
+    }
+    const rows = [];
+    let failed = false;
+    if (!commandsOnly) {
+        const results = targets.filter(c => c.config).map(c => removeClientEntry(c, where));
+        updateConfig(c => {
+            for (const r of results)
+                if (r.status !== 'failed')
+                    delete c.clients[r.slug];
+        });
+        for (const r of results)
+            rows.push([r.slug, r.status === 'written' ? 'removed' : r.status, r.path ? tildify(r.path) : '', r.reason ? `(${r.reason})` : '']);
+        failed = results.some(r => r.status === 'failed');
+    }
+    if (!keepCommands) {
+        const gone = new Set(targets.map(c => c.slug));
+        const cmdRows = [];
+        updateConfig(c => {
+            for (const [id, rec] of Object.entries(c.commands ?? {})) {
+                const left = rec.clients.filter(s => !gone.has(s));
+                // Another client that still uses this target keeps it.
+                if (left.length > 0) {
+                    rec.clients = left;
+                    continue;
+                }
+                const target = registry.commandTargets[id];
+                if (target)
+                    cmdRows.push(...removeCommands(id, target, where));
+                delete c.commands[id];
+            }
+        });
+        for (const r of cmdRows)
+            rows.push([`  ${r.target}/${r.name}`, r.status, tildify(r.path), r.reason ? `(${r.reason})` : '']);
+    }
+    for (const line of table(rows))
+        out(line);
+    return failed ? 1 : 0;
+}
+/** Levenshtein distance, for suggesting a client when somebody mistypes one. */
+export function editDistance(a, b) {
+    const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let prev = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const tmp = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+            prev = tmp;
+        }
+    }
+    return row[b.length];
+}

package/cli/commands/indexSync.js

@@ -0,0 +1,46 @@
+import { GigaRag } from '../sdk.js';
+import { State } from '../state.js';
+const MAX_NODES = 5000;
+/** A worker that started less than this long ago owns the sync. */
+const LOCK_MS = 2 * 60_000;
+/**
+ * Refreshes the local memo index from the server. It is what SessionStart reads,
+ * so it is what makes memos saved from other clients, a chat app or another
+ * machine, show up in the next session. Runs detached from a hook, never in one.
+ */
+export async function indexSync() {
+    const state = new State();
+    let held = false;
+    try {
+        // Only the worker that took the lock may let go of it. A worker that finds it held leaves it alone.
+        held = state.tryAcquire('sync_lock', LOCK_MS);
+        if (!held)
+            return 0;
+        const rag = new GigaRag();
+        const rows = [];
+        for await (const n of rag.iterateNodes({ max: MAX_NODES })) {
+            rows.push({
+                node_id: n.id,
+                ref: n.ref ?? null,
+                title: n.title,
+                type: n.node_type ?? null,
+                tokens: null,
+                touched_at: Date.parse(n.updated_at ?? '') || 0,
+            });
+        }
+        state.replaceNodes(rows);
+        state.setMeta('last_sync', String(Date.now()));
+        return 0;
+    }
+    catch {
+        // Silent on purpose: nobody is watching a detached worker. The attempt is recorded so a machine
+        // that cannot sync is not retried by every session start and every Stop.
+        state.setMeta('last_attempt', String(Date.now()));
+        return 1;
+    }
+    finally {
+        if (held)
+            state.setMeta('sync_lock', '0');
+        state.close();
+    }
+}

package/cli/commands/login.js

@@ -0,0 +1,129 @@
+import { parseArgs } from 'node:util';
+import { updateConfig, readConfig } from '../config.js';
+import { DEFAULT_ISSUER } from '../constants.js';
+import { clearCredential, envKey, looksLikeAgentKey, mask, saveCredential } from '../auth/credentials.js';
+import { runOAuthLogin } from '../auth/oauth.js';
+import { GigaRag, McpHttpError } from '../sdk.js';
+import { assertSecureUrl } from '../secureUrl.js';
+import { err, out, promptHidden, readStdinLine, UsageError } from '../ui.js';
+const HELP = `Usage: gigarag login [--browser] [--key <key>] [--url <mcp url>] [--no-verify]
+
+Stores a credential for this machine. With no flags it asks you to paste an agent key
+from gigarag.com/connect. Piped input works too: echo $KEY | gigarag login
+
+  --browser     Sign in through your browser instead of pasting a key
+  --key <key>   Give the key on the command line (it will sit in your shell history)
+  --url <url>   Use a different MCP endpoint
+  --no-verify   Store the key without checking it against GigaRAG first`;
+export async function login(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            browser: { type: 'boolean' },
+            key: { type: 'string' },
+            url: { type: 'string' },
+            issuer: { type: 'string' },
+            'no-verify': { type: 'boolean' },
+            help: { type: 'boolean', short: 'h' },
+        },
+    });
+    if (values.help) {
+        out(HELP);
+        return 0;
+    }
+    // Checked before it is stored: a typo saved here would break every later command.
+    if (values.url) {
+        try {
+            assertSecureUrl(values.url, 'The --url value');
+        }
+        catch (e) {
+            throw new UsageError(e.message);
+        }
+        updateConfig(c => void (c.mcpUrl = values.url));
+    }
+    if (values.browser)
+        return browserLogin(values.issuer ?? readConfig().issuer ?? DEFAULT_ISSUER, values.url);
+    let key = values.key?.trim();
+    if (!key && envKey()) {
+        out('GIGARAG_API_KEY is set, so every command already uses it. Nothing to store.');
+        return 0;
+    }
+    if (!key) {
+        key = process.stdin.isTTY
+            ? (await promptHidden('Paste your GigaRAG agent key (from gigarag.com/connect): ')).trim()
+            : await readStdinLine();
+    }
+    if (!key)
+        throw new UsageError('No key given. Copy one from gigarag.com/connect, then run gigarag login again.');
+    if (!looksLikeAgentKey(key)) {
+        err('That does not look like an agent key. They start with gr_live_. Storing it anyway would only fail later.');
+        return 1;
+    }
+    if (!values['no-verify']) {
+        try {
+            await new GigaRag({ apiKey: key, url: values.url }).usage();
+        }
+        catch (e) {
+            if (e instanceof McpHttpError && e.status === 401) {
+                err('GigaRAG did not accept that key. If it was revoked, copy a new one from gigarag.com/connect.');
+                return 1;
+            }
+            if (e instanceof McpHttpError && e.status === 403) {
+                err('That key is valid but not allowed to read this workspace. Ask an owner or admin for access.');
+                return 1;
+            }
+            err(`Could not check the key: ${e.message}\nRun again with --no-verify to store it without checking.`);
+            return 1;
+        }
+    }
+    const where = saveCredential({ type: 'key', key });
+    updateConfig(c => void (c.auth = 'key'));
+    out(`Connected. ${mask(key)} is stored in ${where}.`);
+    out('Next: gigarag connect');
+    return 0;
+}
+async function browserLogin(issuer, mcpUrl) {
+    try {
+        const config = readConfig();
+        const result = await runOAuthLogin({
+            issuer,
+            resource: mcpUrl,
+            clientId: config.issuer === issuer ? config.oauthClientId : undefined,
+            log: line => out(line),
+        });
+        const where = saveCredential(result.credential);
+        updateConfig(c => {
+            c.auth = 'oauth';
+            c.issuer = issuer;
+            c.oauthClientId = result.clientId;
+        });
+        out(`Connected through your browser. The sign-in is stored in ${where}.`);
+        out('Next: gigarag connect');
+        return 0;
+    }
+    catch (e) {
+        err(e.message);
+        return 1;
+    }
+}
+const LOGOUT_HELP = 'Usage: gigarag logout\n\nDeletes the stored credential, then lists the clients still configured.';
+export async function logout(argv) {
+    if (argv.includes('--help') || argv.includes('-h')) {
+        out(LOGOUT_HELP);
+        return 0;
+    }
+    clearCredential();
+    updateConfig(c => void (c.auth = undefined));
+    out('Signed out. The stored credential is deleted.');
+    const written = Object.entries(readConfig().clients);
+    if (written.length > 0) {
+        out('');
+        out('These clients still have GigaRAG configured and will report an auth error until you sign in again:');
+        for (const [slug, info] of written)
+            out(`  ${slug}  ${info.path}`);
+        out('');
+        out('Sign back in with: gigarag login');
+        out('Or take GigaRAG out of all of them with: gigarag connect --remove');
+    }
+    return 0;
+}

package/cli/commands/mcp.js

@@ -0,0 +1,22 @@
+import { parseArgs } from 'node:util';
+import { runBridge } from '../mcp/bridge.js';
+import { createClient } from '../mcp/session.js';
+import { err } from '../ui.js';
+/**
+ * The stdio bridge. A client's config file runs this, so stdout belongs to the
+ * protocol and nothing else may write to it: every message for a person goes to
+ * stderr, which clients surface in their MCP logs.
+ */
+export async function mcp(argv) {
+    const { values } = parseArgs({ args: argv, options: { url: { type: 'string' } } });
+    const client = createClient({
+        url: values.url,
+        onRetry: (wait, attempt) => err(`gigarag: rate limited, waiting ${wait}s (retry ${attempt})`),
+    });
+    await runBridge(client, {
+        input: process.stdin,
+        output: process.stdout,
+        log: line => err(`gigarag: ${line}`),
+    });
+    return 0;
+}

package/cli/commands/record.js

@@ -0,0 +1,72 @@
+import { resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+import { repoInfo } from '../scan/repo.js';
+import { State } from '../state.js';
+import { err, out, readStdinAll, UsageError } from '../ui.js';
+const HELP = `Usage: gigarag record < result.json
+
+Tells the local index what the indexing agent just did, so the next scan updates memos in
+place instead of duplicating them. Reads JSON on stdin:
+
+  {
+    "repo": "acme-api",
+    "files": [
+      { "path": "src/auth.ts", "hash": "<hash from the manifest>",
+        "nodes": [ { "id": "<node uuid>", "ref": "N:12", "title": "Auth", "type": "code", "tokens": 800 } ] }
+    ],
+    "removed": [ { "path": "src/old.ts", "deletedNodeIds": [ "<node uuid>" ] } ]
+  }
+
+  --root <dir>   The repository root, when it is not the current directory`;
+export async function record(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: { root: { type: 'string' }, help: { type: 'boolean', short: 'h' } },
+    });
+    if (values.help) {
+        out(HELP);
+        return 0;
+    }
+    let input;
+    try {
+        input = JSON.parse(await readStdinAll());
+    }
+    catch {
+        throw new UsageError('Expected JSON on stdin. Run gigarag record --help for the shape.');
+    }
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new UsageError('Expected a JSON object on stdin. Run gigarag record --help for the shape.');
+    }
+    const info = repoInfo(resolve(values.root ?? '.'));
+    const slug = input.repo ?? info.slug;
+    const state = new State();
+    try {
+        const now = Date.now();
+        let files = 0;
+        let forgotten = 0;
+        state.upsertRepo(slug, info.root, now);
+        for (const f of input.files ?? []) {
+            if (!f.path || !f.hash) {
+                err(`Skipped an entry with no path or hash.`);
+                continue;
+            }
+            const nodes = f.nodes ?? [];
+            for (const n of nodes) {
+                state.upsertNode({ node_id: n.id, ref: n.ref, title: n.title ?? f.path, type: n.type, tokens: n.tokens, touched_at: now });
+            }
+            state.recordFile(slug, f.path, f.hash, nodes.map(n => n.id), now);
+            files++;
+        }
+        for (const r of input.removed ?? []) {
+            state.forgetFile(slug, r.path);
+            for (const id of r.deletedNodeIds ?? [])
+                state.deleteNode(id);
+            forgotten++;
+        }
+        out(`Recorded ${files} files and forgot ${forgotten} in ${slug}.`);
+        return 0;
+    }
+    finally {
+        state.close();
+    }
+}

package/cli/commands/repo.js

@@ -0,0 +1,48 @@
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { parseArgs } from 'node:util';
+import { stateDir } from '../paths.js';
+import { repoInfo } from '../scan/repo.js';
+import { tryOpenState } from '../state.js';
+import { out } from '../ui.js';
+const HELP = `Usage: gigarag repo [path] [--slug]
+
+Prints which GigaRAG bucket a directory belongs to: {slug, root, remote, indexedAt, dirty}.
+The slug comes from the git remote when there is one, so two checkouts of one repository share
+a bucket, and from the directory name plus a short hash of its path when there is not. It walks no files and costs nothing.
+
+  --slug   Print only the slug`;
+export async function repo(argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: { slug: { type: 'boolean' }, help: { type: 'boolean', short: 'h' } },
+    });
+    if (values.help) {
+        out(HELP);
+        return 0;
+    }
+    const info = repoInfo(resolve(positionals[0] ?? '.'));
+    if (values.slug) {
+        out(info.slug);
+        return 0;
+    }
+    let indexedAt;
+    let dirty = 0;
+    if (existsSync(join(stateDir(), 'state.db'))) {
+        const state = tryOpenState();
+        if (state) {
+            try {
+                const row = state.repoBySlug(info.slug);
+                if (row?.indexed_at)
+                    indexedAt = new Date(row.indexed_at).toISOString();
+                dirty = row ? state.dirtyCount(info.slug) : 0;
+            }
+            finally {
+                state.close();
+            }
+        }
+    }
+    out(JSON.stringify({ ...info, ...(indexedAt ? { indexedAt } : {}), dirty }, null, 2));
+    return 0;
+}