@wrongstack/plugins 0.277.1 → 0.280.0

package/dist/diff-summary.js

@@ -0,0 +1,235 @@
+import { execSync } from 'child_process';
+
+// src/diff-summary/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  invocationCount: 0,
+  /** Times a diff was successfully generated and injected. */
+  injectedCount: 0,
+  /** Times git diff failed (not a repo, untracked, etc.). */
+  fallbackCount: 0,
+  /** Hook handle for teardown. */
+  hookUnregister: null,
+  /** Last diff summary — surfaced by health() + status tool. */
+  lastSummary: null
+};
+var DEFAULTS = {
+  maxLines: 50,
+  showStat: true,
+  mode: "diff",
+  includeContext: 3
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    maxLines: typeof r["maxLines"] === "number" && r["maxLines"] > 0 ? r["maxLines"] : DEFAULTS.maxLines,
+    showStat: r["showStat"] !== false,
+    mode: r["mode"] === "stat" ? "stat" : r["mode"] === "off" ? "off" : "diff",
+    includeContext: typeof r["includeContext"] === "number" && r["includeContext"] >= 0 ? r["includeContext"] : DEFAULTS.includeContext
+  };
+}
+function getGitDiff(filePath, contextLines, cwd) {
+  const opts = {
+    encoding: "utf-8",
+    timeout: 3e3,
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"]
+  };
+  let isTracked = false;
+  try {
+    execSync(`git ls-files --error-unmatch "${filePath}"`, opts);
+    isTracked = true;
+  } catch {
+    isTracked = false;
+  }
+  try {
+    let rawDiff;
+    const contextFlag = `-U${contextLines}`;
+    if (isTracked) {
+      rawDiff = execSync(`git diff ${contextFlag} -- "${filePath}"`, opts);
+    } else {
+      try {
+        rawDiff = execSync(`git diff --no-index ${contextFlag} /dev/null "${filePath}"`, opts);
+      } catch (err) {
+        const e = err;
+        rawDiff = e.stdout ?? "";
+      }
+    }
+    if (!rawDiff.trim()) {
+      return { diff: "", added: 0, removed: 0, isNewFile: !isTracked };
+    }
+    const lines = rawDiff.split("\n");
+    let added = 0;
+    let removed = 0;
+    for (const line of lines) {
+      if (line.startsWith("+") && !line.startsWith("+++")) added++;
+      else if (line.startsWith("-") && !line.startsWith("---")) removed++;
+    }
+    return { diff: rawDiff, added, removed, isNewFile: !isTracked };
+  } catch {
+    return null;
+  }
+}
+function buildStatSummary(filePath, result) {
+  if (result.diff === "") return `${filePath}: no changes`;
+  const tag = result.isNewFile ? " (new file)" : "";
+  return `${filePath}${tag}: +${result.added} -${result.removed}`;
+}
+function buildDiffSummary(filePath, result, maxLines) {
+  if (result.diff === "") return `${filePath}: no changes`;
+  const lines = result.diff.split("\n");
+  const tag = result.isNewFile ? " (new file)" : "";
+  if (lines.length <= maxLines) {
+    return `${filePath}${tag}: +${result.added} -${result.removed}
+${result.diff}`;
+  }
+  const truncated = lines.slice(0, maxLines).join("\n");
+  return `${filePath}${tag}: +${result.added} -${result.removed}
+${truncated}
+... (${lines.length - maxLines} more lines truncated)`;
+}
+var plugin = {
+  name: "diff-summary",
+  version: "0.1.0",
+  description: "PostToolUse hook that injects a compact git diff into the LLM context after every write or edit",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      maxLines: {
+        type: "number",
+        minimum: 5,
+        default: 50,
+        description: "Cap diff context at N lines to avoid blowing up the context window."
+      },
+      showStat: {
+        type: "boolean",
+        default: true,
+        description: 'Include "+N -M" summary line.'
+      },
+      mode: {
+        type: "string",
+        enum: ["diff", "stat", "off"],
+        default: "diff",
+        description: '"diff" injects unified diff; "stat" injects only +N -M counts; "off" disables the hook.'
+      },
+      includeContext: {
+        type: "number",
+        minimum: 0,
+        default: 3,
+        description: "Context lines around each change (git -U<N>). 0 = compact (no surrounding lines), 3 = git default, higher = more orientation."
+      }
+    }
+  },
+  setup(api) {
+    state.invocationCount = 0;
+    state.injectedCount = 0;
+    state.fallbackCount = 0;
+    state.hookUnregister = null;
+    state.lastSummary = null;
+    const cfg = readConfig(api.config.extensions?.["diff-summary"]);
+    const cwd = typeof process.cwd === "function" ? process.cwd() : void 0;
+    const hook = (input) => {
+      if (cfg.mode === "off") return;
+      if (input.toolResult?.isError) return;
+      const toolName = input.toolName ?? "";
+      const inp = input.toolInput ?? {};
+      const filePath = inp["path"];
+      if (!filePath || typeof filePath !== "string") return;
+      state.invocationCount += 1;
+      const result = getGitDiff(filePath, cfg.includeContext, cwd);
+      if (!result) {
+        state.fallbackCount += 1;
+        return;
+      }
+      if (result.diff === "" && result.added === 0 && result.removed === 0) {
+        return;
+      }
+      state.injectedCount += 1;
+      state.lastSummary = {
+        path: filePath,
+        tool: toolName,
+        added: result.added,
+        removed: result.removed,
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      let summary;
+      if (cfg.mode === "stat") {
+        summary = buildStatSummary(filePath, result);
+      } else {
+        summary = buildDiffSummary(filePath, result, cfg.maxLines);
+      }
+      const header = cfg.showStat ? `
+\u{1F4DD} diff-summary (${toolName}): ` : "\n\u{1F4DD} diff-summary: ";
+      return {
+        additionalContext: header + summary
+      };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "diff_summary_status",
+      description: "Reports diff-summary state: mode, maxLines, and per-session invocation/injected/fallback counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Meta",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          mode: cfg.mode,
+          maxLines: cfg.maxLines,
+          showStat: cfg.showStat,
+          includeContext: cfg.includeContext,
+          counters: {
+            invocations: state.invocationCount,
+            injected: state.injectedCount,
+            fallbacks: state.fallbackCount
+          },
+          lastSummary: state.lastSummary
+        };
+      }
+    });
+    api.log.info("diff-summary plugin loaded", {
+      version: "0.1.0",
+      mode: cfg.mode,
+      maxLines: cfg.maxLines
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      invocations: state.invocationCount,
+      injected: state.injectedCount,
+      fallbacks: state.fallbackCount
+    };
+    state.invocationCount = 0;
+    state.injectedCount = 0;
+    state.fallbackCount = 0;
+    state.lastSummary = null;
+    api.log.info("diff-summary: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastSummary === null ? `diff-summary: ${state.invocationCount} invocation(s), ${state.injectedCount} injected` : `diff-summary: last ${state.lastSummary.tool} on ${state.lastSummary.path} (+${state.lastSummary.added} -${state.lastSummary.removed}) at ${state.lastSummary.when}`,
+      counters: {
+        invocations: state.invocationCount,
+        injected: state.injectedCount,
+        fallbacks: state.fallbackCount
+      },
+      lastSummary: state.lastSummary
+    };
+  }
+};
+var diff_summary_default = plugin;
+
+export { diff_summary_default as default };

package/dist/error-lens.d.ts

@@ -0,0 +1,67 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * error-lens plugin — turns noisy failure output into a compact,
+ * actionable digest.
+ *
+ * When a shell command fails, the model gets a wall of stderr: full
+ * stack traces, npm noise, repeated frames. A `PostToolUse` hook on
+ * `bash|exec` parses the failure and injects a short digest via
+ * `additionalContext`:
+ *
+ *  - the error type + message line (TypeError, ENOENT, AssertionError…)
+ *  - up to `maxFrames` source locations (`file:line`), *project frames
+ *    first* (node_modules/internal frames are de-prioritized)
+ *  - a repeat marker when the same failure was already seen, so the
+ *    model notices "this is the SAME error as before"
+ *
+ * Recognized trace formats: Node/V8 (`at fn (file:line:col)`), Python
+ * (`File "x.py", line 12`), tsc/vitest (`file.ts:12:5`), Rust
+ * (`--> src/main.rs:4:5`), Go (`file.go:12 +0x…`).
+ *
+ * A ring of recent failures is queryable via `error_lens_history` —
+ * useful for "what have we broken so far this session?".
+ *
+ * Config (`config.extensions['error-lens']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "maxFrames": 5,        // source locations per digest
+ *   "historySize": 20,     // failures kept for error_lens_history
+ *   "minOutputChars": 200, // don't digest tiny outputs (already readable)
+ *   "aiHints": false,      // ask the LLM (api.llm) for a one-line fix hint
+ *   "llm": { "provider": "", "model": "" }  // optional override for the hint model
+ * }
+ * ```
+ *
+ * With `aiHints: true` and a host that wires `api.llm`, each NEW failure
+ * digest is enriched with a one-line fix hint from the configured LLM
+ * (per-plugin `llm.provider`/`llm.model` override the session default).
+ * Hint failures are swallowed — the digest always lands.
+ *
+ * Toggle off with `{ "name": "error-lens", "enabled": false }` in
+ * `config.plugins`, or `"enabled": false` in the options above.
+ *
+ * @public
+ */
+
+interface FailureRecord {
+    when: string;
+    tool: string;
+    command: string | null;
+    errorLine: string | null;
+    frames: string[];
+    repeats: number;
+}
+/** Extract the first recognizable error line from tool output. */
+declare function extractErrorLine(output: string): string | null;
+/**
+ * Extract source locations (`file:line`) from tool output.
+ * Project frames (not node_modules / internal) are ordered first,
+ * duplicates removed, capped at `maxFrames`.
+ */
+declare function extractFrames(output: string, maxFrames: number): string[];
+declare const plugin: Plugin;
+
+export { type FailureRecord, plugin as default, extractErrorLine, extractFrames };

package/dist/error-lens.js

@@ -0,0 +1,280 @@
+// src/error-lens/index.ts
+var state = {
+  history: [],
+  invocations: 0,
+  digestsInjected: 0,
+  repeatsDetected: 0,
+  aiHintsProvided: 0,
+  aiHintErrors: 0,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: true,
+  maxFrames: 5,
+  historySize: 20,
+  minOutputChars: 200,
+  aiHints: false
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    maxFrames: typeof r["maxFrames"] === "number" && r["maxFrames"] >= 1 && r["maxFrames"] <= 20 ? r["maxFrames"] : DEFAULTS.maxFrames,
+    historySize: typeof r["historySize"] === "number" && r["historySize"] >= 1 && r["historySize"] <= 200 ? r["historySize"] : DEFAULTS.historySize,
+    minOutputChars: typeof r["minOutputChars"] === "number" && r["minOutputChars"] >= 0 ? r["minOutputChars"] : DEFAULTS.minOutputChars,
+    aiHints: r["aiHints"] === true
+  };
+}
+var ERROR_LINE_PATTERNS = [
+  // JS/TS: "TypeError: x is not a function", "Error: ENOENT: no such file"
+  /^[ \t]*(?:Uncaught )?((?:[A-Z][a-zA-Z]*)?(?:Error|Exception|AssertionError)[^\n]*)/m,
+  // Node errno style: "ENOENT: no such file or directory"
+  /^[ \t]*((?:ENOENT|EACCES|EADDRINUSE|ECONNREFUSED|ETIMEDOUT|EPERM|ENOTEMPTY)[^\n]*)/m,
+  // Python: "ValueError: invalid literal ..."
+  /^([A-Z][a-zA-Z]*(?:Error|Exception|Warning): [^\n]*)/m,
+  // Rust panic: "thread 'main' panicked at ..."
+  /^(thread '[^']*' panicked at [^\n]*)/m,
+  // Go panic: "panic: runtime error: ..."
+  /^(panic: [^\n]*)/m,
+  // Generic FAIL lines from test runners.
+  /^[ \t]*((?:FAIL|✗|×)[ \t]+[^\n]{5,})/m
+];
+var FRAME_PATTERNS = [
+  // Node/V8: "at fn (path/file.ts:12:5)" or "at path/file.ts:12:5"
+  /\bat\s+(?:[^(\n]+\()?([^()\n:]+:\d+)(?::\d+)?\)?/g,
+  // Python: File "path/file.py", line 12
+  /File "([^"]+)", line (\d+)/g,
+  // tsc/vitest/eslint bare: "src/foo.ts:12:5" (require a path-ish prefix)
+  /(?:^|[ \t(])([A-Za-z0-9_./\\-]+\.[a-z]{1,4}:\d+)(?::\d+)?/gm,
+  // Rust: "--> src/main.rs:4:5"
+  /-->\s+([^\s:]+:\d+)/g
+];
+function extractErrorLine(output) {
+  for (const re of ERROR_LINE_PATTERNS) {
+    const m = re.exec(output);
+    if (m?.[1]) return m[1].trim().slice(0, 300);
+  }
+  return null;
+}
+function extractFrames(output, maxFrames) {
+  const seen = /* @__PURE__ */ new Set();
+  const project = [];
+  const vendor = [];
+  for (const re of FRAME_PATTERNS) {
+    re.lastIndex = 0;
+    let m = re.exec(output);
+    while (m !== null) {
+      const frame = m[2] !== void 0 ? `${m[1]}:${m[2]}` : m[1] ?? "";
+      const cleaned = frame.replace(/\\/g, "/").trim();
+      if (cleaned && !seen.has(cleaned)) {
+        seen.add(cleaned);
+        const isVendor = cleaned.includes("node_modules/") || cleaned.startsWith("node:") || cleaned.includes("internal/");
+        (isVendor ? vendor : project).push(cleaned);
+      }
+      m = re.exec(output);
+    }
+  }
+  return [...project, ...vendor].slice(0, maxFrames);
+}
+function failureKey(errorLine, frames) {
+  return `${errorLine ?? ""}|${frames[0] ?? ""}`;
+}
+var plugin = {
+  name: "error-lens",
+  version: "0.1.0",
+  description: "Distills failed command output into a compact digest (error line + project stack frames) and flags repeated failures",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      maxFrames: {
+        type: "number",
+        minimum: 1,
+        maximum: 20,
+        default: 5,
+        description: "Source locations included per digest."
+      },
+      historySize: {
+        type: "number",
+        minimum: 1,
+        maximum: 200,
+        default: 20,
+        description: "Failures kept for error_lens_history."
+      },
+      minOutputChars: {
+        type: "number",
+        minimum: 0,
+        default: 200,
+        description: "Outputs shorter than this are not digested (already readable)."
+      },
+      aiHints: {
+        type: "boolean",
+        default: false,
+        description: 'Enrich each NEW failure digest with a one-line fix hint from the LLM (api.llm). Provider/model follow config.extensions["error-lens"].llm, then the session default.'
+      },
+      llm: {
+        type: "object",
+        description: "Optional { provider, model } override for AI hints."
+      }
+    }
+  },
+  setup(api) {
+    state.history = [];
+    state.invocations = 0;
+    state.digestsInjected = 0;
+    state.repeatsDetected = 0;
+    state.aiHintsProvided = 0;
+    state.aiHintErrors = 0;
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["error-lens"]);
+    const hook = async (input) => {
+      if (!cfg.enabled) return;
+      state.invocations += 1;
+      const result = input.toolResult;
+      if (!result) return;
+      const output = result.content ?? "";
+      if (!result.isError) return;
+      if (output.length < cfg.minOutputChars) return;
+      const errorLine = extractErrorLine(output);
+      const frames = extractFrames(output, cfg.maxFrames);
+      if (!errorLine && frames.length === 0) return;
+      const key = failureKey(errorLine, frames);
+      const previous = state.history.find((h) => failureKey(h.errorLine, h.frames) === key);
+      let repeats = 1;
+      let isNewFailure = false;
+      if (previous) {
+        previous.repeats += 1;
+        previous.when = (/* @__PURE__ */ new Date()).toISOString();
+        repeats = previous.repeats;
+        state.repeatsDetected += 1;
+        api.metrics.counter("repeats");
+      } else {
+        isNewFailure = true;
+        const ti = input.toolInput ?? {};
+        state.history.push({
+          when: (/* @__PURE__ */ new Date()).toISOString(),
+          tool: input.toolName ?? "unknown",
+          command: typeof ti["command"] === "string" ? ti["command"].slice(0, 200) : null,
+          errorLine,
+          frames,
+          repeats: 1
+        });
+        if (state.history.length > cfg.historySize) {
+          state.history.splice(0, state.history.length - cfg.historySize);
+        }
+      }
+      state.digestsInjected += 1;
+      api.metrics.counter("digests");
+      const parts = ["error-lens digest:"];
+      if (errorLine) parts.push(`  error: ${errorLine}`);
+      if (frames.length > 0) parts.push(`  frames: ${frames.join("  ")}`);
+      if (repeats > 1) {
+        parts.push(
+          `  NOTE: this is the SAME failure as ${repeats - 1} earlier attempt(s) \u2014 the previous fix did not work; try a different approach.`
+        );
+      }
+      if (cfg.aiHints && isNewFailure && api.llm) {
+        try {
+          const hint = await api.llm.complete(
+            `A command failed with this error:
+${errorLine ?? "(no error line)"}
+` + (frames.length > 0 ? `Top stack frames: ${frames.join(", ")}
+` : "") + "Reply with ONE short sentence suggesting the most likely fix. No preamble.",
+            { system: "You are a terse debugging assistant.", maxTokens: 100 }
+          );
+          const text = hint.text.trim();
+          if (text) {
+            state.aiHintsProvided += 1;
+            api.metrics.counter("ai_hints");
+            parts.push(`  hint (${hint.model}): ${text.slice(0, 300)}`);
+          }
+        } catch {
+          state.aiHintErrors += 1;
+        }
+      }
+      return { additionalContext: parts.join("\n") };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "bash|exec", hook);
+    api.tools.register({
+      name: "error_lens_history",
+      description: "Lists failures observed this session (error line, source frames, repeat counts). Useful to review what has been breaking.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: { type: "number", description: "Max entries to return (default 10)." }
+        }
+      },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute(input) {
+        const limit = typeof input.limit === "number" && input.limit >= 1 ? Math.floor(input.limit) : 10;
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          aiHints: cfg.aiHints,
+          llmAvailable: Boolean(api.llm),
+          failures: [...state.history].reverse().slice(0, limit),
+          counters: {
+            invocations: state.invocations,
+            digestsInjected: state.digestsInjected,
+            repeatsDetected: state.repeatsDetected,
+            aiHintsProvided: state.aiHintsProvided,
+            aiHintErrors: state.aiHintErrors
+          }
+        };
+      }
+    });
+    api.log.info("error-lens plugin loaded", {
+      version: "0.1.0",
+      enabled: cfg.enabled,
+      maxFrames: cfg.maxFrames
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      invocations: state.invocations,
+      digestsInjected: state.digestsInjected,
+      repeatsDetected: state.repeatsDetected,
+      aiHintsProvided: state.aiHintsProvided
+    };
+    state.history = [];
+    state.invocations = 0;
+    state.digestsInjected = 0;
+    state.repeatsDetected = 0;
+    state.aiHintsProvided = 0;
+    state.aiHintErrors = 0;
+    api.log.info("error-lens: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: `error-lens: ${state.digestsInjected} digest(s) injected, ${state.repeatsDetected} repeat(s) flagged, ${state.history.length} failure(s) in history`,
+      counters: {
+        invocations: state.invocations,
+        digestsInjected: state.digestsInjected,
+        repeatsDetected: state.repeatsDetected
+      }
+    };
+  }
+};
+var error_lens_default = plugin;
+
+export { error_lens_default as default, extractErrorLine, extractFrames };

package/dist/format-on-save.d.ts

@@ -0,0 +1,35 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * auto-format-on-save plugin — PostToolUse hook that runs biome
+ * `format --write` on the file after every `write` or `edit`.
+ *
+ * Unlike lint-gate (which lints BEFORE the tool runs and can block),
+ * this plugin formats AFTER the write/edit commits — ensuring the
+ * file on disk always matches the project's formatting rules. No
+ * blocking, no warnings — just silently formats in-place.
+ *
+ * Tools registered:
+ * - format_on_save_status : Show config + per-session counters.
+ *
+ * Hooks registered:
+ * - PostToolUse with matcher `write|edit`. After the tool completes,
+ *   runs `biome format --write <path>` on the actual file on disk.
+ *   If the file changed (formatting was applied), logs the diff size.
+ *   If biome fails or the file doesn't exist, silent fallback.
+ *
+ * Config (`config.extensions['format-on-save']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,    // master switch
+ *   "timeoutMs": 5000   // biome process timeout
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };