@wrongstack/plugins 0.281.1 → 0.282.0

package/dist/semantic-search-indexer.js

@@ -0,0 +1,436 @@
+import { statSync, readFileSync, readdirSync } from 'fs';
+import { isAbsolute, resolve, relative } from 'path';
+
+// src/semantic-search-indexer/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  index: null,
+  cachedPath: null,
+  fileCount: 0,
+  termCount: 0,
+  bytesIndexed: 0,
+  truncated: false,
+  queryCount: 0,
+  reindexCount: 0};
+var DEFAULTS = {
+  enabled: true,
+  includeExtensions: [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".java",
+    ".go",
+    ".rs",
+    ".rb",
+    ".php",
+    ".cpp",
+    ".c",
+    ".h",
+    ".cs",
+    ".swift",
+    ".kt",
+    ".scala",
+    ".sh",
+    ".md",
+    ".json",
+    ".yaml",
+    ".yml",
+    ".css",
+    ".scss",
+    ".html"
+  ],
+  excludePatterns: ["node_modules", "\\.git", "\\.wrongstack", "\\.temp_files", "coverage", "dist"],
+  maxFileBytes: 1e6,
+  defaultLimit: 10,
+  minTokenLength: 2,
+  maxMatchesPerFile: 10,
+  maxFiles: 5e3
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS, includeExtensions: [...DEFAULTS.includeExtensions], excludePatterns: [...DEFAULTS.excludePatterns] };
+  const r = raw;
+  const includeExtensions = Array.isArray(r["includeExtensions"]) ? r["includeExtensions"].filter((x) => typeof x === "string") : [...DEFAULTS.includeExtensions];
+  const excludePatterns = Array.isArray(r["excludePatterns"]) ? r["excludePatterns"].filter((x) => typeof x === "string") : [...DEFAULTS.excludePatterns];
+  const clamp = (v, min, max, fallback) => typeof v === "number" && Number.isFinite(v) && v >= min && v <= max ? v : fallback;
+  return {
+    enabled: r["enabled"] !== false,
+    includeExtensions,
+    excludePatterns,
+    maxFileBytes: clamp(r["maxFileBytes"], 1024, 5e7, DEFAULTS.maxFileBytes),
+    defaultLimit: clamp(r["defaultLimit"], 1, 1e3, DEFAULTS.defaultLimit),
+    minTokenLength: clamp(r["minTokenLength"], 1, 10, DEFAULTS.minTokenLength),
+    maxMatchesPerFile: clamp(r["maxMatchesPerFile"], 1, 100, DEFAULTS.maxMatchesPerFile),
+    maxFiles: clamp(r["maxFiles"], 1, 5e4, DEFAULTS.maxFiles)
+  };
+}
+function normalizeSlashes(p) {
+  return p.replace(/\\/g, "/");
+}
+function withinProject(p) {
+  if (typeof p !== "string" || p.length === 0 || p.length > 4096) return false;
+  const root = normalizeSlashes(process.cwd());
+  const resolved = normalizeSlashes(isAbsolute(p) ? resolve(p) : resolve(root, p));
+  const rel = normalizeSlashes(relative(root, resolved));
+  if (rel === "" || rel === ".") return true;
+  if (rel.startsWith("..")) return false;
+  if (isAbsolute(rel)) return false;
+  return true;
+}
+function resolveProjectPath(p) {
+  const raw = typeof p === "string" && p.length > 0 ? p : ".";
+  if (!withinProject(raw)) return null;
+  const root = normalizeSlashes(process.cwd());
+  return normalizeSlashes(isAbsolute(raw) ? resolve(raw) : resolve(root, raw));
+}
+function tokenize(text, minLength) {
+  const tokens = [];
+  for (const match of text.toLowerCase().match(/[a-z0-9]+/g) ?? []) {
+    if (match.length >= minLength) tokens.push(match);
+  }
+  return tokens;
+}
+function compileExcludes(patterns) {
+  const out = [];
+  for (const p of patterns) {
+    try {
+      out.push(new RegExp(p));
+    } catch {
+    }
+  }
+  return out;
+}
+function shouldIndexFile(filePath, cfg) {
+  if (cfg.includeExtensions.length === 0) return true;
+  const lower = filePath.toLowerCase();
+  for (const ext of cfg.includeExtensions) {
+    if (lower.endsWith(ext.toLowerCase())) return true;
+  }
+  return false;
+}
+function indexFile(absPath, relPath, cfg) {
+  if (!state.index) return;
+  if (!shouldIndexFile(relPath, cfg)) return;
+  let stats;
+  try {
+    stats = statSync(absPath);
+  } catch {
+    return;
+  }
+  if (!stats.isFile() || stats.size > cfg.maxFileBytes) return;
+  let content;
+  try {
+    content = readFileSync(absPath, "utf-8");
+  } catch {
+    return;
+  }
+  if (content.includes("\0")) return;
+  state.bytesIndexed += content.length;
+  const lines = content.split(/\r?\n/);
+  state.index.files.set(relPath, { lines, size: stats.size });
+  for (let i = 0; i < lines.length; i += 1) {
+    const terms = tokenize(lines[i], cfg.minTokenLength);
+    for (const term of terms) {
+      let postings = state.index.terms.get(term);
+      if (!postings) {
+        postings = /* @__PURE__ */ new Map();
+        state.index.terms.set(term, postings);
+      }
+      let posting = postings.get(relPath);
+      if (!posting) {
+        posting = { tf: 0 };
+        postings.set(relPath, posting);
+      }
+      posting.tf += 1;
+    }
+  }
+}
+function walkDirectory(absPath, cfg, excludes) {
+  let entries;
+  try {
+    entries = readdirSync(absPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const root = normalizeSlashes(process.cwd());
+  for (const ent of entries) {
+    if (state.fileCount >= cfg.maxFiles) {
+      state.truncated = true;
+      return;
+    }
+    const absChild = normalizeSlashes(resolve(absPath, ent.name));
+    const relChild = normalizeSlashes(relative(root, absChild));
+    if (relChild === "" || relChild === ".") continue;
+    if (excludes.some((re) => re.test(relChild))) continue;
+    if (ent.isDirectory()) {
+      walkDirectory(absChild, cfg, excludes);
+      if (state.truncated) return;
+    } else if (ent.isFile()) {
+      indexFile(absChild, relChild, cfg);
+      state.fileCount += 1;
+    }
+  }
+}
+function buildIndex(rootPath, cfg) {
+  state.index = { terms: /* @__PURE__ */ new Map(), files: /* @__PURE__ */ new Map() };
+  state.cachedPath = rootPath;
+  state.fileCount = 0;
+  state.termCount = 0;
+  state.bytesIndexed = 0;
+  state.truncated = false;
+  state.reindexCount += 1;
+  const excludes = compileExcludes(cfg.excludePatterns);
+  let rootStats;
+  try {
+    rootStats = statSync(rootPath);
+  } catch {
+    state.termCount = 0;
+    return;
+  }
+  if (rootStats.isFile()) {
+    const relPath = normalizeSlashes(relative(normalizeSlashes(process.cwd()), rootPath));
+    indexFile(rootPath, relPath === "" ? "." : relPath, cfg);
+    state.fileCount = state.index.files.size;
+  } else if (rootStats.isDirectory()) {
+    walkDirectory(rootPath, cfg, excludes);
+  }
+  state.termCount = state.index.terms.size;
+}
+function runQuery(query, limit, cfg) {
+  if (!state.index) return [];
+  const rawTokens = tokenize(query, cfg.minTokenLength);
+  const uniqueTokens = [...new Set(rawTokens)];
+  if (uniqueTokens.length === 0) return [];
+  const scores = /* @__PURE__ */ new Map();
+  const matchedTerms = /* @__PURE__ */ new Map();
+  for (const token of uniqueTokens) {
+    const postings = state.index.terms.get(token);
+    if (!postings) continue;
+    for (const [filePath, posting] of postings) {
+      scores.set(filePath, (scores.get(filePath) ?? 0) + posting.tf);
+      let terms = matchedTerms.get(filePath);
+      if (!terms) {
+        terms = /* @__PURE__ */ new Set();
+        matchedTerms.set(filePath, terms);
+      }
+      terms.add(token);
+    }
+  }
+  const ranked = Array.from(scores.entries()).map(([path, score]) => ({
+    path,
+    score,
+    terms: Array.from(matchedTerms.get(path) ?? [])
+  })).sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
+  const top = ranked.slice(0, limit);
+  return top.map(({ path, score, terms }) => {
+    const entry = state.index.files.get(path);
+    const matchedLines = [];
+    if (entry) {
+      const querySet = new Set(uniqueTokens);
+      for (let i = 0; i < entry.lines.length; i += 1) {
+        const line = entry.lines[i];
+        const lower = line.toLowerCase();
+        for (const token of querySet) {
+          if (lower.includes(token)) {
+            matchedLines.push({ lineNumber: i + 1, text: line.trim() });
+            break;
+          }
+        }
+        if (matchedLines.length >= cfg.maxMatchesPerFile) break;
+      }
+    }
+    return { path, score, matchedTerms: terms, matchedLines };
+  });
+}
+var plugin = {
+  name: "semantic-search-indexer",
+  version: "0.1.0",
+  description: "Builds an in-memory keyword index over project source files and answers ranked search queries",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: { ...DEFAULTS, includeExtensions: [...DEFAULTS.includeExtensions], excludePatterns: [...DEFAULTS.excludePatterns] },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      includeExtensions: {
+        type: "array",
+        items: { type: "string" },
+        default: DEFAULTS.includeExtensions,
+        description: "Only index files with these extensions. Empty = all files."
+      },
+      excludePatterns: {
+        type: "array",
+        items: { type: "string" },
+        default: DEFAULTS.excludePatterns,
+        description: "Regex patterns; matching relative paths are skipped."
+      },
+      maxFileBytes: {
+        type: "number",
+        minimum: 1024,
+        maximum: 5e7,
+        default: 1e6,
+        description: "Files larger than this are skipped."
+      },
+      defaultLimit: {
+        type: "number",
+        minimum: 1,
+        maximum: 1e3,
+        default: 10,
+        description: "Default number of results per query."
+      },
+      minTokenLength: {
+        type: "number",
+        minimum: 1,
+        maximum: 10,
+        default: 2,
+        description: "Minimum length of an indexed/query token."
+      },
+      maxMatchesPerFile: {
+        type: "number",
+        minimum: 1,
+        maximum: 100,
+        default: 10,
+        description: "Maximum matching lines returned per result."
+      },
+      maxFiles: {
+        type: "number",
+        minimum: 1,
+        maximum: 5e4,
+        default: 5e3,
+        description: "Maximum files to index in one build."
+      }
+    }
+  },
+  setup(api) {
+    state.index = null;
+    state.cachedPath = null;
+    state.fileCount = 0;
+    state.termCount = 0;
+    state.bytesIndexed = 0;
+    state.truncated = false;
+    state.queryCount = 0;
+    state.reindexCount = 0;
+    const cfg = readConfig(api.config.extensions?.["semantic-search-indexer"]);
+    api.tools.register({
+      name: "semantic_search",
+      description: "Search project source files with a lightweight keyword index. Returns ranked file paths, TF scores, and matched lines.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Space-separated keywords to search for."
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of results (defaults to configured defaultLimit)."
+          },
+          path: {
+            type: "string",
+            description: "Directory or file to search under (defaults to project root)."
+          }
+        },
+        required: ["query"]
+      },
+      permission: "auto",
+      category: "Search",
+      mutating: false,
+      riskTier: "safe",
+      icon: "search",
+      async execute(input) {
+        if (!cfg.enabled) {
+          return { ok: false, error: "semantic-search-indexer is disabled" };
+        }
+        const resolved = resolveProjectPath(input.path);
+        if (!resolved) {
+          return { ok: false, error: "path outside project root" };
+        }
+        if (!state.index || state.cachedPath !== resolved) {
+          buildIndex(resolved, cfg);
+        }
+        const query = String(input.query ?? "");
+        const limit = typeof input.limit === "number" && input.limit >= 1 ? Math.floor(input.limit) : cfg.defaultLimit;
+        const results = runQuery(query, limit, cfg);
+        const queryTokens = [...new Set(tokenize(query, cfg.minTokenLength))];
+        state.queryCount += 1;
+        api.metrics.counter("queries");
+        return {
+          ok: true,
+          query,
+          queryTokens,
+          indexedPath: state.cachedPath,
+          totalResults: results.length,
+          limit,
+          results
+        };
+      }
+    });
+    api.tools.register({
+      name: "semantic_index_status",
+      description: "Reports semantic-search-indexer state: indexed path, file/term counts, and counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      riskTier: "safe",
+      icon: "index",
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          indexedPath: state.cachedPath,
+          fileCount: state.fileCount,
+          termCount: state.termCount,
+          bytesIndexed: state.bytesIndexed,
+          truncated: state.truncated,
+          counters: {
+            queries: state.queryCount,
+            reindexes: state.reindexCount
+          }
+        };
+      }
+    });
+    api.log.info("semantic-search-indexer plugin loaded", {
+      version: "0.1.0",
+      defaultLimit: cfg.defaultLimit,
+      maxFiles: cfg.maxFiles
+    });
+  },
+  teardown(api) {
+    const final = {
+      fileCount: state.fileCount,
+      termCount: state.termCount,
+      queries: state.queryCount,
+      reindexes: state.reindexCount
+    };
+    state.index = null;
+    state.cachedPath = null;
+    state.fileCount = 0;
+    state.termCount = 0;
+    state.bytesIndexed = 0;
+    state.truncated = false;
+    state.queryCount = 0;
+    state.reindexCount = 0;
+    api.log.info("semantic-search-indexer: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: `semantic-search-indexer: ${state.fileCount} file(s), ${state.termCount} term(s), ${state.queryCount} query(ies)`,
+      counters: {
+        fileCount: state.fileCount,
+        termCount: state.termCount,
+        bytesIndexed: state.bytesIndexed,
+        queries: state.queryCount,
+        reindexes: state.reindexCount
+      }
+    };
+  }
+};
+var semantic_search_indexer_default = plugin;
+
+export { semantic_search_indexer_default as default };

package/dist/shell-check.js

@@ -1,9 +1,19 @@
 import { execSync, execFileSync } from 'child_process';
 import { readdirSync, existsSync } from 'fs';
-import { join } from 'path';
+import { join, isAbsolute, resolve, relative } from 'path';
 
 // src/shell-check/index.ts
 var API_VERSION = "^0.1.10";
+function withinProject(p) {
+  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 MAX_PATH_LEN = 4096;
 var state = {
   /** Per-session invocation count. */
   invocationCount: 0,
@@ -17,7 +27,9 @@ function runShellCheck(files, severity, cwd) {
     try {
       execSync("shellcheck --version", { encoding: "utf-8", stdio: "ignore", windowsHide: true });
     } catch {
-      throw new Error("shellcheck is not installed. Install via: apt install shellcheck / brew install shellcheck");
+      throw new Error(
+        "shellcheck is not installed. Install via: apt install shellcheck / brew install shellcheck"
+      );
     }
   }
   const levelMap = {
@@ -94,7 +106,11 @@ var plugin = {
     type: "object",
     properties: {
       severity: { type: "string", enum: ["error", "warning", "info", "style"], default: "warning" },
-      severityThreshold: { type: "string", enum: ["error", "warning", "info", "style"], default: "warning" },
+      severityThreshold: {
+        type: "string",
+        enum: ["error", "warning", "info", "style"],
+        default: "warning"
+      },
       ignoredCodes: { type: "array", items: { type: "string" }, default: [] },
       autoScanOnBash: { type: "boolean", default: false }
     }
@@ -147,6 +163,25 @@ var plugin = {
         const pattern = inp.pattern ?? "";
         const severity = inp.severity ?? "warning";
         state.invocationCount += 1;
+        const pathIsSafe = (p) => typeof p === "string" && p.length > 0 && p.length <= MAX_PATH_LEN && withinProject(p);
+        if (!pathIsSafe(directory)) {
+          return {
+            ok: false,
+            error: `directory path is outside the project root: ${directory}`,
+            issues: [],
+            filesScanned: 0,
+            rejectedOutsideProject: true
+          };
+        }
+        if (files?.some((f) => !pathIsSafe(f))) {
+          return {
+            ok: false,
+            error: "one or more file paths are outside the project root",
+            issues: [],
+            filesScanned: 0,
+            rejectedOutsideProject: true
+          };
+        }
         let checkFiles;
         let scannedDirectories = false;
         if (files && files.length > 0) {

package/dist/smart-rename.d.ts

@@ -0,0 +1,26 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * smart-rename plugin — whole-word identifier rename inside a single source
+ * file using regex replacement.
+ *
+ * Tool registered:
+ * - smart_rename : Replace whole-word occurrences of oldName with newName.
+ *
+ * No hooks are registered.
+ *
+ * Config (`config.extensions['smart-rename']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "extensions": [".ts", ".tsx", ".js", ".jsx"]
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/smart-rename.js

@@ -0,0 +1,170 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { extname, resolve, isAbsolute, relative } from 'path';
+
+// src/smart-rename/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  renameCount: 0,
+  replacementCount: 0,
+  errorCount: 0
+};
+var DEFAULTS = {
+  enabled: true,
+  extensions: [".ts", ".tsx", ".js", ".jsx"]
+};
+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
+  };
+}
+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 toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function relativePath(p) {
+  return toPosix(relative(process.cwd(), p));
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function renameInContent(content, oldName, newName) {
+  const re = new RegExp(`\\b${escapeRegex(oldName)}\\b`, "g");
+  let replacements = 0;
+  const preview = content.replace(re, () => {
+    replacements++;
+    return newName;
+  });
+  return { preview, replacements };
+}
+var plugin = {
+  name: "smart-rename",
+  version: "0.1.0",
+  description: "Whole-word identifier rename inside a single source file",
+  apiVersion: API_VERSION,
+  capabilities: { tools: 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 allowed for renaming."
+      }
+    }
+  },
+  setup(api) {
+    state.renameCount = 0;
+    state.replacementCount = 0;
+    state.errorCount = 0;
+    const cfg = readConfig(api.config.extensions?.["smart-rename"]);
+    api.tools.register({
+      name: "smart_rename",
+      description: "Replace whole-word occurrences of an identifier in a source file. Returns a preview by default; set apply:true to write the result back to disk.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string", description: "Source file path (relative to project root)." },
+          oldName: { type: "string", description: "Identifier to replace." },
+          newName: { type: "string", description: "New identifier." },
+          apply: { type: "boolean", default: false, description: "When true, write the preview back to disk." }
+        },
+        required: ["path", "oldName", "newName"]
+      },
+      permission: "auto",
+      category: "Development",
+      mutating: true,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "smart-rename is disabled" };
+        const rawPath = input.path;
+        const oldName = input.oldName;
+        const newName = input.newName;
+        if (!rawPath || typeof rawPath !== "string") {
+          return { ok: false, error: "path is required" };
+        }
+        if (!oldName || typeof oldName !== "string" || oldName.length === 0) {
+          return { ok: false, error: "oldName is required" };
+        }
+        if (!newName || typeof newName !== "string" || newName.length === 0) {
+          return { ok: false, error: "newName is required" };
+        }
+        if (!withinProject(rawPath)) {
+          return { ok: false, error: "path is outside the project root" };
+        }
+        const ext = extname(rawPath).toLowerCase();
+        if (!cfg.extensions.includes(ext)) {
+          return { ok: false, error: `extension ${ext} is not allowed for rename` };
+        }
+        const resolved = resolve(process.cwd(), rawPath);
+        let content;
+        try {
+          content = readFileSync(resolved, "utf-8");
+        } catch (err) {
+          state.errorCount += 1;
+          return { ok: false, error: String(err) };
+        }
+        const { preview, replacements } = renameInContent(content, oldName, newName);
+        state.renameCount += 1;
+        state.replacementCount += replacements;
+        if (input.apply) {
+          try {
+            writeFileSync(resolved, preview, "utf-8");
+          } catch (err) {
+            state.errorCount += 1;
+            return { ok: false, error: String(err) };
+          }
+        }
+        return {
+          ok: true,
+          path: relativePath(resolved),
+          replacements,
+          preview,
+          applied: Boolean(input.apply)
+        };
+      }
+    });
+    api.log.info("smart-rename plugin loaded", {
+      version: "0.1.0",
+      extensions: cfg.extensions
+    });
+  },
+  teardown(api) {
+    const final = {
+      renames: state.renameCount,
+      replacements: state.replacementCount,
+      errors: state.errorCount
+    };
+    state.renameCount = 0;
+    state.replacementCount = 0;
+    state.errorCount = 0;
+    api.log.info("smart-rename: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.errorCount === 0,
+      message: state.errorCount ? `smart-rename: ${state.errorCount} error(s)` : `smart-rename: ${state.renameCount} rename(s), ${state.replacementCount} replacement(s)`,
+      counters: {
+        renames: state.renameCount,
+        replacements: state.replacementCount,
+        errors: state.errorCount
+      }
+    };
+  }
+};
+var smart_rename_default = plugin;
+
+export { smart_rename_default as default };