@wrongstack/plugins 0.286.0 → 0.289.0

package/dist/interface-contract-guard/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interface-contract-guard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAQ/C,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAwLD,QAAA,MAAM,MAAM,EAAE,MAuMb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interface-contract-guard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAS/C,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAqID,QAAA,MAAM,MAAM,EAAE,MAuMb,CAAC;eAEa,MAAM"}

package/dist/interface-contract-guard.js

@@ -1,55 +1,37 @@
 // src/interface-contract-guard/index.ts
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { extname, isAbsolute, relative, resolve } from "node:path";
-var API_VERSION = "^0.1.10";
-var state = {
-  scanCount: 0,
-  findingCount: 0,
-  hookInvocationCount: 0,
-  warningCount: 0,
-  errorCount: 0,
-  hookUnregister: null
-};
-var DEFAULTS = {
-  enabled: false,
-  extensions: [".ts", ".tsx"],
-  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,
-    maxFindings: typeof r["maxFindings"] === "number" && r["maxFindings"] >= 1 && r["maxFindings"] <= 500 ? r["maxFindings"] : DEFAULTS.maxFindings
-  };
+import { readFileSync } from "node:fs";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
+
+// src/runtime/index.ts
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+function hasLeadingDash(arg) {
+  return arg.length > 0 && arg.startsWith("-");
 }
-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 withinProjectPath(projectRoot, candidate) {
+  if (candidate.length === 0 || candidate.length > 4096) return false;
+  if (hasLeadingDash(candidate)) return false;
+  const resolved = isAbsolute(candidate) ? resolve(candidate) : resolve(projectRoot, candidate);
+  const rel = relative(projectRoot, resolved);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
 }
-function matchesExtension(p, exts) {
-  return exts.includes(extname(p).toLowerCase());
+function withinProject(p) {
+  return withinProjectPath(process.cwd(), p) || relative(process.cwd(), p) === ".";
 }
-function collectSourceFiles(root, exts) {
+var DEFAULT_EXCLUDE_DIRS = ["node_modules", "dist", ".git", "coverage"];
+function collectSourceFiles(root, opts) {
   const files = [];
   if (!existsSync(root)) return files;
   const s = statSync(root);
   if (s.isFile()) {
-    if (matchesExtension(root, exts)) files.push(root);
+    if (matchesExtension(root, opts.extensions)) files.push(root);
     return files;
   }
   if (!s.isDirectory()) return files;
-  function walk(dir) {
+  const exclude = opts.excludeDirs ?? DEFAULT_EXCLUDE_DIRS;
+  function walk(dir, depth) {
+    if (opts.maxDepth !== void 0 && depth > opts.maxDepth) return;
     let entries;
     try {
       entries = readdirSync(dir);
@@ -57,7 +39,7 @@ function collectSourceFiles(root, exts) {
       return;
     }
     for (const entry of entries) {
-      if (entry === "node_modules" || entry === "dist" || entry === ".git" || entry === "coverage") continue;
+      if (exclude.includes(entry)) continue;
       const full = resolve(dir, entry);
       let st;
       try {
@@ -66,20 +48,51 @@ function collectSourceFiles(root, exts) {
         continue;
       }
       if (st.isDirectory()) {
-        walk(full);
-      } else if (st.isFile() && matchesExtension(full, exts)) {
+        walk(full, depth + 1);
+      } else if (st.isFile() && matchesExtension(full, opts.extensions)) {
         files.push(full);
       }
     }
   }
-  walk(root);
+  walk(root, 0);
   return files;
 }
+function matchesExtension(p, exts) {
+  return exts.includes(extname(p).toLowerCase());
+}
+
+// src/interface-contract-guard/index.ts
+var API_VERSION = "^0.1.10";
+var state = {
+  scanCount: 0,
+  findingCount: 0,
+  hookInvocationCount: 0,
+  warningCount: 0,
+  errorCount: 0,
+  hookUnregister: null
+};
+var DEFAULTS = {
+  enabled: false,
+  extensions: [".ts", ".tsx"],
+  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,
+    maxFindings: typeof r["maxFindings"] === "number" && r["maxFindings"] >= 1 && r["maxFindings"] <= 500 ? r["maxFindings"] : DEFAULTS.maxFindings
+  };
+}
+function normalizeExtensions(exts) {
+  return exts.map((e) => e.startsWith(".") ? e.toLowerCase() : `.${e.toLowerCase()}`);
+}
 function toPosix(p) {
   return p.replace(/\\/g, "/");
 }
 function relativePath(p) {
-  return toPosix(relative(process.cwd(), p));
+  return toPosix(relative2(process.cwd(), p));
 }
 var INTERFACE_RE = /(?:export\s+)?interface\s+([A-Za-z_$][A-Za-z0-9_$]*)/g;
 function extractInterfaceNames(content) {
@@ -99,9 +112,9 @@ function hasImplementer(name, contents) {
 }
 function scanPath(rawPath, cfg) {
   const root = process.cwd();
-  const resolved = isAbsolute(rawPath) ? resolve(rawPath) : resolve(root, rawPath);
+  const resolved = isAbsolute2(rawPath) ? resolve2(rawPath) : resolve2(root, rawPath);
   const exts = normalizeExtensions(cfg.extensions);
-  const files = collectSourceFiles(resolved, exts);
+  const files = collectSourceFiles(resolved, { extensions: exts });
   const contents = [];
   for (const p of files) {
     try {
@@ -177,7 +190,7 @@ var plugin = {
       const exts = normalizeExtensions(cfg.extensions);
       if (!matchesExtension(sourcePath, exts)) return;
       state.hookInvocationCount += 1;
-      const resolved = resolve(process.cwd(), sourcePath);
+      const resolved = resolve2(process.cwd(), sourcePath);
       let content;
       try {
         content = readFileSync(resolved, "utf-8");
@@ -195,7 +208,7 @@ var plugin = {
 If you changed member shapes, search the project for implementers/\`satisfies\`/\`as\` usages and update them accordingly.`
       };
     };
-    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook, { background: true });
     api.tools.register({
       name: "check_interface_contracts",
       description: "Scan TypeScript files for interface declarations that have no visible implementer (implements / as / satisfies).",
@@ -225,7 +238,7 @@ If you changed member shapes, search the project for implementers/\`satisfies\`/
         state.findingCount += result.findings.length;
         return {
           ok: true,
-          path: relativePath(resolve(process.cwd(), rawPath)),
+          path: relativePath(resolve2(process.cwd(), rawPath)),
           scannedFiles: result.scannedFiles,
           findings: result.findings
         };

package/dist/lint-gate/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lint-gate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAMH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA6R/C,QAAA,MAAM,MAAM,EAAE,MA8Vb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lint-gate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAQH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAwU/C,QAAA,MAAM,MAAM,EAAE,MAwWb,CAAC;eAEa,MAAM"}

package/dist/lint-gate.js

@@ -1,8 +1,10 @@
 // src/lint-gate/index.ts
 import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 var API_VERSION = "^0.1.10";
 var state = {
   /** Total PreToolUse invocations. */
@@ -36,55 +38,74 @@ function readConfig(raw) {
     fixRules: Array.isArray(r["fixRules"]) ? r["fixRules"].filter((x) => typeof x === "string") : []
   };
 }
-function executable(command) {
-  return process.platform === "win32" && command === "npx" ? "npx.cmd" : command;
+var LINTER_PACKAGES = {
+  biome: "@biomejs/biome",
+  eslint: "eslint"
+};
+function isInside(parent, candidate) {
+  const rel = relative(parent, candidate);
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+function resolveLocalLinter(name, cwd) {
+  try {
+    const packageName = LINTER_PACKAGES[name];
+    const requireFromProject = createRequire(resolve(cwd, "package.json"));
+    const packagePath = requireFromProject.resolve(`${packageName}/package.json`);
+    const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+    const relativeBin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.[name] ?? Object.values(packageJson.bin ?? {})[0];
+    if (!relativeBin || isAbsolute(relativeBin)) return null;
+    const packageDir = dirname(packagePath);
+    const entry = resolve(packageDir, relativeBin);
+    if (!isInside(packageDir, entry)) return null;
+    return {
+      cmd: process.execPath,
+      args: name === "biome" ? [entry, "check", "--reporter=json"] : [entry, "--format=json"],
+      name
+    };
+  } catch {
+    return null;
+  }
 }
-function runCommand(command, args, timeoutMs, signal) {
-  return new Promise((resolve) => {
+function runCommand(command, args, timeoutMs, cwd, signal) {
+  return new Promise((resolveResult) => {
     try {
       execFile(
-        executable(command),
+        command,
         args,
         {
           encoding: "utf-8",
           timeout: timeoutMs,
-          cwd: process.cwd(),
+          cwd,
           windowsHide: true,
+          shell: false,
           maxBuffer: 2 * 1024 * 1024,
           ...signal ? { signal } : {}
         },
-        (error, stdout) => resolve({ stdout, error })
+        (error, stdout) => resolveResult({ stdout, error })
       );
     } catch (err) {
-      resolve({ stdout: "", error: err instanceof Error ? err : new Error(String(err)) });
+      resolveResult({ stdout: "", error: err instanceof Error ? err : new Error(String(err)) });
     }
   });
 }
-async function detectLinter(requested) {
-  const tryBiome = requested === "biome" || requested === "auto";
-  const tryEslint = requested === "eslint" || requested === "auto";
-  if (tryBiome) {
-    const probe = await runCommand("npx", ["biome", "--version"], 5e3);
-    if (!probe.error) {
-      return { cmd: "npx", args: ["biome", "check", "--reporter=json"], name: "biome" };
-    }
-  }
-  if (tryEslint) {
-    const probe = await runCommand("npx", ["eslint", "--version"], 5e3);
-    if (!probe.error) {
-      return { cmd: "npx", args: ["eslint", "--format=json"], name: "eslint" };
-    }
+async function detectLinter(requested, cwd) {
+  const candidates = requested === "auto" ? ["biome", "eslint"] : [requested];
+  for (const name of candidates) {
+    const linter = resolveLocalLinter(name, cwd);
+    if (!linter) continue;
+    const probe = await runCommand(linter.cmd, [linter.args[0], "--version"], 5e3, cwd);
+    if (!probe.error) return linter;
   }
   return null;
 }
-async function lintContent(content, filePath, linter, timeoutMs, signal) {
+async function lintContent(content, filePath, linter, timeoutMs, cwd, signal) {
   const ext = filePath.includes(".") ? filePath.slice(filePath.lastIndexOf(".")) : ".ts";
   const tmpDir = await mkdtemp(join(tmpdir(), "lint-gate-"));
   const tmpFile = join(tmpDir, `input${ext}`);
   try {
     await writeFile(tmpFile, content, "utf-8");
     const fullArgs = [...linter.args, tmpFile];
-    const result = await runCommand(linter.cmd, fullArgs, timeoutMs, signal);
+    const result = await runCommand(linter.cmd, fullArgs, timeoutMs, cwd, signal);
     if (signal.aborted) throw signal.reason;
     if (result.error && !result.stdout) return null;
     return parseLinterOutput(result.stdout, linter.name);
@@ -95,14 +116,14 @@ async function lintContent(content, filePath, linter, timeoutMs, signal) {
     await rm(tmpDir, { recursive: true, force: true }).catch(() => void 0);
   }
 }
-async function lintAndFix(content, filePath, linter, timeoutMs, signal) {
+async function lintAndFix(content, filePath, linter, timeoutMs, cwd, signal) {
   const ext = filePath.includes(".") ? filePath.slice(filePath.lastIndexOf(".")) : ".ts";
   const tmpDir = await mkdtemp(join(tmpdir(), "lint-gate-fix-"));
   const tmpFile = join(tmpDir, `input${ext}`);
   try {
     await writeFile(tmpFile, content, "utf-8");
-    const fixArgs = linter.name === "biome" ? ["biome", "check", "--write", tmpFile] : ["eslint", "--fix", tmpFile];
-    await runCommand(linter.cmd, fixArgs, timeoutMs, signal);
+    const fixArgs = linter.name === "biome" ? [linter.args[0], "check", "--write", tmpFile] : [linter.args[0], "--fix", tmpFile];
+    await runCommand(linter.cmd, fixArgs, timeoutMs, cwd, signal);
     if (signal.aborted) throw signal.reason;
     return await readFile(tmpFile, "utf-8");
   } catch {
@@ -203,7 +224,8 @@ var plugin = {
     state.hookUnregister = null;
     state.lastResult = null;
     const cfg = readConfig(api.config.extensions?.["lint-gate"]);
-    const linterReady = detectLinter(cfg.linter).then((linter) => {
+    const cwd = resolve(api.config.cwd ?? process.cwd());
+    const linterReady = detectLinter(cfg.linter, cwd).then((linter) => {
       if (!linter) {
         api.log.warn("lint-gate: no linter found (biome or eslint) \u2014 hook will be a no-op", {
           requested: cfg.linter
@@ -240,7 +262,14 @@ var plugin = {
       } else {
         return;
       }
-      const issues = await lintContent(content, filePath, linter, cfg.timeoutMs, runtime.signal);
+      const issues = await lintContent(
+        content,
+        filePath,
+        linter,
+        cfg.timeoutMs,
+        cwd,
+        runtime.signal
+      );
       if (issues === null) {
         state.linterErrorCount += 1;
         return;
@@ -280,6 +309,7 @@ ${summary}${truncated}`
             filePath,
             linter,
             cfg.timeoutMs,
+            cwd,
             runtime.signal
           );
           if (fixedContent !== content) {
@@ -318,6 +348,7 @@ ${remainingSummary}` : "")
               filePath,
               linter,
               cfg.timeoutMs,
+              cwd,
               runtime.signal
             );
             if (fixedNewStr !== newStr) {

package/dist/migration-planner/index.d.ts

@@ -4,7 +4,8 @@
  * The plugin reads a package CHANGELOG (project root or node_modules) and
  * produces a migration checklist with breaking changes and recommended steps
  * between two versions. If no changelog is available it returns a generic
- * migration guide.
+ * migration guide. Optional `api.llm` analysis stays separate from the
+ * deterministic facts and falls back to them on any invalid response.
  *
  * Tools registered:
  * - migration_plan   — produce a migration checklist for a package/version range
@@ -16,13 +17,22 @@
  * {
  *   "enabled": true,
  *   "changelogPaths": ["CHANGELOG.md"],
- *   "maxChars": 100_000
+ *   "maxChars": 100_000,
+ *   "useLlm": false,
+ *   "maxLlmChars": 20_000
  * }
  * ```
  *
  * @public
  */
 import type { Plugin } from '@wrongstack/core';
+export interface MigrationAiAnalysis {
+    summary: string;
+    riskLevel: 'low' | 'medium' | 'high' | 'unknown';
+    risks: string[];
+    additionalSteps: string[];
+    verificationSteps: string[];
+}
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/migration-planner/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migration-planner/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAmP/C,QAAA,MAAM,MAAM,EAAE,MAgOb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migration-planner/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAwP/C,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;IACjD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;AAwED,QAAA,MAAM,MAAM,EAAE,MA+Sb,CAAC;eAEa,MAAM"}