dsh-plugin-codegraph-tree-sitter 0.6.0 → 0.6.1

package/lib/index.js

@@ -146,6 +146,10 @@ export function apply(ctx, config) {
     // legitimately trigger another refresh. The map only keeps a burst of sessions opened at once from
     // queueing the same rebuild repeatedly; the freshness decision itself reads the status sidecar.
     const lastAutoRun = new Map();
+    // Roots whose background run is still executing. Kept apart from `lastAutoRun`, which is a time
+    // window: a first build can outlive the window, and two builds on one root would only race the same
+    // index files.
+    const autoIndexInFlight = new Set();
     // `agent/created` is typed by `@deepseek-ai/dsh-agent`'s module augmentation. Reading the event
     // through a local structural face keeps this package's host dependencies unchanged: it needs one
     // event name and one payload shape, not the whole agent package.
@@ -210,13 +214,11 @@ export function apply(ctx, config) {
         if (resolved.autoIndexOnSession) {
             // Registered inside this effect so the listener follows the plugin's lifetime: unloading the
             // plugin must stop new sessions from scheduling work this instance can no longer run.
-            yield agentEvents.on('agent/created', payload => autoIndexOnSession(ctx, resolved, lastAutoRun, payload, ensureWatching));
+            yield agentEvents.on('agent/created', payload => autoIndexOnSession(ctx, resolved, lastAutoRun, autoIndexInFlight, payload, ensureWatching));
         }
         yield ctx.codegraph.registerIndexer(indexer);
     }, 'codegraph-tree-sitter');
 }
-/** Stable job kind of an automatic session-start index, used for retention and diagnostics. */
-const AUTO_INDEX_JOB_KIND = 'codegraph-index';
 /**
  * Whether a directory is the harness's own home rather than a project checkout.
  *
@@ -235,19 +237,28 @@ function isHarnessHome(root) {
  * is there has gone stale.
  *
  * Runs synchronously inside `agent/created` dispatch, so it must never block or throw: it only decides
- * whether a build is warranted and hands one to the host's job registry. A synchronous build here
- * would stall agent creation for the length of a parse, which is why a composition without background
- * jobs does nothing instead.
+ * whether a build is warranted and starts one in the background. A synchronous build here would stall
+ * agent creation for the length of a parse.
+ *
+ * The run deliberately does **not** go through the host's job registry. A registered job reports its
+ * settlement back to the owning agent: the host injects a completion notice into the next step and,
+ * under its default `wakeup` delivery, opens a turn on an idle one. An automatic index nobody asked
+ * for must not appear in the transcript or start a reply of its own, so this runs as a plain
+ * background promise. The explicit `codegraph_index` tool still registers a job — there a caller is
+ * waiting for the id.
  *
  * Refreshing a stale index is what restarts the file watcher after a host restart: watching only
  * begins once a successful index has established a baseline, so a workspace whose index is minutes
  * old would otherwise stay frozen at whatever the last process left behind.
- * @param ctx - the plugin context, consulted for the optional job registry.
+ * @param ctx - the plugin context.
  * @param config - the resolved plugin configuration, for the staleness threshold.
  * @param lastAutoRun - when this instance last started an automatic index for each root.
+ * @param autoIndexInFlight - roots whose background run is still executing, so a slow build cannot be
+ * started twice by sessions that open past the freshness window.
  * @param payload - the `agent/created` dispatch payload.
+ * @param ensureWatching - starts file watching for a workspace that is already current.
  */
-function autoIndexOnSession(ctx, config, lastAutoRun, payload, ensureWatching) {
+function autoIndexOnSession(ctx, config, lastAutoRun, autoIndexInFlight, payload, ensureWatching) {
     try {
         const agent = payload.agent;
         const root = agent?.session?.header?.cwd;
@@ -266,9 +277,12 @@ function autoIndexOnSession(ctx, config, lastAutoRun, payload, ensureWatching) {
         const previous = lastAutoRun.get(root);
         if (previous !== undefined && now - previous < config.autoRefreshAfterMs)
             return;
+        // A build already running for this root is the one the window would have deduplicated had it been
+        // slow enough to straddle it; starting a second would only race the same index files.
+        if (autoIndexInFlight.has(root))
+            return;
         // A fresh sidecar means a recent run is already describing this workspace; an absent, unreadable
-        // or old one means the graph is missing or behind. Checked before the job lookup so a composition
-        // without background jobs never pays for the probe.
+        // or old one means the graph is missing or behind.
         const indexedAt = readStatusIndexedAt(root);
         if (indexedAt !== undefined && now - indexedAt < config.autoRefreshAfterMs) {
             // The graph is current, so no build is warranted — but watching is process-local state and
@@ -278,21 +292,10 @@ function autoIndexOnSession(ctx, config, lastAutoRun, payload, ensureWatching) {
             ensureWatching(root);
             return;
         }
-        // `ctx.get` rather than an `inject` entry: `jobs` is a host composition choice, and requiring it in
-        // `inject` would hide this whole indexer from a profile that runs no background jobs.
-        const jobs = ctx.get('jobs');
-        if (jobs === undefined)
-            return;
-        jobs.start({
-            // The registry keys a job by its owning session id, not the agent object.
-            owner: agent.id,
-            kind: AUTO_INDEX_JOB_KIND,
-            label: `codegraph auto index ${root}`,
-            run: handle => runAutoIndexJob(ctx, root, config, handle),
-        });
-        // Marked only after the registry accepted the job, so a transient refusal leaves the workspace
-        // eligible for the next session that opens in it.
         lastAutoRun.set(root, now);
+        autoIndexInFlight.add(root);
+        // Never rejects: a lost index is a degradation, not an error the session can act on.
+        void runAutomaticIndex(ctx, root, config).finally(() => autoIndexInFlight.delete(root));
     }
     catch (error) {
         // The host treats a throwing listener as vetoing publication. Losing an index is a degradation,
@@ -300,6 +303,33 @@ function autoIndexOnSession(ctx, config, lastAutoRun, payload, ensureWatching) {
         console.error(`codegraph-tree-sitter: automatic indexing for a new session failed: ${String(error)}`);
     }
 }
+/**
+ * Run one automatic index to completion, reporting a failure instead of propagating it.
+ *
+ * The size guard stays: parsing a workspace past `autoIndexMaxFiles` would exhaust the WASM heap and
+ * take the desktop down with it, and an automatic index is a convenience. Skipping it is a decision,
+ * not a failure, so it is logged once and the session continues untouched.
+ * @param ctx - the plugin context.
+ * @param root - absolute workspace path.
+ * @param config - the resolved plugin configuration.
+ */
+async function runAutomaticIndex(ctx, root, config) {
+    const controller = new AbortController();
+    try {
+        const oversized = await exceedsAutoIndexLimit(root, config, controller.signal);
+        if (oversized !== undefined) {
+            console.error(`codegraph-tree-sitter: skipped automatic indexing of ${root}: it holds at least ${String(oversized)} ` +
+                `candidate source files, past the ${String(config.autoIndexMaxFiles)}-file session-start limit. ` +
+                'Run codegraph_index yourself if you want a graph for it.');
+            return;
+        }
+        // A successful index is what starts file watching, inside `indexer.index`.
+        await ctx.codegraph.index(root, controller.signal);
+    }
+    catch (error) {
+        console.error(`codegraph-tree-sitter: automatic index for ${root} failed: ${String(error)}`);
+    }
+}
 /**
  * How many candidate source files `root` holds, when that is past the session-start limit.
  *
@@ -365,46 +395,6 @@ function readStatusIndexedAt(root) {
         return undefined;
     }
 }
-/**
- * The producer body of one automatic indexing job.
- *
- * Both halves of the host's job contract are mandatory: `cancel` aborts the run, and `done` settles
- * even on failure — a rejected `done` breaks the registry's bookkeeping and leaves the job looking
- * stuck forever.
- * @param ctx - the plugin context.
- * @param root - the workspace to index.
- * @param handle - the job's producer face, for the job's live log.
- * @returns the job's cancellation hook and settlement promise.
- */
-function runAutoIndexJob(ctx, root, config, handle) {
-    const controller = new AbortController();
-    const done = (async () => {
-        try {
-            const oversized = await exceedsAutoIndexLimit(root, config, controller.signal);
-            if (oversized !== undefined) {
-                // Declining here is the whole point of the check: parsing this workspace would exhaust the
-                // WASM heap and take the desktop down with it, and an automatic index is a convenience.
-                handle.append(`Skipped automatic indexing of ${root}: it holds at least ${String(oversized)} candidate ` +
-                    `source files, past the ${String(config.autoIndexMaxFiles)}-file session-start limit. ` +
-                    `Run codegraph_index yourself if you want a graph for it.\n`);
-                // `completed`, not `failed`: nothing went wrong. The guard decided this workspace is not a
-                // candidate for an automatic run, and a user reading the job list must be able to tell that
-                // apart from a build that actually broke.
-                return { status: 'completed', detail: 'skipped: workspace too large for automatic indexing' };
-            }
-            const report = await ctx.codegraph.index(root, controller.signal);
-            handle.append(`Indexed ${root}: ${report.filesIndexed} files, ${report.nodeCount} symbols, ` +
-                `${report.edgeCount} relationships.\n`);
-            return { status: 'completed' };
-        }
-        catch (error) {
-            const message = String(error);
-            handle.append(`codegraph auto index failed for ${root}: ${message}\n`);
-            return { status: 'failed', detail: message };
-        }
-    })();
-    return { cancel: () => controller.abort(), done };
-}
 /**
  * Run one watch-triggered reindex. Always a full rebuild in this version — `runIndex` has no notion of
  * a file subset — so the watcher's own collected paths are not consulted here.

package/lib/schema.js

@@ -144,7 +144,12 @@ export async function writeGraph(databasePath, input) {
  */
 async function writeStatusFile(directory, status) {
     const target = join(directory, basename(INDEX_STATUS_RELATIVE_PATH));
-    const temp = `${target}.tmp`;
+    // Unique like the graph's own staging name, and for the same reason: two runs on one workspace are
+    // allowed to overlap (a session-start build and an explicit `codegraph_index`, or a watcher rebuild),
+    // and a shared fixed-name `.tmp` makes the loser's `rename` fail with ENOENT after the winner moved
+    // it — which turned a harmless duplicate run into a failed tool call. Last rename wins; both graphs
+    // are complete.
+    const temp = `${target}.tmp-${process.pid}-${randomUUID()}`;
     await writeFile(temp, JSON.stringify(status));
     await rename(temp, target);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-codegraph-tree-sitter",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Self-built code-graph indexer for DeepSeek Harness — parses a workspace with web-tree-sitter and writes schema version 4 to .codegraph/codegraph.db, the same on-disk format the codegraph CLI writes, so no external indexer is required",
   "keywords": [
     "dsh",
@@ -51,7 +51,7 @@
     "@deepseek-ai/schemastery": "^3.18.1",
     "tree-sitter-wasms": "^0.1.13",
     "web-tree-sitter": "^0.25.10",
-    "dsh-plugin-codegraph-service": "^0.6.0"
+    "dsh-plugin-codegraph-service": "^0.6.1"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1",
@@ -59,11 +59,11 @@
     "@deepseek-ai/dsh-invariants": ">=0.1.0-rc.6"
   },
   "optionalDependencies": {
-    "dsh-plugin-codegraph-indexer-darwin-arm64": "0.6.0",
-    "dsh-plugin-codegraph-indexer-darwin-x64": "0.6.0",
-    "dsh-plugin-codegraph-indexer-linux-x64-gnu": "0.6.0",
-    "dsh-plugin-codegraph-indexer-linux-arm64-gnu": "0.6.0",
-    "dsh-plugin-codegraph-indexer-win32-x64-msvc": "0.6.0"
+    "dsh-plugin-codegraph-indexer-darwin-arm64": "0.6.1",
+    "dsh-plugin-codegraph-indexer-darwin-x64": "0.6.1",
+    "dsh-plugin-codegraph-indexer-linux-x64-gnu": "0.6.1",
+    "dsh-plugin-codegraph-indexer-linux-arm64-gnu": "0.6.1",
+    "dsh-plugin-codegraph-indexer-win32-x64-msvc": "0.6.1"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",