@wrongstack/plugins 0.281.3 → 0.282.1

package/dist/model-router.js

@@ -107,6 +107,11 @@ var plugin = {
     }
     const cfg = readConfig(api.config.extensions?.["model-router"]);
     if (cfg.enabled && cfg.rules.length > 0) {
+      api.emitCustom?.("provider.wrap:loaded", {
+        plugin: "model-router",
+        kind: "routing",
+        wraps: ["request"]
+      });
       state.extensionUnregister = api.extensions.register({
         name: "model-router",
         owner: "model-router",

package/dist/performance-regression-gate.d.ts

@@ -0,0 +1,33 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * performance-regression-gate plugin — compares benchmark results to detect
+ * performance regressions.
+ *
+ * Tool registered:
+ * - perf_regression_status : Reads `bench-results.json` in the project root
+ *   (or a supplied path) and reports benchmarks whose execution time (`mean`)
+ *   increased beyond the configured threshold.
+ *
+ * The tool supports two comparison modes:
+ * 1. Internal pairing: when only `resultsPath` is supplied, benchmarks named
+ *    with `(old)` and `(new)` suffixes are paired. This matches Vitest bench
+ *    output comparing an old implementation against a new one.
+ * 2. Cross-file comparison: when `baselinePath` is also supplied, benchmarks
+ *    are matched by name across the two files.
+ *
+ * Config (`config.extensions['performance-regression-gate']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "thresholdPercent": 10
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/performance-regression-gate.js

@@ -0,0 +1,315 @@
+import { existsSync, readFileSync } from 'fs';
+import { resolve, isAbsolute, relative } from 'path';
+
+// src/performance-regression-gate/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  invocationCount: 0,
+  comparisonCount: 0,
+  regressionCount: 0,
+  missingResultsCount: 0,
+  errorCount: 0,
+  lastResult: null
+};
+var DEFAULTS = {
+  enabled: true,
+  thresholdPercent: 10
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  const threshold = typeof r["thresholdPercent"] === "number" && r["thresholdPercent"] >= 0 && r["thresholdPercent"] <= 1e3 ? r["thresholdPercent"] : DEFAULTS.thresholdPercent;
+  return {
+    enabled: r["enabled"] !== false,
+    thresholdPercent: threshold
+  };
+}
+function withinProject(p, cwd = process.cwd()) {
+  if (typeof p !== "string" || p.length === 0 || p.length > 4096) return false;
+  const root = resolve(cwd);
+  const resolved = isAbsolute(p) ? resolve(p) : resolve(root, p);
+  const rel = relative(root, resolved);
+  if (rel === "" || rel === ".") return true;
+  if (rel.startsWith("..")) return false;
+  if (isAbsolute(rel)) return false;
+  return true;
+}
+function resolveProjectPath(rawPath, cwd = process.cwd()) {
+  if (typeof rawPath !== "string" || rawPath.length === 0) return null;
+  const root = resolve(cwd);
+  const resolved = isAbsolute(rawPath) ? resolve(rawPath) : resolve(root, rawPath);
+  if (!withinProject(resolved, cwd)) return null;
+  return resolved;
+}
+function isValidNumber(n) {
+  return typeof n === "number" && Number.isFinite(n) && n > 0;
+}
+function flattenResults(results) {
+  const flat = [];
+  for (const file of results.files ?? []) {
+    for (const group of file.groups ?? []) {
+      for (const bench of group.benchmarks ?? []) {
+        if (!bench || typeof bench.name !== "string") continue;
+        const mean = isValidNumber(bench.mean) ? bench.mean : isValidNumber(bench.period) ? bench.period : null;
+        if (mean === null) continue;
+        flat.push({
+          key: `${group.fullName} > ${bench.name}`,
+          file: file.filepath ?? "",
+          group: group.fullName ?? "",
+          name: bench.name,
+          mean,
+          hz: isValidNumber(bench.hz) ? bench.hz : null
+        });
+      }
+    }
+  }
+  return flat;
+}
+function loadResults(path) {
+  if (!path || !existsSync(path)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf-8"));
+    return raw;
+  } catch {
+    return null;
+  }
+}
+function stripVariantSuffix(name) {
+  const trimmed = name.trim();
+  const oldMatch = /\(old\)\s*$/i.exec(trimmed);
+  if (oldMatch) {
+    return { base: trimmed.slice(0, oldMatch.index).trim(), variant: "old" };
+  }
+  const newMatch = /\(new\)\s*$/i.exec(trimmed);
+  if (newMatch) {
+    return { base: trimmed.slice(0, newMatch.index).trim(), variant: "new" };
+  }
+  return { base: trimmed, variant: null };
+}
+function pairInternal(benchmarks) {
+  const byBase = /* @__PURE__ */ new Map();
+  for (const bench of benchmarks) {
+    const { base, variant } = stripVariantSuffix(bench.name);
+    if (!variant) continue;
+    const groupBase = `${bench.group} > ${base}`;
+    const entry = byBase.get(groupBase) ?? {};
+    if (variant === "old") entry.old = bench;
+    if (variant === "new") entry.new = bench;
+    byBase.set(groupBase, entry);
+  }
+  const pairs = [];
+  for (const entry of byBase.values()) {
+    if (entry.old && entry.new) {
+      pairs.push({ old: entry.old, new: entry.new });
+    }
+  }
+  return pairs;
+}
+function pairCrossFile(baseline, current) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const bench of baseline) {
+    byKey.set(bench.key, bench);
+  }
+  const pairs = [];
+  for (const bench of current) {
+    const base = stripVariantSuffix(bench.name).base;
+    const lookupKey = `${bench.group} > ${base}`;
+    const old = byKey.get(lookupKey) ?? byKey.get(bench.key);
+    if (old) {
+      pairs.push({ old, new: bench });
+    }
+  }
+  return pairs;
+}
+function comparePairs(pairs, thresholdPercent) {
+  const regressions = [];
+  const thresholdFactor = 1 + thresholdPercent / 100;
+  for (const { old, new: current } of pairs) {
+    if (current.mean > old.mean * thresholdFactor) {
+      const increasePercent = (current.mean - old.mean) / old.mean * 100;
+      regressions.push({
+        benchmark: current.key,
+        metric: "mean",
+        oldValue: old.mean,
+        newValue: current.mean,
+        increasePercent: Math.round(increasePercent * 100) / 100
+      });
+    }
+  }
+  return regressions;
+}
+var plugin = {
+  name: "performance-regression-gate",
+  version: "0.1.0",
+  description: "Compares benchmark results to detect performance regressions and reports metrics that increased beyond the configured threshold",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: true,
+        description: "Master switch."
+      },
+      thresholdPercent: {
+        type: "number",
+        minimum: 0,
+        maximum: 1e3,
+        default: 10,
+        description: "Percentage increase in mean execution time that counts as a regression."
+      }
+    }
+  },
+  setup(api) {
+    state.invocationCount = 0;
+    state.comparisonCount = 0;
+    state.regressionCount = 0;
+    state.missingResultsCount = 0;
+    state.errorCount = 0;
+    state.lastResult = null;
+    const cfg = readConfig(api.config.extensions?.["performance-regression-gate"]);
+    api.tools.register({
+      name: "perf_regression_status",
+      description: "Reads bench-results.json and reports performance regressions. Without baselinePath, pairs benchmarks named with (old) and (new) suffixes. With baselinePath, compares matching benchmarks across the two files.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          resultsPath: {
+            type: "string",
+            default: "bench-results.json",
+            description: "Path to current benchmark results (JSON)."
+          },
+          baselinePath: {
+            type: "string",
+            description: "Optional path to baseline/previous results. If omitted, (old)/(new) pairs within resultsPath are compared."
+          },
+          thresholdPercent: {
+            type: "number",
+            description: "Override the configured threshold percentage."
+          }
+        }
+      },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) {
+          return { ok: false, error: "performance-regression-gate is disabled" };
+        }
+        state.invocationCount += 1;
+        const threshold = typeof input.thresholdPercent === "number" && input.thresholdPercent >= 0 && input.thresholdPercent <= 1e3 ? input.thresholdPercent : cfg.thresholdPercent;
+        const resultsPath = resolveProjectPath(input.resultsPath || "bench-results.json") ?? "";
+        if (!resultsPath) {
+          state.errorCount += 1;
+          return { ok: false, error: "invalid results path (must be inside project)" };
+        }
+        const results = loadResults(resultsPath);
+        if (!results) {
+          state.missingResultsCount += 1;
+          return {
+            ok: true,
+            hasResults: false,
+            thresholdPercent: threshold,
+            comparisons: 0,
+            regressions: [],
+            message: `No benchmark results found at ${input.resultsPath || "bench-results.json"}.`
+          };
+        }
+        const current = flattenResults(results);
+        if (current.length === 0) {
+          state.missingResultsCount += 1;
+          return {
+            ok: true,
+            hasResults: false,
+            thresholdPercent: threshold,
+            comparisons: 0,
+            regressions: [],
+            message: "No benchmarks with valid mean/period values were found."
+          };
+        }
+        let pairs;
+        if (input.baselinePath) {
+          const baselineResolved = resolveProjectPath(input.baselinePath) ?? "";
+          if (!baselineResolved) {
+            state.errorCount += 1;
+            return { ok: false, error: "invalid baseline path (must be inside project)" };
+          }
+          const baselineResults = loadResults(baselineResolved);
+          if (!baselineResults) {
+            state.errorCount += 1;
+            return {
+              ok: false,
+              error: `Could not read baseline results at ${input.baselinePath}.`
+            };
+          }
+          const baseline = flattenResults(baselineResults);
+          pairs = pairCrossFile(baseline, current);
+        } else {
+          pairs = pairInternal(current);
+        }
+        const regressions = comparePairs(pairs, threshold);
+        state.comparisonCount += pairs.length;
+        state.regressionCount += regressions.length;
+        state.lastResult = {
+          comparisons: pairs.length,
+          regressions: regressions.length,
+          thresholdPercent: threshold,
+          when: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        api.metrics.counter("comparisons", pairs.length);
+        if (regressions.length > 0) {
+          api.metrics.counter("regressions", regressions.length);
+        }
+        const regression = regressions.length > 0;
+        return {
+          ok: true,
+          hasResults: true,
+          regression,
+          thresholdPercent: threshold,
+          comparisons: pairs.length,
+          regressions,
+          message: regression ? `Detected ${regressions.length} regression(s) above ${threshold}% threshold.` : `No regressions detected across ${pairs.length} benchmark comparison(s) (threshold ${threshold}%).`
+        };
+      }
+    });
+    api.log.info("performance-regression-gate plugin loaded", {
+      version: "0.1.0",
+      thresholdPercent: cfg.thresholdPercent
+    });
+  },
+  teardown(api) {
+    const final = {
+      invocations: state.invocationCount,
+      comparisons: state.comparisonCount,
+      regressions: state.regressionCount,
+      missingResults: state.missingResultsCount,
+      errors: state.errorCount
+    };
+    state.invocationCount = 0;
+    state.comparisonCount = 0;
+    state.regressionCount = 0;
+    state.missingResultsCount = 0;
+    state.errorCount = 0;
+    state.lastResult = null;
+    api.log.info("performance-regression-gate: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.errorCount === 0,
+      message: state.lastResult ? `performance-regression-gate: ${state.lastResult.regressions} regression(s) across ${state.lastResult.comparisons} comparison(s) (threshold ${state.lastResult.thresholdPercent}%)` : `performance-regression-gate: ${state.invocationCount} invocation(s), ${state.comparisonCount} comparison(s)`,
+      counters: {
+        invocations: state.invocationCount,
+        comparisons: state.comparisonCount,
+        regressions: state.regressionCount,
+        missingResults: state.missingResultsCount,
+        errors: state.errorCount
+      },
+      lastResult: state.lastResult
+    };
+  }
+};
+var performance_regression_gate_default = plugin;
+
+export { performance_regression_gate_default as default };

package/dist/plugin-stack-observer.d.ts

@@ -0,0 +1,35 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * plugin-stack-observer — observability over the providerRunner wrap stack.
+ *
+ * Several official plugins (llm-cache, model-router, prompt-firewall,
+ * token-throttle) register `AgentExtension.wrapProviderRunner` to
+ * intercept every provider call. The runtime composes them in
+ * registration order — but until now there was no way for an operator
+ * (or the LLM itself) to see WHICH wraps are active in what order.
+ *
+ * Each wrap plugin emits `customEvent('provider.wrap:loaded', …)` on
+ * setup. This plugin subscribes via `onPattern('provider.wrap:loaded')`
+ * and:
+ *
+ *   1. Builds an in-memory stack (preserves emission order)
+ *   2. Registers a system-prompt contributor that, when any wraps are
+ *      present, emits a compact one-line block listing them. The LLM
+ *      sees who is wrapping what, in registration order — making the
+ *      stack visible without /diag round-trips.
+ *
+ * Disabled by default (enabled=false) because not every user wants
+ * the LLM to be aware of the wrap stack. The plugin_stack tool is
+ * always registered so operators can read the stack at runtime
+ * regardless of the contributor setting.
+ *
+ * Tools registered:
+ *  - plugin_stack_status : Read the active wrap stack + load order
+ *
+ * @public
+ */
+
+declare const PLUGIN: Plugin;
+
+export { PLUGIN as default };

package/dist/plugin-stack-observer.js

@@ -0,0 +1,138 @@
+// src/plugin-stack-observer/index.ts
+var state = {
+  wraps: [],
+  contributions: 0,
+  patternUnregister: null
+};
+function clearObserverState() {
+  if (state.patternUnregister) {
+    try {
+      state.patternUnregister();
+    } catch {
+    }
+    state.patternUnregister = null;
+  }
+  state.wraps = [];
+  state.contributions = 0;
+}
+var PLUGIN = {
+  name: "plugin-stack-observer",
+  version: "0.1.0",
+  description: "Observes the wrapProviderRunner stack and exposes it to operators (plugin_stack_status) and, optionally, to the LLM (system-prompt contributor).",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true },
+  defaultConfig: {
+    enabled: true,
+    /** Inject the stack into the LLM's system prompt. */
+    injectIntoSystemPrompt: false
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: true,
+        description: "Master switch. When false, no events are collected."
+      },
+      injectIntoSystemPrompt: {
+        type: "boolean",
+        default: false,
+        description: "When true, the active wrap stack is included as a TextBlock in every system-prompt build so the LLM knows who is wrapping its provider calls."
+      }
+    }
+  },
+  setup(api) {
+    clearObserverState();
+    const cfg = readConfig(api.config.extensions?.["plugin-stack-observer"]);
+    if (!cfg.enabled) {
+      api.log.info("plugin-stack-observer loaded (disabled)");
+      return;
+    }
+    state.patternUnregister = api.onPattern(
+      "provider.wrap:loaded",
+      (_eventName, payload) => {
+        const p = payload ?? {};
+        if (typeof p.plugin !== "string" || p.plugin.length === 0) return;
+        const wraps = Array.isArray(p.wraps) ? p.wraps.filter((w) => typeof w === "string") : [];
+        const kind = typeof p.kind === "string" ? p.kind : "unknown";
+        state.wraps.push({
+          plugin: p.plugin,
+          kind,
+          wraps,
+          loadedAt: Date.now()
+        });
+        api.metrics.counter("wrap_loaded");
+      }
+    );
+    if (cfg.injectIntoSystemPrompt) {
+      api.registerSystemPromptContributor(async () => {
+        if (state.wraps.length === 0) return [];
+        state.contributions += 1;
+        api.metrics.counter("system_prompt_contribution");
+        const lines = state.wraps.map(
+          (w, i) => `${i + 1}. ${w.plugin} [${w.kind}] wraps: ${w.wraps.join(", ")}`
+        );
+        return [
+          {
+            type: "text",
+            text: `[wrapProviderRunner stack \u2014 registration order]
+The following plugins wrap every LLM provider call in this order:
+` + lines.join("\n") + `
+Any failure or latency above is attributable to one of the above.`
+          }
+        ];
+      });
+    }
+    api.tools.register({
+      name: "plugin_stack_status",
+      description: "Returns the active wrapProviderRunner stack: plugin names, kinds, what they wrap, and registration order.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          injectIntoSystemPrompt: cfg.injectIntoSystemPrompt,
+          wrapCount: state.wraps.length,
+          wraps: state.wraps,
+          contributions: state.contributions
+        };
+      }
+    });
+    api.log.info("plugin-stack-observer loaded", {
+      enabled: cfg.enabled,
+      injectIntoSystemPrompt: cfg.injectIntoSystemPrompt
+    });
+  },
+  teardown(api) {
+    const final = {
+      wrapCount: state.wraps.length,
+      contributions: state.contributions
+    };
+    clearObserverState();
+    api.log.info("plugin-stack-observer: teardown complete", { final });
+  },
+  async health() {
+    const stack = state.wraps.length === 0 ? "no wraps active" : state.wraps.map((w) => w.plugin).join(" \u2192 ");
+    return {
+      ok: true,
+      message: `plugin-stack-observer: ${state.wraps.length} wrap(s) loaded [${stack}]`,
+      wrapCount: state.wraps.length,
+      contributions: state.contributions,
+      wraps: state.wraps
+    };
+  }
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { enabled: true, injectIntoSystemPrompt: false };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    injectIntoSystemPrompt: r["injectIntoSystemPrompt"] === true
+  };
+}
+var plugin_stack_observer_default = PLUGIN;
+
+export { plugin_stack_observer_default as default };

package/dist/pr-drafter.d.ts

@@ -0,0 +1,35 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * pr-drafter plugin — collects work done during a session and drafts a
+ * pull-request description.
+ *
+ * As the session runs, the plugin listens to:
+ *  - `tool.completed` events for `git_autocommit` (records commit messages)
+ *  - `tool.completed` events for `write`/`edit` (records changed files)
+ *  - `provider.response` events (records model usage)
+ *
+ * On `Stop` it composes a markdown PR body and writes it to a configurable
+ * file (default: `.wrongstack/PR_DRAFT.md`). A `pr_draft` tool lets the
+ * agent request the draft on demand.
+ *
+ * Config (`config.extensions['pr-drafter']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "outputPath": ".wrongstack/PR_DRAFT.md",
+ *   "writeOnStop": true,
+ *   "includeDiff": true,
+ *   "includeCommits": true,
+ *   "includeFiles": true,
+ *   "aiSummary": false
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };