@wrongstack/tools 1.0.10 → 1.0.12

package/dist/chunk-BJ5LXLKE.js

@@ -0,0 +1,351 @@
+import {
+  resolvePythonBinary
+} from "./chunk-R3HR3QI3.js";
+import {
+  GO_BATCH_SCRIPT,
+  PY_BATCH_SCRIPT,
+  goSpawnOptions,
+  parseParserBatchOutput,
+  privateScriptPath,
+  pySpawnOptions,
+  runToolchainChild,
+  toIndexSymbols,
+  withSpawnGate
+} from "./chunk-OIFY4XNP.js";
+import {
+  resolveWin32Command
+} from "./chunk-XZLVJD56.js";
+
+// src/codebase-index/import-extractor.ts
+var IMPORT_MAX_FILE_CHARS = 512 * 1024;
+var IMPORT_MAX_PER_FILE = 400;
+var DOTTED_IMPORT = [
+  { re: /^[ \t]*import\s+(?:static\s+)?([\w.]+(?:\.\*)?)\s*;?\s*$/gm }
+];
+var LANG_IMPORTS = {
+  // Go and Python have real AST extractors; these patterns are the fallback for
+  // machines with no Go toolchain or Python interpreter installed, where the
+  // parser degrades to regex symbols and would otherwise contribute no edges.
+  go: [
+    { re: /^[ \t]*import\s+(?:[\w.]+\s+)?"([^"]+)"/gm },
+    // Grouped form: inside `import ( … )` each line is an optional alias plus a
+    // quoted path. A stray match elsewhere resolves to no file and is dropped.
+    { re: /^[ \t]*(?:[A-Za-z_.]\w*\s+)?"([^"]+)"\s*$/gm }
+  ],
+  py: [{ re: /^[ \t]*import\s+([\w.]+)/gm }, { re: /^[ \t]*from\s+([.\w]+)\s+import\b/gm }],
+  rs: [
+    // use a::b::C;  |  use a::b::{C, D};  |  use a::b::*;  → the path before
+    // any brace or glob. Visibility may be restricted (`pub(crate) use …`),
+    // which the plain `pub\s+` form never matched.
+    { re: /^[ \t]*(?:pub(?:\s*\([^)]*\))?\s+)?use\s+(?:::)?([\w:]+?)(?:::\{|::\*|\s*;|\s+as\b)/gm },
+    // mod foo;  (a declaration *and* a dependency on foo.rs / foo/mod.rs)
+    { re: /^[ \t]*(?:pub(?:\s*\([^)]*\))?\s+)?mod\s+(\w+)\s*;/gm }
+  ],
+  java: DOTTED_IMPORT,
+  kotlin: DOTTED_IMPORT,
+  scala: [{ re: /^[ \t]*import\s+([\w.]+(?:\.[_*])?)\s*$/gm }],
+  csharp: [
+    // using Foo.Bar;  |  using static Foo.Bar;  |  using Alias = Foo.Bar;
+    { re: /^[ \t]*global\s+using\s+(?:static\s+)?([\w.]+)\s*;/gm, name: "full" },
+    { re: /^[ \t]*using\s+(?:static\s+)?(?:\w+\s*=\s*)?([\w.]+)\s*;/gm, name: "full" }
+  ],
+  // Quoted includes only: <stdio.h> is a system header with no indexed file.
+  c: [{ re: /^[ \t]*#\s*include\s+"([^"]+)"/gm }],
+  cpp: [{ re: /^[ \t]*#\s*include\s+"([^"]+)"/gm }],
+  ruby: [{ re: /^[ \t]*(?:require|require_relative|load)\s*\(?\s*['"]([^'"]+)['"]/gm }],
+  php: [
+    // `use A\B\C` imports the class C, which is what the index has a symbol
+    // for — the namespace symbol only covers the `A\B` prefix.
+    { re: /^[ \t]*use\s+(?:function\s+|const\s+)?([\w\\]+)/gm },
+    { re: /^[ \t]*(?:require|require_once|include|include_once)\s*\(?\s*['"]([^'"]+)['"]/gm }
+  ],
+  swift: [{ re: /^[ \t]*import\s+(?:struct\s+|class\s+|func\s+)?([\w.]+)\s*$/gm }],
+  dart: [{ re: /^[ \t]*(?:import|export|part)\s+['"]([^'"]+)['"]/gm }],
+  lua: [{ re: /\brequire\s*\(?\s*['"]([^'"]+)['"]/g }],
+  elixir: [{ re: /^[ \t]*(?:alias|import|require|use)\s+([A-Z][\w.]*)/gm, name: "full" }],
+  haskell: [{ re: /^[ \t]*import\s+(?:qualified\s+)?([\w.]+)/gm, name: "full" }],
+  zig: [{ re: /@import\s*\(\s*"([^"]+)"\s*\)/g }],
+  proto: [{ re: /^[ \t]*import\s+(?:public\s+|weak\s+)?"([^"]+)"\s*;/gm }],
+  // `@import "x"`, `@use "x"`, `@forward "x"` — Sass and plain CSS alike.
+  css: [{ re: /^[ \t]*@(?:import|use|forward)\s+(?:url\()?\s*['"]([^'"]+)['"]/gm }],
+  // A .vue/.svelte file's <script> block is JS; the same ESM syntax applies.
+  vue: [{ re: /^[ \t]*import\s[^'"]*from\s*['"]([^'"]+)['"]/gm }],
+  svelte: [{ re: /^[ \t]*import\s[^'"]*from\s*['"]([^'"]+)['"]/gm }],
+  html: [
+    { re: /<script[^>]+src\s*=\s*['"]([^'"]+)['"]/g },
+    { re: /<link[^>]+href\s*=\s*['"]([^'"]+)['"]/g }
+  ],
+  shell: [{ re: /^[ \t]*(?:source|\.)\s+(\S+)/gm }],
+  r: [{ re: /\b(?:source|library|require)\s*\(\s*['"]?([\w./-]+)['"]?\s*\)/g }]
+};
+function lastSegment(specifier) {
+  const pathLike = /[/\\]|::/.test(specifier);
+  const segments = specifier.split(/[/\\]|::/).filter(Boolean);
+  let last = segments[segments.length - 1] ?? specifier;
+  if (last === "*" || last === "_") {
+    last = segments[segments.length - 2] ?? specifier;
+  }
+  if (pathLike) return last.replace(/\.[A-Za-z0-9]{1,8}$/, "") || last;
+  const dotted = last.split(".").filter((part) => part && part !== "*" && part !== "_");
+  return dotted[dotted.length - 1] ?? last;
+}
+function newlineOffsets(content) {
+  const offsets = [];
+  for (let i = 0; i < content.length; i++) {
+    if (content.charCodeAt(i) === 10) offsets.push(i);
+  }
+  return offsets;
+}
+function lineAt(offsets, index) {
+  let low = 0;
+  let high = offsets.length;
+  while (low < high) {
+    const mid = low + high >>> 1;
+    if ((offsets[mid] ?? 0) < index) low = mid + 1;
+    else high = mid;
+  }
+  return low + 1;
+}
+function hasImportPatterns(lang) {
+  return LANG_IMPORTS[lang] !== void 0;
+}
+function extractImports(opts) {
+  const patterns = LANG_IMPORTS[opts.lang];
+  if (!patterns || !opts.content) return [];
+  const limit = opts.maxImports ?? IMPORT_MAX_PER_FILE;
+  const content = opts.content.length > IMPORT_MAX_FILE_CHARS ? opts.content.slice(0, IMPORT_MAX_FILE_CHARS) : opts.content;
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const offsets = newlineOffsets(content);
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.re.source, pattern.re.flags);
+    for (const match of content.matchAll(re)) {
+      if (refs.length >= limit) return refs;
+      const specifier = match[1]?.trim();
+      if (!specifier) continue;
+      const module = specifier;
+      const toName = pattern.name === "full" ? module : lastSegment(module);
+      if (!toName) continue;
+      const key = `${module}\0${toName}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      refs.push({
+        fromId: 0,
+        toName,
+        callType: "import",
+        line: lineAt(offsets, match.index ?? 0),
+        lang: opts.lang,
+        module
+      });
+    }
+  }
+  return refs;
+}
+
+// src/codebase-index/parser-batch.ts
+var MAX_BATCH_FILES = 100;
+var MAX_BATCH_BYTES = 8 * 1024 * 1024;
+function chunkBatchFiles(files) {
+  const chunks = [];
+  let current = [];
+  let bytes = 0;
+  for (const file of files) {
+    const size = Buffer.byteLength(file.content, "utf8");
+    if (current.length > 0 && (current.length >= MAX_BATCH_FILES || bytes + size > MAX_BATCH_BYTES)) {
+      chunks.push(current);
+      current = [];
+      bytes = 0;
+    }
+    current.push(file);
+    bytes += size;
+  }
+  if (current.length > 0) chunks.push(current);
+  return chunks;
+}
+function batchTimeoutMs(fileCount) {
+  return Math.min(12e4, 15e3 + fileCount * 1500);
+}
+var _goBatchScriptPath = null;
+var _pyBatchScriptPath = null;
+function batchPayload(files) {
+  return JSON.stringify(files.map((f) => ({ file: f.file, content: f.content })));
+}
+function collectBatch(stdout, lang) {
+  const out = /* @__PURE__ */ new Map();
+  for (const entry of parseParserBatchOutput(stdout, lang)) {
+    if (entry.error !== void 0) continue;
+    out.set(entry.file, {
+      file: entry.file,
+      lang,
+      symbols: toIndexSymbols(entry.symbols, entry.file, lang),
+      refs: entry.refs,
+      mtimeMs: Date.now()
+    });
+  }
+  return out;
+}
+async function runGoBatch(files, goBinary) {
+  if (files.length === 0) return /* @__PURE__ */ new Map();
+  const scriptPath = await privateScriptPath("ws-go-parse-", "batch.go", GO_BATCH_SCRIPT);
+  _goBatchScriptPath = scriptPath;
+  const result = await withSpawnGate(
+    () => runToolchainChild(
+      goBinary ?? resolveWin32Command("go"),
+      ["run", scriptPath],
+      batchPayload(files),
+      batchTimeoutMs(files.length),
+      goSpawnOptions(scriptPath)
+    )
+  );
+  if (result?.code !== 0 || !result.stdout.trim()) return /* @__PURE__ */ new Map();
+  return collectBatch(result.stdout, "go");
+}
+async function runPyBatch(files, pythonBinary) {
+  if (files.length === 0) return /* @__PURE__ */ new Map();
+  const scriptPath = await privateScriptPath("ws-py-parse-", "batch.py", PY_BATCH_SCRIPT);
+  _pyBatchScriptPath = scriptPath;
+  const result = await withSpawnGate(
+    () => runToolchainChild(
+      pythonBinary,
+      [scriptPath],
+      batchPayload(files),
+      batchTimeoutMs(files.length),
+      pySpawnOptions(scriptPath)
+    )
+  );
+  if (result?.code !== 0 || !result.stdout.trim()) return /* @__PURE__ */ new Map();
+  return collectBatch(result.stdout, "py");
+}
+
+// src/codebase-index/parser-dispatch.ts
+async function parseFileContent(file, content, lang) {
+  const parsed = await dispatch(file, content, lang);
+  return withRelations(parsed, content, lang);
+}
+async function parseFilesContent(files) {
+  if (files.length === 0) return [];
+  const slots = files.map(() => ({ result: null }));
+  const batchingEnabled = process.env["WRONGSTACK_TOOLCHAIN_BATCH"] !== "0";
+  if (batchingEnabled) {
+    const goFiles = [];
+    const pyFiles = [];
+    files.forEach((f, index) => {
+      if (f.lang === "go") goFiles.push({ ...f, index });
+      else if (f.lang === "py") pyFiles.push({ ...f, index });
+    });
+    if (goFiles.length > 0) {
+      await applyBatchResults(slots, goFiles, (chunks) => runGoBatch(chunks), "go");
+    }
+    if (pyFiles.length > 0) {
+      const pyBinary = await resolvePythonBinary();
+      if (pyBinary) {
+        await applyBatchResults(slots, pyFiles, (chunks) => runPyBatch(chunks, pyBinary), "py");
+      }
+    }
+  }
+  const jobs = [];
+  for (let i = 0; i < files.length; i++) {
+    if (slots[i].result !== null) continue;
+    const { file, content, lang } = files[i];
+    const slot = slots[i];
+    jobs.push(
+      (async () => {
+        try {
+          slot.result = await parseFileContent(file, content, lang);
+        } catch (err) {
+          slot.error = err instanceof Error ? err.message : String(err);
+        }
+      })()
+    );
+  }
+  await Promise.all(jobs);
+  return slots;
+}
+async function applyBatchResults(slots, batchFiles, runBatch, lang) {
+  for (const chunk of chunkBatchFiles(batchFiles)) {
+    let byFile = null;
+    try {
+      byFile = await runBatch(chunk);
+    } catch {
+      byFile = null;
+    }
+    if (!byFile) continue;
+    for (const item of chunk) {
+      const parsed = byFile.get(item.file);
+      if (!parsed) continue;
+      slots[item.index] = { result: withRelations(parsed, item.content, lang) };
+    }
+  }
+}
+async function dispatch(file, content, lang) {
+  switch (lang) {
+    case "ts":
+    case "tsx":
+    case "js":
+    case "jsx": {
+      const { parseSymbols } = await import("./ts-parser-PML6QIH7.js");
+      return parseSymbols({ file, content, lang });
+    }
+    case "go": {
+      const { parseSymbols } = await import("./go-parser-LWV3L5V7.js");
+      return parseSymbols({ file, content, lang: "go" });
+    }
+    case "py": {
+      const { parseSymbols } = await import("./py-parser-B6D6RGH7.js");
+      return parseSymbols({ file, content, lang: "py" });
+    }
+    case "rs": {
+      const { parseSymbols } = await import("./rs-parser-L7SP4GWJ.js");
+      return parseSymbols({ file, content, lang: "rs" });
+    }
+    case "json": {
+      const { parseSymbols } = await import("./json-parser-PERV2JHX.js");
+      return parseSymbols({ file, content, lang: "json" });
+    }
+    case "yaml": {
+      const { parseSymbols } = await import("./yaml-parser-7BJN544B.js");
+      return parseSymbols({ file, content, lang: "yaml" });
+    }
+    // Phase 1: ten languages now route through the Tree-Sitter WASM
+    // universal parser (`tree-sitter-parser.ts`). The dispatch falls back to
+    // the regex extractor in `generic-parser.ts` whenever WASM loading fails
+    // or the parser returns zero symbols — preserving the indexable-file
+    // contract that "missing a parser must never mean skipping the file".
+    case "c":
+    case "cpp":
+    case "java":
+    case "csharp":
+    case "php":
+    case "ruby":
+    case "swift":
+    case "kotlin":
+    case "shell":
+    case "elixir": {
+      try {
+        const { parseSymbols: parseSymbols2 } = await import("./tree-sitter-parser-KU6JF3ZC.js");
+        const parsed = await parseSymbols2({ file, content, lang });
+        if (parsed.symbols.length > 0) return parsed;
+      } catch {
+      }
+      const { parseSymbols } = await import("./generic-parser-IVWLFKMR.js");
+      return parseSymbols({ file, content, lang });
+    }
+    default: {
+      const { parseSymbols } = await import("./generic-parser-IVWLFKMR.js");
+      return parseSymbols({ file, content, lang });
+    }
+  }
+}
+function withRelations(parsed, content, lang) {
+  let refs = parsed.refs ?? [];
+  if (refs.length === 0 && hasImportPatterns(lang)) {
+    refs = extractImports({ content, lang });
+  }
+  return { ...parsed, refs: refs.map((ref) => ref.lang ? ref : { ...ref, lang }) };
+}
+
+export {
+  parseFileContent,
+  parseFilesContent
+};
+//# sourceMappingURL=chunk-BJ5LXLKE.js.map

package/dist/{chunk-C6ZOXNXV.js → chunk-CSS42GRP.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-ZBMANLYH.js";
 import {
   enqueueReindex
-} from "./chunk-HYHE4VNA.js";
+} from "./chunk-UMOP3VGK.js";
 import {
   isBinaryBuffer,
   safeResolveReal,
@@ -423,4 +423,4 @@ export {
   replaceTool,
   __resetRgDetectionForTests
 };
-//# sourceMappingURL=chunk-C6ZOXNXV.js.map
+//# sourceMappingURL=chunk-CSS42GRP.js.map

package/dist/{chunk-SKRMUHTU.js → chunk-HSLDY55L.js}

@@ -1,4 +1,5 @@
 // src/codebase-index/generic-parser.ts
+var NOT_STATEMENT = "(?!(?:return|new|throw|else|case|delete|goto|await|yield|sizeof|typeof)\\b)";
 var C_LIKE = [
   { re: /\b(?:class|struct|enum|interface|union)\s+([A-Za-z_]\w*)/g, kind: "class" },
   {
@@ -12,7 +13,10 @@ var C_LIKE = [
     // separates type from name. Generic types with internal spaces
     // (`Map<String, Integer> x;`) are no longer matched — tree-sitter is the
     // primary parser for C/C++ and this is only its WASM-less fallback.
-    re: /\b(?:(?:public|private|protected|static|final|async|override|virtual|inline|export)\s+)?[\w:<>[\]*&]+\s+([A-Za-z_]\w*)\s*\([^;{]*\)\s*(?:const)?\s*[{;]/g,
+    re: new RegExp(
+      `\\b(?:(?:public|private|protected|static|final|async|override|virtual|inline|export)\\s+)?${NOT_STATEMENT}[\\w:<>[\\]*&]+\\s+([A-Za-z_]\\w*)\\s*\\([^;{]*\\)\\s*(?:const)?\\s*[{;]`,
+      "g"
+    ),
     kind: "function"
   },
   { re: /\b(?:namespace)\s+([A-Za-z_]\w*)/g, kind: "namespace" }
@@ -21,7 +25,8 @@ var LANG_PATTERNS = {
   py: [
     { re: /^(?:async\s+)?def\s+([A-Za-z_]\w*)/gm, kind: "function" },
     { re: /^class\s+([A-Za-z_]\w*)/gm, kind: "class" },
-    { re: /^([A-Za-z_]\w*)\s*=/gm, kind: "var" }
+    // `(?!=)`: a top-level comparison (`x == y`) is not an assignment.
+    { re: /^([A-Za-z_]\w*)\s*=(?!=)/gm, kind: "var" }
   ],
   go: [
     { re: /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/gm, kind: "function" },
@@ -47,7 +52,10 @@ var LANG_PATTERNS = {
       // `(?:…|\s)+\s*[\w.<>,[\]\s]+\s+` let three quantifiers compete for the
       // same whitespace (800 bytes of padding measured at 42 s). Whitespace
       // now has exactly one owner per position.
-      re: /\b(?:(?:public|private|protected|static|final|abstract|synchronized|native|default)\s+)*[\w.$,<>[\]]+\s+([A-Za-z_]\w*)\s*\(/g,
+      re: new RegExp(
+        `\\b(?:(?:public|private|protected|static|final|abstract|synchronized|native|default)\\s+)*${NOT_STATEMENT}[\\w.$,<>[\\]]+\\s+([A-Za-z_]\\w*)\\s*\\(`,
+        "g"
+      ),
       kind: "method"
     }
   ],
@@ -56,7 +64,10 @@ var LANG_PATTERNS = {
     { re: /\bnamespace\s+([A-Za-z_.\w]+)/g, kind: "namespace" },
     {
       // H-10: see java above.
-      re: /\b(?:(?:public|private|protected|internal|static|async|override|virtual)\s+)*[\w.$,<>[\]]+\s+([A-Za-z_]\w*)\s*\(/g,
+      re: new RegExp(
+        `\\b(?:(?:public|private|protected|internal|static|async|override|virtual)\\s+)*${NOT_STATEMENT}[\\w.$,<>[\\]]+\\s+([A-Za-z_]\\w*)\\s*\\(`,
+        "g"
+      ),
       kind: "method"
     }
   ],
@@ -97,7 +108,9 @@ var LANG_PATTERNS = {
     }
   ],
   md: [{ re: /^(#{1,6})\s+(.+)$/gm, kind: "namespace" }],
-  toml: [{ re: /^\[([^\]]+)\]/gm, kind: "namespace" }],
+  // `[table]` and `[[array.of.tables]]` — the old `^\[([^\]]+)\]` captured
+  // `[bin` for `[[bin]]`.
+  toml: [{ re: /^\[\[?\s*([^[\]\s][^[\]]*?)\s*\]\]?/gm, kind: "namespace" }],
   html: [
     { re: /\bid\s*=\s*["']([^"']+)["']/gi, kind: "property" },
     { re: /<(?:script|template|style)\b/gi, kind: "namespace" }
@@ -231,6 +244,24 @@ var KEYWORDS = /* @__PURE__ */ new Set([
   "await",
   "yield"
 ]);
+function maskMarkdownFences(content) {
+  const lines = content.split("\n");
+  let fence = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const marker = /^\s{0,3}(`{3,}|~{3,})/.exec(line)?.[1];
+    if (fence === null) {
+      if (marker) fence = marker;
+      continue;
+    }
+    if (marker && marker[0] === fence[0] && marker.length >= fence.length) {
+      fence = null;
+      continue;
+    }
+    lines[i] = line.replace(/[^\r]/g, " ");
+  }
+  return lines.join("\n");
+}
 function patternsFor(lang) {
   return LANG_PATTERNS[lang] ?? LANG_PATTERNS.other ?? [];
 }
@@ -273,7 +304,8 @@ function parseGeneric(opts) {
   if (!opts.content || looksBinary(opts.content)) {
     return { file, lang, symbols: [], mtimeMs };
   }
-  const content = opts.content.length > GENERIC_MAX_FILE_CHARS ? opts.content.slice(0, GENERIC_MAX_FILE_CHARS) : opts.content;
+  const bounded = opts.content.length > GENERIC_MAX_FILE_CHARS ? opts.content.slice(0, GENERIC_MAX_FILE_CHARS) : opts.content;
+  const content = lang === "md" ? maskMarkdownFences(bounded) : bounded;
   const patterns = patternsFor(lang);
   const symbols = [];
   const seen = /* @__PURE__ */ new Set();
@@ -290,7 +322,8 @@ function parseGeneric(opts) {
       if (lang === "md" && match[2]) name = match[2].trim();
       if (!name || name.length > 200) continue;
       name = name.replace(/^#+\s*/, "").replace(/["'`]/g, "");
-      if (!name || KEYWORDS.has(name.toLowerCase())) continue;
+      if (!name) continue;
+      if (lang !== "md" && lang !== "toml" && KEYWORDS.has(name)) continue;
       if (!/^[A-Za-z_#.@/\w][\w.\-:/#!?]*$/.test(name) && lang !== "md" && lang !== "toml") {
         continue;
       }
@@ -329,4 +362,4 @@ export {
   parseGeneric,
   parseSymbols
 };
-//# sourceMappingURL=chunk-SKRMUHTU.js.map
+//# sourceMappingURL=chunk-HSLDY55L.js.map