@wrongstack/plugins 0.281.3 → 0.282.1

package/dist/feature-flag-tracker.js

@@ -0,0 +1,316 @@
+import { readFileSync, existsSync, statSync, readdirSync } from 'fs';
+import { resolve, isAbsolute, relative, extname } from 'path';
+
+// src/feature-flag-tracker/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  scanCount: 0,
+  flagCount: 0,
+  hookInvocationCount: 0,
+  warningCount: 0,
+  errorCount: 0,
+  hookUnregister: null
+};
+var DEFAULT_PATTERNS = [
+  String.raw`isFeatureEnabled\(['"]([^'"]+)['"]\)`,
+  String.raw`featureFlags?\.([A-Za-z_$][A-Za-z0-9_$]*)`,
+  String.raw`useFeatureFlag\(['"]([^'"]+)['"]\)`,
+  String.raw`flags\.([A-Za-z_$][A-Za-z0-9_$]*)`
+];
+var DEFAULTS = {
+  enabled: false,
+  extensions: [".ts", ".tsx", ".js", ".jsx"],
+  patterns: [],
+  maxFindings: 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,
+    patterns: Array.isArray(r["patterns"]) ? r["patterns"].filter((x) => typeof x === "string") : DEFAULTS.patterns,
+    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 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 compilePatterns(patterns) {
+  const sources = [...DEFAULT_PATTERNS, ...patterns];
+  return sources.map((src) => new RegExp(src, "g"));
+}
+function scanFile(filePath, content, patterns, maxFindings) {
+  const usages = [];
+  const lines = content.split(/\r?\n/);
+  for (const re of patterns) {
+    re.lastIndex = 0;
+    let m;
+    while ((m = re.exec(content)) !== null) {
+      const flag = m[1] ?? m[0];
+      const lineNo = content.slice(0, m.index).split(/\r?\n/).length;
+      const context = (lines[lineNo - 1] ?? "").trim();
+      usages.push({
+        flag,
+        file: relativePath(filePath),
+        line: lineNo,
+        context,
+        pattern: re.source
+      });
+      if (usages.length >= maxFindings) break;
+    }
+    if (usages.length >= maxFindings) break;
+  }
+  return usages.slice(0, maxFindings);
+}
+function scanPath(rawPath, cfg) {
+  const root = process.cwd();
+  const resolved = isAbsolute(rawPath) ? resolve(rawPath) : resolve(root, rawPath);
+  const exts = normalizeExtensions(cfg.extensions);
+  const files = collectSourceFiles(resolved, exts);
+  const patterns = compilePatterns(cfg.patterns);
+  const usages = [];
+  for (const p of files) {
+    try {
+      const content = readFileSync(p, "utf-8");
+      usages.push(...scanFile(p, content, patterns, cfg.maxFindings));
+      if (usages.length >= cfg.maxFindings) break;
+    } catch {
+    }
+  }
+  return { usages: usages.slice(0, cfg.maxFindings), scannedFiles: files.length };
+}
+var plugin = {
+  name: "feature-flag-tracker",
+  version: "0.1.0",
+  description: "Scans source files for feature-flag-like expressions and reports usages",
+  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 scan."
+      },
+      patterns: {
+        type: "array",
+        items: { type: "string" },
+        default: [],
+        description: "Extra regex patterns (merged with built-in defaults)."
+      },
+      maxFindings: {
+        type: "number",
+        minimum: 1,
+        maximum: 500,
+        default: 50,
+        description: "Maximum flag usages reported per scan."
+      }
+    }
+  },
+  setup(api) {
+    state.scanCount = 0;
+    state.flagCount = 0;
+    state.hookInvocationCount = 0;
+    state.warningCount = 0;
+    state.errorCount = 0;
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["feature-flag-tracker"]);
+    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 patterns = compilePatterns(cfg.patterns);
+      const usages = scanFile(resolved, content, patterns, cfg.maxFindings);
+      if (usages.length === 0) return;
+      state.warningCount += usages.length;
+      const flags = [...new Set(usages.map((u) => u.flag))].join(", ");
+      return {
+        additionalContext: `
+\u{1F6A9} feature-flag-tracker: ${sourcePath} references feature flag(s): ${flags}.
+Make sure flag behavior is intentional and consider updating flag inventory/docs.`
+      };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "scan_feature_flags",
+      description: "Scan source files for feature-flag-like expressions (isFeatureEnabled, featureFlags.*, useFeatureFlag, flags.*, plus custom patterns).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", default: ".", description: "File or directory path to scan." }
+        }
+      },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "feature-flag-tracker is disabled" };
+        const rawPath = typeof input.path === "string" ? input.path : ".";
+        if (!withinProject(rawPath)) {
+          return { ok: false, error: "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.flagCount += result.usages.length;
+        return {
+          ok: true,
+          path: relativePath(resolve(process.cwd(), rawPath)),
+          scannedFiles: result.scannedFiles,
+          usages: result.usages
+        };
+      }
+    });
+    api.tools.register({
+      name: "feature_flag_status",
+      description: "Reports feature-flag-tracker state: config + counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          extensions: cfg.extensions,
+          patterns: cfg.patterns,
+          maxFindings: cfg.maxFindings,
+          counters: {
+            scans: state.scanCount,
+            flags: state.flagCount,
+            hookInvocations: state.hookInvocationCount,
+            warnings: state.warningCount,
+            errors: state.errorCount
+          }
+        };
+      }
+    });
+    api.log.info("feature-flag-tracker plugin loaded", {
+      version: "0.1.0",
+      extensions: cfg.extensions,
+      customPatterns: cfg.patterns.length
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      scans: state.scanCount,
+      flags: state.flagCount,
+      hookInvocations: state.hookInvocationCount,
+      warnings: state.warningCount,
+      errors: state.errorCount
+    };
+    state.scanCount = 0;
+    state.flagCount = 0;
+    state.hookInvocationCount = 0;
+    state.warningCount = 0;
+    state.errorCount = 0;
+    api.log.info("feature-flag-tracker: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.errorCount === 0,
+      message: state.errorCount ? `feature-flag-tracker: ${state.errorCount} error(s)` : `feature-flag-tracker: ${state.scanCount} scan(s), ${state.flagCount} flag usage(s)`,
+      counters: {
+        scans: state.scanCount,
+        flags: state.flagCount,
+        hookInvocations: state.hookInvocationCount,
+        warnings: state.warningCount,
+        errors: state.errorCount
+      }
+    };
+  }
+};
+var feature_flag_tracker_default = plugin;
+
+export { feature_flag_tracker_default as default };

package/dist/file-watcher.js

@@ -1,8 +1,18 @@
 import { watch } from 'fs';
-import * as path from 'path';
+import { isAbsolute, resolve, relative } from 'path';
 
 // src/file-watcher/index.ts
 var API_VERSION = "^0.1.10";
+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;
+}
 var watch_idCounter = 0;
 function nextId() {
   return `watch_${++watch_idCounter}_${Date.now().toString(36)}`;
@@ -71,16 +81,30 @@ var plugin = {
     function debounceEvent(key, fn, ms) {
       const existing = debounceTimers.get(key);
       if (existing) clearTimeout(existing);
-      debounceTimers.set(key, setTimeout(() => {
-        debounceTimers.delete(key);
-        fn();
-      }, ms));
+      debounceTimers.set(
+        key,
+        setTimeout(() => {
+          debounceTimers.delete(key);
+          fn();
+        }, ms)
+      );
     }
     const autoIndex = api.config.extensions?.["file-watcher"]?.["autoIndex"] ?? false;
     const indexProjectRoot = api.config.extensions?.["file-watcher"]?.["indexProjectRoot"] ?? "";
+    const safeIndexRoot = indexProjectRoot !== "" && withinProject(indexProjectRoot) ? indexProjectRoot : "";
+    if (indexProjectRoot !== "" && safeIndexRoot === "") {
+      api.log.warn(
+        "file-watcher: indexProjectRoot is outside the project root \u2014 using watched dirPath instead",
+        {
+          indexProjectRoot
+        }
+      );
+    }
     const INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
     function isIndexableFile(filePath) {
-      return INDEXABLE_EXTENSIONS.has(path.extname(filePath));
+      const dot = filePath.lastIndexOf(".");
+      const ext = dot >= 0 ? filePath.slice(dot).toLowerCase() : "";
+      return INDEXABLE_EXTENSIONS.has(ext);
     }
     function safeWatchDir(dirPath, recursive, handle) {
       try {
@@ -88,34 +112,42 @@ var plugin = {
           if (!filename) return;
           const fullPath = `${dirPath}/${filename}`;
           const key = `${handle.id}:${fullPath}:${eventType}`;
-          debounceEvent(key, () => {
-            api.emitCustom("file-watcher:changed", {
-              watch_id: handle.id,
-              path: fullPath,
-              event: eventType,
-              filename,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-            api.metrics.counter("file_change", 1, { event: eventType ?? "unknown" });
-            api.log.debug(`file-watcher: ${eventType} ${fullPath} (watch=${handle.id})`);
-            if (autoIndex && isIndexableFile(fullPath)) {
-              debounceEvent(`index:${fullPath}`, async () => {
-                try {
-                  const { enqueueReindex } = await import('@wrongstack/tools/codebase-index');
-                  const root = indexProjectRoot || dirPath;
-                  enqueueReindex({
-                    projectRoot: root,
-                    files: [fullPath],
-                    onError: (err) => api.log.warn(`file-watcher: auto-index failed for ${fullPath}: ${err}`)
-                  });
-                  api.metrics.counter("index_file", 1);
-                  api.log.debug(`file-watcher: auto-index scheduled for ${fullPath}`);
-                } catch (err) {
-                  api.log.warn(`file-watcher: auto-index failed for ${fullPath}: ${err}`);
-                }
-              }, debounceMs);
-            }
-          }, debounceMs);
+          debounceEvent(
+            key,
+            () => {
+              api.emitCustom("file-watcher:changed", {
+                watch_id: handle.id,
+                path: fullPath,
+                event: eventType,
+                filename,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              api.metrics.counter("file_change", 1, { event: eventType ?? "unknown" });
+              api.log.debug(`file-watcher: ${eventType} ${fullPath} (watch=${handle.id})`);
+              if (autoIndex && isIndexableFile(fullPath)) {
+                debounceEvent(
+                  `index:${fullPath}`,
+                  async () => {
+                    try {
+                      const { enqueueReindex } = await import('@wrongstack/tools/codebase-index');
+                      const root = safeIndexRoot || dirPath;
+                      enqueueReindex({
+                        projectRoot: root,
+                        files: [fullPath],
+                        onError: (err) => api.log.warn(`file-watcher: auto-index failed for ${fullPath}: ${err}`)
+                      });
+                      api.metrics.counter("index_file", 1);
+                      api.log.debug(`file-watcher: auto-index scheduled for ${fullPath}`);
+                    } catch (err) {
+                      api.log.warn(`file-watcher: auto-index failed for ${fullPath}: ${err}`);
+                    }
+                  },
+                  debounceMs
+                );
+              }
+            },
+            debounceMs
+          );
         });
         watcher.on("error", (err) => {
           api.log.warn(`file-watcher: error on ${dirPath}: ${err}`);
@@ -156,14 +188,31 @@ var plugin = {
       async execute(input) {
         const rawPaths = input["paths"];
         if (!rawPaths || typeof rawPaths !== "object" || !Array.isArray(rawPaths)) {
-          return { ok: false, error: "paths must be an array of file/directory paths", watch_id: null };
+          return {
+            ok: false,
+            error: "paths must be an array of file/directory paths",
+            watch_id: null
+          };
         }
         const paths = rawPaths;
         if (paths.length === 0) {
-          return { ok: false, error: "paths array is empty \u2014 provide at least one path", watch_id: null };
+          return {
+            ok: false,
+            error: "paths array is empty \u2014 provide at least one path",
+            watch_id: null
+          };
         }
         const events = input["events"] ?? ["change", "add", "delete"];
         const recursive = input["recursive"] ?? true;
+        const bad = paths.find((p) => !withinProject(p));
+        if (bad !== void 0) {
+          return {
+            ok: false,
+            error: `path is outside the project root: ${bad}`,
+            watch_id: null,
+            rejectedOutsideProject: true
+          };
+        }
         const id = nextId();
         const handle = {
           id,