@archora/core 1.1.0

package/src/analyzer/__tests__/cyclePatterns.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect } from 'vitest';
+import { classifyCyclePattern } from '../cyclePatterns';
+import { feedbackArcSet, edgeKey } from '../feedbackArcSet';
+import type { DependencyEdge } from '../types';
+
+const e = (from: string, to: string, kind: DependencyEdge['kind'] = 'static'): DependencyEdge => ({
+  from,
+  to,
+  kind,
+  specifier: to,
+  resolved: true,
+});
+
+describe('classifyCyclePattern', () => {
+  it('detects mutual-pair', () => {
+    const internal = [e('a.ts', 'b.ts'), e('b.ts', 'a.ts')];
+    const fas = feedbackArcSet(['a.ts', 'b.ts'], internal);
+    const p = classifyCyclePattern({
+      scc: ['a.ts', 'b.ts'],
+      internalEdges: internal,
+      feedback: fas.feedback,
+    });
+    expect(p.kind).toBe('mutual-pair');
+    if (p.kind === 'mutual-pair') {
+      expect(p.a).toBe('a.ts');
+      expect(p.b).toBe('b.ts');
+    }
+  });
+
+  it('detects barrel-cycle (sibling imports through same-folder index)', () => {
+    // src/foo/index.ts imports src/foo/bar.ts; src/foo/bar.ts imports
+    // back through '.' (i.e. resolves to src/foo/index.ts)
+    const internal = [
+      e('src/foo/index.ts', 'src/foo/bar.ts'),
+      e('src/foo/bar.ts', 'src/foo/index.ts'),
+    ];
+    const fas = feedbackArcSet(['src/foo/index.ts', 'src/foo/bar.ts'], internal);
+    const p = classifyCyclePattern({
+      scc: ['src/foo/index.ts', 'src/foo/bar.ts'],
+      internalEdges: internal,
+      feedback: fas.feedback,
+    });
+    // mutual-pair takes precedence for SCC of 2; verify the more interesting
+    // case below where SCC > 2 still routes to barrel
+    expect(['mutual-pair', 'barrel-cycle']).toContain(p.kind);
+  });
+
+  it('detects barrel-cycle in 3-SCC with single feedback edge into sibling index', () => {
+    // a→b→c→index→a, where a is sibling of index in src/foo
+    const nodes = ['src/foo/index.ts', 'src/foo/a.ts', 'src/foo/b.ts'];
+    const internal = [
+      e('src/foo/index.ts', 'src/foo/a.ts'),
+      e('src/foo/a.ts', 'src/foo/b.ts'),
+      e('src/foo/b.ts', 'src/foo/index.ts'),
+    ];
+    const fas = feedbackArcSet(nodes, internal);
+    expect(fas.feedback.size).toBe(1);
+    const p = classifyCyclePattern({ scc: nodes, internalEdges: internal, feedback: fas.feedback });
+    expect(p.kind).toBe('barrel-cycle');
+    if (p.kind === 'barrel-cycle') {
+      expect(p.barrel).toBe('src/foo/index.ts');
+    }
+  });
+
+  it('detects hub-feedback: ≥70% of feedback edges point into same hub', () => {
+    // 5 producers all back-edge into hub
+    const nodes = ['hub.ts', 'p1.ts', 'p2.ts', 'p3.ts', 'p4.ts', 'p5.ts'];
+    const internal: DependencyEdge[] = [];
+    for (const p of nodes.slice(1)) {
+      internal.push(e('hub.ts', p));
+      internal.push(e(p, 'hub.ts'));
+    }
+    const fas = feedbackArcSet(nodes, internal);
+    const p = classifyCyclePattern({
+      scc: nodes,
+      internalEdges: internal,
+      feedback: fas.feedback,
+    });
+    // FAS will pick one orientation; the hub is whichever side becomes target
+    expect(p.kind).toBe('hub-feedback');
+    if (p.kind === 'hub-feedback') {
+      expect(p.incomingCount).toBeGreaterThanOrEqual(4);
+      expect(p.valueImports).toBe(p.incomingCount); // all static
+    }
+  });
+
+  it('hub-feedback excludes type-only edges from valueImports count', () => {
+    const nodes = ['hub.ts', 'p1.ts', 'p2.ts', 'p3.ts', 'p4.ts'];
+    const internal: DependencyEdge[] = [];
+    for (const p of nodes.slice(1)) internal.push(e('hub.ts', p));
+    // back-edges: 3 static, 1 type-only
+    internal.push(e('p1.ts', 'hub.ts'));
+    internal.push(e('p2.ts', 'hub.ts'));
+    internal.push(e('p3.ts', 'hub.ts'));
+    internal.push(e('p4.ts', 'hub.ts', 'type-only'));
+    const fas = feedbackArcSet(nodes, internal);
+    const p = classifyCyclePattern({ scc: nodes, internalEdges: internal, feedback: fas.feedback });
+    expect(p.kind).toBe('hub-feedback');
+    if (p.kind === 'hub-feedback') {
+      // type-only edge isn't even in FAS - all 3 feedback edges are value
+      expect(p.valueImports).toBe(3);
+    }
+  });
+
+  it('detects long-chain: large SCC with single feedback edge', () => {
+    // 10-node ring: chain of 10 + one back-edge from last to first
+    const nodes = Array.from({ length: 10 }, (_, i) => `n${i}.ts`);
+    const internal: DependencyEdge[] = [];
+    for (let i = 0; i < nodes.length - 1; i++) internal.push(e(nodes[i]!, nodes[i + 1]!));
+    internal.push(e(nodes[nodes.length - 1]!, nodes[0]!));
+    const fas = feedbackArcSet(nodes, internal);
+    expect(fas.feedback.size).toBe(1);
+    const p = classifyCyclePattern({ scc: nodes, internalEdges: internal, feedback: fas.feedback });
+    expect(p.kind).toBe('long-chain');
+    if (p.kind === 'long-chain') {
+      expect(p.length).toBe(10);
+      expect(p.bridge).toBe(edgeKey('n9.ts', 'n0.ts'));
+    }
+  });
+
+  it('falls back to mixed when no pattern fits', () => {
+    // 3-cycle a→b→c→a, no special structure (not mutual, not barrel, no hub)
+    const internal = [e('a.ts', 'b.ts'), e('b.ts', 'c.ts'), e('c.ts', 'a.ts')];
+    const fas = feedbackArcSet(['a.ts', 'b.ts', 'c.ts'], internal);
+    const p = classifyCyclePattern({
+      scc: ['a.ts', 'b.ts', 'c.ts'],
+      internalEdges: internal,
+      feedback: fas.feedback,
+    });
+    expect(p.kind).toBe('mixed');
+  });
+});

package/src/analyzer/__tests__/cycles.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { detectCycles } from '../cycles';
+import type { DependencyEdge, ModuleNode } from '../types';
+
+const mod = (id: string): ModuleNode => ({
+  id,
+  absPath: id,
+  kind: 'unknown',
+  language: 'ts',
+  loc: 1,
+  exports: [],
+  isInfra: false,
+});
+
+const edge = (from: string, to: string): DependencyEdge => ({
+  from,
+  to,
+  kind: 'static',
+  specifier: to,
+  resolved: true,
+});
+
+describe('detectCycles', () => {
+  it('finds 2-cycle and marks it direct', () => {
+    const cycles = detectCycles([mod('a'), mod('b'), mod('c')], [edge('a', 'b'), edge('b', 'a')]);
+    expect(cycles).toHaveLength(1);
+    expect(cycles[0]?.severity).toBe('direct');
+    expect(cycles[0]?.modules.sort()).toEqual(['a', 'b']);
+  });
+
+  it('finds 3-cycle and marks it indirect', () => {
+    const cycles = detectCycles(
+      [mod('a'), mod('b'), mod('c')],
+      [edge('a', 'b'), edge('b', 'c'), edge('c', 'a')],
+    );
+    expect(cycles).toHaveLength(1);
+    expect(cycles[0]?.severity).toBe('indirect');
+    expect(cycles[0]?.length).toBe(3);
+  });
+
+  it('ignores type-only edges', () => {
+    const cycles = detectCycles(
+      [mod('a'), mod('b')],
+      [{ from: 'a', to: 'b', kind: 'type-only', specifier: 'b', resolved: true }, edge('b', 'a')],
+    );
+    expect(cycles).toHaveLength(0);
+  });
+
+  it('detects self-import as length-1 direct cycle', () => {
+    const cycles = detectCycles([mod('a')], [edge('a', 'a')]);
+    expect(cycles).toHaveLength(1);
+    expect(cycles[0]?.length).toBe(1);
+    expect(cycles[0]?.severity).toBe('direct');
+  });
+
+  it('produces a short stable content-addressed cycle id', () => {
+    // Regression: the old join('|') form produced 2kB+ ids on a real
+    // 53-module SCC, breaking UI keys, fix-plan ids and baselines.
+    const many = Array.from({ length: 40 }, (_, i) => `src/m${i}.ts`);
+    const mods = many.map(mod);
+    const edges = many.map((id, i) => edge(id, many[(i + 1) % many.length]!));
+    const cycles = detectCycles(mods, edges);
+    expect(cycles).toHaveLength(1);
+    const id = cycles[0]?.id ?? '';
+    expect(id).toMatch(/^cycle:[0-9a-f]{8}$/u);
+    expect(id.length).toBeLessThan(32);
+  });
+
+  it('cycle id is stable across module insertion order', () => {
+    const a = detectCycles([mod('a'), mod('b'), mod('c')], [edge('a', 'b'), edge('b', 'a')]);
+    const b = detectCycles([mod('b'), mod('a'), mod('c')], [edge('b', 'a'), edge('a', 'b')]);
+    expect(a[0]?.id).toBe(b[0]?.id);
+  });
+});

package/src/analyzer/__tests__/detect.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { createInMemoryFileSource } from '../sources/inMemoryFileSource';
+import { detectFramework } from '../detect';
+
+const pkg = (deps: Record<string, string>, dev: Record<string, string> = {}): string =>
+  JSON.stringify({ dependencies: deps, devDependencies: dev });
+
+describe('detectFramework', () => {
+  it('returns generic when package.json is missing', async () => {
+    const src = createInMemoryFileSource('/p', {});
+    expect(await detectFramework(src)).toEqual({ framework: 'generic', signals: [] });
+  });
+
+  it('returns generic on malformed package.json', async () => {
+    const src = createInMemoryFileSource('/p', { 'package.json': '{ not json' });
+    expect(await detectFramework(src)).toEqual({ framework: 'generic', signals: [] });
+  });
+
+  it('detects vue', async () => {
+    const src = createInMemoryFileSource('/p', { 'package.json': pkg({ vue: '^3.0.0' }) });
+    expect(await detectFramework(src)).toEqual({ framework: 'vue', signals: ['vue'] });
+  });
+
+  it('detects react', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'package.json': pkg({ react: '^18.0.0', 'react-dom': '^18.0.0' }),
+    });
+    expect(await detectFramework(src)).toEqual({ framework: 'react', signals: ['react'] });
+  });
+
+  it('detects svelte', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'package.json': pkg({}, { svelte: '^4.0.0' }),
+    });
+    expect(await detectFramework(src)).toEqual({ framework: 'svelte', signals: ['svelte'] });
+  });
+
+  it('prefers nuxt over vue when both present', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'package.json': pkg({ vue: '^3.0.0', nuxt: '^3.0.0' }),
+    });
+    const result = await detectFramework(src);
+    expect(result.framework).toBe('nuxt');
+    expect(result.signals).toEqual(expect.arrayContaining(['nuxt', 'vue']));
+  });
+
+  it('prefers next over react when both present', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'package.json': pkg({ react: '^18.0.0', next: '^14.0.0' }),
+    });
+    const result = await detectFramework(src);
+    expect(result.framework).toBe('next');
+    expect(result.signals).toEqual(expect.arrayContaining(['next', 'react']));
+  });
+
+  it('reads devDependencies as well as dependencies', async () => {
+    const src = createInMemoryFileSource('/p', {
+      'package.json': JSON.stringify({ devDependencies: { vue: '^3.0.0' } }),
+    });
+    expect((await detectFramework(src)).framework).toBe('vue');
+  });
+});

package/src/analyzer/__tests__/discover.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'vitest';
+import type { FileSource } from '../fileSource';
+import { createNodeFsFileSource } from '../sources/nodeFsFileSource';
+import { discoverFiles } from '../discover';
+import { fixturePath } from './_paths';
+
+function inMemorySource(files: string[]): FileSource {
+  return {
+    rootPath: '/virtual',
+    list: () => Promise.resolve(files),
+    read: () => Promise.reject(new Error('read not used')),
+    exists: (p) => Promise.resolve(files.includes(p)),
+  };
+}
+
+describe('discover', () => {
+  it('lists supported files and skips node_modules-like dirs', async () => {
+    const src = await createNodeFsFileSource({ rootPath: fixturePath('sample-vue-app') });
+    const { files, byExt } = await discoverFiles(src);
+    expect(files.length).toBeGreaterThan(20);
+    expect(files.every((f) => !f.startsWith('node_modules'))).toBe(true);
+    expect(byExt['.vue']).toBeGreaterThan(0);
+    expect(byExt['.ts']).toBeGreaterThan(0);
+  });
+
+  it('excludes tests, stories, declarations and configs by default', async () => {
+    const src = inMemorySource([
+      'src/foo.ts',
+      'src/foo.test.ts',
+      'src/foo.spec.tsx',
+      'src/__tests__/bar.ts',
+      'src/__mocks__/baz.ts',
+      'src/__snapshots__/snap.ts',
+      'src/Button.stories.ts',
+      'src/Button.stories.vue',
+      'types/global.d.ts',
+      'types/global.d.mts',
+      'vite.config.ts',
+      'vitest.config.mts',
+      'eslint.config.js',
+      'tailwind.config.cjs',
+      'cypress/e2e/login.cy.ts',
+      'playwright/test.spec.ts',
+      'e2e/login.ts',
+      '.storybook/main.ts',
+      'src/keep.vue',
+    ]);
+    const { files, skipped } = await discoverFiles(src);
+    expect(files.sort()).toEqual(['src/foo.ts', 'src/keep.vue']);
+    expect(skipped).toBe(17);
+  });
+
+  it('respects opt-out flags', async () => {
+    const src = inMemorySource([
+      'src/foo.test.ts',
+      'src/Button.stories.ts',
+      'a.d.ts',
+      'vite.config.ts',
+    ]);
+    const { files } = await discoverFiles(src, {
+      excludeTests: false,
+      excludeStories: false,
+      excludeDeclarations: false,
+      excludeConfigs: false,
+    });
+    expect(files).toHaveLength(4);
+  });
+});

package/src/analyzer/__tests__/displayId.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { displayShortId } from '../displayId';
+
+describe('displayShortId', () => {
+  it('returns bare basename for unique filenames', () => {
+    expect(displayShortId('src/utils/cn.ts')).toBe('cn.ts');
+    expect(displayShortId('src/components/UserCard.vue')).toBe('UserCard.vue');
+  });
+
+  it('prepends parent for ambiguous index.* files', () => {
+    expect(displayShortId('src/router/index.ts')).toBe('router/index.ts');
+    expect(displayShortId('packages/core/src/index.ts')).toBe('src/index.ts');
+  });
+
+  it('prepends parent for SvelteKit special files', () => {
+    expect(displayShortId('src/routes/users/+page.svelte')).toBe('users/+page.svelte');
+    expect(displayShortId('src/routes/api/+server.ts')).toBe('api/+server.ts');
+    expect(displayShortId('src/routes/+layout.ts')).toBe('routes/+layout.ts');
+  });
+
+  it('prepends parent for main/app/root', () => {
+    expect(displayShortId('src/main.ts')).toBe('src/main.ts');
+    expect(displayShortId('src/app.vue')).toBe('src/app.vue');
+  });
+
+  it('returns id as-is when there is no slash', () => {
+    expect(displayShortId('main.ts')).toBe('main.ts');
+    expect(displayShortId('userService')).toBe('userService');
+  });
+});

package/src/analyzer/__tests__/feedbackArcSet.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect } from 'vitest';
+import { feedbackArcSet, countBrokenCycles, edgeKey, parseEdgeKey } from '../feedbackArcSet';
+import type { DependencyEdge } from '../types';
+
+const e = (from: string, to: string, kind: DependencyEdge['kind'] = 'static'): DependencyEdge => ({
+  from,
+  to,
+  kind,
+  specifier: to,
+  resolved: true,
+});
+
+describe('feedbackArcSet', () => {
+  it('breaks a 2-cycle with one edge', () => {
+    const r = feedbackArcSet(['a', 'b'], [e('a', 'b'), e('b', 'a')]);
+    expect(r.feedback.size).toBe(1);
+  });
+
+  it('breaks a 3-cycle with one edge', () => {
+    const r = feedbackArcSet(['a', 'b', 'c'], [e('a', 'b'), e('b', 'c'), e('c', 'a')]);
+    expect(r.feedback.size).toBe(1);
+  });
+
+  it('breaks two independent loops sharing a hub', () => {
+    // x→hub, hub→a→x, hub→b→x : two cycles (hub-a-x-hub) and (hub-b-x-hub)
+    // but x and hub form an SCC of {x, hub, a, b}; both loops close via x→hub.
+    // Greedy FAS should pick a single feedback edge (most likely x→hub) that
+    // breaks both loops.
+    const edges = [e('x', 'hub'), e('hub', 'a'), e('a', 'x'), e('hub', 'b'), e('b', 'x')];
+    const r = feedbackArcSet(['x', 'hub', 'a', 'b'], edges);
+    expect(r.feedback.size).toBeGreaterThanOrEqual(1);
+    expect(r.feedback.size).toBeLessThanOrEqual(2);
+  });
+
+  it('hub-pointing pattern: many feedback edges target the same hub', () => {
+    // 4 producers all feed back into a single hub h that they were reached from
+    // h → p1, p2, p3, p4 (producers); each producer → h (back edge)
+    const edges = [
+      e('h', 'p1'),
+      e('h', 'p2'),
+      e('h', 'p3'),
+      e('h', 'p4'),
+      e('p1', 'h'),
+      e('p2', 'h'),
+      e('p3', 'h'),
+      e('p4', 'h'),
+    ];
+    const r = feedbackArcSet(['h', 'p1', 'p2', 'p3', 'p4'], edges);
+    // either direction (forward or backward) makes all edges feedback - we
+    // accept whichever orientation FAS picks as long as it's consistent
+    const targets = [...r.feedback].map((k) => parseEdgeKey(k).to);
+    const uniqueTargets = new Set(targets);
+    expect(uniqueTargets.size).toBe(1);
+    expect(r.feedback.size).toBe(4);
+  });
+
+  it('handles self-loop on singleton SCC', () => {
+    const r = feedbackArcSet(['a'], [e('a', 'a')]);
+    expect([...r.feedback]).toEqual([edgeKey('a', 'a')]);
+  });
+
+  it('ignores type-only edges', () => {
+    const r = feedbackArcSet(['a', 'b'], [e('a', 'b'), e('b', 'a', 'type-only')]);
+    // SCC isn't actually strongly connected without the type-only edge, but
+    // FAS doesn't re-validate - with only a→b internal there are no feedback
+    // edges (it's a DAG).
+    expect(r.feedback.size).toBe(0);
+  });
+
+  it('dedupes parallel edges with the same direction', () => {
+    const edges = [e('a', 'b'), e('a', 'b', 'dynamic'), e('b', 'a')];
+    const r = feedbackArcSet(['a', 'b'], edges);
+    expect(r.internal.length).toBe(2); // one a→b, one b→a
+  });
+
+  it('produces feedback set whose removal makes the SCC acyclic', () => {
+    // dense SCC: complete digraph K4 (all 12 directed edges)
+    const nodes = ['a', 'b', 'c', 'd'];
+    const edges: DependencyEdge[] = [];
+    for (const a of nodes) for (const b of nodes) if (a !== b) edges.push(e(a, b));
+    const r = feedbackArcSet(nodes, edges);
+
+    // verify: in r.order, no edge points backwards (other than feedback)
+    const pos = new Map(r.order.map((id, i) => [id, i]));
+    const backward = r.internal.filter(
+      (ed) => ed.from !== ed.to && (pos.get(ed.from) ?? 0) > (pos.get(ed.to) ?? 0),
+    );
+    const backwardKeys = new Set(backward.map((ed) => edgeKey(ed.from, ed.to)));
+    expect(backwardKeys).toEqual(r.feedback);
+  });
+});
+
+describe('countBrokenCycles', () => {
+  it('exact count for small SCC: 2-cycle = 1 cycle broken', () => {
+    const internal = [e('a', 'b'), e('b', 'a')];
+    const fas = feedbackArcSet(['a', 'b'], internal);
+    const r = countBrokenCycles(['a', 'b'], internal, fas.feedback);
+    expect(r.totalCycles).toBe(1);
+    expect(r.totalPartial).toBe(false);
+    const only = [...fas.feedback][0]!;
+    expect(r.byEdge.get(only)?.broken).toBe(1);
+  });
+
+  it('exact count for two independent 3-cycles sharing one node', () => {
+    // a→b→c→a and a→d→e→a : two 3-cycles, removing edge into a (the shared
+    // node) breaks both
+    const internal = [e('a', 'b'), e('b', 'c'), e('c', 'a'), e('a', 'd'), e('d', 'e'), e('e', 'a')];
+    const fas = feedbackArcSet(['a', 'b', 'c', 'd', 'e'], internal);
+    const r = countBrokenCycles(['a', 'b', 'c', 'd', 'e'], internal, fas.feedback);
+    expect(r.totalCycles).toBe(2);
+    expect(r.totalPartial).toBe(false);
+    // sum over feedback edges should equal at least the number of cycles
+    // (each cycle has at least one feedback edge along it)
+    const totalBroken = [...r.byEdge.values()].reduce((s, v) => s + v.broken, 0);
+    expect(totalBroken).toBeGreaterThanOrEqual(2);
+  });
+
+  it('terminates on a dense large SCC instead of enumerating exponentially', () => {
+    // Near-complete digraph on 30 nodes: ~870 edges, and the number of simple
+    // paths between any two nodes is ~e·28! (≈1e29). Without a DFS step budget,
+    // countSimplePaths explores that space and never returns. The budget must
+    // bound the work so a real-world dense cyclic cluster can't hang the scan.
+    const N = 30;
+    const nodes = Array.from({ length: N }, (_, i) => `n${i}`);
+    const internal: DependencyEdge[] = [];
+    for (const a of nodes) for (const b of nodes) if (a !== b) internal.push(e(a, b));
+    const fas = feedbackArcSet(nodes, internal);
+    const started = Date.now();
+    const r = countBrokenCycles(nodes, internal, fas.feedback, { stepCap: 5000 });
+    // The assertion that matters is that we got here at all (no hang). Keep a
+    // generous wall-clock guard so a regression that reintroduces the blowup
+    // fails loudly rather than wedging the suite.
+    expect(Date.now() - started).toBeLessThan(3000);
+    expect(r.totalPartial).toBe(true);
+    expect(r.byEdge.size).toBe(fas.feedback.size);
+  }, 8000);
+
+  it('caps elementary-cycle enumeration on a dense sub-limit SCC', () => {
+    // Complete digraph on 12 nodes (≤ exactLimit) has ~e·11! (≈1e8) elementary
+    // cycles. Johnson enumeration must stop at the cycle cap and report partial
+    // rather than enumerating all of them.
+    const N = 12;
+    const nodes = Array.from({ length: N }, (_, i) => `n${i}`);
+    const internal: DependencyEdge[] = [];
+    for (const a of nodes) for (const b of nodes) if (a !== b) internal.push(e(a, b));
+    const fas = feedbackArcSet(nodes, internal);
+    const started = Date.now();
+    const r = countBrokenCycles(nodes, internal, fas.feedback, { exactLimit: 20, cycleCap: 5000 });
+    expect(Date.now() - started).toBeLessThan(3000);
+    expect(r.totalPartial).toBe(true);
+    expect(r.totalCycles).toBe(-1);
+  }, 8000);
+
+  it('partial count for large SCC', () => {
+    // construct a 25-node SCC: linear chain plus back-edge from last to first
+    const nodes = Array.from({ length: 25 }, (_, i) => `n${i}`);
+    const internal: DependencyEdge[] = [];
+    for (let i = 0; i < nodes.length - 1; i++) internal.push(e(nodes[i]!, nodes[i + 1]!));
+    internal.push(e(nodes[nodes.length - 1]!, nodes[0]!));
+    const fas = feedbackArcSet(nodes, internal);
+    const r = countBrokenCycles(nodes, internal, fas.feedback);
+    expect(r.totalCycles).toBe(-1);
+    expect(r.totalPartial).toBe(true);
+    // the single back-edge breaks exactly one elementary cycle
+    const only = [...fas.feedback][0]!;
+    expect(r.byEdge.get(only)?.broken).toBe(1);
+  });
+});

package/src/analyzer/__tests__/inMemoryFileSource.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { createInMemoryFileSource } from '../sources/inMemoryFileSource';
+import { analyze } from '../index';
+
+describe('inMemoryFileSource', () => {
+  it('lists, reads, and reports existence', async () => {
+    const src = createInMemoryFileSource('/proj', {
+      'a.ts': 'export const a = 1;',
+      'b.ts': 'export const b = 2;',
+    });
+    expect(await src.list()).toEqual(['a.ts', 'b.ts']);
+    expect(await src.read('a.ts')).toBe('export const a = 1;');
+    expect(await src.exists('a.ts')).toBe(true);
+    expect(await src.exists('missing.ts')).toBe(false);
+  });
+
+  it('throws on read of missing file', async () => {
+    const src = createInMemoryFileSource('/proj', {});
+    await expect(src.read('x.ts')).rejects.toThrow();
+  });
+
+  it('feeds the full analyzer pipeline end-to-end', async () => {
+    const src = createInMemoryFileSource('/proj', {
+      'package.json': JSON.stringify({ dependencies: { vue: '^3.0.0' } }),
+      'tsconfig.json': JSON.stringify({ compilerOptions: { baseUrl: '.' } }),
+      'src/a.ts': "import { b } from './b';\nexport const a = b + 1;",
+      'src/b.ts': 'export const b = 2;',
+    });
+    const result = await analyze(src);
+    expect(result.project.detectedFramework).toBe('vue');
+    expect(result.modules.map((m) => m.id).sort()).toEqual(['src/a.ts', 'src/b.ts']);
+    expect(result.edges.some((e) => e.from === 'src/a.ts' && e.to === 'src/b.ts')).toBe(true);
+  });
+});