lody 0.72.0 → 0.74.0

package/dist/code-collab-watch-worker.js

@@ -1,31 +1,124 @@
-import { watch } from "node:fs";
-import { a as parseWorkspaceWatchParentMessage, n as normalizeWorkspaceWatchFilename, s as shouldIgnoreWorkspaceWatchFilename } from "./chunks/workspace-watch-protocol-CSO-IQeE.js";
-import "node:path";
+import { watch, readdirSync } from "node:fs";
+import { C as CODE_COLLAB_IGNORED_DIRECTORY_NAMES, a as parseWorkspaceWatchParentMessage, n as normalizeWorkspaceWatchFilename, s as shouldIgnoreWorkspaceWatchFilename } from "./chunks/workspace-watch-protocol-CSO-IQeE.js";
+import path__default from "node:path";
+function planWorkspaceWatchTargets(root, entries) {
+  const targets = [{ directory: root, recursive: false }];
+  for (const entry of entries) {
+    if (!entry.isDirectory || CODE_COLLAB_IGNORED_DIRECTORY_NAMES.has(entry.name)) {
+      continue;
+    }
+    targets.push({ directory: path__default.join(root, entry.name), recursive: true });
+  }
+  return targets;
+}
+function rootEventMayChangeWatchPlan(filename) {
+  if (filename === null) {
+    return true;
+  }
+  const normalized = filename.replaceAll("\\", "/");
+  return !normalized.includes("/");
+}
+const defaultReadDirectory = (directory) => readdirSync(directory, { withFileTypes: true }).map((entry) => ({
+  name: entry.name,
+  isDirectory: entry.isDirectory()
+}));
 function startWorkspaceWatchWorker(options) {
   const watchers = /* @__PURE__ */ new Map();
   const watchFactory = options.watchFactory ?? watch;
+  const readDirectory = options.readDirectory ?? defaultReadDirectory;
   const startedAtMs = Date.now();
   let generation = 0;
   let reconfigurationCount = 0;
   let closed = false;
+  const closeRoot = (root) => {
+    for (const watcher of watchers.get(root) ?? []) watcher.close();
+    watchers.delete(root);
+  };
   const close = () => {
     if (closed) return;
     closed = true;
-    for (const watcher of watchers.values()) watcher.close();
-    watchers.clear();
+    for (const root of [...watchers.keys()]) closeRoot(root);
     clearInterval(statsTimer);
   };
+  const countWatchHandles = () => {
+    let total = 0;
+    for (const handles of watchers.values()) total += handles.length;
+    return total;
+  };
   const statsTimer = setInterval(() => {
     options.send({
       type: "code-collab-watch/stats",
       generation,
-      watcherCount: watchers.size,
+      watcherCount: countWatchHandles(),
       rssBytes: process.memoryUsage().rss,
       reconfigurationCount,
       uptimeMs: Date.now() - startedAtMs
     });
   }, options.statsIntervalMs ?? 3e4);
   statsTimer.unref?.();
+  const reportRootError = (root, error) => {
+    options.send({
+      type: "code-collab-watch/error",
+      generation,
+      root,
+      code: error instanceof Error && "code" in error ? String(error.code) : "UNKNOWN"
+    });
+  };
+  const installRoot = (root) => {
+    let entries;
+    try {
+      entries = readDirectory(root);
+    } catch (error) {
+      reportRootError(root, error);
+      return;
+    }
+    const handles = [];
+    const failRoot = (error) => {
+      const current = watchers.get(root);
+      if (current !== void 0 && current !== handles) return;
+      for (const handle of handles) handle.close();
+      watchers.delete(root);
+      reportRootError(root, error);
+    };
+    for (const target of planWorkspaceWatchTargets(root, entries)) {
+      const isRootWatch = target.directory === root;
+      try {
+        const watcher = watchFactory(
+          target.directory,
+          { recursive: target.recursive, persistent: false },
+          (_, filename) => {
+            if (closed) return;
+            const normalized = filename === null ? null : normalizeWorkspaceWatchFilename(filename);
+            if (normalized !== null && shouldIgnoreWorkspaceWatchFilename(normalized)) return;
+            if (isRootWatch && rootEventMayChangeWatchPlan(normalized)) {
+              scheduleReplan(root);
+            }
+            options.send({ type: "code-collab-watch/dirty", generation, root });
+          }
+        );
+        watcher.on("error", (error) => failRoot(error));
+        handles.push(watcher);
+      } catch (error) {
+        if (isRootWatch) {
+          failRoot(error);
+          return;
+        }
+      }
+    }
+    watchers.set(root, handles);
+  };
+  const replanScheduled = /* @__PURE__ */ new Set();
+  const scheduleReplan = (root) => {
+    if (replanScheduled.has(root)) return;
+    replanScheduled.add(root);
+    const timer = setTimeout(() => {
+      replanScheduled.delete(root);
+      if (closed || !watchers.has(root)) return;
+      closeRoot(root);
+      installRoot(root);
+    }, 0);
+    timer.unref?.();
+  };
   options.onMessage((raw) => {
     const message = parseWorkspaceWatchParentMessage(raw);
     if (!message || closed) return;
@@ -39,41 +132,14 @@ function startWorkspaceWatchWorker(options) {
     generation = message.generation;
     reconfigurationCount += 1;
     const desired = new Set(message.roots);
-    for (const [root, watcher] of watchers) {
+    for (const root of [...watchers.keys()]) {
       if (!desired.has(root)) {
-        watcher.close();
-        watchers.delete(root);
+        closeRoot(root);
       }
     }
     for (const root of desired) {
       if (watchers.has(root)) continue;
-      try {
-        const watcher = watchFactory(root, { recursive: true, persistent: false }, (_, filename) => {
-          if (filename !== null) {
-            const normalized = normalizeWorkspaceWatchFilename(filename);
-            if (normalized !== null && shouldIgnoreWorkspaceWatchFilename(normalized)) return;
-          }
-          options.send({ type: "code-collab-watch/dirty", generation, root });
-        });
-        watcher.on("error", (error) => {
-          watcher.close();
-          watchers.delete(root);
-          options.send({
-            type: "code-collab-watch/error",
-            generation,
-            root,
-            code: error.code ?? "UNKNOWN"
-          });
-        });
-        watchers.set(root, watcher);
-      } catch (error) {
-        options.send({
-          type: "code-collab-watch/error",
-          generation,
-          root,
-          code: error instanceof Error && "code" in error ? String(error.code) : "UNKNOWN"
-        });
-      }
+      installRoot(root);
     }
     options.send({
       type: "code-collab-watch/ready",

package/dist/codex-acp.js

@@ -3,5 +3,5 @@
     console.error("CODEX_PATH is required for the bundled Codex ACP adapter.");
     process.exit(1);
   }
-  await import("./chunks/index-Cbwwpq6s.js");
+  await import("./chunks/index-Cuqd9gip.js");
 })();

package/dist/file-index-scan-worker.js

@@ -1,7 +1,7 @@
 import { opendir } from "node:fs/promises";
 import path__default from "node:path";
-import { u as buildCodeCollabFileIndexState, z as scanGitDirectoryEntries, F as joinWorkspacePath, G as isInsideGitWorktree, x as computeAllChanges, H as pathSegmentComparisonKey, A as closeDirectoryQuietly } from "./chunks/directory-handle-D57OdGy1.js";
-import "./chunks/schemas-CDSDDVK-.js";
+import { x as buildCodeCollabFileIndexState, D as scanGitDirectoryEntries, F as joinWorkspacePath, G as isInsideGitWorktree, A as computeAllChanges, H as pathSegmentComparisonKey, E as closeDirectoryQuietly } from "./chunks/directory-handle-zGmrHbmq.js";
+import "./chunks/schemas-BDpQ67Nq.js";
 import "node:child_process";
 import "node:util";
 import "./chunks/diff-line-counts-BLxwWP6r.js";