@wrongstack/plugins 0.281.3 → 0.282.1

package/dist/auto-i18n-extractor.d.ts

@@ -0,0 +1,36 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * auto-i18n-extractor plugin — detects hardcoded user-facing strings in UI
+ * source files and suggests translation keys.
+ *
+ * Tools registered:
+ * - i18n_extract : Scan a file/directory path for extractable strings.
+ * - i18n_status  : Show config + per-session counters.
+ *
+ * Hooks registered:
+ * - PostToolUse with matcher `write|edit` for `.tsx`, `.jsx`, `.vue` files.
+ *   Scans the written file and injects a short additionalContext with
+ *   suggested i18n keys when user-facing string literals are found.
+ *
+ * Config (`config.extensions['auto-i18n-extractor']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "fileExtensions": [".tsx", ".jsx", ".vue"],
+ *   "minLength": 2,
+ *   "maxContextStrings": 10,
+ *   "excludeAttributes": [
+ *     "className", "class", "testId", "data-testid",
+ *     "aria-label", "aria-labelledby", "key", "id", "name", "htmlFor"
+ *   ]
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/auto-i18n-extractor.js

@@ -0,0 +1,335 @@
+import { readFileSync } from 'fs';
+import { isAbsolute, resolve, relative } from 'path';
+
+// src/auto-i18n-extractor/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  filesScanned: 0,
+  stringsFound: 0,
+  extractions: 0,
+  skipped: 0,
+  readErrors: 0,
+  hookUnregister: null,
+  lastResult: null
+};
+var DEFAULTS = {
+  enabled: false,
+  fileExtensions: [".tsx", ".jsx", ".vue"],
+  minLength: 2,
+  maxContextStrings: 10,
+  excludeAttributes: [
+    "className",
+    "class",
+    "testId",
+    "data-testid",
+    "aria-label",
+    "aria-labelledby",
+    "key",
+    "id",
+    "name",
+    "htmlFor"
+  ]
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  const clamp = (n, min, max, fallback) => typeof n === "number" && Number.isFinite(n) && n >= min && n <= max ? Math.floor(n) : fallback;
+  return {
+    enabled: r["enabled"] !== false,
+    fileExtensions: Array.isArray(r["fileExtensions"]) ? r["fileExtensions"].filter((x) => typeof x === "string") : DEFAULTS.fileExtensions,
+    minLength: clamp(r["minLength"], 1, 500, DEFAULTS.minLength),
+    maxContextStrings: clamp(r["maxContextStrings"], 1, 100, DEFAULTS.maxContextStrings),
+    excludeAttributes: Array.isArray(r["excludeAttributes"]) ? r["excludeAttributes"].filter((x) => typeof x === "string") : DEFAULTS.excludeAttributes
+  };
+}
+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 fileExtension(p) {
+  const dot = p.lastIndexOf(".");
+  return dot > 0 ? p.slice(dot).toLowerCase() : "";
+}
+function generateKey(value) {
+  const base = value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40);
+  return base ? `t.${base}` : "t.unknown";
+}
+function looksLikeUserText(value, minLength) {
+  if (value.length < minLength) return false;
+  if (/^\s*$/.test(value)) return false;
+  if (/^[0-9\s\W_]+$/.test(value)) return false;
+  if (/^(https?:|ftp:|www\.|\/|\.\/|@|#[0-9a-f]{3,8}$|\.?(jsx?|tsx?|vue|css|scss|json|png|svg|jpg)$)/i.test(value)) {
+    return false;
+  }
+  return true;
+}
+function isExcludedContext(line, quoteIndex, excludeAttributes) {
+  const before = line.slice(0, quoteIndex);
+  for (const attr of excludeAttributes) {
+    const re = new RegExp(`\\b${attr.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*=\\s*["'{]?$`);
+    if (re.test(before)) return true;
+  }
+  return false;
+}
+function extractStrings(content, cfg) {
+  const results = [];
+  const lines = content.split(/\r?\n/);
+  const stringRegex = /(["'`])((?:\\.|(?!\1)[^\\])*?)\1/g;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    stringRegex.lastIndex = 0;
+    let match;
+    while ((match = stringRegex.exec(line)) !== null) {
+      const value = match[2] ?? "";
+      const quoteIndex = match.index + (match[1]?.length ?? 1);
+      if (!looksLikeUserText(value, cfg.minLength)) continue;
+      if (isExcludedContext(line, quoteIndex, cfg.excludeAttributes)) continue;
+      results.push({ value, line: i + 1, keySuggestion: generateKey(value) });
+    }
+  }
+  return results;
+}
+function readSourceFile(filePath) {
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+var plugin = {
+  name: "auto-i18n-extractor",
+  version: "0.1.0",
+  description: "Detects hardcoded user-facing strings in UI source files and suggests translation keys",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      fileExtensions: {
+        type: "array",
+        items: { type: "string" },
+        default: [".tsx", ".jsx", ".vue"],
+        description: "Only scan files with these extensions."
+      },
+      minLength: {
+        type: "number",
+        minimum: 1,
+        maximum: 500,
+        default: 2,
+        description: "Minimum string length to consider user-facing."
+      },
+      maxContextStrings: {
+        type: "number",
+        minimum: 1,
+        maximum: 100,
+        default: 10,
+        description: "Maximum strings included in a hook additionalContext."
+      },
+      excludeAttributes: {
+        type: "array",
+        items: { type: "string" },
+        default: [
+          "className",
+          "class",
+          "testId",
+          "data-testid",
+          "aria-label",
+          "aria-labelledby",
+          "key",
+          "id",
+          "name",
+          "htmlFor"
+        ],
+        description: "Attribute names whose string values are never user-facing."
+      }
+    }
+  },
+  setup(api) {
+    state.filesScanned = 0;
+    state.stringsFound = 0;
+    state.extractions = 0;
+    state.skipped = 0;
+    state.readErrors = 0;
+    state.lastResult = null;
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["auto-i18n-extractor"]);
+    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 = fileExtension(sourcePath);
+      if (!cfg.fileExtensions.includes(ext)) {
+        state.skipped += 1;
+        return;
+      }
+      state.filesScanned += 1;
+      const content = readSourceFile(sourcePath);
+      if (content === null) {
+        state.readErrors += 1;
+        return;
+      }
+      const extracted = extractStrings(content, cfg);
+      if (extracted.length === 0) return;
+      state.stringsFound += extracted.length;
+      state.extractions += 1;
+      state.lastResult = {
+        path: sourcePath,
+        stringsFound: extracted.length,
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const shown = extracted.slice(0, cfg.maxContextStrings);
+      const lines = shown.map((s) => `  - "${s.value}" \u2192 ${s.keySuggestion} (line ${s.line})`);
+      const more = extracted.length > shown.length ? `
+  \u2026 and ${extracted.length - shown.length} more` : "";
+      const context = `
+\u{1F30D} auto-i18n-extractor: found ${extracted.length} user-facing string(s) in ${sourcePath}. Consider extracting to i18n keys:
+${lines.join("\n")}${more}`;
+      return { additionalContext: context };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "i18n_extract",
+      description: "Scan a UI source file (.tsx/.jsx/.vue) for hardcoded user-facing string literals and return suggested i18n keys.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Relative or absolute path to the source file to scan."
+          }
+        },
+        required: ["path"]
+      },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "auto-i18n-extractor is disabled" };
+        const filePath = input.path;
+        if (typeof filePath !== "string" || !filePath) {
+          return { ok: false, error: "path is required" };
+        }
+        if (!withinProject(filePath)) {
+          return { ok: false, error: "path must be inside the project" };
+        }
+        const ext = fileExtension(filePath);
+        if (!cfg.fileExtensions.includes(ext)) {
+          return {
+            ok: false,
+            error: `unsupported extension "${ext}"; allowed: ${cfg.fileExtensions.join(", ")}`
+          };
+        }
+        state.filesScanned += 1;
+        const content = readSourceFile(filePath);
+        if (content === null) {
+          state.readErrors += 1;
+          return { ok: false, error: `could not read ${filePath}` };
+        }
+        const extracted = extractStrings(content, cfg);
+        state.stringsFound += extracted.length;
+        if (extracted.length > 0) {
+          state.extractions += 1;
+          state.lastResult = {
+            path: filePath,
+            stringsFound: extracted.length,
+            when: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        return {
+          ok: true,
+          path: filePath,
+          stringsFound: extracted.length,
+          strings: extracted
+        };
+      }
+    });
+    api.tools.register({
+      name: "i18n_status",
+      description: "Reports auto-i18n-extractor state: enabled, extensions, counters, and last extraction.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          fileExtensions: cfg.fileExtensions,
+          minLength: cfg.minLength,
+          maxContextStrings: cfg.maxContextStrings,
+          excludeAttributes: cfg.excludeAttributes,
+          counters: {
+            filesScanned: state.filesScanned,
+            stringsFound: state.stringsFound,
+            extractions: state.extractions,
+            skipped: state.skipped,
+            readErrors: state.readErrors
+          },
+          lastResult: state.lastResult
+        };
+      }
+    });
+    api.log.info("auto-i18n-extractor plugin loaded", {
+      version: "0.1.0",
+      fileExtensions: cfg.fileExtensions,
+      minLength: cfg.minLength
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      filesScanned: state.filesScanned,
+      stringsFound: state.stringsFound,
+      extractions: state.extractions,
+      skipped: state.skipped,
+      readErrors: state.readErrors
+    };
+    state.filesScanned = 0;
+    state.stringsFound = 0;
+    state.extractions = 0;
+    state.skipped = 0;
+    state.readErrors = 0;
+    state.lastResult = null;
+    api.log.info("auto-i18n-extractor: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.readErrors === 0,
+      message: state.lastResult ? `auto-i18n-extractor: ${state.filesScanned} file(s) scanned, ${state.stringsFound} string(s) found, last ${state.lastResult.path} (${state.lastResult.stringsFound})` : `auto-i18n-extractor: ${state.filesScanned} file(s) scanned, ${state.stringsFound} string(s) found`,
+      counters: {
+        filesScanned: state.filesScanned,
+        stringsFound: state.stringsFound,
+        extractions: state.extractions,
+        skipped: state.skipped,
+        readErrors: state.readErrors
+      },
+      lastResult: state.lastResult
+    };
+  }
+};
+var auto_i18n_extractor_default = plugin;
+
+export { auto_i18n_extractor_default as default };

package/dist/branch-guard.d.ts

@@ -8,17 +8,18 @@ import { Plugin } from '@wrongstack/core';
  * - branch_guard_status : Show protected branches, mode, and counters.
  *
  * Hooks registered:
- * - PreToolUse with matcher `bash|git_autocommit`. Inspects the tool
- *   input for git commit / push / merge / rebase commands (bash) or
- *   the tool call itself (git_autocommit). If the current branch is
- *   protected, the call is blocked with a clear reason.
+ * - PreToolUse with matcher `bash|git|git_autocommit`. Inspects the tool
+ *   input for git commit / push / merge commands (bash), structured git
+ *   operations (git), or the tool call itself (git_autocommit). If the current
+ *   branch is protected, the call is blocked with a clear reason.
  *
  * Config (`config.extensions['branch-guard']`):
  *
  * ```jsonc
  * {
+ *   "enabled": true,               // set false to make the hook a no-op
  *   "branches": ["main", "master"],  // protected branch names
- *   "mode": "block",                 // "block" | "warn"
+ *   "mode": "block",                 // "block" | "warn" | "off"
  *   "blockMerge": true,              // also block merges into protected
  *   "blockPush": true,               // also block pushes from protected
  *   "blockCommit": true              // also block commits on protected

package/dist/branch-guard.js

@@ -7,9 +7,11 @@ var state = {
   blockCount: 0,
   warnCount: 0,
   hookUnregister: null,
+  configUnregister: null,
   lastBlock: null
 };
 var DEFAULTS = {
+  enabled: true,
   branches: ["main", "master"],
   mode: "block",
   blockCommit: true,
@@ -20,14 +22,36 @@ function readConfig(raw) {
   if (!raw || typeof raw !== "object") return { ...DEFAULTS };
   const r = raw;
   const branches = Array.isArray(r["branches"]) ? r["branches"].filter((b) => typeof b === "string") : DEFAULTS.branches;
+  const mode = r["mode"] === "warn" ? "warn" : r["mode"] === "off" ? "off" : "block";
   return {
+    enabled: r["enabled"] !== false && mode !== "off",
     branches: branches.length > 0 ? branches : DEFAULTS.branches,
-    mode: r["mode"] === "warn" ? "warn" : "block",
+    mode,
     blockCommit: r["blockCommit"] !== false,
     blockPush: r["blockPush"] !== false,
     blockMerge: r["blockMerge"] !== false
   };
 }
+function readHostConfig(raw) {
+  const host = raw && typeof raw === "object" ? raw : {};
+  const extensions = host["extensions"];
+  const branchGuardOptions = extensions && typeof extensions === "object" ? extensions["branch-guard"] : void 0;
+  const cfg = readConfig(branchGuardOptions);
+  if (hasDisabledPluginEntry(host["plugins"])) {
+    return { ...cfg, enabled: false, mode: "off" };
+  }
+  return cfg;
+}
+function hasDisabledPluginEntry(raw) {
+  if (!Array.isArray(raw)) return false;
+  return raw.some((entry) => {
+    if (!entry || typeof entry !== "object") return false;
+    const r = entry;
+    if (r["enabled"] !== false) return false;
+    const name = typeof r["name"] === "string" ? r["name"] : "";
+    return name === "branch-guard" || name === "@wrongstack/plugins/branch-guard";
+  });
+}
 function getCurrentBranch(cwd) {
   try {
     const branch = execSync("git branch --show-current", {
@@ -67,6 +91,16 @@ function detectGitCommand(command) {
   }
   return null;
 }
+function detectStructuredGitCommand(input) {
+  const command = input["command"];
+  if (command === "commit") {
+    if (input["dry_run"] === true) return null;
+    return { type: "commit", snippet: "git commit" };
+  }
+  if (command === "push") return { type: "push", snippet: "git push" };
+  if (command === "merge") return { type: "merge", snippet: "git merge" };
+  return null;
+}
 function shouldBlock(op, cfg) {
   if (op === "commit") return cfg.blockCommit;
   if (op === "push") return cfg.blockPush;
@@ -117,14 +151,18 @@ var plugin = {
     state.blockCount = 0;
     state.warnCount = 0;
     state.hookUnregister = null;
+    state.configUnregister = null;
     state.lastBlock = null;
-    const cfg = readConfig(api.config.extensions?.["branch-guard"]);
+    let cfg = readHostConfig(api.config);
+    state.configUnregister = api.onConfigChange((next) => {
+      cfg = readHostConfig(next);
+    });
     const cwd = typeof process.cwd === "function" ? process.cwd() : void 0;
-    const protectedSet = new Set(cfg.branches);
     const hook = (input) => {
       const toolName = input.toolName ?? "";
       const inp = input.toolInput ?? {};
       state.invocationCount += 1;
+      if (!cfg.enabled || cfg.mode === "off") return;
       let gitOp = null;
       if (toolName === "git_autocommit") {
         if (inp["dry_run"] === true) return;
@@ -133,11 +171,14 @@ var plugin = {
         const command = inp["command"];
         if (typeof command !== "string") return;
         gitOp = detectGitCommand(command);
+      } else if (toolName === "git") {
+        gitOp = detectStructuredGitCommand(inp);
       }
       if (!gitOp) return;
       if (!shouldBlock(gitOp.type, cfg)) return;
       const branch = getCurrentBranch(cwd);
       if (!branch) return;
+      const protectedSet = new Set(cfg.branches);
       if (!protectedSet.has(branch)) return;
       const when = (/* @__PURE__ */ new Date()).toISOString();
       const opVerb = gitOp.type === "commit" ? "committing to" : gitOp.type === "push" ? "pushing from" : "merging into";
@@ -174,7 +215,7 @@ var plugin = {
 \u26A0\uFE0F branch-guard: you are ${opVerb} protected branch '${branch}'. ` + (hasUncommitted ? `You have uncommitted changes \u2014 consider \`git stash\` before switching branches. ` : "") + `Use a feature branch instead. Protected: ${cfg.branches.join(", ")}.`
       };
     };
-    state.hookUnregister = api.registerHook("PreToolUse", "bash|git_autocommit", hook);
+    state.hookUnregister = api.registerHook("PreToolUse", "bash|git|git_autocommit", hook);
     api.tools.register({
       name: "branch_guard_status",
       description: "Reports branch-guard state: protected branches, mode, and per-session invocation/block/warn counters.",
@@ -185,6 +226,7 @@ var plugin = {
       async execute() {
         return {
           ok: true,
+          enabled: cfg.enabled,
           branches: cfg.branches,
           mode: cfg.mode,
           blockCommit: cfg.blockCommit,
@@ -201,11 +243,19 @@ var plugin = {
     });
     api.log.info("branch-guard plugin loaded", {
       version: "0.1.0",
+      enabled: cfg.enabled,
       branches: cfg.branches,
       mode: cfg.mode
     });
   },
   teardown(api) {
+    if (state.configUnregister) {
+      try {
+        state.configUnregister();
+      } catch {
+      }
+      state.configUnregister = null;
+    }
     if (state.hookUnregister) {
       try {
         state.hookUnregister();

package/dist/checkpoint.js

@@ -33,6 +33,14 @@ function resolveProjectPath(rawPath, cwd = process.cwd()) {
   if (rel === "" || !rel.startsWith("..") && !isAbsolute(rel)) return resolved;
   return null;
 }
+function hashContent(s) {
+  const cap = Math.min(s.length, 65536);
+  let h = 5381;
+  for (let i = 0; i < cap; i++) {
+    h = (h << 5) + h + s.charCodeAt(i) | 0;
+  }
+  return h >>> 0;
+}
 function captureFile(path, maxBytes) {
   try {
     const st = statSync(path);
@@ -117,6 +125,16 @@ var plugin = {
         );
         state.captures += 1;
         api.metrics.counter("captures");
+        api.emitCustom?.("checkpoint:captured", {
+          path: safePath,
+          bytes: captured.bytes,
+          hadContent: captured.content !== null,
+          // 32-bit unsigned hash of the captured bytes. Collisions
+          // are tolerable (consumers should compare hashes per-path,
+          // not across paths).
+          contentHash: captured.content !== null ? hashContent(captured.content) : 0,
+          when: (/* @__PURE__ */ new Date()).toISOString()
+        });
       };
       state.hookUnregister = api.registerHook("PreToolUse", "write|edit", hook);
     }

package/dist/code-metrics.d.ts

@@ -0,0 +1,31 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * code-metrics plugin — lightweight per-file code metrics using regex-based
+ * line counting and complexity heuristics.
+ *
+ * Tools registered:
+ * - measure_code_metrics : Compute lines, comments, blanks, function count,
+ *   and cyclomatic-complexity-like score for a file or directory.
+ * - metrics_status : Report config + counters.
+ *
+ * Hooks registered:
+ * - PostToolUse with matcher `write|edit` to source files, injecting a
+ *   one-line metric summary of the changed file.
+ *
+ * Config (`config.extensions['code-metrics']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "extensions": [".ts", ".tsx", ".js", ".jsx"],
+ *   "maxFiles": 50
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };