@karmaniverous/jeeves-watcher 0.18.2 → 0.18.3

package/dist/cli/jeeves-watcher/{index-1dpUCttm.js → index-Dk_WrV0T.js}

@@ -747,6 +747,104 @@ class ValuesManager extends BinaryFileStore {
     }
 }
 
+/**
+ * @module watcher/globToDir
+ * Adapts glob-based watch config to chokidar v4+, which removed glob support
+ * (see paulmillr/chokidar#1350). Chokidar v4 treats glob patterns as literal
+ * strings, silently producing zero events. This module extracts static directory
+ * roots from glob patterns for chokidar to watch, then filters emitted events
+ * against the original globs via picomatch.
+ */
+/**
+ * Extract the static directory root from a glob pattern.
+ * Stops at the first segment containing glob characters (`*`, `{`, `?`, `[`).
+ *
+ * @param glob - A glob pattern (e.g., `j:/domains/**\/*.json`).
+ * @returns The static directory prefix (e.g., `j:/domains`).
+ */
+function globRoot(glob) {
+    const normalized = normalizeSlashes(glob);
+    const segments = normalized.split('/');
+    const staticSegments = [];
+    for (const seg of segments) {
+        if (/[*?{[\]]/.test(seg))
+            break;
+        staticSegments.push(seg);
+    }
+    return staticSegments.join('/') || '.';
+}
+/**
+ * Deduplicate directory roots, removing paths that are subdirectories of others.
+ *
+ * @param roots - Array of directory paths.
+ * @returns Deduplicated array with subdirectories removed.
+ */
+function deduplicateRoots(roots) {
+    const normalized = roots.map((r) => normalizeSlashes(r).toLowerCase());
+    const sorted = [...new Set(normalized)].sort();
+    return sorted.filter((root, _i, arr) => {
+        const withSlash = root.endsWith('/') ? root : root + '/';
+        return !arr.some((other) => other !== root && withSlash.startsWith(other + '/'));
+    });
+}
+/**
+ * Build a picomatch matcher from an array of glob patterns.
+ * Normalizes Windows paths (backslash → forward slash, lowercase drive letter)
+ * before matching.
+ *
+ * @param globs - Glob patterns to match against.
+ * @returns A function that tests whether a file path matches any of the globs.
+ */
+function buildGlobMatcher(globs) {
+    const normalizedGlobs = globs.map((g) => normalizeSlashes(g));
+    const isMatch = picomatch(normalizedGlobs, { dot: true, nocase: true });
+    return (filePath) => {
+        const normalized = normalizeSlashes(filePath);
+        return isMatch(normalized);
+    };
+}
+/**
+ * Convert an array of glob patterns into chokidar-compatible directory roots
+ * and a filter function for post-hoc event filtering.
+ *
+ * @param globs - Glob patterns from the watch config.
+ * @returns Object with `roots` (directories for chokidar) and `matches` (filter function).
+ */
+function resolveWatchPaths(globs) {
+    const rawRoots = globs.map(globRoot);
+    const roots = deduplicateRoots(rawRoots);
+    const matches = buildGlobMatcher(globs);
+    return { roots, matches };
+}
+/**
+ * Convert ignored glob patterns to picomatch matcher functions.
+ *
+ * Chokidar v5 replaced the external `anymatch` dependency with an inline
+ * implementation that does **exact string equality** for string matchers,
+ * breaking glob-based `ignored` patterns. This function converts glob strings
+ * to picomatch functions that chokidar's `createPattern` passes through
+ * unchanged (`typeof matcher === 'function'`).
+ *
+ * Non-string entries (functions, RegExps) are passed through as-is.
+ *
+ * @param ignored - Array of ignored patterns (globs, functions, RegExps).
+ * @returns Array with glob strings replaced by picomatch matcher functions.
+ */
+function resolveIgnored(ignored) {
+    return ignored.map((entry) => {
+        if (typeof entry !== 'string')
+            return entry;
+        // If the string contains glob characters, convert to a picomatch function.
+        // Literal strings (exact paths) are also converted for consistent matching.
+        const normalizedPattern = normalizeSlashes(entry);
+        const matcher = picomatch(normalizedPattern, { dot: true, nocase: true });
+        return (filePath) => {
+            const normalized = normalizeSlashes(filePath);
+            return matcher(normalized);
+        };
+    });
+}
+
 /**
  * @module vcs/CommitMessageGenerator
  * Generates AI-powered commit messages via the Anthropic Messages API.
@@ -1480,11 +1578,10 @@ class VcsCoordinator {
             const rootVcs = entry.vcs?.enabled ?? config.vcs.enabled;
             if (!rootVcs)
                 continue;
-            if (/[*?{[]/.test(entry.path)) {
-                logger.warn({ path: entry.path }, 'Skipping VCS for watch path containing glob characters');
+            const resolvedRoot = normalizeSlashes(resolve(globRoot(entry.path)));
+            // Deduplicate: skip if another glob already resolved to this root.
+            if (this.managers.has(resolvedRoot))
                 continue;
-            }
-            const resolvedRoot = normalizeSlashes(resolve(entry.path));
             const mergedConfig = {
                 ...config.vcs,
                 ...entry.vcs,
@@ -3088,20 +3185,22 @@ async function initVcs(config, logger) {
     }
     const stateDir = config.stateDir ?? '.jeeves-metadata';
     const pathStrings = extractWatchPathStrings(config.watch.paths);
-    const staticPaths = pathStrings.filter((p) => !/[*?{[]/.test(p));
+    const staticPaths = pathStrings.map((p) => globRoot(p));
     validateStateDirOverlap(stateDir, staticPaths);
     const normalized = normalizeWatchPaths(config.watch.paths);
+    const initializedRoots = new Set();
     for (const entry of normalized) {
         const rootVcs = entry.vcs?.enabled ?? config.vcs.enabled;
         if (!rootVcs)
             continue;
-        if (/[*?{[]/.test(entry.path)) {
-            logger.warn({ path: entry.path }, 'Skipping VCS init for watch path containing glob characters');
+        const root = globRoot(entry.path);
+        // Deduplicate: skip if another glob already resolved to this root.
+        if (initializedRoots.has(root))
             continue;
-        }
-        await initRepo(entry.path);
-        await ensureGitignore(entry.path);
-        logger.info({ root: entry.path }, 'VCS initialized for watch root');
+        initializedRoots.add(root);
+        await initRepo(root);
+        await ensureGitignore(root);
+        logger.info({ root }, 'VCS initialized for watch root');
     }
     return true;
 }
@@ -7054,104 +7153,6 @@ class SystemHealth {
     }
 }
 
-/**
- * @module watcher/globToDir
- * Adapts glob-based watch config to chokidar v4+, which removed glob support
- * (see paulmillr/chokidar#1350). Chokidar v4 treats glob patterns as literal
- * strings, silently producing zero events. This module extracts static directory
- * roots from glob patterns for chokidar to watch, then filters emitted events
- * against the original globs via picomatch.
- */
-/**
- * Extract the static directory root from a glob pattern.
- * Stops at the first segment containing glob characters (`*`, `{`, `?`, `[`).
- *
- * @param glob - A glob pattern (e.g., `j:/domains/**\/*.json`).
- * @returns The static directory prefix (e.g., `j:/domains`).
- */
-function globRoot(glob) {
-    const normalized = normalizeSlashes(glob);
-    const segments = normalized.split('/');
-    const staticSegments = [];
-    for (const seg of segments) {
-        if (/[*?{[\]]/.test(seg))
-            break;
-        staticSegments.push(seg);
-    }
-    return staticSegments.join('/') || '.';
-}
-/**
- * Deduplicate directory roots, removing paths that are subdirectories of others.
- *
- * @param roots - Array of directory paths.
- * @returns Deduplicated array with subdirectories removed.
- */
-function deduplicateRoots(roots) {
-    const normalized = roots.map((r) => normalizeSlashes(r).toLowerCase());
-    const sorted = [...new Set(normalized)].sort();
-    return sorted.filter((root, _i, arr) => {
-        const withSlash = root.endsWith('/') ? root : root + '/';
-        return !arr.some((other) => other !== root && withSlash.startsWith(other + '/'));
-    });
-}
-/**
- * Build a picomatch matcher from an array of glob patterns.
- * Normalizes Windows paths (backslash → forward slash, lowercase drive letter)
- * before matching.
- *
- * @param globs - Glob patterns to match against.
- * @returns A function that tests whether a file path matches any of the globs.
- */
-function buildGlobMatcher(globs) {
-    const normalizedGlobs = globs.map((g) => normalizeSlashes(g));
-    const isMatch = picomatch(normalizedGlobs, { dot: true, nocase: true });
-    return (filePath) => {
-        const normalized = normalizeSlashes(filePath);
-        return isMatch(normalized);
-    };
-}
-/**
- * Convert an array of glob patterns into chokidar-compatible directory roots
- * and a filter function for post-hoc event filtering.
- *
- * @param globs - Glob patterns from the watch config.
- * @returns Object with `roots` (directories for chokidar) and `matches` (filter function).
- */
-function resolveWatchPaths(globs) {
-    const rawRoots = globs.map(globRoot);
-    const roots = deduplicateRoots(rawRoots);
-    const matches = buildGlobMatcher(globs);
-    return { roots, matches };
-}
-/**
- * Convert ignored glob patterns to picomatch matcher functions.
- *
- * Chokidar v5 replaced the external `anymatch` dependency with an inline
- * implementation that does **exact string equality** for string matchers,
- * breaking glob-based `ignored` patterns. This function converts glob strings
- * to picomatch functions that chokidar's `createPattern` passes through
- * unchanged (`typeof matcher === 'function'`).
- *
- * Non-string entries (functions, RegExps) are passed through as-is.
- *
- * @param ignored - Array of ignored patterns (globs, functions, RegExps).
- * @returns Array with glob strings replaced by picomatch matcher functions.
- */
-function resolveIgnored(ignored) {
-    return ignored.map((entry) => {
-        if (typeof entry !== 'string')
-            return entry;
-        // If the string contains glob characters, convert to a picomatch function.
-        // Literal strings (exact paths) are also converted for consistent matching.
-        const normalizedPattern = normalizeSlashes(entry);
-        const matcher = picomatch(normalizedPattern, { dot: true, nocase: true });
-        return (filePath) => {
-            const normalized = normalizeSlashes(filePath);
-            return matcher(normalized);
-        };
-    });
-}
-
 /**
  * @module watcher/MoveCorrelator
  * Correlates unlink+add events as file moves using content hash matching.

package/dist/cli/jeeves-watcher/index.js

@@ -224,7 +224,7 @@ async function startFromConfig(configPath, descriptor) {
     const config = await loadConfig(resolvedPath);
     // Dynamic import breaks the circular dependency between this module
     // and app/index.ts (which defines JeevesWatcher and re-exports startFromConfig).
-    const { JeevesWatcher } = await import('./index-1dpUCttm.js');
+    const { JeevesWatcher } = await import('./index-Dk_WrV0T.js');
     const app = new JeevesWatcher(config, resolvedPath, descriptor);
     installShutdownHandlers(() => app.stop());
     await app.start();

package/dist/index.js

@@ -4654,6 +4654,104 @@ async function ensureGitignore(rootPath, alwaysOnEntries = []) {
     }
 }
 
+/**
+ * @module watcher/globToDir
+ * Adapts glob-based watch config to chokidar v4+, which removed glob support
+ * (see paulmillr/chokidar#1350). Chokidar v4 treats glob patterns as literal
+ * strings, silently producing zero events. This module extracts static directory
+ * roots from glob patterns for chokidar to watch, then filters emitted events
+ * against the original globs via picomatch.
+ */
+/**
+ * Extract the static directory root from a glob pattern.
+ * Stops at the first segment containing glob characters (`*`, `{`, `?`, `[`).
+ *
+ * @param glob - A glob pattern (e.g., `j:/domains/**\/*.json`).
+ * @returns The static directory prefix (e.g., `j:/domains`).
+ */
+function globRoot(glob) {
+    const normalized = normalizeSlashes(glob);
+    const segments = normalized.split('/');
+    const staticSegments = [];
+    for (const seg of segments) {
+        if (/[*?{[\]]/.test(seg))
+            break;
+        staticSegments.push(seg);
+    }
+    return staticSegments.join('/') || '.';
+}
+/**
+ * Deduplicate directory roots, removing paths that are subdirectories of others.
+ *
+ * @param roots - Array of directory paths.
+ * @returns Deduplicated array with subdirectories removed.
+ */
+function deduplicateRoots(roots) {
+    const normalized = roots.map((r) => normalizeSlashes(r).toLowerCase());
+    const sorted = [...new Set(normalized)].sort();
+    return sorted.filter((root, _i, arr) => {
+        const withSlash = root.endsWith('/') ? root : root + '/';
+        return !arr.some((other) => other !== root && withSlash.startsWith(other + '/'));
+    });
+}
+/**
+ * Build a picomatch matcher from an array of glob patterns.
+ * Normalizes Windows paths (backslash → forward slash, lowercase drive letter)
+ * before matching.
+ *
+ * @param globs - Glob patterns to match against.
+ * @returns A function that tests whether a file path matches any of the globs.
+ */
+function buildGlobMatcher(globs) {
+    const normalizedGlobs = globs.map((g) => normalizeSlashes(g));
+    const isMatch = picomatch(normalizedGlobs, { dot: true, nocase: true });
+    return (filePath) => {
+        const normalized = normalizeSlashes(filePath);
+        return isMatch(normalized);
+    };
+}
+/**
+ * Convert an array of glob patterns into chokidar-compatible directory roots
+ * and a filter function for post-hoc event filtering.
+ *
+ * @param globs - Glob patterns from the watch config.
+ * @returns Object with `roots` (directories for chokidar) and `matches` (filter function).
+ */
+function resolveWatchPaths(globs) {
+    const rawRoots = globs.map(globRoot);
+    const roots = deduplicateRoots(rawRoots);
+    const matches = buildGlobMatcher(globs);
+    return { roots, matches };
+}
+/**
+ * Convert ignored glob patterns to picomatch matcher functions.
+ *
+ * Chokidar v5 replaced the external `anymatch` dependency with an inline
+ * implementation that does **exact string equality** for string matchers,
+ * breaking glob-based `ignored` patterns. This function converts glob strings
+ * to picomatch functions that chokidar's `createPattern` passes through
+ * unchanged (`typeof matcher === 'function'`).
+ *
+ * Non-string entries (functions, RegExps) are passed through as-is.
+ *
+ * @param ignored - Array of ignored patterns (globs, functions, RegExps).
+ * @returns Array with glob strings replaced by picomatch matcher functions.
+ */
+function resolveIgnored(ignored) {
+    return ignored.map((entry) => {
+        if (typeof entry !== 'string')
+            return entry;
+        // If the string contains glob characters, convert to a picomatch function.
+        // Literal strings (exact paths) are also converted for consistent matching.
+        const normalizedPattern = normalizeSlashes(entry);
+        const matcher = picomatch(normalizedPattern, { dot: true, nocase: true });
+        return (filePath) => {
+            const normalized = normalizeSlashes(filePath);
+            return matcher(normalized);
+        };
+    });
+}
+
 /**
  * @module vcs/VcsManager
  * Per-root VCS manager for git-backed content versioning.
@@ -4957,11 +5055,10 @@ class VcsCoordinator {
             const rootVcs = entry.vcs?.enabled ?? config.vcs.enabled;
             if (!rootVcs)
                 continue;
-            if (/[*?{[]/.test(entry.path)) {
-                logger.warn({ path: entry.path }, 'Skipping VCS for watch path containing glob characters');
+            const resolvedRoot = normalizeSlashes(resolve(globRoot(entry.path)));
+            // Deduplicate: skip if another glob already resolved to this root.
+            if (this.managers.has(resolvedRoot))
                 continue;
-            }
-            const resolvedRoot = normalizeSlashes(resolve(entry.path));
             const mergedConfig = {
                 ...config.vcs,
                 ...entry.vcs,
@@ -5224,20 +5321,22 @@ async function initVcs(config, logger) {
     }
     const stateDir = config.stateDir ?? '.jeeves-metadata';
     const pathStrings = extractWatchPathStrings(config.watch.paths);
-    const staticPaths = pathStrings.filter((p) => !/[*?{[]/.test(p));
+    const staticPaths = pathStrings.map((p) => globRoot(p));
     validateStateDirOverlap(stateDir, staticPaths);
     const normalized = normalizeWatchPaths(config.watch.paths);
+    const initializedRoots = new Set();
     for (const entry of normalized) {
         const rootVcs = entry.vcs?.enabled ?? config.vcs.enabled;
         if (!rootVcs)
             continue;
-        if (/[*?{[]/.test(entry.path)) {
-            logger.warn({ path: entry.path }, 'Skipping VCS init for watch path containing glob characters');
+        const root = globRoot(entry.path);
+        // Deduplicate: skip if another glob already resolved to this root.
+        if (initializedRoots.has(root))
             continue;
-        }
-        await initRepo(entry.path);
-        await ensureGitignore(entry.path);
-        logger.info({ root: entry.path }, 'VCS initialized for watch root');
+        initializedRoots.add(root);
+        await initRepo(root);
+        await ensureGitignore(root);
+        logger.info({ root }, 'VCS initialized for watch root');
     }
     return true;
 }
@@ -8093,104 +8192,6 @@ class SystemHealth {
     }
 }
 
-/**
- * @module watcher/globToDir
- * Adapts glob-based watch config to chokidar v4+, which removed glob support
- * (see paulmillr/chokidar#1350). Chokidar v4 treats glob patterns as literal
- * strings, silently producing zero events. This module extracts static directory
- * roots from glob patterns for chokidar to watch, then filters emitted events
- * against the original globs via picomatch.
- */
-/**
- * Extract the static directory root from a glob pattern.
- * Stops at the first segment containing glob characters (`*`, `{`, `?`, `[`).
- *
- * @param glob - A glob pattern (e.g., `j:/domains/**\/*.json`).
- * @returns The static directory prefix (e.g., `j:/domains`).
- */
-function globRoot(glob) {
-    const normalized = normalizeSlashes(glob);
-    const segments = normalized.split('/');
-    const staticSegments = [];
-    for (const seg of segments) {
-        if (/[*?{[\]]/.test(seg))
-            break;
-        staticSegments.push(seg);
-    }
-    return staticSegments.join('/') || '.';
-}
-/**
- * Deduplicate directory roots, removing paths that are subdirectories of others.
- *
- * @param roots - Array of directory paths.
- * @returns Deduplicated array with subdirectories removed.
- */
-function deduplicateRoots(roots) {
-    const normalized = roots.map((r) => normalizeSlashes(r).toLowerCase());
-    const sorted = [...new Set(normalized)].sort();
-    return sorted.filter((root, _i, arr) => {
-        const withSlash = root.endsWith('/') ? root : root + '/';
-        return !arr.some((other) => other !== root && withSlash.startsWith(other + '/'));
-    });
-}
-/**
- * Build a picomatch matcher from an array of glob patterns.
- * Normalizes Windows paths (backslash → forward slash, lowercase drive letter)
- * before matching.
- *
- * @param globs - Glob patterns to match against.
- * @returns A function that tests whether a file path matches any of the globs.
- */
-function buildGlobMatcher(globs) {
-    const normalizedGlobs = globs.map((g) => normalizeSlashes(g));
-    const isMatch = picomatch(normalizedGlobs, { dot: true, nocase: true });
-    return (filePath) => {
-        const normalized = normalizeSlashes(filePath);
-        return isMatch(normalized);
-    };
-}
-/**
- * Convert an array of glob patterns into chokidar-compatible directory roots
- * and a filter function for post-hoc event filtering.
- *
- * @param globs - Glob patterns from the watch config.
- * @returns Object with `roots` (directories for chokidar) and `matches` (filter function).
- */
-function resolveWatchPaths(globs) {
-    const rawRoots = globs.map(globRoot);
-    const roots = deduplicateRoots(rawRoots);
-    const matches = buildGlobMatcher(globs);
-    return { roots, matches };
-}
-/**
- * Convert ignored glob patterns to picomatch matcher functions.
- *
- * Chokidar v5 replaced the external `anymatch` dependency with an inline
- * implementation that does **exact string equality** for string matchers,
- * breaking glob-based `ignored` patterns. This function converts glob strings
- * to picomatch functions that chokidar's `createPattern` passes through
- * unchanged (`typeof matcher === 'function'`).
- *
- * Non-string entries (functions, RegExps) are passed through as-is.
- *
- * @param ignored - Array of ignored patterns (globs, functions, RegExps).
- * @returns Array with glob strings replaced by picomatch matcher functions.
- */
-function resolveIgnored(ignored) {
-    return ignored.map((entry) => {
-        if (typeof entry !== 'string')
-            return entry;
-        // If the string contains glob characters, convert to a picomatch function.
-        // Literal strings (exact paths) are also converted for consistent matching.
-        const normalizedPattern = normalizeSlashes(entry);
-        const matcher = picomatch(normalizedPattern, { dot: true, nocase: true });
-        return (filePath) => {
-            const normalized = normalizeSlashes(filePath);
-            return matcher(normalized);
-        };
-    });
-}
-
 /**
  * @module watcher/MoveCorrelator
  * Correlates unlink+add events as file moves using content hash matching.

package/package.json

@@ -149,5 +149,5 @@
   },
   "type": "module",
   "types": "dist/index.d.ts",
-  "version": "0.18.2"
+  "version": "0.18.3"
 }