sofia-cli 0.1.1

package/dist/tests/integration/ralphLoopFlow.spec.js

@@ -0,0 +1,359 @@
+/**
+ * T023: Integration test for Ralph loop with fakes.
+ *
+ * Uses a fake CopilotClient and fake test runner:
+ * scaffold → fail tests → LLM generates fix → tests pass → loop terminates with success.
+ * Verifies at least one iteration where failing test guides a fix (SC-002-003).
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createRequire } from 'node:module';
+import { RalphLoop } from '../../src/develop/ralphLoop.js';
+// Mock npm install
+vi.mock('node:child_process', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        spawn: vi.fn((cmd, args) => {
+            if (cmd === 'npm' && args.includes('install')) {
+                return {
+                    stdout: { on: vi.fn() },
+                    stderr: { on: vi.fn() },
+                    on: vi.fn((event, cb) => {
+                        if (event === 'close')
+                            cb(0);
+                    }),
+                    kill: vi.fn(),
+                    killed: false,
+                };
+            }
+            return actual.spawn(cmd, args);
+        }),
+    };
+});
+// Mock validatePocOutput to always pass in integration tests
+vi.mock('../../src/develop/pocScaffolder.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        validatePocOutput: vi.fn().mockResolvedValue({ valid: true, missingFiles: [], errors: [] }),
+    };
+});
+const require = createRequire(import.meta.url);
+const fixtureSession = require('../fixtures/completedSession.json');
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function makeIo() {
+    return {
+        write: vi.fn(),
+        writeActivity: vi.fn(),
+        writeToolSummary: vi.fn(),
+        readInput: vi.fn().mockResolvedValue(null),
+        showDecisionGate: vi.fn(),
+        isJsonMode: false,
+        isTTY: false,
+    };
+}
+function makeFakeScaffolder(outputDir) {
+    return {
+        scaffold: vi.fn().mockImplementation(async () => {
+            const { writeFile, mkdir } = await import('node:fs/promises');
+            await mkdir(join(outputDir, 'src'), { recursive: true });
+            await mkdir(join(outputDir, 'tests'), { recursive: true });
+            await writeFile(join(outputDir, 'package.json'), JSON.stringify({
+                name: 'route-optimizer-poc',
+                scripts: { test: 'vitest run' },
+                dependencies: {},
+                devDependencies: { vitest: '^3.0.0' },
+            }), 'utf-8');
+            await writeFile(join(outputDir, 'src', 'index.ts'), '// TODO: implement\nexport function optimize() { return []; }', 'utf-8');
+            await writeFile(join(outputDir, 'tests', 'index.test.ts'), 'import { describe, it, expect } from "vitest";\nimport { optimize } from "../src/index.js";\ndescribe("optimizer", () => { it("should return stops", () => { expect(optimize().length).toBeGreaterThan(0); }); });', 'utf-8');
+            return {
+                createdFiles: ['package.json', 'src/index.ts', 'tests/index.test.ts'],
+                skippedFiles: [],
+                context: {
+                    projectName: 'route-optimizer-poc',
+                    ideaTitle: 'AI-Powered Route Optimizer',
+                    ideaDescription: 'Optimize routes',
+                    techStack: { language: 'TypeScript', runtime: 'Node.js 20', testRunner: 'npm test' },
+                    planSummary: 'Route optimization',
+                    sessionId: fixtureSession.sessionId,
+                    outputDir,
+                },
+            };
+        }),
+        getTemplateFiles: () => ['package.json', 'src/index.ts', 'tests/index.test.ts'],
+    };
+}
+// ── SC-002-003: Iterative refinement test ────────────────────────────────────
+describe('RalphLoop integration — iterative refinement (SC-002-003)', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-ralph-flow-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+        vi.clearAllMocks();
+    });
+    it('scaffold → fail tests → LLM fix → tests pass → success', async () => {
+        const io = makeIo();
+        const scaffolder = makeFakeScaffolder(tmpDir);
+        // Test runner: fails first, passes second
+        let testCallCount = 0;
+        const testRunner = {
+            run: vi.fn().mockImplementation(async () => {
+                testCallCount++;
+                if (testCallCount === 1) {
+                    // First run: fails
+                    return {
+                        passed: 0,
+                        failed: 1,
+                        skipped: 0,
+                        total: 1,
+                        durationMs: 400,
+                        failures: [
+                            {
+                                testName: 'optimizer > should return stops',
+                                message: 'Expected length to be greater than 0',
+                                file: 'tests/index.test.ts',
+                                line: 3,
+                            },
+                        ],
+                        rawOutput: 'FAIL tests/index.test.ts',
+                    };
+                }
+                // Subsequent runs: pass
+                return {
+                    passed: 1,
+                    failed: 0,
+                    skipped: 0,
+                    total: 1,
+                    durationMs: 300,
+                    failures: [],
+                    rawOutput: 'PASS tests/index.test.ts',
+                };
+            }),
+        };
+        // LLM response: generates a fix for the failing test
+        const client = {
+            createSession: vi.fn().mockResolvedValue({
+                send: vi.fn().mockReturnValue({
+                    async *[Symbol.asyncIterator]() {
+                        yield {
+                            type: 'TextDelta',
+                            text: [
+                                '```typescript file=src/index.ts',
+                                '// Fixed implementation',
+                                'export function optimize(): string[] {',
+                                '  return ["stop-1", "stop-2", "stop-3"];',
+                                '}',
+                                '```',
+                            ].join('\n') + '\n',
+                            timestamp: '',
+                        };
+                    },
+                }),
+                getHistory: () => [],
+            }),
+        };
+        const sessionUpdates = [];
+        const ralph = new RalphLoop({
+            client,
+            io,
+            session: fixtureSession,
+            outputDir: tmpDir,
+            maxIterations: 5,
+            testRunner,
+            scaffolder,
+            onSessionUpdate: async (session) => {
+                sessionUpdates.push({ ...session });
+            },
+        });
+        const result = await ralph.run();
+        // Loop should succeed
+        expect(result.finalStatus).toBe('success');
+        expect(result.terminationReason).toBe('tests-passing');
+        // Verify at least 2 iterations happened (scaffold + test + fix + pass)
+        expect(result.iterationsCompleted).toBeGreaterThanOrEqual(2);
+        // Verify session was persisted
+        expect(sessionUpdates.length).toBeGreaterThan(0);
+        // Verify the fix was applied
+        const fixedContent = await readFile(join(tmpDir, 'src', 'index.ts'), 'utf-8');
+        expect(fixedContent).toContain('stop-1'); // LLM fix was applied
+        // Verify iteration history
+        const poc = result.session.poc;
+        expect(poc.iterations[0].outcome).toBe('scaffold');
+        const lastIter = poc.iterations[poc.iterations.length - 1];
+        expect(lastIter.outcome).toBe('tests-passing');
+    });
+    it('verifies failing tests are passed to LLM in iteration prompt (SC-002-003)', async () => {
+        const io = makeIo();
+        const scaffolder = makeFakeScaffolder(tmpDir);
+        let testCallCount = 0;
+        const testRunner = {
+            run: vi.fn().mockImplementation(async () => {
+                testCallCount++;
+                if (testCallCount === 1) {
+                    return {
+                        passed: 0,
+                        failed: 1,
+                        skipped: 0,
+                        total: 1,
+                        durationMs: 400,
+                        failures: [{ testName: 'unique-failure-name', message: 'specific-error-message' }],
+                        rawOutput: '',
+                    };
+                }
+                return {
+                    passed: 1,
+                    failed: 0,
+                    skipped: 0,
+                    total: 1,
+                    durationMs: 300,
+                    failures: [],
+                    rawOutput: '',
+                };
+            }),
+        };
+        // Capture the prompt sent to LLM
+        let capturedPrompt = '';
+        const client = {
+            createSession: vi.fn().mockResolvedValue({
+                send: vi.fn().mockImplementation((msg) => {
+                    capturedPrompt = msg.content;
+                    return {
+                        async *[Symbol.asyncIterator]() {
+                            yield {
+                                type: 'TextDelta',
+                                text: '```typescript file=src/index.ts\nexport function optimize() { return [1]; }\n```\n',
+                                timestamp: '',
+                            };
+                        },
+                    };
+                }),
+                getHistory: () => [],
+            }),
+        };
+        const ralph = new RalphLoop({
+            client,
+            io,
+            session: fixtureSession,
+            outputDir: tmpDir,
+            maxIterations: 3,
+            testRunner,
+            scaffolder,
+        });
+        await ralph.run();
+        // Verify the LLM received the failure context
+        expect(capturedPrompt).toContain('unique-failure-name');
+        expect(capturedPrompt).toContain('specific-error-message');
+    });
+});
+// ── T074: TODO tracking writes and updates .sofia-metadata.json ────────────
+describe('TODO tracking integration (T074)', () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await mkdtemp(join(tmpdir(), 'sofia-todo-'));
+    });
+    afterEach(async () => {
+        await rm(tmpDir, { recursive: true, force: true });
+    });
+    it('writes TODO counts to .sofia-metadata.json during scaffold and updates after iteration', async () => {
+        const { writeFile, mkdir } = await import('node:fs/promises');
+        // Create a scaffolder that writes files with TODO markers
+        const todoScaffolder = {
+            scaffold: vi.fn().mockImplementation(async () => {
+                await mkdir(join(tmpDir, 'src'), { recursive: true });
+                await mkdir(join(tmpDir, 'tests'), { recursive: true });
+                await writeFile(join(tmpDir, 'package.json'), JSON.stringify({
+                    name: 'todo-test-poc',
+                    scripts: { test: 'vitest run' },
+                    dependencies: {},
+                    devDependencies: {},
+                }), 'utf-8');
+                await writeFile(join(tmpDir, 'src', 'index.ts'), '// TODO: Implement the main logic\nexport function main() { return []; }\n// TODO: Add validation\n', 'utf-8');
+                await writeFile(join(tmpDir, '.sofia-metadata.json'), JSON.stringify({
+                    sessionId: fixtureSession.sessionId,
+                    scaffoldedAt: new Date().toISOString(),
+                }), 'utf-8');
+                return {
+                    createdFiles: ['package.json', 'src/index.ts', '.sofia-metadata.json'],
+                    skippedFiles: [],
+                    context: {
+                        projectName: 'todo-test-poc',
+                        ideaTitle: 'Test',
+                        ideaDescription: 'Test',
+                        techStack: { language: 'TypeScript', runtime: 'Node.js 20', testRunner: 'npm test' },
+                        planSummary: 'Test',
+                        sessionId: fixtureSession.sessionId,
+                        outputDir: tmpDir,
+                    },
+                };
+            }),
+            getTemplateFiles: () => ['package.json', 'src/index.ts'],
+        };
+        // Test runner that fails on first call (triggering TODO rescan), then passes
+        let runCount = 0;
+        const failThenPassRunner = {
+            run: vi.fn().mockImplementation(async () => {
+                runCount++;
+                if (runCount <= 1) {
+                    return {
+                        passed: 0,
+                        failed: 1,
+                        skipped: 0,
+                        total: 1,
+                        durationMs: 100,
+                        failures: [{ testName: 'test', message: 'fail' }],
+                        rawOutput: 'FAIL',
+                    };
+                }
+                return {
+                    passed: 1,
+                    failed: 0,
+                    skipped: 0,
+                    total: 1,
+                    durationMs: 100,
+                    failures: [],
+                    rawOutput: 'pass',
+                };
+            }),
+        };
+        const io = makeIo();
+        const session = { ...fixtureSession };
+        const client = {
+            createSession: vi.fn().mockResolvedValue({
+                send: vi.fn().mockReturnValue({
+                    async *[Symbol.asyncIterator]() {
+                        yield {
+                            type: 'TextDelta',
+                            text: '```typescript file=src/index.ts\nexport function main() { return [1, 2]; }\n```',
+                            timestamp: '',
+                        };
+                    },
+                }),
+                getHistory: () => [],
+            }),
+        };
+        const ralph = new RalphLoop({
+            client,
+            io,
+            session,
+            outputDir: tmpDir,
+            maxIterations: 3,
+            testRunner: failThenPassRunner,
+            scaffolder: todoScaffolder,
+        });
+        await ralph.run();
+        // Verify .sofia-metadata.json has todos section (written by rescan after failing iteration)
+        const metaRaw = await readFile(join(tmpDir, '.sofia-metadata.json'), 'utf-8');
+        const metadata = JSON.parse(metaRaw);
+        expect(metadata.todos).toBeDefined();
+        expect(typeof metadata.todos.totalInitial).toBe('number');
+        expect(typeof metadata.todos.remaining).toBe('number');
+        expect(Array.isArray(metadata.todos.markers)).toBe(true);
+        // After LLM fix removes TODOs from src/index.ts, remaining count should be ≤ initial scaffold count (2)
+        expect(metadata.todos.remaining).toBeLessThanOrEqual(2);
+    });
+});