@neuralsea/workspace-indexer 0.2.0 → 0.3.2

package/dist/index.js

@@ -1,26 +1,427 @@
 import {
   DEFAULT_PROFILES,
+  GoModuleLinkStrategy,
   HashEmbeddingsProvider,
   IndexerProgressObservable,
+  Neo4jGraphStore,
+  NestedRepoLinkStrategy,
+  NoopAnnIndex,
+  NpmDependencyLinkStrategy,
   OllamaEmbeddingsProvider,
   OpenAIEmbeddingsProvider,
   RepoIndexer,
+  VsCodeContributesLanguageLinkStrategy,
   WorkspaceIndexer,
+  WorkspaceLinker,
+  WorkspaceStore,
   asProgressSink,
+  chunkSource,
+  createAnnIndex,
+  createNeo4jGraphStore,
   createVectorIndex,
   deepMergeProfile,
-  loadConfigFile
-} from "./chunk-Z3BRYSQM.js";
+  discoverGitRepos,
+  languageFromPath,
+  linkWorkspaceRepos,
+  loadConfigFile,
+  mergeIndexerConfig,
+  pickRepoOverride,
+  stableSymbolId
+} from "./chunk-GGL3XTMV.js";
+
+// src/symbolGraph/vscodeProvider.ts
+import path2 from "path";
+import { createRequire } from "module";
+
+// src/symbolGraph/strategies.ts
+import path from "path";
+function toPosixRel(repoRoot, absPath) {
+  const abs = path.resolve(absPath);
+  const root = path.resolve(repoRoot);
+  const rel = path.relative(root, abs);
+  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return null;
+  return rel.split(path.sep).join("/");
+}
+function fromLspRange(r) {
+  return {
+    startLine: r.start.line + 1,
+    startCharacter: r.start.character + 1,
+    endLine: r.end.line + 1,
+    endCharacter: r.end.character + 1
+  };
+}
+function bestRange(sym) {
+  return sym.selectionRange ?? sym.range;
+}
+function makeSymbolId(input, sym) {
+  const range = fromLspRange(bestRange(sym));
+  return stableSymbolId({
+    repoRoot: input.repoRoot,
+    path: input.path,
+    language: input.language,
+    kind: sym.kind,
+    name: sym.name,
+    range
+  });
+}
+function flattenSymbols(input, syms) {
+  const symbols = [];
+  const edges = [];
+  const visit = (s, parentId) => {
+    const id = makeSymbolId(input, s);
+    const range = fromLspRange(bestRange(s));
+    symbols.push({
+      id,
+      repoRoot: input.repoRoot,
+      path: input.path,
+      language: input.language,
+      name: s.name,
+      kind: s.kind,
+      range,
+      containerName: s.containerName,
+      detail: s.detail
+    });
+    if (parentId) {
+      edges.push({
+        repoRoot: input.repoRoot,
+        fromId: parentId,
+        toId: id,
+        kind: "contains",
+        fromPath: input.path,
+        toPath: input.path
+      });
+    }
+    for (const c of s.children ?? []) visit(c, id);
+  };
+  for (const s of syms) visit(s);
+  return { symbols, containsEdges: edges };
+}
+function cacheKeyFor(doc, input) {
+  const hv = input.contentHash ? `h:${input.contentHash}` : doc.version !== void 0 ? `v:${doc.version}` : "v:0";
+  return `${doc.fsPath}::${hv}`;
+}
+var SymbolGraphIndexer = class {
+  constructor(lsp, opts = {}) {
+    this.lsp = lsp;
+    this.opts = opts;
+  }
+  cache = /* @__PURE__ */ new Map();
+  async indexDocument(input, cancel = {}) {
+    const doc = await this.lsp.openTextDocument(path.join(input.repoRoot, input.path.split("/").join(path.sep)));
+    const key = cacheKeyFor(doc, input);
+    const cached = this.cache.get(key);
+    if (cached) {
+      const contains = cached.containsEdges;
+      if ((this.opts.mode ?? "staged") === "full") {
+        const extra = await this.expandDocumentEdges(input, cancel);
+        return { symbols: cached.symbols, edges: [...contains, ...extra] };
+      }
+      return { symbols: cached.symbols, edges: contains };
+    }
+    if (cancel.signal?.aborted) return { symbols: [], edges: [] };
+    const syms = await this.lsp.documentSymbols(doc);
+    const { symbols, containsEdges } = flattenSymbols(input, syms);
+    this.cache.set(key, {
+      key,
+      repoRoot: input.repoRoot,
+      path: input.path,
+      language: input.language,
+      symbols,
+      containsEdges,
+      edgeCache: /* @__PURE__ */ new Map()
+    });
+    if ((this.opts.mode ?? "staged") === "full") {
+      const extra = await this.expandDocumentEdges(input, cancel);
+      return { symbols, edges: [...containsEdges, ...extra] };
+    }
+    return { symbols, edges: containsEdges };
+  }
+  /**
+   * Compute cross-file edges for a document (definition/reference/implementation/typeDefinition).
+   * Intended for staged indexing and on-demand expansion during retrieval.
+   */
+  async expandDocumentEdges(input, cancel = {}) {
+    const doc = await this.lsp.openTextDocument(path.join(input.repoRoot, input.path.split("/").join(path.sep)));
+    const key = cacheKeyFor(doc, input);
+    const cached = this.cache.get(key);
+    if (!cached) {
+      await this.indexDocument(input, cancel);
+    }
+    const cached2 = this.cache.get(key);
+    if (!cached2) return [];
+    const maxEdges = this.opts.maxEdgesPerDocument ?? 200;
+    const out = [];
+    let emitted = 0;
+    const symbols = cached2.symbols;
+    for (const s of symbols) {
+      if (cancel.signal?.aborted) break;
+      if (s.kind === "file" || s.kind === "module" || s.kind === "namespace") continue;
+      const pos = { line: s.range.startLine - 1, character: s.range.startCharacter - 1 };
+      for (const kind of ["definition", "typeDefinition", "implementation", "reference"]) {
+        if (cancel.signal?.aborted) break;
+        if (emitted >= maxEdges) break;
+        const cacheKey = `${kind}:${s.id}`;
+        const existing = cached2.edgeCache.get(cacheKey);
+        if (existing && existing.length > 0) {
+          for (const e of existing) {
+            out.push(e);
+            emitted++;
+            if (emitted >= maxEdges) break;
+          }
+          continue;
+        }
+        let targets = [];
+        try {
+          targets = await this.lsp.resolveEdges(doc, pos, kind);
+        } catch {
+          targets = [];
+        }
+        const edges = [];
+        for (const t of targets) {
+          if (cancel.signal?.aborted) break;
+          if (emitted >= maxEdges) break;
+          const toPath = toPosixRel(input.repoRoot, t.fsPath);
+          if (!toPath) continue;
+          const toId = await this.bestEffortTargetSymbolId(input, t.fsPath, t.range, cancel);
+          edges.push({
+            repoRoot: input.repoRoot,
+            fromId: s.id,
+            toId,
+            kind,
+            fromPath: input.path,
+            toPath
+          });
+          emitted++;
+        }
+        cached2.edgeCache.set(cacheKey, edges);
+        out.push(...edges);
+      }
+      if (emitted >= maxEdges) break;
+    }
+    return out;
+  }
+  async bestEffortTargetSymbolId(input, targetFsPath, targetRange, cancel) {
+    const toPath = toPosixRel(input.repoRoot, targetFsPath) ?? "";
+    const fallback = stableSymbolId({
+      repoRoot: input.repoRoot,
+      path: toPath,
+      language: input.language,
+      kind: "unknown",
+      name: `@${targetRange.start.line + 1}:${targetRange.start.character + 1}`,
+      range: fromLspRange(targetRange)
+    });
+    if (!toPath) return fallback;
+    if (cancel.signal?.aborted) return fallback;
+    let doc;
+    try {
+      doc = await this.lsp.openTextDocument(targetFsPath);
+    } catch {
+      return fallback;
+    }
+    if (cancel.signal?.aborted) return fallback;
+    let syms = [];
+    try {
+      syms = await this.lsp.documentSymbols(doc);
+    } catch {
+      return fallback;
+    }
+    const best = findSymbolAt(syms, targetRange.start);
+    if (!best) return fallback;
+    const language = doc.languageId || input.language;
+    const range = fromLspRange(bestRange(best));
+    return stableSymbolId({
+      repoRoot: input.repoRoot,
+      path: toPath,
+      language,
+      kind: best.kind,
+      name: best.name,
+      range
+    });
+  }
+};
+function rangeContains(r, p) {
+  const le = (a, b) => a.line < b.line || a.line === b.line && a.character <= b.character;
+  return le(r.start, p) && le(p, r.end);
+}
+function findSymbolAt(syms, pos) {
+  let best = null;
+  let bestSpan = Number.POSITIVE_INFINITY;
+  const visit = (s) => {
+    const r = s.range;
+    if (!rangeContains(r, pos)) return;
+    const span = (r.end.line - r.start.line) * 1e6 + (r.end.character - r.start.character);
+    if (span < bestSpan) {
+      bestSpan = span;
+      best = s;
+    }
+    for (const c of s.children ?? []) visit(c);
+  };
+  for (const s of syms) visit(s);
+  return best;
+}
+
+// src/symbolGraph/vscodeProvider.ts
+function fromPosixPath(posixRelPath) {
+  return posixRelPath.split("/").join(path2.sep);
+}
+function toPosixPath(p) {
+  return p.split(path2.sep).join("/");
+}
+function kindFromVscode(vscode, k) {
+  const SK = vscode?.SymbolKind;
+  if (!SK) return "unknown";
+  if (k === SK.File) return "file";
+  if (k === SK.Module) return "module";
+  if (k === SK.Namespace) return "namespace";
+  if (k === SK.Package) return "package";
+  if (k === SK.Class) return "class";
+  if (k === SK.Interface) return "interface";
+  if (k === SK.Enum) return "enum";
+  if (k === SK.TypeParameter) return "type";
+  if (k === SK.Function) return "function";
+  if (k === SK.Method) return "method";
+  if (k === SK.Property) return "property";
+  if (k === SK.Field) return "field";
+  if (k === SK.Variable) return "variable";
+  if (k === SK.Constant) return "constant";
+  if (k === SK.Constructor) return "constructor";
+  if (k === SK.Parameter) return "parameter";
+  return "unknown";
+}
+function fromLocationLike(loc) {
+  if (!loc) return [];
+  if (Array.isArray(loc)) return loc.flatMap(fromLocationLike);
+  if (loc?.uri && loc?.range) return [{ uri: loc.uri, range: loc.range }];
+  if (loc?.targetUri && (loc?.targetSelectionRange || loc?.targetRange)) {
+    return [{ uri: loc.targetUri, range: loc.targetSelectionRange ?? loc.targetRange }];
+  }
+  return [];
+}
+function toLspRange(r) {
+  return { start: { line: r.start.line, character: r.start.character }, end: { line: r.end.line, character: r.end.character } };
+}
+function toLspSymbols(vscode, res) {
+  if (!Array.isArray(res)) return [];
+  if (res.length === 0) return [];
+  if (res[0]?.location) {
+    return res.map((s) => ({
+      name: s.name,
+      kind: kindFromVscode(vscode, s.kind),
+      range: toLspRange(s.location.range),
+      selectionRange: toLspRange(s.location.range),
+      containerName: s.containerName,
+      detail: s.detail,
+      children: []
+    }));
+  }
+  const visit = (d) => ({
+    name: d.name,
+    kind: kindFromVscode(vscode, d.kind),
+    range: toLspRange(d.range),
+    selectionRange: d.selectionRange ? toLspRange(d.selectionRange) : void 0,
+    detail: d.detail,
+    containerName: d.containerName,
+    children: Array.isArray(d.children) ? d.children.map(visit) : []
+  });
+  return res.map(visit);
+}
+function toIndexInput(doc, input) {
+  const rel = toPosixPath(path2.relative(path2.resolve(input.repoRoot), path2.resolve(doc.fsPath)));
+  return { ...input, path: rel || input.path };
+}
+function makeVscodeFacade(vscode) {
+  const cmdForKind = {
+    definition: "vscode.executeDefinitionProvider",
+    reference: "vscode.executeReferenceProvider",
+    implementation: "vscode.executeImplementationProvider",
+    typeDefinition: "vscode.executeTypeDefinitionProvider"
+  };
+  return {
+    async openTextDocument(absPath) {
+      const uri = vscode.Uri.file(absPath);
+      const doc = await vscode.workspace.openTextDocument(uri);
+      return {
+        uri: String(doc.uri.toString()),
+        fsPath: doc.uri.fsPath,
+        languageId: doc.languageId ?? "text",
+        version: doc.version
+      };
+    },
+    async documentSymbols(doc) {
+      const uri = vscode.Uri.file(doc.fsPath);
+      const res = await vscode.commands.executeCommand("vscode.executeDocumentSymbolProvider", uri);
+      return toLspSymbols(vscode, res);
+    },
+    async resolveEdges(doc, pos, kind) {
+      const uri = vscode.Uri.file(doc.fsPath);
+      const command = cmdForKind[kind];
+      const res = await vscode.commands.executeCommand(command, uri, new vscode.Position(pos.line, pos.character));
+      const locs = fromLocationLike(res);
+      return locs.map((l) => ({
+        uri: String(l.uri.toString()),
+        fsPath: l.uri.fsPath,
+        range: toLspRange(l.range)
+      }));
+    }
+  };
+}
+async function createVSCodeSymbolGraphProvider(opts) {
+  let vscode;
+  try {
+    const require2 = createRequire(import.meta.url);
+    vscode = require2("vscode");
+  } catch {
+    return null;
+  }
+  const languages = new Set(
+    opts?.languages ?? ["typescript", "javascript", "python", "go", "isl", "ctl", "ltl", "colour-algebra"]
+  );
+  const lsp = makeVscodeFacade(vscode);
+  const indexer = new SymbolGraphIndexer(lsp, { mode: opts?.mode ?? "staged", maxEdgesPerDocument: opts?.maxEdgesPerDocument ?? 200 });
+  return {
+    id: "vscode.symbolGraph",
+    supports: (language) => languages.has(language),
+    async indexDocument(input) {
+      const absPath = path2.join(input.repoRoot, fromPosixPath(input.path));
+      const doc = await lsp.openTextDocument(absPath);
+      return await indexer.indexDocument(toIndexInput(doc, input), { signal: input.signal });
+    },
+    async expandDocumentEdges(input, o) {
+      const absPath = path2.join(input.repoRoot, fromPosixPath(input.path));
+      const doc = await lsp.openTextDocument(absPath);
+      return await indexer.expandDocumentEdges(toIndexInput(doc, input), { signal: o?.signal });
+    }
+  };
+}
 export {
   DEFAULT_PROFILES,
+  GoModuleLinkStrategy,
   HashEmbeddingsProvider,
   IndexerProgressObservable,
+  Neo4jGraphStore,
+  NestedRepoLinkStrategy,
+  NoopAnnIndex,
+  NpmDependencyLinkStrategy,
   OllamaEmbeddingsProvider,
   OpenAIEmbeddingsProvider,
   RepoIndexer,
+  SymbolGraphIndexer,
+  VsCodeContributesLanguageLinkStrategy,
   WorkspaceIndexer,
+  WorkspaceLinker,
+  WorkspaceStore,
   asProgressSink,
+  chunkSource,
+  createAnnIndex,
+  createNeo4jGraphStore,
+  createVSCodeSymbolGraphProvider,
   createVectorIndex,
   deepMergeProfile,
-  loadConfigFile
+  discoverGitRepos,
+  languageFromPath,
+  linkWorkspaceRepos,
+  loadConfigFile,
+  mergeIndexerConfig,
+  pickRepoOverride,
+  stableSymbolId
 };

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "@neuralsea/workspace-indexer",
-  "version": "0.2.0",
+  "version": "0.3.2",
   "description": "Local-first multi-repo workspace indexer (semantic embeddings + git-aware incremental updates + hybrid retrieval profiles) for AI agents.",
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     }
   },
   "bin": {
@@ -20,10 +22,13 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/cli.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts src/cli.ts --format esm --dts --watch",
+    "build": "tsup src/index.ts src/cli.ts --format esm,cjs --dts --clean",
+    "dev": "tsup src/index.ts src/cli.ts --format esm,cjs --dts --watch",
     "lint": "node -e \"console.log('Add eslint if desired')\"",
-    "test": "node --test dist/test.js || echo \"(optional)\""
+    "test": "node scripts/run-tests.mjs test",
+    "test:unit": "node scripts/run-tests.mjs test/unit",
+    "test:integration": "node scripts/run-tests.mjs test/integration",
+    "test:smoke": "node scripts/run-tests.mjs test/smoke"
   },
   "dependencies": {
     "better-sqlite3": "^12.5.0",
@@ -36,6 +41,7 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.0.3",
     "@types/yargs": "^17.0.35",
+    "neo4j-driver": "^5.28.1",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   },