@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,630 +0,0 @@
-import * as fs from "node:fs";
-import { createHash } 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";
-export function getProjectDataDir(cwd) {
-  const legacyProjectDir = path.join(cwd, ".dm-lens");
-  const configuredBase = process.env.PILENS_DATA_DIR?.trim();
-  if (!configuredBase && fs.existsSync(legacyProjectDir)) {
-    return legacyProjectDir;
-  }
-  const base = configuredBase || path.join(getGlobalDmLensDir(), "projects");
-  const resolvedBase = base.trim();
-  const memoKey = `${resolvedBase}\x00${path.resolve(cwd)}`;
-  const cached = settledDataDirs.get(memoKey);
-  if (cached !== undefined)
-    return cached;
-  const canonical = canonicalProjectRoot(cwd);
-  const readable = projectDataDirReadableSlug(canonical.root);
-  const hash = projectDataDirRootHash(canonical.root);
-  const slug = `${readable || "default"}-${hash}`;
-  const dir = path.join(resolvedBase, slug);
-  const settled = settleProjectDataDir(resolvedBase, readable || "default", dir, memoKey, canonical.fallback);
-  return settled;
-}
-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 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.");
-}