@indigoai-us/hq-cloud 6.18.32 → 6.18.34

package/dist/watcher.test.js

@@ -232,7 +232,33 @@ describe("TreeWatcher pending backlog caps", () => {
             expect(result.scannedPaths).toBe(0);
             expect(result.batch.paths.size).toBe(50_000);
             expect(eventLoopTicks).toBeGreaterThan(1);
-            expect(Number(histogram.max) / 1_000_000).toBeLessThan(250);
+            expect(Number(histogram.max) / 1_000_000).toBeLessThan(50);
+        }
+        finally {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    });
+    it("uses async filesystem calls and prunes excluded trees during warm-up", async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-watcher-warmup-async-fs-"));
+        const allowed = path.join(dir, "core", "knowledge", "public");
+        const nodeModules = path.join(dir, "core", "workers", "demo", "node_modules", "pkg");
+        const target = path.join(dir, "core", "packages", "demo", "target", "debug");
+        fs.mkdirSync(allowed, { recursive: true });
+        fs.mkdirSync(nodeModules, { recursive: true });
+        fs.mkdirSync(target, { recursive: true });
+        fs.writeFileSync(path.join(allowed, "keep.md"), "keep");
+        fs.writeFileSync(path.join(nodeModules, "skip.js"), "skip");
+        fs.writeFileSync(path.join(target, "skip.o"), "skip");
+        try {
+            const watcher = new TreeWatcher({
+                hqRoot: dir,
+                pathFilter: createWatchPathFilter(dir, false),
+            });
+            const result = await watcher.collectWarmupCatchupAsync(Date.now() - 10_000);
+            expect(result.scannedPaths).toBeGreaterThan(0);
+            expect([...result.batch.paths.values()]).toEqual([
+                "core/knowledge/public/keep.md",
+            ]);
         }
         finally {
             fs.rmSync(dir, { recursive: true, force: true });
@@ -3933,20 +3959,33 @@ describe("Linux folder-only native backend (startScopedRecursiveWatch, recursive
         }
         expect(check()).toBe(true);
     }
+    function waitForReady(backend) {
+        return new Promise((resolve) => {
+            if (backend.onReady)
+                backend.onReady(resolve);
+            else
+                resolve();
+        });
+    }
     function startFolderOnly(opts = {}) {
-        const shouldEmit = createWatchPathFilter(root, false);
+        const shouldEmit = opts.includeAll
+            ? () => true
+            : createWatchPathFilter(root, false);
         return startScopedRecursiveWatch(root, shouldEmit, opts.onEvent ?? (() => { }), opts.onError ?? ((err) => { throw err; }), undefined, {
             recursiveWatches: false,
             maxWatchedPaths: opts.maxWatchedPaths,
             onWatchBudgetExceeded: opts.onWatchBudgetExceeded,
             listChildDirs: opts.listChildDirs,
+            watchDirectory: opts.watchDirectory,
+            directoryIdentity: opts.directoryIdentity,
         });
     }
-    it("takes exactly one watch per in-scope directory and none per file", () => {
+    it("takes exactly one watch per in-scope directory and none per file", async () => {
         const { inScopeDirs } = seedTree();
         const before = isLinux ? inotifyWatchDescriptors() : 0;
         const backend = startFolderOnly();
         try {
+            await waitForReady(backend);
             expect(backend.mode).toBe("native");
             expect(backend.attachFailures).toBe(0);
             // 4 in-scope directories; 8 in-scope files and an excluded subtree add nothing.
@@ -4081,6 +4120,7 @@ describe("Linux folder-only native backend (startScopedRecursiveWatch, recursive
         seedTree();
         const seen = [];
         const late = path.join(root, "notes", "late");
+        const watchEvents = new Map();
         // The plan walk lists `notes`, then — before any watch existed on the
         // old code path — `notes/late` appears. The snapshot plan never holds
         // it, and a shallow watch on `notes` attached only after the whole walk
@@ -4095,13 +4135,25 @@ describe("Linux folder-only native backend (startScopedRecursiveWatch, recursive
                 fs.mkdirSync(late);
             return children;
         };
-        const backend = startFolderOnly({ onEvent: (p) => seen.push(p), listChildDirs });
+        const backend = startFolderOnly({
+            onEvent: (p) => seen.push(p),
+            listChildDirs,
+            watchDirectory: ((dir, _options, listener) => {
+                watchEvents.set(path.resolve(String(dir)), listener);
+                const handle = new EventEmitter();
+                handle.close = () => { };
+                return handle;
+            }),
+        });
         try {
+            await waitForReady(backend);
+            watchEvents.get(path.join(root, "notes"))?.("rename", "late");
             // root, docs, docs/deep, notes — plus `late`, picked up by the live
             // watch on `notes` rather than by the plan.
             await waitFor(() => backend.watchedPathCount() === 5);
             const file = path.join(late, "inside.md");
             fs.writeFileSync(file, "x");
+            watchEvents.get(late)?.("rename", "inside.md");
             await waitFor(() => seen.includes(file));
         }
         finally {
@@ -4125,7 +4177,7 @@ describe("Linux folder-only native backend (startScopedRecursiveWatch, recursive
             backend.close();
         }
     });
-    it("stops attaching at the budget and reports the exhaustion exactly once, counting real watches", () => {
+    it("stops attaching at the budget and reports the exhaustion exactly once, counting real watches", async () => {
         seedTree();
         const exceeded = vi.fn();
         const backend = startFolderOnly({
@@ -4133,6 +4185,7 @@ describe("Linux folder-only native backend (startScopedRecursiveWatch, recursive
             onWatchBudgetExceeded: exceeded,
         });
         try {
+            await waitForReady(backend);
             expect(backend.watchedPathCount()).toBe(2);
             expect(exceeded).toHaveBeenCalledTimes(1);
             expect(exceeded.mock.calls[0][0]).toMatchObject({
@@ -4234,6 +4287,7 @@ describe("Linux folder-only native backend (startScopedRecursiveWatch, recursive
         w.onChange(changed);
         w.start();
         try {
+            await new Promise((resolve) => w.onReady(resolve));
             expect(w.watchMode()).toBe("native");
             expect(inotifyWatchDescriptors() - before).toBe(inScopeDirs.length);
             fs.writeFileSync(path.join(root, "notes", "new.md"), "hi");