@wrongstack/plugins 0.295.0 → 0.296.2

package/dist/feature-flag-tracker.js

@@ -4,6 +4,11 @@ import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 }
 
 // src/runtime/index.ts
 import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+
+// src/runtime/local-bin.ts
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+
+// src/runtime/index.ts
 var MAX_BUFFER_BYTES = 16 * 1024 * 1024;
 function hasLeadingDash(arg) {
   return arg.length > 0 && arg.startsWith("-");
@@ -103,8 +108,14 @@ function relativePath(p) {
   return toPosix(relative2(process.cwd(), p));
 }
 function compilePatterns(patterns) {
-  const sources = [...DEFAULT_PATTERNS, ...patterns];
-  return sources.map((src) => new RegExp(src, "g"));
+  const out = [];
+  for (const src of [...DEFAULT_PATTERNS, ...patterns]) {
+    try {
+      out.push(new RegExp(src, "g"));
+    } catch {
+    }
+  }
+  return out;
 }
 function scanFile(filePath, content, patterns, maxFindings) {
   const usages = [];
@@ -135,15 +146,26 @@ async function scanPath(rawPath, cfg) {
   const files = await collectSourceFilesAsync(resolved, { extensions: exts });
   const patterns = compilePatterns(cfg.patterns);
   const usages = [];
+  let scannedFiles = 0;
+  let truncated = false;
   for (const p of files) {
     try {
       const content = await readFile(p, "utf-8");
+      scannedFiles += 1;
       usages.push(...scanFile(p, content, patterns, cfg.maxFindings));
-      if (usages.length >= cfg.maxFindings) break;
+      if (usages.length >= cfg.maxFindings) {
+        truncated = scannedFiles < files.length;
+        break;
+      }
     } catch {
     }
   }
-  return { usages: usages.slice(0, cfg.maxFindings), scannedFiles: files.length };
+  return {
+    usages: usages.slice(0, cfg.maxFindings),
+    scannedFiles,
+    discoveredFiles: files.length,
+    truncated
+  };
 }
 var plugin = {
   name: "feature-flag-tracker",
@@ -252,6 +274,10 @@ Make sure flag behavior is intentional and consider updating flag inventory/docs
           ok: true,
           path: relativePath(resolve2(process.cwd(), rawPath)),
           scannedFiles: result.scannedFiles,
+          discoveredFiles: result.discoveredFiles,
+          // Say so when the cap stopped the walk early: a partial scan
+          // that reports few findings must not read as a clean result.
+          truncated: result.truncated,
           usages: result.usages
         };
       }

package/dist/file-watcher/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/file-watcher/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAqErD,QAAA,MAAM,MAAM,EAAE,MA8Yb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/file-watcher/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAqErD,QAAA,MAAM,MAAM,EAAE,MA+Yb,CAAC;eAEa,MAAM"}

package/dist/file-watcher.js

@@ -80,13 +80,12 @@ 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)
-      );
+      const timer = setTimeout(() => {
+        debounceTimers.delete(key);
+        fn();
+      }, ms);
+      timer.unref?.();
+      debounceTimers.set(key, timer);
     }
     const autoIndex = api.config.extensions?.["file-watcher"]?.["autoIndex"] ?? false;
     const indexProjectRoot = api.config.extensions?.["file-watcher"]?.["indexProjectRoot"] ?? "";

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

@@ -28,6 +28,8 @@
  * @public
  */
 import type { Plugin } from '@wrongstack/core/types';
+/** Which formatter is currently in use — surfaced by health()/status. */
+export declare function activeFormatterLabel(): string | null;
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

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,wBAAwB,CAAC;AA0PrD,QAAA,MAAM,MAAM,EAAE,MAuPb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/format-on-save/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAmPrD,yEAAyE;AACzE,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,IAAI,CAEpD;AAsGD,QAAA,MAAM,MAAM,EAAE,MAsPb,CAAC;eAEa,MAAM"}

package/dist/format-on-save.js

@@ -1,9 +1,200 @@
 // src/format-on-save/index.ts
 import { execFile } from "node:child_process";
-import { access, stat } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { access, readFile, stat } from "node:fs/promises";
+
+// src/runtime/index.ts
+import { basename, extname as extname2, isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "node:path";
+
+// src/runtime/local-bin.ts
+import { createRequire } from "node:module";
+import { delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { accessSync, constants, readFileSync } from "node:fs";
+import { buildWin32CmdShimInvocation, resolveWin32Command } from "@wrongstack/tools/win32";
+function resolveExecInvocation(command, args = []) {
+  const resolved = resolveWin32Command(command);
+  const normalizedResolved = resolved.toLowerCase();
+  const needsShell = process.platform === "win32" && (normalizedResolved.endsWith(".cmd") || normalizedResolved.endsWith(".bat"));
+  if (needsShell) {
+    const shim = buildWin32CmdShimInvocation(resolved, args);
+    return { cmd: shim.command, args: shim.args, windowsVerbatimArguments: true };
+  }
+  return { cmd: resolved, args: [...args], windowsVerbatimArguments: false };
+}
+function findOnPath(cmd) {
+  if (!cmd) return null;
+  const exists = (p) => {
+    try {
+      accessSync(p, constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (cmd.includes("/") || cmd.includes("\\")) {
+    return exists(cmd) ? resolve(cmd) : null;
+  }
+  const suffixes = process.platform === "win32" && extname(cmd) === "" ? (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
+  for (const dir of (process.env["PATH"] ?? "").split(delimiter)) {
+    if (!dir) continue;
+    const base = join(dir, cmd);
+    for (const suffix of suffixes) {
+      const candidate = `${base}${suffix}`;
+      if (exists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function isInside(parent, candidate) {
+  const rel = relative(parent, candidate);
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+var binCache = /* @__PURE__ */ new Map();
+var BIN_CACHE_MAX = 64;
+var NEGATIVE_BIN_CACHE_TTL_MS = 5e3;
+function cachePut(key, value) {
+  while (binCache.size >= BIN_CACHE_MAX) {
+    const oldest = binCache.keys().next().value;
+    if (oldest === void 0) break;
+    binCache.delete(oldest);
+  }
+  binCache.set(key, { value, cachedAt: Date.now() });
+  return value;
+}
+function clearLocalBinCache() {
+  binCache.clear();
+}
+function resolveNodeBin(packageName, binName, cwd, extraArgs = []) {
+  const key = `${packageName}|${binName}|${cwd}`;
+  const cached = binCache.get(key);
+  if (cached !== void 0) {
+    if (cached.value !== null || Date.now() - cached.cachedAt < NEGATIVE_BIN_CACHE_TTL_MS) {
+      return cached.value === null ? null : { ...cached.value, args: [cached.value.entry, ...extraArgs] };
+    }
+    binCache.delete(key);
+  }
+  let resolved = null;
+  try {
+    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?.[binName] ?? Object.values(packageJson.bin ?? {})[0];
+    if (relativeBin && !isAbsolute(relativeBin)) {
+      const packageDir = dirname(packagePath);
+      const entry = resolve(packageDir, relativeBin);
+      if (isInside(packageDir, entry)) {
+        resolved = { cmd: process.execPath, args: [entry], entry };
+      }
+    }
+  } catch {
+    resolved = null;
+  }
+  cachePut(key, resolved);
+  return resolved === null ? null : { ...resolved, args: [resolved.entry, ...extraArgs] };
+}
+function resolveFirstNodeBin(candidates, cwd) {
+  for (const c of candidates) {
+    const hit = resolveNodeBin(c.packageName, c.binName, cwd, c.args ?? []);
+    if (hit) return { ...hit, packageName: c.packageName, binName: c.binName };
+  }
+  return null;
+}
+
+// src/runtime/bounded-map.ts
+var BoundedMap = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  ttlMs;
+  now;
+  /** Entries dropped to stay under `max`. Surfaced by plugin health(). */
+  evictions = 0;
+  constructor(options) {
+    const normalizedMax = Math.floor(options.max);
+    this.max = Number.isSafeInteger(normalizedMax) ? Math.max(1, normalizedMax) : 1;
+    this.ttlMs = options.ttlMs;
+    this.now = options.now ?? Date.now;
+  }
+  expired(entry) {
+    return this.ttlMs !== void 0 && this.now() - entry.storedAt > this.ttlMs;
+  }
+  get(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0) return void 0;
+    if (this.expired(entry)) {
+      this.map.delete(key);
+      return void 0;
+    }
+    this.map.delete(key);
+    this.map.set(key, entry);
+    return entry.value;
+  }
+  /**
+   * Read without promoting the key to most-recently-used. Use for
+   * diagnostics that must not perturb the eviction order.
+   */
+  peek(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0 || this.expired(entry)) return void 0;
+    return entry.value;
+  }
+  has(key) {
+    const entry = this.map.get(key);
+    if (entry === void 0) return false;
+    if (this.expired(entry)) {
+      this.map.delete(key);
+      return false;
+    }
+    return true;
+  }
+  set(key, value) {
+    this.map.delete(key);
+    this.map.set(key, { value, storedAt: this.now() });
+    while (this.map.size > this.max) {
+      const coldest = this.map.keys().next().value;
+      if (coldest === void 0) break;
+      this.map.delete(coldest);
+      this.evictions += 1;
+    }
+    return this;
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+  clear() {
+    this.map.clear();
+    this.evictions = 0;
+  }
+  get size() {
+    return this.map.size;
+  }
+  /** How many entries have been dropped to respect `max`, since the last clear. */
+  get evictionCount() {
+    return this.evictions;
+  }
+  /** Drop every expired entry. Cheap enough to call from a status tool. */
+  prune() {
+    if (this.ttlMs === void 0) return 0;
+    let removed = 0;
+    for (const [key, entry] of this.map) {
+      if (this.expired(entry)) {
+        this.map.delete(key);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+  /** Live (non-expired) entries, coldest first. */
+  *entries() {
+    for (const [key, entry] of this.map) {
+      if (!this.expired(entry)) yield [key, entry.value];
+    }
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
 
 // src/runtime/index.ts
-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("-");
@@ -11,13 +202,13 @@ function hasLeadingDash(arg) {
 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);
+  const resolved = isAbsolute2(candidate) ? resolve2(candidate) : resolve2(projectRoot, candidate);
+  const rel = relative2(projectRoot, resolved);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
 }
 function withinProject(p) {
   const cwd = process.cwd();
-  return withinProjectPath(cwd, p) || relative(cwd, p) === ".";
+  return withinProjectPath(cwd, p) || relative2(cwd, p) === ".";
 }
 
 // src/format-on-save/index.ts
@@ -56,7 +247,7 @@ function readConfig(raw) {
     skipTtlMs: typeof r["skipTtlMs"] === "number" && r["skipTtlMs"] >= 0 ? r["skipTtlMs"] : DEFAULTS.skipTtlMs
   };
 }
-var recentlyCovered = /* @__PURE__ */ new Map();
+var recentlyCovered = new BoundedMap({ max: 256 });
 function clearRegistrations() {
   if (state.hookUnregister) {
     try {
@@ -79,6 +270,55 @@ function evictExpired(ttlMs) {
     if (ts < cutoff) recentlyCovered.delete(path);
   }
 }
+var FORMATTERS = [
+  {
+    packageName: "@biomejs/biome",
+    binName: "biome",
+    writeArgs: ["format", "--write"],
+    label: "biome"
+  },
+  { packageName: "prettier", binName: "prettier", writeArgs: ["--write"], label: "prettier" },
+  { packageName: "dprint", binName: "dprint", writeArgs: ["fmt"], label: "dprint" }
+];
+var activeFormatter;
+function resetFormatter() {
+  activeFormatter = void 0;
+  clearLocalBinCache();
+}
+function resolveFormatter() {
+  if (activeFormatter !== void 0) return activeFormatter;
+  const cwd = process.cwd();
+  for (const f of FORMATTERS) {
+    const local = resolveNodeBinFor(f, cwd);
+    if (local) {
+      activeFormatter = local;
+      return local;
+    }
+  }
+  for (const f of FORMATTERS) {
+    const onPath = findOnPath(f.binName);
+    if (!onPath) continue;
+    activeFormatter = { cmd: onPath, args: [...f.writeArgs], label: f.label };
+    return activeFormatter;
+  }
+  activeFormatter = null;
+  return null;
+}
+function resolveNodeBinFor(f, cwd) {
+  const hit = resolveFirstNodeBin([{ packageName: f.packageName, binName: f.binName }], cwd);
+  if (!hit) return null;
+  return { cmd: hit.cmd, args: [...hit.args, ...f.writeArgs], label: f.label };
+}
+function activeFormatterLabel() {
+  return activeFormatter?.label ?? null;
+}
+async function sha256File(filePath) {
+  try {
+    return createHash("sha256").update(await readFile(filePath)).digest("hex");
+  } catch {
+    return null;
+  }
+}
 async function formatFile(filePath, timeoutMs) {
   if (!withinProject(filePath)) return null;
   try {
@@ -86,30 +326,40 @@ async function formatFile(filePath, timeoutMs) {
   } catch {
     return null;
   }
+  const formatter = resolveFormatter();
+  if (!formatter) return null;
   let bytesBefore;
   try {
     bytesBefore = (await stat(filePath)).size;
   } catch {
     return null;
   }
+  const hashBefore = await sha256File(filePath);
+  let invocation;
+  try {
+    invocation = resolveExecInvocation(formatter.cmd, [...formatter.args, filePath]);
+  } catch {
+    return null;
+  }
   try {
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve3, reject) => {
       execFile(
-        "npx",
-        ["biome", "format", "--write", filePath],
+        invocation.cmd,
+        invocation.args,
         {
           encoding: "utf-8",
           timeout: timeoutMs,
           cwd: process.cwd(),
           windowsHide: true,
-          maxBuffer: 16 * 1024 * 1024
+          maxBuffer: 16 * 1024 * 1024,
+          ...invocation.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}
         },
         (err) => {
           if (err) {
             const e = err;
             if (e.killed) return reject(err);
           }
-          resolve2();
+          resolve3();
         }
       );
     });
@@ -125,28 +375,11 @@ async function formatFile(filePath, timeoutMs) {
   if (bytesAfter !== bytesBefore) {
     return { changed: true, bytesBefore, bytesAfter };
   }
-  try {
-    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();
-        }
-      );
-    });
+  const hashAfter = await sha256File(filePath);
+  if (hashBefore === null || hashAfter === null) {
     return { changed: false, bytesBefore, bytesAfter };
-  } catch {
-    return { changed: true, bytesBefore, bytesAfter };
   }
+  return { changed: hashBefore !== hashAfter, bytesBefore, bytesAfter };
 }
 var plugin = {
   name: "format-on-save",
@@ -192,32 +425,18 @@ var plugin = {
     state.lastResult = null;
     recentlyCovered.clear();
     const cfg = readConfig(api.config.extensions?.["format-on-save"]);
-    let biomeAvailable = false;
-    try {
-      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");
-    } catch {
-      biomeAvailable = false;
-      api.log.warn("format-on-save: biome not found \u2014 hook will be a no-op");
+    resetFormatter();
+    const formatter = resolveFormatter();
+    const formatterAvailable = formatter !== null;
+    if (formatter) {
+      api.log.info(`format-on-save: ${formatter.label} detected`);
+    } else {
+      api.log.warn(
+        "format-on-save: no formatter found (biome, prettier, dprint) \u2014 hook will be a no-op"
+      );
     }
     const hook = async (input) => {
-      if (!cfg.enabled || !biomeAvailable) return;
+      if (!cfg.enabled || !formatterAvailable) return;
       if (input.toolResult?.isError) return;
       const toolName = input.toolName ?? "";
       const inp = input.toolInput ?? {};
@@ -278,7 +497,7 @@ var plugin = {
     );
     api.tools.register({
       name: "format_on_save_status",
-      description: "Reports format-on-save state: biome availability, and per-session formatted/clean/error/skipped counters.",
+      description: "Reports format-on-save state: which formatter is active, and per-session formatted/clean/error/skipped counters.",
       inputSchema: { type: "object", properties: {} },
       permission: "auto",
       category: "Code Quality",
@@ -287,7 +506,14 @@ var plugin = {
         return {
           ok: true,
           enabled: cfg.enabled,
-          biomeAvailable,
+          formatterAvailable,
+          formatter: activeFormatterLabel(),
+          /**
+           * Back-compat alias for the pre-multi-formatter status shape.
+           * Now accurate rather than assumed: true only when the resolved
+           * formatter really is biome.
+           */
+          biomeAvailable: activeFormatterLabel() === "biome",
           timeoutMs: cfg.timeoutMs,
           skipWhenCoveredBy: cfg.skipWhenCoveredBy,
           skipTtlMs: cfg.skipTtlMs,
@@ -305,11 +531,13 @@ var plugin = {
     api.log.info("format-on-save plugin loaded", {
       version: "0.1.0",
       enabled: cfg.enabled,
-      biomeAvailable
+      formatterAvailable,
+      formatter: activeFormatterLabel()
     });
   },
   teardown(api) {
     clearRegistrations();
+    resetFormatter();
     const final = {
       invocations: state.invocationCount,
       formatted: state.formattedCount,
@@ -343,5 +571,6 @@ var plugin = {
 };
 var format_on_save_default = plugin;
 export {
+  activeFormatterLabel,
   format_on_save_default as default
 };

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

@@ -10,6 +10,18 @@
  * - For status: use the built-in `git` tool with `command: "status"` or `command: "diff"`.
  */
 import type { Plugin } from '@wrongstack/core/types';
+/**
+ * Parse one `git status --porcelain` line into the path to stage.
+ *
+ * Two shapes the naive `line.slice(3)` got wrong:
+ *  - **Renames/copies** print `R  old -> new`. Slicing produced the literal
+ *    string `"old -> new"`, which matches no file on disk, so the rename was
+ *    dropped from the commit entirely. The path that must be staged is the
+ *    NEW one.
+ *  - **Quoted paths** (spaces, unicode, control chars) keep their quotes,
+ *    likewise matching nothing.
+ */
+export declare function parsePorcelainLine(line: string): string | null;
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

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,wBAAwB,CAAC;AAoTrD,QAAA,MAAM,MAAM,EAAE,MAsXb,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,wBAAwB,CAAC;AA+IrD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAW9D;AA2OD,QAAA,MAAM,MAAM,EAAE,MAsXb,CAAC;eAEa,MAAM"}

package/dist/git-autocommit.js

@@ -34,10 +34,63 @@ async function runGit(args, cwd, timeoutMs = DEFAULT_GIT_TIMEOUT_MS) {
     );
   });
 }
+function unquotePorcelainPath(raw) {
+  if (!raw.startsWith('"') || !raw.endsWith('"') || raw.length < 2) return raw;
+  const inner = raw.slice(1, -1);
+  const bytes = [];
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch !== "\\") {
+      for (const b of Buffer.from(ch, "utf8")) bytes.push(b);
+      continue;
+    }
+    const next = inner[i + 1];
+    if (next === void 0) {
+      bytes.push(92);
+      break;
+    }
+    const simple = {
+      n: 10,
+      t: 9,
+      r: 13,
+      a: 7,
+      b: 8,
+      f: 12,
+      v: 11,
+      '"': 34,
+      "\\": 92
+    };
+    const mapped = simple[next];
+    if (mapped !== void 0) {
+      bytes.push(mapped);
+      i += 1;
+      continue;
+    }
+    const octal = /^[0-7]{1,3}/.exec(inner.slice(i + 1));
+    if (octal) {
+      bytes.push(Number.parseInt(octal[0], 8) & 255);
+      i += octal[0].length;
+      continue;
+    }
+    for (const b of Buffer.from(next, "utf8")) bytes.push(b);
+    i += 1;
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+function parsePorcelainLine(line) {
+  const body = line.slice(3);
+  if (!body) return null;
+  const status = line.slice(0, 2);
+  if (status.includes("R") || status.includes("C")) {
+    const arrow = body.lastIndexOf(" -> ");
+    if (arrow !== -1) return unquotePorcelainPath(body.slice(arrow + 4).trim());
+  }
+  return unquotePorcelainPath(body.trim());
+}
 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());
+  return output.split("\n").filter((l) => l.trim()).map((l) => parsePorcelainLine(l)).filter((p) => p !== null && p.length > 0);
 }
 async function getStagedFiles(cwd) {
   const output = await runGit(["diff", "--cached", "--name-only"], cwd);
@@ -53,7 +106,7 @@ async function stageFiles(files, cwd) {
     }
   });
   if (existing.length === 0) throw new Error("No files exist to stage");
-  await runGit(["add", ...existing], cwd);
+  await runGit(["add", "--", ...existing], cwd);
 }
 async function commitWithMessage(message, cwd) {
   return await runGit(["commit", "-m", message], cwd, GIT_COMMIT_TIMEOUT_MS);
@@ -106,7 +159,7 @@ async function externalChangesSinceStage(cwd) {
     const unstaged = out.split("\n").filter((l) => l.trim()).filter((l) => {
       const idx = l[0] ?? " ";
       return idx === " " || idx === "?";
-    }).map((l) => l.slice(3).trim());
+    }).map((l) => parsePorcelainLine(l)).filter((p) => p !== null && p.length > 0);
     return unstaged.length > 0 ? unstaged : null;
   } catch {
     return null;
@@ -470,5 +523,6 @@ ${preCommitDiff}
 };
 var git_autocommit_default = plugin;
 export {
-  git_autocommit_default as default
+  git_autocommit_default as default,
+  parsePorcelainLine
 };

package/dist/import-organizer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/import-organizer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAoRrD,QAAA,MAAM,MAAM,EAAE,MA8Nb,CAAC;eAEa,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/import-organizer/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAiXrD,QAAA,MAAM,MAAM,EAAE,MA8Nb,CAAC;eAEa,MAAM"}