@wrongstack/plugins 0.1.0

package/dist/index.js

@@ -0,0 +1,2503 @@
+import { execSync } from 'child_process';
+import { watch, existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+// src/auto-doc/index.ts
+var AUTO_DOC_API_VERSION = "^0.1.10";
+function parseSource(content) {
+  const entities = [];
+  const lines = content.split("\n");
+  const reFunction = /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\((.*?)\)(?:\s*:\s*(.+?))?\s*\{/;
+  const reArrowFn = /^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\((.*?)\)\s*(?::\s*(.+?))?\s*=>/;
+  const reClass = /^(?:export\s+)?class\s+(\w+)/;
+  const reType = /^(?:export\s+)?type\s+(\w+)\s*=\s*\{/;
+  const reInterface = /^(?:export\s+)?interface\s+(\w+)/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    let m = line.match(reFunction);
+    if (m) {
+      entities.push({
+        kind: "function",
+        name: m[1],
+        startLine: i + 1,
+        params: m[2] ? m[2].split(",").map((p) => p.trim().split(":")[0].trim()) : [],
+        returnType: m[3]?.trim()
+      });
+      continue;
+    }
+    m = line.match(reArrowFn);
+    if (m) {
+      entities.push({
+        kind: "function",
+        name: m[1],
+        startLine: i + 1,
+        params: m[2] ? m[2].split(",").map((p) => p.trim().split(":")[0].trim()) : [],
+        returnType: m[3]?.trim()
+      });
+      continue;
+    }
+    m = line.match(reClass);
+    if (m) {
+      entities.push({ kind: "class", name: m[1], startLine: i + 1 });
+      continue;
+    }
+    m = line.match(reType);
+    if (m) {
+      entities.push({ kind: "type", name: m[1], startLine: i + 1 });
+      continue;
+    }
+    m = line.match(reInterface);
+    if (m) {
+      entities.push({ kind: "interface", name: m[1], startLine: i + 1 });
+      continue;
+    }
+  }
+  return entities;
+}
+function generateJSDoc(entity, includeTypes) {
+  switch (entity.kind) {
+    case "function": {
+      const params = entity.params.map((p) => `   * @param ${p} - TODO: describe parameter`).join("\n");
+      const returns = entity.returnType ? `
+   * @returns ${includeTypes ? `{${entity.returnType}} ` : ""}TODO: describe return value` : "";
+      return `/**
+   * TODO: One-line description of ${entity.name}
+${params}${returns}
+   */`;
+    }
+    case "class":
+      return `/**
+   * TODO: Describe class ${entity.name}
+   */`;
+    case "type":
+      return `/**
+   * TODO: Describe type ${entity.name}
+   */`;
+    case "interface":
+      return `/**
+   * TODO: Describe interface ${entity.name}
+   */`;
+  }
+}
+function generateTSDoc(entity, includeTypes) {
+  switch (entity.kind) {
+    case "function": {
+      const params = entity.params.map((p) => `   * @param ${p} - TODO: describe parameter`).join("\n");
+      const returns = entity.returnType ? `
+   * @returns ${includeTypes ? `{${entity.returnType}} ` : ""}TODO: describe return value` : "";
+      return `/**
+   * TODO: One-line description of ${entity.name}
+${params}${returns}
+   */`;
+    }
+    case "class":
+      return `/**
+   * TODO: Describe class ${entity.name}
+   */`;
+    case "type":
+      return `/**
+   * TODO: Describe type ${entity.name}
+   */`;
+    case "interface":
+      return `/**
+   * TODO: Describe interface ${entity.name}
+   */`;
+  }
+}
+function needsDocComment(content, entity) {
+  const lines = content.split("\n");
+  const lineIdx = entity.startLine - 1;
+  if (lineIdx < 1) return true;
+  const prevLine = lines[lineIdx - 1] ?? "";
+  return !/^\s*\/\*\*\s*$/.test(prevLine.trim());
+}
+function injectDocComment(content, entity, doc) {
+  const lines = content.split("\n");
+  const idx = entity.startLine - 1;
+  const codeLine = lines[idx] ?? "";
+  const indent = codeLine.match(/^(\s*)/)?.[1] ?? "";
+  lines.splice(idx, 0, `${indent}${doc} ${codeLine.trim()}`);
+  return lines.join("\n");
+}
+async function runAutoDoc(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", filesProcessed: 0, changes: [] };
+  }
+  if (input.files.length === 0) {
+    return { ok: false, error: "input.files is empty \u2014 provide at least one file path", filesProcessed: 0, changes: [] };
+  }
+  const style = input.style ?? "tsdoc";
+  const includeTypes = api.config.extensions?.["auto-doc"]?.["includeTypes"] ?? false;
+  const results = [];
+  for (const file of input.files) {
+    try {
+      const { readFileSync: readFileSync3, writeFileSync } = await import('fs');
+      let content;
+      try {
+        content = readFileSync3(file, "utf-8");
+      } catch {
+        api.log.warn(`auto-doc: could not read file ${file}`);
+        continue;
+      }
+      const entities = parseSource(content);
+      let modified = content;
+      for (const entity of entities) {
+        if (!input.force && !needsDocComment(modified, entity)) continue;
+        const doc = style === "jsdoc" ? generateJSDoc(entity, includeTypes) : generateTSDoc(entity, includeTypes);
+        modified = injectDocComment(modified, entity, doc);
+        results.push({ file, entity: entity.name });
+      }
+      if (!input.dryRun && results.length > 0) {
+        writeFileSync(file, modified, "utf-8");
+        api.log.info(`auto-doc: updated ${file}`);
+      }
+    } catch (err) {
+      api.log.error(`auto-doc: error processing ${file}: ${err}`);
+    }
+  }
+  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 style = input.style ?? "tsdoc";
+  const includeTypes = api.config.extensions?.["auto-doc"]?.["includeTypes"] ?? false;
+  const previews = [];
+  for (const file of input.files) {
+    try {
+      const { readFileSync: readFileSync3 } = await import('fs');
+      const content = readFileSync3(file, "utf-8");
+      const entities = parseSource(content);
+      const generated = entities.filter((e) => !needsDocComment(content, e)).map((e) => style === "jsdoc" ? generateJSDoc(e, includeTypes) : generateTSDoc(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",
+  description: "Auto-generates JSDoc/TSDoc comments for functions, classes, types, and interfaces",
+  apiVersion: AUTO_DOC_API_VERSION,
+  capabilities: { tools: true, pipelines: ["toolCall"] },
+  defaultConfig: { style: "tsdoc", includeTypes: false, dryRun: false },
+  configSchema: {
+    type: "object",
+    properties: {
+      style: { type: "string", enum: ["jsdoc", "tsdoc"], default: "tsdoc" },
+      includeTypes: { type: "boolean", default: false },
+      dryRun: { type: "boolean", default: false }
+    }
+  },
+  setup(api) {
+    api.tools.register({
+      name: "auto_doc",
+      description: "Auto-generate JSDoc/TSDoc comments for functions, classes, types, and interfaces in source files",
+      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" }
+        },
+        required: ["files"]
+      },
+      permission: "auto",
+      mutating: true,
+      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"] });
+  },
+  teardown(api) {
+    api.log.info("auto-doc plugin unloaded");
+  }
+};
+var auto_doc_default = plugin;
+var API_VERSION = "^0.1.10";
+function runGit(args, cwd) {
+  try {
+    return execSync(`git ${args.join(" ")}`, {
+      encoding: "utf-8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e4,
+      maxBuffer: 10 * 1024 * 1024
+    }).trim();
+  } catch (err) {
+    const e = err;
+    throw new Error(`git command failed: ${e.message ?? e.stderr ?? String(err)}`);
+  }
+}
+function getChangedFiles(cwd) {
+  const output = runGit(["status", "--porcelain"], cwd);
+  if (!output) return [];
+  return output.split("\n").filter((l) => l.trim()).map((l) => l.slice(3).trim());
+}
+function getStagedFiles(cwd) {
+  const output = runGit(["diff", "--cached", "--name-only"], cwd);
+  return output ? output.split("\n").filter(Boolean) : [];
+}
+function stageFiles(files, cwd) {
+  if (!files || !Array.isArray(files)) return;
+  const existing = files.filter((f) => {
+    try {
+      return existsSync(f);
+    } catch {
+      return false;
+    }
+  });
+  if (existing.length === 0) throw new Error("No files exist to stage");
+  runGit(["add", ...existing], 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 generateCommitMessage(type, scope, summary, body) {
+  const scopePart = scope ? `(${scope})` : "";
+  const footer = body ? `
+
+${body}` : "";
+  return `${type}${scopePart}: ${summary}${footer}`;
+}
+var plugin2 = {
+  name: "git-autocommit",
+  version: "0.1.0",
+  description: "AI-powered git staging and conventional commit message generation",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: {
+    conventionalCommits: true,
+    autoStage: false,
+    defaultType: "feat"
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      conventionalCommits: { type: "boolean", default: true },
+      autoStage: { type: "boolean", default: false },
+      defaultType: { type: "string", default: "feat" }
+    }
+  },
+  setup(api) {
+    const cwd = api.config.extensions?.["git-autocommit"];
+    const opts = {
+      conventionalCommits: cwd?.["conventionalCommits"] ?? true,
+      autoStage: cwd?.["autoStage"] ?? false,
+      defaultType: cwd?.["defaultType"] ?? "feat"
+    };
+    api.tools.register({
+      name: "git_autocommit",
+      description: "Stage files and create a git commit with an AI-generated conventional commit message. Pass files to stage specific ones, or leave empty to auto-detect all changed files.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          files: {
+            type: "array",
+            items: { type: "string" },
+            description: "Specific files to stage. If empty, auto-detects all changed files."
+          },
+          type: {
+            type: "string",
+            enum: ["feat", "fix", "docs", "style", "refactor", "test", "chore", "perf", "ci", "build", "revert"],
+            description: "Conventional commit type"
+          },
+          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" }
+        }
+      },
+      permission: "confirm",
+      mutating: true,
+      async execute(input, _ctx) {
+        try {
+          const type = input["type"] ?? opts.defaultType;
+          const scope = input["scope"];
+          const summary = input["message"] ?? "";
+          const body = input["body"];
+          const dryRun = input["dryRun"] ?? 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,
+                message: `Would create: ${summary || "update code"}`
+              };
+            }
+            return { ok: false, error: "type is required and must be a valid conventional commit type" };
+          }
+          const msg = generateCommitMessage(type, scope, summary || "update code", body);
+          let files;
+          const rawFiles = input["files"];
+          if (rawFiles !== void 0) {
+            if (!Array.isArray(rawFiles)) {
+              return { ok: false, error: "files must be an array of file paths" };
+            }
+            files = rawFiles;
+          }
+          if (files && files.length > 0) {
+            try {
+              stageFiles(files);
+            } catch (err) {
+              return { ok: false, error: `Failed to stage files: ${err instanceof Error ? err.message : String(err)}` };
+            }
+          }
+          let staged = [];
+          try {
+            staged = getStagedFiles();
+          } catch {
+            staged = [];
+          }
+          if (staged.length === 0) {
+            try {
+              const changed = getChangedFiles();
+              if (changed.length > 0) {
+                try {
+                  stageFiles(changed);
+                } catch {
+                }
+                try {
+                  staged = getStagedFiles();
+                } catch {
+                  staged = [];
+                }
+              }
+            } catch {
+            }
+          }
+          if (staged.length === 0) {
+            return { ok: false, error: "Nothing staged. Add files with git add or provide files input." };
+          }
+          let hash = "";
+          try {
+            hash = commitWithMessage(msg);
+          } catch (err) {
+            return { ok: false, error: `Failed to commit: ${err instanceof Error ? err.message : String(err)}` };
+          }
+          api.log.info("git-autocommit: created commit", { hash, type, scope });
+          try {
+            await api.session.append({
+              type: "git-autocommit:commit",
+              ts: (/* @__PURE__ */ new Date()).toISOString(),
+              hash: String(hash),
+              commitType: type,
+              scope: String(scope ?? ""),
+              files: Array.isArray(staged) ? staged : []
+            });
+          } catch (_err) {
+          }
+          return {
+            ok: true,
+            hash,
+            message: msg,
+            stagedFiles: staged,
+            type,
+            scope: scope ?? null
+          };
+        } catch (err) {
+          return { ok: false, error: `Uncaught error in git_autocommit: ${err instanceof Error ? err.message : String(err)}` };
+        }
+      }
+    });
+    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 = [];
+        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 {
+        }
+        return {
+          ok: true,
+          branch,
+          changedFiles: changed,
+          stagedFiles: staged,
+          aheadBehind,
+          recentCommits
+        };
+      }
+    });
+    api.log.info("git-autocommit plugin loaded", {
+      version: "0.1.0",
+      conventionalCommits: opts.conventionalCommits
+    });
+  }
+};
+var git_autocommit_default = plugin2;
+var API_VERSION2 = "^0.1.10";
+function runShellCheck(files, severity, cwd) {
+  if (!existsSync("shellcheck")) {
+    try {
+      execSync("shellcheck --version", { encoding: "utf-8", stdio: "ignore" });
+    } catch {
+      throw new Error("shellcheck is not installed. Install via: apt install shellcheck / brew install shellcheck");
+    }
+  }
+  const levelMap = {
+    error: "error",
+    warning: "warning",
+    info: "info",
+    style: "style"
+  };
+  const args = [
+    "-f",
+    "json",
+    "-S",
+    levelMap[severity] ?? "warning",
+    ...files
+  ];
+  let raw;
+  try {
+    raw = execSync(`shellcheck ${args.join(" ")}`, {
+      encoding: "utf-8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 6e4
+    });
+  } catch (err) {
+    const e = err;
+    if (e.stderr && !e.stderr.includes("shellcheck")) {
+      raw = e.stderr;
+    } else {
+      return [];
+    }
+  }
+  if (!raw.trim()) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed.map((item) => ({
+      file: item.file,
+      line: item.line,
+      column: item.column,
+      level: item.level,
+      code: item.code,
+      message: item.message
+    }));
+  } catch {
+    return [];
+  }
+}
+function findShellFiles(dir, pattern) {
+  const results = [];
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git") {
+        results.push(...findShellFiles(full, pattern));
+      } else if (entry.isFile() && (entry.name.endsWith(".sh") || entry.name === "Dockerfile")) {
+        if (!pattern || entry.name.includes(pattern)) {
+          results.push(full);
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+var plugin3 = {
+  name: "shell-check",
+  version: "0.1.0",
+  description: "Runs shellcheck analysis on bash/shell scripts and surfaces issues with severity levels",
+  apiVersion: API_VERSION2,
+  capabilities: { tools: true, pipelines: ["toolCall"] },
+  defaultConfig: {
+    severity: "warning",
+    severityThreshold: "warning",
+    ignoredCodes: [],
+    autoScanOnBash: false
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      severity: { type: "string", enum: ["error", "warning", "info", "style"], default: "warning" },
+      severityThreshold: { type: "string", enum: ["error", "warning", "info", "style"], default: "warning" },
+      ignoredCodes: { type: "array", items: { type: "string" }, default: [] },
+      autoScanOnBash: { type: "boolean", default: false }
+    }
+  },
+  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.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          files: {
+            type: "array",
+            items: { type: "string" },
+            description: "Shell script files to check"
+          },
+          severity: {
+            type: "string",
+            enum: ["error", "warning", "info", "style"],
+            default: "warning",
+            description: "Minimum severity level to report"
+          },
+          fix: {
+            type: "boolean",
+            default: false,
+            description: "Apply safe automatic fixes where possible"
+          }
+        },
+        required: ["files"]
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const files = input["files"];
+        const severity = input["severity"] ?? "warning";
+        let issues;
+        try {
+          issues = runShellCheck(files, severity);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { ok: false, error: msg, issues: [] };
+        }
+        const byFile = {};
+        for (const issue of issues) {
+          (byFile[issue.file] ??= []).push(issue);
+        }
+        const errorCount = issues.filter((i) => i.level === "error").length;
+        const warningCount = issues.filter((i) => i.level === "warning").length;
+        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));
+        return {
+          ok: true,
+          filesScanned: files.length,
+          issues,
+          summary: {
+            total: issues.length,
+            errors: errorCount,
+            warnings: warningCount,
+            info: infoCount,
+            style: styleCount
+          },
+          byFile,
+          recommendation: errorCount > 0 ? "Fix errors before deploying." : warningCount > 0 ? "Review and fix warnings for better script quality." : "No issues found."
+        };
+      }
+    });
+    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: false,
+      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) {
+          (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" });
+  }
+};
+var shell_check_default = plugin3;
+
+// src/cost-tracker/index.ts
+var API_VERSION3 = "^0.1.10";
+var PRICING = {
+  "gpt-4o": { input: 5, output: 15 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "claude-3-5-sonnet": { input: 3, output: 15 },
+  "claude-3-5-haiku": { input: 0.8, output: 4 },
+  "claude-3-opus": { input: 15, output: 75 },
+  "gemini-1.5-pro": { input: 3.5, output: 10.5 },
+  "gemini-1.5-flash": { input: 0.075, output: 0.3 },
+  "default": { input: 5, output: 15 }
+};
+var DEFAULT_PRICING = { input: 5, output: 15 };
+function estimateCost(model, promptTokens, completionTokens) {
+  const pricing = PRICING[model.toLowerCase()] ?? DEFAULT_PRICING;
+  const inputCost = promptTokens / 1e6 * pricing.input;
+  const outputCost = completionTokens / 1e6 * pricing.output;
+  return inputCost + outputCost;
+}
+var plugin4 = {
+  name: "cost-tracker",
+  version: "0.1.0",
+  description: "Tracks LLM token usage and estimated cost per session with per-model breakdown",
+  apiVersion: API_VERSION3,
+  capabilities: { tools: true, pipelines: ["request", "response"] },
+  defaultConfig: {
+    trackPerModel: true,
+    trackPerUser: false,
+    budgetLimit: 0,
+    warningThreshold: 80
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      trackPerModel: { type: "boolean", default: true },
+      trackPerUser: { type: "boolean", default: false },
+      budgetLimit: { type: "number", default: 0, description: "Budget limit in USD (0 = no limit)" },
+      warningThreshold: { type: "number", default: 80, description: "Warning threshold as percentage of budget" }
+    }
+  },
+  setup(api) {
+    const sessionCost = {
+      requests: [],
+      totalPromptTokens: 0,
+      totalCompletionTokens: 0,
+      totalTokens: 0,
+      totalCostUsd: 0,
+      byModel: {}
+    };
+    api.onEvent("provider.response", (payload) => {
+      const usage = payload.usage;
+      const model = payload.ctx?.model ?? "unknown";
+      const promptTokens = usage.input ?? 0;
+      const completionTokens = usage.output ?? 0;
+      const totalTokens = promptTokens + completionTokens;
+      const costUsd = estimateCost(model, promptTokens, completionTokens);
+      const record = {
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        model,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        costUsd
+      };
+      sessionCost.requests.push(record);
+      sessionCost.totalPromptTokens += promptTokens;
+      sessionCost.totalCompletionTokens += completionTokens;
+      sessionCost.totalTokens += totalTokens;
+      sessionCost.totalCostUsd += costUsd;
+      const slot = sessionCost.byModel[model] ??= { tokens: 0, costUsd: 0, requests: 0 };
+      slot.tokens += totalTokens;
+      slot.costUsd += costUsd;
+      slot.requests += 1;
+      api.metrics.counter("tokens_total", totalTokens, { model });
+      api.metrics.histogram("cost_usd", costUsd, { model });
+    });
+    api.tools.register({
+      name: "cost_summary",
+      description: "Returns the current session's token usage breakdown by model, total cost estimate, and budget status.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        const budgetLimit = api.config.extensions?.["cost-tracker"]?.["budgetLimit"] ?? 0;
+        const warningThreshold = api.config.extensions?.["cost-tracker"]?.["warningThreshold"] ?? 80;
+        const usage = {
+          totalRequests: sessionCost.requests.length,
+          totalPromptTokens: sessionCost.totalPromptTokens,
+          totalCompletionTokens: sessionCost.totalCompletionTokens,
+          totalTokens: sessionCost.totalTokens,
+          totalCostUsd: Math.round(sessionCost.totalCostUsd * 1e6) / 1e6,
+          byModel: sessionCost.byModel,
+          recentRequests: sessionCost.requests.slice(-5).map((r) => ({
+            model: r.model,
+            tokens: r.totalTokens,
+            costUsd: r.costUsd,
+            ts: r.timestamp
+          }))
+        };
+        const budgetStatus = budgetLimit > 0 ? {
+          limit: budgetLimit,
+          spent: sessionCost.totalCostUsd,
+          percentUsed: Math.round(sessionCost.totalCostUsd / budgetLimit * 100),
+          warning: sessionCost.totalCostUsd / budgetLimit * 100 >= warningThreshold
+        } : null;
+        return {
+          ok: true,
+          usage,
+          budgetStatus
+        };
+      }
+    });
+    api.tools.register({
+      name: "cost_reset",
+      description: "Resets all token usage and cost counters for the current session.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        const prev = {
+          totalTokens: sessionCost.totalTokens,
+          totalCostUsd: sessionCost.totalCostUsd
+        };
+        sessionCost.requests = [];
+        sessionCost.totalPromptTokens = 0;
+        sessionCost.totalCompletionTokens = 0;
+        sessionCost.totalTokens = 0;
+        sessionCost.totalCostUsd = 0;
+        sessionCost.byModel = {};
+        return {
+          ok: true,
+          previousTotals: prev,
+          message: "Cost tracking counters have been reset."
+        };
+      }
+    });
+    api.tools.register({
+      name: "cost_export",
+      description: "Export the cost report as JSON or CSV.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          format: { type: "string", enum: ["json", "csv"], default: "json" },
+          includeModel: { type: "boolean", default: true }
+        }
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const format = input["format"] ?? "json";
+        const includeModel = input["includeModel"] ?? true;
+        if (format === "csv") {
+          const header = includeModel ? "model,timestamp,prompt_tokens,completion_tokens,total_tokens,cost_usd" : "timestamp,prompt_tokens,completion_tokens,total_tokens,cost_usd";
+          const rows = sessionCost.requests.map(
+            (r) => includeModel ? `${r.model},${r.timestamp},${r.promptTokens},${r.completionTokens},${r.totalTokens},${r.costUsd ?? 0}` : `${r.timestamp},${r.promptTokens},${r.completionTokens},${r.totalTokens},${r.costUsd ?? 0}`
+          );
+          return {
+            ok: true,
+            format: "csv",
+            data: [header, ...rows].join("\n"),
+            summary: {
+              totalTokens: sessionCost.totalTokens,
+              totalCostUsd: sessionCost.totalCostUsd,
+              totalRequests: sessionCost.requests.length
+            }
+          };
+        }
+        return {
+          ok: true,
+          format: "json",
+          data: {
+            summary: {
+              totalTokens: sessionCost.totalTokens,
+              totalPromptTokens: sessionCost.totalPromptTokens,
+              totalCompletionTokens: sessionCost.totalCompletionTokens,
+              totalCostUsd: sessionCost.totalCostUsd,
+              totalRequests: sessionCost.requests.length,
+              byModel: sessionCost.byModel
+            },
+            requests: includeModel ? sessionCost.requests : sessionCost.requests.map(({ promptTokens, completionTokens, totalTokens, costUsd, timestamp }) => ({
+              promptTokens,
+              completionTokens,
+              totalTokens,
+              costUsd,
+              timestamp
+            }))
+          }
+        };
+      }
+    });
+    api.onEvent("session.close", async () => {
+      if (sessionCost.requests.length > 0) {
+        await api.session.append({
+          type: "cost-tracker:session_summary",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          totalTokens: sessionCost.totalTokens,
+          totalCostUsd: sessionCost.totalCostUsd,
+          totalRequests: sessionCost.requests.length,
+          byModel: sessionCost.byModel
+        });
+      }
+    });
+    api.log.info("cost-tracker plugin loaded", { version: "0.1.0" });
+  }
+};
+var cost_tracker_default = plugin4;
+var API_VERSION4 = "^0.1.10";
+var watchIdCounter = 0;
+function nextId() {
+  return `watch_${++watchIdCounter}_${Date.now().toString(36)}`;
+}
+var plugin5 = {
+  name: "file-watcher",
+  version: "0.1.0",
+  description: "Watches project files and emits events when changes occur (add, change, delete)",
+  apiVersion: API_VERSION4,
+  capabilities: { tools: true },
+  defaultConfig: {
+    debounceMs: 500,
+    watchOnStartup: [],
+    autoUnwatchOnExit: true
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      debounceMs: { type: "number", default: 500 },
+      watchOnStartup: { type: "array", items: { type: "string" }, default: [] },
+      autoUnwatchOnExit: { type: "boolean", default: true }
+    }
+  },
+  setup(api) {
+    const watches = /* @__PURE__ */ new Map();
+    let debounceMs = api.config.extensions?.["file-watcher"]?.["debounceMs"] ?? 500;
+    const debounceTimers = /* @__PURE__ */ new Map();
+    function debounceEvent(key, fn, ms) {
+      const existing = debounceTimers.get(key);
+      if (existing) clearTimeout(existing);
+      debounceTimers.set(key, setTimeout(() => {
+        debounceTimers.delete(key);
+        fn();
+      }, ms));
+    }
+    function safeWatchDir(dirPath, recursive, handle) {
+      try {
+        const watcher = watch(dirPath, { recursive }, (eventType, filename) => {
+          if (!filename) return;
+          const fullPath = `${dirPath}/${filename}`;
+          const key = `${handle.id}:${fullPath}:${eventType}`;
+          debounceEvent(key, () => {
+            api.emitCustom("file-watcher:changed", {
+              watchId: handle.id,
+              path: fullPath,
+              event: eventType,
+              filename,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            api.metrics.counter("file_change", 1, { event: eventType ?? "unknown" });
+            api.log.debug(`file-watcher: ${eventType} ${fullPath} (watch=${handle.id})`);
+          }, debounceMs);
+        });
+        watcher.on("error", (err) => {
+          api.log.warn(`file-watcher: error on ${dirPath}: ${err}`);
+        });
+        handle.watcher = watcher;
+      } catch (err) {
+        api.log.warn(`file-watcher: could not watch ${dirPath}: ${err}`);
+      }
+    }
+    api.tools.register({
+      name: "watch_start",
+      description: "Start watching one or more file paths for changes (add, change, delete). Returns a watch ID for stopping the watch later.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: "File or directory paths to watch"
+          },
+          events: {
+            type: "array",
+            items: { type: "string" },
+            default: ["change", "add", "delete"],
+            description: "Event types to watch for"
+          },
+          recursive: {
+            type: "boolean",
+            default: true,
+            description: "Watch directories recursively"
+          }
+        },
+        required: ["paths"]
+      },
+      permission: "confirm",
+      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 };
+        }
+        const paths = rawPaths;
+        if (paths.length === 0) {
+          return { ok: false, error: "paths array is empty \u2014 provide at least one path", watchId: null };
+        }
+        const events = input["events"] ?? ["change", "add", "delete"];
+        const recursive = input["recursive"] ?? true;
+        const id = nextId();
+        const handle = {
+          id,
+          paths,
+          recursive,
+          events,
+          watcher: { close: () => {
+          } },
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        for (const p of paths) {
+          safeWatchDir(p, recursive, handle);
+        }
+        watches.set(id, handle);
+        api.metrics.gauge("active_watches", watches.size);
+        return {
+          ok: true,
+          watchId: id,
+          paths,
+          events,
+          recursive,
+          message: `Started watching ${paths.length} path(s). Use watch_stop to cancel.`
+        };
+      }
+    });
+    api.tools.register({
+      name: "watch_stop",
+      description: "Stop a file watch by its ID. Releases all resources.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          watchId: { type: "string", description: "Watch ID returned by watch_start" }
+        },
+        required: ["watchId"]
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const watchId = input["watchId"];
+        const handle = watches.get(watchId);
+        if (!handle) {
+          return { ok: false, error: `No active watch with ID: ${watchId}` };
+        }
+        try {
+          handle.watcher.close();
+        } catch {
+        }
+        watches.delete(watchId);
+        api.metrics.gauge("active_watches", watches.size);
+        return {
+          ok: true,
+          watchId,
+          message: `Stopped watch ${watchId}. ${watches.size} watch(es) remaining.`
+        };
+      }
+    });
+    api.tools.register({
+      name: "watch_list",
+      description: "List all currently active file watches with their IDs, paths, and creation times.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        const list = Array.from(watches.values()).map((w) => ({
+          id: w.id,
+          paths: w.paths,
+          events: w.events,
+          recursive: w.recursive,
+          createdAt: w.createdAt,
+          age: `${Date.now() - new Date(w.createdAt).getTime()}ms`
+        }));
+        return {
+          ok: true,
+          count: list.length,
+          watches: list
+        };
+      }
+    });
+    api.log.info("file-watcher plugin loaded", { version: "0.1.0" });
+  },
+  teardown(api) {
+    {
+      api.log.info("file-watcher: teardown complete");
+    }
+  }
+};
+var file_watcher_default = plugin5;
+
+// src/web-search/index.ts
+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 class="result__a" href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a class="result__snippet"[^>]*>([\s\S]*?)<\/a>/g;
+  let m;
+  while ((m = resultRe.exec(html)) !== null && results.length < numResults) {
+    const url2 = m[1];
+    if (!url2) continue;
+    const title = (m[2] ?? "").replace(/<[^>]+>/g, "").trim();
+    const snippet = (m[3] ?? "").replace(/<[^>]+>/g, "").trim();
+    results.push({
+      url: url2,
+      title,
+      snippet,
+      score: 1,
+      source: "duckduckgo",
+      cached: false
+    });
+  }
+  return results;
+}
+async function fetchUrl(url, format) {
+  const resp = await fetch(url, {
+    headers: {
+      "User-Agent": "Mozilla/5.0 (compatible; WrongStack/1.0; +https://wrongstack.com)",
+      "Accept": format === "text" ? "text/plain" : "text/html"
+    }
+  });
+  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);
+}
+var plugin6 = {
+  name: "web-search",
+  version: "0.1.0",
+  description: "Cached web search with deduplication and relevance ranking",
+  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" }
+    }
+  },
+  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: false,
+      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 normalized = (r.url.split("?")[0] ?? r.url).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 });
+  }
+};
+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 = 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 = parseInt(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 = 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 = filterMatch[1];
+    const op = filterMatch[2];
+    const rawVal = 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);
+        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 = 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;
+      default:
+        return null;
+    }
+  }
+  return null;
+}
+function validateJsonSchema(data, schema) {
+  const errors = [];
+  function check(value, s, path) {
+    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(`${path}: expected integer, got ${actualType}`);
+      } else if (expectedType !== actualType) {
+        errors.push(`${path}: expected ${expectedType}, got ${actualType}`);
+      }
+    }
+    if (typeof value === "string" && s["format"] === "uri" && value) {
+      try {
+        new URL(value);
+      } catch {
+        errors.push(`${path}: not a valid URI`);
+      }
+    }
+    if (typeof value === "string" && s["pattern"]) {
+      const re = new RegExp(s["pattern"]);
+      if (!re.test(value)) errors.push(`${path}: does not match pattern ${s["pattern"]}`);
+    }
+    if (typeof value === "string" && s["minLength"] !== void 0 && value.length < s["minLength"]) {
+      errors.push(`${path}: string too short (min ${s["minLength"]})`);
+    }
+    if (typeof value === "string" && s["maxLength"] !== void 0 && value.length > s["maxLength"]) {
+      errors.push(`${path}: string too long (max ${s["maxLength"]})`);
+    }
+    if (typeof value === "number" && s["minimum"] !== void 0 && value < s["minimum"]) {
+      errors.push(`${path}: below minimum ${s["minimum"]}`);
+    }
+    if (typeof value === "number" && s["maximum"] !== void 0 && value > s["maximum"]) {
+      errors.push(`${path}: above maximum ${s["maximum"]}`);
+    }
+    if (Array.isArray(value) && s["items"] && Array.isArray(s["items"])) {
+      value.forEach((item, i) => check(item, s["items"], `${path}[${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, `${path}.${k}`);
+      }
+    }
+  }
+  check(data, schema, "$");
+  return { valid: errors.length === 0, errors };
+}
+function deepMerge(base, patch, conflictResolution = "prefer-patch") {
+  if (typeof base !== "object" || base === null || typeof patch !== "object" || patch === null) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  if (Array.isArray(base) && Array.isArray(patch)) {
+    return conflictResolution === "prefer-patch" ? patch : base;
+  }
+  const result = {};
+  const baseObj = base;
+  const patchObj = patch;
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(baseObj), ...Object.keys(patchObj)]);
+  for (const key of allKeys) {
+    const baseVal = baseObj[key];
+    const patchVal = patchObj[key];
+    if (key in baseObj && key in patchObj) {
+      if (typeof baseVal === "object" && baseVal !== null && typeof patchVal === "object" && patchVal !== null && !Array.isArray(baseVal) && !Array.isArray(patchVal)) {
+        result[key] = deepMerge(baseVal, patchVal, conflictResolution);
+      } else {
+        result[key] = conflictResolution === "prefer-patch" ? patchVal : baseVal;
+      }
+    } else if (key in baseObj) {
+      result[key] = baseVal;
+    } else {
+      result[key] = patchVal;
+    }
+  }
+  return result;
+}
+var plugin7 = {
+  name: "json-path",
+  version: "0.1.0",
+  description: "JMESPath query, JSON Schema validation, transformation, and deep merge for JSON/YAML",
+  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" });
+  }
+};
+var json_path_default = plugin7;
+
+// src/cron/index.ts
+var API_VERSION7 = "^0.1.10";
+function formatNextRun(intervalMs) {
+  const ms = isNaN(intervalMs) || intervalMs <= 0 ? 6e4 : intervalMs;
+  return new Date(Date.now() + ms).toISOString();
+}
+var plugin8 = {
+  name: "cron",
+  version: "0.1.0",
+  description: "Schedules recurring tasks using beforeIteration/afterIteration extension hooks",
+  apiVersion: API_VERSION7,
+  capabilities: { tools: true },
+  defaultConfig: {
+    maxConcurrentJobs: 5,
+    timezone: "UTC",
+    persistSchedules: false
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      maxConcurrentJobs: { type: "number", default: 5 },
+      timezone: { type: "string", default: "UTC" },
+      persistSchedules: { type: "boolean", default: false }
+    }
+  },
+  setup(api) {
+    const state = {
+      jobs: /* @__PURE__ */ new Map(),
+      timers: /* @__PURE__ */ new Map(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const maxConcurrent = api.config.extensions?.["cron"]?.["maxConcurrentJobs"] ?? 5;
+    function scheduleNextRun(name) {
+      const job = state.jobs.get(name);
+      if (!job || !job.enabled) return;
+      const existing = state.timers.get(name);
+      if (existing) clearTimeout(existing);
+      const delay = Math.max(0, new Date(job.nextRun).getTime() - Date.now());
+      const timer = setTimeout(() => {
+        job.runCount++;
+        job.lastRun = (/* @__PURE__ */ new Date()).toISOString();
+        job.nextRun = formatNextRun(job.intervalMs);
+        api.emitCustom("cron:job_fired", {
+          name,
+          action: job.action,
+          runCount: job.runCount,
+          ts: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        api.metrics.counter("cron_job_fired", 1, { job: name });
+        api.metrics.histogram("cron_job_interval_ms", job.intervalMs, { job: name });
+        scheduleNextRun(name);
+      }, delay);
+      state.timers.set(name, timer);
+    }
+    function cancelJob(name) {
+      const timer = state.timers.get(name);
+      if (timer) {
+        clearTimeout(timer);
+        state.timers.delete(name);
+      }
+      state.jobs.delete(name);
+    }
+    api.extensions.register({
+      name: "cron-iteration-hooks",
+      owner: "cron",
+      beforeIteration: async (_ctx, _idx) => {
+        const now = Date.now();
+        let activeJobs = 0;
+        const promises = [];
+        for (const [name, job] of state.jobs) {
+          if (!job.enabled) continue;
+          if (activeJobs >= maxConcurrent) break;
+          if (new Date(job.nextRun).getTime() <= now) {
+            activeJobs++;
+            promises.push(
+              (async () => {
+                await api.session.append({
+                  type: "cron:scheduled_trigger",
+                  ts: (/* @__PURE__ */ new Date()).toISOString(),
+                  jobName: name,
+                  action: job.action,
+                  runCount: job.runCount + 1
+                });
+                api.emitCustom("cron:job_due", {
+                  name,
+                  action: job.action,
+                  dueAt: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              })()
+            );
+          }
+        }
+        await Promise.all(promises);
+      },
+      afterIteration: async (_ctx, _idx) => {
+        for (const job of state.jobs.values()) {
+          if (!job.enabled) continue;
+          if (new Date(job.nextRun).getTime() <= Date.now()) {
+            job.nextRun = formatNextRun(job.intervalMs);
+          }
+        }
+      }
+    });
+    api.tools.register({
+      name: "cron_schedule",
+      description: "Schedule a recurring action to fire at a fixed interval (in milliseconds). The action is emitted as a custom event for downstream handlers.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Unique name for this cron job" },
+          intervalMs: { type: "number", description: "Interval between runs in milliseconds (minimum 1000)" },
+          action: { type: "string", description: "Action identifier or description of what to run" },
+          enabled: { type: "boolean", default: true }
+        },
+        required: ["name", "intervalMs", "action"]
+      },
+      permission: "confirm",
+      mutating: false,
+      async execute(input) {
+        const name = input["name"];
+        const intervalMs = Math.max(1e3, Number(input["intervalMs"]));
+        const action = input["action"];
+        const enabled = input["enabled"] ?? true;
+        if (!name || typeof name !== "string" || name.trim() === "") {
+          return { ok: false, error: "name is required and must be a non-empty string" };
+        }
+        if (isNaN(intervalMs)) {
+          return { ok: false, error: "intervalMs must be a number >= 1000" };
+        }
+        if (state.jobs.has(name)) {
+          return { ok: false, error: `Cron job '${name}' already exists. Use cron_cancel first.` };
+        }
+        if (state.jobs.size >= maxConcurrent) {
+          return { ok: false, error: `Maximum concurrent jobs (${maxConcurrent}) reached.` };
+        }
+        const job = {
+          name,
+          intervalMs,
+          action,
+          enabled,
+          lastRun: null,
+          nextRun: formatNextRun(intervalMs),
+          runCount: 0
+        };
+        state.jobs.set(name, job);
+        scheduleNextRun(name);
+        api.metrics.gauge("cron_active_jobs", state.jobs.size);
+        return {
+          ok: true,
+          name,
+          intervalMs,
+          nextRun: job.nextRun,
+          message: `Scheduled '${name}' every ${intervalMs}ms.`
+        };
+      }
+    });
+    api.tools.register({
+      name: "cron_list",
+      description: "List all registered cron jobs with their intervals, next run times, and execution counts.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        const jobs = Array.from(state.jobs.values()).map((j) => ({
+          name: j.name,
+          intervalMs: j.intervalMs,
+          action: j.action,
+          enabled: j.enabled,
+          lastRun: j.lastRun,
+          nextRun: j.nextRun,
+          runCount: j.runCount,
+          overdue: new Date(j.nextRun).getTime() < Date.now()
+        }));
+        return {
+          ok: true,
+          count: jobs.length,
+          maxConcurrent,
+          jobs
+        };
+      }
+    });
+    api.tools.register({
+      name: "cron_cancel",
+      description: "Cancel and remove a cron job by name.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Name of the cron job to cancel" }
+        },
+        required: ["name"]
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const name = input["name"];
+        if (!state.jobs.has(name)) {
+          return { ok: false, error: `No cron job named '${name}'` };
+        }
+        cancelJob(name);
+        api.metrics.gauge("cron_active_jobs", state.jobs.size);
+        return {
+          ok: true,
+          name,
+          message: `Cancelled cron job '${name}'.`
+        };
+      }
+    });
+    api.log.info("cron plugin loaded", { version: "0.1.0", maxConcurrent });
+  },
+  teardown(api) {
+    const { jobs, timers } = api._state ?? { jobs: /* @__PURE__ */ new Map(), timers: /* @__PURE__ */ new Map() };
+    for (const name of jobs.keys()) {
+      const timer = timers.get(name);
+      if (timer) clearTimeout(timer);
+    }
+    jobs.clear();
+    timers.clear();
+    api.log.info("cron plugin unloaded");
+  }
+};
+var cron_default = plugin8;
+
+// src/template-engine/index.ts
+var API_VERSION8 = "^0.1.10";
+function expandTemplate(template, variables) {
+  let result = template;
+  result = result.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    const value = variables[key];
+    if (value !== void 0) return value;
+    return match;
+  });
+  return result;
+}
+function expandConditionals(template, variables) {
+  return template.replace(
+    /\{\{#if\s+(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g,
+    (_, key, content) => {
+      const val = variables[key];
+      return val !== void 0 && val !== "" && val !== "false" && val !== "0" ? content : "";
+    }
+  );
+}
+function expandLoops(template, variables) {
+  return template.replace(
+    /\{\{#each\s+(\w+)\}\}([\s\S]*?)\{\{\/each\}\}/g,
+    (_, key, content) => {
+      const val = variables[key];
+      if (!val) return "";
+      if (typeof val === "string" && val.includes(",")) {
+        const items = val.split(",").map((s) => s.trim());
+        return items.map((item) => expandTemplate(content, { ...variables, [key]: item })).join("\n");
+      }
+      return expandTemplate(content, variables);
+    }
+  );
+}
+function renderTemplate(template, variables) {
+  let result = template;
+  result = expandConditionals(result, variables);
+  result = expandLoops(result, variables);
+  result = expandTemplate(result, variables);
+  {
+    result = result.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  }
+  return result;
+}
+function renderTemplateRaw(template, variables) {
+  let result = template;
+  result = expandConditionals(result, variables);
+  result = expandLoops(result, variables);
+  result = expandTemplate(result, variables);
+  return result;
+}
+var plugin9 = {
+  name: "template-engine",
+  version: "0.1.0",
+  description: "Expands file templates with variable substitution, conditionals, and loops",
+  apiVersion: API_VERSION8,
+  capabilities: { tools: true },
+  defaultConfig: {
+    autoEscapeHtml: true,
+    templateDir: "./templates",
+    strictVariables: false
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      autoEscapeHtml: { type: "boolean", default: true },
+      templateDir: { type: "string", default: "./templates" },
+      strictVariables: { type: "boolean", default: false }
+    }
+  },
+  setup(api) {
+    const templates = /* @__PURE__ */ new Map();
+    api.tools.register({
+      name: "template_expand",
+      description: "Expand a template string with variable substitution. Supports {{variable}}, {{#if var}}...{{/if}} conditionals, and {{#each items}}...{{/each}} loops.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          template: { type: "string", description: "Template string with {{variable}} placeholders" },
+          variables: {
+            type: "object",
+            description: "Variables to substitute into the template",
+            additionalProperties: { type: "string" }
+          },
+          outputPath: { 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",
+      mutating: true,
+      async execute(input) {
+        const template = input["template"];
+        const variables = input["variables"];
+        const outputPath = input["outputPath"];
+        const raw = input["raw"] ?? false;
+        if (!template || typeof template !== "string") {
+          return { ok: false, error: "template is required and must be a string" };
+        }
+        if (!variables || typeof variables !== "object") {
+          return { ok: false, error: "variables is required and must be an object" };
+        }
+        let result;
+        try {
+          result = raw ? renderTemplateRaw(template, variables) : renderTemplate(template, variables);
+        } catch (err) {
+          return { ok: false, error: String(err) };
+        }
+        if (outputPath) {
+          const { writeFileSync } = await import('fs');
+          writeFileSync(outputPath, result, "utf-8");
+          return {
+            ok: true,
+            outputPath,
+            contentLength: result.length,
+            message: `Wrote ${result.length} characters to ${outputPath}`
+          };
+        }
+        return {
+          ok: true,
+          result,
+          contentLength: result.length,
+          variableCount: Object.keys(variables).length
+        };
+      }
+    });
+    api.tools.register({
+      name: "template_render",
+      description: "Read a template file from disk and expand it with the given variables.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          templatePath: { 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" },
+          raw: { type: "boolean", default: false }
+        },
+        required: ["templatePath", "variables"]
+      },
+      permission: "auto",
+      mutating: true,
+      async execute(input) {
+        const templatePath = input["templatePath"];
+        const variables = input["variables"];
+        const outputPath = input["outputPath"];
+        const raw = input["raw"] ?? false;
+        if (!templatePath || typeof templatePath !== "string") {
+          return { ok: false, error: "templatePath is required and must be a string" };
+        }
+        if (!variables || typeof variables !== "object") {
+          return { ok: false, error: "variables is required and must be an object" };
+        }
+        let content;
+        try {
+          const { readFileSync: readFileSync3 } = await import('fs');
+          content = readFileSync3(templatePath, "utf-8");
+        } catch (err) {
+          return { ok: false, error: `Could not read template file: ${err}` };
+        }
+        let result;
+        try {
+          result = raw ? renderTemplateRaw(content, variables) : renderTemplate(content, variables);
+        } catch (err) {
+          return { ok: false, error: `Template rendering failed: ${err}` };
+        }
+        if (outputPath) {
+          const { writeFileSync } = await import('fs');
+          writeFileSync(outputPath, result, "utf-8");
+          return {
+            ok: true,
+            templatePath,
+            outputPath,
+            message: `Rendered and wrote ${result.length} chars to ${outputPath}`
+          };
+        }
+        return {
+          ok: true,
+          templatePath,
+          result,
+          contentLength: result.length
+        };
+      }
+    });
+    api.tools.register({
+      name: "template_create",
+      description: "Save a named template to the plugin's template store for later use.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Unique name for this template" },
+          content: { type: "string", description: "Template content with {{variable}} placeholders" },
+          description: { type: "string", description: "Optional description of what this template is for" }
+        },
+        required: ["name", "content"]
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const name = input["name"];
+        const content = input["content"];
+        const description = input["description"];
+        if (!name || typeof name !== "string" || name.trim() === "") {
+          return { ok: false, error: "name is required and must be a non-empty string" };
+        }
+        if (!content || typeof content !== "string") {
+          return { ok: false, error: "content is required and must be a string" };
+        }
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const existing = templates.get(name);
+        const tmpl = {
+          name,
+          content,
+          description,
+          createdAt: existing?.createdAt ?? now,
+          updatedAt: now
+        };
+        templates.set(name, tmpl);
+        api.metrics.gauge("template_count", templates.size);
+        return {
+          ok: true,
+          name,
+          message: existing ? `Updated template '${name}'.` : `Created template '${name}'.`,
+          createdAt: tmpl.createdAt
+        };
+      }
+    });
+    api.tools.register({
+      name: "template_list",
+      description: "List all templates saved in the plugin's template store.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        const list = Array.from(templates.values()).map((t) => ({
+          name: t.name,
+          description: t.description,
+          contentLength: t.content.length,
+          createdAt: t.createdAt,
+          updatedAt: t.updatedAt
+        }));
+        return {
+          ok: true,
+          count: list.length,
+          templates: list
+        };
+      }
+    });
+    api.registerSystemPromptContributor(async () => [
+      {
+        type: "text",
+        text: `Template engine available:
+- template_expand: expand a template string with {{variable}}, {{#if}} conditionals, {{#each}} loops
+- template_render: render a template file with variables
+- template_create: save a named template
+- template_list: list saved templates`
+      }
+    ]);
+    api.log.info("template-engine plugin loaded", { version: "0.1.0" });
+  }
+};
+var template_engine_default = plugin9;
+var API_VERSION9 = "^0.1.10";
+function runGit2(args, cwd) {
+  try {
+    return execSync(`git ${args.join(" ")}`, {
+      encoding: "utf-8",
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e4
+    }).trim();
+  } catch (err) {
+    const e = err;
+    if (e.status === 128) throw new Error("Not a git repository");
+    throw new Error(`git failed: ${e.message ?? e.stderr ?? String(err)}`);
+  }
+}
+function getPackageJson(cwd) {
+  const path = cwd ? `${cwd}/package.json` : "package.json";
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function parseVersion(v) {
+  const m = v.match(/^v?(\d+)\.(\d+)\.(\d+)/);
+  if (!m) return [0, 0, 0];
+  return [parseInt(m[1]), parseInt(m[2]), parseInt(m[3])];
+}
+function bumpVersion(version, part) {
+  let [major, minor, patch] = parseVersion(version);
+  if (part === "major") {
+    major++;
+    minor = 0;
+    patch = 0;
+  } else if (part === "minor") {
+    minor++;
+    patch = 0;
+  } else if (part === "patch") {
+    patch++;
+  } else {
+    return version;
+  }
+  return `${major}.${minor}.${patch}`;
+}
+function getRecentCommits(sinceTag, cwd) {
+  const range = sinceTag ? `${sinceTag}..HEAD` : "-30";
+  const output = runGit2(["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 m = message.match(/^(\w+)(!)?(?:\(([^)]+)\))?:\s(.+)/);
+    const type = m?.[1] ?? "chore";
+    const breaking = !!m?.[2];
+    const scope = m?.[2];
+    const msg = m?.[3] ?? message;
+    return { hash, type, scope, message: msg, breaking };
+  });
+}
+function determineBump(commits) {
+  for (const c of commits) {
+    if (c.breaking || c.type === "feat!:" || c.type === "fix!") {
+      return "major";
+    }
+  }
+  for (const c of commits) {
+    if (c.type === "feat" || c.type === "refactor" && c.scope) {
+      return "minor";
+    }
+  }
+  return "patch";
+}
+function generateChangelog(commits) {
+  const sections = {
+    breaking: [],
+    feat: [],
+    fix: [],
+    perf: [],
+    docs: [],
+    refactor: [],
+    test: [],
+    chore: [],
+    other: []
+  };
+  for (const c of commits) {
+    if (c.breaking) {
+      sections.breaking.push(c);
+    } else if (c.type in sections) {
+      sections[c.type].push(c);
+    } else {
+      sections.other.push(c);
+    }
+  }
+  const lines = ["# Changelog\n"];
+  if (sections.breaking.length > 0) {
+    lines.push("## \u26A0\uFE0F BREAKING CHANGES\n");
+    for (const c of sections.breaking) {
+      lines.push(`- **${c.hash.slice(0, 7)}** ${c.message} (${c.type})`);
+    }
+    lines.push("");
+  }
+  const ordered = ["feat", "fix", "perf", "docs", "refactor", "test", "chore", "other"];
+  const labels = {
+    breaking: "Breaking",
+    feat: "Features",
+    fix: "Bug Fixes",
+    perf: "Performance",
+    docs: "Documentation",
+    refactor: "Refactoring",
+    test: "Tests",
+    chore: "Chores",
+    other: "Other Changes"
+  };
+  for (const key of ordered) {
+    const items = sections[key];
+    if (items.length === 0) continue;
+    lines.push(`## ${labels[key]}
+`);
+    for (const c of items) {
+      const scope = c.scope ? `**${c.scope}**: ` : "";
+      lines.push(`- **${c.hash.slice(0, 7)}** ${scope}${c.message}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+var plugin10 = {
+  name: "semver-bump",
+  version: "0.1.0",
+  description: "Conventional-commit-driven semver version bumps with changelog generation",
+  apiVersion: API_VERSION9,
+  capabilities: { tools: true },
+  defaultConfig: {
+    tagPrefix: "v",
+    changelogFile: "CHANGELOG.md",
+    autoTag: true,
+    tagMessage: "Release {{version}}"
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      tagPrefix: { type: "string", default: "v" },
+      changelogFile: { type: "string", default: "CHANGELOG.md" },
+      autoTag: { type: "boolean", default: true },
+      tagMessage: { type: "string", default: "Release {{version}}" }
+    }
+  },
+  setup(api) {
+    const tagPrefix = api.config.extensions?.["semver-bump"]?.["tagPrefix"] ?? "v";
+    const autoTag = api.config.extensions?.["semver-bump"]?.["autoTag"] ?? true;
+    api.config.extensions?.["semver-bump"]?.["changelogFile"] ?? "CHANGELOG.md";
+    api.tools.register({
+      name: "semver_bump",
+      description: "Determine the next version bump from conventional commits since the last tag, or force a specific bump. Creates a git tag.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cwd: { type: "string", description: "Working directory (defaults to project root)" },
+          dryRun: { type: "boolean", default: false },
+          part: { type: "string", enum: ["major", "minor", "patch", "auto"], default: "auto", description: "Version part to bump (auto = infer from commits)" }
+        }
+      },
+      permission: "confirm",
+      mutating: true,
+      async execute(input) {
+        const cwd = input["cwd"];
+        const dryRun = input["dryRun"] ?? false;
+        const part = input["part"] ?? "auto";
+        const pkg = getPackageJson(cwd);
+        if (!pkg) {
+          return { ok: false, error: "No package.json found" };
+        }
+        const currentVersion = pkg.version;
+        let bumpPart = part;
+        let commits = [];
+        if (part === "auto") {
+          let lastTag;
+          try {
+            const tagsOutput = runGit2(["describe", "--tags", "--abbrev=0"], cwd);
+            lastTag = tagsOutput || void 0;
+          } catch {
+          }
+          try {
+            commits = getRecentCommits(lastTag, cwd);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: `Git error: ${msg}`, bumpPart: "patch" };
+          }
+          bumpPart = determineBump(commits);
+        } else {
+          bumpPart = part;
+        }
+        const newVersion = bumpVersion(currentVersion, bumpPart);
+        if (dryRun) {
+          return {
+            ok: true,
+            dryRun: true,
+            currentVersion,
+            suggestedBump: bumpPart,
+            newVersion,
+            commitCount: part === "auto" ? commits.length : void 0,
+            message: `Would bump ${currentVersion} \u2192 ${newVersion} (${bumpPart})`
+          };
+        }
+        const fs = await import('fs');
+        const pkgPath = cwd ? `${cwd}/package.json` : "package.json";
+        const pkgData = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        pkgData.version = newVersion;
+        fs.writeFileSync(pkgPath, JSON.stringify(pkgData, null, 2) + "\n", "utf-8");
+        try {
+          runGit2(["add", "package.json"], cwd);
+          runGit2(["commit", "-m", `chore: bump version to ${newVersion}`], cwd);
+        } catch {
+        }
+        if (autoTag) {
+          try {
+            runGit2(["tag", "-a", `${tagPrefix}${newVersion}`, "-m", `Release ${newVersion}`], cwd);
+          } catch {
+          }
+        }
+        api.log.info("semver-bump: bumped", { from: currentVersion, to: newVersion, bump: bumpPart });
+        api.metrics.counter("version_bump", 1, { bump: bumpPart });
+        await api.session.append({
+          type: "semver-bump:bumped",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          from: currentVersion,
+          to: newVersion,
+          bump: bumpPart
+        });
+        return {
+          ok: true,
+          currentVersion,
+          newVersion,
+          bump: bumpPart,
+          tag: `${tagPrefix}${newVersion}`,
+          message: `Bumped ${currentVersion} \u2192 ${newVersion} (${bumpPart})`
+        };
+      }
+    });
+    api.tools.register({
+      name: "semver_current",
+      description: "Return the current version from package.json and the latest git tag.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          cwd: { type: "string", description: "Working directory" }
+        }
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const cwd = input["cwd"];
+        const pkg = getPackageJson(cwd);
+        const currentVersion = pkg?.version ?? "unknown";
+        let latestTag = null;
+        let commitsSinceTag = 0;
+        try {
+          const tagsOutput = runGit2(["describe", "--tags", "--abbrev=0"], cwd);
+          latestTag = tagsOutput || null;
+          if (latestTag) {
+            const countOutput = runGit2(["rev-list", "--count", `${latestTag}..HEAD`], cwd);
+            commitsSinceTag = parseInt(countOutput) || 0;
+          }
+        } catch {
+          latestTag = null;
+        }
+        return {
+          ok: true,
+          currentVersion,
+          latestTag: latestTag ?? null,
+          tagPrefix,
+          commitsSinceTag
+        };
+      }
+    });
+    api.tools.register({
+      name: "semver_changelog",
+      description: "Generate a changelog (in markdown) between two version tags or from a tag to HEAD.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          from: { type: "string", description: "Starting tag (exclusive)" },
+          to: { type: "string", description: 'Ending tag or "HEAD"' },
+          cwd: { type: "string", description: "Working directory" },
+          format: { type: "string", enum: ["markdown", "json"], default: "markdown" }
+        }
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const from = input["from"];
+        const to = input["to"] ?? "HEAD";
+        const cwd = input["cwd"];
+        const format = input["format"] ?? "markdown";
+        const range = from ? `${from}..${to}` : to;
+        let commits;
+        try {
+          const output = runGit2(["log", range === to ? "-30" : range, "--format=%H %s"], cwd);
+          commits = output.split("\n").filter(Boolean).map((line) => {
+            const spaceIdx = line.indexOf(" ");
+            const hash = line.slice(0, spaceIdx);
+            const message = line.slice(spaceIdx + 1);
+            const m = message.match(/^(\w+)(!)?(?:\(([^)]+)\))?:\s(.+)/);
+            const type = m?.[1] ?? "chore";
+            return {
+              hash,
+              type,
+              scope: m?.[2],
+              message: m?.[3] ?? message,
+              breaking: !!m?.[2]
+            };
+          });
+        } catch (err) {
+          return { ok: false, error: `Failed to get git log: ${err}` };
+        }
+        if (format === "json") {
+          return {
+            ok: true,
+            from,
+            to,
+            commits,
+            commitCount: commits.length
+          };
+        }
+        const changelog = generateChangelog(commits);
+        return {
+          ok: true,
+          from: from ?? "(beginning)",
+          to,
+          changelog,
+          commitCount: commits.length,
+          breakingCount: commits.filter((c) => c.breaking).length
+        };
+      }
+    });
+    api.log.info("semver-bump plugin loaded", { version: "0.1.0", tagPrefix, autoTag });
+  }
+};
+var semver_bump_default = plugin10;
+
+export { auto_doc_default as autoDocPlugin, cost_tracker_default as costTrackerPlugin, cron_default as cronPlugin, file_watcher_default as fileWatcherPlugin, git_autocommit_default as gitAutocommitPlugin, json_path_default as jsonPathPlugin, semver_bump_default as semverBumpPlugin, shell_check_default as shellCheckPlugin, template_engine_default as templateEnginePlugin, web_search_default as webSearchPlugin };