@wrongstack/plugins 0.275.1 → 0.276.2

package/dist/json-path.d.ts

@@ -1,13 +1,16 @@
 import { Plugin } from '@wrongstack/core';
 
 /**
- * json-path plugin — JMESPath query, validate, and transform JSON/YAML.
+ * json-path plugin — RETIRED.
  *
- * Tools registered:
- * - jmespath_query: Execute JMESPath query on JSON/YAML data
- * - json_validate: Validate data against a JSON Schema
- * - json_transform: Apply JMESPath transforms to data
- * - json_merge: Deep merge two JSON objects
+ * The four tools this plugin previously registered (`jmespath_query`,
+ * `json_validate`, `json_transform`, `json_merge`) have been consolidated
+ * into the built-in `json` tool (packages/tools/src/json.ts) via its
+ * `action` parameter.
+ *
+ * This file remains as a no-op stub so existing config references
+ * (`"json-path": { "enabled": true }`) do not break. It registers no
+ * tools and logs a deprecation notice on load.
  */
 
 declare const plugin: Plugin;

package/dist/json-path.js

@@ -1,290 +1,13 @@
-import { expectDefined, deepMerge as deepMerge$1 } from '@wrongstack/core';
-
 // src/json-path/index.ts
 var API_VERSION = "^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, 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"])) {
-      for (let i = 0; i < value.length; i++) {
-        check(value[i], 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") {
-  return deepMerge$1(base, patch, { conflictResolution });
-}
 var plugin = {
   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_VERSION,
   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 = plugin;

package/dist/semver-bump.js

@@ -209,7 +209,7 @@ var plugin = {
       if (dryRun) {
         return {
           ok: true,
-          dryRun: true,
+          dry_run: true,
           currentVersion,
           suggestedBump: bumpPart,
           newVersion,
@@ -279,7 +279,7 @@ var plugin = {
         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." }
         }
       },
@@ -287,7 +287,7 @@ var plugin = {
       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);
       }

package/dist/shell-check.d.ts

@@ -4,8 +4,11 @@ import { Plugin } from '@wrongstack/core';
  * shell-check plugin — Runs shellcheck analysis on bash/shell scripts.
  *
  * Tools registered:
- * - shellcheck: Run shellcheck on specific files
- * - shellcheck_scan: Scan directory for shell script issues
+ * - shellcheck: Run shellcheck on specific files OR recursively scan a directory.
+ *
+ * Note: The former `shellcheck (scan mode)` tool has been merged into `shellcheck`
+ * via the `directory` + `pattern` parameters. Pass `files` for specific
+ * files, or `directory` (optionally with `pattern`) for recursive scanning.
  */
 
 declare const plugin: Plugin;

package/dist/shell-check.js

@@ -1,5 +1,5 @@
 import { execSync, execFileSync } from 'child_process';
-import { existsSync, readdirSync } from 'fs';
+import { readdirSync, existsSync } from 'fs';
 import { join } from 'path';
 
 // src/shell-check/index.ts
@@ -72,7 +72,7 @@ function findShellFiles(dir, pattern) {
 }
 var plugin = {
   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_VERSION,
   capabilities: { tools: true, pipelines: ["toolCall"] },
@@ -94,14 +94,24 @@ var plugin = {
   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",
@@ -114,20 +124,39 @@ var plugin = {
             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) {
@@ -141,10 +170,12 @@ var plugin = {
         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,
@@ -158,68 +189,7 @@ var plugin = {
         };
       }
     });
-    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 = plugin;

package/dist/template-engine.js

@@ -85,17 +85,18 @@ var plugin = {
             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" };
@@ -109,17 +110,17 @@ var plugin = {
         } 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 } = await import('fs');
-          writeFileSync(outputPath, result, "utf-8");
+          writeFileSync(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 {
@@ -136,26 +137,26 @@ var plugin = {
       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" };
@@ -163,7 +164,7 @@ var plugin = {
         let content;
         try {
           const { readFileSync } = await import('fs');
-          content = readFileSync(templatePath, "utf-8");
+          content = readFileSync(template_path, "utf-8");
         } catch (err) {
           return { ok: false, error: `Could not read template file: ${err}` };
         }
@@ -173,22 +174,22 @@ var plugin = {
         } 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 } = await import('fs');
-          writeFileSync(outputPath, result, "utf-8");
+          writeFileSync(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
         };

package/dist/web-search.d.ts

@@ -1,5 +1,19 @@
 import { Plugin } from '@wrongstack/core';
 
+/**
+ * web-search plugin — RETIRED.
+ *
+ * Both tools this plugin previously registered have been consolidated:
+ * - `web_search` → built-in `search` tool (packages/tools/src/search.ts)
+ *   with native caching, dedup, ranking, and multiple search engines.
+ * - `web_fetch` → built-in `fetch` tool (packages/tools/src/fetch.ts)
+ *   which is strictly superior (DNS-pinned SSRF, TurndownService markdown,
+ *   streaming, binary-content rejection, structured errors).
+ *
+ * This file remains as a no-op stub so existing config references
+ * (`"web-search": { "enabled": true }`) do not break.
+ */
+
 declare const plugin: Plugin;
 
 export { plugin as default };