@girardelli/architect-agents 8.1.0

package/dist/tests/context-enricher.test.js

@@ -0,0 +1,875 @@
+import { ContextEnricher } from '../src/core/agent-generator/context-enricher.js';
+import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+// ── Test Data Factories ──
+function makeReport(overrides = {}) {
+    return {
+        timestamp: new Date().toISOString(),
+        projectInfo: {
+            path: '/test',
+            name: 'test-project',
+            frameworks: ['NestJS'],
+            totalFiles: 50,
+            totalLines: 5000,
+            primaryLanguages: ['TypeScript'],
+        },
+        score: {
+            overall: 72,
+            components: [],
+            breakdown: { modularity: 80, coupling: 65, cohesion: 70, layering: 75 },
+        },
+        antiPatterns: [
+            {
+                name: 'God Class',
+                severity: 'CRITICAL',
+                location: 'src/AppService.ts',
+                description: 'Class with 800 lines',
+                suggestion: 'Split into smaller services',
+                affectedFiles: ['src/AppService.ts'],
+            },
+        ],
+        layers: [
+            { name: 'API', files: ['src/controller.ts'], description: 'API layer' },
+            { name: 'Service', files: ['src/service.ts'], description: 'Service layer' },
+        ],
+        dependencyGraph: {
+            nodes: ['src/app.module.ts', 'src/app.controller.ts', 'src/app.service.ts', 'src/entity/user.entity.ts'],
+            edges: [
+                { from: 'src/app.controller.ts', to: 'src/app.service.ts', type: 'import', weight: 1 },
+                { from: 'src/app.service.ts', to: 'src/entity/user.entity.ts', type: 'import', weight: 1 },
+            ],
+        },
+        suggestions: [],
+        diagram: { mermaid: '', type: 'layer' },
+        ...overrides,
+    };
+}
+function makePlan(overrides = {}) {
+    return {
+        timestamp: new Date().toISOString(),
+        projectPath: '/test',
+        currentScore: {
+            overall: 72,
+            components: [],
+            breakdown: { modularity: 80, coupling: 65, cohesion: 70, layering: 75 },
+        },
+        estimatedScoreAfter: { overall: 82, breakdown: { modularity: 85, coupling: 75, cohesion: 80, layering: 80 } },
+        steps: [
+            {
+                id: 1,
+                tier: 1,
+                rule: 'hub-splitter',
+                priority: 'HIGH',
+                title: 'Split AppService',
+                description: 'Split monolith service',
+                rationale: 'Reduce coupling',
+                operations: [],
+                scoreImpact: [{ metric: 'modularity', before: 80, after: 85 }],
+            },
+        ],
+        totalOperations: 1,
+        tier1Steps: 1,
+        tier2Steps: 0,
+        ...overrides,
+    };
+}
+// ── Test Suite ──
+describe('ContextEnricher', () => {
+    const enricher = new ContextEnricher();
+    let tempDir;
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(process.cwd(), '__test_context_'));
+    });
+    afterEach(() => {
+        if (tempDir) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe('enrich()', () => {
+        it('should return a valid EnrichedTemplateContext', () => {
+            const report = makeReport();
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            expect(result).toBeDefined();
+            expect(result.report).toBe(report);
+            expect(result.plan).toBe(plan);
+            expect(result.projectName).toBe('test-project');
+            expect(result.modules).toBeDefined();
+            expect(result.endpoints).toBeDefined();
+            expect(result.untestedModules).toBeDefined();
+            expect(result.criticalPaths).toBeDefined();
+            expect(result.projectDepth).toBeDefined();
+        });
+        it('should detect modules from dependency graph nodes', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/users/users.controller.ts',
+                        'src/modules/users/users.service.ts',
+                        'src/modules/users/user.entity.ts',
+                        'src/modules/auth/auth.controller.ts',
+                        'src/modules/auth/auth.service.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            expect(result.modules.length).toBeGreaterThan(0);
+            const moduleNames = result.modules.map(m => m.name);
+            expect(moduleNames).toContain('users');
+            expect(moduleNames).toContain('auth');
+        });
+        it('should extract modules sorted by file count descending', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/users/users.controller.ts',
+                        'src/modules/users/users.service.ts',
+                        'src/modules/users/user.entity.ts',
+                        'src/modules/auth/auth.controller.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            // Users has 3 files, auth has 1 file → users should come first
+            expect(result.modules[0].name).toBe('users');
+            expect(result.modules[0].fileCount).toBe(3);
+        });
+        it('should generate smart descriptions for known patterns', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/extractors/pdf.extractor.ts',
+                        'src/modules/extractors/image.extractor.ts',
+                        'src/modules/ocr/ocr.service.ts',
+                        'src/modules/guards/auth.guard.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const extractorsModule = result.modules.find(m => m.name === 'extractors');
+            expect(extractorsModule).toBeDefined();
+            expect(extractorsModule.description).toContain('Extração');
+            const ocrModule = result.modules.find(m => m.name === 'ocr');
+            expect(ocrModule).toBeDefined();
+            expect(ocrModule.description).toContain('OCR');
+            const guardsModule = result.modules.find(m => m.name === 'guards');
+            expect(guardsModule).toBeDefined();
+            expect(guardsModule.description).toContain('Validação');
+        });
+        it('should count lines for real files', () => {
+            // Create a temp file with 10 lines
+            const subdir = join(tempDir, 'src', 'modules', 'test');
+            mkdirSync(subdir, { recursive: true });
+            const filePath = join(subdir, 'test.ts');
+            const content = Array(10).fill('console.log("test");').join('\n');
+            writeFileSync(filePath, content);
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: ['src/modules/test/test.ts'],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const testModule = result.modules.find(m => m.name === 'test');
+            expect(testModule).toBeDefined();
+            expect(testModule.lineCount).toBeGreaterThan(0);
+        });
+        it('should detect test files in modules', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/users/users.service.ts',
+                        'src/modules/users/users.service.test.ts',
+                        'src/modules/users/__tests__/users.spec.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const usersModule = result.modules.find(m => m.name === 'users');
+            expect(usersModule).toBeDefined();
+            expect(usersModule.hasTests).toBe(true);
+            expect(usersModule.testFiles.length).toBe(2);
+        });
+        it('should extract endpoints from route/controller files', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/users/users.controller.ts',
+                        'src/modules/users/users.service.ts',
+                        'src/auth/auth.controller.ts',
+                        'src/health/health.controller.ts',
+                    ],
+                    edges: [
+                        { from: 'src/modules/users/users.controller.ts', to: 'src/modules/users/users.service.ts', type: 'import', weight: 1 },
+                        { from: 'src/auth/auth.controller.ts', to: 'src/dependencies/auth.guard.ts', type: 'import', weight: 1 },
+                    ],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            expect(result.endpoints.length).toBeGreaterThan(0);
+            // Should detect users endpoints
+            const userEndpoints = result.endpoints.filter(e => e.path.includes('users'));
+            expect(userEndpoints.length).toBeGreaterThan(0);
+        });
+        it('should detect endpoints with authentication', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/auth/auth.controller.ts',
+                        'src/dependencies/auth.guard.ts',
+                    ],
+                    edges: [
+                        { from: 'src/auth/auth.controller.ts', to: 'src/dependencies/auth.guard.ts', type: 'import', weight: 1 },
+                    ],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const authEndpoints = result.endpoints.filter(e => e.path.includes('auth'));
+            expect(authEndpoints.length).toBeGreaterThan(0);
+            // Auth endpoints should be marked as no auth (login/register are public)
+            const loginEndpoint = authEndpoints.find(e => e.path === '/auth/login');
+            expect(loginEndpoint).toBeDefined();
+            expect(loginEndpoint.hasAuth).toBe(false);
+        });
+        it('should detect untested modules', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/users/users.service.ts',
+                        'src/modules/users/users.controller.ts',
+                        'src/modules/notested/service.ts',
+                        'src/modules/notested/handler.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            expect(result.untestedModules).toContain('notested');
+        });
+        it('should identify critical paths (files with high coupling)', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/app.module.ts',
+                        'src/app.controller.ts',
+                        'src/app.service.ts',
+                        'src/users/user.service.ts',
+                        'src/auth/auth.service.ts',
+                    ],
+                    edges: [
+                        { from: 'src/app.module.ts', to: 'src/app.controller.ts', type: 'import', weight: 1 },
+                        { from: 'src/app.module.ts', to: 'src/app.service.ts', type: 'import', weight: 1 },
+                        { from: 'src/app.module.ts', to: 'src/users/user.service.ts', type: 'import', weight: 1 },
+                        { from: 'src/app.module.ts', to: 'src/auth/auth.service.ts', type: 'import', weight: 1 },
+                        { from: 'src/app.controller.ts', to: 'src/app.service.ts', type: 'import', weight: 1 },
+                    ],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            expect(result.criticalPaths.length).toBeGreaterThan(0);
+            // app.module.ts should be in critical paths (4 edges)
+            expect(result.criticalPaths).toContain('src/app.module.ts');
+        });
+        it('should classify project depth as small', () => {
+            const report = makeReport({
+                projectInfo: {
+                    path: '/test',
+                    name: 'small-project',
+                    frameworks: ['NestJS'],
+                    totalFiles: 10,
+                    totalLines: 1000,
+                    primaryLanguages: ['TypeScript'],
+                },
+                dependencyGraph: {
+                    nodes: [],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            expect(result.projectDepth).toBe('small');
+        });
+        it('should classify project depth as medium', () => {
+            const report = makeReport({
+                projectInfo: {
+                    path: '/test',
+                    name: 'medium-project',
+                    frameworks: ['NestJS'],
+                    totalFiles: 150,
+                    totalLines: 30000,
+                    primaryLanguages: ['TypeScript'],
+                },
+                dependencyGraph: {
+                    nodes: [],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            expect(result.projectDepth).toBe('medium');
+        });
+        it('should classify project depth as large', () => {
+            const report = makeReport({
+                projectInfo: {
+                    path: '/test',
+                    name: 'large-project',
+                    frameworks: ['NestJS'],
+                    totalFiles: 300,
+                    totalLines: 70000,
+                    primaryLanguages: ['TypeScript'],
+                },
+                dependencyGraph: {
+                    nodes: [],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            expect(result.projectDepth).toBe('large');
+        });
+        it('should classify project depth as enterprise', () => {
+            const report = makeReport({
+                projectInfo: {
+                    path: '/test',
+                    name: 'enterprise-project',
+                    frameworks: ['NestJS'],
+                    totalFiles: 1000,
+                    totalLines: 150000,
+                    primaryLanguages: ['TypeScript'],
+                },
+                dependencyGraph: {
+                    nodes: [],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            expect(result.projectDepth).toBe('enterprise');
+        });
+    });
+    describe('Module inference strategies', () => {
+        it('should infer module name from explicit module markers', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/users/users.service.ts',
+                        'src/modules/auth/auth.service.ts',
+                        'src/features/notifications/notifier.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const moduleNames = result.modules.map(m => m.name);
+            expect(moduleNames).toContain('users');
+            expect(moduleNames).toContain('auth');
+            expect(moduleNames).toContain('notifications');
+        });
+        it('should infer module name from Django app pattern', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'apps/users/views.py',
+                        'apps/users/models.py',
+                        'apps/posts/views.py',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'Python',
+                languages: ['Python'],
+                frameworks: ['Django'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'pytest',
+                packageManager: 'pip',
+            }, tempDir);
+            const moduleNames = result.modules.map(m => m.name);
+            expect(moduleNames).toContain('users');
+            expect(moduleNames).toContain('posts');
+        });
+        it('should infer module name from clean architecture layers', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/domain/entities/user.entity.ts',
+                        'src/application/services/user.service.ts',
+                        'src/infrastructure/persistence/user.repository.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            // Should infer modules related to user entity
+            expect(result.modules.length).toBeGreaterThan(0);
+        });
+        it('should handle Java package structure', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/main/java/com/example/users/User.java',
+                        'src/main/java/com/example/users/UserService.java',
+                        'src/main/java/com/example/auth/AuthService.java',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'Java',
+                languages: ['Java'],
+                frameworks: ['Spring Boot'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'JUnit',
+                packageManager: 'maven',
+            }, tempDir);
+            const moduleNames = result.modules.map(m => m.name);
+            expect(moduleNames.length).toBeGreaterThan(0);
+        });
+    });
+    describe('Entity and controller detection', () => {
+        it('should detect entity files', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/users/entities/user.entity.ts',
+                        'src/modules/users/models/user.model.ts',
+                        'src/modules/users/user.service.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const usersModule = result.modules.find(m => m.name === 'users');
+            expect(usersModule).toBeDefined();
+            expect(usersModule.entities.length).toBeGreaterThan(0);
+            expect(usersModule.entities.some(e => e.includes('User'))).toBe(true);
+        });
+        it('should detect controller files', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/users/users.controller.ts',
+                        'src/modules/auth/auth.controller.ts',
+                        'src/modules/users/users.service.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const usersModule = result.modules.find(m => m.name === 'users');
+            expect(usersModule).toBeDefined();
+            expect(usersModule.controllers.length).toBeGreaterThan(0);
+        });
+        it('should detect service files', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/users/users.service.ts',
+                        'src/modules/auth/auth.service.ts',
+                        'src/modules/users/users.controller.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const usersModule = result.modules.find(m => m.name === 'users');
+            expect(usersModule).toBeDefined();
+            expect(usersModule.services.length).toBeGreaterThan(0);
+        });
+    });
+    describe('Smart descriptions for patterns', () => {
+        it('should generate description for routes/controllers', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: ['src/modules/routes/app.routes.ts'],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const routesModule = result.modules.find(m => m.name === 'routes');
+            expect(routesModule).toBeDefined();
+            expect(routesModule.description).toContain('rotas');
+        });
+        it('should generate description for services', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: ['src/modules/services/payment.service.ts'],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const servicesModule = result.modules.find(m => m.name === 'services');
+            expect(servicesModule).toBeDefined();
+            expect(servicesModule.description).toContain('Serviços');
+        });
+        it('should generate description for auth modules', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: ['src/modules/auth/auth.service.ts'],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const authModule = result.modules.find(m => m.name === 'auth');
+            expect(authModule).toBeDefined();
+            expect(authModule.description.toLowerCase()).toContain('autenticação');
+        });
+        it('should include composition info in descriptions', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: [
+                        'src/modules/users/users.controller.ts',
+                        'src/modules/users/users.service.ts',
+                        'src/modules/users/entities/user.entity.ts',
+                    ],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const usersModule = result.modules.find(m => m.name === 'users');
+            expect(usersModule).toBeDefined();
+            // Should include composition info (endpoints, services, entities)
+            expect(usersModule.description).toMatch(/endpoint|service|entit/i);
+        });
+    });
+    describe('Line counting edge cases', () => {
+        it('should handle missing files gracefully', () => {
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: ['src/nonexistent/file.ts'],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            // Should not crash, modules should exist
+            expect(result.modules).toBeDefined();
+        });
+        it('should handle empty files', () => {
+            const subdir = join(tempDir, 'src', 'modules', 'empty');
+            mkdirSync(subdir, { recursive: true });
+            const filePath = join(subdir, 'empty.ts');
+            writeFileSync(filePath, '');
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: ['src/modules/empty/empty.ts'],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const emptyModule = result.modules.find(m => m.name === 'empty');
+            expect(emptyModule).toBeDefined();
+            expect(emptyModule.lineCount).toBe(0);
+        });
+        it('should count lines in files with various line endings', () => {
+            const subdir = join(tempDir, 'src', 'modules', 'mixed');
+            mkdirSync(subdir, { recursive: true });
+            const filePath = join(subdir, 'mixed.ts');
+            // 5 lines
+            writeFileSync(filePath, 'line1\nline2\nline3\nline4\nline5');
+            const report = makeReport({
+                dependencyGraph: {
+                    nodes: ['src/modules/mixed/mixed.ts'],
+                    edges: [],
+                },
+            });
+            const plan = makePlan();
+            const result = enricher.enrich(report, plan, {
+                primary: 'TypeScript',
+                languages: ['TypeScript'],
+                frameworks: ['NestJS'],
+                hasBackend: true,
+                hasFrontend: false,
+                hasMobile: false,
+                hasDatabase: true,
+                testFramework: 'Jest',
+                packageManager: 'npm',
+            }, tempDir);
+            const mixedModule = result.modules.find(m => m.name === 'mixed');
+            expect(mixedModule).toBeDefined();
+            expect(mixedModule.lineCount).toBeGreaterThan(0);
+        });
+    });
+});
+//# sourceMappingURL=context-enricher.test.js.map