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

package/lib/index.js

@@ -27,7 +27,7 @@
  * this package ships with.
  * @module dsh-plugin-codegraph-tree-sitter
  */
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { stat } from 'node:fs/promises';
 import { join, posix } from 'node:path';
@@ -210,13 +210,26 @@ 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));
+            yield agentEvents.on('agent/created', payload => autoIndexOnSession(ctx, resolved, lastAutoRun, 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.
+ *
+ * `sessions/` and `profiles/` together are what makes it one: either alone is a plausible folder
+ * name inside an ordinary repository, and requiring both keeps a real workspace eligible. The check
+ * exists because a DSH home is by construction tens of thousands of files — indexing it can only
+ * ever hit the session-start size guard, so queueing the job produces a failure and nothing else.
+ * @param root - the absolute workspace path.
+ * @returns true when the directory holds the harness's own state.
+ */
+function isHarnessHome(root) {
+    return existsSync(join(root, 'sessions')) && existsSync(join(root, 'profiles'));
+}
 /**
  * Index a new session's workspace in the background — when nothing has indexed it yet, or when what
  * is there has gone stale.
@@ -234,13 +247,20 @@ const AUTO_INDEX_JOB_KIND = 'codegraph-index';
  * @param lastAutoRun - when this instance last started an automatic index for each root.
  * @param payload - the `agent/created` dispatch payload.
  */
-function autoIndexOnSession(ctx, config, lastAutoRun, payload) {
+function autoIndexOnSession(ctx, config, lastAutoRun, payload, ensureWatching) {
     try {
         const agent = payload.agent;
         const root = agent?.session?.header?.cwd;
         // No workspace means no root to claim: an agent created without a `cwd` has nothing to index.
         if (agent === undefined || !root)
             return;
+        // DSH's own home directory is not a code repository — `sessions/`, `attachments/`, the index
+        // databases and the installed plugins below it are a program's state. It is also tens of
+        // thousands of files, so every session opened there queued a job whose only possible outcome was
+        // the size guard failing. Skipping here keeps the job list honest: what is not a candidate never
+        // becomes a failure the user cannot act on.
+        if (isHarnessHome(root))
+            return;
         const now = Date.now();
         // A burst of sessions opened on one workspace must not queue the same rebuild repeatedly.
         const previous = lastAutoRun.get(root);
@@ -250,8 +270,14 @@ function autoIndexOnSession(ctx, config, lastAutoRun, payload) {
         // 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.
         const indexedAt = readStatusIndexedAt(root);
-        if (indexedAt !== undefined && now - indexedAt < config.autoRefreshAfterMs)
+        if (indexedAt !== undefined && now - indexedAt < config.autoRefreshAfterMs) {
+            // The graph is current, so no build is warranted — but watching is process-local state and
+            // this is the first time this process has seen this workspace. Without this call, a restart
+            // followed by a session in an up-to-date workspace would leave it unwatched until the sidecar
+            // aged out, and every edit until then would silently not reach the graph.
+            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');
@@ -361,7 +387,10 @@ function runAutoIndexJob(ctx, root, config, handle) {
                 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`);
-                return { status: 'failed', detail: 'workspace too large for automatic indexing' };
+                // `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, ` +

package/lib/rust-engine.d.ts

@@ -18,9 +18,9 @@ import type { FileExtraction } from './extract.ts';
 export declare const RUST_LANGUAGES: readonly string[];
 /**
  * Files handed to one addon call. The addon parses a batch across every core it can, so a large batch
- * is what makes it fast — but the call itself blocks the event loop for its whole duration, so the
- * batch is bounded to keep one call short enough that a watcher rebuild or a host request is not
- * stalled behind it.
+ * is what makes it fast. The call runs on libuv's thread pool (see {@link RustEngine}), so a batch no
+ * longer stalls the event loop; the bound now keeps one promise's lifetime — and the file text it
+ * holds in flight — reasonable, instead of capping a blocking call.
  */
 export declare const RUST_BATCH_SIZE = 200;
 /** One file as the addon takes it. */
@@ -39,11 +39,16 @@ export interface RustExtractInput {
 export interface RustEngine {
     /**
      * Extract definitions, calls, imports, and heritage for a batch of files.
+     *
+     * Answers a promise because the addon's body runs on libuv's thread pool: a synchronous native call
+     * blocked the host's event loop for the whole batch, which is what froze the desktop when automatic
+     * indexing ran inside the renderer. Callers `await` it; an older addon that still returns a string
+     * keeps working, because `await` on a non-promise is the value itself.
      * @param inputs - the files to extract; inputs in an unsupported language are silently skipped.
      * @param rulesJson - the `LanguageSpec` table, as JSON.
-     * @returns JSON of `{ results: [{ path, extraction }], supported: string[] }`.
+     * @returns a promise of JSON `{ results: [{ path, extraction }], supported: string[] }`.
      */
-    extractWorkspace(inputs: RustExtractInput[], rulesJson: string): string;
+    extractWorkspace(inputs: RustExtractInput[], rulesJson: string): Promise<string>;
 }
 /** Options for {@link loadRustEngine}. */
 export interface LoadRustEngineOptions {
@@ -53,14 +58,47 @@ export interface LoadRustEngineOptions {
      */
     readonly modulePath?: string;
 }
+/**
+ * Where the native package for this platform lives, when npm installed one.
+ *
+ * The addon ships as one optional dependency per platform (`optionalDependencies` in this package's
+ * manifest), so a `pnpm add` pulls exactly one binary — the one the running machine can `dlopen` —
+ * instead of every platform's. npm's `os`/`cpu` fields do the selection; a platform this project does
+ * not build for simply never installs one and the walk falls back to JS.
+ * @param platform - `process.platform`.
+ * @param arch - `process.arch`.
+ * @returns the package name, or `undefined` for a platform with no published build.
+ */
+export declare function nativePackageName(platform: string, arch: string): string | undefined;
+/**
+ * Resolve this platform's optional native package to its `.node` entry, if it is installed.
+ *
+ * `require.resolve` is the only thing that knows where a dependency actually landed — pnpm's store,
+ * npm's flat tree, a hoisted profile — so the path is asked for rather than constructed. A missing
+ * package, or one whose `main` does not resolve, is `undefined`: that is the documented "no addon"
+ * answer, not an error.
+ * @param platform - `process.platform`.
+ * @param arch - `process.arch`.
+ * @param resolve - module resolution, injectable so a test does not depend on what this machine has
+ *   installed.
+ * @returns the absolute path to the addon, or `undefined`.
+ */
+export declare function nativePackageModulePath(platform: string, arch: string, resolve?: (name: string) => string): string | undefined;
 /**
  * Every place the addon may live, most specific first.
  *
- * Two layouts matter: a package that ships the binary puts it in `artifacts/` beside `lib/` (the
- * published shape, and what a profile install gets when someone copies it in), while a repository
- * checkout builds it under `crates/indexer-rust/artifacts/`, three directories up from both `src/`
- * and `lib/` since those sit at the same depth. Trying both means one module works whether it was
- * installed or checked out.
+ * Three layouts matter: a package that ships the binary puts it in `artifacts/` beside `lib/` (the
+ * shape an older hand-copied install has), a repository checkout builds it under
+ * `crates/indexer-rust/artifacts/` (three directories up from both `src/` and `lib/`, which sit at the
+ * same depth), and an npm install carries it in the platform's optional dependency. Trying all three
+ * means one module works whether it was installed, copied in, or checked out.
+ * @param base - the importing module's URL; parameterized so a test can point at a scratch tree.
+ * @param fromPackage - this platform's optional-dependency path, or `undefined` when there is none.
+ * @returns absolute paths to try, in order.
+ */
+export declare function modulePathsFor(base: string, fromPackage: string | undefined): string[];
+/**
+ * The paths production should try, with this platform's optional package worked out for it.
  * @param base - the importing module's URL; parameterized so a test can point at a scratch tree.
  * @returns absolute paths to try, in order.
  */
@@ -89,7 +127,7 @@ export declare function loadRustEngine(options?: LoadRustEngineOptions): RustEng
  * @returns one extraction per path the addon answered for, or `undefined` when no answer can be
  *   trusted at all — no addon, a thrown call, or JSON that is not the documented shape.
  */
-export declare function extractWithRust(files: readonly RustExtractInput[], engine: RustEngine | undefined): Map<string, FileExtraction> | undefined;
+export declare function extractWithRust(files: readonly RustExtractInput[], engine: RustEngine | undefined): Promise<Map<string, FileExtraction> | undefined>;
 /**
  * Install a stand-in for the addon the walk resolves, or restore the real one.
  *

package/lib/rust-engine.js

@@ -20,30 +20,93 @@ import { LANGUAGE_TABLE } from "./languages.js";
 export const RUST_LANGUAGES = ['typescript', 'tsx', 'javascript', 'jsx'];
 /**
  * Files handed to one addon call. The addon parses a batch across every core it can, so a large batch
- * is what makes it fast — but the call itself blocks the event loop for its whole duration, so the
- * batch is bounded to keep one call short enough that a watcher rebuild or a host request is not
- * stalled behind it.
+ * is what makes it fast. The call runs on libuv's thread pool (see {@link RustEngine}), so a batch no
+ * longer stalls the event loop; the bound now keeps one promise's lifetime — and the file text it
+ * holds in flight — reasonable, instead of capping a blocking call.
  */
 export const RUST_BATCH_SIZE = 200;
 const require = createRequire(import.meta.url);
+/**
+ * Where the native package for this platform lives, when npm installed one.
+ *
+ * The addon ships as one optional dependency per platform (`optionalDependencies` in this package's
+ * manifest), so a `pnpm add` pulls exactly one binary — the one the running machine can `dlopen` —
+ * instead of every platform's. npm's `os`/`cpu` fields do the selection; a platform this project does
+ * not build for simply never installs one and the walk falls back to JS.
+ * @param platform - `process.platform`.
+ * @param arch - `process.arch`.
+ * @returns the package name, or `undefined` for a platform with no published build.
+ */
+export function nativePackageName(platform, arch) {
+    const suffix = NATIVE_PACKAGES[`${platform}-${arch}`];
+    return suffix === undefined ? undefined : `dsh-plugin-codegraph-indexer-${suffix}`;
+}
+/**
+ * The suffix each published platform package carries, keyed by `platform-arch`.
+ *
+ * A suffix is not mechanical: the Linux builds are `-gnu` because a musl one would have to be a
+ * separate artifact, while Windows spells its ABI out. Keeping the table explicit is what stops this
+ * from silently computing a package name nobody publishes.
+ */
+const NATIVE_PACKAGES = {
+    'darwin-arm64': 'darwin-arm64',
+    'darwin-x64': 'darwin-x64',
+    'linux-x64': 'linux-x64-gnu',
+    'linux-arm64': 'linux-arm64-gnu',
+    'win32-x64': 'win32-x64-msvc',
+};
+/**
+ * Resolve this platform's optional native package to its `.node` entry, if it is installed.
+ *
+ * `require.resolve` is the only thing that knows where a dependency actually landed — pnpm's store,
+ * npm's flat tree, a hoisted profile — so the path is asked for rather than constructed. A missing
+ * package, or one whose `main` does not resolve, is `undefined`: that is the documented "no addon"
+ * answer, not an error.
+ * @param platform - `process.platform`.
+ * @param arch - `process.arch`.
+ * @param resolve - module resolution, injectable so a test does not depend on what this machine has
+ *   installed.
+ * @returns the absolute path to the addon, or `undefined`.
+ */
+export function nativePackageModulePath(platform, arch, resolve = require.resolve) {
+    const name = nativePackageName(platform, arch);
+    if (name === undefined)
+        return undefined;
+    try {
+        return resolve(name);
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Every place the addon may live, most specific first.
  *
- * Two layouts matter: a package that ships the binary puts it in `artifacts/` beside `lib/` (the
- * published shape, and what a profile install gets when someone copies it in), while a repository
- * checkout builds it under `crates/indexer-rust/artifacts/`, three directories up from both `src/`
- * and `lib/` since those sit at the same depth. Trying both means one module works whether it was
- * installed or checked out.
+ * Three layouts matter: a package that ships the binary puts it in `artifacts/` beside `lib/` (the
+ * shape an older hand-copied install has), a repository checkout builds it under
+ * `crates/indexer-rust/artifacts/` (three directories up from both `src/` and `lib/`, which sit at the
+ * same depth), and an npm install carries it in the platform's optional dependency. Trying all three
+ * means one module works whether it was installed, copied in, or checked out.
  * @param base - the importing module's URL; parameterized so a test can point at a scratch tree.
+ * @param fromPackage - this platform's optional-dependency path, or `undefined` when there is none.
  * @returns absolute paths to try, in order.
  */
-export function candidateModulePaths(base = import.meta.url) {
+export function modulePathsFor(base, fromPackage) {
     const artifact = `codegraph-indexer.${process.platform}-${process.arch}.node`;
     return [
         fileURLToPath(new URL(`../artifacts/${artifact}`, base)),
         fileURLToPath(new URL(`../../../crates/indexer-rust/artifacts/${artifact}`, base)),
+        ...fromPackage === undefined ? [] : [fromPackage],
     ];
 }
+/**
+ * The paths production should try, with this platform's optional package worked out for it.
+ * @param base - the importing module's URL; parameterized so a test can point at a scratch tree.
+ * @returns absolute paths to try, in order.
+ */
+export function candidateModulePaths(base = import.meta.url) {
+    return modulePathsFor(base, nativePackageModulePath(process.platform, process.arch));
+}
 /** Addons already loaded, keyed by path, so a test's stand-in never shadows the real artifact. */
 const loaded = new Map();
 /**
@@ -149,7 +212,7 @@ function rustRulesJson() {
  * @returns one extraction per path the addon answered for, or `undefined` when no answer can be
  *   trusted at all — no addon, a thrown call, or JSON that is not the documented shape.
  */
-export function extractWithRust(files, engine) {
+export async function extractWithRust(files, engine) {
     const supported = files.filter(file => RUST_LANGUAGES.includes(file.language));
     if (supported.length === 0)
         return new Map();
@@ -159,7 +222,10 @@ export function extractWithRust(files, engine) {
     try {
         for (let start = 0; start < supported.length; start += RUST_BATCH_SIZE) {
             const batch = supported.slice(start, start + RUST_BATCH_SIZE);
-            const answer = JSON.parse(engine.extractWorkspace(batch, rustRulesJson()));
+            // Awaited one batch at a time: the addon already parses a batch across every core, so
+            // overlapping batches would only compete for the same threads while multiplying the text held
+            // in flight.
+            const answer = JSON.parse(await engine.extractWorkspace(batch, rustRulesJson()));
             if (!isRecord(answer) || !Array.isArray(answer.results))
                 return undefined;
             for (const entry of answer.results) {

package/lib/walk.js

@@ -223,7 +223,7 @@ async function extractPending(pending, config, signal) {
     // those itself (`RUST_LANGUAGES`), so the walk never keeps a second copy of that list in sync.
     const rusted = engine === undefined
         ? new Map()
-        : extractWithRust(pending.map(toRustInput), engine) ?? new Map();
+        : await extractWithRust(pending.map(toRustInput), engine) ?? new Map();
     const extracted = new Array(pending.length);
     const fallback = [];
     for (const [index, file] of pending.entries()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-codegraph-tree-sitter",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "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,13 +51,20 @@
     "@deepseek-ai/schemastery": "^3.18.1",
     "tree-sitter-wasms": "^0.1.13",
     "web-tree-sitter": "^0.25.10",
-    "dsh-plugin-codegraph-service": "^0.5.2"
+    "dsh-plugin-codegraph-service": "^0.6.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1",
     "@deepseek-ai/dsh-fs": ">=0.1.0-rc.6",
     "@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"
+  },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-invariants": "0.1.0-rc.6"