@wrongstack/tools 0.313.0 → 0.313.1

package/dist/chunk-RGISBZBD.js

@@ -0,0 +1,231 @@
+import {
+  compileUserRegex
+} from "./chunk-Q5JPPCZC.js";
+import {
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/logs.ts
+import { spawn } from "node:child_process";
+import { buildChildEnv } from "@wrongstack/core/utils";
+var logsTool = {
+  name: "logs",
+  category: "Logs",
+  description: "Read logs from files or Docker containers. Useful for debugging running applications.",
+  usageHint: "DEBUGGING TOOL \u2014 USE CAREFULLY IN AUTONOMOUS MODE:\n\n- Prefer `path` for local files or `service` for Docker containers.\n- Always use `filter` (regex) when possible to reduce noise and token usage.\n- `since` narrows Docker logs to a recent window.",
+  permission: "confirm",
+  mutating: false,
+  timeoutMs: 3e4,
+  maxOutputBytes: 262144,
+  capabilities: ["shell.restricted"],
+  icon: "logs",
+  inputSchema: {
+    type: "object",
+    properties: {
+      service: {
+        type: "string",
+        description: "Docker container name (passed to `docker logs`)"
+      },
+      path: {
+        type: "string",
+        description: "Path to log file (alternative to service)"
+      },
+      lines: {
+        type: "integer",
+        description: "Number of log lines to fetch (default: 100, 0 for all)",
+        minimum: 0,
+        maximum: 1e4
+      },
+      filter: {
+        type: "string",
+        description: "Regex pattern to filter log lines"
+      },
+      since: {
+        type: "string",
+        enum: ["1h", "6h", "24h", "all"],
+        description: 'Only show Docker logs since duration (ignored for files; "all" = no limit)'
+      },
+      cwd: { type: "string", description: "Working directory (default: cwd)" }
+    }
+  },
+  async execute(input, ctx, opts) {
+    const cwd = input.cwd ? await safeResolveReal(input.cwd, ctx) : ctx.cwd;
+    const lines = input.lines ?? 100;
+    let filterRe = null;
+    if (input.filter) {
+      const compiled = compileUserRegex(input.filter, "i");
+      if (!compiled.ok) {
+        throw new Error(`logs: ${compiled.reason}`);
+      }
+      filterRe = compiled.regex;
+    }
+    if (input.service) {
+      return await dockerLogs(input.service, lines, filterRe, cwd, opts.signal, input.since);
+    }
+    if (input.path) {
+      return await fileLogs(await safeResolveReal(input.path, ctx), lines, filterRe);
+    }
+    return {
+      source: "none",
+      entries: [],
+      total: 0,
+      truncated: false,
+      stream_mode: false
+    };
+  }
+};
+async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
+  const args = ["logs"];
+  if (lines > 0) args.push("--tail", String(lines));
+  if (since && since !== "all") {
+    const sinceMap = { "1h": "1h", "6h": "6h", "24h": "24h" };
+    args.push("--since", sinceMap[since] ?? "1h");
+  }
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._:-]+$/.test(service)) {
+    return {
+      source: `docker:${service}`,
+      entries: [],
+      total: 0,
+      truncated: false,
+      stream_mode: false
+    };
+  }
+  args.push("--timestamps", service);
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    const MAX = 2e5;
+    let settled = false;
+    const empty = () => ({
+      source: `docker:${service}`,
+      entries: [],
+      total: 0,
+      truncated: false,
+      stream_mode: false
+    });
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const child = spawn("docker", args, {
+      cwd,
+      signal,
+      env: buildChildEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish(empty());
+    }, DOCKER_LOGS_TIMEOUT_MS);
+    child.stdout?.on("data", (c) => {
+      if (stdout.length < MAX) stdout += c.toString();
+    });
+    child.stderr?.on("data", (c) => {
+      if (stderr.length < MAX) stderr += c.toString();
+    });
+    child.stdout?.on("error", (e) => {
+      console.log(
+        JSON.stringify({ level: "debug", event: "pipe_error", stream: "stdout", error: e.message })
+      );
+    });
+    child.stderr?.on("error", (e) => {
+      console.log(
+        JSON.stringify({ level: "debug", event: "pipe_error", stream: "stderr", error: e.message })
+      );
+    });
+    child.on("close", () => {
+      const output = stdout + stderr;
+      const entries = parseLogLines(output, filterRe);
+      finish({
+        source: `docker:${service}`,
+        entries,
+        total: entries.length,
+        truncated: output.length >= MAX,
+        stream_mode: false
+      });
+    });
+    child.on("error", () => finish(empty()));
+  });
+}
+var DOCKER_LOGS_TIMEOUT_MS = 3e3;
+var MAX_TAIL_LINES = 1e5;
+async function fileLogs(path, lines, filterRe) {
+  const { createInterface } = await import("node:readline");
+  const { createReadStream } = await import("node:fs");
+  const entries = [];
+  const effLines = lines > 0 ? Math.min(lines, MAX_TAIL_LINES) : MAX_TAIL_LINES;
+  const window = new Array(effLines);
+  let writeIdx = 0;
+  let totalLines = 0;
+  const rl = createInterface({
+    input: createReadStream(path),
+    crlfDelay: Number.POSITIVE_INFINITY
+  });
+  for await (const line of rl) {
+    if (filterRe && !filterRe.test(line)) continue;
+    window[writeIdx] = line;
+    writeIdx = (writeIdx + 1) % effLines;
+    totalLines++;
+  }
+  const ordered = [];
+  const start = totalLines >= effLines ? writeIdx : 0;
+  const count = Math.min(totalLines, effLines);
+  for (let i = 0; i < count; i++) {
+    const v = window[(start + i) % effLines];
+    if (v !== void 0) ordered.push(v);
+  }
+  for (const line of ordered) {
+    const parsed = parseLine(line);
+    if (parsed) entries.push(parsed);
+  }
+  return {
+    source: path,
+    entries,
+    total: entries.length,
+    truncated: totalLines > effLines,
+    stream_mode: false
+  };
+}
+function parseLogLines(output, filterRe) {
+  const lines = output.split("\n").filter(Boolean);
+  const entries = [];
+  for (const line of lines) {
+    if (filterRe && !filterRe.test(line)) continue;
+    const parsed = parseLine(line);
+    if (parsed) entries.push(parsed);
+  }
+  return entries;
+}
+function parseLine(line) {
+  const tsRe = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\s+(?:\[?(\w+)\]?)\s*(.*)/;
+  const match = tsRe.exec(line);
+  if (match) {
+    return {
+      timestamp: match[1] ?? "",
+      level: match[2]?.toLowerCase() ?? "info",
+      message: match[3] ?? ""
+    };
+  }
+  const levelRe = /(ERROR|WARN|INFO|DEBUG|TRACE)\s+(.*)/i;
+  const levelMatch = levelRe.exec(line);
+  if (levelMatch) {
+    return {
+      timestamp: "",
+      level: levelMatch[1]?.toLowerCase() ?? "info",
+      message: levelMatch[2] ?? line
+    };
+  }
+  return {
+    timestamp: "",
+    level: "info",
+    message: line
+  };
+}
+
+export {
+  logsTool
+};
+//# sourceMappingURL=chunk-RGISBZBD.js.map

package/dist/chunk-RJZQWEMS.js

@@ -0,0 +1,84 @@
+// src/tool-search.ts
+var toolSearchTool = {
+  name: "tool_search",
+  category: "Meta",
+  description: "Search the catalog of available tools by name or description. Use this to discover which tool to use for a task. For the full schema and usage details of a specific tool, use `tool_help` instead.",
+  usageHint: "SELF-DISCOVERY TOOL:\n\n- Use when you need to find the right tool for a job.\n- `query` searches names and descriptions.\n- You can filter by `tags` (category), `permission`, or `mutating`.\n- Once you find the right tool name, use `tool_help` with that name for full schema details.\nCall this before guessing tool names. It helps you discover the best tool for the current situation.",
+  permission: "auto",
+  mutating: false,
+  timeoutMs: 1e3,
+  capabilities: ["tool.meta"],
+  icon: "meta",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "Search query for tool name or description"
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Filter by tags (e.g. "filesystem", "network", "dev")'
+      },
+      permission: {
+        type: "string",
+        enum: ["auto", "confirm", "deny"],
+        description: "Filter by required permission level"
+      },
+      mutating: {
+        type: "boolean",
+        description: "Filter by mutating flag (true=filters that modify, false=read-only)"
+      },
+      limit: {
+        type: "integer",
+        description: "Maximum results to return (default: 20)",
+        minimum: 1,
+        maximum: 100
+      }
+    }
+  },
+  async execute(input, ctx) {
+    const limit = Math.min(input.limit ?? 20, 100);
+    const tools = ctx.catalogTools ?? ctx.tools;
+    const query = input.query?.toLowerCase() ?? "";
+    const filtered = tools.filter((t) => {
+      if (query && !t.name.toLowerCase().includes(query) && !t.description.toLowerCase().includes(query)) {
+        return false;
+      }
+      if (input.tags && input.tags.length > 0) {
+        const toolCat = (t.category ?? "").toLowerCase();
+        if (!input.tags.some((tag) => toolCat.includes(tag.toLowerCase()))) {
+          return false;
+        }
+      }
+      if (input.permission && t.permission !== input.permission) {
+        return false;
+      }
+      if (typeof input.mutating === "boolean" && t.mutating !== input.mutating) {
+        return false;
+      }
+      return true;
+    });
+    const results = filtered.slice(0, limit).map((t) => ({
+      name: t.name,
+      description: t.description,
+      permission: t.permission,
+      mutating: t.mutating
+    }));
+    const totalAvailable = tools.length;
+    const hint = results.length === 0 && query ? `No tools matched "${input.query}". Use tool-help (without arguments) to see all ${totalAvailable} available tools.` : void 0;
+    return {
+      tools: results,
+      total: filtered.length,
+      truncated: filtered.length > limit,
+      ...hint ? { hint } : {},
+      _available: totalAvailable
+    };
+  }
+};
+
+export {
+  toolSearchTool
+};
+//# sourceMappingURL=chunk-RJZQWEMS.js.map

package/dist/chunk-RP2ZA47V.js

@@ -0,0 +1,15 @@
+import {
+  builtinTools
+} from "./chunk-URFKEIHM.js";
+
+// src/pack.ts
+var builtinToolsPack = {
+  name: "builtin-tools",
+  description: "The complete set of built-in tools that ship with WrongStack. Covers filesystem, execution, first-party browser automation, read-only E2E planning, networking, code quality, planning, and meta tools.",
+  tools: builtinTools
+};
+
+export {
+  builtinToolsPack
+};
+//# sourceMappingURL=chunk-RP2ZA47V.js.map

package/dist/chunk-RXISBFR5.js

@@ -0,0 +1,315 @@
+import {
+  COMMAND_OUTPUT_MAX_BYTES,
+  normalizeCommandOutput
+} from "./chunk-D33S4RQG.js";
+
+// src/git.ts
+import { spawn } from "node:child_process";
+import { statSync } from "node:fs";
+import { dirname, resolve, sep } from "node:path";
+import { assessCommitSafety } from "@wrongstack/core/coordination";
+import { buildChildEnv } from "@wrongstack/core/utils";
+var TIMEOUT_MS = 3e4;
+var MAX_OUTPUT = 1e5;
+var gitTool = {
+  name: "git",
+  category: "Git",
+  description: "Safe wrapper around common git operations. Supports status, log, diff, commit, branch, checkout, stash, push, pull, fetch, reset, worktree, etc. This is the preferred way to interact with git instead of using the raw `bash` or `exec` tools.",
+  usageHint: "ALWAYS prefer this tool over raw shell git commands.\n\nKey fields:\n- `command`: one of the supported subcommands (status, log, diff, commit, etc.)\n- Use `message` only for commit operations.\n- Use `files` array for operations that take paths (status, diff, add, etc.).\n- Non-mutating commands (status, log, diff, branch, fetch) are still permission:confirm for safety.\n- For `commit` in a possibly-shared working tree, pass an explicit `files` list scoped to what YOU changed. A bare commit (no `files`) includes ALL staged changes and may capture another agent's half-done work. Heed the `warning` field on the result.\nNever pass raw git flags through `args` for dangerous operations \u2014 use the structured fields.",
+  permission: "confirm",
+  icon: "git",
+  // Conservative: any of these may mutate. The non-mutating commands
+  // (status/log/diff/branch/fetch) are still gated on `permission: 'confirm'`
+  // and `MUTATING_SUBCOMMANDS` is consulted at runtime for per-call checks.
+  // WS-046: gives permission decisions something to key on.
+  // The git subcommand (status/commit/push) is what a trust rule needs to
+  // distinguish; `git status` and `git push --force` must not share a subject.
+  subjectKey: "command",
+  // `command` is an enum subcommand, so on its own it rendered the subject
+  // `"push"` — and one "always allow" then covered every push, to any branch,
+  // with or without `--force`. These are the fields that change what the call
+  // actually does, so the stored trust rule is as specific as the invocation
+  // the user approved.
+  subjectFields: ["branch", "force", "worktreeAction", "worktreePath", "newBranch"],
+  mutating: true,
+  capabilities: ["fs.write", "shell.restricted"],
+  timeoutMs: TIMEOUT_MS,
+  inputSchema: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        enum: [
+          "status",
+          "log",
+          "diff",
+          "commit",
+          "branch",
+          "checkout",
+          "stash",
+          "push",
+          "pull",
+          "fetch",
+          "reset",
+          "worktree"
+        ],
+        description: "Git subcommand"
+      },
+      files: {
+        type: "string",
+        description: 'File(s) for status/diff: single path, comma-separated list, or "**/*.ts" glob'
+      },
+      message: { type: "string", description: "Commit message (required for commit)" },
+      branch: { type: "string", description: "Branch name for checkout/branch" },
+      format: {
+        type: "string",
+        enum: ["short", "oneline", "stat", "graph"],
+        description: "Log format (default: short)"
+      },
+      limit: { type: "integer", description: "Limit for log (default: 20)" },
+      dry_run: { type: "boolean", description: "For commit: show what would be committed" },
+      worktreeAction: {
+        type: "string",
+        enum: ["list", "add", "remove", "prune"],
+        description: "Worktree action: list, add, remove, prune"
+      },
+      worktreePath: {
+        type: "string",
+        description: 'Path for worktree add/remove (e.g. "../wt-feature-xyz")'
+      },
+      newBranch: {
+        type: "boolean",
+        description: "Create new branch when adding worktree"
+      },
+      force: {
+        type: "boolean",
+        description: "Force operation (e.g. worktree remove --force)"
+      }
+    },
+    required: ["command"]
+  },
+  async execute(input, ctx, opts) {
+    if (!input?.command) throw new Error("git: command is required");
+    if (input.command === "commit" && !input.message) {
+      return {
+        command: "commit",
+        stdout: "",
+        stderr: "git commit requires a message (-m flag)",
+        exitCode: 1,
+        truncated: false
+      };
+    }
+    const branchGuard = validateBranchInput(input);
+    if (branchGuard) return branchGuard;
+    if (input.command === "worktree") {
+      const guard = validateWorktreeInput(input, ctx.projectRoot);
+      if (guard) return guard;
+    }
+    const gitDir = findGitDir(ctx.cwd, ctx.projectRoot);
+    if (!gitDir) {
+      return {
+        command: input.command,
+        stdout: "",
+        stderr: "Not in a git repository (within project root)",
+        exitCode: 128,
+        truncated: false
+      };
+    }
+    const args = buildArgs(input);
+    let safetyWarning;
+    if (input.command === "commit") {
+      try {
+        const report = await assessCommitSafety({
+          cwd: ctx.cwd,
+          projectRoot: ctx.projectRoot,
+          sessionId: ctx.session?.id,
+          signal: opts.signal
+        });
+        if (report.warning) {
+          const scopeNote = input.files ? "" : "\nNote: this commit has no explicit `files` list, so it will include ALL staged changes. Pass `files` to scope the commit to only what you changed.";
+          safetyWarning = report.warning + scopeNote;
+        }
+      } catch {
+      }
+    }
+    let stagedDiff;
+    if (input.command === "commit" && !input.dry_run) {
+      try {
+        const diffResult = await runGit(["diff", "--cached"], gitDir, opts.signal);
+        if (diffResult.exitCode === 0) {
+          const MAX_DIFF = 2e4;
+          stagedDiff = diffResult.stdout.length > MAX_DIFF ? diffResult.stdout.slice(0, MAX_DIFF) + "\n\n... (diff truncated)" : diffResult.stdout;
+        }
+      } catch {
+      }
+    }
+    const result = await runGit(args, gitDir, opts.signal);
+    if (stagedDiff !== void 0) result.diff = stagedDiff;
+    if (safetyWarning !== void 0) result.warning = safetyWarning;
+    return result;
+  }
+};
+function validateBranchInput(input) {
+  const branch = input.branch;
+  if (branch === void 0) return null;
+  if (!branch.startsWith("-") && !branch.includes(" --")) return null;
+  return {
+    command: input.command,
+    stdout: "",
+    stderr: `unsafe branch name (parsed as a git option): ${branch}`,
+    exitCode: 1,
+    truncated: false
+  };
+}
+function validateWorktreeInput(input, projectRoot) {
+  const reject = (stderr) => ({
+    command: "worktree",
+    stdout: "",
+    stderr,
+    exitCode: 1,
+    truncated: false
+  });
+  if (input.worktreePath?.startsWith("-")) {
+    return reject(`unsafe worktree path: ${input.worktreePath}`);
+  }
+  if ((input.worktreeAction === "add" || input.worktreeAction === "remove") && input.worktreePath) {
+    const root = resolve(projectRoot);
+    const abs = resolve(root, input.worktreePath);
+    if (abs !== root && !abs.startsWith(root + sep)) {
+      return reject(`unsafe worktree path (escapes project root): ${input.worktreePath}`);
+    }
+  }
+  return null;
+}
+function findGitDir(cwd, projectRoot) {
+  const root = projectRoot;
+  let dir = cwd;
+  for (let i = 0; i < 20; i++) {
+    try {
+      const stat = statSync(`${dir}/.git`);
+      if (stat.isDirectory() || stat.isFile()) return dir;
+    } catch {
+    }
+    if (dir === root) break;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function buildArgs(input) {
+  const limit = input.limit ?? 20;
+  const files = input.files ? (Array.isArray(input.files) ? input.files : input.files.split(",")).map((s) => s.trim()).filter(Boolean) : [];
+  switch (input.command) {
+    case "status":
+      return ["status", ...files.length ? ["--", ...files] : []];
+    case "log":
+      return [
+        "log",
+        `--max-count=${limit}`,
+        ...input.format === "oneline" ? ["--oneline"] : [],
+        ...input.format === "stat" ? ["--stat"] : [],
+        ...input.format === "graph" ? ["--oneline", "--graph", "--decorate"] : [],
+        ...input.format === "short" || !input.format ? [] : []
+      ];
+    case "diff":
+      return ["diff", "--no-color", ...files.length ? ["--", ...files] : []];
+    case "commit":
+      return [
+        "commit",
+        ...input.dry_run ? ["--dry-run", "--porcelain"] : [],
+        ...input.message ? ["-m", input.message] : [],
+        ...files.length ? ["--", ...files] : []
+      ];
+    case "branch":
+      return input.branch ? [
+        "branch",
+        ...input.branch.startsWith("-") || input.branch.includes(" --") ? [] : [input.branch]
+      ] : ["branch"];
+    case "checkout":
+      if (files.length) return ["checkout", "--", ...files];
+      return input.branch ? ["checkout", input.branch, "--"] : ["checkout"];
+    case "stash":
+      return input.message ? ["stash", "push", "-m", input.message] : ["stash", "push"];
+    case "push":
+      return ["push"];
+    case "pull":
+      return ["pull"];
+    case "fetch":
+      return ["fetch", ...input.branch ? [input.branch] : ["--all"]];
+    case "reset":
+      return ["reset", ...files.length ? ["--", ...files] : []];
+    case "worktree":
+      switch (input.worktreeAction) {
+        case "list":
+          return ["worktree", "list"];
+        case "add": {
+          if (!input.worktreePath) return ["worktree", "list"];
+          const add = ["worktree", "add"];
+          if (input.newBranch && input.branch) add.push("-b", input.branch);
+          add.push(input.worktreePath);
+          if (!input.newBranch && input.branch) add.push(input.branch);
+          return add;
+        }
+        case "remove":
+          return [
+            "worktree",
+            "remove",
+            ...input.force ? ["--force"] : [],
+            input.worktreePath ?? ""
+          ].filter(Boolean);
+        case "prune":
+          return ["worktree", "prune"];
+        default:
+          return ["worktree", "list"];
+      }
+    default:
+      return [input.command];
+  }
+}
+function runGit(args, cwd, signal) {
+  return new Promise((resolve2) => {
+    let stdout = "";
+    let stderr = "";
+    const child = spawn("git", args, {
+      cwd,
+      signal,
+      env: buildChildEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    child.stdout?.on("data", (chunk) => {
+      if (stdout.length < MAX_OUTPUT) {
+        stdout += chunk.toString();
+      }
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length < MAX_OUTPUT) {
+        stderr += chunk.toString();
+      }
+    });
+    child.on("error", (err) => {
+      resolve2({
+        command: args[0],
+        stdout: normalizeCommandOutput(stdout),
+        stderr: err.message,
+        exitCode: 1,
+        truncated: Buffer.byteLength(stdout, "utf8") > COMMAND_OUTPUT_MAX_BYTES
+      });
+    });
+    child.on("close", (code) => {
+      resolve2({
+        command: args[0],
+        stdout: normalizeCommandOutput(stdout),
+        stderr: normalizeCommandOutput(stderr),
+        exitCode: code ?? 1,
+        truncated: Buffer.byteLength(stdout, "utf8") > COMMAND_OUTPUT_MAX_BYTES || Buffer.byteLength(stderr, "utf8") > COMMAND_OUTPUT_MAX_BYTES
+      });
+    });
+  });
+}
+
+export {
+  gitTool
+};
+//# sourceMappingURL=chunk-RXISBFR5.js.map