sofia-cli 0.1.1

package/dist/tests/unit/phases/phaseHandlers.spec.js

@@ -0,0 +1,425 @@
+/**
+ * Phase handler tests.
+ *
+ * Validates that each phase handler:
+ * - Has the correct phase name
+ * - Builds a system prompt that includes phase-specific content
+ * - Returns references
+ * - Provides extractResult and isComplete logic
+ */
+import { describe, it, expect } from 'vitest';
+import { createPhaseHandler, getPhaseOrder, getNextPhase } from '../../../src/phases/phaseHandlers.js';
+import { backtrackSession } from '../../../src/sessions/sessionManager.js';
+function makeSession(overrides) {
+    return {
+        sessionId: 'test-session',
+        schemaVersion: '1.0.0',
+        createdAt: '2025-01-01T00:00:00Z',
+        updatedAt: '2025-01-01T00:00:00Z',
+        phase: 'Discover',
+        status: 'Active',
+        participants: [],
+        artifacts: { generatedFiles: [] },
+        ...overrides,
+    };
+}
+describe('phaseHandlers', () => {
+    describe('createPhaseHandler', () => {
+        it('creates a Discover handler', async () => {
+            const handler = createPhaseHandler('Discover');
+            expect(handler.phase).toBe('Discover');
+            await handler._preload();
+            const prompt = handler.buildSystemPrompt(makeSession());
+            expect(prompt).toContain('Discover');
+        });
+        it('creates an Ideate handler', async () => {
+            const handler = createPhaseHandler('Ideate');
+            expect(handler.phase).toBe('Ideate');
+            await handler._preload();
+            const prompt = handler.buildSystemPrompt(makeSession());
+            expect(prompt.length).toBeGreaterThan(50);
+        });
+        it('creates a Design handler', async () => {
+            const handler = createPhaseHandler('Design');
+            expect(handler.phase).toBe('Design');
+            await handler._preload();
+            const prompt = handler.buildSystemPrompt(makeSession());
+            expect(prompt.length).toBeGreaterThan(50);
+        });
+        it('creates a Select handler', async () => {
+            const handler = createPhaseHandler('Select');
+            expect(handler.phase).toBe('Select');
+            await handler._preload();
+            const prompt = handler.buildSystemPrompt(makeSession());
+            expect(prompt.length).toBeGreaterThan(50);
+        });
+        it('creates a Plan handler', async () => {
+            const handler = createPhaseHandler('Plan');
+            expect(handler.phase).toBe('Plan');
+            await handler._preload();
+            const prompt = handler.buildSystemPrompt(makeSession());
+            expect(prompt.length).toBeGreaterThan(50);
+        });
+        it('creates a Develop handler', async () => {
+            const handler = createPhaseHandler('Develop');
+            expect(handler.phase).toBe('Develop');
+            await handler._preload();
+            const prompt = handler.buildSystemPrompt(makeSession());
+            expect(prompt.length).toBeGreaterThan(50);
+        });
+    });
+    describe('Discover handler specifics', () => {
+        it('includes grounding references after preload', async () => {
+            const handler = createPhaseHandler('Discover');
+            await handler._preload();
+            const refs = handler.getReferences(makeSession());
+            expect(refs.length).toBeGreaterThan(0);
+        });
+        it('isComplete returns false without business context', () => {
+            const handler = createPhaseHandler('Discover');
+            expect(handler.isComplete(makeSession(), '')).toBe(false);
+        });
+        it('isComplete returns true with business context and workflow', () => {
+            const handler = createPhaseHandler('Discover');
+            const session = makeSession({
+                businessContext: {
+                    businessDescription: 'Widget Co',
+                    challenges: ['Growth'],
+                },
+                workflow: {
+                    activities: [{ id: 'a1', name: 'Activity 1' }],
+                    edges: [],
+                },
+            });
+            expect(handler.isComplete(session, '')).toBe(true);
+        });
+        // T063 — session naming via extractResult
+        it('extractResult sets session.name when sessionName is present in LLM response', () => {
+            const handler = createPhaseHandler('Discover');
+            const session = makeSession();
+            const response = '```json\n{"businessDescription": "Logistics Co", "challenges": ["Routing"], "sessionName": "Logistics AI Routing"}\n```';
+            const result = handler.extractResult(session, response);
+            expect(result.name).toBe('Logistics AI Routing');
+        });
+        it('extractResult does not set session.name when sessionName is absent from LLM response', () => {
+            const handler = createPhaseHandler('Discover');
+            const session = makeSession();
+            const response = '```json\n{"businessDescription": "Tech Co", "challenges": ["Scale"]}\n```';
+            const result = handler.extractResult(session, response);
+            expect(result.name).toBeUndefined();
+        });
+        it('extractResult does not overwrite existing session.name (first-write-wins)', () => {
+            const handler = createPhaseHandler('Discover');
+            const session = makeSession({ name: 'Original Name' });
+            const response = '```json\n{"businessDescription": "Retail Co", "challenges": ["Growth"], "sessionName": "New Name"}\n```';
+            const result = handler.extractResult(session, response);
+            // Should NOT include name in updates since session already has one
+            expect(result.name).toBeUndefined();
+        });
+    });
+    describe('Ideate handler specifics', () => {
+        it('includes business context in prompt when available', async () => {
+            const handler = createPhaseHandler('Ideate');
+            await handler._preload();
+            const session = makeSession({
+                businessContext: {
+                    businessDescription: 'ACME Corp sells rockets',
+                    challenges: ['Supply chain delays'],
+                },
+            });
+            const prompt = handler.buildSystemPrompt(session);
+            expect(prompt).toContain('ACME Corp sells rockets');
+            expect(prompt).toContain('Supply chain delays');
+        });
+        it('isComplete returns true when ideas exist', () => {
+            const handler = createPhaseHandler('Ideate');
+            const session = makeSession({
+                ideas: [
+                    {
+                        id: 'i1',
+                        title: 'Smart Inventory',
+                        description: 'AI-powered inventory management',
+                        workflowStepIds: ['a1'],
+                    },
+                ],
+            });
+            expect(handler.isComplete(session, '')).toBe(true);
+        });
+    });
+    describe('Select handler specifics', () => {
+        it('isComplete returns true when selection is confirmed', () => {
+            const handler = createPhaseHandler('Select');
+            const session = makeSession({
+                selection: {
+                    ideaId: 'i1',
+                    selectionRationale: 'Best fit',
+                    confirmedByUser: true,
+                    confirmedAt: '2025-01-01T00:00:00Z',
+                },
+            });
+            expect(handler.isComplete(session, '')).toBe(true);
+        });
+        it('isComplete returns false when selection not confirmed', () => {
+            const handler = createPhaseHandler('Select');
+            const session = makeSession({
+                selection: {
+                    ideaId: 'i1',
+                    selectionRationale: 'Best fit',
+                    confirmedByUser: false,
+                },
+            });
+            expect(handler.isComplete(session, '')).toBe(false);
+        });
+    });
+    describe('getPhaseOrder', () => {
+        it('returns 6 phases in order', () => {
+            const order = getPhaseOrder();
+            expect(order).toEqual(['Discover', 'Ideate', 'Design', 'Select', 'Plan', 'Develop']);
+        });
+    });
+    describe('getNextPhase', () => {
+        it('returns Ideate after Discover', () => {
+            expect(getNextPhase('Discover')).toBe('Ideate');
+        });
+        it('returns null after Develop', () => {
+            expect(getNextPhase('Develop')).toBeNull();
+        });
+        it('returns null for Complete', () => {
+            expect(getNextPhase('Complete')).toBeNull();
+        });
+    });
+    describe('extractResult integration', () => {
+        it('Discover handler extracts business context from response', () => {
+            const handler = createPhaseHandler('Discover');
+            const session = makeSession();
+            const response = '```json\n{"businessDescription": "Tech Co", "challenges": ["Scale"]}\n```';
+            const result = handler.extractResult(session, response);
+            expect(result.businessContext).toBeDefined();
+            expect(result.businessContext.businessDescription).toBe('Tech Co');
+        });
+        it('Ideate handler extracts ideas from response', () => {
+            const handler = createPhaseHandler('Ideate');
+            const session = makeSession();
+            const response = '```json\n[{"id": "i1", "title": "AI Chat", "description": "Chatbot", "workflowStepIds": ["s1"]}]\n```';
+            const result = handler.extractResult(session, response);
+            expect(result.ideas).toHaveLength(1);
+            expect(result.ideas[0].title).toBe('AI Chat');
+        });
+        it('Ideate handler merges ideas without duplicates', () => {
+            const handler = createPhaseHandler('Ideate');
+            const session = makeSession({
+                ideas: [{ id: 'i1', title: 'Existing', description: 'Already there', workflowStepIds: ['s1'] }],
+            });
+            const response = '```json\n[{"id": "i1", "title": "Dup", "description": "Dup", "workflowStepIds": ["s1"]}, {"id": "i2", "title": "New", "description": "New one", "workflowStepIds": ["s2"]}]\n```';
+            const result = handler.extractResult(session, response);
+            expect(result.ideas).toHaveLength(2);
+            expect(result.ideas[0].title).toBe('Existing');
+            expect(result.ideas[1].title).toBe('New');
+        });
+        it('Design handler extracts evaluation from response', () => {
+            const handler = createPhaseHandler('Design');
+            const session = makeSession();
+            const response = '```json\n{"method": "feasibility-value-matrix", "ideas": [{"ideaId": "i1", "feasibility": 4, "value": 5}]}\n```';
+            const result = handler.extractResult(session, response);
+            expect(result.evaluation).toBeDefined();
+            expect(result.evaluation.method).toBe('feasibility-value-matrix');
+        });
+        it('Select handler extracts selection from response', () => {
+            const handler = createPhaseHandler('Select');
+            const session = makeSession();
+            const response = '```json\n{"ideaId": "i1", "selectionRationale": "Best ROI", "confirmedByUser": true}\n```';
+            const result = handler.extractResult(session, response);
+            expect(result.selection).toBeDefined();
+            expect(result.selection.ideaId).toBe('i1');
+        });
+        it('Plan handler extracts plan from response', () => {
+            const handler = createPhaseHandler('Plan');
+            const session = makeSession();
+            const response = '```json\n{"milestones": [{"id": "m1", "title": "Setup", "items": ["Init repo"]}]}\n```';
+            const result = handler.extractResult(session, response);
+            expect(result.plan).toBeDefined();
+            expect(result.plan.milestones).toHaveLength(1);
+        });
+        it('Develop handler extracts poc state from response', () => {
+            const handler = createPhaseHandler('Develop');
+            const session = makeSession();
+            const response = '```json\n{"repoSource": "local", "iterations": [{"iteration": 1, "startedAt": "2025-01-01T00:00:00Z", "outcome": "scaffold", "filesChanged": []}]}\n```';
+            const result = handler.extractResult(session, response);
+            expect(result.poc).toBeDefined();
+            expect(result.poc.iterations).toHaveLength(1);
+        });
+        it('returns empty object when response has no JSON', () => {
+            const handler = createPhaseHandler('Discover');
+            const result = handler.extractResult(makeSession(), 'Just plain text');
+            expect(result).toEqual({});
+        });
+    });
+    describe('backtrack + recompute (T040)', () => {
+        it('handlers detect cleared state as incomplete after backtrack', () => {
+            // Session that completed Discover and Ideate
+            const session = makeSession({
+                phase: 'Design',
+                businessContext: {
+                    businessDescription: 'ACME',
+                    challenges: ['Growth'],
+                },
+                workflow: {
+                    activities: [{ id: 'a1', name: 'Step 1' }],
+                    edges: [],
+                },
+                ideas: [
+                    { id: 'i1', title: 'Idea A', description: 'Desc', workflowStepIds: ['a1'] },
+                ],
+            });
+            // Backtrack to Ideate: clears ideas (and anything downstream)
+            const result = backtrackSession(session, 'Ideate');
+            expect(result.success).toBe(true);
+            const backtracked = result.session;
+            const ideateHandler = createPhaseHandler('Ideate');
+            // Ideas were cleared, so handler says incomplete
+            expect(ideateHandler.isComplete(backtracked, '')).toBe(false);
+            // Discover data is preserved
+            expect(backtracked.businessContext).toBeDefined();
+        });
+        it('handlers recompute fresh data after backtrack', () => {
+            const session = makeSession({
+                phase: 'Design',
+                businessContext: {
+                    businessDescription: 'ACME',
+                    challenges: ['Growth'],
+                },
+                ideas: [
+                    { id: 'old', title: 'Old Idea', description: 'Was here', workflowStepIds: ['a1'] },
+                ],
+                evaluation: {
+                    method: 'feasibility-value-matrix',
+                    ideas: [{ ideaId: 'old', feasibility: 3, value: 3 }],
+                },
+            });
+            // Backtrack to Ideate clears ideas + evaluation
+            const { session: backtracked } = backtrackSession(session, 'Ideate');
+            expect(backtracked.ideas).toBeUndefined();
+            expect(backtracked.evaluation).toBeUndefined();
+            // Re-running Ideate handler extracts fresh ideas
+            const handler = createPhaseHandler('Ideate');
+            const freshResponse = '```json\n[{"id": "new1", "title": "New Idea", "description": "Fresh", "workflowStepIds": ["a1"]}]\n```';
+            const result = handler.extractResult(backtracked, freshResponse);
+            expect(result.ideas).toHaveLength(1);
+            expect(result.ideas[0].id).toBe('new1');
+        });
+    });
+    // ── T074: getInitialMessage() ──────────────────────────────────────────
+    describe('getInitialMessage (T074)', () => {
+        const phases = ['Discover', 'Ideate', 'Design', 'Select', 'Plan', 'Develop'];
+        it('generates phase introduction for new sessions (no turns)', () => {
+            for (const phase of phases) {
+                const handler = createPhaseHandler(phase);
+                const session = makeSession({ phase, turns: [] });
+                const msg = handler.getInitialMessage(session);
+                expect(msg).toBeDefined();
+                expect(typeof msg).toBe('string');
+                expect(msg.length).toBeGreaterThan(0);
+            }
+        });
+        it('generates progress summary for resumed sessions (existing turns)', () => {
+            for (const phase of phases) {
+                const handler = createPhaseHandler(phase);
+                const session = makeSession({
+                    phase,
+                    turns: [
+                        { phase, sequence: 1, role: 'user', content: 'Previous input', timestamp: '2025-01-01T00:00:00Z' },
+                        { phase, sequence: 2, role: 'assistant', content: 'Previous response', timestamp: '2025-01-01T00:00:00Z' },
+                    ],
+                });
+                const msg = handler.getInitialMessage(session);
+                expect(msg).toBeDefined();
+                expect(typeof msg).toBe('string');
+                expect(msg.length).toBeGreaterThan(0);
+            }
+        });
+        it('returns different messages for new vs resumed sessions', () => {
+            const handler = createPhaseHandler('Discover');
+            const newSession = makeSession({ phase: 'Discover', turns: [] });
+            const resumedSession = makeSession({
+                phase: 'Discover',
+                turns: [
+                    { phase: 'Discover', sequence: 1, role: 'user', content: 'hello', timestamp: '2025-01-01T00:00:00Z' },
+                    { phase: 'Discover', sequence: 2, role: 'assistant', content: 'hi', timestamp: '2025-01-01T00:00:00Z' },
+                ],
+            });
+            const newMsg = handler.getInitialMessage(newSession);
+            const resumedMsg = handler.getInitialMessage(resumedSession);
+            expect(newMsg).not.toBe(resumedMsg);
+        });
+        it('getInitialMessage exists on all 6 phase handlers', () => {
+            for (const phase of phases) {
+                const handler = createPhaseHandler(phase);
+                expect(typeof handler.getInitialMessage).toBe('function');
+            }
+        });
+    });
+    // T040: Verify Ideate handler uses renderSummarizedContext (not ad-hoc context)
+    describe('context summarizer integration', () => {
+        it('Ideate handler uses unified summarized context', async () => {
+            const handler = createPhaseHandler('Ideate');
+            await handler._preload();
+            const session = makeSession({
+                businessContext: {
+                    businessDescription: 'Test Company',
+                    challenges: ['Challenge A'],
+                },
+            });
+            const prompt = handler.buildSystemPrompt(session);
+            expect(prompt).toContain('Test Company');
+            expect(prompt).toContain('Prior Phase Context');
+        });
+        it('Design handler uses unified summarized context with ideas', async () => {
+            const handler = createPhaseHandler('Design');
+            await handler._preload();
+            const session = makeSession({
+                ideas: [
+                    { id: 'idea-1', title: 'AI Bot', description: 'Smart assistant', workflowStepIds: [] },
+                ],
+            });
+            const prompt = handler.buildSystemPrompt(session);
+            expect(prompt).toContain('AI Bot');
+            expect(prompt).toContain('Prior Phase Context');
+        });
+        it('Select handler uses unified summarized context with evaluation', async () => {
+            const handler = createPhaseHandler('Select');
+            await handler._preload();
+            const session = makeSession({
+                evaluation: {
+                    method: 'feasibility-value-matrix',
+                    ideas: [{ ideaId: 'idea-1', feasibility: 8, value: 9 }],
+                },
+            });
+            const prompt = handler.buildSystemPrompt(session);
+            expect(prompt).toContain('feasibility-value-matrix');
+            expect(prompt).toContain('Prior Phase Context');
+        });
+        it('Plan handler uses unified summarized context with selection', async () => {
+            const handler = createPhaseHandler('Plan');
+            await handler._preload();
+            const session = makeSession({
+                selection: {
+                    ideaId: 'idea-1',
+                    selectionRationale: 'Best overall',
+                    confirmedByUser: true,
+                },
+            });
+            const prompt = handler.buildSystemPrompt(session);
+            expect(prompt).toContain('idea-1');
+            expect(prompt).toContain('Prior Phase Context');
+        });
+        it('handlers omit Prior Phase Context section when session is empty', async () => {
+            for (const phase of ['Ideate', 'Design', 'Select', 'Plan', 'Develop']) {
+                const handler = createPhaseHandler(phase);
+                await handler._preload();
+                const prompt = handler.buildSystemPrompt(makeSession());
+                // Should not contain Prior Phase Context if session is empty
+                expect(prompt).not.toContain('Prior Phase Context');
+            }
+        });
+    });
+});

package/dist/tests/unit/prompts/promptLoader.spec.js

@@ -0,0 +1,118 @@
+/**
+ * Prompt loader tests.
+ *
+ * Validates that canonical prompts can be loaded, composed, and
+ * that reference documents are correctly mapped to phases.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { buildSystemPrompt, getPhaseReferences, loadReference, clearPromptCache, listPrompts, listReferences, } from '../../../src/prompts/promptLoader.js';
+describe('promptLoader', () => {
+    beforeEach(() => {
+        clearPromptCache();
+    });
+    describe('buildSystemPrompt', () => {
+        it('loads the base system prompt for Discover phase', async () => {
+            const prompt = await buildSystemPrompt('Discover');
+            expect(prompt).toContain('sofIA');
+            expect(prompt).toContain('AI Discovery Workshop');
+        });
+        it('includes phase-specific content for Discover', async () => {
+            const prompt = await buildSystemPrompt('Discover');
+            expect(prompt).toContain('Understand the Business');
+            expect(prompt).toContain('Choose a Topic');
+            expect(prompt).toContain('Map Workflow');
+        });
+        it('includes phase-specific content for Ideate', async () => {
+            const prompt = await buildSystemPrompt('Ideate');
+            expect(prompt).toContain('AI Envisioning Cards');
+            expect(prompt).toContain('Score Cards');
+            expect(prompt).toContain('Generate Ideas');
+        });
+        it('includes phase-specific content for Design', async () => {
+            const prompt = await buildSystemPrompt('Design');
+            expect(prompt).toContain('Evaluate Ideas');
+            expect(prompt).toContain('Feasibility');
+            expect(prompt).toContain('BXT');
+        });
+        it('includes phase-specific content for Select', async () => {
+            const prompt = await buildSystemPrompt('Select');
+            expect(prompt).toContain('Rank');
+            expect(prompt).toContain('Recommend');
+            expect(prompt).toContain('User Confirmation');
+        });
+        it('includes phase-specific content for Plan', async () => {
+            const prompt = await buildSystemPrompt('Plan');
+            expect(prompt).toContain('milestone');
+            expect(prompt).toContain('Architecture');
+            expect(prompt).toContain('PoC');
+        });
+        it('includes phase-specific content for Develop', async () => {
+            const prompt = await buildSystemPrompt('Develop');
+            expect(prompt).toContain('PoC Requirements');
+            expect(prompt).toContain('Success Criteria');
+        });
+        it('returns only system prompt for Complete phase', async () => {
+            const prompt = await buildSystemPrompt('Complete');
+            // Complete phase gets only the base system prompt
+            expect(prompt).toContain('sofIA');
+            expect(prompt).not.toContain('Understand the Business');
+        });
+        it('caches prompts across calls', async () => {
+            const prompt1 = await buildSystemPrompt('Discover');
+            const prompt2 = await buildSystemPrompt('Discover');
+            expect(prompt1).toBe(prompt2);
+        });
+    });
+    describe('getPhaseReferences', () => {
+        it('returns reference paths for Discover phase', async () => {
+            const refs = await getPhaseReferences('Discover');
+            expect(refs.length).toBeGreaterThan(0);
+            expect(refs.some((r) => r.includes('facilitator_persona'))).toBe(true);
+            expect(refs.some((r) => r.includes('guardrails'))).toBe(true);
+        });
+        it('includes design thinking docs for Ideate phase', async () => {
+            const refs = await getPhaseReferences('Ideate');
+            expect(refs.some((r) => r.includes('design_thinking_persona'))).toBe(true);
+            expect(refs.some((r) => r.includes('design_thinking.md'))).toBe(true);
+        });
+        it('includes document generator for Complete phase', async () => {
+            const refs = await getPhaseReferences('Complete');
+            expect(refs.some((r) => r.includes('document_generator'))).toBe(true);
+        });
+    });
+    describe('loadReference', () => {
+        it('loads facilitator persona reference', async () => {
+            const content = await loadReference('facilitatorPersona');
+            expect(content).toContain('AI Workshop Facilitator');
+        });
+        it('loads design thinking reference', async () => {
+            const content = await loadReference('designThinking');
+            expect(content.length).toBeGreaterThan(100);
+        });
+        it('loads guardrails reference', async () => {
+            const content = await loadReference('guardrails');
+            expect(content).toContain('Guardrails');
+        });
+    });
+    describe('listPrompts', () => {
+        it('returns all prompt names', () => {
+            const prompts = listPrompts();
+            expect(prompts).toContain('system');
+            expect(prompts).toContain('discover');
+            expect(prompts).toContain('ideate');
+            expect(prompts).toContain('design');
+            expect(prompts).toContain('select');
+            expect(prompts).toContain('plan');
+            expect(prompts).toContain('develop');
+        });
+    });
+    describe('listReferences', () => {
+        it('returns all reference document keys', () => {
+            const refs = listReferences();
+            expect(refs).toContain('designThinking');
+            expect(refs).toContain('facilitatorPersona');
+            expect(refs).toContain('guardrails');
+            expect(refs).toContain('documentGenerator');
+        });
+    });
+});