@wrongstack/tools 0.285.0 → 0.287.0

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

@@ -1 +1 @@
-{"version":3,"file":"go-parser.d.ts","sourceRoot":"","sources":["../../src/codebase-index/go-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAyB,UAAU,EAAE,MAAM,aAAa,CAAC;AAIlF,wBAAsB,YAAY,CAAC,IAAI,EAAE;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,UAAU,CAAC;CAClB,GAAG,OAAO,CAAC,WAAW,CAAC,CAavB;AAED,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"go-parser.d.ts","sourceRoot":"","sources":["../../src/codebase-index/go-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,OAAO,KAAK,EAAE,WAAW,EAAyB,UAAU,EAAE,MAAM,aAAa,CAAC;AAIlF,wBAAsB,YAAY,CAAC,IAAI,EAAE;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,UAAU,CAAC;CAClB,GAAG,OAAO,CAAC,WAAW,CAAC,CAavB;AAED,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/codebase-index/index.js

@@ -960,14 +960,14 @@ var IndexStore = class {
 };
 
 // src/codebase-index/background-indexer.ts
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Worker } from "node:worker_threads";
 
 // src/codebase-index/indexer.ts
 import { expectDefined as expectDefined5 } from "@wrongstack/core";
-import * as fs6 from "node:fs/promises";
-import * as path7 from "node:path";
+import * as fs7 from "node:fs/promises";
+import * as path8 from "node:path";
 import { compileGlob as compileGlob2 } from "@wrongstack/core";
 
 // src/codebase-index/ts-parser.ts
@@ -1160,8 +1160,34 @@ function detectLang(file) {
 // src/codebase-index/go-parser.ts
 import { spawn } from "node:child_process";
 import * as os from "node:os";
+import * as path3 from "node:path";
+import * as fs3 from "node:fs/promises";
+
+// src/_win32-resolve.ts
+import * as fs2 from "node:fs";
 import * as path2 from "node:path";
-import * as fs2 from "node:fs/promises";
+function resolveWin32Command(cmd) {
+  if (process.platform !== "win32") return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || path2.extname(cmd.replace(/\//g, "\\"))) {
+    return cmd;
+  }
+  const pathext = (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD;.VBS;.JS;.WS;.MSC").toLowerCase().split(";");
+  const pathDirs = (process.env["PATH"] ?? "").split(path2.delimiter);
+  for (const dir of pathDirs) {
+    const base = path2.join(dir, cmd);
+    for (const ext of pathext) {
+      const full = `${base}${ext}`;
+      try {
+        fs2.accessSync(full, fs2.constants.X_OK);
+        return full;
+      } catch {
+      }
+    }
+  }
+  return cmd;
+}
+
+// src/codebase-index/go-parser.ts
 async function parseSymbols2(opts) {
   const { file, content, lang } = opts;
   try {
@@ -1462,31 +1488,46 @@ func formatType(t ast.Expr) string {
 }
 `;
 async function syncGoParse(filePath, content, lang) {
-  const tmpDir = await fs2.mkdtemp(path2.join(os.tmpdir(), "ws-go-parse-"));
+  const tmpDir = await fs3.mkdtemp(path3.join(os.tmpdir(), "ws-go-parse-"));
   try {
-    const scriptPath = path2.join(tmpDir, "parse.go");
-    await fs2.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
-    const proc = spawn("go", ["run", scriptPath], {
-      stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true
-    });
-    let stdout = "";
-    proc.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    proc.stdin?.write(content);
-    proc.stdin?.end();
-    const { code } = await Promise.race([
-      new Promise((resolve2) => {
-        proc.on("close", (c) => resolve2({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
+    const scriptPath = path3.join(tmpDir, "parse.go");
+    await fs3.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
+    const goBinary = resolveWin32Command("go");
+    const goResult = await new Promise(
+      (resolve2, reject) => {
+        let settled = false;
+        const proc = spawn(goBinary, ["run", scriptPath], {
+          stdio: ["pipe", "pipe", "pipe"],
+          windowsHide: true
+        });
+        proc.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          reject(err);
+        });
+        let stdout2 = "";
+        proc.stdout?.on("data", (chunk) => {
+          stdout2 += chunk.toString();
+        });
+        proc.stderr?.resume();
+        proc.stdin?.write(content);
+        proc.stdin?.end();
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
           proc.kill("SIGKILL");
           reject(new Error("timeout"));
-        }, 15e3)
-      )
-    ]).catch(() => ({ code: -1 }));
+        }, 15e3);
+        timer.unref?.();
+        proc.on("close", (code2) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve2({ code: code2, stdout: stdout2 });
+        });
+      }
+    );
+    const { code, stdout } = goResult;
     if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
@@ -1508,15 +1549,15 @@ async function syncGoParse(filePath, content, lang) {
   } catch {
     return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
   } finally {
-    await fs2.rm(tmpDir, { recursive: true, force: true });
+    await fs3.rm(tmpDir, { recursive: true, force: true });
   }
 }
 
 // src/codebase-index/py-parser.ts
-import { spawn as spawn2 } from "node:child_process";
-import * as fs3 from "node:fs/promises";
+import { spawn as spawn2, spawnSync } from "node:child_process";
+import * as fs4 from "node:fs/promises";
 import * as os2 from "node:os";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 async function parseSymbols3(opts) {
   const { file, content, lang } = opts;
   try {
@@ -1728,36 +1769,74 @@ visitor.visit(tree)
 
 print(json.dumps([s.to_dict() for s in syms]))
 `;
-var _cachedScriptPath = null;
-async function syncPyParse(filePath, content, lang) {
-  try {
-    if (!_cachedScriptPath) {
-      const tmpDir = path3.join(os2.tmpdir(), "ws-py-parse");
-      await fs3.mkdir(tmpDir, { recursive: true });
-      _cachedScriptPath = path3.join(tmpDir, "parse.py");
-      await fs3.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
-    }
-    const proc = spawn2("python", [_cachedScriptPath, filePath], {
+function resolvePython() {
+  const candidates = process.platform === "win32" ? ["python3", "python", "py"] : ["python3", "python"];
+  for (const name of candidates) {
+    const resolved = resolveWin32Command(name);
+    const result = spawnSync(resolved, ["--version"], {
+      stdio: "pipe",
+      timeout: 5e3
+    });
+    if (result.error) continue;
+    if (result.status !== 0) continue;
+    return resolved;
+  }
+  return null;
+}
+function spawnPyParser(pyBinary, scriptPath, filePath, content) {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const proc = spawn2(pyBinary, [scriptPath, filePath], {
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
+    proc.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err);
+    });
     proc.stdin?.write(content);
     proc.stdin?.end();
     let stdout = "";
     proc.stdout?.on("data", (chunk) => {
       stdout += chunk.toString();
     });
-    const { code } = await Promise.race([
-      new Promise((resolve2) => {
-        proc.on("close", (c) => resolve2({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
-          proc.kill("SIGKILL");
-          reject(new Error("timeout"));
-        }, 15e3)
-      )
-    ]).catch(() => ({ code: -1 }));
+    proc.stderr?.resume();
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      proc.kill("SIGKILL");
+      reject(new Error("timeout"));
+    }, 15e3);
+    timer.unref?.();
+    proc.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve2({ code, stdout });
+    });
+  });
+}
+var _cachedScriptPath = null;
+var _cachedPyBinary = null;
+async function syncPyParse(filePath, content, lang) {
+  try {
+    if (!_cachedScriptPath) {
+      const tmpDir = path4.join(os2.tmpdir(), "ws-py-parse");
+      await fs4.mkdir(tmpDir, { recursive: true });
+      _cachedScriptPath = path4.join(tmpDir, "parse.py");
+      await fs4.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
+    }
+    if (!_cachedPyBinary) {
+      _cachedPyBinary = resolvePython();
+      if (!_cachedPyBinary) return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
+    }
+    const { code, stdout } = await spawnPyParser(
+      _cachedPyBinary,
+      _cachedScriptPath,
+      filePath,
+      content
+    );
     if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
@@ -1784,8 +1863,8 @@ async function syncPyParse(filePath, content, lang) {
 // src/codebase-index/rs-parser.ts
 import { expectDefined as expectDefined2 } from "@wrongstack/core";
 import { execFileSync, spawn as spawn3 } from "node:child_process";
-import * as fs4 from "node:fs/promises";
-import * as path4 from "node:path";
+import * as fs5 from "node:fs/promises";
+import * as path5 from "node:path";
 async function parseSymbols4(opts) {
   const { file, content, lang } = opts;
   const nativeAvailable = checkNativeParser();
@@ -1798,7 +1877,7 @@ async function parseSymbols4(opts) {
 function checkNativeParser() {
   try {
     execFileSync("rustc", ["--version"], { stdio: "pipe", windowsHide: true });
-    const toolsDir = path4.join(process.cwd(), "tools");
+    const toolsDir = path5.join(process.cwd(), "tools");
     try {
       execFileSync(
         "cargo",
@@ -1808,7 +1887,7 @@ function checkNativeParser() {
           "--format-version",
           "1",
           "--manifest-path",
-          path4.join(toolsDir, "Cargo.toml")
+          path5.join(toolsDir, "Cargo.toml")
         ],
         { stdio: "pipe", windowsHide: true }
       );
@@ -1822,34 +1901,49 @@ function checkNativeParser() {
 }
 async function tryNativeParse(file, content) {
   try {
-    const toolsDir = path4.join(process.cwd(), "tools");
-    const crateDir = path4.join(toolsDir, "syn-parser");
-    const tmpFile = path4.join(crateDir, "src", "input.rs");
-    await fs4.writeFile(tmpFile, content, "utf8");
-    const proc = spawn3(
-      "cargo",
-      ["run", "--manifest-path", path4.join(toolsDir, "Cargo.toml")],
-      {
-        cwd: process.cwd(),
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true
-      }
-    );
-    let stdout = "";
-    proc.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    const { code } = await Promise.race([
-      new Promise((resolve2) => {
-        proc.on("close", (c) => resolve2({ code: c }));
-      }),
-      new Promise(
-        (_, reject) => setTimeout(() => {
+    const toolsDir = path5.join(process.cwd(), "tools");
+    const crateDir = path5.join(toolsDir, "syn-parser");
+    const tmpFile = path5.join(crateDir, "src", "input.rs");
+    await fs5.writeFile(tmpFile, content, "utf8");
+    const cargoBinary = resolveWin32Command("cargo");
+    const result = await new Promise(
+      (resolve2, reject) => {
+        let settled = false;
+        const proc = spawn3(
+          cargoBinary,
+          ["run", "--manifest-path", path5.join(toolsDir, "Cargo.toml")],
+          {
+            cwd: process.cwd(),
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true
+          }
+        );
+        proc.on("error", (err) => {
+          if (settled) return;
+          settled = true;
+          reject(err);
+        });
+        let stdout2 = "";
+        proc.stdout?.on("data", (chunk) => {
+          stdout2 += chunk.toString();
+        });
+        proc.stderr?.resume();
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
           proc.kill("SIGKILL");
           reject(new Error("timeout"));
-        }, 15e3)
-      )
-    ]).catch(() => ({ code: -1 }));
+        }, 15e3);
+        timer.unref?.();
+        proc.on("close", (c) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve2({ code: c, stdout: stdout2 });
+        });
+      }
+    );
+    const { code, stdout } = result;
     if (code === 0 && stdout.trim()) {
       const symbols = JSON.parse(stdout.trim());
       return {
@@ -1932,7 +2026,7 @@ function regexParse(opts) {
 
 // src/codebase-index/json-parser.ts
 import { expectDefined as expectDefined3 } from "@wrongstack/core";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 function parseSymbols5(opts) {
   const { file, content, lang } = opts;
   try {
@@ -1944,7 +2038,7 @@ function parseSymbols5(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename2 = path5.basename(file).toLowerCase();
+  const basename2 = path6.basename(file).toLowerCase();
   const isPackageJson = basename2 === "package.json";
   const isTsconfig = basename2 === "tsconfig.json" || basename2 === "tsconfig.build.json";
   const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
@@ -1970,11 +2064,11 @@ function regexParse2(opts) {
     const line = lineFromOffset(offset);
     symbols.push(
       makeSymbol({
-        name: path5.basename(file),
+        name: path6.basename(file),
         kind: "object",
         line,
         col: 0,
-        signature: `"${path5.basename(file)}" = { ... }`,
+        signature: `"${path6.basename(file)}" = { ... }`,
         file,
         lang
       })
@@ -2285,8 +2379,8 @@ function makeSymbol2(opts) {
 }
 
 // src/codebase-index/gitignore.ts
-import * as fs5 from "node:fs/promises";
-import * as path6 from "node:path";
+import * as fs6 from "node:fs/promises";
+import * as path7 from "node:path";
 import { compileGlob } from "@wrongstack/core";
 function globBody(glob) {
   return compileGlob(glob).source.replace(/^\^/, "").replace(/\$$/, "");
@@ -2332,7 +2426,7 @@ function compileGitignore(lines) {
 async function loadGitignoreMatcher(projectRoot) {
   let lines = [];
   try {
-    const raw = await fs5.readFile(path6.join(projectRoot, ".gitignore"), "utf8");
+    const raw = await fs6.readFile(path7.join(projectRoot, ".gitignore"), "utf8");
     lines = raw.split("\n");
   } catch {
   }
@@ -2390,21 +2484,21 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     }
     let entries;
     try {
-      entries = await fs6.readdir(dir, { withFileTypes: true });
+      entries = await fs7.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     dirCount++;
     for (const e of entries) {
       if (ignoreSet.has(e.name)) continue;
-      const full = path7.join(dir, e.name);
-      const rel = path7.relative(projectRoot, full).replace(/\\/g, "/");
+      const full = path8.join(dir, e.name);
+      const rel = path8.relative(projectRoot, full).replace(/\\/g, "/");
       if (e.isDirectory()) {
         if (isGitIgnored(rel, true)) continue;
         await walk(full);
       } else if (e.isFile()) {
         if (isGitIgnored(rel, false)) continue;
-        const ext = path7.extname(e.name);
+        const ext = path8.extname(e.name);
         for (const { ext: extName, pat } of globs) {
           if (ext === extName && (pat.test(rel) || pat.test(e.name))) {
             results.push(full);
@@ -2460,7 +2554,7 @@ async function runIndexerWithStore(store, opts) {
   let files;
   let discoveredFiles = null;
   if (opts.files && opts.files.length > 0) {
-    files = opts.files.map((f) => path7.resolve(projectRoot, f)).filter((f) => !isGitIgnored(path7.relative(projectRoot, f).replace(/\\/g, "/"), false));
+    files = opts.files.map((f) => path8.resolve(projectRoot, f)).filter((f) => !isGitIgnored(path8.relative(projectRoot, f).replace(/\\/g, "/"), false));
   } else {
     files = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
     discoveredFiles = new Set(files);
@@ -2490,7 +2584,7 @@ async function runIndexerWithStore(store, opts) {
       batchFiles.map(async (file) => {
         let stat2;
         try {
-          stat2 = await fs6.stat(file, statOpts);
+          stat2 = await fs7.stat(file, statOpts);
         } catch (e) {
           if (isAbortError(e)) throw e;
           return { file, stat: null, lang: "", parsed: null, error: `stat error: ${e instanceof Error ? e.message : String(e)}` };
@@ -2504,7 +2598,7 @@ async function runIndexerWithStore(store, opts) {
         }
         let content;
         try {
-          content = await fs6.readFile(file, { encoding: "utf8", signal });
+          content = await fs7.readFile(file, { encoding: "utf8", signal });
         } catch (e) {
           if (isAbortError(e)) throw e;
           return { file, stat: stat2, lang, parsed: null, error: `read error: ${e instanceof Error ? e.message : String(e)}` };
@@ -2773,7 +2867,7 @@ function resolveWorkerUrl() {
   for (const rel of ["./worker.js", "./codebase-index/worker.js"]) {
     try {
       const url = new URL(rel, import.meta.url);
-      if (url.protocol === "file:" && fs7.existsSync(fileURLToPath(url))) return url;
+      if (url.protocol === "file:" && fs8.existsSync(fileURLToPath(url))) return url;
     } catch {
     }
   }