@wrongstack/tools 1.0.10 → 1.0.12

package/dist/chunk-4CE3RKEP.js

@@ -1,390 +0,0 @@
-import {
-  parseGeneric
-} from "./chunk-SKRMUHTU.js";
-import {
-  parseParserOutput,
-  recordParserSubprocess,
-  withSpawnGate
-} from "./chunk-ZKC5UNGD.js";
-import {
-  resolveWin32Command
-} from "./chunk-XZLVJD56.js";
-
-// src/codebase-index/py-parser.ts
-import { spawn } from "node:child_process";
-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";
-async function parseSymbols(opts) {
-  const { file, content, lang } = opts;
-  try {
-    const native = await withSpawnGate(() => syncPyParse(file, content, lang));
-    if (native !== null) return native;
-  } catch {
-  }
-  return parseGeneric({ file, content, lang: lang === "py" ? "py" : lang });
-}
-var PY_PARSE_SCRIPT = `import ast, json, sys, os
-
-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 get_decorators(node):
-    decs = []
-    for dec in node.decorator_list:
-        decs.append(get_name(dec))
-    return decs
-
-def get_bases(node):
-    bases = []
-    for base in node.bases:
-        bases.append(get_name(base))
-    return bases
-
-def get_args(args):
-    parts = []
-    for arg in args.args:
-        parts.append(arg.arg)
-    return ", ".join(parts)
-
-def get_returns(node):
-    if node.returns is None:
-        return ""
-    return get_name(node.returns)
-
-class Sym:
-    def __init__(self, name, kind, line, col, signature, scope):
-        self.name = name
-        self.kind = kind
-        self.line = line
-        self.col = col
-        self.signature = signature
-        self.scope = scope
-    def to_dict(self):
-        return {
-            "name": self.name,
-            "kind": self.kind,
-            "line": self.line,
-            "col": self.col,
-            "signature": self.signature,
-            "scope": self.scope,
-        }
-
-def is_private(name):
-    return name.startswith("__") and not name.endswith("__")
-
-def leaf_name(node):
-    # Declared name of the callee: \`join\` of \`os.path.join\`. Matches how the
-    # TypeScript and Go extractors record call refs, so resolution behaves the
-    # same across languages.
-    if isinstance(node, ast.Attribute):
-        return node.attr
-    if isinstance(node, ast.Name):
-        return node.id
-    return get_name(node).split(".")[-1]
-
-syms = []
-refs = []
-errors = []
-
-try:
-    source = sys.stdin.read()
-    tree = ast.parse(source, filename=sys.argv[1])
-except Exception as e:
-    errors.append(str(e))
-    print(json.dumps({"symbols": [], "refs": []}))
-    sys.exit(0)
-
-# Module-level scope
-module_scope = os.path.basename(sys.argv[1])[:-3]  # strip .py
-
-class ModuleVisitor(ast.NodeVisitor):
-    def __init__(self):
-        self.scope_stack = [module_scope]
-
-    def visit_ClassDef(self, node):
-        bases = get_bases(node)
-        decs = get_decorators(node)
-        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(self.scope_stack) + "." + node.name,
-        ))
-        self.scope_stack.append(node.name)
-        self.generic_visit(node)
-        self.scope_stack.pop()
-
-    def visit_FunctionDef(self, node):
-        decs = get_decorators(node)
-        args = get_args(node.args)
-        returns = get_returns(node)
-        is_async = isinstance(node, ast.AsyncFunctionDef)
-
-        kind = "function"
-        prefix = "def "
-        if decs:
-            for d in decs:
-                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}"
-        scope = ".".join(self.scope_stack) + "." + node.name
-
-        syms.append(Sym(
-            name=node.name,
-            kind=kind,
-            line=node.lineno,
-            col=node.col_offset,
-            signature=sig,
-            scope=scope,
-        ))
-        # Don't descend into function bodies to avoid local symbols
-        # self.generic_visit(node)
-
-    def visit_AsyncFunctionDef(self, node):
-        # Treat as function
-        self.visit_FunctionDef(node)
-
-    def visit_Assign(self, node):
-        for target in node.targets:
-            if isinstance(target, ast.Name):
-                name = target.id
-                if is_private(name):
-                    continue
-                # Infer constness from UPPER_CASE naming
-                kind = "const" if name.isupper() else "var"
-                col = target.col_offset if hasattr(target, 'col_offset') else 0
-                syms.append(Sym(
-                    name=name,
-                    kind=kind,
-                    line=node.lineno,
-                    col=col,
-                    signature=f"{name} = ...",
-                    scope=".".join(self.scope_stack),
-                ))
-
-    def visit_AnnAssign(self, node):
-        if isinstance(node.target, ast.Name):
-            name = node.target.id
-            if is_private(name):
-                return
-            kind = "const" if name.isupper() else "var"
-            col = node.target.col_offset if hasattr(node.target, 'col_offset') else 0
-            sig = f"{name}: {get_name(node.annotation)}"
-            if node.value:
-                sig += " = ..."
-            syms.append(Sym(
-                name=name,
-                kind=kind,
-                line=node.lineno,
-                col=col,
-                signature=sig,
-                scope=".".join(self.scope_stack),
-            ))
-
-    def visit_Import(self, node):
-        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(self.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(self.scope_stack),
-            ))
-
-visitor = ModuleVisitor()
-visitor.visit(tree)
-
-# Refs need a separate full walk: ModuleVisitor deliberately does not descend
-# into function bodies (it would index locals as symbols), but that is exactly
-# where the calls are.
-for node in ast.walk(tree):
-    if isinstance(node, ast.Call):
-        name = leaf_name(node.func)
-        if name:
-            refs.append({"toName": name, "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):
-        # PEP 328: node.level is the number of leading dots. Preserving them is
-        # what lets the resolver walk up from the importing file's package \u2014
-        # dropping them made \`from .foo import X\` indistinguishable from an
-        # absolute \`foo\`.
-        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:
-            name = leaf_name(base)
-            if name:
-                refs.append({"toName": name, "callType": "inherit", "line": node.lineno})
-
-print(json.dumps({"symbols": [s.to_dict() for s in syms], "refs": refs}))
-`;
-async function resolvePython() {
-  const candidates = process.platform === "win32" ? ["python3", "python", "py"] : ["python3", "python"];
-  for (const name of candidates) {
-    const resolved = resolveWin32Command(name);
-    if (!await commandIsAvailable(resolved)) continue;
-    return resolved;
-  }
-  return null;
-}
-function commandIsAvailable(command) {
-  return new Promise((resolve) => {
-    let settled = false;
-    const proc = spawn(command, ["--version"], {
-      stdio: "ignore",
-      windowsHide: true
-    });
-    const finish = (available) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(available);
-    };
-    const timer = setTimeout(() => {
-      proc.kill("SIGKILL");
-      finish(false);
-    }, 5e3);
-    timer.unref?.();
-    proc.once("error", () => finish(false));
-    proc.once("close", (code) => finish(code === 0));
-  });
-}
-function spawnPyParser(pyBinary, scriptPath, filePath, content) {
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    recordParserSubprocess();
-    const proc = spawn(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 = "";
-    const stdoutDecoder = new StringDecoder("utf8");
-    proc.stdout?.on("data", (chunk) => {
-      stdout += stdoutDecoder.write(chunk);
-    });
-    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);
-      stdout += stdoutDecoder.end();
-      resolve({ code, stdout });
-    });
-  });
-}
-var _cachedScriptPath = null;
-var cachedPyBinary;
-function resolvePythonBinary() {
-  cachedPyBinary ??= resolvePython();
-  return cachedPyBinary;
-}
-async function syncPyParse(filePath, content, lang) {
-  try {
-    if (!_cachedScriptPath) {
-      const tmpDir = path.join(os.tmpdir(), "ws-py-parse");
-      await fs.mkdir(tmpDir, { recursive: true });
-      _cachedScriptPath = path.join(tmpDir, "parse.py");
-      await fs.writeFile(_cachedScriptPath, PY_PARSE_SCRIPT, "utf8");
-    }
-    cachedPyBinary ??= resolvePython();
-    const pyBinary = await cachedPyBinary;
-    if (!pyBinary) return null;
-    const { code, stdout } = await spawnPyParser(pyBinary, _cachedScriptPath, filePath, content);
-    if (code !== 0 || !stdout.trim()) {
-      return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
-    }
-    const { symbols: raw, refs } = parseParserOutput(stdout, lang);
-    const symbols = raw.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 null;
-  }
-}
-
-export {
-  parseSymbols,
-  resolvePythonBinary
-};
-//# sourceMappingURL=chunk-4CE3RKEP.js.map