@wrongstack/plugins 0.281.3 → 0.282.1

package/dist/test-coverage-gate.js

@@ -0,0 +1,263 @@
+import { readFileSync } from 'fs';
+import { isAbsolute, resolve, relative } from 'path';
+
+// src/test-coverage-gate/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  invocationCount: 0,
+  runCount: 0,
+  passCount: 0,
+  failCount: 0,
+  errorCount: 0,
+  skippedCount: 0,
+  lastOverallPct: null,
+  lastResult: null,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: true,
+  coveragePath: "coverage/coverage-summary.json",
+  threshold: 80,
+  mode: "warn",
+  deltaThreshold: 1,
+  runOnChange: [".ts", ".tsx", ".js", ".jsx"]
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    coveragePath: typeof r["coveragePath"] === "string" ? r["coveragePath"] : DEFAULTS.coveragePath,
+    threshold: typeof r["threshold"] === "number" && r["threshold"] >= 0 && r["threshold"] <= 100 ? r["threshold"] : DEFAULTS.threshold,
+    mode: r["mode"] === "block" ? "block" : DEFAULTS.mode,
+    deltaThreshold: typeof r["deltaThreshold"] === "number" && r["deltaThreshold"] >= 0 ? r["deltaThreshold"] : DEFAULTS.deltaThreshold,
+    runOnChange: Array.isArray(r["runOnChange"]) ? r["runOnChange"].filter((x) => typeof x === "string") : DEFAULTS.runOnChange
+  };
+}
+function withinProject(p) {
+  if (typeof p !== "string" || p.length === 0 || p.length > 4096) return false;
+  const root = process.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 readCoverageSummary(coveragePath) {
+  try {
+    const raw = readFileSync(coveragePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function overallPercent(summary) {
+  const total = summary.total;
+  if (!total || typeof total !== "object") return null;
+  const t = total;
+  const values = ["lines", "statements", "functions", "branches"].map((k) => t[k]?.pct).filter((v) => typeof v === "number");
+  if (values.length === 0) return null;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+var plugin = {
+  name: "test-coverage-gate",
+  version: "0.1.0",
+  description: "PostToolUse hook that detects test coverage regressions after source-file edits",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: true,
+        description: "Master switch."
+      },
+      coveragePath: {
+        type: "string",
+        default: "coverage/coverage-summary.json",
+        description: "Path to the JSON coverage summary file."
+      },
+      threshold: {
+        type: "number",
+        minimum: 0,
+        maximum: 100,
+        default: 80,
+        description: "Minimum allowed overall coverage percentage."
+      },
+      mode: {
+        type: "string",
+        enum: ["warn", "block"],
+        default: "warn",
+        description: "warn = inject context; block = refuse the mutating tool."
+      },
+      deltaThreshold: {
+        type: "number",
+        minimum: 0,
+        default: 1,
+        description: "Warn/block when coverage drops by at least this many percentage points."
+      },
+      runOnChange: {
+        type: "array",
+        items: { type: "string" },
+        default: [".ts", ".tsx", ".js", ".jsx"],
+        description: "Only check coverage when the edited file has one of these extensions."
+      }
+    }
+  },
+  setup(api) {
+    state.invocationCount = 0;
+    state.runCount = 0;
+    state.passCount = 0;
+    state.failCount = 0;
+    state.errorCount = 0;
+    state.skippedCount = 0;
+    state.lastOverallPct = null;
+    state.lastResult = null;
+    state.hookUnregister = null;
+    const cfg = readConfig(api.config.extensions?.["test-coverage-gate"]);
+    const hook = (input) => {
+      if (!cfg.enabled) return;
+      if (input.toolResult?.isError) return;
+      const inp = input.toolInput ?? {};
+      const sourcePath = inp["path"];
+      if (!sourcePath || typeof sourcePath !== "string") return;
+      if (!withinProject(sourcePath)) return;
+      const ext = sourcePath.includes(".") ? sourcePath.slice(sourcePath.lastIndexOf(".")).toLowerCase() : "";
+      if (!cfg.runOnChange.includes(ext)) {
+        state.skippedCount += 1;
+        return;
+      }
+      state.invocationCount += 1;
+      const summary = readCoverageSummary(cfg.coveragePath);
+      if (!summary) {
+        state.errorCount += 1;
+        return;
+      }
+      const pct = overallPercent(summary);
+      if (pct === null) {
+        state.errorCount += 1;
+        return;
+      }
+      state.runCount += 1;
+      const previous = state.lastOverallPct;
+      state.lastOverallPct = pct;
+      const belowThreshold = pct < cfg.threshold;
+      const dropped = previous !== null && previous - pct >= cfg.deltaThreshold;
+      const passed = !belowThreshold && !dropped;
+      state.lastResult = {
+        overallPct: pct,
+        previousOverallPct: previous,
+        threshold: cfg.threshold,
+        passed,
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (passed) {
+        state.passCount += 1;
+        return;
+      }
+      state.failCount += 1;
+      const parts = ["\n\u274C test-coverage-gate:"];
+      if (belowThreshold) {
+        parts.push(
+          `  Overall coverage ${pct.toFixed(2)}% is below the ${cfg.threshold}% threshold.`
+        );
+      }
+      if (dropped) {
+        parts.push(
+          `  Coverage dropped from ${previous.toFixed(2)}% to ${pct.toFixed(2)}% (>= ${cfg.deltaThreshold}% delta).`
+        );
+      }
+      parts.push("  Add or update tests to recover coverage before continuing.");
+      const message = parts.join("\n");
+      if (cfg.mode === "block") {
+        return {
+          decision: "block",
+          reason: message
+        };
+      }
+      return { additionalContext: message };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "coverage_gate_status",
+      description: "Reports test-coverage-gate state: threshold, mode, last coverage percentage, and counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          coveragePath: cfg.coveragePath,
+          threshold: cfg.threshold,
+          mode: cfg.mode,
+          deltaThreshold: cfg.deltaThreshold,
+          lastOverallPct: state.lastOverallPct,
+          counters: {
+            invocations: state.invocationCount,
+            runs: state.runCount,
+            passed: state.passCount,
+            failed: state.failCount,
+            errors: state.errorCount,
+            skipped: state.skippedCount
+          },
+          lastResult: state.lastResult
+        };
+      }
+    });
+    api.log.info("test-coverage-gate plugin loaded", {
+      version: "0.1.0",
+      coveragePath: cfg.coveragePath,
+      threshold: cfg.threshold,
+      mode: cfg.mode
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      invocations: state.invocationCount,
+      runs: state.runCount,
+      passed: state.passCount,
+      failed: state.failCount,
+      errors: state.errorCount,
+      skipped: state.skippedCount
+    };
+    state.invocationCount = 0;
+    state.runCount = 0;
+    state.passCount = 0;
+    state.failCount = 0;
+    state.errorCount = 0;
+    state.skippedCount = 0;
+    state.lastOverallPct = null;
+    state.lastResult = null;
+    api.log.info("test-coverage-gate: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastResult ? `test-coverage-gate: ${state.runCount} run(s), last ${state.lastResult.passed ? "PASSED" : "FAILED"} (${state.lastResult.overallPct.toFixed(2)}%)` : `test-coverage-gate: ${state.invocationCount} invocation(s), ${state.runCount} run(s)`,
+      counters: {
+        invocations: state.invocationCount,
+        runs: state.runCount,
+        passed: state.passCount,
+        failed: state.failCount,
+        errors: state.errorCount,
+        skipped: state.skippedCount
+      },
+      lastResult: state.lastResult
+    };
+  }
+};
+var test_coverage_gate_default = plugin;
+
+export { test_coverage_gate_default as default };

package/dist/test-flake-detector.d.ts

@@ -0,0 +1,27 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * test-flake-detector plugin — runs a test command multiple times and reports
+ * tests that fail non-deterministically (flaky tests).
+ *
+ * Tools registered:
+ * - `flake_detect` : run a test command N times and identify flaky tests
+ * - `flake_status` : show config + per-session counters
+ *
+ * Config (`config.extensions['test-flake-detector']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "defaultCommand": "npx vitest run", // used when flake_detect.command is omitted
+ *   "maxRuns": 20,                      // hard upper bound for runs param
+ *   "timeoutMs": 120000                 // per-run timeout
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/test-flake-detector.js

@@ -0,0 +1,274 @@
+import { execSync } from 'child_process';
+
+// src/test-flake-detector/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  invocationCount: 0,
+  runCount: 0,
+  errorCount: 0,
+  lastResult: null
+};
+var DEFAULTS = {
+  enabled: true,
+  defaultCommand: "npx vitest run",
+  maxRuns: 20,
+  timeoutMs: 12e4
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    defaultCommand: typeof r["defaultCommand"] === "string" ? r["defaultCommand"] : DEFAULTS.defaultCommand,
+    maxRuns: typeof r["maxRuns"] === "number" && r["maxRuns"] >= 1 && r["maxRuns"] <= 100 ? Math.floor(r["maxRuns"]) : DEFAULTS.maxRuns,
+    timeoutMs: typeof r["timeoutMs"] === "number" && r["timeoutMs"] > 0 ? r["timeoutMs"] : DEFAULTS.timeoutMs
+  };
+}
+function parseTestOutput(output) {
+  const passed = [];
+  const failed = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const rawLine of output.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const passMatch = line.match(/^[✓✔]\s+(.+)/);
+    if (passMatch) {
+      const name = passMatch[1].trim();
+      if (!seen.has(`p:${name}`)) {
+        seen.add(`p:${name}`);
+        passed.push(name);
+      }
+      continue;
+    }
+    const failMatch = line.match(/^[✕✗×]\s+(.+)/);
+    if (failMatch) {
+      const name = failMatch[1].trim();
+      if (!seen.has(`f:${name}`)) {
+        seen.add(`f:${name}`);
+        failed.push(name);
+      }
+      continue;
+    }
+    const jestFailMatch = line.match(/^●\s+(.+)/);
+    if (jestFailMatch) {
+      const name = jestFailMatch[1].trim();
+      if (!seen.has(`f:${name}`)) {
+        seen.add(`f:${name}`);
+        failed.push(name);
+      }
+    }
+  }
+  return { passed, failed };
+}
+function buildCommand(baseCommand, testPattern) {
+  const trimmedBase = baseCommand.trim();
+  if (!testPattern) return trimmedBase;
+  if (trimmedBase.includes(testPattern)) return trimmedBase;
+  return `${trimmedBase} ${testPattern}`;
+}
+function runOnce(command, timeoutMs) {
+  try {
+    const output = execSync(command, {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { output };
+  } catch (err) {
+    const e = err;
+    if (e.killed) {
+      return { output: e.stdout ?? "", error: `timeout after ${timeoutMs}ms` };
+    }
+    const output = `${e.stdout ?? ""}
+${e.stderr ?? ""}`.trim();
+    return { output, error: e.message ?? "test command exited with non-zero code" };
+  }
+}
+var plugin = {
+  name: "test-flake-detector",
+  version: "0.1.0",
+  description: "Runs a test command multiple times and reports tests that fail non-deterministically",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: true,
+        description: "Master switch."
+      },
+      defaultCommand: {
+        type: "string",
+        default: "npx vitest run",
+        description: "Command used when flake_detect.command is omitted."
+      },
+      maxRuns: {
+        type: "number",
+        minimum: 1,
+        maximum: 100,
+        default: 20,
+        description: "Hard upper bound for the runs parameter."
+      },
+      timeoutMs: {
+        type: "number",
+        minimum: 1e3,
+        default: 12e4,
+        description: "Per-run timeout in milliseconds."
+      }
+    }
+  },
+  setup(api) {
+    state.invocationCount = 0;
+    state.runCount = 0;
+    state.errorCount = 0;
+    state.lastResult = null;
+    const cfg = readConfig(api.config.extensions?.["test-flake-detector"]);
+    api.tools.register({
+      name: "flake_detect",
+      description: "Runs a test command multiple times and reports tests that fail non-deterministically. Provide testPattern and optionally runs (default 5) and command.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          testPattern: {
+            type: "string",
+            description: "Test file pattern or path to pass to the test command."
+          },
+          runs: {
+            type: "number",
+            minimum: 1,
+            maximum: 100,
+            default: 5,
+            description: "How many times to run the command."
+          },
+          command: {
+            type: "string",
+            description: "Custom test command. Defaults to the configured defaultCommand."
+          }
+        }
+      },
+      permission: "confirm",
+      category: "Diagnostics",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) {
+          return { ok: false, error: "test-flake-detector is disabled" };
+        }
+        const requestedRuns = typeof input.runs === "number" && input.runs >= 1 ? Math.min(Math.floor(input.runs), cfg.maxRuns) : 5;
+        const command = buildCommand(
+          typeof input.command === "string" && input.command.trim().length > 0 ? input.command : cfg.defaultCommand,
+          input.testPattern
+        );
+        state.invocationCount += 1;
+        const start = Date.now();
+        const records = /* @__PURE__ */ new Map();
+        let runsCompleted = 0;
+        const runErrors = [];
+        for (let run = 1; run <= requestedRuns; run += 1) {
+          const { output, error } = runOnce(command, cfg.timeoutMs);
+          state.runCount += 1;
+          if (error) {
+            state.errorCount += 1;
+            runErrors.push(`run ${run}: ${error}`);
+          }
+          const parsed = parseTestOutput(output);
+          runsCompleted += 1;
+          for (const name of parsed.passed) {
+            const rec = records.get(name) ?? { test: name, passCount: 0, failCount: 0 };
+            rec.passCount += 1;
+            records.set(name, rec);
+          }
+          for (const name of parsed.failed) {
+            const rec = records.get(name) ?? { test: name, passCount: 0, failCount: 0 };
+            rec.failCount += 1;
+            records.set(name, rec);
+          }
+        }
+        const all = Array.from(records.values());
+        const flakyTests = all.filter((r) => r.passCount > 0 && r.failCount > 0);
+        const alwaysFailing = all.filter((r) => r.passCount === 0 && r.failCount > 0);
+        const alwaysPassing = all.filter((r) => r.passCount > 0 && r.failCount === 0);
+        const durationMs = Date.now() - start;
+        state.lastResult = {
+          runsRequested: requestedRuns,
+          runsCompleted,
+          flakyTests,
+          alwaysFailing,
+          alwaysPassing,
+          durationMs,
+          when: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return {
+          ok: true,
+          command,
+          runsRequested: requestedRuns,
+          runsCompleted,
+          durationMs,
+          totalTestsObserved: all.length,
+          flakyCount: flakyTests.length,
+          flakyTests,
+          alwaysFailing,
+          alwaysPassing,
+          runErrors: runErrors.length > 0 ? runErrors : void 0
+        };
+      }
+    });
+    api.tools.register({
+      name: "flake_status",
+      description: "Reports test-flake-detector state: config and per-session counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          defaultCommand: cfg.defaultCommand,
+          maxRuns: cfg.maxRuns,
+          timeoutMs: cfg.timeoutMs,
+          counters: {
+            invocations: state.invocationCount,
+            runs: state.runCount,
+            errors: state.errorCount
+          },
+          lastResult: state.lastResult
+        };
+      }
+    });
+    api.log.info("test-flake-detector plugin loaded", {
+      version: "0.1.0",
+      defaultCommand: cfg.defaultCommand,
+      maxRuns: cfg.maxRuns
+    });
+  },
+  teardown(api) {
+    const final = {
+      invocations: state.invocationCount,
+      runs: state.runCount,
+      errors: state.errorCount
+    };
+    state.invocationCount = 0;
+    state.runCount = 0;
+    state.errorCount = 0;
+    state.lastResult = null;
+    api.log.info("test-flake-detector: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastResult ? `test-flake-detector: ${state.runCount} run(s), last detection found ${state.lastResult.flakyTests.length} flaky test(s)` : `test-flake-detector: ${state.invocationCount} invocation(s), ${state.runCount} run(s)`,
+      counters: {
+        invocations: state.invocationCount,
+        runs: state.runCount,
+        errors: state.errorCount
+      },
+      lastResult: state.lastResult
+    };
+  }
+};
+var test_flake_detector_default = plugin;
+
+export { test_flake_detector_default as default };

package/dist/test-generator.d.ts

@@ -0,0 +1,32 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * test-generator plugin — generates a Vitest test skeleton from a source file
+ * using regex-based export detection.
+ *
+ * Tool registered:
+ * - generate_unit_tests : Read a source file and return a test file skeleton.
+ *
+ * No hooks are registered.
+ *
+ * Config (`config.extensions['test-generator']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "framework": "vitest",
+ *   "testSuffix": ".test",
+ *   "includeImports": true
+ * }
+ * ```
+ *
+ * @public
+ */
+
+interface DetectedExport {
+    name: string;
+    kind: 'function' | 'arrow' | 'class' | 'named';
+}
+declare const plugin: Plugin;
+
+export { type DetectedExport, plugin as default };