@soederpop/luca 0.0.6 → 0.0.8

package/src/node/features/file-manager.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod'
-import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+import { FeatureEventsSchema, FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
 import { State } from "../../state.js";
 import { Feature } from "../feature.js";
-import { parse, relative } from "path";
-import { statSync } from "fs";
+import { parse, relative, join as pathJoin } from "path";
+import { statSync, readFileSync, existsSync } from "fs";
 import micromatch from "micromatch";
 import { castArray } from "lodash-es";
 import chokidar from "chokidar";
@@ -37,6 +37,15 @@ export const FileManagerOptionsSchema = FeatureOptionsSchema.extend({
   exclude: z.union([z.string(), z.array(z.string())]).optional().describe('Glob patterns to exclude from file scanning'),
 })
 
+export const FileManagerEventsSchema = FeatureEventsSchema.extend({
+  'file:change': z.tuple([
+    z.object({
+      type: z.enum(['add', 'change', 'delete']).describe('The type of file change'),
+      path: z.string().describe('Absolute path to the changed file'),
+    }).describe('File change event payload'),
+  ]).describe('Emitted when a watched file is added, changed, or deleted'),
+}).describe('FileManager events')
+
 export type FileManagerState = z.infer<typeof FileManagerStateSchema>
 export type FileManagerOptions = z.infer<typeof FileManagerOptionsSchema>
 
@@ -61,6 +70,7 @@ export class FileManager<
   static override shortcut = 'features.fileManager' as const
   static override stateSchema = FileManagerStateSchema
   static override optionsSchema = FileManagerOptionsSchema
+  static override eventsSchema = FileManagerEventsSchema
   static { Feature.register(this, 'fileManager') }
   
   files: State<Record<string, File>> = new State<Record<string, File>>({
@@ -135,6 +145,11 @@ export class FileManager<
     return !!this.state.get("watching");
   }
 
+  /** Returns the list of directories currently being watched. */
+  get watchedPaths(): string[] {
+    return this.state.get("watchedPaths") || [];
+  }
+
   /** 
    * Starts the file manager and scans the files in the project.
    * @param {object} [options={}] - Options for the file manager
@@ -154,7 +169,11 @@ export class FileManager<
     }
 
     try {
-      await this.scanFiles(options);
+      const loaded = await this.loadFromCache();
+      if (!loaded) {
+        await this.scanFiles(options);
+        await this.writeToCache();
+      }
     } catch (error) {
       console.error(error);
       this.state.set("failed", true);
@@ -166,6 +185,117 @@ export class FileManager<
     return this;
   }
 
+  /**
+   * Attempts to load the file index from disk cache.
+   * Only uses cache when in a clean git repo (sha hasn't changed, no dirty files).
+   * @returns true if cache was loaded successfully, false otherwise
+   */
+  /**
+   * Reads the current git SHA by reading .git/HEAD directly,
+   * avoiding the ~19ms cost of shelling out to `git rev-parse HEAD`.
+   */
+  private readGitShaFast(): string | null {
+    try {
+      const { git } = this.container;
+      if (!git.isRepo) return null;
+
+      const gitDir = pathJoin(git.repoRoot, '.git');
+      const head = readFileSync(pathJoin(gitDir, 'HEAD'), 'utf8').trim();
+
+      // Detached HEAD — already a sha
+      if (!head.startsWith('ref: ')) return head;
+
+      // Resolve the ref
+      const refPath = pathJoin(gitDir, head.slice(5));
+      if (existsSync(refPath)) {
+        return readFileSync(refPath, 'utf8').trim();
+      }
+
+      // Packed refs fallback
+      const packedRefsPath = pathJoin(gitDir, 'packed-refs');
+      if (existsSync(packedRefsPath)) {
+        const ref = head.slice(5);
+        const packed = readFileSync(packedRefsPath, 'utf8');
+        const match = packed.match(new RegExp(`^([0-9a-f]{40}) ${ref}`, 'm'));
+        if (match) return match[1];
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  private async loadFromCache(): Promise<boolean> {
+    try {
+      const sha = this.readGitShaFast();
+      if (!sha) return false;
+
+      const cache = this.container.feature('diskCache') as any;
+      const cacheKey = `file-index:${sha}`;
+
+      if (!(await cache.has(cacheKey))) return false;
+
+      const cached = await cache.get(cacheKey, true) as { dirs: Record<string, number>, files: Record<string, any> };
+      if (!cached?.files || !cached?.dirs) return false;
+
+      // Check if any directory mtime has changed — catches new/deleted/renamed files
+      for (const [dir, cachedMtimeMs] of Object.entries(cached.dirs)) {
+        try {
+          const current = statSync(dir).mtimeMs;
+          if (current !== cachedMtimeMs) return false;
+        } catch {
+          // Directory no longer exists
+          return false;
+        }
+      }
+
+      for (const [relativePath, file] of Object.entries(cached.files)) {
+        this.files.set(relativePath, {
+          ...file as File,
+          modifiedAt: new Date((file as any).modifiedAt),
+          createdAt: new Date((file as any).createdAt),
+        });
+      }
+
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Writes the current file index to disk cache, keyed by git sha.
+   * Stores directory mtimes alongside file data so the cache can be
+   * invalidated when files are added/removed without a new commit.
+   */
+  private async writeToCache(): Promise<void> {
+    try {
+      const sha = this.readGitShaFast();
+      if (!sha) return;
+
+      const cache = this.container.feature('diskCache') as any;
+      const cacheKey = `file-index:${sha}`;
+
+      // Collect unique directories and their mtimes
+      const dirs: Record<string, number> = {};
+      const files: Record<string, any> = {};
+
+      for (const [key, file] of this.files.entries()) {
+        files[key] = file;
+        if (!dirs[file.dirname]) {
+          try {
+            dirs[file.dirname] = statSync(file.dirname).mtimeMs;
+          } catch {}
+        }
+      }
+
+      await cache.set(cacheKey, { dirs, files });
+    } catch {
+      // Cache write failure is non-fatal
+    }
+  }
+
   /** 
    * Scans the files in the project and updates the file manager state.
    * @param {object} [options={}] - Options for the file manager
@@ -252,14 +382,33 @@ export class FileManager<
     return this.watcher?.getWatched() || {};
   }
 
-  /** 
-   * Watches the files in the project and updates the file manager state.
+  /**
+   * Watches directories for file changes. Can be called multiple times to add
+   * more directories to an existing watcher. Tracks all watched paths in state.
+   *
+   * When called without `paths`, watches the project's `directoryIds` (default behavior).
+   * When called with `paths`, watches only those specific directories/globs.
+   * Subsequent calls add to the existing watcher — they never replace what's already watched.
+   *
    * @param {object} [options={}] - Options for the file manager
+   * @param {string | string[]} [options.paths] - Specific directories or globs to watch. Defaults to project directoryIds.
    * @param {string | string[]} [options.exclude] - The patterns to exclude from the watch
-   * @returns {Promise<void>} The file manager instance
+   * @returns {Promise<void>}
   */
-  async watch(options: { exclude?: string | string[] } = {}) {
-    if (this.isWatching) {
+  async watch(options: { paths?: string | string[]; exclude?: string | string[] } = {}) {
+    const pathsToWatch = castArray(options.paths || this.directoryIds.map(id => this.container.paths.resolve(id)))
+      .map(p => this.container.paths.resolve(p));
+
+    // If already watching, just add the new paths
+    if (this.isWatching && this.watcher) {
+      const currentPaths: string[] = this.state.get("watchedPaths") || [];
+      const newPaths = pathsToWatch.filter(p => !currentPaths.includes(p));
+
+      if (newPaths.length) {
+        this.watcher.add(newPaths);
+        this.state.set("watchedPaths", [...currentPaths, ...newPaths]);
+      }
+
       return;
     }
 
@@ -273,11 +422,7 @@ export class FileManager<
 
     exclude.push(...castArray(this.options.exclude!).filter((v) => v?.length));
 
-    const { cwd } = this.container;
-
-    const watcher = chokidar.watch(
-      this.directoryIds.map(id => this.container.paths.resolve(id)) 
-      , {
+    const watcher = chokidar.watch(pathsToWatch, {
       ignoreInitial: true,
       persistent: true,
       ignored: [
@@ -292,17 +437,17 @@ export class FileManager<
 
     watcher
       .on("add", (path) => {
+        this.updateFile(path);
         this.emit("file:change", {
           type: "add",
           path,
         });
-        this.updateFile(path);
       })
       .on("change", (path) => {
         this.updateFile(path);
         this.emit("file:change", {
-          path,
           type: "change",
+          path,
         });
       })
       .on("unlink", (path) => {
@@ -315,6 +460,7 @@ export class FileManager<
 
     watcher.on("ready", () => {
       this.state.set("watching", true);
+      this.state.set("watchedPaths", pathsToWatch);
     });
 
     this.watcher = watcher;
@@ -328,26 +474,35 @@ export class FileManager<
     if (this.watcher) {
       this.watcher.close();
       this.state.set("watching", false);
+      this.state.set("watchedPaths", []);
       this.watcher = null;
     }
   }
 
   async updateFile(path: string) {
-    // Reuse the logic from the scanFiles method to update a single file
     const absolutePath = this.container.paths.resolve(path);
     const { name, ext, dir } = parse(absolutePath);
-    const stats = statSync(absolutePath);
-
-    this.files.set(path, {
-      dirname: dir,
-      absolutePath,
-      relativePath: path,
-      name,
-      extension: ext,
-      size: stats.size,
-      modifiedAt: stats.mtime,
-      createdAt: stats.birthtime,
-    });
+
+    try {
+      const stats = statSync(absolutePath);
+      this.files.set(path, {
+        dirname: dir,
+        absolutePath,
+        relativePath: path,
+        name,
+        extension: ext,
+        size: stats.size,
+        modifiedAt: stats.mtime,
+        createdAt: stats.birthtime,
+      });
+    } catch (err: any) {
+      // File may have been moved or deleted by an event handler — remove from index gracefully
+      if (err.code === 'ENOENT') {
+        this.files.delete(path);
+      } else {
+        throw err;
+      }
+    }
   }
 
   async removeFile(path: string) {