@wrongstack/plugins 0.291.2 → 0.292.1

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/duplicate-code-detector/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAoM/C,QAAA,MAAM,MAAM,EAAE,MA8Qb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/duplicate-code-detector/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAiN/C,QAAA,MAAM,MAAM,EAAE,MAySb,CAAC;eAEa,MAAM"}

package/dist/duplicate-code-detector.js

@@ -1,5 +1,5 @@
 // src/duplicate-code-detector/index.ts
-import { readFileSync } from "node:fs";
+import { readFileSync, statSync as statSync2 } from "node:fs";
 import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
 
 // src/runtime/index.ts
@@ -70,7 +70,8 @@ var state = {
   warningCount: 0,
   errorCount: 0,
   hookUnregister: null,
-  lastHookWarning: /* @__PURE__ */ new Map()
+  lastHookWarning: /* @__PURE__ */ new Map(),
+  fileIndex: /* @__PURE__ */ new Map()
 };
 var DEFAULTS = {
   enabled: false,
@@ -218,6 +219,7 @@ var plugin = {
     state.warningCount = 0;
     state.errorCount = 0;
     state.lastHookWarning.clear();
+    state.fileIndex.clear();
     if (state.hookUnregister) {
       try {
         state.hookUnregister();
@@ -226,6 +228,27 @@ var plugin = {
       state.hookUnregister = null;
     }
     const cfg = readConfig(api.config.extensions?.["duplicate-code-detector"]);
+    function readCachedWindows(filePath, minLines) {
+      let st;
+      try {
+        st = statSync2(filePath);
+      } catch {
+        return null;
+      }
+      const cached = state.fileIndex.get(filePath);
+      if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+        return cached.windows;
+      }
+      let content;
+      try {
+        content = readFileSync(filePath, "utf-8");
+      } catch {
+        return null;
+      }
+      const windows = extractWindows(filePath, content, minLines);
+      state.fileIndex.set(filePath, { mtimeMs: st.mtimeMs, size: st.size, windows });
+      return windows;
+    }
     const hook = (input) => {
       if (!cfg.enabled) return;
       if (input.toolResult?.isError) return;
@@ -240,33 +263,27 @@ var plugin = {
       const lastWarning = state.lastHookWarning.get(sourcePath);
       if (lastWarning !== void 0 && now - lastWarning < 6e4) return;
       const changedFile = resolve2(process.cwd(), sourcePath);
-      let content;
-      try {
-        content = readFileSync(changedFile, "utf-8");
-      } catch {
+      const changedWindows = readCachedWindows(changedFile, cfg.minLines);
+      if (changedWindows === null) {
         state.errorCount += 1;
         return;
       }
-      const changedWindows = extractWindows(changedFile, content, cfg.minLines);
       if (changedWindows.length === 0) return;
       const projectRoot = resolve2(process.cwd());
-      let otherFiles;
+      let otherFilePaths;
       try {
-        const filePaths = collectSourceFiles(projectRoot, { extensions: cfg.extensions, excludeDirs: cfg.excludeDirs }).filter((p) => p !== changedFile);
-        otherFiles = /* @__PURE__ */ new Map();
-        for (const p of filePaths) {
-          try {
-            otherFiles.set(p, readFileSync(p, "utf-8"));
-          } catch {
-          }
-        }
+        otherFilePaths = collectSourceFiles(projectRoot, {
+          extensions: cfg.extensions,
+          excludeDirs: cfg.excludeDirs
+        }).filter((p) => p !== changedFile);
       } catch {
         state.errorCount += 1;
         return;
       }
       const existingWindows = [];
-      for (const [p, c] of otherFiles.entries()) {
-        existingWindows.push(...extractWindows(p, c, cfg.minLines));
+      for (const p of otherFilePaths) {
+        const w = readCachedWindows(p, cfg.minLines);
+        if (w !== null) existingWindows.push(...w);
       }
       const hits = [];
       for (const cw of changedWindows) {

package/dist/format-on-save/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/format-on-save/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA2N/C,QAAA,MAAM,MAAM,EAAE,MA2Ob,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/format-on-save/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA0P/C,QAAA,MAAM,MAAM,EAAE,MAuPb,CAAC;eAEa,MAAM"}

package/dist/format-on-save.js

@@ -1,6 +1,6 @@
 // src/format-on-save/index.ts
-import { execFileSync, execSync } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { access, stat } from "node:fs/promises";
 
 // src/runtime/index.ts
 import { basename, extname, isAbsolute, relative, resolve } from "node:path";
@@ -78,29 +78,46 @@ function evictExpired(ttlMs) {
     if (ts < cutoff) recentlyCovered.delete(path);
   }
 }
-function formatFile(filePath, timeoutMs) {
+async function formatFile(filePath, timeoutMs) {
   if (!withinProject(filePath)) return null;
-  if (!existsSync(filePath)) return null;
+  try {
+    await access(filePath);
+  } catch {
+    return null;
+  }
   let bytesBefore;
   try {
-    bytesBefore = statSync(filePath).size;
+    bytesBefore = (await stat(filePath)).size;
   } catch {
     return null;
   }
   try {
-    execFileSync("npx", ["biome", "format", "--write", filePath], {
-      encoding: "utf-8",
-      timeout: timeoutMs,
-      cwd: process.cwd(),
-      stdio: ["pipe", "pipe", "pipe"]
+    await new Promise((resolve2, reject) => {
+      execFile(
+        "npx",
+        ["biome", "format", "--write", filePath],
+        {
+          encoding: "utf-8",
+          timeout: timeoutMs,
+          cwd: process.cwd(),
+          windowsHide: true,
+          maxBuffer: 16 * 1024 * 1024
+        },
+        (err) => {
+          if (err) {
+            const e = err;
+            if (e.killed) return reject(err);
+          }
+          resolve2();
+        }
+      );
     });
-  } catch (err) {
-    const e = err;
-    if (e.killed) return null;
+  } catch {
+    return null;
   }
   let bytesAfter;
   try {
-    bytesAfter = statSync(filePath).size;
+    bytesAfter = (await stat(filePath)).size;
   } catch {
     return null;
   }
@@ -108,11 +125,22 @@ function formatFile(filePath, timeoutMs) {
     return { changed: true, bytesBefore, bytesAfter };
   }
   try {
-    execFileSync("npx", ["biome", "format", filePath], {
-      encoding: "utf-8",
-      timeout: timeoutMs,
-      cwd: process.cwd(),
-      stdio: ["pipe", "pipe", "pipe"]
+    await new Promise((resolve2, reject) => {
+      execFile(
+        "npx",
+        ["biome", "format", filePath],
+        {
+          encoding: "utf-8",
+          timeout: timeoutMs,
+          cwd: process.cwd(),
+          windowsHide: true,
+          maxBuffer: 16 * 1024 * 1024
+        },
+        (err) => {
+          if (err) return reject(err);
+          resolve2();
+        }
+      );
     });
     return { changed: false, bytesBefore, bytesAfter };
   } catch {
@@ -153,7 +181,7 @@ var plugin = {
       }
     }
   },
-  setup(api) {
+  async setup(api) {
     clearRegistrations();
     state.invocationCount = 0;
     state.formattedCount = 0;
@@ -165,11 +193,21 @@ var plugin = {
     const cfg = readConfig(api.config.extensions?.["format-on-save"]);
     let biomeAvailable = false;
     try {
-      execSync("npx biome --version", {
-        encoding: "utf-8",
-        timeout: 5e3,
-        cwd: process.cwd(),
-        stdio: ["pipe", "pipe", "pipe"]
+      await new Promise((resolve2, reject) => {
+        execFile(
+          "npx",
+          ["biome", "--version"],
+          {
+            encoding: "utf-8",
+            timeout: 5e3,
+            cwd: process.cwd(),
+            windowsHide: true
+          },
+          (err) => {
+            if (err) reject(err);
+            else resolve2();
+          }
+        );
       });
       biomeAvailable = true;
       api.log.info("format-on-save: biome detected");
@@ -177,7 +215,7 @@ var plugin = {
       biomeAvailable = false;
       api.log.warn("format-on-save: biome not found \u2014 hook will be a no-op");
     }
-    const hook = (input) => {
+    const hook = async (input) => {
       if (!cfg.enabled || !biomeAvailable) return;
       if (input.toolResult?.isError) return;
       const toolName = input.toolName ?? "";
@@ -199,7 +237,7 @@ var plugin = {
         }
       }
       state.invocationCount += 1;
-      const result = formatFile(filePath, cfg.timeoutMs);
+      const result = await formatFile(filePath, cfg.timeoutMs);
       if (!result) {
         state.errorCount += 1;
         return;

package/dist/git-autocommit/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/git-autocommit/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AA+R/C,QAAA,MAAM,MAAM,EAAE,MAqXb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/git-autocommit/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAoT/C,QAAA,MAAM,MAAM,EAAE,MAsXb,CAAC;eAEa,MAAM"}

package/dist/git-autocommit.js

@@ -1,5 +1,5 @@
 // src/git-autocommit/index.ts
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import { existsSync } from "node:fs";
 var API_VERSION = "^0.1.10";
 var commitCount = { value: 0 };
@@ -7,31 +7,43 @@ var lastCommit = { hash: null, at: null };
 var llmGenerated = { value: 0 };
 var DEFAULT_GIT_TIMEOUT_MS = 3e4;
 var GIT_COMMIT_TIMEOUT_MS = 5 * 6e4;
-function runGit(args, cwd, timeoutMs = DEFAULT_GIT_TIMEOUT_MS) {
-  try {
-    return execFileSync("git", args, {
-      encoding: "utf-8",
-      cwd,
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: timeoutMs,
-      maxBuffer: 10 * 1024 * 1024,
-      windowsHide: true
-    }).trim();
-  } catch (err) {
-    const e = err;
-    throw new Error(`git command failed: ${e.message ?? e.stderr ?? String(err)}`);
-  }
+async function runGit(args, cwd, timeoutMs = DEFAULT_GIT_TIMEOUT_MS) {
+  return await new Promise((resolvePromise, rejectPromise) => {
+    execFile(
+      "git",
+      args,
+      {
+        encoding: "utf-8",
+        cwd,
+        windowsHide: true,
+        timeout: timeoutMs,
+        maxBuffer: 10 * 1024 * 1024
+      },
+      (err, stdout) => {
+        if (err) {
+          const e = err;
+          rejectPromise(
+            new Error(
+              `git command failed: ${e.message ?? e.stderr ?? String(err)}`
+            )
+          );
+          return;
+        }
+        resolvePromise(stdout.trim());
+      }
+    );
+  });
 }
-function getChangedFiles(cwd) {
-  const output = runGit(["status", "--porcelain"], cwd);
+async function getChangedFiles(cwd) {
+  const output = await runGit(["status", "--porcelain"], cwd);
   if (!output) return [];
   return output.split("\n").filter((l) => l.trim()).map((l) => l.slice(3).trim());
 }
-function getStagedFiles(cwd) {
-  const output = runGit(["diff", "--cached", "--name-only"], cwd);
+async function getStagedFiles(cwd) {
+  const output = await runGit(["diff", "--cached", "--name-only"], cwd);
   return output ? output.split("\n").filter(Boolean) : [];
 }
-function stageFiles(files, cwd) {
+async function stageFiles(files, cwd) {
   if (!files || !Array.isArray(files)) return;
   const existing = files.filter((f) => {
     try {
@@ -41,14 +53,14 @@ function stageFiles(files, cwd) {
     }
   });
   if (existing.length === 0) throw new Error("No files exist to stage");
-  runGit(["add", ...existing], cwd);
+  await runGit(["add", ...existing], cwd);
 }
-function commitWithMessage(message, cwd) {
-  return runGit(["commit", "-m", message], cwd, GIT_COMMIT_TIMEOUT_MS);
+async function commitWithMessage(message, cwd) {
+  return await runGit(["commit", "-m", message], cwd, GIT_COMMIT_TIMEOUT_MS);
 }
-function getWorktrees(cwd) {
+async function getWorktrees(cwd) {
   try {
-    const out = runGit(["worktree", "list", "--porcelain"], cwd);
+    const out = await runGit(["worktree", "list", "--porcelain"], cwd);
     if (!out) return [];
     const entries = [];
     let current = {};
@@ -68,18 +80,18 @@ function getWorktrees(cwd) {
     return [];
   }
 }
-function simultaneousEditWarning(cwd) {
-  const worktrees = getWorktrees(cwd);
+async function simultaneousEditWarning(cwd) {
+  const worktrees = await getWorktrees(cwd);
   if (worktrees.length > 1) {
     const otherBranches = worktrees.filter((wt) => wt.branch).map((wt) => wt.branch.replace("refs/heads/", ""));
     return `\u26A0 Simultaneous edits detected: ${worktrees.length} active worktrees (${otherBranches.join(", ")}). Changes from other agents may mix into this commit. Consider using worktree isolation or verifying the diff below before committing.`;
   }
   return null;
 }
-function getStagedDiff(cwd) {
+async function getStagedDiff(cwd) {
   try {
-    const stat = runGit(["diff", "--cached", "--stat"], cwd);
-    const diff = runGit(["diff", "--cached"], cwd);
+    const stat = await runGit(["diff", "--cached", "--stat"], cwd);
+    const diff = await runGit(["diff", "--cached"], cwd);
     const MAX_DIFF = 2e4;
     const truncated = diff.length > MAX_DIFF ? diff.slice(0, MAX_DIFF) + "\n\n... (diff truncated)" : diff;
     return { stat: stat || "(no stat)", diff: truncated || "(clean)" };
@@ -87,9 +99,9 @@ function getStagedDiff(cwd) {
     return { stat: "(unavailable)", diff: "(unavailable)" };
   }
 }
-function externalChangesSinceStage(cwd) {
+async function externalChangesSinceStage(cwd) {
   try {
-    const out = runGit(["status", "--porcelain"], cwd);
+    const out = await runGit(["status", "--porcelain"], cwd);
     if (!out) return null;
     const unstaged = out.split("\n").filter((l) => l.trim()).filter((l) => {
       const idx = l[0] ?? " ";
@@ -264,7 +276,7 @@ var plugin = {
           }
           if (files && files.length > 0) {
             try {
-              stageFiles(files);
+              await stageFiles(files);
             } catch (err) {
               return {
                 ok: false,
@@ -274,20 +286,20 @@ var plugin = {
           }
           let staged = [];
           try {
-            staged = getStagedFiles();
+            staged = await getStagedFiles();
           } catch {
             staged = [];
           }
           if (staged.length === 0) {
             try {
-              const changed = getChangedFiles();
+              const changed = await getChangedFiles();
               if (changed.length > 0) {
                 try {
-                  stageFiles(changed);
+                  await stageFiles(changed);
                 } catch {
                 }
                 try {
-                  staged = getStagedFiles();
+                  staged = await getStagedFiles();
                 } catch {
                   staged = [];
                 }
@@ -295,7 +307,7 @@ var plugin = {
             } catch {
             }
           }
-          const { stat, diff: stagedDiff } = getStagedDiff();
+          const { stat, diff: stagedDiff } = await getStagedDiff();
           let generatedByLlm = false;
           if (wantGenerate && staged.length > 0) {
             const g = await generateCommitFromDiff(api, stat, stagedDiff);
@@ -341,8 +353,8 @@ var plugin = {
               error: "Nothing staged. Add files with git add or provide files input."
             };
           }
-          const worktreeWarn = simultaneousEditWarning();
-          const externalChanges = externalChangesSinceStage();
+          const worktreeWarn = await simultaneousEditWarning();
+          const externalChanges = await externalChangesSinceStage();
           let externalWarning = null;
           if (externalChanges && externalChanges.length > 0) {
             const preview = externalChanges.slice(0, 10).join(", ");
@@ -369,13 +381,13 @@ ${stagedDiff}
           let preCommitDiff = stagedDiff;
           let preCommitStat = stat;
           if (staged.length === 0) {
-            const fresh = getStagedDiff();
+            const fresh = await getStagedDiff();
             preCommitDiff = fresh.diff;
             preCommitStat = fresh.stat;
           }
           let hash = "";
           try {
-            hash = commitWithMessage(msg);
+            hash = await commitWithMessage(msg);
           } catch (err) {
             return {
               ok: false,