@wrongstack/tools 1.0.11 → 1.0.12

package/dist/codebase-index/tree-sitter/util.d.ts

@@ -8,7 +8,12 @@
  * identifiers that we extract from arbitrary child nodes whose byte offset
  * we have to translate into 1-based line + 0-based col ourselves.
  */
-/** 1-based {line, col} for a byte offset, using binary search over newline offsets. */
+/**
+ * 1-based line, 0-based col (the index schema's convention) for an offset,
+ * using binary search over newline offsets. The col used to be 1-based —
+ * `index - lastNl` counts the newline itself — so every tree-sitter symbol
+ * sat one column right of where every other parser puts it.
+ */
 export declare function lineColAt(offsets: readonly number[], index: number): {
     line: number;
     col: number;

package/dist/codebase-index/tree-sitter-parser.d.ts

@@ -64,4 +64,11 @@ export declare function parseTreeSitterAst(opts: {
     tree: import('web-tree-sitter').Tree;
     parser: import('web-tree-sitter').Parser;
 } | null>;
+/**
+ * The identifier a tree-sitter declaration is named by. C/C++ nest it in a
+ * declarator chain (`function_definition` → `function_declarator` →
+ * `identifier`); comparing or reporting the OUTER declarator's text yields
+ * `add(int a, int b)` instead of `add`.
+ */
+export declare function treeSitterDeclarationName(node: import('web-tree-sitter').Node): string | undefined;
 //# sourceMappingURL=tree-sitter-parser.d.ts.map

package/dist/codebase-index/worker.js

@@ -9,11 +9,11 @@ import {
   statsService,
   symbolGraphService,
   vectorSearchService
-} from "../chunk-NEYUPZL6.js";
-import "../chunk-KHUCKLOR.js";
-import "../chunk-4CE3RKEP.js";
-import "../chunk-SKRMUHTU.js";
-import "../chunk-ZKC5UNGD.js";
+} from "../chunk-6D3UIQMF.js";
+import "../chunk-BJ5LXLKE.js";
+import "../chunk-R3HR3QI3.js";
+import "../chunk-HSLDY55L.js";
+import "../chunk-OIFY4XNP.js";
 import "../chunk-YOHO4DVT.js";
 import "../chunk-XHSHNOAF.js";
 import "../chunk-XZLVJD56.js";
@@ -78,19 +78,26 @@ port.on("message", (msg) => {
     return;
   }
   void dispatch(msg).then(
-    (result) => post({ type: "response", id: msg.id, ok: true, result }),
-    (err) => {
+    (result) => {
       try {
-        post({
-          type: "response",
-          id: msg.id,
-          ok: false,
-          error: err instanceof Error ? err.message : String(err),
-          errorName: err instanceof Error ? err.name : void 0
-        });
-      } catch {
+        post({ type: "response", id: msg.id, ok: true, result });
+      } catch (err) {
+        postError(msg.id, err);
       }
-    }
+    },
+    (err) => postError(msg.id, err)
   );
 });
+function postError(id, err) {
+  try {
+    post({
+      type: "response",
+      id,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      errorName: err instanceof Error ? err.name : void 0
+    });
+  } catch {
+  }
+}
 //# sourceMappingURL=worker.js.map

package/dist/codebase-index/writer-refs.d.ts

@@ -34,15 +34,30 @@ export declare function getAllImportRefsWithStatement(stmtFn: (sql: string) => {
 export declare function resolveRefsWithStatement(stmtFn: (sql: string) => {
     run: (...args: (string | number)[]) => unknown;
 }): number;
+/**
+ * Importer files holding an import ref whose `to_file` is no longer indexed —
+ * the target was deleted or renamed. A watcher run only re-resolves the files
+ * it touched, and the importer of a deleted file is not one of them, so these
+ * are added to its scope; otherwise the edge to the missing file survives.
+ */
+export declare function getFilesWithDanglingImportsWithStatement(stmtFn: (sql: string) => {
+    all: () => unknown[];
+}): string[];
+/**
+ * Write module-resolution results. `toFile: null` records "re-resolved, no
+ * target": it CLEARS a previous `to_file`. Only resolved entries used to be
+ * written, so an import whose target had since been deleted kept pointing at
+ * it through every later run, full reindex included.
+ */
 export declare function applyImportResolutionsWithStatement(db: {
     exec: (sql: string) => unknown;
 }, stmtFn: (sql: string) => {
-    run: (...args: string[]) => unknown;
+    run: (...args: (string | null)[]) => unknown;
 }, runWithRetry: <T>(fn: () => T) => T, maxSqlVars: number, resolutions: ReadonlyArray<{
     fromFile: string;
     lang: string;
     module: string;
-    toFile: string;
+    toFile: string | null;
 }>): number;
 export declare function resolveRefsForNamesUnsafe(stmtFn: (sql: string) => {
     run: (...args: (string | number)[]) => unknown;

package/dist/codebase-index/writer-search-helpers.d.ts

@@ -36,6 +36,15 @@ export interface WriterSearchRow {
  */
 export declare const SEARCH_CANDIDATE_SCAN_CAP = 5000;
 export declare function normalizeSearchLimit(limit: number | undefined): number | undefined;
+/**
+ * The symbol kinds a search may return.
+ *
+ * `undefined` — no kind constraint. `null` — the filter can match nothing (an
+ * LSP kind with no internal equivalent, or a `kind` outside the `lspKind`'s
+ * set). Otherwise the allowed kinds. `kind` and `lspKind` INTERSECT: the old
+ * code let `lspKind` silently override an explicit `kind`.
+ */
+export declare function resolveKindFilter(filter: WriterSearchFilter | undefined): readonly SymbolKind[] | null | undefined;
 export declare function buildWriterSearchWhere(query: string, filter?: WriterSearchFilter | undefined): {
     where: string;
     values: unknown[];

package/dist/codebase-index/writer.d.ts

@@ -18,6 +18,8 @@ export declare class IndexStore {
     private readonly stmtCache;
     private bm25Cache;
     private bm25Dirty;
+    /** `PRAGMA data_version` the BM25 cache was built at. */
+    private bm25DataVersion;
     private stmt;
     constructor(projectRoot: string, opts?: {
         indexDir?: string | undefined;
@@ -26,6 +28,12 @@ export declare class IndexStore {
     runAtomicIndexUpdate<T>(job: () => Promise<T>): Promise<T>;
     private beginWriteTransaction;
     private commitWriteTransaction;
+    /**
+     * Never throws: every caller is already propagating the failure that caused
+     * the rollback. When SQLite has rolled the transaction back itself (disk
+     * full, I/O error) the ROLLBACK fails with "no transaction is active", and
+     * that message used to replace the real error.
+     */
     private rollbackWriteTransaction;
     private initSchema;
     private static readonly NEXT_SYMBOL_ID_KEY;
@@ -50,11 +58,12 @@ export declare class IndexStore {
         lang: string;
         module: string;
     }>;
+    getFilesWithDanglingImports(): string[];
     applyImportResolutions(resolutions: ReadonlyArray<{
         fromFile: string;
         lang: string;
         module: string;
-        toFile: string;
+        toFile: string | null;
     }>): number;
     search(query: string, filter?: WriterSearchFilter, opts?: {
         limit?: number | undefined;
@@ -65,7 +74,16 @@ export declare class IndexStore {
         total: number;
     };
     private invalidateBm25;
+    /**
+     * The corpus is rebuilt when this connection wrote (bm25Dirty) OR another
+     * connection committed since it was built. Pooled stores stay open for the
+     * life of the host while the project daemon, an inline indexer or another
+     * process writes the same database; the dirty flag alone never saw those
+     * writes, so short-query results silently dropped every symbol added since.
+     */
     private getOrBuildBm25;
+    /** Changes whenever ANOTHER connection commits to this database. */
+    private dataVersion;
     getAllIndexable(): Array<{
         id: number;
         text: string;
@@ -174,6 +192,7 @@ export declare class IndexStore {
         file: string;
         kind: SymbolKind;
         line: number;
+        scope: string;
     }>;
     /** Declarations in one file, in source order. */
     getFileSymbols(file: string, limit: number): Array<{

package/dist/edit.js

@@ -1,14 +1,14 @@
 import {
   editTool
-} from "./chunk-7GOE2ZTZ.js";
+} from "./chunk-OMWC2OGT.js";
 import "./chunk-MSOAX3GC.js";
-import "./chunk-HYHE4VNA.js";
-import "./chunk-XPVYZ2S6.js";
-import "./chunk-NEYUPZL6.js";
-import "./chunk-KHUCKLOR.js";
-import "./chunk-4CE3RKEP.js";
-import "./chunk-SKRMUHTU.js";
-import "./chunk-ZKC5UNGD.js";
+import "./chunk-UMOP3VGK.js";
+import "./chunk-RYLMSGR5.js";
+import "./chunk-6D3UIQMF.js";
+import "./chunk-BJ5LXLKE.js";
+import "./chunk-R3HR3QI3.js";
+import "./chunk-HSLDY55L.js";
+import "./chunk-OIFY4XNP.js";
 import "./chunk-YOHO4DVT.js";
 import "./chunk-XHSHNOAF.js";
 import "./chunk-XZLVJD56.js";

package/dist/{generic-parser-N2PLGBC2.js → generic-parser-IVWLFKMR.js}

@@ -3,11 +3,11 @@ import {
   GENERIC_MAX_SYMBOLS_DEFAULT,
   parseGeneric,
   parseSymbols
-} from "./chunk-SKRMUHTU.js";
+} from "./chunk-HSLDY55L.js";
 export {
   GENERIC_MAX_FILE_CHARS,
   GENERIC_MAX_SYMBOLS_DEFAULT,
   parseGeneric,
   parseSymbols
 };
-//# sourceMappingURL=generic-parser-N2PLGBC2.js.map
+//# sourceMappingURL=generic-parser-IVWLFKMR.js.map

package/dist/go-parser-LWV3L5V7.js

@@ -0,0 +1,197 @@
+import {
+  GO_PARSE_SCRIPT,
+  goSpawnOptions,
+  parseParserOutput,
+  privateScriptPath,
+  runToolchainChild,
+  toIndexSymbols,
+  withSpawnGate
+} from "./chunk-OIFY4XNP.js";
+import {
+  detectLang
+} from "./chunk-YOHO4DVT.js";
+import {
+  resolveWin32Command
+} from "./chunk-XZLVJD56.js";
+
+// src/codebase-index/go-parser.ts
+async function parseSymbols(opts) {
+  const { file, content, lang } = opts;
+  try {
+    const parsed = await withSpawnGate(() => syncGoParse(file, content, lang));
+    if (parsed.symbols.length > 0) {
+      return parsed;
+    }
+    const fallback = parseGoWithoutToolchain(file, content, lang);
+    return parsed.refs?.length ? { ...fallback, refs: parsed.refs } : fallback;
+  } catch {
+    return parseGoWithoutToolchain(file, content, lang);
+  }
+}
+var GO_FUNC_RE = /^func\s+(?:\(\s*(?:[A-Za-z_]\w*\s+)?\*?\s*([A-Za-z_]\w*)(?:\[[^\]]*\])?\s*\)\s*)?([A-Za-z_]\w*)\s*[[(]/;
+var GO_NAME_LIST_RE = /^([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)/;
+function maskGoNonCode(src) {
+  const blank = (text) => text.replace(/[^\n]/g, " ");
+  let out = "";
+  let i = 0;
+  const n = src.length;
+  while (i < n) {
+    const c = src[i];
+    const next = src[i + 1];
+    if (c === "/" && next === "/") {
+      const newline = src.indexOf("\n", i);
+      const stop = newline === -1 ? n : newline;
+      out += blank(src.slice(i, stop));
+      i = stop;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      const end = src.indexOf("*/", i + 2);
+      const stop = end === -1 ? n : end + 2;
+      out += blank(src.slice(i, stop));
+      i = stop;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      const raw = c === "`";
+      let j = i + 1;
+      while (j < n && src[j] !== c && (raw || src[j] !== "\n")) {
+        j += !raw && src[j] === "\\" ? 2 : 1;
+      }
+      if (j < n && src[j] === c) {
+        out += c + blank(src.slice(i + 1, j)) + c;
+        i = j + 1;
+      } else {
+        const stop = Math.min(j, n);
+        out += c + blank(src.slice(i + 1, stop));
+        i = stop;
+      }
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+function parseGoWithoutToolchain(filePath, content, lang = "go") {
+  const code = maskGoNonCode(content);
+  if (!/^\s*package\s+[A-Za-z_]\w*/m.test(code) || hasUnbalancedDelimiters(code)) {
+    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+  }
+  const symbols = [];
+  const packageName = code.match(/^\s*package\s+([A-Za-z_]\w*)/m)?.[1] ?? "";
+  const qualify = (...parts) => [packageName, ...parts].filter(Boolean).join(".");
+  const codeLines = code.split("\n");
+  const srcLines = content.split("\n");
+  let braces = 0;
+  let parens = 0;
+  let group = null;
+  for (const [idx, line] of codeLines.entries()) {
+    const trimmed = line.trimStart();
+    const add = (kind, name, scope) => {
+      if (name === "_") return;
+      addFallbackSymbol(symbols, {
+        filePath,
+        lang,
+        kind,
+        name,
+        line: idx + 1,
+        col: line.length - trimmed.length,
+        signature: (srcLines[idx] ?? "").trim(),
+        scope
+      });
+    };
+    if (braces === 0 && parens === 0) {
+      group = null;
+      const fn = GO_FUNC_RE.exec(trimmed);
+      const opener = /^(const|var|type)\s*\(/.exec(trimmed);
+      if (fn?.[2]) {
+        add(fn[1] ? "method" : "function", fn[2], fn[1] ? qualify(fn[1], fn[2]) : qualify(fn[2]));
+      } else if (opener?.[1]) {
+        group = opener[1];
+      } else {
+        const typeDecl = /^type\s+([A-Za-z_]\w*)/.exec(trimmed);
+        if (typeDecl?.[1]) add("type", typeDecl[1], packageName);
+        const valueDecl = /^(const|var)\s+/.exec(trimmed);
+        const names = valueDecl ? GO_NAME_LIST_RE.exec(trimmed.slice(valueDecl[0].length)) : null;
+        if (valueDecl?.[1] && names?.[1]) {
+          for (const name of names[1].split(",")) {
+            add(valueDecl[1], name.trim(), packageName);
+          }
+        }
+      }
+    } else if (group && braces === 0 && parens === 1) {
+      const names = GO_NAME_LIST_RE.exec(trimmed)?.[1];
+      if (names) {
+        const members = group === "type" ? [names.split(",")[0] ?? ""] : names.split(",");
+        for (const name of members) add(group, name.trim(), packageName);
+      }
+    }
+    for (const ch of line) {
+      if (ch === "{") braces++;
+      else if (ch === "}") braces--;
+      else if (ch === "(") parens++;
+      else if (ch === ")") parens--;
+    }
+  }
+  return { file: filePath, lang, symbols, mtimeMs: Date.now() };
+}
+function addFallbackSymbol(symbols, opts) {
+  symbols.push({
+    id: 0,
+    lang: opts.lang,
+    kind: opts.kind,
+    name: opts.name,
+    file: opts.filePath,
+    line: opts.line,
+    col: opts.col,
+    signature: opts.signature,
+    docComment: "",
+    scope: opts.scope,
+    text: `${opts.name} ${opts.signature}`.trim()
+  });
+}
+function hasUnbalancedDelimiters(content) {
+  const pairs = { "(": ")", "[": "]", "{": "}" };
+  const closers = new Set(Object.values(pairs));
+  const stack = [];
+  for (const ch of content) {
+    if (pairs[ch]) {
+      stack.push(pairs[ch]);
+    } else if (closers.has(ch) && stack.pop() !== ch) {
+      return true;
+    }
+  }
+  return stack.length > 0;
+}
+async function syncGoParse(filePath, content, lang) {
+  const empty = { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+  try {
+    const scriptPath = await privateScriptPath("ws-go-parse-", "parse.go", GO_PARSE_SCRIPT);
+    const result = await runToolchainChild(
+      resolveWin32Command("go"),
+      ["run", scriptPath],
+      content,
+      15e3,
+      goSpawnOptions(scriptPath)
+    );
+    if (result?.code !== 0 || !result.stdout.trim()) return empty;
+    const { symbols, refs } = parseParserOutput(result.stdout, lang);
+    return {
+      file: filePath,
+      lang,
+      symbols: toIndexSymbols(symbols, filePath, lang),
+      refs,
+      mtimeMs: Date.now()
+    };
+  } catch {
+    return empty;
+  }
+}
+export {
+  detectLang,
+  maskGoNonCode,
+  parseGoWithoutToolchain,
+  parseSymbols
+};
+//# sourceMappingURL=go-parser-LWV3L5V7.js.map

package/dist/index.js

@@ -46,10 +46,10 @@ import "./chunk-Z6DAKQ3U.js";
 import {
   registerBuiltinToolTier,
   selectBuiltinToolsForTier
-} from "./chunk-DKXMDO5F.js";
+} from "./chunk-K3VX6V5P.js";
 import {
   builtinToolsPack
-} from "./chunk-6OIEYJM4.js";
+} from "./chunk-VMNWQI4V.js";
 import {
   OFF_ONLY_TOOLS,
   OPTIONAL_TOOLS,
@@ -64,7 +64,7 @@ import {
   pwshTool,
   readUrlContentTool,
   securityAstScanTool
-} from "./chunk-GU7TZE6Z.js";
+} from "./chunk-2BCRQAIW.js";
 import {
   discoverE2EProjects,
   e2ePlanTool
@@ -98,8 +98,8 @@ import {
   runDeadCodeScan,
   setContextQueryEmbedder,
   writeProjectAtlas
-} from "./chunk-ENE22I5W.js";
-import "./chunk-XRNN44QY.js";
+} from "./chunk-K37AKCTN.js";
+import "./chunk-2IRHFHZY.js";
 import {
   designTool
 } from "./chunk-MRXWOOOR.js";
@@ -131,7 +131,7 @@ import {
 } from "./chunk-SPNXDTCJ.js";
 import {
   patchTool
-} from "./chunk-2UVAIS5O.js";
+} from "./chunk-YPSVPCIE.js";
 import {
   jsonTool
 } from "./chunk-D6RQZMZS.js";
@@ -174,7 +174,7 @@ import {
 import "./chunk-UVYRQKPZ.js";
 import {
   replaceTool
-} from "./chunk-C6ZOXNXV.js";
+} from "./chunk-CSS42GRP.js";
 import {
   globTool
 } from "./chunk-ON6ET5ER.js";
@@ -284,13 +284,13 @@ import {
 } from "./chunk-O2MHULBO.js";
 import {
   readTool
-} from "./chunk-IE4KDAOB.js";
+} from "./chunk-OYQE2UNT.js";
 import {
   writeTool
-} from "./chunk-PWZUHZP7.js";
+} from "./chunk-Z77XMU3U.js";
 import {
   editTool
-} from "./chunk-7GOE2ZTZ.js";
+} from "./chunk-OMWC2OGT.js";
 import {
   checkSyntax
 } from "./chunk-MSOAX3GC.js";
@@ -313,8 +313,8 @@ import {
   shutdownCodebaseIndexHost,
   shutdownCodebaseIndexServer,
   symbolGraphService
-} from "./chunk-HYHE4VNA.js";
-import "./chunk-XPVYZ2S6.js";
+} from "./chunk-UMOP3VGK.js";
+import "./chunk-RYLMSGR5.js";
 import {
   CONCEPT_RELATIONS,
   CircuitOpenError,
@@ -322,11 +322,11 @@ import {
   IndexTimeoutError,
   indexCircuitBreaker,
   resetIndexCircuitBreaker
-} from "./chunk-NEYUPZL6.js";
-import "./chunk-KHUCKLOR.js";
-import "./chunk-4CE3RKEP.js";
-import "./chunk-SKRMUHTU.js";
-import "./chunk-ZKC5UNGD.js";
+} from "./chunk-6D3UIQMF.js";
+import "./chunk-BJ5LXLKE.js";
+import "./chunk-R3HR3QI3.js";
+import "./chunk-HSLDY55L.js";
+import "./chunk-OIFY4XNP.js";
 import "./chunk-YOHO4DVT.js";
 import "./chunk-XHSHNOAF.js";
 import "./chunk-XZLVJD56.js";