@pratik7368patil/anchor-core 0.1.24 → 0.1.26

package/dist/index.js

@@ -1299,6 +1299,7 @@ function countValidTeamRules(cwd) {
 
 // src/indexer/test-awareness.ts
 import path3 from "path";
+var TEST_AWARENESS_PROGRESS_INTERVAL = 500;
 function normalizePath(filePath) {
   return filePath.replace(/\\/g, "/").replace(/^\.\/+/, "");
 }
@@ -1335,25 +1336,127 @@ function strengthFor(reason) {
   if (reason === "same directory") return 0.7;
   return 0.5;
 }
-function pathMentionedInTest(testPath, sourcePath, chunksByFile) {
-  const text = (chunksByFile.get(testPath) ?? []).map((chunk) => chunk.sanitizedText).join("\n");
-  if (!text) return false;
-  const sourceNoExt = sourcePath.replace(/\.[^.]+$/i, "");
-  const sourceBase = basenameWithoutExtensions(sourcePath);
-  return text.includes(sourcePath) || text.includes(sourceNoExt) || new RegExp(`from\\s+["'][^"']*${escapeRegExp(sourceBase)}["']`, "i").test(text) || new RegExp(`require\\(["'][^"']*${escapeRegExp(sourceBase)}["']\\)`, "i").test(text);
+function shouldEmitProgress(current, total) {
+  return current === 0 || current === 1 || current === total || current % TEST_AWARENESS_PROGRESS_INTERVAL === 0;
 }
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function addToMap(map, key, value) {
+  const values = map.get(key) ?? [];
+  values.push(value);
+  map.set(key, values);
+}
+function withoutExtension(filePath) {
+  return normalizePath(filePath).replace(/\.[^.]+$/i, "");
+}
+function testText(testPath, chunksByFile) {
+  return (chunksByFile.get(testPath) ?? []).map((chunk) => chunk.sanitizedText).join("\n");
+}
+function importSpecifiers(text) {
+  const specifiers = [];
+  const patterns = [
+    /\bfrom\s+["']([^"']+)["']/g,
+    /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g,
+    /\brequire\s*\(\s*["']([^"']+)["']\s*\)/g
+  ];
+  for (const pattern of patterns) {
+    for (const match of text.matchAll(pattern)) {
+      if (match[1]) specifiers.push(match[1]);
+    }
+  }
+  return uniqueStrings(specifiers);
+}
+function pathLikeMentions(text) {
+  const mentions = /* @__PURE__ */ new Set();
+  const pattern = /[A-Za-z0-9_@./-]+(?:\.[A-Za-z0-9_@./-]+)?/g;
+  for (const match of text.matchAll(pattern)) {
+    const value = match[0];
+    if (value.includes("/") || /\.[A-Za-z0-9]+$/.test(value)) mentions.add(value);
+  }
+  return [...mentions];
 }
-function inferTestAwareness(repo, codeFiles, codeChunks) {
-  const testFiles = codeFiles.filter((file) => isTestFilePath(file.path));
-  const sourceFiles = codeFiles.filter((file) => !isTestFilePath(file.path));
+function sourceCandidatesForSpecifier(testPath, specifier, sourcesByBase, sourcesByPath, sourcesByNoExt) {
+  const normalizedSpecifier = normalizePath(specifier);
+  const candidates = [];
+  const add = (items) => {
+    if (items) candidates.push(...items);
+  };
+  add(sourcesByPath.get(normalizedSpecifier));
+  add(sourcesByNoExt.get(normalizedSpecifier));
+  if (normalizedSpecifier.startsWith(".")) {
+    const resolved = normalizePath(path3.posix.join(path3.posix.dirname(testPath), normalizedSpecifier));
+    add(sourcesByPath.get(resolved));
+    add(sourcesByNoExt.get(resolved));
+  }
+  const base = basenameWithoutExtensions(normalizedSpecifier).toLowerCase();
+  if (base) add(sourcesByBase.get(base));
+  return uniqueStrings(candidates.map((source) => source.path)).map((sourcePath) => sourcesByPath.get(sourcePath)?.[0]).filter((source) => source !== void 0);
+}
+function inferTestAwareness(repo, codeFiles, codeChunks, options = {}) {
+  const testFiles = [];
+  const sourceFiles = [];
+  options.onProgress?.({
+    stage: "inferring_test_awareness",
+    repo,
+    phase: "classifying_files",
+    current: 0,
+    total: codeFiles.length,
+    testFiles: 0,
+    testLinks: 0
+  });
+  for (const [index, file] of codeFiles.entries()) {
+    if (isTestFilePath(file.path)) testFiles.push(file);
+    else sourceFiles.push(file);
+    const current = index + 1;
+    if (shouldEmitProgress(current, codeFiles.length)) {
+      options.onProgress?.({
+        stage: "inferring_test_awareness",
+        repo,
+        phase: "classifying_files",
+        current,
+        total: codeFiles.length,
+        filePath: file.path,
+        testFiles: testFiles.length,
+        testLinks: 0
+      });
+    }
+  }
   const chunksByFile = /* @__PURE__ */ new Map();
   for (const chunk of codeChunks) {
     const chunks = chunksByFile.get(chunk.filePath) ?? [];
     chunks.push(chunk);
     chunksByFile.set(chunk.filePath, chunks);
   }
+  const sourcesByBase = /* @__PURE__ */ new Map();
+  const sourcesByDir = /* @__PURE__ */ new Map();
+  const sourcesByPath = /* @__PURE__ */ new Map();
+  const sourcesByNoExt = /* @__PURE__ */ new Map();
+  options.onProgress?.({
+    stage: "inferring_test_awareness",
+    repo,
+    phase: "indexing_sources",
+    current: 0,
+    total: sourceFiles.length,
+    testFiles: testFiles.length,
+    testLinks: 0
+  });
+  for (const [index, source] of sourceFiles.entries()) {
+    addToMap(sourcesByBase, basenameWithoutExtensions(source.path).toLowerCase(), source);
+    addToMap(sourcesByDir, sourceLikeDir(source.path).join("/"), source);
+    addToMap(sourcesByPath, normalizePath(source.path), source);
+    addToMap(sourcesByNoExt, withoutExtension(source.path), source);
+    const current = index + 1;
+    if (shouldEmitProgress(current, sourceFiles.length)) {
+      options.onProgress?.({
+        stage: "inferring_test_awareness",
+        repo,
+        phase: "indexing_sources",
+        current,
+        total: sourceFiles.length,
+        filePath: source.path,
+        testFiles: testFiles.length,
+        testLinks: 0
+      });
+    }
+  }
   const linkMap = /* @__PURE__ */ new Map();
   const addLink = (sourcePath, testPath, reason) => {
     const key = `${sourcePath}\0${testPath}\0${reason}`;
@@ -1365,22 +1468,78 @@ function inferTestAwareness(repo, codeFiles, codeChunks) {
       strength: strengthFor(reason)
     });
   };
-  for (const test of testFiles) {
+  options.onProgress?.({
+    stage: "inferring_test_awareness",
+    repo,
+    phase: "linking_tests",
+    current: 0,
+    total: testFiles.length,
+    testFiles: testFiles.length,
+    testLinks: 0
+  });
+  for (const [index, test] of testFiles.entries()) {
     const testBase = basenameWithoutExtensions(test.path).toLowerCase();
     const testDir = sourceLikeDir(test.path).join("/");
-    for (const source of sourceFiles) {
-      const sourceBase = basenameWithoutExtensions(source.path).toLowerCase();
-      const sourceDir = sourceLikeDir(source.path).join("/");
-      if (testBase === sourceBase) addLink(source.path, test.path, "same basename");
-      else if (testDir && sourceDir && testDir === sourceDir) {
+    for (const source of sourcesByBase.get(testBase) ?? []) {
+      addLink(source.path, test.path, "same basename");
+    }
+    if (testDir) {
+      for (const source of sourcesByDir.get(testDir) ?? []) {
+        if (basenameWithoutExtensions(source.path).toLowerCase() === testBase) continue;
         addLink(source.path, test.path, "same directory");
       }
-      if (pathMentionedInTest(test.path, source.path, chunksByFile)) {
-        addLink(source.path, test.path, "imported source path");
+    }
+    const text = testText(test.path, chunksByFile);
+    const importedSources = /* @__PURE__ */ new Map();
+    for (const specifier of importSpecifiers(text)) {
+      for (const source of sourceCandidatesForSpecifier(
+        test.path,
+        specifier,
+        sourcesByBase,
+        sourcesByPath,
+        sourcesByNoExt
+      )) {
+        importedSources.set(source.path, source);
+      }
+    }
+    for (const mention of pathLikeMentions(text)) {
+      for (const source of sourceCandidatesForSpecifier(
+        test.path,
+        mention,
+        sourcesByBase,
+        sourcesByPath,
+        sourcesByNoExt
+      )) {
+        importedSources.set(source.path, source);
       }
     }
+    for (const source of importedSources.values()) {
+      addLink(source.path, test.path, "imported source path");
+    }
+    const current = index + 1;
+    if (shouldEmitProgress(current, testFiles.length)) {
+      options.onProgress?.({
+        stage: "inferring_test_awareness",
+        repo,
+        phase: "linking_tests",
+        current,
+        total: testFiles.length,
+        filePath: test.path,
+        testFiles: testFiles.length,
+        testLinks: linkMap.size
+      });
+    }
   }
   const dedupedTests = testFiles.map(testRecord);
+  options.onProgress?.({
+    stage: "inferring_test_awareness",
+    repo,
+    phase: "completed",
+    current: testFiles.length,
+    total: testFiles.length,
+    testFiles: dedupedTests.length,
+    testLinks: linkMap.size
+  });
   return {
     testFiles: dedupedTests,
     testLinks: uniqueStrings([...linkMap.keys()]).map((key) => linkMap.get(key))
@@ -1535,6 +1694,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 +2065,24 @@ 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();
-  const testAwareness = inferTestAwareness(repo, codeFiles, codeChunks);
+  options.onProgress?.({ stage: "writing_code_index", repo, phase: "Inferring test awareness" });
+  const testAwareness = inferTestAwareness(repo, codeFiles, codeChunks, {
+    onProgress: options.onProgress
+  });
+  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 +2095,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 +2110,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 +2134,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 +2166,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 +2230,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 +2252,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 +2269,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 +2289,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 +2310,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 +2338,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 +2365,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 +2414,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 +2436,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 +2796,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 shouldEmitProgress2(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);
@@ -2579,15 +2908,47 @@ function extractCodeImports(sourcePath, content, codePaths, repo = "") {
     return true;
   });
 }
-function relatedTestsFor(filePath, allPaths) {
+function addToStringMap(map, key, value) {
+  const values = map.get(key) ?? [];
+  values.push(value);
+  map.set(key, values);
+}
+function testBaseFor(filePath) {
+  return path6.posix.parse(filePath).name.replace(/\.(test|spec)$/i, "");
+}
+function buildRelatedTestIndex(allPaths) {
+  const testPaths = allPaths.filter((candidate) => isTestFilePath(candidate));
+  const byBase = /* @__PURE__ */ new Map();
+  const byDirectory = /* @__PURE__ */ new Map();
+  for (const testPath of testPaths) {
+    addToStringMap(byBase, testBaseFor(testPath), testPath);
+    const segments = path6.posix.dirname(testPath).split("/").filter(Boolean);
+    for (let index = 1; index <= segments.length; index += 1) {
+      addToStringMap(byDirectory, segments.slice(0, index).join("/"), testPath);
+    }
+  }
+  return { testPaths, byBase, byDirectory };
+}
+function relatedTestsFor(filePath, index) {
   if (isTestFilePath(filePath)) return [];
   const parsed = path6.posix.parse(filePath);
   const basename = parsed.name.replace(/\.(test|spec)$/i, "");
-  return allPaths.filter((candidate) => isTestFilePath(candidate)).filter((candidate) => {
-    const candidateParsed = path6.posix.parse(candidate);
-    const candidateBase = candidateParsed.name.replace(/\.(test|spec)$/i, "");
-    return candidateBase === basename || candidate.startsWith(`${parsed.dir}/`) || candidate.includes(`/${basename}.`);
-  }).slice(0, 8);
+  const related = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (testPath) => {
+    if (seen.has(testPath)) return;
+    seen.add(testPath);
+    related.push(testPath);
+  };
+  for (const testPath of index.byBase.get(basename) ?? []) add(testPath);
+  if (parsed.dir) {
+    for (const testPath of index.byDirectory.get(parsed.dir) ?? []) add(testPath);
+  }
+  for (const testPath of index.testPaths) {
+    if (testPath.includes(`/${basename}.`)) add(testPath);
+    if (related.length >= 8) break;
+  }
+  return related.slice(0, 8);
 }
 function directoryLabel(filePath) {
   const directory = path6.posix.dirname(filePath.replace(/\\/g, "/"));
@@ -2618,28 +2979,60 @@ 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();
+  const relatedTestIndex = buildRelatedTestIndex(allPaths);
+  const symbolSetsByPath = /* @__PURE__ */ new Map();
   for (const chunk of chunks) {
-    const existing = symbolsByPath.get(chunk.filePath) ?? [];
-    symbolsByPath.set(chunk.filePath, uniqueStrings([...existing, ...chunk.symbols]).slice(0, 40));
+    const existing = symbolSetsByPath.get(chunk.filePath) ?? /* @__PURE__ */ new Set();
+    for (const symbol of chunk.symbols) {
+      if (existing.size >= 40) break;
+      existing.add(symbol);
+    }
+    symbolSetsByPath.set(chunk.filePath, existing);
+  }
+  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 (shouldEmitProgress2(current, files.length)) {
+      options.onProgress?.({
+        stage: "building_architecture_imports",
+        repo,
+        current,
+        total: files.length,
+        filePath: file.path,
+        imports: imports.length
+      });
+    }
   }
-  const imports = files.flatMap(
-    (file) => extractCodeImports(file.path, file.content, codePaths, repo)
-  );
   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 {
+    const symbols = [...symbolSetsByPath.get(file.path) ?? []];
+    components.push({
       repo,
       path: file.path,
       area,
@@ -2649,19 +3042,52 @@ function buildArchitectureIndex(repo, files, chunks) {
       imports: uniqueStrings(
         fileImports.map((item) => item.importedPath ?? item.specifier).filter(Boolean)
       ).slice(0, 20),
-      relatedTests: relatedTestsFor(file.path, allPaths),
+      relatedTests: relatedTestsFor(file.path, relatedTestIndex),
       confidence: area === "unknown" ? 0.45 : 0.82,
       updatedAt: file.updatedAt
-    };
-  });
+    });
+    const current = index + 1;
+    if (shouldEmitProgress2(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 +3103,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 (shouldEmitProgress2(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 +3128,17 @@ function buildArchitectureIndex(repo, files, chunks) {
         confidence: 0.62 + Math.min(0.25, value.count * 0.05)
       })
     );
+    patternProgress += 1;
+    if (shouldEmitProgress2(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 +3468,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 +3493,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 +3503,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 +3552,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 +3569,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,
@@ -3620,7 +4085,7 @@ function symbolMatch2(unit, querySymbols) {
     const lower = symbol.toLowerCase();
     if (unitSymbols.includes(lower)) best = Math.max(best, 1);
     else if (text.includes(`\`${lower}\``)) best = Math.max(best, 1);
-    else if (new RegExp(`\\b${escapeRegExp2(lower)}\\b`, "i").test(text))
+    else if (new RegExp(`\\b${escapeRegExp(lower)}\\b`, "i").test(text))
       best = Math.max(best, 0.66);
     else if (unitSymbols.some((candidate) => candidate.includes(lower) || lower.includes(candidate))) {
       best = Math.max(best, 0.35);
@@ -3701,7 +4166,7 @@ function scoreUnit(unit, input, duplicateCount, repeatedEvidenceCount, freshness
     rankSignals: parts
   };
 }
-function escapeRegExp2(value) {
+function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function loadCandidates(db, input) {
@@ -3864,7 +4329,7 @@ function symbolMatch3(chunk, querySymbols) {
   for (const symbol of querySymbols) {
     const lower = symbol.toLowerCase();
     if (chunkSymbols.includes(lower)) best = Math.max(best, 1);
-    else if (new RegExp(`\\b${escapeRegExp3(lower)}\\b`, "i").test(text)) best = Math.max(best, 0.7);
+    else if (new RegExp(`\\b${escapeRegExp2(lower)}\\b`, "i").test(text)) best = Math.max(best, 0.7);
     else if (chunkSymbols.some((candidate) => candidate.includes(lower) || lower.includes(candidate))) {
       best = Math.max(best, 0.42);
     }
@@ -3900,7 +4365,7 @@ function matchReasons3(parts) {
   if (parts.recency >= 0.75) reasons.push("recent code file");
   return reasons.slice(0, 5);
 }
-function escapeRegExp3(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function escapeLike(value) {
@@ -4135,7 +4600,7 @@ function rowToRanked(row, input) {
   const text = row.sanitized_text ?? "";
   const matchedSymbols = (input.symbols ?? []).filter((symbol) => {
     const lower = symbol.toLowerCase();
-    return symbols.some((candidate) => candidate.toLowerCase() === lower) || new RegExp(`\\b${escapeRegExp4(symbol)}\\b`, "i").test(text);
+    return symbols.some((candidate) => candidate.toLowerCase() === lower) || new RegExp(`\\b${escapeRegExp3(symbol)}\\b`, "i").test(text);
   });
   const exactFile = (input.files ?? []).some((file) => row.source_path === file);
   const basenameMatch = (input.files ?? []).some((file) => baseStem(file) === baseStem(row.path));
@@ -4155,7 +4620,7 @@ function rowToRanked(row, input) {
     matchedSymbols
   };
 }
-function escapeRegExp4(value) {
+function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function rankRelevantTests(db, input) {
@@ -7929,10 +8394,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);
 }
@@ -8160,6 +8682,13 @@ function dependenciesFor(manifest) {
     ...Object.keys(manifest.peerDependencies ?? {})
   ]);
 }
+function packageRootForSpecifier(specifier) {
+  const normalized = specifier.trim();
+  if (!normalized) return "";
+  const parts = normalized.split("/");
+  if (normalized.startsWith("@") && parts.length >= 2) return `${parts[0]}/${parts[1]}`;
+  return parts[0] ?? "";
+}
 function parseJsonArray9(value) {
   try {
     const parsed = JSON.parse(value);
@@ -8194,7 +8723,7 @@ function isApiConsumerText(text) {
 function evidenceJson(evidence) {
   return JSON.stringify(evidence);
 }
-function shouldEmitProgress(current, total, interval = 100) {
+function shouldEmitProgress3(current, total, interval = 100) {
   return current === 1 || current === total || current % interval === 0;
 }
 function resolveOptions(baseDirOrOptions) {
@@ -8274,33 +8803,30 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
          FROM code_imports ci
          JOIN repositories r ON r.id = ci.repo_id`
     ).all();
-    const packageMatchers = [...packageNames.entries()].flatMap(([repo, names]) => names.map((name) => ({ repo, name }))).sort((a, b) => b.name.length - a.name.length);
     imports.forEach((item, index) => {
       const sourceRepo = repoByName.get(item.repo);
       if (!sourceRepo) return;
-      for (const candidate of packageMatchers) {
-        if (candidate.repo === item.repo) continue;
-        const matched = item.specifier === candidate.name || item.specifier.startsWith(`${candidate.name}/`);
-        if (!matched) continue;
+      const rootSpecifier = packageRootForSpecifier(item.specifier);
+      const targetRepo = packageToRepo.get(rootSpecifier) ?? packageToRepo.get(item.specifier);
+      if (targetRepo && targetRepo !== item.repo) {
         addEdge({
           org: config.org,
           sourceRepo: item.repo,
           sourcePath: item.source_path,
-          targetRepo: candidate.repo,
+          targetRepo,
           targetPath: item.imported_path ?? void 0,
           relationship: "imports",
           evidence: [
             fileEvidence(
               item.repo,
               item.source_path,
-              `imports ${sanitizeHistoricalText(candidate.name)}`
+              `imports ${sanitizeHistoricalText(rootSpecifier || item.specifier)}`
             )
           ],
           confidence: parseJsonArray9(item.imported_symbols_json).length > 0 ? 0.88 : 0.76
         });
-        break;
       }
-      if (shouldEmitProgress(index + 1, imports.length)) {
+      if (shouldEmitProgress3(index + 1, imports.length)) {
         options.onProgress?.({
           stage: "building_import_edges",
           org: config.org,
@@ -8341,7 +8867,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
         bucket.push(apiContract);
         contractsByToken.set(sanitizedContract, bucket);
       }
-      if (shouldEmitProgress(index + 1, providerChunks.length)) {
+      if (shouldEmitProgress3(index + 1, providerChunks.length)) {
         options.onProgress?.({
           stage: "extracting_api_contracts",
           org: config.org,
@@ -8401,7 +8927,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           });
         }
       }
-      if (shouldEmitProgress(index + 1, consumerChunks.length)) {
+      if (shouldEmitProgress3(index + 1, consumerChunks.length)) {
         options.onProgress?.({
           stage: "matching_api_consumers",
           org: config.org,
@@ -8433,7 +8959,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
            confidence = excluded.confidence,
            created_at = excluded.created_at`
       );
-      for (const edge of edges) {
+      for (const [index, edge] of edges.entries()) {
         insertEdge.run(
           `oge_${stableId([edge.org, edge.sourceRepo, edge.sourcePath, edge.targetRepo, edge.targetPath ?? "", edge.relationship])}`,
           edge.org,
@@ -8446,6 +8972,19 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           edge.confidence,
           now
         );
+        const current = index + 1;
+        if (shouldEmitProgress3(current, edges.length, 500)) {
+          options.onProgress?.({
+            stage: "writing_org_graph",
+            org: config.org,
+            edges: current,
+            apiContracts: apiContracts.length,
+            apiConsumers: apiConsumers.length,
+            current,
+            total: edges.length,
+            kind: "edges"
+          });
+        }
       }
       const insertContract = db.prepare(
         `INSERT INTO org_api_contracts
@@ -8457,7 +8996,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
            confidence = excluded.confidence,
            created_at = excluded.created_at`
       );
-      for (const contract of apiContracts) {
+      for (const [index, contract] of apiContracts.entries()) {
         insertContract.run(
           `oac_${stableId([config.org, contract.repo, contract.filePath, contract.contract])}`,
           config.org,
@@ -8468,6 +9007,19 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           contract.confidence,
           now
         );
+        const current = index + 1;
+        if (shouldEmitProgress3(current, apiContracts.length, 500)) {
+          options.onProgress?.({
+            stage: "writing_org_graph",
+            org: config.org,
+            edges: edges.length,
+            apiContracts: current,
+            apiConsumers: apiConsumers.length,
+            current,
+            total: apiContracts.length,
+            kind: "contracts"
+          });
+        }
       }
       const insertConsumer = db.prepare(
         `INSERT INTO org_api_consumers
@@ -8479,7 +9031,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
            confidence = excluded.confidence,
            created_at = excluded.created_at`
       );
-      for (const consumer of apiConsumers) {
+      for (const [index, consumer] of apiConsumers.entries()) {
         insertConsumer.run(
           `oap_${stableId([
             consumer.org,
@@ -8499,6 +9051,19 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           consumer.confidence,
           now
         );
+        const current = index + 1;
+        if (shouldEmitProgress3(current, apiConsumers.length, 500)) {
+          options.onProgress?.({
+            stage: "writing_org_graph",
+            org: config.org,
+            edges: edges.length,
+            apiContracts: apiContracts.length,
+            apiConsumers: current,
+            current,
+            total: apiConsumers.length,
+            kind: "consumers"
+          });
+        }
       }
     });
     transaction();