gitnexus 1.6.10-rc.12 → 1.6.10-rc.13

package/dist/core/run-analyze.js

@@ -424,10 +424,27 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
     // clear it, the on-disk index may be in a half-state. Cheapest path
     // back to a known-good index is to wipe + rebuild from scratch.
     if (existingMeta?.incrementalInProgress) {
+        const dirty = existingMeta.incrementalInProgress;
+        const dirtyDetails = typeof dirty === 'object'
+            ? [
+                dirty.phase ? `phase=${dirty.phase}` : undefined,
+                `toWrite=${dirty.toWriteCount}`,
+                dirty.importerExpansion !== undefined
+                    ? `importerExpansion=${dirty.importerExpansion}`
+                    : undefined,
+                dirty.effectiveWriteCount !== undefined
+                    ? `effectiveWrite=${dirty.effectiveWriteCount}`
+                    : undefined,
+                dirty.deleteCount !== undefined ? `deleteCount=${dirty.deleteCount}` : undefined,
+            ]
+                .filter(Boolean)
+                .join(', ')
+            : 'legacy dirty flag';
         log(
         // "analyze run", not "incremental run" — since #2099 F1 the flag is a
         // generic dirty marker written by BOTH writeback branches.
         'Previous analyze run did not complete cleanly (incrementalInProgress flag set); ' +
+            `last dirty state: ${dirtyDetails}; ` +
             'forcing full rebuild to restore a known-good index.');
         options = { ...options, force: true };
         // Reload meta after clearing the flag in-memory; we still want fileHashes
@@ -728,11 +745,15 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             `(skipping wipe + ${allFilePaths.length - hashDiff.toWrite.length} unchanged file rows preserved)`);
         // Set the dirty flag BEFORE any destructive DB mutation. Cleared on
         // success at the meta-save step. Scoped to this branch's meta.json.
+        const now = Date.now();
         await saveMeta(metaDir, {
             ...existingMeta,
             incrementalInProgress: {
-                startedAt: Date.now(),
+                startedAt: now,
+                updatedAt: now,
+                phase: 'pre-write',
                 toWriteCount: hashDiff.toWrite.length,
+                directWriteCount: hashDiff.toWrite.length,
             },
         });
     }
@@ -746,9 +767,15 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
         // pdg flip, certify zombie/missing BasicBlock rows indefinitely).
         // toWriteCount: 0 is the full-path sentinel (no incremental write set).
         if (existingMeta) {
+            const now = Date.now();
             await saveMeta(metaDir, {
                 ...existingMeta,
-                incrementalInProgress: { startedAt: Date.now(), toWriteCount: 0 },
+                incrementalInProgress: {
+                    startedAt: now,
+                    updatedAt: now,
+                    phase: 'full-rebuild',
+                    toWriteCount: 0,
+                },
             });
         }
         await closeLbug();
@@ -808,6 +835,20 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             const MAX_IMPORTER_BFS_DEPTH = 4;
             const writableFiles = new Set(hashDiff.toWrite);
             const directlyChangedCount = writableFiles.size;
+            const dirtyStartedAt = existingMeta.incrementalInProgress?.startedAt ?? Date.now();
+            const saveIncrementalDirtyState = async (phase, extra = {}) => {
+                await saveMeta(metaDir, {
+                    ...existingMeta,
+                    incrementalInProgress: {
+                        startedAt: dirtyStartedAt,
+                        updatedAt: Date.now(),
+                        phase,
+                        toWriteCount: writableFiles.size,
+                        directWriteCount: directlyChangedCount,
+                        ...extra,
+                    },
+                });
+            };
             // Shadow-seed: for ADDED files, queryImporters returns 0 (the new
             // file has no IMPORTS rows in the pre-pipeline DB yet). But pre-
             // existing unchanged files may have IMPORTS edges whose module-
@@ -850,6 +891,10 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                 }
             }
             const importerExpansion = writableFiles.size - directlyChangedCount;
+            await saveIncrementalDirtyState('importer-bfs', {
+                importerExpansion,
+                shadowSeedCount: shadowSeed.length,
+            });
             if (importerExpansion > 0) {
                 log(`Incremental: +${importerExpansion} importer(s) added to writable set ` +
                     `(BFS depth ≤ ${MAX_IMPORTER_BFS_DEPTH}` +
@@ -876,6 +921,12 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             // would otherwise call deleteNodesForFile twice for the same file
             // (Bugbot LOW finding on PR #1479).
             const filesToDelete = [...new Set([...effectiveWriteSet, ...hashDiff.deleted])];
+            await saveIncrementalDirtyState('effective-write-set', {
+                importerExpansion,
+                shadowSeedCount: shadowSeed.length,
+                effectiveWriteCount: effectiveWriteSet.size,
+                deleteCount: filesToDelete.length,
+            });
             for (let i = 0; i < filesToDelete.length; i++) {
                 const f = filesToDelete[i];
                 try {
@@ -925,6 +976,12 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             //    the SAME effectiveWriteSet so the subgraph and the deletes
             //    cover identical files (asymmetry would silently corrupt).
             const subgraph = extractChangedSubgraph(pipelineResult.graph, effectiveWriteSet);
+            await saveIncrementalDirtyState('load-graph', {
+                importerExpansion,
+                shadowSeedCount: shadowSeed.length,
+                effectiveWriteCount: effectiveWriteSet.size,
+                deleteCount: filesToDelete.length,
+            });
             await loadGraphToLbug(subgraph, pipelineResult.repoPath, storagePath, (msg) => {
                 lbugMsgCount++;
                 const pct = Math.min(84, 65 + Math.round((lbugMsgCount / (lbugMsgCount + 10)) * 19));

package/dist/storage/repo-manager.d.ts

@@ -110,9 +110,23 @@ export interface RepoMeta {
     incrementalInProgress?: {
         /** When the run started (epoch ms). */
         startedAt: number;
+        /** Last dirty-flag refresh (epoch ms). */
+        updatedAt?: number;
         /** Number of files in the writable set, for diagnostic logs.
          *  `0` on the full-rebuild path (no incremental write set exists). */
         toWriteCount: number;
+        /** Last completed writeback phase before the process stopped. */
+        phase?: string;
+        /** Directly changed/added files before importer expansion. */
+        directWriteCount?: number;
+        /** Extra files pulled into the writable set by importer BFS. */
+        importerExpansion?: number;
+        /** Files in the effective write set after graph-boundary expansion. */
+        effectiveWriteCount?: number;
+        /** Files whose persisted rows were scheduled for deletion. */
+        deleteCount?: number;
+        /** Added-file shadow seeds included in importer BFS. */
+        shadowSeedCount?: number;
     };
     /**
      * Name of the git branch this index represents (#2106). Absent for the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.12",
+  "version": "1.6.10-rc.13",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",