dsh-plugin-codegraph-tree-sitter 0.1.5 → 0.1.7

package/lib/index.d.ts

@@ -25,6 +25,8 @@ export { loadGitignore, matchesGitignore, parseGitignore } from './gitignore.ts'
 export type { GitignoreRule } from './gitignore.ts';
 export { resolveWorkspace } from './resolve.ts';
 export type { ExtractedFile, GraphEdge, GraphNode, ResolvedGraph, UnresolvedRef } from './resolve.ts';
+export { isMinifiedName, looksMinified, measureText, MINIFIED_AVERAGE_LINE_LENGTH } from './minified.ts';
+export type { TextShape } from './minified.ts';
 export { SCHEMA_VERSION, writeGraph } from './schema.ts';
 export { isExcluded, walkAndExtract } from './walk.ts';
 export type { WalkConfig, WalkResult } from './walk.ts';
@@ -80,6 +82,18 @@ export interface Config {
      * see `./gitignore.ts`. A project with no root `.gitignore` is unaffected either way.
      */
     respectGitignore?: boolean;
+    /**
+     * Leave generated (bundled or minified) artifacts out of the index instead of parsing them
+     * (default true). A workspace that commits its build output — `dist/` in version control so a
+     * server can serve it — hands the walk megabytes of bundler output declaring thousands of short
+     * mangled names; indexing it both dominates the run's time and collides with real source symbols,
+     * making "one unique workspace-wide name wins" refuse calls the duplicates made ambiguous.
+     *
+     * Two signals, one structural: a `.min.` path segment, or an average line length past
+     * {@link MINIFIED_AVERAGE_LINE_LENGTH}. Set false to index such files anyway, or name their
+     * directory in `exclude`.
+     */
+    skipMinified?: boolean;
     /** Files larger than this are skipped and counted in the report, never parsed (default 2000000). */
     maxFileBytes?: number;
     /** The walk stops discovering new files once this many have been found (default 50000). */

package/lib/index.js

@@ -29,6 +29,7 @@ export { LANGUAGE_TABLE, languageFor } from "./languages.js";
 export { extractFile } from "./extract.js";
 export { loadGitignore, matchesGitignore, parseGitignore } from "./gitignore.js";
 export { resolveWorkspace } from "./resolve.js";
+export { isMinifiedName, looksMinified, measureText, MINIFIED_AVERAGE_LINE_LENGTH } from "./minified.js";
 export { SCHEMA_VERSION, writeGraph } from "./schema.js";
 export { isExcluded, walkAndExtract } from "./walk.js";
 export { createWatcher, nodeWatch } from "./watcher.js";
@@ -64,6 +65,7 @@ export const Config = z.object({
     languages: z.array(z.string()).default([...new Set(LANGUAGE_TABLE.map(spec => spec.language))]),
     exclude: z.array(z.string()).default(DEFAULT_EXCLUDE),
     respectGitignore: z.boolean().default(true),
+    skipMinified: z.boolean().default(true),
     maxFileBytes: z.number().default(DEFAULT_MAX_FILE_BYTES),
     maxFiles: z.number().default(DEFAULT_MAX_FILES),
     concurrency: z.number().default(DEFAULT_CONCURRENCY),
@@ -167,9 +169,10 @@ async function runSync(projectRoot, config) {
  * @returns the run's report.
  */
 async function runIndex(projectRoot, config, signal) {
-    const { files, filesSkipped } = await walkAndExtract(projectRoot, {
+    const { files, filesSkipped, filesMinified } = await walkAndExtract(projectRoot, {
         exclude: config.exclude,
         respectGitignore: config.respectGitignore,
+        skipMinified: config.skipMinified,
         maxFileBytes: config.maxFileBytes,
         maxFiles: config.maxFiles,
         concurrency: config.concurrency,
@@ -191,6 +194,7 @@ async function runIndex(projectRoot, config, signal) {
         projectRoot,
         filesIndexed: files.length,
         filesSkipped,
+        filesMinified,
         nodeCount: graph.nodes.length,
         edgeCount: graph.edges.length,
         unresolvedCount: graph.unresolved.length,

package/lib/minified.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Detection of generated (bundled or minified) code, so an index can leave it out.
+ *
+ * A workspace's build output is not always gitignored: a deployment that ships committed artifacts
+ * (`dist/` committed so a server can serve it as-is) hands the walk megabytes of bundler output that
+ * is neither source nor hidden from version control. Indexing it is not merely wasted time — those
+ * files declare thousands of short, mangled names (`e`, `t`, `n`) that collide with real source
+ * symbols, and "one unique workspace-wide name wins" then refuses to resolve every call that the
+ * duplicate makes ambiguous.
+ *
+ * Two signals, both structural rather than name-based on a build tool:
+ *  - a `.min.` path segment (`bundle.min.js`) — the conventional marker, checked before any read;
+ *  - an average source line longer than {@link MINIFIED_AVERAGE_LINE_LENGTH} characters, which
+ *    hand-written code does not reach. Measured on real workspaces: the longest average found in
+ *    hand-written source is ~70 characters, while bundled output runs from thousands to tens of
+ *    thousands.
+ * @module dsh-plugin-codegraph-tree-sitter/minified
+ */
+/**
+ * Average line length at or above which a file is treated as generated output. Chosen with roughly
+ * 7× headroom over the widest real source line measured (~70 characters), and far below the narrowest
+ * generated sample seen (~5 000).
+ */
+export declare const MINIFIED_AVERAGE_LINE_LENGTH = 500;
+/** A file's size expressed in lines, without allocating one array element per line. */
+export interface TextShape {
+    /** Number of newline-separated lines, matching `text.split('\n').length`. */
+    readonly lineCount: number;
+    /** Mean characters per line, counting the trailing partial line. */
+    readonly averageLineLength: number;
+}
+/**
+ * Measure a file's line structure in one pass over its text.
+ * @param text - the file's decoded contents.
+ * @returns its line count and mean line length. An empty file is one empty line, matching
+ *   `''.split('\n').length`.
+ */
+export declare function measureText(text: string): TextShape;
+/**
+ * Whether a path carries the conventional `.min.` marker, which needs no content read to decide.
+ * @param path - project-relative path of the file.
+ * @returns whether its own name marks it as minified.
+ */
+export declare function isMinifiedName(path: string): boolean;
+/**
+ * Whether a file is generated output the index should leave out.
+ * @param path - project-relative path of the file.
+ * @param shape - the file's measured line structure.
+ * @returns whether its name or its line shape marks it as generated.
+ */
+export declare function looksMinified(path: string, shape: TextShape): boolean;
+//# sourceMappingURL=minified.d.ts.map

package/lib/minified.js

@@ -0,0 +1,58 @@
+/**
+ * Detection of generated (bundled or minified) code, so an index can leave it out.
+ *
+ * A workspace's build output is not always gitignored: a deployment that ships committed artifacts
+ * (`dist/` committed so a server can serve it as-is) hands the walk megabytes of bundler output that
+ * is neither source nor hidden from version control. Indexing it is not merely wasted time — those
+ * files declare thousands of short, mangled names (`e`, `t`, `n`) that collide with real source
+ * symbols, and "one unique workspace-wide name wins" then refuses to resolve every call that the
+ * duplicate makes ambiguous.
+ *
+ * Two signals, both structural rather than name-based on a build tool:
+ *  - a `.min.` path segment (`bundle.min.js`) — the conventional marker, checked before any read;
+ *  - an average source line longer than {@link MINIFIED_AVERAGE_LINE_LENGTH} characters, which
+ *    hand-written code does not reach. Measured on real workspaces: the longest average found in
+ *    hand-written source is ~70 characters, while bundled output runs from thousands to tens of
+ *    thousands.
+ * @module dsh-plugin-codegraph-tree-sitter/minified
+ */
+import { posix } from 'node:path';
+/**
+ * Average line length at or above which a file is treated as generated output. Chosen with roughly
+ * 7× headroom over the widest real source line measured (~70 characters), and far below the narrowest
+ * generated sample seen (~5 000).
+ */
+export const MINIFIED_AVERAGE_LINE_LENGTH = 500;
+/**
+ * Measure a file's line structure in one pass over its text.
+ * @param text - the file's decoded contents.
+ * @returns its line count and mean line length. An empty file is one empty line, matching
+ *   `''.split('\n').length`.
+ */
+export function measureText(text) {
+    let newlines = 0;
+    for (let index = 0; index < text.length; index++) {
+        if (text.charCodeAt(index) === 10)
+            newlines++;
+    }
+    const lineCount = newlines + 1;
+    return { lineCount, averageLineLength: text.length / lineCount };
+}
+/**
+ * Whether a path carries the conventional `.min.` marker, which needs no content read to decide.
+ * @param path - project-relative path of the file.
+ * @returns whether its own name marks it as minified.
+ */
+export function isMinifiedName(path) {
+    return posix.basename(path).includes('.min.');
+}
+/**
+ * Whether a file is generated output the index should leave out.
+ * @param path - project-relative path of the file.
+ * @param shape - the file's measured line structure.
+ * @returns whether its name or its line shape marks it as generated.
+ */
+export function looksMinified(path, shape) {
+    return isMinifiedName(path) || shape.averageLineLength >= MINIFIED_AVERAGE_LINE_LENGTH;
+}
+//# sourceMappingURL=minified.js.map

package/lib/resolve.d.ts

@@ -3,13 +3,20 @@
  *
  * Pass 1 collects every definition into a name index. Pass 2 resolves each call site's callee name,
  * in order: (1) the enclosing file imports that name from a relative specifier resolving to a file
- * this run indexed — that file's matching declaration wins; (2) otherwise exactly one definition
- * workspace-wide carries the name — it wins; (3) otherwise the call is recorded in `unresolved` and no
- * `calls` edge is written. An ambiguous edge is worse than a missing one: the model acts on `callers`
- * output, so a confidently wrong caller sends it to edit the wrong file, while a missing caller merely
- * sends it back to text search.
+ * this run indexed — that file's matching declaration wins; (2) otherwise exactly one definition **in
+ * the calling file itself** carries the name — lexical scope settles it before the workspace gets a
+ * say, which is what keeps a helper declared in two test files (or a `render` in two components) from
+ * being counted as ambiguous; (3) otherwise exactly one definition workspace-wide carries the name —
+ * it wins; (4) otherwise the call is recorded in `unresolved` and no `calls` edge is written. An
+ * ambiguous edge is worse than a missing one: the model acts on `callers` output, so a confidently
+ * wrong caller sends it to edit the wrong file, while a missing caller merely sends it back to text
+ * search.
  *
- * Rule 3's `unresolved` entries are not one uniform signal. Each carries {@link UnresolvedRef.likelyExternal},
+ * Rule 2 is restricted to bare calls. A member call (`x.map()`) names a property of a receiver whose
+ * type this resolver does not track, so a same-named local declaration winning it would be a guess
+ * rather than a scope resolution — exactly the kind of confidently wrong edge rule 4 exists to avoid.
+ *
+ * Rule 4's `unresolved` entries are not one uniform signal. Each carries {@link UnresolvedRef.likelyExternal},
  * which is true for a member call (no type information behind its receiver) or a name the file itself
  * imports (a known external origin the specifier just didn't resolve) — both real code that was never a
  * candidate for a workspace edge, as against a bare, undeclared name, which is the actual gap this

package/lib/resolve.js

@@ -3,13 +3,20 @@
  *
  * Pass 1 collects every definition into a name index. Pass 2 resolves each call site's callee name,
  * in order: (1) the enclosing file imports that name from a relative specifier resolving to a file
- * this run indexed — that file's matching declaration wins; (2) otherwise exactly one definition
- * workspace-wide carries the name — it wins; (3) otherwise the call is recorded in `unresolved` and no
- * `calls` edge is written. An ambiguous edge is worse than a missing one: the model acts on `callers`
- * output, so a confidently wrong caller sends it to edit the wrong file, while a missing caller merely
- * sends it back to text search.
+ * this run indexed — that file's matching declaration wins; (2) otherwise exactly one definition **in
+ * the calling file itself** carries the name — lexical scope settles it before the workspace gets a
+ * say, which is what keeps a helper declared in two test files (or a `render` in two components) from
+ * being counted as ambiguous; (3) otherwise exactly one definition workspace-wide carries the name —
+ * it wins; (4) otherwise the call is recorded in `unresolved` and no `calls` edge is written. An
+ * ambiguous edge is worse than a missing one: the model acts on `callers` output, so a confidently
+ * wrong caller sends it to edit the wrong file, while a missing caller merely sends it back to text
+ * search.
  *
- * Rule 3's `unresolved` entries are not one uniform signal. Each carries {@link UnresolvedRef.likelyExternal},
+ * Rule 2 is restricted to bare calls. A member call (`x.map()`) names a property of a receiver whose
+ * type this resolver does not track, so a same-named local declaration winning it would be a guess
+ * rather than a scope resolution — exactly the kind of confidently wrong edge rule 4 exists to avoid.
+ *
+ * Rule 4's `unresolved` entries are not one uniform signal. Each carries {@link UnresolvedRef.likelyExternal},
  * which is true for a member call (no type information behind its receiver) or a name the file itself
  * imports (a known external origin the specifier just didn't resolve) — both real code that was never a
  * candidate for a workspace edge, as against a bare, undeclared name, which is the actual gap this
@@ -99,6 +106,22 @@ function buildNameIndex(nodesByFile) {
     }
     return index;
 }
+/**
+ * Group one file's own nodes by declaration name, for the same-file tier of call resolution.
+ * @param nodes - the nodes declared in one file.
+ * @returns every name that file declares, mapped to the nodes carrying it.
+ */
+function indexByName(nodes) {
+    const index = new Map();
+    for (const node of nodes) {
+        const existing = index.get(node.name);
+        if (existing === undefined)
+            index.set(node.name, [node]);
+        else
+            existing.push(node);
+    }
+    return index;
+}
 /**
  * A name index restricted to `class`/`interface` nodes, for `extends`/`implements` resolution.
  * `extractHeritage` only ever names a base class or interface, never a function or variable — indexing
@@ -213,9 +236,10 @@ export function resolveWorkspace(files, now) {
         }
         const keyToId = mustGet(defIdByKey, file.path);
         const importedLocalNames = new Set(file.extraction.imports.map(binding => binding.localName));
+        const localByName = indexByName(mustGet(nodesByFile, file.path));
         for (const call of file.extraction.calls) {
             const callerId = call.callerKey === null ? mustGet(fileNodeId, file.path) : mustGet(keyToId, call.callerKey);
-            const resolved = resolveName(call.calleeName, bindings, nodesByFile, nameIndex);
+            const resolved = resolveName(call.calleeName, bindings, nodesByFile, call.isMemberCall ? undefined : localByName, nameIndex);
             if (resolved === undefined) {
                 const likelyExternal = call.isMemberCall || importedLocalNames.has(call.calleeName);
                 unresolved.push({ source: callerId, filePath: file.path, calleeName: call.calleeName, line: call.line, col: call.column, likelyExternal });
@@ -228,7 +252,7 @@ export function resolveWorkspace(files, now) {
         // on it) is a calibrated signal specifically about call-resolution gaps; folding in a different edge
         // kind would change what that count measures.
         for (const ref of file.extraction.heritage) {
-            const resolved = resolveName(ref.targetName, bindings, nodesByFile, typeNameIndex);
+            const resolved = resolveName(ref.targetName, bindings, nodesByFile, undefined, typeNameIndex);
             if (resolved === undefined)
                 continue;
             edges.push({ source: mustGet(keyToId, ref.sourceKey), target: resolved, kind: ref.relation, provenance: 'tree-sitter' });
@@ -237,13 +261,21 @@ export function resolveWorkspace(files, now) {
     return { nodes, edges, unresolved };
 }
 /**
- * Resolve a bare name to exactly one declaration, or `undefined` per rule 3 — shared by call
+ * Resolve a bare name to exactly one declaration, or `undefined` per rule 4 — shared by call
  * resolution (against the workspace-wide, any-kind `nameIndex`) and `extends`/`implements` resolution
- * (against the `class`/`interface`-only {@link buildTypeNameIndex}); the two-tier rule itself (an
- * imported binding wins if unambiguous in its target file, else a workspace-wide-unique name wins) does
- * not depend on which candidate pool the caller passes in.
+ * (against the `class`/`interface`-only {@link buildTypeNameIndex}); the rule itself (an imported
+ * binding wins if unambiguous in its target file, else a same-file declaration when the caller passes
+ * one, else a workspace-wide-unique name wins) does not depend on which candidate pool the caller
+ * passes in.
+ * @param calleeName - the name at the call or heritage site.
+ * @param bindings - the calling file's resolved import bindings.
+ * @param nodesByFile - every file's declarations, for the import target lookup.
+ * @param localByName - the calling file's own declarations, or `undefined` to skip the same-file tier
+ *   (the caller decides: member calls and heritage references do not get it).
+ * @param nameIndex - the workspace-wide candidate pool this reference resolves against.
+ * @returns the winning declaration's node id, or `undefined` when nothing settles it.
  */
-function resolveName(calleeName, bindings, nodesByFile, nameIndex) {
+function resolveName(calleeName, bindings, nodesByFile, localByName, nameIndex) {
     const bound = bindings.byLocalName.get(calleeName);
     if (bound !== undefined) {
         const targetNodes = mustGet(nodesByFile, bound.targetFile);
@@ -253,6 +285,11 @@ function resolveName(calleeName, bindings, nodesByFile, nameIndex) {
         if (candidates.length === 1)
             return candidates[0]?.id;
     }
+    // Lexical scope before workspace scope: a name this very file declares is the call's declaration
+    // whenever exactly one declaration carries it, no matter how many other files reuse the name.
+    const local = localByName?.get(calleeName);
+    if (local !== undefined && local.length === 1)
+        return local[0]?.id;
     const workspaceWide = nameIndex.get(calleeName) ?? [];
     return workspaceWide.length === 1 ? workspaceWide[0]?.id : undefined;
 }

package/lib/walk.d.ts

@@ -33,6 +33,12 @@ export interface WalkConfig {
     readonly concurrency: number;
     /** Restrict extraction to these seam language labels when set; every loaded grammar otherwise. */
     readonly languages?: readonly string[];
+    /**
+     * Leave generated (bundled or minified) artifacts out of the index instead of parsing them. See
+     * `./minified.ts` for the two signals; a workspace that commits its build output is the case this
+     * exists for, since such output is neither gitignored nor declared in `exclude`.
+     */
+    readonly skipMinified: boolean;
     /**
      * Also exclude whatever the project root's `.gitignore` names, unioned with `exclude`. A project
      * that compiles to a gitignored directory (`lib`, `dist`, ...) would otherwise hand the same symbol
@@ -44,7 +50,11 @@ export interface WalkConfig {
 /** What the walk produced. */
 export interface WalkResult {
     readonly files: ExtractedFile[];
+    /** Candidates skipped for a reason other than being generated output: over `maxFileBytes`, or cut
+     * off by `maxFiles`. */
     readonly filesSkipped: number;
+    /** Candidates skipped because they are generated output — see {@link WalkConfig.skipMinified}. */
+    readonly filesMinified: number;
 }
 /**
  * Walk `projectRoot` and parse every candidate file it finds.

package/lib/walk.js

@@ -15,6 +15,7 @@ import { createParser } from "./grammar.js";
 import { extractFile } from "./extract.js";
 import { loadGitignore, matchesGitignore } from "./gitignore.js";
 import { languageFor } from "./languages.js";
+import { isMinifiedName, looksMinified, measureText } from "./minified.js";
 /**
  * Whether one directory entry is excluded from both the index and (for `watcher.ts`) the watch tree —
  * the single definition both consult, so "what the index covers" and "what gets watched" can never
@@ -69,8 +70,18 @@ async function discover(projectRoot, config, signal) {
     await scan('');
     return { candidates, overflow };
 }
-/** Parse one candidate, or return `undefined` when it is over {@link WalkConfig.maxFileBytes}. */
+/**
+ * Parse one candidate.
+ * @param candidate - the file to parse.
+ * @param config - the walk's bounds.
+ * @param signal - aborts the parse.
+ * @returns the extracted file, `'minified'` when it was skipped as generated output, or `undefined`
+ *   when it is over {@link WalkConfig.maxFileBytes}.
+ */
 async function parseCandidate(candidate, config, signal) {
+    // Checked before the stat and read: a `.min.` name settles it with no I/O at all.
+    if (config.skipMinified && isMinifiedName(candidate.path))
+        return 'minified';
     const stats = await stat(candidate.absolute);
     if (stats.size > config.maxFileBytes)
         return undefined;
@@ -79,6 +90,9 @@ async function parseCandidate(candidate, config, signal) {
     if (spec === undefined)
         return undefined;
     const text = await readFile(candidate.absolute, 'utf8');
+    const shape = measureText(text);
+    if (config.skipMinified && looksMinified(candidate.path, shape))
+        return 'minified';
     const parser = await createParser(spec);
     try {
         signal?.throwIfAborted();
@@ -94,7 +108,7 @@ async function parseCandidate(candidate, config, signal) {
             size: stats.size,
             modifiedAt: stats.mtimeMs,
             contentHash: createHash('sha256').update(text).digest('hex'),
-            lineCount: text.split('\n').length,
+            lineCount: shape.lineCount,
             extraction,
         };
     }
@@ -135,12 +149,15 @@ export async function walkAndExtract(projectRoot, config, signal) {
     const parsed = await mapWithConcurrency(candidates, config.concurrency, candidate => parseCandidate(candidate, config, signal));
     const files = [];
     let filesSkipped = overflow;
-    for (const file of parsed) {
-        if (file === undefined)
+    let filesMinified = 0;
+    for (const result of parsed) {
+        if (result === undefined)
             filesSkipped++;
+        else if (result === 'minified')
+            filesMinified++;
         else
-            files.push(file);
+            files.push(result);
     }
-    return { files, filesSkipped };
+    return { files, filesSkipped, filesMinified };
 }
 //# sourceMappingURL=walk.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-codegraph-tree-sitter",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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.1.5"
+    "dsh-plugin-codegraph-service": "^0.1.7"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1",