sofia-cli 0.1.1

package/tests/integration/directCommandTty.spec.ts

@@ -0,0 +1,185 @@
+/**
+ * Integration test: Direct command TTY mode (T045)
+ *
+ * Tests direct command entry with --session and --phase flags
+ * in a TTY environment where interactive prompts are available.
+ *
+ * Verifies:
+ * - `--session <id> --phase <phase>` jumps to the requested phase
+ * - Session is loaded and used for the conversation loop
+ * - TTY mode prompts for missing inputs
+ * - Decision gates work in direct TTY mode
+ * - Session state is correctly updated after direct phase run
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import type { LoopIO, DecisionGateResult } from '../../src/loop/conversationLoop.js';
+import { createFakeCopilotClient } from '../../src/shared/copilotClient.js';
+import type { WorkshopSession, PhaseValue } from '../../src/shared/schemas/session.js';
+import { SessionStore } from '../../src/sessions/sessionStore.js';
+import {
+  runDirectCommand,
+} from '../../src/cli/directCommands.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function createTestSession(overrides?: Partial<WorkshopSession>): WorkshopSession {
+  const now = new Date().toISOString();
+  return {
+    sessionId: 'test-direct-tty',
+    schemaVersion: '1.0.0',
+    createdAt: now,
+    updatedAt: now,
+    phase: 'Discover',
+    status: 'Active',
+    participants: [],
+    artifacts: { generatedFiles: [] },
+    turns: [],
+    ...overrides,
+  };
+}
+
+function createScriptedIO(
+  inputs: (string | null)[],
+  decisionGateChoice: DecisionGateResult = { choice: 'exit' },
+): LoopIO & { output: string[]; activityLog: string[] } {
+  let inputIdx = 0;
+  const output: string[] = [];
+  const activityLog: string[] = [];
+
+  return {
+    write(text: string) { output.push(text); },
+    writeActivity(text: string) { activityLog.push(text); },
+    writeToolSummary(_toolName: string, _summary: string) {},
+    async readInput(_prompt?: string): Promise<string | null> {
+      if (inputIdx >= inputs.length) return null;
+      return inputs[inputIdx++];
+    },
+    async showDecisionGate(_phase: PhaseValue): Promise<DecisionGateResult> {
+      return decisionGateChoice;
+    },
+    isJsonMode: false,
+    isTTY: true,
+    output,
+    activityLog,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('Direct command TTY mode', () => {
+  let tmpDir: string;
+  let store: SessionStore;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'sofia-direct-tty-'));
+    store = new SessionStore(tmpDir);
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('runs a specific phase with --session and --phase', async () => {
+    const session = createTestSession({ phase: 'Ideate' });
+    await store.save(session);
+
+    const io = createScriptedIO(['Here are some ideas about AI automation'], { choice: 'exit' });
+    const client = createFakeCopilotClient([
+      { role: 'assistant', content: '{"ideas": [{"title": "AI Helper", "description": "An AI assistant"}]}' },
+    ]);
+
+    const result = await runDirectCommand({
+      sessionId: session.sessionId,
+      phase: 'Ideate',
+      store,
+      client,
+      io,
+    });
+
+    expect(result.exitCode).toBe(0);
+    const loaded = await store.load(session.sessionId);
+    expect(loaded.phase).toBe('Ideate');
+  });
+
+  it('prompts for missing input in TTY mode', async () => {
+    const session = createTestSession();
+    await store.save(session);
+
+    const io = createScriptedIO(['My business is a retail company'], { choice: 'exit' });
+    const client = createFakeCopilotClient([
+      { role: 'assistant', content: 'Thank you. Let me analyze your business context.' },
+    ]);
+
+    const result = await runDirectCommand({
+      sessionId: session.sessionId,
+      phase: 'Discover',
+      store,
+      client,
+      io,
+    });
+
+    // TTY mode should succeed — it can prompt
+    expect(result.exitCode).toBe(0);
+  });
+
+  it('returns error when session not found', async () => {
+    const io = createScriptedIO([]);
+    const client = createFakeCopilotClient([]);
+
+    const result = await runDirectCommand({
+      sessionId: 'nonexistent-session',
+      phase: 'Discover',
+      store,
+      client,
+      io,
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.error).toContain('not found');
+  });
+
+  it('returns error for invalid phase', async () => {
+    const session = createTestSession();
+    await store.save(session);
+
+    const io = createScriptedIO([]);
+    const client = createFakeCopilotClient([]);
+
+    const result = await runDirectCommand({
+      sessionId: session.sessionId,
+      phase: 'InvalidPhase' as PhaseValue,
+      store,
+      client,
+      io,
+    });
+
+    expect(result.exitCode).toBe(1);
+    expect(result.error).toContain('Invalid phase');
+  });
+
+  it('persists session after running a phase', async () => {
+    const session = createTestSession({ phase: 'Discover' });
+    await store.save(session);
+
+    const io = createScriptedIO(['We are a tech company'], { choice: 'exit' });
+    const client = createFakeCopilotClient([
+      { role: 'assistant', content: 'Great, I understand your business context.' },
+    ]);
+
+    await runDirectCommand({
+      sessionId: session.sessionId,
+      phase: 'Discover',
+      store,
+      client,
+      io,
+    });
+
+    const loaded = await store.load(session.sessionId);
+    expect(loaded.updatedAt).not.toBe(session.updatedAt);
+    expect(loaded.turns!.length).toBeGreaterThan(0);
+  });
+});

package/tests/integration/discoveryEnrichmentFlow.spec.ts

@@ -0,0 +1,209 @@
+/**
+ * Integration test for Discovery Phase Enrichment Flow (T029).
+ *
+ * Simulates Step 1 completion in the discover handler and verifies:
+ * - The user is offered web search enrichment when available
+ * - DiscoveryEnricher.enrichFromWebSearch() is called when web search provided
+ * - Session is updated with discovery.enrichment
+ * - Enrichment data is included in the Ideate phase system prompt
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+import { createPhaseHandler } from '../../src/phases/phaseHandlers.js';
+import type { WebSearchClient } from '../../src/phases/discoveryEnricher.js';
+import type { LoopIO } from '../../src/loop/conversationLoop.js';
+import type { McpManager } from '../../src/mcp/mcpManager.js';
+import type { WorkshopSession } from '../../src/shared/schemas/session.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeSession(overrides?: Partial<WorkshopSession>): WorkshopSession {
+  return {
+    sessionId: 'test-session',
+    schemaVersion: '0.3.0',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    phase: 'Discover' as const,
+    status: 'Active' as const,
+    participants: [],
+    artifacts: { generatedFiles: [] },
+    ...overrides,
+  };
+}
+
+function makeLoopIO(): LoopIO {
+  return {
+    write: vi.fn(),
+    writeActivity: vi.fn(),
+    writeToolSummary: vi.fn(),
+    readInput: vi.fn().mockResolvedValue('n'),
+    showDecisionGate: vi.fn().mockResolvedValue({ choice: 'continue' }),
+    isJsonMode: false,
+    isTTY: true,
+  };
+}
+
+function makeMcpManager(): McpManager {
+  return {
+    isAvailable: vi.fn().mockReturnValue(false),
+    callTool: vi.fn().mockResolvedValue({}),
+    markConnected: vi.fn(),
+    markDisconnected: vi.fn(),
+    disconnectAll: vi.fn().mockResolvedValue(undefined),
+  } as unknown as McpManager;
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('Discovery enrichment integration flow (T029)', () => {
+  let io: LoopIO;
+  let mcpManager: McpManager;
+  let webSearchClient: WebSearchClient;
+
+  beforeEach(() => {
+    io = makeLoopIO();
+    mcpManager = makeMcpManager();
+    webSearchClient = {
+      search: vi.fn().mockResolvedValue({
+        results: [
+          {
+            title: 'Acme launches AI',
+            url: 'https://news.com/1',
+            snippet: 'Acme Corp announced a new AI product',
+          },
+        ],
+        degraded: false,
+      }),
+    };
+  });
+
+  it('runs enrichment via postExtract when businessContext is available and webSearchClient provided', async () => {
+    const handler = createPhaseHandler('Discover', {
+      discover: { io, mcpManager, webSearchClient },
+    });
+    await handler._preload();
+
+    const session = makeSession({
+      businessContext: {
+        businessDescription: 'Acme Corp manufactures widgets and is exploring AI',
+        challenges: ['efficiency', 'quality control'],
+      },
+    });
+
+    // postExtract should trigger enrichment
+    const updates = await handler.postExtract!(session);
+
+    expect(updates.discovery).toBeDefined();
+    expect(updates.discovery!.enrichment).toBeDefined();
+    expect(updates.discovery!.enrichment!.sourcesUsed).toContain('websearch');
+    expect(updates.discovery!.enrichment!.companyNews).toBeDefined();
+    expect(updates.discovery!.enrichment!.companyNews!.length).toBeGreaterThan(0);
+    expect(webSearchClient.search).toHaveBeenCalled();
+  });
+
+  it('does not run enrichment when businessContext is missing', async () => {
+    const handler = createPhaseHandler('Discover', {
+      discover: { io, mcpManager, webSearchClient },
+    });
+    await handler._preload();
+
+    const session = makeSession(); // no businessContext
+
+    const updates = await handler.postExtract!(session);
+
+    expect(updates.discovery).toBeUndefined();
+    expect(webSearchClient.search).not.toHaveBeenCalled();
+  });
+
+  it('runs enrichment only once (first extraction)', async () => {
+    const handler = createPhaseHandler('Discover', {
+      discover: { io, mcpManager, webSearchClient },
+    });
+    await handler._preload();
+
+    const session = makeSession({
+      businessContext: {
+        businessDescription: 'Acme Corp',
+        challenges: ['challenge'],
+      },
+    });
+
+    // First call: triggers enrichment
+    const updates1 = await handler.postExtract!(session);
+    expect(updates1.discovery).toBeDefined();
+
+    // Second call: should not re-trigger
+    const updates2 = await handler.postExtract!(session);
+    expect(updates2).toEqual({});
+    // search is called once (first successful query) in the first call only, not in second
+    expect(webSearchClient.search).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not run enrichment when no webSearchClient or WorkIQ available', async () => {
+    const handler = createPhaseHandler('Discover', {
+      discover: { io, mcpManager },
+    });
+    await handler._preload();
+
+    const session = makeSession({
+      businessContext: {
+        businessDescription: 'Acme Corp',
+        challenges: ['challenge'],
+      },
+    });
+
+    const updates = await handler.postExtract!(session);
+    expect(updates).toEqual({});
+  });
+
+  it('enrichment result stored in session.discovery.enrichment is picked up by Ideate prompt', async () => {
+    // Create a session with enrichment already stored
+    const session = makeSession({
+      phase: 'Ideate',
+      businessContext: {
+        businessDescription: 'Acme Corp',
+        challenges: ['efficiency'],
+      },
+      discovery: {
+        enrichment: {
+          companyNews: ['Acme raises $10M Series B'],
+          competitorInfo: ['Widget Inc growing fast'],
+          industryTrends: ['AI in manufacturing trending'],
+          enrichedAt: new Date().toISOString(),
+          sourcesUsed: ['websearch'],
+        },
+      },
+    });
+
+    const ideateHandler = createPhaseHandler('Ideate');
+    await ideateHandler._preload();
+
+    const prompt = ideateHandler.buildSystemPrompt(session);
+    // The ideate handler includes businessContext in its prompt
+    expect(prompt).toContain('Acme Corp');
+    // Note: Enrichment injection into ideation prompt is a downstream task,
+    // this test verifies the data is available for injection
+  });
+
+  it('enrichment does not interfere with normal extractResult', async () => {
+    const handler = createPhaseHandler('Discover', {
+      discover: { io, mcpManager, webSearchClient },
+    });
+    await handler._preload();
+
+    const session = makeSession();
+
+    // Normal extractResult should still work
+    const response = `## Business Context
+\`\`\`json
+{
+  "businessDescription": "Acme Corp",
+  "challenges": ["efficiency"]
+}
+\`\`\``;
+
+    const updates = handler.extractResult(session, response);
+    // extractResult should not contain discovery (that's postExtract's job)
+    expect(updates.businessContext).toBeDefined();
+  });
+});

package/tests/integration/exportArtifacts.spec.ts

@@ -0,0 +1,232 @@
+/**
+ * Integration test: Export Artifacts (T037)
+ *
+ * Tests the export pipeline from session to Markdown + summary.json:
+ * - Export a complete session with all phases populated
+ * - Verify per-phase Markdown files are generated
+ * - Verify summary.json matches contract structure
+ * - Verify export handles partial sessions (only some phases done)
+ * - Verify export paths and directory creation
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import type { WorkshopSession } from '../../src/shared/schemas/session.js';
+import { exportSession } from '../../src/sessions/exportWriter.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function createFullSession(): WorkshopSession {
+  return {
+    sessionId: 'test-export-session',
+    schemaVersion: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-06-15T12:00:00Z',
+    phase: 'Complete',
+    status: 'Completed',
+    participants: [
+      { id: 'p1', displayName: 'Alice', role: 'Facilitator' },
+    ],
+    businessContext: {
+      businessDescription: 'Logistics company specializing in last-mile delivery',
+      challenges: ['Route optimization is manual', 'High fuel costs'],
+      constraints: ['Budget limited to $50k'],
+      successMetrics: [{ name: 'Delivery time', value: '30', unit: 'minutes' }],
+    },
+    workflow: {
+      activities: [
+        { id: 'a1', name: 'Receive Order', description: 'Customer places order' },
+        { id: 'a2', name: 'Plan Route', description: 'Manual route planning' },
+        { id: 'a3', name: 'Deliver', description: 'Driver delivers package' },
+      ],
+      edges: [
+        { fromStepId: 'a1', toStepId: 'a2' },
+        { fromStepId: 'a2', toStepId: 'a3' },
+      ],
+    },
+    ideas: [
+      {
+        id: 'i1',
+        title: 'AI Route Optimizer',
+        description: 'Use ML to find optimal delivery routes',
+        workflowStepIds: ['a2'],
+        aspirationalScope: 'Cover all urban routes',
+      },
+      {
+        id: 'i2',
+        title: 'Predictive Demand',
+        description: 'Forecast delivery demand to pre-position drivers',
+        workflowStepIds: ['a1', 'a2'],
+      },
+    ],
+    evaluation: {
+      method: 'feasibility-value-matrix',
+      ideas: [
+        { ideaId: 'i1', feasibility: 4, value: 5, risks: ['Data quality'] },
+        { ideaId: 'i2', feasibility: 3, value: 4 },
+      ],
+    },
+    selection: {
+      ideaId: 'i1',
+      selectionRationale: 'Highest combined feasibility + value score',
+      confirmedByUser: true,
+      confirmedAt: '2025-06-15T11:00:00Z',
+    },
+    plan: {
+      milestones: [
+        { id: 'm1', title: 'Data Collection', items: ['Set up telemetry', 'Collect 3 months of delivery data'] },
+        { id: 'm2', title: 'Model Training', items: ['Train route model', 'Validate on historical data'] },
+        { id: 'm3', title: 'Integration', items: ['API endpoint', 'Driver app integration'] },
+      ],
+      architectureNotes: 'Microservices with Azure Maps API',
+      dependencies: ['Azure subscription', 'Historical delivery data'],
+    },
+    poc: {
+      repoSource: 'local' as const,
+      iterations: [
+        {
+          iteration: 1,
+          startedAt: '2025-06-15T11:30:00Z',
+          outcome: 'scaffold' as const,
+          filesChanged: ['package.json', 'src/index.ts'],
+          changesSummary: 'Initial scaffold with simple greedy routing',
+        },
+      ],
+    },
+    artifacts: { generatedFiles: [] },
+    turns: [
+      { phase: 'Discover', sequence: 1, role: 'user', content: 'We are a logistics company', timestamp: '2025-01-01T00:01:00Z' },
+      { phase: 'Discover', sequence: 2, role: 'assistant', content: 'Understood, let me document that.', timestamp: '2025-01-01T00:02:00Z' },
+      { phase: 'Ideate', sequence: 3, role: 'user', content: 'Generate ideas', timestamp: '2025-01-01T00:03:00Z' },
+    ],
+  };
+}
+
+function createPartialSession(): WorkshopSession {
+  return {
+    sessionId: 'test-partial-session',
+    schemaVersion: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-01-01T01:00:00Z',
+    phase: 'Ideate',
+    status: 'Active',
+    participants: [],
+    businessContext: {
+      businessDescription: 'A SaaS platform',
+      challenges: ['Customer churn'],
+    },
+    artifacts: { generatedFiles: [] },
+    turns: [],
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('Export Artifacts Flow', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'sofia-export-'));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('exports a complete session with all phase Markdown files', async () => {
+    const session = createFullSession();
+    const exportDir = join(tmpDir, session.sessionId);
+    const result = await exportSession(session, exportDir);
+
+    expect(result.files.length).toBeGreaterThanOrEqual(6); // discover + ideate + design + select + plan + develop + summary
+
+    const files = await readdir(exportDir);
+    expect(files).toContain('summary.json');
+  });
+
+  it('generates valid summary.json matching contract', async () => {
+    const session = createFullSession();
+    const exportDir = join(tmpDir, session.sessionId);
+    await exportSession(session, exportDir);
+
+    const summaryRaw = await readFile(join(exportDir, 'summary.json'), 'utf-8');
+    const summary = JSON.parse(summaryRaw);
+
+    expect(summary.sessionId).toBe('test-export-session');
+    expect(summary.phase).toBe('Complete');
+    expect(summary.status).toBe('Completed');
+    expect(summary.exportedAt).toBeDefined();
+    expect(Array.isArray(summary.files)).toBe(true);
+    expect(summary.files.length).toBeGreaterThan(0);
+  });
+
+  it('exports Discover markdown with business context', async () => {
+    const session = createFullSession();
+    const exportDir = join(tmpDir, session.sessionId);
+    await exportSession(session, exportDir);
+
+    const files = await readdir(exportDir);
+    const discoverFile = files.find((f) => f.includes('discover'));
+    expect(discoverFile).toBeDefined();
+
+    const content = await readFile(join(exportDir, discoverFile!), 'utf-8');
+    expect(content).toContain('Logistics company');
+    expect(content).toContain('Route optimization');
+  });
+
+  it('exports Ideate markdown with ideas', async () => {
+    const session = createFullSession();
+    const exportDir = join(tmpDir, session.sessionId);
+    await exportSession(session, exportDir);
+
+    const files = await readdir(exportDir);
+    const ideateFile = files.find((f) => f.includes('ideate'));
+    expect(ideateFile).toBeDefined();
+
+    const content = await readFile(join(exportDir, ideateFile!), 'utf-8');
+    expect(content).toContain('AI Route Optimizer');
+  });
+
+  it('exports Plan markdown with milestones', async () => {
+    const session = createFullSession();
+    const exportDir = join(tmpDir, session.sessionId);
+    await exportSession(session, exportDir);
+
+    const files = await readdir(exportDir);
+    const planFile = files.find((f) => f.includes('plan'));
+    expect(planFile).toBeDefined();
+
+    const content = await readFile(join(exportDir, planFile!), 'utf-8');
+    expect(content).toContain('Data Collection');
+    expect(content).toContain('Model Training');
+  });
+
+  it('handles partial session with only Discover data', async () => {
+    const session = createPartialSession();
+    const exportDir = join(tmpDir, session.sessionId);
+    const result = await exportSession(session, exportDir);
+
+    // Should still have at least discover markdown + summary.json
+    expect(result.files.length).toBeGreaterThanOrEqual(2);
+
+    const files = await readdir(exportDir);
+    expect(files).toContain('summary.json');
+    const discoverFile = files.find((f) => f.includes('discover'));
+    expect(discoverFile).toBeDefined();
+  });
+
+  it('summary file list contains relative paths', async () => {
+    const session = createFullSession();
+    const exportDir = join(tmpDir, session.sessionId);
+    await exportSession(session, exportDir);
+
+    const summaryRaw = await readFile(join(exportDir, 'summary.json'), 'utf-8');
+    const summary = JSON.parse(summaryRaw);
+
+    for (const file of summary.files) {
+      expect(file).not.toContain(tmpDir); // Should be relative, not absolute
+    }
+  });
+});