sofia-cli 0.1.1

package/dist/tests/unit/develop/checkpointState.spec.js

@@ -0,0 +1,315 @@
+/**
+ * Unit tests for deriveCheckpointState.
+ *
+ * T012: Verify correct state for no-poc, completed, partial, interrupted sessions
+ * T068: Corrupted iterations cause safe fallback
+ * T069: Metadata integrity mismatch triggers warning
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { deriveCheckpointState } from '../../../src/develop/checkpointState.js';
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function makeSession(overrides) {
+    const now = new Date().toISOString();
+    return {
+        sessionId: 'cp-test-session',
+        schemaVersion: '1.0.0',
+        createdAt: now,
+        updatedAt: now,
+        phase: 'Develop',
+        status: 'Active',
+        participants: [],
+        artifacts: { generatedFiles: [] },
+        ...overrides,
+    };
+}
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe('deriveCheckpointState', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = mkdtempSync(join(tmpdir(), 'checkpoint-'));
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('returns fresh state when session has no poc', () => {
+        const session = makeSession();
+        const state = deriveCheckpointState(session, tmpDir);
+        expect(state.hasPriorRun).toBe(false);
+        expect(state.completedIterations).toBe(0);
+        expect(state.lastIterationIncomplete).toBe(false);
+        expect(state.resumeFromIteration).toBe(1);
+        expect(state.canSkipScaffold).toBe(false);
+        expect(state.priorFinalStatus).toBeUndefined();
+        expect(state.priorIterations).toEqual([]);
+    });
+    it('returns fresh state when poc has empty iterations', () => {
+        const session = makeSession({
+            poc: { repoSource: 'local', iterations: [] },
+        });
+        const state = deriveCheckpointState(session, tmpDir);
+        expect(state.hasPriorRun).toBe(false);
+        expect(state.resumeFromIteration).toBe(1);
+    });
+    it('returns completed state for sessions with all iterations having testResults', () => {
+        const session = makeSession({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 1,
+                        startedAt: new Date().toISOString(),
+                        endedAt: new Date().toISOString(),
+                        outcome: 'scaffold',
+                        filesChanged: [],
+                    },
+                    {
+                        iteration: 2,
+                        startedAt: new Date().toISOString(),
+                        endedAt: new Date().toISOString(),
+                        outcome: 'tests-failing',
+                        filesChanged: ['src/index.ts'],
+                        testResults: {
+                            passed: 1,
+                            failed: 1,
+                            skipped: 0,
+                            total: 2,
+                            durationMs: 100,
+                            failures: [],
+                        },
+                    },
+                ],
+                finalStatus: 'partial',
+            },
+        });
+        const state = deriveCheckpointState(session, tmpDir);
+        expect(state.hasPriorRun).toBe(true);
+        expect(state.completedIterations).toBe(2);
+        expect(state.lastIterationIncomplete).toBe(false);
+        expect(state.resumeFromIteration).toBe(3);
+        expect(state.priorFinalStatus).toBe('partial');
+        expect(state.priorIterations).toHaveLength(2);
+    });
+    it('detects incomplete last iteration (no testResults, not scaffold)', () => {
+        const session = makeSession({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 1,
+                        startedAt: new Date().toISOString(),
+                        endedAt: new Date().toISOString(),
+                        outcome: 'scaffold',
+                        filesChanged: [],
+                    },
+                    {
+                        iteration: 2,
+                        startedAt: new Date().toISOString(),
+                        outcome: 'tests-failing',
+                        filesChanged: [],
+                        // No testResults — interrupted
+                    },
+                ],
+            },
+        });
+        const state = deriveCheckpointState(session, tmpDir);
+        expect(state.hasPriorRun).toBe(true);
+        expect(state.lastIterationIncomplete).toBe(true);
+        expect(state.completedIterations).toBe(1);
+        expect(state.resumeFromIteration).toBe(2);
+        expect(state.priorIterations).toHaveLength(1);
+    });
+    it('sets canSkipScaffold when metadata file exists with matching sessionId', () => {
+        mkdirSync(tmpDir, { recursive: true });
+        writeFileSync(join(tmpDir, '.sofia-metadata.json'), JSON.stringify({ sessionId: 'cp-test-session' }));
+        const session = makeSession({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 1,
+                        startedAt: new Date().toISOString(),
+                        endedAt: new Date().toISOString(),
+                        outcome: 'scaffold',
+                        filesChanged: [],
+                    },
+                ],
+            },
+        });
+        const state = deriveCheckpointState(session, tmpDir);
+        expect(state.canSkipScaffold).toBe(true);
+    });
+    it('sets canSkipScaffold false when metadata file has mismatched sessionId (T069)', () => {
+        mkdirSync(tmpDir, { recursive: true });
+        writeFileSync(join(tmpDir, '.sofia-metadata.json'), JSON.stringify({ sessionId: 'different-session' }));
+        const session = makeSession({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 1,
+                        startedAt: new Date().toISOString(),
+                        endedAt: new Date().toISOString(),
+                        outcome: 'scaffold',
+                        filesChanged: [],
+                    },
+                ],
+            },
+        });
+        const state = deriveCheckpointState(session, tmpDir);
+        expect(state.canSkipScaffold).toBe(false);
+    });
+    it('sets canSkipScaffold false when metadata file is corrupt JSON (T069)', () => {
+        mkdirSync(tmpDir, { recursive: true });
+        writeFileSync(join(tmpDir, '.sofia-metadata.json'), '{invalid json');
+        const session = makeSession({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 1,
+                        startedAt: new Date().toISOString(),
+                        endedAt: new Date().toISOString(),
+                        outcome: 'scaffold',
+                        filesChanged: [],
+                    },
+                ],
+            },
+        });
+        const state = deriveCheckpointState(session, tmpDir);
+        expect(state.canSkipScaffold).toBe(false);
+    });
+    it('falls back to fresh run when iterations have corrupt entries (T068)', () => {
+        const session = makeSession({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 1,
+                        startedAt: '', // Empty string — invalid
+                        outcome: 'scaffold',
+                        filesChanged: [],
+                    },
+                ],
+            },
+        });
+        const state = deriveCheckpointState(session, tmpDir);
+        expect(state.hasPriorRun).toBe(false);
+        expect(state.resumeFromIteration).toBe(1);
+    });
+    it('falls back to fresh run when iteration has non-number iteration field (T068)', () => {
+        const session = makeSession({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 'not a number',
+                        startedAt: new Date().toISOString(),
+                        outcome: 'scaffold',
+                        filesChanged: [],
+                    },
+                ],
+            },
+        });
+        const state = deriveCheckpointState(session, tmpDir);
+        expect(state.hasPriorRun).toBe(false);
+        expect(state.resumeFromIteration).toBe(1);
+    });
+    it('returns success priorFinalStatus for successful sessions', () => {
+        const session = makeSession({
+            poc: {
+                repoSource: 'local',
+                iterations: [
+                    {
+                        iteration: 1,
+                        startedAt: new Date().toISOString(),
+                        endedAt: new Date().toISOString(),
+                        outcome: 'tests-passing',
+                        filesChanged: [],
+                        testResults: {
+                            passed: 3,
+                            failed: 0,
+                            skipped: 0,
+                            total: 3,
+                            durationMs: 100,
+                            failures: [],
+                        },
+                    },
+                ],
+                finalStatus: 'success',
+            },
+        });
+        const state = deriveCheckpointState(session, tmpDir);
+        expect(state.priorFinalStatus).toBe('success');
+    });
+    // ── T075: Validation — fresh vs resumed run quality comparison ────────────
+    describe('fresh vs resumed run quality (T075)', () => {
+        it('preserves iteration count consistency across fresh and resumed checkpoint derivations', () => {
+            // Fresh session (no prior run)
+            const freshSession = makeSession();
+            const freshState = deriveCheckpointState(freshSession, tmpDir);
+            expect(freshState.hasPriorRun).toBe(false);
+            expect(freshState.resumeFromIteration).toBe(1);
+            expect(freshState.completedIterations).toBe(0);
+            // Session with 3 completed iterations (simulating prior run)
+            const resumedSession = makeSession({
+                poc: {
+                    iterations: [
+                        { iteration: 1, startedAt: '2026-01-01T12:00:00Z', endedAt: '2026-01-01T12:01:00Z', outcome: 'tests-failing', filesChanged: ['src/index.ts'], testResults: { passed: 0, failed: 1, skipped: 0, total: 1, durationMs: 100, failures: [{ testName: 'a', message: 'fail' }] } },
+                        { iteration: 2, startedAt: '2026-01-01T12:01:00Z', endedAt: '2026-01-01T12:02:00Z', outcome: 'tests-failing', filesChanged: ['src/index.ts'], testResults: { passed: 1, failed: 1, skipped: 0, total: 2, durationMs: 100, failures: [{ testName: 'b', message: 'fail' }] } },
+                        { iteration: 3, startedAt: '2026-01-01T12:02:00Z', endedAt: '2026-01-01T12:03:00Z', outcome: 'tests-passing', filesChanged: ['src/index.ts'], testResults: { passed: 2, failed: 0, skipped: 0, total: 2, durationMs: 100, failures: [] } },
+                    ],
+                    finalStatus: 'success',
+                    repoSource: 'local',
+                },
+            });
+            writeFileSync(join(tmpDir, '.sofia-metadata.json'), JSON.stringify({ sessionId: 'cp-test-session' }));
+            const resumeState = deriveCheckpointState(resumedSession, tmpDir);
+            expect(resumeState.hasPriorRun).toBe(true);
+            expect(resumeState.completedIterations).toBe(3);
+            expect(resumeState.resumeFromIteration).toBe(4);
+            // Quality validation: resumed state preserves iteration history
+            expect(resumeState.priorIterations).toHaveLength(3);
+            // Test pass counts increase across iterations (quality signal)
+            expect(resumeState.priorIterations[0].testResults.passed).toBe(0);
+            expect(resumeState.priorIterations[2].testResults.passed).toBe(2);
+        });
+    });
+    // ── T076: Benchmark — resume detection overhead <500ms ────────────────────
+    describe('resume detection performance (T076)', () => {
+        it('deriveCheckpointState completes within 500ms even with many iterations', () => {
+            // Create a session with 50 iterations to stress-test derivation
+            const iterations = Array.from({ length: 50 }, (_, i) => ({
+                iteration: i + 1,
+                startedAt: '2026-01-01T12:00:00Z',
+                endedAt: '2026-01-01T12:01:00Z',
+                outcome: 'tests-failing',
+                filesChanged: ['src/index.ts'],
+                testResults: {
+                    passed: i,
+                    failed: 50 - i,
+                    skipped: 0,
+                    total: 50,
+                    durationMs: 100,
+                    failures: [{ testName: `test-${i}`, message: 'fail' }],
+                },
+            }));
+            const session = makeSession({
+                poc: {
+                    iterations,
+                    finalStatus: 'failed',
+                    repoSource: 'local',
+                },
+            });
+            writeFileSync(join(tmpDir, '.sofia-metadata.json'), JSON.stringify({ sessionId: 'cp-test-session' }));
+            const start = performance.now();
+            const state = deriveCheckpointState(session, tmpDir);
+            const elapsed = performance.now() - start;
+            expect(elapsed).toBeLessThan(500);
+            expect(state.completedIterations).toBe(50);
+            expect(state.resumeFromIteration).toBe(51);
+        });
+    });
+});

package/dist/tests/unit/develop/codeGenerator.spec.js

@@ -0,0 +1,355 @@
+/**
+ * T013: Unit tests for CodeGenerator.
+ *
+ * Verifies:
+ * - Parses fenced code blocks with `file=path` from LLM response
+ * - Writes files to outputDir
+ * - Handles empty response gracefully
+ * - Builds iteration prompt with test failures context
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { CodeGenerator, parseFencedCodeBlocks, buildFileTree, isUnsafePath, isPathWithinDirectory, } from '../../../src/develop/codeGenerator.js';
+// ── Fixtures ──────────────────────────────────────────────────────────────────
+function makeTestResults(overrides) {
+    return {
+        passed: 1,
+        failed: 2,
+        skipped: 0,
+        total: 3,
+        durationMs: 500,
+        failures: [
+            {
+                testName: 'suite > test A',
+                message: 'Expected 3 but got 5',
+                file: 'tests/a.test.ts',
+                line: 10,
+            },
+            {
+                testName: 'suite > test B',
+                message: 'Cannot read properties of undefined',
+                file: 'tests/b.test.ts',
+            },
+        ],
+        rawOutput: 'FAIL tests/a.test.ts\nFAIL tests/b.test.ts\n',
+        ...overrides,
+    };
+}
+// ── parseFencedCodeBlocks ─────────────────────────────────────────────────────
+describe('parseFencedCodeBlocks', () => {
+    it('parses a single typescript code block with file=', () => {
+        const response = `Here are the changes:\n\n\`\`\`typescript file=src/index.ts\nexport function main() {\n  return 42;\n}\n\`\`\`\n`;
+        const files = parseFencedCodeBlocks(response);
+        expect(files).toHaveLength(1);
+        expect(files[0].path).toBe('src/index.ts');
+        expect(files[0].content).toContain('export function main()');
+        expect(files[0].language).toBe('typescript');
+    });
+    it('parses multiple code blocks', () => {
+        const response = `\`\`\`typescript file=src/index.ts\nexport function a() {}\n\`\`\`\n\n\`\`\`typescript file=tests/index.test.ts\nimport { test } from "vitest";\n\`\`\`\n`;
+        const files = parseFencedCodeBlocks(response);
+        expect(files).toHaveLength(2);
+        expect(files[0].path).toBe('src/index.ts');
+        expect(files[1].path).toBe('tests/index.test.ts');
+    });
+    it('handles code block with ./prefix in path', () => {
+        const response = `\`\`\`typescript file=./src/index.ts\nexport const x = 1;\n\`\`\`\n`;
+        const files = parseFencedCodeBlocks(response);
+        expect(files).toHaveLength(1);
+        expect(files[0].path).toBe('src/index.ts'); // normalized
+    });
+    it('handles empty LLM response gracefully', () => {
+        const files = parseFencedCodeBlocks('');
+        expect(files).toHaveLength(0);
+    });
+    it('ignores code blocks without file= annotation', () => {
+        const response = `\`\`\`typescript\nexport function main() {}\n\`\`\`\n`;
+        const files = parseFencedCodeBlocks(response);
+        expect(files).toHaveLength(0);
+    });
+    it('handles ts shorthand language tag', () => {
+        const response = `\`\`\`ts file=src/index.ts\nexport const x = 1;\n\`\`\`\n`;
+        const files = parseFencedCodeBlocks(response);
+        expect(files).toHaveLength(1);
+        expect(files[0].language).toBe('ts');
+    });
+    it('handles json file type', () => {
+        const response = `\`\`\`json file=package.json\n{"name":"test"}\n\`\`\`\n`;
+        const files = parseFencedCodeBlocks(response);
+        expect(files).toHaveLength(1);
+        expect(files[0].path).toBe('package.json');
+    });
+});
+// ── buildFileTree ─────────────────────────────────────────────────────────────
+describe('buildFileTree', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-filetree-test-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('returns empty array for non-existent directory', () => {
+        const tree = buildFileTree('/non/existent/path');
+        expect(tree).toEqual([]);
+    });
+    it('lists files in directory', async () => {
+        const { writeFile } = await import('node:fs/promises');
+        await writeFile(join(tmpDir, 'index.ts'), '', 'utf-8');
+        await writeFile(join(tmpDir, 'helper.ts'), '', 'utf-8');
+        const tree = buildFileTree(tmpDir);
+        expect(tree).toContain('helper.ts');
+        expect(tree).toContain('index.ts');
+    });
+    it('excludes node_modules and dist', async () => {
+        const { mkdir, writeFile } = await import('node:fs/promises');
+        await mkdir(join(tmpDir, 'node_modules'), { recursive: true });
+        await writeFile(join(tmpDir, 'node_modules', 'pkg.js'), '', 'utf-8');
+        await mkdir(join(tmpDir, 'dist'), { recursive: true });
+        await writeFile(join(tmpDir, 'dist', 'index.js'), '', 'utf-8');
+        await writeFile(join(tmpDir, 'index.ts'), '', 'utf-8');
+        const tree = buildFileTree(tmpDir);
+        expect(tree).toContain('index.ts');
+        expect(tree.some((f) => f.includes('node_modules'))).toBe(false);
+        expect(tree.some((f) => f.includes('dist'))).toBe(false);
+    });
+    it('recursively lists subdirectories', async () => {
+        const { mkdir, writeFile } = await import('node:fs/promises');
+        await mkdir(join(tmpDir, 'src'), { recursive: true });
+        await writeFile(join(tmpDir, 'src', 'index.ts'), '', 'utf-8');
+        const tree = buildFileTree(tmpDir);
+        expect(tree).toContain('src/');
+        expect(tree).toContain('  index.ts');
+    });
+});
+// ── isUnsafePath ──────────────────────────────────────────────────────────────
+describe('isUnsafePath', () => {
+    it('returns true for POSIX absolute paths', () => {
+        expect(isUnsafePath('/etc/passwd')).toBe(true);
+        expect(isUnsafePath('/tmp/evil')).toBe(true);
+    });
+    it('returns true for Windows drive-letter paths', () => {
+        expect(isUnsafePath('C:\\Windows\\System32\\evil.ts')).toBe(true);
+        expect(isUnsafePath('c:/Windows/evil.ts')).toBe(true);
+    });
+    it('returns true for UNC paths (backslash and forward-slash)', () => {
+        expect(isUnsafePath('\\\\server\\share\\evil.ts')).toBe(true);
+        expect(isUnsafePath('//server/share/evil.ts')).toBe(true);
+    });
+    it('returns true for path traversal segments', () => {
+        expect(isUnsafePath('../../etc/passwd')).toBe(true);
+        expect(isUnsafePath('src/../../../evil')).toBe(true);
+    });
+    it('returns false for normal relative paths', () => {
+        expect(isUnsafePath('src/index.ts')).toBe(false);
+        expect(isUnsafePath('tests/index.test.ts')).toBe(false);
+        expect(isUnsafePath('package.json')).toBe(false);
+    });
+});
+// ── isPathWithinDirectory ─────────────────────────────────────────────────────
+describe('isPathWithinDirectory', () => {
+    it('returns true for relative paths inside the directory', () => {
+        expect(isPathWithinDirectory('src/index.ts', '/tmp/poc')).toBe(true);
+        expect(isPathWithinDirectory('package.json', '/tmp/poc')).toBe(true);
+    });
+    it('returns false for paths that resolve outside the directory', () => {
+        // On POSIX, path.resolve('/tmp/poc', '../../etc/passwd') → '/etc/passwd'
+        expect(isPathWithinDirectory('../../etc/passwd', '/tmp/poc')).toBe(false);
+    });
+});
+// ── CodeGenerator ─────────────────────────────────────────────────────────────
+describe('CodeGenerator', () => {
+    let tmpDir;
+    let generator;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-codegen-test-'));
+        generator = new CodeGenerator(tmpDir);
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    describe('buildIterationPrompt', () => {
+        it('includes iteration number and max', () => {
+            const prompt = generator.buildIterationPrompt({
+                iteration: 3,
+                maxIterations: 10,
+                previousOutcome: 'tests-failing',
+                testResults: makeTestResults(),
+                filesInPoc: ['src/index.ts'],
+            });
+            expect(prompt).toContain('Iteration: 3 of 10');
+            expect(prompt).toContain('tests-failing');
+        });
+        it('includes failing test details', () => {
+            const prompt = generator.buildIterationPrompt({
+                iteration: 2,
+                maxIterations: 5,
+                previousOutcome: 'scaffold',
+                testResults: makeTestResults(),
+                filesInPoc: ['src/index.ts'],
+            });
+            expect(prompt).toContain('suite > test A');
+            expect(prompt).toContain('Expected 3 but got 5');
+            expect(prompt).toContain('tests/a.test.ts');
+        });
+        it('includes files in PoC', () => {
+            const prompt = generator.buildIterationPrompt({
+                iteration: 2,
+                maxIterations: 5,
+                previousOutcome: 'scaffold',
+                testResults: makeTestResults({ failed: 0, failures: [], total: 1, passed: 1 }),
+                filesInPoc: ['src/index.ts', 'tests/index.test.ts', 'package.json'],
+            });
+            expect(prompt).toContain('src/index.ts');
+            expect(prompt).toContain('tests/index.test.ts');
+        });
+        it('includes MCP context when provided', () => {
+            const prompt = generator.buildIterationPrompt({
+                iteration: 2,
+                maxIterations: 5,
+                previousOutcome: 'tests-failing',
+                testResults: makeTestResults(),
+                filesInPoc: [],
+                mcpContext: 'express@5.0.0 API docs: use app.get()',
+            });
+            expect(prompt).toContain('express@5.0.0 API docs');
+            expect(prompt).toContain('MCP Context');
+        });
+        it('includes raw test output', () => {
+            const prompt = generator.buildIterationPrompt({
+                iteration: 2,
+                maxIterations: 5,
+                previousOutcome: 'tests-failing',
+                testResults: makeTestResults({ rawOutput: 'FAIL tests/a.test.ts\n' }),
+                filesInPoc: [],
+            });
+            expect(prompt).toContain('FAIL tests/a.test.ts');
+        });
+        it('shows "0 failing tests" task when no failures', () => {
+            const prompt = generator.buildIterationPrompt({
+                iteration: 3,
+                maxIterations: 10,
+                previousOutcome: 'tests-passing',
+                testResults: makeTestResults({ passed: 3, failed: 0, failures: [], total: 3 }),
+                filesInPoc: [],
+            });
+            expect(prompt).toContain('0 failing tests');
+        });
+        it('includes file contents in ## Current Code section when fileContents provided', () => {
+            const prompt = generator.buildIterationPrompt({
+                iteration: 2,
+                maxIterations: 5,
+                previousOutcome: 'tests-failing',
+                testResults: makeTestResults(),
+                filesInPoc: ['src/index.ts'],
+                fileContents: [
+                    { path: 'src/index.ts', content: 'export function main() { return 42; }' },
+                    { path: 'tests/index.test.ts', content: 'import { test } from "vitest";' },
+                ],
+            });
+            expect(prompt).toContain('## Current Code');
+            expect(prompt).toContain('### src/index.ts');
+            expect(prompt).toContain('export function main() { return 42; }');
+            expect(prompt).toContain('### tests/index.test.ts');
+        });
+        it('omits ## Current Code section when fileContents is empty or absent', () => {
+            const prompt = generator.buildIterationPrompt({
+                iteration: 2,
+                maxIterations: 5,
+                previousOutcome: 'tests-failing',
+                testResults: makeTestResults(),
+                filesInPoc: ['src/index.ts'],
+            });
+            expect(prompt).not.toContain('## Current Code');
+        });
+    });
+    describe('buildPromptContextSummary', () => {
+        it('returns a compact summary for auditability', () => {
+            const summary = generator.buildPromptContextSummary({
+                iteration: 3,
+                maxIterations: 10,
+                previousOutcome: 'tests-failing',
+                testResults: makeTestResults({ failed: 2 }),
+                filesInPoc: ['src/index.ts', 'tests/index.test.ts'],
+            });
+            expect(summary).toContain('Iteration 3 of 10');
+            expect(summary).toContain('2 failures');
+            expect(summary).toContain('src/index.ts');
+        });
+    });
+    describe('applyChanges', () => {
+        it('writes parsed files to outputDir', async () => {
+            const llmResponse = `\`\`\`typescript file=src/index.ts\nexport function hello() { return 'hello'; }\n\`\`\`\n`;
+            await generator.applyChanges(llmResponse);
+            const content = await readFile(join(tmpDir, 'src', 'index.ts'), 'utf-8');
+            expect(content).toContain('export function hello()');
+        });
+        it('handles empty LLM response gracefully', async () => {
+            const result = await generator.applyChanges('');
+            expect(result.writtenFiles).toHaveLength(0);
+            expect(result.dependenciesChanged).toBe(false);
+        });
+        it('creates parent directories for nested files', async () => {
+            const llmResponse = `\`\`\`typescript file=src/utils/helper.ts\nexport function help() {}\n\`\`\`\n`;
+            const result = await generator.applyChanges(llmResponse);
+            expect(result.writtenFiles).toContain('src/utils/helper.ts');
+            const content = await readFile(join(tmpDir, 'src', 'utils', 'helper.ts'), 'utf-8');
+            expect(content).toContain('export function help()');
+        });
+        it('rejects paths with path traversal', async () => {
+            const llmResponse = `\`\`\`typescript file=../../etc/passwd\nmalicious content\n\`\`\`\n`;
+            const result = await generator.applyChanges(llmResponse);
+            expect(result.writtenFiles).toHaveLength(0);
+        });
+        it('rejects Windows absolute paths (drive-letter)', async () => {
+            const llmResponse = `\`\`\`typescript file=C:\\Windows\\System32\\malicious.ts\nevil\n\`\`\`\n`;
+            const result = await generator.applyChanges(llmResponse);
+            expect(result.writtenFiles).toHaveLength(0);
+        });
+        it('rejects Windows UNC paths', async () => {
+            const llmResponse = `\`\`\`typescript file=\\\\server\\share\\malicious.ts\nevil\n\`\`\`\n`;
+            const result = await generator.applyChanges(llmResponse);
+            expect(result.writtenFiles).toHaveLength(0);
+        });
+        it('detects dependency changes when package.json is updated', async () => {
+            const { writeFile } = await import('node:fs/promises');
+            // Create initial package.json
+            await writeFile(join(tmpDir, 'package.json'), JSON.stringify({ dependencies: { express: '^4.0.0' }, devDependencies: {} }), 'utf-8');
+            // Update with new dependency
+            const llmResponse = `\`\`\`json file=package.json\n{"dependencies":{"express":"^4.0.0","axios":"^1.0.0"},"devDependencies":{}}\n\`\`\`\n`;
+            const result = await generator.applyChanges(llmResponse);
+            expect(result.dependenciesChanged).toBe(true);
+            expect(result.newDependencies['axios']).toBe('^1.0.0');
+        });
+        it('returns dependenciesChanged=false when package.json unchanged', async () => {
+            const { writeFile } = await import('node:fs/promises');
+            await writeFile(join(tmpDir, 'package.json'), JSON.stringify({ dependencies: { express: '^4.0.0' }, devDependencies: {} }), 'utf-8');
+            // Same package.json
+            const llmResponse = `\`\`\`json file=package.json\n{"dependencies":{"express":"^4.0.0"},"devDependencies":{}}\n\`\`\`\n`;
+            const result = await generator.applyChanges(llmResponse);
+            expect(result.dependenciesChanged).toBe(false);
+        });
+        it('returns writtenFiles list', async () => {
+            const llmResponse = [
+                '```typescript file=src/index.ts\nexport const x = 1;\n```',
+                '```typescript file=tests/index.test.ts\nimport { test } from "vitest";\n```',
+            ].join('\n');
+            const result = await generator.applyChanges(llmResponse);
+            expect(result.writtenFiles).toContain('src/index.ts');
+            expect(result.writtenFiles).toContain('tests/index.test.ts');
+        });
+    });
+    describe('getFilesInPoc', () => {
+        it('returns list of files in the output directory', async () => {
+            const { writeFile, mkdir } = await import('node:fs/promises');
+            await mkdir(join(tmpDir, 'src'), { recursive: true });
+            await writeFile(join(tmpDir, 'src', 'index.ts'), '', 'utf-8');
+            await writeFile(join(tmpDir, 'package.json'), '{}', 'utf-8');
+            const files = generator.getFilesInPoc();
+            expect(files.some((f) => f.includes('index.ts'))).toBe(true);
+            expect(files.some((f) => f.includes('package.json'))).toBe(true);
+        });
+    });
+});