ctxman 3.1.1 → 3.2.8

package/lib/watch/FileWatcher.js

@@ -1,12 +1,12 @@
 /**
  * FileWatcher - Real-Time File Watching Module
- * v3.0.0 - Watch mode
+ * v3.0.0 - Watch mode (with Cross-Repo Multi-Root Workspace support)
  *
  * Responsibilities:
- * - Watch file system for changes
+ * - Watch file system for changes across one or more repositories
  * - Debounce rapid changes
- * - Emit change events
- * - Support ignore patterns
+ * - Emit change events (namespaced as <alias>/<relativePath> in multi-repo mode)
+ * - Support per-repository ignore patterns (.gitignore, .contextignore, .contextinclude)
  */
 
 import fs from 'fs';
@@ -14,6 +14,7 @@ import path from 'path';
 import { EventEmitter } from 'events';
 import GitIgnoreParser from '../parsers/gitignore-parser.js';
 import FileUtils from '../utils/file-utils.js';
+import { resolveWorkspaceRepos } from '../workspace/index.js';
 import { getLogger } from '../utils/logger.js';
 
 const logger = getLogger('FileWatcher');
@@ -22,20 +23,29 @@ export class FileWatcher extends EventEmitter {
   constructor(rootPath, options = {}) {
     super();
 
-    this.rootPath = rootPath;
+    this.rootPath = path.resolve(rootPath);
     this.options = {
       debounce: 1000, // 1 second debounce
       recursive: true,
       ignorePatterns: [],
+      repos: [],
       ...options,
     };
 
-    // Initialize GitIgnoreParser with correct file paths
-    const gitignorePath = path.join(rootPath, '.gitignore');
-    const contextIgnorePath = path.join(rootPath, '.contextignore');
-    const contextIncludePath = path.join(rootPath, '.contextinclude');
+    const extraRepos = Array.isArray(this.options.repos) ? this.options.repos.filter(Boolean) : [];
+    this.isMultiRepo = extraRepos.length > 0;
+    this.repos = this.isMultiRepo
+      ? resolveWorkspaceRepos([this.rootPath, ...extraRepos])
+      : [{ root: this.rootPath, alias: null }];
+
+    // Initialize GitIgnoreParser for primary root and per-repo parsers
+    this.gitIgnoreByRoot = new Map();
+    for (const repo of this.repos) {
+      this.gitIgnoreByRoot.set(repo.root, this._createGitIgnoreParser(repo.root));
+    }
+    this.gitIgnore =
+      this.gitIgnoreByRoot.get(this.rootPath) || this._createGitIgnoreParser(this.rootPath);
 
-    this.gitIgnore = new GitIgnoreParser(gitignorePath, contextIgnorePath, contextIncludePath);
     this.watchers = [];
     this.debounceTimers = new Map();
     this.isWatching = false;
@@ -48,7 +58,19 @@ export class FileWatcher extends EventEmitter {
   }
 
   /**
-   * Start watching
+   * Create a GitIgnoreParser for a repository root
+   * @param {string} repoRoot
+   * @returns {GitIgnoreParser}
+   */
+  _createGitIgnoreParser(repoRoot) {
+    const gitignorePath = path.join(repoRoot, '.gitignore');
+    const contextIgnorePath = path.join(repoRoot, '.contextignore');
+    const contextIncludePath = path.join(repoRoot, '.contextinclude');
+    return new GitIgnoreParser(gitignorePath, contextIgnorePath, contextIncludePath);
+  }
+
+  /**
+   * Start watching all configured repositories
    */
   start() {
     if (this.isWatching) {
@@ -56,23 +78,40 @@ export class FileWatcher extends EventEmitter {
       return;
     }
 
-    logger.info(`Starting file watch: ${this.rootPath}`);
+    logger.info(
+      this.isMultiRepo
+        ? `Starting multi-repo file watch (${this.repos.map((r) => r.alias).join(', ')})`
+        : `Starting file watch: ${this.rootPath}`
+    );
 
     try {
-      const watcher = fs.watch(
-        this.rootPath,
-        { recursive: this.options.recursive },
-        (eventType, filename) => {
-          this.handleFileChange(eventType, filename);
-        }
-      );
+      for (const repo of this.repos) {
+        const watcher = fs.watch(
+          repo.root,
+          { recursive: this.options.recursive },
+          (eventType, filename) => {
+            this.handleFileChange(eventType, filename, repo);
+          }
+        );
+        this.watchers.push(watcher);
+      }
 
-      this.watchers.push(watcher);
       this.isWatching = true;
 
-      this.emit('watch:started', { path: this.rootPath });
+      this.emit('watch:started', {
+        path: this.rootPath,
+        repos: this.repos.map((r) => ({ root: r.root, alias: r.alias })),
+      });
       logger.info('Watch mode started');
     } catch (error) {
+      for (const watcher of this.watchers) {
+        try {
+          watcher.close();
+        } catch {
+          // ignore cleanup errors
+        }
+      }
+      this.watchers = [];
       logger.error(`Failed to start watch: ${error.message}`);
       this.emit('watch:error', { error });
       throw error;
@@ -111,19 +150,26 @@ export class FileWatcher extends EventEmitter {
    * Handle file change event
    * @param {string} eventType - 'rename' or 'change'
    * @param {string} filename - Changed file name
+   * @param {Object} [repo] - Resolved repository entry { root, alias }
    */
-  handleFileChange(eventType, filename) {
+  handleFileChange(eventType, filename, repo = null) {
     if (!filename) return;
 
-    const filePath = path.join(this.rootPath, filename);
-    const relativePath = path.relative(this.rootPath, filePath);
+    const targetRepo = repo || this.repos[0] || { root: this.rootPath, alias: null };
+    const filePath = path.join(targetRepo.root, filename);
+    const repoRelativePath = path.relative(targetRepo.root, filePath);
 
-    // Check ignore patterns
-    if (this.shouldIgnore(relativePath)) {
+    // Check ignore patterns against the owning repository
+    if (this.shouldIgnore(repoRelativePath, targetRepo.root)) {
       this.stats.ignoredChanges++;
       return;
     }
 
+    const relativePath =
+      this.isMultiRepo && targetRepo.alias
+        ? `${targetRepo.alias}/${repoRelativePath.split(path.sep).join('/')}`
+        : repoRelativePath;
+
     this.stats.totalChanges++;
 
     // Debounce rapid changes
@@ -133,7 +179,7 @@ export class FileWatcher extends EventEmitter {
 
     const timer = setTimeout(() => {
       this.debounceTimers.delete(filePath);
-      this.emitFileChange(eventType, filePath, relativePath);
+      this.emitFileChange(eventType, filePath, relativePath, targetRepo, repoRelativePath);
     }, this.options.debounce);
 
     this.debounceTimers.set(filePath, timer);
@@ -144,8 +190,10 @@ export class FileWatcher extends EventEmitter {
    * @param {string} eventType
    * @param {string} filePath
    * @param {string} relativePath
+   * @param {Object} [repo]
+   * @param {string} [repoRelativePath]
    */
-  emitFileChange(eventType, filePath, relativePath) {
+  emitFileChange(eventType, filePath, relativePath, repo = null, repoRelativePath = null) {
     logger.debug(`File ${eventType}: ${relativePath}`);
 
     const event = {
@@ -156,6 +204,12 @@ export class FileWatcher extends EventEmitter {
       exists: fs.existsSync(filePath),
     };
 
+    if (this.isMultiRepo && repo?.alias) {
+      event.repo = repo.alias;
+      event.repoRoot = repo.root;
+      event.repoRelativePath = repoRelativePath || relativePath;
+    }
+
     // Add file stats if exists
     if (event.exists) {
       try {
@@ -173,15 +227,50 @@ export class FileWatcher extends EventEmitter {
   /**
    * Check if file should be ignored
    * @param {string} relativePath
+   * @param {string} [repoRoot]
    * @returns {boolean}
    */
-  shouldIgnore(relativePath) {
+  shouldIgnore(relativePath, repoRoot = this.rootPath) {
+    const parts = relativePath.split(/[/\\]/);
+    const normalized = parts.join('/');
+
     // node_modules, .git and build output are skipped like in the scanners, .gitignore or not
-    if (relativePath.split(path.sep).some((part) => FileUtils.isSkippedDirectory(part))) {
+    if (parts.some((part) => FileUtils.isSkippedDirectory(part))) {
+      return true;
+    }
+
+    // Ignore .ctxman internal state (e.g. .ctxman/self-knowledge/index.sqlite) and SQLite journals
+    // so watch-mode RAG/graph writes never trigger a recursive watch feedback loop
+    if (
+      parts.includes('.ctxman') ||
+      normalized.endsWith('.sqlite') ||
+      normalized.endsWith('.sqlite-wal') ||
+      normalized.endsWith('.sqlite-shm') ||
+      normalized.endsWith('.sqlite-journal')
+    ) {
       return true;
     }
+
+    // Check custom ignorePatterns if configured
+    if (Array.isArray(this.options.ignorePatterns) && this.options.ignorePatterns.length > 0) {
+      for (const pattern of this.options.ignorePatterns) {
+        if (
+          typeof pattern === 'string' &&
+          (normalized === pattern || normalized.startsWith(`${pattern}/`))
+        ) {
+          return true;
+        }
+        if (pattern instanceof RegExp && pattern.test(normalized)) {
+          return true;
+        }
+      }
+    }
+
+    const resolvedRoot = repoRoot ? path.resolve(repoRoot) : this.rootPath;
+    const parser = this.gitIgnoreByRoot.get(resolvedRoot) || this.gitIgnore;
+
     // Use GitIgnoreParser for ignore rules
-    return this.gitIgnore.isIgnored(path.join(this.rootPath, relativePath), relativePath);
+    return parser.isIgnored(path.join(resolvedRoot, relativePath), relativePath);
   }
 
   /**
@@ -194,6 +283,7 @@ export class FileWatcher extends EventEmitter {
       isWatching: this.isWatching,
       activeWatchers: this.watchers.length,
       pendingDebounce: this.debounceTimers.size,
+      repos: this.repos.map((r) => ({ root: r.root, alias: r.alias })),
     };
   }