@archora/core 1.1.0

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

@@ -0,0 +1,154 @@
+// Контракт: incrementalAnalyze должен либо вернуть результат, эквивалентный
+// полному `analyze()` после применения тех же изменений к источнику, либо
+// прозрачно делегировать в analyze(). В обоих случаях downstream-данные
+// (modules/edges/cycles/metrics) должны соответствовать пост-стейту источника.
+
+import { describe, expect, it } from 'vitest';
+import { analyze } from '../index';
+import { incrementalAnalyze } from '../incremental';
+import { createInMemoryFileSource } from '../sources/inMemoryFileSource';
+
+function project(files: Record<string, string>) {
+  return createInMemoryFileSource('/proj', {
+    'tsconfig.json': JSON.stringify({ compilerOptions: { paths: { '@/*': ['src/*'] } } }),
+    ...files,
+  });
+}
+
+describe('incrementalAnalyze', () => {
+  it('пере-парс одного файла даёт тот же результат, что и полный analyze пост-стейта', async () => {
+    const before = {
+      'src/a.ts': "import { b } from '@/b';\nexport const a = b;\n",
+      'src/b.ts': 'export const b = 1;\n',
+      'src/c.ts': 'export const c = 2;\n',
+    };
+    const prev = await analyze(project(before));
+
+    const after = { ...before, 'src/a.ts': "import { c } from '@/c';\nexport const a = c;\n" };
+    const expected = await analyze(project(after));
+    const got = await incrementalAnalyze({
+      prev,
+      source: project(after),
+      changedFiles: ['src/a.ts'],
+    });
+
+    // структурное равенство по ключевым полям (durationMs/scannedAt отбрасываем)
+    expect(sortEdges(got.edges)).toEqual(sortEdges(expected.edges));
+    expect(got.modules.find((m) => m.id === 'src/a.ts')?.exports).toEqual(['a']);
+    expect(got.cycles).toEqual(expected.cycles);
+  });
+
+  it('изменение типа модуля (loc, exports) попадает в результат', async () => {
+    const before = {
+      'src/util.ts': 'export const x = 1;\n',
+      'src/main.ts': "import { x } from '@/util';\nexport default x;\n",
+    };
+    const prev = await analyze(project(before));
+
+    const after = {
+      ...before,
+      'src/util.ts': 'export const x = 1;\nexport const y = 2;\nexport const z = 3;\n',
+    };
+    const got = await incrementalAnalyze({
+      prev,
+      source: project(after),
+      changedFiles: ['src/util.ts'],
+    });
+
+    const util = got.modules.find((m) => m.id === 'src/util.ts');
+    expect(util?.exports.sort()).toEqual(['x', 'y', 'z']);
+    expect(util?.loc).toBeGreaterThanOrEqual(3);
+    expect(util?.loc).toBe(prev.modules.find((m) => m.id === 'src/util.ts')!.loc + 2);
+  });
+
+  it('появление цикла после правки детектируется', async () => {
+    const before = {
+      'src/a.ts': "import { b } from '@/b';\nexport const a = b;\n",
+      'src/b.ts': 'export const b = 1;\n',
+    };
+    const prev = await analyze(project(before));
+    expect(prev.cycles).toHaveLength(0);
+
+    const after = {
+      ...before,
+      'src/b.ts': "import { a } from '@/a';\nexport const b = a;\n",
+    };
+    const got = await incrementalAnalyze({
+      prev,
+      source: project(after),
+      changedFiles: ['src/b.ts'],
+    });
+    expect(got.cycles).toHaveLength(1);
+    expect(got.cycles[0]?.modules.sort()).toEqual(['src/a.ts', 'src/b.ts']);
+  });
+
+  it('изменение конфигурационного файла → fallback на полный analyze', async () => {
+    const before = {
+      'src/a.ts': 'export const a = 1;\n',
+    };
+    const prev = await analyze(project(before));
+
+    const newSource = createInMemoryFileSource('/proj', {
+      'tsconfig.json': JSON.stringify({ compilerOptions: { paths: { '~/*': ['src/*'] } } }),
+      'src/a.ts': 'export const a = 1;\n',
+      'src/b.ts': "import { a } from '~/a';\nexport const b = a;\n",
+    });
+    const got = await incrementalAnalyze({
+      prev,
+      source: newSource,
+      changedFiles: ['tsconfig.json', 'src/b.ts'],
+    });
+    // если прошло через analyze, новый алиас и новый файл подхвачены
+    expect(got.modules.map((m) => m.id).sort()).toEqual(['src/a.ts', 'src/b.ts']);
+    expect(got.edges.find((e) => e.from === 'src/b.ts')?.to).toBe('src/a.ts');
+  });
+
+  it('новый файл (не в prev) → fallback на полный analyze', async () => {
+    const before = {
+      'src/a.ts': 'export const a = 1;\n',
+    };
+    const prev = await analyze(project(before));
+
+    const after = {
+      ...before,
+      'src/new.ts': "import { a } from '@/a';\nexport const n = a;\n",
+    };
+    const got = await incrementalAnalyze({
+      prev,
+      source: project(after),
+      changedFiles: ['src/new.ts'],
+    });
+    expect(got.modules.map((m) => m.id).sort()).toEqual(['src/a.ts', 'src/new.ts']);
+  });
+
+  it('удалённый файл → fallback на полный analyze', async () => {
+    const before = {
+      'src/a.ts': "import { b } from '@/b';\nexport const a = b;\n",
+      'src/b.ts': 'export const b = 1;\n',
+    };
+    const prev = await analyze(project(before));
+
+    const after = { 'src/a.ts': 'export const a = 1;\n' };
+    const got = await incrementalAnalyze({
+      prev,
+      source: project(after),
+      changedFiles: ['src/b.ts'],
+    });
+    expect(got.modules.map((m) => m.id)).toEqual(['src/a.ts']);
+  });
+
+  it('пустой changedFiles → возвращает prev без работы', async () => {
+    const before = { 'src/a.ts': 'export const a = 1;\n' };
+    const prev = await analyze(project(before));
+    const got = await incrementalAnalyze({
+      prev,
+      source: project(before),
+      changedFiles: [],
+    });
+    expect(got).toBe(prev);
+  });
+});
+
+function sortEdges<T extends { from: string; to: string }>(edges: readonly T[]): T[] {
+  return [...edges].sort((a, b) => (a.from + a.to).localeCompare(b.from + b.to));
+}

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

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest';
+import { detectLayer, detectLayerViolations } from '../layers';
+import type { DependencyEdge, ModuleNode } from '../types';
+
+function module(id: string, overrides: Partial<ModuleNode> = {}): ModuleNode {
+  return {
+    id,
+    absPath: `/${id}`,
+    kind: 'unknown',
+    language: 'ts',
+    loc: 1,
+    exports: [],
+    isInfra: false,
+    ...overrides,
+  };
+}
+
+function edge(from: string, to: string, kind: DependencyEdge['kind'] = 'static'): DependencyEdge {
+  return { from, to, kind, specifier: to, resolved: true };
+}
+
+describe('detectLayer', () => {
+  it('extracts the FSD layer from src/<layer>/ paths', () => {
+    expect(detectLayer('src/widgets/Foo.vue')).toBe('widgets');
+    expect(detectLayer('src/features/auth/login.ts')).toBe('features');
+    expect(detectLayer('src/shared/ui/Button.vue')).toBe('shared');
+  });
+
+  it('works without src/ prefix', () => {
+    expect(detectLayer('entities/order/model.ts')).toBe('entities');
+  });
+
+  it('returns unknown for non-FSD paths', () => {
+    expect(detectLayer('vendor/lib.ts')).toBe('unknown');
+    expect(detectLayer('main.ts')).toBe('unknown');
+  });
+
+  it('does not match layer names nested deeper than the first segment', () => {
+    expect(detectLayer('src/lib/app/something.ts')).toBe('unknown');
+  });
+});
+
+describe('detectLayerViolations', () => {
+  it('flags entities → widgets as a violation (warning severity)', () => {
+    const modules = [
+      module('src/entities/order/model.ts'),
+      module('src/widgets/order-card/OrderCard.vue'),
+    ];
+    const edges = [edge('src/entities/order/model.ts', 'src/widgets/order-card/OrderCard.vue')];
+    const v = detectLayerViolations(modules, edges);
+    expect(v).toHaveLength(1);
+    expect(v[0]?.fromLayer).toBe('entities');
+    expect(v[0]?.toLayer).toBe('widgets');
+    expect(v[0]?.severity).toBe('warning');
+  });
+
+  it('escalates deep → top-level imports to error severity', () => {
+    const modules = [module('src/shared/lib/x.ts'), module('src/pages/Home.vue')];
+    const edges = [edge('src/shared/lib/x.ts', 'src/pages/Home.vue')];
+    const v = detectLayerViolations(modules, edges);
+    expect(v[0]?.severity).toBe('error');
+  });
+
+  it('does not flag allowed top-down imports (widgets → entities)', () => {
+    const modules = [
+      module('src/widgets/order-card/OrderCard.vue'),
+      module('src/entities/order/model.ts'),
+    ];
+    const edges = [edge('src/widgets/order-card/OrderCard.vue', 'src/entities/order/model.ts')];
+    expect(detectLayerViolations(modules, edges)).toHaveLength(0);
+  });
+
+  it('ignores type-only edges and unresolved edges', () => {
+    const modules = [module('src/entities/order/model.ts'), module('src/widgets/x/X.vue')];
+    const edges = [
+      edge('src/entities/order/model.ts', 'src/widgets/x/X.vue', 'type-only'),
+      { ...edge('src/entities/order/model.ts', 'src/widgets/x/X.vue'), resolved: false },
+    ];
+    expect(detectLayerViolations(modules, edges)).toHaveLength(0);
+  });
+
+  it('does not flag same-layer imports', () => {
+    const modules = [module('src/features/a/index.ts'), module('src/features/b/index.ts')];
+    const edges = [edge('src/features/a/index.ts', 'src/features/b/index.ts')];
+    expect(detectLayerViolations(modules, edges)).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,120 @@
+import { describe, expect, it } from 'vitest';
+import {
+  detectLayer,
+  detectLayerViolations,
+  recomputeLayers,
+  validateLayerOverride,
+} from '../layers';
+import type { DependencyEdge, ModuleNode } from '../types';
+
+function module(id: string): ModuleNode {
+  return {
+    id,
+    absPath: `/${id}`,
+    kind: 'unknown',
+    language: 'ts',
+    loc: 1,
+    exports: [],
+    isInfra: false,
+  };
+}
+
+function edge(from: string, to: string): DependencyEdge {
+  return { from, to, kind: 'static', specifier: to, resolved: true };
+}
+
+describe('detectLayer with overrides', () => {
+  it('promotes a path under src/lib/* into shared via glob', () => {
+    expect(detectLayer('src/lib/utils.ts', { 'src/lib/**': 'shared' })).toBe('shared');
+  });
+
+  it('falls through to FSD detection when no override matches', () => {
+    expect(detectLayer('src/widgets/X.vue', { 'src/lib/**': 'shared' })).toBe('widgets');
+  });
+
+  it('first matching pattern wins (insertion order)', () => {
+    const overrides = {
+      'src/lib/auth/**': 'features',
+      'src/lib/**': 'shared',
+    };
+    expect(detectLayer('src/lib/auth/index.ts', overrides)).toBe('features');
+    expect(detectLayer('src/lib/db.ts', overrides)).toBe('shared');
+  });
+
+  it('skips overrides with unknown layer values', () => {
+    expect(detectLayer('src/lib/x.ts', { 'src/lib/**': 'bogus' })).toBe('unknown');
+  });
+});
+
+describe('detectLayerViolations with overrides', () => {
+  it('flags new violations introduced by promoting a path to a higher layer', () => {
+    // baseline: src/lib/utils.ts is unknown, so widgets→lib doesn't violate.
+    const modules = [module('src/widgets/X.vue'), module('src/lib/utils.ts')];
+    const edges = [edge('src/lib/utils.ts', 'src/widgets/X.vue')];
+    expect(detectLayerViolations(modules, edges)).toHaveLength(0);
+    // promote lib→shared: now lib (= shared, rank 5) → widgets (rank 2) becomes a violation.
+    const v = detectLayerViolations(modules, edges, { 'src/lib/**': 'shared' });
+    expect(v).toHaveLength(1);
+    expect(v[0]?.fromLayer).toBe('shared');
+    expect(v[0]?.toLayer).toBe('widgets');
+  });
+
+  it('clears violations when overrides reclassify both endpoints', () => {
+    // baseline: entities → widgets is a warning.
+    const modules = [module('src/entities/order/model.ts'), module('src/widgets/order-card/X.vue')];
+    const edges = [edge('src/entities/order/model.ts', 'src/widgets/order-card/X.vue')];
+    expect(detectLayerViolations(modules, edges)).toHaveLength(1);
+    // declare both files as `unknown`-equivalent via reclassification to widgets:
+    // entities→widgets becomes widgets→widgets (same layer, allowed).
+    const v = detectLayerViolations(modules, edges, {
+      'src/entities/**': 'widgets',
+    });
+    expect(v).toHaveLength(0);
+  });
+});
+
+describe('recomputeLayers', () => {
+  it('returns deterministic byModule and violations', () => {
+    const modules = [
+      module('src/widgets/X.vue'),
+      module('src/entities/order/model.ts'),
+      module('src/lib/util.ts'),
+    ];
+    const edges = [
+      edge('src/widgets/X.vue', 'src/entities/order/model.ts'),
+      edge('src/entities/order/model.ts', 'src/lib/util.ts'),
+    ];
+    const a = recomputeLayers({ modules, edges, overrides: { 'src/lib/**': 'shared' } });
+    const b = recomputeLayers({ modules, edges, overrides: { 'src/lib/**': 'shared' } });
+    expect(a).toEqual(b);
+    expect(a.byModule['src/lib/util.ts']).toBe('shared');
+    expect(a.byModule['src/widgets/X.vue']).toBe('widgets');
+    expect(a.violations).toHaveLength(0);
+  });
+
+  it('is idempotent: same input → same output', () => {
+    const modules = [module('src/shared/x.ts'), module('src/pages/Home.vue')];
+    const edges = [edge('src/shared/x.ts', 'src/pages/Home.vue')];
+    const r1 = recomputeLayers({ modules, edges });
+    const r2 = recomputeLayers({ modules, edges });
+    expect(r1).toEqual(r2);
+    expect(r1.violations[0]?.severity).toBe('error');
+  });
+});
+
+describe('validateLayerOverride', () => {
+  it('rejects empty patterns', () => {
+    expect(validateLayerOverride('', 'shared')).toBe('empty');
+    expect(validateLayerOverride('   ', 'shared')).toBe('empty');
+  });
+
+  it('rejects unknown layers', () => {
+    expect(validateLayerOverride('src/**', 'bogus')).toBe('unknown-layer');
+    expect(validateLayerOverride('src/**', 'unknown')).toBe('unknown-layer');
+  });
+
+  it('accepts a well-formed pattern + known layer', () => {
+    expect(validateLayerOverride('src/lib/**', 'shared')).toBeNull();
+    expect(validateLayerOverride('apps/*/src/**', 'features')).toBeNull();
+  });
+});

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

@@ -0,0 +1,132 @@
+import { describe, expect, it } from 'vitest';
+import { analyze } from '..';
+import { createInMemoryFileSource } from '../sources/inMemoryFileSource';
+
+describe('memory risk analysis', () => {
+  it('flags a React effect that registers an event listener without cleanup', async () => {
+    const result = await analyze(
+      createInMemoryFileSource('/p', {
+        'package.json': JSON.stringify({ dependencies: { react: '^18.0.0' } }),
+        'tsconfig.json': JSON.stringify({ compilerOptions: { jsx: 'react-jsx' } }),
+        'src/App.tsx': `
+          import { useEffect } from 'react';
+
+          export function App() {
+            useEffect(() => {
+              window.addEventListener('resize', () => {});
+            }, []);
+            return null;
+          }
+        `,
+      }),
+    );
+
+    expect(result.memoryRisks).toEqual([
+      expect.objectContaining({
+        kind: 'event-listener-cleanup',
+        moduleId: 'src/App.tsx',
+        framework: 'react',
+        confidence: 'high',
+      }),
+    ]);
+    expect(result.signals?.some((signal) => signal.kind === 'memory-risk')).toBe(true);
+  });
+
+  it('keeps a React effect with matching cleanup clean', async () => {
+    const result = await analyze(
+      createInMemoryFileSource('/p', {
+        'package.json': JSON.stringify({ dependencies: { react: '^18.0.0' } }),
+        'tsconfig.json': JSON.stringify({ compilerOptions: { jsx: 'react-jsx' } }),
+        'src/App.tsx': `
+          import { useEffect } from 'react';
+
+          export function App() {
+            useEffect(() => {
+              const onResize = () => {};
+              window.addEventListener('resize', onResize);
+              return () => window.removeEventListener('resize', onResize);
+            }, []);
+            return null;
+          }
+        `,
+      }),
+    );
+
+    expect(result.memoryRisks ?? []).toEqual([]);
+  });
+
+  it('flags Vue mounted listeners without an unmounted cleanup', async () => {
+    const result = await analyze(
+      createInMemoryFileSource('/p', {
+        'package.json': JSON.stringify({ dependencies: { vue: '^3.0.0' } }),
+        'tsconfig.json': '{}',
+        'src/App.vue': `
+          <script setup lang="ts">
+          import { onMounted } from 'vue';
+
+          onMounted(() => {
+            window.addEventListener('scroll', () => {});
+          });
+          </script>
+        `,
+      }),
+    );
+
+    expect(result.memoryRisks).toEqual([
+      expect.objectContaining({
+        kind: 'event-listener-cleanup',
+        moduleId: 'src/App.vue',
+        framework: 'vue',
+        confidence: 'high',
+      }),
+    ]);
+  });
+
+  it('flags Svelte subscriptions without returned cleanup', async () => {
+    const result = await analyze(
+      createInMemoryFileSource('/p', {
+        'package.json': JSON.stringify({ devDependencies: { svelte: '^4.0.0' } }),
+        'tsconfig.json': '{}',
+        'src/App.svelte': `
+          <script lang="ts">
+            import { onMount } from 'svelte';
+            import { writable } from 'svelte/store';
+
+            const count = writable(0);
+            onMount(() => {
+              count.subscribe(() => {});
+            });
+          </script>
+        `,
+      }),
+    );
+
+    expect(result.memoryRisks).toEqual([
+      expect.objectContaining({
+        kind: 'subscription-cleanup',
+        moduleId: 'src/App.svelte',
+        framework: 'svelte',
+        confidence: 'high',
+      }),
+    ]);
+  });
+
+  it('does not flag Next server modules as browser memory risks', async () => {
+    const result = await analyze(
+      createInMemoryFileSource('/p', {
+        'package.json': JSON.stringify({ dependencies: { next: '^14.0.0', react: '^18.0.0' } }),
+        'tsconfig.json': JSON.stringify({ compilerOptions: { jsx: 'preserve' } }),
+        'app/page.tsx': `
+          'use server';
+
+          export default function Page() {
+            setInterval(() => {}, 1000);
+            return null;
+          }
+        `,
+      }),
+    );
+
+    expect(result.memoryRisks ?? []).toEqual([]);
+  });
+});

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

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { computeMetrics } from '../metrics';
+import { detectCycles } from '../cycles';
+import type { DependencyEdge, ModuleNode } from '../types';
+
+const mod = (id: string, loc = 10): ModuleNode => ({
+  id,
+  absPath: id,
+  kind: 'unknown',
+  language: 'ts',
+  loc,
+  exports: [],
+  isInfra: false,
+});
+const edge = (from: string, to: string): DependencyEdge => ({
+  from,
+  to,
+  kind: 'static',
+  specifier: to,
+  resolved: true,
+});
+
+describe('computeMetrics', () => {
+  it('counts fan-in/out and instability', () => {
+    const modules = [mod('a'), mod('b'), mod('c')];
+    const edges = [edge('a', 'b'), edge('a', 'c'), edge('b', 'c')];
+    const m = computeMetrics({ modules, edges, cycles: [], entries: ['a'] });
+    expect(m['a']!.fanIn).toBe(0);
+    expect(m['a']!.fanOut).toBe(2);
+    expect(m['a']!.instability).toBe(1);
+    expect(m['b']!.fanIn).toBe(1);
+    expect(m['b']!.fanOut).toBe(1);
+    expect(m['b']!.instability).toBe(0.5);
+    expect(m['c']!.fanIn).toBe(2);
+    expect(m['c']!.fanOut).toBe(0);
+    expect(m['c']!.instability).toBe(0);
+  });
+
+  it('marks inCycle and ranks coupling', () => {
+    const modules = [mod('a'), mod('b'), mod('c')];
+    const edges = [edge('a', 'b'), edge('b', 'a'), edge('a', 'c')];
+    const cycles = detectCycles(modules, edges);
+    const m = computeMetrics({ modules, edges, cycles, entries: [] });
+    expect(m['a']!.inCycle).toBe(true);
+    expect(m['b']!.inCycle).toBe(true);
+    expect(m['c']!.inCycle).toBe(false);
+    expect(m['a']!.couplingScore).toBeGreaterThan(0);
+  });
+
+  it('computes depth from entry through DAG (after SCC condensation)', () => {
+    const modules = [mod('a'), mod('b'), mod('c'), mod('d')];
+    const edges = [edge('a', 'b'), edge('b', 'c'), edge('c', 'd')];
+    const m = computeMetrics({ modules, edges, cycles: [], entries: ['a'] });
+    expect(m['a']!.depth).toBe(0);
+    expect(m['b']!.depth).toBe(1);
+    expect(m['c']!.depth).toBe(2);
+    expect(m['d']!.depth).toBe(3);
+  });
+});

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

@@ -0,0 +1,54 @@
+import { describe, it, expect } from 'vitest';
+import { createParserRegistry, isParseFailure } from '../parsers';
+import type { ParsedFile } from '../types';
+
+describe('parserRegistry', () => {
+  const registry = createParserRegistry();
+
+  it('routes .ts files to TS parser', () => {
+    const r = registry.parse({
+      relPath: 'a.ts',
+      content: "import { x } from './b';\nexport const a = x;",
+    });
+    expect(isParseFailure(r)).toBe(false);
+    const parsed = r as ParsedFile;
+    expect(parsed.language).toBe('ts');
+    expect(parsed.imports.map((i) => i.specifier)).toEqual(['./b']);
+  });
+
+  it('routes .tsx files to TS parser as ts language', () => {
+    const r = registry.parse({
+      relPath: 'a.tsx',
+      content: 'export const A = () => null;',
+    });
+    expect((r as ParsedFile).language).toBe('ts');
+  });
+
+  it('routes .jsx/.mjs/.cjs files to TS parser as js language', () => {
+    for (const ext of ['jsx', 'mjs', 'cjs']) {
+      const r = registry.parse({ relPath: `a.${ext}`, content: 'export const a = 1;' });
+      expect((r as ParsedFile).language).toBe('js');
+    }
+  });
+
+  it('routes .vue files to Vue parser', () => {
+    const sfc = `<script setup lang="ts">
+import { ref } from 'vue';
+const x = ref(1);
+</script>`;
+    const r = registry.parse({ relPath: 'A.vue', content: sfc });
+    expect(isParseFailure(r)).toBe(false);
+    expect((r as ParsedFile).language).toBe('vue');
+  });
+
+  it('returns failure on unsupported extension', () => {
+    const r = registry.parse({ relPath: 'a.css', content: 'body { color: red; }' });
+    expect(isParseFailure(r)).toBe(true);
+    if (isParseFailure(r)) expect(r.reason).toBe('unsupported-extension');
+  });
+
+  it('returns failure on extensionless files', () => {
+    const r = registry.parse({ relPath: 'README', content: '' });
+    expect(isParseFailure(r)).toBe(true);
+  });
+});