@wrongstack/plugins 0.281.3 → 0.282.0

package/dist/code-metrics.js

@@ -0,0 +1,338 @@
+import { readFileSync, existsSync, statSync, readdirSync } from 'fs';
+import { resolve, isAbsolute, relative, extname } from 'path';
+
+// src/code-metrics/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  measureCount: 0,
+  fileCount: 0,
+  hookInvocationCount: 0,
+  errorCount: 0,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: false,
+  extensions: [".ts", ".tsx", ".js", ".jsx"],
+  maxFiles: 50
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    extensions: Array.isArray(r["extensions"]) ? r["extensions"].filter((x) => typeof x === "string") : DEFAULTS.extensions,
+    maxFiles: typeof r["maxFiles"] === "number" && r["maxFiles"] >= 1 && r["maxFiles"] <= 500 ? r["maxFiles"] : DEFAULTS.maxFiles
+  };
+}
+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 normalizeExtensions(exts) {
+  return exts.map((e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`);
+}
+function matchesExtension(p, exts) {
+  return exts.includes(extname(p).toLowerCase());
+}
+function collectSourceFiles(root, exts) {
+  const files = [];
+  if (!existsSync(root)) return files;
+  const s = statSync(root);
+  if (s.isFile()) {
+    if (matchesExtension(root, exts)) files.push(root);
+    return files;
+  }
+  if (!s.isDirectory()) return files;
+  function walk(dir) {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry === "dist" || entry === ".git" || entry === "coverage") continue;
+      const full = resolve(dir, entry);
+      let st;
+      try {
+        st = statSync(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        walk(full);
+      } else if (st.isFile() && matchesExtension(full, exts)) {
+        files.push(full);
+      }
+    }
+  }
+  walk(root);
+  return files;
+}
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function relativePath(p) {
+  return toPosix(relative(process.cwd(), p));
+}
+function countFunctions(content) {
+  let count = 0;
+  const declRe = /\bfunction\s+[A-Za-z_$][A-Za-z0-9_$]*\s*\(/g;
+  const methodRe = /\b[A-Za-z_$][A-Za-z0-9_$]*\s*\([^)]*\)\s*\{/g;
+  const arrowRe = /=>\s*(?:\{|\(|[^\s;{}])/g;
+  let m;
+  declRe.lastIndex = 0;
+  while ((m = declRe.exec(content)) !== null) count++;
+  methodRe.lastIndex = 0;
+  while ((m = methodRe.exec(content)) !== null) {
+    const prefix = content.slice(0, m.index).trimEnd();
+    if (/\bfunction\s*$/.test(prefix)) continue;
+    count++;
+  }
+  arrowRe.lastIndex = 0;
+  while ((m = arrowRe.exec(content)) !== null) count++;
+  return count;
+}
+function countComplexity(content) {
+  const controlRe = /\b(if|else\s+if|for|while|switch|catch)\b/g;
+  const operatorRe = /[?&|]/g;
+  let complexity = 0;
+  let m;
+  controlRe.lastIndex = 0;
+  while ((m = controlRe.exec(content)) !== null) complexity++;
+  operatorRe.lastIndex = 0;
+  while ((m = operatorRe.exec(content)) !== null) {
+    const ch = m[0];
+    if (ch === "?") {
+      complexity++;
+    } else {
+      const next = content[m.index + 1];
+      if (next === ch) complexity++;
+    }
+  }
+  return complexity;
+}
+function analyzeFile(filePath, content) {
+  const lines = content.split(/\r?\n/);
+  let codeLines = 0;
+  let commentLines = 0;
+  let blankLines = 0;
+  let inBlockComment = false;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line.length === 0) {
+      blankLines++;
+      continue;
+    }
+    if (inBlockComment) {
+      commentLines++;
+      if (line.includes("*/")) inBlockComment = false;
+      continue;
+    }
+    if (line.startsWith("//")) {
+      commentLines++;
+      continue;
+    }
+    if (line.startsWith("/*")) {
+      commentLines++;
+      if (!line.includes("*/")) inBlockComment = true;
+      continue;
+    }
+    codeLines++;
+  }
+  return {
+    file: relativePath(filePath),
+    lines: lines.length,
+    codeLines,
+    commentLines,
+    blankLines,
+    functionCount: countFunctions(content),
+    complexity: countComplexity(content)
+  };
+}
+function measurePath(rawPath, cfg) {
+  const root = process.cwd();
+  const resolved = isAbsolute(rawPath) ? resolve(rawPath) : resolve(root, rawPath);
+  const exts = normalizeExtensions(cfg.extensions);
+  const allFiles = collectSourceFiles(resolved, exts);
+  const files = allFiles.slice(0, cfg.maxFiles);
+  const metrics = [];
+  for (const p of files) {
+    try {
+      const content = readFileSync(p, "utf-8");
+      metrics.push(analyzeFile(p, content));
+    } catch {
+    }
+  }
+  return { files: metrics, totalFiles: allFiles.length };
+}
+var plugin = {
+  name: "code-metrics",
+  version: "0.1.0",
+  description: "Computes per-file line counts, function counts, and cyclomatic-complexity-like scores",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      extensions: {
+        type: "array",
+        items: { type: "string" },
+        default: [".ts", ".tsx", ".js", ".jsx"],
+        description: "File extensions to measure."
+      },
+      maxFiles: {
+        type: "number",
+        minimum: 1,
+        maximum: 500,
+        default: 50,
+        description: "Maximum files measured in a directory scan."
+      }
+    }
+  },
+  setup(api) {
+    state.measureCount = 0;
+    state.fileCount = 0;
+    state.hookInvocationCount = 0;
+    state.errorCount = 0;
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["code-metrics"]);
+    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 exts = normalizeExtensions(cfg.extensions);
+      if (!matchesExtension(sourcePath, exts)) return;
+      state.hookInvocationCount += 1;
+      const resolved = resolve(process.cwd(), sourcePath);
+      let content;
+      try {
+        content = readFileSync(resolved, "utf-8");
+      } catch {
+        state.errorCount += 1;
+        return;
+      }
+      const metrics = analyzeFile(resolved, content);
+      return {
+        additionalContext: `
+\u{1F4CA} code-metrics: ${relativePath(resolved)} \u2014 ${metrics.lines} lines (${metrics.codeLines} code, ${metrics.commentLines} comments, ${metrics.blankLines} blank), ${metrics.functionCount} function(s), complexity ${metrics.complexity}.`
+      };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "measure_code_metrics",
+      description: "Measure lines, comments, blank lines, function count, and cyclomatic-complexity-like score for a source file or directory.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", default: ".", description: "File or directory path to measure." }
+        }
+      },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "code-metrics is disabled" };
+        const rawPath = typeof input.path === "string" ? input.path : ".";
+        if (!withinProject(rawPath)) {
+          return { ok: false, error: "path is outside the project root" };
+        }
+        state.measureCount += 1;
+        let result;
+        try {
+          result = measurePath(rawPath, cfg);
+        } catch (err) {
+          state.errorCount += 1;
+          return { ok: false, error: String(err) };
+        }
+        state.fileCount += result.files.length;
+        return {
+          ok: true,
+          path: relativePath(resolve(process.cwd(), rawPath)),
+          files: result.files,
+          totalFiles: result.totalFiles,
+          capped: result.totalFiles > cfg.maxFiles
+        };
+      }
+    });
+    api.tools.register({
+      name: "metrics_status",
+      description: "Reports code-metrics state: config + counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          extensions: cfg.extensions,
+          maxFiles: cfg.maxFiles,
+          counters: {
+            measures: state.measureCount,
+            files: state.fileCount,
+            hookInvocations: state.hookInvocationCount,
+            errors: state.errorCount
+          }
+        };
+      }
+    });
+    api.log.info("code-metrics plugin loaded", {
+      version: "0.1.0",
+      extensions: cfg.extensions,
+      maxFiles: cfg.maxFiles
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      measures: state.measureCount,
+      files: state.fileCount,
+      hookInvocations: state.hookInvocationCount,
+      errors: state.errorCount
+    };
+    state.measureCount = 0;
+    state.fileCount = 0;
+    state.hookInvocationCount = 0;
+    state.errorCount = 0;
+    api.log.info("code-metrics: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.errorCount === 0,
+      message: state.errorCount ? `code-metrics: ${state.errorCount} error(s)` : `code-metrics: ${state.measureCount} measurement(s), ${state.fileCount} file(s)`,
+      counters: {
+        measures: state.measureCount,
+        files: state.fileCount,
+        hookInvocations: state.hookInvocationCount,
+        errors: state.errorCount
+      }
+    };
+  }
+};
+var code_metrics_default = plugin;
+
+export { code_metrics_default as default };

package/dist/commit-validator.js

@@ -4,6 +4,10 @@ var state = {
   invocationCount: 0,
   validCount: 0,
   invalidCount: 0,
+  /** Times the LLM successfully produced a subject suggestion. */
+  suggestFixCount: 0,
+  /** Times the LLM call failed or was skipped (api.llm absent, etc.). */
+  suggestFixErrors: 0,
   hookUnregister: null,
   lastValidation: null
 };
@@ -13,7 +17,8 @@ var DEFAULTS = {
   allowedTypes: [],
   maxSubjectLength: 72,
   bodyRequired: false,
-  minBodyLength: 10
+  minBodyLength: 10,
+  suggestFix: false
 };
 function readConfig(raw) {
   if (!raw || typeof raw !== "object") return { ...DEFAULTS };
@@ -24,7 +29,8 @@ function readConfig(raw) {
     allowedTypes: Array.isArray(r["allowedTypes"]) ? r["allowedTypes"].filter((x) => typeof x === "string") : [],
     maxSubjectLength: typeof r["maxSubjectLength"] === "number" && r["maxSubjectLength"] > 0 ? r["maxSubjectLength"] : DEFAULTS.maxSubjectLength,
     bodyRequired: r["bodyRequired"] === true,
-    minBodyLength: typeof r["minBodyLength"] === "number" && r["minBodyLength"] > 0 ? r["minBodyLength"] : DEFAULTS.minBodyLength
+    minBodyLength: typeof r["minBodyLength"] === "number" && r["minBodyLength"] > 0 ? r["minBodyLength"] : DEFAULTS.minBodyLength,
+    suggestFix: r["suggestFix"] === true
   };
 }
 var STANDARD_TYPES = [
@@ -44,7 +50,14 @@ function parseCommitMessage(message, cfg) {
   const errors = [];
   const firstLine = message.trim().split("\n")[0] ?? "";
   if (!firstLine) {
-    return { valid: false, type: "", scope: "", subject: "", breaking: false, errors: ["empty commit message"] };
+    return {
+      valid: false,
+      type: "",
+      scope: "",
+      subject: "",
+      breaking: false,
+      errors: ["empty commit message"]
+    };
   }
   const match = firstLine.match(/^([a-zA-Z]+)(?:\(([^)]+)\))?(!)?:\s*(.+)$/);
   if (!match) {
@@ -84,7 +97,9 @@ function parseCommitMessage(message, cfg) {
     const bodyStart = lines.findIndex((line, i) => i > 0 && line.trim() === "");
     const body = bodyStart >= 0 ? lines.slice(bodyStart + 1).join("\n").trim() : "";
     if (!body) {
-      errors.push("A commit body is required. Add a blank line after the subject, then the description.");
+      errors.push(
+        "A commit body is required. Add a blank line after the subject, then the description."
+      );
     } else if (body.length < cfg.minBodyLength) {
       errors.push(
         `Body is ${body.length} characters \u2014 minimum is ${cfg.minBodyLength}. Add more context about what changed and why.`
@@ -152,6 +167,11 @@ var plugin = {
         minimum: 1,
         default: 10,
         description: "Minimum body length in characters (when bodyRequired is true)."
+      },
+      suggestFix: {
+        type: "boolean",
+        default: false,
+        description: "When true and mode=warn, ask the host LLM for a corrected conventional-commit subject and include it in the warn context. Off by default (LLM calls aren't free). Ignored in block mode."
       }
     }
   },
@@ -159,10 +179,12 @@ var plugin = {
     state.invocationCount = 0;
     state.validCount = 0;
     state.invalidCount = 0;
+    state.suggestFixCount = 0;
+    state.suggestFixErrors = 0;
     state.hookUnregister = null;
     state.lastValidation = null;
     const cfg = readConfig(api.config.extensions?.["commit-validator"]);
-    const hook = (input) => {
+    const hook = async (input) => {
       const toolName = input.toolName ?? "";
       const inp = input.toolInput ?? {};
       let message = null;
@@ -237,12 +259,37 @@ Examples:
   ${example}`
         };
       }
+      let baseContext = `
+?? commit-validator: commit message has ${parsed.errors.length} issue(s):
+${errorList}
+Expected: <type>[(scope)][!]: <description>`;
+      if (cfg.suggestFix && api.llm) {
+        try {
+          const suggest = await api.llm.complete(
+            `The user wrote a conventional-commit message that fails validation:
+Original: ${message}
+Errors: ${parsed.errors.join("; ")}
+Reply with ONE corrected conventional-commit subject line (and optional body) and nothing else.`,
+            {
+              system: "You rewrite commit subjects to follow the conventional-commits format. Reply tersely, no preamble, no quotes.",
+              maxTokens: 120
+            }
+          );
+          const text = suggest.text.trim();
+          if (text) {
+            state.suggestFixCount += 1;
+            api.metrics.counter("suggest_fix");
+            baseContext += `
+Suggested rewrite (${suggest.model}):
+  ${text.split("\n").join("\n  ")}`;
+          }
+        } catch {
+          state.suggestFixErrors += 1;
+        }
+      }
       return {
         decision: "allow",
-        additionalContext: `
-\u26A0\uFE0F commit-validator: commit message has ${parsed.errors.length} issue(s):
-${errorList}
-Expected: <type>[(scope)][!]: <description>`
+        additionalContext: baseContext
       };
     };
     state.hookUnregister = api.registerHook("PreToolUse", "bash|git_autocommit", hook);
@@ -266,7 +313,9 @@ Expected: <type>[(scope)][!]: <description>`
           counters: {
             invocations: state.invocationCount,
             valid: state.validCount,
-            invalid: state.invalidCount
+            invalid: state.invalidCount,
+            suggestFix: state.suggestFixCount,
+            suggestFixErrors: state.suggestFixErrors
           },
           lastValidation: state.lastValidation
         };
@@ -289,11 +338,15 @@ Expected: <type>[(scope)][!]: <description>`
     const final = {
       invocations: state.invocationCount,
       valid: state.validCount,
-      invalid: state.invalidCount
+      invalid: state.invalidCount,
+      suggestFix: state.suggestFixCount,
+      suggestFixErrors: state.suggestFixErrors
     };
     state.invocationCount = 0;
     state.validCount = 0;
     state.invalidCount = 0;
+    state.suggestFixCount = 0;
+    state.suggestFixErrors = 0;
     state.lastValidation = null;
     api.log.info("commit-validator: teardown complete", { final });
   },
@@ -304,7 +357,9 @@ Expected: <type>[(scope)][!]: <description>`
       counters: {
         invocations: state.invocationCount,
         valid: state.validCount,
-        invalid: state.invalidCount
+        invalid: state.invalidCount,
+        suggestFix: state.suggestFixCount,
+        suggestFixErrors: state.suggestFixErrors
       },
       lastValidation: state.lastValidation
     };

package/dist/cost-tracker.js

@@ -11,16 +11,23 @@ var PRICING = {
   "claude-3-opus": { input: 15, output: 75 },
   "gemini-1.5-pro": { input: 3.5, output: 10.5 },
   "gemini-1.5-flash": { input: 0.075, output: 0.3 },
-  "default": { input: 5, output: 15 }
+  default: { input: 5, output: 15 }
 };
 var DEFAULT_PRICING = { input: 5, output: 15 };
 var pricingOverrides = {};
 var bundledFromRegistry = {};
 var lastCost = { usd: 0, model: null, at: null };
+var digestCounters = {
+  totalRequests: 0,
+  mailboxDigestsSent: 0,
+  mailboxDigestErrors: 0
+};
 function readCostTrackerConfig(raw) {
   return {
     budgetLimit: typeof raw?.["budgetLimit"] === "number" ? raw["budgetLimit"] : 0,
-    warningThreshold: typeof raw?.["warningThreshold"] === "number" ? raw["warningThreshold"] : 80
+    warningThreshold: typeof raw?.["warningThreshold"] === "number" ? raw["warningThreshold"] : 80,
+    mailboxDigestEveryN: typeof raw?.["mailboxDigestEveryN"] === "number" && raw?.["mailboxDigestEveryN"] >= 0 ? Math.floor(raw?.["mailboxDigestEveryN"]) : 0,
+    mailboxDigestTo: typeof raw?.["mailboxDigestTo"] === "string" && (raw?.["mailboxDigestTo"]).length > 0 ? raw?.["mailboxDigestTo"] : "cost-tracker"
   };
 }
 function estimateCost(model, promptTokens, completionTokens) {
@@ -48,8 +55,16 @@ var plugin = {
     properties: {
       trackPerModel: { type: "boolean", default: true },
       trackPerUser: { type: "boolean", default: false },
-      budgetLimit: { type: "number", default: 0, description: "Budget limit in USD (0 = no limit)" },
-      warningThreshold: { type: "number", default: 80, description: "Warning threshold as percentage of budget" },
+      budgetLimit: {
+        type: "number",
+        default: 0,
+        description: "Budget limit in USD (0 = no limit)"
+      },
+      warningThreshold: {
+        type: "number",
+        default: 80,
+        description: "Warning threshold as percentage of budget"
+      },
       pricingOverrides: {
         type: "object",
         description: "Per-model pricing overrides in USD per 1M tokens. Keys are lowercased model names; values are { input, output }. Takes precedence over the bundled PRICING table.",
@@ -76,7 +91,11 @@ var plugin = {
     lastCost.usd = 0;
     lastCost.model = null;
     lastCost.at = null;
+    digestCounters.totalRequests = 0;
+    digestCounters.mailboxDigestsSent = 0;
+    digestCounters.mailboxDigestErrors = 0;
     const rawConfig = api.config.extensions?.["cost-tracker"];
+    const cfg = readCostTrackerConfig(rawConfig);
     const userOverrides = rawConfig?.["pricingOverrides"];
     if (userOverrides && typeof userOverrides === "object") {
       for (const [model, value] of Object.entries(userOverrides)) {
@@ -124,7 +143,7 @@ var plugin = {
       totalCostUsd: 0,
       byModel: {}
     };
-    api.onEvent("provider.response", (payload) => {
+    api.onEvent("provider.response", async (payload) => {
       const usage = payload.usage;
       const model = payload.ctx?.model ?? "unknown";
       const promptTokens = usage.input ?? 0;
@@ -153,6 +172,23 @@ var plugin = {
       slot.requests += 1;
       api.metrics.counter("tokens_total", totalTokens, { model });
       api.metrics.histogram("cost_usd", costUsd, { model });
+      digestCounters.totalRequests += 1;
+      if (cfg.mailboxDigestEveryN > 0 && digestCounters.totalRequests % cfg.mailboxDigestEveryN === 0 && api.mailbox) {
+        const top = Object.entries(sessionCost.byModel).map(([m, v]) => `${m}:${v.tokens}t/${v.costUsd.toFixed(4)}`).join(", ");
+        try {
+          await api.mailbox.send({
+            to: cfg.mailboxDigestTo,
+            from: "cost-tracker",
+            type: "note",
+            subject: `cost-tracker digest @ #${digestCounters.totalRequests} requests`,
+            body: `running totals: ${sessionCost.totalTokens} tokens, ~${sessionCost.totalCostUsd.toFixed(4)} USD, ${sessionCost.requests.length} reqs
+by model: ${top || "(none)"}`
+          });
+          digestCounters.mailboxDigestsSent += 1;
+        } catch {
+          digestCounters.mailboxDigestErrors += 1;
+        }
+      }
       lastCost.usd = costUsd;
       lastCost.model = model;
       lastCost.at = (/* @__PURE__ */ new Date()).toISOString();
@@ -165,9 +201,7 @@ var plugin = {
       category: "Meta",
       mutating: false,
       async execute() {
-        const { budgetLimit, warningThreshold } = readCostTrackerConfig(
-          api.config.extensions?.["cost-tracker"]
-        );
+        const { budgetLimit, warningThreshold } = cfg;
         const usage = {
           totalRequests: sessionCost.requests.length,
           totalPromptTokens: sessionCost.totalPromptTokens,
@@ -263,13 +297,15 @@ var plugin = {
               totalRequests: sessionCost.requests.length,
               byModel: sessionCost.byModel
             },
-            requests: includeModel ? sessionCost.requests : sessionCost.requests.map(({ promptTokens, completionTokens, totalTokens, costUsd, timestamp }) => ({
-              promptTokens,
-              completionTokens,
-              totalTokens,
-              costUsd,
-              timestamp
-            }))
+            requests: includeModel ? sessionCost.requests : sessionCost.requests.map(
+              ({ promptTokens, completionTokens, totalTokens, costUsd, timestamp }) => ({
+                promptTokens,
+                completionTokens,
+                totalTokens,
+                costUsd,
+                timestamp
+              })
+            )
           }
         };
       }
@@ -301,6 +337,9 @@ var plugin = {
     lastCost.usd = 0;
     lastCost.model = null;
     lastCost.at = null;
+    digestCounters.totalRequests = 0;
+    digestCounters.mailboxDigestsSent = 0;
+    digestCounters.mailboxDigestErrors = 0;
     api.log.info("cost-tracker: teardown complete", {
       overrideCount,
       registryCount,
@@ -315,7 +354,10 @@ var plugin = {
       registryCount: Object.keys(bundledFromRegistry).length,
       lastCostUsd: lastCost.usd,
       lastCostModel: lastCost.model,
-      lastCostAt: lastCost.at
+      lastCostAt: lastCost.at,
+      mailboxDigestsSent: digestCounters.mailboxDigestsSent,
+      mailboxDigestErrors: digestCounters.mailboxDigestErrors,
+      totalRequests: digestCounters.totalRequests
     };
   }
 };

package/dist/dead-code-detector.d.ts

@@ -0,0 +1,34 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * dead-code-detector plugin — lightweight regex-based scan for exported
+ * identifiers that appear unused anywhere in the project.
+ *
+ * The plugin registers one tool:
+ *  - `dead_code_scan` — scan a path for suspicious exported symbols.
+ *
+ * And one hook:
+ *  - `PostToolUse` matcher `write|edit` — auto-scan changed source files and
+ *    inject a short warning when newly exported symbols look unused.
+ *
+ * No external AST parser is used; all detection is regex-based and
+ * deterministic. Expect false positives on re-exports, public API surface,
+ * and test-only exports.
+ *
+ * Config (`config.extensions['dead-code-detector']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "extensions": [".ts", ".tsx", ".js", ".jsx"],
+ *   "defaultDepth": 3,
+ *   "excludeDirs": ["node_modules", "dist", ".git", "coverage"]
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };