presubmit 0.1.0 → 0.1.1

package/README.md

@@ -18,7 +18,7 @@ presubmit /absolute/path/to/your/repository
 For a locally built release, install its tarball instead:
 
 ```sh
-npm install -g ./presubmit-0.1.0.tgz
+npm install -g ./presubmit-0.1.1.tgz
 presubmit /absolute/path/to/your/repository
 ```
 
@@ -37,6 +37,10 @@ Sessions, uploads, worktrees, and credentials live under `~/.local/share/presubm
 Set `PRESUBMIT_HOME` to use another private data directory. Keep it outside your
 repository. These runtime files are not part of the npm package.
 
+At startup, file watching excludes existing Git-ignored paths, including datasets
+and downloaded models. Restart Presubmit after changing ignore rules or adding a
+large ignored directory so the watcher refreshes its exclusions.
+
 Use `presubmit --help` for CLI options. To follow an existing session in a terminal:
 
 ```sh

package/dist/apps/server/src/server.js

@@ -1708,21 +1708,24 @@ async function startLockedServer(options, cwd, lock) {
         return refresh;
     }
     let watcher;
+    const watcherError = (error) => {
+        if (!closing)
+            activity({
+                type: 'error',
+                text: 'File watcher unavailable; use Refresh. ' + errorText(error),
+            });
+    };
     try {
-        watcher = watchWorkspace(cwd, {
+        watcher = await watchWorkspace(cwd, {
             changed: () => {
                 void refreshWorkspace();
             },
-            error: (error) => {
-                if (!closing)
-                    activity({
-                        type: 'error',
-                        text: 'File watcher unavailable; use Refresh. ' + errorText(error),
-                    });
-            },
+            error: watcherError,
         });
     }
-    catch { }
+    catch (error) {
+        watcherError(error);
+    }
     let commandQueue = Promise.resolve();
     function acceptChildReport(id, text) {
         const operation = commandQueue.then(() => {

package/dist/apps/server/src/workspace-watcher.js

@@ -1,46 +1,101 @@
+import { execFile } from 'node:child_process';
 import { realpathSync } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { promisify } from 'node:util';
 import { watch } from 'chokidar';
 import { diagnosticsEnabled, performanceMetrics, diagnosticGauges } from './diagnostics.js';
-export function createWorkspaceWatchers(create = watch, debounceMs = 500) {
+const execute = promisify(execFile);
+/** Snapshot Git's exclusions before opening recursive filesystem subscriptions. */
+export async function workspaceWatchFilter(cwd) {
+    const ignoredFiles = new Set();
+    const ignoredDirectories = new Set();
+    try {
+        const { stdout } = await execute('git', ['ls-files', '--others', '--ignored', '--exclude-standard', '--directory', '-z'], {
+            cwd,
+            encoding: 'utf8',
+            maxBuffer: 16 * 1024 * 1024,
+            timeout: 30_000,
+            env: { ...process.env, GIT_OPTIONAL_LOCKS: '0', LC_ALL: 'C' },
+        });
+        for (const name of stdout.split('\0').filter(Boolean)) {
+            // Git keeps tracked files out of this list, even when an ignore rule matches.
+            if (name.endsWith('/'))
+                ignoredDirectories.add(resolve(cwd, name));
+            else
+                ignoredFiles.add(resolve(cwd, name));
+        }
+    }
+    catch (error) {
+        const failure = error;
+        if (failure.code !== 'ENOENT' && !failure.stderr?.includes('not a git repository'))
+            throw new Error('Could not load Git exclusions; automatic file watching is unavailable.', {
+                cause: error,
+            });
+    }
+    return (file) => {
+        const name = resolve(file);
+        const local = relative(cwd, name);
+        if (isAbsolute(local) || local === '..' || local.startsWith('..' + sep))
+            return true;
+        if (local.split(sep).some((part) => ['node_modules', '.git', 'dist', '.cache'].includes(part)))
+            return true;
+        if (ignoredFiles.has(name))
+            return true;
+        for (let parent = name; parent !== cwd; parent = dirname(parent)) {
+            if (ignoredDirectories.has(parent))
+                return true;
+        }
+        return false;
+    };
+}
+export function createWorkspaceWatchers(create = watch, debounceMs = 500, filter = workspaceWatchFilter) {
     const entries = new Map();
+    let subscribers = 0;
     const updateGauges = () => {
         diagnosticGauges.set('workspace.watchers', entries.size);
-        diagnosticGauges.set('workspace.subscribers', [...entries.values()].reduce((sum, entry) => sum + entry.subscribers.size, 0));
+        diagnosticGauges.set('workspace.subscribers', subscribers);
     };
-    return (cwd, subscriber) => {
+    const subscribe = async (cwd, subscriber) => {
         const key = realpathSync(cwd);
-        let entry = entries.get(key);
-        if (!entry) {
-            const watcher = create(key, {
-                ignoreInitial: true,
-                ignored: (path) => path
-                    .split(/[\\/]/)
-                    .some((segment) => ['node_modules', '.git', 'dist', '.cache'].includes(segment)),
-            });
-            entry = { watcher, subscribers: new Set() };
-            entries.set(key, entry);
-            const shared = entry;
-            watcher.on('all', () => {
-                if (diagnosticsEnabled)
-                    performanceMetrics.count('workspace.fileEvents');
-                // Coalesce a sustained stream as well as a short burst. Do not allocate
-                // a fresh timer for every event or postpone refresh indefinitely.
-                if (shared.timer)
-                    return;
-                shared.timer = setTimeout(() => {
-                    shared.timer = undefined;
+        let pending = entries.get(key);
+        if (!pending) {
+            pending = filter(key).then((ignored) => {
+                const watcher = create(key, { ignoreInitial: true, followSymlinks: false, ignored });
+                const entry = { watcher, subscribers: new Set() };
+                const shared = entry;
+                watcher.on('all', () => {
                     if (diagnosticsEnabled)
-                        performanceMetrics.count('workspace.changeBatches');
+                        performanceMetrics.count('workspace.fileEvents');
+                    // Coalesce a sustained stream as well as a short burst. Do not allocate
+                    // a fresh timer for every event or postpone refresh indefinitely.
+                    if (shared.timer)
+                        return;
+                    shared.timer = setTimeout(() => {
+                        shared.timer = undefined;
+                        if (diagnosticsEnabled)
+                            performanceMetrics.count('workspace.changeBatches');
+                        for (const listener of shared.subscribers)
+                            listener.changed();
+                    }, debounceMs);
+                });
+                watcher.on('error', (error) => {
                     for (const listener of shared.subscribers)
-                        listener.changed();
-                }, debounceMs);
+                        listener.error(error);
+                });
+                return entry;
             });
-            watcher.on('error', (error) => {
-                for (const listener of shared.subscribers)
-                    listener.error(error);
+            entries.set(key, pending);
+            void pending.catch(() => {
+                if (entries.get(key) === pending)
+                    entries.delete(key);
             });
         }
+        const entry = await pending;
+        // A last unsubscribe may have closed this entry while initialization was awaited.
+        if (entries.get(key) !== pending)
+            return subscribe(cwd, subscriber);
         entry.subscribers.add(subscriber);
+        subscribers++;
         updateGauges();
         const shared = entry;
         let closed;
@@ -48,6 +103,7 @@ export function createWorkspaceWatchers(create = watch, debounceMs = 500) {
             close() {
                 if (closed)
                     return closed;
+                subscribers--;
                 shared.subscribers.delete(subscriber);
                 if (!shared.subscribers.size) {
                     entries.delete(key);
@@ -61,5 +117,6 @@ export function createWorkspaceWatchers(create = watch, debounceMs = 500) {
             },
         };
     };
+    return subscribe;
 }
 export const watchWorkspace = createWorkspaceWatchers();

package/dist/apps/server/src/workspace.js

@@ -24,6 +24,8 @@ async function gitRoot(cwd) {
         const failure = error;
         if (failure.code === 'ENOENT' || failure.stderr?.includes('not a git repository'))
             return null;
+        if (failure.code === 'EMFILE' || failure.code === 'ENFILE')
+            throw new Error('Too many open files to inspect Git. Stop and restart Presubmit to release file watchers.', { cause: error });
         throw new Error('Could not inspect the folder’s Git repository.', { cause: error });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "presubmit",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A local coding agent and human review workspace",
   "type": "module",
   "bin": {