@nomos-arc/arc 0.1.0

package/src/core/graph/__tests__/contract-writer.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { ContractWriter } from '../contract-writer.js';
+import type { FileNode, SemanticInfo } from '../../../types/index.js';
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeLogger() {
+  return { info: () => {}, debug: () => {} };
+}
+
+function makeSemantic(overrides: Partial<SemanticInfo> = {}): SemanticInfo {
+  return {
+    overview: 'Manages state transitions',
+    purpose: 'Provides atomic read-write operations',
+    key_logic: ['Reads JSON from disk', 'Writes atomically via tmp→rename'],
+    usage_context: ['Used by Orchestrator', 'Used by CLI'],
+    source_hash: 'deadbeef',
+    enriched_at: '2026-04-05T12:00:00.000Z',
+    model: 'gemini-1.5-flash',
+    ...overrides,
+  };
+}
+
+function makeFileNode(overrides: Partial<FileNode> = {}): FileNode {
+  return {
+    file: 'src/core/state.ts',
+    hash: 'deadbeef',
+    language: 'typescript',
+    symbols: [],
+    imports: [],
+    dependents: ['src/orchestrator.ts'],
+    dependencies: [],
+    depth: 2,
+    last_parsed_at: null,
+    semantic: makeSemantic(),
+    enrichment_status: 'semantic',
+    ...overrides,
+  };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('ContractWriter', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'contract-writer-test-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  // ─── Test 1: Writes .semantic.md with correct structure ──────────────────
+
+  it('writes .semantic.md with all four sections', async () => {
+    const writer = new ContractWriter(tmpDir, makeLogger());
+    const node = makeFileNode({ file: 'src/core/state.ts' });
+
+    // Create the source directory
+    await fs.mkdir(path.join(tmpDir, 'src', 'core'), { recursive: true });
+
+    const nodes = new Map([['src/core/state.ts', node]]);
+    await writer.writeContracts(nodes);
+
+    const outputPath = path.join(tmpDir, 'src', 'core', 'state.semantic.md');
+    const content = await fs.readFile(outputPath, 'utf-8');
+
+    // Header
+    expect(content).toContain('# state.ts — Semantic Contract');
+    expect(content).toContain('Auto-generated by `arc map`');
+
+    // All four sections
+    expect(content).toContain('## Overview');
+    expect(content).toContain('Manages state transitions');
+
+    expect(content).toContain('## Purpose');
+    expect(content).toContain('Provides atomic read-write operations');
+
+    expect(content).toContain('## Key Logic');
+    expect(content).toContain('1. Reads JSON from disk');
+    expect(content).toContain('2. Writes atomically via tmp→rename');
+
+    expect(content).toContain('## Usage Context');
+    expect(content).toContain('- Used by Orchestrator');
+    expect(content).toContain('- Used by CLI');
+
+    // Footer
+    expect(content).toContain('Enriched at: 2026-04-05T12:00:00.000Z');
+    expect(content).toContain('Model: gemini-1.5-flash');
+
+    // source_hash must be present (for skip-on-unchanged check)
+    expect(content).toContain('deadbeef');
+  });
+
+  // ─── Test 2: Skips when source_hash matches ───────────────────────────────
+
+  it('skips writing when existing .semantic.md contains the current source_hash', async () => {
+    const writer = new ContractWriter(tmpDir, makeLogger());
+    const node = makeFileNode({ file: 'src/core/state.ts' });
+
+    await fs.mkdir(path.join(tmpDir, 'src', 'core'), { recursive: true });
+    const outputPath = path.join(tmpDir, 'src', 'core', 'state.semantic.md');
+
+    // Pre-create file that already contains the current source_hash
+    const existingContent = `# state.ts — Semantic Contract\ndeadbeef\nold content`;
+    await fs.writeFile(outputPath, existingContent, 'utf-8');
+
+    const nodes = new Map([['src/core/state.ts', node]]);
+    await writer.writeContracts(nodes);
+
+    // File should be unchanged
+    const content = await fs.readFile(outputPath, 'utf-8');
+    expect(content).toBe(existingContent);
+  });
+
+  // ─── Test 3: Overwrites when hash changed ─────────────────────────────────
+
+  it('overwrites .semantic.md when source_hash has changed', async () => {
+    const writer = new ContractWriter(tmpDir, makeLogger());
+    const node = makeFileNode({
+      file: 'src/core/state.ts',
+      hash: 'newhash999',
+      semantic: makeSemantic({ source_hash: 'newhash999' }),
+    });
+
+    await fs.mkdir(path.join(tmpDir, 'src', 'core'), { recursive: true });
+    const outputPath = path.join(tmpDir, 'src', 'core', 'state.semantic.md');
+
+    // Existing file has old hash
+    await fs.writeFile(outputPath, '# old content\noldhash000', 'utf-8');
+
+    const nodes = new Map([['src/core/state.ts', node]]);
+    await writer.writeContracts(nodes);
+
+    const content = await fs.readFile(outputPath, 'utf-8');
+    expect(content).toContain('newhash999');
+    expect(content).not.toContain('old content');
+  });
+
+  // ─── Test 4: Skips files with semantic: null ──────────────────────────────
+
+  it('skips files where semantic is null', async () => {
+    const writer = new ContractWriter(tmpDir, makeLogger());
+    const node = makeFileNode({ file: 'src/core/state.ts', semantic: null });
+
+    await fs.mkdir(path.join(tmpDir, 'src', 'core'), { recursive: true });
+    const outputPath = path.join(tmpDir, 'src', 'core', 'state.semantic.md');
+
+    const nodes = new Map([['src/core/state.ts', node]]);
+    await writer.writeContracts(nodes);
+
+    // File should NOT have been created
+    await expect(fs.access(outputPath)).rejects.toThrow();
+  });
+
+  // ─── Test 5: [AMB-5] Creates parent directory if missing ─────────────────
+
+  it('[AMB-5] creates missing parent directory before writing', async () => {
+    const writer = new ContractWriter(tmpDir, makeLogger());
+    // Nested path whose parent directories do not exist yet
+    const node = makeFileNode({ file: 'src/deep/nested/util.ts' });
+
+    // Do NOT create the directory ahead of time
+    const nodes = new Map([['src/deep/nested/util.ts', node]]);
+    await writer.writeContracts(nodes);
+
+    const outputPath = path.join(tmpDir, 'src', 'deep', 'nested', 'util.semantic.md');
+    const content = await fs.readFile(outputPath, 'utf-8');
+    expect(content).toContain('# util.ts — Semantic Contract');
+  });
+});

package/src/core/graph/__tests__/enricher.test.ts

@@ -0,0 +1,299 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { NomosError } from '../../errors.js';
+import type { NomosConfig, FileNode } from '../../../types/index.js';
+
+// ─── Hoist mocks so they are available in vi.mock factory ────────────────────
+
+const mocks = vi.hoisted(() => ({
+  generateContent: vi.fn(),
+  getGenerativeModel: vi.fn(),
+  readFile: vi.fn(),
+}));
+
+// ─── Mock @google/generative-ai ───────────────────────────────────────────────
+
+vi.mock('@google/generative-ai', () => ({
+  // Use a class so `new GoogleGenerativeAI()` works correctly in the enricher
+  GoogleGenerativeAI: class MockGAI {
+    getGenerativeModel(...args: unknown[]) {
+      return mocks.getGenerativeModel(...args);
+    }
+  },
+  SchemaType: {
+    OBJECT: 'OBJECT',
+    STRING: 'STRING',
+    ARRAY: 'ARRAY',
+  },
+}));
+
+// ─── Mock fs/promises ─────────────────────────────────────────────────────────
+
+vi.mock('node:fs/promises', () => ({
+  readFile: mocks.readFile,
+}));
+
+// ─── Import under test (after mocks registered) ───────────────────────────────
+
+const { SemanticEnricher } = await import('../enricher.js');
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeConfig(overrides: Partial<NomosConfig['graph']> = {}): NomosConfig['graph'] {
+  return {
+    exclude_patterns: [],
+    ai_enrichment: true,
+    ai_model: 'gemini-1.5-flash',
+    ai_concurrency: 1,
+    ai_requests_per_minute: 3600, // gapMs = 16ms — fast for tests
+    max_file_chars: 4000,
+    core_modules_count: 3,
+    output_dir: 'tasks-management/graph',
+    ...overrides,
+  };
+}
+
+function makeLogger() {
+  return { info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+}
+
+function makeFileNode(overrides: Partial<FileNode> = {}): FileNode {
+  return {
+    file: 'src/foo.ts',
+    hash: 'abc123',
+    language: 'typescript',
+    symbols: [],
+    imports: [],
+    dependents: [],
+    dependencies: [],
+    depth: 0,
+    last_parsed_at: null,
+    semantic: null,
+    enrichment_status: 'structural',
+    ...overrides,
+  };
+}
+
+const VALID_RESPONSE = {
+  overview: 'Overview text',
+  purpose: 'Purpose text',
+  key_logic: ['Logic A', 'Logic B'],
+  usage_context: ['Context A'],
+};
+
+function okResponse(data = VALID_RESPONSE) {
+  return { response: { text: () => JSON.stringify(data) } };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('SemanticEnricher', () => {
+  let savedApiKey: string | undefined;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    savedApiKey = process.env['GEMINI_API_KEY'];
+    process.env['GEMINI_API_KEY'] = 'test-key';
+
+    // Wire getGenerativeModel to return an object with a generateContent mock
+    mocks.getGenerativeModel.mockReturnValue({ generateContent: mocks.generateContent });
+    mocks.generateContent.mockResolvedValue(okResponse());
+    mocks.readFile.mockResolvedValue('file content here');
+
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    if (savedApiKey === undefined) {
+      delete process.env['GEMINI_API_KEY'];
+    } else {
+      process.env['GEMINI_API_KEY'] = savedApiKey;
+    }
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  // ─── Test 1: Enriches a file with semantic: null ─────────────────────────
+
+  it('enriches a file with null semantic — populates SemanticInfo', async () => {
+    const enricher = new SemanticEnricher('/project', makeConfig(), makeLogger());
+    const node = makeFileNode();
+    const nodes = new Map([['src/foo.ts', node]]);
+
+    const enrichPromise = enricher.enrich(nodes, { cancelled: false });
+    await vi.runAllTimersAsync();
+    const failures = await enrichPromise;
+
+    expect(failures).toBe(0);
+    expect(node.semantic).not.toBeNull();
+    expect(node.semantic?.overview).toBe('Overview text');
+    expect(node.semantic?.purpose).toBe('Purpose text');
+    expect(node.semantic?.key_logic).toEqual(['Logic A', 'Logic B']);
+    expect(node.semantic?.source_hash).toBe('abc123');
+    expect(node.semantic?.model).toBe('gemini-1.5-flash');
+  });
+
+  // ─── Test 2: Staleness check — skips when source_hash matches ────────────
+
+  it('skips enrichment when source_hash matches current hash', async () => {
+    const enricher = new SemanticEnricher('/project', makeConfig(), makeLogger());
+    const node = makeFileNode({
+      hash: 'abc123',
+      semantic: {
+        overview: 'Existing',
+        purpose: 'Existing purpose',
+        key_logic: [],
+        usage_context: [],
+        source_hash: 'abc123', // matches hash → should skip
+        enriched_at: '2026-01-01T00:00:00.000Z',
+        model: 'gemini-1.5-flash',
+      },
+    });
+    const nodes = new Map([['src/foo.ts', node]]);
+
+    const failures = await enricher.enrich(nodes, { cancelled: false });
+
+    expect(failures).toBe(0);
+    expect(mocks.generateContent).not.toHaveBeenCalled();
+    expect(node.semantic?.overview).toBe('Existing'); // unchanged
+  });
+
+  // ─── Test 3: Zod validation failure → semantic: null ─────────────────────
+
+  it('sets semantic: null when Zod validation fails (wrong type for overview)', async () => {
+    const logger = makeLogger();
+    const enricher = new SemanticEnricher('/project', makeConfig(), logger);
+    const node = makeFileNode();
+    const nodes = new Map([['src/foo.ts', node]]);
+
+    // overview is a number instead of string → Zod fails
+    mocks.generateContent.mockResolvedValueOnce(
+      okResponse({ overview: 123 as unknown as string, purpose: 'p', key_logic: [], usage_context: [] }),
+    );
+
+    const enrichPromise = enricher.enrich(nodes, { cancelled: false });
+    await vi.runAllTimersAsync();
+    const failures = await enrichPromise;
+
+    expect(failures).toBe(1);
+    expect(node.semantic).toBeNull();
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('Zod validation failed'));
+  });
+
+  // ─── Test 4: Retry on 429 — succeeds on 3rd attempt ──────────────────────
+
+  it('retries on 429 and succeeds on the 3rd attempt', async () => {
+    const enricher = new SemanticEnricher('/project', makeConfig(), makeLogger());
+    const node = makeFileNode();
+    const nodes = new Map([['src/foo.ts', node]]);
+
+    const retryError = new Error('HTTP 429 Too Many Requests');
+    mocks.generateContent
+      .mockRejectedValueOnce(retryError)
+      .mockRejectedValueOnce(retryError)
+      .mockResolvedValueOnce(okResponse());
+
+    const enrichPromise = enricher.enrich(nodes, { cancelled: false });
+    await vi.runAllTimersAsync();
+    const failures = await enrichPromise;
+
+    expect(failures).toBe(0);
+    expect(mocks.generateContent).toHaveBeenCalledTimes(3);
+    expect(node.semantic).not.toBeNull();
+    expect(node.semantic?.overview).toBe('Overview text');
+  });
+
+  // ─── Test 5: Missing API key → constructor throws NomosError ─────────────
+
+  it('throws NomosError with code graph_ai_key_missing when GEMINI_API_KEY unset', () => {
+    delete process.env['GEMINI_API_KEY'];
+    const config = makeConfig({ ai_enrichment: true });
+
+    let caught: unknown;
+    try {
+      new SemanticEnricher('/project', config, makeLogger());
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(NomosError);
+    expect((caught as NomosError).code).toBe('graph_ai_key_missing');
+  });
+
+  // ─── Test 6: All retries exhausted → semantic: null, error logged ─────────
+
+  it('sets semantic: null and logs error when all 3 retries are exhausted', async () => {
+    const logger = makeLogger();
+    const enricher = new SemanticEnricher('/project', makeConfig(), logger);
+    const node = makeFileNode();
+    const nodes = new Map([['src/foo.ts', node]]);
+
+    const retryError = new Error('HTTP 429 Too Many Requests');
+    // 1 initial + 3 retries = 4 total calls, all fail
+    mocks.generateContent
+      .mockRejectedValueOnce(retryError)
+      .mockRejectedValueOnce(retryError)
+      .mockRejectedValueOnce(retryError)
+      .mockRejectedValueOnce(retryError);
+
+    const enrichPromise = enricher.enrich(nodes, { cancelled: false });
+    await vi.runAllTimersAsync();
+    const failures = await enrichPromise;
+
+    expect(failures).toBe(1);
+    expect(node.semantic).toBeNull();
+    expect(mocks.generateContent).toHaveBeenCalledTimes(4);
+    expect(logger.error).toHaveBeenCalledWith(
+      expect.stringContaining('after 3 retries — skipping'),
+    );
+  });
+
+  // ─── Test 7: [GAP-3] Cancellation flag stops processing ──────────────────
+
+  it('[GAP-3] stops enrichment when cancellationFlag is set mid-run', async () => {
+    const logger = makeLogger();
+    const enricher = new SemanticEnricher('/project', makeConfig({ ai_concurrency: 1 }), logger);
+
+    const node1 = makeFileNode({ file: 'src/a.ts' });
+    const node2 = makeFileNode({ file: 'src/b.ts' });
+    const cancellationFlag = { cancelled: false };
+
+    // After first file is enriched, set the cancellation flag
+    mocks.generateContent.mockImplementationOnce(async () => {
+      cancellationFlag.cancelled = true;
+      return okResponse();
+    });
+
+    const nodes = new Map([
+      ['src/a.ts', node1],
+      ['src/b.ts', node2],
+    ]);
+
+    const enrichPromise = enricher.enrich(nodes, cancellationFlag);
+    await vi.runAllTimersAsync();
+    await enrichPromise;
+
+    // Only a.ts should have been processed
+    expect(mocks.generateContent).toHaveBeenCalledTimes(1);
+    expect(node2.semantic).toBeNull();
+    expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('cancelled'));
+  });
+
+  // ─── Test 8: [AMB-2] Reads file content from disk (not ScanResult) ───────
+
+  it('[AMB-2] reads file content from disk via fs.readFile, not from ScanResult', async () => {
+    const enricher = new SemanticEnricher('/project', makeConfig(), makeLogger());
+    const node = makeFileNode({ file: 'src/foo.ts' });
+    const nodes = new Map([['src/foo.ts', node]]);
+
+    mocks.readFile.mockResolvedValueOnce('actual disk content');
+
+    const enrichPromise = enricher.enrich(nodes, { cancelled: false });
+    await vi.runAllTimersAsync();
+    await enrichPromise;
+
+    expect(mocks.readFile).toHaveBeenCalledWith(
+      expect.stringContaining('src/foo.ts'),
+      'utf-8',
+    );
+  });
+});

package/src/core/graph/__tests__/parser.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { ASTParser } from '../parser.js';
+
+let parser: ASTParser;
+
+beforeAll(async () => {
+  // WASM init is async — must complete before any tests run
+  parser = new ASTParser();
+  await parser.init();
+});
+
+// ─── 1. Function declarations ────────────────────────────────────────────────
+
+describe('function declarations', () => {
+  it('extracts name, line, end_line, exported, and signature', () => {
+    const src = `export function greet(name: string): string {\n  return name;\n}`;
+    const { symbols } = parser.parse('test.ts', src, 'typescript');
+    const fn = symbols.find(s => s.name === 'greet');
+    expect(fn).toBeDefined();
+    expect(fn!.kind).toBe('function');
+    expect(fn!.line).toBe(1);
+    expect(fn!.end_line).toBe(3);
+    expect(fn!.exported).toBe(true);
+    expect(fn!.signature).toContain('greet');
+  });
+
+  it('marks non-exported function as exported=false', () => {
+    const src = `function hidden() {}`;
+    const { symbols } = parser.parse('test.ts', src, 'typescript');
+    const fn = symbols.find(s => s.name === 'hidden');
+    expect(fn).toBeDefined();
+    expect(fn!.exported).toBe(false);
+  });
+});
+
+// ─── 2. Class + method extraction ────────────────────────────────────────────
+
+describe('class and method extraction', () => {
+  it('extracts class and methods with ClassName.methodName format', () => {
+    const src = `
+export class MyService {
+  doWork(x: number): void {}
+  private helper(): string { return ''; }
+}`.trim();
+    const { symbols } = parser.parse('test.ts', src, 'typescript');
+
+    const cls = symbols.find(s => s.name === 'MyService');
+    expect(cls).toBeDefined();
+    expect(cls!.kind).toBe('class');
+    expect(cls!.exported).toBe(true);
+
+    const method = symbols.find(s => s.name === 'MyService.doWork');
+    expect(method).toBeDefined();
+    expect(method!.kind).toBe('method');
+
+    const priv = symbols.find(s => s.name === 'MyService.helper');
+    expect(priv).toBeDefined();
+  });
+});
+
+// ─── 3. Interface, type, enum ─────────────────────────────────────────────────
+
+describe('interface, type, and enum declarations', () => {
+  it('extracts interface declaration', () => {
+    const src = `export interface Config { host: string; }`;
+    const { symbols } = parser.parse('test.ts', src, 'typescript');
+    const iface = symbols.find(s => s.name === 'Config');
+    expect(iface).toBeDefined();
+    expect(iface!.kind).toBe('interface');
+    expect(iface!.exported).toBe(true);
+  });
+
+  it('extracts type alias declaration', () => {
+    const src = `export type ID = string | number;`;
+    const { symbols } = parser.parse('test.ts', src, 'typescript');
+    const t = symbols.find(s => s.name === 'ID');
+    expect(t).toBeDefined();
+    expect(t!.kind).toBe('type');
+  });
+
+  it('extracts enum declaration', () => {
+    const src = `export enum Status { Active, Inactive }`;
+    const { symbols } = parser.parse('test.ts', src, 'typescript');
+    const e = symbols.find(s => s.name === 'Status');
+    expect(e).toBeDefined();
+    expect(e!.kind).toBe('enum');
+  });
+});
+
+// ─── 4. export const variable declarations ────────────────────────────────────
+
+describe('export const variable / arrow function declarations', () => {
+  it('extracts export const arrow function as kind=function', () => {
+    const src = `export const multiply = (a: number, b: number) => a * b;`;
+    const { symbols } = parser.parse('test.ts', src, 'typescript');
+    const sym = symbols.find(s => s.name === 'multiply');
+    expect(sym).toBeDefined();
+    expect(sym!.kind).toBe('function');
+    expect(sym!.exported).toBe(true);
+  });
+
+  it('extracts export const non-function variable', () => {
+    const src = `export const VERSION = '1.0.0';`;
+    const { symbols } = parser.parse('test.ts', src, 'typescript');
+    const sym = symbols.find(s => s.name === 'VERSION');
+    expect(sym).toBeDefined();
+    expect(sym!.kind).toBe('variable');
+    expect(sym!.exported).toBe(true);
+  });
+});
+
+// ─── 5. TSX grammar selection ─────────────────────────────────────────────────
+
+describe('TSX grammar selection', () => {
+  it('parses .tsx file with JSX content without throwing', () => {
+    const src = `
+export function Button({ label }: { label: string }) {
+  return <button>{label}</button>;
+}`.trim();
+    const { symbols } = parser.parse('Button.tsx', src, 'tsx');
+    const fn = symbols.find(s => s.name === 'Button');
+    expect(fn).toBeDefined();
+    expect(fn!.kind).toBe('function');
+  });
+});
+
+// ─── 6. Error-node threshold ──────────────────────────────────────────────────
+
+describe('error-node threshold', () => {
+  it('returns empty arrays for heavily malformed TypeScript (> 20% errors)', () => {
+    // Produce a file that tree-sitter cannot parse — mostly garbage tokens
+    const src = '??? @@@ !!! ??? @@@ !!! ??? @@@ !!! ??? @@@ !!!'.repeat(20);
+    const { symbols, imports } = parser.parse('broken.ts', src, 'typescript');
+    expect(symbols).toHaveLength(0);
+    expect(imports).toHaveLength(0);
+  });
+});
+
+// ─── 7. Import statements with named symbols ──────────────────────────────────
+
+describe('import statement extraction', () => {
+  it('extracts named import symbols and source', () => {
+    const src = `import { readFile, writeFile } from 'node:fs/promises';`;
+    const { imports } = parser.parse('test.ts', src, 'typescript');
+    expect(imports).toHaveLength(1);
+    expect(imports[0].source).toBe('node:fs/promises');
+    expect(imports[0].symbols).toEqual(expect.arrayContaining(['readFile', 'writeFile']));
+    expect(imports[0].is_external).toBe(false); // resolver sets this later
+  });
+
+  it('extracts default import with empty symbols array', () => {
+    const src = `import path from 'node:path';`;
+    const { imports } = parser.parse('test.ts', src, 'typescript');
+    expect(imports).toHaveLength(1);
+    expect(imports[0].source).toBe('node:path');
+    expect(imports[0].symbols).toHaveLength(0);
+  });
+
+  it('extracts namespace import with empty symbols array', () => {
+    const src = `import * as fs from 'fs';`;
+    const { imports } = parser.parse('test.ts', src, 'typescript');
+    expect(imports).toHaveLength(1);
+    expect(imports[0].symbols).toHaveLength(0);
+  });
+
+  it('extracts relative import source correctly', () => {
+    const src = `import { foo } from './utils/helper';`;
+    const { imports } = parser.parse('test.ts', src, 'typescript');
+    expect(imports[0].source).toBe('./utils/helper');
+  });
+});
+
+// ─── 8. require() calls ──────────────────────────────────────────────────────
+
+describe('require() call extraction', () => {
+  it('extracts require() call source', () => {
+    const src = `const mod = require('./legacy-module');`;
+    const { imports } = parser.parse('test.ts', src, 'typescript');
+    const req = imports.find(i => i.source === './legacy-module');
+    expect(req).toBeDefined();
+    expect(req!.symbols).toHaveLength(0);
+  });
+});
+
+// ─── 9. resolved is always null at parse stage ────────────────────────────────
+
+describe('resolved field', () => {
+  it('sets resolved to null for all imports at parse stage', () => {
+    const src = `
+import { a } from './a';
+import b from './b';
+const c = require('./c');
+`.trim();
+    const { imports } = parser.parse('test.ts', src, 'typescript');
+    expect(imports.length).toBeGreaterThanOrEqual(2);
+    for (const imp of imports) {
+      expect(imp.resolved).toBeNull();
+    }
+  });
+});