dsh-plugin-codegraph-tree-sitter 0.6.2 → 0.6.4

package/lib/index.d.ts

@@ -67,6 +67,14 @@ export declare const DEFAULT_INDEXER_ID = "codegraph-tree-sitter";
  * Directory segments never descended into by default. Includes this package's own `.codegraph`
  * output — without it, a watcher would treat its own `writeGraph()` as an in-scope change and
  * rebuild forever.
+ *
+ * `target` is here for a reason that cost real file descriptors to learn: this plugin is developed
+ * in its own repository, and `crates/indexer-rust/target/` holds thousands of cargo artefacts
+ * across ~1000 directories. Without the exclusion the walk descends into every one of them, and on
+ * macOS each watched file pins a descriptor — a single workspace accumulated 9.7k open handles,
+ * which is what makes a host's `spawn()` fail with `EBADF` long before any real limit is reached.
+ * `.scratch` and `vendor` cover the same shape of accident for working copies and dependency
+ * checkouts.
  */
 export declare const DEFAULT_EXCLUDE: string[];
 /** Default ceiling on a single file's size before it is skipped. */

package/lib/index.js

@@ -71,8 +71,26 @@ export const DEFAULT_INDEXER_ID = 'codegraph-tree-sitter';
  * Directory segments never descended into by default. Includes this package's own `.codegraph`
  * output — without it, a watcher would treat its own `writeGraph()` as an in-scope change and
  * rebuild forever.
+ *
+ * `target` is here for a reason that cost real file descriptors to learn: this plugin is developed
+ * in its own repository, and `crates/indexer-rust/target/` holds thousands of cargo artefacts
+ * across ~1000 directories. Without the exclusion the walk descends into every one of them, and on
+ * macOS each watched file pins a descriptor — a single workspace accumulated 9.7k open handles,
+ * which is what makes a host's `spawn()` fail with `EBADF` long before any real limit is reached.
+ * `.scratch` and `vendor` cover the same shape of accident for working copies and dependency
+ * checkouts.
  */
-export const DEFAULT_EXCLUDE = ['node_modules', 'dist', 'build', 'coverage', '.git', '.codegraph'];
+export const DEFAULT_EXCLUDE = [
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '.git',
+    '.codegraph',
+    'target',
+    '.scratch',
+    'vendor',
+];
 /** Default ceiling on a single file's size before it is skipped. */
 export const DEFAULT_MAX_FILE_BYTES = 2_000_000;
 /** Default ceiling on how many files one run indexes. */

package/lib/schema.js

@@ -10,7 +10,7 @@
  * naive "delete then recreate" leaves open between `CREATE TABLE` and the first `COMMIT`.
  * @module dsh-plugin-codegraph-tree-sitter/schema
  */
-import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { mkdir, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { randomUUID } from 'node:crypto';
@@ -52,6 +52,121 @@ async function removeGraphFiles(path) {
     await rm(`${path}-wal`, { force: true });
     await rm(`${path}-shm`, { force: true });
 }
+/**
+ * Report whether the process that claimed a lock file is still running.
+ *
+ * A timestamp is the wrong staleness test here: an index over a large tree legitimately runs
+ * for minutes, so any fixed window either steals a lock that is still held or waits forever on
+ * one whose holder crashed. The holder writes its pid after the exclusive create, and a pid the
+ * OS no longer knows is garbage. `process.kill(pid, 0)` sends no signal — it only asks whether
+ * the process exists; `EPERM` means it does and is simply not ours to signal.
+ * @param lockPath - absolute path of the `.graph.lock` file to inspect.
+ * @returns true when the recorded holder still exists.
+ */
+async function lockHolderIsAlive(lockPath) {
+    let raw;
+    try {
+        raw = await readFile(lockPath, 'utf8');
+    }
+    catch {
+        // Vanished between the failed `wx` and this read: let the caller retry the create.
+        return false;
+    }
+    const pid = Number.parseInt(raw, 10);
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // ESRCH: no such process. EPERM: alive, but owned by another user.
+        return error.code === 'EPERM';
+    }
+}
+/**
+ * Serialize graph writes on one workspace, across processes.
+ *
+ * Two runs used to be allowed to overlap (see writeStatusFile): each built its own
+ * temporary file and the last rename won. That is safe for the file, but the loser's
+ * status.json can then describe a graph the winner already replaced.
+ * @param dir - the `.codegraph` directory, which must already exist.
+ * @param work - the write to run while the lock is held.
+ */
+async function withGraphLock(dir, work) {
+    const lockPath = join(dir, '.graph.lock');
+    const ACQUIRE_MS = 10_000;
+    const RETRY_MS = 25;
+    const started = Date.now();
+    let handle = null;
+    while (handle === null) {
+        try {
+            handle = await open(lockPath, 'wx');
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            // A holder that died leaves the file behind; only a dead pid may be stolen, so a
+            // live run slower than ACQUIRE_MS is waited out rather than overrun.
+            if (!(await lockHolderIsAlive(lockPath))) {
+                try {
+                    await rm(lockPath, { force: true });
+                }
+                catch {
+                    // another contender reclaimed it first
+                }
+                continue;
+            }
+            if (Date.now() - started > ACQUIRE_MS) {
+                throw new Error(`codegraph: another index run holds ${lockPath}`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, RETRY_MS));
+        }
+    }
+    try {
+        // Record the holder so the next contender can tell a live run from a crashed one. An
+        // absent or unparseable pid reads as dead, which is also the right answer for a lock
+        // left by a process that died between the create and this write.
+        await handle.writeFile(String(process.pid));
+        return await work();
+    }
+    finally {
+        try {
+            await handle.close();
+        }
+        catch {
+            // already closed
+        }
+        try {
+            await rm(lockPath, { force: true });
+        }
+        catch {
+            // best effort
+        }
+    }
+}
+/**
+ * `rename` on Windows fails with EPERM/EBUSY/EACCES while ANY handle holds the target.
+ * Those are transient by nature -- an antivirus read, a reader closing its connection --
+ * and a single attempt turns one of them into a failed index.
+ */
+async function renameWithRetry(from, to) {
+    let last = null;
+    for (let attempt = 0; attempt <= 3; attempt += 1) {
+        try {
+            await rename(from, to);
+            return;
+        }
+        catch (error) {
+            last = error;
+            const retryable = ['EPERM', 'EBUSY', 'EACCES'];
+            if (!retryable.includes(error.code ?? '') || attempt === 3)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, 25 * (attempt + 1)));
+        }
+    }
+    throw last;
+}
 /**
  * Replace the graph at `databasePath` with one indexing run's output.
  *
@@ -63,6 +178,12 @@ async function removeGraphFiles(path) {
  * @param input - the run's resolved graph and per-file metadata.
  */
 export async function writeGraph(databasePath, input) {
+    // The lock file lives beside the database, so its directory must exist before the lock can
+    // be created — the first index of a workspace has no `.codegraph/` yet.
+    await mkdir(dirname(databasePath), { recursive: true });
+    return withGraphLock(dirname(databasePath), () => writeGraphUnlocked(databasePath, input));
+}
+async function writeGraphUnlocked(databasePath, input) {
     await mkdir(dirname(databasePath), { recursive: true });
     const tempPath = `${databasePath}.tmp-${process.pid}-${randomUUID()}`;
     // Defensive: a previous run that crashed mid-write may have left this exact temp name behind.
@@ -119,7 +240,15 @@ export async function writeGraph(databasePath, input) {
     // before the rename so the new file never inherits a stale WAL/SHM pair.
     await rm(`${databasePath}-wal`, { force: true });
     await rm(`${databasePath}-shm`, { force: true });
-    await rename(tempPath, databasePath);
+    try {
+        await renameWithRetry(tempPath, databasePath);
+    }
+    catch (error) {
+        // The rename sat outside the build's cleanup, so a failed replace left a finished
+        // multi-megabyte temp behind. Reproduced before this change.
+        await removeGraphFiles(tempPath);
+        throw error;
+    }
     // rename() only moves the main file; the temp name's own sidecars (should the driver have left any)
     // never travel with it and would otherwise linger under the temp name forever.
     await removeGraphFiles(tempPath);
@@ -149,7 +278,7 @@ export async function writeGraph(databasePath, input) {
 export async function writeJsonAtomically(target, value) {
     const temp = `${target}.tmp-${process.pid}-${randomUUID()}`;
     await writeFile(temp, JSON.stringify(value));
-    await rename(temp, target);
+    await renameWithRetry(temp, target);
 }
 /**
  * Write the prompt-time status sidecar beside the graph, replacing it atomically.

package/lib/walk.js

@@ -171,9 +171,12 @@ async function prepareCandidate(candidate, config, cache, signal) {
  */
 async function extractWithJs(file, signal) {
     const parser = await createParser(file.spec);
+    // Declared outside the `try` so the `finally` can free it: a `const` inside the `try` is not
+    // in scope there, and the tree is where a parse keeps its memory.
+    let tree = null;
     try {
         signal?.throwIfAborted();
-        const tree = parser.parse(file.text);
+        tree = parser.parse(file.text);
         /* v8 ignore next 2 -- createParser() always assigns a language before returning; parse() returns
          * null only when the parser has none. */
         if (tree === null)
@@ -181,6 +184,13 @@ async function extractWithJs(file, signal) {
         return extractFile(tree, file.spec);
     }
     finally {
+        // The memory a parse holds lives in the tree, not the parser: a 362 KB source keeps tens of
+        // megabytes of AST. Deleting only the parser leaked it for the life of the process -- measured
+        // on a 477-file workspace: RSS +103 MB per index run, +1.1 GB across 11 runs before the host ran
+        // out of memory. With this line the same loop is flat at 95 MB.
+        /* v8 ignore next -- the same impossible null as the check above: parse() returns null only
+         * when the parser has no language, which createParser() never returns. */
+        tree?.delete();
         parser.delete();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-codegraph-tree-sitter",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "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.2"
+    "dsh-plugin-codegraph-service": "^0.6.4"
   },
   "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.2",
-    "dsh-plugin-codegraph-indexer-darwin-x64": "0.6.2",
-    "dsh-plugin-codegraph-indexer-linux-x64-gnu": "0.6.2",
-    "dsh-plugin-codegraph-indexer-linux-arm64-gnu": "0.6.2",
-    "dsh-plugin-codegraph-indexer-win32-x64-msvc": "0.6.2"
+    "dsh-plugin-codegraph-indexer-darwin-arm64": "0.6.4",
+    "dsh-plugin-codegraph-indexer-darwin-x64": "0.6.4",
+    "dsh-plugin-codegraph-indexer-linux-x64-gnu": "0.6.4",
+    "dsh-plugin-codegraph-indexer-linux-arm64-gnu": "0.6.4",
+    "dsh-plugin-codegraph-indexer-win32-x64-msvc": "0.6.4"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",