@wrongstack/tools 1.0.11 → 1.0.12

package/dist/chunk-KHUCKLOR.js

@@ -1,899 +0,0 @@
-import {
-  resolvePythonBinary
-} from "./chunk-4CE3RKEP.js";
-import {
-  parseParserBatchOutput,
-  recordParserSubprocess,
-  withSpawnGate
-} from "./chunk-ZKC5UNGD.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};  → 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";
-import { StringDecoder } from "node:string_decoder";
-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 {
-      recordParserSubprocess();
-      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));
-    const stdoutDecoder = new StringDecoder("utf8");
-    proc.stdout?.on("data", (chunk) => {
-      stdout += stdoutDecoder.write(chunk);
-    });
-    proc.stderr?.resume();
-    proc.stdin?.on("error", () => {
-    });
-    proc.stdin?.write(stdinPayload);
-    proc.stdin?.end();
-    proc.on("close", (code) => {
-      stdout += stdoutDecoder.end();
-      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-7W26YB26.js");
-      return parseSymbols({ file, content, lang });
-    }
-    case "go": {
-      const { parseSymbols } = await import("./go-parser-Z4H6SR3R.js");
-      return parseSymbols({ file, content, lang: "go" });
-    }
-    case "py": {
-      const { parseSymbols } = await import("./py-parser-4PFZYAJ7.js");
-      return parseSymbols({ file, content, lang: "py" });
-    }
-    case "rs": {
-      const { parseSymbols } = await import("./rs-parser-GIWPUA3T.js");
-      return parseSymbols({ file, content, lang: "rs" });
-    }
-    case "json": {
-      const { parseSymbols } = await import("./json-parser-IJD77VL4.js");
-      return parseSymbols({ file, content, lang: "json" });
-    }
-    case "yaml": {
-      const { parseSymbols } = await import("./yaml-parser-DFBC5FWH.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-GILYQLS4.js");
-        const parsed = await parseSymbols2({ file, content, lang });
-        if (parsed.symbols.length > 0) return parsed;
-      } catch {
-      }
-      const { parseSymbols } = await import("./generic-parser-N2PLGBC2.js");
-      return parseSymbols({ file, content, lang });
-    }
-    default: {
-      const { parseSymbols } = await import("./generic-parser-N2PLGBC2.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-KHUCKLOR.js.map