@wrongstack/tools 1.0.11 → 1.0.12

package/dist/{chunk-7GOE2ZTZ.js → chunk-OMWC2OGT.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-MSOAX3GC.js";
 import {
   enqueueReindex
-} from "./chunk-HYHE4VNA.js";
+} from "./chunk-UMOP3VGK.js";
 import {
   safeResolveReal,
   sha256hex,
@@ -518,4 +518,4 @@ Compare this against your old_string and retry with the file's actual text.` : "
 export {
   editTool
 };
-//# sourceMappingURL=chunk-7GOE2ZTZ.js.map
+//# sourceMappingURL=chunk-OMWC2OGT.js.map

package/dist/{chunk-IE4KDAOB.js → chunk-OYQE2UNT.js}

@@ -1,10 +1,10 @@
 import {
   getIndexState,
   searchCodebaseIndex
-} from "./chunk-HYHE4VNA.js";
+} from "./chunk-UMOP3VGK.js";
 import {
   codebaseIndexDirOverride
-} from "./chunk-NEYUPZL6.js";
+} from "./chunk-6D3UIQMF.js";
 import {
   isBinaryBuffer,
   safeResolveReal,
@@ -340,4 +340,4 @@ ${interesting.join("\n")}` : "symbols/imports: (none detected)"
 export {
   readTool
 };
-//# sourceMappingURL=chunk-IE4KDAOB.js.map
+//# sourceMappingURL=chunk-OYQE2UNT.js.map

package/dist/chunk-R3HR3QI3.js

@@ -0,0 +1,97 @@
+import {
+  parseGeneric
+} from "./chunk-HSLDY55L.js";
+import {
+  PY_PARSE_SCRIPT,
+  parseParserOutput,
+  privateScriptPath,
+  pySpawnOptions,
+  runToolchainChild,
+  toIndexSymbols,
+  withSpawnGate
+} from "./chunk-OIFY4XNP.js";
+import {
+  resolveWin32Command
+} from "./chunk-XZLVJD56.js";
+
+// src/codebase-index/py-parser.ts
+import { spawn } from "node:child_process";
+async function parseSymbols(opts) {
+  const { file, content, lang } = opts;
+  try {
+    const native = await withSpawnGate(() => syncPyParse(file, content, lang));
+    if (native !== null) return native;
+  } catch {
+  }
+  return parseGeneric({ file, content, lang: lang === "py" ? "py" : lang });
+}
+async function resolvePython() {
+  const candidates = process.platform === "win32" ? ["python3", "python", "py"] : ["python3", "python"];
+  for (const name of candidates) {
+    const resolved = resolveWin32Command(name);
+    if (!await commandIsAvailable(resolved)) continue;
+    return resolved;
+  }
+  return null;
+}
+function commandIsAvailable(command) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const proc = spawn(command, ["--version"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    const finish = (available) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(available);
+    };
+    const timer = setTimeout(() => {
+      proc.kill("SIGKILL");
+      finish(false);
+    }, 5e3);
+    timer.unref?.();
+    proc.once("error", () => finish(false));
+    proc.once("close", (code) => finish(code === 0));
+  });
+}
+var cachedPyBinary;
+function resolvePythonBinary() {
+  cachedPyBinary ??= resolvePython();
+  return cachedPyBinary;
+}
+async function syncPyParse(filePath, content, lang) {
+  try {
+    const scriptPath = await privateScriptPath("ws-py-parse-", "parse.py", PY_PARSE_SCRIPT);
+    const pyBinary = await resolvePythonBinary();
+    if (!pyBinary) return null;
+    const result = await runToolchainChild(
+      pyBinary,
+      [scriptPath, filePath],
+      content,
+      15e3,
+      pySpawnOptions(scriptPath)
+    );
+    if (!result) return null;
+    if (result.code !== 0 || !result.stdout.trim()) {
+      return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+    }
+    const { symbols, refs } = parseParserOutput(result.stdout, lang);
+    return {
+      file: filePath,
+      lang,
+      symbols: toIndexSymbols(symbols, filePath, lang),
+      refs,
+      mtimeMs: Date.now()
+    };
+  } catch {
+    return null;
+  }
+}
+
+export {
+  parseSymbols,
+  resolvePythonBinary
+};
+//# sourceMappingURL=chunk-R3HR3QI3.js.map

package/dist/{chunk-XPVYZ2S6.js → chunk-RYLMSGR5.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexDir
-} from "./chunk-NEYUPZL6.js";
+} from "./chunk-6D3UIQMF.js";
 
 // src/codebase-index/project-server-endpoint.ts
 import { createHash } from "node:crypto";
@@ -158,4 +158,4 @@ export {
   PROJECT_INDEX_SERVER_MAX_FRAME_CHARS,
   encodeProjectServerMessage
 };
-//# sourceMappingURL=chunk-XPVYZ2S6.js.map
+//# sourceMappingURL=chunk-RYLMSGR5.js.map

package/dist/{chunk-HYHE4VNA.js → chunk-UMOP3VGK.js}

@@ -13,11 +13,12 @@ import {
   projectIndexServerMetadataPath,
   projectIndexServerStderrPath,
   readProjectIndexServerStderrTail
-} from "./chunk-XPVYZ2S6.js";
+} from "./chunk-RYLMSGR5.js";
 import {
   CircuitOpenError,
   IndexTimeoutError,
   LockError,
+  contextService,
   fileGraphService,
   incomingCallsService,
   indexCircuitBreaker,
@@ -27,11 +28,12 @@ import {
   packageGraphService,
   searchService,
   statsService,
-  symbolGraphService
-} from "./chunk-NEYUPZL6.js";
+  symbolGraphService,
+  vectorSearchService
+} from "./chunk-6D3UIQMF.js";
 import {
   recordIpcPending
-} from "./chunk-ZKC5UNGD.js";
+} from "./chunk-OIFY4XNP.js";
 import {
   isIndexablePath
 } from "./chunk-YOHO4DVT.js";
@@ -511,14 +513,18 @@ var ProjectServerConnection = class {
         if (this.readBuffer.length < 5 + frameLen) return;
         const payload = this.readBuffer.subarray(5, 5 + frameLen);
         this.readBuffer = this.readBuffer.subarray(5 + frameLen);
-        let message2;
+        let decoded;
         try {
-          message2 = decodeBinaryFrame(payload);
+          decoded = decodeBinaryFrame(payload);
         } catch {
           socket.destroy(new Error("invalid binary codebase-index server response"));
           return;
         }
-        this.onMessage(message2);
+        if (!isServerMessage(decoded)) {
+          socket.destroy(new Error("invalid binary codebase-index server response"));
+          return;
+        }
+        this.onMessage(decoded);
         continue;
       }
       const newline = this.readBuffer.indexOf(10);
@@ -535,14 +541,18 @@ var ProjectServerConnection = class {
       const line = this.readBuffer.subarray(0, newline).toString("utf8");
       this.readBuffer = this.readBuffer.subarray(newline + 1);
       if (!line) continue;
-      let message;
+      let parsed;
       try {
-        message = JSON.parse(line);
+        parsed = JSON.parse(line);
       } catch {
         socket.destroy(new Error("invalid codebase-index server response"));
         return;
       }
-      this.onMessage(message);
+      if (!isServerMessage(parsed)) {
+        socket.destroy(new Error("invalid codebase-index server response"));
+        return;
+      }
+      this.onMessage(parsed);
     }
   }
   onMessage(message) {
@@ -722,6 +732,9 @@ var ProjectServerConnection = class {
 var connections = /* @__PURE__ */ new Map();
 var MAX_CACHED_CONNECTIONS = 8;
 var heartbeatTimer;
+function isServerMessage(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.type === "string";
+}
 function binaryFramingEnabled() {
   const flag = process.env["WRONGSTACK_INDEX_BINARY"];
   return flag === "1" || flag === "true";
@@ -826,6 +839,12 @@ var _indexing = false;
 var _currentFile = 0;
 var _totalFiles = 0;
 var _lastError = null;
+var _lastErrorAt = 0;
+function resolveLastError(remote, local, localAt) {
+  if (!remote) return local;
+  if (local !== null && localAt > (remote.updatedAt ?? 0)) return local;
+  return remote.lastError;
+}
 function isIndexReady() {
   return _ready;
 }
@@ -841,7 +860,7 @@ function getIndexState() {
     indexing: _indexing || remoteIndexing,
     currentFile: remoteIndexing ? remoteActivity?.currentFile ?? 0 : _currentFile,
     totalFiles: remoteIndexing ? remoteActivity?.totalFiles ?? 0 : _totalFiles,
-    lastError: remoteActivity?.lastError ?? _lastError,
+    lastError: resolveLastError(remoteActivity, _lastError, _lastErrorAt),
     server,
     circuit: indexCircuitBreaker.snapshot()
   };
@@ -1051,6 +1070,14 @@ async function callInline(op, args, opts) {
         });
       case "search":
         return searchService(args);
+      // `context` and `vectorSearch` were served by the worker and the project
+      // server but missing here, so inline mode (WRONGSTACK_INDEX_INLINE=1, or
+      // no worker build) failed every codebase-context call with
+      // "unknown index op".
+      case "context":
+        return contextService(args);
+      case "vectorSearch":
+        return vectorSearchService(args);
       case "stats":
         return statsService(args);
       case "packageGraph":
@@ -1183,51 +1210,58 @@ async function runStartupIndex(opts) {
   _indexing = true;
   emitState();
   try {
-    const result = await withMutex(() => {
-      _currentFile = 0;
-      _totalFiles = 0;
-      _lastError = null;
-      return callIndexOp(
-        "index",
-        {
-          projectRoot: opts.projectRoot,
-          indexDir: opts.indexDir,
-          force: opts.force,
-          langs: opts.langs
-        },
-        {
-          timeoutMs: opts.timeoutMs ?? DEFAULT_FULL_INDEX_TIMEOUT_MS,
-          signal: opts.signal,
-          onProgress: setIndexProgress
-        }
-      );
-    });
+    let result;
+    try {
+      result = await runIndexPass(opts);
+    } catch (err) {
+      if (!isRecoverableConstraintError(err) || opts.force || opts.signal?.aborted) throw err;
+      const failure = err instanceof Error ? err.message : String(err);
+      result = {
+        ...await runIndexPass({ ...opts, force: true }),
+        // Tag the result so callers can distinguish a normal run from a
+        // corruption-triggered recovery.
+        autoRecovered: { failure, rebuiltWithForce: true }
+      };
+    }
     _ready = true;
     indexCircuitBreaker.recordSuccess();
     return result;
   } catch (err) {
-    _lastError = err instanceof Error ? err.message : String(err);
-    const originalError = _lastError;
-    if (isRecoverableConstraintError(err) && !opts.force) {
-      _lastError = null;
-      const rebuildResult = await runStartupIndex({
-        ...opts,
-        force: true
-      });
-      _ready = true;
-      return {
-        ...rebuildResult,
-        autoRecovered: { failure: originalError, rebuiltWithForce: true }
-      };
+    if (!opts.signal?.aborted) {
+      _lastError = err instanceof Error ? err.message : String(err);
+      _lastErrorAt = Date.now();
     }
     _ready = true;
-    if (!opts.signal?.aborted) indexCircuitBreaker.recordFailure(err);
+    if (opts.signal?.aborted) indexCircuitBreaker.abandonProbe();
+    else indexCircuitBreaker.recordFailure(err);
     throw err;
   } finally {
     _indexing = false;
     emitState();
   }
 }
+function runIndexPass(opts) {
+  return withMutex(() => {
+    _currentFile = 0;
+    _totalFiles = 0;
+    _lastError = null;
+    _lastErrorAt = 0;
+    return callIndexOp(
+      "index",
+      {
+        projectRoot: opts.projectRoot,
+        indexDir: opts.indexDir,
+        force: opts.force,
+        langs: opts.langs
+      },
+      {
+        timeoutMs: opts.timeoutMs ?? DEFAULT_FULL_INDEX_TIMEOUT_MS,
+        signal: opts.signal,
+        onProgress: setIndexProgress
+      }
+    );
+  });
+}
 function enqueueReindex(opts) {
   const files = opts.files.filter(isIndexableFile);
   if (files.length === 0) return Promise.resolve();
@@ -1352,4 +1386,4 @@ export {
   checkCodebaseIndexServerHealth,
   ensureCodebaseIndexServer
 };
-//# sourceMappingURL=chunk-HYHE4VNA.js.map
+//# sourceMappingURL=chunk-UMOP3VGK.js.map

package/dist/{chunk-6OIEYJM4.js → chunk-VMNWQI4V.js}

@@ -1,6 +1,6 @@
 import {
   builtinTools
-} from "./chunk-GU7TZE6Z.js";
+} from "./chunk-2BCRQAIW.js";
 
 // src/pack.ts
 var builtinToolsPack = {
@@ -12,4 +12,4 @@ var builtinToolsPack = {
 export {
   builtinToolsPack
 };
-//# sourceMappingURL=chunk-6OIEYJM4.js.map
+//# sourceMappingURL=chunk-VMNWQI4V.js.map

package/dist/{chunk-2UVAIS5O.js → chunk-YPSVPCIE.js}

@@ -1,6 +1,6 @@
 import {
   enqueueReindex
-} from "./chunk-HYHE4VNA.js";
+} from "./chunk-UMOP3VGK.js";
 import {
   resolveRealInsideRoot,
   safeResolveReal,
@@ -390,4 +390,4 @@ function extractPatchedFiles(output) {
 export {
   patchTool
 };
-//# sourceMappingURL=chunk-2UVAIS5O.js.map
+//# sourceMappingURL=chunk-YPSVPCIE.js.map

package/dist/{chunk-PWZUHZP7.js → chunk-Z77XMU3U.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-MSOAX3GC.js";
 import {
   enqueueReindex
-} from "./chunk-HYHE4VNA.js";
+} from "./chunk-UMOP3VGK.js";
 import {
   safeResolveReal,
   sha256hex,
@@ -179,4 +179,4 @@ async function finishWrite(input, ctx, prepared, signal) {
 export {
   writeTool
 };
-//# sourceMappingURL=chunk-PWZUHZP7.js.map
+//# sourceMappingURL=chunk-Z77XMU3U.js.map

package/dist/codebase-index/ast-invariant-engine.d.ts

@@ -4,11 +4,14 @@
  * Deterministic backward-compatibility & invariant validator that checks AST
  * diffs between original code and LLM mutations before changes are written to disk.
  *
- * Catches breaking changes across TypeScript/JavaScript, Python, Go, Rust, Java, etc.:
+ * Rules are implemented for TypeScript/JavaScript, Python, Go and Rust:
  *   - INV-001: Export / Public Symbol Deletion or Rename
  *   - INV-002: Mandatory / Non-Default Parameter Addition
  *   - INV-003: Mandatory Interface / Trait / Model Property Addition
  *   - INV-004: Incompatible Return Type Alteration
+ *
+ * Any other language has no contract extractor: the result says so through
+ * `supported: false` instead of reporting an empty diff as "compatible".
  */
 import type { SymbolLang } from './schema.js';
 export type InvariantRuleId = 'INV-001' | 'INV-002' | 'INV-003' | 'INV-004';
@@ -29,6 +32,13 @@ export interface InvariantViolation {
 export interface InvariantEvaluationResult {
     valid: boolean;
     violations: InvariantViolation[];
+    /** Language the rules were evaluated as. */
+    lang: SymbolLang;
+    /**
+     * False when no contract extractor exists for `lang` (or its grammar failed
+     * to load). `valid: true` then means "nothing was checked", not "compatible".
+     */
+    supported: boolean;
     stats: {
         originalSymbols: number;
         modifiedSymbols: number;
@@ -68,8 +78,15 @@ interface InterfaceContract {
 export interface ModuleContract {
     lang: SymbolLang;
     exports: Set<string>;
+    /**
+     * Keyed by SCOPED name (`Class.method`, `Receiver.Method`, `Type.fn`): a
+     * bare-name key let `impl A { fn new }` overwrite `impl B { fn new }`, so the
+     * rules compared unrelated functions and missed the real change.
+     */
     functions: Map<string, FunctionContract>;
     interfaces: Map<string, InterfaceContract>;
+    /** False when this language has no extractor or its grammar did not load. */
+    supported: boolean;
 }
 /**
  * Universal AST Invariant Engine for deterministic backward compatibility validation.
@@ -93,7 +110,7 @@ export declare class PolyglotInvariantEngine {
      */
     private extractTsContract;
     /**
-     * Polyglot extraction (Python, Go, Rust, Java, etc.) via Tree-sitter WASM.
+     * Polyglot extraction (Python, Go, Rust) via Tree-sitter WASM.
      */
     private extractTreeSitterContract;
 }

package/dist/codebase-index/atlas-projection.d.ts

@@ -43,6 +43,25 @@ export declare const ATLAS_SCHEMA = 2;
  * small enough to read in a diff — the full 8k-file list would be neither.
  */
 export declare const ATLAS_FILE_LIMIT = 300;
+/**
+ * Code-unit string order. `localeCompare` follows the host's ICU locale, so
+ * the same index sorted `B`/`a` (or `I`/`ı` under tr-TR) differently on two
+ * machines — a committed atlas that must be byte-identical everywhere
+ * churned on every regeneration by someone with another locale.
+ */
+export declare function compareText(a: string, b: string): number;
+/**
+ * The package a file is shown under. Single source for the projection AND the
+ * brief: a file with an empty `package` label is grouped by its first path
+ * segment.
+ */
+export declare function atlasPackageName(packageLabel: string | undefined, relativePath: string): string;
+/**
+ * Indexed files per displayed package name. Counting by the raw label gave
+ * every path-derived package the total of ALL unlabelled files (they share
+ * the '' label), and counted '' itself as a package.
+ */
+export declare function atlasPackageFileCounts(store: IndexStore, relativeOf: (file: string) => string): Map<string, number>;
 export type { AtlasDocument, AtlasEdge, AtlasFile, AtlasManifest, AtlasPackage, AtlasProjection, AtlasSymbol, };
 /**
  * Build the projection from the index. Pure with respect to the filesystem —

package/dist/codebase-index/background-indexer.d.ts

@@ -31,6 +31,20 @@ import { type IncomingCallsResult, type OutgoingCallsResult } from './index-serv
 import { type ProjectIndexServerClientHealth, type ProjectIndexServerConnectionState, type ProjectIndexServerShutdownResult } from './project-server-client.js';
 import type { CodeMapGraph, IndexResult, IndexStats } from './schema.js';
 import type { CallRefsOpArgs, ContextOpArgs, FileGraphOpArgs, SearchOpArgs, SearchOpResult, StatsOpArgs, SymbolGraphOpArgs, VectorSearchOpArgs, VectorSearchOpResult } from './worker-protocol.js';
+/**
+ * The error read tools gate on, from this process's own runs and the shared
+ * project server's activity.
+ *
+ * `remote?.lastError ?? local` let a stale local failure outlive the server's
+ * later successful generation (`null ?? local` is `local`), so search,
+ * incoming/outgoing calls and impact analysis kept refusing with "Index build
+ * failed" against a healthy index. The newer report wins; a tie trusts the
+ * server, which owns the index.
+ */
+export declare function resolveLastError(remote: {
+    lastError: string | null;
+    updatedAt: number | null;
+} | null | undefined, local: string | null, localAt: number): string | null;
 /** True once the first full-project index has completed (success or failure). */
 export declare function isIndexReady(): boolean;
 /**

package/dist/codebase-index/circuit-breaker.d.ts

@@ -78,6 +78,13 @@ export declare class IndexCircuitBreaker {
     allowRequest(): boolean;
     recordSuccess(): void;
     recordFailure(err: unknown): void;
+    /**
+     * Release a probe that ended without a verdict (the caller aborted it).
+     * Neither success nor failure is recorded, but a half-open circuit must be
+     * able to admit the next probe — otherwise it refuses every request until a
+     * manual reset.
+     */
+    abandonProbe(): void;
     /** Force-close the circuit (manual recovery: `/codebase-reindex`). */
     reset(): void;
     snapshot(): CircuitSnapshot;

package/dist/codebase-index/codebase-ast-replace-tool.d.ts

@@ -8,7 +8,7 @@
  *   target?: 'body' | 'full', // whether to replace only the body (default) or the full declaration
  * })
  */
-import type { Tool } from '@wrongstack/core/types';
+import { type Tool } from '@wrongstack/core/types';
 import { type MutateSymbolOptions } from './ast-symbol-mutator.js';
 export interface CodebaseAstReplaceInput extends MutateSymbolOptions {
 }

package/dist/codebase-index/codebase-impact-analysis-tool.d.ts

@@ -24,6 +24,8 @@ export interface ImpactCallSite {
     callerKind: string;
     callType: string;
     isTest: boolean;
+    /** A caller of a caller: reached through the transitive tree, not a direct use. */
+    indirect?: boolean | undefined;
 }
 export interface ImpactAnalysisOutput {
     status: 'ok';
@@ -37,7 +39,11 @@ export interface ImpactAnalysisOutput {
     recommendedActionPlan: string[];
     /** False when the symbol could not be resolved in the index. */
     symbolFound?: boolean;
+    /** True when a previous generation's cached answer was served during a refresh. */
+    stale?: boolean | undefined;
 }
 export type CodebaseImpactAnalysisOutput = ImpactAnalysisOutput;
+/** Whether a project-relative path looks like a test, fixture, mock, or bench file. */
+export declare function isTestFilePath(relPath: string): boolean;
 export declare const codebaseImpactAnalysisTool: Tool<ImpactAnalysisInput, ImpactAnalysisOutput>;
 //# sourceMappingURL=codebase-impact-analysis-tool.d.ts.map

package/dist/codebase-index/codebase-invariant-check-tool.d.ts

@@ -15,6 +15,8 @@ export interface CodebaseInvariantCheckInput {
 }
 export interface CodebaseInvariantCheckOutput {
     valid: boolean;
+    /** False when the language has no invariant rules — `valid` then proves nothing. */
+    verified: boolean;
     violations: InvariantViolation[];
     summary: string;
 }

package/dist/codebase-index/codebase-targeted-test-tool.d.ts

@@ -27,5 +27,31 @@ export interface TargetedTestOutput {
     output: string;
 }
 export type CodebaseTargetedTestOutput = TargetedTestOutput;
+/**
+ * Pull pass/fail counts out of a runner's (ANSI-stripped) output.
+ *
+ * Vitest prints `Test Files  1 passed (1)` BEFORE `Tests  5 passed (5)`; the
+ * old first-match regex reported the suite count as the test count. Scope to
+ * the vitest `Tests` summary line when present, otherwise take the LAST
+ * summary (pytest prints `== 3 passed, 1 failed in 0.2s ==` at the end).
+ * Returns null when no counts are printed (e.g. `go test`).
+ */
+export declare function parseTestCounts(output: string): {
+    passed: number;
+    failed: number;
+} | null;
+/**
+ * Pick the runner for the discovered suites.
+ *
+ * - `go test` takes PACKAGES: handed `pkg/foo_test.go` it compiles that one
+ *   file without the package's sources and fails on every undefined symbol.
+ * - A jest project was run with `npx vitest run`, which is not installed there.
+ * - Suites of different runners cannot share one command line; the old
+ *   fallback handed `.py` files to vitest.
+ */
+export declare function selectTestRunner(projectRoot: string, suites: readonly string[]): Promise<{
+    cmd: string;
+    args: string[];
+}>;
 export declare const codebaseTargetedTestTool: Tool<TargetedTestInput, TargetedTestOutput>;
 //# sourceMappingURL=codebase-targeted-test-tool.d.ts.map

package/dist/codebase-index/dead-code-scan.d.ts

@@ -69,6 +69,10 @@ export interface DeadCodeScanOutput {
     };
 }
 export declare const deadCodeScanTool: Tool<DeadCodeScanInput, DeadCodeScanOutput>;
+/**
+ * Walk the workspace and discover entry-point files from package.json(s).
+ */
+export declare function discoverEntryPoints(projectRoot: string, userEntryPoints: string[] | undefined): string[];
 export declare function runDeadCodeScan(projectRoot: string, opts?: {
     indexDir?: string | undefined;
     userEntryPoints?: string[] | undefined;

package/dist/codebase-index/go-parser.d.ts

@@ -1,10 +1,11 @@
 /**
  * Go source symbol extraction using `go/parser`.
  *
- * Spawns a `go run -` child process that parses the file with go/ast and
- * emits JSON. Falls back to empty results on any error.
+ * Runs the extraction program from `toolchain-scripts.ts` under `go run`, with
+ * the source on stdin, and decodes its JSON. When the toolchain is missing or
+ * the run yields nothing, a line-based extractor keeps the file indexed.
  *
- * Extracts: package, func, type, const, var
+ * Extracts: func, method, type, const, var
  */
 import type { FileSymbols, SymbolLang } from './schema.js';
 export declare function parseSymbols(opts: {
@@ -13,4 +14,23 @@ export declare function parseSymbols(opts: {
     lang: SymbolLang;
 }): Promise<FileSymbols>;
 export { detectLang } from './languages.js';
+/**
+ * Blank comment and string/rune literal contents, keeping offsets and newlines.
+ * Quote characters survive so the line structure stays readable.
+ */
+export declare function maskGoNonCode(src: string): string;
+/**
+ * Line-based extraction for when `go run` is unavailable or failed.
+ *
+ * Runs over {@link maskGoNonCode} output and only reads declarations at the top
+ * level. Previously it scanned every trimmed line of the raw source, so:
+ *  - a `(` or `}` inside a string or comment tripped the delimiter check and
+ *    the whole file indexed empty (`strings.Split(s, "(")` is enough);
+ *  - every `var x` / `type t` local inside a function body became a
+ *    package-level symbol;
+ *  - generic functions (`func Map[T any](`) were missing, grouped
+ *    `const ( … )` / `var ( … )` members were missing, and methods were
+ *    scoped `pkg.Name` instead of the native parser's `pkg.Recv.Name`.
+ */
+export declare function parseGoWithoutToolchain(filePath: string, content: string, lang?: SymbolLang): FileSymbols;
 //# sourceMappingURL=go-parser.d.ts.map

package/dist/codebase-index/graph-rank-pass.d.ts

@@ -11,6 +11,16 @@
  * watcher run, which is what {@link shouldRefreshRanks} arbitrates.
  */
 import type { IndexStore } from './writer.js';
+/**
+ * Build the `implicitlyVisible` predicate for one rank pass.
+ *
+ * Without it every same-package Go/Java/C# reference — code that needs no
+ * import by the language's own rules — was scored as a contradicted
+ * misresolution (weight 0.02), as was every call into a Go package other than
+ * the one file the resolver picked to represent it. Centrality for those
+ * languages was computed on a graph with its package-internal wiring erased.
+ */
+export declare function createImplicitVisibility(): (sourceFile: string, targetFile: string, imports: ReadonlySet<string> | undefined) => boolean;
 /**
  * Data-version marker for the rank layer, in the same spirit as
  * `relation_graph_version`: bumping it forces every index to recompute ranks