sofia-cli 0.1.2 → 0.1.4

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

@@ -1,141 +0,0 @@
-/**
- * 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

@@ -1,147 +0,0 @@
-/**
- * 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

@@ -1,279 +0,0 @@
-/**
- * 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');
-        });
-    });
-});