@kaelio/ktx 0.4.1 → 0.6.0

package/dist/admin-reindex.test.js

@@ -1,119 +0,0 @@
-import { createRequire } from 'node:module';
-import { describe, expect, it, vi } from 'vitest';
-import { renderReindexJson, renderReindexPlain, reindexHasErrors } from './admin-reindex.js';
-import { runKtxCli } from './index.js';
-const cliVersion = createRequire(import.meta.url)('@ktx/cli/package.json')
-    .version;
-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 summary(overrides = {}) {
-    return {
-        scopes: [
-            {
-                kind: 'wiki',
-                label: 'global',
-                scope: 'global',
-                scopeId: null,
-                scanned: 42,
-                updated: 3,
-                deleted: 1,
-                embeddingsRecomputed: 3,
-                embeddingsFailed: 0,
-                durationMs: 412,
-            },
-            {
-                kind: 'sl',
-                label: 'warehouse',
-                connectionId: 'warehouse',
-                scanned: 18,
-                updated: 2,
-                deleted: 0,
-                embeddingsRecomputed: 2,
-                embeddingsFailed: 0,
-                durationMs: 287,
-            },
-        ],
-        totals: { scanned: 60, updated: 5, deleted: 1, embeddingsRecomputed: 5, embeddingsFailed: 0 },
-        dbPath: '.ktx/db.sqlite',
-        force: false,
-        embeddingsAvailable: true,
-        durationMs: 1234,
-        ...overrides,
-    };
-}
-describe('admin reindex renderers', () => {
-    it('renders plain scope lines to stderr and summary to stdout', () => {
-        const io = makeIo();
-        renderReindexPlain(summary(), io.io);
-        expect(io.stderr()).toContain('wiki/global\tscanned=42\tupdated=3\tdeleted=1\tembeddings=3\tduration_ms=412\n');
-        expect(io.stderr()).toContain('sl/warehouse\tscanned=18\tupdated=2\tdeleted=0\tembeddings=2\tduration_ms=287\n');
-        expect(io.stdout()).toBe('reindex\tscopes=2\tscanned=60\tupdated=5\tdeleted=1\tembeddings=5\tduration_ms=1234\n');
-    });
-    it('renders rebuilt labels in plain force mode', () => {
-        const io = makeIo();
-        renderReindexPlain(summary({ force: true }), io.io);
-        expect(io.stderr()).toContain('rebuilt=3');
-        expect(io.stdout()).toContain('rebuilt=5');
-        expect(io.stdout()).not.toContain('updated=5');
-    });
-    it('renders json envelope to stdout only', () => {
-        const io = makeIo();
-        renderReindexJson(summary(), io.io);
-        expect(JSON.parse(io.stdout())).toMatchObject({
-            kind: 'reindex',
-            data: { totals: { scanned: 60, updated: 5 } },
-            meta: { command: 'admin reindex' },
-        });
-        expect(io.stderr()).toBe('');
-    });
-    it('detects per-scope errors', () => {
-        expect(reindexHasErrors(summary({
-            scopes: [{ ...summary().scopes[0], error: 'provider failed' }],
-        }))).toBe(true);
-    });
-});
-describe('admin reindex Commander routing', () => {
-    it('routes flags to the injectable reindex runner', async () => {
-        const { mkdir, mkdtemp, rm, writeFile } = await import('node:fs/promises');
-        const { tmpdir } = await import('node:os');
-        const { join } = await import('node:path');
-        const tempDir = await mkdtemp(join(tmpdir(), 'ktx-admin-reindex-cli-'));
-        const projectDir = join(tempDir, 'project');
-        const io = makeIo();
-        const adminReindex = vi.fn(async () => 0);
-        try {
-            await mkdir(projectDir, { recursive: true });
-            await writeFile(join(projectDir, 'ktx.yaml'), '{}\n', 'utf-8');
-            await expect(runKtxCli(['--project-dir', projectDir, 'admin', 'reindex', '--force', '--json', '--output', 'plain'], io.io, { adminReindex })).resolves.toBe(0);
-        }
-        finally {
-            await rm(tempDir, { recursive: true, force: true });
-        }
-        expect(adminReindex).toHaveBeenCalledWith({
-            projectDir,
-            force: true,
-            json: true,
-            output: 'plain',
-            cliVersion,
-        }, io.io);
-    });
-});

package/dist/admin.test.js

@@ -1,201 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { runKtxCli } from './index.js';
-function makeIo() {
-    let stdout = '';
-    let stderr = '';
-    return {
-        io: {
-            stdout: {
-                write: (chunk) => {
-                    stdout += chunk;
-                },
-            },
-            stderr: {
-                write: (chunk) => {
-                    stderr += chunk;
-                },
-            },
-        },
-        stdout: () => stdout,
-        stderr: () => stderr,
-    };
-}
-describe('admin Commander tree', () => {
-    it('prints visible admin help with supported low-level command groups', async () => {
-        const testIo = makeIo();
-        await expect(runKtxCli(['admin', '--help'], testIo.io)).resolves.toBe(0);
-        expect(testIo.stdout()).toContain('Usage: ktx admin [options] [command]');
-        for (const command of ['init', 'runtime', 'reindex']) {
-            expect(testIo.stdout()).toContain(command);
-        }
-        for (const removed of [
-            'doctor',
-            'scan',
-            'ingest',
-            'mapping',
-            'knowledge',
-            'model',
-            'replay',
-            'report',
-            'status',
-            'artifacts',
-            'config',
-            'tools',
-            'daemon',
-        ]) {
-            expect(testIo.stdout()).not.toContain(`${removed} `);
-        }
-        expect(testIo.stderr()).toBe('');
-    });
-    it('lists admin in root command rows', async () => {
-        const testIo = makeIo();
-        await expect(runKtxCli(['--help'], testIo.io)).resolves.toBe(0);
-        expect(testIo.stdout()).not.toContain('Advanced:');
-        expect(testIo.stdout()).toContain('admin');
-        expect(testIo.stdout()).toMatch(/Low-level project initialization,\s+runtime,\s+and index management/);
-        expect(testIo.stderr()).toBe('');
-    });
-    it('does not keep a dev alias', async () => {
-        const testIo = makeIo();
-        await expect(runKtxCli(['dev', '--help'], testIo.io)).resolves.toBe(1);
-        expect(testIo.stderr()).toContain("unknown command 'dev'");
-    });
-    it('keeps project scaffolding under admin init', async () => {
-        const { mkdtemp, readFile, rm } = await import('node:fs/promises');
-        const { tmpdir } = await import('node:os');
-        const { join } = await import('node:path');
-        const tempDir = await mkdtemp(join(tmpdir(), 'ktx-admin-init-'));
-        const projectDir = join(tempDir, 'warehouse');
-        const testIo = makeIo();
-        try {
-            await expect(runKtxCli(['admin', 'init', projectDir], testIo.io)).resolves.toBe(0);
-            expect(testIo.stdout()).toContain(`Initialized KTX project at ${projectDir}`);
-            await expect(readFile(join(projectDir, 'ktx.yaml'), 'utf-8')).resolves.not.toContain('project:');
-            expect(testIo.stderr()).toBe('');
-        }
-        finally {
-            await rm(tempDir, { recursive: true, force: true });
-        }
-    });
-    it('uses global project-dir for admin init when the positional directory is omitted', async () => {
-        const { mkdtemp, rm } = await import('node:fs/promises');
-        const { tmpdir } = await import('node:os');
-        const { join } = await import('node:path');
-        const tempDir = await mkdtemp(join(tmpdir(), 'ktx-admin-init-global-'));
-        const projectDir = join(tempDir, 'global-init');
-        const testIo = makeIo();
-        try {
-            await expect(runKtxCli(['--project-dir', projectDir, 'admin', 'init'], testIo.io)).resolves.toBe(0);
-            expect(testIo.stdout()).toContain(`Initialized KTX project at ${projectDir}`);
-            expect(testIo.stderr()).toBe('');
-        }
-        finally {
-            await rm(tempDir, { recursive: true, force: true });
-        }
-    });
-    it('prints config schema without requiring a KTX project directory', async () => {
-        const { mkdtemp, rm } = await import('node:fs/promises');
-        const { tmpdir } = await import('node:os');
-        const { join } = await import('node:path');
-        const tempDir = await mkdtemp(join(tmpdir(), 'ktx-admin-schema-'));
-        const missingProjectDir = join(tempDir, 'missing-project');
-        const originalProjectDir = process.env.KTX_PROJECT_DIR;
-        const testIo = makeIo();
-        try {
-            process.env.KTX_PROJECT_DIR = missingProjectDir;
-            await expect(runKtxCli(['admin', 'schema'], testIo.io)).resolves.toBe(0);
-            expect(JSON.parse(testIo.stdout())).toMatchObject({
-                title: 'ktx.yaml',
-                type: 'object',
-            });
-            expect(testIo.stderr()).toBe('');
-        }
-        finally {
-            if (originalProjectDir === undefined) {
-                delete process.env.KTX_PROJECT_DIR;
-            }
-            else {
-                process.env.KTX_PROJECT_DIR = originalProjectDir;
-            }
-            await rm(tempDir, { recursive: true, force: true });
-        }
-    });
-    it('rejects removed admin command groups', async () => {
-        for (const argv of [
-            ['admin', 'doctor', 'setup'],
-            ['admin', 'runtime', 'doctor'],
-            ['admin', 'runtime', 'prune', '--dry-run'],
-            ['admin', 'scan', 'warehouse'],
-            ['admin', 'ingest', 'run'],
-            ['admin', 'mapping', 'list'],
-            ['admin', 'completion', 'zsh'],
-            ['admin', '__complete', '--shell', 'zsh', '--position', '2', '--', 'ktx', ''],
-            ['admin', 'knowledge', 'list'],
-            ['admin', 'model', 'list'],
-            ['admin', 'artifacts'],
-        ]) {
-            const testIo = makeIo();
-            await expect(runKtxCli(argv, testIo.io)).resolves.toBe(1);
-            expect(testIo.stderr()).toMatch(/unknown command|error:/);
-        }
-    });
-    it.each([
-        {
-            argv: ['admin', 'runtime', '--help'],
-            expected: ['Usage: ktx admin runtime', 'install', 'start', 'stop', 'status'],
-        },
-    ])('prints generated nested help for $argv', async ({ argv, expected }) => {
-        const io = makeIo();
-        const doctor = vi.fn(async () => 0);
-        await expect(runKtxCli(argv, io.io, { doctor })).resolves.toBe(0);
-        for (const text of expected) {
-            expect(io.stdout()).toContain(text);
-        }
-        if (argv.join(' ') === 'admin runtime --help') {
-            expect(io.stdout()).not.toContain('prune');
-            expect(io.stdout()).not.toContain('doctor');
-        }
-        expect(io.stderr()).toBe('');
-        expect(doctor).not.toHaveBeenCalled();
-    });
-    it('rejects old adapter-backed ingest flags through public option parsing and keeps run out of ingest help', async () => {
-        const helpIo = makeIo();
-        const runIo = makeIo();
-        const publicIngest = vi.fn(async () => 0);
-        await expect(runKtxCli(['ingest', '--help'], helpIo.io, { publicIngest })).resolves.toBe(0);
-        await expect(runKtxCli(['ingest', 'run', '--connection-id', 'warehouse', '--adapter', 'metabase', '--project-dir', '/tmp/project'], runIo.io, { publicIngest })).resolves.toBe(1);
-        expect(helpIo.stdout()).not.toMatch(/^  run\s/m);
-        expect(runIo.stderr()).toMatch(/unknown option '--connection-id'|error:/);
-        expect(publicIngest).not.toHaveBeenCalled();
-    });
-    it.each([
-        { argv: ['scan'] },
-        { argv: ['scan', '--help'] },
-        { argv: ['scan', 'warehouse'] },
-        { argv: ['scan', 'warehouse', '--project-dir', '/tmp/project', '--dry-run'] },
-        { argv: ['scan', 'warehouse', '--project-dir', '/tmp/project', '--mode', 'relationships'] },
-    ])('rejects removed top-level scan command $argv', async ({ argv }) => {
-        const io = makeIo();
-        const publicIngest = vi.fn(async () => 0);
-        await expect(runKtxCli(argv, io.io, { publicIngest })).resolves.toBe(1);
-        expect(publicIngest).not.toHaveBeenCalled();
-        expect(io.stderr()).toMatch(/unknown command|error:/);
-    });
-    it('rejects old adapter-backed top-level ingest flags without low-level ingest registration', async () => {
-        const io = makeIo();
-        const publicIngest = vi.fn(async () => 0);
-        await expect(runKtxCli([
-            'ingest',
-            'run',
-            '--connection-id',
-            'warehouse',
-            '--adapter',
-            'metabase',
-            '--project-dir',
-            '/tmp/project',
-            '--json',
-        ], io.io, { publicIngest })).resolves.toBe(1);
-        expect(publicIngest).not.toHaveBeenCalled();
-        expect(io.stderr()).toMatch(/unknown option '--connection-id'|error:/);
-    });
-});

package/dist/cli-program.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildKtxProgram } from './cli-program.js';
-function stubIo() {
-    return {
-        stdout: { isTTY: false, columns: 80, write: () => { } },
-        stderr: { write: () => { } },
-    };
-}
-function stubPackageInfo() {
-    return {
-        name: '@ktx/cli',
-        version: '0.0.0-test',
-        contextPackageName: '@ktx/context',
-    };
-}
-describe('buildKtxProgram', () => {
-    it('returns a Command named "ktx" with all registered top-level subcommands', () => {
-        const program = buildKtxProgram({
-            io: stubIo(),
-            deps: {},
-            packageInfo: stubPackageInfo(),
-            runInit: async () => 0,
-        });
-        expect(program.name()).toBe('ktx');
-        const topLevel = program.commands.map((command) => command.name()).sort();
-        for (const expected of ['setup', 'connection', 'ingest', 'sl', 'admin']) {
-            expect(topLevel).toContain(expected);
-        }
-    });
-    it('does not parse argv or invoke action handlers', () => {
-        let wrote = '';
-        const io = {
-            stdout: {
-                isTTY: false,
-                columns: 80,
-                write: (chunk) => {
-                    wrote += chunk;
-                },
-            },
-            stderr: {
-                write: (chunk) => {
-                    wrote += chunk;
-                },
-            },
-        };
-        buildKtxProgram({ io, deps: {}, packageInfo: stubPackageInfo(), runInit: async () => 0 });
-        expect(wrote).toBe('');
-    });
-});

package/dist/cli-project.d.ts

@@ -1,12 +0,0 @@
-import { loadKtxProject, type KtxLocalProject } from '@ktx/context/project';
-export interface LoadKtxCliProjectOptions {
-    projectDir: string;
-}
-export interface LoadKtxCliProjectDeps {
-    loadProject?: typeof loadKtxProject;
-}
-/**
- * Thin wrapper around `loadKtxProject`. Kept as a single entrypoint so the CLI can grow shared
- * pre-load behavior later (telemetry, project lock, etc.). Today it does no extra work.
- */
-export declare function loadKtxCliProject(options: LoadKtxCliProjectOptions, deps?: LoadKtxCliProjectDeps): Promise<KtxLocalProject>;

package/dist/cli-project.js

@@ -1,8 +0,0 @@
-import { loadKtxProject } from '@ktx/context/project';
-/**
- * Thin wrapper around `loadKtxProject`. Kept as a single entrypoint so the CLI can grow shared
- * pre-load behavior later (telemetry, project lock, etc.). Today it does no extra work.
- */
-export async function loadKtxCliProject(options, deps = {}) {
-    return (deps.loadProject ?? loadKtxProject)({ projectDir: options.projectDir });
-}

package/dist/cli-project.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { buildDefaultKtxProjectConfig } from '@ktx/context/project';
-import { loadKtxCliProject } from './cli-project.js';
-function projectWithConfig(config) {
-    return {
-        projectDir: '/work/proj',
-        configPath: '/work/proj/ktx.yaml',
-        config,
-        coreConfig: {},
-        git: {},
-        fileStore: {},
-    };
-}
-describe('loadKtxCliProject', () => {
-    it('delegates to loadKtxProject and returns the project unchanged', async () => {
-        const project = projectWithConfig(buildDefaultKtxProjectConfig());
-        const loadProject = vi.fn(async () => project);
-        const result = await loadKtxCliProject({ projectDir: '/work/proj' }, { loadProject });
-        expect(result).toBe(project);
-        expect(loadProject).toHaveBeenCalledWith({ projectDir: '/work/proj' });
-    });
-});

package/dist/command-tree.test.js

@@ -1,126 +0,0 @@
-import { Command } from '@commander-js/extra-typings';
-import { describe, expect, it } from 'vitest';
-import { formatCommandTree, walkCommandTree } from './command-tree.js';
-describe('walkCommandTree', () => {
-    it('captures name, description, aliases, and nested children', () => {
-        const root = new Command('root').description('the root');
-        const child = new Command('child').description('a child').alias('c').alias('ch');
-        const grandchild = new Command('grand').description('a grandchild');
-        child.addCommand(grandchild);
-        root.addCommand(child);
-        const tree = walkCommandTree(root);
-        expect(tree).toEqual({
-            name: 'root',
-            description: 'the root',
-            aliases: [],
-            arguments: [],
-            children: [
-                {
-                    name: 'child',
-                    description: 'a child',
-                    aliases: ['c', 'ch'],
-                    arguments: [],
-                    children: [{ name: 'grand', description: 'a grandchild', aliases: [], arguments: [], children: [] }],
-                },
-            ],
-        });
-    });
-    it('returns an empty children array when there are no subcommands', () => {
-        const leaf = new Command('leaf').description('alone');
-        expect(walkCommandTree(leaf)).toEqual({
-            name: 'leaf',
-            description: 'alone',
-            aliases: [],
-            arguments: [],
-            children: [],
-        });
-    });
-    it('uses an empty string when description is unset', () => {
-        const command = new Command('bare');
-        expect(walkCommandTree(command).description).toBe('');
-    });
-    it('captures required, optional, and variadic arguments', () => {
-        const command = new Command('scan')
-            .argument('<connectionId>', 'KTX connection id')
-            .argument('[schemas...]', 'Schemas');
-        expect(walkCommandTree(command).arguments).toEqual(['<connectionId>', '[schemas...]']);
-    });
-    it('walks registered commands without applying hidden-command policy', () => {
-        const root = new Command('ktx');
-        root.command('scan', { hidden: true }).description('Run a standalone connection scan');
-        const ingest = root.command('ingest').description('Build or inspect KTX context');
-        ingest.command('run', { hidden: true }).description('Run local ingest by adapter');
-        ingest.command('watch', { hidden: true }).description('Open a stored visual report');
-        ingest.command('status').description('Print status');
-        root.command('status').description('Check readiness');
-        const tree = walkCommandTree(root);
-        expect(tree.children.map((child) => child.name)).toEqual(['scan', 'ingest', 'status']);
-        expect(tree.children[0]).toMatchObject({
-            name: 'scan',
-            description: 'Run a standalone connection scan',
-            children: [],
-        });
-        expect(tree.children[1]).toMatchObject({
-            name: 'ingest',
-            children: [
-                { name: 'run', description: 'Run local ingest by adapter', aliases: [], arguments: [], children: [] },
-                { name: 'watch', description: 'Open a stored visual report', aliases: [], arguments: [], children: [] },
-                { name: 'status', description: 'Print status', aliases: [], arguments: [], children: [] },
-            ],
-        });
-    });
-});
-describe('formatCommandTree', () => {
-    it('renders a single node with no children', () => {
-        const node = { name: 'solo', description: 'just me', aliases: [], arguments: [], children: [] };
-        expect(formatCommandTree(node)).toMatch(/^solo\s+just me\n$/);
-    });
-    it('renders aliases in parentheses before the description', () => {
-        const node = { name: 'cmd', description: 'does things', aliases: ['c', 'co'], arguments: [], children: [] };
-        expect(formatCommandTree(node)).toMatch(/^cmd \(c, co\)\s+does things\n$/);
-    });
-    it('renders command arguments after the command name', () => {
-        const node = {
-            name: 'test',
-            description: 'Test a configured connection',
-            aliases: [],
-            arguments: ['<connectionId>'],
-            children: [],
-        };
-        expect(formatCommandTree(node)).toMatch(/^test <connectionId>\s+Test a configured connection\n$/);
-    });
-    it('omits the dash when description is empty', () => {
-        const node = { name: 'bare', description: '', aliases: [], arguments: [], children: [] };
-        expect(formatCommandTree(node)).toBe('bare\n');
-    });
-    it('renders tree connectors and preserves sibling registration order', () => {
-        const tree = {
-            name: 'root',
-            description: 'top',
-            aliases: [],
-            arguments: [],
-            children: [
-                {
-                    name: 'beta',
-                    description: 'b',
-                    aliases: [],
-                    arguments: [],
-                    children: [{ name: 'leaf', description: 'l', aliases: [], arguments: [], children: [] }],
-                },
-                {
-                    name: 'alpha',
-                    description: 'a',
-                    aliases: ['al'],
-                    arguments: ['<id>'],
-                    children: [{ name: 'inner', description: 'i', aliases: [], arguments: [], children: [] }],
-                },
-            ],
-        };
-        const lines = formatCommandTree(tree).trimEnd().split('\n');
-        expect(lines[0]).toMatch(/^root\s+top$/);
-        expect(lines[1]).toMatch(/^  ├── beta\s+b$/);
-        expect(lines[2]).toMatch(/^  │   └── leaf\s+l$/);
-        expect(lines[3]).toMatch(/^  └── alpha <id> \(al\)\s+a$/);
-        expect(lines[4]).toMatch(/^      └── inner\s+i$/);
-    });
-});

package/dist/commands/mcp-commands.test.js

@@ -1,111 +0,0 @@
-import { Command } from '@commander-js/extra-typings';
-import { describe, expect, it, vi } from 'vitest';
-import { registerMcpCommands } from './mcp-commands.js';
-function makeContext(overrides = {}) {
-    let exitCode = 0;
-    return {
-        io: {
-            stdout: { write: vi.fn() },
-            stderr: { write: vi.fn() },
-        },
-        deps: {},
-        packageInfo: { name: '@ktx/cli', version: '0.0.0-test', contextPackageName: '@ktx/context' },
-        setExitCode: (code) => {
-            exitCode = code;
-        },
-        runInit: vi.fn(),
-        writeDebug: vi.fn(),
-        ...overrides,
-        get exitCode() {
-            return exitCode;
-        },
-    };
-}
-describe('registerMcpCommands', () => {
-    it('registers the public mcp lifecycle commands', () => {
-        const program = new Command().exitOverride();
-        registerMcpCommands(program, makeContext());
-        const mcp = program.commands.find((command) => command.name() === 'mcp');
-        expect(mcp?.commands.map((command) => command.name()).sort()).toEqual([
-            'logs',
-            'serve-internal',
-            'start',
-            'status',
-            'stdio',
-            'stop',
-        ]);
-        expect(mcp?.commands.find((command) => command.name() === 'serve-internal')
-            ?._hidden).toBe(true);
-    });
-    it('rejects non-loopback start without token before spawning', async () => {
-        const program = new Command().exitOverride();
-        const startDaemon = vi.fn();
-        const context = makeContext({ deps: { mcp: { startDaemon } } });
-        registerMcpCommands(program, context);
-        await expect(program.parseAsync(['mcp', 'start', '--host', '0.0.0.0'], { from: 'user' })).rejects.toThrow('Binding KTX MCP to 0.0.0.0 requires --token or KTX_MCP_TOKEN');
-        expect(startDaemon).not.toHaveBeenCalled();
-    });
-    it('prints "already running" when startDaemon reports already-running', async () => {
-        const program = new Command().exitOverride().option('--project-dir <path>');
-        const startDaemon = vi.fn().mockResolvedValue({
-            status: 'already-running',
-            url: 'http://127.0.0.1:7878/mcp',
-            state: {
-                schemaVersion: 1,
-                pid: 4242,
-                host: '127.0.0.1',
-                port: 7878,
-                tokenAuth: false,
-                projectDir: '/tmp/ktx-already',
-                startedAt: '2026-05-14T00:00:00.000Z',
-                logPath: '/tmp/ktx-already/.ktx/logs/mcp.log',
-            },
-        });
-        const context = makeContext({ deps: { mcp: { startDaemon } } });
-        registerMcpCommands(program, context);
-        await program.parseAsync(['--project-dir', '/tmp/ktx-already', 'mcp', 'start'], { from: 'user' });
-        expect(startDaemon).toHaveBeenCalledTimes(1);
-        expect(context.io.stdout.write).toHaveBeenCalledWith([
-            'KTX MCP daemon already running: http://127.0.0.1:7878/mcp',
-            '',
-            'KTX is ready for configured agents.',
-            'Open your agent for this KTX project and ask a data question, for example:',
-            '  "Use KTX to show me the available tables and metrics."',
-            '',
-        ].join('\n'));
-    });
-    it('prints a friendly next step after starting the daemon', async () => {
-        const program = new Command().exitOverride().option('--project-dir <path>');
-        const startDaemon = vi.fn().mockResolvedValue({
-            status: 'started',
-            url: 'http://127.0.0.1:7878/mcp',
-            state: {
-                schemaVersion: 1,
-                pid: 4242,
-                host: '127.0.0.1',
-                port: 7878,
-                tokenAuth: false,
-                projectDir: '/tmp/ktx-started',
-                startedAt: '2026-05-14T00:00:00.000Z',
-                logPath: '/tmp/ktx-started/.ktx/logs/mcp.log',
-            },
-        });
-        const context = makeContext({ deps: { mcp: { startDaemon } } });
-        registerMcpCommands(program, context);
-        await program.parseAsync(['--project-dir', '/tmp/ktx-started', 'mcp', 'start'], { from: 'user' });
-        expect(context.io.stdout.write).toHaveBeenCalledWith(expect.stringContaining('KTX MCP daemon started: http://127.0.0.1:7878/mcp\n\nKTX is ready for configured agents.'));
-        expect(context.io.stdout.write).toHaveBeenCalledWith(expect.stringContaining('"Use KTX to show me the available tables and metrics."'));
-    });
-    it('runs the stdio server with the resolved project directory', async () => {
-        const program = new Command().exitOverride().option('--project-dir <path>');
-        const runStdioServer = vi.fn().mockResolvedValue(undefined);
-        const context = makeContext({ deps: { mcp: { runStdioServer } } });
-        registerMcpCommands(program, context);
-        await expect(program.parseAsync(['--project-dir', '/tmp/ktx6', 'mcp', 'stdio'], { from: 'user' })).resolves.toBe(program);
-        expect(runStdioServer).toHaveBeenCalledWith({
-            projectDir: '/tmp/ktx6',
-            cliVersion: '0.0.0-test',
-            io: context.io,
-        });
-    });
-});