@archora/core 1.1.0

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

@@ -0,0 +1,122 @@
+import { describe, expect, it } from 'vitest';
+import { analyze } from '..';
+import { createInMemoryFileSource } from '../sources/inMemoryFileSource';
+
+describe('async lifecycle risk analysis', () => {
+  it('flags a React effect that fetches without abort or stale guard', 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, useState } from 'react';
+
+          export function App() {
+            const [name, setName] = useState('');
+            useEffect(() => {
+              fetch('/api/user')
+                .then((res) => res.text())
+                .then(setName);
+            }, []);
+            return <div>{name}</div>;
+          }
+        `,
+      }),
+    );
+
+    expect(result.asyncLifecycleRisks).toEqual([
+      expect.objectContaining({
+        kind: 'async-effect-cleanup',
+        moduleId: 'src/App.tsx',
+        framework: 'react',
+        confidence: 'high',
+      }),
+    ]);
+    expect(result.signals?.some((signal) => signal.kind === 'async-lifecycle-risk')).toBe(true);
+  });
+
+  it('keeps a React effect with AbortController 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, useState } from 'react';
+
+          export function App() {
+            const [name, setName] = useState('');
+            useEffect(() => {
+              const controller = new AbortController();
+              fetch('/api/user', { signal: controller.signal })
+                .then((res) => res.text())
+                .then(setName);
+              return () => controller.abort();
+            }, []);
+            return <div>{name}</div>;
+          }
+        `,
+      }),
+    );
+
+    expect(result.asyncLifecycleRisks ?? []).toEqual([]);
+  });
+
+  it('flags Vue mounted async work without unmounted guard', 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, ref } from 'vue';
+
+          const name = ref('');
+          onMounted(async () => {
+            const res = await fetch('/api/user');
+            name.value = await res.text();
+          });
+          </script>
+        `,
+      }),
+    );
+
+    expect(result.asyncLifecycleRisks).toEqual([
+      expect.objectContaining({
+        kind: 'async-effect-cleanup',
+        moduleId: 'src/App.vue',
+        framework: 'vue',
+        confidence: 'high',
+      }),
+    ]);
+  });
+
+  it('flags Svelte onMount async work 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';
+
+            let name = '';
+            onMount(() => {
+              fetch('/api/user')
+                .then((res) => res.text())
+                .then((value) => { name = value; });
+            });
+          </script>
+        `,
+      }),
+    );
+
+    expect(result.asyncLifecycleRisks).toEqual([
+      expect.objectContaining({
+        kind: 'async-effect-cleanup',
+        moduleId: 'src/App.svelte',
+        framework: 'svelte',
+        confidence: 'high',
+      }),
+    ]);
+  });
+});

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

@@ -0,0 +1,97 @@
+import { describe, it, expect } from 'vitest';
+import { createBrowserFsAccessFileSource } from '../sources/browserFsAccessFileSource';
+
+// minimal FS Access handle mock - only the methods the source touches
+type MockTree = { [name: string]: string | MockTree };
+
+function makeFileHandle(content: string): unknown {
+  return {
+    kind: 'file',
+    async getFile() {
+      return {
+        text: () => Promise.resolve(content),
+      };
+    },
+  };
+}
+
+function makeDirHandle(name: string, tree: MockTree): unknown {
+  return {
+    kind: 'directory',
+    name,
+    async *entries() {
+      for (const [child, value] of Object.entries(tree)) {
+        if (typeof value === 'string') {
+          yield [child, makeFileHandle(value)];
+        } else {
+          yield [child, makeDirHandle(child, value)];
+        }
+      }
+    },
+    async getDirectoryHandle(child: string): Promise<unknown> {
+      const v = tree[child];
+      if (!v || typeof v === 'string') throw new Error(`No such dir: ${child}`);
+      return makeDirHandle(child, v);
+    },
+    async getFileHandle(child: string): Promise<unknown> {
+      const v = tree[child];
+      if (typeof v !== 'string') throw new Error(`No such file: ${child}`);
+      return makeFileHandle(v);
+    },
+  };
+}
+
+describe('browserFsAccessFileSource', () => {
+  it('list() filters by SUPPORTED_EXT (config files excluded)', async () => {
+    const root = makeDirHandle('proj', {
+      'tsconfig.json': '{}',
+      'package.json': '{}',
+      'README.md': 'docs',
+      src: { 'main.ts': 'export {}' },
+    });
+    const source = await createBrowserFsAccessFileSource({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      rootHandle: root as any,
+    });
+    const list = await source.list();
+    expect(list).toEqual(['src/main.ts']);
+  });
+
+  it('exists() resolves config files outside SUPPORTED_EXT', async () => {
+    const root = makeDirHandle('proj', {
+      'tsconfig.json': '{}',
+      '.archora.json': '{}',
+      src: { 'main.ts': 'export {}' },
+    });
+    const source = await createBrowserFsAccessFileSource({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      rootHandle: root as any,
+    });
+    expect(await source.exists('tsconfig.json')).toBe(true);
+    expect(await source.exists('.archora.json')).toBe(true);
+    expect(await source.exists('src/main.ts')).toBe(true);
+    expect(await source.exists('missing.json')).toBe(false);
+  });
+
+  it('read() returns config files outside SUPPORTED_EXT', async () => {
+    const root = makeDirHandle('proj', {
+      'tsconfig.json': '{"compilerOptions":{"paths":{"@/*":["src/*"]}}}',
+      src: { 'main.ts': 'import x from "@/x"' },
+    });
+    const source = await createBrowserFsAccessFileSource({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      rootHandle: root as any,
+    });
+    expect(await source.read('tsconfig.json')).toContain('"paths"');
+    expect(await source.read('src/main.ts')).toContain('@/x');
+  });
+
+  it('read() throws on non-existent path', async () => {
+    const root = makeDirHandle('proj', { src: { 'a.ts': 'x' } });
+    const source = await createBrowserFsAccessFileSource({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      rootHandle: root as any,
+    });
+    await expect(source.read('nope.json')).rejects.toThrow();
+  });
+});

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

@@ -0,0 +1,191 @@
+// Bundle-aware analysis.
+// Covers stats parsing for both supported formats, mapping onto the module
+// graph, and bloat detection thresholds.
+
+import { describe, expect, it } from 'vitest';
+
+import { analyzeBundle, parseBundleStats } from '../bundle';
+import type { ModuleNode } from '../types';
+
+function mod(id: string, overrides: Partial<ModuleNode> = {}): ModuleNode {
+  return {
+    id,
+    absPath: id,
+    kind: 'unknown',
+    language: 'ts',
+    loc: 50,
+    exports: [],
+    isInfra: false,
+    ...overrides,
+  };
+}
+
+describe('parseBundleStats', () => {
+  it('parses webpack stats and normalizes module paths', () => {
+    const stats = parseBundleStats(
+      {
+        chunks: [
+          {
+            id: 0,
+            names: ['main'],
+            files: ['main.js'],
+            size: 12000,
+            modules: [
+              { name: './src/app/index.ts', size: 4000 },
+              { name: 'src/shared/lib/utils.ts?vue&type=script', size: 800 },
+            ],
+          },
+        ],
+      },
+      { rootPath: '/repo' },
+    );
+
+    expect(stats.format).toBe('webpack');
+    expect(stats.chunks).toHaveLength(1);
+    expect(stats.chunks[0]?.modules.map((m) => m.normalizedPath)).toEqual([
+      'src/app/index.ts',
+      'src/shared/lib/utils.ts',
+    ]);
+  });
+
+  it('parses rollup-plugin-visualizer trees', () => {
+    const stats = parseBundleStats(
+      {
+        tree: {
+          name: 'root',
+          children: [
+            {
+              name: 'main.js',
+              children: [
+                {
+                  name: 'src',
+                  children: [
+                    { name: 'app/index.ts', size: 2000 },
+                    { name: 'shared/lib/utils.ts', size: 600 },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      },
+      { rootPath: '/repo' },
+    );
+
+    expect(stats.format).toBe('rollup-visualizer');
+    expect(stats.chunks).toHaveLength(1);
+    expect(stats.chunks[0]?.size).toBe(2600);
+    const paths = stats.chunks[0]?.modules.map((m) => m.normalizedPath);
+    expect(paths).toContain('main.js/src/app/index.ts');
+  });
+
+  it('returns empty unknown report on garbage input', () => {
+    expect(parseBundleStats(null, { rootPath: '/x' })).toEqual({ format: 'unknown', chunks: [] });
+    expect(parseBundleStats({ random: 1 }, { rootPath: '/x' })).toEqual({
+      format: 'unknown',
+      chunks: [],
+    });
+  });
+});
+
+describe('analyzeBundle', () => {
+  it('flags duplicates, heavy chunks and solo-hot modules', () => {
+    const modules = [
+      mod('src/app/index.ts'),
+      mod('src/shared/big.ts', { loc: 4000 }),
+      mod('src/shared/lib/utils.ts'),
+    ];
+
+    const stats = parseBundleStats(
+      {
+        chunks: [
+          {
+            id: 'main',
+            files: ['main.js'],
+            size: 600_000,
+            modules: [
+              { name: 'src/app/index.ts', size: 100_000 },
+              { name: 'src/shared/big.ts', size: 480_000 },
+              { name: 'src/shared/lib/utils.ts', size: 5_000 },
+            ],
+          },
+          {
+            id: 'admin',
+            files: ['admin.js'],
+            size: 220_000,
+            modules: [{ name: 'src/shared/lib/utils.ts', size: 5_000 }],
+          },
+        ],
+      },
+      { rootPath: '/repo' },
+    );
+
+    const report = analyzeBundle({ modules, stats });
+
+    expect(report.format).toBe('webpack');
+    expect(report.totalSize).toBe(820_000);
+
+    const kinds = report.bloat.map((b) => b.kind).sort();
+    expect(kinds).toContain('duplicate');
+    expect(kinds).toContain('heavy-chunk');
+    expect(kinds).toContain('solo-hot');
+
+    const dup = report.bloat.find((b) => b.kind === 'duplicate');
+    expect(dup?.modules).toEqual(['src/shared/lib/utils.ts']);
+    expect(dup?.chunks.sort()).toEqual(['admin', 'main']);
+
+    const heavy = report.bloat.find((b) => b.kind === 'heavy-chunk');
+    expect(heavy?.chunks).toEqual(['main']);
+
+    const solo = report.bloat.find((b) => b.kind === 'solo-hot');
+    expect(solo?.modules).toEqual(['src/shared/big.ts']);
+    expect(solo?.detail?.sharePercent).toBeGreaterThan(70);
+  });
+
+  it('respects custom thresholds', () => {
+    const modules = [mod('src/x.ts')];
+    const stats = parseBundleStats(
+      {
+        chunks: [
+          {
+            id: 'a',
+            files: ['a.js'],
+            size: 100_000,
+            modules: [{ name: 'src/x.ts', size: 100_000 }],
+          },
+        ],
+      },
+      { rootPath: '/repo' },
+    );
+
+    const report = analyzeBundle({
+      modules,
+      stats,
+      thresholds: { heavyChunkBytes: 50_000 },
+    });
+
+    expect(report.bloat.some((b) => b.kind === 'heavy-chunk')).toBe(true);
+  });
+
+  it('does not flag unmapped paths', () => {
+    const modules = [mod('src/known.ts')];
+    const stats = parseBundleStats(
+      {
+        chunks: [
+          {
+            id: 'main',
+            files: ['main.js'],
+            size: 600_000,
+            modules: [{ name: 'node_modules/foo/index.js', size: 600_000 }],
+          },
+        ],
+      },
+      { rootPath: '/repo' },
+    );
+
+    const report = analyzeBundle({ modules, stats });
+    // heavy-chunk still fires (about chunk size) but not solo-hot (no internal modules).
+    expect(report.bloat.some((b) => b.kind === 'solo-hot')).toBe(false);
+    expect(Object.keys(report.moduleToChunks)).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import { isInfra, classifyKind } from '../classify';
+import type { ParsedFile } from '../types';
+
+const parsed = (over: Partial<ParsedFile> = {}): ParsedFile => ({
+  relPath: '',
+  language: 'ts',
+  exports: [],
+  imports: [],
+  hasDefineStore: false,
+  loc: 10,
+  ...over,
+});
+
+describe('isInfra', () => {
+  it.each([
+    'src/types.d.ts',
+    'vite.config.ts',
+    'vitest.config.ts',
+    'rollup.config.mjs',
+    'webpack.config.js',
+    'astro.config.mjs',
+    'playwright.config.ts',
+    'eslint.config.js',
+    '.eslintrc.cjs',
+    'postcss.config.cjs',
+    'tailwind.config.ts',
+  ])('treats %s as infra', (path) => {
+    expect(isInfra(path)).toBe(true);
+  });
+
+  it.each([
+    'src/main.ts',
+    'src/components/Button.vue',
+    'src/utils/format.ts',
+    'src/api/users.config.profile.ts',
+  ])('keeps %s as regular', (path) => {
+    expect(isInfra(path)).toBe(false);
+  });
+});
+
+describe('classifyKind', () => {
+  it('vue file → component', () => {
+    expect(classifyKind(parsed({ language: 'vue' }), 'src/X.vue')).toBe('component');
+  });
+
+  it('svelte file → component', () => {
+    expect(classifyKind(parsed({ language: 'svelte' }), 'src/X.svelte')).toBe('component');
+  });
+
+  it('defineStore call → store regardless of path', () => {
+    expect(classifyKind(parsed({ hasDefineStore: true }), 'src/random.ts')).toBe('store');
+  });
+
+  it('composables/ folder → composable', () => {
+    expect(classifyKind(parsed(), 'src/composables/useX.ts')).toBe('composable');
+  });
+
+  it('useFoo.ts at any path → composable', () => {
+    expect(classifyKind(parsed(), 'src/lib/useDebounce.ts')).toBe('composable');
+  });
+
+  it('exported `use*` function → composable even with neutral name', () => {
+    expect(classifyKind(parsed({ exports: ['useTheme'] }), 'src/lib/theme.ts')).toBe('composable');
+  });
+
+  it('router file → route', () => {
+    expect(classifyKind(parsed(), 'src/router/index.ts')).toBe('route');
+  });
+
+  it('utils/lib/helpers folders → util', () => {
+    expect(classifyKind(parsed(), 'src/utils/format.ts')).toBe('util');
+    expect(classifyKind(parsed(), 'src/lib/cn.ts')).toBe('util');
+    expect(classifyKind(parsed(), 'src/helpers/x.ts')).toBe('util');
+  });
+
+  it('main/index/entry → entry', () => {
+    expect(classifyKind(parsed(), 'src/main.ts')).toBe('entry');
+    expect(classifyKind(parsed(), 'src/index.ts')).toBe('entry');
+  });
+
+  it('XLoader / XPlugin / XRegistry / XProvider → integration', () => {
+    expect(classifyKind(parsed(), 'src/services/AuthLoader.ts')).toBe('integration');
+    expect(classifyKind(parsed(), 'src/plugins/MyPlugin.ts')).toBe('integration');
+  });
+
+  it('recognizes common project roles outside FSD', () => {
+    expect(classifyKind(parsed(), 'src/api/person.ts')).toBe('api');
+    expect(classifyKind(parsed(), 'src/services/personClient.ts')).toBe('service');
+    expect(classifyKind(parsed(), 'src/model/session.ts')).toBe('model');
+    expect(classifyKind(parsed(), 'src/types/person.ts')).toBe('schema');
+    expect(classifyKind(parsed(), 'src/config/routes.ts')).toBe('config');
+    expect(classifyKind(parsed(), 'src/__tests__/session.test.ts')).toBe('test');
+  });
+
+  it('uses a project module fallback otherwise', () => {
+    expect(classifyKind(parsed(), 'src/random/file.ts')).toBe('module');
+  });
+});