@wrongstack/plugins 0.281.3 → 0.282.0

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/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 };