sofia-cli 0.1.1

package/tests/unit/loop/phaseSummarizer.spec.ts

@@ -0,0 +1,169 @@
+/**
+ * Phase summarizer tests.
+ *
+ * Tests for the post-phase summarization fallback that extracts
+ * structured data from conversation transcripts when the conversation
+ * loop's inline extraction fails.
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+import {
+  needsSummarization,
+  buildPhaseTranscript,
+  phaseSummarize,
+} from '../../../src/loop/phaseSummarizer.js';
+import type { WorkshopSession } from '../../../src/shared/schemas/session.js';
+import type { PhaseHandler } from '../../../src/loop/conversationLoop.js';
+
+function emptySession(overrides?: Partial<WorkshopSession>): 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: [],
+    ...overrides,
+  };
+}
+
+describe('needsSummarization', () => {
+  it('returns true when Ideate session field is null', () => {
+    const session = emptySession();
+    expect(needsSummarization('Ideate', session)).toBe(true);
+  });
+
+  it('returns false when Ideate session field is populated', () => {
+    const session = emptySession({
+      ideas: [{ id: 'idea-1', title: 'Test', description: 'Desc', workflowStepIds: [] }],
+    });
+    expect(needsSummarization('Ideate', session)).toBe(false);
+  });
+
+  it('returns true when Design session field is null', () => {
+    expect(needsSummarization('Design', emptySession())).toBe(true);
+  });
+
+  it('returns false when Design session field is populated', () => {
+    const session = emptySession({
+      evaluation: { method: 'feasibility-value-matrix', ideas: [] },
+    });
+    expect(needsSummarization('Design', session)).toBe(false);
+  });
+
+  it('returns false for unknown phase', () => {
+    expect(needsSummarization('Complete', emptySession())).toBe(false);
+  });
+});
+
+describe('buildPhaseTranscript', () => {
+  it('returns empty string when no turns for phase', () => {
+    const session = emptySession();
+    expect(buildPhaseTranscript('Ideate', session)).toBe('');
+  });
+
+  it('concatenates turns for the specified phase', () => {
+    const session = emptySession({
+      turns: [
+        { phase: 'Ideate', sequence: 1, role: 'user', content: 'Hello', timestamp: '2025-01-01T00:00:00Z' },
+        { phase: 'Ideate', sequence: 2, role: 'assistant', content: 'Hi there', timestamp: '2025-01-01T00:00:00Z' },
+        { phase: 'Design', sequence: 3, role: 'user', content: 'Other phase', timestamp: '2025-01-01T00:00:00Z' },
+      ],
+    });
+    const transcript = buildPhaseTranscript('Ideate', session);
+    expect(transcript).toContain('[user]: Hello');
+    expect(transcript).toContain('[assistant]: Hi there');
+    expect(transcript).not.toContain('Other phase');
+  });
+});
+
+describe('phaseSummarize', () => {
+  function createFakeClient(responseText: string) {
+    return {
+      createSession: vi.fn().mockResolvedValue({
+        send: vi.fn().mockImplementation(async function* () {
+          yield { type: 'TextDelta', text: responseText };
+        }),
+      }),
+    };
+  }
+
+  function createHandler(extractReturn: Partial<WorkshopSession> = {}): PhaseHandler {
+    return {
+      phase: 'Ideate',
+      buildSystemPrompt: () => 'test prompt',
+      extractResult: vi.fn().mockReturnValue(extractReturn),
+    };
+  }
+
+  it('returns empty object when session field already populated (no-op)', async () => {
+    const session = emptySession({
+      ideas: [{ id: 'idea-1', title: 'Test', description: 'Desc', workflowStepIds: [] }],
+    });
+    const client = createFakeClient('');
+    const handler = createHandler();
+    const result = await phaseSummarize(client as never, 'Ideate', session, handler);
+    expect(result).toEqual({});
+    expect(client.createSession).not.toHaveBeenCalled();
+  });
+
+  it('returns empty object when no transcript turns exist', async () => {
+    const session = emptySession();
+    const client = createFakeClient('');
+    const handler = createHandler();
+    const result = await phaseSummarize(client as never, 'Ideate', session, handler);
+    expect(result).toEqual({});
+  });
+
+  it('extracts IdeaCard[] from LLM summary response', async () => {
+    const ideas = [{ id: 'idea-1', title: 'AI Assistant', description: 'Automate tasks', workflowStepIds: ['s1'] }];
+    const responseJson = '```json\n' + JSON.stringify(ideas) + '\n```';
+    const client = createFakeClient(responseJson);
+    const handler = createHandler({ ideas });
+
+    const session = emptySession({
+      turns: [
+        { phase: 'Ideate', sequence: 1, role: 'user', content: 'Give me ideas', timestamp: '2025-01-01T00:00:00Z' },
+        { phase: 'Ideate', sequence: 2, role: 'assistant', content: 'Here are ideas', timestamp: '2025-01-01T00:00:00Z' },
+      ],
+    });
+
+    const result = await phaseSummarize(client as never, 'Ideate', session, handler);
+    expect(result).toEqual({ ideas });
+    expect(handler.extractResult).toHaveBeenCalledWith(session, responseJson);
+  });
+
+  it('returns empty object when LLM returns invalid response (no crash)', async () => {
+    const client = createFakeClient('This is not JSON at all');
+    const handler = createHandler({});
+
+    const session = emptySession({
+      turns: [
+        { phase: 'Ideate', sequence: 1, role: 'user', content: 'Give me ideas', timestamp: '2025-01-01T00:00:00Z' },
+        { phase: 'Ideate', sequence: 2, role: 'assistant', content: 'Here are ideas', timestamp: '2025-01-01T00:00:00Z' },
+      ],
+    });
+
+    const result = await phaseSummarize(client as never, 'Ideate', session, handler);
+    expect(result).toEqual({});
+  });
+
+  it('does not throw when client throws', async () => {
+    const client = {
+      createSession: vi.fn().mockRejectedValue(new Error('Network error')),
+    };
+    const handler = createHandler();
+
+    const session = emptySession({
+      turns: [
+        { phase: 'Ideate', sequence: 1, role: 'user', content: 'Hello', timestamp: '2025-01-01T00:00:00Z' },
+      ],
+    });
+
+    const result = await phaseSummarize(client as never, 'Ideate', session, handler);
+    expect(result).toEqual({});
+  });
+});

package/tests/unit/loop/streamingMarkdown.spec.ts

@@ -0,0 +1,180 @@
+/**
+ * Tests for incremental markdown rendering during streaming (T080).
+ *
+ * Verifies that TextDelta chunks are rendered through markdownRenderer
+ * in TTY mode, raw markdown in non-TTY/JSON mode, and that turn history
+ * stores raw markdown (not ANSI).
+ */
+import { describe, it, expect, vi } from 'vitest';
+
+import {
+  ConversationLoop,
+  type LoopIO,
+  type PhaseHandler,
+} from '../../../src/loop/conversationLoop.js';
+import { createFakeCopilotClient } from '../../../src/shared/copilotClient.js';
+import type { WorkshopSession } from '../../../src/shared/schemas/session.js';
+import * as markdownRenderer from '../../../src/shared/markdownRenderer.js';
+import { createNoOpSpinner } from '../../../src/shared/activitySpinner.js';
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeSession(overrides?: Partial<WorkshopSession>): WorkshopSession {
+  return {
+    sessionId: 'test-md-stream',
+    schemaVersion: '1.0.0',
+    createdAt: '2025-01-01T00:00:00Z',
+    updatedAt: '2025-01-01T00:00:00Z',
+    phase: 'Discover',
+    status: 'Active',
+    participants: [],
+    artifacts: { generatedFiles: [] },
+    ...overrides,
+  };
+}
+
+function makeIO(inputs: (string | null)[], opts?: { json?: boolean; tty?: boolean }): LoopIO & { _written: string[]; _activities: string[] } {
+  let inputIndex = 0;
+  const written: string[] = [];
+  const activities: string[] = [];
+
+  return {
+    write(text: string) {
+      written.push(text);
+    },
+    writeActivity(text: string) {
+      activities.push(text);
+    },
+    writeToolSummary(_toolName: string, _summary: string) {
+      // no-op for these tests
+    },
+    async readInput(): Promise<string | null> {
+      if (inputIndex >= inputs.length) return null;
+      return inputs[inputIndex++] ?? null;
+    },
+    async showDecisionGate() {
+      return { choice: 'continue' as const };
+    },
+    isJsonMode: opts?.json ?? false,
+    isTTY: opts?.tty ?? true,
+    get _written() {
+      return written;
+    },
+    get _activities() {
+      return activities;
+    },
+  };
+}
+
+function makePhaseHandler(overrides?: Partial<PhaseHandler>): PhaseHandler {
+  return {
+    phase: 'Discover',
+    buildSystemPrompt: () => 'System prompt',
+    extractResult: () => ({}),
+    ...overrides,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('Incremental streaming markdown rendering (T080)', () => {
+  it('renders TextDelta chunks through renderMarkdown in TTY mode', async () => {
+    const renderSpy = vi.spyOn(markdownRenderer, 'renderMarkdown');
+
+    const client = createFakeCopilotClient([
+      { role: 'assistant', content: '## Hello World\n\nSome **bold** text.' },
+    ]);
+
+    const io = makeIO(['test input'], { tty: true, json: false });
+
+    const loop = new ConversationLoop({
+      client,
+      io,
+      session: makeSession(),
+      phaseHandler: makePhaseHandler(),
+      spinner: createNoOpSpinner(),
+    });
+
+    await loop.run();
+
+    // renderMarkdown should have been called for the TextDelta chunk
+    expect(renderSpy).toHaveBeenCalled();
+    const callArgs = renderSpy.mock.calls;
+    // At least one call should have the LLM content
+    const contentCalls = callArgs.filter(([text]) => text.includes('Hello World'));
+    expect(contentCalls.length).toBeGreaterThanOrEqual(1);
+
+    renderSpy.mockRestore();
+  });
+
+  it('writes raw text in non-TTY mode without markdown rendering', async () => {
+    const client = createFakeCopilotClient([
+      { role: 'assistant', content: '## Raw heading' },
+    ]);
+
+    const io = makeIO(['test'], { tty: false, json: false });
+
+    const loop = new ConversationLoop({
+      client,
+      io,
+      session: makeSession(),
+      phaseHandler: makePhaseHandler(),
+      spinner: createNoOpSpinner(),
+    });
+
+    await loop.run();
+
+    // In non-TTY mode, raw text should be written
+    const allOutput = io._written.join('');
+    expect(allOutput).toContain('## Raw heading');
+  });
+
+  it('preserves raw markdown in JSON mode output', async () => {
+    const client = createFakeCopilotClient([
+      { role: 'assistant', content: '**Bold** text' },
+    ]);
+
+    const io = makeIO(['test'], { tty: false, json: true });
+
+    const loop = new ConversationLoop({
+      client,
+      io,
+      session: makeSession(),
+      phaseHandler: makePhaseHandler(),
+      spinner: createNoOpSpinner(),
+    });
+
+    await loop.run();
+
+    const jsonOutputs = io._written.filter((w: string) => w.startsWith('{'));
+    expect(jsonOutputs.length).toBeGreaterThanOrEqual(1);
+    const parsed = JSON.parse(jsonOutputs[0]);
+    expect(parsed.content).toBe('**Bold** text');
+  });
+
+  it('stores raw markdown in turn history (not ANSI)', async () => {
+    const client = createFakeCopilotClient([
+      { role: 'assistant', content: '## Phase Output\n\nContent here.' },
+    ]);
+
+    const io = makeIO(['input'], { tty: true, json: false });
+
+    const loop = new ConversationLoop({
+      client,
+      io,
+      session: makeSession(),
+      phaseHandler: makePhaseHandler(),
+      spinner: createNoOpSpinner(),
+    });
+
+    const result = await loop.run();
+
+    // Turn history should contain raw markdown, not ANSI escape codes
+    const assistantTurn = result.turns?.find(t => t.role === 'assistant');
+    expect(assistantTurn).toBeDefined();
+    expect(assistantTurn!.content).toBe('## Phase Output\n\nContent here.');
+    // Should NOT contain ANSI escape sequences
+    // eslint-disable-next-line no-control-regex
+    expect(assistantTurn!.content).not.toMatch(/\u001b\[/);
+  });
+});

package/tests/unit/mcp/mcpManager.spec.ts

@@ -0,0 +1,336 @@
+/**
+ * MCP Manager tests.
+ *
+ * The McpManager loads .vscode/mcp.json, manages connections to MCP servers,
+ * lists available tools, and classifies errors.
+ *
+ * T007: Tests for callTool() real dispatch (lazy transport, retry, normalization)
+ * T049: Tests for toSdkMcpServers() conversion
+ */
+import { describe, it, expect } from 'vitest';
+
+import {
+  McpManager,
+  loadMcpConfig,
+  classifyMcpError,
+  toSdkMcpServers,
+} from '../../../src/mcp/mcpManager.js';
+import type {
+  McpConfig,
+  StdioServerConfig,
+  HttpServerConfig,
+} from '../../../src/mcp/mcpManager.js';
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('McpManager', () => {
+  describe('loadMcpConfig', () => {
+    it('loads and parses .vscode/mcp.json from given path', async () => {
+      const config = await loadMcpConfig(
+        new URL('../../../.vscode/mcp.json', import.meta.url).pathname,
+      );
+
+      expect(config).toBeDefined();
+      expect(config.servers).toBeDefined();
+      expect(Object.keys(config.servers).length).toBeGreaterThan(0);
+    });
+
+    it('returns empty servers when file does not exist', async () => {
+      const config = await loadMcpConfig('/nonexistent/mcp.json');
+      expect(config.servers).toEqual({});
+    });
+
+    it('identifies server types correctly (stdio vs http)', async () => {
+      const config = await loadMcpConfig(
+        new URL('../../../.vscode/mcp.json', import.meta.url).pathname,
+      );
+
+      // workiq has command → stdio type
+      const workiq = config.servers['workiq'];
+      expect(workiq).toBeDefined();
+      expect(workiq.type).toBe('stdio');
+
+      // github has url → http type
+      const github = config.servers['github'];
+      expect(github).toBeDefined();
+      expect(github.type).toBe('http');
+    });
+  });
+
+  describe('McpManager instance', () => {
+    it('can be created with a config', () => {
+      const config = {
+        servers: {
+          testServer: {
+            name: 'testServer',
+            type: 'stdio' as const,
+            command: 'echo',
+            args: ['hello'],
+          },
+        },
+      };
+
+      const manager = new McpManager(config);
+      expect(manager).toBeDefined();
+    });
+
+    it('listServers returns configured server names', () => {
+      const config = {
+        servers: {
+          s1: { name: 's1', type: 'stdio' as const, command: 'echo', args: [] },
+          s2: { name: 's2', type: 'http' as const, url: 'http://example.com' },
+        },
+      };
+
+      const manager = new McpManager(config);
+      const names = manager.listServers();
+      expect(names).toEqual(['s1', 's2']);
+    });
+
+    it('getServerConfig returns config for a known server', () => {
+      const config = {
+        servers: {
+          myServer: {
+            name: 'myServer',
+            type: 'stdio' as const,
+            command: 'npx',
+            args: ['-y', 'my-tool'],
+          },
+        },
+      };
+
+      const manager = new McpManager(config);
+      const sc = manager.getServerConfig('myServer');
+      expect(sc).toBeDefined();
+      expect(sc!.type).toBe('stdio');
+      expect((sc as import('../../../src/mcp/mcpManager.js').StdioServerConfig).command).toBe(
+        'npx',
+      );
+    });
+
+    it('getServerConfig returns undefined for unknown server', () => {
+      const manager = new McpManager({ servers: {} });
+      expect(manager.getServerConfig('nope')).toBeUndefined();
+    });
+
+    it('isAvailable returns false when not connected', () => {
+      const config = {
+        servers: {
+          s1: { name: 's1', type: 'stdio' as const, command: 'echo', args: [] },
+        },
+      };
+
+      const manager = new McpManager(config);
+      expect(manager.isAvailable('s1')).toBe(false);
+    });
+  });
+
+  describe('classifyMcpError', () => {
+    it('classifies ECONNREFUSED as connection-refused', () => {
+      const err = new Error('connect ECONNREFUSED 127.0.0.1:3000');
+      (err as Error & { code?: string }).code = 'ECONNREFUSED';
+      expect(classifyMcpError(err)).toBe('connection-refused');
+    });
+
+    it('classifies ENOTFOUND as dns-failure', () => {
+      const err = new Error('getaddrinfo ENOTFOUND example.com');
+      (err as Error & { code?: string }).code = 'ENOTFOUND';
+      expect(classifyMcpError(err)).toBe('dns-failure');
+    });
+
+    it('classifies ETIMEDOUT as timeout', () => {
+      const err = new Error('connect ETIMEDOUT');
+      (err as Error & { code?: string }).code = 'ETIMEDOUT';
+      expect(classifyMcpError(err)).toBe('timeout');
+    });
+
+    it('classifies unknown errors as unknown', () => {
+      expect(classifyMcpError(new Error('something weird'))).toBe('unknown');
+    });
+
+    it('classifies non-Error values as unknown', () => {
+      expect(classifyMcpError('string error')).toBe('unknown');
+    });
+  });
+
+  // ── T007: callTool() real dispatch tests ─────────────────────────────────
+
+  describe('callTool() real dispatch', () => {
+    it('throws when server is not in config', async () => {
+      const manager = new McpManager({ servers: {} });
+      await expect(manager.callTool('nonexistent', 'tool', {})).rejects.toThrow(
+        /[Uu]nknown.*nonexistent|not available/,
+      );
+    });
+
+    it('returns unwrapped content from ToolCallResponse', async () => {
+      // This test will fail until T016 implements real dispatch.
+      // Once implemented, McpManager.callTool should return the
+      // unwrapped content from the transport's ToolCallResponse.
+      const config: McpConfig = {
+        servers: {
+          testserver: {
+            name: 'testserver',
+            type: 'http',
+            url: 'https://test.example.com/mcp',
+          } as HttpServerConfig,
+        },
+      };
+      const manager = new McpManager(config);
+      manager.markConnected('testserver');
+
+      // After T016: This should dispatch to transport and return parsed content.
+      // For now, we just verify the method exists and can be called
+      // (it currently throws "not yet wired to transport").
+      try {
+        await manager.callTool('testserver', 'search', { query: 'test' });
+      } catch (err) {
+        // Expected to throw "not yet wired" until T016
+        expect(err).toBeInstanceOf(Error);
+      }
+    });
+
+    it('throws when calling unavailable server', async () => {
+      const config: McpConfig = {
+        servers: {
+          myserver: {
+            name: 'myserver',
+            type: 'stdio',
+            command: 'echo',
+            args: [],
+          } as StdioServerConfig,
+        },
+      };
+      const manager = new McpManager(config);
+      // Don't mark connected
+
+      await expect(manager.callTool('myserver', 'tool', {})).rejects.toThrow(/not available/);
+    });
+  });
+
+  // ── T049: toSdkMcpServers() tests ───────────────────────────────────────
+
+  describe('toSdkMcpServers()', () => {
+    it('converts StdioServerConfig to SDK format', () => {
+      const config: McpConfig = {
+        servers: {
+          context7: {
+            name: 'context7',
+            type: 'stdio',
+            command: 'npx',
+            args: ['-y', '@upstash/context7-mcp'],
+            env: { NODE_ENV: 'production' },
+            cwd: '/tmp',
+            tools: ['resolve-library-id', 'query-docs'],
+            timeout: 15000,
+          } as StdioServerConfig,
+        },
+      };
+
+      const result = toSdkMcpServers(config);
+      expect(result).toEqual({
+        context7: {
+          type: 'stdio',
+          command: 'npx',
+          args: ['-y', '@upstash/context7-mcp'],
+          tools: ['resolve-library-id', 'query-docs'],
+          env: { NODE_ENV: 'production' },
+          cwd: '/tmp',
+          timeout: 15000,
+        },
+      });
+    });
+
+    it('converts HttpServerConfig to SDK format', () => {
+      const config: McpConfig = {
+        servers: {
+          github: {
+            name: 'github',
+            type: 'http',
+            url: 'https://api.githubcopilot.com/mcp/',
+            headers: { 'X-Custom': 'value' },
+            tools: ['create_repository'],
+            timeout: 60000,
+          } as HttpServerConfig,
+        },
+      };
+
+      const result = toSdkMcpServers(config);
+      expect(result).toEqual({
+        github: {
+          type: 'http',
+          url: 'https://api.githubcopilot.com/mcp/',
+          tools: ['create_repository'],
+          headers: { 'X-Custom': 'value' },
+          timeout: 60000,
+        },
+      });
+    });
+
+    it('returns empty object for empty servers', () => {
+      const config: McpConfig = { servers: {} };
+      const result = toSdkMcpServers(config);
+      expect(result).toEqual({});
+    });
+
+    it('defaults tools to ["*"] when not specified', () => {
+      const config: McpConfig = {
+        servers: {
+          simple: {
+            name: 'simple',
+            type: 'stdio',
+            command: 'echo',
+            args: [],
+          } as StdioServerConfig,
+        },
+      };
+
+      const result = toSdkMcpServers(config);
+      expect(result.simple.tools).toEqual(['*']);
+    });
+
+    it('omits optional fields when not in source config', () => {
+      const config: McpConfig = {
+        servers: {
+          minimal: {
+            name: 'minimal',
+            type: 'http',
+            url: 'https://example.com/mcp',
+          } as HttpServerConfig,
+        },
+      };
+
+      const result = toSdkMcpServers(config);
+      expect(result.minimal).toEqual({
+        type: 'http',
+        url: 'https://example.com/mcp',
+        tools: ['*'],
+      });
+      expect(result.minimal).not.toHaveProperty('headers');
+      expect(result.minimal).not.toHaveProperty('timeout');
+    });
+
+    it('converts mixed stdio and http configs', () => {
+      const config: McpConfig = {
+        servers: {
+          local: {
+            name: 'local',
+            type: 'stdio',
+            command: 'node',
+            args: ['server.js'],
+          } as StdioServerConfig,
+          remote: {
+            name: 'remote',
+            type: 'http',
+            url: 'https://api.example.com',
+          } as HttpServerConfig,
+        },
+      };
+
+      const result = toSdkMcpServers(config);
+      expect(Object.keys(result)).toEqual(['local', 'remote']);
+      expect(result.local.type).toBe('stdio');
+      expect(result.remote.type).toBe('http');
+    });
+  });
+});