specforge-mcp 0.1.0

package/dist/engine/analyzer.test.js

@@ -0,0 +1,1461 @@
+// analyzer.test.ts — Unit tests for the project analysis engine
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock all filesystem and glob dependencies
+vi.mock('node:fs/promises', () => ({
+    readFile: vi.fn(),
+    readdir: vi.fn(),
+    stat: vi.fn(),
+    access: vi.fn(),
+}));
+vi.mock('glob', () => ({
+    glob: vi.fn(),
+}));
+import { readFile, readdir, stat, access } from 'node:fs/promises';
+import { glob } from 'glob';
+const mockedReadFile = vi.mocked(readFile);
+const mockedReaddir = vi.mocked(readdir);
+const mockedStat = vi.mocked(stat);
+const mockedAccess = vi.mocked(access);
+const mockedGlob = vi.mocked(glob);
+// Import after mocks are set up
+const { analyzeProject, quickAnalyze, checkProjectCompleteness } = await import('./analyzer.js');
+// === Helpers ===
+const STACK_SIGNATURES = {
+    languages: {
+        typescript: {
+            files: ['tsconfig.json'],
+            extensions: ['.ts', '.tsx'],
+        },
+        python: {
+            files: ['requirements.txt', 'pyproject.toml'],
+            extensions: ['.py'],
+        },
+        go: {
+            files: ['go.mod'],
+            extensions: ['.go'],
+        },
+    },
+    frameworks: {
+        'next.js': {
+            indicators: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
+            dependencies: ['next'],
+        },
+        express: {
+            indicators: [],
+            dependencies: ['express'],
+        },
+        react: {
+            indicators: [],
+            dependencies: ['react'],
+        },
+        django: {
+            indicators: ['manage.py'],
+            dependencies: ['django'],
+        },
+        expo: {
+            indicators: ['app.json'],
+            dependencies: ['expo'],
+        },
+        hono: {
+            indicators: [],
+            dependencies: ['hono'],
+        },
+    },
+    packageManagers: {
+        npm: { lockfile: 'package-lock.json' },
+        pnpm: { lockfile: 'pnpm-lock.yaml' },
+        yarn: { lockfile: 'yarn.lock' },
+    },
+    databases: {
+        postgresql: {
+            engine: 'postgresql',
+            indicators: ['prisma/schema.prisma'],
+            dependencies: ['pg', 'prisma', '@prisma/client'],
+        },
+        mongodb: {
+            engine: 'mongodb',
+            indicators: [],
+            dependencies: ['mongoose', 'mongodb'],
+        },
+        sqlite: {
+            engine: 'sqlite',
+            indicators: [],
+            dependencies: ['better-sqlite3', 'sqlite3'],
+        },
+        supabase: {
+            engine: 'supabase',
+            indicators: [],
+            dependencies: ['@supabase/supabase-js'],
+        },
+        firebase: {
+            engine: 'firebase',
+            indicators: ['firebase.json'],
+            dependencies: ['firebase'],
+        },
+        mysql: {
+            engine: 'mysql',
+            indicators: [],
+            dependencies: ['mysql2'],
+        },
+    },
+};
+const ARCH_PATTERNS = {
+    patterns: {
+        monolith: {
+            name: 'Monolith',
+            indicators: {
+                directories: ['src/', 'app/'],
+            },
+        },
+        'modular-monolith': {
+            name: 'Modular Monolith',
+            indicators: {
+                directories: ['src/modules/', 'src/features/'],
+            },
+        },
+        layered: {
+            name: 'Layered',
+            indicators: {
+                directories: ['controllers/', 'services/', 'repositories/'],
+            },
+        },
+        microservices: {
+            name: 'Microservices',
+            indicators: {
+                files: ['docker-compose.yml'],
+                dependencies: ['@nestjs/microservices'],
+            },
+        },
+    },
+};
+/** Helper: make access() succeed for specific files */
+function setupFileExists(existingFiles) {
+    mockedAccess.mockImplementation(((p) => {
+        const path = p;
+        if (existingFiles.some((f) => path.endsWith(f))) {
+            return Promise.resolve(undefined);
+        }
+        const err = new Error('ENOENT');
+        err.code = 'ENOENT';
+        return Promise.reject(err);
+    }));
+}
+/** Helper: make stat return isDirectory for specific paths */
+function setupStat(directories) {
+    mockedStat.mockImplementation(((p) => {
+        const path = p;
+        if (directories.some((d) => path.includes(d))) {
+            return Promise.resolve({ isDirectory: () => true });
+        }
+        const err = new Error('ENOENT');
+        err.code = 'ENOENT';
+        return Promise.reject(err);
+    }));
+}
+beforeEach(() => {
+    vi.resetAllMocks();
+    // Default: nothing exists
+    mockedAccess.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+    mockedReadFile.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+    mockedReaddir.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+    mockedStat.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+    mockedGlob.mockResolvedValue([]);
+});
+// =============================================================================
+// analyzeProject — full analysis
+// =============================================================================
+describe('analyzeProject', () => {
+    it('should return a complete ProjectKnowledge object for a minimal project', async () => {
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.projectId).toBe('proj-1');
+        expect(result.projectPath).toBe('/tmp/project');
+        expect(result.locale).toBe('en');
+        expect(result.experienceLevel).toBe('intermediate');
+        expect(result.language).toBeDefined();
+        expect(result.stack).toBeDefined();
+        expect(result.architecture).toBeDefined();
+        expect(result.conventions).toBeDefined();
+        expect(result.environments).toBeDefined();
+        expect(result.specLocation).toBe('docs/sdd/specs');
+        expect(result.lastAnalyzed).toBeDefined();
+    });
+    it('should detect TypeScript language from tsconfig.json', async () => {
+        setupFileExists(['tsconfig.json', 'package-lock.json']);
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'tsconfig.json' || p === 'tsconfig.*.json') {
+                return ['tsconfig.json'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.language).toBe('typescript');
+    });
+    it('should detect Next.js framework from next.config.js', async () => {
+        setupFileExists(['tsconfig.json', 'package-lock.json']);
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'tsconfig.json') {
+                return ['tsconfig.json'];
+            }
+            if (p === 'next.config.js' || p === 'next.config.mjs' || p === 'next.config.ts') {
+                return ['next.config.js'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.framework).toBe('next.js');
+    });
+    it('should detect npm as package manager from package-lock.json', async () => {
+        setupFileExists(['tsconfig.json', 'package-lock.json']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.packageManager).toBe('npm');
+    });
+    it('should detect pnpm from pnpm-lock.yaml', async () => {
+        setupFileExists(['tsconfig.json', 'pnpm-lock.yaml']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.packageManager).toBe('pnpm');
+    });
+    it('should detect yarn from yarn.lock', async () => {
+        setupFileExists(['tsconfig.json', 'yarn.lock']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.packageManager).toBe('yarn');
+    });
+    it('should build stack list with language, framework, database, package manager', async () => {
+        setupFileExists(['tsconfig.json', 'package-lock.json']);
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'tsconfig.json') {
+                return ['tsconfig.json'];
+            }
+            if (p === 'next.config.js') {
+                return ['next.config.js'];
+            }
+            return [];
+        }));
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({
+                    dependencies: { next: '14.0.0', pg: '8.0.0' },
+                    scripts: { build: 'next build', test: 'vitest' },
+                });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.stack).toContain('typescript');
+        expect(result.packageManager).toBe('npm');
+    });
+    it('should detect framework from dependencies in package.json', async () => {
+        setupFileExists(['tsconfig.json', 'package-lock.json']);
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({ dependencies: { express: '4.18.0' } });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'tsconfig.json') {
+                return ['tsconfig.json'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.framework).toBe('express');
+    });
+    it('should detect database from dependencies', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({ dependencies: { mongoose: '7.0.0' } });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.database).toBe('mongodb');
+    });
+    it('should detect database from indicator files', async () => {
+        setupFileExists(['tsconfig.json']);
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'tsconfig.json') {
+                return ['tsconfig.json'];
+            }
+            if (p === 'prisma/schema.prisma') {
+                return ['prisma/schema.prisma'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.database).toBe('postgresql');
+    });
+    it('should return "unknown" database when none detected', async () => {
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.database).toBe('unknown');
+    });
+    it('should detect monorepo apps from turbo.json', async () => {
+        setupFileExists(['tsconfig.json', 'turbo.json']);
+        mockedReaddir.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('/apps') || p.endsWith('/packages')) {
+                return [
+                    { name: 'web', isDirectory: () => true },
+                    { name: 'api', isDirectory: () => true },
+                ];
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.apps.length).toBeGreaterThan(0);
+    });
+    it('should infer frontend app type from directory name containing "web"', async () => {
+        setupFileExists(['tsconfig.json', 'turbo.json']);
+        mockedReaddir.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('/apps')) {
+                return [
+                    { name: 'web-client', isDirectory: () => true },
+                ];
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const webApp = result.apps.find((a) => a.name === 'web-client');
+        expect(webApp?.type).toBe('frontend');
+    });
+    it('should infer backend type from directory name with "api"', async () => {
+        setupFileExists(['tsconfig.json', 'turbo.json']);
+        mockedReaddir.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('/apps')) {
+                return [
+                    { name: 'api-server', isDirectory: () => true },
+                ];
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const apiApp = result.apps.find((a) => a.name === 'api-server');
+        expect(apiApp?.type).toBe('backend');
+    });
+    it('should infer mobile type from directory name', async () => {
+        setupFileExists(['tsconfig.json', 'turbo.json']);
+        mockedReaddir.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('/apps')) {
+                return [
+                    { name: 'mobile-app', isDirectory: () => true },
+                ];
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const mApp = result.apps.find((a) => a.name === 'mobile-app');
+        expect(mApp?.type).toBe('mobile');
+    });
+    it('should infer shared type from directory name containing "shared"', async () => {
+        setupFileExists(['tsconfig.json', 'turbo.json']);
+        mockedReaddir.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('/packages')) {
+                return [
+                    { name: 'shared-utils', isDirectory: () => true },
+                ];
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const sharedApp = result.apps.find((a) => a.name === 'shared-utils');
+        expect(sharedApp?.type).toBe('shared');
+    });
+    it('should infer docs type from directory name', async () => {
+        setupFileExists(['tsconfig.json', 'turbo.json']);
+        mockedReaddir.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('/apps')) {
+                return [
+                    { name: 'docs', isDirectory: () => true },
+                ];
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const docsApp = result.apps.find((a) => a.name === 'docs');
+        expect(docsApp?.type).toBe('docs');
+    });
+    it('should infer worker type from directory name', async () => {
+        setupFileExists(['tsconfig.json', 'turbo.json']);
+        mockedReaddir.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('/apps')) {
+                return [
+                    { name: 'worker-queue', isDirectory: () => true },
+                ];
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const workerApp = result.apps.find((a) => a.name === 'worker-queue');
+        expect(workerApp?.type).toBe('worker');
+    });
+    it('should treat root as single app when no monorepo detected', async () => {
+        const result = await analyzeProject('/tmp/my-project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.apps.length).toBeGreaterThanOrEqual(0);
+    });
+    it('should detect architecture patterns scoring directories', async () => {
+        setupStat(['src/', 'app/']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture).toBeDefined();
+        expect(result.architecture.primary).toBeDefined();
+    });
+    it('should detect linting tools from config files', async () => {
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === '.eslintrc*' || p === 'eslint.config.*') {
+                return ['.eslintrc.js'];
+            }
+            if (p === '.prettierrc*' || p === 'prettier.config.*') {
+                return ['.prettierrc'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.linting).toBeDefined();
+        expect(result.linting.detectedLinters.length).toBeGreaterThanOrEqual(0);
+    });
+    it('should detect linter conflicts between eslint and biome', async () => {
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === '.eslintrc*' || p === 'eslint.config.*') {
+                return ['.eslintrc.js'];
+            }
+            if (p === 'biome.json' || p === 'biome.jsonc') {
+                return ['biome.json'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const conflicts = result.linting.rulesConflicts;
+        expect(conflicts.some((c) => c.linterA === 'eslint' && c.linterB === 'biome')).toBe(true);
+    });
+    it('should detect prettier vs biome conflict', async () => {
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === '.prettierrc*' || p === 'prettier.config.*') {
+                return ['.prettierrc'];
+            }
+            if (p === 'biome.json' || p === 'biome.jsonc') {
+                return ['biome.json'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const conflicts = result.linting.rulesConflicts;
+        expect(conflicts.some((c) => c.linterA === 'prettier' && c.linterB === 'biome')).toBe(true);
+    });
+    it('should detect linter as installed-not-configured from npm deps', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({
+                    devDependencies: { eslint: '8.0.0' },
+                });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const eslintDetection = result.linting.detectedLinters.find((l) => l.tool === 'eslint');
+        if (eslintDetection) {
+            expect(eslintDetection.status).toBe('installed-not-configured');
+        }
+    });
+    it('should parse .env.example and detect env variables', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('.env.example')) {
+                return 'DATABASE_URL=postgres://localhost\nAPI_SECRET_KEY=\nPORT=3000\n# comment\n\n';
+            }
+            if (p.endsWith('.gitignore')) {
+                return '.env\nnode_modules';
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.envSetup.variables.length).toBeGreaterThan(0);
+        const dbVar = result.envSetup.variables.find((v) => v.name === 'DATABASE_URL');
+        expect(dbVar).toBeDefined();
+        expect(dbVar.service).toBe('database');
+        const secretVar = result.envSetup.variables.find((v) => v.name === 'API_SECRET_KEY');
+        expect(secretVar).toBeDefined();
+        expect(secretVar.sensitive).toBe(true);
+    });
+    it('should detect env security issue when .gitignore does not have .env', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('.gitignore')) {
+                return 'node_modules\ndist';
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.envSetup.security.gitignoreHasEnv).toBe(false);
+        expect(result.envSetup.security.issues.length).toBeGreaterThan(0);
+        expect(result.envSetup.security.issues[0].severity).toBe('critical');
+    });
+    it('should detect .env in gitignore as secure', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('.gitignore')) {
+                return '.env\nnode_modules';
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.envSetup.security.gitignoreHasEnv).toBe(true);
+        expect(result.envSetup.security.issues).toHaveLength(0);
+    });
+    it('should detect OpenAPI contracts', async () => {
+        setupFileExists(['openapi.yaml']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.apiContracts.some((c) => c.type === 'openapi')).toBe(true);
+    });
+    it('should detect GraphQL contracts', async () => {
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'schema.graphql' || p === 'schema.gql' || p === '**/*.graphql') {
+                return ['schema.graphql'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.apiContracts.some((c) => c.type === 'graphql')).toBe(true);
+    });
+    it('should detect tRPC contracts from dependencies', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({ dependencies: { '@trpc/server': '10.0.0' } });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.apiContracts.some((c) => c.type === 'trpc')).toBe(true);
+    });
+    it('should detect gRPC contracts from .proto files', async () => {
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === '**/*.proto') {
+                return ['api/service.proto'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.apiContracts.some((c) => c.type === 'grpc')).toBe(true);
+    });
+    it('should discover MCP servers from .claude/settings.json', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('.claude/settings.json')) {
+                return JSON.stringify({
+                    mcpServers: {
+                        supabase: { command: 'npx supabase-mcp', tools: ['query', 'migrate'] },
+                    },
+                });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.availableMcps.length).toBeGreaterThan(0);
+        expect(result.availableMcps[0].name).toBe('supabase');
+        expect(result.availableMcps[0].command).toBe('npx supabase-mcp');
+        expect(result.availableMcps[0].tools).toEqual(['query', 'migrate']);
+    });
+    it('should handle MCP config with non-string command and non-array tools', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('.claude/settings.json')) {
+                return JSON.stringify({
+                    mcpServers: {
+                        test: { command: 123, tools: 'not-array' },
+                    },
+                });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const testMcp = result.availableMcps.find((m) => m.name === 'test');
+        if (testMcp) {
+            expect(testMcp.command).toBe('');
+            expect(testMcp.tools).toEqual([]);
+        }
+    });
+    it('should detect conventions: CLAUDE.md, .cursorrules, .editorconfig', async () => {
+        setupFileExists(['CLAUDE.md', '.cursorrules', '.editorconfig']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.conventions['ai-rules']).toBe('CLAUDE.md');
+        expect(result.conventions['cursor-rules']).toBe('.cursorrules');
+        expect(result.conventions['editor-config']).toBe('.editorconfig');
+    });
+    it('should detect commit conventions from commitlint config', async () => {
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'commitlint.config.*' || p === '.commitlintrc*') {
+                return ['commitlint.config.js'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.conventions['commit-convention']).toBe('conventional-commits');
+    });
+    it('should detect husky git hooks', async () => {
+        setupFileExists(['.husky']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.conventions['git-hooks']).toBe('husky');
+    });
+    it('should detect environments from env files', async () => {
+        setupFileExists(['.env.staging', '.env.production']);
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === '.env.staging' || p === '.env.test' || p === '.env.production') {
+                return ['.env.staging'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.environments).toContain('development');
+    });
+    it('should default environments to development + staging + production when no env files found', async () => {
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.environments).toContain('development');
+        expect(result.environments).toContain('staging');
+        expect(result.environments).toContain('production');
+    });
+    it('should detect build command from package.json scripts', async () => {
+        setupFileExists(['tsconfig.json', 'package-lock.json']);
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({ scripts: { build: 'tsc', test: 'vitest' } });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.buildCommand).toBe('npm run build');
+    });
+    it('should detect pnpm run build for pnpm package manager', async () => {
+        setupFileExists(['tsconfig.json', 'pnpm-lock.yaml']);
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({ scripts: { build: 'tsc', test: 'vitest' } });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.buildCommand).toBe('pnpm run build');
+    });
+    it('should detect yarn run build for yarn package manager', async () => {
+        setupFileExists(['tsconfig.json', 'yarn.lock']);
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({ scripts: { build: 'tsc', test: 'vitest' } });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.buildCommand).toBe('yarn run build');
+    });
+    it('should detect Makefile build command', async () => {
+        setupFileExists(['Makefile']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.buildCommand).toBe('make build');
+    });
+    it('should detect cargo build for Rust projects', async () => {
+        setupFileExists(['Cargo.toml']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.buildCommand).toBe('cargo build');
+    });
+    it('should detect go build for Go projects', async () => {
+        setupFileExists(['go.mod']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.buildCommand).toBe('go build ./...');
+    });
+    it('should detect npm test command', async () => {
+        setupFileExists(['package-lock.json']);
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({ scripts: { test: 'vitest' } });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.testCommand).toBe('npm test');
+    });
+    it('should detect cargo test for Rust projects', async () => {
+        setupFileExists(['Cargo.toml']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.testCommand).toBe('cargo test');
+    });
+    it('should detect go test for Go projects', async () => {
+        setupFileExists(['go.mod']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.testCommand).toBe('go test ./...');
+    });
+    it('should detect pytest from pytest.ini', async () => {
+        setupFileExists(['pytest.ini']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.testCommand).toBe('pytest');
+    });
+    it('should detect pytest from pyproject.toml', async () => {
+        setupFileExists(['pyproject.toml']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.testCommand).toBe('pytest');
+    });
+    it('should detect Docker deployment unit', async () => {
+        setupFileExists(['Dockerfile']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.deploymentUnits).toContain('docker');
+    });
+    it('should detect docker-compose deployment unit', async () => {
+        setupFileExists(['docker-compose.yml']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.deploymentUnits).toContain('docker-compose');
+    });
+    it('should detect vercel deployment unit', async () => {
+        setupFileExists(['vercel.json']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.deploymentUnits).toContain('vercel');
+    });
+    it('should detect netlify deployment unit', async () => {
+        setupFileExists(['netlify.toml']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.deploymentUnits).toContain('netlify');
+    });
+    it('should detect railway deployment unit from railway.json', async () => {
+        setupFileExists(['railway.json']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.deploymentUnits).toContain('railway');
+    });
+    it('should detect fly.io deployment unit', async () => {
+        setupFileExists(['fly.toml']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.deploymentUnits).toContain('fly.io');
+    });
+    it('should detect render deployment unit', async () => {
+        setupFileExists(['render.yaml']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.deploymentUnits).toContain('render');
+    });
+    it('should detect terraform deployment unit', async () => {
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === '*.tf') {
+                return ['main.tf'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.deploymentUnits).toContain('terraform');
+    });
+    it('should default to "manual" when no deployment unit found', async () => {
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.deploymentUnits).toContain('manual');
+    });
+    it('should detect layers from directory structure', async () => {
+        mockedStat.mockImplementation(((p) => {
+            const path = p;
+            if (path.includes('/src/services') ||
+                path.includes('/src/components') ||
+                path.includes('/src/lib')) {
+                return { isDirectory: () => true };
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.layers.length).toBeGreaterThanOrEqual(0);
+    });
+    it('should detect module boundaries from src/modules', async () => {
+        mockedReaddir.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('/src/modules')) {
+                return [
+                    { name: 'auth', isDirectory: () => true },
+                    { name: 'billing', isDirectory: () => true },
+                ];
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        // Make index.ts exist for auth module
+        setupFileExists(['src/modules/auth/index.ts']);
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.boundaries.length).toBeGreaterThan(0);
+    });
+    it('should detect communication patterns based on architecture', async () => {
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.architecture.communicationPatterns).toBeDefined();
+        expect(result.architecture.communicationPatterns.length).toBeGreaterThan(0);
+    });
+    it('should include default quality profile', async () => {
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.qualityProfile).toBeDefined();
+        expect(result.qualityProfile.enabledCategories).toContain('solid');
+        expect(result.qualityProfile.principles).toContain('SOLID');
+        expect(result.qualityProfile.strictness).toBe('standard');
+    });
+    it('should collect dependencies from requirements.txt', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('requirements.txt')) {
+                return 'django>=4.0\ncelery~=5.3\n# comment\nredis';
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.framework).toBe('django');
+    });
+    it('should collect dependencies from pyproject.toml', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('pyproject.toml')) {
+                return '[project]\ndependencies = [\n"django>=4.0"\n"celery>=5.3"\n]';
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.framework).toBe('django');
+    });
+    it('should collect dependencies from go.mod', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('go.mod')) {
+                return 'module myapp\n\ngo 1.22\n\nrequire (\n\tgithub.com/gin-gonic/gin v1.9.1\n)';
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        // gin framework detects via dependency
+        const goSignatures = {
+            ...STACK_SIGNATURES,
+            frameworks: {
+                ...STACK_SIGNATURES.frameworks,
+                gin: { indicators: [], dependencies: ['github.com/gin-gonic/gin'] },
+            },
+        };
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', goSignatures, ARCH_PATTERNS);
+        expect(result.framework).toBe('gin');
+    });
+    it('should collect dependencies from Gemfile', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('Gemfile')) {
+                return "source 'https://rubygems.org'\ngem 'rails', '~> 7.0'\ngem 'pg'\n";
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const railsSigs = {
+            ...STACK_SIGNATURES,
+            frameworks: {
+                ...STACK_SIGNATURES.frameworks,
+                rails: { indicators: [], dependencies: ['rails'] },
+            },
+        };
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', railsSigs, ARCH_PATTERNS);
+        expect(result.framework).toBe('rails');
+    });
+    it('should collect dependencies from Cargo.toml', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('Cargo.toml')) {
+                return '[package]\nname = "myapp"\n\n[dependencies]\nactix-web = "4"\nserde = { version = "1" }';
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const rustSigs = {
+            ...STACK_SIGNATURES,
+            frameworks: {
+                ...STACK_SIGNATURES.frameworks,
+                actix: { indicators: [], dependencies: ['actix-web'] },
+            },
+        };
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', rustSigs, ARCH_PATTERNS);
+        expect(result.framework).toBe('actix');
+    });
+    it('should collect dependencies from composer.json', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('composer.json')) {
+                return JSON.stringify({
+                    require: { 'laravel/framework': '^10.0' },
+                    'require-dev': { 'phpunit/phpunit': '^10.0' },
+                });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const phpSigs = {
+            ...STACK_SIGNATURES,
+            frameworks: {
+                ...STACK_SIGNATURES.frameworks,
+                laravel: { indicators: [], dependencies: ['laravel/framework'] },
+            },
+        };
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', phpSigs, ARCH_PATTERNS);
+        expect(result.framework).toBe('laravel');
+    });
+    it('should infer env variable services correctly', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('.env.example')) {
+                return [
+                    'SUPABASE_URL=',
+                    'STRIPE_KEY=',
+                    'FIREBASE_API_KEY=',
+                    'AWS_ACCESS_KEY=',
+                    'DATABASE_URL=',
+                    'REDIS_URL=',
+                    'SENTRY_DSN=',
+                    'GITHUB_TOKEN=',
+                    'OPENAI_API_KEY=',
+                    'ANTHROPIC_KEY=',
+                    'APP_PORT=',
+                    'DB_HOST=',
+                ].join('\n');
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        const vars = result.envSetup.variables;
+        expect(vars.find((v) => v.name === 'SUPABASE_URL')?.service).toBe('supabase');
+        expect(vars.find((v) => v.name === 'STRIPE_KEY')?.service).toBe('stripe');
+        expect(vars.find((v) => v.name === 'FIREBASE_API_KEY')?.service).toBe('firebase');
+        expect(vars.find((v) => v.name === 'AWS_ACCESS_KEY')?.service).toBe('aws');
+        expect(vars.find((v) => v.name === 'DATABASE_URL')?.service).toBe('database');
+        expect(vars.find((v) => v.name === 'REDIS_URL')?.service).toBe('redis');
+        expect(vars.find((v) => v.name === 'SENTRY_DSN')?.service).toBe('sentry');
+        expect(vars.find((v) => v.name === 'GITHUB_TOKEN')?.service).toBe('github');
+        expect(vars.find((v) => v.name === 'OPENAI_API_KEY')?.service).toBe('ai');
+        expect(vars.find((v) => v.name === 'ANTHROPIC_KEY')?.service).toBe('ai');
+        expect(vars.find((v) => v.name === 'APP_PORT')?.service).toBe('app');
+        expect(vars.find((v) => v.name === 'DB_HOST')?.service).toBe('database');
+    });
+    it('should parse .env.local.example as fallback', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('.env.example')) {
+                throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+            }
+            if (p.endsWith('.env.local.example')) {
+                return 'SECRET_KEY=abc';
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.envSetup.variables.length).toBeGreaterThan(0);
+    });
+    it('should fallback detect language by file extensions when no signature files match', async () => {
+        mockedGlob.mockImplementation(((pattern, opts) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === '**/*' && opts && typeof opts === 'object') {
+                return ['main.py', 'utils.py', 'test.py'];
+            }
+            return [];
+        }));
+        const minimalSigs = {
+            languages: {
+                python: { files: [], extensions: ['.py'] },
+            },
+            frameworks: {},
+            packageManagers: {},
+            databases: {},
+        };
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', minimalSigs, ARCH_PATTERNS);
+        expect(result.language).toBe('python');
+    });
+    it('should return "unknown" language when nothing matches', async () => {
+        const emptySigs = {
+            languages: {},
+            frameworks: {},
+            packageManagers: {},
+            databases: {},
+        };
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', emptySigs, ARCH_PATTERNS);
+        expect(result.language).toBe('unknown');
+    });
+    it('should return null framework when none detected', async () => {
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.framework).toBeNull();
+    });
+    it('should return null package manager when none detected', async () => {
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.packageManager).toBeNull();
+    });
+    it('should score architecture patterns from file indicators', async () => {
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'docker-compose.yml') {
+                return ['docker-compose.yml'];
+            }
+            return [];
+        }));
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({ dependencies: { '@nestjs/microservices': '10.0.0' } });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/project', 'proj-1', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        // microservices pattern should score higher
+        expect(result.architecture.primary).toBeDefined();
+    });
+});
+// =============================================================================
+// quickAnalyze
+// =============================================================================
+describe('quickAnalyze', () => {
+    it('should return language, framework, packageManager, database', async () => {
+        setupFileExists(['tsconfig.json', 'package-lock.json']);
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'tsconfig.json') {
+                return ['tsconfig.json'];
+            }
+            return [];
+        }));
+        const result = await quickAnalyze('/tmp/project');
+        expect(result).toHaveProperty('language');
+        expect(result).toHaveProperty('framework');
+        expect(result).toHaveProperty('packageManager');
+        expect(result).toHaveProperty('database');
+    });
+    it('should return unknown values for empty project', async () => {
+        const result = await quickAnalyze('/tmp/empty-project');
+        expect(result.language).toBe('unknown');
+        expect(result.framework).toBeNull();
+        expect(result.packageManager).toBeNull();
+        expect(result.database).toBe('unknown');
+    });
+});
+// =============================================================================
+// checkProjectCompleteness
+// =============================================================================
+describe('checkProjectCompleteness', () => {
+    it('should return completeness score of 0 for empty project', async () => {
+        const result = await checkProjectCompleteness('/tmp/empty-project');
+        expect(result.completenessScore).toBe(0);
+        expect(result.hasReadme).toBe(false);
+        expect(result.hasGitignore).toBe(false);
+        expect(result.hasLicense).toBe(false);
+    });
+    it('should return higher score when files exist', async () => {
+        setupFileExists(['README.md', '.gitignore', 'LICENSE']);
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === '.eslintrc*' || p === 'eslint.config.*') {
+                return ['.eslintrc.js'];
+            }
+            if (p === '.prettierrc*' || p === 'biome.json' || p === '.editorconfig') {
+                return ['.prettierrc'];
+            }
+            if (p === 'vitest.config.*' || p === 'jest.config.*') {
+                return ['vitest.config.ts'];
+            }
+            return [];
+        }));
+        const result = await checkProjectCompleteness('/tmp/project');
+        expect(result.hasReadme).toBe(true);
+        expect(result.hasGitignore).toBe(true);
+        expect(result.hasLicense).toBe(true);
+        expect(result.hasLinting).toBe(true);
+        expect(result.hasFormatting).toBe(true);
+        expect(result.hasTesting).toBe(true);
+        expect(result.completenessScore).toBeGreaterThan(0);
+    });
+    it('should detect .env.example', async () => {
+        setupFileExists(['.env.example']);
+        const result = await checkProjectCompleteness('/tmp/project');
+        expect(result.hasEnvExample).toBe(true);
+    });
+    it('should detect .env.local.example as fallback for env example', async () => {
+        setupFileExists(['.env.local.example']);
+        const result = await checkProjectCompleteness('/tmp/project');
+        expect(result.hasEnvExample).toBe(true);
+    });
+    it('should detect CI/CD from github workflows', async () => {
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === '.github/workflows/*') {
+                return ['.github/workflows/ci.yml'];
+            }
+            return [];
+        }));
+        const result = await checkProjectCompleteness('/tmp/project');
+        expect(result.hasCiCd).toBe(true);
+    });
+    it('should detect type checking from tsconfig.json', async () => {
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'tsconfig.json') {
+                return ['tsconfig.json'];
+            }
+            return [];
+        }));
+        const result = await checkProjectCompleteness('/tmp/project');
+        expect(result.hasTypeChecking).toBe(true);
+    });
+    it('should detect editorconfig', async () => {
+        setupFileExists(['.editorconfig']);
+        const result = await checkProjectCompleteness('/tmp/project');
+        expect(result.hasEditorConfig).toBe(true);
+    });
+    it('should detect contributing guide', async () => {
+        setupFileExists(['CONTRIBUTING.md']);
+        const result = await checkProjectCompleteness('/tmp/project');
+        expect(result.hasContributing).toBe(true);
+    });
+    it('should return all 20 completeness fields', async () => {
+        const result = await checkProjectCompleteness('/tmp/project');
+        expect(result).toHaveProperty('hasReadme');
+        expect(result).toHaveProperty('hasGitignore');
+        expect(result).toHaveProperty('hasEnvExample');
+        expect(result).toHaveProperty('hasLicense');
+        expect(result).toHaveProperty('hasEditorConfig');
+        expect(result).toHaveProperty('hasLinting');
+        expect(result).toHaveProperty('hasFormatting');
+        expect(result).toHaveProperty('hasTesting');
+        expect(result).toHaveProperty('hasCiCd');
+        expect(result).toHaveProperty('hasErrorTracking');
+        expect(result).toHaveProperty('hasTypeChecking');
+        expect(result).toHaveProperty('hasSecurityScanning');
+        expect(result).toHaveProperty('hasDocumentation');
+        expect(result).toHaveProperty('hasContributing');
+        expect(result).toHaveProperty('hasChangelogStrategy');
+        expect(result).toHaveProperty('hasBackupStrategy');
+        expect(result).toHaveProperty('hasAccessibility');
+        expect(result).toHaveProperty('hasSeo');
+        expect(result).toHaveProperty('hasPerformanceBudget');
+        expect(result).toHaveProperty('hasSeedData');
+        expect(result).toHaveProperty('completenessScore');
+    });
+    it('should calculate 100% completeness score when all checks pass', async () => {
+        // Make everything exist
+        setupFileExists([
+            'README.md',
+            '.gitignore',
+            '.env.example',
+            'LICENSE',
+            '.editorconfig',
+            'CONTRIBUTING.md',
+        ]);
+        mockedGlob.mockResolvedValue(['match']);
+        const result = await checkProjectCompleteness('/tmp/project');
+        expect(result.completenessScore).toBe(100);
+    });
+});
+// =============================================================================
+// hasAnyFile — positive path (glob finds matches → returns true)
+// =============================================================================
+describe('hasAnyFile positive path', () => {
+    it('should return true for completeness checks when glob matches files', async () => {
+        // Mock glob to return matches for specific patterns used by checkProjectCompleteness
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === '.eslintrc*' || p === 'eslint.config.*') {
+                return ['.eslintrc.js'];
+            }
+            if (p === '.prettierrc*') {
+                return ['.prettierrc'];
+            }
+            if (p === 'vitest.config.*' || p === 'jest.config.*') {
+                return ['vitest.config.ts'];
+            }
+            if (p === '.github/workflows/*') {
+                return ['.github/workflows/ci.yml'];
+            }
+            if (p === 'tsconfig.json') {
+                return ['tsconfig.json'];
+            }
+            if (p === 'docs/**/*.md') {
+                return ['docs/guide.md'];
+            }
+            if (p === 'CHANGELOG.md') {
+                return ['CHANGELOG.md'];
+            }
+            if (p === 'robots.txt') {
+                return ['robots.txt'];
+            }
+            if (p === 'lighthouse*') {
+                return ['lighthouse.config.js'];
+            }
+            if (p === 'seed.*' || p === 'seeds/*') {
+                return ['seed.ts'];
+            }
+            return [];
+        }));
+        setupFileExists([
+            'README.md',
+            '.gitignore',
+            '.env.example',
+            'LICENSE',
+            '.editorconfig',
+            'CONTRIBUTING.md',
+        ]);
+        const result = await checkProjectCompleteness('/tmp/project');
+        expect(result.hasLinting).toBe(true);
+        expect(result.hasFormatting).toBe(true);
+        expect(result.hasTesting).toBe(true);
+        expect(result.hasCiCd).toBe(true);
+        expect(result.hasTypeChecking).toBe(true);
+        expect(result.hasDocumentation).toBe(true);
+        expect(result.completenessScore).toBeGreaterThan(50);
+    });
+    it('should return false for completeness checks when glob returns empty arrays', async () => {
+        mockedGlob.mockResolvedValue([]);
+        const result = await checkProjectCompleteness('/tmp/empty-project');
+        expect(result.hasLinting).toBe(false);
+        expect(result.hasFormatting).toBe(false);
+        expect(result.hasTesting).toBe(false);
+        expect(result.hasCiCd).toBe(false);
+    });
+    it('should handle glob errors in hasAnyFile gracefully (catch block)', async () => {
+        mockedGlob.mockRejectedValue(new Error('glob failed'));
+        const result = await checkProjectCompleteness('/tmp/broken-project');
+        expect(result.hasLinting).toBe(false);
+        expect(result.hasFormatting).toBe(false);
+        expect(result.completenessScore).toBe(0);
+    });
+});
+// =============================================================================
+// loadStackSignatures / loadArchPatterns — catch blocks (fallback paths)
+// =============================================================================
+describe('loadStackSignatures and loadArchPatterns fallback', () => {
+    it('quickAnalyze falls back to empty signatures when config file fails to load', async () => {
+        // The default beforeEach mocks readFile to reject with ENOENT for ALL paths,
+        // so loadStackSignatures() will hit its catch block and return the fallback.
+        // With empty signatures, detection returns "unknown" / null.
+        const result = await quickAnalyze('/tmp/no-config-project');
+        expect(result.language).toBe('unknown');
+        expect(result.framework).toBeNull();
+        expect(result.packageManager).toBeNull();
+        expect(result.database).toBe('unknown');
+    });
+    it('analyzeProject falls back when called without explicit signatures', async () => {
+        // Call analyzeProject WITHOUT passing stackSignatures and archPatterns
+        // so it invokes loadStackSignatures() and loadArchPatterns() internally.
+        // Both will fail (readFile rejects) and use fallback values.
+        const result = await analyzeProject('/tmp/fallback-project', 'proj-fallback', 'en');
+        expect(result.projectId).toBe('proj-fallback');
+        expect(result.language).toBe('unknown');
+        expect(result.framework).toBeNull();
+        expect(result.architecture).toBeDefined();
+        expect(result.architecture.primary).toBeDefined();
+    });
+    it('loadStackSignatures succeeds when readFile returns valid JSON', async () => {
+        // Make readFile succeed for the config path with valid JSON
+        mockedReadFile.mockImplementation(((path) => {
+            const p = String(path);
+            if (p.includes('stack-signatures.json')) {
+                return Promise.resolve(JSON.stringify({
+                    languages: { ruby: { files: ['Gemfile'], extensions: ['.rb'] } },
+                    frameworks: {},
+                    packageManagers: {},
+                    databases: {},
+                }));
+            }
+            return Promise.reject(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+        }));
+        // hasAnyFile uses glob to check for files; return match for Gemfile
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'Gemfile') {
+                return ['Gemfile'];
+            }
+            return [];
+        }));
+        const result = await quickAnalyze('/tmp/ruby-project');
+        expect(result.language).toBe('ruby');
+    });
+    it('loadArchPatterns succeeds when readFile returns valid JSON', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = String(path);
+            if (p.includes('stack-signatures.json')) {
+                return Promise.resolve(JSON.stringify({
+                    languages: {},
+                    frameworks: {},
+                    packageManagers: {},
+                    databases: {},
+                }));
+            }
+            if (p.includes('architecture-patterns.json')) {
+                return Promise.resolve(JSON.stringify({
+                    patterns: {
+                        'custom-arch': {
+                            name: 'Custom Arch',
+                            indicators: { directories: ['src/custom/'] },
+                        },
+                    },
+                }));
+            }
+            return Promise.reject(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+        }));
+        mockedGlob.mockResolvedValue([]);
+        // Call analyzeProject without explicit archPatterns to trigger loadArchPatterns
+        const result = await analyzeProject('/tmp/arch-project', 'proj-arch', 'en');
+        expect(result.architecture).toBeDefined();
+    });
+    it('loadStackSignatures returns fallback when JSON is malformed', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = String(path);
+            if (p.includes('stack-signatures.json')) {
+                return Promise.resolve('not-valid-json{{{');
+            }
+            if (p.includes('architecture-patterns.json')) {
+                return Promise.resolve('also-not-valid{');
+            }
+            return Promise.reject(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+        }));
+        const result = await quickAnalyze('/tmp/malformed-config');
+        // With fallback (empty) signatures, nothing is detected
+        expect(result.language).toBe('unknown');
+        expect(result.framework).toBeNull();
+    });
+    it('loadArchPatterns returns fallback when JSON is malformed', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = String(path);
+            if (p.includes('stack-signatures.json')) {
+                return Promise.resolve(JSON.stringify({
+                    languages: {},
+                    frameworks: {},
+                    packageManagers: {},
+                    databases: {},
+                }));
+            }
+            if (p.includes('architecture-patterns.json')) {
+                return Promise.resolve('{invalid json!!}');
+            }
+            return Promise.reject(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+        }));
+        // Call without explicit archPatterns to trigger loadArchPatterns
+        const result = await analyzeProject('/tmp/bad-arch-config', 'proj-bad-arch', 'en');
+        // Architecture should still work with fallback patterns
+        expect(result.architecture).toBeDefined();
+        expect(result.architecture.primary).toBeDefined();
+    });
+});
+// =============================================================================
+// detectProjectType — mobile framework branch
+// =============================================================================
+describe('detectProjectType — mobile framework', () => {
+    it('should return "mobile" when framework is react-native', async () => {
+        setupFileExists(['tsconfig.json', 'package-lock.json']);
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({ dependencies: { 'react-native': '0.72.0' } });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const sigs = {
+            ...STACK_SIGNATURES,
+            frameworks: {
+                ...STACK_SIGNATURES.frameworks,
+                'react-native': { indicators: [], dependencies: ['react-native'] },
+            },
+        };
+        const result = await analyzeProject('/tmp/mobile-project', 'proj-mobile', 'en', 'intermediate', sigs, ARCH_PATTERNS);
+        expect(result.framework).toBe('react-native');
+    });
+    it('should return "mobile" when framework is expo', async () => {
+        setupFileExists(['tsconfig.json', 'package-lock.json']);
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('package.json')) {
+                return JSON.stringify({ dependencies: { expo: '49.0.0' } });
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/expo-project', 'proj-expo', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.framework).toBe('expo');
+    });
+    it('should return "mobile" when framework is flutter', async () => {
+        const flutterSigs = {
+            ...STACK_SIGNATURES,
+            languages: {
+                ...STACK_SIGNATURES.languages,
+                dart: { files: ['pubspec.yaml'], extensions: ['.dart'] },
+            },
+            frameworks: {
+                ...STACK_SIGNATURES.frameworks,
+                flutter: { indicators: ['pubspec.yaml'], dependencies: ['flutter'] },
+            },
+        };
+        setupFileExists(['pubspec.yaml']);
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] : pattern;
+            if (p === 'pubspec.yaml') {
+                return ['pubspec.yaml'];
+            }
+            return [];
+        }));
+        const result = await analyzeProject('/tmp/flutter-project', 'proj-flutter', 'en', 'intermediate', flutterSigs, ARCH_PATTERNS);
+        expect(result.framework).toBe('flutter');
+    });
+});
+// =============================================================================
+// parseEnvFile — line with no = sign
+// =============================================================================
+describe('parseEnvFile — skip lines without equals sign', () => {
+    it('should skip .env lines that have no = sign', async () => {
+        mockedReadFile.mockImplementation(((path) => {
+            const p = path;
+            if (p.endsWith('.env.example')) {
+                return 'VALID_KEY=some_value\nINVALID_LINE_NO_EQUALS\nANOTHER_KEY=value2\n';
+            }
+            throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+        }));
+        const result = await analyzeProject('/tmp/env-test', 'proj-env', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        // Only 2 vars should be parsed (the one without = is skipped)
+        expect(result.envSetup.variables).toHaveLength(2);
+        expect(result.envSetup.variables.map((v) => v.name)).toContain('VALID_KEY');
+        expect(result.envSetup.variables.map((v) => v.name)).toContain('ANOTHER_KEY');
+    });
+});
+// =============================================================================
+// detectEnvironments — .env.test file exists
+// =============================================================================
+describe('detectEnvironments — test environment', () => {
+    it('should detect test environment when .env.test exists', async () => {
+        setupFileExists(['.env.staging', '.env.test', '.env.production']);
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] ?? '' : pattern;
+            if (p === '.env.staging' || p === '.env.test' || p === '.env.production') {
+                return Promise.resolve([p]);
+            }
+            return Promise.resolve([]);
+        }));
+        const result = await analyzeProject('/tmp/env-envs', 'proj-envs', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.environments).toContain('development');
+        expect(result.environments).toContain('test');
+        expect(result.environments).toContain('staging');
+        expect(result.environments).toContain('production');
+    });
+    it('should detect only test environment when only .env.test exists', async () => {
+        setupFileExists(['.env.test']);
+        mockedGlob.mockImplementation(((pattern) => {
+            const p = Array.isArray(pattern) ? pattern[0] ?? '' : pattern;
+            if (p === '.env.test') {
+                return Promise.resolve([p]);
+            }
+            return Promise.resolve([]);
+        }));
+        const result = await analyzeProject('/tmp/env-test-only', 'proj-envs2', 'en', 'intermediate', STACK_SIGNATURES, ARCH_PATTERNS);
+        expect(result.environments).toContain('development');
+        expect(result.environments).toContain('test');
+        expect(result.environments).not.toContain('staging');
+        expect(result.environments).not.toContain('production');
+    });
+});
+//# sourceMappingURL=analyzer.test.js.map