@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-IYK7XGDZ.js

@@ -0,0 +1,892 @@
+import {
+  resolvePythonBinary
+} from "./chunk-ZLTFLC25.js";
+import {
+  parseParserBatchOutput,
+  withSpawnGate
+} from "./chunk-UCYQTZ7F.js";
+import {
+  resolveWin32Command
+} from "./chunk-V43EQ6VR.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};  → the path before any brace
+    { re: /^[ \t]*(?:pub\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+)?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
+import { spawn } from "node:child_process";
+import * as fsSync from "node:fs";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+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 GO_BATCH_SCRIPT = `
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+)
+
+type Sym struct {
+	Name      string \`json:"name"\`
+	Kind      string \`json:"kind"\`
+	Line      int    \`json:"line"\`
+	Col       int    \`json:"col"\`
+	Signature string \`json:"signature"\`
+	Scope     string \`json:"scope"\`
+}
+
+type Ref struct {
+	ToName   string \`json:"toName"\`
+	CallType string \`json:"callType"\`
+	Line     int    \`json:"line"\`
+	Module   string \`json:"module"\`
+}
+
+type FileResult struct {
+	File    string \`json:"file"\`
+	Error   string \`json:"error,omitempty"\`
+	Symbols []Sym  \`json:"symbols"\`
+	Refs    []Ref  \`json:"refs"\`
+}
+
+type BatchResult struct {
+	Version int          \`json:"version"\`
+	Results []FileResult \`json:"results"\`
+}
+
+type inputFile struct {
+	File    string \`json:"file"\`
+	Content string \`json:"content"\`
+}
+
+func parseOne(name string, src []byte) FileResult {
+	res := FileResult{File: name, Symbols: []Sym{}, Refs: []Ref{}}
+	fset := token.NewFileSet()
+	node, err := parser.ParseFile(fset, "src.go", src, 0)
+	if err != nil {
+		res.Error = err.Error()
+		return res
+	}
+	pkgScope := node.Name.Name
+	for _, decl := range node.Decls {
+		switch d := decl.(type) {
+		case *ast.FuncDecl:
+			symName := d.Name.Name
+			kind := "function"
+			scope := pkgScope
+			if d.Recv != nil && len(d.Recv.List) > 0 {
+				scope = pkgScope + "." + recvTypeName(d.Recv.List[0].Type) + "." + symName
+				kind = "method"
+			} else {
+				scope = pkgScope + "." + symName
+			}
+			pos := fset.Position(d.Pos())
+			res.Symbols = append(res.Symbols, Sym{Name: symName, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: formatFuncSig(d), Scope: scope})
+		case *ast.GenDecl:
+			for _, spec := range d.Specs {
+				switch s := spec.(type) {
+				case *ast.TypeSpec:
+					typeName := s.Name.Name
+					pos := fset.Position(s.Pos())
+					sig := "type " + typeName
+					if s.TypeParams != nil {
+						sig += formatTypeParams(s.TypeParams)
+					}
+					if st, ok := s.Type.(*ast.StructType); ok {
+						sig += " = struct { " + formatFields(st.Fields.List) + " }"
+					} else if it, ok := s.Type.(*ast.InterfaceType); ok {
+						sig += " = interface { " + formatMethods(it.Methods.List) + " }"
+					} else {
+						sig += " = " + formatType(s.Type)
+					}
+					res.Symbols = append(res.Symbols, Sym{Name: typeName, Kind: "type", Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
+				case *ast.ValueSpec:
+					for _, n := range s.Names {
+						valueName := n.Name
+						pos := fset.Position(n.Pos())
+						kind := "var"
+						if d.Tok == token.CONST {
+							kind = "const"
+						}
+						sig := kind + " " + valueName
+						if s.Type != nil {
+							sig += " " + formatType(s.Type)
+						}
+						res.Symbols = append(res.Symbols, Sym{Name: valueName, Kind: kind, Line: pos.Line, Col: pos.Column, Signature: sig, Scope: pkgScope})
+					}
+				}
+			}
+		}
+	}
+	ast.Inspect(node, func(n ast.Node) bool {
+		switch expr := n.(type) {
+		case *ast.CallExpr:
+			line := fset.Position(expr.Pos()).Line
+			switch fun := expr.Fun.(type) {
+			case *ast.Ident:
+				res.Refs = append(res.Refs, Ref{ToName: fun.Name, CallType: "call", Line: line})
+			case *ast.SelectorExpr:
+				res.Refs = append(res.Refs, Ref{ToName: fun.Sel.Name, CallType: "call", Line: line})
+			}
+		case *ast.ImportSpec:
+			if expr.Path != nil {
+				if importPath, uerr := strconv.Unquote(expr.Path.Value); uerr == nil {
+					line := fset.Position(expr.Pos()).Line
+					name := importPath
+					if idx := strings.LastIndex(importPath, "/"); idx >= 0 {
+						name = importPath[idx+1:]
+					}
+					res.Refs = append(res.Refs, Ref{ToName: name, CallType: "import", Line: line, Module: importPath})
+				}
+			}
+		}
+		return true
+	})
+	return res
+}
+
+func main() {
+	raw, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		out, _ := json.Marshal(BatchResult{Version: 1, Results: []FileResult{}})
+		fmt.Print(string(out))
+		return
+	}
+	var inputs []inputFile
+	if err := json.Unmarshal(raw, &inputs); err != nil {
+		out, _ := json.Marshal(BatchResult{Version: 1, Results: []FileResult{}})
+		fmt.Print(string(out))
+		return
+	}
+	results := make([]FileResult, 0, len(inputs))
+	for _, in := range inputs {
+		results = append(results, parseOne(in.File, []byte(in.Content)))
+	}
+	data, err := json.Marshal(BatchResult{Version: 1, Results: results})
+	if err != nil {
+		fmt.Print("{\\"version\\":1,\\"results\\":[]}")
+		return
+	}
+	fmt.Print(string(data))
+}
+
+func recvTypeName(t ast.Expr) string {
+	switch v := t.(type) {
+	case *ast.Ident:
+		return v.Name
+	case *ast.StarExpr:
+		return recvTypeName(v.X)
+	default:
+		return "?"
+	}
+}
+
+func formatFuncSig(d *ast.FuncDecl) string {
+	scope := ""
+	if d.Recv != nil && len(d.Recv.List) > 0 {
+		scope = "(" + formatFieldList(d.Recv.List) + ") "
+	}
+	scope += formatFuncType(d.Type)
+	return "func " + scope
+}
+
+func formatFuncType(f *ast.FuncType) string {
+	params := formatFieldList(f.Params.List)
+	results := ""
+	if f.Results != nil {
+		results = " -> " + formatFieldList(f.Results.List)
+	}
+	return params + results
+}
+
+func formatFieldList(fields []*ast.Field) string {
+	if len(fields) == 0 {
+		return "()"
+	}
+	names := make([]string, 0, len(fields))
+	for _, f := range fields {
+		name := ""
+		if len(f.Names) > 0 {
+			name = f.Names[0].Name
+		}
+		t := formatType(f.Type)
+		if name != "" {
+			names = append(names, name+" "+t)
+		} else {
+			names = append(names, t)
+		}
+	}
+	return "(" + strings.Join(names, ", ") + ")"
+}
+
+func formatFields(fields []*ast.Field) string {
+	lines := make([]string, 0)
+	for _, f := range fields {
+		name := ""
+		if len(f.Names) > 0 {
+			name = f.Names[0].Name
+		}
+		t := formatType(f.Type)
+		if name != "" {
+			lines = append(lines, name+" "+t)
+		} else {
+			lines = append(lines, t)
+		}
+	}
+	return strings.Join(lines, "; ")
+}
+
+func formatMethods(fields []*ast.Field) string {
+	return formatFields(fields)
+}
+
+func formatTypeParams(tp *ast.FieldList) string {
+	if tp == nil || len(tp.List) == 0 {
+		return ""
+	}
+	params := make([]string, len(tp.List))
+	for i, p := range tp.List {
+		if len(p.Names) > 0 {
+			params[i] = p.Names[0].Name
+		} else {
+			params[i] = "T"
+		}
+	}
+	return "[" + strings.Join(params, ", ") + "]"
+}
+
+func formatType(t ast.Expr) string {
+	if t == nil {
+		return "?"
+	}
+	switch v := t.(type) {
+	case *ast.Ident:
+		return v.Name
+	case *ast.SelectorExpr:
+		return formatType(v.X) + "." + v.Sel.Name
+	case *ast.StarExpr:
+		return "*" + formatType(v.X)
+	case *ast.ArrayType:
+		if v.Len == nil {
+			return "[]" + formatType(v.Elt)
+		}
+		return "[...]" + formatType(v.Elt)
+	case *ast.MapType:
+		return "map[" + formatType(v.Key) + "]" + formatType(v.Value)
+	case *ast.InterfaceType:
+		return "interface{}"
+	case *ast.StructType:
+		return "struct{}"
+	case *ast.FuncType:
+		return formatFuncType(v)
+	case *ast.ChanType:
+		return "chan " + formatType(v.Value)
+	case *ast.BasicLit:
+		return v.Value
+	case *ast.IndexExpr:
+		return formatType(v.X) + "[" + formatType(v.Index) + "]"
+	case *ast.IndexListExpr:
+		args := make([]string, len(v.Indices))
+		for i, idx := range v.Indices {
+			args[i] = formatType(idx)
+		}
+		return formatType(v.X) + "[" + strings.Join(args, ", ") + "]"
+	default:
+		return "?"
+	}
+}
+`;
+var PY_BATCH_SCRIPT = `import ast, json, sys
+
+def get_name(node):
+    if isinstance(node, ast.Name):
+        return node.id
+    elif isinstance(node, ast.Attribute):
+        return get_name(node.value) + "." + node.attr
+    elif isinstance(node, ast.Subscript):
+        return get_name(node.value)
+    elif isinstance(node, ast.Call):
+        return get_name(node.func)
+    elif isinstance(node, ast.Constant):
+        return str(node.value)
+    return ""
+
+def leaf_name(node):
+    if isinstance(node, ast.Attribute):
+        return node.attr
+    if isinstance(node, ast.Name):
+        return node.id
+    return get_name(node).split(".")[-1]
+
+def is_private(name):
+    return name.startswith("__") and not name.endswith("__")
+
+def parse_one(name, source, module_name):
+    result = {"file": name, "symbols": [], "refs": []}
+    try:
+        tree = ast.parse(source, filename=name)
+    except Exception as e:
+        result["error"] = str(e)
+        return result
+    syms = []
+    refs = []
+    scope_stack = [module_name]
+
+    def sym(d):
+        return {
+            "name": d["name"], "kind": d["kind"], "line": d["line"], "col": d["col"],
+            "signature": d["signature"], "scope": d["scope"],
+        }
+
+    class Visitor(ast.NodeVisitor):
+        def visit_ClassDef(self, node):
+            bases = [get_name(b) for b in node.bases]
+            sig = "class " + node.name
+            if bases:
+                sig += "(" + ", ".join(bases) + ")"
+            sig += ": ..."
+            syms.append(sym({
+                "name": node.name, "kind": "class", "line": node.lineno,
+                "col": node.col_offset, "signature": sig,
+                "scope": ".".join(scope_stack) + "." + node.name,
+            }))
+            scope_stack.append(node.name)
+            self.generic_visit(node)
+            scope_stack.pop()
+
+        def visit_FunctionDef(self, node):
+            args = ", ".join(a.arg for a in node.args.args)
+            returns = get_name(node.returns) if node.returns is not None else ""
+            is_async = isinstance(node, ast.AsyncFunctionDef)
+            kind = "function"
+            prefix = "def "
+            for dec in node.decorator_list:
+                d = get_name(dec)
+                if d.endswith(".staticmethod"):
+                    kind = "staticmethod"
+                elif d.endswith(".classmethod"):
+                    kind = "classmethod"
+                elif d == "property":
+                    kind = "property"
+            if is_async:
+                kind = "async_" + kind
+            sig = f"{prefix}{node.name}({args})"
+            if returns:
+                sig += f" -> {returns}"
+            syms.append(sym({
+                "name": node.name, "kind": kind, "line": node.lineno,
+                "col": node.col_offset, "signature": sig,
+                "scope": ".".join(scope_stack) + "." + node.name,
+            }))
+
+        def visit_AsyncFunctionDef(self, node):
+            self.visit_FunctionDef(node)
+
+        def visit_Assign(self, node):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    tname = target.id
+                    if is_private(tname):
+                        continue
+                    kind = "const" if tname.isupper() else "var"
+                    col = target.col_offset if hasattr(target, "col_offset") else 0
+                    syms.append(sym({
+                        "name": tname, "kind": kind, "line": node.lineno, "col": col,
+                        "signature": f"{tname} = ...", "scope": ".".join(scope_stack),
+                    }))
+
+        def visit_AnnAssign(self, node):
+            if isinstance(node.target, ast.Name):
+                tname = node.target.id
+                if is_private(tname):
+                    return
+                kind = "const" if tname.isupper() else "var"
+                col = node.target.col_offset if hasattr(node.target, "col_offset") else 0
+                sig = f"{tname}: {get_name(node.annotation)}"
+                if node.value:
+                    sig += " = ..."
+                syms.append(sym({
+                    "name": tname, "kind": kind, "line": node.lineno, "col": col,
+                    "signature": sig, "scope": ".".join(scope_stack),
+                }))
+
+        def visit_Import(self, node):
+            # Parity with the single-file parser: imports are symbols too.
+            for alias in node.names:
+                name = alias.asname or alias.name
+                syms.append(sym({
+                    "name": name, "kind": "import", "line": node.lineno,
+                    "col": node.col_offset, "signature": f"import {alias.name}",
+                    "scope": ".".join(scope_stack),
+                }))
+
+        def visit_ImportFrom(self, node):
+            module = node.module or ""
+            for alias in node.names:
+                name = alias.asname or alias.name
+                syms.append(sym({
+                    "name": name, "kind": "import", "line": node.lineno,
+                    "col": node.col_offset, "signature": f"from {module} import {alias.name}",
+                    "scope": ".".join(scope_stack),
+                }))
+
+    Visitor().visit(tree)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call):
+            cname = leaf_name(node.func)
+            if cname:
+                refs.append({"toName": cname, "callType": "call", "line": node.lineno})
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                refs.append({
+                    "toName": alias.name.split(".")[-1], "callType": "import",
+                    "line": node.lineno, "module": alias.name,
+                })
+        elif isinstance(node, ast.ImportFrom):
+            module = ("." * (node.level or 0)) + (node.module or "")
+            for alias in node.names:
+                refs.append({
+                    "toName": alias.name, "callType": "import",
+                    "line": node.lineno, "module": module,
+                })
+        elif isinstance(node, ast.ClassDef):
+            for base in node.bases:
+                bname = leaf_name(base)
+                if bname:
+                    refs.append({"toName": bname, "callType": "inherit", "line": node.lineno})
+
+    result["symbols"] = syms
+    result["refs"] = refs
+    return result
+
+def main():
+    try:
+        inputs = json.loads(sys.stdin.read())
+    except Exception:
+        print(json.dumps({"version": 1, "results": []}))
+        return
+    results = []
+    for entry in inputs:
+        name = entry.get("file", "")
+        module_name = name.rsplit("/", 1)[-1].rsplit("\\\\", 1)[-1][:-3]
+        results.append(parse_one(name, entry.get("content", ""), module_name))
+    print(json.dumps({"version": 1, "results": results}))
+
+main()
+`;
+var _goBatchScriptPath = null;
+var _pyBatchScriptPath = null;
+async function ensureScriptPath(cached, prefix, fileName, script) {
+  if (cached) return { path: cached, wrote: false };
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+  const scriptPath = path.join(dir, fileName);
+  await fs.writeFile(scriptPath, script, { encoding: "utf8", flag: "wx" });
+  process.once("exit", () => {
+    try {
+      fsSync.rmSync(dir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  return { path: scriptPath, wrote: true };
+}
+function runToolchainChild(binary, args, stdinPayload, timeoutMs) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let stdout = "";
+    let proc;
+    try {
+      proc = spawn(binary, args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+    } catch {
+      resolve(null);
+      return;
+    }
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const timer = setTimeout(() => {
+      proc.kill("SIGKILL");
+      finish(null);
+    }, timeoutMs);
+    timer.unref?.();
+    proc.on("error", () => finish(null));
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr?.resume();
+    proc.stdin?.on("error", () => {
+    });
+    proc.stdin?.write(stdinPayload);
+    proc.stdin?.end();
+    proc.on("close", (code) => finish({ code, stdout }));
+  });
+}
+async function runGoBatch(files, goBinary) {
+  const out = /* @__PURE__ */ new Map();
+  if (files.length === 0) return out;
+  const { path: scriptPath } = await ensureScriptPath(
+    _goBatchScriptPath,
+    "ws-go-parse",
+    "batch.go",
+    GO_BATCH_SCRIPT
+  );
+  _goBatchScriptPath = scriptPath;
+  const payload = JSON.stringify(files.map((f) => ({ file: f.file, content: f.content })));
+  const result = await withSpawnGate(
+    () => runToolchainChild(
+      goBinary ?? resolveWin32Command("go"),
+      ["run", scriptPath],
+      payload,
+      batchTimeoutMs(files.length)
+    )
+  );
+  if (result?.code !== 0 || !result.stdout.trim()) return out;
+  for (const entry of parseParserBatchOutput(result.stdout, "go")) {
+    if (entry.error !== void 0) continue;
+    out.set(entry.file, {
+      file: entry.file,
+      lang: "go",
+      symbols: entry.symbols.map((s) => ({
+        id: 0,
+        lang: "go",
+        kind: s.kind,
+        name: s.name,
+        file: entry.file,
+        line: s.line,
+        col: s.col,
+        signature: s.signature ?? "",
+        docComment: "",
+        scope: s.scope ?? "",
+        text: `${s.name} ${s.signature ?? ""}`.trim()
+      })),
+      refs: entry.refs,
+      mtimeMs: Date.now()
+    });
+  }
+  return out;
+}
+async function runPyBatch(files, pythonBinary) {
+  const out = /* @__PURE__ */ new Map();
+  if (files.length === 0) return out;
+  const { path: scriptPath } = await ensureScriptPath(
+    _pyBatchScriptPath,
+    "ws-py-parse",
+    "batch.py",
+    PY_BATCH_SCRIPT
+  );
+  _pyBatchScriptPath = scriptPath;
+  const payload = JSON.stringify(files.map((f) => ({ file: f.file, content: f.content })));
+  const result = await withSpawnGate(
+    () => runToolchainChild(pythonBinary, [scriptPath], payload, batchTimeoutMs(files.length))
+  );
+  if (result?.code !== 0 || !result.stdout.trim()) return out;
+  for (const entry of parseParserBatchOutput(result.stdout, "py")) {
+    if (entry.error !== void 0) continue;
+    out.set(entry.file, {
+      file: entry.file,
+      lang: "py",
+      symbols: entry.symbols.map((s) => ({
+        id: 0,
+        lang: "py",
+        kind: s.kind,
+        name: s.name,
+        file: entry.file,
+        line: s.line,
+        col: s.col,
+        signature: s.signature ?? "",
+        docComment: "",
+        scope: s.scope ?? "",
+        text: `${s.name} ${s.signature ?? ""}`.trim()
+      })),
+      refs: entry.refs,
+      mtimeMs: Date.now()
+    });
+  }
+  return out;
+}
+
+// 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-RCTYKSVI.js");
+      return parseSymbols({ file, content, lang });
+    }
+    case "go": {
+      const { parseSymbols } = await import("./go-parser-JXYKJHRC.js");
+      return parseSymbols({ file, content, lang: "go" });
+    }
+    case "py": {
+      const { parseSymbols } = await import("./py-parser-IS4HKYMF.js");
+      return parseSymbols({ file, content, lang: "py" });
+    }
+    case "rs": {
+      const { parseSymbols } = await import("./rs-parser-XHUUO2KZ.js");
+      return parseSymbols({ file, content, lang: "rs" });
+    }
+    case "json": {
+      const { parseSymbols } = await import("./json-parser-IBHZ4BZC.js");
+      return parseSymbols({ file, content, lang: "json" });
+    }
+    case "yaml": {
+      const { parseSymbols } = await import("./yaml-parser-4SAXV3PL.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-AIERW3YI.js");
+        const parsed = await parseSymbols2({ file, content, lang });
+        if (parsed.symbols.length > 0) return parsed;
+      } catch {
+      }
+      const { parseSymbols } = await import("./generic-parser-VUXDIAOZ.js");
+      return parseSymbols({ file, content, lang });
+    }
+    default: {
+      const { parseSymbols } = await import("./generic-parser-VUXDIAOZ.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-IYK7XGDZ.js.map