@getmikk/watcher 1.8.0 → 1.9.1

package/package.json

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

package/src/incremental-analyzer.ts

@@ -2,7 +2,7 @@ import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
 import {
     getParser, GraphBuilder, ImpactAnalyzer, LockCompiler, hashFile,
-    type ParsedFile, type DependencyGraph, type MikkLock, type MikkContract, type ImpactResult
+    type ParsedFile, type DependencyGraph, type MikkLock, type MikkContract, type ImpactResult, type GraphEdge
 } from '@getmikk/core'
 import type { FileChangeEvent } from './types.js'
 
@@ -13,14 +13,9 @@ const FULL_ANALYSIS_THRESHOLD = 15
 const MAX_RETRIES = 3
 
 /**
- * IncrementalAnalyzer — re-parses only changed files, updates graph nodes,
- * and recomputes affected module hashes. O(changed files) not O(whole repo).
- *
- * Supports batch analysis: if > 15 files change at once (e.g. git checkout),
- * runs a full re-analysis instead of incremental.
- *
- * Race condition handling: after parsing, re-hashes the file and re-parses
- * if the content changed during parsing (up to 3 retries).
+ * IncrementalAnalyzer — re-parses only changed files, performs a surgical
+ * graph update (removes stale nodes/edges, inserts new ones), then runs
+ * impact analysis over the affected subgraph.
  */
 export class IncrementalAnalyzer {
     private parsedFiles: Map<string, ParsedFile> = new Map()
@@ -30,59 +25,96 @@ export class IncrementalAnalyzer {
         private lock: MikkLock,
         private contract: MikkContract,
         private projectRoot: string
-    ) { }
+    ) {
+        if (!this.graph.outEdges) this.graph.outEdges = new Map()
+        if (!this.graph.inEdges) this.graph.inEdges = new Map()
+    }
 
-    /** Handle a batch of file change events (debounced by daemon) */
+    public get fileCount(): number {
+        return this.parsedFiles.size
+    }
+
+    /** Handle a batch of file change events */
     async analyzeBatch(events: FileChangeEvent[]): Promise<{
         graph: DependencyGraph
         lock: MikkLock
         impactResult: ImpactResult
         mode: 'incremental' | 'full'
     }> {
-        // If too many changes at once, run full analysis
         if (events.length > FULL_ANALYSIS_THRESHOLD) {
             return this.runFullAnalysis(events)
         }
 
-        // 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)
-                changedFilePaths.push(event.path)
             } else {
                 const parsed = await this.parseWithRaceCheck(event.path)
-                if (parsed) {
-                    this.parsedFiles.set(event.path, parsed)
-                }
-                changedFilePaths.push(event.path)
+                if (parsed) this.parsedFiles.set(event.path, parsed)
             }
+            changedFilePaths.push(event.path)
         }
 
-        // 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)
+        // --- Surgical graph update ---
+        const staleNodeIds = new Set<string>(
+            changedFilePaths.flatMap(fp => this.findNodeIdsForFile(fp))
+        )
+
+        for (const nodeId of staleNodeIds) {
+            this.graph.nodes.delete(nodeId)
+        }
+        for (const fp of changedFilePaths) {
+            this.graph.nodes.delete(fp)
+        }
+
+        const allStaleIds = new Set([...staleNodeIds, ...changedFilePaths])
+        this.graph.edges = this.graph.edges.filter(
+            edge => !allStaleIds.has(edge.from) && !allStaleIds.has(edge.to)
+        )
+
+        const changedParsedFiles = changedFilePaths
+            .map(fp => this.parsedFiles.get(fp))
+            .filter((f): f is ParsedFile => f !== undefined)
+
+        if (changedParsedFiles.length > 0) {
+            const miniBuilder = new GraphBuilder()
+            const miniGraph = miniBuilder.build(changedParsedFiles)
+
+            for (const [id, node] of miniGraph.nodes) {
+                this.graph.nodes.set(id, node)
+            }
+            
+            for (const edge of miniGraph.edges) {
+                 this.graph.edges.push(edge)
+            }
+        }
+
+        // Rebuild adjacency maps
+        this.graph.outEdges = new Map()
+        this.graph.inEdges = new Map()
+        for (const edge of this.graph.edges) {
+            if (!this.graph.outEdges.has(edge.from)) this.graph.outEdges.set(edge.from, [])
+            this.graph.outEdges.get(edge.from)!.push(edge)
+            if (!this.graph.inEdges.has(edge.to)) this.graph.inEdges.set(edge.to, [])
+            this.graph.inEdges.get(edge.to)!.push(edge)
+        }
 
-        // Map changed file paths → graph node IDs using the updated graph
-        const changedNodeIds = [...new Set(
-            changedFilePaths.flatMap(fp => this.findAffectedNodes(fp))
-        )]
+        const changedNodeIds = [
+            ...new Set(changedFilePaths.flatMap(fp => this.findNodeIdsForFile(fp)))
+        ]
 
-        // Run impact analysis on all changed nodes
         const analyzer = new ImpactAnalyzer(this.graph)
         const impactResult = analyzer.analyze(changedNodeIds)
 
-        // Recompile lock
+        const allParsedFiles = [...this.parsedFiles.values()]
         const compiler = new LockCompiler()
-        this.lock = compiler.compile(this.graph, this.contract, allParsedFiles)
+        this.lock = compiler.compile(this.graph, this.contract, allParsedFiles, undefined, this.projectRoot)
 
         return { graph: this.graph, lock: this.lock, impactResult, mode: 'incremental' }
     }
 
-    /** Handle a single file change event */
     async analyze(event: FileChangeEvent): Promise<{
         graph: DependencyGraph
         lock: MikkLock
@@ -92,112 +124,75 @@ export class IncrementalAnalyzer {
         return { graph: result.graph, lock: result.lock, impactResult: result.impactResult }
     }
 
-    /** Add a parsed file to the tracker */
     addParsedFile(file: ParsedFile): void {
         this.parsedFiles.set(file.path, file)
     }
 
-    /** Get the current parsed file count */
-    get fileCount(): number {
-        return this.parsedFiles.size
-    }
-
-    // ─── Private ──────────────────────────────────────────────────
-
-    /**
-     * Parse a file with race-condition detection.
-     * After parsing, re-hash the file. If the hash differs from what we started with,
-     * the file changed during parsing — re-parse (up to MAX_RETRIES).
-     */
     private async parseWithRaceCheck(changedFile: string): Promise<ParsedFile | null> {
         const fullPath = path.join(this.projectRoot, changedFile)
-
         for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
             try {
                 const content = await fs.readFile(fullPath, 'utf-8')
                 const parser = getParser(changedFile)
                 const parsedFile = await parser.parse(changedFile, content)
 
-                // Race condition check: re-hash after parse
                 try {
                     const postParseHash = await hashFile(fullPath)
-                    if (postParseHash === parsedFile.hash) {
-                        return parsedFile // Content stable
-                    }
-                    // Content changed during parse — retry
+                    if (postParseHash === parsedFile.hash) return parsedFile
                 } catch {
-                    return parsedFile // File may have been deleted, return what we have
+                    return parsedFile
                 }
             } catch {
-                return null // File unreadable
+                return null
             }
         }
-
-        // Exhausted retries — parse one final time and accept
-        try {
-            const content = await fs.readFile(fullPath, 'utf-8')
-            const parser = getParser(changedFile)
-            return await parser.parse(changedFile, content)
-        } catch {
-            return null
-        }
+        return null
     }
 
-    /** Run a full re-analysis (for large batches like git checkout) */
     private async runFullAnalysis(events: FileChangeEvent[]): Promise<{
         graph: DependencyGraph
         lock: MikkLock
         impactResult: ImpactResult
         mode: 'full'
     }> {
-        // Remove deleted files
         for (const event of events) {
-            if (event.type === 'deleted') {
-                this.parsedFiles.delete(event.path)
-            }
+            if (event.type === 'deleted') this.parsedFiles.delete(event.path)
         }
 
-        // Re-parse all non-deleted changed files
         const nonDeleted = events.filter(e => e.type !== 'deleted')
         await Promise.all(nonDeleted.map(async (event) => {
             const parsed = await this.parseWithRaceCheck(event.path)
-            if (parsed) {
-                this.parsedFiles.set(event.path, parsed)
-            }
+            if (parsed) this.parsedFiles.set(event.path, parsed)
         }))
 
-        // Full rebuild
         const allParsedFiles = [...this.parsedFiles.values()]
         const builder = new GraphBuilder()
         this.graph = builder.build(allParsedFiles)
 
         const compiler = new LockCompiler()
-        this.lock = compiler.compile(this.graph, this.contract, allParsedFiles)
-
-        const changedPaths = events.map(e => e.path)
-
-        return {
-            graph: this.graph,
-            lock: this.lock,
-            impactResult: {
-                changed: changedPaths,
-                impacted: [],
-                classified: {
-                    critical: [],
-                    high: [],
-                    medium: [],
-                    low: [],
-                },
-                depth: 0,
-                confidence: 'low', // Full rebuild = can't determine precise impact
-            },
-            mode: 'full',
+        this.lock = compiler.compile(this.graph, this.contract, allParsedFiles, undefined, this.projectRoot)
+
+        const impactResult: ImpactResult = {
+            changed: events.map(e => e.path),
+            impacted: [],
+            allImpacted: [],
+            depth: 0,
+            entryPoints: [],
+            criticalModules: [],
+            paths: [],
+            confidence: 1.0,
+            riskScore: 0,
+            classified: { critical: [], high: [], medium: [], low: [] }
         }
+
+        return { graph: this.graph, lock: this.lock, impactResult, mode: 'full' }
     }
 
-    private findAffectedNodes(filePath: string): string[] {
-        return [...this.graph.nodes.values()]
-            .filter(n => n.file === filePath)
-            .map(n => n.id)
+    private findNodeIdsForFile(filePath: string): string[] {
+        const ids: string[] = []
+        for (const [id, node] of this.graph.nodes) {
+            if (node.file === filePath) ids.push(id)
+        }
+        return ids
     }
 }

package/tests/analyzer.test.ts

@@ -1,91 +1,158 @@
 import { describe, it, expect } from 'bun:test'
 import { IncrementalAnalyzer } from '../src/incremental-analyzer.js'
-import type { MikkLock, ParsedFile } from '@getmikk/core'
+import type { MikkLock, DependencyGraph, MikkContract } from '@getmikk/core'
+import type { FileChangeEvent } from '../src/types.js'
 
 describe('IncrementalAnalyzer', () => {
-    it('detects changes correctly without throwing', async () => {
-        const mockLock: MikkLock = {
-            version: '1',
-            lastUpdated: new Date().toISOString(),
-            files: {
-                'src/index.ts': {
-                    hash: 'abc',
-                    lastModified: new Date().toISOString(),
-                    path: 'src/index.ts',
-                    moduleId: 'root',
-                    imports: [],
-                    exports: []
-                }
-            },
-            functions: {},
-            classes: {},
-            modules: {}
+    const mockGraph = (): DependencyGraph => ({
+        nodes: new Map(),
+        edges: [],
+        outEdges: new Map(),
+        inEdges: new Map()
+    })
+
+    const mockLock: MikkLock = {
+        version: '2.0.0',
+        generatedAt: new Date().toISOString(),
+        generatorVersion: '1.0.0',
+        projectRoot: '/project',
+        syncState: {
+            status: 'clean',
+            lastSyncAt: new Date().toISOString(),
+            lockHash: 'abc',
+            contractHash: 'xyz'
+        },
+        files: {
+            'src/index.ts': {
+                path: 'src/index.ts',
+                hash: 'abc',
+                moduleId: 'root',
+                lastModified: new Date().toISOString(),
+                imports: []
+            }
+        },
+        functions: {},
+        classes: {},
+        modules: {},
+        graph: {
+            nodes: 1,
+            edges: 0,
+            rootHash: 'abc'
         }
+    }
 
+    const contract: MikkContract = {
+        version: '2.0.0',
+        project: { 
+            name: 'test', 
+            description: 'test project',
+            language: 'typescript', 
+            framework: 'none',
+            entryPoints: [] 
+        },
+        declared: {
+            modules: [],
+            constraints: [],
+            decisions: []
+        },
+        overwrite: { 
+            mode: 'never', 
+            requireConfirmation: false 
+        },
+        policies: {
+            maxRiskScore: 70,
+            maxImpactNodes: 10,
+            protectedModules: [],
+            enforceStrictBoundaries: true,
+            requireReasoningForCritical: true
+        }
+    }
+
+    it('detects changes correctly without throwing', async () => {
         const analyzer = new IncrementalAnalyzer(
-            { nodes: new Map(), edges: [] },
+            mockGraph(),
             mockLock,
-            {
-                project: { name: 'test', language: 'typescript', framework: null },
-                declared: { modules: [], constraints: [], decisions: [] },
-                overwrite: { mode: 'never', requireConfirmation: false }
-            },
+            contract,
             '/project'
         )
         
-        // This simulates a file change event
-        const result = await analyzer.analyze({ path: 'src/index.ts', type: 'modified' })
+        const event: FileChangeEvent = { 
+            path: 'src/index.ts', 
+            type: 'changed',
+            oldHash: 'old',
+            newHash: 'abc',
+            timestamp: Date.now(),
+            affectedModuleIds: []
+        }
+        const result = await analyzer.analyze(event)
         expect(result.graph).toBeDefined()
         expect(result.lock).toBeDefined()
         expect(result.impactResult).toBeDefined()
     })
 
     describe('Edge Cases and Batch Processing', () => {
-        const mockLock: MikkLock = {
-            version: '1',
-            lastUpdated: new Date().toISOString(),
-            files: {}, functions: {}, classes: {}, modules: {}
-        }
-        
-        const contract = {
-            project: { name: 'test', language: 'typescript', framework: null },
-            declared: { modules: [], constraints: [], decisions: [] },
-            overwrite: { mode: 'never', requireConfirmation: false }
-        }
-
         it('handles file deletions by removing nodes from graph and lock', async () => {
-            const analyzer = new IncrementalAnalyzer({ nodes: new Map(), edges: [] }, mockLock, contract, '/project')
+            const analyzer = new IncrementalAnalyzer(mockGraph(), mockLock, contract, '/project')
             // First add it
-            analyzer.addParsedFile({ path: 'src/to-delete.ts', language: 'ts', hash: 'foo', parsedAt: Date.now(), functions: [], classes: [], imports: [], exports: [], routes: [] })
+            analyzer.addParsedFile({ 
+                path: 'src/to-delete.ts', 
+                language: 'typescript', 
+                hash: 'foo', 
+                parsedAt: Date.now(), 
+                functions: [], 
+                classes: [], 
+                imports: [], 
+                exports: [], 
+                routes: [],
+                variables: [],
+                generics: [],
+                calls: []
+            })
             expect(analyzer.fileCount).toBe(1)
             
             // Now send a deleted event
-            await analyzer.analyze({ path: 'src/to-delete.ts', type: 'deleted' })
+            const event: FileChangeEvent = { 
+                path: 'src/to-delete.ts', 
+                type: 'deleted',
+                oldHash: 'foo',
+                newHash: '',
+                timestamp: Date.now(),
+                affectedModuleIds: []
+            }
+            await analyzer.analyze(event)
             expect(analyzer.fileCount).toBe(0)
         })
 
         it('survives analyze events on completely non-existent OS files gracefully', async () => {
-            const analyzer = new IncrementalAnalyzer({ nodes: new Map(), edges: [] }, mockLock, contract, '/project')
-            // Will fail to fs.readFile inside parseWithRaceCheck
-            const result = await analyzer.analyze({ path: 'does/not/exist.ts', type: 'modified' })
-            expect(result.mode).toBeUndefined() // Returns incremental by default
+            const analyzer = new IncrementalAnalyzer(mockGraph(), mockLock, contract, '/project')
+            const event: FileChangeEvent = { 
+                path: 'does/not/exist.ts', 
+                type: 'changed',
+                oldHash: '',
+                newHash: 'new',
+                timestamp: Date.now(),
+                affectedModuleIds: []
+            }
+            const result = await analyzer.analyzeBatch([event])
+            expect(result.mode).toBe('incremental')
             expect(result.impactResult).toBeDefined()
-            // Should not have crashed the analyzer
             expect(analyzer.fileCount).toBe(0) 
         })
 
         it('triggers a full re-analysis if file batch exceeds FULL_ANALYSIS_THRESHOLD (15)', async () => {
-            const analyzer = new IncrementalAnalyzer({ nodes: new Map(), edges: [] }, mockLock, contract, '/project')
-            const events = Array.from({ length: 16 }).map((_, i) => ({
+            const analyzer = new IncrementalAnalyzer(mockGraph(), mockLock, contract, '/project')
+            const events: FileChangeEvent[] = Array.from({ length: 16 }).map((_, i) => ({
                 path: `src/file_${i}.ts`,
-                type: 'modified' as const
+                type: 'changed',
+                oldHash: '',
+                newHash: `hash_${i}`,
+                timestamp: Date.now(),
+                affectedModuleIds: []
             }))
             
             const result = await analyzer.analyzeBatch(events)
-            // It should have hit runFullAnalysis, which returns mode: 'full'
             expect(result.mode).toBe('full')
-            // It will also have gracefully continued despite the 16 files failing to load off disk
-            expect(result.impactResult.confidence).toBe('low')
+            expect(result.impactResult.confidence).toBe(1.0)
         })
     })
 })