@wrongstack/tools 0.313.0 → 0.313.1

package/dist/chunk-42AKKX7O.js

@@ -0,0 +1,385 @@
+import {
+  parseGeneric
+} from "./chunk-A6BRWIXN.js";
+import {
+  parseParserOutput,
+  withSpawnGate
+} from "./chunk-42SKEETB.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-42AKKX7O.js.map

package/dist/chunk-42SKEETB.js

@@ -0,0 +1,113 @@
+// 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/spawn-gate.ts
+var chain = Promise.resolve();
+function withSpawnGate(fn) {
+  const run = chain.then(fn, fn);
+  chain = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+
+export {
+  parseParserOutput,
+  parseParserBatchOutput,
+  withSpawnGate
+};
+//# sourceMappingURL=chunk-42SKEETB.js.map

package/dist/chunk-4BHUSMNL.js

@@ -0,0 +1,104 @@
+// src/mode.ts
+function modeFamily(mode) {
+  if (mode.tags?.includes("lite")) return "lite";
+  if (mode.tags?.includes("deep")) return "deep";
+  if (mode.tags?.includes("balanced") || mode.id === "default") return "balanced";
+  return "custom";
+}
+function createModeTool(modeStore) {
+  return {
+    name: "mode",
+    category: "Session",
+    description: "Manage agent operating modes. Modes change the agent's behavior, personality, and system prompt for different workflows (e.g. coding, security review, planning).",
+    usageHint: "POWERFUL BEHAVIOR CONTROL TOOL:\n\n- Use `list` to see available modes.\n- Use `set <modeId>` to switch the agent into a specific role/mode.\n- Use `get` to check current mode.\n- Use `clear` to return to default behavior.\nSwitching modes is very effective for specialized tasks. The mode change affects how the agent reasons and which guidelines it follows.",
+    permission: "confirm",
+    // WS-046: gives permission decisions something to key on — the mode being
+    // activated. Permission semantics are unchanged.
+    subjectKey: "mode",
+    mutating: true,
+    timeoutMs: 5e3,
+    capabilities: ["session.mode"],
+    icon: "settings",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["get", "list", "set", "clear"],
+          description: "The mode operation to perform."
+        },
+        mode: {
+          type: "string",
+          description: "The mode identifier to activate (only required when action=set)."
+        }
+      },
+      required: ["action"]
+    },
+    async execute(input) {
+      switch (input.action) {
+        case "get": {
+          const mode = await modeStore.getActiveMode();
+          return {
+            action: "get",
+            currentMode: mode?.id,
+            success: true,
+            message: mode ? `Current mode: ${mode.name} \u2014 ${mode.description}` : "No mode set (using default)"
+          };
+        }
+        case "list": {
+          const modes = await modeStore.listModes();
+          const lines = modes.map((m) => `  ${m.id.padEnd(20)} [${modeFamily(m)}] ${m.name} \u2014 ${m.description}`).join("\n");
+          return {
+            action: "list",
+            modes: modes.map((m) => ({
+              id: m.id,
+              name: m.name,
+              description: m.description,
+              family: modeFamily(m),
+              tags: m.tags ?? []
+            })),
+            success: true,
+            message: lines
+          };
+        }
+        case "set": {
+          if (!input.mode) {
+            return { action: "set", success: false, message: "mode is required for action=set" };
+          }
+          const mode = await modeStore.getMode(input.mode);
+          if (!mode) {
+            return { action: "set", success: false, message: `Mode "${input.mode}" not found` };
+          }
+          await modeStore.setActiveMode(input.mode);
+          return {
+            action: "set",
+            currentMode: mode.id,
+            success: true,
+            message: `Switched to mode: ${mode.name}
+
+${mode.description}`
+          };
+        }
+        case "clear": {
+          await modeStore.setActiveMode(null);
+          return {
+            action: "clear",
+            success: true,
+            message: "Mode cleared \u2014 using default mode"
+          };
+        }
+        default:
+          return {
+            action: input.action,
+            success: false,
+            message: `Unknown action "${input.action}"`
+          };
+      }
+    }
+  };
+}
+
+export {
+  createModeTool
+};
+//# sourceMappingURL=chunk-4BHUSMNL.js.map