@wrongstack/tools 1.0.10 → 1.0.12

package/dist/chunk-ZKC5UNGD.js

@@ -1,167 +0,0 @@
-// src/codebase-index/parser-output.ts
-var CALL_TYPES = /* @__PURE__ */ new Set([
-  "call",
-  "type_ref",
-  "inherit",
-  "implement",
-  "import"
-]);
-function coerceSymbols(value) {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((entry) => {
-    const candidate = entry;
-    if (typeof candidate.name !== "string" || typeof candidate.kind !== "string") return [];
-    return [
-      {
-        name: candidate.name,
-        kind: candidate.kind,
-        line: typeof candidate.line === "number" ? candidate.line : 1,
-        col: typeof candidate.col === "number" ? candidate.col : 0,
-        signature: typeof candidate.signature === "string" ? candidate.signature : "",
-        scope: typeof candidate.scope === "string" ? candidate.scope : ""
-      }
-    ];
-  });
-}
-function coerceRefs(value, lang) {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((entry) => {
-    const candidate = entry;
-    if (typeof candidate.toName !== "string" || !candidate.toName) return [];
-    if (typeof candidate.callType !== "string" || !CALL_TYPES.has(candidate.callType)) return [];
-    const module = typeof candidate.module === "string" && candidate.module ? candidate.module : void 0;
-    return [
-      {
-        fromId: 0,
-        toName: candidate.toName,
-        callType: candidate.callType,
-        line: typeof candidate.line === "number" ? candidate.line : 1,
-        lang,
-        module
-      }
-    ];
-  });
-}
-function parseParserOutput(stdout, lang) {
-  const trimmed = stdout.trim();
-  if (!trimmed) return { symbols: [], refs: [] };
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    return { symbols: [], refs: [] };
-  }
-  if (Array.isArray(parsed)) return { symbols: coerceSymbols(parsed), refs: [] };
-  const record = parsed;
-  return {
-    symbols: coerceSymbols(record.symbols),
-    refs: dedupeRefs(coerceRefs(record.refs, lang))
-  };
-}
-function parseParserBatchOutput(stdout, lang) {
-  const trimmed = stdout.trim();
-  if (!trimmed) return [];
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    return [];
-  }
-  if (!parsed || typeof parsed !== "object") return [];
-  const results = parsed.results;
-  if (!Array.isArray(results)) return [];
-  return results.flatMap((entry) => {
-    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return [];
-    const candidate = entry;
-    if (typeof candidate.file !== "string" || !candidate.file) return [];
-    return [
-      {
-        file: candidate.file,
-        error: typeof candidate.error === "string" && candidate.error ? candidate.error : void 0,
-        symbols: coerceSymbols(candidate.symbols),
-        refs: dedupeRefs(coerceRefs(candidate.refs, lang))
-      }
-    ];
-  });
-}
-function dedupeRefs(refs) {
-  const seen = /* @__PURE__ */ new Set();
-  return refs.filter((ref) => {
-    const key = `${ref.toName}:${ref.callType}:${ref.line}:${ref.module ?? ""}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-}
-
-// src/codebase-index/perf-metrics.ts
-var counters = {
-  filesystemBytesRead: 0,
-  filesystemReadCount: 0,
-  parserGateWaitMs: 0,
-  parserGateCalls: 0,
-  parserSubprocessCount: 0,
-  ipcPendingPeak: 0,
-  writeQueueWaitMs: 0,
-  writeQueueCalls: 0
-};
-function resetCodebaseIndexPerfMetrics() {
-  for (const key of Object.keys(counters)) {
-    counters[key] = 0;
-  }
-}
-function getCodebaseIndexPerfSnapshot() {
-  return { ...counters };
-}
-function recordFilesystemRead(bytes) {
-  counters.filesystemBytesRead += Math.max(0, bytes);
-  counters.filesystemReadCount++;
-}
-function recordParserGateWait(waitMs) {
-  counters.parserGateWaitMs += Math.max(0, waitMs);
-  counters.parserGateCalls++;
-}
-function recordParserSubprocess() {
-  counters.parserSubprocessCount++;
-}
-function recordIpcPending(depth) {
-  counters.ipcPendingPeak = Math.max(counters.ipcPendingPeak, depth);
-}
-function recordWriteQueueWait(waitMs) {
-  counters.writeQueueWaitMs += Math.max(0, waitMs);
-  counters.writeQueueCalls++;
-}
-
-// src/codebase-index/spawn-gate.ts
-var chain = Promise.resolve();
-function withSpawnGate(fn) {
-  const queuedAt = performance.now();
-  const run = chain.then(
-    () => {
-      recordParserGateWait(performance.now() - queuedAt);
-      return fn();
-    },
-    () => {
-      recordParserGateWait(performance.now() - queuedAt);
-      return fn();
-    }
-  );
-  chain = run.then(
-    () => void 0,
-    () => void 0
-  );
-  return run;
-}
-
-export {
-  parseParserOutput,
-  parseParserBatchOutput,
-  resetCodebaseIndexPerfMetrics,
-  getCodebaseIndexPerfSnapshot,
-  recordFilesystemRead,
-  recordParserSubprocess,
-  recordIpcPending,
-  recordWriteQueueWait,
-  withSpawnGate
-};
-//# sourceMappingURL=chunk-ZKC5UNGD.js.map

package/dist/go-parser-Z4H6SR3R.js

@@ -1,474 +0,0 @@
-import {
-  parseParserOutput,
-  recordParserSubprocess,
-  withSpawnGate
-} from "./chunk-ZKC5UNGD.js";
-import {
-  detectLang
-} from "./chunk-YOHO4DVT.js";
-import {
-  resolveWin32Command
-} from "./chunk-XZLVJD56.js";
-
-// src/codebase-index/go-parser.ts
-import { spawn } from "node:child_process";
-import * as os from "node:os";
-import * as path from "node:path";
-import * as fs from "node:fs/promises";
-import { StringDecoder } from "node:string_decoder";
-async function parseSymbols(opts) {
-  const { file, content, lang } = opts;
-  try {
-    const parsed = await withSpawnGate(() => syncGoParse(file, content, lang));
-    if (parsed.symbols.length > 0) {
-      return parsed;
-    }
-    const fallback = fallbackParse(file, content, lang);
-    return parsed.refs?.length ? { ...fallback, refs: parsed.refs } : fallback;
-  } catch {
-    return fallbackParse(file, content, lang);
-  }
-}
-function fallbackParse(filePath, content, lang) {
-  if (!/^\s*package\s+[A-Za-z_]\w*/m.test(content) || hasUnbalancedDelimiters(content)) {
-    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-  }
-  const symbols = [];
-  const packageName = content.match(/^\s*package\s+([A-Za-z_]\w*)/m)?.[1] ?? "";
-  const lines = content.split(/\r?\n/);
-  for (const [idx, line] of lines.entries()) {
-    const trimmed = line.trimStart();
-    const col = line.length - trimmed.length;
-    const fn = /^func\s+(?:\([^)]*\)\s*)?([A-Za-z_]\w*)\s*\(/.exec(trimmed);
-    if (fn?.[1]) {
-      addFallbackSymbol(symbols, {
-        filePath,
-        lang,
-        kind: trimmed.startsWith("func (") ? "method" : "function",
-        name: fn[1],
-        line: idx + 1,
-        col,
-        signature: trimmed,
-        scope: packageName ? `${packageName}.${fn[1]}` : fn[1]
-      });
-      continue;
-    }
-    const typeDecl = /^type\s+([A-Za-z_]\w*)\b/.exec(trimmed);
-    if (typeDecl?.[1]) {
-      addFallbackSymbol(symbols, {
-        filePath,
-        lang,
-        kind: "type",
-        name: typeDecl[1],
-        line: idx + 1,
-        col,
-        signature: trimmed,
-        scope: packageName
-      });
-      continue;
-    }
-    const valueDecl = /^(const|var)\s+([A-Za-z_]\w*)\b/.exec(trimmed);
-    if (valueDecl?.[1] && valueDecl[2]) {
-      addFallbackSymbol(symbols, {
-        filePath,
-        lang,
-        kind: valueDecl[1],
-        name: valueDecl[2],
-        line: idx + 1,
-        col,
-        signature: trimmed,
-        scope: packageName
-      });
-    }
-  }
-  return { file: filePath, lang, symbols, mtimeMs: Date.now() };
-}
-function addFallbackSymbol(symbols, opts) {
-  symbols.push({
-    id: 0,
-    lang: opts.lang,
-    kind: opts.kind,
-    name: opts.name,
-    file: opts.filePath,
-    line: opts.line,
-    col: opts.col,
-    signature: opts.signature,
-    docComment: "",
-    scope: opts.scope,
-    text: `${opts.name} ${opts.signature}`.trim()
-  });
-}
-function hasUnbalancedDelimiters(content) {
-  const pairs = { "(": ")", "[": "]", "{": "}" };
-  const closers = new Set(Object.values(pairs));
-  const stack = [];
-  for (const ch of content) {
-    if (pairs[ch]) {
-      stack.push(pairs[ch]);
-    } else if (closers.has(ch) && stack.pop() !== ch) {
-      return true;
-    }
-  }
-  return stack.length > 0;
-}
-var GO_PARSE_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"\`
-}
-
-// Ref is a cross-reference emitted alongside the symbols, so one \`go run\`
-// yields both. Module is the import path for CallType "import", else empty.
-type Ref struct {
-	ToName   string \`json:"toName"\`
-	CallType string \`json:"callType"\`
-	Line     int    \`json:"line"\`
-	Module   string \`json:"module"\`
-}
-
-type Result struct {
-	Symbols []Sym \`json:"symbols"\`
-	Refs    []Ref \`json:"refs"\`
-}
-
-func emptyResult() string {
-	return "{\\"symbols\\":[],\\"refs\\":[]}"
-}
-
-func main() {
-	src, err := io.ReadAll(os.Stdin)
-	if err != nil {
-		fmt.Print(emptyResult())
-		return
-	}
-	fset := token.NewFileSet()
-	node, err := parser.ParseFile(fset, "src.go", src, 0)
-	if err != nil {
-		fmt.Print(emptyResult())
-		return
-	}
-
-	var syms []Sym
-
-	// Package-level scope
-	pkgScope := node.Name.Name
-
-	// Collect all top-level declarations
-	for _, decl := range node.Decls {
-		switch d := decl.(type) {
-		case *ast.FuncDecl:
-			name := d.Name.Name
-			kind := "function"
-			scope := pkgScope
-			if d.Recv != nil && len(d.Recv.List) > 0 {
-				scope = pkgScope + "." + recvTypeName(d.Recv.List[0].Type) + "." + name
-				kind = "method"
-			} else {
-				scope = pkgScope + "." + name
-			}
-			pos := fset.Position(d.Pos())
-			sig := formatFuncSig(d)
-			syms = append(syms, Sym{Name: name, Kind: kind, Line: pos.Line, Col: pos.Column - 1, Signature: sig, Scope: scope})
-
-		case *ast.GenDecl:
-			for _, spec := range d.Specs {
-				switch s := spec.(type) {
-				case *ast.TypeSpec:
-					name := s.Name.Name
-					pos := fset.Position(s.Pos())
-					sig := "type " + name
-					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)
-					}
-					syms = append(syms, Sym{Name: name, Kind: "type", Line: pos.Line, Col: pos.Column - 1, Signature: sig, Scope: pkgScope})
-
-				case *ast.ValueSpec:
-					for _, n := range s.Names {
-						name := n.Name
-						pos := fset.Position(n.Pos())
-						kind := "var"
-						if d.Tok == token.CONST {
-							kind = "const"
-						}
-						sig := kind + " " + name
-						if s.Type != nil {
-							sig += " " + formatType(s.Type)
-						}
-						syms = append(syms, Sym{Name: name, Kind: kind, Line: pos.Line, Col: pos.Column - 1, Signature: sig, Scope: pkgScope})
-					}
-				}
-			}
-		}
-	}
-
-	refs := []Ref{}
-	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:
-				refs = append(refs, Ref{ToName: fun.Name, CallType: "call", Line: line})
-			case *ast.SelectorExpr:
-				// Record the selected name (\`Join\` of \`filepath.Join\`): it is the
-				// declared symbol name, so it resolves the same way the TypeScript
-				// and Python extractors' call refs do.
-				refs = append(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
-					// A Go import names a package, not a symbol; the package's
-					// last path segment is the name it is referenced by.
-					name := importPath
-					if idx := strings.LastIndex(importPath, "/"); idx >= 0 {
-						name = importPath[idx+1:]
-					}
-					refs = append(refs, Ref{ToName: name, CallType: "import", Line: line, Module: importPath})
-				}
-			}
-		}
-		return true
-	})
-
-	if syms == nil {
-		syms = []Sym{}
-	}
-	data, err := json.Marshal(Result{Symbols: syms, Refs: refs})
-	if err != nil {
-		fmt.Print(emptyResult())
-		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:
-		// Generic instantiation with one type arg, e.g. Logger[int].
-		return formatType(v.X) + "[" + formatType(v.Index) + "]"
-	case *ast.IndexListExpr:
-		// Generic instantiation with multiple type args, e.g. Map[K, V].
-		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 _cachedGoScriptPath = null;
-async function syncGoParse(filePath, content, lang) {
-  try {
-    let scriptPath = _cachedGoScriptPath;
-    if (!scriptPath) {
-      const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "ws-go-parse-"));
-      scriptPath = path.join(tmpDir, "parse.go");
-      await fs.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
-      _cachedGoScriptPath = scriptPath;
-    }
-    const goBinary = resolveWin32Command("go");
-    const goResult = await new Promise(
-      (resolve, reject) => {
-        let settled = false;
-        recordParserSubprocess();
-        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 = "";
-        const stdoutDecoder = new StringDecoder("utf8");
-        proc.stdout?.on("data", (chunk) => {
-          stdout2 += stdoutDecoder.write(chunk);
-        });
-        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);
-        timer.unref?.();
-        proc.on("close", (code2) => {
-          if (settled) return;
-          settled = true;
-          clearTimeout(timer);
-          stdout2 += stdoutDecoder.end();
-          resolve({ code: code2, stdout: stdout2 });
-        });
-      }
-    );
-    const { code, stdout } = goResult;
-    if (code !== 0 || !stdout.trim()) {
-      return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-    }
-    const { symbols: rawSymbols, refs } = parseParserOutput(stdout, lang);
-    const symbols = rawSymbols.map((s) => ({
-      id: 0,
-      lang,
-      kind: s.kind,
-      name: s.name,
-      file: filePath,
-      line: s.line,
-      col: s.col,
-      signature: s.signature ?? "",
-      docComment: "",
-      scope: s.scope ?? "",
-      text: `${s.name} ${s.signature ?? ""}`.trim()
-    }));
-    return { file: filePath, lang, symbols, refs, mtimeMs: Date.now() };
-  } catch {
-    return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-  }
-}
-export {
-  detectLang,
-  parseSymbols
-};
-//# sourceMappingURL=go-parser-Z4H6SR3R.js.map