sofia-cli 0.1.1

package/tests/unit/phases/phaseExtractors.spec.ts

@@ -0,0 +1,406 @@
+/**
+ * Phase extraction logic tests.
+ *
+ * Tests for extractResult() implementations that parse structured JSON
+ * blocks from LLM responses and map them to WorkshopSession fields.
+ */
+import { describe, it, expect } from 'vitest';
+
+import {
+  extractJsonBlock,
+  extractBusinessContext,
+  extractWorkflow,
+  extractIdeas,
+  extractEvaluation,
+  extractSelection,
+  extractPlan,
+  extractPocState,
+  extractSessionName,
+  extractAllJsonBlocks,
+  extractJsonBlockForSchema,
+} from '../../../src/phases/phaseExtractors.js';
+import type { WorkshopSession } from '../../../src/shared/schemas/session.js';
+import { z } from '../../../src/vendor/zod.js';
+
+function _emptySession(): WorkshopSession {
+  return {
+    sessionId: 'test-1',
+    schemaVersion: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-01-01T00:00:00Z',
+    phase: 'Discover',
+    status: 'Active',
+    participants: [],
+    artifacts: { generatedFiles: [] },
+    turns: [],
+  };
+}
+
+describe('extractJsonBlock', () => {
+  it('extracts JSON from markdown code fence', () => {
+    const response = `Here are the results:\n\`\`\`json\n{"key": "value"}\n\`\`\`\nDone.`;
+    const result = extractJsonBlock(response);
+    expect(result).toEqual({ key: 'value' });
+  });
+
+  it('extracts JSON from unfenced block', () => {
+    const response = `Result: {"businessDescription": "A company"}`;
+    const result = extractJsonBlock(response);
+    expect(result).toEqual({ businessDescription: 'A company' });
+  });
+
+  it('returns null when no JSON found', () => {
+    const response = 'This is a plain text response with no JSON.';
+    const result = extractJsonBlock(response);
+    expect(result).toBeNull();
+  });
+
+  it('handles malformed JSON gracefully', () => {
+    const response = '```json\n{broken: json}\n```';
+    const result = extractJsonBlock(response);
+    expect(result).toBeNull();
+  });
+
+  it('extracts JSON array from code fence', () => {
+    const response = '```json\n[{"id": "1"}, {"id": "2"}]\n```';
+    const result = extractJsonBlock(response);
+    expect(result).toEqual([{ id: '1' }, { id: '2' }]);
+  });
+});
+
+describe('extractBusinessContext', () => {
+  it('extracts valid business context from response', () => {
+    const response = `Here's what I gathered:
+
+\`\`\`json
+{
+  "businessDescription": "A logistics company",
+  "challenges": ["Slow routing", "High costs"]
+}
+\`\`\``;
+    const result = extractBusinessContext(response);
+    expect(result).not.toBeNull();
+    expect(result!.businessDescription).toBe('A logistics company');
+    expect(result!.challenges).toEqual(['Slow routing', 'High costs']);
+  });
+
+  it('returns null for non-matching JSON', () => {
+    const response = '```json\n{"unrelated": "data"}\n```';
+    const result = extractBusinessContext(response);
+    expect(result).toBeNull();
+  });
+
+  it('returns null when no JSON present', () => {
+    const result = extractBusinessContext('No structured data here.');
+    expect(result).toBeNull();
+  });
+
+  it('includes optional fields when present', () => {
+    const response = `\`\`\`json
+{
+  "businessDescription": "SaaS platform",
+  "challenges": ["Scale"],
+  "constraints": ["Budget limited"],
+  "successMetrics": [{"name": "Revenue", "value": "10M", "unit": "USD"}]
+}
+\`\`\``;
+    const result = extractBusinessContext(response);
+    expect(result!.constraints).toEqual(['Budget limited']);
+    expect(result!.successMetrics).toHaveLength(1);
+  });
+});
+
+describe('extractWorkflow', () => {
+  it('extracts workflow map with activities and edges', () => {
+    const response = `\`\`\`json
+{
+  "activities": [
+    {"id": "s1", "name": "Receive Order"},
+    {"id": "s2", "name": "Process Order"}
+  ],
+  "edges": [
+    {"fromStepId": "s1", "toStepId": "s2"}
+  ]
+}
+\`\`\``;
+    const result = extractWorkflow(response);
+    expect(result).not.toBeNull();
+    expect(result!.activities).toHaveLength(2);
+    expect(result!.edges).toHaveLength(1);
+  });
+
+  it('returns null for invalid workflow', () => {
+    const response = '```json\n{"name": "not a workflow"}\n```';
+    const result = extractWorkflow(response);
+    expect(result).toBeNull();
+  });
+});
+
+describe('extractIdeas', () => {
+  it('extracts array of idea cards', () => {
+    const response = `\`\`\`json
+[
+  {
+    "id": "idea-1",
+    "title": "AI Routing",
+    "description": "Use AI to optimize delivery routes",
+    "workflowStepIds": ["s1", "s2"]
+  }
+]
+\`\`\``;
+    const result = extractIdeas(response);
+    expect(result).toHaveLength(1);
+    expect(result![0].title).toBe('AI Routing');
+  });
+
+  it('extracts ideas from object wrapper', () => {
+    const response = `\`\`\`json
+{
+  "ideas": [
+    {
+      "id": "idea-1",
+      "title": "AI Routing",
+      "description": "Optimize routes",
+      "workflowStepIds": ["s1"]
+    }
+  ]
+}
+\`\`\``;
+    const result = extractIdeas(response);
+    expect(result).toHaveLength(1);
+  });
+
+  it('returns null when no ideas found', () => {
+    const result = extractIdeas('No ideas in this response');
+    expect(result).toBeNull();
+  });
+});
+
+describe('extractEvaluation', () => {
+  it('extracts evaluation with method', () => {
+    const response = `\`\`\`json
+{
+  "method": "feasibility-value-matrix",
+  "ideas": [
+    {
+      "ideaId": "idea-1",
+      "feasibility": 4,
+      "value": 5,
+      "risks": ["Data quality"]
+    }
+  ]
+}
+\`\`\``;
+    const result = extractEvaluation(response);
+    expect(result).not.toBeNull();
+    expect(result!.method).toBe('feasibility-value-matrix');
+    expect(result!.ideas).toHaveLength(1);
+  });
+
+  it('returns null for non-evaluation JSON', () => {
+    const result = extractEvaluation('```json\n{"foo": "bar"}\n```');
+    expect(result).toBeNull();
+  });
+});
+
+describe('extractSelection', () => {
+  it('extracts selected idea', () => {
+    const response = `\`\`\`json
+{
+  "ideaId": "idea-1",
+  "selectionRationale": "Highest combined score",
+  "confirmedByUser": false
+}
+\`\`\``;
+    const result = extractSelection(response);
+    expect(result).not.toBeNull();
+    expect(result!.ideaId).toBe('idea-1');
+    expect(result!.confirmedByUser).toBe(false);
+  });
+});
+
+describe('extractPlan', () => {
+  it('extracts implementation plan with milestones', () => {
+    const response = `\`\`\`json
+{
+  "milestones": [
+    {
+      "id": "m1",
+      "title": "Setup",
+      "items": ["Initialize project", "Configure CI"]
+    },
+    {
+      "id": "m2",
+      "title": "Core Features",
+      "items": ["Implement routing", "Add monitoring"]
+    }
+  ],
+  "architectureNotes": "Microservices architecture",
+  "dependencies": ["Azure Maps API"]
+}
+\`\`\``;
+    const result = extractPlan(response);
+    expect(result).not.toBeNull();
+    expect(result!.milestones).toHaveLength(2);
+    expect(result!.architectureNotes).toBe('Microservices architecture');
+  });
+});
+
+describe('extractPocState', () => {
+  it('extracts PoC development state', () => {
+    const response = `\`\`\`json
+{
+  "repoSource": "local",
+  "iterations": [
+    {
+      "iteration": 1,
+      "startedAt": "2025-01-01T00:00:00Z",
+      "outcome": "scaffold",
+      "filesChanged": ["package.json", "src/index.ts"],
+      "changesSummary": "Initial scaffold"
+    }
+  ]
+}
+\`\`\``;
+    const result = extractPocState(response);
+    expect(result).not.toBeNull();
+    expect(result!.iterations).toHaveLength(1);
+  });
+
+  it('returns null when no PoC data', () => {
+    const result = extractPocState('Just text here');
+    expect(result).toBeNull();
+  });
+});
+
+// ── T062: extractSessionName ─────────────────────────────────────────────────
+
+describe('extractSessionName', () => {
+  it('extracts sessionName from JSON block in response', () => {
+    const response = `Here's the summary:
+
+\`\`\`json
+{
+  "businessDescription": "A logistics company",
+  "challenges": ["Slow routing"],
+  "sessionName": "Logistics AI Routing"
+}
+\`\`\``;
+    const result = extractSessionName(response);
+    expect(result).toBe('Logistics AI Routing');
+  });
+
+  it('returns null when sessionName is missing from JSON block', () => {
+    const response = `\`\`\`json
+{
+  "businessDescription": "A company",
+  "challenges": ["Growth"]
+}
+\`\`\``;
+    const result = extractSessionName(response);
+    expect(result).toBeNull();
+  });
+
+  it('returns null when no JSON block is present', () => {
+    const result = extractSessionName('Just a plain text response with no JSON.');
+    expect(result).toBeNull();
+  });
+
+  it('returns null when sessionName is not a string', () => {
+    const response = `\`\`\`json
+{ "sessionName": 42 }
+\`\`\``;
+    const result = extractSessionName(response);
+    expect(result).toBeNull();
+  });
+
+  it('trims whitespace from sessionName', () => {
+    const response = `\`\`\`json
+{ "sessionName": "  Retail AI Onboarding  " }
+\`\`\``;
+    const result = extractSessionName(response);
+    expect(result).toBe('Retail AI Onboarding');
+  });
+
+  it('returns null for empty string sessionName', () => {
+    const response = `\`\`\`json
+{ "sessionName": "" }
+\`\`\``;
+    const result = extractSessionName(response);
+    expect(result).toBeNull();
+  });
+});
+
+// ── Multi-block extraction tests (T006, T007) ──────────────────────────────
+
+describe('extractAllJsonBlocks', () => {
+  it('returns empty array when no JSON blocks found', () => {
+    const response = 'This is a plain text response with no JSON.';
+    expect(extractAllJsonBlocks(response)).toEqual([]);
+  });
+
+  it('extracts a single fenced JSON block', () => {
+    const response = `Here are the results:\n\`\`\`json\n{"key": "value"}\n\`\`\`\nDone.`;
+    const results = extractAllJsonBlocks(response);
+    expect(results).toEqual([{ key: 'value' }]);
+  });
+
+  it('extracts two fenced JSON blocks', () => {
+    const response = `First:\n\`\`\`json\n{"a": 1}\n\`\`\`\nSecond:\n\`\`\`json\n{"b": 2}\n\`\`\``;
+    const results = extractAllJsonBlocks(response);
+    expect(results).toHaveLength(2);
+    expect(results[0]).toEqual({ a: 1 });
+    expect(results[1]).toEqual({ b: 2 });
+  });
+
+  it('extracts three fenced JSON blocks', () => {
+    const response = `\`\`\`json\n[1]\n\`\`\`\n\`\`\`json\n[2]\n\`\`\`\n\`\`\`json\n[3]\n\`\`\``;
+    const results = extractAllJsonBlocks(response);
+    expect(results).toHaveLength(3);
+  });
+
+  it('falls back to bracket-depth counting when no fenced blocks', () => {
+    const response = 'Result: {"key": "value"} and also [1, 2, 3]';
+    const results = extractAllJsonBlocks(response);
+    expect(results).toHaveLength(2);
+    expect(results[0]).toEqual({ key: 'value' });
+    expect(results[1]).toEqual([1, 2, 3]);
+  });
+
+  it('skips invalid JSON in fenced blocks', () => {
+    const response = `\`\`\`json\n{invalid}\n\`\`\`\n\`\`\`json\n{"valid": true}\n\`\`\``;
+    const results = extractAllJsonBlocks(response);
+    expect(results).toEqual([{ valid: true }]);
+  });
+});
+
+describe('extractJsonBlockForSchema', () => {
+  const simpleSchema = z.object({
+    name: z.string(),
+    age: z.number(),
+  });
+
+  it('returns null when no blocks match schema', () => {
+    const response = `\`\`\`json\n{"unrelated": true}\n\`\`\``;
+    expect(extractJsonBlockForSchema(response, simpleSchema)).toBeNull();
+  });
+
+  it('returns the first matching block when multiple blocks present', () => {
+    const response = `\`\`\`json\n{"unrelated": true}\n\`\`\`\n\`\`\`json\n{"name": "Alice", "age": 30}\n\`\`\``;
+    const result = extractJsonBlockForSchema(response, simpleSchema);
+    expect(result).toEqual({ name: 'Alice', age: 30 });
+  });
+
+  it('skips first block that does not match and returns second that does', () => {
+    const response = `\`\`\`json\n{"name": 123}\n\`\`\`\n\`\`\`json\n{"name": "Bob", "age": 25}\n\`\`\``;
+    const result = extractJsonBlockForSchema(response, simpleSchema);
+    expect(result).toEqual({ name: 'Bob', age: 25 });
+  });
+
+  it('works with array schemas', () => {
+    const arraySchema = z.array(z.object({ id: z.string() }));
+    const response = `\`\`\`json\n{"not": "array"}\n\`\`\`\n\`\`\`json\n[{"id": "a"}]\n\`\`\``;
+    const result = extractJsonBlockForSchema(response, arraySchema);
+    expect(result).toEqual([{ id: 'a' }]);
+  });
+});