@wrongstack/plugins 0.1.0

package/dist/json-path.d.ts

@@ -0,0 +1,15 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * json-path plugin — JMESPath query, validate, and transform JSON/YAML.
+ *
+ * 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
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/json-path.js

@@ -0,0 +1,311 @@
+// 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 = 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 plugin = {
+  name: "json-path",
+  version: "0.1.0",
+  description: "JMESPath query, JSON Schema validation, transformation, and deep merge for JSON/YAML",
+  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" });
+  }
+};
+var json_path_default = plugin;
+
+export { json_path_default as default };

package/dist/semver-bump.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * semver-bump plugin — Conventional-commit-driven semver version bumps.
+ *
+ * Tools registered:
+ * - semver_bump: Determine and apply the next version bump
+ * - semver_current: Show the current version from package.json
+ * - semver_changelog: Generate a changelog between two versions
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/semver-bump.js

@@ -0,0 +1,347 @@
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+
+// src/semver-bump/index.ts
+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
+    }).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 = 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 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 plugin = {
+  name: "semver-bump",
+  version: "0.1.0",
+  description: "Conventional-commit-driven semver version bumps with changelog generation",
+  apiVersion: API_VERSION,
+  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 = runGit(["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 {
+          runGit(["add", "package.json"], cwd);
+          runGit(["commit", "-m", `chore: bump version to ${newVersion}`], cwd);
+        } catch {
+        }
+        if (autoTag) {
+          try {
+            runGit(["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 = runGit(["describe", "--tags", "--abbrev=0"], cwd);
+          latestTag = tagsOutput || null;
+          if (latestTag) {
+            const countOutput = runGit(["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 = runGit(["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 = plugin;
+
+export { semver_bump_default as default };

package/dist/shell-check.d.ts

@@ -0,0 +1,13 @@
+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
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };