@wrongstack/plugins 0.281.3 → 0.282.0

package/dist/doc-sync-guard.js

@@ -0,0 +1,223 @@
+import { isAbsolute, resolve, relative, basename, extname } from 'path';
+
+// src/doc-sync-guard/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  changedFiles: [],
+  sourceWrites: 0,
+  docWrites: 0,
+  warningsIssued: 0,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: false,
+  sourceExtensions: [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"],
+  docNames: ["README.md", "README", "CONTRIBUTING.md", "CHANGELOG.md"],
+  maxTrackedFiles: 20
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    sourceExtensions: Array.isArray(r["sourceExtensions"]) ? r["sourceExtensions"].filter((x) => typeof x === "string") : DEFAULTS.sourceExtensions,
+    docNames: Array.isArray(r["docNames"]) ? r["docNames"].filter((x) => typeof x === "string") : DEFAULTS.docNames,
+    maxTrackedFiles: typeof r["maxTrackedFiles"] === "number" && r["maxTrackedFiles"] >= 1 && r["maxTrackedFiles"] <= 200 ? r["maxTrackedFiles"] : DEFAULTS.maxTrackedFiles
+  };
+}
+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 normalizeSlashes(p) {
+  return p.replace(/\\/g, "/");
+}
+function isSourceFile(p, extensions) {
+  const ext = extname(p).toLowerCase();
+  return extensions.includes(ext);
+}
+function isPublicSource(p, extensions) {
+  if (!isSourceFile(p, extensions)) return false;
+  const norm = normalizeSlashes(p);
+  if (norm.includes("/node_modules/") || norm.startsWith("node_modules/")) return false;
+  const base = basename(norm).toLowerCase();
+  if (/\.(test|spec)\./.test(base)) return false;
+  if (base.startsWith("_")) return false;
+  return true;
+}
+function isDocFile(p, docNames) {
+  const norm = normalizeSlashes(p);
+  const base = basename(norm);
+  const lowerBase = base.toLowerCase();
+  if (docNames.some((name) => lowerBase === name.toLowerCase())) return true;
+  if (norm.includes("/docs/") || norm.startsWith("docs/")) return true;
+  return false;
+}
+function extractPath(toolInput) {
+  const inp = toolInput ?? {};
+  const p = inp["path"];
+  return typeof p === "string" ? p : void 0;
+}
+function extractDocContent(toolInput) {
+  const inp = toolInput ?? {};
+  if (typeof inp["content"] === "string") return inp["content"];
+  if (typeof inp["new_string"] === "string") return inp["new_string"];
+  return void 0;
+}
+function referenceTokens(p) {
+  const base = basename(p);
+  const withoutExt = base.replace(/\.[^.]+$/, "");
+  const tokens = [base];
+  if (withoutExt && withoutExt !== base) tokens.push(withoutExt);
+  return tokens;
+}
+function isReferenced(path, content) {
+  const lowerContent = content.toLowerCase();
+  for (const token of referenceTokens(path)) {
+    if (token.length < 2) continue;
+    if (lowerContent.includes(token.toLowerCase())) return true;
+  }
+  return false;
+}
+function trackChangedFile(path, maxTracked) {
+  state.changedFiles = state.changedFiles.filter((p) => p !== path);
+  state.changedFiles.push(path);
+  if (state.changedFiles.length > maxTracked) {
+    state.changedFiles = state.changedFiles.slice(-maxTracked);
+  }
+}
+var plugin = {
+  name: "doc-sync-guard",
+  version: "0.1.0",
+  description: "PostToolUse hook that tracks changed public source files and warns when README/docs edits omit them",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      sourceExtensions: {
+        type: "array",
+        items: { type: "string" },
+        default: [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts"],
+        description: "Extensions considered public source files."
+      },
+      docNames: {
+        type: "array",
+        items: { type: "string" },
+        default: ["README.md", "README", "CONTRIBUTING.md", "CHANGELOG.md"],
+        description: "Base file names treated as documentation."
+      },
+      maxTrackedFiles: {
+        type: "number",
+        minimum: 1,
+        maximum: 200,
+        default: 20,
+        description: "Maximum number of recently changed source files to remember."
+      }
+    }
+  },
+  setup(api) {
+    state.changedFiles = [];
+    state.sourceWrites = 0;
+    state.docWrites = 0;
+    state.warningsIssued = 0;
+    state.hookUnregister = null;
+    const cfg = readConfig(api.config.extensions?.["doc-sync-guard"]);
+    const hook = (input) => {
+      if (!cfg.enabled) return;
+      if (input.toolResult?.isError) return;
+      const path = extractPath(input.toolInput);
+      if (!path || !withinProject(path)) return;
+      if (isPublicSource(path, cfg.sourceExtensions)) {
+        trackChangedFile(path, cfg.maxTrackedFiles);
+        state.sourceWrites += 1;
+        return;
+      }
+      if (isDocFile(path, cfg.docNames)) {
+        state.docWrites += 1;
+        const content = extractDocContent(input.toolInput);
+        if (!content || state.changedFiles.length === 0) return;
+        const missing = state.changedFiles.filter((changedPath) => !isReferenced(changedPath, content));
+        if (missing.length === 0) return;
+        state.warningsIssued += 1;
+        const missingList = missing.map((p) => `  - ${p}`).join("\n");
+        const message = `
+\u26A0\uFE0F doc-sync-guard: ${path} was updated but does not appear to reference recently changed public source file(s):
+${missingList}
+Consider mentioning these changes in the documentation.`;
+        return { additionalContext: message };
+      }
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "doc_sync_status",
+      description: "Reports doc-sync-guard state: tracked changed files, doc-write count, and warning count.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          maxTrackedFiles: cfg.maxTrackedFiles,
+          changedFiles: [...state.changedFiles],
+          counters: {
+            sourceWrites: state.sourceWrites,
+            docWrites: state.docWrites,
+            warningsIssued: state.warningsIssued
+          }
+        };
+      }
+    });
+    api.log.info("doc-sync-guard plugin loaded", {
+      version: "0.1.0",
+      maxTrackedFiles: cfg.maxTrackedFiles,
+      sourceExtensions: cfg.sourceExtensions,
+      docNames: cfg.docNames
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      changedFiles: state.changedFiles.length,
+      sourceWrites: state.sourceWrites,
+      docWrites: state.docWrites,
+      warningsIssued: state.warningsIssued
+    };
+    state.changedFiles = [];
+    state.sourceWrites = 0;
+    state.docWrites = 0;
+    state.warningsIssued = 0;
+    api.log.info("doc-sync-guard: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: `doc-sync-guard: ${state.changedFiles.length} tracked file(s), ${state.warningsIssued} warning(s)`,
+      counters: {
+        changedFiles: state.changedFiles.length,
+        sourceWrites: state.sourceWrites,
+        docWrites: state.docWrites,
+        warningsIssued: state.warningsIssued
+      }
+    };
+  }
+};
+var doc_sync_guard_default = plugin;
+
+export { doc_sync_guard_default as default };

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

@@ -0,0 +1,33 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * duplicate-code-detector plugin — finds duplicated code blocks across source
+ * files using normalized-line fingerprinting.
+ *
+ * Tools registered:
+ * - detect_duplicate_code : Scan a path for duplicated blocks.
+ * - duplicate_code_status : Report config + counters.
+ *
+ * Hooks registered:
+ * - PostToolUse with matcher `write|edit` to source files, warning when the
+ *   changed file introduces blocks that duplicate existing code elsewhere.
+ *
+ * Config (`config.extensions['duplicate-code-detector']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "minLines": 5,
+ *   "threshold": 0.8,
+ *   "extensions": [".ts", ".tsx", ".js", ".jsx"],
+ *   "excludeDirs": ["node_modules", "dist", ".git", "coverage"],
+ *   "maxFindings": 20
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/duplicate-code-detector.js

@@ -0,0 +1,384 @@
+import { readFileSync, existsSync, statSync, readdirSync } from 'fs';
+import { resolve, isAbsolute, relative, extname } from 'path';
+
+// src/duplicate-code-detector/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  scanCount: 0,
+  findingCount: 0,
+  hookInvocationCount: 0,
+  warningCount: 0,
+  errorCount: 0,
+  hookUnregister: null,
+  lastHookWarning: /* @__PURE__ */ new Map()
+};
+var DEFAULTS = {
+  enabled: false,
+  minLines: 8,
+  threshold: 0.8,
+  extensions: [".ts", ".tsx", ".js", ".jsx"],
+  excludeDirs: ["node_modules", "dist", ".git", "coverage"],
+  maxFindings: 5
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] === true,
+    minLines: typeof r["minLines"] === "number" && r["minLines"] >= 2 && r["minLines"] <= 100 ? r["minLines"] : DEFAULTS.minLines,
+    threshold: typeof r["threshold"] === "number" && r["threshold"] > 0 && r["threshold"] <= 1 ? r["threshold"] : DEFAULTS.threshold,
+    extensions: Array.isArray(r["extensions"]) ? r["extensions"].filter((x) => typeof x === "string") : DEFAULTS.extensions,
+    excludeDirs: Array.isArray(r["excludeDirs"]) ? r["excludeDirs"].filter((x) => typeof x === "string") : DEFAULTS.excludeDirs,
+    maxFindings: typeof r["maxFindings"] === "number" && r["maxFindings"] >= 1 && r["maxFindings"] <= 500 ? r["maxFindings"] : DEFAULTS.maxFindings
+  };
+}
+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 matchesExtension(p, exts) {
+  const ext = extname(p).toLowerCase();
+  return exts.includes(ext);
+}
+function collectSourceFiles(root, cfg) {
+  const files = [];
+  if (!existsSync(root)) return files;
+  const s = statSync(root);
+  if (s.isFile()) {
+    if (matchesExtension(root, cfg.extensions)) 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) {
+      const full = resolve(dir, entry);
+      let st;
+      try {
+        st = statSync(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        if (!cfg.excludeDirs.includes(entry)) walk(full);
+      } else if (st.isFile() && matchesExtension(full, cfg.extensions)) {
+        files.push(full);
+      }
+    }
+  }
+  walk(root);
+  return files;
+}
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function relativePath(p) {
+  return toPosix(relative(process.cwd(), p));
+}
+function removeInlineComments(line) {
+  return line.replace(/\/\/.*$/, "").replace(/\/\*[\s\S]*?\*\//, "");
+}
+function normalizeLine(line) {
+  let normalized = line.trim().toLowerCase();
+  normalized = removeInlineComments(normalized);
+  normalized = normalized.replace(/\s+/g, " ").trim();
+  return normalized;
+}
+function buildFingerprint(lines) {
+  return lines.map(normalizeLine).filter((l) => l.length > 0).join("\n");
+}
+function extractWindows(filePath, content, minLines) {
+  const rawLines = content.split(/\r?\n/);
+  const windows = [];
+  for (let i = 0; i <= rawLines.length - minLines; i++) {
+    const slice = rawLines.slice(i, i + minLines);
+    const fingerprint = buildFingerprint(slice);
+    if (fingerprint.length === 0) continue;
+    const snippet = slice.join("\n");
+    windows.push({
+      file: filePath,
+      startLine: i + 1,
+      endLine: i + minLines,
+      snippet,
+      fingerprint
+    });
+  }
+  return windows;
+}
+function findDuplicates(files, minLines, maxFindings) {
+  const byFingerprint = /* @__PURE__ */ new Map();
+  for (const [filePath, content] of files.entries()) {
+    const windows = extractWindows(filePath, content, minLines);
+    for (const w of windows) {
+      const list = byFingerprint.get(w.fingerprint) ?? [];
+      list.push(w);
+      byFingerprint.set(w.fingerprint, list);
+    }
+  }
+  const findings = [];
+  for (const [fingerprint, windows] of byFingerprint.entries()) {
+    if (windows.length < 2) continue;
+    const locations = windows.map((w) => ({
+      file: relativePath(w.file),
+      startLine: w.startLine,
+      endLine: w.endLine,
+      snippet: w.snippet
+    }));
+    findings.push({ fingerprint, lineCount: fingerprint.split("\n").length, locations });
+    if (findings.length >= maxFindings) break;
+  }
+  return findings;
+}
+function scanPath(rawPath, cfg) {
+  const root = process.cwd();
+  const resolved = isAbsolute(rawPath) ? resolve(rawPath) : resolve(root, rawPath);
+  const filePaths = collectSourceFiles(resolved, cfg);
+  const files = /* @__PURE__ */ new Map();
+  for (const p of filePaths) {
+    try {
+      files.set(p, readFileSync(p, "utf-8"));
+    } catch {
+    }
+  }
+  return { findings: findDuplicates(files, cfg.minLines, cfg.maxFindings), scannedFiles: files.size };
+}
+var plugin = {
+  name: "duplicate-code-detector",
+  version: "0.1.0",
+  description: "Finds duplicated code blocks across source files using normalized-line fingerprinting",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: false, description: "Master switch." },
+      minLines: {
+        type: "number",
+        minimum: 2,
+        maximum: 100,
+        default: 8,
+        description: "Minimum number of consecutive lines to form a block."
+      },
+      threshold: {
+        type: "number",
+        minimum: 0.01,
+        maximum: 1,
+        default: 0.8,
+        description: "Similarity threshold (currently exact-match only)."
+      },
+      extensions: {
+        type: "array",
+        items: { type: "string" },
+        default: [".ts", ".tsx", ".js", ".jsx"],
+        description: "File extensions to scan."
+      },
+      excludeDirs: {
+        type: "array",
+        items: { type: "string" },
+        default: ["node_modules", "dist", ".git", "coverage"],
+        description: "Directory names to skip while scanning."
+      },
+      maxFindings: {
+        type: "number",
+        minimum: 1,
+        maximum: 500,
+        default: 20,
+        description: "Maximum duplicate groups reported per scan."
+      }
+    }
+  },
+  setup(api) {
+    state.scanCount = 0;
+    state.findingCount = 0;
+    state.hookInvocationCount = 0;
+    state.warningCount = 0;
+    state.errorCount = 0;
+    state.lastHookWarning.clear();
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["duplicate-code-detector"]);
+    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 = sourcePath.includes(".") ? sourcePath.slice(sourcePath.lastIndexOf(".")).toLowerCase() : "";
+      if (!cfg.extensions.includes(ext)) return;
+      state.hookInvocationCount += 1;
+      const now = Date.now();
+      const lastWarning = state.lastHookWarning.get(sourcePath);
+      if (lastWarning !== void 0 && now - lastWarning < 6e4) return;
+      const changedFile = resolve(process.cwd(), sourcePath);
+      let content;
+      try {
+        content = readFileSync(changedFile, "utf-8");
+      } catch {
+        state.errorCount += 1;
+        return;
+      }
+      const changedWindows = extractWindows(changedFile, content, cfg.minLines);
+      if (changedWindows.length === 0) return;
+      const projectRoot = resolve(process.cwd());
+      let otherFiles;
+      try {
+        const filePaths = collectSourceFiles(projectRoot, cfg).filter((p) => p !== changedFile);
+        otherFiles = /* @__PURE__ */ new Map();
+        for (const p of filePaths) {
+          try {
+            otherFiles.set(p, readFileSync(p, "utf-8"));
+          } catch {
+          }
+        }
+      } catch {
+        state.errorCount += 1;
+        return;
+      }
+      const existingWindows = [];
+      for (const [p, c] of otherFiles.entries()) {
+        existingWindows.push(...extractWindows(p, c, cfg.minLines));
+      }
+      const hits = [];
+      for (const cw of changedWindows) {
+        for (const ew of existingWindows) {
+          if (cw.fingerprint === ew.fingerprint) {
+            hits.push(ew);
+            break;
+          }
+        }
+      }
+      if (hits.length === 0) return;
+      state.warningCount += hits.length;
+      state.lastHookWarning.set(sourcePath, now);
+      return {
+        additionalContext: `\u26A0\uFE0F duplicate-code-detector: ${sourcePath} contains ${hits.length} block(s) already present elsewhere. Run detect_duplicate_code for details.`,
+        contextAs: "separate"
+      };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "detect_duplicate_code",
+      description: "Scan source files for duplicated code blocks. Uses normalized-line fingerprinting to find identical multi-line blocks across files.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", default: ".", description: "Directory or file path to scan." }
+        }
+      },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "duplicate-code-detector is disabled" };
+        const rawPath = typeof input.path === "string" ? input.path : ".";
+        if (!withinProject(rawPath)) {
+          return { ok: false, error: "scan path is outside the project root" };
+        }
+        state.scanCount += 1;
+        let result;
+        try {
+          result = scanPath(rawPath, cfg);
+        } catch (err) {
+          state.errorCount += 1;
+          return { ok: false, error: String(err) };
+        }
+        state.findingCount += result.findings.length;
+        return {
+          ok: true,
+          path: relativePath(resolve(process.cwd(), rawPath)),
+          scannedFiles: result.scannedFiles,
+          minLines: cfg.minLines,
+          findings: result.findings
+        };
+      }
+    });
+    api.tools.register({
+      name: "duplicate_code_status",
+      description: "Reports duplicate-code-detector state: config + counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          minLines: cfg.minLines,
+          threshold: cfg.threshold,
+          extensions: cfg.extensions,
+          excludeDirs: cfg.excludeDirs,
+          maxFindings: cfg.maxFindings,
+          counters: {
+            scans: state.scanCount,
+            findings: state.findingCount,
+            hookInvocations: state.hookInvocationCount,
+            warnings: state.warningCount,
+            errors: state.errorCount
+          }
+        };
+      }
+    });
+    api.log.info("duplicate-code-detector plugin loaded", {
+      version: "0.1.0",
+      minLines: cfg.minLines,
+      extensions: cfg.extensions
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      scans: state.scanCount,
+      findings: state.findingCount,
+      hookInvocations: state.hookInvocationCount,
+      warnings: state.warningCount,
+      errors: state.errorCount
+    };
+    state.scanCount = 0;
+    state.findingCount = 0;
+    state.hookInvocationCount = 0;
+    state.warningCount = 0;
+    state.errorCount = 0;
+    state.lastHookWarning.clear();
+    api.log.info("duplicate-code-detector: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.errorCount === 0,
+      message: state.errorCount ? `duplicate-code-detector: ${state.errorCount} error(s)` : `duplicate-code-detector: ${state.scanCount} scan(s), ${state.findingCount} duplicate group(s)`,
+      counters: {
+        scans: state.scanCount,
+        findings: state.findingCount,
+        hookInvocations: state.hookInvocationCount,
+        warnings: state.warningCount,
+        errors: state.errorCount
+      }
+    };
+  }
+};
+var duplicate_code_detector_default = plugin;
+
+export { duplicate_code_detector_default as default };

package/dist/feature-flag-tracker.d.ts

@@ -0,0 +1,38 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * feature-flag-tracker plugin — scans source files for feature-flag-like
+ * expressions and reports where they are used.
+ *
+ * Tools registered:
+ * - scan_feature_flags : Scan a path for feature flag usages.
+ * - feature_flag_status : Report config + counters.
+ *
+ * Hooks registered:
+ * - PostToolUse with matcher `write|edit` to source files, noting any feature
+ *   flags used in the changed file.
+ *
+ * Config (`config.extensions['feature-flag-tracker']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "extensions": [".ts", ".tsx", ".js", ".jsx"],
+ *   "patterns": ["extra-regex"],
+ *   "maxFindings": 50
+ * }
+ * ```
+ *
+ * @public
+ */
+
+interface FeatureFlagUsage {
+    flag: string;
+    file: string;
+    line: number;
+    context: string;
+    pattern: string;
+}
+declare const plugin: Plugin;
+
+export { type FeatureFlagUsage, plugin as default };