@getcodesentinel/codesentinel 1.17.0 → 1.17.1

package/dist/index.js

@@ -7,6 +7,12 @@ import { Command, Option } from "commander";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { setTimeout as sleep } from "timers/promises";
+import { join as join4 } from "path";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { createHash } from "crypto";
+import { mkdir, readdir, readFile, rename, stat, unlink, writeFile } from "fs/promises";
+import { join as join3 } from "path";
 var round4 = (value) => Number(value.toFixed(4));
 var normalizeNodes = (nodes) => {
   const byName = /* @__PURE__ */ new Map();
@@ -614,6 +620,23 @@ var parseLockfileExtraction = (lockfileKind, lockfileRaw, directSpecs) => {
       throw new Error("unsupported_lockfile_format");
   }
 };
+var cachedFetch = async (options) => {
+  const nowMs = options.nowMs ?? Date.now();
+  const cachedEntry = options.cacheStore === null ? null : await options.cacheStore.get(options.key);
+  if (cachedEntry !== null && nowMs - cachedEntry.fetchedAtMs <= options.ttlMs) {
+    return cachedEntry.value;
+  }
+  try {
+    const fresh = await options.fetchFresh();
+    if (fresh !== null) {
+      void options.cacheStore?.set(options.key, { value: fresh, fetchedAtMs: nowMs }).catch(() => {
+      });
+      return fresh;
+    }
+  } catch {
+  }
+  return cachedEntry?.value ?? null;
+};
 var parseRetryAfterMs = (value) => {
   if (value === null) {
     return null;
@@ -640,8 +663,202 @@ var fetchJsonWithRetry = async (url, options) => {
   }
   return null;
 };
+var resolveCodesentinelCacheDir = (env = process.env) => {
+  const explicit = env["CODESENTINEL_CACHE_DIR"]?.trim();
+  if (explicit !== void 0 && explicit.length > 0) {
+    return explicit;
+  }
+  if (process.platform === "win32") {
+    const localAppData = env["LOCALAPPDATA"]?.trim();
+    if (localAppData !== void 0 && localAppData.length > 0) {
+      return join2(localAppData, "codesentinel", "Cache");
+    }
+    return join2(homedir(), "AppData", "Local", "codesentinel", "Cache");
+  }
+  const xdgCacheHome = env["XDG_CACHE_HOME"]?.trim();
+  if (xdgCacheHome !== void 0 && xdgCacheHome.length > 0) {
+    return join2(xdgCacheHome, "codesentinel");
+  }
+  return join2(homedir(), ".cache", "codesentinel");
+};
+var parseCacheEntryPayload = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const payload = value;
+  if (typeof payload.key !== "string" || payload.key.length === 0) {
+    return null;
+  }
+  if (typeof payload.fetchedAtMs !== "number" || !Number.isFinite(payload.fetchedAtMs)) {
+    return null;
+  }
+  return {
+    key: payload.key,
+    fetchedAtMs: payload.fetchedAtMs,
+    value: payload.value
+  };
+};
+var DEFAULT_OPTIONS = {
+  maxBytes: 100 * 1024 * 1024,
+  maxEntryBytes: 4 * 1024 * 1024,
+  sweepIntervalWrites: 25
+};
+var FileCacheStore = class {
+  constructor(directoryPath, options = DEFAULT_OPTIONS) {
+    this.directoryPath = directoryPath;
+    this.options = options;
+  }
+  byKey = /* @__PURE__ */ new Map();
+  inFlightWrites = /* @__PURE__ */ new Map();
+  writesSinceSweep = 0;
+  sweepPromise = Promise.resolve();
+  toEntryPath(key) {
+    const digest = createHash("sha256").update(key).digest("hex");
+    return join3(this.directoryPath, `${digest}.json`);
+  }
+  async writeEntry(key, entry) {
+    const filePath = this.toEntryPath(key);
+    await mkdir(this.directoryPath, { recursive: true });
+    const tempPath = `${filePath}.tmp`;
+    const payload = {
+      key,
+      fetchedAtMs: entry.fetchedAtMs,
+      value: entry.value
+    };
+    const raw = JSON.stringify(payload);
+    if (Buffer.byteLength(raw, "utf8") > this.options.maxEntryBytes) {
+      return;
+    }
+    await writeFile(tempPath, raw, "utf8");
+    await rename(tempPath, filePath);
+  }
+  async sweepIfNeeded() {
+    this.writesSinceSweep += 1;
+    if (this.writesSinceSweep < this.options.sweepIntervalWrites) {
+      return;
+    }
+    this.writesSinceSweep = 0;
+    this.sweepPromise = this.sweepPromise.catch(() => {
+    }).then(async () => {
+      await this.evictToSizeLimit();
+    });
+    await this.sweepPromise;
+  }
+  async evictToSizeLimit() {
+    let entries;
+    try {
+      const dirEntries = await readdir(this.directoryPath, { withFileTypes: true });
+      entries = (await Promise.all(
+        dirEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => {
+          const path = join3(this.directoryPath, entry.name);
+          const info = await stat(path);
+          return { path, size: info.size, mtimeMs: info.mtimeMs };
+        })
+      )).filter((entry) => Number.isFinite(entry.size) && entry.size > 0);
+    } catch {
+      return;
+    }
+    let totalBytes = entries.reduce((sum, entry) => sum + entry.size, 0);
+    if (totalBytes <= this.options.maxBytes) {
+      return;
+    }
+    entries.sort((a, b) => a.mtimeMs - b.mtimeMs);
+    for (const entry of entries) {
+      if (totalBytes <= this.options.maxBytes) {
+        break;
+      }
+      try {
+        await unlink(entry.path);
+        totalBytes -= entry.size;
+      } catch {
+      }
+    }
+  }
+  async get(key) {
+    if (this.byKey.has(key)) {
+      return this.byKey.get(key) ?? null;
+    }
+    try {
+      const raw = await readFile(this.toEntryPath(key), "utf8");
+      const parsed = parseCacheEntryPayload(JSON.parse(raw));
+      if (parsed === null || parsed.key !== key) {
+        this.byKey.set(key, null);
+        return null;
+      }
+      const value = { fetchedAtMs: parsed.fetchedAtMs, value: parsed.value };
+      this.byKey.set(key, value);
+      return value;
+    } catch {
+      this.byKey.set(key, null);
+      return null;
+    }
+  }
+  async set(key, entry) {
+    const normalized = entry;
+    this.byKey.set(key, normalized);
+    const previous = this.inFlightWrites.get(key) ?? Promise.resolve();
+    const next = previous.catch(() => {
+    }).then(async () => {
+      await this.writeEntry(key, normalized);
+      await this.sweepIfNeeded();
+    });
+    this.inFlightWrites.set(key, next);
+    await next;
+  }
+};
+var SIX_HOURS_MS = 6 * 60 * 60 * 1e3;
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
+var DEFAULT_MAX_ENTRY_BYTES = 4 * 1024 * 1024;
+var DEFAULT_SWEEP_INTERVAL_WRITES = 25;
+var cacheStoreSingleton;
+var parsePositiveIntegerFromEnv = (value, fallback) => {
+  if (value === void 0) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return parsed;
+};
+var cacheDisabled = (env) => {
+  const mode = env["CODESENTINEL_CACHE_MODE"]?.trim().toLowerCase();
+  return mode === "none";
+};
+var getNpmMetadataCacheStore = () => {
+  if (cacheStoreSingleton !== void 0) {
+    return cacheStoreSingleton;
+  }
+  if (cacheDisabled(process.env)) {
+    cacheStoreSingleton = null;
+    return cacheStoreSingleton;
+  }
+  const path = join4(resolveCodesentinelCacheDir(process.env), "npm-metadata-v2");
+  cacheStoreSingleton = new FileCacheStore(path, {
+    maxBytes: parsePositiveIntegerFromEnv(
+      process.env["CODESENTINEL_CACHE_MAX_BYTES"],
+      DEFAULT_MAX_BYTES
+    ),
+    maxEntryBytes: parsePositiveIntegerFromEnv(
+      process.env["CODESENTINEL_CACHE_MAX_ENTRY_BYTES"],
+      DEFAULT_MAX_ENTRY_BYTES
+    ),
+    sweepIntervalWrites: parsePositiveIntegerFromEnv(
+      process.env["CODESENTINEL_CACHE_SWEEP_INTERVAL_WRITES"],
+      DEFAULT_SWEEP_INTERVAL_WRITES
+    )
+  });
+  return cacheStoreSingleton;
+};
+var getPackumentCacheTtlMs = () => parsePositiveIntegerFromEnv(process.env["CODESENTINEL_CACHE_TTL_PACKUMENT_MS"], SIX_HOURS_MS);
+var getWeeklyDownloadsCacheTtlMs = () => parsePositiveIntegerFromEnv(process.env["CODESENTINEL_CACHE_TTL_DOWNLOADS_MS"], ONE_DAY_MS);
+var toMetadataPackumentCacheKey = (name) => `npm:packument:metadata:${name}`;
+var toGraphPackumentCacheKey = (name) => `npm:packument:graph:${name}`;
+var toWeeklyDownloadsCacheKey = (name) => `npm:downloads:last-week:${name}`;
 var MAX_RETRIES = 3;
 var RETRY_BASE_DELAY_MS = 500;
+var PACKUMENT_CACHE_STORE = getNpmMetadataCacheStore();
 var parsePrerelease = (value) => {
   if (value === void 0 || value.length === 0) {
     return [];
@@ -892,23 +1109,62 @@ var resolveRangeVersion = (versions, requested) => {
   }
   return null;
 };
+var slimPackumentForGraph = (payload) => {
+  const versions = payload.versions ?? {};
+  const dependenciesByVersion = {};
+  const versionNames = Object.keys(versions);
+  for (const [version2, manifest] of Object.entries(versions)) {
+    const dependenciesRaw = manifest?.dependencies ?? {};
+    const dependencies = {};
+    for (const [dependencyName, dependencyRange] of Object.entries(dependenciesRaw)) {
+      if (dependencyName.length > 0 && dependencyRange.length > 0) {
+        dependencies[dependencyName] = dependencyRange;
+      }
+    }
+    if (Object.keys(dependencies).length > 0) {
+      dependenciesByVersion[version2] = dependencies;
+    }
+  }
+  const slim = {
+    versionNames,
+    dependenciesByVersion
+  };
+  if (payload["dist-tags"] !== void 0) {
+    slim["dist-tags"] = payload["dist-tags"];
+  }
+  return slim;
+};
 var fetchPackument = async (name) => {
   const encodedName = encodeURIComponent(name);
   try {
-    return await fetchJsonWithRetry(`https://registry.npmjs.org/${encodedName}`, {
-      retries: MAX_RETRIES,
-      baseDelayMs: RETRY_BASE_DELAY_MS
+    return await cachedFetch({
+      key: toGraphPackumentCacheKey(name),
+      ttlMs: getPackumentCacheTtlMs(),
+      cacheStore: PACKUMENT_CACHE_STORE,
+      fetchFresh: async () => {
+        const payload = await fetchJsonWithRetry(
+          `https://registry.npmjs.org/${encodedName}`,
+          {
+            retries: MAX_RETRIES,
+            baseDelayMs: RETRY_BASE_DELAY_MS
+          }
+        );
+        if (payload === null) {
+          return null;
+        }
+        return slimPackumentForGraph(payload);
+      }
     });
   } catch {
     return null;
   }
 };
 var resolveRequestedVersion = (packument, requested) => {
-  const versions = packument.versions ?? {};
-  const versionKeys = Object.keys(versions);
+  const versionKeys = [...packument.versionNames];
+  const versionSet = new Set(versionKeys);
   const tags = packument["dist-tags"] ?? {};
   const latest = tags["latest"];
-  if (requested !== null && versions[requested] !== void 0) {
+  if (requested !== null && versionSet.has(requested)) {
     return {
       version: requested,
       resolution: "exact",
@@ -917,7 +1173,7 @@ var resolveRequestedVersion = (packument, requested) => {
   }
   if (requested !== null) {
     const tagged = tags[requested];
-    if (tagged !== void 0 && versions[tagged] !== void 0) {
+    if (tagged !== void 0 && versionSet.has(tagged)) {
       return {
         version: tagged,
         resolution: "tag",
@@ -927,7 +1183,7 @@ var resolveRequestedVersion = (packument, requested) => {
   }
   if (requested !== null) {
     const matched = resolveRangeVersion(versionKeys, requested);
-    if (matched !== null && versions[matched] !== void 0) {
+    if (matched !== null && versionSet.has(matched)) {
       return {
         version: matched,
         resolution: "range",
@@ -935,7 +1191,7 @@ var resolveRequestedVersion = (packument, requested) => {
       };
     }
   }
-  if (latest !== void 0 && versions[latest] !== void 0) {
+  if (latest !== void 0 && versionSet.has(latest)) {
     return {
       version: latest,
       resolution: "latest",
@@ -1016,8 +1272,8 @@ var resolveRegistryGraphFromDirectSpecs = async (directSpecs, options) => {
     if (nodesByKey.has(nodeKey)) {
       continue;
     }
-    const manifest = (packument.versions ?? {})[resolved.version] ?? {};
-    const dependencies = Object.entries(manifest.dependencies ?? {}).filter(
+    const manifestDependencies = packument.dependenciesByVersion[resolved.version] ?? {};
+    const dependencies = Object.entries(manifestDependencies).filter(
       ([dependencyName, dependencyRange]) => dependencyName.length > 0 && dependencyRange.length > 0
     ).sort((a, b) => a[0].localeCompare(b[0]));
     nodesByKey.set(nodeKey, {
@@ -1301,7 +1557,7 @@ var analyzeDependencyCandidate = async (input, metadataProvider) => {
     external
   };
 };
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var ONE_DAY_MS2 = 24 * 60 * 60 * 1e3;
 var MAX_RETRIES2 = 3;
 var RETRY_BASE_DELAY_MS2 = 500;
 var round42 = (value) => Number(value.toFixed(4));
@@ -1314,12 +1570,18 @@ var parseDate = (iso) => {
 };
 var NpmRegistryMetadataProvider = class {
   cache = /* @__PURE__ */ new Map();
+  cacheStore = getNpmMetadataCacheStore();
   async fetchWeeklyDownloads(name) {
     const encodedName = encodeURIComponent(name);
-    const payload = await fetchJsonWithRetry(
-      `https://api.npmjs.org/downloads/point/last-week/${encodedName}`,
-      { retries: MAX_RETRIES2, baseDelayMs: RETRY_BASE_DELAY_MS2 }
-    );
+    const payload = await cachedFetch({
+      key: toWeeklyDownloadsCacheKey(name),
+      ttlMs: getWeeklyDownloadsCacheTtlMs(),
+      cacheStore: this.cacheStore,
+      fetchFresh: async () => await fetchJsonWithRetry(
+        `https://api.npmjs.org/downloads/point/last-week/${encodedName}`,
+        { retries: MAX_RETRIES2, baseDelayMs: RETRY_BASE_DELAY_MS2 }
+      )
+    });
     if (payload === null) {
       return null;
     }
@@ -1336,10 +1598,31 @@ var NpmRegistryMetadataProvider = class {
     }
     try {
       const encodedName = encodeURIComponent(name);
-      const payload = await fetchJsonWithRetry(
-        `https://registry.npmjs.org/${encodedName}`,
-        { retries: MAX_RETRIES2, baseDelayMs: RETRY_BASE_DELAY_MS2 }
-      );
+      const payload = await cachedFetch({
+        key: toMetadataPackumentCacheKey(name),
+        ttlMs: getPackumentCacheTtlMs(),
+        cacheStore: this.cacheStore,
+        fetchFresh: async () => {
+          const fresh = await fetchJsonWithRetry(
+            `https://registry.npmjs.org/${encodedName}`,
+            {
+              retries: MAX_RETRIES2,
+              baseDelayMs: RETRY_BASE_DELAY_MS2
+            }
+          );
+          if (fresh === null) {
+            return null;
+          }
+          const slim = {};
+          if (fresh.time !== void 0) {
+            slim.time = fresh.time;
+          }
+          if (fresh.maintainers !== void 0) {
+            slim.maintainers = fresh.maintainers;
+          }
+          return slim;
+        }
+      });
       if (payload === null) {
         this.cache.set(key, null);
         return null;
@@ -1348,7 +1631,7 @@ var NpmRegistryMetadataProvider = class {
       const publishDates = Object.entries(timeEntries).filter(([tag]) => tag !== "created" && tag !== "modified").map(([, date]) => parseDate(date)).filter((value) => value !== null).sort((a, b) => a - b);
       const modifiedAt = parseDate(timeEntries["modified"]);
       const now = Date.now();
-      const daysSinceLastRelease = modifiedAt === null ? null : Math.max(0, round42((now - modifiedAt) / ONE_DAY_MS));
+      const daysSinceLastRelease = modifiedAt === null ? null : Math.max(0, round42((now - modifiedAt) / ONE_DAY_MS2));
       let releaseFrequencyDays = null;
       if (publishDates.length >= 2) {
         const totalIntervals = publishDates.length - 1;
@@ -1360,7 +1643,7 @@ var NpmRegistryMetadataProvider = class {
             sum += current - previous;
           }
         }
-        releaseFrequencyDays = round42(sum / totalIntervals / ONE_DAY_MS);
+        releaseFrequencyDays = round42(sum / totalIntervals / ONE_DAY_MS2);
       }
       const maintainers = payload.maintainers ?? [];
       const maintainerCount = maintainers.length > 0 ? maintainers.length : null;
@@ -1925,7 +2208,7 @@ var formatReport = (report, format) => {
 
 // ../governance/dist/index.js
 import { mkdirSync, rmSync } from "fs";
-import { basename, join as join2, resolve } from "path";
+import { basename, join as join5, resolve } from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var EXIT_CODES = {
@@ -2446,7 +2729,7 @@ var tryRunGit = async (repositoryPath, args) => {
   }
 };
 var buildWorktreePath = (repoRoot, sha) => {
-  const tmpRoot = join2(repoRoot, SENTINEL_TMP_DIR, WORKTREE_DIR);
+  const tmpRoot = join5(repoRoot, SENTINEL_TMP_DIR, WORKTREE_DIR);
   mkdirSync(tmpRoot, { recursive: true });
   const baseName = `baseline-${sha.slice(0, 12)}-${process.pid}`;
   const candidate = resolve(tmpRoot, baseName);
@@ -2538,7 +2821,7 @@ var resolveAutoBaselineRef = async (input) => {
 
 // src/index.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
 import { dirname as dirname2, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 
@@ -2931,13 +3214,13 @@ var parseLogLevel = (value) => {
 
 // src/application/check-for-updates.ts
 import { spawn } from "child_process";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { dirname, join as join3 } from "path";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join6 } from "path";
 import { stderr, stdin } from "process";
 import { clearScreenDown, cursorTo, emitKeypressEvents } from "readline";
 var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-var UPDATE_CACHE_PATH = join3(homedir(), ".cache", "codesentinel", "update-check.json");
+var UPDATE_CACHE_PATH = join6(homedir2(), ".cache", "codesentinel", "update-check.json");
 var SEMVER_PATTERN = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<prerelease>[0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
 var ANSI = {
   reset: "\x1B[0m",
@@ -3061,7 +3344,7 @@ var parseNpmViewVersionOutput = (output) => {
 };
 var readCache = async () => {
   try {
-    const raw = await readFile(UPDATE_CACHE_PATH, "utf8");
+    const raw = await readFile2(UPDATE_CACHE_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && typeof parsed.lastCheckedAt === "string") {
       return { lastCheckedAt: parsed.lastCheckedAt };
@@ -3072,8 +3355,8 @@ var readCache = async () => {
   return null;
 };
 var writeCache = async (cache) => {
-  await mkdir(dirname(UPDATE_CACHE_PATH), { recursive: true });
-  await writeFile(UPDATE_CACHE_PATH, JSON.stringify(cache), "utf8");
+  await mkdir2(dirname(UPDATE_CACHE_PATH), { recursive: true });
+  await writeFile2(UPDATE_CACHE_PATH, JSON.stringify(cache), "utf8");
 };
 var shouldRunUpdateCheck = (input) => {
   if (!input.isInteractive) {
@@ -6590,7 +6873,7 @@ var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logg
 };
 
 // src/application/run-check-command.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 
 // src/application/build-analysis-snapshot.ts
 var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logger) => {
@@ -6674,7 +6957,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
   let diff;
   if (options.baselinePath !== void 0) {
     logger.info(`loading baseline snapshot: ${options.baselinePath}`);
-    const baselineRaw = await readFile2(options.baselinePath, "utf8");
+    const baselineRaw = await readFile3(options.baselinePath, "utf8");
     try {
       baseline = parseSnapshot(baselineRaw);
     } catch (error) {
@@ -6700,7 +6983,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
     options.outputFormat
   );
   if (options.outputPath !== void 0) {
-    await writeFile2(options.outputPath, rendered, "utf8");
+    await writeFile3(options.outputPath, rendered, "utf8");
     logger.info(`check output written: ${options.outputPath}`);
   }
   return {
@@ -6713,7 +6996,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
 };
 
 // src/application/run-ci-command.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { relative as relative2, resolve as resolve4 } from "path";
 var isPathOutsideBase = (value) => {
   return value === ".." || value.startsWith("../") || value.startsWith("..\\");
@@ -6740,7 +7023,7 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
     logger
   );
   if (options.snapshotPath !== void 0) {
-    await writeFile3(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
+    await writeFile4(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
     logger.info(`snapshot written: ${options.snapshotPath}`);
   }
   let baseline;
@@ -6813,7 +7096,7 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
     diff = compareSnapshots(current, baseline);
   } else if (options.baselinePath !== void 0) {
     logger.info(`loading baseline snapshot: ${options.baselinePath}`);
-    const baselineRaw = await readFile3(options.baselinePath, "utf8");
+    const baselineRaw = await readFile4(options.baselinePath, "utf8");
     try {
       baseline = parseSnapshot(baselineRaw);
     } catch (error) {
@@ -6835,7 +7118,7 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
 
 ${ciMarkdown}`;
   if (options.reportPath !== void 0) {
-    await writeFile3(options.reportPath, markdownSummary, "utf8");
+    await writeFile4(options.reportPath, markdownSummary, "utf8");
     logger.info(`report written: ${options.reportPath}`);
   }
   const machineReadable = {
@@ -6847,7 +7130,7 @@ ${ciMarkdown}`;
     exitCode: gateResult.exitCode
   };
   if (options.jsonOutputPath !== void 0) {
-    await writeFile3(options.jsonOutputPath, JSON.stringify(machineReadable, null, 2), "utf8");
+    await writeFile4(options.jsonOutputPath, JSON.stringify(machineReadable, null, 2), "utf8");
     logger.info(`ci machine output written: ${options.jsonOutputPath}`);
   }
   return {
@@ -6861,7 +7144,7 @@ ${ciMarkdown}`;
 };
 
 // src/application/run-report-command.ts
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 var runReportCommand = async (inputPath, authorIdentityMode, options, logger = createSilentLogger()) => {
   logger.info("building analysis snapshot");
   const current = await buildAnalysisSnapshot(
@@ -6875,7 +7158,7 @@ var runReportCommand = async (inputPath, authorIdentityMode, options, logger = c
     logger
   );
   if (options.snapshotPath !== void 0) {
-    await writeFile4(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
+    await writeFile5(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
     logger.info(`snapshot written: ${options.snapshotPath}`);
   }
   let report;
@@ -6883,14 +7166,14 @@ var runReportCommand = async (inputPath, authorIdentityMode, options, logger = c
     report = createReport(current);
   } else {
     logger.info(`loading baseline snapshot: ${options.comparePath}`);
-    const baselineRaw = await readFile4(options.comparePath, "utf8");
+    const baselineRaw = await readFile5(options.comparePath, "utf8");
     const baseline = parseSnapshot(baselineRaw);
     const diff = compareSnapshots(current, baseline);
     report = createReport(current, diff);
   }
   const rendered = formatReport(report, options.format);
   if (options.outputPath !== void 0) {
-    await writeFile4(options.outputPath, rendered, "utf8");
+    await writeFile5(options.outputPath, rendered, "utf8");
     logger.info(`report written: ${options.outputPath}`);
   }
   return { report, rendered };
@@ -7269,12 +7552,12 @@ program.command("run").argument("[path]", "path to the project to analyze").addO
       ...options.trace === true ? { trace: explain.trace } : {}
     });
     if (options.snapshot !== void 0) {
-      await writeFile5(options.snapshot, JSON.stringify(snapshot, null, 2), "utf8");
+      await writeFile6(options.snapshot, JSON.stringify(snapshot, null, 2), "utf8");
       logger.info(`snapshot written: ${options.snapshot}`);
     }
     const report = options.compare === void 0 ? createReport(snapshot) : createReport(
       snapshot,
-      compareSnapshots(snapshot, parseSnapshot(await readFile5(options.compare, "utf8")))
+      compareSnapshots(snapshot, parseSnapshot(await readFile6(options.compare, "utf8")))
     );
     if (options.format === "json") {
       const analyzeSummaryOutput = formatAnalyzeOutput(explain.summary, "summary");