@pratik7368patil/anchor-core 0.1.25 → 0.1.26

package/dist/index.d.ts

@@ -574,6 +574,9 @@ type OrgGraphProgress = {
     edges: number;
     apiContracts: number;
     apiConsumers: number;
+    current?: number;
+    total?: number;
+    kind?: "edges" | "contracts" | "consumers";
 } | {
     stage: "completed_org_graph";
     org: string;
@@ -762,6 +765,15 @@ type CodeIndexProgress = {
     stage: "writing_code_index";
     repo: string;
     phase: string;
+} | {
+    stage: "inferring_test_awareness";
+    repo: string;
+    phase: "classifying_files" | "indexing_sources" | "linking_tests" | "completed";
+    current: number;
+    total: number;
+    testFiles: number;
+    testLinks: number;
+    filePath?: string;
 } | {
     stage: "deleting_existing_code_index";
     repo: string;
@@ -1131,8 +1143,11 @@ declare function indexCodebase(db: AnchorDatabase, options: {
 }): CodeIndexSummary;
 declare function emptyCodeIndexSummary(cwd: string): CodeIndexSummary;
 
+type TestAwarenessOptions = {
+    onProgress?: (progress: CodeIndexProgress) => void;
+};
 declare function isTestFilePath(filePath: string): boolean;
-declare function inferTestAwareness(repo: string, codeFiles: CodeFileRecord[], codeChunks: CodeChunk[]): {
+declare function inferTestAwareness(repo: string, codeFiles: CodeFileRecord[], codeChunks: CodeChunk[], options?: TestAwarenessOptions): {
     testFiles: TestFileRecord[];
     testLinks: TestLink[];
 };

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 inferTestAwareness(repo, codeFiles, codeChunks) {
-  const testFiles = codeFiles.filter((file) => isTestFilePath(file.path));
-  const sourceFiles = codeFiles.filter((file) => !isTestFilePath(file.path));
+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 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))
@@ -1911,7 +2070,9 @@ function replaceCodeIndex(db, repo, codeFiles, codeChunks, skippedFiles, cwd, ar
   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);
+  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);
@@ -2636,7 +2797,7 @@ 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) {
+function shouldEmitProgress2(current, total) {
   return current === 0 || current === 1 || current === total || current % ARCHITECTURE_PROGRESS_INTERVAL === 0;
 }
 function classifyArchitectureArea(filePath, language, content = "") {
@@ -2747,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, "/"));
@@ -2789,10 +2982,15 @@ function createPattern(input) {
 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?.({
@@ -2805,7 +3003,7 @@ function buildArchitectureIndex(repo, files, chunks, options = {}) {
   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)) {
+    if (shouldEmitProgress2(current, files.length)) {
       options.onProgress?.({
         stage: "building_architecture_imports",
         repo,
@@ -2833,7 +3031,7 @@ function buildArchitectureIndex(repo, files, chunks, options = {}) {
   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) ?? [];
+    const symbols = [...symbolSetsByPath.get(file.path) ?? []];
     components.push({
       repo,
       path: file.path,
@@ -2844,12 +3042,12 @@ function buildArchitectureIndex(repo, files, chunks, options = {}) {
       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 (shouldEmitProgress(current, files.length)) {
+    if (shouldEmitProgress2(current, files.length)) {
       options.onProgress?.({
         stage: "building_architecture_components",
         repo,
@@ -2906,7 +3104,7 @@ function buildArchitectureIndex(repo, files, chunks, options = {}) {
       })
     );
     patternProgress += 1;
-    if (shouldEmitProgress(patternProgress, patternTotal)) {
+    if (shouldEmitProgress2(patternProgress, patternTotal)) {
       options.onProgress?.({
         stage: "building_architecture_patterns",
         repo,
@@ -2931,7 +3129,7 @@ function buildArchitectureIndex(repo, files, chunks, options = {}) {
       })
     );
     patternProgress += 1;
-    if (shouldEmitProgress(patternProgress, patternTotal)) {
+    if (shouldEmitProgress2(patternProgress, patternTotal)) {
       options.onProgress?.({
         stage: "building_architecture_patterns",
         repo,
@@ -3887,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);
@@ -3968,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) {
@@ -4131,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);
     }
@@ -4167,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) {
@@ -4402,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));
@@ -4422,7 +4620,7 @@ function rowToRanked(row, input) {
     matchedSymbols
   };
 }
-function escapeRegExp4(value) {
+function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function rankRelevantTests(db, input) {
@@ -8484,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);
@@ -8518,7 +8723,7 @@ function isApiConsumerText(text) {
 function evidenceJson(evidence) {
   return JSON.stringify(evidence);
 }
-function shouldEmitProgress2(current, total, interval = 100) {
+function shouldEmitProgress3(current, total, interval = 100) {
   return current === 1 || current === total || current % interval === 0;
 }
 function resolveOptions(baseDirOrOptions) {
@@ -8598,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 (shouldEmitProgress2(index + 1, imports.length)) {
+      if (shouldEmitProgress3(index + 1, imports.length)) {
         options.onProgress?.({
           stage: "building_import_edges",
           org: config.org,
@@ -8665,7 +8867,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
         bucket.push(apiContract);
         contractsByToken.set(sanitizedContract, bucket);
       }
-      if (shouldEmitProgress2(index + 1, providerChunks.length)) {
+      if (shouldEmitProgress3(index + 1, providerChunks.length)) {
         options.onProgress?.({
           stage: "extracting_api_contracts",
           org: config.org,
@@ -8725,7 +8927,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           });
         }
       }
-      if (shouldEmitProgress2(index + 1, consumerChunks.length)) {
+      if (shouldEmitProgress3(index + 1, consumerChunks.length)) {
         options.onProgress?.({
           stage: "matching_api_consumers",
           org: config.org,
@@ -8757,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,
@@ -8770,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
@@ -8781,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,
@@ -8792,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
@@ -8803,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,
@@ -8823,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();