@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-ZLTFLC25.js

@@ -0,0 +1,385 @@
+import {
+  parseGeneric
+} from "./chunk-A6BRWIXN.js";
+import {
+  parseParserOutput,
+  withSpawnGate
+} from "./chunk-UCYQTZ7F.js";
+import {
+  resolveWin32Command
+} from "./chunk-V43EQ6VR.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";
+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;
+    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 = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    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);
+      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-ZLTFLC25.js.map

package/dist/circuit-breaker.js

@@ -1,194 +1,6 @@
-// src/circuit-breaker.ts
-var DEFAULT_MAX_CONSECUTIVE_FAILURES = 5;
-var DEFAULT_SLOW_CALL_THRESHOLD_MS = 18e4;
-var DEFAULT_MAX_SLOW_CALLS = 3;
-var DEFAULT_WINDOW_MS = 6e4;
-var DEFAULT_MAX_CALLS_PER_WINDOW = 30;
-var DEFAULT_COOLDOWN_MS = 3e4;
-var CircuitBreaker = class {
-  maxConsecutiveFailures;
-  slowCallThresholdMs;
-  maxSlowCalls;
-  windowMs;
-  maxCallsPerWindow;
-  cooldownMs;
-  state = "closed";
-  consecutiveFailures = 0;
-  window = [];
-  lastFailureAt = null;
-  lastSlowAt = null;
-  /** Timestamp when the breaker was opened (for cooldown calculation). */
-  openedAt = null;
-  /**
-   * Master enable flag. When false the breaker is bypassed: `beforeCall`
-   * always returns true and `afterCall` records nothing. The class itself
-   * defaults to enabled (so the standalone unit tests exercise tripping); the
-   * ProcessRegistry flips this off until the user opts in via `/settings`.
-   */
-  enabled = true;
-  /**
-   * Fired (best-effort) when the breaker transitions into the `open` state.
-   * The registry uses this to arm its auto kill/reset countdown.
-   */
-  onTrip;
-  /**
-   * Fired (best-effort) when the breaker returns to `closed` after having been
-   * open/half-open. The registry uses this to cancel a pending kill/reset.
-   */
-  onReset;
-  constructor(config = {}) {
-    this.maxConsecutiveFailures = config.maxConsecutiveFailures ?? DEFAULT_MAX_CONSECUTIVE_FAILURES;
-    this.slowCallThresholdMs = config.slowCallThresholdMs ?? DEFAULT_SLOW_CALL_THRESHOLD_MS;
-    this.maxSlowCalls = config.maxSlowCalls ?? DEFAULT_MAX_SLOW_CALLS;
-    this.windowMs = config.windowMs ?? DEFAULT_WINDOW_MS;
-    this.maxCallsPerWindow = config.maxCallsPerWindow ?? DEFAULT_MAX_CALLS_PER_WINDOW;
-    this.cooldownMs = config.cooldownMs ?? DEFAULT_COOLDOWN_MS;
-  }
-  /** Toggle the master enable. Disabling resets to a clean `closed` state. */
-  setEnabled(enabled) {
-    if (this.enabled === enabled) return;
-    this.enabled = enabled;
-    if (!enabled) this._reset();
-  }
-  get isEnabled() {
-    return this.enabled;
-  }
-  /**
-   * Returns true if the circuit allows a new call to proceed.
-   * When false, callers should abort the tool call and return a
-   * circuit-breaker error instead of spawning a process.
-   */
-  get canProceed() {
-    if (!this.enabled) return true;
-    this._checkStateTransition();
-    return this.state !== "open";
-  }
-  /**
-   * Snapshot of the current breaker state for observability (`/kill`).
-   */
-  snapshot() {
-    this._checkStateTransition();
-    const now = Date.now();
-    let cooldownRemaining = null;
-    if (this.openedAt !== null && this.state === "open") {
-      const elapsed = now - this.openedAt;
-      cooldownRemaining = Math.max(0, this.cooldownMs - elapsed);
-    }
-    return {
-      state: this.state,
-      consecutiveFailures: this.consecutiveFailures,
-      slowCallsInWindow: this.window.filter((c) => c.slow).length,
-      callsInWindow: this.window.length,
-      windowMs: this.windowMs,
-      cooldownRemainingMs: cooldownRemaining,
-      lastFailureAt: this.lastFailureAt,
-      lastSlowAt: this.lastSlowAt
-    };
-  }
-  /**
-   * Call this BEFORE spawning a bash/exec process.
-   * Returns true if the call is allowed; false if the breaker is open.
-   * When false, callers MUST NOT spawn a process.
-   *
-   * @param bypass - If true, skip the circuit breaker check entirely.
-   *                  Use for background/fire-and-forget processes that should
-   *                  not affect breaker state.
-   */
-  beforeCall(bypass = false) {
-    if (bypass || !this.enabled) return true;
-    this._checkStateTransition();
-    if (this.state === "open") return false;
-    return true;
-  }
-  /**
-   * Call this AFTER a bash/exec process finishes (success or failure).
-   * `durationMs` is the wall-clock time the process ran.
-   * `failed` is true when the process returned a non-zero exit code or
-   * threw an exception before spawning.
-   *
-   * @param bypass - If true, do not update breaker state.
-   *                  Use for background/fire-and-forget processes.
-   */
-  afterCall(durationMs, failed, bypass = false) {
-    if (bypass || !this.enabled) return;
-    const now = Date.now();
-    if (this.state === "half-open") {
-      if (failed) {
-        this._trip();
-        return;
-      }
-      this._reset();
-      return;
-    }
-    this._pruneWindow(now);
-    const slow = durationMs >= this.slowCallThresholdMs;
-    this.window.push({ at: now, failed, slow });
-    if (failed) {
-      this.consecutiveFailures++;
-      this.lastFailureAt = now;
-      if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
-        this._trip();
-      }
-      return;
-    }
-    this.consecutiveFailures = 0;
-    if (slow) {
-      this.lastSlowAt = now;
-      const slowCount = this.window.filter((c) => c.slow).length;
-      if (slowCount >= this.maxSlowCalls) {
-        this._trip();
-      }
-    }
-    const callCount = this.window.length;
-    if (callCount >= this.maxCallsPerWindow) {
-      this._trip();
-    }
-  }
-  /** Force the breaker open. Used by /kill force and Ctrl+C. */
-  forceOpen() {
-    this._trip();
-  }
-  /** Force a reset to closed. Used by tests and /kill reset. */
-  forceReset() {
-    this._reset();
-  }
-  _trip() {
-    if (this.state === "open") return;
-    this.state = "open";
-    this.openedAt = Date.now();
-    this.window = [];
-    try {
-      this.onTrip?.();
-    } catch {
-    }
-  }
-  _reset() {
-    const wasRecovering = this.state !== "closed";
-    this.state = "closed";
-    this.consecutiveFailures = 0;
-    this.window = [];
-    this.openedAt = null;
-    if (wasRecovering) {
-      try {
-        this.onReset?.();
-      } catch {
-      }
-    }
-  }
-  /** Transition from open → half-open when cooldown elapses. */
-  _checkStateTransition() {
-    if (this.state !== "open" || this.openedAt === null) return;
-    const elapsed = Date.now() - this.openedAt;
-    if (elapsed >= this.cooldownMs) {
-      this.state = "half-open";
-      this.openedAt = null;
-    }
-  }
-  _pruneWindow(now) {
-    const cutoff = now - this.windowMs;
-    this.window = this.window.filter((c) => c.at >= cutoff);
-  }
-};
+import {
+  CircuitBreaker
+} from "./chunk-HFXSNKCV.js";
 export {
   CircuitBreaker
 };

package/dist/codebase-index/ast-invariant-engine.d.ts

@@ -35,26 +35,26 @@ export interface InvariantEvaluationResult {
         durationMs: number;
     };
 }
-export interface ParameterContract {
+interface ParameterContract {
     name: string;
     isOptional: boolean;
     hasDefault: boolean;
     isRest: boolean;
     type?: string | undefined;
 }
-export interface FunctionContract {
+interface FunctionContract {
     name: string;
     isExported: boolean;
     params: ParameterContract[];
     returnType?: string | undefined;
 }
-export interface InterfacePropertyContract {
+interface InterfacePropertyContract {
     name: string;
     isOptional: boolean;
     hasDefault?: boolean | undefined;
     type?: string | undefined;
 }
-export interface InterfaceContract {
+interface InterfaceContract {
     name: string;
     isExported: boolean;
     properties: InterfacePropertyContract[];
@@ -99,4 +99,5 @@ export declare class PolyglotInvariantEngine {
 }
 /** Singleton instance ready for use across WrongStack */
 export declare const polyglotInvariantEngine: PolyglotInvariantEngine;
+export {};
 //# sourceMappingURL=ast-invariant-engine.d.ts.map

package/dist/codebase-index/binary-frame.d.ts

@@ -25,8 +25,6 @@
  * of a different version (the buildId changes when the compiled artifact
  * changes), so there is no protocol ambiguity in practice.
  */
-/** Magic byte that prefixes every binary frame. 'W' for WrongStack. */
-export declare const BINARY_FRAME_MAGIC = 87;
 /**
  * Hard cap on one binary frame's declared payload length for the CLIENT
  * reader (project-server-client.ts). A malformed or hostile peer could

package/dist/codebase-index/bm25.d.ts

@@ -17,7 +17,7 @@ interface Bm25Doc {
  * conventionally split words in snake_case identifiers).
  */
 export declare function tokenise(text: string): string[];
-export interface IndexableDoc {
+interface IndexableDoc {
     id: number;
     text: string;
 }

package/dist/codebase-index/circuit-breaker.d.ts

@@ -52,7 +52,7 @@ export declare class IndexTimeoutError extends Error {
 export declare class LockError extends Error {
     readonly name = "LockError";
 }
-export interface CircuitBreakerOptions {
+interface CircuitBreakerOptions {
     /** Consecutive failures before the circuit opens. Default: 3. */
     failureThreshold?: number | undefined;
     /** How long an open circuit rejects requests before allowing a probe. Default: 60s. */
@@ -91,4 +91,5 @@ export declare class IndexCircuitBreaker {
 export declare const indexCircuitBreaker: IndexCircuitBreaker;
 /** Reset the shared breaker — used by `/codebase-reindex` and tests. */
 export declare function resetIndexCircuitBreaker(): void;
+export {};
 //# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/codebase-index/codebase-ast-replace-tool.d.ts

@@ -10,9 +10,9 @@
  */
 import type { Tool } from '@wrongstack/core/types';
 import { type MutateSymbolOptions } from './ast-symbol-mutator.js';
-export interface CodebaseAstReplaceInput extends MutateSymbolOptions {
+interface CodebaseAstReplaceInput extends MutateSymbolOptions {
 }
-export interface CodebaseAstReplaceOutput {
+interface CodebaseAstReplaceOutput {
     status: 'ok' | 'error';
     file: string;
     symbol: string;
@@ -28,4 +28,5 @@ export interface CodebaseAstReplaceOutput {
     error?: string | undefined;
 }
 export declare const codebaseAstReplaceTool: Tool<CodebaseAstReplaceInput, CodebaseAstReplaceOutput>;
+export {};
 //# sourceMappingURL=codebase-ast-replace-tool.d.ts.map

package/dist/codebase-index/codebase-impact-analysis-tool.d.ts

@@ -8,7 +8,7 @@
  * })
  */
 import type { Tool } from '@wrongstack/core/types';
-export interface ImpactAnalysisInput {
+interface ImpactAnalysisInput {
     /** The symbol name (function, method, class, interface, type) to analyze. */
     symbol: string;
     /** Optional file path to disambiguate when multiple symbols share a name. */
@@ -16,7 +16,7 @@ export interface ImpactAnalysisInput {
     /** Whether to traverse transitive callers (callers of callers). Defaults to true. */
     transitive?: boolean | undefined;
 }
-export interface ImpactCallSite {
+interface ImpactCallSite {
     file: string;
     line: number;
     callerName: string;
@@ -24,7 +24,7 @@ export interface ImpactCallSite {
     callType: string;
     isTest: boolean;
 }
-export interface ImpactAnalysisOutput {
+interface ImpactAnalysisOutput {
     status: 'ok' | 'error';
     symbol: string;
     riskLevel: 'low' | 'medium' | 'high';
@@ -39,4 +39,5 @@ export interface ImpactAnalysisOutput {
     error?: string | undefined;
 }
 export declare const codebaseImpactAnalysisTool: Tool<ImpactAnalysisInput, ImpactAnalysisOutput>;
+export {};
 //# sourceMappingURL=codebase-impact-analysis-tool.d.ts.map