@nomos-arc/arc 0.1.0

package/src/core/graph/drift/__tests__/comparator.test.ts

@@ -0,0 +1,335 @@
+import { describe, it, expect } from 'vitest';
+import { compare } from '../comparator.js';
+import type { FileNode, ProjectMap, SymbolEntry, ImportEntry, SemanticInfo } from '../../../../types/index.js';
+
+// ─── Factory helpers ──────────────────────────────────────────────────────────
+
+function makeSymbol(
+  overrides: Pick<SymbolEntry, 'name'> & Partial<SymbolEntry>,
+): SymbolEntry {
+  return {
+    kind: 'function',
+    line: 1,
+    end_line: null,
+    signature: null,
+    exported: false,
+    ...overrides,
+  };
+}
+
+function makeImport(
+  overrides: Pick<ImportEntry, 'source'> & Partial<ImportEntry>,
+): ImportEntry {
+  return {
+    resolved: null,
+    symbols: [],
+    is_external: false,
+    ...overrides,
+  };
+}
+
+function makeSemanticInfo(sourceHash: string): SemanticInfo {
+  return {
+    overview: 'test overview',
+    purpose: 'test purpose',
+    key_logic: [],
+    usage_context: [],
+    source_hash: sourceHash,
+    enriched_at: '2026-01-01T00:00:00.000Z',
+    model: 'gemini-1.5-pro',
+  };
+}
+
+function makeFileNode(
+  file: string,
+  hash: string,
+  overrides: Partial<Omit<FileNode, 'file' | 'hash'>> = {},
+): FileNode {
+  return {
+    file,
+    hash,
+    language: 'typescript',
+    symbols: [],
+    imports: [],
+    dependents: [],
+    dependencies: [],
+    depth: 0,
+    last_parsed_at: null,
+    semantic: null,
+    enrichment_status: 'structural',
+    ...overrides,
+  };
+}
+
+function makeMap(
+  files: Record<string, FileNode>,
+  statsOverrides: Partial<ProjectMap['stats']> = {},
+): ProjectMap {
+  return {
+    schema_version: 1,
+    generated_at: '2026-01-01T00:00:00.000Z',
+    root: '/project',
+    files,
+    stats: {
+      total_files: Object.keys(files).length,
+      total_symbols: 0,
+      total_edges: 0,
+      core_modules: [],
+      structural_only: Object.keys(files).length,
+      semantically_enriched: 0,
+      indexed: 0,
+      ...statsOverrides,
+    },
+  };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('compare()', () => {
+  it('1. empty maps → empty DriftReport with all counts 0', () => {
+    const result = compare(makeMap({}), makeMap({}));
+    expect(result.files).toHaveLength(0);
+    expect(result.symbols).toHaveLength(0);
+    expect(result.imports).toHaveLength(0);
+    expect(result.graph.depth_changes).toHaveLength(0);
+    expect(result.graph.core_modules_added).toHaveLength(0);
+    expect(result.graph.core_modules_removed).toHaveLength(0);
+    expect(result.stale_enrichments).toHaveLength(0);
+    expect(result.summary.files_added).toBe(0);
+    expect(result.summary.files_removed).toBe(0);
+    expect(result.summary.files_modified).toBe(0);
+    expect(result.summary.symbols_added).toBe(0);
+    expect(result.summary.symbols_removed).toBe(0);
+    expect(result.summary.symbols_changed).toBe(0);
+    expect(result.summary.imports_added).toBe(0);
+    expect(result.summary.imports_removed).toBe(0);
+    expect(result.summary.depth_changes).toBe(0);
+    expect(result.summary.stale_enrichments).toBe(0);
+  });
+
+  it('2. file added → status "added", hash_before null', () => {
+    const baseline = makeMap({});
+    const current = makeMap({ 'src/new.ts': makeFileNode('src/new.ts', 'hash-new') });
+    const result = compare(baseline, current);
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].status).toBe('added');
+    expect(result.files[0].file).toBe('src/new.ts');
+    expect(result.files[0].hash_before).toBeNull();
+    expect(result.files[0].hash_after).toBe('hash-new');
+    expect(result.summary.files_added).toBe(1);
+  });
+
+  it('3. file removed → status "removed", hash_after null', () => {
+    const baseline = makeMap({ 'src/old.ts': makeFileNode('src/old.ts', 'hash-old') });
+    const current = makeMap({});
+    const result = compare(baseline, current);
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].status).toBe('removed');
+    expect(result.files[0].file).toBe('src/old.ts');
+    expect(result.files[0].hash_before).toBe('hash-old');
+    expect(result.files[0].hash_after).toBeNull();
+    expect(result.summary.files_removed).toBe(1);
+  });
+
+  it('4. file modified (hash change) → status "modified"', () => {
+    const baseline = makeMap({ 'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v1') });
+    const current = makeMap({ 'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v2') });
+    const result = compare(baseline, current);
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0].status).toBe('modified');
+    expect(result.files[0].hash_before).toBe('hash-v1');
+    expect(result.files[0].hash_after).toBe('hash-v2');
+    expect(result.summary.files_modified).toBe(1);
+  });
+
+  it('5. file unchanged (same hash) → not in files[]', () => {
+    const node = makeFileNode('src/same.ts', 'hash-stable');
+    const result = compare(
+      makeMap({ 'src/same.ts': node }),
+      makeMap({ 'src/same.ts': { ...node } }),
+    );
+    expect(result.files).toHaveLength(0);
+  });
+
+  it('6. symbol added → status "added"', () => {
+    const baseline = makeMap({ 'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v1') });
+    const current = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v2', {
+        symbols: [makeSymbol({ name: 'doSomething', kind: 'function', exported: true })],
+      }),
+    });
+    const result = compare(baseline, current);
+    expect(result.symbols).toHaveLength(1);
+    expect(result.symbols[0].status).toBe('added');
+    expect(result.symbols[0].name).toBe('doSomething');
+    expect(result.summary.symbols_added).toBe(1);
+  });
+
+  it('7. symbol removed (exported, has dependents) → status "removed", dependents_affected populated', () => {
+    const baseline = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v1', {
+        symbols: [makeSymbol({ name: 'doSomething', kind: 'function', exported: true })],
+        dependents: ['src/consumer.ts', 'src/other.ts'],
+      }),
+    });
+    const current = makeMap({ 'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v2') });
+    const result = compare(baseline, current);
+    expect(result.symbols).toHaveLength(1);
+    expect(result.symbols[0].status).toBe('removed');
+    expect(result.symbols[0].exported).toBe(true);
+    expect(result.symbols[0].dependents_affected).toEqual(['src/consumer.ts', 'src/other.ts']);
+    expect(result.summary.symbols_removed).toBe(1);
+  });
+
+  it('8. symbol removed (not exported) → status "removed", exported false', () => {
+    const baseline = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v1', {
+        symbols: [makeSymbol({ name: 'internalHelper', kind: 'function', exported: false })],
+      }),
+    });
+    const current = makeMap({ 'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v2') });
+    const result = compare(baseline, current);
+    expect(result.symbols).toHaveLength(1);
+    expect(result.symbols[0].status).toBe('removed');
+    expect(result.symbols[0].exported).toBe(false);
+  });
+
+  it('9. signature changed → status "signature_changed", signature_before/after populated', () => {
+    const baseline = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v1', {
+        symbols: [
+          makeSymbol({ name: 'doSomething', kind: 'function', signature: '(a: string): void' }),
+        ],
+      }),
+    });
+    const current = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v2', {
+        symbols: [
+          makeSymbol({
+            name: 'doSomething',
+            kind: 'function',
+            signature: '(a: string, b: number): void',
+          }),
+        ],
+      }),
+    });
+    const result = compare(baseline, current);
+    expect(result.symbols).toHaveLength(1);
+    expect(result.symbols[0].status).toBe('signature_changed');
+    expect(result.symbols[0].signature_before).toBe('(a: string): void');
+    expect(result.symbols[0].signature_after).toBe('(a: string, b: number): void');
+    expect(result.summary.symbols_changed).toBe(1);
+  });
+
+  it('10. import added → status "added" in imports[]', () => {
+    const baseline = makeMap({ 'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v1') });
+    const current = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v2', {
+        imports: [
+          makeImport({ source: 'src/bar.ts', resolved: 'src/bar.ts', is_external: false }),
+        ],
+      }),
+    });
+    const result = compare(baseline, current);
+    expect(result.imports).toHaveLength(1);
+    expect(result.imports[0].status).toBe('added');
+    expect(result.imports[0].source).toBe('src/bar.ts');
+    expect(result.summary.imports_added).toBe(1);
+  });
+
+  it('11. import removed → status "removed" in imports[]', () => {
+    const baseline = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v1', {
+        imports: [
+          makeImport({ source: 'src/bar.ts', resolved: 'src/bar.ts', is_external: false }),
+        ],
+      }),
+    });
+    const current = makeMap({ 'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v2') });
+    const result = compare(baseline, current);
+    expect(result.imports).toHaveLength(1);
+    expect(result.imports[0].status).toBe('removed');
+    expect(result.summary.imports_removed).toBe(1);
+  });
+
+  it('12. depth change → graph.depth_changes[] populated', () => {
+    const baseline = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-same', { depth: 1 }),
+    });
+    const current = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-same', { depth: 4 }),
+    });
+    const result = compare(baseline, current);
+    expect(result.graph.depth_changes).toHaveLength(1);
+    expect(result.graph.depth_changes[0]).toEqual({ file: 'src/foo.ts', before: 1, after: 4 });
+    expect(result.summary.depth_changes).toBe(1);
+  });
+
+  it('13. core module promoted → graph.core_modules_added[] populated, removed empty', () => {
+    const baseline = makeMap({}, { core_modules: [] });
+    const current = makeMap({}, { core_modules: ['src/core.ts'] });
+    const result = compare(baseline, current);
+    expect(result.graph.core_modules_added).toContain('src/core.ts');
+    expect(result.graph.core_modules_removed).toHaveLength(0);
+  });
+
+  it('14. stale enrichment (source_hash !== hash) → stale_enrichments[] populated', () => {
+    const current = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-new', {
+        enrichment_status: 'semantic',
+        semantic: makeSemanticInfo('hash-old'), // source_hash differs from file hash 'hash-new'
+      }),
+    });
+    const result = compare(makeMap({}), current);
+    expect(result.stale_enrichments).toHaveLength(1);
+    expect(result.stale_enrichments[0].file).toBe('src/foo.ts');
+    expect(result.stale_enrichments[0].hash_changed).toBe(true);
+    expect(result.summary.stale_enrichments).toBe(1);
+  });
+
+  it('15. summary counts are accurate for mixed changes', () => {
+    const baseline = makeMap({
+      'src/removed.ts': makeFileNode('src/removed.ts', 'hash-rm'),
+      'src/modified.ts': makeFileNode('src/modified.ts', 'hash-v1', {
+        symbols: [makeSymbol({ name: 'fn', kind: 'function' })],
+      }),
+    });
+    const current = makeMap({
+      'src/added.ts': makeFileNode('src/added.ts', 'hash-new'),
+      'src/modified.ts': makeFileNode('src/modified.ts', 'hash-v2', {
+        symbols: [
+          makeSymbol({ name: 'fn', kind: 'function', signature: '(x: number): void' }),
+          makeSymbol({ name: 'newFn', kind: 'function' }),
+        ],
+      }),
+    });
+    const result = compare(baseline, current);
+    expect(result.summary.files_added).toBe(1);
+    expect(result.summary.files_removed).toBe(1);
+    expect(result.summary.files_modified).toBe(1);
+    expect(result.summary.symbols_changed).toBe(1);
+    expect(result.summary.symbols_added).toBe(1);
+    expect(result.summary.symbols_removed).toBe(0);
+  });
+
+  it('16. same-name symbols with different kinds tracked separately via name:kind composite key', () => {
+    const typeSym = makeSymbol({ name: 'Config', kind: 'type', exported: true });
+    const fnSym = makeSymbol({ name: 'Config', kind: 'function', exported: true });
+    const baseline = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v1', {
+        symbols: [typeSym, fnSym],
+      }),
+    });
+    const current = makeMap({
+      'src/foo.ts': makeFileNode('src/foo.ts', 'hash-v2', {
+        symbols: [], // both removed
+      }),
+    });
+    const result = compare(baseline, current);
+    expect(result.symbols).toHaveLength(2);
+    const compositeKeys = result.symbols.map((s) => `${s.name}:${s.kind}`);
+    expect(compositeKeys).toContain('Config:type');
+    expect(compositeKeys).toContain('Config:function');
+    expect(result.summary.symbols_removed).toBe(2);
+  });
+});