@kaelio/ktx 0.4.1 → 0.6.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/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 {};

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

@@ -1,247 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { render as renderInkTest } from 'ink-testing-library';
-import React from 'react';
-import { describe, expect, it, vi } from 'vitest';
-import { MemoryFlowTuiApp, memoryFlowCommandForInkInput, renderMemoryFlowTui, sanitizeMemoryFlowTuiError, startLiveMemoryFlowTui, } from './memory-flow-tui.js';
-function replayInput() {
-    return {
-        runId: 'run-1', connectionId: 'warehouse', adapter: 'live-database',
-        status: 'done', sourceDir: null, syncId: 'sync-1', reportId: 'report-1', reportPath: 'report-1', errors: [],
-        plannedWorkUnits: [
-            { unitKey: 'orders', rawFiles: ['orders'], peerFileCount: 0, dependencyCount: 1 },
-            { unitKey: 'customers', rawFiles: ['customers'], peerFileCount: 1, dependencyCount: 0 },
-        ],
-        details: {
-            actions: [
-                { unitKey: 'orders', target: 'wiki', action: 'created', key: 'wiki/orders.md', summary: 'order lifecycle', rawFiles: ['orders'], status: 'success' },
-                { unitKey: 'customers', target: 'sl', action: 'updated', key: 'orbit_demo.customers', summary: 'customer metrics', rawFiles: ['customers'], status: 'success' },
-            ],
-            provenance: [{ rawPath: 'orders', artifactKind: 'wiki', artifactKey: 'wiki/orders.md', actionType: 'wiki_written' }],
-            transcripts: [{ unitKey: 'orders', path: '/tmp/t.jsonl', toolCallCount: 2, errorCount: 0, toolNames: ['read_raw_span', 'memory_ingest'] }],
-        },
-        events: [
-            { type: 'source_acquired', adapter: 'live-database', trigger: 'manual_resync', fileCount: 2 },
-            { type: 'scope_detected', fingerprint: 'scope-1' },
-            { 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: 40 },
-            { type: 'candidate_action', unitKey: 'orders', target: 'wiki', action: 'created', key: 'wiki/orders.md' },
-            { type: 'work_unit_finished', unitKey: 'orders', status: 'success' },
-            { type: 'work_unit_started', unitKey: 'customers', skills: ['sl_capture'], stepBudget: 40 },
-            { type: 'candidate_action', unitKey: 'customers', target: 'sl', action: 'updated', key: 'orbit_demo.customers' },
-            { type: 'work_unit_finished', unitKey: 'customers', status: 'success' },
-            { type: 'reconciliation_finished', conflictCount: 0, fallbackCount: 0 },
-            { type: 'saved', commitSha: 'commit-one', wikiCount: 1, slCount: 1 },
-            { type: 'provenance_recorded', rowCount: 1 },
-            { type: 'report_created', runId: 'run-1', reportPath: 'report-1' },
-        ],
-    };
-}
-function runningReplayInput() {
-    return { ...replayInput(), status: 'running', syncId: 'pending', reportId: undefined, reportPath: undefined, plannedWorkUnits: [], events: [{ type: 'source_acquired', adapter: 'live-database', trigger: 'manual_resync', fileCount: 1 }] };
-}
-function packagedReplayInput(overrides = {}) {
-    return {
-        ...replayInput(),
-        connectionId: 'orbit_demo',
-        metadata: {
-            schemaVersion: 1,
-            mode: 'seeded',
-            origin: 'packaged',
-            timing: 'prebuilt',
-            capturedAt: null,
-            sourceReportId: 'demo-seeded-report',
-            sourceReportPath: 'reports/seeded-demo-report.json',
-            fallbackReason: null,
-        },
-        ...overrides,
-    };
-}
-function makeIo() {
-    let stderr = '';
-    return { io: { stdin: { isTTY: true, setRawMode: vi.fn() }, stdout: { isTTY: true, columns: 120, write: vi.fn() }, stderr: { write(chunk) { stderr += chunk; } } }, stderr: () => stderr };
-}
-function fakeInkInstance() {
-    return { rerender: vi.fn(), unmount: vi.fn(), waitUntilExit: vi.fn(async () => undefined), clear: vi.fn() };
-}
-async function waitForInkInput() { await new Promise((r) => setTimeout(r, 10)); }
-function renderedAppProps(tree) {
-    expect(React.isValidElement(tree)).toBe(true);
-    return tree.props;
-}
-describe('memoryFlowCommandForInkInput', () => {
-    it('maps input to commands', () => {
-        expect(memoryFlowCommandForInkInput('q', {})).toBe('quit');
-        expect(memoryFlowCommandForInkInput('c', { ctrl: true })).toBe('quit');
-        expect(memoryFlowCommandForInkInput('x', {})).toBeNull();
-    });
-});
-describe('sanitizeMemoryFlowTuiError', () => {
-    it('redacts credentials', () => {
-        expect(sanitizeMemoryFlowTuiError(new Error('postgres://x?api_key=y password=z'))).toBe('[redacted-url] [redacted]');
-    });
-});
-describe('MemoryFlowTuiApp', () => {
-    it('always shows the KTX logo', () => {
-        const { lastFrame } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: replayInput(), terminalWidth: 120, onExit: vi.fn(), showBoot: false }));
-        expect(lastFrame()).toContain('╚███╔╝');
-    });
-    it('shows persistent HUD with source and status terminology', () => {
-        const { lastFrame } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: { ...replayInput(), connectionId: 'warehouse' }, terminalWidth: 120, onExit: vi.fn(), showBoot: false }));
-        const frame = lastFrame() ?? '';
-        expect(frame).toContain('Database (warehouse)');
-        expect(frame).toContain('2 tables');
-        expect(frame).toContain('done');
-        expect(frame).toContain('warehouse');
-        expect(frame).toContain('╭');
-        expect(frame).toContain('╰');
-    });
-    it('hides the internal demo connection id before packaged replay source events are visible', () => {
-        const { lastFrame } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: packagedReplayInput({ status: 'running', events: [] }), terminalWidth: 120, onExit: vi.fn(), showBoot: false }));
-        const frame = lastFrame() ?? '';
-        expect(frame).toContain('Orbit Demo');
-        expect(frame).not.toContain('orbit_demo');
-        expect(frame).not.toContain('Database (orbit_demo)');
-    });
-    it('keeps the packaged replay source label public while only one source event is visible', () => {
-        const { lastFrame } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: packagedReplayInput({
-                status: 'running',
-                events: [{ type: 'source_acquired', adapter: 'live-database', trigger: 'demo_seeded', fileCount: 8 }],
-            }), terminalWidth: 120, onExit: vi.fn(), showBoot: false }));
-        const frame = lastFrame() ?? '';
-        expect(frame).toContain('Orbit Demo');
-        expect(frame).not.toContain('orbit_demo');
-        expect(frame).not.toContain('Database (orbit_demo)');
-    });
-    it('shows a prepopulated data disclaimer for packaged demo replay cost estimates', () => {
-        const { lastFrame } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: packagedReplayInput(), terminalWidth: 120, onExit: vi.fn(), showBoot: false }));
-        const frame = lastFrame() ?? '';
-        expect(frame).toContain('$');
-        expect(frame).toContain('Pre-run demo: $ shown is illustrative; no money is being spent now.');
-        expect(frame).not.toContain('orbit_demo');
-    });
-    it('does not show the prepopulated data disclaimer for captured full replay cost estimates', () => {
-        const { lastFrame } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: {
-                ...replayInput(),
-                metadata: {
-                    schemaVersion: 1,
-                    mode: 'full',
-                    origin: 'captured',
-                    timing: 'captured',
-                    capturedAt: '2026-05-01T00:00:00.000Z',
-                    sourceReportId: 'report-full',
-                    sourceReportPath: 'reports/report-full.json',
-                    fallbackReason: null,
-                },
-            }, terminalWidth: 120, onExit: vi.fn(), showBoot: false }));
-        expect(lastFrame()).not.toContain('Demo data is prepopulated');
-    });
-    it('shows accumulated activity feed on completion', () => {
-        const { lastFrame } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: replayInput(), terminalWidth: 120, onExit: vi.fn(), showBoot: false }));
-        const frame = lastFrame() ?? '';
-        expect(frame).toContain('Connected — found 2 tables to ingest');
-        expect(frame).toContain('Created so far:');
-        expect(frame).toContain('order lifecycle');
-        expect(frame).toContain('customer metrics');
-        expect(frame).toContain('KTX finished ingesting your data');
-        expect(frame).toContain('ktx sl');
-        expect(frame).toContain('ktx wiki');
-        expect(frame).not.toContain('ktx serve --mcp stdio --user-id local');
-        expect(frame).not.toContain(['ktx', 'ask'].join(' '));
-        expect(frame).not.toContain(['ktx', 'mcp'].join(' '));
-    });
-    it('handles quit while running', async () => {
-        const onExit = vi.fn();
-        const { stdin } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: runningReplayInput(), terminalWidth: 120, onExit: onExit, showBoot: false }));
-        stdin.write('q');
-        await waitForInkInput();
-        expect(onExit).toHaveBeenCalledTimes(1);
-    });
-    it('shows active work unit with progress', () => {
-        const running = {
-            ...runningReplayInput(),
-            events: [
-                { type: 'source_acquired', adapter: 'live-database', trigger: 'manual_resync', fileCount: 1 },
-                { type: 'diff_computed', added: 1, modified: 0, deleted: 0, unchanged: 0 },
-                { type: 'chunks_planned', chunkCount: 1, workUnitCount: 1, evictionCount: 0 },
-                { type: 'work_unit_started', unitKey: 'orders', skills: ['wiki_capture'], stepBudget: 40 },
-            ],
-            plannedWorkUnits: [{ unitKey: 'orders', rawFiles: ['orders'], peerFileCount: 0, dependencyCount: 1 }],
-        };
-        const { lastFrame } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: running, terminalWidth: 120, onExit: vi.fn(), showBoot: false }));
-        const frame = lastFrame() ?? '';
-        expect(frame).toContain('Ingesting — 0/1 business area done');
-        expect(frame).toContain('Reading table schemas, understanding relationships, creating query definitions');
-        expect(frame).toContain('╚███╔╝');
-    });
-    it('describes multi-source ingestion as building the context layer', () => {
-        const running = {
-            ...runningReplayInput(),
-            adapter: 'multi-source',
-            events: [
-                { type: 'source_acquired', adapter: 'live-database', trigger: 'manual_resync', fileCount: 8 },
-                { type: 'source_acquired', adapter: 'dbt-descriptions', trigger: 'manual_resync', fileCount: 3 },
-                { type: 'diff_computed', added: 11, modified: 0, deleted: 0, unchanged: 0 },
-                { type: 'chunks_planned', chunkCount: 1, workUnitCount: 1, evictionCount: 0 },
-                { type: 'work_unit_started', unitKey: 'orders', skills: ['wiki_capture'], stepBudget: 40 },
-            ],
-            plannedWorkUnits: [{ unitKey: 'orders', rawFiles: ['orders'], peerFileCount: 0, dependencyCount: 1 }],
-        };
-        const { lastFrame } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: running, terminalWidth: 120, onExit: vi.fn(), showBoot: false }));
-        const frame = lastFrame() ?? '';
-        expect(frame).toContain('Ingesting warehouse, dbt, BI, and docs into a unified context layer');
-        expect(frame).not.toContain('unified semantic layer');
-    });
-    it('hides completion while running', () => {
-        const { lastFrame } = renderInkTest(_jsx(MemoryFlowTuiApp, { input: runningReplayInput(), terminalWidth: 120, onExit: vi.fn(), showBoot: false }));
-        expect(lastFrame()).not.toContain('KTX finished ingesting');
-    });
-});
-describe('startLiveMemoryFlowTui', () => {
-    it('starts and updates', async () => {
-        const { io } = makeIo();
-        const instance = fakeInkInstance();
-        const live = await startLiveMemoryFlowTui(runningReplayInput(), io, { renderInk: () => instance });
-        expect(live).not.toBeNull();
-        live?.update(replayInput());
-        expect(instance.rerender).toHaveBeenCalledTimes(1);
-        live?.close();
-        expect(instance.unmount).toHaveBeenCalledTimes(1);
-    });
-    it('redacts errors', async () => {
-        const { io, stderr } = makeIo();
-        await expect(startLiveMemoryFlowTui(runningReplayInput(), io, { renderInk: () => { throw new Error('postgres://x?token=y'); } })).resolves.toBeNull();
-        expect(stderr()).toContain('[redacted-url]');
-    });
-});
-describe('renderMemoryFlowTui', () => {
-    it('renders and returns true', async () => {
-        const { io } = makeIo();
-        const instance = fakeInkInstance();
-        await expect(renderMemoryFlowTui(replayInput(), io, { renderInk: () => instance })).resolves.toBe(true);
-    });
-    it('scales event timing with the speed multiplier while keeping animations normal speed', async () => {
-        const { io } = makeIo();
-        const instance = fakeInkInstance();
-        let renderedTree = null;
-        await expect(renderMemoryFlowTui(replayInput(), io, {
-            speedMultiplier: 0.125,
-            renderInk: (tree) => {
-                renderedTree = tree;
-                return instance;
-            },
-        })).resolves.toBe(true);
-        expect(renderedAppProps(renderedTree)).toMatchObject({
-            paceMsPerEvent: 1440,
-            frameMs: 140,
-            completionFrameMs: 80,
-            completionHoldMs: 1000,
-        });
-    });
-    it('redacts errors', async () => {
-        const { io, stderr } = makeIo();
-        await expect(renderMemoryFlowTui(replayInput(), io, { renderInk: () => { throw new Error('postgres://x?token=y'); } })).resolves.toBe(false);
-        expect(stderr()).toContain('[redacted-url]');
-    });
-});

package/dist/next-steps.test.d.ts

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

package/dist/next-steps.test.js

@@ -1,77 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { KTX_CONTEXT_BUILD_COMMANDS, KTX_NEXT_STEP_COMMANDS, formatNextStepLines, formatSetupNextStepLines, } from './next-steps.js';
-describe('KTX demo next steps', () => {
-    it('uses supported context-build commands before agent usage', () => {
-        expect(KTX_CONTEXT_BUILD_COMMANDS).toEqual([
-            {
-                command: 'ktx ingest',
-                description: 'Build or refresh agent-ready context from all configured connections',
-            },
-            {
-                command: 'ktx status',
-                description: 'Check setup and context readiness',
-            },
-        ]);
-    });
-    it('uses supported final public commands', () => {
-        expect(KTX_NEXT_STEP_COMMANDS).toEqual([
-            {
-                command: 'ktx status --json',
-                description: 'Verify project setup and context readiness',
-            },
-            {
-                command: 'ktx sl',
-                description: 'Inspect generated semantic-layer sources',
-            },
-            {
-                command: 'ktx wiki',
-                description: 'Inspect generated wiki pages',
-            },
-        ]);
-    });
-    it('uses only the direct CLI route for agent verification', () => {
-        const commands = KTX_NEXT_STEP_COMMANDS.map((step) => step.command);
-        expect(commands).not.toContain('ktx agent context --json');
-        expect(commands).toContain('ktx status --json');
-        expect(commands).not.toContain('ktx serve --mcp stdio --user-id local');
-    });
-    it('explains what the next-step commands are for', () => {
-        const rendered = formatNextStepLines().join('\n');
-        expect(rendered).toContain('KTX context is ready for agents.');
-        expect(rendered).toContain('KTX project directory');
-        expect(rendered).toContain('ask a data question');
-        expect(rendered).toContain('Verify with:');
-        expect(rendered).not.toContain('this directory');
-        expect(rendered).not.toContain('Preferred route');
-        expect(rendered).not.toContain('Optional MCP:');
-    });
-    it('keeps setup next steps focused on building context when the build is not ready', () => {
-        const rendered = formatSetupNextStepLines({
-            setupReady: true,
-            hasContextTargets: true,
-            contextReady: false,
-            agentIntegrationReady: true,
-        }).join('\n');
-        expect(rendered).toContain('Build KTX context next.');
-        expect(rendered).toContain('Run ingest to build database schema context before context-source ingest.');
-        expect(rendered).toContain('ktx ingest');
-        expect(rendered).not.toContain('resume');
-        expect(rendered).not.toContain('scan');
-        expect(rendered).toContain('ktx status');
-        expect(rendered).not.toContain('ktx agent context --json');
-        expect(rendered).not.toContain('ktx serve --mcp');
-    });
-    it('shows agent commands only after setup and context build are ready', () => {
-        const rendered = formatSetupNextStepLines({
-            setupReady: true,
-            hasContextTargets: true,
-            contextReady: true,
-            agentIntegrationReady: true,
-        }).join('\n');
-        expect(rendered).toContain('KTX context is ready for agents.');
-        expect(rendered).toContain('ktx status --json');
-        expect(rendered).not.toContain('ktx agent');
-        expect(rendered).not.toContain('ktx serve --mcp stdio --user-id local');
-        expect(rendered).not.toContain('Build KTX context next.');
-    });
-});

package/dist/notion-page-picker.test.d.ts

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