gigarag-claude-code 0.1.1 → 0.2.1

package/cli/sync/worker.js

@@ -0,0 +1,159 @@
+import { spawn } from 'node:child_process';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isSea } from 'node:sea';
+import { stateDir } from '../paths.js';
+import { State } from '../state.js';
+import { isClean } from '../git/git.js';
+import { maxRewriteFiles, writeNote } from './notes.js';
+import { syncSlug } from './slug.js';
+import { RepoSyncRemote } from './remote.js';
+import { claudeInvocation, findClaude, runRewriter } from './rewriter.js';
+import { finishSync, holderFor, leaseMetaKey, runStage, WORKER_LOCK_MS as LOCK_MS } from './stage.js';
+import { syncTarget } from './target.js';
+const TICK_MS = 4 * 60_000;
+const CHILD_TIMEOUT_MS = 40 * 60_000;
+const quietMs = () => {
+    const n = Number(process.env['GIGARAG_SYNC_QUIET_MS']);
+    return Number.isFinite(n) && n >= 0 ? n : 20_000;
+};
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+/** Starts the background worker for `root`, detached from whatever is calling this, and does not
+ * wait for it. Used by a git hook, and by `sync end`/`sync begin` when clearing the interactive
+ * marker frees a hook-mode sync that deferred behind it (its `deferred` note), so that commit
+ * gets synced once the marker is gone instead of waiting for another one to arrive. */
+export function spawnWorker(root) {
+    const [cmd, args] = isSea()
+        ? [process.execPath, ['sync', 'worker', root]]
+        : [process.execPath, [fileURLToPath(new URL('../bin.js', import.meta.url)), 'sync', 'worker', root]];
+    spawn(cmd, args, { detached: true, stdio: 'ignore', windowsHide: true, cwd: root }).unref();
+}
+/**
+ * What a git hook runs. Records that a sync was asked for and starts the
+ * worker detached, then returns, so the hook costs one Node start in the
+ * background. Every failure ends as exit 0 and silence.
+ */
+export async function hookEntry(_hook) {
+    try {
+        if (process.env['GIGARAG_NO_SYNC'] || process.env['GIGARAG_SYNC_WORKER'])
+            return 0;
+        const { root, git, slug } = syncSlug(process.cwd());
+        if (!git)
+            return 0;
+        const state = new State();
+        try {
+            state.setMeta(`sync_request:${slug}`, String(Date.now()));
+        }
+        finally {
+            state.close();
+        }
+        spawnWorker(root);
+    }
+    catch {
+        /* a hook never fails the git command that ran it */
+    }
+    return 0;
+}
+/**
+ * The background run. One per repository at a time (a local lock), started no
+ * sooner than the quiet period after the latest request, and run again if a
+ * request arrived while it worked, so a burst of commits costs one run.
+ */
+export async function runWorker(root) {
+    const target = syncTarget(resolve(root));
+    const state = new State();
+    const lockKey = `sync_run:${target.slug}`;
+    try {
+        if (!state.tryAcquire(lockKey, LOCK_MS))
+            return 0;
+        for (;;) {
+            const requested = Number(state.getMeta(`sync_request:${target.slug}`) ?? 0);
+            const wait = requested + quietMs() - Date.now();
+            if (wait > 0) {
+                await sleep(wait);
+                continue;
+            }
+            const started = Date.now();
+            state.setMeta(lockKey, String(started));
+            try {
+                await syncOnce(state, target);
+            }
+            finally {
+                // Release before looking for another request. A hook that fires between the sync
+                // finishing and this check must find the lock free, or its request is lost: this
+                // run is about to decide there is nothing left to do, and nothing else would ever
+                // look again.
+                state.setMeta(lockKey, '0');
+            }
+            if (Number(state.getMeta(`sync_request:${target.slug}`) ?? 0) <= started)
+                return 0;
+            if (!state.tryAcquire(lockKey, LOCK_MS))
+                return 0;
+        }
+    }
+    catch (e) {
+        state.setMeta(lockKey, '0');
+        writeNote(state, target.slug, { kind: 'failed', detail: e.message });
+        return 1;
+    }
+    finally {
+        state.close();
+    }
+}
+async function syncOnce(state, target) {
+    const stage = await runStage(state, target, { mode: 'hook' });
+    if (stage.kind === 'stop') {
+        if (stage.note)
+            writeNote(state, target.slug, stage.note);
+        return;
+    }
+    const remote = new RepoSyncRemote(target.rag(), stage.bucketId);
+    let token = stage.token;
+    try {
+        const { plan } = stage;
+        const work = plan.rewrite.length + plan.partial.length;
+        const commit = stage.head;
+        if (plan.suspicious) {
+            writeNote(state, target.slug, { kind: 'mass_delete', files: plan.goneCount });
+            return;
+        }
+        if (work === 0) {
+            await finishSync(state, target, { bucketId: stage.bucketId, token, mode: 'hook' });
+            return;
+        }
+        if (work > maxRewriteFiles()) {
+            writeNote(state, target.slug, { kind: 'needs_approval', files: work, ...(commit ? { commit } : {}) });
+            return;
+        }
+        if (!isClean(target.root)) {
+            writeNote(state, target.slug, { kind: 'dirty', files: plan.stale.length, ...(commit ? { commit } : {}) });
+            return;
+        }
+        const claude = process.env['GIGARAG_NO_REWRITE'] ? undefined : findClaude(process.env, process.platform);
+        if (!claude) {
+            writeNote(state, target.slug, { kind: 'no_agent', files: plan.stale.length, ...(commit ? { commit } : {}) });
+            return;
+        }
+        const outcome = await runRewriter(claudeInvocation(claude, process.platform), target.root, join(stateDir(), 'logs', `sync-${target.slug}.log`), {
+            timeoutMs: CHILD_TIMEOUT_MS,
+            tickMs: TICK_MS,
+            onTick: async () => {
+                const renewed = await remote.claim(holderFor(state, 'hook'), token);
+                if (renewed.granted)
+                    token = renewed.token;
+            },
+            env: { ...process.env, GIGARAG_SYNC_WORKER: '1' },
+        });
+        if (outcome.timedOut || outcome.code !== 0) {
+            writeNote(state, target.slug, { kind: 'failed', detail: outcome.timedOut ? 'it ran past 40 minutes and was stopped' : `claude exited with code ${outcome.code ?? 'none'}` });
+            return;
+        }
+        const fin = await finishSync(state, target, { bucketId: stage.bucketId, token, mode: 'hook' });
+        if (!fin.advanced)
+            writeNote(state, target.slug, { kind: 'failed', detail: `the agent finished with ${fin.remaining} files still to rewrite` });
+    }
+    finally {
+        await remote.release(token);
+        state.setMeta(leaseMetaKey(target.slug, 'hook'), '');
+    }
+}

package/commands/gigaindex.md

@@ -5,6 +5,12 @@ argument-hint: [path]
 
 Index the codebase at "$ARGUMENTS" into GigaRAG. If that is empty, use the current directory.
 
+First, check which workspace this repository uses. Run `gigarag repo` in it. If the output has no `workspace`, run `gigarag workspaces --json`. When that lists more than one workspace, ask me which one this repository belongs to, showing each name and how I reach it, then run `gigarag use <id>` in the repository root. If I pick a workspace where I am a guest, `gigarag use` asks for `--bucket` and lists the buckets I can write to; ask me which, and run it again with `--bucket <slug>`. When it lists only one workspace, use it without asking.
+
 Hand the work to the `gigarag:gigarag-indexer` subagent, so the repository walk happens in its own context and not in this conversation. Run it in the foreground and wait for it to finish, because a background run ends with nothing indexed if this session closes first. Give it the path exactly as I gave it, or the current directory, and tell it to run a full index.
 
-When it finishes, tell me in five lines or fewer: the bucket it used, how many memos it created, updated and deleted, anything it could not index and why, and whether the index is now up to date. Do not paste the file list.
+If `gigarag scan` (which the subagent runs first) refuses because `.gigarag.json` names a workspace that has not been trusted, it exits nonzero and prints why instead of a manifest. Stop there, relay exactly what it printed to me, and do not run `gigarag use` on my behalf: someone should look at that file before it is trusted or replaced. If I placed or reviewed it myself I run `gigarag trust`; if it should point elsewhere I run `gigarag use <workspace>` myself. Only then run `/gigaindex` again.
+
+When it finishes, run `gigarag sync end --init` in the directory that was indexed. It saves the index on the server, records the current branch as the one GigaRAG keeps in sync, and installs git hooks that sync after each commit on it.
+
+Then tell me in five lines or fewer: the bucket it used, how many memos it created, updated and deleted, anything it could not index and why, whether the index is now up to date, and the last line `gigarag sync end --init` printed. Do not paste the file list.

package/commands/gigasync.md

@@ -2,8 +2,10 @@
 description: Bring GigaRAG up to date with the files that changed since the last index
 ---
 
-Run `gigarag scan --summary` in the current directory and read the counts.
+Run `gigarag sync begin` in the current directory. It claims this repository's sync lease, applies the renames and deletions that need no model, and marks the memos of changed files stale.
 
-If nothing is new, changed or gone, say "GigaRAG is up to date with this repository." and stop. Do not start the indexer for nothing.
+If it exits with status 3, tell me what it printed, in its words, and stop. Do not start the indexer.
 
-Otherwise hand the work to the `gigarag:gigarag-indexer` subagent, in the foreground and waiting for it to finish, for the current directory, and tell it this is an incremental sync: only the files the scan reports. When it finishes, tell me in three lines or fewer what changed: memos created, updated and deleted.
+Then run `gigarag scan --summary` and read the counts. If nothing is new, changed or gone, run `gigarag sync end`, say "GigaRAG is up to date with this repository." and stop.
+
+Otherwise hand the work to the `gigarag:gigarag-indexer` subagent, in the foreground and waiting for it to finish, for the current directory, and tell it this is an incremental sync: only the files the scan reports. When it finishes, run `gigarag sync end`. Tell me in three lines or fewer what changed: memos created, updated and deleted, and the last line `gigarag sync end` printed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gigarag-claude-code",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "The GigaRAG plugin for Claude Code. Commands, an indexing agent, hooks and an MCP server that carry the gigarag CLI inside them.",
   "license": "UNLICENSED",
   "files": [