@nomos-arc/arc 0.1.0

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

@@ -0,0 +1,202 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as fsSync from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { MapPipeline } from '../pipeline.js';
+import { getDefaultConfig } from '../../config.js';
+import type { NomosConfig } from '../../../types/index.js';
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'nomos-pipeline-test-'));
+});
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+const FIXTURE_DIR = path.resolve(
+  new URL(import.meta.url).pathname,
+  '../../../../../test/fixtures/sample-project',
+);
+
+function makeConfig(overrides: Partial<NomosConfig['graph']> = {}): NomosConfig {
+  const config = getDefaultConfig();
+  config.graph = {
+    ...config.graph,
+    ai_enrichment: false,
+    output_dir: path.relative(tmpDir, path.join(tmpDir, 'tasks-management/graph')),
+    exclude_patterns: ['node_modules', 'dist', '.git', '**/*.semantic.md'],
+    ...overrides,
+  };
+  return config;
+}
+
+function makeLogger() {
+  return {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  };
+}
+
+async function copyFixture(targetDir: string): Promise<void> {
+  const files = await fs.readdir(FIXTURE_DIR, { recursive: true });
+  for (const file of files) {
+    const srcPath = path.join(FIXTURE_DIR, file as string);
+    const stat = await fs.stat(srcPath);
+    if (stat.isDirectory()) continue;
+    const destPath = path.join(targetDir, file as string);
+    await fs.mkdir(path.dirname(destPath), { recursive: true });
+    await fs.copyFile(srcPath, destPath);
+  }
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('MapPipeline', () => {
+  // 1. Full pipeline noAi: true → all 8 fixture files mapped
+  it('maps all 8 fixture files with noAi=true', async () => {
+    await copyFixture(tmpDir);
+    const config = makeConfig();
+    const pipeline = new MapPipeline(config, tmpDir, makeLogger());
+
+    const result = await pipeline.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] });
+
+    expect(result.map.stats.total_files).toBe(9);
+    expect(result.aiFailures).toBe(0);
+    expect(Object.keys(result.map.files)).toHaveLength(9);
+  });
+
+  // 2. src/types.ts and src/utils/index.ts have highest depth (most dependents)
+  it('assigns highest depth to most-imported files', async () => {
+    await copyFixture(tmpDir);
+    const config = makeConfig();
+    const pipeline = new MapPipeline(config, tmpDir, makeLogger());
+
+    const result = await pipeline.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] });
+
+    const typesDepth = result.map.files['src/types.ts']?.depth ?? -1;
+    const utilsDepth = result.map.files['src/utils/index.ts']?.depth ?? -1;
+    const mainDepth  = result.map.files['src/main.ts']?.depth ?? -1;
+
+    // types.ts and utils/index.ts are imported by many — should have higher depth than main
+    expect(typesDepth).toBeGreaterThan(0);
+    expect(utilsDepth).toBeGreaterThan(0);
+    // main.ts imports everything but nothing imports it
+    expect(mainDepth).toBe(0);
+  });
+
+  // 3. src/main.ts = depth 0 (nobody imports it)
+  it('assigns depth 0 to entry-point files', async () => {
+    await copyFixture(tmpDir);
+    const pipeline = new MapPipeline(makeConfig(), tmpDir, makeLogger());
+    const result = await pipeline.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] });
+    expect(result.map.files['src/main.ts']?.depth).toBe(0);
+  });
+
+  // 4. Circular pair detected — circular-a and circular-b both present
+  it('handles circular dependency pair without crashing', async () => {
+    await copyFixture(tmpDir);
+    const pipeline = new MapPipeline(makeConfig(), tmpDir, makeLogger());
+    const result = await pipeline.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] });
+    expect(result.map.files['src/circular-a.ts']).toBeDefined();
+    expect(result.map.files['src/circular-b.ts']).toBeDefined();
+  });
+
+  // 5. Incremental: second run carries all (0 re-parsed)
+  it('carries all files on second run when nothing changed', async () => {
+    await copyFixture(tmpDir);
+    const config = makeConfig();
+    const logger = makeLogger();
+    const pipeline = new MapPipeline(config, tmpDir, logger);
+
+    // First run
+    await pipeline.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] });
+
+    // Second run — everything carried, no re-parsing
+    const result2 = await pipeline.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] });
+
+    // All files should still be present
+    expect(result2.map.stats.total_files).toBe(9);
+  });
+
+  // 6. --force: all re-parsed
+  it('re-parses all files when force=true', async () => {
+    await copyFixture(tmpDir);
+    const config = makeConfig();
+    const pipeline = new MapPipeline(config, tmpDir, makeLogger());
+
+    // First run to populate the map
+    await pipeline.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] });
+
+    // Force run
+    const result = await pipeline.run({ noAi: true, force: true, patterns: ['src/**/*.ts'] });
+
+    expect(result.map.stats.total_files).toBe(9);
+  });
+
+  // 7. core_modules identified correctly
+  it('identifies core_modules', async () => {
+    await copyFixture(tmpDir);
+    const config = makeConfig({ core_modules_count: 2 });
+    const pipeline = new MapPipeline(config, tmpDir, makeLogger());
+    const result = await pipeline.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] });
+
+    // src/types.ts should be in core_modules as it is imported by many files
+    expect(result.map.stats.core_modules).toContain('src/types.ts');
+  });
+
+  // 8. stats.total_edges correct
+  it('records correct total_edges', async () => {
+    await copyFixture(tmpDir);
+    const pipeline = new MapPipeline(makeConfig(), tmpDir, makeLogger());
+    const result = await pipeline.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] });
+    // There are multiple import edges in the fixture — just check > 0
+    expect(result.map.stats.total_edges).toBeGreaterThan(0);
+  });
+
+  // 9. [BLK-2] Concurrent: two pipeline runs simultaneously — no corruption
+  it('handles concurrent runs without map corruption', async () => {
+    await copyFixture(tmpDir);
+    const config = makeConfig();
+    const pipeline1 = new MapPipeline(config, tmpDir, makeLogger());
+    const pipeline2 = new MapPipeline(config, tmpDir, makeLogger());
+
+    // Launch both simultaneously
+    const [result1, result2] = await Promise.all([
+      pipeline1.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] }),
+      pipeline2.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] }),
+    ]);
+
+    // Both should complete with valid maps
+    expect(result1.map.stats.total_files).toBe(9);
+    expect(result2.map.stats.total_files).toBe(9);
+
+    // Final map on disk should be valid JSON
+    const mapPath = path.join(tmpDir, 'tasks-management/graph', 'project_map.json');
+    const raw = await fs.readFile(mapPath, 'utf-8');
+    expect(() => JSON.parse(raw)).not.toThrow();
+  });
+
+  // 10. [GAP-2] Intermediate map written to disk before enrichment begins
+  it('writes intermediate map before AI enrichment', async () => {
+    await copyFixture(tmpDir);
+    const config = makeConfig();
+    const mapPath = path.join(tmpDir, 'tasks-management/graph', 'project_map.json');
+
+    // Run with noAi to simulate the intermediate write (the intermediate map IS the final map when noAi=true)
+    const pipeline = new MapPipeline(config, tmpDir, makeLogger());
+    await pipeline.run({ noAi: true, force: false, patterns: ['src/**/*.ts'] });
+
+    // Map must exist on disk after run
+    const raw = await fs.readFile(mapPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    expect(parsed.schema_version).toBe(1);
+    expect(typeof parsed.files).toBe('object');
+  });
+});

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

@@ -0,0 +1,128 @@
+import { describe, it, expect } from 'vitest';
+import { MapRenderer } from '../renderer.js';
+import type { FileNode, ProjectMap } from '../../../types/index.js';
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeNode(
+  file: string,
+  deps: string[] = [],
+  dependents: string[] = [],
+  depth = 0,
+): FileNode {
+  return {
+    file,
+    hash: 'sha256:test',
+    language: 'typescript',
+    symbols: [
+      { name: 'MyClass', kind: 'class', line: 1, end_line: 10, signature: null, exported: true },
+    ],
+    imports: [],
+    dependencies: deps,
+    dependents,
+    depth,
+    last_parsed_at: null,
+    semantic: null,
+    enrichment_status: 'structural',
+  };
+}
+
+function makeMap(files: FileNode[]): ProjectMap {
+  const filesRecord: Record<string, FileNode> = {};
+  for (const f of files) {
+    filesRecord[f.file] = f;
+  }
+  return {
+    schema_version: 1,
+    generated_at: new Date().toISOString(),
+    root: '/project',
+    files: filesRecord,
+    stats: {
+      total_files: files.length,
+      total_symbols: files.reduce((acc, f) => acc + f.symbols.length, 0),
+      total_edges: files.reduce((acc, f) => acc + f.dependencies.length, 0),
+      core_modules: [],
+      structural_only: 0,
+      semantically_enriched: 0,
+      indexed: 0,
+    },
+  };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('MapRenderer', () => {
+  const renderer = new MapRenderer();
+
+  it('1. node count matches ProjectMap.files count', () => {
+    const map = makeMap([
+      makeNode('src/a.ts'),
+      makeNode('src/b.ts'),
+      makeNode('src/c.ts'),
+    ]);
+    const { nodes } = renderer.render(map);
+    expect(nodes).toHaveLength(3);
+  });
+
+  it('2. edge count matches total internal dependency links', () => {
+    const map = makeMap([
+      makeNode('src/a.ts', ['src/b.ts', 'src/c.ts']),
+      makeNode('src/b.ts', ['src/c.ts']),
+      makeNode('src/c.ts'),
+    ]);
+    const { edges } = renderer.render(map);
+    // a→b, a→c, b→c = 3 edges
+    expect(edges).toHaveLength(3);
+  });
+
+  it('3. color at depth 0 is #a8d8ea (cool blue)', () => {
+    const color = renderer.computeColor(0, 10);
+    expect(color).toBe('#a8d8ea');
+  });
+
+  it('4. color at max depth is #c0392b (deep red)', () => {
+    const color = renderer.computeColor(10, 10);
+    expect(color).toBe('#c0392b');
+  });
+
+  it('5. color at mid depth is in amber range (between blue and red)', () => {
+    const color = renderer.computeColor(5, 10);
+    // Should be approximately #f9c784 (warm amber) at exact midpoint
+    // Parse hex and verify it has high red, moderate green, low blue
+    const r = parseInt(color.slice(1, 3), 16);
+    const g = parseInt(color.slice(3, 5), 16);
+    const b = parseInt(color.slice(5, 7), 16);
+    // Amber = high R, mid G, low B
+    expect(r).toBeGreaterThan(200);
+    expect(g).toBeGreaterThan(150);
+    expect(b).toBeLessThan(150);
+  });
+
+  it('6. node data includes all FileNode fields', () => {
+    const node = makeNode('src/a.ts');
+    const map = makeMap([node]);
+    const { nodes } = renderer.render(map);
+    expect(nodes[0].data.file).toBe('src/a.ts');
+    expect(nodes[0].data.language).toBe('typescript');
+    expect(nodes[0].data.symbols).toHaveLength(1);
+    expect(nodes[0].data.hash).toBe('sha256:test');
+  });
+
+  it('7. edge source and target match dependency relationships', () => {
+    const map = makeMap([
+      makeNode('src/a.ts', ['src/b.ts']),
+      makeNode('src/b.ts'),
+    ]);
+    const { edges } = renderer.render(map);
+    expect(edges).toHaveLength(1);
+    expect(edges[0].data.source).toBe('src/a.ts');
+    expect(edges[0].data.target).toBe('src/b.ts');
+  });
+
+  it('8. empty map produces 0 nodes and 0 edges without crashing', () => {
+    const map = makeMap([]);
+    const { nodes, edges } = renderer.render(map);
+    expect(nodes).toHaveLength(0);
+    expect(edges).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,185 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { ImportResolver } from '../resolver.js';
+
+// ─── Fixtures ─────────────────────────────────────────────────────────────────
+
+function makeLogger() {
+  return { warn: vi.fn(), info: vi.fn() };
+}
+
+/**
+ * Build a knownFiles Set<string> from a list of project-relative paths.
+ * Mirrors the contract: caller must include both new and carried files.
+ */
+function makeKnownFiles(...relativePaths: string[]): Set<string> {
+  return new Set(relativePaths);
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('ImportResolver', () => {
+  let tmpDir: string;
+  let resolver: ImportResolver;
+  let logger: ReturnType<typeof makeLogger>;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'nomos-resolver-'));
+    // Write a minimal tsconfig.json (no paths by default)
+    await fs.writeFile(
+      path.join(tmpDir, 'tsconfig.json'),
+      JSON.stringify({ compilerOptions: { target: 'ES2022' } }),
+    );
+    logger = makeLogger();
+    resolver = new ImportResolver(tmpDir, logger);
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  // ── Test 1: Extension append ──────────────────────────────────────────────
+
+  it('resolves ./utils/hash → src/utils/hash.ts (extension append)', async () => {
+    const knownFiles = makeKnownFiles('src/utils/hash.ts', 'src/importer.ts');
+    const result = await resolver.resolve('./utils/hash', 'src/importer.ts', knownFiles);
+    expect(result).toEqual({ resolved: 'src/utils/hash.ts', is_external: false });
+  });
+
+  // ── Test 2: Index resolution ──────────────────────────────────────────────
+
+  it('resolves ./utils → src/utils/index.ts (index resolution)', async () => {
+    const knownFiles = makeKnownFiles('src/utils/index.ts', 'src/importer.ts');
+    const result = await resolver.resolve('./utils', 'src/importer.ts', knownFiles);
+    expect(result).toEqual({ resolved: 'src/utils/index.ts', is_external: false });
+  });
+
+  // ── Test 3: Tsconfig alias ────────────────────────────────────────────────
+
+  it('resolves tsconfig alias @/utils → src/utils/index.ts', async () => {
+    // Write tsconfig with path alias
+    await fs.writeFile(
+      path.join(tmpDir, 'tsconfig.json'),
+      JSON.stringify({
+        compilerOptions: {
+          paths: {
+            '@/*': ['src/*'],
+          },
+        },
+      }),
+    );
+    resolver = new ImportResolver(tmpDir, logger);
+
+    const knownFiles = makeKnownFiles('src/utils/index.ts', 'src/importer.ts');
+    const result = await resolver.resolve('@/utils', 'src/importer.ts', knownFiles);
+    expect(result).toEqual({ resolved: 'src/utils/index.ts', is_external: false });
+  });
+
+  // ── Test 4: zod → external ────────────────────────────────────────────────
+
+  it('marks zod as external', async () => {
+    const knownFiles = makeKnownFiles('src/importer.ts');
+    const result = await resolver.resolve('zod', 'src/importer.ts', knownFiles);
+    expect(result).toEqual({ resolved: null, is_external: true });
+  });
+
+  // ── Test 5: commander → external ─────────────────────────────────────────
+
+  it('marks commander as external', async () => {
+    const knownFiles = makeKnownFiles('src/importer.ts');
+    const result = await resolver.resolve('commander', 'src/importer.ts', knownFiles);
+    expect(result).toEqual({ resolved: null, is_external: true });
+  });
+
+  // ── Test 6: Path traversal → external with warning ───────────────────────
+
+  it('treats path traversal outside projectRoot as external with warning', async () => {
+    const knownFiles = makeKnownFiles('src/importer.ts');
+    const result = await resolver.resolve(
+      '../../outside-project',
+      'src/importer.ts',
+      knownFiles,
+    );
+    expect(result).toEqual({ resolved: null, is_external: true });
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('traversal outside projectRoot'),
+    );
+  });
+
+  // ── Test 7: Unresolvable relative ────────────────────────────────────────
+
+  it('returns { resolved: null, is_external: false } for unresolvable relative import', async () => {
+    const knownFiles = makeKnownFiles('src/importer.ts');
+    const result = await resolver.resolve('./nonexistent', 'src/importer.ts', knownFiles);
+    expect(result).toEqual({ resolved: null, is_external: false });
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining("Cannot resolve import './nonexistent'"),
+    );
+  });
+
+  // ── Test 8: Missing tsconfig.json → alias skipped gracefully ─────────────
+
+  it('gracefully skips alias resolution when tsconfig.json is missing', async () => {
+    await fs.rm(path.join(tmpDir, 'tsconfig.json'));
+    resolver = new ImportResolver(tmpDir, logger);
+
+    // Relative imports still work; alias-looking bare specifiers go external
+    const knownFiles = makeKnownFiles('src/utils/hash.ts', 'src/importer.ts');
+    const relResult = await resolver.resolve('./utils/hash', 'src/importer.ts', knownFiles);
+    expect(relResult).toEqual({ resolved: 'src/utils/hash.ts', is_external: false });
+
+    const aliasResult = await resolver.resolve('@/utils', 'src/importer.ts', knownFiles);
+    expect(aliasResult).toEqual({ resolved: null, is_external: true });
+  });
+
+  // ── Test 9: [AMB-4] No filesystem calls during resolve ───────────────────
+
+  it('[AMB-4] resolve() uses knownFiles Set — resolves file that does NOT exist on disk', async () => {
+    // The file 'src/utils/ghost.ts' is in knownFiles but does NOT physically
+    // exist in tmpDir. If resolver relied on fs.existsSync/fs.access, it would
+    // return null. Since it uses only knownFiles.has(), it resolves correctly.
+    const knownFiles = makeKnownFiles('src/utils/ghost.ts', 'src/importer.ts');
+    // Verify the file truly does not exist on disk
+    await expect(
+      fs.access(path.join(tmpDir, 'src/utils/ghost.ts')),
+    ).rejects.toThrow();
+
+    const result = await resolver.resolve('./utils/ghost', 'src/importer.ts', knownFiles);
+    expect(result).toEqual({ resolved: 'src/utils/ghost.ts', is_external: false });
+  });
+
+  // ── Test 10: [WATCH-4] Resolver finds a carried-forward file ─────────────
+
+  it('[WATCH-4] resolves import to a carried-forward file not in fresh scan', async () => {
+    // knownFiles includes src/utils/hash.ts ONLY from the carried map
+    // (simulates: the file was unchanged so it was NOT freshly scanned)
+    const freshlyScanned = new Set<string>(['src/importer.ts']);
+    const fromCarried = new Set<string>(['src/utils/hash.ts']);
+    const knownFiles = new Set([...freshlyScanned, ...fromCarried]);
+
+    const result = await resolver.resolve('./utils/hash', 'src/importer.ts', knownFiles);
+    expect(result).toEqual({ resolved: 'src/utils/hash.ts', is_external: false });
+  });
+
+  // ── Bonus: Exact tsconfig alias (non-wildcard) ────────────────────────────
+
+  it('resolves exact tsconfig alias', async () => {
+    await fs.writeFile(
+      path.join(tmpDir, 'tsconfig.json'),
+      JSON.stringify({
+        compilerOptions: {
+          paths: {
+            'shared': ['src/shared/index.ts'],
+          },
+        },
+      }),
+    );
+    resolver = new ImportResolver(tmpDir, logger);
+
+    const knownFiles = makeKnownFiles('src/shared/index.ts', 'src/importer.ts');
+    const result = await resolver.resolve('shared', 'src/importer.ts', knownFiles);
+    expect(result).toEqual({ resolved: 'src/shared/index.ts', is_external: false });
+  });
+});