@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/dist/agent.d.ts

@@ -0,0 +1,71 @@
+import type { KtxCliIo } from './cli-runtime.js';
+import { type KtxAgentRuntime, type KtxAgentRuntimeDeps } from './agent-runtime.js';
+import type { KtxManagedPythonInstallPolicy } from './managed-python-command.js';
+import { type KtxSetupStatus } from './setup.js';
+export type KtxAgentArgs = {
+    command: 'tools';
+    projectDir: string;
+    json: true;
+} | {
+    command: 'context';
+    projectDir: string;
+    json: true;
+} | {
+    command: 'sl-list';
+    projectDir: string;
+    json: true;
+    connectionId?: string;
+    query?: string;
+} | {
+    command: 'sl-read';
+    projectDir: string;
+    json: true;
+    connectionId?: string;
+    sourceName: string;
+} | {
+    command: 'sl-query';
+    projectDir: string;
+    json: true;
+    connectionId: string;
+    queryFile: string;
+    execute: boolean;
+    maxRows?: number;
+    cliVersion: string;
+    runtimeInstallPolicy: KtxManagedPythonInstallPolicy;
+} | {
+    command: 'wiki-search';
+    projectDir: string;
+    json: true;
+    query: string;
+    limit: number;
+} | {
+    command: 'wiki-read';
+    projectDir: string;
+    json: true;
+    pageId: string;
+} | {
+    command: 'sql-execute';
+    projectDir: string;
+    json: true;
+    connectionId: string;
+    sqlFile: string;
+    maxRows?: number;
+};
+export interface KtxAgentDeps extends KtxAgentRuntimeDeps {
+    createRuntime?: (options: {
+        projectDir: string;
+        enableSemanticCompute: boolean;
+        enableQueryExecution: boolean;
+        cliVersion?: string;
+        runtimeInstallPolicy?: KtxManagedPythonInstallPolicy;
+        io?: KtxCliIo;
+    }) => Promise<KtxAgentRuntime>;
+    readSetupStatus?: (projectDir: string) => Promise<KtxSetupStatus | {
+        project: {
+            path?: string;
+            ready: boolean;
+        };
+        agents: unknown[];
+    }>;
+}
+export declare function runKtxAgent(args: KtxAgentArgs, io: KtxCliIo, deps?: KtxAgentDeps): Promise<number>;

package/dist/agent.js

@@ -0,0 +1,156 @@
+import { readFile } from 'node:fs/promises';
+import { createKtxAgentRuntime, parseAgentMaxRows, readAgentJsonFile, writeAgentJson, writeAgentJsonError, } from './agent-runtime.js';
+import { isMissingProjectConfigError, missingConnectionSlSearchReadiness, missingProjectSlSearchReadiness, noConnectionsSlSearchReadiness, noIndexedSourcesSlSearchReadiness, } from './agent-search-readiness.js';
+import { readKtxSetupStatus } from './setup.js';
+const AGENT_TOOLS = [
+    { name: 'context', command: 'ktx agent context --json' },
+    { name: 'sl.list', command: 'ktx agent sl list --json [--connection-id <id>] [--query <text>]' },
+    { name: 'sl.read', command: 'ktx agent sl read <sourceName> --json [--connection-id <id>]' },
+    {
+        name: 'sl.query',
+        command: 'ktx agent sl query --json --connection-id <id> --query-file <path> --execute --max-rows 100',
+    },
+    { name: 'wiki.search', command: 'ktx agent wiki search <query> --json [--limit 10]' },
+    { name: 'wiki.read', command: 'ktx agent wiki read <pageId> --json' },
+    {
+        name: 'sql.execute',
+        command: 'ktx agent sql execute --json --connection-id <id> --sql-file <path> --max-rows 100',
+    },
+];
+function writeAgentSlSearchReadinessError(io, detail) {
+    writeAgentJsonError(io, detail.message, { code: detail.code, nextSteps: detail.nextSteps });
+}
+async function runtimeFor(args, deps, io) {
+    const needsSemanticCompute = args.command === 'sl-query';
+    const needsQueryExecution = args.command === 'sql-execute' || (args.command === 'sl-query' && args.execute);
+    const runtimeOptions = {
+        projectDir: args.projectDir,
+        enableSemanticCompute: needsSemanticCompute,
+        enableQueryExecution: needsQueryExecution,
+        ...(args.command === 'sl-query'
+            ? {
+                cliVersion: args.cliVersion,
+                runtimeInstallPolicy: args.runtimeInstallPolicy,
+                io,
+            }
+            : {}),
+    };
+    return deps.createRuntime ? deps.createRuntime(runtimeOptions) : createKtxAgentRuntime(runtimeOptions, deps);
+}
+function connectionIdForSource(runtime, requested) {
+    if (requested)
+        return requested;
+    const ids = Object.keys(runtime.project.config.connections ?? {});
+    if (ids.length === 1)
+        return ids[0];
+    throw new Error('Use --connection-id when the project has zero or multiple connections.');
+}
+export async function runKtxAgent(args, io, deps = {}) {
+    try {
+        if (args.command === 'tools') {
+            writeAgentJson(io, { projectDir: args.projectDir, tools: AGENT_TOOLS });
+            return 0;
+        }
+        const runtime = await runtimeFor(args, deps, io);
+        if (args.command === 'context') {
+            const [status, connections, semanticLayer] = await Promise.all([
+                (deps.readSetupStatus ?? readKtxSetupStatus)(args.projectDir),
+                runtime.ports.connections?.list() ?? [],
+                runtime.ports.semanticLayer?.listSources({}) ?? { sources: [], totalSources: 0 },
+            ]);
+            writeAgentJson(io, { projectDir: args.projectDir, status, connections, semanticLayer, tools: AGENT_TOOLS });
+            return 0;
+        }
+        if (args.command === 'sl-list') {
+            const semanticLayer = runtime.ports.semanticLayer;
+            if (!semanticLayer)
+                throw new Error('Semantic-layer tools are not available for this project.');
+            if (args.query) {
+                const connectionIds = Object.keys(runtime.project.config.connections ?? {});
+                if (args.connectionId && !runtime.project.config.connections[args.connectionId]) {
+                    writeAgentSlSearchReadinessError(io, missingConnectionSlSearchReadiness(args.projectDir, args.connectionId, args.query));
+                    return 1;
+                }
+                if (connectionIds.length === 0) {
+                    writeAgentSlSearchReadinessError(io, noConnectionsSlSearchReadiness(args.projectDir, args.query));
+                    return 1;
+                }
+            }
+            const listed = await semanticLayer.listSources({ connectionId: args.connectionId, query: args.query });
+            if (args.query && listed.sources.length === 0) {
+                const allSources = await semanticLayer.listSources({ connectionId: args.connectionId });
+                if (allSources.totalSources === 0) {
+                    writeAgentSlSearchReadinessError(io, noIndexedSourcesSlSearchReadiness(args.projectDir, args.query));
+                    return 1;
+                }
+            }
+            writeAgentJson(io, listed);
+            return 0;
+        }
+        if (args.command === 'sl-read') {
+            const semanticLayer = runtime.ports.semanticLayer;
+            if (!semanticLayer)
+                throw new Error('Semantic-layer tools are not available for this project.');
+            const source = await semanticLayer.readSource({
+                connectionId: connectionIdForSource(runtime, args.connectionId),
+                sourceName: args.sourceName,
+            });
+            if (!source)
+                throw new Error(`Semantic-layer source "${args.sourceName}" was not found.`);
+            writeAgentJson(io, source);
+            return 0;
+        }
+        if (args.command === 'sl-query') {
+            const semanticLayer = runtime.ports.semanticLayer;
+            if (!semanticLayer)
+                throw new Error('Semantic-layer tools are not available for this project.');
+            const query = await readAgentJsonFile(args.queryFile);
+            const maxRows = args.execute ? parseAgentMaxRows(args.maxRows) : args.maxRows;
+            writeAgentJson(io, await semanticLayer.query({
+                connectionId: args.connectionId,
+                query: { ...query, ...(maxRows !== undefined ? { limit: maxRows } : {}) },
+            }));
+            return 0;
+        }
+        if (args.command === 'wiki-search') {
+            const knowledge = runtime.ports.knowledge;
+            if (!knowledge)
+                throw new Error('Wiki tools are not available for this project.');
+            writeAgentJson(io, await knowledge.search({ userId: 'agent', query: args.query, limit: args.limit }));
+            return 0;
+        }
+        if (args.command === 'wiki-read') {
+            const knowledge = runtime.ports.knowledge;
+            if (!knowledge)
+                throw new Error('Wiki tools are not available for this project.');
+            const page = await knowledge.read({ userId: 'agent', key: args.pageId });
+            if (!page)
+                throw new Error(`Wiki page "${args.pageId}" was not found.`);
+            writeAgentJson(io, page);
+            return 0;
+        }
+        const queryExecutor = runtime.queryExecutor;
+        if (!queryExecutor)
+            throw new Error('SQL execution is not available for this project.');
+        const connection = runtime.project.config.connections[args.connectionId];
+        if (!connection)
+            throw new Error(`Connection "${args.connectionId}" was not found.`);
+        const maxRows = parseAgentMaxRows(args.maxRows);
+        writeAgentJson(io, await queryExecutor.execute({
+            connectionId: args.connectionId,
+            projectDir: runtime.project.projectDir,
+            connection,
+            sql: await readFile(args.sqlFile, 'utf-8'),
+            maxRows,
+        }));
+        return 0;
+    }
+    catch (error) {
+        if (args.command === 'sl-list' && args.query && isMissingProjectConfigError(error)) {
+            writeAgentSlSearchReadinessError(io, missingProjectSlSearchReadiness(args.projectDir, args.query));
+            return 1;
+        }
+        writeAgentJsonError(io, error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}

package/dist/agent.test.d.ts

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

package/dist/agent.test.js

@@ -0,0 +1,338 @@
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildDefaultKtxProjectConfig } from '@ktx/context/project';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { runKtxAgent } from './agent.js';
+function makeIo() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        io: {
+            stdout: { write: (chunk) => (stdout += chunk) },
+            stderr: { write: (chunk) => (stderr += chunk) },
+        },
+        stdout: () => stdout,
+        stderr: () => stderr,
+    };
+}
+function runtime(overrides = {}) {
+    const config = buildDefaultKtxProjectConfig('revenue');
+    return {
+        project: {
+            projectDir: '/tmp/revenue',
+            configPath: '/tmp/revenue/ktx.yaml',
+            config: {
+                ...config,
+                connections: {
+                    warehouse: { driver: 'sqlite', path: 'warehouse.sqlite', readonly: true },
+                },
+            },
+            coreConfig: {},
+            git: {},
+            fileStore: {},
+        },
+        ports: {
+            connections: { list: vi.fn(async () => [{ id: 'warehouse', name: 'warehouse', connectionType: 'sqlite' }]) },
+            semanticLayer: {
+                listSources: vi.fn(async () => ({
+                    sources: [
+                        {
+                            connectionId: 'warehouse',
+                            connectionName: 'warehouse',
+                            name: 'orders',
+                            columnCount: 2,
+                            measureCount: 1,
+                            joinCount: 0,
+                        },
+                    ],
+                    totalSources: 1,
+                })),
+                readSource: vi.fn(async () => ({ sourceName: 'orders', yaml: 'name: orders\n' })),
+                writeSource: vi.fn(async () => ({ success: true, sourceName: 'orders' })),
+                validate: vi.fn(async () => ({ success: true, errors: [], warnings: [] })),
+                query: vi.fn(async () => ({ sql: 'select 1', headers: ['x'], rows: [[1]], totalRows: 1, plan: {} })),
+            },
+            knowledge: {
+                search: vi.fn(async () => ({
+                    results: [
+                        {
+                            key: 'page-1',
+                            path: 'knowledge/global/page-1.md',
+                            scope: 'GLOBAL',
+                            summary: 'Revenue logic',
+                            score: 0.9,
+                            matchReasons: ['lexical'],
+                        },
+                    ],
+                    totalFound: 1,
+                })),
+                read: vi.fn(async () => ({
+                    key: 'page-1',
+                    scope: 'GLOBAL',
+                    summary: 'Revenue logic',
+                    content: 'Use net revenue.',
+                })),
+                write: vi.fn(async () => ({ success: true, key: 'page-1', action: 'created' })),
+            },
+        },
+        queryExecutor: {
+            execute: vi.fn(async () => ({ headers: ['x'], rows: [[1]], totalRows: 1, command: 'SELECT', rowCount: 1 })),
+        },
+        ...overrides,
+    };
+}
+function runtimeWithoutConnections() {
+    const base = runtime();
+    return {
+        ...base,
+        project: {
+            ...base.project,
+            config: {
+                ...base.project.config,
+                connections: {},
+            },
+        },
+        ports: {
+            ...base.ports,
+            semanticLayer: {
+                ...base.ports.semanticLayer,
+                listSources: vi.fn(async () => ({ sources: [], totalSources: 0 })),
+            },
+        },
+    };
+}
+describe('runKtxAgent', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-agent-'));
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('prints tool discovery with every stable command', async () => {
+        const io = makeIo();
+        await expect(runKtxAgent({ command: 'tools', projectDir: tempDir, json: true }, io.io)).resolves.toBe(0);
+        const body = JSON.parse(io.stdout());
+        expect(body.projectDir).toBe(tempDir);
+        expect(body.tools.map((tool) => tool.name)).toEqual([
+            'context',
+            'sl.list',
+            'sl.read',
+            'sl.query',
+            'wiki.search',
+            'wiki.read',
+            'sql.execute',
+        ]);
+        expect(io.stderr()).toBe('');
+    });
+    it('prints project context from setup status, connections, and SL summaries', async () => {
+        const io = makeIo();
+        const createRuntime = vi.fn(async () => runtime());
+        const readSetupStatus = vi.fn(async () => ({ project: { path: tempDir, ready: true }, agents: [] }));
+        await expect(runKtxAgent({ command: 'context', projectDir: tempDir, json: true }, io.io, { createRuntime, readSetupStatus })).resolves.toBe(0);
+        expect(JSON.parse(io.stdout())).toMatchObject({
+            projectDir: tempDir,
+            status: { project: { ready: true } },
+            connections: [{ id: 'warehouse' }],
+            semanticLayer: { totalSources: 1 },
+        });
+    });
+    it('dispatches SL list, SL read, wiki search, and wiki read through local ports', async () => {
+        for (const args of [
+            { command: 'sl-list', projectDir: tempDir, json: true, connectionId: 'warehouse' },
+            {
+                command: 'sl-read',
+                projectDir: tempDir,
+                json: true,
+                connectionId: 'warehouse',
+                sourceName: 'orders',
+            },
+            { command: 'wiki-search', projectDir: tempDir, json: true, query: 'revenue', limit: 10 },
+            { command: 'wiki-read', projectDir: tempDir, json: true, pageId: 'page-1' },
+        ]) {
+            const io = makeIo();
+            await expect(runKtxAgent(args, io.io, { createRuntime: async () => runtime() })).resolves.toBe(0);
+            expect(JSON.parse(io.stdout())).toBeTruthy();
+            expect(io.stderr()).toBe('');
+        }
+    });
+    it('prints wiki hybrid search metadata from the hidden agent wiki search command', async () => {
+        const fakeRuntime = runtime();
+        const knowledge = fakeRuntime.ports.knowledge;
+        if (!knowledge) {
+            throw new Error('Expected runtime knowledge port');
+        }
+        fakeRuntime.ports.knowledge = {
+            ...knowledge,
+            search: vi.fn(async () => ({
+                results: [
+                    {
+                        key: 'metrics/revenue',
+                        path: 'knowledge/global/metrics/revenue.md',
+                        scope: 'GLOBAL',
+                        summary: 'Revenue metric definition',
+                        score: 0.02459016393442623,
+                        matchReasons: ['lexical', 'token'],
+                    },
+                ],
+                totalFound: 1,
+            })),
+        };
+        const io = makeIo();
+        await expect(runKtxAgent({ command: 'wiki-search', projectDir: tempDir, json: true, query: 'paid order', limit: 5 }, io.io, {
+            createRuntime: async () => fakeRuntime,
+        })).resolves.toBe(0);
+        expect(JSON.parse(io.stdout())).toEqual({
+            results: [
+                expect.objectContaining({
+                    key: 'metrics/revenue',
+                    path: 'knowledge/global/metrics/revenue.md',
+                    matchReasons: ['lexical', 'token'],
+                }),
+            ],
+            totalFound: 1,
+        });
+    });
+    it('executes SL queries from a JSON query file', async () => {
+        const queryFile = join(tempDir, 'sl-query.json');
+        const io = makeIo();
+        await writeFile(queryFile, '{"measures":["total_revenue"],"dimensions":[]}', 'utf-8');
+        await expect(runKtxAgent({
+            command: 'sl-query',
+            projectDir: tempDir,
+            json: true,
+            connectionId: 'warehouse',
+            queryFile,
+            execute: true,
+            maxRows: 100,
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'never',
+        }, io.io, { createRuntime: async () => runtime() })).resolves.toBe(0);
+        expect(JSON.parse(io.stdout())).toMatchObject({ sql: 'select 1', rows: [[1]] });
+    });
+    it('passes managed runtime options into default SL query runtime creation', async () => {
+        const queryFile = join(tempDir, 'sl-query.json');
+        const io = makeIo();
+        const createRuntime = vi.fn(async () => runtime());
+        await writeFile(queryFile, '{"measures":["total_revenue"],"dimensions":[]}', 'utf-8');
+        await expect(runKtxAgent({
+            command: 'sl-query',
+            projectDir: tempDir,
+            json: true,
+            connectionId: 'warehouse',
+            queryFile,
+            execute: false,
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'auto',
+        }, io.io, { createRuntime })).resolves.toBe(0);
+        expect(createRuntime).toHaveBeenCalledWith({
+            projectDir: tempDir,
+            enableSemanticCompute: true,
+            enableQueryExecution: false,
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'auto',
+            io: io.io,
+        });
+    });
+    it('executes read-only SQL from a SQL file with an explicit row limit', async () => {
+        const sqlFile = join(tempDir, 'query.sql');
+        const fakeRuntime = runtime();
+        const io = makeIo();
+        await writeFile(sqlFile, 'select 1', 'utf-8');
+        await expect(runKtxAgent({
+            command: 'sql-execute',
+            projectDir: tempDir,
+            json: true,
+            connectionId: 'warehouse',
+            sqlFile,
+            maxRows: 100,
+        }, io.io, { createRuntime: async () => fakeRuntime })).resolves.toBe(0);
+        expect(fakeRuntime.queryExecutor?.execute).toHaveBeenCalledWith({
+            connectionId: 'warehouse',
+            projectDir: '/tmp/revenue',
+            connection: { driver: 'sqlite', path: 'warehouse.sqlite', readonly: true },
+            sql: 'select 1',
+            maxRows: 100,
+        });
+    });
+    it('prints guided JSON when semantic-layer search runs outside a project', async () => {
+        const io = makeIo();
+        const missingProjectError = Object.assign(new Error('ENOENT: no such file or directory'), {
+            code: 'ENOENT',
+            path: join(tempDir, 'ktx.yaml'),
+        });
+        await expect(runKtxAgent({ command: 'sl-list', projectDir: tempDir, json: true, query: 'gross revenue' }, io.io, { createRuntime: vi.fn(async () => Promise.reject(missingProjectError)) })).resolves.toBe(1);
+        expect(JSON.parse(io.stderr())).toEqual({
+            ok: false,
+            error: {
+                code: 'agent_sl_search_missing_project',
+                message: `Semantic-layer search needs an initialized KTX project at ${tempDir}.`,
+                nextSteps: [
+                    'ktx demo',
+                    `ktx setup --project-dir ${tempDir}`,
+                    'ktx ingest <connection>',
+                    `ktx agent sl list --json --query "gross revenue" --project-dir ${tempDir}`,
+                ],
+            },
+        });
+        expect(io.stdout()).toBe('');
+    });
+    it('prints guided JSON when semantic-layer search has no configured connections', async () => {
+        const io = makeIo();
+        await expect(runKtxAgent({ command: 'sl-list', projectDir: tempDir, json: true, query: 'revenue' }, io.io, { createRuntime: async () => runtimeWithoutConnections() })).resolves.toBe(1);
+        expect(JSON.parse(io.stderr())).toMatchObject({
+            ok: false,
+            error: {
+                code: 'agent_sl_search_no_connections',
+                message: `Semantic-layer search found no configured connections in ${tempDir}.`,
+                nextSteps: [
+                    'ktx demo',
+                    `ktx setup --project-dir ${tempDir}`,
+                    'ktx ingest <connection>',
+                    `ktx agent sl list --json --query "revenue" --project-dir ${tempDir}`,
+                ],
+            },
+        });
+    });
+    it('prints guided JSON when semantic-layer search asks for an unknown connection', async () => {
+        const io = makeIo();
+        await expect(runKtxAgent({ command: 'sl-list', projectDir: tempDir, json: true, connectionId: 'missing', query: 'revenue' }, io.io, { createRuntime: async () => runtime() })).resolves.toBe(1);
+        expect(JSON.parse(io.stderr())).toMatchObject({
+            ok: false,
+            error: {
+                code: 'agent_sl_search_unknown_connection',
+                message: `Semantic-layer search connection "missing" is not configured in ${tempDir}.`,
+            },
+        });
+    });
+    it('prints guided JSON when semantic-layer search has no indexed sources', async () => {
+        const fakeRuntime = runtime();
+        const semanticLayer = fakeRuntime.ports.semanticLayer;
+        fakeRuntime.ports.semanticLayer = {
+            ...semanticLayer,
+            listSources: vi.fn(async () => ({ sources: [], totalSources: 0 })),
+        };
+        const io = makeIo();
+        await expect(runKtxAgent({ command: 'sl-list', projectDir: tempDir, json: true, connectionId: 'warehouse', query: 'revenue' }, io.io, { createRuntime: async () => fakeRuntime })).resolves.toBe(1);
+        expect(JSON.parse(io.stderr())).toMatchObject({
+            ok: false,
+            error: {
+                code: 'agent_sl_search_no_indexed_sources',
+                message: `Semantic-layer search found no indexed semantic-layer sources in ${tempDir}.`,
+            },
+        });
+    });
+    it('returns JSON errors when required ports or records are missing', async () => {
+        const io = makeIo();
+        await expect(runKtxAgent({ command: 'wiki-read', projectDir: tempDir, json: true, pageId: 'missing' }, io.io, {
+            createRuntime: async () => runtime({
+                ports: { knowledge: { read: vi.fn(async () => null) } },
+            }),
+        })).resolves.toBe(1);
+        expect(JSON.parse(io.stderr())).toMatchObject({
+            ok: false,
+            error: { message: expect.stringContaining('missing') },
+        });
+    });
+});

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { installStartupProfileReporter, profileMark, profileSpan } from './startup-profile.js';
+installStartupProfileReporter();
+profileMark('bin:entry');
+const { runKtxCli } = await profileSpan('import ./cli-runtime.js', () => import('./cli-runtime.js'));
+profileMark('bin:runKtxCli');
+process.exitCode = await runKtxCli(process.argv.slice(2));

package/dist/clack.d.ts

@@ -0,0 +1,6 @@
+export interface KtxCliSpinner {
+    start(message: string): void;
+    stop(message: string): void;
+    error(message: string): void;
+}
+export declare function createClackSpinner(): KtxCliSpinner;

package/dist/clack.js

@@ -0,0 +1,4 @@
+import { spinner } from '@clack/prompts';
+export function createClackSpinner() {
+    return spinner();
+}

package/dist/cli-program.d.ts

@@ -0,0 +1,43 @@
+import type { KtxCliDeps, KtxCliIo, KtxCliPackageInfo } from './cli-runtime.js';
+export interface KtxCliCommandContext {
+    io: KtxCliIo;
+    deps: KtxCliDeps;
+    packageInfo: KtxCliPackageInfo;
+    setExitCode: (code: number) => void;
+    runInit: (args: {
+        projectDir: string;
+        projectName?: string;
+        force: boolean;
+    }, io: KtxCliIo) => Promise<number>;
+    writeDebug?: (command: string, commandContext: CommandWithGlobalOptions) => void;
+}
+export interface OutputModeOptions {
+    plain?: boolean;
+    json?: boolean;
+    viz?: boolean;
+    input?: boolean;
+}
+interface KtxCommanderProgramOptions {
+    runInit: (args: {
+        projectDir: string;
+        projectName?: string;
+        force: boolean;
+    }, io: KtxCliIo) => Promise<number>;
+}
+export interface CommandWithGlobalOptions {
+    opts: () => object;
+    optsWithGlobals?: () => object;
+}
+export declare function collectOption(value: string, previous?: string[]): string[];
+export declare function parsePositiveIntegerOption(value: string): number;
+export declare function parseNonNegativeIntegerOption(value: string): number;
+export declare function parseBooleanStringOption(value: string): boolean;
+export declare function parseSafeConnectionIdOption(value: string): string;
+export declare function parseNonEmptyAssignmentOption(value: string): {
+    key: string;
+    value: string;
+};
+export declare function resolveCommandProjectDir(command: CommandWithGlobalOptions): string;
+export declare function resolveCommandProjectDirOverride(command: CommandWithGlobalOptions): string | undefined;
+export declare function runCommanderKtxCli(argv: string[], io: KtxCliIo, deps: KtxCliDeps, info: KtxCliPackageInfo, options: KtxCommanderProgramOptions): Promise<number>;
+export {};