@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/clients/file-utils.js

@@ -0,0 +1,706 @@
+import * as fs from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Minimatch } from "./deps/minimatch.js";
+import { detectFileRole } from "./file-role.js";
+import { FRESHNESS_CADENCE_MS } from "./freshness-cadence.js";
+import { isInSpawnTimeoutCooldown, noteSpawnTimeout } from "./spawn-timeout-cooldown.js";
+import { collectTrackedFiles, getTrackedFilesSnapshot } from "./git-tracked-ignore.js";
+import { getGlobalIgnorePatterns, getDmLensGlobalConfigPath } from "./lens-config.js";
+import { homeRelativePath, isExternalOrVendorFile, isUnderDir, normalizeEphemeralMapKey, normalizeFilePath, toProjectRelativePath } from "./path-utils.js";
+import { findDmLensConfigInDir, findDmLensProjectConfig, loadDmLensConfigInDir, loadDmLensProjectConfig } from "./project-lens-config.js";
+import { safeSpawnAsync } from "./safe-spawn.js";
+import { isPiOwnedTempPath, isEphemeralCheckoutRoot } from "./ephemeral-root.js";
+import { getProcessSingleton } from "./process-singletons.js";
+export function getProjectDataDir(cwd) {
+  const legacyProjectDir = path.join(cwd, ".dm-lens");
+  const configuredBase = process.env.PILENS_DATA_DIR?.trim();
+  const resolvedBase = projectDataBase();
+  const memoKey = `${resolvedBase}\x00${path.resolve(cwd)}`;
+  const cached = settledDataDirs.get(memoKey);
+  if (cached !== undefined)
+    return cached;
+  if (!configuredBase && fs.existsSync(legacyProjectDir)) {
+    return legacyProjectDir;
+  }
+  const canonical = canonicalProjectRoot(cwd);
+  const readable = projectDataDirReadableSlug(canonical.root);
+  const hash = projectDataDirRootHash(canonical.root);
+  const slug = `${readable || "default"}-${hash}`;
+  const base = isEphemeralCheckoutRoot(cwd) ? ephemeralDataBase(resolvedBase) : resolvedBase;
+  const dir = path.join(base, slug);
+  if (base !== resolvedBase && pendingDataDirMigrations.length < 32) {
+    pendingDataDirMigrations.push({ to: dir, outcome: "ephemeral" });
+  }
+  const settled = settleProjectDataDir(base, readable || "default", dir, memoKey, canonical.fallback);
+  return settled;
+}
+function projectDataBase() {
+  const configuredBase = process.env.PILENS_DATA_DIR?.trim();
+  return configuredBase || path.join(getGlobalDmLensDir(), "projects");
+}
+const EPHEMERAL_DATA_DIR_NAME = ".ephemeral";
+const EPHEMERAL_TOKEN_PATTERN = /^(\d+)-[0-9a-f]{8}$/;
+function ephemeralDataToken() {
+  return getProcessSingleton("project-data-ephemeral-token", 1, () => ({
+    token: `${process.pid}-${randomBytes(4).toString("hex")}`,
+    exitHook: false
+  }));
+}
+function ephemeralDataBase(resolvedBase) {
+  const state = ephemeralDataToken();
+  if (!state.exitHook) {
+    state.exitHook = true;
+    process.once("exit", removeEphemeralDataDirs);
+  }
+  return path.join(resolvedBase, EPHEMERAL_DATA_DIR_NAME, state.token);
+}
+export function removeEphemeralDataDirs() {
+  const dir = path.join(projectDataBase(), EPHEMERAL_DATA_DIR_NAME, ephemeralDataToken().token);
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch {}
+}
+export async function sweepDeadEphemeralDataDirs(options) {
+  const parent = path.join(projectDataBase(), EPHEMERAL_DATA_DIR_NAME);
+  let handle;
+  try {
+    handle = await fs.promises.opendir(parent);
+  } catch {
+    return 0;
+  }
+  let removed = 0;
+  try {
+    for (let i = 0;i < (options.maxEntries ?? 512); i++) {
+      const entry = await handle.read();
+      if (entry === null)
+        break;
+      const pid = entry.isDirectory() ? EPHEMERAL_TOKEN_PATTERN.exec(entry.name)?.[1] : undefined;
+      if (pid === undefined || options.isPidAlive(Number(pid)))
+        continue;
+      try {
+        await fs.promises.rm(path.join(parent, entry.name), {
+          recursive: true,
+          force: true
+        });
+        removed++;
+      } catch {}
+    }
+  } catch {} finally {
+    await handle.close().catch(() => {});
+  }
+  return removed;
+}
+function projectDataDirReadableSlug(canonicalRoot) {
+  const normalized = normalizeFilePath(canonicalRoot);
+  return normalized.replace(/^[a-z]:/i, "").replace(/\/+/g, "-").replace(/[^A-Za-z0-9-]/g, "").replace(/^-+/, "").replace(/-+$/, "");
+}
+function canonicalProjectRoot(cwd) {
+  const resolved = path.resolve(cwd);
+  try {
+    fs.realpathSync(resolved);
+  } catch {
+    return { root: resolved, fallback: true };
+  }
+  return { root: resolved, fallback: false };
+}
+function projectDataDirRootHash(canonicalRoot) {
+  return createHash("sha256").update(canonicalRoot).digest("hex").slice(0, 8);
+}
+const pendingDataDirMigrations = [];
+const settledDataDirs = new Map;
+export function resetProjectDataDirSessionState() {
+  pendingDataDirMigrations.splice(0);
+}
+function settleProjectDataDir(base, oldSlug, dir, memoKey, identityFallback) {
+  const oldDir = path.join(base, oldSlug);
+  const newExists = fs.existsSync(dir);
+  const oldExists = fs.existsSync(oldDir);
+  if (!oldExists) {
+    if (identityFallback && pendingDataDirMigrations.length < 32) {
+      pendingDataDirMigrations.push({
+        to: dir,
+        outcome: "identity-fallback"
+      });
+    }
+    settledDataDirs.set(memoKey, dir);
+    return dir;
+  }
+  if (!newExists) {
+    try {
+      fs.renameSync(oldDir, dir);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        if (fs.existsSync(dir)) {
+          settledDataDirs.set(memoKey, dir);
+          return dir;
+        }
+        if (fs.existsSync(oldDir))
+          return oldDir;
+        return dir;
+      }
+      if (pendingDataDirMigrations.length < 32) {
+        pendingDataDirMigrations.push({
+          to: dir,
+          outcome: "rename-failed"
+        });
+      }
+      settledDataDirs.set(memoKey, oldDir);
+      return oldDir;
+    }
+  }
+  settledDataDirs.set(memoKey, dir);
+  if (pendingDataDirMigrations.length < 32) {
+    pendingDataDirMigrations.push({
+      to: dir,
+      outcome: newExists ? "coexisting" : "renamed"
+    });
+  }
+  return dir;
+}
+export function drainProjectDataDirMigrations() {
+  return pendingDataDirMigrations.splice(0);
+}
+export function _resetProjectDataDirMemoForTests() {
+  settledDataDirs.clear();
+}
+export function displayProjectDataPath(cwd, ...segments) {
+  const absolute = path.resolve(getProjectDataDir(cwd), ...segments);
+  const absolutePosix = absolute.replace(/\\/g, "/");
+  const relative = toProjectRelativePath(absolute, cwd);
+  if (relative !== absolutePosix) {
+    return relative;
+  }
+  return homeRelativePath(absolutePosix);
+}
+export function getGlobalDmLensDir() {
+  const override = process.env.DM_LENS_HOME?.trim();
+  if (override)
+    return path.resolve(override);
+  return path.join(os.homedir(), ".dm-lens");
+}
+export function isDmLensInternalPath(filePath, projectRoot) {
+  const absolute = path.resolve(filePath);
+  const home = path.resolve(os.homedir());
+  const candidates = [
+    getGlobalDmLensDir(),
+    getProjectDataDir(projectRoot),
+    path.join(home, ".pi"),
+    path.join(home, ".dm-lens")
+  ];
+  if (candidates.some((dir) => isUnderDir(absolute, dir)))
+    return true;
+  if (isPiOwnedTempPath(absolute))
+    return true;
+  return false;
+}
+export const EXCLUDED_DIRS = [
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".turbo",
+  ".cache",
+  "target",
+  "out",
+  ".parcel-cache",
+  ".svelte-kit",
+  ".nuxt",
+  ".yarn",
+  ".pnpm-store",
+  ".gradle",
+  ".next",
+  ".dm-lens",
+  ".pi",
+  ".omp",
+  ".ruff_cache",
+  ".worktrees",
+  ".claude",
+  ".codex",
+  ".rescue",
+  ".agents",
+  ".gstack",
+  ".superpowers",
+  ".guardrails",
+  ".playwright-cli",
+  ".playwright-mcp",
+  ".vscode",
+  "venv",
+  ".venv",
+  "coverage",
+  "__pycache__",
+  ".tox",
+  ".pytest_cache",
+  "*.dSYM",
+  "vendor",
+  "third_party",
+  "third-party",
+  "vendors"
+];
+function resolveGitIgnoreRoot(startDir) {
+  const fallback = path.resolve(startDir);
+  let current = fallback;
+  while (true) {
+    if (fs.existsSync(path.join(current, ".git")))
+      return current;
+    const parent = path.dirname(current);
+    if (parent === current)
+      return fallback;
+    current = parent;
+  }
+}
+function collapseSlashes(value) {
+  let out = "";
+  let previousWasSlash = false;
+  for (const ch of value) {
+    if (ch === "/") {
+      if (!previousWasSlash)
+        out += ch;
+      previousWasSlash = true;
+      continue;
+    }
+    out += ch === "\\" ? "/" : ch;
+    previousWasSlash = false;
+  }
+  return out;
+}
+function stripLeadingDotSlash(value) {
+  return value.startsWith("./") ? value.slice(2) : value;
+}
+function stripTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/")
+    end -= 1;
+  return value.slice(0, end);
+}
+function stripLeadingSlashes(value) {
+  let start = 0;
+  while (start < value.length && value[start] === "/")
+    start += 1;
+  return value.slice(start);
+}
+function normalizeIgnorePath(value) {
+  return collapseSlashes(stripLeadingDotSlash(value));
+}
+function stripTrailingSpaces(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === " " && value[end - 2] !== "\\")
+    end -= 1;
+  return value.slice(0, end).replace(/\\ /g, " ");
+}
+function parseGitignoreContent(content, layer) {
+  const patterns = [];
+  for (const rawLine of content.split(/\r?\n/)) {
+    let line = stripTrailingSpaces(rawLine.trimStart());
+    if (!line || line.startsWith("#"))
+      continue;
+    let negated = false;
+    if (line.startsWith("!")) {
+      negated = true;
+      line = line.slice(1);
+    }
+    line = normalizeIgnorePath(line);
+    if (!line)
+      continue;
+    const directoryOnly = line.endsWith("/");
+    if (directoryOnly)
+      line = stripTrailingSlashes(line);
+    const rooted = line.startsWith("/");
+    if (rooted)
+      line = stripLeadingSlashes(line);
+    if (!line)
+      continue;
+    patterns.push({
+      pattern: line,
+      negated,
+      directoryOnly,
+      rooted,
+      hasSlash: line.includes("/"),
+      layer
+    });
+  }
+  return patterns;
+}
+function expandGitignorePattern(pattern) {
+  const body = pattern.pattern;
+  if (pattern.directoryOnly) {
+    if (pattern.rooted || pattern.hasSlash)
+      return [body, `${body}/**`];
+    return [body, `${body}/**`, `**/${body}`, `**/${body}/**`];
+  }
+  if (pattern.rooted || pattern.hasSlash)
+    return [body];
+  return [body, `**/${body}`];
+}
+function matchesGitignorePattern(pattern, relativePath, isDirectory, matchExpanded) {
+  const candidate = stripLeadingSlashes(normalizeIgnorePath(relativePath));
+  if (!candidate)
+    return false;
+  const candidates = isDirectory ? [candidate, `${candidate}/`] : [candidate];
+  return expandGitignorePattern(pattern).some((expanded) => {
+    if (isDirectory && expanded.endsWith("/**")) {
+      const prefix = expanded.slice(0, -3);
+      if (candidate === prefix || candidate.startsWith(`${prefix}/`))
+        return true;
+    }
+    return candidates.some((value) => matchExpanded(value, expanded));
+  });
+}
+function readGitignorePatterns(rootDir, layer = "gitignore") {
+  const gitignorePath = path.join(rootDir, ".gitignore");
+  try {
+    return parseGitignoreContent(fs.readFileSync(gitignorePath, "utf-8"), layer);
+  } catch {
+    return [];
+  }
+}
+function ancestorDirsBetween(rootDir, targetDir) {
+  const relative = path.relative(rootDir, targetDir);
+  if (relative.startsWith("..") || path.isAbsolute(relative))
+    return [];
+  const dirs = [rootDir];
+  if (!relative)
+    return dirs;
+  let current = rootDir;
+  for (const segment of relative.split(path.sep).filter(Boolean)) {
+    current = path.join(current, segment);
+    dirs.push(current);
+  }
+  return dirs;
+}
+function buildProjectIgnoreMatcher(resolvedRoot, patterns) {
+  const consumedIgnoreSources = new Map;
+  const rememberIgnoreSource = (filePath, signature = fileFreshnessSignature(filePath)) => {
+    consumedIgnoreSources.set(filePath, { path: filePath, ...signature });
+  };
+  rememberIgnoreSource(path.join(resolvedRoot, ".gitignore"));
+  const nestedCache = new Map;
+  const patternsForDir = (dir) => {
+    if (dir === resolvedRoot)
+      return patterns;
+    const cached = nestedCache.get(dir);
+    const now = Date.now();
+    if (cached !== undefined && now - cached.checkedAtMs < PROJECT_IGNORE_FRESHNESS_CADENCE_MS) {
+      return cached.patterns;
+    }
+    const gitignoreSig = gitignoreSignature(dir);
+    rememberIgnoreSource(path.join(dir, ".gitignore"), gitignoreSig);
+    const dmlensInfo = findDmLensConfigInDir(dir);
+    const dmlensMtime = dmlensInfo?.mtimeMs ?? -1;
+    const dmlensSize = dmlensInfo?.size ?? -1;
+    if (cached?.gitignoreMtimeMs === gitignoreSig.mtimeMs && cached?.gitignoreSize === gitignoreSig.size && cached?.dmlensMtimeMs === dmlensMtime && cached?.dmlensSize === dmlensSize) {
+      cached.checkedAtMs = now;
+      return cached.patterns;
+    }
+    const nestedConfig = loadDmLensConfigInDir(dir);
+    const nextPatterns = [
+      ...readGitignorePatterns(dir),
+      ...parseGitignoreContent(nestedConfig.ignore.join(`
+`), "dmlens")
+    ];
+    nestedCache.set(dir, {
+      checkedAtMs: now,
+      gitignoreMtimeMs: gitignoreSig.mtimeMs,
+      gitignoreSize: gitignoreSig.size,
+      dmlensMtimeMs: dmlensMtime,
+      dmlensSize,
+      patterns: nextPatterns
+    });
+    if (cached !== undefined)
+      dropVerdictsUnder(dir);
+    return nextPatterns;
+  };
+  const patternMemo = new Map;
+  function dropVerdictsUnder(subtree) {
+    const resolvedSubtree = path.resolve(subtree);
+    for (const key of patternMemo.keys()) {
+      const memoPath = key.slice(2);
+      const relative = path.relative(resolvedSubtree, memoPath);
+      if (!relative || !relative.startsWith("..") && !path.isAbsolute(relative)) {
+        patternMemo.delete(key);
+      }
+    }
+  }
+  const invalidateSubtree = (subtree) => {
+    dropVerdictsUnder(subtree);
+    nestedCache.delete(path.resolve(subtree));
+  };
+  const gitignoreGlobOptions = {
+    dot: true,
+    nocase: process.platform === "win32"
+  };
+  const compiledGlobs = new Map;
+  const matchExpanded = (value, expanded) => {
+    let compiled = compiledGlobs.get(expanded);
+    if (compiled === undefined) {
+      compiled = new Minimatch(expanded, gitignoreGlobOptions);
+      compiledGlobs.set(expanded, compiled);
+    }
+    return compiled.match(value);
+  };
+  function isTrackedAndRescued(resolved) {
+    const snapshot = getTrackedFilesSnapshot(resolvedRoot);
+    if (!snapshot)
+      return false;
+    return snapshot.has(normalizeEphemeralMapKey(resolved));
+  }
+  return {
+    rootDir: resolvedRoot,
+    patterns,
+    getConsumedIgnoreSources: () => [...consumedIgnoreSources.values()],
+    refreshConsumedIgnoreSource(filePath) {
+      if (consumedIgnoreSources.has(filePath))
+        rememberIgnoreSource(filePath);
+    },
+    invalidateSubtree,
+    ensureTrackedIndex() {
+      return collectTrackedFiles(resolvedRoot).then(() => {
+        return;
+      });
+    },
+    isIgnored(filePath, isDirectory = false) {
+      const resolved = path.resolve(filePath);
+      const memoKey = (isDirectory ? "D:" : "F:") + resolved;
+      let verdict = patternMemo.get(memoKey);
+      if (verdict === undefined) {
+        const rootRelative = path.relative(resolvedRoot, resolved);
+        if (!rootRelative || rootRelative.startsWith("..") || path.isAbsolute(rootRelative)) {
+          verdict = { ignored: false, layer: undefined };
+        } else {
+          let ignored = false;
+          let layer;
+          const patternDirs = ancestorDirsBetween(resolvedRoot, path.dirname(resolved));
+          for (const dir of patternDirs) {
+            const dirPatterns = patternsForDir(dir);
+            if (dirPatterns.length === 0)
+              continue;
+            const relative = path.relative(dir, resolved);
+            const normalized = normalizeIgnorePath(relative);
+            for (const pattern of dirPatterns) {
+              if (!matchesGitignorePattern(pattern, normalized, isDirectory, matchExpanded))
+                continue;
+              ignored = !pattern.negated;
+              layer = pattern.layer;
+            }
+          }
+          verdict = { ignored, layer };
+        }
+        patternMemo.set(memoKey, verdict);
+      }
+      if (!verdict.ignored)
+        return false;
+      if (!isDirectory && verdict.layer !== "dmlens" && isTrackedAndRescued(resolved)) {
+        return false;
+      }
+      return true;
+    }
+  };
+}
+export function createProjectIgnoreMatcher(rootDir, extraPatterns = [], globalPatterns = []) {
+  const resolvedRoot = resolveGitIgnoreRoot(rootDir);
+  const patterns = [
+    ...parseGitignoreContent(globalPatterns.join(`
+`), "global"),
+    ...readGitignorePatterns(resolvedRoot, "gitignore"),
+    ...parseGitignoreContent(extraPatterns.join(`
+`), "dmlens")
+  ];
+  return buildProjectIgnoreMatcher(resolvedRoot, patterns);
+}
+const projectIgnoreMatcherCache = new Map;
+export const PROJECT_IGNORE_FRESHNESS_CADENCE_MS = FRESHNESS_CADENCE_MS;
+function fileFreshnessSignature(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    return { mtimeMs: stat.mtimeMs, size: stat.size };
+  } catch {
+    return { mtimeMs: -1, size: -1 };
+  }
+}
+function globalConfigSignature() {
+  return fileFreshnessSignature(getDmLensGlobalConfigPath());
+}
+function gitignoreSignature(rootDir) {
+  return fileFreshnessSignature(path.join(rootDir, ".gitignore"));
+}
+function hasIgnoreSourceDrift(sources) {
+  return sources.some((source) => {
+    const current = fileFreshnessSignature(source.path);
+    return current.mtimeMs !== source.mtimeMs || current.size !== source.size;
+  });
+}
+function lensConfigInfo(rootDir) {
+  const info = findDmLensProjectConfig(rootDir);
+  return info ? { info, path: info.path, mtimeMs: info.mtimeMs, size: info.size } : { info, path: undefined, mtimeMs: -1, size: -1 };
+}
+export function getProjectIgnoreMatcher(rootDir) {
+  const resolvedRoot = resolveGitIgnoreRoot(rootDir);
+  const gitignoreSig = gitignoreSignature(resolvedRoot);
+  const lensConfig = lensConfigInfo(resolvedRoot);
+  const globalSig = globalConfigSignature();
+  const cached = projectIgnoreMatcherCache.get(resolvedRoot);
+  if (cached) {
+    const known = new Set(cached.ignoreSources.map((source) => source.path));
+    for (const source of cached.matcher.getConsumedIgnoreSources()) {
+      if (!known.has(source.path))
+        cached.ignoreSources.push(source);
+    }
+  }
+  if (cached && Date.now() - cached.lastIgnoreFreshnessCheckMs >= PROJECT_IGNORE_FRESHNESS_CADENCE_MS) {
+    cached.lastIgnoreFreshnessCheckMs = Date.now();
+    if (hasIgnoreSourceDrift(cached.ignoreSources)) {
+      for (const source of cached.ignoreSources) {
+        if (hasIgnoreSourceDrift([source])) {
+          const sourceIndex = cached.ignoreSources.findIndex((cachedSource) => cachedSource.path === source.path);
+          invalidateProjectIgnoreMatcherForPath(source.path);
+          cached.matcher.refreshConsumedIgnoreSource(source.path);
+          const refreshedSource = cached.matcher.getConsumedIgnoreSources().find((current) => current.path === source.path);
+          if (sourceIndex !== -1 && refreshedSource !== undefined) {
+            cached.ignoreSources.splice(sourceIndex, 1, refreshedSource);
+          }
+        }
+      }
+    }
+  }
+  if (cached?.gitignoreMtimeMs === gitignoreSig.mtimeMs && cached?.gitignoreSize === gitignoreSig.size && cached?.lensConfigPath === lensConfig.path && cached?.lensConfigMtimeMs === lensConfig.mtimeMs && cached?.lensConfigSize === lensConfig.size && cached?.globalConfigMtimeMs === globalSig.mtimeMs && cached?.globalConfigSize === globalSig.size) {
+    return cached.matcher;
+  }
+  const projectConfig = loadDmLensProjectConfig(resolvedRoot, lensConfig.info);
+  const matcher = createProjectIgnoreMatcher(resolvedRoot, projectConfig.ignore, getGlobalIgnorePatterns());
+  projectIgnoreMatcherCache.set(resolvedRoot, {
+    ignoreSources: [...matcher.getConsumedIgnoreSources()],
+    lastIgnoreFreshnessCheckMs: Date.now(),
+    gitignoreMtimeMs: gitignoreSig.mtimeMs,
+    gitignoreSize: gitignoreSig.size,
+    lensConfigPath: lensConfig.path,
+    lensConfigMtimeMs: lensConfig.mtimeMs,
+    lensConfigSize: lensConfig.size,
+    globalConfigMtimeMs: globalSig.mtimeMs,
+    globalConfigSize: globalSig.size,
+    matcher
+  });
+  return matcher;
+}
+export function invalidateProjectIgnoreMatcherForPath(filePath) {
+  const resolvedPath = path.resolve(filePath);
+  if (path.basename(resolvedPath).toLowerCase() !== ".gitignore")
+    return;
+  for (const [cachedRoot, cached] of projectIgnoreMatcherCache) {
+    if (!isUnderDir(resolvedPath, cachedRoot))
+      continue;
+    if (normalizeFilePath(resolvedPath) === normalizeFilePath(path.join(cachedRoot, ".gitignore"))) {
+      projectIgnoreMatcherCache.delete(cachedRoot);
+      continue;
+    }
+    cached.matcher.invalidateSubtree(path.dirname(resolvedPath));
+  }
+}
+export function isPathIgnoredByProject(filePath, rootDir, isDirectory = false) {
+  return getProjectIgnoreMatcher(rootDir).isIgnored(filePath, isDirectory);
+}
+export function isRecordableProjectPath(filePath, projectRoot) {
+  if (isPathIgnoredByProject(filePath, projectRoot, false))
+    return false;
+  if (isExternalOrVendorFile(filePath, projectRoot))
+    return false;
+  return true;
+}
+const projectIgnoreGlobsCache = new Map;
+export function getProjectIgnoreGlobs(rootDir) {
+  const resolvedRoot = path.resolve(rootDir);
+  const signature = gitignoreSignature(resolvedRoot);
+  const cached = projectIgnoreGlobsCache.get(resolvedRoot);
+  if (cached && cached.mtimeMs === signature.mtimeMs && cached.size === signature.size) {
+    return cached.globs;
+  }
+  const globs = readGitignorePatterns(resolvedRoot).filter((pattern) => !pattern.negated).flatMap((pattern) => expandGitignorePattern(pattern));
+  projectIgnoreGlobsCache.set(resolvedRoot, { ...signature, globs });
+  return globs;
+}
+export function readGitignoreDirs(rootDir) {
+  return readGitignorePatterns(rootDir).filter((entry) => !entry.negated && !entry.pattern.includes("*") && !entry.pattern.includes("?") && !entry.pattern.includes("[") && !entry.pattern.includes("/")).map((entry) => entry.pattern);
+}
+function globToRegExp(glob) {
+  const escaped = glob.replace(/\*+/g, "*").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+}
+export function isExcludedDirName(dirName, extraPatterns = []) {
+  const candidate = dirName.trim();
+  if (!candidate)
+    return false;
+  const patterns = [...EXCLUDED_DIRS, ...extraPatterns].map((p) => p.trim()).filter((p) => p.length > 0);
+  const candidateLower = candidate.toLowerCase();
+  for (const pattern of patterns) {
+    const patLower = pattern.toLowerCase();
+    if (!patLower.includes("*") && !patLower.includes("?")) {
+      if (candidateLower === patLower)
+        return true;
+      continue;
+    }
+    if (globToRegExp(pattern).test(candidate))
+      return true;
+  }
+  return false;
+}
+export function getExcludedDirGlobs() {
+  return EXCLUDED_DIRS.map((dir) => `**/${dir}/**`);
+}
+export function getKnipIgnorePatterns() {
+  return [
+    ...getExcludedDirGlobs(),
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.test.js",
+    "**/*.test.jsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "**/*.spec.js",
+    "**/*.spec.jsx",
+    "**/*.poc.test.ts",
+    "**/*.poc.test.tsx",
+    "**/__tests__/**",
+    "**/tests/**"
+  ];
+}
+export async function detectFileChangedAfterCommand(filePath, command, args, cwd, ignoreStatuses = []) {
+  let before = "";
+  try {
+    before = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return 0;
+  }
+  if (isInSpawnTimeoutCooldown(command))
+    return 0;
+  const result = await safeSpawnAsync(command, args, {
+    timeout: 30000,
+    cwd
+  });
+  if (result.error)
+    return 0;
+  if (result.failure === "timeout") {
+    noteSpawnTimeout({
+      tool: path.basename(command).replace(/\.[^.]+$/, ""),
+      command,
+      phase: "autofix",
+      durationMs: 30000,
+      teardown: result.timeoutTeardown
+    });
+    return 0;
+  }
+  if (result.status !== 0 && !ignoreStatuses.includes(result.status ?? -1)) {
+    return 0;
+  }
+  try {
+    const after = fs.readFileSync(filePath, "utf-8");
+    return before !== after ? 1 : 0;
+  } catch {
+    return 0;
+  }
+}
+export function isTestFile(filePath) {
+  if (detectFileRole(filePath) === "test")
+    return true;
+  const normalized = filePath.replace(/\\/g, "/");
+  return normalized.includes("test-utils") || normalized.startsWith("test-") || normalized.includes(".fixture.") || normalized.includes(".mock.");
+}