gigarag-cursor 0.1.2 → 0.3.0

package/cli/state.js

@@ -53,6 +53,16 @@ export class State {
         // Several Claude Code sessions write to this file at once, each from its own hook process.
         this.db.exec('PRAGMA busy_timeout = 2000; PRAGMA journal_mode = WAL; PRAGMA synchronous = NORMAL;');
         this.db.exec(SCHEMA);
+        // Memos from different workspaces share this file. Rows from before the
+        // column existed read as workspace '', the legacy single sign-in.
+        const columns = this.db.prepare('PRAGMA table_info(nodes)').all();
+        if (!columns.some(c => c.name === 'workspace')) {
+            this.db.exec("ALTER TABLE nodes ADD COLUMN workspace TEXT NOT NULL DEFAULT ''");
+        }
+        // Columns added after 0.1.2. SQLite has no ADD COLUMN IF NOT EXISTS, so ask first. An old row
+        // counts as unpushed, which is what makes a repository indexed before sync upload its state once.
+        this.addColumn('files', 'pushed', 'INTEGER NOT NULL DEFAULT 0');
+        this.addColumn('nodes', 'stale', 'INTEGER NOT NULL DEFAULT 0');
         try {
             chmodSync(path, 0o600);
         }
@@ -60,6 +70,11 @@ export class State {
             /* Windows has no chmod that means anything */
         }
     }
+    addColumn(table, column, type) {
+        const cols = this.db.prepare(`PRAGMA table_info(${table})`).all();
+        if (!cols.some(c => c.name === column))
+            this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+    }
     stmt(sql) {
         let s = this.cache.get(sql);
         if (!s) {
@@ -142,13 +157,58 @@ export class State {
     /** Records that `path` was indexed at `hash` and now lives in `nodeIds`. */
     recordFile(repo, path, hash, nodeIds, now = Date.now()) {
         this.transaction(() => {
-            this.stmt(`INSERT INTO files (repo, path, hash, dirty, indexed_at) VALUES (?, ?, ?, 0, ?)
-         ON CONFLICT(repo, path) DO UPDATE SET hash = excluded.hash, dirty = 0, indexed_at = excluded.indexed_at`).run(repo, path, hash, now);
+            this.stmt(`INSERT INTO files (repo, path, hash, dirty, indexed_at, pushed) VALUES (?, ?, ?, 0, ?, 0)
+         ON CONFLICT(repo, path) DO UPDATE SET hash = excluded.hash, dirty = 0, indexed_at = excluded.indexed_at, pushed = 0`).run(repo, path, hash, now);
             for (const id of nodeIds) {
                 this.stmt('INSERT OR IGNORE INTO links (repo, path, node_id) VALUES (?, ?, ?)').run(repo, path, id);
             }
         });
     }
+    manifestOf(repo) {
+        const out = new Map();
+        for (const [path, row] of this.files(repo))
+            out.set(path, { hash: row.hash, nodeIds: this.nodesOf(repo, path) });
+        return out;
+    }
+    unpushedFiles(repo) {
+        const rows = this.stmt('SELECT path, hash FROM files WHERE repo = ? AND pushed = 0 ORDER BY path').all(repo);
+        return rows.map(r => ({ path: r.path, hash: r.hash, nodeIds: this.nodesOf(repo, r.path) }));
+    }
+    markPushed(repo, paths) {
+        this.transaction(() => {
+            for (const p of paths)
+                this.stmt('UPDATE files SET pushed = 1 WHERE repo = ? AND path = ?').run(repo, p);
+        });
+    }
+    /**
+     * Takes the server's manifest as the truth for every row already pushed. Unpushed rows are this
+     * machine's work the server hasn't seen, so they stay; dirty flags are local knowledge, so they stay.
+     */
+    replaceManifest(repo, rows) {
+        this.transaction(() => {
+            const dirty = new Set(this.dirtyFiles(repo));
+            const unpushed = new Set(this.unpushedFiles(repo).map(f => f.path));
+            for (const path of this.files(repo).keys()) {
+                if (unpushed.has(path))
+                    continue;
+                this.stmt('DELETE FROM files WHERE repo = ? AND path = ?').run(repo, path);
+                this.stmt('DELETE FROM links WHERE repo = ? AND path = ?').run(repo, path);
+            }
+            for (const row of rows) {
+                if (unpushed.has(row.path))
+                    continue;
+                this.stmt('INSERT INTO files (repo, path, hash, dirty, indexed_at, pushed) VALUES (?, ?, ?, ?, NULL, 1)').run(repo, row.path, row.hash, dirty.has(row.path) ? 1 : 0);
+                for (const id of row.nodeIds)
+                    this.stmt('INSERT OR IGNORE INTO links (repo, path, node_id) VALUES (?, ?, ?)').run(repo, row.path, id);
+            }
+        });
+    }
+    renameFile(repo, from, to) {
+        this.transaction(() => {
+            this.stmt('UPDATE files SET path = ?, pushed = 0 WHERE repo = ? AND path = ?').run(to, repo, from);
+            this.stmt('UPDATE links SET path = ? WHERE repo = ? AND path = ?').run(to, repo, from);
+        });
+    }
     forgetFile(repo, path) {
         this.transaction(() => {
             this.stmt('DELETE FROM files WHERE repo = ? AND path = ?').run(repo, path);
@@ -182,21 +242,21 @@ export class State {
             this.stmt('DELETE FROM links WHERE node_id = ?').run(nodeId);
         });
     }
-    /** Replaces the synced set: rows not in `keep` are dropped, so deletions elsewhere disappear here. */
-    replaceNodes(rows) {
+    /** Replaces the synced set for one workspace: rows of that workspace not in the new set are dropped. */
+    replaceNodes(rows, workspace = '') {
         this.transaction(() => {
-            const known = new Map(this.stmt('SELECT node_id, tokens FROM nodes').all().map(r => [r.node_id, r.tokens]));
-            this.db.exec('DELETE FROM nodes');
+            const known = new Map(this.stmt('SELECT node_id, tokens FROM nodes WHERE workspace = ?').all(workspace).map(r => [r.node_id, r.tokens]));
+            this.stmt('DELETE FROM nodes WHERE workspace = ?').run(workspace);
             for (const row of rows) {
-                this.stmt('INSERT INTO nodes (node_id, ref, title, type, tokens, touched_at) VALUES (?, ?, ?, ?, ?, ?)').run(row.node_id, row.ref, row.title, row.type, row.tokens ?? known.get(row.node_id) ?? null, row.touched_at);
+                this.stmt('INSERT OR REPLACE INTO nodes (node_id, ref, title, type, tokens, touched_at, workspace, stale) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(row.node_id, row.ref, row.title, row.type, row.tokens ?? known.get(row.node_id) ?? null, row.touched_at, workspace, row.stale ?? 0);
             }
         });
     }
-    recentNodes(limit) {
-        return this.stmt('SELECT node_id, ref, title, type, tokens, touched_at FROM nodes ORDER BY touched_at DESC LIMIT ?').all(limit);
+    recentNodes(limit, workspace = '') {
+        return this.stmt('SELECT node_id, ref, title, type, tokens, touched_at, stale FROM nodes WHERE workspace = ? ORDER BY touched_at DESC LIMIT ?').all(workspace, limit);
     }
-    nodeCount() {
-        return this.stmt('SELECT COUNT(*) AS n FROM nodes').get().n;
+    nodeCount(workspace = '') {
+        return this.stmt('SELECT COUNT(*) AS n FROM nodes WHERE workspace = ?').get(workspace).n;
     }
 }
 /** Opens the state, or returns undefined when it cannot be opened, so a hook never fails a session. */

package/cli/sync/notes.js

@@ -0,0 +1,50 @@
+const key = (slug) => `sync_note:${slug}`;
+export function readNote(state, slug) {
+    const raw = state.getMeta(key(slug));
+    if (!raw)
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeNote(state, slug, note) {
+    state.setMeta(key(slug), JSON.stringify({ ...note, at: Date.now() }));
+}
+export function clearNote(state, slug) {
+    state.setMeta(key(slug), '');
+}
+export function maxRewriteFiles() {
+    const n = Number(process.env['GIGARAG_SYNC_MAX_FILES']);
+    return Number.isInteger(n) && n >= 0 ? n : 40;
+}
+const short = (commit) => (commit && /^[0-9a-f]{7,64}$/.test(commit) ? commit.slice(0, 7) : 'an unknown commit');
+const count = (n) => (Number.isInteger(n) && n >= 0 ? n : 0);
+const clean = (s) => (s ?? 'no reason given').replace(/[^\x20-\x7e]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 120);
+const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+export function renderNote(note, slug, maxFiles) {
+    const c = short(note.commit);
+    const n = count(note.files);
+    switch (note.kind) {
+        case 'needs_approval':
+            return `${plural(n, 'file', 'files')} in this repository (${slug}) changed at ${c}, more than the ${maxFiles} a background sync rewrites on its own. Their memos are marked stale. Ask the user whether to run /gigasync now; it rewrites them with this session's model.`;
+        case 'no_agent':
+            return `${plural(n, 'memo', 'memos')} in this repository (${slug}) are marked stale since ${c} and no background agent could rewrite them. /gigasync rewrites them.`;
+        case 'dirty':
+            return `${plural(n, 'memo', 'memos')} in this repository (${slug}) are marked stale since ${c}. The background rewrite waits for a clean working tree, because it reads files from disk. /gigasync rewrites them now.`;
+        case 'failed':
+            return `The background rewrite of ${slug} stopped: ${clean(note.detail)}. Its memos are still marked stale. /gigasync rewrites them, and the log is at ~/.gigarag/logs/sync-${slug}.log.`;
+        case 'behind':
+            return `This checkout of ${slug} doesn't contain ${c}, the commit GigaRAG last synced, so automatic sync is paused. Pulling the branch resumes it; if this checkout is meant to replace what GigaRAG has (an amend, a rebase or a deliberate rewrite), gigarag sync begin --force syncs it instead.`;
+        case 'held':
+            return `Another machine was syncing ${slug} when this one tried. Nothing to do; the next commit tries again.`;
+        case 'mass_delete':
+            return `${plural(n, 'file', 'files')} in ${slug} look deleted, more than half of what was indexed, so no memos were deleted. If the files really are gone, ask the user whether to run gigarag sync begin --force, which deletes their memos; if not, the checkout needs checking.`;
+        case 'deferred':
+            return `An interactive /gigasync was running for ${slug} on this machine when the background sync tried to run after a commit. The sync is queued, not dropped, and runs once that session finishes; gigarag sync end clears a session that already finished but never called it.`;
+        case 'untrusted':
+            return `This repository's .gigarag.json links it to workspace ${clean(note.detail)}, which has not been trusted, so no sync ran here and none will until it is. If you placed or reviewed that file yourself, run: gigarag trust. To use a different workspace instead: gigarag use <workspace>.`;
+    }
+}

package/cli/sync/plan.js

@@ -0,0 +1,76 @@
+/**
+ * What a sync does without a model, decided from two maps: what the manifest
+ * says was indexed, and what is on disk now. Pure, so every rule here has a
+ * test that doesn't need git or a server.
+ */
+/** More than this many gone paths, and more than half the manifest, is what a broken checkout looks like. */
+export const MASS_DELETE_MIN = 20;
+function byHash(paths, hashOf) {
+    const m = new Map();
+    for (const p of paths) {
+        const h = hashOf(p);
+        m.set(h, [...(m.get(h) ?? []), p]);
+    }
+    return m;
+}
+export function planSync(input) {
+    const { known, current } = input;
+    const gone = input.truncated ? [] : [...known.keys()].filter(p => !current.has(p) && !(input.atHead?.has(p) ?? false));
+    const added = [...current.keys()].filter(p => !known.has(p));
+    // A rename only when the hash is unique on both sides. Two copies of one LICENSE are not evidence.
+    const goneByHash = byHash(gone, p => known.get(p).hash);
+    const addedByHash = byHash(added, p => current.get(p));
+    const renames = [];
+    for (const [hash, from] of goneByHash) {
+        const to = addedByHash.get(hash);
+        if (from.length === 1 && to?.length === 1)
+            renames.push({ from: from[0], to: to[0], hash, nodeIds: known.get(from[0]).nodeIds });
+    }
+    const renamedTo = new Map(renames.map(r => [r.from, r.to]));
+    const newPaths = new Set(renames.map(r => r.to));
+    const trulyGone = gone.filter(p => !renamedTo.has(p));
+    const suspicious = trulyGone.length > MASS_DELETE_MIN && trulyGone.length * 2 > known.size;
+    // Which live paths feed each memo once renames are applied.
+    const feeders = new Map();
+    for (const [path, file] of known) {
+        const live = renamedTo.get(path) ?? path;
+        for (const id of file.nodeIds)
+            feeders.set(id, [...(feeders.get(id) ?? []), live]);
+    }
+    const goneSet = new Set(trulyGone);
+    const deleteNodeIds = new Set();
+    const deletedPaths = [];
+    const partial = [];
+    if (!suspicious || input.allowMassDelete) {
+        for (const path of trulyGone) {
+            const ids = known.get(path).nodeIds;
+            const orphaned = ids.filter(id => (feeders.get(id) ?? []).every(p => goneSet.has(p)));
+            for (const id of orphaned)
+                deleteNodeIds.add(id);
+            const shared = ids.filter(id => !orphaned.includes(id));
+            if (shared.length > 0)
+                partial.push({ path, nodeIds: shared });
+            else
+                deletedPaths.push(path);
+        }
+    }
+    const changed = [...current].filter(([p, h]) => known.has(p) && known.get(p).hash !== h).map(([p]) => p);
+    const rewrite = [...changed, ...added.filter(p => !newPaths.has(p))].sort();
+    const stale = new Set();
+    for (const p of changed)
+        for (const id of known.get(p).nodeIds)
+            stale.add(id);
+    for (const p of partial)
+        for (const id of p.nodeIds)
+            stale.add(id);
+    return {
+        renames,
+        deleteNodeIds: [...deleteNodeIds].sort(),
+        deletedPaths: deletedPaths.sort(),
+        partial,
+        stale: [...stale].sort(),
+        rewrite,
+        suspicious,
+        goneCount: trulyGone.length,
+    };
+}

package/cli/sync/remote.js

@@ -0,0 +1,72 @@
+const RECORD_BATCH = 500;
+const STALE_BATCH = 200;
+function chunks(items, size) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size)
+        out.push(items.slice(i, i + size));
+    return out;
+}
+/** The bucket whose slug is exactly `slug`. list_buckets filters by substring, so the match is checked here. */
+export async function findBucketId(rag, slug) {
+    const page = await rag.listBuckets({ q: slug, limit: 50 });
+    const hit = page.items.find(b => b['slug'] === slug);
+    return typeof hit?.['id'] === 'string' ? hit['id'] : undefined;
+}
+/** repo_sync for one bucket, with core's limits applied by batching rather than by the caller. */
+export class RepoSyncRemote {
+    rag;
+    bucketId;
+    constructor(rag, bucketId) {
+        this.rag = rag;
+        this.bucketId = bucketId;
+    }
+    call(action, args = {}) {
+        return this.rag.callTool('repo_sync', { bucket_id: this.bucketId, action, ...args });
+    }
+    state() {
+        return this.call('state');
+    }
+    async manifest() {
+        const all = [];
+        let after;
+        do {
+            const page = await this.call('manifest', { limit: 1000, ...(after ? { after } : {}) });
+            all.push(...page.items);
+            after = page.next_cursor ?? undefined;
+        } while (after);
+        return all;
+    }
+    claim(holder, token) {
+        return this.call('claim', { holder, ttl_seconds: 600, ...(token ? { token } : {}) });
+    }
+    /** Never throws: a lease that can't be released lapses on its own in ten minutes. */
+    async release(token) {
+        try {
+            await this.call('release', { token });
+        }
+        catch {
+            /* lapses */
+        }
+    }
+    async record(upserts, removes) {
+        const entries = [
+            ...upserts.map(u => ({ up: { path: u.path, hash: u.hash, node_ids: u.nodeIds } })),
+            ...removes.map(rm => ({ rm })),
+        ];
+        for (const batch of chunks(entries, RECORD_BATCH)) {
+            await this.call('record', {
+                upserts: batch.flatMap(e => ('up' in e ? [e.up] : [])),
+                removes: batch.flatMap(e => ('rm' in e ? [e.rm] : [])),
+            });
+        }
+    }
+    async advance(token, commit, branch) {
+        await this.call('advance', { token, commit, ...(branch ? { branch } : {}) });
+    }
+    async markStale(nodeIds, commit) {
+        let marked = 0;
+        for (const batch of chunks(nodeIds, STALE_BATCH))
+            marked += (await this.call('mark_stale', { node_ids: batch, commit })).marked;
+        return marked;
+    }
+}

package/cli/sync/rewriter.js

@@ -0,0 +1,125 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { closeSync, existsSync, mkdirSync, openSync } from 'node:fs';
+import { delimiter, dirname, join } from 'node:path';
+/**
+ * The GigaRAG MCP tools the gigasync/gigaindex flow actually calls (see
+ * plugins/claude-code/agents/gigarag-indexer.md and commands/gigasync.md): find or create the
+ * bucket and its threads, write and remove memos, and resolve a link's ref. Nothing here can
+ * delete a bucket or thread, link two memos, or read outside what `gigarag scan` already named.
+ */
+const GIGARAG_TOOLS = ['list_buckets', 'create_bucket', 'list_threads', 'create_thread', 'find_nodes', 'create_node', 'update_node', 'delete_node'];
+/**
+ * Starts Claude Code to rewrite stale memos, with nothing but the GigaRAG tools the flow needs,
+ * reading tools and three gigarag subcommands. dontAsk denies anything else rather than waiting
+ * for a person who isn't there. Both prefixes are granted per tool, never as `mcp__*__*`, because
+ * the plugin and the bare MCP server register the same tool names under different prefixes and an
+ * unattended agent should not gain whatever else either server exposes later.
+ */
+export const CLAUDE_ARGS = [
+    '/gigarag:gigasync',
+    '--print',
+    '--permission-mode',
+    'dontAsk',
+    '--max-turns',
+    '300',
+    '--output-format',
+    'json',
+    '--no-session-persistence',
+    '--allowedTools',
+    ...GIGARAG_TOOLS.map(t => `mcp__plugin_gigarag_gigarag__${t}`),
+    ...GIGARAG_TOOLS.map(t => `mcp__gigarag__${t}`),
+    'Read',
+    'Grep',
+    'Glob',
+    'Agent',
+    'Bash(gigarag scan *)',
+    'Bash(gigarag record *)',
+    'Bash(gigarag sync *)',
+    '--disallowedTools',
+    'Write',
+    'Edit',
+    'NotebookEdit',
+    'WebFetch',
+    'WebSearch',
+];
+/** One cmd.exe command line, every part double-quoted. Refuses what quoting can't make literal. */
+export function cmdLine(parts) {
+    for (const p of parts) {
+        if (/["%\r\n]/.test(p))
+            throw new Error(`An argument for claude holds a character cmd.exe would read as syntax, so the rewrite did not start: ${p}`);
+    }
+    return parts.map(p => `"${p}"`).join(' ');
+}
+/** GIGARAG_CLAUDE (a path, for tests and odd installs), then claude on PATH, preferring an .exe on Windows. */
+export function findClaude(env, platform) {
+    const override = env['GIGARAG_CLAUDE'];
+    if (override)
+        return existsSync(override) ? override : undefined;
+    const names = platform === 'win32' ? ['claude.exe', 'claude.cmd'] : ['claude'];
+    for (const dir of (env['PATH'] ?? env['Path'] ?? '').split(delimiter).filter(Boolean)) {
+        for (const name of names) {
+            const candidate = join(dir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
+export function claudeInvocation(path, platform) {
+    if (/\.(mjs|js)$/i.test(path))
+        return { command: process.execPath, args: [path, ...CLAUDE_ARGS] };
+    if (platform === 'win32' && /\.(cmd|bat)$/i.test(path)) {
+        return { command: process.env['ComSpec'] ?? 'cmd.exe', args: ['/d', '/s', '/c', `"${cmdLine([path, ...CLAUDE_ARGS])}"`], verbatim: true };
+    }
+    return { command: path, args: CLAUDE_ARGS };
+}
+function killTree(pid) {
+    if (!pid)
+        return;
+    try {
+        if (process.platform === 'win32')
+            spawnSync('taskkill', ['/pid', String(pid), '/T', '/F'], { windowsHide: true, stdio: 'ignore' });
+        else
+            process.kill(-pid, 'SIGTERM');
+    }
+    catch {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            /* already gone */
+        }
+    }
+}
+export function runRewriter(inv, cwd, logPath, opts) {
+    mkdirSync(dirname(logPath), { recursive: true, mode: 0o700 });
+    const fd = openSync(logPath, 'w', 0o600);
+    return new Promise(resolvePromise => {
+        let settled = false;
+        let timedOut = false;
+        const child = spawn(inv.command, inv.args, {
+            cwd,
+            env: opts.env,
+            stdio: ['ignore', fd, fd],
+            windowsHide: true,
+            windowsVerbatimArguments: inv.verbatim ?? false,
+            detached: process.platform !== 'win32',
+        });
+        const tick = setInterval(() => void opts.onTick().catch(() => { }), opts.tickMs);
+        const timer = setTimeout(() => {
+            timedOut = true;
+            killTree(child.pid);
+        }, opts.timeoutMs);
+        const done = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearInterval(tick);
+            clearTimeout(timer);
+            closeSync(fd);
+            resolvePromise({ code, timedOut });
+        };
+        child.on('error', () => done(null));
+        child.on('close', code => done(code));
+    });
+}

package/cli/sync/slug.js

@@ -0,0 +1,30 @@
+import { isTrusted, readBinding } from '../binding.js';
+import { findRepoRoot, localSlug, readOriginUrl, repoInfo, slugFromRemote } from '../scan/repo.js';
+/**
+ * Which bucket a repository syncs into. The only file in sync that reads the
+ * binding from the sharing levels spec: with one that is trusted, its bucket and workspace;
+ * without, the slug from the remote, which is how everything worked before. An untrusted
+ * binding's bucket and workspace are both ignored, not just its workspace: reporting
+ * `untrustedWorkspace` instead so callers refuse rather than sync under the unreviewed name.
+ * Kept free of the SDK so a hook can call it without loading a client.
+ *
+ * Deviation from the plan: the sharing levels binding is `readBinding(start): { binding, root } | undefined`
+ * with `binding.workspace` (a uuid), not `readBinding(root): { workspaceId, bucket } | undefined`. Adapted here.
+ */
+export function syncSlug(start) {
+    const { root, git } = findRepoRoot(start);
+    const found = readBinding(root);
+    if (found && !isTrusted(found.root, found.binding.workspace)) {
+        // Never `repoInfo(root).slug`: it reads the same binding and would still hand back the
+        // untrusted file's own bucket name. Recomputed the way an unbound repository resolves,
+        // ignoring the binding entirely, same as `workspaceId` below.
+        const remote = git ? readOriginUrl(root) : undefined;
+        const slug = (remote && slugFromRemote(remote)) || localSlug(root);
+        return { root, git, slug, untrustedWorkspace: found.binding.workspace };
+    }
+    // Trusted or absent: delegate entirely to repoInfo, which applies the same trust check
+    // (`trustedBinding` in binding.ts) rather than re-reading `found.binding.bucket` here, so the
+    // two functions cannot drift on what a trusted binding hands back.
+    const info = repoInfo(root);
+    return { root, git, slug: info.slug, ...(info.workspace ? { workspaceId: info.workspace } : {}) };
+}