@wrongstack/plugins 0.275.1 → 0.276.3

package/dist/index.js

@@ -2,9 +2,7 @@ import { execFileSync, execSync } from 'child_process';
 import { watch, existsSync, readFileSync, writeFileSync, readdirSync } from 'fs';
 import * as path from 'path';
 import { isAbsolute, join } from 'path';
-import { expectDefined, deepMerge as deepMerge$1, isPrivateIPv4, isPrivateIPv6 } from '@wrongstack/core';
-import { lookup } from 'dns/promises';
-import { isIPv4, isIPv6 } from 'net';
+import { expectDefined } from '@wrongstack/core';
 import { toErrorMessage } from '@wrongstack/core/utils';
 
 // src/auto-doc/index.ts
@@ -126,7 +124,7 @@ async function runAutoDoc(input, api) {
         modified = injectDocComment(modified, entity, doc);
         results.push({ file, entity: entity.name });
       }
-      if (!input.dryRun && results.length > 0) {
+      if (!input.dry_run && results.length > 0) {
         writeFileSync2(file, modified, "utf-8");
         api.log.info(`auto-doc: updated ${file}`);
       }
@@ -136,31 +134,9 @@ async function runAutoDoc(input, api) {
   }
   return { ok: true, filesProcessed: input.files.length, changes: results };
 }
-async function runAutoDocPreview(input, api) {
-  if (!input.files || typeof input.files !== "object" || !Array.isArray(input.files)) {
-    return { ok: false, error: "input.files must be an array of file paths", previews: [] };
-  }
-  if (input.files.length === 0) {
-    return { ok: false, error: "input.files is empty \u2014 provide at least one file path", previews: [] };
-  }
-  const includeTypes = api.config.extensions?.["auto-doc"]?.["includeTypes"] ?? false;
-  const previews = [];
-  for (const file of input.files) {
-    try {
-      const { readFileSync: readFileSync2 } = await import('fs');
-      const content = readFileSync2(file, "utf-8");
-      const entities = parseSource(content);
-      const generated = entities.filter((e) => needsDocComment(content, e)).map((e) => generateDocComment(e, includeTypes));
-      previews.push({ file, entities: generated });
-    } catch {
-      api.log.warn(`auto-doc-preview: could not read file ${file}`);
-    }
-  }
-  return { ok: true, previews };
-}
 var plugin = {
   name: "auto-doc",
-  version: "0.1.0",
+  version: "0.2.0",
   description: "Auto-generates JSDoc/TSDoc comments for functions, classes, types, and interfaces",
   apiVersion: AUTO_DOC_API_VERSION,
   capabilities: { tools: true, pipelines: ["toolCall"] },
@@ -176,41 +152,25 @@ var plugin = {
   setup(api) {
     api.tools.register({
       name: "auto_doc",
-      description: "Auto-generate JSDoc/TSDoc comments for functions, classes, types, and interfaces in source files",
+      description: "Auto-generate JSDoc/TSDoc comments for functions, classes, types, and interfaces in source files. Set `dry_run: true` to preview without writing.",
       inputSchema: {
         type: "object",
         properties: {
           files: { type: "array", items: { type: "string" }, description: "Source files to document" },
           style: { type: "string", enum: ["jsdoc", "tsdoc"], default: "tsdoc", description: "Comment style" },
           force: { type: "boolean", default: false, description: "Overwrite existing docstrings" },
-          dryRun: { type: "boolean", default: false, description: "Preview without writing" }
+          dry_run: { type: "boolean", default: false, description: "Preview generated comments without writing to files" }
         },
         required: ["files"]
       },
       permission: "auto",
       mutating: true,
+      category: "Project",
       async execute(input) {
         return runAutoDoc(input, api);
       }
     });
-    api.tools.register({
-      name: "auto_doc_preview",
-      description: "Preview what JSDoc/TSDoc comments would be generated for files, without writing",
-      inputSchema: {
-        type: "object",
-        properties: {
-          files: { type: "array", items: { type: "string" }, description: "Source files to preview" },
-          style: { type: "string", enum: ["jsdoc", "tsdoc"], default: "tsdoc" }
-        },
-        required: ["files"]
-      },
-      permission: "auto",
-      mutating: false,
-      async execute(input) {
-        return runAutoDocPreview(input, api);
-      }
-    });
-    api.log.info("auto-doc plugin loaded", { version: "0.1.0", capabilities: ["auto_doc", "auto_doc_preview"] });
+    api.log.info("auto-doc plugin loaded", { version: "0.2.0", capabilities: ["auto_doc"] });
   },
   teardown(api) {
     api.log.info("auto-doc plugin unloaded");
@@ -257,19 +217,6 @@ function stageFiles(files, cwd) {
 function commitWithMessage(message, cwd) {
   return runGit(["commit", "-m", message], cwd);
 }
-function getCommitHistory(since, cwd) {
-  const range = `${since}..HEAD` ;
-  const output = runGit(["log", range, "--format=%H %s"], cwd);
-  if (!output) return [];
-  return output.split("\n").filter(Boolean).map((line) => {
-    const spaceIdx = line.indexOf(" ");
-    const hash = line.slice(0, spaceIdx);
-    const message = line.slice(spaceIdx + 1);
-    const typeMatch = message.match(/^(\w+)(!)?:\s/);
-    const type = typeMatch?.[1] ?? "chore";
-    return { hash, message, type };
-  });
-}
 function getWorktrees(cwd) {
   try {
     const out = runGit(["worktree", "list", "--porcelain"], cwd);
@@ -333,7 +280,7 @@ ${body}` : "";
 }
 var plugin2 = {
   name: "git-autocommit",
-  version: "0.1.0",
+  version: "0.2.0",
   description: "AI-powered git staging and conventional commit message generation",
   apiVersion: API_VERSION,
   capabilities: { tools: true },
@@ -376,10 +323,11 @@ var plugin2 = {
           scope: { type: "string", description: "Commit scope (e.g. auth, api, ui)" },
           message: { type: "string", description: "Commit summary message" },
           body: { type: "string", description: "Optional commit body/description" },
-          dryRun: { type: "boolean", default: false, description: "Show what would be committed without committing" }
+          dry_run: { type: "boolean", default: false, description: "Show what would be committed without committing" }
         }
       },
       permission: "confirm",
+      category: "Git",
       mutating: true,
       async execute(input, _ctx) {
         try {
@@ -387,13 +335,13 @@ var plugin2 = {
           const scope = input["scope"];
           const summary = input["message"] ?? "";
           const body = input["body"];
-          const dryRun = input["dryRun"] ?? false;
+          const dryRun = input["dry_run"] ?? false;
           const validTypes = ["feat", "fix", "docs", "style", "refactor", "test", "chore", "perf", "ci", "build", "revert"];
           if (!type || !validTypes.includes(type)) {
             if (dryRun) {
               return {
                 ok: true,
-                dryRun: true,
+                dry_run: true,
                 message: `Would create: ${summary || "update code"}`
               };
             }
@@ -454,7 +402,7 @@ var plugin2 = {
           if (dryRun) {
             return {
               ok: true,
-              dryRun: true,
+              dry_run: true,
               message: `Would create: ${msg}`,
               warning: warning ?? void 0,
               stagedDiff: `
@@ -516,126 +464,8 @@ ${preCommitDiff}
         }
       }
     });
-    api.tools.register({
-      name: "git_stage",
-      description: "Stage specific files for commit. Shows what would be staged without staging if dryRun is true.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          files: { type: "array", items: { type: "string" }, description: "Files to stage" },
-          dryRun: { type: "boolean", default: false }
-        },
-        required: ["files"]
-      },
-      permission: "confirm",
-      mutating: true,
-      async execute(input) {
-        try {
-          let files;
-          try {
-            files = input["files"] ?? [];
-          } catch {
-            files = [];
-          }
-          const dryRun = input["dryRun"] ?? false;
-          if (!Array.isArray(files) || files.length === 0) {
-            return { ok: false, error: "files must be a non-empty array of file paths" };
-          }
-          if (dryRun) {
-            return { ok: true, dryRun: true, files, message: `Would stage: ${files.join(", ")}` };
-          }
-          try {
-            stageFiles(files);
-          } catch (err) {
-            return { ok: false, error: `Failed to stage files: ${err instanceof Error ? err.message : String(err)}` };
-          }
-          let stillChanged = [];
-          try {
-            stillChanged = getChangedFiles();
-          } catch {
-            stillChanged = [];
-          }
-          return {
-            ok: true,
-            staged: files,
-            stillChanged,
-            message: `Staged ${files.length} file(s). ${stillChanged.length} file(s) still changed.`
-          };
-        } catch (err) {
-          return { ok: false, error: `git_stage error: ${err instanceof Error ? err.message : String(err)}` };
-        }
-      }
-    });
-    api.tools.register({
-      name: "git_status_summary",
-      description: "Returns a summary of the current git repository status: changed files, staged files, current branch, and recent commits.",
-      inputSchema: { type: "object", properties: {} },
-      permission: "auto",
-      mutating: false,
-      async execute() {
-        let branch = "";
-        let changed = [];
-        let staged = [];
-        let aheadBehind = "";
-        const recentCommits = [];
-        let worktrees = [];
-        let worktreeWarn = null;
-        let externalChanges = null;
-        try {
-          branch = runGit(["branch", "--show-current"]);
-        } catch {
-        }
-        try {
-          changed = getChangedFiles();
-        } catch {
-        }
-        try {
-          staged = getStagedFiles();
-        } catch {
-        }
-        try {
-          aheadBehind = runGit(["status", "-sb"]).split("\n")[0] ?? "";
-        } catch {
-        }
-        try {
-          recentCommits.push(...getCommitHistory("-3", void 0).map((c) => ({ hash: (c.hash ?? "").slice(0, 7), message: c.message })));
-        } catch {
-        }
-        try {
-          worktrees = getWorktrees();
-        } catch {
-        }
-        try {
-          worktreeWarn = simultaneousEditWarning();
-        } catch {
-        }
-        try {
-          const out = runGit(["status", "--porcelain"]);
-          const unstaged = out.split("\n").filter((l) => {
-            const idx = l[0] ?? " ";
-            return idx === " " || idx === "?";
-          }).map((l) => l.slice(3).trim()).filter(Boolean);
-          externalChanges = unstaged.length > 0 ? unstaged : null;
-        } catch {
-        }
-        return {
-          ok: true,
-          branch,
-          changedFiles: changed,
-          stagedFiles: staged,
-          aheadBehind,
-          recentCommits,
-          worktrees: worktrees.length > 0 ? worktrees.map((w) => ({
-            path: w.path,
-            branch: w.branch.replace("refs/heads/", "")
-          })) : [],
-          worktreeWarning: worktreeWarn ?? void 0,
-          externalChanges: externalChanges ?? void 0
-        };
-      }
-    });
     api.log.info("git-autocommit plugin loaded", {
-      version: "0.1.0",
+      version: "0.2.0",
       conventionalCommits: opts.conventionalCommits
     });
   }
@@ -710,7 +540,7 @@ function findShellFiles(dir, pattern) {
 }
 var plugin3 = {
   name: "shell-check",
-  version: "0.1.0",
+  version: "0.2.0",
   description: "Runs shellcheck analysis on bash/shell scripts and surfaces issues with severity levels",
   apiVersion: API_VERSION2,
   capabilities: { tools: true, pipelines: ["toolCall"] },
@@ -732,14 +562,24 @@ var plugin3 = {
   setup(api) {
     api.tools.register({
       name: "shellcheck",
-      description: "Run shellcheck analysis on shell script files. Returns issues with file, line, column, severity, code, and message.",
+      description: "Run shellcheck analysis on shell script files. Pass `files` for specific files, or `directory` (optionally with `pattern`) to recursively scan for .sh files. Returns issues with file, line, column, severity, code, and message.",
       inputSchema: {
         type: "object",
         properties: {
           files: {
             type: "array",
             items: { type: "string" },
-            description: "Shell script files to check"
+            description: "Shell script files to check. Mutually exclusive with `directory`."
+          },
+          directory: {
+            type: "string",
+            default: ".",
+            description: "Directory to recursively scan for .sh files. Used when `files` is omitted."
+          },
+          pattern: {
+            type: "string",
+            default: "",
+            description: "Filename pattern to match when scanning a directory (default: all .sh files)."
           },
           severity: {
             type: "string",
@@ -752,20 +592,39 @@ var plugin3 = {
             default: false,
             description: "Apply safe automatic fixes where possible"
           }
-        },
-        required: ["files"]
+        }
       },
       permission: "auto",
+      category: "Code Quality",
       mutating: true,
       async execute(input) {
         const files = input["files"];
+        const directory = input["directory"] ?? ".";
+        const pattern = input["pattern"] ?? "";
         const severity = input["severity"] ?? "warning";
+        let checkFiles;
+        let scannedDirectories = false;
+        if (files && files.length > 0) {
+          checkFiles = files;
+        } else {
+          checkFiles = findShellFiles(directory, pattern);
+          scannedDirectories = true;
+        }
+        if (checkFiles.length === 0) {
+          return {
+            ok: true,
+            filesScanned: 0,
+            issues: [],
+            summary: { total: 0 },
+            mode: scannedDirectories ? "directory" : "files"
+          };
+        }
         let issues;
         try {
-          issues = runShellCheck(files, severity);
+          issues = runShellCheck(checkFiles, severity);
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
-          return { ok: false, error: msg, issues: [] };
+          return { ok: false, error: msg, issues: [], filesScanned: 0 };
         }
         const byFile = {};
         for (const issue of issues) {
@@ -779,10 +638,12 @@ var plugin3 = {
         const infoCount = issues.filter((i) => i.level === "info").length;
         const styleCount = issues.filter((i) => i.level === "style").length;
         api.metrics.counter("issues_found", issues.length, { severity });
-        api.metrics.histogram("issues_per_file", issues.length / Math.max(files.length, 1));
+        api.metrics.histogram("issues_per_file", issues.length / Math.max(checkFiles.length, 1));
         return {
           ok: true,
-          filesScanned: files.length,
+          mode: scannedDirectories ? "directory" : "files",
+          filesScanned: checkFiles.length,
+          filesWithIssues: Object.keys(byFile).length,
           issues,
           summary: {
             total: issues.length,
@@ -796,68 +657,7 @@ var plugin3 = {
         };
       }
     });
-    api.tools.register({
-      name: "shellcheck_scan",
-      description: "Recursively scan a directory for shell scripts and run shellcheck on all found files.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          directory: {
-            type: "string",
-            default: ".",
-            description: "Directory to scan"
-          },
-          pattern: {
-            type: "string",
-            default: "",
-            description: "Filename pattern to match (default: all .sh files)"
-          },
-          severity: {
-            type: "string",
-            enum: ["error", "warning", "info", "style"],
-            default: "warning"
-          }
-        }
-      },
-      permission: "auto",
-      mutating: true,
-      async execute(input) {
-        const dir = input["directory"] ?? ".";
-        const pattern = input["pattern"] ?? "";
-        const severity = input["severity"] ?? "warning";
-        const files = findShellFiles(dir, pattern);
-        if (files.length === 0) {
-          return { ok: true, filesScanned: 0, issues: [], summary: { total: 0 } };
-        }
-        let issues;
-        try {
-          issues = runShellCheck(files, severity);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return { ok: false, error: msg, issues: [], filesScanned: 0 };
-        }
-        const byFile = {};
-        for (const issue of issues) {
-          if (byFile[issue.file] === void 0) {
-            byFile[issue.file] = [];
-          }
-          byFile[issue.file]?.push(issue);
-        }
-        return {
-          ok: true,
-          filesScanned: files.length,
-          filesWithIssues: Object.keys(byFile).length,
-          issues,
-          summary: {
-            total: issues.length,
-            errors: issues.filter((i) => i.level === "error").length,
-            warnings: issues.filter((i) => i.level === "warning").length
-          },
-          byFile
-        };
-      }
-    });
-    api.log.info("shell-check plugin loaded", { version: "0.1.0" });
+    api.log.info("shell-check plugin loaded", { version: "0.2.0" });
   }
 };
 var shell_check_default = plugin3;
@@ -951,6 +751,7 @@ var plugin4 = {
       description: "Returns the current session's token usage breakdown by model, total cost estimate, and budget status.",
       inputSchema: { type: "object", properties: {} },
       permission: "auto",
+      category: "Meta",
       mutating: false,
       async execute() {
         const { budgetLimit, warningThreshold } = readCostTrackerConfig(
@@ -1079,9 +880,9 @@ var plugin4 = {
 };
 var cost_tracker_default = plugin4;
 var API_VERSION4 = "^0.1.10";
-var watchIdCounter = 0;
+var watch_idCounter = 0;
 function nextId() {
-  return `watch_${++watchIdCounter}_${Date.now().toString(36)}`;
+  return `watch_${++watch_idCounter}_${Date.now().toString(36)}`;
 }
 var watches = /* @__PURE__ */ new Map();
 var debounceTimers = /* @__PURE__ */ new Map();
@@ -1166,7 +967,7 @@ var plugin5 = {
           const key = `${handle.id}:${fullPath}:${eventType}`;
           debounceEvent(key, () => {
             api.emitCustom("file-watcher:changed", {
-              watchId: handle.id,
+              watch_id: handle.id,
               path: fullPath,
               event: eventType,
               filename,
@@ -1227,15 +1028,16 @@ var plugin5 = {
         required: ["paths"]
       },
       permission: "confirm",
+      category: "Filesystem",
       mutating: false,
       async execute(input) {
         const rawPaths = input["paths"];
         if (!rawPaths || typeof rawPaths !== "object" || !Array.isArray(rawPaths)) {
-          return { ok: false, error: "paths must be an array of file/directory paths", watchId: null };
+          return { ok: false, error: "paths must be an array of file/directory paths", watch_id: null };
         }
         const paths = rawPaths;
         if (paths.length === 0) {
-          return { ok: false, error: "paths array is empty \u2014 provide at least one path", watchId: null };
+          return { ok: false, error: "paths array is empty \u2014 provide at least one path", watch_id: null };
         }
         const events = input["events"] ?? ["change", "add", "delete"];
         const recursive = input["recursive"] ?? true;
@@ -1255,7 +1057,7 @@ var plugin5 = {
         api.metrics.gauge("active_watches", watches.size);
         return {
           ok: true,
-          watchId: id,
+          watch_id: id,
           paths,
           events,
           recursive,
@@ -1269,17 +1071,17 @@ var plugin5 = {
       inputSchema: {
         type: "object",
         properties: {
-          watchId: { type: "string", description: "Watch ID returned by watch_start" }
+          watch_id: { type: "string", description: "Watch ID returned by watch_start" }
         },
-        required: ["watchId"]
+        required: ["watch_id"]
       },
       permission: "auto",
       mutating: false,
       async execute(input) {
-        const watchId = input["watchId"];
-        const handle = watches.get(watchId);
+        const watch_id = input["watch_id"];
+        const handle = watches.get(watch_id);
         if (!handle) {
-          return { ok: false, error: `No active watch with ID: ${watchId}` };
+          return { ok: false, error: `No active watch with ID: ${watch_id}` };
         }
         for (const w of handle.watchers) {
           try {
@@ -1287,12 +1089,12 @@ var plugin5 = {
           } catch {
           }
         }
-        watches.delete(watchId);
+        watches.delete(watch_id);
         api.metrics.gauge("active_watches", watches.size);
         return {
           ok: true,
-          watchId,
-          message: `Stopped watch ${watchId}. ${watches.size} watch(es) remaining.`
+          watch_id,
+          message: `Stopped watch ${watch_id}. ${watches.size} watch(es) remaining.`
         };
       }
     });
@@ -1339,568 +1141,31 @@ var plugin5 = {
   }
 };
 var file_watcher_default = plugin5;
-var API_VERSION5 = "^0.1.10";
-async function duckduckgoSearch(query, numResults) {
-  const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}&kl=us-en`;
-  const resp = await fetch(url, {
-    headers: {
-      "User-Agent": "Mozilla/5.0 (compatible; WrongStack/1.0; +https://wrongstack.com)"
-    }
-  });
-  if (!resp.ok) throw new Error(`DuckDuckGo search failed: ${resp.status}`);
-  const html = await resp.text();
-  const results = [];
-  const resultRe = /<a\b[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>([\s\S]*?)(?=<a\b[^>]*class="[^"]*result__a[^"]*"|<\/body>|$)/gi;
-  let m;
-  while ((m = resultRe.exec(html)) !== null && results.length < numResults) {
-    const url2 = normalizeDuckDuckGoUrl(m[1]);
-    if (!url2) continue;
-    const title = htmlToText(m[2] ?? "");
-    const snippet = extractDuckDuckGoSnippet(m[3] ?? "");
-    results.push({
-      url: url2,
-      title,
-      snippet,
-      score: 1,
-      source: "duckduckgo",
-      cached: false
-    });
-  }
-  if (results.length === 0 && /result__a|result__snippet|result__body|anomaly-modal|captcha/i.test(html)) {
-    throw new Error("DuckDuckGo response format was not recognized or was blocked");
-  }
-  return results;
-}
-function normalizeDuckDuckGoUrl(rawUrl) {
-  if (!rawUrl) return null;
-  let url = htmlToText(rawUrl);
-  if (url.startsWith("//duckduckgo.com/l/")) url = `https:${url}`;
-  if (url.startsWith("/l/")) url = new URL(url, "https://duckduckgo.com").toString();
-  try {
-    const parsed = new URL(url);
-    const redirected = parsed.searchParams.get("uddg");
-    if (redirected) return redirected;
-    return parsed.toString();
-  } catch {
-    return null;
-  }
-}
-function htmlToText(html) {
-  return html.replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s+/g, " ").trim();
-}
-function extractDuckDuckGoSnippet(html) {
-  const snippetRe = /<(?:a|div)\b[^>]*class="[^"]*(?:result__snippet|result__body)[^"]*"[^>]*>([\s\S]*?)<\/(?:a|div)>/i;
-  const snippetMatch = snippetRe.exec(html);
-  return htmlToText(snippetMatch?.[1] ?? "");
-}
-function assertSafeIp(ip) {
-  if (isIPv4(ip) && isPrivateIPv4(ip)) {
-    throw new Error(`Blocked private/loopback address: ${ip}`);
-  }
-  if (isIPv6(ip) && isPrivateIPv6(ip)) {
-    throw new Error(`Blocked private/loopback address: ${ip}`);
-  }
-}
-async function assertSafeUrl(rawUrl) {
-  const u = new URL(rawUrl);
-  if (u.protocol !== "http:" && u.protocol !== "https:") {
-    throw new Error(`Unsupported protocol: ${u.protocol}`);
-  }
-  const host = u.hostname.startsWith("[") && u.hostname.endsWith("]") ? u.hostname.slice(1, -1) : u.hostname;
-  if (host === "localhost" || host.endsWith(".localhost") || host === "" || host === "0.0.0.0") {
-    throw new Error("Blocked localhost target");
-  }
-  if (isIPv4(host) || isIPv6(host)) {
-    assertSafeIp(host);
-    return;
-  }
-  let addrs;
-  try {
-    addrs = await lookup(host, { all: true });
-  } catch {
-    throw new Error(`Could not resolve host: ${host}`);
-  }
-  for (const { address } of addrs) assertSafeIp(address);
-}
-async function fetchUrl(url, format) {
-  const MAX_REDIRECTS = 5;
-  let currentUrl = url;
-  let resp;
-  for (let i = 0; i <= MAX_REDIRECTS; i++) {
-    await assertSafeUrl(currentUrl);
-    resp = await fetch(currentUrl, {
-      redirect: "manual",
-      headers: {
-        "User-Agent": "Mozilla/5.0 (compatible; WrongStack/1.0; +https://wrongstack.com)",
-        Accept: format === "text" ? "text/plain" : "text/html"
-      }
-    });
-    if (resp.status >= 300 && resp.status < 400) {
-      const loc = resp.headers.get("location");
-      if (!loc) break;
-      currentUrl = new URL(loc, currentUrl).toString();
-      if (i === MAX_REDIRECTS) throw new Error("Too many redirects");
-      continue;
-    }
-    break;
-  }
-  if (!resp) throw new Error(`Failed to fetch ${url}`);
-  if (!resp.ok) throw new Error(`Failed to fetch ${url}: ${resp.status} ${resp.statusText}`);
-  if (format === "text") {
-    return resp.text();
-  }
-  let html = await resp.text();
-  html = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
-  html = html.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
-  html = html.replace(/<h[1-6][^>]*>([\s\S]*?)<\/h[1-6]>/gi, (_, t) => `
-## ${t.trim()}
-`);
-  html = html.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, (_, t) => `${t.trim()}
 
-`);
-  html = html.replace(/<br\s*\/?>/gi, "\n");
-  html = html.replace(/<[^>]+>/g, "");
-  html = html.replace(/&amp;/g, "&");
-  html = html.replace(/&lt;/g, "<");
-  html = html.replace(/&gt;/g, ">");
-  html = html.replace(/&quot;/g, '"');
-  html = html.replace(/&#39;/g, "'");
-  html = html.replace(/\n{3,}/g, "\n\n");
-  return html.trim().slice(0, 5e4);
-}
-function scoreResults(results, query) {
-  const terms = query.toLowerCase().split(/\s+/);
-  return results.map((r) => {
-    const titleLower = r.title.toLowerCase();
-    const snippetLower = r.snippet.toLowerCase();
-    let score = r.score;
-    for (const term of terms) {
-      if (titleLower.includes(term)) score += 2;
-      if (snippetLower.includes(term)) score += 1;
-    }
-    return { ...r, score };
-  }).sort((a, b) => b.score - a.score);
-}
+// src/web-search/index.ts
+var API_VERSION5 = "^0.1.10";
 var plugin6 = {
   name: "web-search",
-  version: "0.1.0",
-  description: "Cached web search with deduplication and relevance ranking",
+  version: "0.3.0",
+  description: "Retired \u2014 capabilities merged into built-in search and fetch tools",
   apiVersion: API_VERSION5,
-  capabilities: { tools: true, pipelines: ["request"] },
-  defaultConfig: {
-    cacheTtlMs: 3e5,
-    maxResults: 10,
-    userAgent: "WrongStack/1.0"
-  },
-  configSchema: {
-    type: "object",
-    properties: {
-      cacheTtlMs: { type: "number", default: 3e5 },
-      maxResults: { type: "number", default: 10 },
-      userAgent: { type: "string", default: "WrongStack/1.0" }
-    }
-  },
+  capabilities: { tools: true },
   setup(api) {
-    const cache = /* @__PURE__ */ new Map();
-    const cacheTtlMs = api.config.extensions?.["web-search"]?.["cacheTtlMs"] ?? 3e5;
-    const maxResults = api.config.extensions?.["web-search"]?.["maxResults"] ?? 10;
-    api.tools.register({
-      name: "web_search",
-      description: "Search the web using DuckDuckGo with automatic caching and deduplication. Results are cached for faster subsequent queries.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query" },
-          numResults: { type: "number", default: 10, description: "Maximum number of results" },
-          source: { type: "string", enum: ["duckduckgo"], default: "duckduckgo", description: "Search engine" },
-          skipCache: { type: "boolean", default: false, description: "Skip cache and force fresh search" }
-        },
-        required: ["query"]
-      },
-      permission: "auto",
-      mutating: true,
-      async execute(input) {
-        const query = input["query"];
-        if (!query || typeof query !== "string" || query.trim() === "") {
-          return { ok: false, error: "query is required and must be a non-empty string", results: [] };
-        }
-        const numResults = input["numResults"] ?? maxResults;
-        const skipCache = input["skipCache"] ?? false;
-        if (!skipCache) {
-          const cached = cache.get(query);
-          if (cached && Date.now() - cached.timestamp < cacheTtlMs) {
-            const results = cached.results.map((r) => ({ ...r, cached: true }));
-            api.metrics.counter("cache_hit", 1, { query: query.slice(0, 20) });
-            return {
-              ok: true,
-              query,
-              cached: true,
-              results: results.slice(0, numResults),
-              count: results.length
-            };
-          }
-        }
-        api.metrics.counter("cache_miss", 1, { query: query.slice(0, 20) });
-        const seenUrls = /* @__PURE__ */ new Set();
-        let rawResults;
-        try {
-          rawResults = await duckduckgoSearch(query, numResults * 2);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return { ok: false, error: `Search failed: ${msg}`, results: [] };
-        }
-        const deduplicated = [];
-        for (const r of rawResults) {
-          const noQuery = r.url.split("?")[0] ?? r.url;
-          const normalized = noQuery.split("#")[0] ?? r.url;
-          if (!seenUrls.has(normalized) && r.url.startsWith("http")) {
-            seenUrls.add(normalized);
-            deduplicated.push(r);
-          }
-        }
-        const ranked = scoreResults(deduplicated, query);
-        cache.set(query, { results: ranked, timestamp: Date.now() });
-        const now = Date.now();
-        for (const [key, entry] of cache.entries()) {
-          if (now - entry.timestamp > cacheTtlMs * 2) cache.delete(key);
-        }
-        return {
-          ok: true,
-          query,
-          cached: false,
-          results: ranked.slice(0, numResults),
-          count: ranked.length
-        };
-      }
-    });
-    api.tools.register({
-      name: "web_fetch",
-      description: "Fetch a URL and return its content as markdown or plain text.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          url: { type: "string", format: "uri", description: "URL to fetch" },
-          format: { type: "string", enum: ["markdown", "text"], default: "markdown" }
-        },
-        required: ["url"]
-      },
-      permission: "confirm",
-      mutating: false,
-      async execute(input) {
-        const rawUrl = input["url"];
-        if (!rawUrl || typeof rawUrl !== "string") {
-          return { ok: false, error: "url is required and must be a string" };
-        }
-        const url = rawUrl;
-        const format = input["format"] ?? "markdown";
-        if (!url.startsWith("http://") && !url.startsWith("https://")) {
-          return { ok: false, error: "URL must start with http:// or https://" };
-        }
-        let content;
-        try {
-          content = await fetchUrl(url, format);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          return { ok: false, error: msg };
-        }
-        return {
-          ok: true,
-          url,
-          format,
-          contentLength: content.length,
-          content: content.slice(0, 2e4),
-          truncated: content.length > 2e4
-        };
-      }
-    });
-    api.log.info("web-search plugin loaded", { version: "0.1.0", cacheTtlMs });
+    api.log.info("web-search plugin retired \u2014 use the built-in search and fetch tools");
   }
 };
 var web_search_default = plugin6;
+
+// src/json-path/index.ts
 var API_VERSION6 = "^0.1.10";
-function jmespathSearch(data, query) {
-  if (!query || query === "@") return data;
-  if (query === "$") return data;
-  const dotMatch = query.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(?:\.(.+))?$/);
-  if (dotMatch) {
-    const key = expectDefined(dotMatch[1]);
-    const rest = dotMatch[2];
-    const val = data?.[key];
-    if (rest === void 0) return val;
-    return jmespathSearch(val, rest);
-  }
-  const arrMatch = query.match(/^\[(\d+)\](?:\.(.+))?$/);
-  if (arrMatch) {
-    const idx = Number.parseInt(expectDefined(arrMatch[1]), 10);
-    const rest = arrMatch[2];
-    const arr = data;
-    const val = arr?.[idx];
-    if (rest === void 0) return val;
-    return jmespathSearch(val, rest);
-  }
-  if (query === "[*]") {
-    if (Array.isArray(data)) {
-      return data;
-    }
-    return data;
-  }
-  const multiMatch = query.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\[\*\](?:\.(.+))?$/);
-  if (multiMatch) {
-    const key = expectDefined(multiMatch[1]);
-    const rest = multiMatch[2];
-    const arr = data?.[key];
-    if (!Array.isArray(arr)) return [];
-    if (rest === void 0) return arr;
-    return arr.map((item) => jmespathSearch(item, rest));
-  }
-  const filterMatch = query.match(/^\[\\?([a-zA-Z_][a-zA-Z0-9_]*)(==|!=|<|>|<=|>=)(`[^`]+`|'[^']*')\](?:\.(.+))?$/);
-  if (filterMatch) {
-    const field = expectDefined(filterMatch[1]);
-    const op = expectDefined(filterMatch[2]);
-    const rawVal = expectDefined(filterMatch[3]);
-    const rest = filterMatch[4];
-    const cmpVal = JSON.parse(rawVal.slice(1, -1));
-    const arr = data;
-    if (!Array.isArray(arr)) return [];
-    const filtered = arr.filter((item) => {
-      const itemVal = item[field];
-      switch (op) {
-        case "==":
-          return itemVal === cmpVal;
-        case "!=":
-          return itemVal !== cmpVal;
-        case ">":
-          return Number(itemVal) > Number(cmpVal);
-        case "<":
-          return Number(itemVal) < Number(cmpVal);
-        case ">=":
-          return Number(itemVal) >= Number(cmpVal);
-        case "<=":
-          return Number(itemVal) <= Number(cmpVal);
-        /* v8 ignore next -- op is constrained to the six operators by the filter regex; default is unreachable. */
-        default:
-          return true;
-      }
-    });
-    if (rest === void 0) return filtered;
-    return filtered.map((item) => jmespathSearch(item, rest));
-  }
-  const fnMatch = query.match(/^(length|keys|values|type)\(@\)$/);
-  if (fnMatch) {
-    const fn = expectDefined(fnMatch[1]);
-    switch (fn) {
-      case "length":
-        if (Array.isArray(data)) return data.length;
-        if (typeof data === "string") return data.length;
-        if (typeof data === "object" && data !== null) return Object.keys(data).length;
-        return 0;
-      case "keys":
-        if (typeof data === "object" && data !== null && !Array.isArray(data)) return Object.keys(data);
-        return [];
-      case "values":
-        if (typeof data === "object" && data !== null && !Array.isArray(data)) return Object.values(data);
-        return [];
-      case "type":
-        if (data === null) return "null";
-        if (Array.isArray(data)) return "array";
-        return typeof data;
-      /* v8 ignore next 2 -- fn is constrained to the four names by the function regex; default is unreachable. */
-      default:
-        return null;
-    }
-  }
-  return null;
-}
-function validateJsonSchema(data, schema) {
-  const errors = [];
-  function check(value, s, path2) {
-    if (s["type"]) {
-      const expectedType = s["type"];
-      const actualType = Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
-      if (expectedType === "integer") {
-        if (!Number.isInteger(value)) errors.push(`${path2}: expected integer, got ${actualType}`);
-      } else if (expectedType !== actualType) {
-        errors.push(`${path2}: expected ${expectedType}, got ${actualType}`);
-      }
-    }
-    if (typeof value === "string" && s["format"] === "uri" && value) {
-      try {
-        new URL(value);
-      } catch {
-        errors.push(`${path2}: not a valid URI`);
-      }
-    }
-    if (typeof value === "string" && s["pattern"]) {
-      const re = new RegExp(s["pattern"]);
-      if (!re.test(value)) errors.push(`${path2}: does not match pattern ${s["pattern"]}`);
-    }
-    if (typeof value === "string" && s["minLength"] !== void 0 && value.length < s["minLength"]) {
-      errors.push(`${path2}: string too short (min ${s["minLength"]})`);
-    }
-    if (typeof value === "string" && s["maxLength"] !== void 0 && value.length > s["maxLength"]) {
-      errors.push(`${path2}: string too long (max ${s["maxLength"]})`);
-    }
-    if (typeof value === "number" && s["minimum"] !== void 0 && value < s["minimum"]) {
-      errors.push(`${path2}: below minimum ${s["minimum"]}`);
-    }
-    if (typeof value === "number" && s["maximum"] !== void 0 && value > s["maximum"]) {
-      errors.push(`${path2}: above maximum ${s["maximum"]}`);
-    }
-    if (Array.isArray(value) && s["items"] && Array.isArray(s["items"])) {
-      for (let i = 0; i < value.length; i++) {
-        check(value[i], s["items"], `${path2}[${i}]`);
-      }
-    }
-    if (typeof value === "object" && value !== null && !Array.isArray(value) && s["properties"]) {
-      const props = s["properties"];
-      for (const [k, propSchema] of Object.entries(props)) {
-        check(value[k], propSchema, `${path2}.${k}`);
-      }
-    }
-  }
-  check(data, schema, "$");
-  return { valid: errors.length === 0, errors };
-}
-function deepMerge(base, patch, conflictResolution = "prefer-patch") {
-  return deepMerge$1(base, patch, { conflictResolution });
-}
 var plugin7 = {
   name: "json-path",
-  version: "0.1.0",
-  description: "JMESPath query, JSON Schema validation, transformation, and deep merge for JSON/YAML",
+  version: "0.2.0",
+  description: "Retired \u2014 capabilities merged into the built-in json tool",
   apiVersion: API_VERSION6,
   capabilities: { tools: true },
-  defaultConfig: {
-    strictValidation: false,
-    maxDepth: 50,
-    allowLargeFiles: false
-  },
-  configSchema: {
-    type: "object",
-    properties: {
-      strictValidation: { type: "boolean", default: false },
-      maxDepth: { type: "number", default: 50 },
-      allowLargeFiles: { type: "boolean", default: false }
-    }
-  },
   setup(api) {
-    api.tools.register({
-      name: "jmespath_query",
-      description: "Execute a JMESPath query on JSON or YAML data. Supports dot notation, array indexing, wildcards, filters, and functions.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          data: { description: "JSON/YAML data to query (object or array)" },
-          query: { type: "string", description: "JMESPath query expression" }
-        },
-        required: ["data", "query"]
-      },
-      permission: "auto",
-      mutating: false,
-      async execute(input) {
-        const data = input["data"];
-        const query = input["query"];
-        try {
-          const result = jmespathSearch(data, query);
-          return {
-            ok: true,
-            query,
-            result,
-            resultType: result === null ? "null" : Array.isArray(result) ? "array" : typeof result
-          };
-        } catch (err) {
-          return { ok: false, error: String(err), query };
-        }
-      }
-    });
-    api.tools.register({
-      name: "json_validate",
-      description: "Validate JSON/YAML data against a JSON Schema. Reports all validation errors found.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          data: { description: "JSON data to validate" },
-          schema: { description: "JSON Schema to validate against" }
-        },
-        required: ["data", "schema"]
-      },
-      permission: "auto",
-      mutating: false,
-      async execute(input) {
-        const data = input["data"];
-        const schema = input["schema"];
-        try {
-          const { valid, errors } = validateJsonSchema(data, schema);
-          return { ok: true, valid, errors, errorCount: errors.length };
-        } catch (err) {
-          return { ok: false, error: String(err) };
-        }
-      }
-    });
-    api.tools.register({
-      name: "json_transform",
-      description: "Apply a series of JMESPath transforms to data, passing the output of each as input to the next.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          data: { description: "Initial JSON data" },
-          transforms: {
-            type: "array",
-            items: { type: "string" },
-            description: "Array of JMESPath query strings to apply in sequence"
-          }
-        },
-        required: ["data", "transforms"]
-      },
-      permission: "auto",
-      mutating: false,
-      async execute(input) {
-        const data = input["data"];
-        const transforms = input["transforms"];
-        try {
-          let current = data;
-          const steps = [];
-          for (const t of transforms) {
-            current = jmespathSearch(current, t);
-            steps.push({ transform: t, result: current });
-          }
-          return { ok: true, finalResult: current, steps };
-        } catch (err) {
-          return { ok: false, error: String(err) };
-        }
-      }
-    });
-    api.tools.register({
-      name: "json_merge",
-      description: "Deep merge two JSON objects. Use conflictResolution to decide which value wins on collision.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          base: { description: "Base JSON object" },
-          patch: { description: "Patch JSON object to merge in" },
-          conflictResolution: {
-            type: "string",
-            enum: ["prefer-base", "prefer-patch"],
-            default: "prefer-patch"
-          }
-        },
-        required: ["base", "patch"]
-      },
-      permission: "auto",
-      mutating: false,
-      async execute(input) {
-        const base = input["base"];
-        const patch = input["patch"];
-        const conflictResolution = input["conflictResolution"] ?? "prefer-patch";
-        try {
-          const result = deepMerge(base, patch, conflictResolution);
-          return { ok: true, result };
-        } catch (err) {
-          return { ok: false, error: String(err) };
-        }
-      }
-    });
-    api.log.info("json-path plugin loaded", { version: "0.1.0" });
+    api.log.info("json-path plugin retired \u2014 use the built-in json tool with action: query|validate|transform|merge");
   }
 };
 var json_path_default = plugin7;
@@ -2026,6 +1291,7 @@ var plugin8 = {
         required: ["name", "intervalMs", "action"]
       },
       permission: "confirm",
+      category: "Session",
       mutating: false,
       capabilities: [COORDINATION_CRON_CAPABILITY],
       async execute(input) {
@@ -2215,17 +1481,18 @@ var plugin9 = {
             description: "Variables to substitute into the template",
             additionalProperties: { type: "string" }
           },
-          outputPath: { type: "string", description: "Optional path to write the expanded result" },
+          output_path: { type: "string", description: "Optional path to write the expanded result" },
           raw: { type: "boolean", default: false, description: "Disable HTML auto-escaping" }
         },
         required: ["template", "variables"]
       },
       permission: "auto",
+      category: "Project",
       mutating: true,
       async execute(input) {
         const template = input["template"];
         const variables = input["variables"];
-        const outputPath = input["outputPath"];
+        const output_path = input["output_path"];
         const raw = input["raw"] ?? false;
         if (!template || typeof template !== "string") {
           return { ok: false, error: "template is required and must be a string" };
@@ -2239,17 +1506,17 @@ var plugin9 = {
         } catch (err) {
           return { ok: false, error: String(err) };
         }
-        if (outputPath) {
-          if (isAbsolute(outputPath) || outputPath.includes("..")) {
-            return { ok: false, error: 'outputPath must be a relative path without ".." components' };
+        if (output_path) {
+          if (isAbsolute(output_path) || output_path.includes("..")) {
+            return { ok: false, error: 'output_path must be a relative path without ".." components' };
           }
           const { writeFileSync: writeFileSync2 } = await import('fs');
-          writeFileSync2(outputPath, result, "utf-8");
+          writeFileSync2(output_path, result, "utf-8");
           return {
             ok: true,
-            outputPath,
+            output_path,
             contentLength: result.length,
-            message: `Wrote ${result.length} characters to ${outputPath}`
+            message: `Wrote ${result.length} characters to ${output_path}`
           };
         }
         return {
@@ -2266,26 +1533,26 @@ var plugin9 = {
       inputSchema: {
         type: "object",
         properties: {
-          templatePath: { type: "string", description: "Path to the template file" },
+          template_path: { type: "string", description: "Path to the template file" },
           variables: {
             type: "object",
             description: "Variables to substitute",
             additionalProperties: { type: "string" }
           },
-          outputPath: { type: "string", description: "Optional path to write the rendered result" },
+          output_path: { type: "string", description: "Optional path to write the rendered result" },
           raw: { type: "boolean", default: false }
         },
-        required: ["templatePath", "variables"]
+        required: ["template_path", "variables"]
       },
       permission: "auto",
       mutating: true,
       async execute(input) {
-        const templatePath = input["templatePath"];
+        const template_path = input["template_path"];
         const variables = input["variables"];
-        const outputPath = input["outputPath"];
+        const output_path = input["output_path"];
         const raw = input["raw"] ?? false;
-        if (!templatePath || typeof templatePath !== "string") {
-          return { ok: false, error: "templatePath is required and must be a string" };
+        if (!template_path || typeof template_path !== "string") {
+          return { ok: false, error: "template_path is required and must be a string" };
         }
         if (!variables || typeof variables !== "object") {
           return { ok: false, error: "variables is required and must be an object" };
@@ -2293,7 +1560,7 @@ var plugin9 = {
         let content;
         try {
           const { readFileSync: readFileSync2 } = await import('fs');
-          content = readFileSync2(templatePath, "utf-8");
+          content = readFileSync2(template_path, "utf-8");
         } catch (err) {
           return { ok: false, error: `Could not read template file: ${err}` };
         }
@@ -2303,22 +1570,22 @@ var plugin9 = {
         } catch (err) {
           return { ok: false, error: `Template rendering failed: ${err}` };
         }
-        if (outputPath) {
-          if (isAbsolute(outputPath) || outputPath.includes("..")) {
-            return { ok: false, error: 'outputPath must be a relative path without ".." components' };
+        if (output_path) {
+          if (isAbsolute(output_path) || output_path.includes("..")) {
+            return { ok: false, error: 'output_path must be a relative path without ".." components' };
           }
           const { writeFileSync: writeFileSync2 } = await import('fs');
-          writeFileSync2(outputPath, result, "utf-8");
+          writeFileSync2(output_path, result, "utf-8");
           return {
             ok: true,
-            templatePath,
-            outputPath,
-            message: `Rendered and wrote ${result.length} chars to ${outputPath}`
+            template_path,
+            output_path,
+            message: `Rendered and wrote ${result.length} chars to ${output_path}`
           };
         }
         return {
           ok: true,
-          templatePath,
+          template_path,
           result,
           contentLength: result.length
         };
@@ -2606,7 +1873,7 @@ var plugin10 = {
       if (dryRun) {
         return {
           ok: true,
-          dryRun: true,
+          dry_run: true,
           currentVersion,
           suggestedBump: bumpPart,
           newVersion,
@@ -2676,7 +1943,7 @@ var plugin10 = {
         type: "object",
         properties: {
           cwd: { type: "string", description: "Working directory (defaults to project root)" },
-          dryRun: { type: "boolean", default: false },
+          dry_run: { type: "boolean", default: false },
           part: { type: "string", enum: ["major", "minor", "patch", "auto"], default: defaultPart, description: "Version part to bump. Omitted \u2192 the configured default (/settings semver-part, factory default: patch). Use auto to infer from commits." }
         }
       },
@@ -2684,7 +1951,7 @@ var plugin10 = {
       mutating: true,
       async execute(input) {
         const cwd = input["cwd"];
-        const dryRun = input["dryRun"] ?? false;
+        const dryRun = input["dry_run"] ?? false;
         const part = input["part"] ?? defaultPart;
         return performBump(part, dryRun, cwd);
       }