@indigoai-us/hq-cloud 5.26.0 → 5.28.0

package/test/e2e/watcher-recursive-backend.test.ts

@@ -0,0 +1,115 @@
+/**
+ * REAL-fs regression E2E for the single-recursive-watch backend.
+ *
+ * Why this exists:
+ * chokidar 4 dropped its `fsevents` backend, so on macOS it watches via kqueue
+ * — ~1 open fd PER watched path. Over a real HQ tree (~11k files+dirs) that
+ * exhausts the default soft `ulimit -n` (256) with EMFILE, silently killing the
+ * watcher so instant sync degrades to the 10-min poll. The fix replaces the
+ * per-path chokidar watch with a SINGLE recursive `fs.watch` on macOS/Windows
+ * (1 OS handle for the whole tree), filtering events per-path at emit time.
+ *
+ * These tests pin the two load-bearing behaviors of that backend (both also
+ * hold for the chokidar Linux fallback, so the suite is backend-agnostic):
+ *   1. A file created under a subtree that DID NOT EXIST when the watcher
+ *      started still fires — i.e. coverage doesn't depend on per-directory
+ *      watch registration at start time.
+ *   2. An out-of-scope edit (`repos/`, excluded by DEFAULT_IGNORES) does NOT
+ *      fire — the OS reports it under a recursive watch, and it must be dropped
+ *      by the emit filter, not woken on.
+ */
+
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { TreeWatcher } from "../../src/watcher.js";
+
+let hqRoot: string;
+let watcher: TreeWatcher | null = null;
+
+beforeEach(async () => {
+  hqRoot = await mkdtemp(path.join(tmpdir(), "hqcloud-recwatch-e2e-"));
+  await writeFile(path.join(hqRoot, ".hqinclude"), "companies/*/knowledge/\n");
+  // Only the `acme` company exists at start; `newco` is created later to prove
+  // the recursive watch covers subtrees born after start().
+  await mkdir(path.join(hqRoot, "companies", "acme", "knowledge"), {
+    recursive: true,
+  });
+});
+
+afterEach(async () => {
+  watcher?.dispose();
+  watcher = null;
+  await rm(hqRoot, { recursive: true, force: true });
+});
+
+/** Resolve true if the watcher emits a debounced change within `ms`, else false. */
+function waitForEmit(w: TreeWatcher, ms: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    let settled = false;
+    const off = w.onChange(() => {
+      if (settled) return;
+      settled = true;
+      off();
+      clearTimeout(t);
+      resolve(true);
+    });
+    const t = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      off();
+      resolve(false);
+    }, ms);
+  });
+}
+
+describe("event-push watcher -- single recursive watch backend", () => {
+  it(
+    "FIRES for an in-scope file created under a subtree that did not exist at start",
+    async () => {
+      watcher = new TreeWatcher({ hqRoot, debounceMs: 250, personalMode: false });
+      watcher.start();
+      // Let the recursive watch establish before any mutation.
+      await new Promise((r) => setTimeout(r, 600));
+
+      // Create a brand-new company subtree AFTER the watcher started. A
+      // per-directory watcher would only catch this if it dynamically
+      // registered the new dirs; the recursive watch covers it inherently.
+      await mkdir(path.join(hqRoot, "companies", "newco", "knowledge"), {
+        recursive: true,
+      });
+
+      const emitted = waitForEmit(watcher, 4000);
+      await writeFile(
+        path.join(hqRoot, "companies", "newco", "knowledge", "fresh.md"),
+        "# fresh\n",
+      );
+      expect(await emitted).toBe(true);
+    },
+    8000,
+  );
+
+  it(
+    "does NOT fire for an out-of-scope edit the OS reports under the recursive watch (repos/)",
+    async () => {
+      watcher = new TreeWatcher({ hqRoot, debounceMs: 250, personalMode: false });
+      watcher.start();
+      await new Promise((r) => setTimeout(r, 600));
+
+      // `repos/` is excluded by DEFAULT_IGNORES. Under a recursive OS watch the
+      // event is still delivered, so the emit filter — not watch-time pruning —
+      // is what must drop it.
+      await mkdir(path.join(hqRoot, "repos", "some-repo"), { recursive: true });
+      const emitted = waitForEmit(watcher, 2500);
+      await writeFile(
+        path.join(hqRoot, "repos", "some-repo", "code.ts"),
+        "export const x = 1;\n",
+      );
+      expect(await emitted).toBe(false);
+    },
+    8000,
+  );
+});