sofia-cli 0.1.1

package/dist/tests/unit/schemas/pocSchemas.spec.js

@@ -0,0 +1,412 @@
+/**
+ * T008: Unit tests for new/extended PoC schemas (Feature 002).
+ *
+ * Tests TechStack, TestResults, TestFailure, extended PocIteration,
+ * and extended PocDevelopmentState schemas.
+ */
+import { describe, it, expect } from 'vitest';
+import { techStackSchema, testFailureSchema, testResultsSchema, pocIterationSchema, pocDevelopmentStateSchema, } from '../../../src/shared/schemas/session.js';
+// ── TechStack ────────────────────────────────────────────────────────────────
+describe('techStackSchema', () => {
+    it('parses a minimal valid tech stack (required fields only)', () => {
+        const result = techStackSchema.safeParse({
+            language: 'TypeScript',
+            testRunner: 'npm test',
+            runtime: 'Node.js 20',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.language).toBe('TypeScript');
+            expect(result.data.testRunner).toBe('npm test');
+            expect(result.data.runtime).toBe('Node.js 20');
+            expect(result.data.framework).toBeUndefined();
+            expect(result.data.buildCommand).toBeUndefined();
+        }
+    });
+    it('parses a full tech stack with optional fields', () => {
+        const result = techStackSchema.safeParse({
+            language: 'TypeScript',
+            framework: 'Express',
+            testRunner: 'npm test',
+            buildCommand: 'npm run build',
+            runtime: 'Node.js 20',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.framework).toBe('Express');
+            expect(result.data.buildCommand).toBe('npm run build');
+        }
+    });
+    it('rejects a tech stack missing required language', () => {
+        const result = techStackSchema.safeParse({
+            testRunner: 'npm test',
+            runtime: 'Node.js 20',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects a tech stack missing required testRunner', () => {
+        const result = techStackSchema.safeParse({
+            language: 'TypeScript',
+            runtime: 'Node.js 20',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects a tech stack missing required runtime', () => {
+        const result = techStackSchema.safeParse({
+            language: 'TypeScript',
+            testRunner: 'npm test',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+// ── TestFailure ──────────────────────────────────────────────────────────────
+describe('testFailureSchema', () => {
+    it('parses a minimal test failure', () => {
+        const result = testFailureSchema.safeParse({
+            testName: 'route optimizer > should return shortest path',
+            message: 'Expected 3 but got 5',
+        });
+        expect(result.success).toBe(true);
+    });
+    it('parses a full test failure with optional fields', () => {
+        const result = testFailureSchema.safeParse({
+            testName: 'route optimizer > should return shortest path',
+            message: 'Expected 3 but got 5',
+            expected: '3',
+            actual: '5',
+            file: 'tests/optimizer.test.ts',
+            line: 42,
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.expected).toBe('3');
+            expect(result.data.actual).toBe('5');
+            expect(result.data.file).toBe('tests/optimizer.test.ts');
+            expect(result.data.line).toBe(42);
+        }
+    });
+    it('rejects a failure missing testName', () => {
+        const result = testFailureSchema.safeParse({
+            message: 'Expected 3 but got 5',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects a failure missing message', () => {
+        const result = testFailureSchema.safeParse({
+            testName: 'route optimizer > should return shortest path',
+        });
+        expect(result.success).toBe(false);
+    });
+});
+// ── TestResults ──────────────────────────────────────────────────────────────
+describe('testResultsSchema', () => {
+    it('parses valid test results where total = passed + failed + skipped', () => {
+        const result = testResultsSchema.safeParse({
+            passed: 3,
+            failed: 1,
+            skipped: 1,
+            total: 5,
+            durationMs: 1234,
+            failures: [{ testName: 'test A', message: 'err' }],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects test results where total !== passed + failed + skipped', () => {
+        const result = testResultsSchema.safeParse({
+            passed: 3,
+            failed: 1,
+            skipped: 0,
+            total: 10, // wrong
+            durationMs: 1234,
+            failures: [],
+        });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.error.issues[0].message).toContain('total must equal');
+        }
+    });
+    it('parses results with zero failures', () => {
+        const result = testResultsSchema.safeParse({
+            passed: 5,
+            failed: 0,
+            skipped: 0,
+            total: 5,
+            durationMs: 500,
+            failures: [],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('parses results with optional rawOutput', () => {
+        const result = testResultsSchema.safeParse({
+            passed: 1,
+            failed: 0,
+            skipped: 0,
+            total: 1,
+            durationMs: 100,
+            failures: [],
+            rawOutput: 'PASS  tests/index.test.ts',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.rawOutput).toBe('PASS  tests/index.test.ts');
+        }
+    });
+    it('allows rawOutput to be omitted', () => {
+        const result = testResultsSchema.safeParse({
+            passed: 1,
+            failed: 0,
+            skipped: 0,
+            total: 1,
+            durationMs: 100,
+            failures: [],
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.rawOutput).toBeUndefined();
+        }
+    });
+    it('handles multiple test failures', () => {
+        const result = testResultsSchema.safeParse({
+            passed: 0,
+            failed: 2,
+            skipped: 0,
+            total: 2,
+            durationMs: 800,
+            failures: [
+                { testName: 'test A', message: 'err A', file: 'tests/a.test.ts', line: 10 },
+                { testName: 'test B', message: 'err B', expected: 'foo', actual: 'bar' },
+            ],
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.failures).toHaveLength(2);
+        }
+    });
+});
+// ── PocIteration (extended) ─────────────────────────────────────────────────
+describe('pocIterationSchema (extended)', () => {
+    it('parses a scaffold iteration', () => {
+        const result = pocIterationSchema.safeParse({
+            iteration: 1,
+            startedAt: '2026-01-15T10:00:00Z',
+            endedAt: '2026-01-15T10:01:00Z',
+            outcome: 'scaffold',
+            filesChanged: ['package.json', 'src/index.ts', 'tests/index.test.ts'],
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.outcome).toBe('scaffold');
+            expect(result.data.filesChanged).toHaveLength(3);
+        }
+    });
+    it('parses a tests-passing iteration with testResults', () => {
+        const result = pocIterationSchema.safeParse({
+            iteration: 2,
+            startedAt: '2026-01-15T10:01:00Z',
+            endedAt: '2026-01-15T10:02:00Z',
+            outcome: 'tests-passing',
+            filesChanged: ['src/index.ts'],
+            testResults: {
+                passed: 3,
+                failed: 0,
+                skipped: 0,
+                total: 3,
+                durationMs: 450,
+                failures: [],
+            },
+        });
+        expect(result.success).toBe(true);
+    });
+    it('parses a tests-failing iteration with failures', () => {
+        const result = pocIterationSchema.safeParse({
+            iteration: 3,
+            startedAt: '2026-01-15T10:02:00Z',
+            outcome: 'tests-failing',
+            filesChanged: ['src/optimizer.ts'],
+            testResults: {
+                passed: 1,
+                failed: 2,
+                skipped: 0,
+                total: 3,
+                durationMs: 600,
+                failures: [{ testName: 'optimizer test', message: 'wrong output' }],
+            },
+        });
+        expect(result.success).toBe(true);
+    });
+    it('parses an error iteration with errorMessage', () => {
+        const result = pocIterationSchema.safeParse({
+            iteration: 4,
+            startedAt: '2026-01-15T10:03:00Z',
+            outcome: 'error',
+            filesChanged: [],
+            errorMessage: 'npm install failed: ENOTFOUND registry.npmjs.org',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.errorMessage).toContain('npm install failed');
+        }
+    });
+    it('rejects invalid outcome enum value', () => {
+        const result = pocIterationSchema.safeParse({
+            iteration: 1,
+            startedAt: '2026-01-15T10:00:00Z',
+            outcome: 'unknown-outcome',
+            filesChanged: [],
+        });
+        expect(result.success).toBe(false);
+    });
+    it('defaults outcome to scaffold when omitted', () => {
+        const result = pocIterationSchema.safeParse({
+            iteration: 1,
+            startedAt: '2026-01-15T10:00:00Z',
+            filesChanged: [],
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.outcome).toBe('scaffold');
+        }
+    });
+    it('defaults filesChanged to empty array when omitted', () => {
+        const result = pocIterationSchema.safeParse({
+            iteration: 1,
+            startedAt: '2026-01-15T10:00:00Z',
+            outcome: 'scaffold',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.filesChanged).toEqual([]);
+        }
+    });
+    it('preserves optional testsRun field for backward compatibility', () => {
+        const result = pocIterationSchema.safeParse({
+            iteration: 1,
+            startedAt: '2026-01-15T10:00:00Z',
+            outcome: 'scaffold',
+            filesChanged: [],
+            testsRun: ['tests/old.spec.ts'], // legacy field
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.testsRun).toEqual(['tests/old.spec.ts']);
+        }
+    });
+    it('parses iteration with llmPromptContext for auditability', () => {
+        const result = pocIterationSchema.safeParse({
+            iteration: 2,
+            startedAt: '2026-01-15T10:01:00Z',
+            outcome: 'tests-failing',
+            filesChanged: [],
+            llmPromptContext: 'Iteration 2 of 5, 2 failures, files: src/index.ts',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.llmPromptContext).toContain('Iteration 2');
+        }
+    });
+});
+// ── PocDevelopmentState (extended) ─────────────────────────────────────────
+describe('pocDevelopmentStateSchema (extended)', () => {
+    it('parses a minimal poc state with repoSource=local', () => {
+        const result = pocDevelopmentStateSchema.safeParse({
+            repoSource: 'local',
+            iterations: [],
+        });
+        expect(result.success).toBe(true);
+    });
+    it('rejects a poc state with repoSource=github-mcp (always-local policy)', () => {
+        const result = pocDevelopmentStateSchema.safeParse({
+            repoSource: 'github-mcp',
+            repoUrl: 'https://github.com/acme/poc-route-optimizer',
+            iterations: [],
+        });
+        expect(result.success).toBe(false);
+    });
+    it('parses a completed poc state with all fields', () => {
+        const result = pocDevelopmentStateSchema.safeParse({
+            repoSource: 'local',
+            repoPath: './poc/fixture-session-001',
+            techStack: {
+                language: 'TypeScript',
+                testRunner: 'npm test',
+                runtime: 'Node.js 20',
+            },
+            iterations: [
+                {
+                    iteration: 1,
+                    startedAt: '2026-01-15T10:00:00Z',
+                    outcome: 'scaffold',
+                    filesChanged: ['package.json'],
+                },
+            ],
+            finalStatus: 'success',
+            terminationReason: 'tests-passing',
+            totalDurationMs: 45000,
+            finalTestResults: {
+                passed: 3,
+                failed: 0,
+                skipped: 0,
+                total: 3,
+                durationMs: 400,
+                failures: [],
+            },
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.finalStatus).toBe('success');
+            expect(result.data.terminationReason).toBe('tests-passing');
+        }
+    });
+    it('accepts finalStatus "partial" (new in Feature 002)', () => {
+        const result = pocDevelopmentStateSchema.safeParse({
+            repoSource: 'local',
+            iterations: [],
+            finalStatus: 'partial',
+            terminationReason: 'max-iterations',
+        });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data.finalStatus).toBe('partial');
+        }
+    });
+    it('rejects invalid repoSource', () => {
+        const result = pocDevelopmentStateSchema.safeParse({
+            repoSource: 'bitbucket',
+            iterations: [],
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid terminationReason', () => {
+        const result = pocDevelopmentStateSchema.safeParse({
+            repoSource: 'local',
+            iterations: [],
+            terminationReason: 'timeout',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects invalid finalStatus', () => {
+        const result = pocDevelopmentStateSchema.safeParse({
+            repoSource: 'local',
+            iterations: [],
+            finalStatus: 'abandoned',
+        });
+        expect(result.success).toBe(false);
+    });
+    it('rejects missing repoSource', () => {
+        const result = pocDevelopmentStateSchema.safeParse({
+            iterations: [],
+        });
+        expect(result.success).toBe(false);
+    });
+    it('accepts all valid terminationReason values', () => {
+        const reasons = ['tests-passing', 'max-iterations', 'user-stopped', 'error'];
+        for (const reason of reasons) {
+            const result = pocDevelopmentStateSchema.safeParse({
+                repoSource: 'local',
+                iterations: [],
+                terminationReason: reason,
+            });
+            expect(result.success, `Expected ${reason} to be valid`).toBe(true);
+        }
+    });
+});

package/dist/tests/unit/schemas/session.spec.js

@@ -0,0 +1,257 @@
+/**
+ * Unit tests for WorkshopSession Zod schemas.
+ *
+ * Validates that the session data model matches the spec in data-model.md
+ * and the contract in contracts/session-json.md.
+ */
+import { describe, it, expect } from 'vitest';
+import { Phase, SessionStatus, workshopSessionSchema, } from '../../../src/shared/schemas/session.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function validSession(overrides = {}) {
+    return {
+        sessionId: 'test-001',
+        schemaVersion: '1',
+        createdAt: '2026-01-01T00:00:00Z',
+        updatedAt: '2026-01-01T00:00:00Z',
+        phase: 'Discover',
+        status: 'Active',
+        participants: [],
+        artifacts: { generatedFiles: [] },
+        ...overrides,
+    };
+}
+// ── Phase enum ───────────────────────────────────────────────────────────────
+describe('Phase', () => {
+    it('contains all seven governed phases', () => {
+        const expected = [
+            'Discover',
+            'Ideate',
+            'Design',
+            'Select',
+            'Plan',
+            'Develop',
+            'Complete',
+        ];
+        expect(Phase).toEqual(expected);
+    });
+});
+// ── SessionStatus enum ───────────────────────────────────────────────────────
+describe('SessionStatus', () => {
+    it('contains Active, Paused, Completed, Errored', () => {
+        expect(SessionStatus).toEqual(['Active', 'Paused', 'Completed', 'Errored']);
+    });
+});
+// ── workshopSessionSchema ────────────────────────────────────────────────────
+describe('workshopSessionSchema', () => {
+    it('parses a minimal valid session', () => {
+        const result = workshopSessionSchema.parse(validSession());
+        expect(result.sessionId).toBe('test-001');
+        expect(result.phase).toBe('Discover');
+        expect(result.status).toBe('Active');
+    });
+    it('rejects missing required field sessionId', () => {
+        const data = validSession();
+        delete data.sessionId;
+        expect(() => workshopSessionSchema.parse(data)).toThrow();
+    });
+    it('rejects invalid phase value', () => {
+        expect(() => workshopSessionSchema.parse(validSession({ phase: 'InvalidPhase' }))).toThrow();
+    });
+    it('rejects invalid status value', () => {
+        expect(() => workshopSessionSchema.parse(validSession({ status: 'Nope' }))).toThrow();
+    });
+    it('accepts optional entity fields', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            businessContext: {
+                businessDescription: 'A retail company',
+                challenges: ['inventory tracking'],
+            },
+            topic: { topicArea: 'Supply Chain' },
+        }));
+        expect(result.businessContext?.businessDescription).toBe('A retail company');
+        expect(result.topic?.topicArea).toBe('Supply Chain');
+    });
+    it('preserves unknown extra fields (forward compat)', () => {
+        const base = validSession();
+        base.futureField = 'hello';
+        const result = workshopSessionSchema.parse(base);
+        // Zod passthrough should keep the extra field
+        expect(result.futureField).toBe('hello');
+    });
+    it('handles a full session with ideas and evaluation', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            ideas: [
+                {
+                    id: 'idea-1',
+                    title: 'Smart Onboarding',
+                    description: 'AI-guided onboarding',
+                    workflowStepIds: ['step-1'],
+                },
+            ],
+            evaluation: {
+                ideas: [
+                    {
+                        ideaId: 'idea-1',
+                        feasibility: 4,
+                        value: 5,
+                    },
+                ],
+                method: 'feasibility-value-matrix',
+            },
+        }));
+        expect(result.ideas).toHaveLength(1);
+        expect(result.evaluation?.method).toBe('feasibility-value-matrix');
+    });
+    it('validates participant roles', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            participants: [
+                { id: 'p1', displayName: 'Alice', role: 'Facilitator' },
+                { id: 'p2', displayName: 'Bob', role: 'Attendee' },
+            ],
+        }));
+        expect(result.participants).toHaveLength(2);
+    });
+    it('rejects invalid participant role', () => {
+        expect(() => workshopSessionSchema.parse(validSession({
+            participants: [{ id: 'p1', displayName: 'Alice', role: 'Admin' }],
+        }))).toThrow();
+    });
+    it('validates ConversationTurn array in turns', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            turns: [
+                {
+                    phase: 'Discover',
+                    sequence: 1,
+                    role: 'user',
+                    content: 'We are a retail company',
+                    timestamp: '2026-01-01T00:01:00Z',
+                },
+                {
+                    phase: 'Discover',
+                    sequence: 2,
+                    role: 'assistant',
+                    content: 'Got it! Tell me more about your challenges.',
+                    timestamp: '2026-01-01T00:02:00Z',
+                },
+            ],
+        }));
+        expect(result.turns).toHaveLength(2);
+    });
+    it('validates ArtifactIndex with generated files', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            artifacts: {
+                exportDir: './exports/test-001/',
+                generatedFiles: [
+                    {
+                        relativePath: 'discover.md',
+                        type: 'markdown',
+                        createdAt: '2026-01-01T00:05:00Z',
+                    },
+                ],
+            },
+        }));
+        expect(result.artifacts.generatedFiles).toHaveLength(1);
+    });
+    it('validates PocDevelopmentState', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            poc: {
+                repoSource: 'local',
+                iterations: [],
+            },
+        }));
+        expect(result.poc?.iterations).toEqual([]);
+    });
+    it('validates ImplementationPlan with milestones', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            plan: {
+                milestones: [
+                    { id: 'm1', title: 'Phase 1', items: ['Setup', 'Build'] },
+                ],
+            },
+        }));
+        expect(result.plan?.milestones).toHaveLength(1);
+    });
+    it('validates BXT evaluation with classification', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            evaluation: {
+                ideas: [
+                    {
+                        ideaId: 'idea-1',
+                        feasibility: 3,
+                        value: 4,
+                        risks: ['Data quality'],
+                        dataNeeded: ['CRM data'],
+                        humanValue: ['Time savings'],
+                        kpisInfluenced: ['CSAT'],
+                    },
+                ],
+                method: 'feasibility-value-matrix',
+            },
+        }));
+        expect(result.evaluation?.ideas[0].risks).toContain('Data quality');
+    });
+    it('validates SelectedIdea', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            selection: {
+                ideaId: 'idea-1',
+                selectionRationale: 'Highest BXT score',
+                confirmedByUser: true,
+                confirmedAt: '2026-01-01T01:00:00Z',
+            },
+        }));
+        expect(result.selection?.confirmedByUser).toBe(true);
+    });
+    it('validates WorkflowMap with steps and edges', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            workflow: {
+                activities: [
+                    { id: 'step-1', name: 'Receive Order' },
+                    { id: 'step-2', name: 'Process Payment' },
+                ],
+                edges: [{ fromStepId: 'step-1', toStepId: 'step-2' }],
+            },
+        }));
+        expect(result.workflow?.activities).toHaveLength(2);
+        expect(result.workflow?.edges).toHaveLength(1);
+    });
+    it('validates CardSelection', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            cards: {
+                selectedCards: [
+                    { id: 'extract-information', title: 'Extract Information' },
+                ],
+                scores: [
+                    {
+                        cardId: 'extract-information',
+                        dimensions: { relevance: 5, feasibility: 3 },
+                    },
+                ],
+            },
+        }));
+        expect(result.cards?.selectedCards).toHaveLength(1);
+    });
+    // ── T061: name field tests ─────────────────────────────────────────────────
+    it('accepts optional name field as string', () => {
+        const result = workshopSessionSchema.parse(validSession({ name: 'Logistics AI Routing' }));
+        expect(result.name).toBe('Logistics AI Routing');
+    });
+    it('omits name field gracefully when not provided', () => {
+        const result = workshopSessionSchema.parse(validSession());
+        expect(result.name).toBeUndefined();
+    });
+    it('rejects non-string name field', () => {
+        expect(() => workshopSessionSchema.parse(validSession({ name: 42 }))).toThrow();
+    });
+    it('validates ErrorRecord array', () => {
+        const result = workshopSessionSchema.parse(validSession({
+            errors: [
+                {
+                    timestamp: '2026-01-01T00:10:00Z',
+                    code: 'MCP_TIMEOUT',
+                    message: 'WorkIQ timed out after 30s',
+                },
+            ],
+        }));
+        expect(result.errors).toHaveLength(1);
+    });
+});