@planu/cli 0.89.0 → 0.90.1

package/dist/tools/generate-execution-plan.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-execution-plan.test.d.ts.map

package/dist/tools/generate-execution-plan.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-execution-plan.test.d.ts","sourceRoot":"","sources":["../../src/tools/generate-execution-plan.test.ts"],"names":[],"mappings":""}

package/dist/tools/generate-execution-plan.test.js

@@ -0,0 +1,643 @@
+// Tests for handleGenerateExecutionPlan
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('../i18n/index.js', () => ({
+    t: (key) => key,
+    ti: (key, vars) => `${key}:${JSON.stringify(vars)}`,
+}));
+vi.mock('../storage/index.js', () => ({
+    specStore: { getSpec: vi.fn() },
+    knowledgeStore: { getKnowledge: vi.fn() },
+    patternStore: { listPatterns: vi.fn() },
+}));
+vi.mock('node:fs/promises', () => ({
+    readFile: vi.fn(),
+}));
+import { handleGenerateExecutionPlan } from './generate-execution-plan.js';
+import { specStore, knowledgeStore, patternStore } from '../storage/index.js';
+import { readFile } from 'node:fs/promises';
+const mockGetSpec = vi.mocked(specStore.getSpec);
+const mockGetKnowledge = vi.mocked(knowledgeStore.getKnowledge);
+const mockListPatterns = vi.mocked(patternStore.listPatterns);
+const mockReadFile = vi.mocked(readFile);
+const baseSpec = {
+    id: 'SPEC-001',
+    slug: 'user-auth',
+    title: 'User Authentication',
+    type: 'feature',
+    scope: 'feature',
+    target: 'fullstack',
+    tags: ['auth', 'api'],
+    status: 'approved',
+    risk: 'medium',
+    difficulty: 3,
+    estimation: { devHours: 16, reviewHours: 4, totalCostUsd: 200 },
+    dependencies: [],
+    huPath: null,
+    fichaTecnicaPath: null,
+    gitBranch: null,
+};
+const baseKnowledge = {
+    language: 'typescript',
+    framework: 'next',
+    projectPath: '/test',
+    stack: [],
+    conventions: {},
+    architecture: {
+        primary: 'monolith',
+        secondary: [],
+        layers: [
+            { name: 'infrastructure', directories: ['src/infra'] },
+            { name: 'application', directories: ['src/services'] },
+        ],
+    },
+    database: 'postgresql',
+    testCommand: 'npm test',
+    buildCommand: 'npm run build',
+    linting: { detectedLinters: [{ tool: 'eslint' }] },
+    apiContracts: [{ type: 'rest' }],
+    layers: [],
+};
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockReadFile.mockRejectedValue(new Error('not found'));
+    mockListPatterns.mockResolvedValue([]);
+});
+describe('handleGenerateExecutionPlan', () => {
+    it('should return error when spec not found', async () => {
+        mockGetSpec.mockResolvedValue(null);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-999',
+            projectId: 'proj-1',
+        });
+        expect(result.isError).toBe(true);
+    });
+    it('should return error when knowledge not found', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockGetKnowledge.mockResolvedValue(null);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        expect(result.isError).toBe(true);
+    });
+    it('should generate plan for fullstack spec', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        expect(result.isError).toBeUndefined();
+        expect(result.content).toHaveLength(2);
+        const data = JSON.parse(result.content[1].text);
+        expect(data.phases.length).toBeGreaterThanOrEqual(4);
+        expect(data.totalSteps).toBeGreaterThan(0);
+        expect(data.criticalPath.length).toBeGreaterThan(0);
+        expect(data.summary).toBeDefined();
+        expect(data.summary.estimatedMinutes).toBeGreaterThan(0);
+        // Should include: Setup, Data Layer, Business Logic, UI, Testing, Integration
+        const phaseNames = data.phases.map((p) => p.name);
+        expect(phaseNames).toContain('Setup & Scaffolding');
+        expect(phaseNames).toContain('Data Layer');
+        expect(phaseNames).toContain('Business Logic & API');
+        expect(phaseNames).toContain('UI Implementation');
+        expect(phaseNames).toContain('Testing & Verification');
+        expect(phaseNames).toContain('Integration & Cleanup');
+    });
+    it('should skip UI phase for backend-only spec', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec, target: 'backend',
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const phaseNames = data.phases.map((p) => p.name);
+        expect(phaseNames).not.toContain('UI Implementation');
+    });
+    it('should skip data layer for frontend-only spec', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec, target: 'frontend',
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const phaseNames = data.phases.map((p) => p.name);
+        expect(phaseNames).not.toContain('Data Layer');
+        expect(phaseNames).not.toContain('Business Logic & API');
+        expect(phaseNames).toContain('UI Implementation');
+    });
+    it('should include config update step for architectural scope', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec, scope: 'architectural',
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const setupPhase = data.phases.find((p) => p.name === 'Setup & Scaffolding');
+        const hasConfigStep = setupPhase.steps.some((s) => s.title.includes('configuration'));
+        expect(hasConfigStep).toBe(true);
+    });
+    it('should include type definitions step for typescript', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const setupPhase = data.phases.find((p) => p.name === 'Setup & Scaffolding');
+        const hasTypeStep = setupPhase.steps.some((s) => s.title.includes('types'));
+        expect(hasTypeStep).toBe(true);
+    });
+    it('should skip integration tests for trivial scope', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec, scope: 'trivial', target: 'backend',
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const testPhase = data.phases.find((p) => p.name === 'Testing & Verification');
+        const hasIntegration = testPhase.steps.some((s) => s.title.includes('integration'));
+        expect(hasIntegration).toBe(false);
+    });
+    it('should use next.js page file paths for next framework', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const uiPhase = data.phases.find((p) => p.name === 'UI Implementation');
+        if (uiPhase) {
+            const pageStep = uiPhase.steps.find((s) => s.title.includes('page layout'));
+            if (pageStep) {
+                expect(pageStep.files[0]).toContain('app/');
+            }
+        }
+    });
+    // --- Coverage for readSpecContent catch blocks (lines 632-639) ---
+    it('should read huPath content when available', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            huPath: '/test/hu.md',
+            fichaTecnicaPath: null,
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        mockReadFile.mockImplementation(((path) => {
+            if (path === '/test/hu.md') {
+                return Promise.resolve('validation input form api endpoint route');
+            }
+            return Promise.reject(new Error('not found'));
+        }));
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        expect(result.isError).toBeUndefined();
+        const data = JSON.parse(result.content[1].text);
+        expect(data.phases.length).toBeGreaterThan(0);
+    });
+    it('should read fichaTecnicaPath content when available', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            huPath: null,
+            fichaTecnicaPath: '/test/ficha.md',
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        mockReadFile.mockImplementation(((path) => {
+            if (path === '/test/ficha.md') {
+                return Promise.resolve('table schema model entity migration seed fixture sample data');
+            }
+            return Promise.reject(new Error('not found'));
+        }));
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        expect(result.isError).toBeUndefined();
+        const data = JSON.parse(result.content[1].text);
+        const dataPhase = data.phases.find((p) => p.name === 'Data Layer');
+        expect(dataPhase).toBeDefined();
+    });
+    it('should handle readFile errors gracefully for both paths', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            huPath: '/test/missing-hu.md',
+            fichaTecnicaPath: '/test/missing-ficha.md',
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        mockReadFile.mockRejectedValue(new Error('ENOENT'));
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        expect(result.isError).toBeUndefined();
+    });
+    // --- Coverage for generateDataLayerPhase with seed data (lines 315-618) ---
+    it('should include seed data step when content mentions seed/fixture', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'backend',
+            title: 'User management with seed data and sample data',
+            tags: ['seed'],
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const dataPhase = data.phases.find((p) => p.name === 'Data Layer');
+        expect(dataPhase).toBeDefined();
+        const hasSeed = dataPhase.steps.some((s) => s.title.includes('seed data'));
+        expect(hasSeed).toBe(true);
+    });
+    // --- Coverage for generateBusinessLogicPhase: validation step ---
+    it('should include validation step when content mentions validation', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'backend',
+            title: 'User registration validation input form',
+            tags: ['validation'],
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const logicPhase = data.phases.find((p) => p.name === 'Business Logic & API');
+        expect(logicPhase).toBeDefined();
+        const hasValidation = logicPhase.steps.some((s) => s.title.includes('validation'));
+        expect(hasValidation).toBe(true);
+    });
+    // --- Coverage for generateBusinessLogicPhase: API endpoints step ---
+    it('should include API endpoints step when content mentions api/endpoint/route', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'backend',
+            title: 'REST api endpoint route handler',
+            tags: ['api'],
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const logicPhase = data.phases.find((p) => p.name === 'Business Logic & API');
+        const hasApiEndpoints = logicPhase.steps.some((s) => s.title.includes('API endpoints'));
+        expect(hasApiEndpoints).toBe(true);
+    });
+    // --- Coverage for generateUIPhase: form handling step ---
+    it('should include form handling step when UI content mentions form/create/edit', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'frontend',
+            title: 'User form create edit input submission',
+            tags: ['form'],
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const uiPhase = data.phases.find((p) => p.name === 'UI Implementation');
+        expect(uiPhase).toBeDefined();
+        const hasFormHandling = uiPhase.steps.some((s) => s.title.includes('form handling'));
+        expect(hasFormHandling).toBe(true);
+    });
+    // --- Coverage for generateTestingPhase: E2E tests for frontend/fullstack ---
+    it('should include E2E tests for frontend spec', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'frontend',
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const testPhase = data.phases.find((p) => p.name === 'Testing & Verification');
+        const hasE2E = testPhase.steps.some((s) => s.title.includes('E2E'));
+        expect(hasE2E).toBe(true);
+    });
+    // --- Coverage for inferPageFiles: nuxt framework ---
+    it('should use nuxt page paths for nuxt framework', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'frontend',
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            framework: 'nuxt',
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const uiPhase = data.phases.find((p) => p.name === 'UI Implementation');
+        const pageStep = uiPhase?.steps.find((s) => s.title.includes('page layout'));
+        if (pageStep) {
+            expect(pageStep.files[0]).toContain('pages/');
+        }
+    });
+    // --- Coverage for inferPageFiles: generic framework (not next/nuxt) ---
+    it('should use generic page paths for unknown framework', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'frontend',
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            framework: 'react',
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const uiPhase = data.phases.find((p) => p.name === 'UI Implementation');
+        const pageStep = uiPhase?.steps.find((s) => s.title.includes('page layout'));
+        if (pageStep) {
+            expect(pageStep.files[0]).toContain('src/pages/');
+        }
+    });
+    // --- Coverage for inferComponentFiles: vue extension ---
+    it('should use .vue extension for vue components', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'frontend',
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            framework: 'vue',
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const uiPhase = data.phases.find((p) => p.name === 'UI Implementation');
+        const componentStep = uiPhase?.steps.find((s) => s.title.includes('UI components'));
+        if (componentStep) {
+            expect(componentStep.files[0]).toContain('.vue');
+        }
+    });
+    // --- Coverage for inferApiFiles: trpc type ---
+    it('should use trpc router paths for trpc API type', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'backend',
+            title: 'API endpoint route',
+            tags: ['api'],
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            apiContracts: [{ type: 'trpc' }],
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const logicPhase = data.phases.find((p) => p.name === 'Business Logic & API');
+        const apiStep = logicPhase?.steps.find((s) => s.title.includes('API endpoints'));
+        if (apiStep) {
+            expect(apiStep.files[0]).toContain('src/server/routers');
+        }
+    });
+    // --- Coverage for inferDataLayerFiles: no infrastructure layer ---
+    it('should use default src path when no infrastructure layer exists', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'backend',
+            title: 'table schema model entity',
+            tags: [],
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            architecture: {
+                primary: 'monolith',
+                secondary: [],
+                layers: [], // no layers defined
+            },
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const dataPhase = data.phases.find((p) => p.name === 'Data Layer');
+        expect(dataPhase).toBeDefined();
+    });
+    // --- Coverage for database-only spec ---
+    it('should generate data layer for database-only spec', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'database',
+            title: 'Schema migration',
+            tags: [],
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const phaseNames = data.phases.map((p) => p.name);
+        expect(phaseNames).toContain('Data Layer');
+        // No UI for database spec
+        expect(phaseNames).not.toContain('UI Implementation');
+    });
+    // --- Coverage for data layer without migration keywords (no schema/table/model) ---
+    it('should still generate data layer with repository when database is known even without keywords', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'backend',
+            title: 'Simple backend service',
+            tags: [],
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            database: 'postgresql',
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const dataPhase = data.phases.find((p) => p.name === 'Data Layer');
+        expect(dataPhase).toBeDefined();
+        const hasRepo = dataPhase.steps.some((s) => s.title.includes('data access'));
+        expect(hasRepo).toBe(true);
+    });
+    // --- Coverage for non-typescript language (no types step) ---
+    it('should skip types step for non-typescript language', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'backend',
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            language: 'python',
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const setupPhase = data.phases.find((p) => p.name === 'Setup & Scaffolding');
+        const hasTypeStep = setupPhase.steps.some((s) => s.title.includes('types'));
+        expect(hasTypeStep).toBe(false);
+    });
+    // --- Coverage for findParallelizable: groups with shared dependencies ---
+    it('should find parallelizable step groups', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'fullstack',
+            scope: 'architectural',
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        // parallelizable groups are arrays of step titles that can run in parallel
+        expect(data.parallelizable).toBeDefined();
+        expect(data.summary.parallelizableGroups).toBeDefined();
+    });
+    // --- Coverage for cross-module scope config step ---
+    it('should include config step for cross-module scope', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            scope: 'cross-module',
+        });
+        mockGetKnowledge.mockResolvedValue(baseKnowledge);
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const setupPhase = data.phases.find((p) => p.name === 'Setup & Scaffolding');
+        const hasConfigStep = setupPhase.steps.some((s) => s.title.includes('configuration'));
+        expect(hasConfigStep).toBe(true);
+    });
+    // --- Coverage for inferApiFiles without apiContracts ---
+    it('should default to rest routes when no apiContracts defined', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'backend',
+            title: 'api endpoint route',
+            tags: ['api'],
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            apiContracts: [],
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const logicPhase = data.phases.find((p) => p.name === 'Business Logic & API');
+        const apiStep = logicPhase?.steps.find((s) => s.title.includes('API endpoints'));
+        if (apiStep) {
+            expect(apiStep.files[0]).toContain('src/routes');
+        }
+    });
+    // --- Coverage for linting step with no detected linters ---
+    it('should default to eslint in linting step when no linters detected', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'backend',
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            linting: { detectedLinters: [] },
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const integrationPhase = data.phases.find((p) => p.name === 'Integration & Cleanup');
+        const lintStep = integrationPhase?.steps.find((s) => s.title.includes('linting'));
+        expect(lintStep).toBeDefined();
+        expect(lintStep.verification).toContain('eslint');
+    });
+    // --- Coverage for no framework (null) ---
+    it('should handle null framework', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'frontend',
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            framework: null,
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        expect(result.isError).toBeUndefined();
+        const data = JSON.parse(result.content[1].text);
+        const uiPhase = data.phases.find((p) => p.name === 'UI Implementation');
+        expect(uiPhase).toBeDefined();
+    });
+    // --- Coverage for javascript language (should also get types step) ---
+    it('should include types step for javascript language', async () => {
+        mockGetSpec.mockResolvedValue(baseSpec);
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            language: 'javascript',
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const setupPhase = data.phases.find((p) => p.name === 'Setup & Scaffolding');
+        const hasTypeStep = setupPhase.steps.some((s) => s.title.includes('types'));
+        expect(hasTypeStep).toBe(true);
+    });
+    // --- Coverage for null buildCommand and testCommand ---
+    it('should use defaults when buildCommand and testCommand are null', async () => {
+        mockGetSpec.mockResolvedValue({
+            ...baseSpec,
+            target: 'backend',
+        });
+        mockGetKnowledge.mockResolvedValue({
+            ...baseKnowledge,
+            buildCommand: null,
+            testCommand: null,
+        });
+        const result = await handleGenerateExecutionPlan({
+            specId: 'SPEC-001',
+            projectId: 'proj-1',
+        });
+        const data = JSON.parse(result.content[1].text);
+        const integrationPhase = data.phases.find((p) => p.name === 'Integration & Cleanup');
+        const buildStep = integrationPhase?.steps.find((s) => s.title.includes('Full build'));
+        expect(buildStep.verification).toContain('npm run build');
+        expect(buildStep.verification).toContain('npm test');
+    });
+});
+//# sourceMappingURL=generate-execution-plan.test.js.map