@wrongstack/plugins 0.281.1 → 0.282.0

package/dist/test-generator.js

@@ -0,0 +1,243 @@
+import { readFileSync } from 'fs';
+import { resolve, isAbsolute, relative } from 'path';
+
+// src/test-generator/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  generateCount: 0,
+  exportCount: 0,
+  errorCount: 0
+};
+var DEFAULTS = {
+  enabled: true,
+  framework: "vitest",
+  testSuffix: ".test",
+  includeImports: true
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    framework: typeof r["framework"] === "string" ? r["framework"] : DEFAULTS.framework,
+    testSuffix: typeof r["testSuffix"] === "string" ? r["testSuffix"] : DEFAULTS.testSuffix,
+    includeImports: r["includeImports"] !== false
+  };
+}
+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 toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function relativePath(p) {
+  return toPosix(relative(process.cwd(), p));
+}
+function detectExports(content) {
+  const exports = [];
+  const seen = /* @__PURE__ */ new Set();
+  const functionRe = /export\s+(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
+  const arrowRe = /export\s+(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/g;
+  const classRe = /export\s+(?:abstract\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
+  const namedRe = /export\s*\{([^}]+)\}/g;
+  let m;
+  functionRe.lastIndex = 0;
+  while ((m = functionRe.exec(content)) !== null) {
+    if (!seen.has(m[1])) {
+      seen.add(m[1]);
+      exports.push({ name: m[1], kind: "function" });
+    }
+  }
+  arrowRe.lastIndex = 0;
+  while ((m = arrowRe.exec(content)) !== null) {
+    if (!seen.has(m[1])) {
+      seen.add(m[1]);
+      exports.push({ name: m[1], kind: "arrow" });
+    }
+  }
+  classRe.lastIndex = 0;
+  while ((m = classRe.exec(content)) !== null) {
+    if (!seen.has(m[1])) {
+      seen.add(m[1]);
+      exports.push({ name: m[1], kind: "class" });
+    }
+  }
+  namedRe.lastIndex = 0;
+  while ((m = namedRe.exec(content)) !== null) {
+    const names = m[1].split(",").map((s) => s.trim()).filter(Boolean);
+    for (const raw of names) {
+      const parts = raw.split(/\s+as\s+/);
+      const name = (parts.length > 1 ? parts[parts.length - 1] : raw).trim();
+      if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) continue;
+      if (!seen.has(name)) {
+        seen.add(name);
+        exports.push({ name, kind: "named" });
+      }
+    }
+  }
+  return exports;
+}
+function generateTestContent(filePath, detected, cfg) {
+  const sourcePath = relativePath(filePath);
+  const importNames = detected.map((e) => e.name).join(", ");
+  const lines = [];
+  if (cfg.framework === "vitest") {
+    lines.push(`import { describe, it, expect } from 'vitest';`);
+  } else {
+    lines.push(`const { describe, it, expect } = require('${cfg.framework}');`);
+  }
+  if (cfg.includeImports && detected.length > 0) {
+    lines.push(`import { ${importNames} } from './${sourcePath.replace(/\.[^.]+$/, "")}';`);
+  }
+  lines.push("");
+  lines.push(`describe('${sourcePath}', () => {`);
+  for (const exp of detected) {
+    lines.push(`  it('${exp.name} behaves as expected', () => {`);
+    lines.push(`    // TODO: replace with a real assertion for ${exp.name}`);
+    if (exp.kind === "class") {
+      lines.push(`    const instance = new ${exp.name}();`);
+      lines.push(`    expect(instance).toBeDefined();`);
+    } else {
+      lines.push(`    expect(${exp.name}).toBeDefined();`);
+    }
+    lines.push(`  });`);
+    lines.push("");
+  }
+  if (detected.length === 0) {
+    lines.push(`  it('has no exported symbols to test', () => {`);
+    lines.push(`    expect(true).toBe(true);`);
+    lines.push(`  });`);
+  }
+  lines.push(`});`);
+  return lines.join("\n");
+}
+function generateForFile(filePath, cfg) {
+  const content = readFileSync(filePath, "utf-8");
+  const detected = detectExports(content);
+  const sourceName = relativePath(filePath).split("/").pop();
+  const baseName = sourceName.replace(/\.[^.]+$/, "");
+  const testFile = `${baseName}${cfg.testSuffix}.ts`;
+  return {
+    sourceFile: relativePath(filePath),
+    testFile,
+    exports: detected,
+    content: generateTestContent(filePath, detected, cfg)
+  };
+}
+var plugin = {
+  name: "test-generator",
+  version: "0.1.0",
+  description: "Generates a test file skeleton from exported functions, classes, and arrow functions",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      framework: {
+        type: "string",
+        default: "vitest",
+        description: "Test framework to target."
+      },
+      testSuffix: {
+        type: "string",
+        default: ".test",
+        description: "Suffix inserted before the extension of the generated test filename."
+      },
+      includeImports: {
+        type: "boolean",
+        default: true,
+        description: "Emit import statements for detected exports."
+      }
+    }
+  },
+  setup(api) {
+    state.generateCount = 0;
+    state.exportCount = 0;
+    state.errorCount = 0;
+    const cfg = readConfig(api.config.extensions?.["test-generator"]);
+    api.tools.register({
+      name: "generate_unit_tests",
+      description: "Generate a test skeleton for a source file. Detects exported functions, arrow functions, classes, and named exports. Returns the test content as a string; it does not write to disk.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Source file path (relative to project root)."
+          }
+        },
+        required: ["path"]
+      },
+      permission: "auto",
+      category: "Development",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "test-generator is disabled" };
+        const rawPath = input.path;
+        if (!rawPath || typeof rawPath !== "string") {
+          return { ok: false, error: "path is required" };
+        }
+        if (!withinProject(rawPath)) {
+          return { ok: false, error: "path is outside the project root" };
+        }
+        const resolved = resolve(process.cwd(), rawPath);
+        state.generateCount += 1;
+        let result;
+        try {
+          result = generateForFile(resolved, cfg);
+        } catch (err) {
+          state.errorCount += 1;
+          return { ok: false, error: String(err) };
+        }
+        state.exportCount += result.exports.length;
+        return {
+          ok: true,
+          sourceFile: result.sourceFile,
+          testFile: result.testFile,
+          framework: cfg.framework,
+          exports: result.exports,
+          content: result.content
+        };
+      }
+    });
+    api.log.info("test-generator plugin loaded", {
+      version: "0.1.0",
+      framework: cfg.framework,
+      testSuffix: cfg.testSuffix
+    });
+  },
+  teardown(api) {
+    const final = {
+      generated: state.generateCount,
+      exports: state.exportCount,
+      errors: state.errorCount
+    };
+    state.generateCount = 0;
+    state.exportCount = 0;
+    state.errorCount = 0;
+    api.log.info("test-generator: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.errorCount === 0,
+      message: state.errorCount ? `test-generator: ${state.errorCount} error(s)` : `test-generator: ${state.generateCount} generation(s), ${state.exportCount} export(s)`,
+      counters: {
+        generated: state.generateCount,
+        exports: state.exportCount,
+        errors: state.errorCount
+      }
+    };
+  }
+};
+var test_generator_default = plugin;
+
+export { test_generator_default as default };

package/dist/test-runner-gate.js

@@ -1,6 +1,6 @@
-import { execSync } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 import { existsSync } from 'fs';
-import { basename, dirname, join } from 'path';
+import { isAbsolute, resolve, relative, basename, dirname, join } from 'path';
 
 // src/test-runner-gate/index.ts
 var API_VERSION = "^0.1.10";
@@ -16,36 +16,82 @@ var state = {
   noTestCount: 0,
   /** Times the test runner itself failed (timeout, crash). */
   errorCount: 0,
+  /** Times the extension filter short-circuited the hook (.json, .md, etc.). */
+  extensionSkippedCount: 0,
+  /** Times a re-run was skipped because the source hash matched a previous PASS. */
+  cachedSkipCount: 0,
   /** Hook handle for teardown. */
   hookUnregister: null,
   /** Last test result — surfaced by health() + status tool. */
   lastResult: null
 };
 var DEFAULTS = {
-  enabled: true,
+  enabled: false,
   runner: "auto",
   command: "",
   timeoutMs: 3e4,
-  testFilePatterns: [
-    "src/{name}.test.ts",
-    "tests/{name}.test.ts",
-    "tests/{name}-exec.test.ts"
-  ],
-  injectOnPass: false
+  testFilePatterns: ["src/{name}.test.ts", "tests/{name}.test.ts", "tests/{name}-exec.test.ts"],
+  injectOnPass: false,
+  enableContentHashCache: true,
+  enableExtensionFilter: true
 };
 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,
+    enabled: r["enabled"] === true,
     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
+    injectOnPass: r["injectOnPass"] === true,
+    enableContentHashCache: r["enableContentHashCache"] !== false,
+    enableExtensionFilter: r["enableExtensionFilter"] !== false
   };
 }
+var TESTABLE_DEFAULT_EXTS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".mts", ".cts"]);
+function getResolvableExtensions(patterns) {
+  const exts = /* @__PURE__ */ new Set();
+  for (const p of patterns) {
+    const m = /\.([a-z0-9]+)$/i.exec(p);
+    if (m?.[1]) exts.add(`.${m[1].toLowerCase()}`);
+  }
+  return exts;
+}
+function pathContentHash(content) {
+  const cap = Math.min(content.length, 65536);
+  let h = 5381;
+  for (let i = 0; i < cap; i++) {
+    h = (h << 5) + h + content.charCodeAt(i) | 0;
+  }
+  return h >>> 0;
+}
+var lastPassedHash = /* @__PURE__ */ new Map();
+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;
+}
+var ALLOWED_COMMAND_TOKENS = /* @__PURE__ */ new Set([
+  "npx",
+  "pnpm",
+  "pnpm",
+  "npm",
+  "yarn",
+  "vitest",
+  "jest",
+  "mocha",
+  // Useful for `command: "node ./scripts/run-tests.js"` style configs.
+  "node"
+  // Direct binary paths under the project's node_modules — resolved
+  // by basename in resolveAllowedCommand().
+]);
 function resolveTestFiles(sourcePath, patterns) {
   const name = basename(sourcePath).replace(/\.[^.]+$/, "");
   const pathNoExt = sourcePath.replace(/\.[^.]+$/, "");
@@ -106,16 +152,49 @@ function detectRunner(requested) {
   }
   return null;
 }
+function resolveAllowedCommand(customCommand) {
+  const tokens = customCommand.split(/\s+/).filter(Boolean);
+  if (tokens.length === 0) return null;
+  const head = tokens[0];
+  if (ALLOWED_COMMAND_TOKENS.has(head)) {
+    return { cmd: head, args: tokens.slice(1) };
+  }
+  if (isAbsolute(head)) {
+    if (!withinProject(head)) return null;
+    const base = basename(head);
+    if (ALLOWED_COMMAND_TOKENS.has(base)) {
+      return { cmd: head, args: tokens.slice(1) };
+    }
+  }
+  return null;
+}
 function runTests(testFile, runner, customCommand, timeoutMs) {
-  const baseCommand = customCommand || runner.command;
-  const fullCommand = `${baseCommand} "${testFile}" ${runner.jsonFlags}`;
+  if (!withinProject(testFile)) return null;
+  let cmd;
+  let cmdArgs;
+  let trailingFlag;
+  if (customCommand) {
+    const resolved = resolveAllowedCommand(customCommand);
+    if (!resolved) return null;
+    cmd = resolved.cmd;
+    cmdArgs = [...resolved.args, testFile];
+    trailingFlag = runner.jsonFlags;
+  } else {
+    const tokens = runner.command.split(/\s+/).filter(Boolean);
+    cmd = tokens[0];
+    cmdArgs = [...tokens.slice(1), testFile];
+    trailingFlag = runner.jsonFlags;
+  }
+  const trailing = trailingFlag.split(/\s+/).filter(Boolean);
+  const fullArgs = [...cmdArgs, ...trailing];
   let stdout = "";
   try {
-    stdout = execSync(fullCommand, {
+    stdout = execFileSync(cmd, fullArgs, {
       encoding: "utf-8",
       timeout: timeoutMs,
       cwd: process.cwd(),
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: false
     });
   } catch (err) {
     const e = err;
@@ -176,7 +255,7 @@ var plugin = {
     properties: {
       enabled: {
         type: "boolean",
-        default: true,
+        default: false,
         description: "Master switch."
       },
       runner: {
@@ -206,6 +285,16 @@ var plugin = {
         type: "boolean",
         default: false,
         description: "Inject additionalContext when tests pass too (default: only on failure)."
+      },
+      enableContentHashCache: {
+        type: "boolean",
+        default: true,
+        description: "Skip re-running tests when the source path is touched again with the same content hash as a previous PASS in this session."
+      },
+      enableExtensionFilter: {
+        type: "boolean",
+        default: true,
+        description: "Fast-path skip for non-TS/JS files (.json, .md, .lock, .txt, ...) before the test-file resolve walk."
       }
     }
   },
@@ -216,14 +305,20 @@ var plugin = {
     state.failCount = 0;
     state.noTestCount = 0;
     state.errorCount = 0;
+    state.extensionSkippedCount = 0;
+    state.cachedSkipCount = 0;
     state.hookUnregister = null;
     state.lastResult = null;
+    lastPassedHash.clear();
     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
-      });
+      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 });
     }
@@ -233,8 +328,30 @@ var plugin = {
       const inp = input.toolInput ?? {};
       const sourcePath = inp["path"];
       if (!sourcePath || typeof sourcePath !== "string") return;
+      if (!withinProject(sourcePath)) return;
       if (sourcePath.includes(".test.") || sourcePath.includes(".spec.")) return;
+      if (cfg.enableExtensionFilter) {
+        const ext = sourcePath.includes(".") ? sourcePath.slice(sourcePath.lastIndexOf(".")).toLowerCase() : "";
+        const resolvable = getResolvableExtensions(cfg.testFilePatterns);
+        if (ext && !resolvable.has(ext) && !TESTABLE_DEFAULT_EXTS.has(ext)) {
+          state.extensionSkippedCount += 1;
+          api.metrics.counter("extension_skipped");
+          return;
+        }
+      }
       state.invocationCount += 1;
+      if (cfg.enableContentHashCache) {
+        const content = input.toolName === "write" ? inp["content"] ?? "" : input.toolName === "edit" ? inp["new_string"] ?? "" : "";
+        if (typeof content === "string" && content.length > 0) {
+          const hash = pathContentHash(content);
+          const last = lastPassedHash.get(sourcePath);
+          if (last !== void 0 && last === hash) {
+            state.cachedSkipCount += 1;
+            api.metrics.counter("cached_skip");
+            return;
+          }
+        }
+      }
       const testFile = findTestFile(sourcePath, cfg.testFilePatterns);
       if (!testFile) {
         state.noTestCount += 1;
@@ -256,6 +373,12 @@ var plugin = {
       };
       if (result.passed) {
         state.passCount += 1;
+        if (cfg.enableContentHashCache) {
+          const content = input.toolName === "write" ? inp["content"] ?? "" : input.toolName === "edit" ? inp["new_string"] ?? "" : "";
+          if (typeof content === "string" && content.length > 0) {
+            lastPassedHash.set(sourcePath, pathContentHash(content));
+          }
+        }
         if (!cfg.injectOnPass) return;
         return {
           additionalContext: `
@@ -298,7 +421,9 @@ Fix the failing tests or revert the change if it broke something.`
             passed: state.passCount,
             failed: state.failCount,
             noTest: state.noTestCount,
-            errors: state.errorCount
+            errors: state.errorCount,
+            extensionSkipped: state.extensionSkippedCount,
+            cachedSkips: state.cachedSkipCount
           },
           lastResult: state.lastResult
         };
@@ -324,7 +449,9 @@ Fix the failing tests or revert the change if it broke something.`
       passed: state.passCount,
       failed: state.failCount,
       noTest: state.noTestCount,
-      errors: state.errorCount
+      errors: state.errorCount,
+      extensionSkipped: state.extensionSkippedCount,
+      cachedSkips: state.cachedSkipCount
     };
     state.invocationCount = 0;
     state.runCount = 0;
@@ -332,7 +459,10 @@ Fix the failing tests or revert the change if it broke something.`
     state.failCount = 0;
     state.noTestCount = 0;
     state.errorCount = 0;
+    state.extensionSkippedCount = 0;
+    state.cachedSkipCount = 0;
     state.lastResult = null;
+    lastPassedHash.clear();
     api.log.info("test-runner-gate: teardown complete", { final });
   },
   async health() {
@@ -345,7 +475,9 @@ Fix the failing tests or revert the change if it broke something.`
         passed: state.passCount,
         failed: state.failCount,
         noTest: state.noTestCount,
-        errors: state.errorCount
+        errors: state.errorCount,
+        extensionSkipped: state.extensionSkippedCount,
+        cachedSkips: state.cachedSkipCount
       },
       lastResult: state.lastResult
     };

package/dist/todo-listener.d.ts

@@ -22,10 +22,10 @@ import { Plugin } from '@wrongstack/core';
  *
  * ```jsonc
  * {
- *   "enabled": true,
+ *   "enabled": false,
  *   "subjectPrefix": "todo: ",
  *   "broadcastOnChange": true,
- *   "cooldownMs": 5000
+ *   "cooldownMs": 30000
  * }
  * ```
  *

package/dist/todo-listener.js

@@ -10,16 +10,16 @@ var state = {
   hookUnregister: null
 };
 var DEFAULTS = {
-  enabled: true,
+  enabled: false,
   subjectPrefix: "todo: ",
   broadcastOnChange: true,
-  cooldownMs: 5e3
+  cooldownMs: 3e4
 };
 function readConfig(raw) {
   if (!raw || typeof raw !== "object") return { ...DEFAULTS };
   const r = raw;
   return {
-    enabled: r["enabled"] !== false,
+    enabled: r["enabled"] === true,
     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
@@ -44,7 +44,7 @@ var plugin = {
   configSchema: {
     type: "object",
     properties: {
-      enabled: { type: "boolean", default: true, description: "Master switch." },
+      enabled: { type: "boolean", default: false, description: "Master switch." },
       subjectPrefix: {
         type: "string",
         default: DEFAULTS.subjectPrefix,
@@ -58,7 +58,7 @@ var plugin = {
       cooldownMs: {
         type: "number",
         minimum: 0,
-        default: 5e3,
+        default: DEFAULTS.cooldownMs,
         description: "Minimum interval between consecutive broadcasts (ms)."
       }
     }

package/dist/token-throttle.js

@@ -110,6 +110,11 @@ var plugin = {
     }
     const cfg = readConfig(api.config.extensions?.["token-throttle"]);
     if (cfg.enabled) {
+      api.emitCustom?.("provider.wrap:loaded", {
+        plugin: "token-throttle",
+        kind: "throttle",
+        wraps: ["request"]
+      });
       state.extensionUnregister = api.extensions.register({
         name: "token-throttle",
         owner: "token-throttle",

package/dist/type-gate.d.ts

@@ -0,0 +1,37 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * type-gate plugin — PostToolUse hook that runs TypeScript type-checking
+ * after every `write` or `edit` to a source file.
+ *
+ * `lint-gate` validates style; this plugin validates types. It runs
+ * `tsc --noEmit` (or a user-supplied command) and injects the first few
+ * errors as `additionalContext` so the model can fix type regressions in
+ * the same turn.
+ *
+ * Tools registered:
+ * - type_gate_status : Show config + per-session counters.
+ *
+ * Hooks registered:
+ * - PostToolUse with matcher `write|edit`.
+ *
+ * Config (`config.extensions['type-gate']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "command": "npx tsc --noEmit",  // base type-check command
+ *   "tsConfigPath": "tsconfig.json",
+ *   "timeoutMs": 60000,
+ *   "failSeverity": "warn",         // "warn" | "block"
+ *   "maxErrors": 5,                 // errors shown in context
+ *   "runOnChange": [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"]
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };