@pratik7368patil/anchor-core 0.1.24 → 0.1.25

package/dist/index.js

@@ -1535,6 +1535,10 @@ function calculateCoverage(input) {
 }
 
 // src/db/database.ts
+var CODE_WRITE_PROGRESS_INTERVAL = 500;
+function shouldEmitCodeWriteProgress(current, total) {
+  return current === 0 || current === 1 || current === total || current % CODE_WRITE_PROGRESS_INTERVAL === 0;
+}
 function defaultDatabasePath(cwd) {
   return path4.join(cwd, ".anchor", "index.sqlite");
 }
@@ -1902,13 +1906,22 @@ function upsertPullRequest(db, pr, wisdomUnits, regressionEvents = []) {
     regressions: regressionEvents.length
   };
 }
-function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, architecture = { components: [], patterns: [], imports: [] }) {
+function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, architecture = { components: [], patterns: [], imports: [] }, options = {}) {
   initializeSchema(db);
   const repoId = ensureRepository(db, repo);
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  options.onProgress?.({ stage: "writing_code_index", repo, phase: "Inferring test awareness" });
   const testAwareness = inferTestAwareness(repo, codeFiles, codeChunks);
+  options.onProgress?.({ stage: "writing_code_index", repo, phase: "Writing code index" });
   const transaction = db.transaction(() => {
     const existingChunks = db.prepare("SELECT id FROM code_chunks WHERE repo_id = ?").all(repoId);
+    const existingPatternCount = db.prepare("SELECT COUNT(*) AS count FROM architecture_patterns WHERE repo_id = ?").get(repoId).count;
+    options.onProgress?.({
+      stage: "deleting_existing_code_index",
+      repo,
+      chunks: existingChunks.length,
+      patterns: existingPatternCount
+    });
     const deleteFts = db.prepare("DELETE FROM code_chunks_fts WHERE chunkId = ?");
     for (const row of existingChunks) deleteFts.run(row.id);
     db.prepare("DELETE FROM code_chunks WHERE repo_id = ?").run(repoId);
@@ -1921,7 +1934,13 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
        (repo_id, path, language, size_bytes, content_hash, updated_at)
        VALUES (?, ?, ?, ?, ?, ?)`
     );
-    for (const file of codeFiles) {
+    options.onProgress?.({
+      stage: "writing_code_files",
+      repo,
+      current: 0,
+      total: codeFiles.length
+    });
+    for (const [index, file] of codeFiles.entries()) {
       insertFile.run(
         repoId,
         file.path,
@@ -1930,6 +1949,16 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
         file.contentHash,
         file.updatedAt
       );
+      const current = index + 1;
+      if (shouldEmitCodeWriteProgress(current, codeFiles.length)) {
+        options.onProgress?.({
+          stage: "writing_code_files",
+          repo,
+          current,
+          total: codeFiles.length,
+          filePath: file.path
+        });
+      }
     }
     const fileRows = db.prepare("SELECT id, path FROM code_files WHERE repo_id = ?").all(repoId);
     const fileIds = new Map(fileRows.map((row) => [row.path, row.id]));
@@ -1944,7 +1973,15 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
        (chunkId, sanitizedText, filePath, symbols, language)
        VALUES (?, ?, ?, ?, ?)`
     );
-    for (const chunk of codeChunks) {
+    options.onProgress?.({
+      stage: "writing_code_chunks",
+      repo,
+      current: 0,
+      total: codeChunks.length,
+      chunks: 0
+    });
+    let writtenChunks = 0;
+    for (const [index, chunk] of codeChunks.entries()) {
       const fileId = fileIds.get(chunk.filePath);
       if (!fileId) continue;
       insertChunk.run(
@@ -1968,10 +2005,23 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
         chunk.symbols.join(" "),
         chunk.language ?? ""
       );
+      writtenChunks += 1;
+      const current = index + 1;
+      if (shouldEmitCodeWriteProgress(current, codeChunks.length)) {
+        options.onProgress?.({
+          stage: "writing_code_chunks",
+          repo,
+          current,
+          total: codeChunks.length,
+          filePath: chunk.filePath,
+          chunks: writtenChunks
+        });
+      }
     }
-    insertTestAwareness(db, repoId, testAwareness.testFiles, testAwareness.testLinks);
-    insertArchitectureData(db, repoId, architecture);
-    insertArchitectureMapEdges(db, repoId, repo, architecture, testAwareness.testLinks);
+    insertTestAwareness(db, repoId, repo, testAwareness.testFiles, testAwareness.testLinks, options);
+    insertArchitectureData(db, repoId, repo, architecture, options);
+    insertArchitectureMapEdges(db, repoId, repo, architecture, testAwareness.testLinks, options);
+    options.onProgress?.({ stage: "writing_code_index", repo, phase: "Updating index state" });
     db.prepare(
       `INSERT INTO code_index_state (repo, last_indexed_at, indexed_files, code_chunks, skipped_files)
        VALUES (?, ?, ?, ?, ?)
@@ -2019,13 +2069,20 @@ function deleteExistingArchitectureData(db, repoId) {
   db.prepare("DELETE FROM code_imports WHERE repo_id = ?").run(repoId);
   db.prepare("DELETE FROM architecture_map_edges WHERE repo_id = ?").run(repoId);
 }
-function insertArchitectureData(db, repoId, architecture) {
+function insertArchitectureData(db, repoId, repo, architecture, options = {}) {
   const insertImport = db.prepare(
     `INSERT INTO code_imports
      (repo_id, source_path, specifier, imported_path, imported_symbols_json, kind)
      VALUES (?, ?, ?, ?, ?, ?)`
   );
-  for (const item of architecture.imports) {
+  options.onProgress?.({
+    stage: "writing_architecture_data",
+    repo,
+    current: 0,
+    total: architecture.imports.length,
+    kind: "imports"
+  });
+  for (const [index, item] of architecture.imports.entries()) {
     insertImport.run(
       repoId,
       item.sourcePath,
@@ -2034,6 +2091,16 @@ function insertArchitectureData(db, repoId, architecture) {
       JSON.stringify(item.importedSymbols),
       item.kind
     );
+    const current = index + 1;
+    if (shouldEmitCodeWriteProgress(current, architecture.imports.length)) {
+      options.onProgress?.({
+        stage: "writing_architecture_data",
+        repo,
+        current,
+        total: architecture.imports.length,
+        kind: "imports"
+      });
+    }
   }
   const insertComponent = db.prepare(
     `INSERT INTO architecture_components
@@ -2041,7 +2108,14 @@ function insertArchitectureData(db, repoId, architecture) {
       confidence, updated_at)
      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   );
-  for (const component of architecture.components) {
+  options.onProgress?.({
+    stage: "writing_architecture_data",
+    repo,
+    current: 0,
+    total: architecture.components.length,
+    kind: "components"
+  });
+  for (const [index, component] of architecture.components.entries()) {
     insertComponent.run(
       repoId,
       component.path,
@@ -2054,6 +2128,16 @@ function insertArchitectureData(db, repoId, architecture) {
       component.confidence,
       component.updatedAt
     );
+    const current = index + 1;
+    if (shouldEmitCodeWriteProgress(current, architecture.components.length)) {
+      options.onProgress?.({
+        stage: "writing_architecture_data",
+        repo,
+        current,
+        total: architecture.components.length,
+        kind: "components"
+      });
+    }
   }
   const insertPattern = db.prepare(
     `INSERT INTO architecture_patterns
@@ -2065,7 +2149,14 @@ function insertArchitectureData(db, repoId, architecture) {
     `INSERT INTO architecture_patterns_fts (patternId, summary, area, sourceFiles, symbols)
      VALUES (?, ?, ?, ?, ?)`
   );
-  for (const pattern of architecture.patterns) {
+  options.onProgress?.({
+    stage: "writing_architecture_data",
+    repo,
+    current: 0,
+    total: architecture.patterns.length,
+    kind: "patterns"
+  });
+  for (const [index, pattern] of architecture.patterns.entries()) {
     insertPattern.run(
       pattern.id,
       repoId,
@@ -2086,9 +2177,19 @@ function insertArchitectureData(db, repoId, architecture) {
       pattern.sourceFiles.join(" "),
       pattern.symbols.join(" ")
     );
+    const current = index + 1;
+    if (shouldEmitCodeWriteProgress(current, architecture.patterns.length)) {
+      options.onProgress?.({
+        stage: "writing_architecture_data",
+        repo,
+        current,
+        total: architecture.patterns.length,
+        kind: "patterns"
+      });
+    }
   }
 }
-function insertArchitectureMapEdges(db, repoId, repo, architecture, testLinks) {
+function insertArchitectureMapEdges(db, repoId, repo, architecture, testLinks, options = {}) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const insert = db.prepare(
     `INSERT INTO architecture_map_edges
@@ -2103,11 +2204,40 @@ function insertArchitectureMapEdges(db, repoId, repo, architecture, testLinks) {
     seen.add(id);
     insert.run(id, repoId, repo, sourcePath, targetPath, relationship, weight, now);
   };
+  const total = architecture.imports.length + testLinks.length;
+  let current = 0;
+  options.onProgress?.({
+    stage: "writing_architecture_map_edges",
+    repo,
+    current,
+    total,
+    edges: 0
+  });
   for (const item of architecture.imports) {
     if (item.importedPath) addEdge(item.sourcePath, item.importedPath, "imports", 0.9);
+    current += 1;
+    if (shouldEmitCodeWriteProgress(current, total)) {
+      options.onProgress?.({
+        stage: "writing_architecture_map_edges",
+        repo,
+        current,
+        total,
+        edges: seen.size
+      });
+    }
   }
   for (const link of testLinks) {
     addEdge(link.sourcePath, link.testPath, "tested_by", link.strength);
+    current += 1;
+    if (shouldEmitCodeWriteProgress(current, total)) {
+      options.onProgress?.({
+        stage: "writing_architecture_map_edges",
+        repo,
+        current,
+        total,
+        edges: seen.size
+      });
+    }
   }
 }
 function insertPrCochangeTestLinks(db, repoId, filePaths) {
@@ -2123,13 +2253,20 @@ function insertPrCochangeTestLinks(db, repoId, filePaths) {
     for (const testPath of testPaths) insert.run(repoId, sourcePath, testPath);
   }
 }
-function insertTestAwareness(db, repoId, testFiles, testLinks) {
+function insertTestAwareness(db, repoId, repo, testFiles, testLinks, options = {}) {
   const insertTestFile = db.prepare(
     `INSERT INTO test_files
      (repo_id, path, language, size_bytes, content_hash, updated_at)
      VALUES (?, ?, ?, ?, ?, ?)`
   );
-  for (const file of testFiles) {
+  options.onProgress?.({
+    stage: "writing_test_awareness",
+    repo,
+    current: 0,
+    total: testFiles.length,
+    kind: "test_files"
+  });
+  for (const [index, file] of testFiles.entries()) {
     insertTestFile.run(
       repoId,
       file.path,
@@ -2138,13 +2275,40 @@ function insertTestAwareness(db, repoId, testFiles, testLinks) {
       file.contentHash,
       file.updatedAt
     );
+    const current = index + 1;
+    if (shouldEmitCodeWriteProgress(current, testFiles.length)) {
+      options.onProgress?.({
+        stage: "writing_test_awareness",
+        repo,
+        current,
+        total: testFiles.length,
+        kind: "test_files"
+      });
+    }
   }
   const insertTestLink = db.prepare(
     `INSERT INTO test_links (repo_id, source_path, test_path, reason, strength)
      VALUES (?, ?, ?, ?, ?)`
   );
-  for (const link of testLinks) {
+  options.onProgress?.({
+    stage: "writing_test_awareness",
+    repo,
+    current: 0,
+    total: testLinks.length,
+    kind: "test_links"
+  });
+  for (const [index, link] of testLinks.entries()) {
     insertTestLink.run(repoId, link.sourcePath, link.testPath, link.reason, link.strength);
+    const current = index + 1;
+    if (shouldEmitCodeWriteProgress(current, testLinks.length)) {
+      options.onProgress?.({
+        stage: "writing_test_awareness",
+        repo,
+        current,
+        total: testLinks.length,
+        kind: "test_links"
+      });
+    }
   }
 }
 function recordIndexRun(db, run) {
@@ -2471,6 +2635,10 @@ function chunkCodeFile(file, options = {}) {
 import crypto2 from "crypto";
 import path6 from "path";
 var KNOWN_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"];
+var ARCHITECTURE_PROGRESS_INTERVAL = 250;
+function shouldEmitProgress(current, total) {
+  return current === 0 || current === 1 || current === total || current % ARCHITECTURE_PROGRESS_INTERVAL === 0;
+}
 function classifyArchitectureArea(filePath, language, content = "") {
   const normalized = filePath.replace(/\\/g, "/").toLowerCase();
   const basename = path6.basename(normalized);
@@ -2618,7 +2786,7 @@ function createPattern(input) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function buildArchitectureIndex(repo, files, chunks) {
+function buildArchitectureIndex(repo, files, chunks, options = {}) {
   const allPaths = files.map((file) => file.path);
   const codePaths = new Set(allPaths);
   const symbolsByPath = /* @__PURE__ */ new Map();
@@ -2626,20 +2794,47 @@ function buildArchitectureIndex(repo, files, chunks) {
     const existing = symbolsByPath.get(chunk.filePath) ?? [];
     symbolsByPath.set(chunk.filePath, uniqueStrings([...existing, ...chunk.symbols]).slice(0, 40));
   }
-  const imports = files.flatMap(
-    (file) => extractCodeImports(file.path, file.content, codePaths, repo)
-  );
+  const imports = [];
+  options.onProgress?.({
+    stage: "building_architecture_imports",
+    repo,
+    current: 0,
+    total: files.length,
+    imports: 0
+  });
+  for (const [index, file] of files.entries()) {
+    imports.push(...extractCodeImports(file.path, file.content, codePaths, repo));
+    const current = index + 1;
+    if (shouldEmitProgress(current, files.length)) {
+      options.onProgress?.({
+        stage: "building_architecture_imports",
+        repo,
+        current,
+        total: files.length,
+        filePath: file.path,
+        imports: imports.length
+      });
+    }
+  }
   const importsByPath = /* @__PURE__ */ new Map();
   for (const item of imports) {
     const existing = importsByPath.get(item.sourcePath) ?? [];
     existing.push(item);
     importsByPath.set(item.sourcePath, existing);
   }
-  const components = files.map((file) => {
+  const components = [];
+  options.onProgress?.({
+    stage: "building_architecture_components",
+    repo,
+    current: 0,
+    total: files.length,
+    components: 0
+  });
+  for (const [index, file] of files.entries()) {
     const area = classifyArchitectureArea(file.path, file.language, file.content);
     const fileImports = importsByPath.get(file.path) ?? [];
     const symbols = symbolsByPath.get(file.path) ?? [];
-    return {
+    components.push({
       repo,
       path: file.path,
       area,
@@ -2652,16 +2847,49 @@ function buildArchitectureIndex(repo, files, chunks) {
       relatedTests: relatedTestsFor(file.path, allPaths),
       confidence: area === "unknown" ? 0.45 : 0.82,
       updatedAt: file.updatedAt
-    };
-  });
+    });
+    const current = index + 1;
+    if (shouldEmitProgress(current, files.length)) {
+      options.onProgress?.({
+        stage: "building_architecture_components",
+        repo,
+        current,
+        total: files.length,
+        filePath: file.path,
+        components: components.length
+      });
+    }
+  }
   const componentByPath = new Map(components.map((component) => [component.path, component]));
-  const patterns = [];
   const componentsByArea = /* @__PURE__ */ new Map();
   for (const component of components) {
     const existing = componentsByArea.get(component.area) ?? [];
     existing.push(component);
     componentsByArea.set(component.area, existing);
   }
+  const importDirectionCounts = /* @__PURE__ */ new Map();
+  for (const item of imports) {
+    if (!item.importedPath) continue;
+    const source = componentByPath.get(item.sourcePath);
+    const target = componentByPath.get(item.importedPath);
+    if (!source || !target || source.area === target.area) continue;
+    const key = `${source.area}->${target.area}`;
+    const existing = importDirectionCounts.get(key) ?? { count: 0, files: [], symbols: [] };
+    existing.count += 1;
+    existing.files.push(source.path, target.path);
+    existing.symbols.push(...item.importedSymbols);
+    importDirectionCounts.set(key, existing);
+  }
+  const patterns = [];
+  const patternTotal = componentsByArea.size + importDirectionCounts.size;
+  let patternProgress = 0;
+  options.onProgress?.({
+    stage: "building_architecture_patterns",
+    repo,
+    current: 0,
+    total: patternTotal,
+    patterns: 0
+  });
   for (const [area, areaComponents] of componentsByArea.entries()) {
     const filesForArea = areaComponents.map((component) => component.path);
     const directories = topDirectories(filesForArea);
@@ -2677,19 +2905,17 @@ function buildArchitectureIndex(repo, files, chunks) {
         confidence: 0.55 + Math.min(0.3, filesForArea.length * 0.04)
       })
     );
-  }
-  const importDirectionCounts = /* @__PURE__ */ new Map();
-  for (const item of imports) {
-    if (!item.importedPath) continue;
-    const source = componentByPath.get(item.sourcePath);
-    const target = componentByPath.get(item.importedPath);
-    if (!source || !target || source.area === target.area) continue;
-    const key = `${source.area}->${target.area}`;
-    const existing = importDirectionCounts.get(key) ?? { count: 0, files: [], symbols: [] };
-    existing.count += 1;
-    existing.files.push(source.path, target.path);
-    existing.symbols.push(...item.importedSymbols);
-    importDirectionCounts.set(key, existing);
+    patternProgress += 1;
+    if (shouldEmitProgress(patternProgress, patternTotal)) {
+      options.onProgress?.({
+        stage: "building_architecture_patterns",
+        repo,
+        current: patternProgress,
+        total: patternTotal,
+        area,
+        patterns: patterns.length
+      });
+    }
   }
   for (const [key, value] of importDirectionCounts.entries()) {
     const [sourceArea, targetArea] = key.split("->");
@@ -2704,6 +2930,17 @@ function buildArchitectureIndex(repo, files, chunks) {
         confidence: 0.62 + Math.min(0.25, value.count * 0.05)
       })
     );
+    patternProgress += 1;
+    if (shouldEmitProgress(patternProgress, patternTotal)) {
+      options.onProgress?.({
+        stage: "building_architecture_patterns",
+        repo,
+        current: patternProgress,
+        total: patternTotal,
+        area: sourceArea,
+        patterns: patterns.length
+      });
+    }
   }
   const testedComponents = components.filter((component) => component.relatedTests.length > 0);
   if (testedComponents.length > 0) {
@@ -3033,8 +3270,24 @@ function detectTestCommands(db, cwd, files = []) {
     return true;
   });
 }
-function refreshTestCommands(db, cwd, repo, files = []) {
+function refreshTestCommands(db, cwd, repo, files = [], options = {}) {
+  options.onProgress?.({
+    stage: "refreshing_test_commands",
+    repo,
+    phase: "detecting",
+    current: 0,
+    total: files.length,
+    commands: 0
+  });
   const commands = detectTestCommands(db, cwd, files);
+  options.onProgress?.({
+    stage: "refreshing_test_commands",
+    repo,
+    phase: "writing",
+    current: 0,
+    total: commands.length,
+    commands: commands.length
+  });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const transaction = db.transaction(() => {
     db.prepare("DELETE FROM test_commands WHERE repo = ?").run(repo);
@@ -3042,7 +3295,7 @@ function refreshTestCommands(db, cwd, repo, files = []) {
       `INSERT INTO test_commands (id, repo, file_path, command, reason, confidence, created_at)
        VALUES (?, ?, ?, ?, ?, ?, ?)`
     );
-    for (const command of commands) {
+    for (const [index, command] of commands.entries()) {
       insert.run(
         commandId(repo, command),
         repo,
@@ -3052,6 +3305,17 @@ function refreshTestCommands(db, cwd, repo, files = []) {
         command.confidence,
         now
       );
+      const current = index + 1;
+      if (current === 1 || current === commands.length || current % 250 === 0) {
+        options.onProgress?.({
+          stage: "refreshing_test_commands",
+          repo,
+          phase: "writing",
+          current,
+          total: commands.length,
+          commands: commands.length
+        });
+      }
     }
   });
   transaction();
@@ -3090,7 +3354,9 @@ function indexCodebase(db, options) {
       chunks: fileChunks.length
     });
   }
-  const architecture = buildArchitectureIndex(options.repo, discovery.files, chunks);
+  const architecture = buildArchitectureIndex(options.repo, discovery.files, chunks, {
+    onProgress: options.onProgress
+  });
   options.onProgress?.({
     stage: "indexed_architecture",
     repo: options.repo,
@@ -3105,9 +3371,10 @@ function indexCodebase(db, options) {
     chunks,
     discovery.skippedFiles,
     options.cwd,
-    architecture
+    architecture,
+    { onProgress: options.onProgress }
   );
-  refreshTestCommands(db, options.cwd, options.repo);
+  refreshTestCommands(db, options.cwd, options.repo, [], { onProgress: options.onProgress });
   options.onProgress?.({
     stage: "completed_code_index",
     repo: options.repo,
@@ -7929,10 +8196,67 @@ function parseHeartbeat(value) {
     repoIndex: typeof candidate.repoIndex === "number" ? candidate.repoIndex : void 0,
     repoTotal: typeof candidate.repoTotal === "number" ? candidate.repoTotal : void 0,
     phase: candidate.phase,
+    timeline: parseTimeline(candidate.timeline),
     startedAt: candidate.startedAt,
     updatedAt: candidate.updatedAt
   };
 }
+function parseTimelineStatus(value) {
+  if (value === "active" || value === "done" || value === "skipped" || value === "warn" || value === "fail" || value === "wait") {
+    return value;
+  }
+  return void 0;
+}
+function parseTimelineNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function parseTimelineStep(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const candidate = value;
+  const status = parseTimelineStatus(candidate.status);
+  if (typeof candidate.id !== "string" || typeof candidate.label !== "string" || !status || typeof candidate.startedAt !== "string" || typeof candidate.updatedAt !== "string") {
+    return void 0;
+  }
+  return {
+    id: candidate.id,
+    label: candidate.label,
+    status,
+    startedAt: candidate.startedAt,
+    updatedAt: candidate.updatedAt,
+    completedAt: typeof candidate.completedAt === "string" ? candidate.completedAt : void 0,
+    durationMs: parseTimelineNumber(candidate.durationMs),
+    current: parseTimelineNumber(candidate.current),
+    total: parseTimelineNumber(candidate.total),
+    detail: typeof candidate.detail === "string" ? candidate.detail : void 0
+  };
+}
+function parseTimelineRepoSummary(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const candidate = value;
+  const status = parseTimelineStatus(candidate.status);
+  if (typeof candidate.repo !== "string" || !status) return void 0;
+  return {
+    repo: candidate.repo,
+    status,
+    durationMs: parseTimelineNumber(candidate.durationMs) ?? 0,
+    detail: typeof candidate.detail === "string" ? candidate.detail : void 0
+  };
+}
+function parseTimeline(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const candidate = value;
+  if (!Array.isArray(candidate.steps) || !Array.isArray(candidate.recentRepos)) return void 0;
+  const steps = candidate.steps.map(parseTimelineStep).filter((step) => step !== void 0);
+  const recentRepos = candidate.recentRepos.map(parseTimelineRepoSummary).filter((repo) => repo !== void 0);
+  return {
+    repo: typeof candidate.repo === "string" ? candidate.repo : void 0,
+    repoIndex: parseTimelineNumber(candidate.repoIndex),
+    repoTotal: parseTimelineNumber(candidate.repoTotal),
+    activeStepId: typeof candidate.activeStepId === "string" ? candidate.activeStepId : void 0,
+    steps,
+    recentRepos
+  };
+}
 function writeOrgHeartbeat(heartbeat, baseDir) {
   atomicWriteJson2(orgHeartbeatPath(heartbeat.org, baseDir), heartbeat);
 }
@@ -8194,7 +8518,7 @@ function isApiConsumerText(text) {
 function evidenceJson(evidence) {
   return JSON.stringify(evidence);
 }
-function shouldEmitProgress(current, total, interval = 100) {
+function shouldEmitProgress2(current, total, interval = 100) {
   return current === 1 || current === total || current % interval === 0;
 }
 function resolveOptions(baseDirOrOptions) {
@@ -8300,7 +8624,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
         });
         break;
       }
-      if (shouldEmitProgress(index + 1, imports.length)) {
+      if (shouldEmitProgress2(index + 1, imports.length)) {
         options.onProgress?.({
           stage: "building_import_edges",
           org: config.org,
@@ -8341,7 +8665,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
         bucket.push(apiContract);
         contractsByToken.set(sanitizedContract, bucket);
       }
-      if (shouldEmitProgress(index + 1, providerChunks.length)) {
+      if (shouldEmitProgress2(index + 1, providerChunks.length)) {
         options.onProgress?.({
           stage: "extracting_api_contracts",
           org: config.org,
@@ -8401,7 +8725,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           });
         }
       }
-      if (shouldEmitProgress(index + 1, consumerChunks.length)) {
+      if (shouldEmitProgress2(index + 1, consumerChunks.length)) {
         options.onProgress?.({
           stage: "matching_api_consumers",
           org: config.org,