@moda-ai/cli 1.0.4 → 1.1.0

package/dist/__tests__/api-client.test.js

@@ -1,73 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Mock config before importing api-client
-vi.mock('../config.js', () => ({
-    MODA_API_KEY: 'moda_sk_test_key',
-    MODA_BASE_URL: 'https://test.modaflows.com',
-}));
-import { callDataAPI, ApiError } from '../api-client.js';
-describe('callDataAPI', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('constructs correct URL', async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({ data: 'test' }),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await callDataAPI('/overview?days_back=7');
-        expect(mockFetch).toHaveBeenCalledWith('https://test.modaflows.com/api/v1/data/overview?days_back=7', expect.objectContaining({
-            headers: expect.objectContaining({
-                'x-api-key': 'moda_sk_test_key',
-            }),
-        }));
-    });
-    it('throws ApiError on non-ok response', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: false,
-            status: 401,
-            text: () => Promise.resolve('Unauthorized'),
-        }));
-        await expect(callDataAPI('/overview')).rejects.toThrow('API error (401): Unauthorized');
-        await vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: false,
-            status: 401,
-            text: () => Promise.resolve('Unauthorized'),
-        }));
-        try {
-            await callDataAPI('/overview');
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(ApiError);
-            expect(e.statusCode).toBe(401);
-        }
-    });
-    it('retries on 500 errors', async () => {
-        const mockFetch = vi.fn()
-            .mockResolvedValueOnce({ ok: false, status: 500, text: () => Promise.resolve('Internal Server Error') })
-            .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ data: 'ok' }) });
-        vi.stubGlobal('fetch', mockFetch);
-        const result = await callDataAPI('/overview');
-        expect(result).toEqual({ data: 'ok' });
-        expect(mockFetch).toHaveBeenCalledTimes(2);
-    });
-    it('does not retry on 4xx errors (except 429)', async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: false,
-            status: 403,
-            text: () => Promise.resolve('Forbidden'),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await expect(callDataAPI('/overview')).rejects.toThrow('API error (403)');
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-    it('returns parsed JSON on success', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({ conversations: { total: 100 } }),
-        }));
-        const result = await callDataAPI('/overview');
-        expect(result).toEqual({ conversations: { total: 100 } });
-    });
-});
-//# sourceMappingURL=api-client.test.js.map

package/dist/__tests__/cli.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cli.test.d.ts.map

package/dist/__tests__/cli.test.js

@@ -1,109 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Mock api-client (same pattern as handlers.test.ts)
-vi.mock('../api-client.js', () => ({
-    callDataAPI: vi.fn().mockResolvedValue({ mock: true }),
-}));
-// Mock config to prevent process.exit
-vi.mock('../config.js', () => ({
-    validateConfig: vi.fn(),
-    MODA_API_KEY: 'test-key',
-    MODA_BASE_URL: 'https://test.example.com',
-    PORT: 3003,
-}));
-// Import after mocks
-import { parseArgs, flagsToArgs } from '../cli.js';
-import { callDataAPI } from '../api-client.js';
-const mockCallDataAPI = vi.mocked(callDataAPI);
-describe('parseArgs', () => {
-    it('extracts command from argv', () => {
-        const result = parseArgs(['node', 'cli.js', 'overview']);
-        expect(result.command).toBe('overview');
-        expect(result.positional).toBeUndefined();
-        expect(result.flags).toEqual({});
-    });
-    it('extracts positional argument', () => {
-        const result = parseArgs(['node', 'cli.js', 'cluster-conversations', 'node-123']);
-        expect(result.command).toBe('cluster-conversations');
-        expect(result.positional).toBe('node-123');
-    });
-    it('parses --key=value flags', () => {
-        const result = parseArgs(['node', 'cli.js', 'overview', '--days-back=30']);
-        expect(result.flags).toEqual({ 'days-back': '30' });
-    });
-    it('parses --key value flags', () => {
-        const result = parseArgs(['node', 'cli.js', 'overview', '--days-back', '30']);
-        expect(result.flags).toEqual({ 'days-back': '30' });
-    });
-    it('parses mixed flag formats', () => {
-        const result = parseArgs(['node', 'cli.js', 'conversations', '--search=error', '--limit', '5']);
-        expect(result.flags).toEqual({ search: 'error', limit: '5' });
-    });
-    it('handles boolean flags (no value)', () => {
-        const result = parseArgs(['node', 'cli.js', '--help']);
-        expect(result.command).toBe('--help');
-    });
-    it('returns empty command for no args', () => {
-        const result = parseArgs(['node', 'cli.js']);
-        expect(result.command).toBe('');
-    });
-    it('handles positional before flags', () => {
-        const result = parseArgs(['node', 'cli.js', 'context', 'conv-abc', '--window=3']);
-        expect(result.command).toBe('context');
-        expect(result.positional).toBe('conv-abc');
-        expect(result.flags).toEqual({ window: '3' });
-    });
-});
-describe('flagsToArgs', () => {
-    it('converts kebab-case to snake_case', () => {
-        const result = flagsToArgs({ 'days-back': '30', 'time-range': '7d' });
-        expect(result).toEqual({ days_back: 30, time_range: '7d' });
-    });
-    it('parses numeric values', () => {
-        const result = flagsToArgs({ limit: '10', offset: '0' });
-        expect(result).toEqual({ limit: 10, offset: 0 });
-    });
-    it('keeps string values as strings', () => {
-        const result = flagsToArgs({ search: 'error message' });
-        expect(result).toEqual({ search: 'error message' });
-    });
-    it('includes positional key/value', () => {
-        const result = flagsToArgs({ limit: '5' }, 'node_id', 'node-123');
-        expect(result).toEqual({ node_id: 'node-123', limit: 5 });
-    });
-});
-describe('CLI command dispatch', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    // We test the commands by dynamically importing and calling runCommand.
-    // Since runCommand is not exported, we test indirectly via the module's behavior.
-    // The key thing to test is that each command constructs the correct API URL.
-    // This is tested at the integration level via handlers.test.ts already.
-    // Here we focus on the arg parsing + flag conversion that is unique to the CLI.
-    it('overview command builds correct args from flags', () => {
-        const args = flagsToArgs({ 'days-back': '14' });
-        expect(args).toEqual({ days_back: 14 });
-    });
-    it('cluster-conversations builds args with positional node_id', () => {
-        const args = flagsToArgs({ limit: '5', offset: '0' }, 'node_id', 'cluster-abc');
-        expect(args).toEqual({ node_id: 'cluster-abc', limit: 5, offset: 0 });
-    });
-    it('conversations builds args with multiple flags', () => {
-        const args = flagsToArgs({ search: 'error', 'user-id': 'user-1', 'time-range': '7d', limit: '10', offset: '0' });
-        expect(args).toEqual({ search: 'error', user_id: 'user-1', time_range: '7d', limit: 10, offset: 0 });
-    });
-    it('context builds args with positional conversation_id', () => {
-        const args = flagsToArgs({ 'msg-index': '5', window: '3' }, 'conversation_id', 'conv-xyz');
-        expect(args).toEqual({ conversation_id: 'conv-xyz', msg_index: 5, window: 3 });
-    });
-    it('tool-failure-detail builds args with positional tool_name', () => {
-        const args = flagsToArgs({ subtype: 'timeout', 'days-back': '14' }, 'tool_name', 'search');
-        expect(args).toEqual({ tool_name: 'search', subtype: 'timeout', days_back: 14 });
-    });
-    it('offset=0 is preserved (not dropped as falsy)', () => {
-        const args = flagsToArgs({ offset: '0' });
-        expect(args.offset).toBe(0);
-        expect(args.offset).not.toBeUndefined();
-    });
-});
-//# sourceMappingURL=cli.test.js.map

package/dist/__tests__/e2e.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=e2e.test.d.ts.map

package/dist/__tests__/e2e.test.js

@@ -1,239 +0,0 @@
-import { spawn } from 'node:child_process';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const SERVER_PATH = resolve(__dirname, '../../dist/index.js');
-const MODA_API_KEY = process.env.MODA_API_KEY;
-// --- JSON-RPC Helper ---
-let nextId = 1;
-function sendJsonRpc(server, method, params) {
-    const id = nextId++;
-    return new Promise((resolve, reject) => {
-        let buffer = '';
-        const onData = (chunk) => {
-            buffer += chunk.toString();
-            const lines = buffer.split('\n');
-            // Keep the last (potentially incomplete) line in the buffer
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                try {
-                    const parsed = JSON.parse(line);
-                    if (parsed.id === id) {
-                        server.stdout.removeListener('data', onData);
-                        resolve(parsed);
-                    }
-                }
-                catch {
-                    // Not valid JSON, skip
-                }
-            }
-        };
-        server.stdout.on('data', onData);
-        const message = JSON.stringify({
-            jsonrpc: '2.0',
-            method,
-            ...(params && { params }),
-            id,
-        });
-        server.stdin.write(message + '\n');
-        // Timeout after 30s
-        setTimeout(() => {
-            server.stdout.removeListener('data', onData);
-            reject(new Error(`sendJsonRpc timed out waiting for response id=${id}`));
-        }, 30_000);
-    });
-}
-// --- Shared State for Chained Tests ---
-let capturedNodeId;
-let capturedConversationId;
-let capturedToolName;
-// --- Test Suite ---
-describe.skipIf(!MODA_API_KEY)('E2E: MCP Server against live backend', { timeout: 30_000 }, () => {
-    let mcpServer;
-    beforeAll(async () => {
-        // Spawn the MCP server process
-        mcpServer = spawn('node', [SERVER_PATH], {
-            env: { ...process.env },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        // Wait for the server startup message on stderr
-        await new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => reject(new Error('Server startup timeout')), 10_000);
-            mcpServer.stderr.on('data', (data) => {
-                if (data.toString().includes('running on stdio')) {
-                    clearTimeout(timeout);
-                    resolve();
-                }
-            });
-            mcpServer.on('error', (err) => {
-                clearTimeout(timeout);
-                reject(err);
-            });
-        });
-        // MCP protocol: send initialize request
-        const initResponse = await sendJsonRpc(mcpServer, 'initialize', {
-            protocolVersion: '2024-11-05',
-            capabilities: {},
-            clientInfo: { name: 'e2e-test', version: '1.0.0' },
-        });
-        expect(initResponse.result).toBeDefined();
-        // MCP protocol: send initialized notification (no id, no response)
-        mcpServer.stdin.write(JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' }) + '\n');
-    });
-    afterAll(() => {
-        mcpServer?.kill();
-    });
-    // --- Phase 1: Overview ---
-    it('moda_get_overview returns valid overview data', async () => {
-        const response = await sendJsonRpc(mcpServer, 'tools/call', {
-            name: 'moda_get_overview',
-            arguments: { days_back: 7 },
-        });
-        expect(response.result).toBeDefined();
-        expect(response.result.content).toHaveLength(1);
-        expect(response.result.content[0].type).toBe('text');
-        const data = JSON.parse(response.result.content[0].text);
-        expect(data).toHaveProperty('conversations');
-        expect(data).toHaveProperty('frustrations');
-        expect(data).toHaveProperty('tool_failures');
-        expect(data).toHaveProperty('top_clusters');
-        expect(data).toHaveProperty('recent_activity');
-    });
-    // --- Phase 2: Independent Tools ---
-    it('moda_get_clusters returns cluster hierarchy', async () => {
-        const response = await sendJsonRpc(mcpServer, 'tools/call', {
-            name: 'moda_get_clusters',
-            arguments: {},
-        });
-        expect(response.result).toBeDefined();
-        const data = JSON.parse(response.result.content[0].text);
-        expect(data).toHaveProperty('clusters');
-        expect(Array.isArray(data.clusters)).toBe(true);
-        if (data.clusters.length > 0) {
-            const cluster = data.clusters[0];
-            expect(cluster).toHaveProperty('node_id');
-            expect(cluster).toHaveProperty('label');
-            // Capture for Phase 3
-            capturedNodeId = cluster.node_id;
-        }
-    });
-    it('moda_search_conversations returns conversations list', async () => {
-        const response = await sendJsonRpc(mcpServer, 'tools/call', {
-            name: 'moda_search_conversations',
-            arguments: {},
-        });
-        expect(response.result).toBeDefined();
-        const data = JSON.parse(response.result.content[0].text);
-        expect(data).toHaveProperty('conversations');
-        expect(Array.isArray(data.conversations)).toBe(true);
-        expect(data).toHaveProperty('pagination');
-        if (data.conversations.length > 0) {
-            const convo = data.conversations[0];
-            expect(convo).toHaveProperty('conversation_id');
-            expect(convo).toHaveProperty('summary');
-            // Capture for Phase 3
-            capturedConversationId = convo.conversation_id;
-        }
-    });
-    it('moda_get_frustrations returns frustration data', async () => {
-        const response = await sendJsonRpc(mcpServer, 'tools/call', {
-            name: 'moda_get_frustrations',
-            arguments: { days_back: 7 },
-        });
-        expect(response.result).toBeDefined();
-        const data = JSON.parse(response.result.content[0].text);
-        expect(data).toHaveProperty('summary');
-        expect(data).toHaveProperty('frustrations');
-        expect(Array.isArray(data.frustrations)).toBe(true);
-        if (data.frustrations.length > 0) {
-            expect(data.frustrations[0]).toHaveProperty('conversation_id');
-        }
-    });
-    it('moda_get_tool_failures returns failure overview', async () => {
-        const response = await sendJsonRpc(mcpServer, 'tools/call', {
-            name: 'moda_get_tool_failures',
-            arguments: { days_back: 7 },
-        });
-        expect(response.result).toBeDefined();
-        const data = JSON.parse(response.result.content[0].text);
-        expect(data).toHaveProperty('summary');
-        expect(data).toHaveProperty('tools');
-        expect(Array.isArray(data.tools)).toBe(true);
-        if (data.tools.length > 0) {
-            const tool = data.tools[0];
-            expect(tool).toHaveProperty('tool_name');
-            expect(tool).toHaveProperty('failure_count');
-            // Capture for Phase 3
-            capturedToolName = tool.tool_name;
-        }
-    });
-    // --- Phase 3: Chained Tools ---
-    it('moda_get_cluster_conversations returns conversations for a cluster', async () => {
-        if (!capturedNodeId) {
-            console.warn('Skipping: no node_id captured from moda_get_clusters (empty data)');
-            return;
-        }
-        const response = await sendJsonRpc(mcpServer, 'tools/call', {
-            name: 'moda_get_cluster_conversations',
-            arguments: { node_id: capturedNodeId },
-        });
-        expect(response.result).toBeDefined();
-        const data = JSON.parse(response.result.content[0].text);
-        expect(data).toHaveProperty('cluster');
-        expect(data).toHaveProperty('conversations');
-        expect(Array.isArray(data.conversations)).toBe(true);
-        expect(data).toHaveProperty('pagination');
-        if (data.conversations.length > 0) {
-            expect(data.conversations[0]).toHaveProperty('conversation_id');
-        }
-    });
-    it('moda_get_conversation_context returns message context', async () => {
-        if (!capturedConversationId) {
-            console.warn('Skipping: no conversation_id captured from moda_search_conversations (empty data)');
-            return;
-        }
-        const response = await sendJsonRpc(mcpServer, 'tools/call', {
-            name: 'moda_get_conversation_context',
-            arguments: { conversation_id: capturedConversationId },
-        });
-        expect(response.result).toBeDefined();
-        const data = JSON.parse(response.result.content[0].text);
-        expect(data).toHaveProperty('conversation_id');
-        expect(data).toHaveProperty('summary');
-        expect(data).toHaveProperty('context');
-        expect(data.context).toHaveProperty('messages');
-        expect(Array.isArray(data.context.messages)).toBe(true);
-    });
-    it('moda_get_tool_failure_detail returns failure details', async () => {
-        if (!capturedToolName) {
-            console.warn('Skipping: no tool_name captured from moda_get_tool_failures (empty data)');
-            return;
-        }
-        const response = await sendJsonRpc(mcpServer, 'tools/call', {
-            name: 'moda_get_tool_failure_detail',
-            arguments: { tool_name: capturedToolName },
-        });
-        expect(response.result).toBeDefined();
-        const data = JSON.parse(response.result.content[0].text);
-        expect(data).toHaveProperty('tool_name');
-        expect(typeof data.tool_name).toBe('string');
-        expect(data).toHaveProperty('subtypes');
-        expect(Array.isArray(data.subtypes)).toBe(true);
-        expect(data).toHaveProperty('examples');
-        expect(Array.isArray(data.examples)).toBe(true);
-    });
-    // --- Error Handling ---
-    it('returns error for invalid arguments (Zod validation)', async () => {
-        const response = await sendJsonRpc(mcpServer, 'tools/call', {
-            name: 'moda_get_overview',
-            arguments: { days_back: 999 },
-        });
-        // The MCP SDK wraps handler errors into an error response
-        expect(response.error).toBeDefined();
-        expect(response.error.message).toContain('Invalid arguments');
-    });
-});
-//# sourceMappingURL=e2e.test.js.map

package/dist/__tests__/handlers.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=handlers.test.d.ts.map

package/dist/__tests__/handlers.test.js

@@ -1,71 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Mock api-client
-vi.mock('../api-client.js', () => ({
-    callDataAPI: vi.fn().mockResolvedValue({ mock: true }),
-}));
-import { handleToolCall } from '../handlers.js';
-import { callDataAPI } from '../api-client.js';
-const mockCallDataAPI = vi.mocked(callDataAPI);
-describe('handleToolCall', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('moda_get_overview calls correct endpoint', async () => {
-        await handleToolCall('moda_get_overview', { days_back: 14 });
-        expect(mockCallDataAPI).toHaveBeenCalledWith('/overview?days_back=14');
-    });
-    it('moda_get_overview with no args omits query string', async () => {
-        await handleToolCall('moda_get_overview', {});
-        expect(mockCallDataAPI).toHaveBeenCalledWith('/overview');
-    });
-    it('moda_get_clusters passes parent_id and time_range', async () => {
-        await handleToolCall('moda_get_clusters', { parent_id: 'node-1', time_range: '7d' });
-        expect(mockCallDataAPI).toHaveBeenCalledWith(expect.stringContaining('parent_id=node-1'));
-        expect(mockCallDataAPI).toHaveBeenCalledWith(expect.stringContaining('time_range=7d'));
-    });
-    it('moda_get_cluster_conversations includes offset=0', async () => {
-        await handleToolCall('moda_get_cluster_conversations', { node_id: 'c-1', offset: 0 });
-        const calledUrl = mockCallDataAPI.mock.calls[0][0];
-        expect(calledUrl).toContain('offset=0');
-    });
-    it('moda_search_conversations includes offset=0', async () => {
-        await handleToolCall('moda_search_conversations', { offset: 0 });
-        const calledUrl = mockCallDataAPI.mock.calls[0][0];
-        expect(calledUrl).toContain('offset=0');
-    });
-    it('moda_get_frustrations includes offset=0', async () => {
-        await handleToolCall('moda_get_frustrations', { offset: 0 });
-        const calledUrl = mockCallDataAPI.mock.calls[0][0];
-        expect(calledUrl).toContain('offset=0');
-    });
-    it('moda_get_tool_failure_detail includes offset=0', async () => {
-        await handleToolCall('moda_get_tool_failure_detail', { tool_name: 'search', offset: 0 });
-        const calledUrl = mockCallDataAPI.mock.calls[0][0];
-        expect(calledUrl).toContain('offset=0');
-    });
-    it('moda_get_conversation_context uses conversation_id in path', async () => {
-        await handleToolCall('moda_get_conversation_context', { conversation_id: 'conv-abc' });
-        expect(mockCallDataAPI).toHaveBeenCalledWith(expect.stringContaining('/conversations/conv-abc/context'));
-    });
-    it('moda_get_tool_failures calls correct endpoint', async () => {
-        await handleToolCall('moda_get_tool_failures', { days_back: 30 });
-        expect(mockCallDataAPI).toHaveBeenCalledWith('/tool-failures?days_back=30');
-    });
-    it('moda_get_tool_failure_detail uses tool_name in path', async () => {
-        await handleToolCall('moda_get_tool_failure_detail', { tool_name: 'compose' });
-        expect(mockCallDataAPI).toHaveBeenCalledWith(expect.stringContaining('/tool-failures/compose'));
-    });
-    it('throws on unknown tool', async () => {
-        await expect(handleToolCall('unknown_tool', {})).rejects.toThrow('Unknown tool: unknown_tool');
-    });
-    it('throws on invalid arguments', async () => {
-        await expect(handleToolCall('moda_get_overview', { days_back: 'invalid' })).rejects.toThrow('Invalid arguments');
-    });
-    it('returns content array with JSON text', async () => {
-        const result = await handleToolCall('moda_get_overview', {});
-        expect(result.content).toHaveLength(1);
-        expect(result.content[0].type).toBe('text');
-        expect(JSON.parse(result.content[0].text)).toEqual({ mock: true });
-    });
-});
-//# sourceMappingURL=handlers.test.js.map

package/dist/__tests__/integration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=integration.test.d.ts.map

package/dist/__tests__/integration.test.js

@@ -1,114 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { spawn } from 'child_process';
-import { resolve } from 'path';
-import { fileURLToPath } from 'url';
-const __dirname = fileURLToPath(new URL('.', import.meta.url));
-const ROOT = resolve(__dirname, '../..');
-let mockServer;
-function sendJsonRpc(proc, method, params, id = 1) {
-    return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => reject(new Error('Timeout waiting for response')), 10000);
-        let buffer = '';
-        const onData = (data) => {
-            buffer += data.toString();
-            const lines = buffer.split('\n');
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                try {
-                    const parsed = JSON.parse(line);
-                    if (parsed.id === id) {
-                        clearTimeout(timeout);
-                        proc.stdout.off('data', onData);
-                        resolve(parsed);
-                    }
-                }
-                catch { /* incomplete JSON */ }
-            }
-        };
-        proc.stdout.on('data', onData);
-        const request = JSON.stringify({ jsonrpc: '2.0', method, params, id });
-        proc.stdin.write(request + '\n');
-    });
-}
-beforeAll(async () => {
-    // Start mock server
-    mockServer = spawn('node', [resolve(ROOT, 'mock-server.js')], { stdio: ['pipe', 'pipe', 'pipe'] });
-    await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => reject(new Error('Mock server did not start in time')), 10000);
-        // mock-server.js uses console.log which goes to stdout
-        mockServer.stdout.on('data', (data) => {
-            if (data.toString().includes('Mock Data API server running')) {
-                clearTimeout(timeout);
-                resolve();
-            }
-        });
-        mockServer.stderr.on('data', (data) => {
-            if (data.toString().includes('Mock Data API server running')) {
-                clearTimeout(timeout);
-                resolve();
-            }
-        });
-    });
-}, 15000);
-afterAll(() => {
-    mockServer?.kill();
-});
-describe('MCP Server Integration', () => {
-    it('lists 8 tools', async () => {
-        const mcpServer = spawn('node', [resolve(ROOT, 'dist/index.js')], {
-            env: { ...process.env, MODA_API_KEY: 'moda_sk_test', MODA_BASE_URL: 'http://localhost:3002' },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        try {
-            // Wait for server to start
-            await new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => reject(new Error('MCP server did not start in time')), 10000);
-                mcpServer.stderr.on('data', (data) => {
-                    if (data.toString().includes('running on stdio')) {
-                        clearTimeout(timeout);
-                        resolve();
-                    }
-                });
-            });
-            const response = await sendJsonRpc(mcpServer, 'tools/list');
-            expect(response.result.tools).toHaveLength(8);
-            const toolNames = response.result.tools.map((t) => t.name);
-            expect(toolNames).toContain('moda_get_overview');
-            expect(toolNames).toContain('moda_get_frustrations');
-            expect(toolNames).toContain('moda_get_tool_failures');
-        }
-        finally {
-            mcpServer.kill();
-        }
-    }, 20000);
-    it('calls moda_get_overview and returns data', async () => {
-        const mcpServer = spawn('node', [resolve(ROOT, 'dist/index.js')], {
-            env: { ...process.env, MODA_API_KEY: 'moda_sk_test', MODA_BASE_URL: 'http://localhost:3002' },
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        try {
-            await new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => reject(new Error('MCP server did not start in time')), 10000);
-                mcpServer.stderr.on('data', (data) => {
-                    if (data.toString().includes('running on stdio')) {
-                        clearTimeout(timeout);
-                        resolve();
-                    }
-                });
-            });
-            const response = await sendJsonRpc(mcpServer, 'tools/call', {
-                name: 'moda_get_overview',
-                arguments: { days_back: 7 },
-            });
-            expect(response.result.content).toHaveLength(1);
-            expect(response.result.content[0].type).toBe('text');
-            const data = JSON.parse(response.result.content[0].text);
-            expect(data.conversations.total).toBe(1011);
-        }
-        finally {
-            mcpServer.kill();
-        }
-    }, 20000);
-});
-//# sourceMappingURL=integration.test.js.map

package/dist/__tests__/schemas.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=schemas.test.d.ts.map