@getmikk/core 2.0.12 → 2.0.14

package/src/utils/fs.ts

@@ -1,6 +1,7 @@
 import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
 import fg from 'fast-glob'
+import { getDiscoveryExtensions } from './language-registry.js'
 
 // --- Well-known patterns for schema/config/route files ---------------------
 // These are structural files an AI agent needs but aren't source code.
@@ -275,7 +276,7 @@ function inferContextFileType(filePath: string): ContextFileType {
 }
 
 /** Recognised project language */
-export type ProjectLanguage = 'typescript' | 'javascript' | 'python' | 'go' | 'rust' | 'java' | 'ruby' | 'php' | 'csharp' | 'c' | 'cpp' | 'unknown'
+export type ProjectLanguage = 'typescript' | 'javascript' | 'python' | 'go' | 'rust' | 'java' | 'swift' | 'ruby' | 'php' | 'csharp' | 'c' | 'cpp' | 'unknown' | 'polyglot'
 
 /** Auto-detect the project's primary language from manifest files */
 export async function detectProjectLanguage(projectRoot: string): Promise<ProjectLanguage> {
@@ -293,6 +294,7 @@ export async function detectProjectLanguage(projectRoot: string): Promise<Projec
     if (await exists('pyproject.toml') || await exists('setup.py') || await exists('requirements.txt')) return 'python'
     if (await exists('Gemfile')) return 'ruby'
     if (await exists('pom.xml') || await exists('build.gradle') || await exists('build.gradle.kts')) return 'java'
+    if (await exists('Package.swift')) return 'swift'
     if (await exists('composer.json')) return 'php'
     if (await hasGlob('*.csproj') || await hasGlob('*.sln')) return 'csharp'
     if (await hasGlob('CMakeLists.txt') || await hasGlob('**/*.cmake') || await hasGlob('*.cpp')) return 'cpp'
@@ -306,68 +308,95 @@ export function getDiscoveryPatterns(language: ProjectLanguage): { patterns: str
     const commonIgnore = [
         '**/.mikk/**', '**/.git/**', '**/coverage/**', '**/build/**',
     ]
+
+    const toPatterns = (lang: ProjectLanguage): string[] => {
+        if (lang === 'polyglot') {
+            // For polyglot, use LANGUAGE_EXTENSIONS.polyglot directly
+            return getDiscoveryExtensions('polyglot' as any).map(ext => `**/*${ext}`)
+        }
+        return getDiscoveryExtensions(lang as any).map(ext => `**/*${ext}`)
+    }
+
     switch (language) {
         case 'typescript':
             return {
-                patterns: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
-                ignore: [...commonIgnore, '**/node_modules/**', '**/dist/**', '**/.next/**', '**/.nuxt/**', '**/.svelte-kit/**', '**/*.d.ts', '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}'],
+                patterns: toPatterns(language),
+                ignore: [...commonIgnore, '**/node_modules/**', '**/dist/**', '**/.next/**', '**/.nuxt/**', '**/.svelte-kit/**', '**/*.d.ts', '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}', '**/venv/**', '**/.venv/**'],
             }
         case 'javascript':
             return {
-                patterns: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.cjs', '**/*.ts', '**/*.tsx'],
-                ignore: [...commonIgnore, '**/node_modules/**', '**/dist/**', '**/.next/**', '**/*.d.ts', '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}'],
+                patterns: toPatterns(language),
+                ignore: [...commonIgnore, '**/node_modules/**', '**/dist/**', '**/.next/**', '**/*.d.ts', '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}', '**/venv/**', '**/.venv/**'],
             }
         case 'python':
             return {
-                patterns: ['**/*.py'],
-                ignore: [...commonIgnore, '**/__pycache__/**', '**/venv/**', '**/.venv/**', '**/.tox/**', '**/test_*.py', '**/*_test.py'],
+                patterns: toPatterns(language),
+                ignore: [...commonIgnore, '**/__pycache__/**', '**/venv/**', '**/.venv/**', '**/.tox/**', '**/test_*.py', '**/*_test.py', '**/lib/site-packages/**'],
             }
         case 'go':
             return {
-                patterns: ['**/*.go'],
+                patterns: toPatterns(language),
                 ignore: [...commonIgnore, '**/vendor/**', '**/*_test.go'],
             }
         case 'rust':
             return {
-                patterns: ['**/*.rs'],
+                patterns: toPatterns(language),
                 ignore: [...commonIgnore, '**/target/**'],
             }
         case 'java':
             return {
-                patterns: ['**/*.java', '**/*.kt'],
+                patterns: toPatterns(language),
                 ignore: [...commonIgnore, '**/target/**', '**/.gradle/**', '**/Test*.java', '**/*Test.java'],
             }
+        case 'swift':
+            return {
+                patterns: toPatterns(language),
+                ignore: [...commonIgnore, '**/.build/**', '**/Tests/**'],
+            }
         case 'ruby':
             return {
-                patterns: ['**/*.rb'],
-                ignore: [...commonIgnore, '**/vendor/**', '**/*_spec.rb', '**/spec/**'],
+                patterns: toPatterns(language),
+                ignore: [...commonIgnore, '**/vendor/**', '**/*.gemspec'],
             }
         case 'php':
             return {
-                patterns: ['**/*.php'],
-                ignore: [...commonIgnore, '**/vendor/**', '**/*Test.php'],
+                patterns: toPatterns(language),
+                ignore: [...commonIgnore, '**/vendor/**', '**/tests/**', '**/Test*.php'],
             }
         case 'csharp':
             return {
-                patterns: ['**/*.cs'],
-                ignore: [...commonIgnore, '**/bin/**', '**/obj/**'],
+                patterns: toPatterns(language),
+                ignore: [...commonIgnore, '**/bin/**', '**/obj/**', '**/*Test.cs'],
+            }
+        case 'c':
+            return {
+                patterns: toPatterns(language),
+                ignore: [...commonIgnore, '**/*.h'],
             }
         case 'cpp':
             return {
-                patterns: ['**/*.cpp', '**/*.cc', '**/*.cxx', '**/*.hpp', '**/*.hxx', '**/*.h'],
-                ignore: [...commonIgnore, '**/build/**', '**/cmake-build-*/**'],
+                patterns: toPatterns(language),
+                ignore: [...commonIgnore, '**/build/**', '**/*.hpp'],
             }
-        case 'c':
+        case 'polyglot':
             return {
-                patterns: ['**/*.c', '**/*.h'],
-                ignore: [...commonIgnore, '**/build/**'],
+                patterns: toPatterns(language),
+                ignore: [
+                    ...commonIgnore,
+                    '**/node_modules/**', '**/dist/**', '**/.next/**', '**/.nuxt/**', '**/.svelte-kit/**',
+                    '**/__pycache__/**', '**/venv/**', '**/.venv/**', '**/.tox/**', '**/lib/site-packages/**',
+                    '**/vendor/**', '**/target/**', '**/.gradle/**', '**/.build/**', '**/bin/**', '**/obj/**',
+                    '**/*.d.ts', '**/*.test.{ts,js,tsx,jsx}', '**/*.spec.{ts,js,tsx,jsx}',
+                    '**/test_*.py', '**/*_test.py', '**/Test*.java', '**/*Test.java', '**/*Test.cs',
+                ],
             }
-        default:
-            // Fallback: discover JS/TS (most common)
+        case 'unknown':
             return {
-                patterns: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
-                ignore: [...commonIgnore, '**/node_modules/**', '**/dist/**', '**/*.d.ts'],
+                patterns: ['**/*.{ts,tsx,js,jsx}'],
+                ignore: [...commonIgnore, '**/node_modules/**'],
             }
+        default:
+            return { patterns: [], ignore: commonIgnore }
     }
 }
 
@@ -550,6 +579,14 @@ const LANGUAGE_IGNORE_TEMPLATES: Record<ProjectLanguage, string[]> = {
         'gradle/',
         '',
     ],
+    swift: [
+        '# Swift artifacts',
+        '.build/',
+        '.swiftpm/',
+        'Packages/',
+        'Tests/',
+        '',
+    ],
     ruby: [
         '# Test files',
         '*_spec.rb',
@@ -605,6 +642,20 @@ const LANGUAGE_IGNORE_TEMPLATES: Record<ProjectLanguage, string[]> = {
         '__tests__/',
         '',
     ],
+    polyglot: [
+        '# Multi-language project',
+        '**/node_modules/**',
+        '**/venv/**',
+        '**/.venv/**',
+        '**/__pycache__/**',
+        '**/site-packages/**',
+        '**/vendor/**',
+        '**/target/**',
+        '**/build/**',
+        '**/dist/**',
+        '**/.next/**',
+        '',
+    ],
 }
 
 /**

package/src/utils/language-registry.ts

@@ -0,0 +1,95 @@
+export type ParserKind = 'oxc' | 'go' | 'tree-sitter' | 'unknown'
+
+export type RegistryLanguage =
+    | 'typescript'
+    | 'javascript'
+    | 'python'
+    | 'go'
+    | 'rust'
+    | 'java'
+    | 'kotlin'
+    | 'swift'
+    | 'ruby'
+    | 'php'
+    | 'csharp'
+    | 'c'
+    | 'cpp'
+    | 'polyglot'
+    | 'unknown'
+
+const OXC_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'] as const
+const GO_EXTENSIONS = ['.go'] as const
+const TREE_SITTER_EXTENSIONS = [
+    '.py', '.java', '.kt', '.kts', '.swift',
+    '.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.hh',
+    '.cs', '.rs', '.php', '.rb',
+] as const
+
+const PARSER_EXTENSIONS: Record<Exclude<ParserKind, 'unknown'>, readonly string[]> = {
+    oxc: OXC_EXTENSIONS,
+    go: GO_EXTENSIONS,
+    'tree-sitter': TREE_SITTER_EXTENSIONS,
+}
+
+const LANGUAGE_EXTENSIONS: Record<RegistryLanguage, readonly string[]> = {
+    typescript: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+    javascript: ['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx'],
+    python: ['.py'],
+    go: ['.go'],
+    rust: ['.rs'],
+    kotlin: ['.kt', '.kts'],
+    java: ['.java', '.kt', '.kts'],
+    swift: ['.swift'],
+    ruby: ['.rb'],
+    php: ['.php'],
+    csharp: ['.cs'],
+    c: ['.c', '.h'],
+    cpp: ['.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.hh', '.h'],
+    polyglot: [
+        '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+        '.py',
+        '.go',
+        '.rs',
+        '.java', '.kt', '.kts',
+        '.swift',
+        '.rb',
+        '.php',
+        '.cs',
+        '.c', '.h', '.cpp', '.cc', '.cxx', '.hpp', '.hxx', '.hh',
+    ],
+    unknown: ['.ts', '.tsx', '.js', '.jsx'],
+}
+
+const EXT_TO_PARSER = new Map<string, ParserKind>()
+for (const ext of OXC_EXTENSIONS) EXT_TO_PARSER.set(ext, 'oxc')
+for (const ext of GO_EXTENSIONS) EXT_TO_PARSER.set(ext, 'go')
+for (const ext of TREE_SITTER_EXTENSIONS) EXT_TO_PARSER.set(ext, 'tree-sitter')
+
+const EXT_TO_LANGUAGE = new Map<string, RegistryLanguage>()
+for (const [language, extensions] of Object.entries(LANGUAGE_EXTENSIONS)) {
+    for (const ext of extensions) {
+        if (!EXT_TO_LANGUAGE.has(ext)) {
+            EXT_TO_LANGUAGE.set(ext, language as RegistryLanguage)
+        }
+    }
+}
+
+export function parserKindForExtension(ext: string): ParserKind {
+    return EXT_TO_PARSER.get(ext.toLowerCase()) ?? 'unknown'
+}
+
+export function languageForExtension(ext: string): RegistryLanguage {
+    return EXT_TO_LANGUAGE.get(ext.toLowerCase()) ?? 'unknown'
+}
+
+export function getParserExtensions(kind: Exclude<ParserKind, 'unknown'>): readonly string[] {
+    return PARSER_EXTENSIONS[kind]
+}
+
+export function getDiscoveryExtensions(language: RegistryLanguage): readonly string[] {
+    return LANGUAGE_EXTENSIONS[language]
+}
+
+export function isTreeSitterExtension(ext: string): boolean {
+    return parserKindForExtension(ext) === 'tree-sitter'
+}

package/src/utils/minimatch.ts

@@ -4,7 +4,7 @@
  * Rules:
  *   - Pattern with no glob chars (*, ?, {, [) → directory prefix match
  *     "src/auth" matches "src/auth/jwt.ts" and "src/auth" itself
- *   - "**" matches any depth
+ *   - "**" matches any depth (zero or more directory segments)
  *   - "*"  matches within a single directory segment
  */
 export function minimatch(filePath: string, pattern: string): boolean {
@@ -17,12 +17,55 @@ export function minimatch(filePath: string, pattern: string): boolean {
     return normalizedPath === bare || normalizedPath.startsWith(bare + '/')
   }
 
-  // Convert glob to regex
-  const regexStr = normalizedPattern
+  // Handle patterns that start with ** - these should match anywhere in the path
+  // e.g., **/venv/** should match if there's a /venv/ segment anywhere
+  if (normalizedPattern.startsWith('**/')) {
+    const rest = normalizedPattern.slice(3) // Remove **/
+    // Check if the rest of the pattern appears as a path segment
+    // For **/venv/**, check if /venv/ is in the path
+    // For **/node_modules/**, check if /node_modules/ is in the path
+    const segments = normalizedPath.split('/')
+    const patternSegments = rest.split('/').filter(Boolean)
+    
+    // Check if pattern segments appear consecutively in path
+    for (let i = 0; i <= segments.length - patternSegments.length; i++) {
+      let match = true
+      for (let j = 0; j < patternSegments.length; j++) {
+        const pseg = patternSegments[j].replace(/\*/g, '[^/]*')
+        if (!new RegExp('^' + pseg + '$', 'i').test(segments[i + j])) {
+          match = false
+          break
+        }
+      }
+      if (match) return true
+    }
+    return false
+  }
+
+  // Convert glob to regex (for patterns not starting with **)
+  let regexStr = normalizedPattern
+    .replace(/\[/g, '\\[')
+    .replace(/\]/g, '\\]')
     .replace(/\./g, '\\.')
-    .replace(/\*\*\//g, '(?:.+/)?')
-    .replace(/\*\*/g, '.*')
-    .replace(/\*/g, '[^/]*')
+  
+  // Replace **/ at end with (?:[^/]+/)* - matches zero or more dir segments ending with /
+  // But we need to handle path/** specifically - matching path/file, path/dir/file, etc.
+  
+  // Handle trailing /** specifically - should match path itself and anything under it
+  if (normalizedPattern.endsWith('/**')) {
+    const base = normalizedPattern.slice(0, -3) // Remove /**
+    // Match either exact base or base + anything
+    return normalizedPath === base || normalizedPath.startsWith(base + '/')
+  }
+  
+  // Replace **/ with (?:[^/]+/)* - matches zero or more directory segments
+  regexStr = regexStr.replace(/\*\*\//g, '(?:[^/]+/)*')
+  // Replace trailing ** with (?:[^/]+/)*[^/]+ - matches zero or more at end  
+  regexStr = regexStr.replace(/\*\*$/g, '(?:[^/]+/)*[^/]+')
+  // Standalone **
+  regexStr = regexStr.replace(/\*\*/g, '(?:[^/]+/)*[^/]+')
+  // Single * matches any characters except slash
+  regexStr = regexStr.replace(/\*/g, '[^/]*')
 
   return new RegExp(`^${regexStr}$`, 'i').test(normalizedPath)
 }

package/tests/adr-manager.test.ts

@@ -94,4 +94,10 @@ describe('AdrManager', () => {
         const decisions = await manager.list()
         expect(decisions).toHaveLength(0)
     })
+
+    it('returns false when removing a missing decision', async () => {
+        const manager = new AdrManager(CONTRACT_PATH)
+        const success = await manager.remove('ADR-404')
+        expect(success).toBe(false)
+    })
 })

package/tests/artifact-transaction.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'bun:test'
+import * as fs from 'node:fs/promises'
+import * as path from 'node:path'
+import * as os from 'node:os'
+import {
+    runArtifactWriteTransaction,
+    recoverArtifactWriteTransactions,
+} from '../src/utils/artifact-transaction'
+
+describe('artifact write transactions', () => {
+    it('commits grouped writes atomically', async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mikk-tx-'))
+        const aPath = path.join(root, 'mikk.lock.json')
+        const bPath = path.join(root, 'claude.md')
+
+        await runArtifactWriteTransaction(root, 'commit-test', [
+            { targetPath: aPath, content: '{"ok":true}' },
+            { targetPath: bPath, content: '# context' },
+        ])
+
+        expect(await fs.readFile(aPath, 'utf-8')).toContain('ok')
+        expect(await fs.readFile(bPath, 'utf-8')).toContain('context')
+
+        await fs.rm(root, { recursive: true, force: true })
+    })
+
+    it('rolls back staged writes after pre-commit crash', async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mikk-tx-'))
+        const lockPath = path.join(root, 'mikk.lock.json')
+
+        await expect(
+            runArtifactWriteTransaction(
+                root,
+                'rollback-test',
+                [{ targetPath: lockPath, content: '{"v":1}' }],
+                { simulateCrashAt: 'after-stage' },
+            ),
+        ).rejects.toThrow('Simulated crash after stage')
+
+        const summary = await recoverArtifactWriteTransactions(root)
+        expect(summary.rolledBack).toBeGreaterThanOrEqual(1)
+
+        let exists = true
+        try {
+            await fs.access(lockPath)
+        } catch {
+            exists = false
+        }
+        expect(exists).toBe(false)
+
+        await fs.rm(root, { recursive: true, force: true })
+    })
+
+    it('recovers commit-ready journals after post-commit-marker crash', async () => {
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'mikk-tx-'))
+        const lockPath = path.join(root, 'mikk.lock.json')
+
+        await expect(
+            runArtifactWriteTransaction(
+                root,
+                'recovery-test',
+                [{ targetPath: lockPath, content: '{"v":2}' }],
+                { simulateCrashAt: 'after-commit-marker' },
+            ),
+        ).rejects.toThrow('Simulated crash after commit marker')
+
+        const summary = await recoverArtifactWriteTransactions(root)
+        expect(summary.recovered).toBeGreaterThanOrEqual(1)
+        expect(await fs.readFile(lockPath, 'utf-8')).toContain('"v":2')
+
+        await fs.rm(root, { recursive: true, force: true })
+    })
+})

package/tests/contract.test.ts

@@ -49,6 +49,18 @@ describe('MikkContractSchema', () => {
             expect(result.data.overwrite.mode).toBe('never')
         }
     })
+
+    it('rejects contract with invalid declared.modules type', () => {
+        const bad = {
+            ...validContract,
+            declared: {
+                ...validContract.declared,
+                modules: 'not-an-array',
+            },
+        }
+        const result = MikkContractSchema.safeParse(bad)
+        expect(result.success).toBe(false)
+    })
 })
 
 describe('LockCompiler', () => {

package/tests/dead-code.test.ts

@@ -131,4 +131,16 @@ describe('DeadCodeDetector', () => {
 
         expect(result.deadFunctions).toHaveLength(0) // InternalHelper is called by exported fn in same file
     })
+
+    it('keeps deadCount aligned with deadFunctions length', () => {
+        const graph = buildTestGraph([
+            ['A', 'nothing'],
+            ['B', 'nothing'],
+        ])
+        const lock = generateDummyLock(graph.nodes)
+
+        const detector = new DeadCodeDetector(graph, lock)
+        const result = detector.detect()
+        expect(result.deadCount).toBe(result.deadFunctions.length)
+    })
 })

package/tests/esm-resolver.test.ts

@@ -73,4 +73,10 @@ describe('OxcResolver - ESM and CJS Resolution', () => {
         const res = await resolver.resolve('./local', path.join(FIXTURE_DIR, 'index.ts'))
         expect(res).toContain('.test-fixture-esm/local.ts')
     })
+
+    it('does not throw for missing package imports', async () => {
+        const resolver = new OxcResolver(FIXTURE_DIR)
+        const res = await resolver.resolve('totally-missing-pkg', path.join(FIXTURE_DIR, 'index.ts'))
+        expect(typeof res).toBe('string')
+    })
 })

package/tests/fs.test.ts

@@ -75,6 +75,12 @@ describe('detectProjectLanguage', () => {
         })
     })
 
+    it('detects Swift from Package.swift', async () => {
+        await withFile('Package.swift', async () => {
+            expect(await detectProjectLanguage(tmpDir)).toBe('swift')
+        })
+    })
+
     it('detects C# from .csproj file', async () => {
         await withFile('MyApp.csproj', async () => {
             expect(await detectProjectLanguage(tmpDir)).toBe('csharp')
@@ -116,7 +122,7 @@ describe('detectProjectLanguage', () => {
 describe('getDiscoveryPatterns', () => {
     const languages: ProjectLanguage[] = [
         'typescript', 'javascript', 'python', 'go', 'rust',
-        'java', 'ruby', 'php', 'csharp', 'unknown',
+        'java', 'swift', 'ruby', 'php', 'csharp', 'unknown',
     ]
 
     for (const lang of languages) {
@@ -143,6 +149,21 @@ describe('getDiscoveryPatterns', () => {
         expect(patterns).toContain('**/*.py')
     })
 
+    it('java discovery patterns include Kotlin scripts for mixed JVM codebases', () => {
+        const { patterns } = getDiscoveryPatterns('java')
+        expect(patterns).toContain('**/*.kts')
+    })
+
+    it('swift patterns include .swift', () => {
+        const { patterns } = getDiscoveryPatterns('swift')
+        expect(patterns).toContain('**/*.swift')
+    })
+
+    it('cpp patterns include .hh headers', () => {
+        const { patterns } = getDiscoveryPatterns('cpp')
+        expect(patterns).toContain('**/*.hh')
+    })
+
     it('all languages ignore .mikk and .git', () => {
         for (const lang of languages) {
             const { ignore } = getDiscoveryPatterns(lang)

package/tests/fuzzy-match.test.ts

@@ -61,6 +61,12 @@ describe('levenshtein', () => {
     test('insertion', () => {
         expect(levenshtein('test', 'tests')).toBe(1)
     })
+
+    test('distance is symmetric', () => {
+        expect(levenshtein('verifyToken', 'tokenVerify')).toBe(
+            levenshtein('tokenVerify', 'verifyToken'),
+        )
+    })
 })
 
 describe('splitCamelCase', () => {

package/tests/go-parser.test.ts

@@ -363,4 +363,11 @@ describe('GoParser', () => {
         const resolved = await parser.resolveImports(files, '/tmp/no-gomod-' + Date.now())
         expect(resolved.length).toBe(1)
     })
+
+    test('parse keeps deterministic hash for identical input', async () => {
+        const parser = new GoParser()
+        const a = await parser.parse('auth/service.go', SIMPLE_GO)
+        const b = await parser.parse('auth/service.go', SIMPLE_GO)
+        expect(a.hash).toBe(b.hash)
+    })
 })

package/tests/graph.test.ts

@@ -167,4 +167,14 @@ describe('ClusterDetector', () => {
         expect(score).toBeGreaterThanOrEqual(0)
         expect(score).toBeLessThanOrEqual(1)
     })
+
+    it('keeps distinct function nodes for same function names in different files', () => {
+        const files = [
+            mockParsedFile('src/auth/a.ts', [mockFunction('shared', [], 'src/auth/a.ts')]),
+            mockParsedFile('src/db/b.ts', [mockFunction('shared', [], 'src/db/b.ts')]),
+        ]
+        const graph = new GraphBuilder().build(files)
+        expect(graph.nodes.has('fn:src/auth/a.ts:shared')).toBe(true)
+        expect(graph.nodes.has('fn:src/db/b.ts:shared')).toBe(true)
+    })
 })

package/tests/hash.test.ts

@@ -46,4 +46,10 @@ describe('computeRootHash', () => {
         const hash2 = computeRootHash({ payments: 'def', auth: 'abc' })
         expect(hash1).toBe(hash2)
     })
+
+    it('changes when a module hash changes', () => {
+        const base = computeRootHash({ auth: 'abc', payments: 'def' })
+        const changed = computeRootHash({ auth: 'abc', payments: 'xyz' })
+        expect(base).not.toBe(changed)
+    })
 })

package/tests/impact-classified.test.ts

@@ -71,4 +71,17 @@ describe('ImpactAnalyzer - Classified', () => {
         expect(result.classified.low).toHaveLength(1)
         expect(result.classified.low[0].nodeId).toBe('fn:src/highriskauthservice.ts:highriskauthservice')
     })
+
+    it('deduplicates impacted nodes when changed list includes duplicates', () => {
+        const graph = buildTestGraph([
+            ['A', 'B'],
+            ['B', 'C'],
+            ['C', 'nothing'],
+        ])
+
+        const analyzer = new ImpactAnalyzer(graph)
+        const result = analyzer.analyze(['fn:src/c.ts:c', 'fn:src/c.ts:c'])
+        const unique = new Set(result.impacted)
+        expect(unique.size).toBe(result.impacted.length)
+    })
 })

package/tests/js-parser.test.ts

@@ -1042,6 +1042,16 @@ describe('JavaScript - Additional Edge Cases', () => {
         })
     })
 
+    describe('Deterministic parsing', () => {
+        test('produces identical file hash for identical source', async () => {
+            const parser = new JavaScriptParser()
+            const source = 'export function stable() { return 1 }'
+            const a = await parser.parse('src/stable.js', source)
+            const b = await parser.parse('src/stable.js', source)
+            expect(a.hash).toBe(b.hash)
+        })
+    })
+
     describe('Chained Methods', () => {
         test('handles method chaining', () => {
             const src = `