@kaelio/ktx 0.5.0 → 0.7.0

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 {};

package/dist/notion-page-picker.test.js

@@ -1,244 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { discoverNotionPickerPages, notionPickerPageFromSearchResult, normalizeNotionPageId, pickNotionRootPages, resolveNotionWorkspaceLabel, } from './notion-page-picker.js';
-function makeIo() {
-    let stdout = '';
-    let stderr = '';
-    return {
-        io: {
-            stdout: {
-                isTTY: true,
-                write: (chunk) => {
-                    stdout += chunk;
-                },
-            },
-            stderr: {
-                write: (chunk) => {
-                    stderr += chunk;
-                },
-            },
-        },
-        stdout: () => stdout,
-        stderr: () => stderr,
-    };
-}
-const PAGE_IDS = {
-    engineering: '11111111-1111-1111-1111-111111111111',
-    architecture: '22222222-2222-2222-2222-222222222222',
-    stale: '99999999-9999-9999-9999-999999999999',
-};
-function notionPage(id, title, parentId = null) {
-    return {
-        object: 'page',
-        id,
-        archived: false,
-        parent: parentId ? { type: 'page_id', page_id: parentId } : { type: 'workspace', workspace: true },
-        properties: {
-            title: {
-                type: 'title',
-                title: [{ plain_text: title }],
-            },
-        },
-    };
-}
-function fakeNotionApi(pages) {
-    return {
-        search: vi.fn(async (_filterValue, startCursor) => {
-            if (startCursor === 'page-2') {
-                return { results: pages.slice(2), hasMore: false, nextCursor: null };
-            }
-            return {
-                results: pages.slice(0, 2),
-                hasMore: pages.length > 2,
-                nextCursor: pages.length > 2 ? 'page-2' : null,
-            };
-        }),
-        retrieveBotUser: vi.fn(async () => ({ name: 'Notion bot', bot: { workspace_name: 'Design Workspace' } })),
-    };
-}
-describe('normalizeNotionPageId', () => {
-    it('accepts dashed and compact UUIDs', () => {
-        expect(normalizeNotionPageId('11111111222233334444555555555555')).toBe('11111111-2222-3333-4444-555555555555');
-        expect(normalizeNotionPageId('AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE')).toBe('aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee');
-    });
-});
-describe('Notion page picker helpers', () => {
-    it('extracts picker page inputs from Notion search results', () => {
-        expect(notionPickerPageFromSearchResult(notionPage(PAGE_IDS.architecture, 'Architecture', PAGE_IDS.engineering)))
-            .toEqual({
-            id: PAGE_IDS.architecture,
-            title: 'Architecture',
-            archived: false,
-            parentId: PAGE_IDS.engineering,
-        });
-        expect(notionPickerPageFromSearchResult({
-            object: 'page',
-            id: PAGE_IDS.engineering.replaceAll('-', ''),
-            archived: true,
-            parent: { type: 'workspace', workspace: true },
-            properties: {},
-        })).toEqual({
-            id: PAGE_IDS.engineering,
-            title: 'Untitled',
-            archived: true,
-            parentId: null,
-        });
-    });
-    it('discovers visible pages up to the cap and reports cap state', async () => {
-        const api = fakeNotionApi([
-            notionPage(PAGE_IDS.engineering, 'Engineering'),
-            notionPage(PAGE_IDS.architecture, 'Architecture', PAGE_IDS.engineering),
-            notionPage('33333333-3333-3333-3333-333333333333', 'Onboarding', PAGE_IDS.engineering),
-        ]);
-        await expect(discoverNotionPickerPages(api, { cap: 2 })).resolves.toEqual({
-            pages: [
-                { id: PAGE_IDS.engineering, title: 'Engineering', archived: false, parentId: null },
-                { id: PAGE_IDS.architecture, title: 'Architecture', archived: false, parentId: PAGE_IDS.engineering },
-            ],
-            cappedAtCount: 2,
-            warnings: [],
-        });
-        expect(api.search).toHaveBeenCalledTimes(1);
-    });
-    it('keeps partial discovery results when Notion search fails after at least one page', async () => {
-        const api = {
-            search: vi
-                .fn()
-                .mockResolvedValueOnce({
-                results: [notionPage(PAGE_IDS.engineering, 'Engineering')],
-                hasMore: true,
-                nextCursor: 'cursor-2',
-            })
-                .mockRejectedValueOnce(new Error('rate limit after first page')),
-            retrieveBotUser: vi.fn(async () => ({ name: 'Notion bot' })),
-        };
-        await expect(discoverNotionPickerPages(api)).resolves.toEqual({
-            pages: [{ id: PAGE_IDS.engineering, title: 'Engineering', archived: false, parentId: null }],
-            cappedAtCount: null,
-            warnings: ['Notion search stopped early: rate limit after first page'],
-        });
-    });
-    it('uses the Notion workspace name when available and falls back to the connection id', async () => {
-        await expect(resolveNotionWorkspaceLabel(fakeNotionApi([]), 'notion-main')).resolves.toBe('Design Workspace');
-        await expect(resolveNotionWorkspaceLabel({
-            search: vi.fn(),
-            retrieveBotUser: vi.fn(async () => {
-                throw new Error('users.me unavailable');
-            }),
-        }, 'notion-main')).resolves.toBe('notion-main');
-    });
-});
-describe('pickNotionRootPages', () => {
-    it('discovers visible pages, warns about stale roots, renders the TUI, and returns selected roots', async () => {
-        const api = fakeNotionApi([
-            notionPage(PAGE_IDS.engineering, 'Engineering'),
-            notionPage(PAGE_IDS.architecture, 'Architecture', PAGE_IDS.engineering),
-        ]);
-        const renderPicker = vi.fn(async (chrome, state) => {
-            expect(chrome.title).toBe('Select Notion pages to ingest');
-            expect(chrome.subtitleLines).toEqual(['Workspace: Design Workspace']);
-            expect(chrome.warningLines ?? []).toEqual([]);
-            expect(chrome.confirmSaveMessage).toBeTypeOf('function');
-            expect(state.requireConfirmOnSave).toBe(true);
-            expect(state.preLoadWarnings).toEqual([
-                '1 stored root_page_ids no longer visible - they will be removed if you save',
-            ]);
-            return { kind: 'save', selectedIds: [PAGE_IDS.engineering] };
-        });
-        const io = makeIo();
-        await expect(pickNotionRootPages({
-            connectionId: 'notion-main',
-            connection: {
-                driver: 'notion',
-                auth_token_ref: 'env:NOTION_TOKEN',
-                crawl_mode: 'all_accessible',
-                root_page_ids: [PAGE_IDS.stale],
-            },
-        }, io.io, {
-            env: { NOTION_TOKEN: 'ntn_test_token' },
-            createNotionApi: vi.fn(() => api),
-            renderPicker,
-        })).resolves.toEqual({ kind: 'selected', rootPageIds: [PAGE_IDS.engineering] });
-        expect(io.stderr()).toContain('1 stored root_page_ids no longer visible');
-        expect(io.stdout()).toBe('');
-    });
-    it('uses inline Notion auth_token for discovery', async () => {
-        const api = fakeNotionApi([notionPage(PAGE_IDS.engineering, 'Engineering')]);
-        const createNotionApi = vi.fn((authToken) => {
-            expect(authToken).toBe('ntn_inline_token');
-            return api;
-        });
-        await expect(pickNotionRootPages({
-            connectionId: 'notion-main',
-            connection: {
-                driver: 'notion',
-                auth_token: 'ntn_inline_token',
-                crawl_mode: 'selected_roots',
-                root_page_ids: [PAGE_IDS.engineering],
-            },
-        }, makeIo().io, {
-            createNotionApi,
-            renderPicker: vi.fn(async () => ({ kind: 'quit' })),
-        })).resolves.toEqual({ kind: 'back' });
-        expect(createNotionApi).toHaveBeenCalledOnce();
-    });
-    it('passes partial-discovery warnings into the TUI banner state', async () => {
-        const api = {
-            search: vi
-                .fn()
-                .mockResolvedValueOnce({
-                results: [notionPage(PAGE_IDS.engineering, 'Engineering')],
-                hasMore: true,
-                nextCursor: 'cursor-2',
-            })
-                .mockRejectedValueOnce(new Error('rate limit after first page')),
-            retrieveBotUser: vi.fn(async () => ({ name: 'Notion bot', bot: { workspace_name: 'Design Workspace' } })),
-        };
-        let captured;
-        const renderPicker = vi.fn(async (chrome, state, io) => {
-            captured = [chrome, state, io];
-            return { kind: 'quit' };
-        });
-        const io = makeIo();
-        await expect(pickNotionRootPages({
-            connectionId: 'notion-main',
-            connection: {
-                driver: 'notion',
-                auth_token_ref: 'env:NOTION_TOKEN',
-                crawl_mode: 'selected_roots',
-                root_page_ids: [PAGE_IDS.engineering],
-            },
-        }, io.io, {
-            env: { NOTION_TOKEN: 'ntn_test_token' },
-            createNotionApi: vi.fn(() => api),
-            renderPicker,
-        })).resolves.toEqual({ kind: 'back' });
-        expect(renderPicker).toHaveBeenCalledOnce();
-        if (!captured) {
-            throw new Error('renderPicker was not called');
-        }
-        const [, state] = captured;
-        expect(state.preLoadWarnings).toEqual(['Notion search stopped early: rate limit after first page']);
-        expect(state.tree.map((node) => node.title)).toEqual(['Engineering']);
-        expect(io.stderr()).toContain('Notion search stopped early: rate limit after first page');
-    });
-    it('returns unavailable when discovery cannot load any pages', async () => {
-        await expect(pickNotionRootPages({
-            connectionId: 'notion-main',
-            connection: {
-                driver: 'notion',
-                auth_token_ref: 'env:NOTION_TOKEN',
-                crawl_mode: 'selected_roots',
-                root_page_ids: [],
-            },
-        }, makeIo().io, {
-            env: { NOTION_TOKEN: 'ntn_test_token' },
-            createNotionApi: vi.fn(() => ({
-                search: vi.fn(async () => {
-                    throw new Error('Notion API unavailable');
-                }),
-                retrieveBotUser: vi.fn(async () => ({ name: 'Notion bot' })),
-            })),
-            renderPicker: vi.fn(async () => ({ kind: 'quit' })),
-        })).resolves.toEqual({ kind: 'unavailable', message: 'Notion API unavailable' });
-    });
-});

package/dist/print-command-tree.test.d.ts

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

package/dist/print-command-tree.test.js

@@ -1,37 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { renderKtxCommandTree } from './print-command-tree.js';
-describe('renderKtxCommandTree', () => {
-    it('renders an indented tree rooted at "ktx" with known top-level commands', () => {
-        const output = renderKtxCommandTree();
-        const lines = output.split('\n');
-        expect(lines[0]).toMatch(/^ktx( |$)/);
-        const topLevel = lines
-            .filter((line) => /^ {2}[├└]── \S/.test(line))
-            .map((line) => line.replace(/^ {2}[├└]── /, '').trim().split(' ')[0]);
-        for (const expected of ['setup', 'connection', 'ingest', 'sl', 'mcp', 'admin']) {
-            expect(topLevel).toContain(expected);
-        }
-        expect(output).toContain('│   └── test [connectionId]');
-        expect(output).toContain('│   ├── status                          Show KTX MCP daemon status');
-        expect(output).not.toContain('│   ├── add');
-        expect(output).not.toContain('│   ├── remove');
-        expect(output).not.toContain('│   ├── map');
-        expect(output).not.toContain('│   ├── mapping');
-        expect(output).not.toContain('│   ├── metabase');
-        expect(output).not.toContain('│   ├── notion');
-        expect(output).not.toContain('scan <connectionId>');
-        expect(output).not.toContain('│   ├── replay');
-        expect(output).not.toContain('│   └── replay');
-        expect(output).not.toContain('│   ├── run');
-        expect(output).not.toContain('│   ├── watch');
-        expect(output).not.toContain('│   └── watch');
-        expect(output).not.toContain('│   ├── read');
-        expect(output).not.toContain('│   ├── write');
-        expect(output).not.toContain('│   └── write');
-    });
-    it('ends with a single trailing newline', () => {
-        const output = renderKtxCommandTree();
-        expect(output.endsWith('\n')).toBe(true);
-        expect(output.endsWith('\n\n')).toBe(false);
-    });
-});

package/dist/project-dir.test.d.ts

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