@wrongstack/plugins 0.281.3 → 0.282.1

package/dist/refactor-suggester.js

@@ -0,0 +1,382 @@
+import { readFileSync, existsSync, statSync, readdirSync } from 'fs';
+import { resolve, isAbsolute, relative, extname } from 'path';
+
+// src/refactor-suggester/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  scanCount: 0,
+  suggestionCount: 0,
+  hookInvocationCount: 0,
+  warningCount: 0,
+  errorCount: 0,
+  hookUnregister: null,
+  lastHookWarning: /* @__PURE__ */ new Map()
+};
+var DEFAULTS = {
+  enabled: false,
+  extensions: [".ts", ".tsx", ".js", ".jsx"],
+  maxSuggestions: 5,
+  rules: { longFunctionLines: 50, maxParams: 5, maxNesting: 3 }
+};
+function readRules(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS.rules };
+  const r = raw;
+  return {
+    longFunctionLines: typeof r["longFunctionLines"] === "number" && r["longFunctionLines"] >= 1 ? r["longFunctionLines"] : DEFAULTS.rules.longFunctionLines,
+    maxParams: typeof r["maxParams"] === "number" && r["maxParams"] >= 1 ? r["maxParams"] : DEFAULTS.rules.maxParams,
+    maxNesting: typeof r["maxNesting"] === "number" && r["maxNesting"] >= 1 ? r["maxNesting"] : DEFAULTS.rules.maxNesting
+  };
+}
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] === true,
+    extensions: Array.isArray(r["extensions"]) ? r["extensions"].filter((x) => typeof x === "string") : DEFAULTS.extensions,
+    maxSuggestions: typeof r["maxSuggestions"] === "number" && r["maxSuggestions"] >= 1 && r["maxSuggestions"] <= 500 ? r["maxSuggestions"] : DEFAULTS.maxSuggestions,
+    rules: readRules(r["rules"])
+  };
+}
+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 leadingIndentLevel(line) {
+  const leading = line.match(/^(\s*)/)?.[1] ?? "";
+  const tabs = leading.split("	").length - 1;
+  const spaces = leading.replace(/\t/g, "").length;
+  return tabs + Math.floor(spaces / 2);
+}
+function detectSmells(filePath, content, rules) {
+  const suggestions = [];
+  const lines = content.split(/\r?\n/);
+  const stripped = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, " ");
+  const functionLikeRe = /(?:export\s+)?(?:async\s+)?(?:function\s+)?([A-Za-z_$][A-Za-z0-9_$]*)\s*\(([^)]*)\)\s*\{/g;
+  let m;
+  functionLikeRe.lastIndex = 0;
+  while ((m = functionLikeRe.exec(stripped)) !== null) {
+    const name = m[1];
+    const paramsRaw = m[2];
+    const params = paramsRaw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    if (params.length > rules.maxParams) {
+      suggestions.push({
+        file: relativePath(filePath),
+        line: content.slice(0, m.index).split(/\r?\n/).length,
+        type: "many-parameters",
+        message: `${name} has ${params.length} parameters (limit ${rules.maxParams})`
+      });
+    }
+    const bodyStart = m.index + m[0].length;
+    let depth = 1;
+    let lineEnd = bodyStart;
+    for (let i = bodyStart; i < stripped.length && depth > 0; i++) {
+      const ch = stripped[i];
+      if (ch === "{") depth++;
+      if (ch === "}") depth--;
+      lineEnd = i;
+    }
+    const bodyLines = stripped.slice(bodyStart, lineEnd + 1).split(/\r?\n/).length;
+    if (bodyLines > rules.longFunctionLines) {
+      suggestions.push({
+        file: relativePath(filePath),
+        line: content.slice(0, m.index).split(/\r?\n/).length,
+        type: "long-function",
+        message: `${name} spans ~${bodyLines} lines (limit ${rules.longFunctionLines})`
+      });
+    }
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNo = i + 1;
+    const strippedLine = line.replace(/\/\/.*$/, "");
+    const level = leadingIndentLevel(line);
+    if (level > rules.maxNesting) {
+      suggestions.push({
+        file: relativePath(filePath),
+        line: lineNo,
+        type: "deep-nesting",
+        message: `indentation level ${level} exceeds ${rules.maxNesting}`
+      });
+    }
+    if (/\bconsole\.(log|warn|error)\b/.test(strippedLine)) {
+      suggestions.push({
+        file: relativePath(filePath),
+        line: lineNo,
+        type: "console-log",
+        message: "console.log/warn/error usage detected"
+      });
+    }
+  }
+  const magicRe = /\b-?\d+(?:\.\d+)?\b/g;
+  const allowed = /* @__PURE__ */ new Set(["0", "1", "-1", "2"]);
+  magicRe.lastIndex = 0;
+  while ((m = magicRe.exec(content)) !== null) {
+    const match = m[0];
+    if (allowed.has(match)) continue;
+    const before = content[m.index - 1];
+    const after = content[m.index + match.length];
+    if (before === "[" && after === "]") continue;
+    suggestions.push({
+      file: relativePath(filePath),
+      line: content.slice(0, m.index).split(/\r?\n/).length,
+      type: "magic-number",
+      message: `magic number ${match} should be a named constant`
+    });
+  }
+  return suggestions;
+}
+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 suggestions = [];
+  for (const p of files) {
+    try {
+      const content = readFileSync(p, "utf-8");
+      suggestions.push(...detectSmells(p, content, cfg.rules));
+      if (suggestions.length >= cfg.maxSuggestions) break;
+    } catch {
+    }
+  }
+  return { suggestions: suggestions.slice(0, cfg.maxSuggestions), scannedFiles: files.length };
+}
+var plugin = {
+  name: "refactor-suggester",
+  version: "0.1.0",
+  description: "Suggests refactoring opportunities using regex-based smell detection",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: false, description: "Master switch." },
+      extensions: {
+        type: "array",
+        items: { type: "string" },
+        default: [".ts", ".tsx", ".js", ".jsx"],
+        description: "File extensions to scan."
+      },
+      maxSuggestions: {
+        type: "number",
+        minimum: 1,
+        maximum: 500,
+        default: 20,
+        description: "Maximum suggestions returned per scan."
+      },
+      rules: {
+        type: "object",
+        properties: {
+          longFunctionLines: { type: "number", minimum: 1, default: 50 },
+          maxParams: { type: "number", minimum: 1, default: 5 },
+          maxNesting: { type: "number", minimum: 1, default: 3 }
+        }
+      }
+    }
+  },
+  setup(api) {
+    state.scanCount = 0;
+    state.suggestionCount = 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?.["refactor-suggester"]);
+    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 now = Date.now();
+      const lastWarning = state.lastHookWarning.get(sourcePath);
+      if (lastWarning !== void 0 && now - lastWarning < 6e4) return;
+      const resolved = resolve(process.cwd(), sourcePath);
+      let content;
+      try {
+        content = readFileSync(resolved, "utf-8");
+      } catch {
+        state.errorCount += 1;
+        return;
+      }
+      const suggestions = detectSmells(resolved, content, cfg.rules);
+      if (suggestions.length === 0) return;
+      state.warningCount += suggestions.length;
+      state.lastHookWarning.set(sourcePath, now);
+      return {
+        additionalContext: `\u{1F527} refactor-suggester: ${suggestions.length} suggestion(s) for ${sourcePath}. Run suggest_refactors for the full list.`,
+        contextAs: "separate"
+      };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "suggest_refactors",
+      description: "Scan source files for refactoring smells: long functions, deep nesting, many parameters, magic numbers, and console logging.",
+      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: "refactor-suggester 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.suggestionCount += result.suggestions.length;
+        return {
+          ok: true,
+          path: relativePath(resolve(process.cwd(), rawPath)),
+          scannedFiles: result.scannedFiles,
+          suggestions: result.suggestions,
+          rules: cfg.rules
+        };
+      }
+    });
+    api.tools.register({
+      name: "refactor_status",
+      description: "Reports refactor-suggester state: config + counters.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          extensions: cfg.extensions,
+          maxSuggestions: cfg.maxSuggestions,
+          rules: cfg.rules,
+          counters: {
+            scans: state.scanCount,
+            suggestions: state.suggestionCount,
+            hookInvocations: state.hookInvocationCount,
+            warnings: state.warningCount,
+            errors: state.errorCount
+          }
+        };
+      }
+    });
+    api.log.info("refactor-suggester plugin loaded", {
+      version: "0.1.0",
+      rules: cfg.rules,
+      extensions: cfg.extensions
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      scans: state.scanCount,
+      suggestions: state.suggestionCount,
+      hookInvocations: state.hookInvocationCount,
+      warnings: state.warningCount,
+      errors: state.errorCount
+    };
+    state.scanCount = 0;
+    state.suggestionCount = 0;
+    state.hookInvocationCount = 0;
+    state.warningCount = 0;
+    state.errorCount = 0;
+    state.lastHookWarning.clear();
+    api.log.info("refactor-suggester: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.errorCount === 0,
+      message: state.errorCount ? `refactor-suggester: ${state.errorCount} error(s)` : `refactor-suggester: ${state.scanCount} scan(s), ${state.suggestionCount} suggestion(s)`,
+      counters: {
+        scans: state.scanCount,
+        suggestions: state.suggestionCount,
+        hookInvocations: state.hookInvocationCount,
+        warnings: state.warningCount,
+        errors: state.errorCount
+      }
+    };
+  }
+};
+var refactor_suggester_default = plugin;
+
+export { refactor_suggester_default as default };

package/dist/release-notes-generator.d.ts

@@ -0,0 +1,27 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * release-notes-generator plugin — generates grouped release notes from git
+ * history using conventional-commit parsing.
+ *
+ * Tool registered:
+ * - generate_release_notes : Produce grouped notes between two refs.
+ *
+ * No hooks are registered.
+ *
+ * Config (`config.extensions['release-notes-generator']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "includeScope": true,
+ *   "defaultFrom": "latest-tag"
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/release-notes-generator.js

@@ -0,0 +1,209 @@
+import { execSync } from 'child_process';
+
+// src/release-notes-generator/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  generateCount: 0,
+  commitCount: 0,
+  errorCount: 0
+};
+var DEFAULTS = {
+  enabled: true,
+  includeScope: true,
+  defaultFrom: "latest-tag"
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    includeScope: r["includeScope"] !== false,
+    defaultFrom: typeof r["defaultFrom"] === "string" ? r["defaultFrom"] : DEFAULTS.defaultFrom
+  };
+}
+var CONVENTIONAL_TYPES = ["feat", "fix", "docs", "refactor", "perf", "test", "chore"];
+function parseConventionalCommit(subject) {
+  const match = subject.match(/^([a-z]+)(?:\(([^)]+)\))?!?:\s*(.+)$/);
+  if (!match) {
+    return { type: "uncategorized", scope: null, description: subject };
+  }
+  const rawType = match[1];
+  const scope = match[2] ?? null;
+  const description = match[3];
+  const type = CONVENTIONAL_TYPES.includes(rawType) ? rawType : "uncategorized";
+  return { type, scope, description };
+}
+function formatCommit(c, includeScope) {
+  let line = `- ${c.hash.slice(0, 7)}`;
+  if (includeScope && c.scope) {
+    line += ` [${c.scope}]`;
+  }
+  line += ` ${c.description}`;
+  return line;
+}
+function resolveFromRef(defaultFrom, inputFrom) {
+  if (inputFrom) return inputFrom;
+  if (defaultFrom === "latest-tag") {
+    try {
+      return execSync("git describe --tags --abbrev=0", { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+    } catch {
+      return "";
+    }
+  }
+  return defaultFrom;
+}
+function getCommits(from, to) {
+  const range = from ? `${from}..${to}` : to;
+  const output = execSync(`git log --pretty=format:'%H%x09%s' ${range}`, {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "ignore"]
+  });
+  if (!output.trim()) return [];
+  const commits = [];
+  for (const line of output.split(/\r?\n/)) {
+    const tab = line.indexOf("	");
+    if (tab === -1) continue;
+    const hash = line.slice(0, tab);
+    const subject = line.slice(tab + 1);
+    const parsed = parseConventionalCommit(subject);
+    commits.push({ hash, subject, ...parsed });
+  }
+  return commits;
+}
+function groupCommits(commits) {
+  const groups = {};
+  for (const c of commits) {
+    const key = c.type;
+    if (!groups[key]) groups[key] = [];
+    groups[key].push(c);
+  }
+  return groups;
+}
+function generateNotes(commits, includeScope) {
+  if (commits.length === 0) return "No commits found.";
+  const groups = groupCommits(commits);
+  const lines = [];
+  lines.push(`## Release Notes (${commits.length} commit${commits.length === 1 ? "" : "s"})`);
+  lines.push("");
+  const order = ["feat", "fix", "perf", "refactor", "docs", "test", "chore"];
+  for (const type of order) {
+    const list = groups[type];
+    if (!list || list.length === 0) continue;
+    lines.push(`### ${type}`);
+    for (const c of list) {
+      lines.push(formatCommit(c, includeScope));
+    }
+    lines.push("");
+  }
+  const uncategorized = groups["uncategorized"];
+  if (uncategorized && uncategorized.length > 0) {
+    lines.push("### Uncategorized");
+    for (const c of uncategorized) {
+      lines.push(formatCommit(c, includeScope));
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trim();
+}
+var plugin = {
+  name: "release-notes-generator",
+  version: "0.1.0",
+  description: "Generates grouped release notes from conventional commits between two git refs",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      includeScope: {
+        type: "boolean",
+        default: true,
+        description: "Include commit scopes in the formatted notes."
+      },
+      defaultFrom: {
+        type: "string",
+        default: "latest-tag",
+        description: 'Default starting ref when `from` is omitted. Use "latest-tag" to discover the most recent tag.'
+      }
+    }
+  },
+  setup(api) {
+    state.generateCount = 0;
+    state.commitCount = 0;
+    state.errorCount = 0;
+    const cfg = readConfig(api.config.extensions?.["release-notes-generator"]);
+    api.tools.register({
+      name: "generate_release_notes",
+      description: "Generate release notes by grouping conventional commits between two git refs. Defaults to the latest tag..HEAD.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          from: {
+            type: "string",
+            description: "Starting git ref (tag, commit, branch). Defaults to the configured defaultFrom."
+          },
+          to: {
+            type: "string",
+            default: "HEAD",
+            description: "Ending git ref."
+          }
+        }
+      },
+      permission: "auto",
+      category: "Development",
+      mutating: false,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "release-notes-generator is disabled" };
+        const toRef = typeof input.to === "string" ? input.to : "HEAD";
+        const fromRef = resolveFromRef(cfg.defaultFrom, input.from);
+        state.generateCount += 1;
+        let commits;
+        try {
+          commits = getCommits(fromRef, toRef);
+        } catch (err) {
+          state.errorCount += 1;
+          return { ok: false, error: String(err) };
+        }
+        state.commitCount += commits.length;
+        return {
+          ok: true,
+          from: fromRef || null,
+          to: toRef,
+          commitCount: commits.length,
+          notes: generateNotes(commits, cfg.includeScope)
+        };
+      }
+    });
+    api.log.info("release-notes-generator plugin loaded", {
+      version: "0.1.0",
+      defaultFrom: cfg.defaultFrom,
+      includeScope: cfg.includeScope
+    });
+  },
+  teardown(api) {
+    const final = {
+      generated: state.generateCount,
+      commits: state.commitCount,
+      errors: state.errorCount
+    };
+    state.generateCount = 0;
+    state.commitCount = 0;
+    state.errorCount = 0;
+    api.log.info("release-notes-generator: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.errorCount === 0,
+      message: state.errorCount ? `release-notes-generator: ${state.errorCount} error(s)` : `release-notes-generator: ${state.generateCount} generation(s), ${state.commitCount} commit(s)`,
+      counters: {
+        generated: state.generateCount,
+        commits: state.commitCount,
+        errors: state.errorCount
+      }
+    };
+  }
+};
+var release_notes_generator_default = plugin;
+
+export { release_notes_generator_default as default };

package/dist/schema-evolution-guard.d.ts

@@ -0,0 +1,42 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * schema-evolution-guard plugin — guards database/API schema changes.
+ *
+ * Registers a `PostToolUse` hook on `write|edit` that scans files matching
+ * schema-related patterns for destructive changes:
+ *
+ *   - DROP TABLE / DROP COLUMN (Prisma migrations, raw SQL)
+ *   - NOT NULL added without a default (SQL)
+ *   - Required field without a default (Prisma, TypeScript schema files)
+ *   - Required field added to an OpenAPI schema (YAML/JSON)
+ *
+ * When a destructive pattern is found the plugin either injects an
+ * `additionalContext` warning or blocks the tool, depending on `failSeverity`.
+ *
+ * Tools registered:
+ *   - schema_evolution_status : counters + config snapshot.
+ *
+ * Config (`config.extensions['schema-evolution-guard']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "failSeverity": "warn", // "warn" | "block"
+ *   "maxFindings": 5,
+ *   "filePatterns": [
+ *     "*.prisma",
+ *     "*migration*.sql",
+ *     "*openapi*.yaml",
+ *     "*openapi*.json",
+ *     "*schema*.ts"
+ *   ]
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };