@kaelio/ktx 0.5.0 → 0.7.0

package/dist/mcp-http-server.test.js

@@ -1,209 +0,0 @@
-import { request } from 'node:http';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { describe, expect, it } from 'vitest';
-import { buildMcpSecurityConfig, isMcpRequestAuthorized, normalizeHostHeader, runKtxMcpHttpServer, } from './mcp-http-server.js';
-describe('normalizeHostHeader', () => {
-    it('normalizes host headers before allow-list comparison', () => {
-        expect(normalizeHostHeader('LOCALHOST:7878')).toBe('localhost');
-        expect(normalizeHostHeader('127.0.0.1:7878')).toBe('127.0.0.1');
-        expect(normalizeHostHeader('[::1]:7878')).toBe('::1');
-        expect(normalizeHostHeader('  Example.COM  ')).toBe('example.com');
-    });
-});
-describe('buildMcpSecurityConfig', () => {
-    it('allows loopback hosts without a token', () => {
-        const config = buildMcpSecurityConfig({
-            host: '127.0.0.1',
-            port: 7878,
-            token: undefined,
-            allowedHosts: [],
-            allowedOrigins: [],
-        });
-        expect(config.token).toBeUndefined();
-        expect(config.allowedHosts).toEqual(['localhost', '127.0.0.1', '::1']);
-    });
-    it('requires a token for non-loopback binding', () => {
-        expect(() => buildMcpSecurityConfig({
-            host: '0.0.0.0',
-            port: 7878,
-            token: undefined,
-            allowedHosts: [],
-            allowedOrigins: [],
-        })).toThrow('Binding KTX MCP to 0.0.0.0 requires --token or KTX_MCP_TOKEN');
-    });
-    it('validates allowed origins as full origins', () => {
-        expect(() => buildMcpSecurityConfig({
-            host: '127.0.0.1',
-            port: 7878,
-            token: undefined,
-            allowedHosts: [],
-            allowedOrigins: ['localhost:7878'],
-        })).toThrow('Allowed origin must be a full origin URL');
-    });
-});
-describe('isMcpRequestAuthorized', () => {
-    const config = buildMcpSecurityConfig({
-        host: '0.0.0.0',
-        port: 7878,
-        token: 'secret-token',
-        allowedHosts: ['mcp.example.test'],
-        allowedOrigins: ['https://mcp.example.test'],
-    });
-    it('accepts a valid host, origin, and bearer token', () => {
-        expect(isMcpRequestAuthorized({
-            path: '/mcp',
-            headers: {
-                host: 'mcp.example.test:7878',
-                origin: 'https://mcp.example.test',
-                authorization: 'Bearer secret-token',
-            },
-        }, config)).toEqual({ ok: true });
-    });
-    it('rejects bad host headers before MCP handling', () => {
-        expect(isMcpRequestAuthorized({ path: '/health', headers: { host: 'evil.example.test' } }, config)).toEqual({ ok: false, status: 403, message: 'Host header is not allowed for KTX MCP.' });
-    });
-    it('rejects browser origins unless explicitly allowed', () => {
-        expect(isMcpRequestAuthorized({
-            path: '/health',
-            headers: { host: 'mcp.example.test', origin: 'https://evil.example.test' },
-        }, config)).toEqual({ ok: false, status: 403, message: 'Origin header is not allowed for KTX MCP.' });
-    });
-    it('requires bearer auth on /mcp when token auth is enabled', () => {
-        expect(isMcpRequestAuthorized({ path: '/mcp', headers: { host: 'mcp.example.test', authorization: 'Bearer wrong' } }, config)).toEqual({ ok: false, status: 401, message: 'Missing or invalid KTX MCP bearer token.' });
-    });
-    it('does not require bearer auth on /health', () => {
-        expect(isMcpRequestAuthorized({ path: '/health', headers: { host: 'mcp.example.test' } }, config)).toEqual({
-            ok: true,
-        });
-    });
-});
-function postJson(port, path, body, headers = {}) {
-    return new Promise((resolve, reject) => {
-        const payload = JSON.stringify(body);
-        const req = request({
-            host: '127.0.0.1',
-            port,
-            path,
-            method: 'POST',
-            headers: {
-                host: `127.0.0.1:${port}`,
-                accept: 'application/json, text/event-stream',
-                'content-type': 'application/json',
-                'content-length': Buffer.byteLength(payload),
-                ...headers,
-            },
-        }, (res) => {
-            const chunks = [];
-            res.on('data', (chunk) => chunks.push(chunk));
-            res.on('end', () => resolve({
-                status: res.statusCode ?? 0,
-                headers: res.headers,
-                body: Buffer.concat(chunks).toString('utf8'),
-            }));
-        });
-        req.on('error', reject);
-        req.end(payload);
-    });
-}
-function get(port, path, headers = {}) {
-    return new Promise((resolve, reject) => {
-        const req = request({
-            host: '127.0.0.1',
-            port,
-            path,
-            method: 'GET',
-            headers: { host: `127.0.0.1:${port}`, ...headers },
-        }, (res) => {
-            const chunks = [];
-            res.on('data', (chunk) => chunks.push(chunk));
-            res.on('end', () => resolve({
-                status: res.statusCode ?? 0,
-                headers: res.headers,
-                body: Buffer.concat(chunks).toString('utf8'),
-            }));
-        });
-        req.on('error', reject);
-        req.end();
-    });
-}
-function createTestMcpServer() {
-    return () => {
-        const server = new McpServer({ name: 'ktx-test', version: '0.0.0-test' });
-        server.registerTool('ping', { inputSchema: {} }, async () => ({
-            content: [{ type: 'text', text: 'pong' }],
-        }));
-        return server;
-    };
-}
-describe('runKtxMcpHttpServer', () => {
-    it('serves /health with project metadata', async () => {
-        const handle = await runKtxMcpHttpServer({
-            projectDir: '/tmp/ktx-project',
-            host: '127.0.0.1',
-            port: 0,
-            allowedHosts: [],
-            allowedOrigins: [],
-            createMcpServer: createTestMcpServer(),
-        });
-        try {
-            const port = handle.server.address().port;
-            const response = await get(port, '/health');
-            expect(response.status).toBe(200);
-            expect(JSON.parse(response.body)).toEqual({
-                status: 'ok',
-                projectDir: '/tmp/ktx-project',
-                port,
-            });
-        }
-        finally {
-            await handle.close();
-        }
-    });
-    it('allocates a stateful MCP session on initialize', async () => {
-        const handle = await runKtxMcpHttpServer({
-            projectDir: '/tmp/ktx-project',
-            host: '127.0.0.1',
-            port: 0,
-            allowedHosts: [],
-            allowedOrigins: [],
-            createMcpServer: createTestMcpServer(),
-        });
-        try {
-            const port = handle.server.address().port;
-            const response = await postJson(port, '/mcp', {
-                jsonrpc: '2.0',
-                id: 1,
-                method: 'initialize',
-                params: {
-                    protocolVersion: '2025-06-18',
-                    capabilities: {},
-                    clientInfo: { name: 'vitest', version: '0.0.0' },
-                },
-            });
-            expect(response.status).toBe(200);
-            expect(response.headers['mcp-session-id']).toBeTruthy();
-        }
-        finally {
-            await handle.close();
-        }
-    });
-    it('rejects unknown session ids with 404', async () => {
-        const handle = await runKtxMcpHttpServer({
-            projectDir: '/tmp/ktx-project',
-            host: '127.0.0.1',
-            port: 0,
-            allowedHosts: [],
-            allowedOrigins: [],
-            createMcpServer: createTestMcpServer(),
-        });
-        try {
-            const port = handle.server.address().port;
-            const response = await postJson(port, '/mcp', { jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} }, { 'mcp-session-id': 'missing-session' });
-            expect(response.status).toBe(404);
-            expect(response.body).toContain('Unknown MCP session');
-        }
-        finally {
-            await handle.close();
-        }
-    });
-});

package/dist/mcp-server-factory.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/mcp-server-factory.test.js

@@ -1,142 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { createDefaultKtxMcpServer } from './context/mcp/server.js';
-import { createLocalProjectMcpContextPorts } from './context/mcp/local-project-ports.js';
-import { createLocalProjectMemoryIngest } from './context/memory/local-memory.js';
-import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
-import { createKtxCliScanConnector } from './local-scan-connectors.js';
-import { createKtxMcpServerFactory } from './mcp-server-factory.js';
-const mocks = vi.hoisted(() => ({
-    queryExecutor: { execute: vi.fn() },
-    semanticLayerCompute: { validateSources: vi.fn(), generateSources: vi.fn(), query: vi.fn() },
-    sqlAnalysis: { analyzeForFingerprint: vi.fn(), analyzeBatch: vi.fn(), validateReadOnly: vi.fn() },
-    memoryIngest: { ingest: vi.fn(), status: vi.fn(), waitForRun: vi.fn() },
-}));
-vi.mock('./context/llm/embedding-port.js', () => ({
-    KtxIngestEmbeddingPortAdapter: class {
-        provider;
-        maxBatchSize;
-        constructor(provider) {
-            this.provider = provider;
-            this.maxBatchSize = provider.maxBatchSize;
-        }
-        computeEmbedding(text) {
-            return this.provider.embed(text);
-        }
-        computeEmbeddingsBulk(texts) {
-            return this.provider.embedMany(texts);
-        }
-    },
-}));
-vi.mock('./context/mcp/server.js', () => ({
-    createDefaultKtxMcpServer: vi.fn(() => ({ kind: 'mcp-server' })),
-}));
-vi.mock('./context/mcp/local-project-ports.js', () => ({
-    createLocalProjectMcpContextPorts: vi.fn(() => ({ context_tool: { name: 'context_tool' } })),
-}));
-vi.mock('./context/memory/local-memory.js', () => ({
-    createLocalProjectMemoryIngest: vi.fn(() => mocks.memoryIngest),
-}));
-vi.mock('./embedding-resolution.js', () => ({
-    resolveProjectEmbeddingProvider: vi.fn(),
-}));
-vi.mock('./ingest-query-executor.js', () => ({
-    createKtxCliIngestQueryExecutor: vi.fn(() => mocks.queryExecutor),
-}));
-vi.mock('./local-scan-connectors.js', () => ({
-    createKtxCliScanConnector: vi.fn(() => ({ source: 'fake-scan-connector' })),
-}));
-vi.mock('./managed-python-command.js', () => ({
-    createManagedPythonSemanticLayerComputePort: vi.fn(async () => mocks.semanticLayerCompute),
-}));
-vi.mock('./managed-python-http.js', () => ({
-    createManagedDaemonSqlAnalysisPort: vi.fn(() => mocks.sqlAnalysis),
-}));
-const project = {
-    projectDir: '/work/project',
-    configPath: '/work/project/ktx.yaml',
-    config: {},
-    coreConfig: {},
-    git: {},
-    fileStore: {},
-};
-const io = {
-    stdout: { write: vi.fn() },
-    stderr: { write: vi.fn() },
-};
-describe('createKtxMcpServerFactory', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('passes a resolved embedding provider to MCP context ports and memory ingest', async () => {
-        const provider = {
-            maxBatchSize: 4,
-            embed: vi.fn(async () => [0.2, 0.4]),
-            embedMany: vi.fn(async () => [[0.2, 0.4]]),
-        };
-        vi.mocked(resolveProjectEmbeddingProvider).mockResolvedValue({ kind: 'configured', provider });
-        const factory = await createKtxMcpServerFactory({
-            project: project,
-            projectDir: project.projectDir,
-            cliVersion: '0.5.0',
-            io,
-        });
-        const contextOptions = vi.mocked(createLocalProjectMcpContextPorts).mock.calls[0][1];
-        await expect(contextOptions.embeddingService.computeEmbedding('gross revenue')).resolves.toEqual([0.2, 0.4]);
-        await expect(contextOptions.embeddingService.computeEmbeddingsBulk(['gross revenue'])).resolves.toEqual([[0.2, 0.4]]);
-        await expect(contextOptions.localScan.createConnector('warehouse')).resolves.toEqual({
-            source: 'fake-scan-connector',
-        });
-        expect(provider.embed).toHaveBeenCalledWith('gross revenue');
-        expect(provider.embedMany).toHaveBeenCalledWith(['gross revenue']);
-        expect(createKtxCliScanConnector).toHaveBeenCalledWith(project, 'warehouse');
-        expect(contextOptions).toMatchObject({
-            queryExecutor: mocks.queryExecutor,
-            semanticLayerCompute: mocks.semanticLayerCompute,
-            sqlAnalysis: mocks.sqlAnalysis,
-        });
-        expect(createLocalProjectMemoryIngest).toHaveBeenCalledWith(project, expect.objectContaining({
-            embeddingProvider: provider,
-            queryExecutor: mocks.queryExecutor,
-            semanticLayerCompute: mocks.semanticLayerCompute,
-        }));
-        expect(factory()).toEqual({ kind: 'mcp-server' });
-        expect(createDefaultKtxMcpServer).toHaveBeenCalledWith(expect.objectContaining({
-            contextTools: expect.objectContaining({
-                context_tool: { name: 'context_tool' },
-                memoryIngest: mocks.memoryIngest,
-            }),
-        }));
-    });
-    it('uses null embedding ports when no configured provider is available', async () => {
-        vi.mocked(resolveProjectEmbeddingProvider).mockResolvedValue({ kind: 'managed-unavailable' });
-        await createKtxMcpServerFactory({
-            project: project,
-            projectDir: project.projectDir,
-            cliVersion: '0.5.0',
-            io,
-        });
-        expect(vi.mocked(createLocalProjectMcpContextPorts).mock.calls[0][1]).toMatchObject({
-            embeddingService: null,
-        });
-        expect(createLocalProjectMemoryIngest).toHaveBeenCalledWith(project, expect.objectContaining({
-            embeddingProvider: null,
-        }));
-    });
-    it('omits memory ingest and logs when memory ingest construction fails', async () => {
-        vi.mocked(resolveProjectEmbeddingProvider).mockResolvedValue({ kind: 'disabled' });
-        vi.mocked(createLocalProjectMemoryIngest).mockImplementationOnce(() => {
-            throw new Error('missing local memory prerequisites');
-        });
-        const factory = await createKtxMcpServerFactory({
-            project: project,
-            projectDir: project.projectDir,
-            cliVersion: '0.5.0',
-            io,
-        });
-        factory();
-        expect(io.stderr.write).toHaveBeenCalledWith('KTX MCP memory_ingest disabled: missing local memory prerequisites\n');
-        expect(createDefaultKtxMcpServer).toHaveBeenCalledWith(expect.objectContaining({
-            contextTools: { context_tool: { name: 'context_tool' } },
-        }));
-    });
-});

package/dist/memory-flow-interactive.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/memory-flow-interactive.test.js

@@ -1,109 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { describe, expect, it, vi } from 'vitest';
-import { memoryFlowCommandForKey, renderMemoryFlowInteractively } from './memory-flow-interactive.js';
-class FakeStdin extends EventEmitter {
-    isTTY = true;
-    isRaw = false;
-    rawModes = [];
-    resume = vi.fn();
-    pause = vi.fn();
-    setRawMode(value) {
-        this.isRaw = value;
-        this.rawModes.push(value);
-    }
-}
-function replay() {
-    return {
-        runId: 'run-1',
-        connectionId: 'warehouse',
-        adapter: 'metricflow',
-        status: 'done',
-        sourceDir: '/tmp/source',
-        syncId: 'sync-1',
-        errors: [],
-        plannedWorkUnits: [
-            {
-                unitKey: 'orders',
-                rawFiles: ['models/orders.yml'],
-                peerFileCount: 0,
-                dependencyCount: 1,
-            },
-            {
-                unitKey: 'customers',
-                rawFiles: ['models/customers.yml'],
-                peerFileCount: 0,
-                dependencyCount: 0,
-            },
-        ],
-        details: { actions: [], provenance: [], transcripts: [] },
-        events: [
-            { type: 'source_acquired', adapter: 'metricflow', trigger: 'manual_resync', fileCount: 2 },
-            { type: 'scope_detected', fingerprint: null },
-            { type: 'raw_snapshot_written', syncId: 'sync-1', rawFileCount: 2 },
-            { type: 'diff_computed', added: 1, modified: 1, deleted: 0, unchanged: 0 },
-            { type: 'chunks_planned', chunkCount: 2, workUnitCount: 2, evictionCount: 0 },
-            { type: 'work_unit_started', unitKey: 'orders', skills: ['wiki_capture'], stepBudget: 4 },
-            { type: 'work_unit_finished', unitKey: 'orders', status: 'success' },
-            { type: 'work_unit_started', unitKey: 'customers', skills: ['wiki_capture'], stepBudget: 4 },
-            { type: 'work_unit_finished', unitKey: 'customers', status: 'failed', reason: 'validation reset' },
-            { type: 'reconciliation_finished', conflictCount: 0, fallbackCount: 1 },
-            { type: 'saved', commitSha: 'abc12345', wikiCount: 1, slCount: 1 },
-            { type: 'provenance_recorded', rowCount: 2 },
-            { type: 'report_created', runId: 'run-1', reportPath: 'report-1' },
-        ],
-    };
-}
-describe('memoryFlowCommandForKey', () => {
-    it('maps supported terminal key names to memory-flow commands', () => {
-        const idleSearch = { editing: false, query: '', matchIndex: 0 };
-        const editingSearch = { editing: true, query: 'c', matchIndex: 0 };
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'left' })).toBe('left');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'right' })).toBe('right');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'up' })).toBe('up');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'down' })).toBe('down');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'return' })).toBe('enter');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'tab' })).toBe('tab');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'f' })).toBe('filter');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'p' })).toBe('provenance');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 't' })).toBe('transcript');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'q' })).toBe('quit');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'c', ctrl: true })).toBe('quit');
-        expect(memoryFlowCommandForKey('/', { editing: false, query: '', matchIndex: 0 }, { name: '/' })).toBe('search-start');
-        expect(memoryFlowCommandForKey('c', { editing: true, query: '', matchIndex: 0 }, { name: 'c' })).toEqual({
-            type: 'search-input',
-            value: 'c',
-        });
-        expect(memoryFlowCommandForKey('', editingSearch, { name: 'backspace' })).toBe('search-backspace');
-        expect(memoryFlowCommandForKey('', editingSearch, { name: 'return' })).toBe('search-submit');
-        expect(memoryFlowCommandForKey('', editingSearch, { name: 'escape' })).toBe('search-clear');
-        expect(memoryFlowCommandForKey('', idleSearch, { name: 'x' })).toBeNull();
-    });
-});
-describe('renderMemoryFlowInteractively', () => {
-    it('repaints on keypress and restores raw mode on quit', async () => {
-        let stdout = '';
-        const stdin = new FakeStdin();
-        const prepareKeypressEvents = vi.fn();
-        const promise = renderMemoryFlowInteractively(replay(), {
-            stdin,
-            stdout: {
-                isTTY: true,
-                columns: 120,
-                write: (chunk) => {
-                    stdout += chunk;
-                },
-            },
-        }, { prepareKeypressEvents });
-        stdin.emit('keypress', '', { name: 'right' });
-        stdin.emit('keypress', '', { name: 'tab' });
-        stdin.emit('keypress', '', { name: 'q' });
-        await expect(promise).resolves.toBeUndefined();
-        expect(prepareKeypressEvents).toHaveBeenCalledWith(stdin);
-        expect(stdin.rawModes).toEqual([true, false]);
-        expect(stdin.resume).toHaveBeenCalledTimes(1);
-        expect(stdin.pause).toHaveBeenCalledTimes(1);
-        expect(stdout).toContain('\u001b[2J\u001b[H');
-        expect(stdout).toContain('[ACTIONS]');
-        expect(stdout).toContain('Pane: trust');
-    });
-});

package/dist/memory-flow-tui.test.d.ts

@@ -1 +0,0 @@
-export {};