@kaelio/ktx 0.5.0 → 0.7.0

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

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

package/dist/setup-project.test.js

@@ -1,209 +0,0 @@
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { readKtxSetupState } from './context/project/setup-config.js';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { gray } from './io/symbols.js';
-import { runKtxSetupProjectStep } from './setup-project.js';
-function makeIo(options = {}) {
-    let stdout = '';
-    let stderr = '';
-    return {
-        io: {
-            stdout: {
-                isTTY: options.stdoutIsTty,
-                write: (chunk) => {
-                    stdout += chunk;
-                },
-            },
-            stderr: {
-                write: (chunk) => {
-                    stderr += chunk;
-                },
-            },
-        },
-        stdout: () => stdout,
-        stderr: () => stderr,
-    };
-}
-function makePromptAdapter(options) {
-    const choices = [...(options.choices ?? (options.choice ? [options.choice] : []))];
-    const textValues = [...(options.textValues ?? (options.textValue !== undefined ? [options.textValue] : []))];
-    return {
-        select: vi.fn(async () => choices.shift() ?? 'exit'),
-        text: vi.fn(async () => textValues.shift() ?? ''),
-        cancel: vi.fn(),
-    };
-}
-function defaultSubfolderLabel(parentDir) {
-    const childName = 'ktx-project';
-    const childDir = join(parentDir, childName);
-    return `New subfolder (${gray(childDir.slice(0, -childName.length))}${childName})`;
-}
-describe('setup project step', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-setup-project-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('creates a new project in non-interactive auto mode with --yes and marks the project step complete', async () => {
-        const projectDir = join(tempDir, 'warehouse');
-        const testIo = makeIo();
-        const result = await runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'disabled', yes: true }, testIo.io);
-        expect(result.status).toBe('ready');
-        expect(result.projectDir).toBe(projectDir);
-        expect(await readFile(join(projectDir, 'ktx.yaml'), 'utf-8')).not.toContain('completed_steps:');
-        expect(await readKtxSetupState(projectDir)).toEqual({ completed_steps: ['project'] });
-        await expect(stat(join(projectDir, '.git'))).resolves.toBeDefined();
-        await expect(readFile(join(projectDir, '.ktx/.gitignore'), 'utf-8')).resolves.toContain('secrets/');
-        expect(testIo.stdout()).toContain(`Project: ${projectDir}`);
-        expect(testIo.stderr()).toBe('');
-    });
-    it('creates a missing auto-mode project only when --yes is present in no-input mode', async () => {
-        const projectDir = join(tempDir, 'warehouse');
-        const rejectedIo = makeIo();
-        const acceptedIo = makeIo();
-        await expect(runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'disabled', yes: false }, rejectedIo.io)).resolves.toMatchObject({ status: 'missing-input' });
-        expect(rejectedIo.stderr()).toContain('Missing setup choice: pass --yes');
-        await expect(stat(join(projectDir, 'ktx.yaml'))).rejects.toThrow();
-        await expect(runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'disabled', yes: true }, acceptedIo.io)).resolves.toMatchObject({ status: 'ready', projectDir });
-        await expect(stat(join(projectDir, 'ktx.yaml'))).resolves.toBeDefined();
-    });
-    it('fails clearly in no-input auto mode when ktx.yaml is missing and --yes is absent', async () => {
-        const projectDir = join(tempDir, 'warehouse');
-        const testIo = makeIo();
-        await expect(runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'disabled', yes: false }, testIo.io)).resolves.toMatchObject({ status: 'missing-input' });
-        expect(testIo.stderr()).toContain('Missing setup choice: pass --yes');
-    });
-    it('prompts to use the current directory and creates a project in interactive auto mode', async () => {
-        const projectDir = join(tempDir, 'warehouse');
-        const prompts = makePromptAdapter({ choice: 'current' });
-        const testIo = makeIo({ stdoutIsTty: true });
-        const result = await runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'auto', yes: false }, testIo.io, { prompts });
-        expect(result.status).toBe('ready');
-        expect(result.projectDir).toBe(projectDir);
-        expect(prompts.select).toHaveBeenCalledWith(expect.objectContaining({
-            message: 'Where should KTX create the project?',
-            options: [
-                expect.objectContaining({ value: 'current', label: `Current directory (${projectDir})` }),
-                expect.objectContaining({
-                    value: 'new-default',
-                    label: defaultSubfolderLabel(projectDir),
-                }),
-                expect.objectContaining({ value: 'new-custom', label: 'Custom path' }),
-                expect.objectContaining({ value: 'exit', label: 'Exit' }),
-            ],
-        }));
-        expect(prompts.text).not.toHaveBeenCalled();
-        expect(await readFile(join(projectDir, 'ktx.yaml'), 'utf-8')).not.toContain('completed_steps:');
-        expect(await readKtxSetupState(projectDir)).toEqual({ completed_steps: ['project'] });
-    });
-    it('offers an absolute default destination for a new project folder', async () => {
-        const startDir = join(tempDir, 'start');
-        const projectDir = join(startDir, 'ktx-project');
-        const prompts = makePromptAdapter({ choices: ['new-default', 'create'] });
-        const testIo = makeIo({ stdoutIsTty: true });
-        const result = await runKtxSetupProjectStep({ projectDir: startDir, mode: 'auto', inputMode: 'auto', yes: false }, testIo.io, { prompts });
-        expect(result.status).toBe('ready');
-        expect(result.projectDir).toBe(projectDir);
-        expect(prompts.select).toHaveBeenNthCalledWith(1, expect.objectContaining({
-            message: 'Where should KTX create the project?',
-            options: expect.arrayContaining([
-                expect.objectContaining({
-                    value: 'new-default',
-                    label: defaultSubfolderLabel(startDir),
-                }),
-            ]),
-        }));
-        expect(prompts.select).toHaveBeenNthCalledWith(2, expect.objectContaining({ message: `Create KTX project at ${projectDir}?` }));
-        expect(prompts.text).not.toHaveBeenCalled();
-        expect(result.status === 'ready' ? result.project.configPath : '').toBe(join(projectDir, 'ktx.yaml'));
-        expect(testIo.stdout()).toContain(`│  KTX will create:\n│    ${projectDir}`);
-        await expect(stat(join(projectDir, 'ktx.yaml'))).resolves.toBeDefined();
-    });
-    it('prompts for a custom path and resolves it inside the current setup directory', async () => {
-        const startDir = join(tempDir, 'start');
-        const projectDir = join(startDir, 'analytics-ktx');
-        const prompts = makePromptAdapter({ choices: ['new-custom', 'create'], textValue: 'analytics-ktx' });
-        const result = await runKtxSetupProjectStep({ projectDir: startDir, mode: 'auto', inputMode: 'auto', yes: false }, makeIo({ stdoutIsTty: true }).io, { prompts });
-        expect(result.status).toBe('ready');
-        expect(result.projectDir).toBe(projectDir);
-        expect(prompts.text).toHaveBeenCalledWith(expect.objectContaining({
-            message: 'Project folder path\n│  Press Escape to go back.\n│',
-            placeholder: './analytics-ktx, ~/analytics-ktx, or /Users/you/projects/analytics-ktx',
-        }));
-        await expect(stat(join(projectDir, 'ktx.yaml'))).resolves.toBeDefined();
-    });
-    it('expands a custom home-directory path before creating a new project', async () => {
-        const startDir = join(tempDir, 'start');
-        const homeDir = join(tempDir, 'home');
-        const projectDir = join(homeDir, 'analytics-ktx');
-        const prompts = makePromptAdapter({ choices: ['new-custom', 'create'], textValue: '~/analytics-ktx' });
-        const result = await runKtxSetupProjectStep({ projectDir: startDir, mode: 'auto', inputMode: 'auto', yes: false }, makeIo({ stdoutIsTty: true }).io, { prompts, homeDir });
-        expect(result.status).toBe('ready');
-        expect(result.projectDir).toBe(projectDir);
-        await expect(stat(join(projectDir, 'ktx.yaml'))).resolves.toBeDefined();
-    });
-    it('confirms a custom new project path and lets Back return to the project choice', async () => {
-        const startDir = join(tempDir, 'start');
-        const homeDir = join(tempDir, 'home');
-        const customProjectDir = join(homeDir, 'analytics-ktx');
-        const prompts = makePromptAdapter({
-            choices: ['new-custom', 'back', 'exit'],
-            textValue: '~/analytics-ktx',
-        });
-        const result = await runKtxSetupProjectStep({ projectDir: startDir, mode: 'auto', inputMode: 'auto', yes: false }, makeIo({ stdoutIsTty: true }).io, { prompts, homeDir });
-        expect(result.status).toBe('cancelled');
-        expect(result.projectDir).toBe(startDir);
-        expect(prompts.select).toHaveBeenNthCalledWith(2, expect.objectContaining({
-            message: `Create KTX project at ${customProjectDir}?`,
-            options: [
-                expect.objectContaining({ value: 'create', label: 'Create project' }),
-                expect.objectContaining({ value: 'choose-another', label: 'Choose another folder' }),
-                expect.objectContaining({ value: 'back', label: 'Back' }),
-            ],
-        }));
-        expect(prompts.select).toHaveBeenNthCalledWith(3, expect.objectContaining({ message: 'Where should KTX create the project?' }));
-        await expect(stat(join(customProjectDir, 'ktx.yaml'))).rejects.toThrow();
-    });
-    it('rejects an empty new folder path without creating a project in the process cwd', async () => {
-        const startDir = join(tempDir, 'start');
-        const prompts = makePromptAdapter({ choices: ['new-custom'], textValue: '   ' });
-        const initProject = vi.fn(async () => {
-            throw new Error('initProject should not run for an empty path');
-        });
-        const testIo = makeIo({ stdoutIsTty: true });
-        await expect(runKtxSetupProjectStep({ projectDir: startDir, mode: 'auto', inputMode: 'auto', yes: false }, testIo.io, { prompts, initProject })).resolves.toMatchObject({ status: 'missing-input', projectDir: startDir });
-        expect(initProject).not.toHaveBeenCalled();
-        expect(testIo.stderr()).toContain('Enter a relative path like ./analytics-ktx, a home path like ~/analytics-ktx, or an absolute path.');
-    });
-    it('confirms before creating KTX files inside an existing non-empty folder', async () => {
-        const startDir = join(tempDir, 'start');
-        const projectDir = join(startDir, 'analytics-ktx');
-        await mkdir(projectDir, { recursive: true });
-        await writeFile(join(projectDir, 'README.md'), 'Existing project notes\n', 'utf-8');
-        const prompts = makePromptAdapter({ choices: ['new-custom', 'use-existing'], textValue: 'analytics-ktx' });
-        const result = await runKtxSetupProjectStep({ projectDir: startDir, mode: 'auto', inputMode: 'auto', yes: false }, makeIo({ stdoutIsTty: true }).io, { prompts });
-        expect(result.status).toBe('ready');
-        expect(result.projectDir).toBe(projectDir);
-        expect(prompts.select).toHaveBeenNthCalledWith(2, expect.objectContaining({
-            message: `That folder already exists and is not empty: ${projectDir}`,
-            options: expect.arrayContaining([
-                expect.objectContaining({ value: 'use-existing', label: 'Yes, create KTX files there' }),
-                expect.objectContaining({ value: 'choose-another', label: 'Choose another folder' }),
-            ]),
-        }));
-        await expect(readFile(join(projectDir, 'README.md'), 'utf-8')).resolves.toBe('Existing project notes\n');
-        await expect(stat(join(projectDir, 'ktx.yaml'))).resolves.toBeDefined();
-    });
-    it('prompts to exit and returns cancelled in interactive auto mode', async () => {
-        const projectDir = join(tempDir, 'warehouse');
-        const prompts = makePromptAdapter({ choice: 'exit' });
-        await expect(runKtxSetupProjectStep({ projectDir, mode: 'auto', inputMode: 'auto', yes: false }, makeIo({ stdoutIsTty: true }).io, { prompts })).resolves.toMatchObject({ status: 'cancelled', projectDir });
-        expect(prompts.cancel).toHaveBeenCalledWith('Setup cancelled.');
-        expect(prompts.text).not.toHaveBeenCalled();
-        await expect(stat(join(projectDir, 'ktx.yaml'))).rejects.toThrow();
-    });
-});

package/dist/setup-prompts.test.d.ts

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

package/dist/setup-prompts.test.js

@@ -1,208 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { createKtxSetupPromptAdapter, } from './setup-prompts.js';
-const mocks = vi.hoisted(() => {
-    const cancelSymbol = Symbol('cancel');
-    return {
-        cancelSymbol,
-        cancel: vi.fn(),
-        confirm: vi.fn(),
-        intro: vi.fn(),
-        isCancel: vi.fn((value) => value === cancelSymbol),
-        log: { info: vi.fn() },
-        multiselect: vi.fn(),
-        autocomplete: vi.fn(),
-        autocompleteMultiselect: vi.fn(),
-        note: vi.fn(),
-        password: vi.fn(),
-        select: vi.fn(),
-        text: vi.fn(),
-        withSetupInterruptConfirmation: vi.fn((prompt) => prompt()),
-    };
-});
-vi.mock('@clack/prompts', () => ({
-    cancel: mocks.cancel,
-    confirm: mocks.confirm,
-    intro: mocks.intro,
-    isCancel: mocks.isCancel,
-    log: mocks.log,
-    multiselect: mocks.multiselect,
-    autocomplete: mocks.autocomplete,
-    autocompleteMultiselect: mocks.autocompleteMultiselect,
-    note: mocks.note,
-    password: mocks.password,
-    select: mocks.select,
-    text: mocks.text,
-}));
-vi.mock('./setup-interrupt.js', () => ({
-    withSetupInterruptConfirmation: mocks.withSetupInterruptConfirmation,
-}));
-describe('setup prompt adapter', () => {
-    beforeEach(() => {
-        mocks.cancel.mockReset();
-        mocks.confirm.mockReset();
-        mocks.intro.mockReset();
-        mocks.isCancel.mockClear();
-        mocks.log.info.mockReset();
-        mocks.multiselect.mockReset();
-        mocks.autocomplete.mockReset();
-        mocks.autocompleteMultiselect.mockReset();
-        mocks.note.mockReset();
-        mocks.password.mockReset();
-        mocks.select.mockReset();
-        mocks.text.mockReset();
-        mocks.withSetupInterruptConfirmation.mockClear();
-    });
-    it('passes select hint and disabled options through Clack and delegates cancellation handling', async () => {
-        mocks.select.mockResolvedValueOnce('openai');
-        const adapter = createKtxSetupPromptAdapter({ selectCancelValue: 'back' });
-        const options = [
-            { value: 'local', label: 'Local embeddings', disabled: true },
-            { value: 'openai', label: 'OpenAI embeddings', hint: 'recommended' },
-        ];
-        await expect(adapter.select({
-            message: 'Which embedding option should KTX use?\n\nKTX uses embeddings for search.',
-            options,
-        })).resolves.toBe('openai');
-        expect(mocks.withSetupInterruptConfirmation).toHaveBeenCalledTimes(1);
-        expect(mocks.select).toHaveBeenCalledWith({
-            message: 'Which embedding option should KTX use?\n\nKTX uses embeddings for search.\n',
-            options,
-        });
-    });
-    it('maps select cancellation to the configured sentinel', async () => {
-        mocks.select.mockResolvedValueOnce(mocks.cancelSymbol);
-        const adapter = createKtxSetupPromptAdapter({
-            selectCancelValue: 'exit',
-            cancelOnSelectCancel: false,
-        });
-        await expect(adapter.select({ message: 'What do you want to do?', options: [] })).resolves.toBe('exit');
-        expect(mocks.cancel).not.toHaveBeenCalled();
-    });
-    it('decorates text and password prompts with setup navigation copy', async () => {
-        mocks.text.mockResolvedValueOnce('analytics-ktx');
-        mocks.password.mockResolvedValueOnce('secret');
-        const adapter = createKtxSetupPromptAdapter({ selectCancelValue: 'back' });
-        await expect(adapter.text({ message: 'Project folder path', placeholder: './analytics-ktx' })).resolves.toBe('analytics-ktx');
-        await expect(adapter.password({ message: 'Anthropic API key' })).resolves.toBe('secret');
-        expect(mocks.text).toHaveBeenCalledWith({
-            message: 'Project folder path\n│  Press Escape to go back.\n│',
-            placeholder: './analytics-ktx',
-        });
-        expect(mocks.password).toHaveBeenCalledWith({
-            message: 'Anthropic API key\n│  Press Escape to go back.\n│',
-        });
-    });
-    it('passes multiselect hint and disabled options through Clack', async () => {
-        mocks.multiselect.mockResolvedValueOnce(['postgres']);
-        const adapter = createKtxSetupPromptAdapter({
-            selectCancelValue: 'back',
-            multiselectCancelValue: 'back',
-            confirmEmptyOptionalMultiselect: true,
-        });
-        const options = [
-            { value: 'postgres', label: 'PostgreSQL', hint: 'recommended' },
-            { value: 'snowflake', label: 'Snowflake', disabled: true },
-        ];
-        await expect(adapter.multiselect({ message: 'Which primary sources?', options, required: true })).resolves.toEqual([
-            'postgres',
-        ]);
-        expect(mocks.multiselect).toHaveBeenCalledWith({
-            message: 'Which primary sources?',
-            options,
-            required: true,
-        });
-    });
-    it('confirms an empty optional multiselect and retries when skip is declined', async () => {
-        mocks.multiselect.mockResolvedValueOnce([]).mockResolvedValueOnce(['postgres']);
-        mocks.confirm.mockResolvedValueOnce(false);
-        const adapter = createKtxSetupPromptAdapter({
-            selectCancelValue: 'back',
-            multiselectCancelValue: 'back',
-            confirmEmptyOptionalMultiselect: true,
-        });
-        await expect(adapter.multiselect({ message: 'Which primary sources?', options: [], required: false })).resolves.toEqual([
-            'postgres',
-        ]);
-        expect(mocks.confirm).toHaveBeenCalledWith({ message: 'Nothing selected. Skip this step?', initialValue: false });
-        expect(mocks.multiselect).toHaveBeenCalledTimes(2);
-    });
-    it('maps multiselect cancellation to the configured back value', async () => {
-        mocks.multiselect.mockResolvedValueOnce(mocks.cancelSymbol);
-        const adapter = createKtxSetupPromptAdapter({
-            selectCancelValue: 'back',
-            multiselectCancelValue: 'back',
-            confirmEmptyOptionalMultiselect: true,
-        });
-        await expect(adapter.multiselect({ message: 'Which primary sources?', options: [] })).resolves.toEqual(['back']);
-        expect(mocks.cancel).toHaveBeenCalledWith('Setup cancelled.');
-    });
-    it('returns autocomplete selections and maps cancel to back', async () => {
-        mocks.autocomplete.mockResolvedValueOnce('analytics');
-        const adapter = createKtxSetupPromptAdapter({ selectCancelValue: 'back' });
-        await expect(adapter.autocomplete({
-            message: 'Dataset',
-            placeholder: 'Type to search',
-            options: [{ value: 'analytics', label: 'analytics' }],
-        })).resolves.toBe('analytics');
-        mocks.autocomplete.mockResolvedValueOnce(mocks.cancelSymbol);
-        await expect(adapter.autocomplete({
-            message: 'Dataset',
-            options: [{ value: 'analytics', label: 'analytics' }],
-        })).resolves.toBe('back');
-    });
-    it('returns autocomplete multiselect selections and maps cancel to back', async () => {
-        mocks.autocompleteMultiselect.mockResolvedValueOnce(['analytics', 'mart']);
-        const adapter = createKtxSetupPromptAdapter({ selectCancelValue: 'back', multiselectCancelValue: 'back' });
-        await expect(adapter.autocompleteMultiselect({
-            message: 'Datasets',
-            placeholder: 'Type to filter',
-            options: [
-                { value: 'analytics', label: 'analytics', hint: 'suggested' },
-                { value: 'mart', label: 'mart' },
-            ],
-            initialValues: ['analytics'],
-        })).resolves.toEqual(['analytics', 'mart']);
-        mocks.autocompleteMultiselect.mockResolvedValueOnce(mocks.cancelSymbol);
-        await expect(adapter.autocompleteMultiselect({
-            message: 'Datasets',
-            options: [{ value: 'analytics', label: 'analytics' }],
-        })).resolves.toEqual(['back']);
-    });
-    it('keeps setup intro and note plain for non-stream output', async () => {
-        const { createKtxSetupUiAdapter } = await import('./setup-prompts.js');
-        const chunks = [];
-        const io = {
-            stdout: {
-                isTTY: true,
-                write(chunk) {
-                    chunks.push(chunk);
-                },
-            },
-            stderr: { write: vi.fn() },
-        };
-        const ui = createKtxSetupUiAdapter();
-        ui.intro('KTX setup', io);
-        ui.note('  $ ktx status', 'What you can do next', io);
-        expect(chunks.join('')).toBe('KTX setup\n\nWhat you can do next:\n  $ ktx status\n');
-        expect(mocks.intro).not.toHaveBeenCalled();
-        expect(mocks.note).not.toHaveBeenCalled();
-    });
-    it('uses Clack intro and note for writable TTY output', async () => {
-        const { createKtxSetupUiAdapter } = await import('./setup-prompts.js');
-        const output = {
-            columns: 80,
-            isTTY: true,
-            on: vi.fn(),
-            write: vi.fn(),
-        };
-        const io = {
-            stdout: output,
-            stderr: { write: vi.fn() },
-        };
-        const ui = createKtxSetupUiAdapter();
-        ui.intro('KTX setup', io);
-        ui.note('  $ ktx status', 'What you can do next', io);
-        expect(mocks.intro).toHaveBeenCalledWith('KTX setup', { output });
-        expect(mocks.note).toHaveBeenCalledWith('  $ ktx status', 'What you can do next', { output });
-    });
-});

package/dist/setup-ready-menu.test.d.ts

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

package/dist/setup-ready-menu.test.js

@@ -1,44 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { isKtxPreAgentSetupReady, isKtxSetupReady, runKtxSetupReadyChangeMenu } from './setup-ready-menu.js';
-const readyStatus = {
-    project: { path: '/tmp/revenue', ready: true },
-    llm: { backend: 'anthropic', ready: true, model: 'claude-sonnet-4-6' },
-    embeddings: { backend: 'openai', ready: true, model: 'text-embedding-3-small', dimensions: 1536 },
-    databases: [{ connectionId: 'warehouse', ready: true }],
-    sources: [],
-    runtime: { required: false, ready: true, features: [] },
-    context: { ready: true, status: 'completed' },
-    agents: [{ target: 'codex', scope: 'project', ready: true }],
-};
-describe('setup ready menu', () => {
-    it('recognizes a ready setup only when required sections are ready', () => {
-        expect(isKtxSetupReady(readyStatus)).toBe(true);
-        expect(isKtxSetupReady({ ...readyStatus, embeddings: { ready: false } })).toBe(false);
-        expect(isKtxSetupReady({ ...readyStatus, runtime: { required: true, ready: false, features: ['core'] } })).toBe(false);
-        expect(isKtxSetupReady({ ...readyStatus, context: { ready: false, status: 'not_started' } })).toBe(false);
-        expect(isKtxSetupReady({ ...readyStatus, agents: [] })).toBe(false);
-    });
-    it('recognizes pre-agent readiness without requiring agents', () => {
-        expect(isKtxPreAgentSetupReady(readyStatus)).toBe(true);
-        expect(isKtxPreAgentSetupReady({ ...readyStatus, agents: [] })).toBe(true);
-        expect(isKtxPreAgentSetupReady({ ...readyStatus, embeddings: { ready: false } })).toBe(false);
-        expect(isKtxPreAgentSetupReady({ ...readyStatus, runtime: { required: true, ready: false, features: ['core'] } })).toBe(false);
-        expect(isKtxPreAgentSetupReady({ ...readyStatus, context: { ready: false, status: 'not_started' } })).toBe(false);
-    });
-    it('maps ready-project menu choices to setup sections', async () => {
-        const prompts = { select: vi.fn(async () => 'agents'), cancel: vi.fn() };
-        await expect(runKtxSetupReadyChangeMenu(readyStatus, { prompts })).resolves.toEqual({ action: 'agents' });
-        expect(prompts.select).toHaveBeenCalledWith({
-            message: 'KTX is already set up for /tmp/revenue. What would you like to change?',
-            options: [
-                { value: 'models', label: 'Models' },
-                { value: 'embeddings', label: 'Embeddings' },
-                { value: 'databases', label: 'Databases' },
-                { value: 'sources', label: 'Context sources' },
-                { value: 'context', label: 'Rebuild KTX context' },
-                { value: 'agents', label: 'Agent integration' },
-                { value: 'exit', label: 'Exit' },
-            ],
-        });
-    });
-});

package/dist/setup-runtime.test.d.ts

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

package/dist/setup-runtime.test.js

@@ -1,111 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { buildDefaultKtxProjectConfig } from './context/project/config.js';
-import { readKtxSetupState } from './context/project/setup-config.js';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { runKtxSetupRuntimeStep } from './setup-runtime.js';
-function makeIo() {
-    let stdout = '';
-    let stderr = '';
-    return {
-        io: {
-            stdout: {
-                write: (chunk) => {
-                    stdout += chunk;
-                },
-            },
-            stderr: {
-                write: (chunk) => {
-                    stderr += chunk;
-                },
-            },
-        },
-        stdout: () => stdout,
-        stderr: () => stderr,
-    };
-}
-function projectConfig(config) {
-    return vi.fn(async () => ({ config }));
-}
-describe('runKtxSetupRuntimeStep', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-setup-runtime-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('skips runtime setup when the project has no direct runtime requirements', async () => {
-        const io = makeIo();
-        const ensureRuntime = vi.fn();
-        await expect(runKtxSetupRuntimeStep({
-            projectDir: tempDir,
-            inputMode: 'auto',
-            cliVersion: '0.2.0',
-            runtimeInstallPolicy: 'prompt',
-        }, io.io, {
-            loadProject: projectConfig(buildDefaultKtxProjectConfig()),
-            ensureRuntime,
-            env: {},
-        })).resolves.toMatchObject({ status: 'skipped' });
-        expect(ensureRuntime).not.toHaveBeenCalled();
-        expect((await readKtxSetupState(tempDir)).completed_steps).not.toContain('runtime');
-        expect(io.stdout()).toContain('Runtime setup skipped.');
-    });
-    it('fails fast when required runtime features cannot be installed in no-input mode', async () => {
-        const io = makeIo();
-        const ensureRuntime = vi.fn(async () => {
-            throw new Error('KTX Python runtime is required for this command. Run: ktx admin runtime install --yes');
-        });
-        await expect(runKtxSetupRuntimeStep({
-            projectDir: tempDir,
-            inputMode: 'disabled',
-            cliVersion: '0.2.0',
-            runtimeInstallPolicy: 'never',
-            databaseIntrospectionFallback: true,
-        }, io.io, {
-            loadProject: projectConfig(buildDefaultKtxProjectConfig()),
-            ensureRuntime,
-            env: {},
-        })).resolves.toMatchObject({ status: 'failed' });
-        expect(ensureRuntime).toHaveBeenCalledWith(expect.objectContaining({ installPolicy: 'never' }));
-        expect((await readKtxSetupState(tempDir)).completed_steps).not.toContain('runtime');
-        expect(io.stderr()).toContain('ktx admin runtime install --yes');
-    });
-    it('starts the KTX daemon for configured sentence-transformers embeddings', async () => {
-        const io = makeIo();
-        const ensureLocalEmbeddings = vi.fn(async () => ({
-            baseUrl: 'http://127.0.0.1:61234',
-            stdoutLog: join(tempDir, '.ktx', 'runtime', 'daemon.stdout.log'),
-            stderrLog: join(tempDir, '.ktx', 'runtime', 'daemon.stderr.log'),
-        }));
-        const config = {
-            ...buildDefaultKtxProjectConfig(),
-            ingest: {
-                ...buildDefaultKtxProjectConfig().ingest,
-                embeddings: {
-                    backend: 'sentence-transformers',
-                    model: 'all-MiniLM-L6-v2',
-                    dimensions: 384,
-                    sentenceTransformers: { base_url: '' },
-                },
-            },
-        };
-        await expect(runKtxSetupRuntimeStep({
-            projectDir: tempDir,
-            inputMode: 'auto',
-            cliVersion: '0.2.0',
-            runtimeInstallPolicy: 'auto',
-        }, io.io, {
-            loadProject: projectConfig(config),
-            ensureLocalEmbeddings,
-            env: {},
-        })).resolves.toMatchObject({ status: 'ready' });
-        expect(ensureLocalEmbeddings).toHaveBeenCalledWith(expect.objectContaining({
-            projectDir: tempDir,
-            installPolicy: 'auto',
-        }));
-        expect(io.stdout()).toContain('Runtime ready: yes (local embeddings)');
-    });
-});

package/dist/setup-secrets.test.d.ts

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

package/dist/setup-secrets.test.js

@@ -1,30 +0,0 @@
-import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { envCredentialReference, writeProjectLocalSecretReference } from './setup-secrets.js';
-describe('setup secrets', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-setup-secrets-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('formats env credential references', () => {
-        expect(envCredentialReference('ANTHROPIC_API_KEY')).toBe('env:ANTHROPIC_API_KEY');
-    });
-    it('writes project-local secrets with restricted permissions and returns a file reference', async () => {
-        const result = await writeProjectLocalSecretReference({
-            projectDir: tempDir,
-            fileName: 'anthropic-api-key',
-            value: 'sk-ant-test',
-        });
-        expect(result).toBe(`file:${resolve(tempDir, '.ktx/secrets/anthropic-api-key')}`);
-        await expect(readFile(join(tempDir, '.ktx/secrets/anthropic-api-key'), 'utf-8')).resolves.toBe('sk-ant-test\n');
-        if (process.platform !== 'win32') {
-            const mode = (await stat(join(tempDir, '.ktx/secrets/anthropic-api-key'))).mode & 0o777;
-            expect(mode).toBe(0o600);
-        }
-    });
-});

package/dist/setup-sources-notion.test.d.ts

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