gitnexus 1.6.11-rc.44 → 1.6.11-rc.45

package/dist/cli/analyze-watch.js

@@ -179,13 +179,15 @@ export function shouldStopAfterWatchRefreshFailure(error, paths) {
 export async function startWatchFileLoop(repoPath, debounceMs, refresh, onError, onWatcherError = (error) => onError(error, [])) {
     let ignorePath = await createWatchIgnorePredicate(repoPath);
     let ignoreControlValid = true;
+    let rearmPending = false;
+    let closed = false;
     const queue = new WatchRefreshQueue(async (paths) => {
         if (paths.some(isIgnoreControlPath) || !ignoreControlValid) {
             const retryingInvalidControls = !ignoreControlValid;
             try {
                 ignorePath = await createWatchIgnorePredicate(repoPath);
                 ignoreControlValid = true;
-                watcher.add(repoPath);
+                rearmPending = true;
             }
             catch (error) {
                 ignoreControlValid = false;
@@ -196,6 +198,12 @@ export async function startWatchFileLoop(repoPath, debounceMs, refresh, onError,
                     : error);
             }
         }
+        // Re-arm before refreshing, never after: the refresh reads the whole
+        // repository, so a write that lands while the replacement watcher is
+        // arming is still picked up by this refresh, and a write that lands
+        // afterwards is reported by the armed watcher.
+        if (rearmPending)
+            await rearmWatcher();
         await refresh(paths);
     }, onError, debounceMs, {
         maxWaitMs: Math.max(2_000, debounceMs * 10),
@@ -203,46 +211,90 @@ export async function startWatchFileLoop(repoPath, debounceMs, refresh, onError,
         holdEventsUntilInitialRefresh: true,
         isPriorityPath: (filePath) => isIgnoreControlPath(filePath) || isConfigControlPath(filePath),
     });
-    const watcher = watch(repoPath, {
-        ignoreInitial: true,
-        atomic: true,
-        followSymlinks: false,
-        awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 20 },
-        ignored: (candidate, stats) => {
-            const relative = repoRelativeWatchPath(repoPath, candidate);
-            if (relative !== null && isAnalyzerOwnedWatchPath(relative))
-                return true;
-            if (relative !== null && (isIgnoreControlPath(relative) || isConfigControlPath(relative))) {
-                return false;
+    const createWatcher = () => {
+        const created = watch(repoPath, {
+            ignoreInitial: true,
+            atomic: true,
+            followSymlinks: false,
+            awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 20 },
+            ignored: (candidate, stats) => {
+                const relative = repoRelativeWatchPath(repoPath, candidate);
+                if (relative !== null && isAnalyzerOwnedWatchPath(relative))
+                    return true;
+                if (relative !== null && (isIgnoreControlPath(relative) || isConfigControlPath(relative))) {
+                    return false;
+                }
+                return ignorePath(candidate, stats?.isDirectory() ?? false);
+            },
+        });
+        // Events from an instance being retired are kept: they overlap with the
+        // replacement's coverage and the queue coalesces the duplicates.
+        created.on('all', (event, changedPath) => {
+            if (event !== 'add' && event !== 'change' && event !== 'unlink')
+                return;
+            const relative = repoRelativeWatchPath(repoPath, changedPath);
+            if (relative && isRelevantWatchPath(relative) && !isAnalyzerOwnedWatchPath(relative)) {
+                queue.enqueue(relative);
             }
-            return ignorePath(candidate, stats?.isDirectory() ?? false);
-        },
-    });
-    watcher.on('all', (event, changedPath) => {
-        if (event !== 'add' && event !== 'change' && event !== 'unlink')
+        });
+        created.on('error', (error) => {
+            // Replacement failures before the swap are reported through `waitUntilReady`.
+            if (created !== watcher)
+                return;
+            // Chokidar can surface a transient EPERM on Windows while an ignored
+            // analyzer-owned path is replaced. Re-arm the watcher and force one
+            // bounded catch-up refresh so a missed event cannot leave the graph
+            // stale. Other watcher errors may mean coverage was lost and stay fatal.
+            if (TRANSIENT_WATCH_ERROR_CODES.has(error.code ?? '')) {
+                rearmPending = true;
+                queue.enqueue(WATCH_FULL_REFRESH_PATH);
+                return;
+            }
+            onWatcherError(error);
+        });
+        return created;
+    };
+    let watcher = createWatcher();
+    // Chokidar emits `ready` once per instance and `add()` returns before the
+    // rescan it starts has finished, with no signal for that completion. A file
+    // an ignore-rule reload has just unignored is therefore still unregistered
+    // when `add()` returns, and because `ignoreInitial` suppresses the `add` the
+    // rescan would emit, an immediate rewrite of that file is dropped for good
+    // (reproduced on chokidar 4 and 5). So re-arm by arming a replacement
+    // watcher and awaiting its `ready` instead. The outgoing instance keeps
+    // reporting until the replacement is armed, so the swap has no blind window,
+    // and a replacement that fails to arm leaves the working instance in place.
+    const rearmWatcher = async () => {
+        rearmPending = false;
+        if (closed)
             return;
-        const relative = repoRelativeWatchPath(repoPath, changedPath);
-        if (relative && isRelevantWatchPath(relative) && !isAnalyzerOwnedWatchPath(relative)) {
-            queue.enqueue(relative);
+        const replacement = createWatcher();
+        try {
+            await waitUntilReady(replacement);
         }
-    });
-    watcher.on('error', (error) => {
-        // Chokidar can surface a transient EPERM on Windows while an ignored
-        // analyzer-owned path is replaced. Re-arm the root and force one bounded
-        // catch-up refresh so a missed event cannot leave the graph stale. Other
-        // watcher errors may mean coverage was lost and remain fatal.
-        if (TRANSIENT_WATCH_ERROR_CODES.has(error.code ?? '')) {
-            watcher.add(repoPath);
-            queue.enqueue(WATCH_FULL_REFRESH_PATH);
-            return;
+        catch (error) {
+            rearmPending = true;
+            try {
+                await replacement.close();
+            }
+            catch {
+                // The instance never became live; the arm error is the one to report.
+            }
+            throw new WatchControlReloadError(new Error('Unable to re-arm the filesystem watcher', { cause: error }));
         }
-        onWatcherError(error);
-    });
+        const retired = watcher;
+        watcher = replacement;
+        await retired.close();
+        // `close()` can land between arming the replacement and the swap above.
+        if (closed)
+            await replacement.close();
+    };
     try {
         await waitUntilReady(watcher);
         await queue.runInitial();
     }
     catch (error) {
+        closed = true;
         await watcher.close();
         await queue.close();
         throw error;
@@ -250,6 +302,7 @@ export async function startWatchFileLoop(repoPath, debounceMs, refresh, onError,
     return {
         waitForIdle: () => queue.waitForIdle(),
         close: async () => {
+            closed = true;
             await watcher.close();
             await queue.close();
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.11-rc.44",
+  "version": "1.6.11-rc.45",
   "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",