sofia-cli 0.1.1

package/tests/integration/exportFallbackFlow.spec.ts

@@ -0,0 +1,115 @@
+/**
+ * Integration test: Export fallback flow.
+ *
+ * Tests the full export pipeline with null structured data but present
+ * conversation turns — verifies that all phase files are generated.
+ */
+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 { exportSession } from '../../src/sessions/exportWriter.js';
+import type { WorkshopSession } from '../../src/shared/schemas/session.js';
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), 'sofia-export-fallback-'));
+});
+
+afterEach(async () => {
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe('export fallback flow', () => {
+  it('generates 6 markdown files when all phases have turns but no structured data', async () => {
+    const now = new Date().toISOString();
+    const phases = ['Discover', 'Ideate', 'Design', 'Select', 'Plan', 'Develop'] as const;
+
+    const turns = phases.flatMap((phase, i) => [
+      {
+        phase,
+        sequence: i * 2 + 1,
+        role: 'user' as const,
+        content: `Tell me about the ${phase} phase`,
+        timestamp: now,
+      },
+      {
+        phase,
+        sequence: i * 2 + 2,
+        role: 'assistant' as const,
+        content: `Here is information about the ${phase} phase.`,
+        timestamp: now,
+      },
+    ]);
+
+    const session: WorkshopSession = {
+      sessionId: 'fallback-test',
+      schemaVersion: '1.0.0',
+      createdAt: now,
+      updatedAt: now,
+      phase: 'Complete',
+      status: 'Completed',
+      participants: [],
+      artifacts: { generatedFiles: [] },
+      turns,
+      // Discover has conversation fallback built-in
+      businessContext: {
+        businessDescription: 'Test Company',
+        challenges: ['Testing'],
+      },
+      // All other structured fields are null/undefined
+    };
+
+    await exportSession(session, tmpDir);
+
+    const files = await readdir(tmpDir);
+    expect(files).toContain('discover.md');
+    expect(files).toContain('ideate.md');
+    expect(files).toContain('design.md');
+    expect(files).toContain('select.md');
+    expect(files).toContain('plan.md');
+    expect(files).toContain('develop.md');
+    expect(files).toContain('summary.json');
+
+    // Verify each file has conversation content
+    for (const phase of phases) {
+      const content = await readFile(join(tmpDir, `${phase.toLowerCase()}.md`), 'utf-8');
+      expect(content).toContain('## Conversation');
+    }
+
+    // Verify summary.json lists all files
+    const summaryRaw = await readFile(join(tmpDir, 'summary.json'), 'utf-8');
+    const summary = JSON.parse(summaryRaw) as { files: Array<{ path: string }>; highlights?: string[] };
+    const mdFiles = summary.files.filter((f) => f.path.endsWith('.md'));
+    expect(mdFiles.length).toBe(6);
+
+    // Verify highlights exist
+    expect(summary.highlights).toBeDefined();
+    expect(summary.highlights!.length).toBeGreaterThan(0);
+  });
+
+  it('returns null for phase with neither structured data nor turns', async () => {
+    const now = new Date().toISOString();
+    const session: WorkshopSession = {
+      sessionId: 'empty-test',
+      schemaVersion: '1.0.0',
+      createdAt: now,
+      updatedAt: now,
+      phase: 'Discover',
+      status: 'Active',
+      participants: [],
+      artifacts: { generatedFiles: [] },
+      turns: [],
+    };
+
+    await exportSession(session, tmpDir);
+    const files = await readdir(tmpDir);
+
+    // Only summary.json should be generated — no phase files
+    expect(files).toContain('summary.json');
+    const mdFiles = files.filter((f) => f.endsWith('.md'));
+    expect(mdFiles).toHaveLength(0);
+  });
+});

package/tests/integration/mcpDegradationFlow.spec.ts

@@ -0,0 +1,231 @@
+/**
+ * T042: Integration test for MCP degradation flow.
+ *
+ * Configures McpManager with servers marked unavailable (or stub transports
+ * that throw), runs GitHubMcpAdapter + McpContextEnricher calls, and asserts
+ * graceful degradation (no throws; adapters return { available: false, reason }
+ * or fallback context) per US1 Acceptance Scenario 4 and FR-013.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+import { McpManager } from '../../src/mcp/mcpManager.js';
+import type { McpConfig } from '../../src/mcp/mcpManager.js';
+import { GitHubMcpAdapter } from '../../src/develop/githubMcpAdapter.js';
+import { McpContextEnricher } from '../../src/develop/mcpContextEnricher.js';
+
+vi.mock('../../src/mcp/webSearch.js', () => ({
+  isWebSearchConfigured: vi.fn(() => false),
+}));
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function makeEmptyConfig(): McpConfig {
+  return { servers: {} };
+}
+
+function makeConfigWithServers(): McpConfig {
+  return {
+    servers: {
+      github: {
+        name: 'github',
+        type: 'http' as const,
+        url: 'https://api.github.com/mcp',
+      },
+      context7: {
+        name: 'context7',
+        type: 'stdio' as const,
+        command: 'npx',
+        args: ['-y', '@upstash/context7-mcp'],
+      },
+      azure: {
+        name: 'azure',
+        type: 'stdio' as const,
+        command: 'npx',
+        args: ['-y', '@azure/mcp'],
+      },
+    },
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('MCP Degradation Flow (integration)', () => {
+  let originalGithubToken: string | undefined;
+
+  beforeEach(() => {
+    originalGithubToken = process.env.GITHUB_TOKEN;
+  });
+
+  afterEach(() => {
+    if (originalGithubToken !== undefined) {
+      process.env.GITHUB_TOKEN = originalGithubToken;
+    } else {
+      delete process.env.GITHUB_TOKEN;
+    }
+    vi.restoreAllMocks();
+  });
+
+  describe('GitHubMcpAdapter graceful degradation', () => {
+    it('returns available:false when GitHub MCP is not configured', async () => {
+      const manager = new McpManager(makeEmptyConfig());
+      const adapter = new GitHubMcpAdapter(manager);
+
+      expect(adapter.isAvailable()).toBe(false);
+
+      const createResult = await adapter.createRepository({ name: 'test-poc' });
+      expect(createResult.available).toBe(false);
+      if (!createResult.available) {
+        expect(createResult.reason).toBeDefined();
+      }
+
+      const pushResult = await adapter.pushFiles({
+        repoUrl: 'https://github.com/acme/test',
+        files: [{ path: 'index.ts', content: 'hello' }],
+        commitMessage: 'init',
+      });
+      expect(pushResult.available).toBe(false);
+      if (!pushResult.available) {
+        expect(pushResult.reason).toBeDefined();
+      }
+    });
+
+    it('returns available:false when GitHub is configured but not connected', async () => {
+      const manager = new McpManager(makeConfigWithServers());
+      // Do NOT call markConnected — server is configured but unavailable
+      const adapter = new GitHubMcpAdapter(manager);
+
+      expect(adapter.isAvailable()).toBe(false);
+
+      const createResult = await adapter.createRepository({ name: 'test-poc' });
+      expect(createResult.available).toBe(false);
+    });
+
+    it('never throws from createRepository or pushFiles', async () => {
+      const manager = new McpManager(makeConfigWithServers());
+      manager.markConnected('github');
+
+      // Stub callTool to throw
+      vi.spyOn(manager, 'callTool').mockRejectedValue(new Error('network crash'));
+
+      const adapter = new GitHubMcpAdapter(manager);
+
+      // Should not throw
+      const createResult = await adapter.createRepository({ name: 'test-poc' });
+      expect(createResult.available).toBe(false);
+      if (!createResult.available) {
+        expect(createResult.reason).toBeDefined();
+      }
+
+      const pushResult = await adapter.pushFiles({
+        repoUrl: 'https://github.com/acme/test',
+        files: [{ path: 'index.ts', content: 'hello' }],
+        commitMessage: 'init',
+      });
+      expect(pushResult.available).toBe(false);
+    });
+  });
+
+  describe('McpContextEnricher graceful degradation', () => {
+    it('returns empty context when all services unavailable', async () => {
+      const manager = new McpManager(makeEmptyConfig());
+      const enricher = new McpContextEnricher(manager);
+
+      const result = await enricher.enrich({
+        dependencies: ['express', 'zod'],
+        architectureNotes: 'Use Azure Cosmos DB',
+        stuckIterations: 3,
+        failingTests: ['test fails with TypeError'],
+      });
+
+      expect(result.combined).toBe('');
+      expect(result.libraryDocs).toBeUndefined();
+      expect(result.azureGuidance).toBeUndefined();
+      expect(result.webSearchResults).toBeUndefined();
+    });
+
+    it('returns empty context when servers configured but not connected', async () => {
+      const manager = new McpManager(makeConfigWithServers());
+      // Not marking any server as connected
+      const enricher = new McpContextEnricher(manager);
+
+      const result = await enricher.enrich({
+        dependencies: ['express'],
+        architectureNotes: 'Use Azure Functions',
+      });
+
+      expect(result.combined).toBe('');
+      expect(result.libraryDocs).toBeUndefined();
+      expect(result.azureGuidance).toBeUndefined();
+    });
+
+    it('returns fallback context when callTool throws for all services', async () => {
+      const manager = new McpManager(makeConfigWithServers());
+      manager.markConnected('context7');
+      manager.markConnected('azure');
+
+      // Stub callTool to throw for all calls
+      vi.spyOn(manager, 'callTool').mockRejectedValue(new Error('transport broken'));
+
+      const enricher = new McpContextEnricher(manager);
+
+      const result = await enricher.enrich({
+        dependencies: ['express'],
+        architectureNotes: 'Use Azure Cosmos DB for data',
+      });
+
+      // Context7 should fall back to npm links
+      if (result.libraryDocs) {
+        expect(result.libraryDocs).toContain('npmjs.com');
+      }
+
+      // Azure should fall back to static guidance
+      if (result.azureGuidance) {
+        expect(result.azureGuidance).toContain('DefaultAzureCredential');
+      }
+    });
+
+    it('never throws from enrich()', async () => {
+      const manager = new McpManager(makeConfigWithServers());
+      manager.markConnected('context7');
+      manager.markConnected('azure');
+
+      vi.spyOn(manager, 'callTool').mockRejectedValue(new Error('catastrophic'));
+
+      const enricher = new McpContextEnricher(manager);
+
+      // Should not throw
+      const result = await enricher.enrich({
+        dependencies: ['express', 'zod'],
+        architectureNotes: 'Use Azure Cosmos DB',
+        stuckIterations: 5,
+        failingTests: ['test fails'],
+      });
+
+      // Should still return a valid EnrichedContext
+      expect(result).toHaveProperty('combined');
+      expect(typeof result.combined).toBe('string');
+    });
+  });
+
+  describe('Combined adapter + enricher degradation', () => {
+    it('full workflow with all MCP unavailable returns graceful defaults', async () => {
+      const manager = new McpManager(makeEmptyConfig());
+      const adapter = new GitHubMcpAdapter(manager);
+      const enricher = new McpContextEnricher(manager);
+
+      // Adapter: not available
+      expect(adapter.isAvailable()).toBe(false);
+      const repoResult = await adapter.createRepository({ name: 'test' });
+      expect(repoResult.available).toBe(false);
+
+      // Enricher: empty context
+      const contextResult = await enricher.enrich({
+        dependencies: ['express'],
+        architectureNotes: 'Use Azure',
+        stuckIterations: 3,
+        failingTests: ['test fails'],
+      });
+      expect(contextResult.combined).toBe('');
+    });
+  });
+});

package/tests/integration/mcpTransportFlow.spec.ts

@@ -0,0 +1,178 @@
+/**
+ * T011: Integration test for MCP transport flow.
+ *
+ * Spawns a minimal JSON-RPC echo server as a child process, verifies that
+ * StdioMcpTransport can connect and round-trip a `tools/call` request,
+ * and verifies McpManager.callTool() dispatches through StdioMcpTransport
+ * for stdio config.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import { writeFile, mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import pino from 'pino';
+
+import { StdioMcpTransport } from '../../src/mcp/mcpTransport.js';
+import { McpManager } from '../../src/mcp/mcpManager.js';
+import type { McpConfig, StdioServerConfig } from '../../src/mcp/mcpManager.js';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+const silentLogger = pino({ level: 'silent' });
+
+/**
+ * Minimal JSON-RPC echo server script.
+ * Handles `initialize` handshake and echoes `tools/call` params back.
+ */
+const ECHO_SERVER_SCRIPT = `
+const readline = require('readline');
+const rl = readline.createInterface({ input: process.stdin, terminal: false });
+
+rl.on('line', (line) => {
+  let msg;
+  try { msg = JSON.parse(line); } catch { return; }
+
+  if (msg.method === 'initialize') {
+    const response = {
+      jsonrpc: '2.0',
+      id: msg.id,
+      result: {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'echo-server', version: '0.1.0' },
+      },
+    };
+    process.stdout.write(JSON.stringify(response) + '\\n');
+    return;
+  }
+
+  if (msg.method === 'tools/call') {
+    const result = {
+      jsonrpc: '2.0',
+      id: msg.id,
+      result: {
+        content: [{ type: 'text', text: JSON.stringify(msg.params) }],
+      },
+    };
+    process.stdout.write(JSON.stringify(result) + '\\n');
+    return;
+  }
+});
+`;
+
+let tmpDir: string | undefined;
+
+async function createEchoServer(): Promise<string> {
+  tmpDir = await mkdtemp(join(tmpdir(), 'mcp-echo-'));
+  const scriptPath = join(tmpDir, 'echo-server.js');
+  await writeFile(scriptPath, ECHO_SERVER_SCRIPT, 'utf-8');
+  return scriptPath;
+}
+
+function makeStdioConfig(name: string, scriptPath: string): StdioServerConfig {
+  return {
+    name,
+    type: 'stdio' as const,
+    command: 'node',
+    args: [scriptPath],
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe('MCP Transport Flow (integration)', () => {
+  let transport: StdioMcpTransport | undefined;
+  let manager: McpManager | undefined;
+
+  afterEach(async () => {
+    if (transport?.isConnected()) {
+      await transport.disconnect().catch(() => {});
+    }
+    transport = undefined;
+
+    if (manager) {
+      await manager.disconnectAll().catch(() => {});
+    }
+    manager = undefined;
+
+    if (tmpDir) {
+      await rm(tmpDir, { recursive: true, force: true }).catch(() => {});
+      tmpDir = undefined;
+    }
+  });
+
+  it('StdioMcpTransport connects and round-trips a tools/call request', async () => {
+    const scriptPath = await createEchoServer();
+
+    transport = new StdioMcpTransport(makeStdioConfig('echo-test', scriptPath), silentLogger);
+
+    await transport.connect();
+    expect(transport.isConnected()).toBe(true);
+
+    const response = await transport.callTool('test-tool', { greeting: 'hello' }, 10_000);
+
+    expect(response.content).toBeDefined();
+
+    const content =
+      typeof response.content === 'string'
+        ? (JSON.parse(response.content) as Record<string, unknown>)
+        : response.content;
+
+    expect(content).toHaveProperty('name', 'test-tool');
+    expect(content).toHaveProperty('arguments');
+    const args = content.arguments as Record<string, unknown>;
+    expect(args).toHaveProperty('greeting', 'hello');
+
+    await transport.disconnect();
+    expect(transport.isConnected()).toBe(false);
+  }, 15_000);
+
+  it('McpManager.callTool() dispatches through StdioMcpTransport for stdio config', async () => {
+    const scriptPath = await createEchoServer();
+
+    const config: McpConfig = {
+      servers: {
+        'echo-server': makeStdioConfig('echo-server', scriptPath),
+      },
+    };
+    manager = new McpManager(config, silentLogger);
+    manager.markConnected('echo-server');
+
+    const result = await manager.callTool(
+      'echo-server',
+      'ping-tool',
+      { message: 'pong' },
+      { timeoutMs: 10_000 },
+    );
+
+    expect(result).toBeDefined();
+    expect(result).toHaveProperty('name', 'ping-tool');
+    expect(result).toHaveProperty('arguments');
+    const args = result.arguments as Record<string, unknown>;
+    expect(args).toHaveProperty('message', 'pong');
+  }, 15_000);
+
+  it('echo server round-trips multiple sequential calls', async () => {
+    const scriptPath = await createEchoServer();
+
+    transport = new StdioMcpTransport(makeStdioConfig('echo-multi', scriptPath), silentLogger);
+
+    await transport.connect();
+
+    const r1 = await transport.callTool('tool-a', { n: 1 }, 10_000);
+    const c1 =
+      typeof r1.content === 'string'
+        ? (JSON.parse(r1.content) as Record<string, unknown>)
+        : r1.content;
+    expect((c1.arguments as Record<string, unknown>).n).toBe(1);
+
+    const r2 = await transport.callTool('tool-b', { n: 2 }, 10_000);
+    const c2 =
+      typeof r2.content === 'string'
+        ? (JSON.parse(r2.content) as Record<string, unknown>)
+        : r2.content;
+    expect((c2.arguments as Record<string, unknown>).n).toBe(2);
+
+    await transport.disconnect();
+  }, 15_000);
+});