@getmikk/watcher 1.6.0 → 1.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@getmikk/watcher",
-    "version": "1.6.0",
+    "version": "1.7.1",
     "license": "Apache-2.0",
     "repository": {
         "type": "git",
@@ -21,7 +21,7 @@
         "dev": "tsc --watch"
     },
     "dependencies": {
-        "@getmikk/core": "^1.6.0",
+        "@getmikk/core": "^1.7.1",
         "chokidar": "^4.0.0"
     },
     "devDependencies": {

package/src/daemon.ts

@@ -70,6 +70,16 @@ export class WatcherDaemon {
             this.analyzer.addParsedFile(file)
         }
 
+        // Seed the file watcher's hash store with initial hashes so the first
+        // change to any file can be properly deduplicated by content.
+        const initialHashes = new Map<string, string>()
+        for (const file of parsedFiles) {
+            if (file.hash) {
+                initialHashes.set(file.path.replace(/\\/g, '/'), file.hash)
+            }
+        }
+        this.watcher.seedHashes(initialHashes)
+
         // Subscribe to file changes with debouncing
         this.watcher.on(async (event: WatcherEvent) => {
             if (event.type === 'file:changed') {

package/src/file-watcher.ts

@@ -16,25 +16,37 @@ export class FileWatcher {
 
     /** Start watching — non-blocking */
     start(): void {
-        this.watcher = watch(this.config.include, {
-            ignored: this.config.exclude,
+        const excludesRegexes = this.config.exclude.map(
+            pattern => new RegExp(pattern.replace(/\*/g, '.*').replace(/\//g, '[\\\\/]'))
+        )
+        const includeExts = ['.ts', '.tsx']
+
+        this.watcher = watch(this.config.projectRoot, {
+            ignored: (testPath: string, stats?: import('fs').Stats) => {
+                // Ignore matching exclude patterns
+                if (excludesRegexes.some(r => r.test(testPath))) return true
+                // Keep directories so we can recurse
+                if (!stats || stats.isDirectory()) return false
+                // Ignore non-matching file extensions
+                return !includeExts.some(ext => testPath.endsWith(ext))
+            },
             cwd: this.config.projectRoot,
             ignoreInitial: true,
             persistent: true,
             awaitWriteFinish: {
-                stabilityThreshold: 50,
-                pollInterval: 10,
+                stabilityThreshold: 300,
+                pollInterval: 50,
             },
         })
 
-        this.watcher.on('change', (relativePath: string) => {
-            this.handleChange(relativePath, 'changed')
-        })
-        this.watcher.on('add', (relativePath: string) => {
-            this.handleChange(relativePath, 'added')
-        })
-        this.watcher.on('unlink', (relativePath: string) => {
-            this.handleChange(relativePath, 'deleted')
+        this.watcher.on('all', (event, relativePath) => {
+            if (event === 'change') {
+                this.handleChange(relativePath, 'changed')
+            } else if (event === 'add') {
+                this.handleChange(relativePath, 'added')
+            } else if (event === 'unlink') {
+                this.handleChange(relativePath, 'deleted')
+            }
         })
     }
 
@@ -49,11 +61,18 @@ export class FileWatcher {
         this.handlers.push(handler)
     }
 
-    /** Set initial hash for a file */
+    /** Seed the initial hash for a file (called at startup for all known files) */
     setHash(filePath: string, hash: string): void {
         this.hashStore.set(filePath, hash)
     }
 
+    /** Bulk-seed hashes for all known files so first-change dedup works correctly */
+    seedHashes(entries: ReadonlyMap<string, string>): void {
+        for (const [p, h] of entries) {
+            this.hashStore.set(p.replace(/\\/g, '/'), h)
+        }
+    }
+
     private async handleChange(relativePath: string, type: FileChangeEvent['type']): Promise<void> {
         const fullPath = path.join(this.config.projectRoot, relativePath)
         const normalizedPath = relativePath.replace(/\\/g, '/')
@@ -68,7 +87,8 @@ export class FileWatcher {
             }
         }
 
-        if (oldHash === newHash) return // Content unchanged
+        // Skip only when both hashes are known and identical (true no-op change)
+        if (oldHash !== null && newHash !== null && oldHash === newHash) return
 
         if (newHash) this.hashStore.set(normalizedPath, newHash)
         if (type === 'deleted') this.hashStore.delete(normalizedPath)

package/src/incremental-analyzer.ts

@@ -44,31 +44,36 @@ export class IncrementalAnalyzer {
             return this.runFullAnalysis(events)
         }
 
-        // Incremental: process each event
-        let combinedChanged: string[] = []
-        let combinedImpacted: string[] = []
+        // Incremental: process each event, collecting changed file paths
+        const changedFilePaths: string[] = []
 
         for (const event of events) {
             if (event.type === 'deleted') {
                 this.parsedFiles.delete(event.path)
-                combinedChanged.push(event.path)
+                changedFilePaths.push(event.path)
             } else {
                 const parsed = await this.parseWithRaceCheck(event.path)
                 if (parsed) {
                     this.parsedFiles.set(event.path, parsed)
                 }
-                combinedChanged.push(...this.findAffectedNodes(event.path))
+                changedFilePaths.push(event.path)
             }
         }
 
-        // Rebuild graph from all parsed files
+        // Rebuild graph from all parsed files BEFORE deriving node IDs,
+        // so newly-added files are present in the graph when we look them up.
         const allParsedFiles = [...this.parsedFiles.values()]
         const builder = new GraphBuilder()
         this.graph = builder.build(allParsedFiles)
 
+        // Map changed file paths → graph node IDs using the updated graph
+        const changedNodeIds = [...new Set(
+            changedFilePaths.flatMap(fp => this.findAffectedNodes(fp))
+        )]
+
         // Run impact analysis on all changed nodes
         const analyzer = new ImpactAnalyzer(this.graph)
-        const impactResult = analyzer.analyze([...new Set(combinedChanged)])
+        const impactResult = analyzer.analyze(changedNodeIds)
 
         // Recompile lock
         const compiler = new LockCompiler()