@agentv/core 4.8.0 → 4.9.0

package/dist/index.js

@@ -2914,6 +2914,60 @@ function parseMetadata(suite) {
   });
 }
 
+// src/evaluation/workspace/repo-config-parser.ts
+function parseRepoSource(raw) {
+  if (!isJsonObject(raw)) return void 0;
+  const obj = raw;
+  if (obj.type === "git" && typeof obj.url === "string") {
+    return { type: "git", url: obj.url };
+  }
+  if (obj.type === "local" && typeof obj.path === "string") {
+    return { type: "local", path: obj.path };
+  }
+  return void 0;
+}
+function parseRepoCheckout(raw) {
+  if (!isJsonObject(raw)) return void 0;
+  const obj = raw;
+  const ref = typeof obj.ref === "string" ? obj.ref : void 0;
+  const resolve = obj.resolve === "remote" || obj.resolve === "local" ? obj.resolve : void 0;
+  const ancestor = typeof obj.ancestor === "number" ? obj.ancestor : void 0;
+  if (!ref && !resolve && ancestor === void 0) return void 0;
+  return {
+    ...ref !== void 0 && { ref },
+    ...resolve !== void 0 && { resolve },
+    ...ancestor !== void 0 && { ancestor }
+  };
+}
+function parseRepoClone(raw) {
+  if (!isJsonObject(raw)) return void 0;
+  const obj = raw;
+  const depth = typeof obj.depth === "number" ? obj.depth : void 0;
+  const filter = typeof obj.filter === "string" ? obj.filter : void 0;
+  const sparse = Array.isArray(obj.sparse) ? obj.sparse.filter((s) => typeof s === "string") : void 0;
+  if (depth === void 0 && !filter && !sparse) return void 0;
+  return {
+    ...depth !== void 0 && { depth },
+    ...filter !== void 0 && { filter },
+    ...sparse !== void 0 && { sparse }
+  };
+}
+function parseRepoConfig(raw) {
+  if (!isJsonObject(raw)) return void 0;
+  const obj = raw;
+  const repoPath = typeof obj.path === "string" ? obj.path : void 0;
+  const source = parseRepoSource(obj.source);
+  if (!repoPath || !source) return void 0;
+  const checkout = parseRepoCheckout(obj.checkout);
+  const clone = parseRepoClone(obj.clone);
+  return {
+    path: repoPath,
+    source,
+    ...checkout !== void 0 && { checkout },
+    ...clone !== void 0 && { clone }
+  };
+}
+
 // src/evaluation/formatting/prompt-builder.ts
 async function buildPromptInputs(testCase, mode = "lm") {
   const segmentsByMessage = testCase.input.map(
@@ -3308,58 +3362,6 @@ function parseWorkspaceScriptConfig(raw, evalFileDir) {
   }
   return cwd ? { ...config, cwd } : config;
 }
-function parseRepoSource(raw) {
-  if (!isJsonObject(raw)) return void 0;
-  const obj = raw;
-  if (obj.type === "git" && typeof obj.url === "string") {
-    return { type: "git", url: obj.url };
-  }
-  if (obj.type === "local" && typeof obj.path === "string") {
-    return { type: "local", path: obj.path };
-  }
-  return void 0;
-}
-function parseRepoCheckout(raw) {
-  if (!isJsonObject(raw)) return void 0;
-  const obj = raw;
-  const ref = typeof obj.ref === "string" ? obj.ref : void 0;
-  const resolve = obj.resolve === "remote" || obj.resolve === "local" ? obj.resolve : void 0;
-  const ancestor = typeof obj.ancestor === "number" ? obj.ancestor : void 0;
-  if (!ref && !resolve && ancestor === void 0) return void 0;
-  return {
-    ...ref !== void 0 && { ref },
-    ...resolve !== void 0 && { resolve },
-    ...ancestor !== void 0 && { ancestor }
-  };
-}
-function parseRepoClone(raw) {
-  if (!isJsonObject(raw)) return void 0;
-  const obj = raw;
-  const depth = typeof obj.depth === "number" ? obj.depth : void 0;
-  const filter = typeof obj.filter === "string" ? obj.filter : void 0;
-  const sparse = Array.isArray(obj.sparse) ? obj.sparse.filter((s) => typeof s === "string") : void 0;
-  if (depth === void 0 && !filter && !sparse) return void 0;
-  return {
-    ...depth !== void 0 && { depth },
-    ...filter !== void 0 && { filter },
-    ...sparse !== void 0 && { sparse }
-  };
-}
-function parseRepoConfig(raw) {
-  if (!isJsonObject(raw)) return void 0;
-  const obj = raw;
-  const repoPath = typeof obj.path === "string" ? obj.path : void 0;
-  const source = parseRepoSource(obj.source);
-  if (!repoPath || !source) return void 0;
-  const checkout = parseRepoCheckout(obj.checkout);
-  const clone = parseRepoClone(obj.clone);
-  return {
-    path: repoPath,
-    source,
-    ...checkout !== void 0 && { checkout },
-    ...clone !== void 0 && { clone }
-  };
-}
 function parseWorkspaceHookConfig(raw, evalFileDir) {
   if (!isJsonObject(raw)) return void 0;
   const script = parseWorkspaceScriptConfig(raw, evalFileDir);
@@ -10823,15 +10825,15 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir16, readFile: readFile15, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
+  const { mkdir: mkdir16, readFile: readFile16, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
   const { tmpdir: tmpdir3 } = await import("node:os");
-  const path50 = await import("node:path");
+  const path51 = await import("node:path");
   const { randomUUID: randomUUID10 } = await import("node:crypto");
-  const dir = path50.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
+  const dir = path51.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
   await mkdir16(dir, { recursive: true });
-  const stdinPath = path50.join(dir, "stdin.txt");
-  const stdoutPath = path50.join(dir, "stdout.txt");
-  const stderrPath = path50.join(dir, "stderr.txt");
+  const stdinPath = path51.join(dir, "stdin.txt");
+  const stdoutPath = path51.join(dir, "stdout.txt");
+  const stderrPath = path51.join(dir, "stderr.txt");
   await writeFile9(stdinPath, stdinPayload, "utf8");
   const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
   const { spawn: spawn5 } = await import("node:child_process");
@@ -10861,8 +10863,8 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
         resolve(code ?? 0);
       });
     });
-    const stdout = (await readFile15(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile15(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    const stdout = (await readFile16(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile16(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
     await rm6(dir, { recursive: true, force: true });
@@ -13121,115 +13123,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path50, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path50);
-    const expectedValue = resolvePath(expectedData, path50);
+    const { path: path51, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path51);
+    const expectedValue = resolvePath(expectedData, path51);
     if (expectedValue === void 0) {
       return {
-        path: path50,
+        path: path51,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path50}: no expected value`
+        message: `${path51}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path50,
+          path: path51,
           score: 0,
           weight,
           hit: false,
-          message: `${path50} (required, missing)`
+          message: `${path51} (required, missing)`
         };
       }
       return {
-        path: path50,
+        path: path51,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path50}: optional field missing`
+        message: `${path51}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path50, candidateValue, expectedValue, weight);
+        return this.compareExact(path51, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path50,
+          path51,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path50, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path51, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path50,
+          path: path51,
           score: 0,
           weight,
           hit: false,
-          message: `${path50}: unknown match type "${match}"`
+          message: `${path51}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path50, candidateValue, expectedValue, weight) {
+  compareExact(path51, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path50,
+        path: path51,
         score: 1,
         weight,
         hit: true,
-        message: path50
+        message: path51
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path50,
+        path: path51,
         score: 0,
         weight,
         hit: false,
-        message: `${path50} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path51} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path50,
+      path: path51,
       score: 0,
       weight,
       hit: false,
-      message: `${path50} (value mismatch)`
+      message: `${path51} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path50, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path51, candidateValue, expectedValue, fieldConfig, weight) {
     const { tolerance = 0, relative = false } = fieldConfig;
     const candidateNum = toNumber(candidateValue);
     const expectedNum = toNumber(expectedValue);
     if (candidateNum === null || expectedNum === null) {
       return {
-        path: path50,
+        path: path51,
         score: 0,
         weight,
         hit: false,
-        message: `${path50} (non-numeric value)`
+        message: `${path51} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path50,
+        path: path51,
         score: 0,
         weight,
         hit: false,
-        message: `${path50} (invalid numeric value)`
+        message: `${path51} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -13242,61 +13244,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path50,
+        path: path51,
         score: 1,
         weight,
         hit: true,
-        message: `${path50} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path51} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path50,
+      path: path51,
       score: 0,
       weight,
       hit: false,
-      message: `${path50} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path51} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path50, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path51, candidateValue, expectedValue, fieldConfig, weight) {
     const formats = fieldConfig.formats ?? DEFAULT_DATE_FORMATS;
     const candidateDate = parseDate(String(candidateValue), formats);
     const expectedDate = parseDate(String(expectedValue), formats);
     if (candidateDate === null) {
       return {
-        path: path50,
+        path: path51,
         score: 0,
         weight,
         hit: false,
-        message: `${path50} (unparseable candidate date)`
+        message: `${path51} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path50,
+        path: path51,
         score: 0,
         weight,
         hit: false,
-        message: `${path50} (unparseable expected date)`
+        message: `${path51} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path50,
+        path: path51,
         score: 1,
         weight,
         hit: true,
-        message: path50
+        message: path51
       };
     }
     return {
-      path: path50,
+      path: path51,
       score: 0,
       weight,
       hit: false,
-      message: `${path50} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path51} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -13329,11 +13331,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path50) {
-  if (!path50 || !obj) {
+function resolvePath(obj, path51) {
+  if (!path51 || !obj) {
     return void 0;
   }
-  const parts = path50.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path51.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -13825,8 +13827,8 @@ var TokenUsageEvaluator = class {
 };
 
 // src/evaluation/evaluators/tool-trajectory.ts
-function getNestedValue(obj, path50) {
-  const parts = path50.split(".");
+function getNestedValue(obj, path51) {
+  const parts = path51.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -18324,9 +18326,106 @@ function buildPrompt(criteria, question, referenceAnswer) {
   return parts.join("\n");
 }
 
-// src/evaluation/cache/response-cache.ts
-import { mkdir as mkdir15, readFile as readFile13, writeFile as writeFile8 } from "node:fs/promises";
+// src/evaluation/workspace/deps-scanner.ts
+import { readFile as readFile13 } from "node:fs/promises";
 import path46 from "node:path";
+import { parse as parse5 } from "yaml";
+function normalizeGitUrl(url) {
+  let normalized = url.replace(/\.git$/, "");
+  try {
+    const parsed = new URL(normalized);
+    parsed.hostname = parsed.hostname.toLowerCase();
+    normalized = parsed.toString().replace(/\/$/, "");
+  } catch {
+  }
+  return normalized;
+}
+async function scanRepoDeps(evalFilePaths) {
+  const seen = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const filePath of evalFilePaths) {
+    try {
+      const repos = await extractReposFromEvalFile(filePath);
+      for (const repo of repos) {
+        if (repo.source.type !== "git") continue;
+        const ref = repo.checkout?.ref;
+        const key = `${normalizeGitUrl(repo.source.url)}\0${ref ?? ""}`;
+        const existing = seen.get(key);
+        if (existing) {
+          existing.usedBy.push(filePath);
+        } else {
+          const { ref: _ref, ...checkoutRest } = repo.checkout ?? {};
+          const hasCheckout = Object.keys(checkoutRest).length > 0;
+          seen.set(key, {
+            url: repo.source.url,
+            ref,
+            clone: repo.clone,
+            checkout: hasCheckout ? checkoutRest : void 0,
+            usedBy: [filePath]
+          });
+        }
+      }
+    } catch (err) {
+      errors.push({
+        file: filePath,
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return { repos: [...seen.values()], errors };
+}
+async function extractReposFromEvalFile(filePath) {
+  const content = await readFile13(filePath, "utf8");
+  const parsed = interpolateEnv(parse5(content), process.env);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+  const obj = parsed;
+  const evalFileDir = path46.dirname(path46.resolve(filePath));
+  const repos = [];
+  const suiteRepos = await extractReposFromWorkspaceRaw(obj.workspace, evalFileDir);
+  repos.push(...suiteRepos);
+  const tests = Array.isArray(obj.tests) ? obj.tests : [];
+  for (const test of tests) {
+    if (test && typeof test === "object" && !Array.isArray(test)) {
+      const testObj = test;
+      const testRepos = await extractReposFromWorkspaceRaw(testObj.workspace, evalFileDir);
+      repos.push(...testRepos);
+    }
+  }
+  return repos;
+}
+async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
+  if (typeof raw === "string") {
+    const workspaceFilePath = path46.resolve(evalFileDir, raw);
+    const content = await readFile13(workspaceFilePath, "utf8");
+    const parsed = interpolateEnv(parse5(content), process.env);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+    return extractReposFromObject(parsed);
+  }
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    return extractReposFromObject(raw);
+  }
+  return [];
+}
+function extractReposFromObject(obj) {
+  const rawRepos = Array.isArray(obj.repos) ? obj.repos : [];
+  const result = [];
+  for (const r of rawRepos) {
+    if (!r || typeof r !== "object" || Array.isArray(r)) continue;
+    const repo = r;
+    const source = parseRepoSource(repo.source);
+    if (!source) continue;
+    result.push({
+      source,
+      checkout: parseRepoCheckout(repo.checkout),
+      clone: parseRepoClone(repo.clone)
+    });
+  }
+  return result;
+}
+
+// src/evaluation/cache/response-cache.ts
+import { mkdir as mkdir15, readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
+import path47 from "node:path";
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
   cachePath;
@@ -18336,7 +18435,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await readFile13(filePath, "utf8");
+      const data = await readFile14(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -18344,13 +18443,13 @@ var ResponseCache = class {
   }
   async set(key, value) {
     const filePath = this.keyToPath(key);
-    const dir = path46.dirname(filePath);
+    const dir = path47.dirname(filePath);
     await mkdir15(dir, { recursive: true });
     await writeFile8(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
-    return path46.join(this.cachePath, prefix, `${key}.json`);
+    return path47.join(this.cachePath, prefix, `${key}.json`);
   }
 };
 function shouldEnableCache(params) {
@@ -18367,10 +18466,10 @@ function shouldSkipCacheForTemperature(targetConfig) {
 
 // src/projects.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync as statSync2, writeFileSync } from "node:fs";
-import path47 from "node:path";
+import path48 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml } from "yaml";
 function getProjectsRegistryPath() {
-  return path47.join(getAgentvHome(), "projects.yaml");
+  return path48.join(getAgentvHome(), "projects.yaml");
 }
 function loadProjectRegistry() {
   const registryPath = getProjectsRegistryPath();
@@ -18390,14 +18489,14 @@ function loadProjectRegistry() {
 }
 function saveProjectRegistry(registry) {
   const registryPath = getProjectsRegistryPath();
-  const dir = path47.dirname(registryPath);
+  const dir = path48.dirname(registryPath);
   if (!existsSync6(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   writeFileSync(registryPath, stringifyYaml(registry), "utf-8");
 }
 function deriveProjectId(dirPath, existingIds) {
-  const base = path47.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const base = path48.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   let candidate = base || "project";
   let suffix = 2;
   while (existingIds.includes(candidate)) {
@@ -18407,11 +18506,11 @@ function deriveProjectId(dirPath, existingIds) {
   return candidate;
 }
 function addProject(projectPath) {
-  const absPath = path47.resolve(projectPath);
+  const absPath = path48.resolve(projectPath);
   if (!existsSync6(absPath)) {
     throw new Error(`Directory not found: ${absPath}`);
   }
-  if (!existsSync6(path47.join(absPath, ".agentv"))) {
+  if (!existsSync6(path48.join(absPath, ".agentv"))) {
     throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
   }
   const registry = loadProjectRegistry();
@@ -18425,7 +18524,7 @@ function addProject(projectPath) {
       absPath,
       registry.projects.map((p) => p.id)
     ),
-    name: path47.basename(absPath),
+    name: path48.basename(absPath),
     path: absPath,
     addedAt: now,
     lastOpenedAt: now
@@ -18454,14 +18553,14 @@ function touchProject(projectId) {
   }
 }
 function discoverProjects(rootDir, maxDepth = 2) {
-  const absRoot = path47.resolve(rootDir);
+  const absRoot = path48.resolve(rootDir);
   if (!existsSync6(absRoot) || !statSync2(absRoot).isDirectory()) {
     return [];
   }
   const results = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
-    if (existsSync6(path47.join(dir, ".agentv"))) {
+    if (existsSync6(path48.join(dir, ".agentv"))) {
       results.push(dir);
       return;
     }
@@ -18471,7 +18570,7 @@ function discoverProjects(rootDir, maxDepth = 2) {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        scan(path47.join(dir, entry.name), depth + 1);
+        scan(path48.join(dir, entry.name), depth + 1);
       }
     } catch {
     }
@@ -19384,8 +19483,8 @@ function extractResponseItemContent(content) {
 // src/import/codex-session-discovery.ts
 import { readdir as readdir8, stat as stat9 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import path48 from "node:path";
-var DEFAULT_SESSIONS_DIR = () => path48.join(homedir3(), ".codex", "sessions");
+import path49 from "node:path";
+var DEFAULT_SESSIONS_DIR = () => path49.join(homedir3(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
@@ -19397,7 +19496,7 @@ async function discoverCodexSessions(opts) {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = path48.join(sessionsDir, year);
+    const yearPath = path49.join(sessionsDir, year);
     let monthDirs;
     try {
       monthDirs = await readdir8(yearPath);
@@ -19405,7 +19504,7 @@ async function discoverCodexSessions(opts) {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = path48.join(yearPath, month);
+      const monthPath = path49.join(yearPath, month);
       let dayDirs;
       try {
         dayDirs = await readdir8(monthPath);
@@ -19417,7 +19516,7 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = path48.join(monthPath, day);
+        const dayPath = path49.join(monthPath, day);
         let files;
         try {
           files = await readdir8(dayPath);
@@ -19426,7 +19525,7 @@ async function discoverCodexSessions(opts) {
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = path48.join(dayPath, file);
+          const filePath = path49.join(dayPath, file);
           const nameWithoutExt = file.replace(/\.jsonl$/, "");
           const parts = nameWithoutExt.split("-");
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
@@ -19449,8 +19548,8 @@ async function discoverCodexSessions(opts) {
 // src/import/session-discovery.ts
 import { readdir as readdir9, stat as stat10 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import path49 from "node:path";
-var DEFAULT_PROJECTS_DIR = () => path49.join(homedir4(), ".claude", "projects");
+import path50 from "node:path";
+var DEFAULT_PROJECTS_DIR = () => path50.join(homedir4(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -19469,7 +19568,7 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = path49.join(projectsDir, projectDir);
+    const dirPath = path50.join(projectsDir, projectDir);
     let entries;
     try {
       entries = await readdir9(dirPath);
@@ -19480,7 +19579,7 @@ async function discoverClaudeSessions(opts) {
       if (!entry.endsWith(".jsonl")) continue;
       const sessionId = entry.replace(/\.jsonl$/, "");
       if (opts?.sessionId && sessionId !== opts.sessionId) continue;
-      const filePath = path49.join(dirPath, entry);
+      const filePath = path50.join(dirPath, entry);
       let updatedAt;
       try {
         const fileStat = await stat10(filePath);
@@ -19501,7 +19600,7 @@ async function discoverClaudeSessions(opts) {
 }
 
 // src/import/types.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 function toTranscriptJsonLine(entry) {
   const firstUserMessage = entry.messages.find((m) => m.role === "user");
   const input = typeof firstUserMessage?.content === "string" ? firstUserMessage.content : "";
@@ -19527,11 +19626,11 @@ function toTranscriptJsonLine(entry) {
   };
 }
 async function readTranscriptJsonl(filePath) {
-  const text = await readFile14(filePath, "utf8");
+  const text = await readFile15(filePath, "utf8");
   return text.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 async function readTranscriptFile(filePath) {
-  return readFile14(filePath, "utf8");
+  return readFile15(filePath, "utf8");
 }
 
 // src/import/transcript-provider.ts
@@ -19745,6 +19844,7 @@ export {
   runRegexAssertion,
   runStartsWithAssertion,
   saveProjectRegistry,
+  scanRepoDeps,
   scoreToVerdict,
   shouldEnableCache,
   shouldSkipCacheForTemperature,