@wrongstack/tools 0.310.1 → 0.313.1

package/dist/tool-use.js

@@ -1,97 +1,6 @@
-// src/tool-use.ts
 import {
-  GOVERNED_TOOL_EXECUTOR_META_KEY
-} from "@wrongstack/core/types";
-var toolUseTool = {
-  name: "tool_use",
-  category: "Meta",
-  description: "Directly execute any registered tool by its exact name, bypassing normal discovery. This is a powerful meta-tool intended for cases where the agent has a clear plan and knows precisely which tool to invoke.",
-  usageHint: "ADVANCED META TOOL \u2014 USE WITH CARE:\n\n- Only use when you are certain of the exact tool name and its expected input shape.\n- Prefer using the normal tool calling mechanism when possible.\n- Very useful in batch-tool-use or when orchestrating complex workflows programmatically.\n- The call still goes through full permission checks and capability validation.",
-  permission: "confirm",
-  // WS-046: gives permission decisions something to key on.
-  // The tool being invoked through this indirection — the whole point of a
-  // permission decision here is WHICH tool is being reached.
-  subjectKey: "tool",
-  mutating: true,
-  timeoutMs: 6e4,
-  capabilities: ["tool.mutate.any"],
-  icon: "meta",
-  inputSchema: {
-    type: "object",
-    properties: {
-      tool: {
-        type: "string",
-        description: 'The exact registered name of the tool to invoke (e.g. "bash", "read", "codebase-search").'
-      },
-      input: {
-        type: "object",
-        description: "The input object matching the target tool's inputSchema."
-      }
-    },
-    required: ["tool"]
-  },
-  async execute(input, ctx) {
-    const start = Date.now();
-    if (!input?.tool) {
-      return {
-        tool: "unknown",
-        success: false,
-        error: "tool_use: tool name is required",
-        executionMs: 0
-      };
-    }
-    const tool = (ctx.catalogTools ?? ctx.tools).find((t) => t.name === input.tool);
-    if (!tool) {
-      return {
-        tool: input.tool,
-        success: false,
-        error: `tool_use: tool "${input.tool}" not found`,
-        executionMs: Date.now() - start
-      };
-    }
-    if (tool.name === toolUseTool.name) {
-      return {
-        tool: input.tool,
-        success: false,
-        error: "tool_use: recursive meta-tool execution is not allowed",
-        executionMs: Date.now() - start
-      };
-    }
-    if (tool.permission === "deny") {
-      return {
-        tool: input.tool,
-        success: false,
-        error: `tool_use: tool "${input.tool}" is denied by policy`,
-        executionMs: Date.now() - start
-      };
-    }
-    const governedExecute = ctx.meta[GOVERNED_TOOL_EXECUTOR_META_KEY];
-    if (typeof governedExecute !== "function") {
-      return {
-        tool: input.tool,
-        success: false,
-        error: "tool_use: governed nested execution is unavailable; call the tool directly",
-        executionMs: Date.now() - start
-      };
-    }
-    try {
-      const result = await governedExecute(input.tool, input.input ?? {});
-      return {
-        tool: input.tool,
-        success: result.success,
-        ...result.success ? { result: result.result } : { error: result.error ?? "nested tool failed" },
-        executionMs: Date.now() - start
-      };
-    } catch (e) {
-      return {
-        tool: input.tool,
-        success: false,
-        error: e instanceof Error ? e.message : String(e),
-        executionMs: Date.now() - start
-      };
-    }
-  }
-};
+  toolUseTool
+} from "./chunk-S5CCLZL3.js";
 export {
   toolUseTool
 };

package/dist/tree-sitter-parser-YCILHGZD.js

@@ -0,0 +1,17 @@
+import {
+  __smokeRootType,
+  getGrammarWasmPath,
+  isTreeSitterSupported,
+  loadTreeSitterLanguage,
+  parseSymbols,
+  parseTreeSitterAst
+} from "./chunk-B2CIOKWP.js";
+export {
+  __smokeRootType,
+  getGrammarWasmPath,
+  isTreeSitterSupported,
+  loadTreeSitterLanguage,
+  parseSymbols,
+  parseTreeSitterAst
+};
+//# sourceMappingURL=tree-sitter-parser-YCILHGZD.js.map

package/dist/tree.js

@@ -1,291 +1,7 @@
-// src/tree.ts
-import * as fs from "node:fs/promises";
-import * as path2 from "node:path";
-import { DEFAULT_WALK_IGNORE_DIRS, compileGlob, expectDefined } from "@wrongstack/core/utils";
-
-// src/_util.ts
-import * as fsp from "node:fs/promises";
-import * as path from "node:path";
-import * as Core from "@wrongstack/core/utils";
-function resolvePath(input, ctx) {
-  return path.isAbsolute(input) ? path.normalize(input) : path.resolve(ctx.workingDir ?? ctx.cwd, input);
-}
-function allowedRoots(ctx) {
-  return [path.resolve(ctx.projectRoot), path.resolve(Core.wstackGlobalRoot())];
-}
-function isInsideAny(target, roots) {
-  return roots.some((root) => {
-    const rel = path.relative(root, target);
-    return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
-  });
-}
-function ensureInsideRoot(absPath, ctx) {
-  const target = path.resolve(absPath);
-  if (ctx.allowOutsideProjectRoot) return target;
-  if (isInsideAny(target, allowedRoots(ctx))) return target;
-  throw new Error(`Path "${absPath}" is outside project root "${path.resolve(ctx.projectRoot)}"`);
-}
-function safeResolve(input, ctx) {
-  return ensureInsideRoot(resolvePath(input, ctx), ctx);
-}
-async function resolveRealInsideRoot(absPath, ctx) {
-  if (ctx.allowOutsideProjectRoot) return absPath;
-  const realRoots = await Promise.all(
-    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r)))
-  );
-  let probe = absPath;
-  const pendingTail = [];
-  for (; ; ) {
-    let real;
-    try {
-      real = await fsp.realpath(probe);
-    } catch (err) {
-      if (err.code === "ENOENT") {
-        const parent = path.dirname(probe);
-        if (parent === probe) return absPath;
-        pendingTail.unshift(path.basename(probe));
-        probe = parent;
-        continue;
-      }
-      throw err;
-    }
-    const candidate = pendingTail.length > 0 ? path.join(real, ...pendingTail) : real;
-    if (isInsideAny(candidate, realRoots)) {
-      return candidate;
-    }
-    throw new Error(
-      `Path "${absPath}" resolves through a symlink outside project root "${realRoots[0]}"`
-    );
-  }
-}
-async function safeResolveReal(input, ctx) {
-  const abs = safeResolve(input, ctx);
-  return await resolveRealInsideRoot(abs, ctx);
-}
-
-// src/tree.ts
-var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
-  ...DEFAULT_WALK_IGNORE_DIRS,
-  ".wrongstack",
-  ".ssh",
-  ".gnupg",
-  ".aws"
-]);
-var DEFAULT_MAX_ENTRIES = 5e3;
-var MAX_TREE_OUTPUT_BYTES = 256 * 1024;
-var treeTool = {
-  name: "tree",
-  category: "Filesystem",
-  description: "Display a project or subpath directory tree. Use it for structural layout; use index-backed `codebase-search` first for code understanding when it is live.",
-  usageHint: "DIRECTORY-LAYOUT EXPLORATION:\n\n- When `codebase-search` is live, use it first for symbols and concepts; use `tree` when the directory hierarchy itself matters.\n- Tune `depth` (default 3) and use `glob`/`exclude` to focus the view.\n- Prefer this over raw `bash find` or `glob` + manual reading when you need a quick structural overview.\nOutput is truncated for very large trees.",
-  permission: "auto",
-  mutating: false,
-  capabilities: ["fs.read"],
-  icon: "tree",
-  maxOutputBytes: 262144,
-  timeoutMs: 15e3,
-  inputSchema: {
-    type: "object",
-    properties: {
-      path: {
-        type: "string",
-        description: "Root directory to display the tree from (defaults to project root)."
-      },
-      depth: {
-        type: "integer",
-        description: "Maximum directory depth to traverse (default 3, use 0 for unlimited).",
-        minimum: 0,
-        maximum: 20
-      },
-      glob: {
-        type: "string",
-        description: "Only include files matching this glob pattern."
-      },
-      exclude: {
-        type: "array",
-        items: { type: "string" },
-        description: "List of directory names to completely ignore."
-      },
-      show_files: {
-        type: "boolean",
-        description: "Whether to show individual files (default true)."
-      },
-      show_dirs: {
-        type: "boolean",
-        description: "Whether to show directories (default true)."
-      },
-      show_hidden: {
-        type: "boolean",
-        description: "Show hidden files starting with . (default: false)"
-      },
-      max_entries: {
-        type: "integer",
-        description: `Maximum entries retained in the rendered tree (default ${DEFAULT_MAX_ENTRIES}).`,
-        minimum: 1,
-        maximum: 5e4
-      }
-    }
-  },
-  async execute(input, ctx, opts) {
-    let final;
-    const executeStream = treeTool.executeStream;
-    if (!executeStream) throw new Error("treeTool: stream execution unavailable");
-    for await (const ev of executeStream(input, ctx, opts)) {
-      if (ev.type === "final") final = ev.output;
-    }
-    if (!final) throw new Error("tree: stream ended without final event");
-    return final;
-  },
-  async *executeStream(input, ctx, opts) {
-    const basePath = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
-    const maxDepth = input.depth ?? 3;
-    const showFiles = input.show_files ?? true;
-    const showDirs = input.show_dirs ?? true;
-    const showHidden = input.show_hidden ?? false;
-    const exclude = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...input.exclude ?? []]);
-    const globRe = input.glob ? compileGlob(input.glob) : void 0;
-    const maxEntries = input.max_entries ?? DEFAULT_MAX_ENTRIES;
-    const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
-    const lines = [basePath];
-    const totals = { totalFiles: { value: 0 }, totalDirs: { value: 0 } };
-    const retention = {
-      entries: 0,
-      outputBytes: Buffer.byteLength(basePath, "utf8"),
-      maxEntries,
-      maxOutputBytes: MAX_TREE_OUTPUT_BYTES,
-      truncated: false
-    };
-    const queue = [];
-    const FLUSH_EVERY = 200;
-    let lastEmittedTotal = 0;
-    const tickProgress = () => {
-      const seen = totals.totalFiles.value + totals.totalDirs.value;
-      if (seen - lastEmittedTotal >= FLUSH_EVERY) {
-        queue.push({
-          type: "metric",
-          text: `${seen} entries`,
-          data: { files: totals.totalFiles.value, dirs: totals.totalDirs.value }
-        });
-        lastEmittedTotal = seen;
-      }
-    };
-    const walkPromise = walkDir(basePath, 0, {
-      maxDepth,
-      exclude,
-      showFiles,
-      showDirs,
-      showHidden,
-      globRe,
-      basePath,
-      lines,
-      prefix: "",
-      isLast: true,
-      totalFiles: totals.totalFiles,
-      totalDirs: totals.totalDirs,
-      onProgress: tickProgress,
-      retention,
-      signal
-    });
-    let walkDone = false;
-    void walkPromise.then(
-      () => {
-        walkDone = true;
-      },
-      () => {
-        walkDone = true;
-      }
-    );
-    while (!walkDone || queue.length > 0) {
-      if (queue.length > 0) {
-        yield expectDefined(queue.shift());
-      } else {
-        let pollTimer;
-        const poll = new Promise((r) => {
-          pollTimer = setTimeout(r, 50);
-        });
-        try {
-          await Promise.race([walkPromise, poll]).catch(() => void 0);
-        } finally {
-          if (pollTimer) clearTimeout(pollTimer);
-        }
-      }
-    }
-    await walkPromise;
-    yield {
-      type: "final",
-      output: {
-        tree: lines.join("\n"),
-        total_files: totals.totalFiles.value,
-        total_dirs: totals.totalDirs.value,
-        truncated: retention.truncated,
-        path: basePath
-      }
-    };
-  }
-};
-function matchesTreeGlob(globRe, fileName, absPath, basePath) {
-  if (globRe.test(fileName)) return true;
-  const rel = path2.relative(basePath, absPath);
-  const posixRel = !rel || rel.startsWith("..") || path2.isAbsolute(rel) ? absPath.split(path2.sep).join("/") : rel.split(path2.sep).join("/");
-  return globRe.test(posixRel);
-}
-async function walkDir(dir, depth, opts) {
-  opts.signal.throwIfAborted();
-  if (opts.retention.truncated) return;
-  const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-  const filtered = entries.filter((e) => {
-    if (!opts.showHidden && e.name.startsWith(".")) return false;
-    if (opts.exclude.has(e.name)) return false;
-    if (e.isFile() && opts.globRe) {
-      const abs = path2.join(dir, e.name);
-      if (!matchesTreeGlob(opts.globRe, e.name, abs, opts.basePath)) return false;
-    }
-    return true;
-  });
-  let dirCount = 0;
-  let fileCount = 0;
-  for (const e of filtered) {
-    if (e.isDirectory()) dirCount++;
-    else if (e.isFile()) fileCount++;
-  }
-  opts.totalDirs.value += dirCount;
-  opts.totalFiles.value += fileCount;
-  opts.onProgress?.();
-  const items = filtered.sort((a, b) => {
-    if (a.isDirectory() && !b.isDirectory()) return -1;
-    if (!a.isDirectory() && b.isDirectory()) return 1;
-    return a.name.localeCompare(b.name);
-  });
-  for (let i = 0; i < items.length; i++) {
-    opts.signal.throwIfAborted();
-    if (opts.retention.truncated) return;
-    const entry = items[i];
-    if (!entry) continue;
-    const isLast = i === items.length - 1;
-    const connector = opts.isLast ? "    " : "\u2502   ";
-    const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-    const displayName = entry.name + (entry.isDirectory() ? "/" : "");
-    if (!opts.showDirs && entry.isDirectory()) continue;
-    if (!opts.showFiles && entry.isFile()) continue;
-    const line = opts.prefix + branch + displayName;
-    const lineBytes = Buffer.byteLength(line, "utf8") + 1;
-    if (opts.retention.entries >= opts.retention.maxEntries || opts.retention.outputBytes + lineBytes > opts.retention.maxOutputBytes) {
-      opts.retention.truncated = true;
-      return;
-    }
-    opts.lines.push(line);
-    opts.retention.entries++;
-    opts.retention.outputBytes += lineBytes;
-    if (entry.isDirectory() && (opts.maxDepth === 0 || depth < opts.maxDepth)) {
-      const childPrefix = opts.prefix + connector;
-      await walkDir(path2.join(dir, entry.name), depth + 1, {
-        ...opts,
-        prefix: childPrefix,
-        isLast
-      });
-    }
-  }
-}
+import {
+  treeTool
+} from "./chunk-J5SKD6LN.js";
+import "./chunk-D33S4RQG.js";
 export {
   treeTool
 };

package/dist/ts-parser-YH4ZMWMH.js

@@ -0,0 +1,232 @@
+import {
+  detectLang
+} from "./chunk-ILESNGNM.js";
+
+// src/codebase-index/ts-parser.ts
+var ts;
+var tsLoad = null;
+function loadTypescript() {
+  tsLoad ??= import("@typescript/typescript6").then((m) => {
+    ts = m.default ?? m;
+    return ts;
+  });
+  return tsLoad;
+}
+var kindMapCache = null;
+function kindMap() {
+  kindMapCache ??= {
+    [ts.SyntaxKind.ClassDeclaration]: "class",
+    [ts.SyntaxKind.InterfaceDeclaration]: "interface",
+    [ts.SyntaxKind.EnumDeclaration]: "enum",
+    [ts.SyntaxKind.TypeAliasDeclaration]: "type",
+    [ts.SyntaxKind.FunctionDeclaration]: "function",
+    [ts.SyntaxKind.MethodDeclaration]: "method",
+    [ts.SyntaxKind.GetAccessor]: "property",
+    [ts.SyntaxKind.SetAccessor]: "property",
+    [ts.SyntaxKind.PropertyDeclaration]: "property",
+    [ts.SyntaxKind.Parameter]: "parameter",
+    [ts.SyntaxKind.NamespaceExportDeclaration]: "namespace"
+  };
+  return kindMapCache;
+}
+function kindOf(node) {
+  if (ts.isVariableDeclaration(node)) {
+    const parent = node.parent;
+    if (ts.isVariableDeclarationList(parent)) {
+      const flags = parent.flags;
+      if (flags & ts.NodeFlags.Let) return "let";
+      if (flags & ts.NodeFlags.Const) return "const";
+      return "var";
+    }
+  }
+  if (ts.isModuleDeclaration(node)) return "namespace";
+  return kindMap()[node.kind] ?? null;
+}
+function getSignature(printer, node, sourceFile) {
+  const raw = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+  return raw.replace(/\s+/g, " ").slice(0, 500);
+}
+function getJsDoc(node, sourceFile) {
+  const fullText = sourceFile.getFullText();
+  const nodePos = node.getFullStart();
+  const comments = ts.getLeadingCommentRanges(fullText, nodePos);
+  if (!comments) return "";
+  for (const range of comments) {
+    const commentText = fullText.slice(range.pos, range.end);
+    const trimmed = commentText.trim();
+    if (trimmed.startsWith("/**") && trimmed.endsWith("*/")) {
+      const inner = trimmed.slice(3, -2).replace(/^[ \t]*\*[ ]?/gm, "").trim();
+      return inner.split("\n")[0]?.trim().slice(0, 200) ?? "";
+    }
+  }
+  return "";
+}
+function pushScopeName(node, parts) {
+  if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isEnumDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+    parts.push(node.name?.text ?? "Anon");
+  } else if (ts.isMethodDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isPropertyDeclaration(node) || ts.isFunctionDeclaration(node)) {
+    if (node.name && ts.isIdentifier(node.name)) {
+      parts.push(node.name.text);
+    }
+  }
+}
+async function parseSymbols(opts) {
+  const { file, content, lang } = opts;
+  await loadTypescript();
+  let sourceFile;
+  try {
+    sourceFile = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true);
+  } catch {
+    return { file, lang, symbols: [], mtimeMs: Date.now() };
+  }
+  const symbols = [];
+  const refs = [];
+  const printer = ts.createPrinter({});
+  function visit(node, funcDepth, scopeParts) {
+    const kind = kindOf(node);
+    if (kind) {
+      if ((kind === "const" || kind === "let" || kind === "var" || kind === "parameter") && funcDepth > 0) {
+      } else {
+        const nameNode = node.name;
+        if (!nameNode || !ts.isIdentifier(nameNode)) {
+          return;
+        }
+        const name = nameNode.text;
+        const pos2 = nameNode.getStart(sourceFile);
+        const { line: line2, character } = sourceFile.getLineAndCharacterOfPosition(pos2);
+        const scope = scopeParts.join(".");
+        const signature = getSignature(printer, node, sourceFile);
+        const docComment = getJsDoc(node, sourceFile);
+        const text = [name, signature, docComment].filter(Boolean).join(" | ");
+        symbols.push({
+          id: 0,
+          lang,
+          kind,
+          name,
+          file,
+          line: line2 + 1,
+          col: character,
+          signature,
+          docComment,
+          scope,
+          text
+        });
+      }
+    }
+    const pos = node.getStart(sourceFile);
+    const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
+    const lineNum = line + 1;
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isIdentifier(expr)) {
+        refs.push({ fromId: 0, toName: expr.text, callType: "call", line: lineNum });
+      }
+    } else if (ts.isPropertyAccessExpression(node)) {
+      if (ts.isIdentifier(node.expression)) {
+        refs.push({ fromId: 0, toName: node.expression.text, callType: "call", line: lineNum });
+      }
+    } else if (ts.isTypeReferenceNode(node)) {
+      const name = getTypeName(node.typeName);
+      if (name) refs.push({ fromId: 0, toName: name, callType: "type_ref", line: lineNum });
+    } else if (ts.isHeritageClause(node)) {
+      for (const t of node.types) {
+        const name = getTypeName(t.expression);
+        if (name)
+          refs.push({
+            fromId: 0,
+            toName: name,
+            callType: node.token === ts.SyntaxKind.ExtendsKeyword ? "inherit" : "implement",
+            line: lineNum
+          });
+      }
+    } else if (ts.isImportDeclaration(node)) {
+      emitImportSpecifierRefs(node, refs, lineNum);
+    } else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
+      emitExportSpecifierRefs(node, refs, lineNum);
+    }
+    const scopeIdx = scopeParts.length;
+    pushScopeName(node, scopeParts);
+    const childFuncDepth = ts.isFunctionLike(node) ? funcDepth + 1 : funcDepth;
+    ts.forEachChild(node, (child) => visit(child, childFuncDepth, scopeParts));
+    scopeParts.length = scopeIdx;
+  }
+  visit(sourceFile, 0, []);
+  return { file, lang, symbols, refs: deduplicateRefs(refs), mtimeMs: Date.now() };
+}
+function getTypeName(name) {
+  if (ts.isIdentifier(name)) return name.text;
+  if (ts.isQualifiedName(name)) return `${getTypeName(name.left)}.${name.right.text}`;
+  return "";
+}
+function deduplicateRefs(refs) {
+  const seen = /* @__PURE__ */ new Set();
+  return refs.filter((r) => {
+    const key = `${r.toName}:${r.callType}:${r.line}:${r.module ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function getImportSpecifierName(spec) {
+  return spec.propertyName?.text ?? spec.name.text;
+}
+function emitImportSpecifierRefs(node, refs, lineNum) {
+  const module = moduleSpecifierOf(node.moduleSpecifier);
+  const clause = node.importClause;
+  if (!clause) {
+    if (module) {
+      refs.push({ fromId: 0, toName: module, callType: "import", line: lineNum, module });
+    }
+    return;
+  }
+  if (clause.name) {
+    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum, module });
+  }
+  const bindings = clause.namedBindings;
+  if (!bindings) return;
+  if (ts.isNamedImports(bindings)) {
+    for (const element of bindings.elements) {
+      refs.push({
+        fromId: 0,
+        toName: getImportSpecifierName(element),
+        callType: "import",
+        line: lineNum,
+        module
+      });
+    }
+  } else if (ts.isNamespaceImport(bindings)) {
+    refs.push({
+      fromId: 0,
+      toName: bindings.name.text,
+      callType: "import",
+      line: lineNum,
+      module
+    });
+  }
+}
+function moduleSpecifierOf(node) {
+  return node && ts.isStringLiteral(node) ? node.text : void 0;
+}
+function emitExportSpecifierRefs(node, refs, lineNum) {
+  const module = moduleSpecifierOf(node.moduleSpecifier);
+  const clause = node.exportClause;
+  if (clause && ts.isNamespaceExport(clause)) {
+    refs.push({ fromId: 0, toName: clause.name.text, callType: "import", line: lineNum, module });
+    return;
+  }
+  if (clause && ts.isNamedExports(clause)) {
+    for (const element of clause.elements) {
+      const originalName = element.propertyName?.text ?? element.name.text;
+      refs.push({ fromId: 0, toName: originalName, callType: "import", line: lineNum, module });
+    }
+    return;
+  }
+  if (module) {
+    refs.push({ fromId: 0, toName: module, callType: "import", line: lineNum, module });
+  }
+}
+export {
+  detectLang,
+  parseSymbols
+};
+//# sourceMappingURL=ts-parser-YH4ZMWMH.js.map