sofia-cli 0.1.1

package/dist/tests/unit/loop/phaseSummarizer.spec.js

@@ -0,0 +1,141 @@
+/**
+ * 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';
+function emptySession(overrides) {
+    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) {
+        return {
+            createSession: vi.fn().mockResolvedValue({
+                send: vi.fn().mockImplementation(async function* () {
+                    yield { type: 'TextDelta', text: responseText };
+                }),
+            }),
+        };
+    }
+    function createHandler(extractReturn = {}) {
+        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, '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, '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, '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, '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, 'Ideate', session, handler);
+        expect(result).toEqual({});
+    });
+});

package/dist/tests/unit/loop/streamingMarkdown.spec.js

@@ -0,0 +1,147 @@
+/**
+ * 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, } from '../../../src/loop/conversationLoop.js';
+import { createFakeCopilotClient } from '../../../src/shared/copilotClient.js';
+import * as markdownRenderer from '../../../src/shared/markdownRenderer.js';
+import { createNoOpSpinner } from '../../../src/shared/activitySpinner.js';
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeSession(overrides) {
+    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, opts) {
+    let inputIndex = 0;
+    const written = [];
+    const activities = [];
+    return {
+        write(text) {
+            written.push(text);
+        },
+        writeActivity(text) {
+            activities.push(text);
+        },
+        writeToolSummary(_toolName, _summary) {
+            // no-op for these tests
+        },
+        async readInput() {
+            if (inputIndex >= inputs.length)
+                return null;
+            return inputs[inputIndex++] ?? null;
+        },
+        async showDecisionGate() {
+            return { choice: 'continue' };
+        },
+        isJsonMode: opts?.json ?? false,
+        isTTY: opts?.tty ?? true,
+        get _written() {
+            return written;
+        },
+        get _activities() {
+            return activities;
+        },
+    };
+}
+function makePhaseHandler(overrides) {
+    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) => 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/dist/tests/unit/mcp/mcpManager.spec.js

@@ -0,0 +1,279 @@
+/**
+ * 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';
+// ── 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',
+                        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', command: 'echo', args: [] },
+                    s2: { name: 's2', type: 'http', 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',
+                        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.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', 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.code = 'ECONNREFUSED';
+            expect(classifyMcpError(err)).toBe('connection-refused');
+        });
+        it('classifies ENOTFOUND as dns-failure', () => {
+            const err = new Error('getaddrinfo ENOTFOUND example.com');
+            err.code = 'ENOTFOUND';
+            expect(classifyMcpError(err)).toBe('dns-failure');
+        });
+        it('classifies ETIMEDOUT as timeout', () => {
+            const err = new Error('connect ETIMEDOUT');
+            err.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 = {
+                servers: {
+                    testserver: {
+                        name: 'testserver',
+                        type: 'http',
+                        url: 'https://test.example.com/mcp',
+                    },
+                },
+            };
+            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 = {
+                servers: {
+                    myserver: {
+                        name: 'myserver',
+                        type: 'stdio',
+                        command: 'echo',
+                        args: [],
+                    },
+                },
+            };
+            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 = {
+                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,
+                    },
+                },
+            };
+            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 = {
+                servers: {
+                    github: {
+                        name: 'github',
+                        type: 'http',
+                        url: 'https://api.githubcopilot.com/mcp/',
+                        headers: { 'X-Custom': 'value' },
+                        tools: ['create_repository'],
+                        timeout: 60000,
+                    },
+                },
+            };
+            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 = { servers: {} };
+            const result = toSdkMcpServers(config);
+            expect(result).toEqual({});
+        });
+        it('defaults tools to ["*"] when not specified', () => {
+            const config = {
+                servers: {
+                    simple: {
+                        name: 'simple',
+                        type: 'stdio',
+                        command: 'echo',
+                        args: [],
+                    },
+                },
+            };
+            const result = toSdkMcpServers(config);
+            expect(result.simple.tools).toEqual(['*']);
+        });
+        it('omits optional fields when not in source config', () => {
+            const config = {
+                servers: {
+                    minimal: {
+                        name: 'minimal',
+                        type: 'http',
+                        url: 'https://example.com/mcp',
+                    },
+                },
+            };
+            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 = {
+                servers: {
+                    local: {
+                        name: 'local',
+                        type: 'stdio',
+                        command: 'node',
+                        args: ['server.js'],
+                    },
+                    remote: {
+                        name: 'remote',
+                        type: 'http',
+                        url: 'https://api.example.com',
+                    },
+                },
+            };
+            const result = toSdkMcpServers(config);
+            expect(Object.keys(result)).toEqual(['local', 'remote']);
+            expect(result.local.type).toBe('stdio');
+            expect(result.remote.type).toBe('http');
+        });
+    });
+});