@wrongstack/plugins 0.277.1 → 0.280.0

package/dist/test-runner-gate.js

@@ -0,0 +1,356 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { basename, dirname, join } from 'path';
+
+// src/test-runner-gate/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  invocationCount: 0,
+  /** Times a test file was found and tests ran. */
+  runCount: 0,
+  /** Times tests passed. */
+  passCount: 0,
+  /** Times tests failed. */
+  failCount: 0,
+  /** Times no test file was found for the source file. */
+  noTestCount: 0,
+  /** Times the test runner itself failed (timeout, crash). */
+  errorCount: 0,
+  /** Hook handle for teardown. */
+  hookUnregister: null,
+  /** Last test result — surfaced by health() + status tool. */
+  lastResult: null
+};
+var DEFAULTS = {
+  enabled: true,
+  runner: "auto",
+  command: "",
+  timeoutMs: 3e4,
+  testFilePatterns: [
+    "src/{name}.test.ts",
+    "tests/{name}.test.ts",
+    "tests/{name}-exec.test.ts"
+  ],
+  injectOnPass: false
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  const runner = r["runner"] === "vitest" || r["runner"] === "jest" || r["runner"] === "mocha" ? r["runner"] : "auto";
+  return {
+    enabled: r["enabled"] !== false,
+    runner,
+    command: typeof r["command"] === "string" ? r["command"] : DEFAULTS.command,
+    timeoutMs: typeof r["timeoutMs"] === "number" && r["timeoutMs"] > 0 ? r["timeoutMs"] : DEFAULTS.timeoutMs,
+    testFilePatterns: Array.isArray(r["testFilePatterns"]) && r["testFilePatterns"].length > 0 ? r["testFilePatterns"].filter((x) => typeof x === "string") : DEFAULTS.testFilePatterns,
+    injectOnPass: r["injectOnPass"] === true
+  };
+}
+function resolveTestFiles(sourcePath, patterns) {
+  const name = basename(sourcePath).replace(/\.[^.]+$/, "");
+  const pathNoExt = sourcePath.replace(/\.[^.]+$/, "");
+  const dir = dirname(sourcePath);
+  const candidates = [];
+  for (const pattern of patterns) {
+    const candidate = pattern.replace(/\{name\}/g, name).replace(/\{path\}/g, pathNoExt).replace(/\{dir\}/g, dir);
+    if (!candidate.startsWith("/") && !candidate.includes("{")) {
+      if (pattern.includes("{dir}")) {
+        candidates.push(candidate);
+      } else {
+        candidates.push(candidate);
+        candidates.push(join(dir, candidate));
+      }
+    }
+  }
+  return candidates;
+}
+function findTestFile(sourcePath, patterns) {
+  const candidates = resolveTestFiles(sourcePath, patterns);
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function detectRunner(requested) {
+  const candidates = [
+    { name: "vitest", command: "npx vitest run", jsonFlags: "--reporter=json" },
+    { name: "jest", command: "npx jest", jsonFlags: "--json" },
+    { name: "mocha", command: "npx mocha", jsonFlags: "--reporter json" }
+  ];
+  if (requested !== "auto") {
+    const match = candidates.find((c) => c.name === requested);
+    if (!match) return null;
+    try {
+      execSync(`npx ${match.name} --version`, {
+        encoding: "utf-8",
+        timeout: 5e3,
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return match;
+    } catch {
+      return null;
+    }
+  }
+  for (const candidate of candidates) {
+    try {
+      execSync(`npx ${candidate.name} --version`, {
+        encoding: "utf-8",
+        timeout: 5e3,
+        cwd: process.cwd(),
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function runTests(testFile, runner, customCommand, timeoutMs) {
+  const baseCommand = customCommand || runner.command;
+  const fullCommand = `${baseCommand} "${testFile}" ${runner.jsonFlags}`;
+  let stdout = "";
+  try {
+    stdout = execSync(fullCommand, {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (err) {
+    const e = err;
+    if (e.killed) return null;
+    if (e.stdout) stdout = e.stdout;
+    else return null;
+  }
+  try {
+    const data = JSON.parse(stdout);
+    const numTotalTests = data.numTotalTests ?? 0;
+    const numFailedTests = data.numFailedTests ?? 0;
+    const numPassedTests = data.numPassedTests ?? 0;
+    const success = data.success ?? numFailedTests === 0;
+    const failures = [];
+    if (data.testResults) {
+      for (const fileResult of data.testResults) {
+        for (const assertion of fileResult.assertionResults ?? []) {
+          if (assertion.status === "failed") {
+            const fullName = assertion.fullName ?? assertion.title ?? "unknown";
+            const message = (assertion.failureMessages?.[0] ?? "").split("\n")[0]?.slice(0, 200);
+            failures.push(`${fullName}: ${message}`);
+            if (failures.length >= 5) break;
+          }
+        }
+        if (failures.length >= 5) break;
+      }
+    }
+    return {
+      passed: success && numFailedTests === 0,
+      testCount: numTotalTests,
+      failCount: numFailedTests,
+      duration: `${data.startTime ? "\u2014" : ""} ${numPassedTests} passed, ${numFailedTests} failed`,
+      failures
+    };
+  } catch {
+    const passedMatch = stdout.match(/(\d+)\s+passed/);
+    const failedMatch = stdout.match(/(\d+)\s+failed/);
+    const passed = passedMatch ? Number.parseInt(passedMatch[1], 10) : 0;
+    const failed = failedMatch ? Number.parseInt(failedMatch[1], 10) : 0;
+    return {
+      passed: failed === 0,
+      testCount: passed + failed,
+      failCount: failed,
+      duration: `${passed} passed, ${failed} failed`,
+      failures: []
+    };
+  }
+}
+var plugin = {
+  name: "test-runner-gate",
+  version: "0.1.0",
+  description: "PostToolUse hook that runs the relevant test file after every write or edit to a source file",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: {
+        type: "boolean",
+        default: true,
+        description: "Master switch."
+      },
+      runner: {
+        type: "string",
+        enum: ["vitest", "jest", "mocha", "auto"],
+        default: "auto",
+        description: 'Which test runner to use. "auto" tries vitest first, then jest, then mocha.'
+      },
+      command: {
+        type: "string",
+        default: "",
+        description: "Custom command prefix (overrides the runner default). Empty = use runner default."
+      },
+      timeoutMs: {
+        type: "number",
+        minimum: 5e3,
+        default: 3e4,
+        description: "Test process timeout in milliseconds."
+      },
+      testFilePatterns: {
+        type: "array",
+        items: { type: "string" },
+        default: ["src/{name}.test.ts", "tests/{name}.test.ts", "tests/{name}-exec.test.ts"],
+        description: "Patterns to derive test file from source. {name}=basename, {path}=path-no-ext, {dir}=dirname."
+      },
+      injectOnPass: {
+        type: "boolean",
+        default: false,
+        description: "Inject additionalContext when tests pass too (default: only on failure)."
+      }
+    }
+  },
+  setup(api) {
+    state.invocationCount = 0;
+    state.runCount = 0;
+    state.passCount = 0;
+    state.failCount = 0;
+    state.noTestCount = 0;
+    state.errorCount = 0;
+    state.hookUnregister = null;
+    state.lastResult = null;
+    const cfg = readConfig(api.config.extensions?.["test-runner-gate"]);
+    const runner = detectRunner(cfg.runner);
+    if (!runner) {
+      api.log.warn("test-runner-gate: no test runner found (vitest, jest, mocha) \u2014 hook will be a no-op", {
+        requested: cfg.runner
+      });
+    } else {
+      api.log.info("test-runner-gate: detected runner", { name: runner.name });
+    }
+    const hook = (input) => {
+      if (!cfg.enabled || !runner) return;
+      if (input.toolResult?.isError) return;
+      const inp = input.toolInput ?? {};
+      const sourcePath = inp["path"];
+      if (!sourcePath || typeof sourcePath !== "string") return;
+      if (sourcePath.includes(".test.") || sourcePath.includes(".spec.")) return;
+      state.invocationCount += 1;
+      const testFile = findTestFile(sourcePath, cfg.testFilePatterns);
+      if (!testFile) {
+        state.noTestCount += 1;
+        return;
+      }
+      const result = runTests(testFile, runner, cfg.command, cfg.timeoutMs);
+      if (!result) {
+        state.errorCount += 1;
+        return;
+      }
+      state.runCount += 1;
+      state.lastResult = {
+        sourcePath,
+        testPath: testFile,
+        passed: result.passed,
+        testCount: result.testCount,
+        duration: result.duration,
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (result.passed) {
+        state.passCount += 1;
+        if (!cfg.injectOnPass) return;
+        return {
+          additionalContext: `
+\u2705 test-runner-gate: ${result.testCount} test(s) passed for ${testFile} (${result.duration}). Source: ${sourcePath}.`
+        };
+      }
+      state.failCount += 1;
+      const failureList = result.failures.length > 0 ? "\n" + result.failures.map((f) => `  \u274C ${f}`).join("\n") : "";
+      const truncated = result.failCount > 5 ? `
+  \u2026 and ${result.failCount - 5} more failure(s)` : "";
+      api.log.warn(`test-runner-gate: ${result.failCount} test(s) failed for ${testFile}`, {
+        source: sourcePath
+      });
+      return {
+        additionalContext: `
+\u274C test-runner-gate: ${result.failCount} of ${result.testCount} test(s) FAILED for ${testFile} after editing ${sourcePath}.${failureList}${truncated}
+Fix the failing tests or revert the change if it broke something.`
+      };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "test_gate_status",
+      description: "Reports test-runner-gate state: command, patterns, and per-session pass/fail/error/no-test counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Testing",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          runner: runner?.name ?? "none",
+          command: cfg.command || runner?.command || "",
+          timeoutMs: cfg.timeoutMs,
+          testFilePatterns: cfg.testFilePatterns,
+          injectOnPass: cfg.injectOnPass,
+          counters: {
+            invocations: state.invocationCount,
+            runs: state.runCount,
+            passed: state.passCount,
+            failed: state.failCount,
+            noTest: state.noTestCount,
+            errors: state.errorCount
+          },
+          lastResult: state.lastResult
+        };
+      }
+    });
+    api.log.info("test-runner-gate plugin loaded", {
+      version: "0.1.0",
+      command: cfg.command,
+      patterns: cfg.testFilePatterns.length
+    });
+  },
+  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,
+      noTest: state.noTestCount,
+      errors: state.errorCount
+    };
+    state.invocationCount = 0;
+    state.runCount = 0;
+    state.passCount = 0;
+    state.failCount = 0;
+    state.noTestCount = 0;
+    state.errorCount = 0;
+    state.lastResult = null;
+    api.log.info("test-runner-gate: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: state.lastResult === null ? `test-runner-gate: ${state.invocationCount} invocation(s), ${state.runCount} test run(s)` : state.lastResult.passed ? `test-runner-gate: last run PASSED (${state.lastResult.testCount} tests) on ${state.lastResult.testPath}` : `test-runner-gate: last run FAILED (${state.lastResult.testCount} tests) on ${state.lastResult.testPath} at ${state.lastResult.when}`,
+      counters: {
+        invocations: state.invocationCount,
+        runs: state.runCount,
+        passed: state.passCount,
+        failed: state.failCount,
+        noTest: state.noTestCount,
+        errors: state.errorCount
+      },
+      lastResult: state.lastResult
+    };
+  }
+};
+var test_runner_gate_default = plugin;
+
+export { test_runner_gate_default as default };

package/dist/todo-listener.d.ts

@@ -0,0 +1,37 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * todo-listener plugin — PostToolUse hook on the `todo` tool that
+ * broadcasts a structured status update to the project mailbox.
+ *
+ * When the agent (or any plugin) calls the built-in `todo` tool, the
+ * full todo list is replaced in `ctx.todos`. The hook fires after the
+ * tool completes, reads the new state, and posts a compact summary
+ * to the project mailbox so that other agents in the same project
+ * (terminals, WebUIs, shadow agents) can see what this agent is
+ * working on in real time.
+ *
+ * Use cases:
+ *  - Multi-agent fleets where a coordinator should know which
+ *    sub-agent is working on which item
+ *  - Long-running sessions where a user opens a second terminal and
+ *    wants to see the in-progress plan
+ *  - Shadow agents that audit progress across the project
+ *
+ * Config (`config.extensions['todo-listener']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "subjectPrefix": "todo: ",
+ *   "broadcastOnChange": true,
+ *   "cooldownMs": 5000
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/todo-listener.js

@@ -0,0 +1,216 @@
+// src/todo-listener/index.ts
+var state = {
+  invocationCount: 0,
+  sentCount: 0,
+  skippedCount: 0,
+  errorCount: 0,
+  lastMessageId: null,
+  lastPayloadHash: "",
+  lastBroadcastAt: 0,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: true,
+  subjectPrefix: "todo: ",
+  broadcastOnChange: true,
+  cooldownMs: 5e3
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    subjectPrefix: typeof r["subjectPrefix"] === "string" ? r["subjectPrefix"] : DEFAULTS.subjectPrefix,
+    broadcastOnChange: r["broadcastOnChange"] !== false,
+    cooldownMs: typeof r["cooldownMs"] === "number" && r["cooldownMs"] >= 0 ? r["cooldownMs"] : DEFAULTS.cooldownMs
+  };
+}
+function hashTodos(todos) {
+  const sorted = todos.map((t) => `${t.id}|${t.status}|${t.content ?? ""}`).sort();
+  let h = 2166136261;
+  for (let i = 0; i < sorted.join("\n").length; i++) {
+    h ^= sorted.join("\n").charCodeAt(i);
+    h = h * 16777619 >>> 0;
+  }
+  return h.toString(16);
+}
+var plugin = {
+  name: "todo-listener",
+  version: "0.1.0",
+  description: "PostToolUse hook on `todo` tool \u2014 broadcasts a status update to the project mailbox so other agents can see what this one is working on",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      subjectPrefix: {
+        type: "string",
+        default: DEFAULTS.subjectPrefix,
+        description: "Prepended to the broadcast `subject`. Useful for filtering the inbox."
+      },
+      broadcastOnChange: {
+        type: "boolean",
+        default: true,
+        description: "When true, identical consecutive payloads are suppressed."
+      },
+      cooldownMs: {
+        type: "number",
+        minimum: 0,
+        default: 5e3,
+        description: "Minimum interval between consecutive broadcasts (ms)."
+      }
+    }
+  },
+  setup(api) {
+    state.invocationCount = 0;
+    state.sentCount = 0;
+    state.skippedCount = 0;
+    state.errorCount = 0;
+    state.lastMessageId = null;
+    state.lastPayloadHash = "";
+    state.lastBroadcastAt = 0;
+    state.hookUnregister = null;
+    const cfg = readConfig(api.config.extensions?.["todo-listener"]);
+    const mailbox = api.mailbox;
+    const hook = async (input) => {
+      if (!cfg.enabled) return;
+      if (input.toolName !== "todo") return;
+      if (input.toolResult?.isError) return;
+      state.invocationCount += 1;
+      if (!mailbox) {
+        state.skippedCount += 1;
+        api.log.warn(
+          "todo-listener: no mailbox available on api \u2014 broadcasts disabled. Add `mailbox` to the setupPlugins() call to enable cross-agent visibility."
+        );
+        return;
+      }
+      const inp = input.toolInput ?? {};
+      const todos = Array.isArray(inp.todos) ? inp.todos : [];
+      const inProgress = todos.find((t) => t.status === "in_progress");
+      const pending = todos.filter((t) => t.status === "pending").length;
+      const completed = todos.filter((t) => t.status === "completed").length;
+      const payload = {
+        count: todos.length,
+        inProgress: inProgress ? { id: inProgress.id, content: inProgress.content } : null,
+        pending,
+        completed,
+        items: todos.map((t) => ({ id: t.id, status: t.status, content: t.content }))
+      };
+      const hash = hashTodos(todos);
+      if (cfg.broadcastOnChange && hash === state.lastPayloadHash) {
+        state.skippedCount += 1;
+        return;
+      }
+      const now = Date.now();
+      if (now - state.lastBroadcastAt < cfg.cooldownMs) {
+        state.skippedCount += 1;
+        return;
+      }
+      const subject = `${cfg.subjectPrefix}${inProgress ? `working on '${inProgress.content}'` : `${todos.length} item(s)`}`.slice(
+        0,
+        200
+      );
+      const body = JSON.stringify(payload, null, 2);
+      const sendInput = {
+        from: `plugin:todo-listener`,
+        to: "*",
+        type: "status",
+        subject,
+        body,
+        priority: "normal"
+      };
+      try {
+        const result = await mailbox.send(sendInput);
+        const id = result.id ?? null;
+        state.sentCount += 1;
+        state.lastMessageId = id;
+        state.lastPayloadHash = hash;
+        state.lastBroadcastAt = now;
+        api.log.info(`todo-listener: broadcast todo update`, {
+          count: payload.count,
+          inProgress: payload.inProgress?.id ?? null,
+          messageId: id
+        });
+      } catch (err) {
+        state.errorCount += 1;
+        api.log.warn("todo-listener: mailbox.send failed", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "todo", hook);
+    api.tools.register({
+      name: "todo_listener_status",
+      description: "Reports todo-listener state: config + per-session counters (invocations, sent, skipped, errors) and last broadcast id.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          subjectPrefix: cfg.subjectPrefix,
+          broadcastOnChange: cfg.broadcastOnChange,
+          cooldownMs: cfg.cooldownMs,
+          mailboxAvailable: Boolean(mailbox),
+          counters: {
+            invocations: state.invocationCount,
+            sent: state.sentCount,
+            skipped: state.skippedCount,
+            errors: state.errorCount
+          },
+          lastMessageId: state.lastMessageId,
+          lastBroadcastAt: state.lastBroadcastAt > 0 ? new Date(state.lastBroadcastAt).toISOString() : null
+        };
+      }
+    });
+    api.log.info("todo-listener plugin loaded", {
+      version: "0.1.0",
+      enabled: cfg.enabled,
+      mailboxAvailable: Boolean(mailbox)
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      invocations: state.invocationCount,
+      sent: state.sentCount,
+      skipped: state.skippedCount,
+      errors: state.errorCount
+    };
+    state.invocationCount = 0;
+    state.sentCount = 0;
+    state.skippedCount = 0;
+    state.errorCount = 0;
+    state.lastMessageId = null;
+    state.lastPayloadHash = "";
+    state.lastBroadcastAt = 0;
+    api.log.info("todo-listener: teardown complete", { final });
+  },
+  async health() {
+    const base = `todo-listener: ${state.invocationCount} invocation(s), ${state.sentCount} sent, ${state.skippedCount} skipped, ${state.errorCount} error(s)`;
+    return {
+      ok: true,
+      message: state.lastMessageId ? `${base}; last broadcast ${state.lastMessageId}` : `${base}; no broadcast yet`,
+      counters: {
+        invocations: state.invocationCount,
+        sent: state.sentCount,
+        skipped: state.skippedCount,
+        errors: state.errorCount
+      },
+      lastMessageId: state.lastMessageId
+    };
+  }
+};
+var todo_listener_default = plugin;
+
+export { todo_listener_default as default };

package/dist/todo-tracker.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from '@wrongstack/core';
+
+declare const plugin: Plugin;
+
+export { plugin as default };