@wrongstack/tools 0.310.1 → 0.313.1

package/dist/chunk-URFKEIHM.js

@@ -0,0 +1,1091 @@
+import {
+  e2ePlanTool
+} from "./chunk-JRJJX3L5.js";
+import {
+  codebaseAstReplaceTool,
+  codebaseImpactAnalysisTool,
+  codebaseIncomingCallsTool,
+  codebaseIndexTool,
+  codebaseInvariantCheckTool,
+  codebaseOutgoingCallsTool,
+  codebaseRepoMapTool,
+  codebaseSearchTool,
+  codebaseSkeletonTool,
+  codebaseStatsTool,
+  codebaseTargetedTestTool,
+  deadCodeScanTool
+} from "./chunk-OZC255IC.js";
+import {
+  planTool
+} from "./chunk-KXNDHMUB.js";
+import {
+  taskTool
+} from "./chunk-FW65TP4G.js";
+import {
+  toolSearchTool
+} from "./chunk-RJZQWEMS.js";
+import {
+  toolUseTool
+} from "./chunk-S5CCLZL3.js";
+import {
+  batchToolUseTool
+} from "./chunk-U4VAATKP.js";
+import {
+  toolHelpTool
+} from "./chunk-QBV725YG.js";
+import {
+  designTool
+} from "./chunk-6RNIFLG4.js";
+import {
+  testTool
+} from "./chunk-HC5RM4WY.js";
+import {
+  installTool
+} from "./chunk-H5OHH6F4.js";
+import {
+  auditTool
+} from "./chunk-HEQFMLZ7.js";
+import {
+  outdatedTool
+} from "./chunk-2CTB3UK5.js";
+import {
+  logsTool
+} from "./chunk-RGISBZBD.js";
+import {
+  documentTool
+} from "./chunk-EMRGN4KM.js";
+import {
+  scaffoldTool
+} from "./chunk-AHHDWNXC.js";
+import {
+  gitTool
+} from "./chunk-RXISBFR5.js";
+import {
+  patchTool
+} from "./chunk-2ZCJNKFE.js";
+import {
+  jsonTool
+} from "./chunk-VB3MJGCV.js";
+import {
+  diffTool
+} from "./chunk-UKU2ZX4C.js";
+import {
+  treeTool
+} from "./chunk-J5SKD6LN.js";
+import {
+  lintTool
+} from "./chunk-DIJKHSUO.js";
+import {
+  formatTool
+} from "./chunk-UTV7YAW7.js";
+import {
+  typecheckTool
+} from "./chunk-INF5CGAO.js";
+import {
+  languageInfoTool,
+  languagePackageTool,
+  languageTool
+} from "./chunk-DPL47QGS.js";
+import {
+  replaceTool
+} from "./chunk-6HLZK37X.js";
+import {
+  globTool
+} from "./chunk-UNSKG6DC.js";
+import {
+  grepTool
+} from "./chunk-553IQUMO.js";
+import {
+  bashTool,
+  checkAndBlockKillCommand,
+  diagnoseBashism,
+  shellArgs
+} from "./chunk-FGOABE4Z.js";
+import {
+  detectDanger,
+  execTool
+} from "./chunk-HXSBQ2SE.js";
+import {
+  buildChildEnv
+} from "./chunk-BTSFTGIL.js";
+import {
+  createOutputSpool,
+  spoolNote
+} from "./chunk-2TFQDEPU.js";
+import {
+  getProcessRegistry,
+  redactCommand
+} from "./chunk-3PVYQFRQ.js";
+import {
+  fetchTool
+} from "./chunk-IXMNTNW5.js";
+import {
+  searchTool
+} from "./chunk-4I4LWFOO.js";
+import {
+  todoTool
+} from "./chunk-J4SRJKBW.js";
+import {
+  kanbanTool
+} from "./chunk-55KF77OK.js";
+import {
+  browserTools
+} from "./chunk-XMIFYKUT.js";
+import {
+  readTool
+} from "./chunk-H5MJUAA6.js";
+import {
+  writeTool
+} from "./chunk-PUR6WU2B.js";
+import {
+  editTool
+} from "./chunk-MKRQMLZA.js";
+import {
+  resolvePowerShell
+} from "./chunk-V43EQ6VR.js";
+import {
+  normalizeCommandOutput,
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/clarify.ts
+import { toErrorMessage } from "@wrongstack/core/utils";
+var clarifyTool = {
+  name: "clarify",
+  category: "Meta",
+  icon: "meta",
+  permission: "auto",
+  mutating: false,
+  description: "Ask the user for proactive clarification with structured multiple-choice options ONLY when an architectural, database schema, or API decision is truly irreversible and has mutually exclusive trade-offs.",
+  usageHint: "AUTONOMOUS EXECUTION PRINCIPLE (BIAS FOR ACTION):\n\n- DO NOT overuse or interrupt the user for routine implementation choices. For 95%+ of tasks, autonomously pick the standard best practice and continue executing.\n- Use ONLY when facing an irreversible fork (e.g. data destruction, fundamentally conflicting domain rules) where guessing would be catastrophic.\n- If a solid industry standard exists (e.g. E.164 phone format, indexed foreign keys, ISO dates), adopt it autonomously, execute the next steps, and document the decision in the final reply.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      question: {
+        type: "string",
+        description: "The specific architectural, schema, or contract decision to clarify."
+      },
+      context: {
+        type: "string",
+        description: "Brief explanation of tradeoffs or why this decision is needed."
+      },
+      options: {
+        type: "array",
+        items: { type: "string" },
+        description: "2 to 4 distinct options formatted as clear user decisions.",
+        minItems: 2,
+        maxItems: 5
+      },
+      recommendedOption: {
+        type: "string",
+        description: "The assistant-recommended default choice."
+      },
+      isMultiSelect: {
+        type: "boolean",
+        description: "Whether multiple options can be chosen simultaneously."
+      },
+      allowCustomResponse: {
+        type: "boolean",
+        description: "Whether to allow the user to type a custom response (default: true)."
+      }
+    },
+    required: ["question", "options"],
+    additionalProperties: false
+  },
+  async execute(input, ctx) {
+    try {
+      const options = input.options;
+      if (!options || options.length < 2) {
+        throw new Error("clarify requires at least 2 distinct options.");
+      }
+      const hostAsk = ctx.askUserChoices;
+      if (typeof hostAsk === "function") {
+        const res = await hostAsk(input.question, options, input.isMultiSelect);
+        return {
+          status: "answered",
+          question: input.question,
+          selectedOptions: res.selected,
+          customResponse: res.custom,
+          decisionSummary: `User selected: ${res.selected.join(", ")}${res.custom ? ` (Custom: ${res.custom})` : ""}`
+        };
+      }
+      const defaultChoice = input.recommendedOption ?? options[0] ?? "Default";
+      return {
+        status: "auto_decided",
+        question: input.question,
+        selectedOptions: [defaultChoice],
+        decisionSummary: `Auto-selected recommended option: "${defaultChoice}" (Non-interactive mode)`
+      };
+    } catch (err) {
+      return {
+        status: "skipped",
+        question: input.question ?? "",
+        selectedOptions: [],
+        decisionSummary: "",
+        error: toErrorMessage(err)
+      };
+    }
+  }
+};
+
+// src/pwsh.ts
+import { spawn } from "node:child_process";
+import * as os from "node:os";
+import { StringDecoder } from "node:string_decoder";
+import {
+  emitProcessCompleted,
+  emitProcessOutput,
+  emitProcessStarted
+} from "@wrongstack/core/observability";
+var MAX_OUTPUT = 32768;
+var DEFAULT_TIMEOUT_MS = 3e5;
+var STREAM_FLUSH_INTERVAL_MS = 200;
+var STREAM_FLUSH_BYTES = 4 * 1024;
+var MAX_QUEUE_CHUNKS = 500;
+var PWSH_TOOL_DESCRIPTION = "Execute a PowerShell command (`pwsh -Command`) in a fresh process on Windows and return its stdout/stderr. Stateless per call: pass `workdir` instead of using `cd`.";
+var PWSH_TOOL_USAGE_HINT = "Best practices & sandbox protocol for pwsh:\n- **Stateless**: No cwd, variables, or functions persist between calls. Use `workdir` to set the directory.\n- **Paths & Environs**: Use native Windows paths (`C:\\...`) and read env vars via `$env:NAME` (and `$env:DSH_*`).\n- **Exit Codes**: Non-zero exits are reported as `[exit code: N]`. On Windows, a force-killed command settles as exit code 1 (interruption).\n- **Background**: Set `run_in_background: true` for long-running processes (returns job id; manage via job_output/job_kill).\n- **Sandboxing**: Under read-only sandbox, pwsh runs in `ConstrainedLanguage` mode (prefer cmdlets, basic types; .NET reflection and COM fail). Workspace-write runs in `FullLanguage`.\n- **Escalation**: If denied by policy (`[sandbox: file access denied]`), retry once with `sandbox_permissions` plus a one-sentence `justification`.";
+function wrapPwshCommand(command) {
+  const bootstrap = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8;$ProgressPreference = 'SilentlyContinue';$ConfirmPreference = 'None';$WhatIfPreference = $false";
+  return `${bootstrap}
+$ErrorActionPreference = 'Stop'
+${command}
+if ($LASTEXITCODE -is [int]) { exit $LASTEXITCODE }`;
+}
+var pwshTool = {
+  name: "pwsh",
+  category: "Shell",
+  description: PWSH_TOOL_DESCRIPTION,
+  usageHint: PWSH_TOOL_USAGE_HINT,
+  selection: {
+    doNotUseWhen: "the command is an allowlisted single binary (node, git, pnpm, tsc) needing no shell expansion or pipelines.",
+    useInstead: ["exec"]
+  },
+  permission: "confirm",
+  mutating: true,
+  riskTier: "destructive",
+  icon: "terminal",
+  subjectKey: "command",
+  capabilities: ["shell.arbitrary"],
+  timeoutMs: 61e4,
+  maxOutputBytes: MAX_OUTPUT,
+  estimatedDurationMs: 3e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: "The exact PowerShell command or script block to run."
+      },
+      workdir: {
+        type: "string",
+        description: "Absolute or project-relative path to the working directory for this command. Defaults to session working directory."
+      },
+      timeout_ms: {
+        type: "integer",
+        description: "Optional timeout for this specific command in milliseconds (default 300000, max 600000)."
+      },
+      run_in_background: {
+        type: "boolean",
+        description: "If true, launch the process in the background and return the job ID / PID immediately."
+      },
+      background: {
+        type: "boolean",
+        description: "Alias for run_in_background."
+      },
+      sandbox_permissions: {
+        type: "string",
+        description: "Escalation mode if retrying a sandbox-denied command (e.g., workspace-write)."
+      },
+      justification: {
+        type: "string",
+        description: "One-sentence justification when retrying a denied command with sandbox_permissions."
+      }
+    },
+    required: ["command"]
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = pwshTool.executeStream;
+    if (!executeStream) throw new Error("pwshTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("pwsh: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    if (!input?.command) throw new Error("pwsh: command is required");
+    const isBackground = !!(input.run_in_background || input.background);
+    const registry = getProcessRegistry();
+    if (!registry.beforeCall(isBackground)) {
+      yield {
+        type: "final",
+        output: {
+          output: "",
+          exit_code: 1,
+          timed_out: false,
+          pid: null,
+          error: "pwsh: circuit breaker open \u2014 too many consecutive failures or slow calls. Use /kill to inspect or /kill reset to recover."
+        }
+      };
+      return;
+    }
+    const killCheck = await checkAndBlockKillCommand(input.command);
+    if (killCheck.blocked) {
+      yield {
+        type: "final",
+        output: {
+          output: "",
+          exit_code: 1,
+          timed_out: false,
+          pid: null,
+          error: `pwsh: ${killCheck.reason}`
+        }
+      };
+      return;
+    }
+    const isWin = os.platform() === "win32";
+    const bin = isWin ? resolvePowerShell("pwsh.exe") : "pwsh";
+    const encodedCommand = Buffer.from(wrapPwshCommand(input.command), "utf16le").toString(
+      "base64"
+    );
+    const args = [...shellArgs("pwsh"), encodedCommand];
+    const env = buildChildEnv(ctx.session?.id);
+    let targetCwd;
+    try {
+      targetCwd = await safeResolveReal(input.workdir ?? ctx.workingDir ?? ctx.projectRoot, ctx);
+    } catch (err) {
+      yield {
+        type: "final",
+        output: {
+          output: "",
+          exit_code: 1,
+          timed_out: false,
+          pid: null,
+          error: `pwsh: ${err.message}`
+        }
+      };
+      return;
+    }
+    const startedAt = Date.now();
+    const detached = !isWin;
+    if (isBackground) {
+      const child2 = spawn(bin, args, {
+        cwd: targetCwd,
+        env,
+        detached,
+        stdio: ["ignore", "ignore", "ignore"],
+        windowsHide: true
+      });
+      const pid2 = child2.pid;
+      if (typeof pid2 === "number") {
+        registry.register({
+          pid: pid2,
+          name: "pwsh",
+          command: redactCommand(input.command),
+          startedAt: Date.now(),
+          sessionId: ctx.session?.id,
+          child: child2,
+          processGroupLeader: detached && child2.pid === pid2,
+          background: true
+        });
+        child2.on("close", () => registry.unregister(pid2));
+        child2.on("error", () => {
+          registry.unregister(pid2);
+          registry.afterCall(Date.now() - startedAt, true, isBackground);
+        });
+        child2.unref();
+        const jobId = `job_${pid2}`;
+        ctx.recordSideEffect?.({
+          toolUseId: `pwsh-bg-${Date.now()}`,
+          toolName: "pwsh",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          input: { command: redactCommand(input.command), background: true },
+          outcome: `started background job ${jobId} (PID: ${pid2})`,
+          risk: "shell"
+        });
+        yield {
+          type: "final",
+          output: {
+            output: `Background job started: ${jobId} (PID: ${pid2})
+Working directory: ${targetCwd}`,
+            exit_code: null,
+            timed_out: false,
+            pid: pid2,
+            job_id: jobId
+          }
+        };
+        return;
+      }
+      yield {
+        type: "final",
+        output: {
+          output: "",
+          exit_code: 1,
+          timed_out: false,
+          pid: null,
+          error: "pwsh: failed to obtain PID for background process"
+        }
+      };
+      return;
+    }
+    const spool = createOutputSpool({ tool: "pwsh", thresholdBytes: MAX_OUTPUT });
+    const child = spawn(bin, args, {
+      cwd: targetCwd,
+      env,
+      detached,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const pid = child.pid;
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let telemetryCompleted = false;
+    emitProcessStarted({
+      ...pid !== void 0 ? { pid } : {},
+      parentPid: process.pid,
+      command: redactCommand(`${bin} ${args.join(" ")}`),
+      args: redactCommand(args.join(" ")).split(" ").filter(Boolean),
+      cwd: targetCwd,
+      background: false,
+      startedAt: new Date(startedAt).toISOString()
+    });
+    const completeForeground = (exitCode, sig) => {
+      if (telemetryCompleted) return;
+      telemetryCompleted = true;
+      emitProcessCompleted({
+        ...pid !== void 0 ? { pid } : {},
+        exitCode,
+        ...sig ? { signal: sig } : {},
+        durationMs: Date.now() - startedAt,
+        stdoutBytes,
+        stderrBytes,
+        timedOut,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    };
+    if (typeof pid === "number") {
+      registry.register({
+        pid,
+        name: "pwsh",
+        command: redactCommand(input.command),
+        startedAt: Date.now(),
+        sessionId: ctx.session?.id,
+        child,
+        processGroupLeader: detached && child.pid === pid
+      });
+    }
+    const timeoutMs = Math.min(Math.max(1e3, input.timeout_ms ?? DEFAULT_TIMEOUT_MS), 6e5);
+    let timedOut = false;
+    const timers = [];
+    const killWithTimeout = (timeout) => {
+      if (isWin) {
+        if (typeof child.pid === "number" && child.exitCode === null) {
+          const attempted = registry.kill(child.pid, { force: true, graceMs: timeout });
+          if (!attempted) {
+            try {
+              child.kill();
+            } catch (err) {
+              console.log(
+                JSON.stringify({
+                  level: "warn",
+                  event: "pwsh.kill_fallback_failed",
+                  pid: child.pid,
+                  platform: process.platform,
+                  error: err instanceof Error ? err.message : String(err),
+                  message: "pwsh child.kill() raised after the registry kill failed; process may be leaked"
+                })
+              );
+            }
+          }
+        }
+        return;
+      }
+      if (typeof child.pid === "number") {
+        registry.kill(child.pid, { graceMs: timeout });
+      } else {
+        try {
+          child.kill("SIGTERM");
+        } catch (err) {
+          console.log(
+            JSON.stringify({
+              level: "warn",
+              event: "pwsh.sigterm_failed",
+              platform: process.platform,
+              error: err instanceof Error ? err.message : String(err),
+              message: 'pwsh child.kill("SIGTERM") raised on POSIX fallback; process may be leaked'
+            })
+          );
+        }
+      }
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killWithTimeout(2e3);
+    }, timeoutMs);
+    timers.push(timer);
+    const onAbort = () => killWithTimeout(2e3);
+    if (opts.signal.aborted) onAbort();
+    else opts.signal.addEventListener("abort", onAbort, { once: true });
+    const queue = [];
+    let resolveNext = null;
+    const push = (c) => {
+      if (resolveNext) {
+        const r = resolveNext;
+        resolveNext = null;
+        r(c);
+      } else {
+        queue.push(c);
+      }
+    };
+    const next = () => new Promise((resolve2) => {
+      const c = queue.shift();
+      if (c) resolve2(c);
+      else resolveNext = resolve2;
+    });
+    let buf = "";
+    let pending = "";
+    let lastFlush = Date.now();
+    const flush = () => {
+      if (pending.length === 0) return null;
+      const text = pending;
+      pending = "";
+      lastFlush = Date.now();
+      return text;
+    };
+    let paused = false;
+    const pauseIfFlooded = () => {
+      if (!paused && queue.length >= MAX_QUEUE_CHUNKS) {
+        paused = true;
+        child.stdout?.pause();
+        child.stderr?.pause();
+      }
+    };
+    const resumeIfDrained = () => {
+      if (paused && queue.length < MAX_QUEUE_CHUNKS) {
+        paused = false;
+        child.stdout?.resume();
+        child.stderr?.resume();
+      }
+    };
+    const stdoutDecoder = new StringDecoder("utf8");
+    const stderrDecoder = new StringDecoder("utf8");
+    const onData = (chunk, stream) => {
+      const text = (stream === "stdout" ? stdoutDecoder : stderrDecoder).write(chunk);
+      if (stream === "stdout") stdoutBytes += chunk.byteLength;
+      else stderrBytes += chunk.byteLength;
+      emitProcessOutput({ pid: pid ?? 0, stream, chunk });
+      if (buf.length < MAX_OUTPUT) {
+        buf += text.slice(0, MAX_OUTPUT - buf.length);
+      }
+      spool.write(text);
+      pending += text;
+      push({ kind: "data", text });
+      pauseIfFlooded();
+    };
+    child.stdout?.on("data", (chunk) => onData(chunk, "stdout"));
+    child.stderr?.on("data", (chunk) => onData(chunk, "stderr"));
+    child.on("error", (err) => {
+      for (const t of timers) clearTimeout(t);
+      registry.afterCall(Date.now() - startedAt, true);
+      completeForeground(1);
+      push({ kind: "error", err });
+    });
+    child.on("close", (code, signal) => {
+      for (const t of timers) clearTimeout(t);
+      if (typeof pid === "number") registry.unregister(pid);
+      registry.afterCall(Date.now() - startedAt, code !== 0 && code !== null);
+      completeForeground(timedOut ? 124 : code ?? (signal ? 1 : 0), signal ?? void 0);
+      const tail = stdoutDecoder.end() + stderrDecoder.end();
+      if (tail) {
+        if (buf.length < MAX_OUTPUT) buf += tail.slice(0, MAX_OUTPUT - buf.length);
+        spool.write(tail);
+        pending += tail;
+      }
+      push({ kind: "end", code });
+    });
+    try {
+      while (true) {
+        const c = await next();
+        resumeIfDrained();
+        if (c.kind === "error") throw c.err;
+        if (c.kind === "end") {
+          const remainder = flush();
+          if (remainder !== null) {
+            yield { type: "partial_output", text: remainder };
+          }
+          const spooled = spool.finalize();
+          let formattedOutput = normalizeCommandOutput(buf);
+          if (c.code !== null && c.code !== 0 && !timedOut) {
+            if (!formattedOutput.includes(`[exit code: ${c.code}]`)) {
+              formattedOutput = formattedOutput ? `${formattedOutput}
+[exit code: ${c.code}]` : `[exit code: ${c.code}]`;
+            }
+          }
+          const hint = !timedOut && typeof c.code === "number" && c.code !== 0 ? diagnoseBashism(input.command, "pwsh") : void 0;
+          const danger = detectDanger("pwsh", [input.command]);
+          const cautionText = danger.level === "caution" && danger.reasons.length > 0 ? `
+[caution: ${danger.reasons.join("; ")}]` : "";
+          const finalResultText = formattedOutput + (spooled ? spoolNote(spooled) : "") + (hint ? `
+
+${hint}` : "") + cautionText;
+          ctx.recordSideEffect?.({
+            toolUseId: `pwsh-${Date.now()}`,
+            toolName: "pwsh",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            input: { command: redactCommand(input.command) },
+            outcome: timedOut ? `timed out (exit ${c.code})` : `exit ${c.code}`,
+            risk: "shell"
+          });
+          yield {
+            type: "final",
+            output: {
+              output: finalResultText,
+              exit_code: timedOut ? 1 : c.code,
+              timed_out: timedOut,
+              pid
+            }
+          };
+          return;
+        }
+        const now = Date.now();
+        if (pending.length >= STREAM_FLUSH_BYTES || now - lastFlush >= STREAM_FLUSH_INTERVAL_MS) {
+          const text = flush();
+          if (text) yield { type: "partial_output", text };
+        }
+      }
+    } finally {
+      for (const t of timers) clearTimeout(t);
+    }
+  }
+};
+
+// src/security-ast-scan-tool.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
+var SECRET_PATTERNS = [
+  { name: "AWS Access Key", regex: /\b(AKIA[0-9A-Z]{16})\b/ },
+  { name: "GitHub Token", regex: /\b(gh[pousr]_[A-Za-z0-9_]{36,255})\b/ },
+  { name: "Stripe Secret Key", regex: /\b(sk_live_[0-9a-zA-Z]{24,})\b/ },
+  { name: "Slack Token", regex: /\b(xox[baprs]-[0-9a-zA-Z]{10,48})\b/ },
+  { name: "Private Key Header", regex: /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/ }
+];
+var REDOS_PATTERNS = [
+  /\([^)]+[+*]\)[+*]/,
+  /\([a-zA-Z0-9_.\\-]+\+?\)\+/i,
+  /\([a-zA-Z0-9_.\\-]+\*?\)\*/i
+];
+var DB_QUERY_CALL_REGEX = /(?:db|prisma|sequelize|knex|typeorm|connection|pool|repo|repository|client)\.(?:query|execute|raw|find|findAll|findOne|findMany|create|update|delete|save|insert|select)\s*\(/i;
+var SQL_INTERPOLATION_REGEX = /(?:SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|JOIN).*\$\{[^}]+\}/i;
+var RAW_SQL_CONCAT_REGEX = /(?:SELECT|INSERT|UPDATE|DELETE).+['"]\s*\+\s*[a-zA-Z0-9_]/i;
+function analyzeSecurityAndPerformance(filePath, content) {
+  const findings = [];
+  const lines = content.split("\n");
+  const relPath = filePath.replace(/\\/g, "/");
+  const isTestFile = /(?:test|spec|mock|fixture)[s]?[/\\._]/i.test(relPath);
+  if (!isTestFile) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i] ?? "";
+      for (const secretRule of SECRET_PATTERNS) {
+        if (secretRule.regex.test(line)) {
+          findings.push({
+            ruleId: "sec/hardcoded-secret",
+            category: "security",
+            severity: "critical",
+            file: relPath,
+            line: i + 1,
+            message: `Hardcoded ${secretRule.name} detected.`,
+            snippet: line.trim(),
+            recommendation: "Store sensitive keys and credentials in environment variables or a secret vault."
+          });
+        }
+      }
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.includes("__proto__") || line.includes("constructor.prototype") || /\bObject\.assign\s*\(\s*\{\}\s*,\s*req\.body\b/.test(line)) {
+      findings.push({
+        ruleId: "sec/prototype-pollution",
+        category: "security",
+        severity: "warning",
+        file: relPath,
+        line: i + 1,
+        message: "Potential prototype pollution vulnerability on object mutation.",
+        snippet: line.trim(),
+        recommendation: "Validate input keys, use `Object.create(null)` for map dictionaries, or use secure deep-merge utilities."
+      });
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (/\beval\s*\(/.test(line) || /\bnew\s+Function\s*\(/.test(line) || /(?:exec|execSync)\s*\(\s*`[^`]*\$\{/.test(line)) {
+      findings.push({
+        ruleId: "sec/unsafe-dynamic-exec",
+        category: "security",
+        severity: "critical",
+        file: relPath,
+        line: i + 1,
+        message: "Unsafe dynamic code execution with variable template interpolation.",
+        snippet: line.trim(),
+        recommendation: "Use static function dispatch or `spawnFile`/`execFile` with an explicit argument array rather than passing raw shell strings."
+      });
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (SQL_INTERPOLATION_REGEX.test(line) || RAW_SQL_CONCAT_REGEX.test(line)) {
+      findings.push({
+        ruleId: "sec/sql-injection",
+        category: "security",
+        severity: "critical",
+        file: relPath,
+        line: i + 1,
+        message: "Raw SQL query constructed via string concatenation or template literal interpolation.",
+        snippet: line.trim(),
+        recommendation: "Use parameterized queries ($1, ?), prepared statements, or ORM query builder methods."
+      });
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.includes("RegExp") || line.includes("/")) {
+      for (const redosPat of REDOS_PATTERNS) {
+        if (redosPat.test(line)) {
+          findings.push({
+            ruleId: "sec/redos-vulnerable-regex",
+            category: "security",
+            severity: "warning",
+            file: relPath,
+            line: i + 1,
+            message: "Regular expression contains nested quantifiers prone to catastrophic backtracking (ReDoS).",
+            snippet: line.trim(),
+            recommendation: "Refactor regular expression to avoid nested repetitions like `(a+)+` or `(x*)*`."
+          });
+          break;
+        }
+      }
+    }
+  }
+  let inLoopDepth = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const trimmed = line.trim();
+    if (/\b(?:for\s*\(|while\s*\(|for\s+await|\.forEach\s*\(|\.map\s*\(\s*(?:async\s*)?\()/.test(
+      trimmed
+    )) {
+      inLoopDepth++;
+    }
+    if (inLoopDepth > 0 && DB_QUERY_CALL_REGEX.test(trimmed)) {
+      findings.push({
+        ruleId: "perf/n-plus-one-query",
+        category: "performance",
+        severity: "critical",
+        file: relPath,
+        line: i + 1,
+        message: "Database query executed inside a loop (N+1 query anti-pattern).",
+        snippet: trimmed,
+        recommendation: "Batch query data using `IN (...)` or fetch relationships eagerly before the loop."
+      });
+    }
+    if (trimmed.includes("}") || trimmed.endsWith(");") && inLoopDepth > 0) {
+      inLoopDepth = Math.max(0, inLoopDepth - 1);
+    }
+  }
+  return findings;
+}
+var securityAstScanTool = {
+  name: "security-ast-scan",
+  category: "Code Quality",
+  icon: "code",
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  description: "Scan source code for contract-based security vulnerabilities and performance bottlenecks (N+1 SQL queries, SQL injection, hardcoded secrets, prototype pollution, ReDoS, and unsafe eval).",
+  usageHint: 'RUN AFTER WRITING OR REFACTORING CODE TO CATCH HIDDEN DEFECTS:\n\n- Pass `file: "src/user-service.ts"` or direct `content: "..."`.\n- Catches N+1 loops, hardcoded secrets, SQL injection, and prototype pollution before committing.\n- Returns severity-ranked findings with line numbers and exact remediation recommendations.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      file: {
+        type: "string",
+        description: "File path to scan (relative to project root)."
+      },
+      content: {
+        type: "string",
+        description: "Direct code string to scan without writing to disk."
+      },
+      rules: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional list of rule IDs to filter by."
+      }
+    },
+    additionalProperties: false
+  },
+  async execute(input, ctx) {
+    try {
+      const projectRoot = ctx.projectRoot;
+      let targetFile = input.file ?? "inline-code.ts";
+      let content = input.content;
+      if (!content && input.file) {
+        const absPath = path.isAbsolute(input.file) ? input.file : path.resolve(projectRoot, input.file);
+        targetFile = path.relative(projectRoot, absPath).replace(/\\/g, "/");
+        content = await fs.readFile(absPath, "utf8");
+      }
+      if (!content) {
+        return {
+          status: "clean",
+          filesScanned: 0,
+          totalFindings: 0,
+          criticalCount: 0,
+          warningCount: 0,
+          findings: [],
+          summary: "No content or file provided to scan."
+        };
+      }
+      let findings = analyzeSecurityAndPerformance(targetFile, content);
+      if (input.rules && input.rules.length > 0) {
+        const ruleSet = new Set(input.rules);
+        findings = findings.filter((f) => ruleSet.has(f.ruleId));
+      }
+      const criticalCount = findings.filter((f) => f.severity === "critical").length;
+      const warningCount = findings.filter((f) => f.severity === "warning").length;
+      const totalFindings = findings.length;
+      const status = totalFindings === 0 ? "clean" : "findings_detected";
+      const summary = totalFindings === 0 ? `Security & Performance AST Scan: CLEAN (${targetFile})` : `Security & Performance AST Scan: ${totalFindings} issue(s) detected (${criticalCount} critical, ${warningCount} warning).`;
+      return {
+        status,
+        filesScanned: 1,
+        totalFindings,
+        criticalCount,
+        warningCount,
+        findings,
+        summary
+      };
+    } catch (err) {
+      return {
+        status: "error",
+        filesScanned: 0,
+        totalFindings: 0,
+        criticalCount: 0,
+        warningCount: 0,
+        findings: [],
+        summary: "",
+        error: toErrorMessage2(err)
+      };
+    }
+  }
+};
+
+// src/set-working-dir.ts
+import * as fs2 from "node:fs/promises";
+import { toErrorMessage as toErrorMessage3 } from "@wrongstack/core/utils";
+var setWorkingDirTool = {
+  name: "set_working_dir",
+  category: "Context",
+  description: "Change the current working directory for subsequent file operations and shell tools (`bash`/`exec` spawn in this directory unless given an explicit cwd). The new directory must be inside the project root. Use this to navigate between subdirectories when working on files in different parts of the project.",
+  usageHint: "Change the working directory so relative paths in subsequent tool calls resolve from a different directory. Pass `path` to set a new directory, or omit to query the current one. The directory must exist and be inside the project root.",
+  permission: "confirm",
+  mutating: true,
+  capabilities: ["fs.read"],
+  icon: "settings",
+  timeoutMs: 5e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Directory to navigate to. Can be relative (to projectRoot) or absolute. If omitted, returns the current working directory without changing it."
+      }
+    }
+  },
+  async execute(input, ctx, _opts) {
+    if (!input.path) {
+      return {
+        current: ctx.workingDir,
+        message: `Current working directory is ${ctx.workingDir}`
+      };
+    }
+    const previous = ctx.workingDir;
+    let resolved;
+    try {
+      resolved = ctx.setWorkingDir(input.path);
+    } catch (err) {
+      return {
+        current: ctx.workingDir,
+        error: toErrorMessage3(err)
+      };
+    }
+    let isDirectory = false;
+    try {
+      isDirectory = (await fs2.stat(resolved)).isDirectory();
+    } catch {
+      isDirectory = false;
+    }
+    if (!isDirectory) {
+      try {
+        ctx.setWorkingDir(previous);
+      } catch {
+      }
+      return {
+        current: ctx.workingDir,
+        error: `Directory does not exist (or is not a directory): ${resolved}`
+      };
+    }
+    return {
+      current: resolved,
+      previous,
+      message: `Working directory changed to ${resolved}`
+    };
+  }
+};
+
+// src/builtin.ts
+var OPTIONAL_TOOLS = [
+  ...browserTools,
+  e2ePlanTool,
+  installTool,
+  auditTool,
+  outdatedTool,
+  logsTool,
+  documentTool,
+  scaffoldTool,
+  toolSearchTool,
+  toolUseTool,
+  batchToolUseTool,
+  toolHelpTool,
+  setWorkingDirTool
+];
+var OFF_ONLY_TOOLS = [...browserTools, e2ePlanTool];
+var TIER1_TOOLS = [
+  readTool,
+  writeTool,
+  editTool,
+  clarifyTool,
+  codebaseAstReplaceTool,
+  codebaseInvariantCheckTool,
+  codebaseStatsTool,
+  codebaseSearchTool,
+  codebaseSkeletonTool,
+  codebaseRepoMapTool,
+  codebaseImpactAnalysisTool,
+  codebaseTargetedTestTool,
+  securityAstScanTool,
+  codebaseIncomingCallsTool,
+  codebaseOutgoingCallsTool,
+  codebaseIndexTool,
+  bashTool,
+  grepTool,
+  globTool,
+  diffTool,
+  patchTool,
+  jsonTool,
+  searchTool
+];
+var TIER2_TOOLS = [
+  replaceTool,
+  execTool,
+  pwshTool,
+  fetchTool,
+  gitTool,
+  treeTool,
+  lintTool,
+  formatTool,
+  typecheckTool,
+  testTool,
+  languageInfoTool,
+  languageTool,
+  languagePackageTool,
+  todoTool,
+  planTool,
+  kanbanTool,
+  taskTool,
+  installTool,
+  auditTool,
+  designTool
+];
+var TIER3_TOOLS = [
+  outdatedTool,
+  logsTool,
+  documentTool,
+  scaffoldTool,
+  deadCodeScanTool,
+  toolSearchTool,
+  toolUseTool,
+  batchToolUseTool,
+  toolHelpTool,
+  setWorkingDirTool
+];
+var builtinTools = [
+  ...browserTools,
+  e2ePlanTool,
+  readTool,
+  writeTool,
+  editTool,
+  clarifyTool,
+  codebaseAstReplaceTool,
+  codebaseInvariantCheckTool,
+  codebaseStatsTool,
+  codebaseSearchTool,
+  codebaseSkeletonTool,
+  codebaseRepoMapTool,
+  codebaseImpactAnalysisTool,
+  codebaseTargetedTestTool,
+  securityAstScanTool,
+  codebaseIncomingCallsTool,
+  codebaseOutgoingCallsTool,
+  codebaseIndexTool,
+  deadCodeScanTool,
+  replaceTool,
+  globTool,
+  grepTool,
+  bashTool,
+  execTool,
+  pwshTool,
+  fetchTool,
+  searchTool,
+  todoTool,
+  planTool,
+  kanbanTool,
+  taskTool,
+  gitTool,
+  patchTool,
+  jsonTool,
+  diffTool,
+  treeTool,
+  lintTool,
+  formatTool,
+  typecheckTool,
+  testTool,
+  languageInfoTool,
+  languageTool,
+  languagePackageTool,
+  installTool,
+  auditTool,
+  outdatedTool,
+  logsTool,
+  documentTool,
+  scaffoldTool,
+  designTool,
+  toolSearchTool,
+  toolUseTool,
+  batchToolUseTool,
+  toolHelpTool,
+  setWorkingDirTool
+];
+
+export {
+  clarifyTool,
+  PWSH_TOOL_DESCRIPTION,
+  pwshTool,
+  analyzeSecurityAndPerformance,
+  securityAstScanTool,
+  OPTIONAL_TOOLS,
+  OFF_ONLY_TOOLS,
+  TIER1_TOOLS,
+  TIER2_TOOLS,
+  TIER3_TOOLS,
+  builtinTools
+};
+//# sourceMappingURL=chunk-URFKEIHM.js.map