@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/dist/commands/serve-commands.js

@@ -0,0 +1,48 @@
+import { InvalidArgumentError } from '@commander-js/extra-typings';
+import { resolveCommandProjectDir } from '../cli-program.js';
+import { runtimeInstallPolicyFromFlags } from '../managed-python-command.js';
+import { profileMark } from '../startup-profile.js';
+profileMark('module:commands/serve-commands');
+function parseMcp(value) {
+    if (value === 'stdio') {
+        return 'stdio';
+    }
+    throw new InvalidArgumentError('Only stdio is supported in this phase');
+}
+export function registerServeCommands(program, context) {
+    program
+        .command('serve')
+        .description('Run standalone KTX services such as MCP stdio')
+        .requiredOption('--mcp <mode>', 'MCP transport mode', parseMcp)
+        .option('--user-id <id>', 'Local user id', 'local')
+        .option('--semantic-compute', 'Enable semantic-layer compute', false)
+        .option('--semantic-compute-url <url>', 'HTTP semantic-layer compute URL')
+        .option('--yes', 'Install the managed Python runtime without prompting when required', false)
+        .option('--no-input', 'Disable interactive managed runtime installation')
+        .option('--database-introspection-url <url>', 'Daemon URL for live-database introspection')
+        .option('--execute-queries', 'Allow semantic-layer query execution', false)
+        .option('--memory-capture', 'Enable memory capture', false)
+        .option('--memory-model <model>', 'Memory capture model')
+        .showHelpAfterError()
+        .action(async (options, command) => {
+        const semanticCompute = options.semanticCompute === true || Boolean(options.semanticComputeUrl);
+        if (options.executeQueries === true && !semanticCompute) {
+            throw new Error('--execute-queries requires --semantic-compute');
+        }
+        const args = {
+            mcp: options.mcp,
+            projectDir: resolveCommandProjectDir(command),
+            userId: options.userId,
+            semanticCompute,
+            semanticComputeUrl: options.semanticComputeUrl,
+            databaseIntrospectionUrl: options.databaseIntrospectionUrl,
+            executeQueries: options.executeQueries === true,
+            memoryCapture: options.memoryCapture === true,
+            memoryModel: options.memoryModel,
+            cliVersion: context.packageInfo.version,
+            runtimeInstallPolicy: runtimeInstallPolicyFromFlags(options),
+        };
+        const runner = context.deps.serveStdio ?? (await import('../serve.js')).runKtxServeStdio;
+        context.setExitCode(await runner(args));
+    });
+}

package/dist/commands/setup-commands.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '@commander-js/extra-typings';
+import type { KtxCliCommandContext } from '../cli-program.js';
+export declare function registerSetupCommands(program: Command, context: KtxCliCommandContext): void;

package/dist/commands/setup-commands.js

@@ -0,0 +1,378 @@
+import { InvalidArgumentError, Option } from '@commander-js/extra-typings';
+import { resolveCommandProjectDir } from '../cli-program.js';
+import { registerDemoCommands } from './demo-commands.js';
+async function runSetupArgs(context, args) {
+    const runner = context.deps.setup ?? (await import('../setup.js')).runKtxSetup;
+    context.setExitCode(await runner(args, context.io));
+}
+function positiveInteger(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`Expected a positive integer, received ${value}`);
+    }
+    return parsed;
+}
+function embeddingBackend(value) {
+    if (value === 'openai' || value === 'sentence-transformers') {
+        return value;
+    }
+    throw new InvalidArgumentError(`invalid choice '${value}'`);
+}
+function databaseDriver(value) {
+    if (value === 'sqlite' ||
+        value === 'postgres' ||
+        value === 'mysql' ||
+        value === 'clickhouse' ||
+        value === 'sqlserver' ||
+        value === 'bigquery' ||
+        value === 'snowflake') {
+        return value;
+    }
+    throw new InvalidArgumentError(`invalid choice '${value}'`);
+}
+function sourceType(value) {
+    if (value === 'dbt' ||
+        value === 'metricflow' ||
+        value === 'metabase' ||
+        value === 'looker' ||
+        value === 'lookml' ||
+        value === 'notion') {
+        return value;
+    }
+    throw new InvalidArgumentError(`invalid choice '${value}'`);
+}
+function agentScope(value) {
+    if (value === 'project' || value === 'global') {
+        return value;
+    }
+    throw new InvalidArgumentError(`invalid choice '${value}'`);
+}
+function agentInstallMode(value) {
+    if (value === 'cli' || value === 'mcp' || value === 'both') {
+        return value;
+    }
+    throw new InvalidArgumentError(`invalid choice '${value}'`);
+}
+function positiveNumber(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new InvalidArgumentError(`Expected a positive integer, received ${value}`);
+    }
+    return parsed;
+}
+function optionWasSpecified(command, optionName) {
+    const commandWithSources = command;
+    const source = commandWithSources.getOptionValueSourceWithGlobals?.(optionName) ??
+        commandWithSources.getOptionValueSource?.(optionName);
+    return source !== undefined && source !== 'default';
+}
+function shouldShowSetupEntryMenu(options, command) {
+    if (options.database && options.database.length > 0) {
+        return false;
+    }
+    if (options.databaseConnectionId && options.databaseConnectionId.length > 0) {
+        return false;
+    }
+    if (options.databaseSchema && options.databaseSchema.length > 0) {
+        return false;
+    }
+    if (options.historicSqlServiceAccountPattern && options.historicSqlServiceAccountPattern.length > 0) {
+        return false;
+    }
+    if (options.historicSqlRedactionPattern && options.historicSqlRedactionPattern.length > 0) {
+        return false;
+    }
+    if (options.notionRootPageId && options.notionRootPageId.length > 0) {
+        return false;
+    }
+    return ![
+        'new',
+        'existing',
+        'agents',
+        'target',
+        'global',
+        'project',
+        'skipAgents',
+        'yes',
+        'input',
+        'anthropicApiKeyEnv',
+        'anthropicApiKeyFile',
+        'anthropicModel',
+        'skipLlm',
+        'embeddingBackend',
+        'embeddingApiKeyEnv',
+        'embeddingApiKeyFile',
+        'skipEmbeddings',
+        'newDatabaseConnectionId',
+        'databaseUrl',
+        'enableHistoricSql',
+        'disableHistoricSql',
+        'historicSqlWindowDays',
+        'historicSqlMinCalls',
+        'skipDatabases',
+        'source',
+        'sourceConnectionId',
+        'sourcePath',
+        'sourceGitUrl',
+        'sourceBranch',
+        'sourceSubpath',
+        'sourceAuthTokenRef',
+        'sourceUrl',
+        'sourceApiKeyRef',
+        'sourceClientId',
+        'sourceClientSecretRef',
+        'sourceWarehouseConnectionId',
+        'sourceProjectName',
+        'sourceProfilesPath',
+        'sourceTarget',
+        'metabaseDatabaseId',
+        'notionCrawlMode',
+        'skipInitialSourceIngest',
+        'skipSources',
+    ].some((optionName) => optionWasSpecified(command, optionName));
+}
+export function registerSetupCommands(program, context) {
+    const setup = program
+        .command('setup')
+        .description('Set up or resume a local KTX project')
+        .option('--project-dir <path>', 'KTX project directory')
+        .option('--new', 'Create a new KTX project before setup', false)
+        .option('--existing', 'Use an existing KTX project', false)
+        .option('--agents', 'Install agent integration only', false)
+        .addOption(new Option('--target <target>', 'Agent target').choices([
+        'claude-code',
+        'codex',
+        'cursor',
+        'opencode',
+        'universal',
+    ]))
+        .addOption(new Option('--agent-scope <scope>', 'Agent install scope').argParser(agentScope).default('project'))
+        .option('--project', 'Install agent integration into the project scope', false)
+        .option('--global', 'Install agent integration into the global target scope', false)
+        .addOption(new Option('--agent-install-mode <mode>', 'Agent install mode').argParser(agentInstallMode).default('cli'))
+        .option('--skip-agents', 'Leave agent integration incomplete for now', false)
+        .option('--yes', 'Accept safe defaults in non-interactive setup', false)
+        .option('--no-input', 'Disable interactive terminal input')
+        .option('--anthropic-api-key-env <name>', 'Environment variable containing the Anthropic API key')
+        .option('--anthropic-api-key-file <path>', 'File containing the Anthropic API key')
+        .option('--anthropic-model <model>', 'Anthropic model ID to validate and save')
+        .addOption(new Option('--skip-llm', 'Leave LLM setup incomplete for now').hideHelp().default(false))
+        .addOption(new Option('--embedding-backend <backend>', 'Embedding backend').argParser(embeddingBackend))
+        .option('--embedding-api-key-env <name>', 'Environment variable containing the embedding provider API key')
+        .option('--embedding-api-key-file <path>', 'File containing the embedding provider API key')
+        .addOption(new Option('--skip-embeddings', 'Leave embedding setup incomplete for now').hideHelp().default(false))
+        .option('--database <driver>', 'Database driver to configure; repeatable', (value, previous) => {
+        return [...previous, databaseDriver(value)];
+    }, [])
+        .option('--database-connection-id <id>', 'Existing selected connection id or new connection id', (value, previous) => [...previous, value], [])
+        .option('--new-database-connection-id <id>', 'Connection id for one new database connection', (value) => {
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value)) {
+            throw new InvalidArgumentError(`Unsafe connection id: ${value}`);
+        }
+        return value;
+    })
+        .option('--database-url <url>', 'URL, env:NAME, or file:/path for one new URL-style database connection')
+        .option('--database-schema <schema>', 'Database schema to include; repeatable', (value, previous) => [...previous, value], [])
+        .option('--enable-historic-sql', 'Enable Historic SQL when the selected database supports it', false)
+        .option('--disable-historic-sql', 'Disable Historic SQL for the selected database', false)
+        .option('--historic-sql-window-days <number>', 'Historic SQL query-history window', positiveInteger)
+        .option('--historic-sql-min-calls <number>', 'Postgres Historic SQL pg_stat_statements minimum calls floor', positiveInteger)
+        .option('--historic-sql-service-account-pattern <pattern>', 'Historic SQL service-account regex; repeatable', (value, previous) => [...previous, value], [])
+        .option('--historic-sql-redaction-pattern <pattern>', 'Historic SQL SQL-literal redaction regex; repeatable', (value, previous) => [...previous, value], [])
+        .option('--skip-databases', 'Leave database setup incomplete; KTX cannot work until a primary source is added', false)
+        .addOption(new Option('--source <type>', 'Source connector type').argParser(sourceType))
+        .option('--source-connection-id <id>', 'Connection id for source setup')
+        .option('--source-path <path>', 'Local source path for dbt, MetricFlow, or LookML')
+        .option('--source-git-url <url>', 'Git URL for dbt, MetricFlow, or LookML')
+        .option('--source-branch <branch>', 'Git branch for source setup')
+        .option('--source-subpath <path>', 'Repo subpath for source setup')
+        .option('--source-auth-token-ref <ref>', 'env: or file: credential ref for source repo auth')
+        .option('--source-url <url>', 'Source service URL for Metabase or Looker')
+        .option('--source-api-key-ref <ref>', 'env: or file: API key ref for Metabase or Notion')
+        .option('--source-client-id <id>', 'Looker client id')
+        .option('--source-client-secret-ref <ref>', 'env: or file: Looker client secret ref')
+        .option('--source-warehouse-connection-id <id>', 'Mapped warehouse connection id')
+        .option('--source-project-name <name>', 'dbt project name override')
+        .option('--source-profiles-path <path>', 'dbt profiles path')
+        .option('--source-target <target>', 'dbt target or source-specific mapping target')
+        .option('--metabase-database-id <id>', 'Metabase database id to map', positiveNumber)
+        .addOption(new Option('--notion-crawl-mode <mode>', 'Notion crawl mode').choices(['all_accessible', 'selected_roots']))
+        .option('--notion-root-page-id <id>', 'Notion root page id; repeatable', (value, previous) => [...previous, value], [])
+        .option('--skip-initial-source-ingest', 'Validate source setup without building source context during setup', false)
+        .option('--skip-sources', 'Mark optional source setup complete with no sources', false)
+        .showHelpAfterError();
+    setup.hook('preAction', (_thisCommand, actionCommand) => {
+        context.writeDebug?.('setup', actionCommand);
+    });
+    setup.action(async (options, command) => {
+        if (options.anthropicApiKeyEnv && options.anthropicApiKeyFile) {
+            context.io.stderr.write('Choose only one Anthropic credential source: --anthropic-api-key-env or --anthropic-api-key-file.\n');
+            context.setExitCode(1);
+            return;
+        }
+        if (options.embeddingApiKeyEnv && options.embeddingApiKeyFile) {
+            context.io.stderr.write('Choose only one embedding credential source: --embedding-api-key-env or --embedding-api-key-file.\n');
+            context.setExitCode(1);
+            return;
+        }
+        if (options.enableHistoricSql && options.disableHistoricSql) {
+            context.io.stderr.write('Choose only one Historic SQL action: --enable-historic-sql or --disable-historic-sql.\n');
+            context.setExitCode(1);
+            return;
+        }
+        if (options.sourcePath && options.sourceGitUrl) {
+            context.io.stderr.write('Choose only one source location: --source-path or --source-git-url.\n');
+            context.setExitCode(1);
+            return;
+        }
+        if (options.skipSources && options.source) {
+            context.io.stderr.write('Choose either --source or --skip-sources.\n');
+            context.setExitCode(1);
+            return;
+        }
+        const mode = options.new ? 'new' : options.existing ? 'existing' : 'auto';
+        const resolvedAgentScope = options.global ? 'global' : options.agentScope;
+        await runSetupArgs(context, {
+            command: 'run',
+            projectDir: resolveCommandProjectDir(command),
+            mode,
+            agents: options.agents === true,
+            ...(options.target ? { target: options.target } : {}),
+            agentScope: resolvedAgentScope,
+            agentInstallMode: options.agentInstallMode,
+            skipAgents: options.skipAgents === true,
+            inputMode: options.input === false ? 'disabled' : 'auto',
+            yes: options.yes === true,
+            cliVersion: context.packageInfo.version,
+            ...(options.anthropicApiKeyEnv ? { anthropicApiKeyEnv: options.anthropicApiKeyEnv } : {}),
+            ...(options.anthropicApiKeyFile ? { anthropicApiKeyFile: options.anthropicApiKeyFile } : {}),
+            ...(options.anthropicModel ? { anthropicModel: options.anthropicModel } : {}),
+            skipLlm: options.skipLlm === true,
+            ...(options.embeddingBackend ? { embeddingBackend: options.embeddingBackend } : {}),
+            ...(options.embeddingApiKeyEnv ? { embeddingApiKeyEnv: options.embeddingApiKeyEnv } : {}),
+            ...(options.embeddingApiKeyFile ? { embeddingApiKeyFile: options.embeddingApiKeyFile } : {}),
+            skipEmbeddings: options.skipEmbeddings === true,
+            ...(options.database.length > 0 ? { databaseDrivers: options.database } : {}),
+            ...(options.databaseConnectionId.length > 0 ? { databaseConnectionIds: options.databaseConnectionId } : {}),
+            ...(options.newDatabaseConnectionId ? { databaseConnectionId: options.newDatabaseConnectionId } : {}),
+            ...(options.databaseUrl ? { databaseUrl: options.databaseUrl } : {}),
+            databaseSchemas: options.databaseSchema,
+            ...(options.enableHistoricSql ? { enableHistoricSql: true } : {}),
+            ...(options.disableHistoricSql ? { disableHistoricSql: true } : {}),
+            ...(options.historicSqlWindowDays !== undefined ? { historicSqlWindowDays: options.historicSqlWindowDays } : {}),
+            ...(options.historicSqlMinCalls !== undefined ? { historicSqlMinCalls: options.historicSqlMinCalls } : {}),
+            ...(options.historicSqlServiceAccountPattern.length > 0
+                ? { historicSqlServiceAccountPatterns: options.historicSqlServiceAccountPattern }
+                : {}),
+            ...(options.historicSqlRedactionPattern.length > 0
+                ? { historicSqlRedactionPatterns: options.historicSqlRedactionPattern }
+                : {}),
+            skipDatabases: options.skipDatabases === true,
+            ...(options.source ? { source: options.source } : {}),
+            ...(options.sourceConnectionId ? { sourceConnectionId: options.sourceConnectionId } : {}),
+            ...(options.sourcePath ? { sourcePath: options.sourcePath } : {}),
+            ...(options.sourceGitUrl ? { sourceGitUrl: options.sourceGitUrl } : {}),
+            ...(options.sourceBranch ? { sourceBranch: options.sourceBranch } : {}),
+            ...(options.sourceSubpath ? { sourceSubpath: options.sourceSubpath } : {}),
+            ...(options.sourceAuthTokenRef ? { sourceAuthTokenRef: options.sourceAuthTokenRef } : {}),
+            ...(options.sourceUrl ? { sourceUrl: options.sourceUrl } : {}),
+            ...(options.sourceApiKeyRef ? { sourceApiKeyRef: options.sourceApiKeyRef } : {}),
+            ...(options.sourceClientId ? { sourceClientId: options.sourceClientId } : {}),
+            ...(options.sourceClientSecretRef ? { sourceClientSecretRef: options.sourceClientSecretRef } : {}),
+            ...(options.sourceWarehouseConnectionId
+                ? { sourceWarehouseConnectionId: options.sourceWarehouseConnectionId }
+                : {}),
+            ...(options.sourceProjectName ? { sourceProjectName: options.sourceProjectName } : {}),
+            ...(options.sourceProfilesPath ? { sourceProfilesPath: options.sourceProfilesPath } : {}),
+            ...(options.sourceTarget ? { sourceTarget: options.sourceTarget } : {}),
+            ...(options.metabaseDatabaseId !== undefined ? { metabaseDatabaseId: options.metabaseDatabaseId } : {}),
+            ...(options.notionCrawlMode ? { notionCrawlMode: options.notionCrawlMode } : {}),
+            ...(options.notionRootPageId.length > 0 ? { notionRootPageIds: options.notionRootPageId } : {}),
+            runInitialSourceIngest: false,
+            skipSources: options.skipSources === true,
+            showEntryMenu: shouldShowSetupEntryMenu(options, command),
+        });
+    });
+    registerDemoCommands(setup, context, { description: 'Run the packaged KTX demo from setup' });
+    const setupContext = setup.command('context').description('Build, inspect, and recover setup-managed KTX context');
+    function setupContextInputMode(command) {
+        const options = command.optsWithGlobals?.();
+        return options?.input === false ? 'disabled' : 'auto';
+    }
+    setupContext
+        .command('build')
+        .description('Build agent-ready KTX context for setup')
+        .option('--no-input', 'Disable interactive terminal input')
+        .action(async (options, command) => {
+        await runSetupArgs(context, {
+            command: 'context-build',
+            projectDir: resolveCommandProjectDir(command),
+            inputMode: options.input === false ? 'disabled' : setupContextInputMode(command),
+        });
+    });
+    setupContext
+        .command('watch')
+        .description('Watch a setup-managed context build')
+        .argument('[runId]', 'Setup context build run id')
+        .option('--no-input', 'Disable interactive terminal input')
+        .action(async (runId, options, command) => {
+        await runSetupArgs(context, {
+            command: 'context-watch',
+            projectDir: resolveCommandProjectDir(command),
+            ...(runId ? { runId } : {}),
+            inputMode: options.input === false ? 'disabled' : setupContextInputMode(command),
+        });
+    });
+    setupContext
+        .command('status')
+        .description('Print setup-managed context build status')
+        .argument('[runId]', 'Setup context build run id')
+        .option('--json', 'Print JSON output', false)
+        .action(async (runId, options, command) => {
+        await runSetupArgs(context, {
+            command: 'context-status',
+            projectDir: resolveCommandProjectDir(command),
+            ...(runId ? { runId } : {}),
+            json: options.json === true,
+        });
+    });
+    setupContext
+        .command('stop')
+        .description('Request a pause for a setup-managed context build')
+        .argument('[runId]', 'Setup context build run id')
+        .option('--force', 'Request the pause without an interactive confirmation', false)
+        .action(async (runId, _options, command) => {
+        await runSetupArgs(context, {
+            command: 'context-stop',
+            projectDir: resolveCommandProjectDir(command),
+            ...(runId ? { runId } : {}),
+        });
+    });
+    setup
+        .command('remove')
+        .description('Remove setup-managed local integrations')
+        .option('--agents', 'Remove setup-managed agent integration files', false)
+        .action(async (options, command) => {
+        const parentOptions = command.parent?.opts();
+        if (options.agents !== true && parentOptions?.agents !== true) {
+            context.io.stderr.write('Choose what to remove: --agents.\n');
+            context.setExitCode(1);
+            return;
+        }
+        await runSetupArgs(context, {
+            command: 'remove-agents',
+            projectDir: resolveCommandProjectDir(command),
+        });
+    });
+    setup
+        .command('status')
+        .description('Show setup readiness for the resolved KTX project')
+        .option('--json', 'Print JSON output', false)
+        .action(async (options, command) => {
+        await runSetupArgs(context, {
+            command: 'status',
+            projectDir: resolveCommandProjectDir(command),
+            json: options.json === true,
+        });
+    });
+}

package/dist/commands/sl-commands.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '@commander-js/extra-typings';
+import { type KtxCliCommandContext } from '../cli-program.js';
+export declare function registerSlCommands(program: Command, context: KtxCliCommandContext, commandName?: string): void;

package/dist/commands/sl-commands.js

@@ -0,0 +1,129 @@
+import { InvalidArgumentError, Option } from '@commander-js/extra-typings';
+import { collectOption, parsePositiveIntegerOption, resolveCommandProjectDir, } from '../cli-program.js';
+import { slQueryCommandSchema } from '../command-schemas.js';
+import { runtimeInstallPolicyFromFlags } from '../managed-python-command.js';
+import { profileMark } from '../startup-profile.js';
+profileMark('module:commands/sl-commands');
+function parseOrderBy(value) {
+    const [field, direction] = value.split(':');
+    if (!field) {
+        throw new InvalidArgumentError('requires a field');
+    }
+    if (!direction) {
+        return field;
+    }
+    if (direction !== 'asc' && direction !== 'desc') {
+        throw new InvalidArgumentError('direction must be asc or desc');
+    }
+    return { field, direction };
+}
+function collectOrderBy(value, previous = []) {
+    return [...previous, parseOrderBy(value)];
+}
+async function runSlArgs(context, args) {
+    const runner = context.deps.sl ?? (await import('../sl.js')).runKtxSl;
+    context.setExitCode(await runner(args, context.io));
+}
+export function registerSlCommands(program, context, commandName = 'sl') {
+    const sl = program
+        .command(commandName)
+        .description('List, read, validate, query, or write local semantic-layer sources')
+        .showHelpAfterError()
+        .addHelpText('after', '\nProject directory defaults to KTX_PROJECT_DIR when set, otherwise the current working directory.\n');
+    sl.command('list')
+        .description('List semantic-layer sources')
+        .option('--connection-id <id>', 'KTX connection id')
+        .addOption(new Option('--output <mode>', 'Output mode: pretty (default in TTY), plain (TSV), or json').choices([
+        'pretty',
+        'plain',
+        'json',
+    ]))
+        .option('--json', 'Shortcut for --output=json (overrides --output)', false)
+        .action(async (options, command) => {
+        await runSlArgs(context, {
+            command: 'list',
+            projectDir: resolveCommandProjectDir(command),
+            connectionId: options.connectionId,
+            output: options.output,
+            json: options.json,
+        });
+    });
+    sl.command('read')
+        .description('Read a semantic-layer source')
+        .argument('<sourceName>', 'Semantic-layer source name')
+        .requiredOption('--connection-id <id>', 'KTX connection id')
+        .action(async (sourceName, options, command) => {
+        await runSlArgs(context, {
+            command: 'read',
+            projectDir: resolveCommandProjectDir(command),
+            connectionId: options.connectionId,
+            sourceName,
+        });
+    });
+    sl.command('validate')
+        .description('Validate a semantic-layer source')
+        .argument('<sourceName>', 'Semantic-layer source name')
+        .requiredOption('--connection-id <id>', 'KTX connection id')
+        .action(async (sourceName, options, command) => {
+        await runSlArgs(context, {
+            command: 'validate',
+            projectDir: resolveCommandProjectDir(command),
+            connectionId: options.connectionId,
+            sourceName,
+        });
+    });
+    sl.command('write')
+        .description('Write a semantic-layer source')
+        .argument('<sourceName>', 'Semantic-layer source name')
+        .requiredOption('--connection-id <id>', 'KTX connection id')
+        .requiredOption('--yaml <yaml>', 'Semantic-layer source YAML')
+        .action(async (sourceName, options, command) => {
+        await runSlArgs(context, {
+            command: 'write',
+            projectDir: resolveCommandProjectDir(command),
+            connectionId: options.connectionId,
+            sourceName,
+            yaml: options.yaml,
+        });
+    });
+    sl.command('query')
+        .description('Compile or execute a semantic-layer query')
+        .option('--connection-id <id>', 'KTX connection id')
+        .option('--measure <measure>', 'Measure to query; repeatable', collectOption, [])
+        .option('--dimension <dimension>', 'Dimension to include; repeatable', collectOption, [])
+        .option('--filter <filter>', 'Filter expression; repeatable', collectOption, [])
+        .option('--segment <segment>', 'Segment to include; repeatable', collectOption, [])
+        .option('--order-by <field[:direction]>', 'Order field, optionally suffixed with :asc or :desc', collectOrderBy, [])
+        .option('--limit <n>', 'Query limit', parsePositiveIntegerOption)
+        .option('--include-empty', 'Include empty rows', false)
+        .addOption(new Option('--format <format>', 'json or sql').choices(['json', 'sql']).default('json'))
+        .option('--execute', 'Execute the compiled query', false)
+        .option('--yes', 'Install the managed Python runtime without prompting when required', false)
+        .option('--no-input', 'Disable interactive managed runtime installation')
+        .option('--max-rows <n>', 'Maximum rows to return when executing', parsePositiveIntegerOption)
+        .action(async (options, command) => {
+        if (options.measure.length === 0) {
+            throw new Error('sl query requires at least one --measure');
+        }
+        const args = slQueryCommandSchema.parse({
+            command: 'query',
+            projectDir: resolveCommandProjectDir(command),
+            connectionId: options.connectionId,
+            query: {
+                measures: options.measure,
+                dimensions: options.dimension,
+                ...(options.filter.length > 0 ? { filters: options.filter } : {}),
+                ...(options.segment.length > 0 ? { segments: options.segment } : {}),
+                ...(options.orderBy.length > 0 ? { order_by: options.orderBy } : {}),
+                ...(options.limit !== undefined ? { limit: options.limit } : {}),
+                ...(options.includeEmpty === true ? { include_empty: true } : {}),
+            },
+            format: options.format,
+            execute: options.execute === true,
+            cliVersion: context.packageInfo.version,
+            runtimeInstallPolicy: runtimeInstallPolicyFromFlags(options),
+            ...(options.maxRows !== undefined ? { maxRows: options.maxRows } : {}),
+        });
+        await runSlArgs(context, args);
+    });
+}

package/dist/commands/status-commands.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from '@commander-js/extra-typings';
+import type { KtxCliCommandContext } from '../cli-program.js';
+export declare function registerStatusCommands(program: Command, context: KtxCliCommandContext): void;

package/dist/commands/status-commands.js

@@ -0,0 +1,15 @@
+import { resolveCommandProjectDir } from '../cli-program.js';
+export function registerStatusCommands(program, context) {
+    program
+        .command('status')
+        .description('Show current KTX project setup status')
+        .option('--json', 'Print JSON output', false)
+        .action(async (options, command) => {
+        const runner = context.deps.setup ?? (await import('../setup.js')).runKtxSetup;
+        context.setExitCode(await runner({
+            command: 'status',
+            projectDir: resolveCommandProjectDir(command),
+            json: options.json === true,
+        }, context.io));
+    });
+}

package/dist/completion.d.ts

@@ -0,0 +1,12 @@
+import type { CommandUnknownOpts } from '@commander-js/extra-typings';
+export interface CompletionRequest {
+    position: number;
+    words: string[];
+}
+export interface ZshCompletionInstallResult {
+    completionPath: string;
+    zshrcPath: string;
+}
+export declare function zshCompletionScript(): string;
+export declare function installZshCompletion(): Promise<ZshCompletionInstallResult>;
+export declare function completeCommanderInput(program: CommandUnknownOpts, request: CompletionRequest): string[];