@wrongstack/plugins 0.277.2 → 0.280.0

package/dist/spec-linker.js

@@ -0,0 +1,541 @@
+import { existsSync, statSync } from 'fs';
+import * as fsp from 'fs/promises';
+import 'child_process';
+import 'path';
+import '@wrongstack/core';
+import 'os';
+import 'crypto';
+import '@wrongstack/core/utils';
+
+// src/spec-linker/index.ts
+var plugin = {
+  name: "auto-doc"};
+var auto_doc_default = plugin;
+var plugin2 = {
+  name: "auto-escalate"};
+var auto_escalate_default = plugin2;
+var plugin3 = {
+  name: "branch-guard"};
+var branch_guard_default = plugin3;
+var plugin4 = {
+  name: "changelog-writer"};
+var changelog_writer_default = plugin4;
+var plugin5 = {
+  name: "checkpoint"};
+var checkpoint_default = plugin5;
+var plugin6 = {
+  name: "commit-validator"};
+var commit_validator_default = plugin6;
+var plugin7 = {
+  name: "config-validator"};
+var config_validator_default = plugin7;
+var plugin8 = {
+  name: "context-pins"};
+var context_pins_default = plugin8;
+var plugin9 = {
+  name: "cost-tracker"};
+var cost_tracker_default = plugin9;
+({
+  createdAt: (/* @__PURE__ */ new Date()).toISOString()
+});
+var plugin10 = {
+  name: "cron"};
+var cron_default = plugin10;
+var plugin11 = {
+  name: "dep-guard"};
+var dep_guard_default = plugin11;
+var plugin12 = {
+  name: "diff-summary"};
+var diff_summary_default = plugin12;
+var plugin13 = {
+  name: "error-lens"};
+var error_lens_default = plugin13;
+var plugin14 = {
+  name: "file-watcher"};
+var file_watcher_default = plugin14;
+var plugin15 = {
+  name: "format-on-save"};
+var format_on_save_default = plugin15;
+var plugin16 = {
+  name: "git-autocommit"};
+var git_autocommit_default = plugin16;
+var plugin17 = {
+  name: "import-organizer"};
+var import_organizer_default = plugin17;
+var plugin18 = {
+  name: "injection-shield"};
+var injection_shield_default = plugin18;
+var plugin19 = {
+  name: "lint-gate"};
+var lint_gate_default = plugin19;
+var plugin20 = {
+  name: "llm-cache"};
+var llm_cache_default = plugin20;
+var plugin21 = {
+  name: "loop-breaker"};
+var loop_breaker_default = plugin21;
+var plugin22 = {
+  name: "model-router"};
+var model_router_default = plugin22;
+var plugin23 = {
+  name: "notify-hub"};
+var notify_hub_default = plugin23;
+var plugin24 = {
+  name: "path-guard"};
+var path_guard_default = plugin24;
+var plugin25 = {
+  name: "prompt-firewall"};
+var prompt_firewall_default = plugin25;
+
+// src/secret-scanner/index.ts
+var BASE_PATTERNS = [
+  // LLM provider keys
+  { type: "anthropic_key", regex: /(?<![A-Za-z0-9])sk-ant-api\d+-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g },
+  { type: "openai_key", regex: /(?<![A-Za-z0-9])sk-(?:proj-)?[A-Za-z0-9_-]{20,}(?![A-Za-z0-9])/g },
+  // GitHub
+  { type: "github_pat", regex: /(?<![A-Za-z0-9])ghp_[A-Za-z0-9]{36,}(?![A-Za-z0-9])/g },
+  { type: "github_pat_v2", regex: /(?<![A-Za-z0-9])github_pat_[A-Za-z0-9_]{50,}(?![A-Za-z0-9])/g },
+  // AWS
+  { type: "aws_access_key", regex: /(?<![A-Za-z0-9])AKIA[0-9A-Z]{16}(?![A-Za-z0-9])/g },
+  // GCP
+  { type: "gcp_key", regex: /(?<![A-Za-z0-9])AIza[0-9A-Za-z_-]{35}(?![A-Za-z0-9])/g },
+  // Slack
+  { type: "slack_token", regex: /(?<![A-Za-z0-9-])xox[abpos]-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])/g },
+  // Stripe
+  { type: "stripe_key", regex: /(?<![A-Za-z0-9])sk_(?:live|test)_[A-Za-z0-9]{24,}(?![A-Za-z0-9])/g },
+  // Twilio
+  { type: "twilio_sid", regex: /(?<![A-Za-z0-9])AC[a-f0-9]{32}(?![A-Za-z0-9])/g },
+  // Telegram
+  {
+    type: "telegram_bot_token",
+    regex: /\/bot\d+:[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])/g
+  },
+  // JWT
+  {
+    type: "jwt",
+    regex: /(?<![A-Za-z0-9/+=])eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}(?![A-Za-z0-9/+=])/g
+  },
+  // Private keys
+  {
+    type: "private_key",
+    regex: /(?:^|\n)-----BEGIN (?:RSA|EC|OPENSSH|DSA|PGP)? ?PRIVATE KEY-----[\s\S]*?-----END (?:RSA|EC|OPENSSH|DSA|PGP)? ?PRIVATE KEY-----(?!\S)/g
+  },
+  // AI/ML provider tokens
+  { type: "huggingface_token", regex: /(?<![A-Za-z0-9])hf_[A-Za-z0-9]{34}(?![A-Za-z0-9])/g },
+  { type: "replicate_token", regex: /(?<![A-Za-z0-9])r8_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
+  { type: "perplexity_key", regex: /(?<![A-Za-z0-9])pplx-[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
+  { type: "groq_key", regex: /(?<![A-Za-z0-9])gsk_[A-Za-z0-9]{40,}(?![A-Za-z0-9])/g },
+  // Bearer tokens
+  {
+    type: "bearer_token",
+    regex: /(?:^|[^A-Za-z0-9_.~+/-])Bearer\s+[A-Za-z0-9._~+/-]{12,512}=*(?![A-Za-z0-9._~+/-])/g
+  },
+  // Database URIs
+  { type: "mongodb_uri", regex: /mongodb(?:\+srv)?:\/\/[^\s"'`]+/g },
+  { type: "postgres_uri", regex: /postgres(?:ql)?:\/\/[^\s"'`]+/g },
+  { type: "mysql_uri", regex: /mysql:\/\/[^\s"'`]+/g },
+  { type: "redis_uri", regex: /redis:\/\/[^\s"'`]+/g }
+];
+var PATTERNS3 = [...BASE_PATTERNS];
+buildCombinedRegex(PATTERNS3);
+function buildCombinedRegex(patterns) {
+  return new RegExp(
+    patterns.map((p) => `(${p.regex.source})`).join("|"),
+    "g"
+  );
+}
+var plugin26 = {
+  name: "secret-scanner"};
+var secret_scanner_default = plugin26;
+var plugin27 = {
+  name: "semver-bump"};
+var semver_bump_default = plugin27;
+var plugin28 = {
+  name: "session-recap"};
+var session_recap_default = plugin28;
+var plugin29 = {
+  name: "shell-check"};
+var shell_check_default = plugin29;
+var plugin30 = {
+  name: "template-engine"};
+var template_engine_default = plugin30;
+var plugin31 = {
+  name: "test-runner-gate"};
+var test_runner_gate_default = plugin31;
+var plugin32 = {
+  name: "todo-listener"};
+var todo_listener_default = plugin32;
+var plugin33 = {
+  name: "todo-tracker"};
+var todo_tracker_default = plugin33;
+var plugin34 = {
+  name: "token-budget"};
+var token_budget_default = plugin34;
+var plugin35 = {
+  name: "token-throttle"};
+var token_throttle_default = plugin35;
+
+// src/catalog.ts
+var ENTRIES = [
+  { name: auto_doc_default.name, path: "./src/auto-doc" },
+  { name: git_autocommit_default.name, path: "./src/git-autocommit" },
+  { name: shell_check_default.name, path: "./src/shell-check" },
+  { name: cost_tracker_default.name, path: "./src/cost-tracker" },
+  { name: file_watcher_default.name, path: "./src/file-watcher" },
+  { name: cron_default.name, path: "./src/cron" },
+  { name: template_engine_default.name, path: "./src/template-engine" },
+  { name: semver_bump_default.name, path: "./src/semver-bump" },
+  { name: secret_scanner_default.name, path: "./src/secret-scanner" },
+  { name: todo_tracker_default.name, path: "./src/todo-tracker" },
+  { name: token_budget_default.name, path: "./src/token-budget" },
+  { name: lint_gate_default.name, path: "./src/lint-gate" },
+  { name: branch_guard_default.name, path: "./src/branch-guard" },
+  { name: diff_summary_default.name, path: "./src/diff-summary" },
+  { name: commit_validator_default.name, path: "./src/commit-validator" },
+  { name: format_on_save_default.name, path: "./src/format-on-save" },
+  { name: test_runner_gate_default.name, path: "./src/test-runner-gate" },
+  { name: import_organizer_default.name, path: "./src/import-organizer" },
+  { name: todo_listener_default.name, path: "./src/todo-listener" },
+  { name: session_recap_default.name, path: "./src/session-recap" },
+  { name: "spec-linker", path: "./src/spec-linker" },
+  { name: loop_breaker_default.name, path: "./src/loop-breaker" },
+  { name: path_guard_default.name, path: "./src/path-guard" },
+  { name: context_pins_default.name, path: "./src/context-pins" },
+  { name: checkpoint_default.name, path: "./src/checkpoint" },
+  { name: error_lens_default.name, path: "./src/error-lens" },
+  { name: dep_guard_default.name, path: "./src/dep-guard" },
+  { name: config_validator_default.name, path: "./src/config-validator" },
+  { name: notify_hub_default.name, path: "./src/notify-hub" },
+  { name: changelog_writer_default.name, path: "./src/changelog-writer" },
+  { name: injection_shield_default.name, path: "./src/injection-shield" },
+  { name: llm_cache_default.name, path: "./src/llm-cache" },
+  { name: model_router_default.name, path: "./src/model-router" },
+  { name: prompt_firewall_default.name, path: "./src/prompt-firewall" },
+  { name: auto_escalate_default.name, path: "./src/auto-escalate" },
+  { name: token_throttle_default.name, path: "./src/token-throttle" }
+];
+function assertValidCatalog(entries) {
+  for (const e of entries) {
+    if (typeof e.name !== "string" || e.name.length === 0) {
+      throw new Error(`plugin catalog: entry has invalid name: ${JSON.stringify(e)}`);
+    }
+    if (!/^[a-z0-9-]+$/.test(e.name)) {
+      throw new Error(`plugin catalog: name "${e.name}" is not kebab-case`);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (seen.has(e.name)) {
+      throw new Error(`plugin catalog: duplicate entry for "${e.name}"`);
+    }
+    seen.add(e.name);
+  }
+}
+assertValidCatalog(ENTRIES);
+var PLUGIN_CATALOG = (() => {
+  const m = /* @__PURE__ */ new Map();
+  for (const e of ENTRIES) m.set(e.name, e.path);
+  return m;
+})();
+var PLUGIN_CATALOG_ENTRIES = Object.freeze(
+  ENTRIES.map((e) => Object.freeze({ ...e }))
+);
+var PLUGIN_NAMES = PLUGIN_CATALOG_ENTRIES.map((e) => e.name);
+
+// src/spec-linker/index.ts
+var state32 = {
+  postInvocations: 0,
+  preInvocations: 0,
+  unlinkedCount: 0,
+  cleanCount: 0,
+  skippedNonMd: 0,
+  readErrorCount: 0,
+  autoFixApplied: 0,
+  postHookUnregister: null,
+  preHookUnregister: null
+};
+var DEFAULTS25 = {
+  enabled: true,
+  fileGlobs: ["**/*.md", "**/*.mdx"],
+  maxReferences: 8,
+  autoFix: false
+};
+function readConfig27(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS25 };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    fileGlobs: Array.isArray(r["fileGlobs"]) ? r["fileGlobs"].filter((g) => typeof g === "string") : DEFAULTS25.fileGlobs,
+    maxReferences: typeof r["maxReferences"] === "number" && r["maxReferences"] > 0 ? r["maxReferences"] : DEFAULTS25.maxReferences,
+    autoFix: r["autoFix"] === true
+  };
+}
+function fileMatchesGlobs(filePath, globs) {
+  const lower = filePath.toLowerCase();
+  return globs.some((g) => {
+    const normalized = g.replace(/\\/g, "/").toLowerCase();
+    const pattern = normalized.replace(/^\*\*\//, "");
+    if (pattern.startsWith("*.")) {
+      return lower.endsWith(pattern.slice(1));
+    }
+    return lower.includes(pattern);
+  });
+}
+function isWrappedAsLinkOrCode(line, name) {
+  const lower = line.toLowerCase();
+  const target = name.toLowerCase();
+  if (lower.includes(`[${target}](`)) return true;
+  if (lower.includes(`\`${target}\``)) return true;
+  if (lower.includes(`[\``) && lower.includes(`\`](`)) return true;
+  return false;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findUnlinkedReferences(lines, names) {
+  const found = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    if (line.length === 0) continue;
+    for (const name of names) {
+      const re = new RegExp(`(^|[^\\w-])${escapeRegExp(name)}(?![\\w-])`, "i");
+      if (re.test(line) && !isWrappedAsLinkOrCode(line, name)) {
+        if (!found.has(name)) found.set(name, true);
+      }
+    }
+  }
+  return [...found.keys()];
+}
+function wrapUnlinkedReferences(content) {
+  const lines = content.split("\n");
+  let changed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.length === 0) continue;
+    const newLine = wrapLineReferences(line);
+    if (newLine !== line) {
+      lines[i] = newLine;
+      changed = true;
+    }
+  }
+  return changed ? lines.join("\n") : content;
+}
+function wrapLineReferences(line) {
+  let out = "";
+  let cursor = 0;
+  const spans = [];
+  for (const name of PLUGIN_NAMES) {
+    const re = new RegExp(`(^|[^\\w-])(${escapeRegExp(name)})(?![\\w-])`, "gi");
+    let m;
+    re.lastIndex = 0;
+    while ((m = re.exec(line)) !== null) {
+      const leadingLen = m[1].length;
+      const nameStart = m.index + leadingLen;
+      const nameEnd = nameStart + m[2].length;
+      const originalName = line.slice(nameStart, nameEnd);
+      if (isWrappedAsLinkOrCode(line, originalName)) continue;
+      if (spans.some((s) => !(nameEnd <= s.start || nameStart >= s.end))) {
+        continue;
+      }
+      spans.push({ start: nameStart, end: nameEnd, name: originalName });
+      re.lastIndex = nameEnd;
+    }
+  }
+  if (spans.length === 0) return line;
+  spans.sort((a, b) => a.start - b.start);
+  for (const span of spans) {
+    out += line.slice(cursor, span.start);
+    const path2 = PLUGIN_CATALOG.get(span.name.toLowerCase()) ?? `./src/${span.name.toLowerCase()}`;
+    out += `[${span.name}](${path2})`;
+    cursor = span.end;
+  }
+  out += line.slice(cursor);
+  return out;
+}
+var plugin36 = {
+  name: "spec-linker",
+  version: "0.2.0",
+  description: "Markdown link auditor for plugin references. PostToolUse surfaces unlinked references; PreToolUse on `write` (autoFix) wraps them in markdown links via modifiedInput.",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS25 },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      fileGlobs: {
+        type: "array",
+        items: { type: "string" },
+        default: DEFAULTS25.fileGlobs,
+        description: "Glob patterns to match (markdown by default)."
+      },
+      maxReferences: {
+        type: "number",
+        minimum: 1,
+        maximum: 50,
+        default: 8,
+        description: "Hard cap on the number of unlinked references in the injected context."
+      },
+      autoFix: {
+        type: "boolean",
+        default: false,
+        description: "When true, the PreToolUse hook on `write` returns a `modifiedInput.content` where each unlinked plugin reference is wrapped in a markdown link. Default false (opt in)."
+      }
+    }
+  },
+  setup(api) {
+    state32.postInvocations = 0;
+    state32.preInvocations = 0;
+    state32.unlinkedCount = 0;
+    state32.cleanCount = 0;
+    state32.skippedNonMd = 0;
+    state32.readErrorCount = 0;
+    state32.autoFixApplied = 0;
+    state32.postHookUnregister = null;
+    state32.preHookUnregister = null;
+    const cfg = readConfig27(api.config.extensions?.["spec-linker"]);
+    const postHook = async (input) => {
+      if (!cfg.enabled) return;
+      if (input.toolResult?.isError) return;
+      const toolName = input.toolName ?? "";
+      if (toolName !== "write" && toolName !== "edit") return;
+      const inp = input.toolInput ?? {};
+      const filePath = inp.path;
+      if (!filePath || typeof filePath !== "string") return;
+      if (!fileMatchesGlobs(filePath, cfg.fileGlobs)) {
+        state32.skippedNonMd += 1;
+        return;
+      }
+      state32.postInvocations += 1;
+      if (!existsSync(filePath)) return;
+      let content;
+      try {
+        const stat = statSync(filePath);
+        if (!stat.isFile()) return;
+        content = await fsp.readFile(filePath, "utf-8");
+      } catch {
+        state32.readErrorCount += 1;
+        return;
+      }
+      const unlinked = findUnlinkedReferences(content.split("\n"), [...PLUGIN_NAMES]);
+      if (unlinked.length === 0) {
+        state32.cleanCount += 1;
+        return;
+      }
+      state32.unlinkedCount += 1;
+      const limited = unlinked.slice(0, cfg.maxReferences);
+      const overflow = unlinked.length - limited.length;
+      const lines = limited.map((name) => `- \`${name}\` \u2192 \`[${name}](${PLUGIN_CATALOG.get(name) ?? `./src/${name}`})\``).join("\n");
+      const overflowNote = overflow > 0 ? `
+- \u2026and ${overflow} more` : "";
+      return {
+        additionalContext: `
+\u{1F517} spec-linker: ${unlinked.length} unlinked plugin reference(s) in '${filePath}'. Consider wrapping them in markdown links to keep the docs navigable:
+${lines}${overflowNote}`
+      };
+    };
+    state32.postHookUnregister = api.registerHook("PostToolUse", "write|edit", postHook);
+    if (cfg.autoFix) {
+      const preHook = async (input) => {
+        if (!cfg.enabled) return;
+        if (input.toolName !== "write") return;
+        const inp = input.toolInput ?? {};
+        const filePath = inp.path;
+        if (!filePath || typeof filePath !== "string") return;
+        if (!fileMatchesGlobs(filePath, cfg.fileGlobs)) return;
+        if (typeof inp.content !== "string" || inp.content.length === 0) return;
+        state32.preInvocations += 1;
+        const fixed = wrapUnlinkedReferences(inp.content);
+        if (fixed === inp.content) return;
+        state32.autoFixApplied += 1;
+        return {
+          decision: "allow",
+          modifiedInput: { ...inp, content: fixed, path: filePath },
+          additionalContext: `
+\u{1F517} spec-linker (autoFix): wrapped unlinked plugin reference(s) in '${filePath}'.`
+        };
+      };
+      state32.preHookUnregister = api.registerHook("PreToolUse", "write", preHook);
+    }
+    api.tools.register({
+      name: "spec_linker_status",
+      description: "Reports spec-linker state: config, counters (post + pre hooks), and the canonical plugin catalog used for detection.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          fileGlobs: cfg.fileGlobs,
+          maxReferences: cfg.maxReferences,
+          autoFix: cfg.autoFix,
+          counters: {
+            postInvocations: state32.postInvocations,
+            preInvocations: state32.preInvocations,
+            unlinked: state32.unlinkedCount,
+            clean: state32.cleanCount,
+            skippedNonMd: state32.skippedNonMd,
+            readErrors: state32.readErrorCount,
+            autoFixApplied: state32.autoFixApplied
+          },
+          catalogSize: PLUGIN_NAMES.length
+        };
+      }
+    });
+    api.log.info("spec-linker plugin loaded", {
+      version: "0.2.0",
+      enabled: cfg.enabled,
+      fileGlobs: cfg.fileGlobs,
+      autoFix: cfg.autoFix,
+      catalogSize: PLUGIN_NAMES.length
+    });
+  },
+  teardown(api) {
+    for (const off of [state32.postHookUnregister, state32.preHookUnregister]) {
+      if (off) {
+        try {
+          off();
+        } catch {
+        }
+      }
+    }
+    state32.postHookUnregister = null;
+    state32.preHookUnregister = null;
+    const final = {
+      postInvocations: state32.postInvocations,
+      preInvocations: state32.preInvocations,
+      unlinked: state32.unlinkedCount,
+      clean: state32.cleanCount,
+      skippedNonMd: state32.skippedNonMd,
+      readErrors: state32.readErrorCount,
+      autoFixApplied: state32.autoFixApplied
+    };
+    state32.postInvocations = 0;
+    state32.preInvocations = 0;
+    state32.unlinkedCount = 0;
+    state32.cleanCount = 0;
+    state32.skippedNonMd = 0;
+    state32.readErrorCount = 0;
+    state32.autoFixApplied = 0;
+    api.log.info("spec-linker: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: `spec-linker: post=${state32.postInvocations} pre=${state32.preInvocations}, unlinked=${state32.unlinkedCount}, autoFix=${state32.autoFixApplied}, clean=${state32.cleanCount}, non-md=${state32.skippedNonMd}`,
+      counters: {
+        postInvocations: state32.postInvocations,
+        preInvocations: state32.preInvocations,
+        unlinked: state32.unlinkedCount,
+        clean: state32.cleanCount,
+        skippedNonMd: state32.skippedNonMd,
+        readErrors: state32.readErrorCount,
+        autoFixApplied: state32.autoFixApplied
+      }
+    };
+  }
+};
+var spec_linker_default = plugin36;
+
+export { spec_linker_default as default };

package/dist/template-engine.js

@@ -2,6 +2,7 @@ import { isAbsolute } from 'path';
 
 // src/template-engine/index.ts
 var API_VERSION = "^0.1.10";
+var templates = /* @__PURE__ */ new Map();
 function expandTemplate(template, variables) {
   let result = template;
   result = result.replace(/\{\{(\w+)\}\}/g, (match, key) => {
@@ -71,7 +72,7 @@ var plugin = {
     }
   },
   setup(api) {
-    const templates = /* @__PURE__ */ new Map();
+    templates.clear();
     const autoEscapeHtml = api.config.extensions?.["template-engine"]?.["autoEscapeHtml"] ?? true;
     api.tools.register({
       name: "template_expand",
@@ -270,6 +271,23 @@ var plugin = {
       }
     ]);
     api.log.info("template-engine plugin loaded", { version: "0.1.0" });
+  },
+  teardown(api) {
+    const count = templates.size;
+    templates.clear();
+    api.log.info("template-engine: teardown complete", { cleared: count });
+  },
+  async health() {
+    let totalBytes = 0;
+    for (const t of templates.values()) {
+      totalBytes += t.content.length;
+    }
+    return {
+      ok: true,
+      message: `template-engine: ${templates.size} saved template(s), ${totalBytes} bytes total`,
+      count: templates.size,
+      totalBytes
+    };
   }
 };
 var template_engine_default = plugin;

package/dist/test-runner-gate.d.ts

@@ -0,0 +1,37 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * test-runner-gate plugin — PostToolUse hook that runs the relevant
+ * test file after every `write` or `edit` to a source file.
+ *
+ * Tools registered:
+ * - test_gate_status : Show config + per-session counters.
+ *
+ * Hooks registered:
+ * - PostToolUse with matcher `write|edit`. After the tool completes,
+ *   maps the changed source file to its test file (using configurable
+ *   patterns), runs `vitest run <test-file>` and injects the result
+ *   as `additionalContext`.
+ *
+ * Config (`config.extensions['test-runner-gate']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "command": "npx vitest run",       // base test command
+ *   "timeoutMs": 30000,                // test process timeout
+ *   "testFilePatterns": [              // how to derive test path from source
+ *     "src/{path}.test.ts",            // co-located: src/foo.ts → src/foo.test.ts
+ *     "tests/{name}.test.ts",          // mirror dir: src/foo.ts → tests/foo.test.ts
+ *     "tests/{name}-exec.test.ts"      // exec variant
+ *   ],
+ *   "injectOnPass": false              // inject context when tests pass too?
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };