@kaelio/ktx 0.0.0 → 0.1.0-rc.1

package/dist/commands/setup-commands.js

@@ -0,0 +1,347 @@
+import { InvalidArgumentError, Option } from '@commander-js/extra-typings';
+import { resolveCommandProjectDir } from '../cli-program.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 llmBackend(value) {
+    if (value === 'anthropic' || value === 'vertex' || value === 'claude-code') {
+        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 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.queryHistoryServiceAccountPattern && options.queryHistoryServiceAccountPattern.length > 0) {
+        return false;
+    }
+    if (options.queryHistoryRedactionPattern && options.queryHistoryRedactionPattern.length > 0) {
+        return false;
+    }
+    if (options.notionRootPageId && options.notionRootPageId.length > 0) {
+        return false;
+    }
+    return ![
+        'new',
+        'existing',
+        'agents',
+        'target',
+        'global',
+        'local',
+        'skipAgents',
+        'yes',
+        'input',
+        'llmBackend',
+        'anthropicApiKeyEnv',
+        'anthropicApiKeyFile',
+        'anthropicModel',
+        'vertexProject',
+        'vertexLocation',
+        'skipLlm',
+        'embeddingBackend',
+        'embeddingApiKeyEnv',
+        'embeddingApiKeyFile',
+        'skipEmbeddings',
+        'newDatabaseConnectionId',
+        'databaseUrl',
+        'enableQueryHistory',
+        'disableQueryHistory',
+        'queryHistoryWindowDays',
+        'queryHistoryMinExecutions',
+        'skipDatabases',
+        'source',
+        'sourceConnectionId',
+        'sourcePath',
+        'sourceGitUrl',
+        'sourceBranch',
+        'sourceSubpath',
+        'sourceAuthTokenRef',
+        'sourceUrl',
+        'sourceApiKeyRef',
+        'sourceClientId',
+        'sourceClientSecretRef',
+        'sourceWarehouseConnectionId',
+        'sourceProjectName',
+        'sourceProfilesPath',
+        'sourceTarget',
+        'metabaseDatabaseId',
+        'notionCrawlMode',
+        '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')
+        .addOption(new Option('--project-dir <path>', 'KTX project directory').hideHelp())
+        .addOption(new Option('--new', 'Create a new KTX project before setup').hideHelp().default(false))
+        .addOption(new Option('--existing', 'Use an existing KTX project').hideHelp().default(false))
+        .option('--agents', 'Install agent integration only', false)
+        .addOption(new Option('--target <target>', 'Agent target').choices([
+        'claude-code',
+        'codex',
+        'cursor',
+        'opencode',
+        'universal',
+    ]))
+        .option('--global', 'Install agent integration into the global target scope', false)
+        .option('--local', 'Install Claude Code MCP config into the private per-project ~/.claude.json scope', false)
+        .addOption(new Option('--skip-agents', 'Leave agent integration incomplete for now').hideHelp().default(false))
+        .option('--yes', 'Accept safe defaults in non-interactive setup', false)
+        .option('--no-input', 'Disable interactive terminal input')
+        .addOption(new Option('--llm-backend <backend>', 'LLM backend').argParser(llmBackend).hideHelp())
+        .addOption(new Option('--anthropic-api-key-env <name>', 'Environment variable containing the Anthropic API key').hideHelp())
+        .addOption(new Option('--anthropic-api-key-file <path>', 'File containing the Anthropic API key').hideHelp())
+        .addOption(new Option('--anthropic-model <model>', 'Anthropic model ID to validate and save').hideHelp())
+        .addOption(new Option('--vertex-project <project>', 'Google Vertex AI project ID, env:NAME, or file:/path').hideHelp())
+        .addOption(new Option('--vertex-location <location>', 'Google Vertex AI location, env:NAME, or file:/path').hideHelp())
+        .addOption(new Option('--skip-llm', 'Leave LLM setup incomplete for now').hideHelp().default(false))
+        .addOption(new Option('--embedding-backend <backend>', 'Embedding backend').argParser(embeddingBackend).hideHelp())
+        .addOption(new Option('--embedding-api-key-env <name>', 'Environment variable containing the embedding provider API key').hideHelp())
+        .addOption(new Option('--embedding-api-key-file <path>', 'File containing the embedding provider API key').hideHelp())
+        .addOption(new Option('--skip-embeddings', 'Leave embedding setup incomplete for now').hideHelp().default(false))
+        .addOption(new Option('--database <driver>', 'Database driver to configure; repeatable')
+        .argParser((value, previous) => {
+        return [...previous, databaseDriver(value)];
+    })
+        .default([])
+        .hideHelp())
+        .addOption(new Option('--database-connection-id <id>', 'Existing selected connection id or new connection id')
+        .argParser((value, previous) => [...previous, value])
+        .default([])
+        .hideHelp())
+        .addOption(new Option('--new-database-connection-id <id>', 'Connection id for one new database connection')
+        .argParser((value) => {
+        if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value)) {
+            throw new InvalidArgumentError(`Unsafe connection id: ${value}`);
+        }
+        return value;
+    })
+        .hideHelp())
+        .addOption(new Option('--database-url <url>', 'URL, env:NAME, or file:/path for one new URL-style database connection').hideHelp())
+        .addOption(new Option('--database-schema <schema>', 'Database schema to include; repeatable')
+        .argParser((value, previous) => [...previous, value])
+        .default([])
+        .hideHelp())
+        .addOption(new Option('--enable-query-history', 'Enable query history when the selected database supports it')
+        .hideHelp()
+        .default(false))
+        .addOption(new Option('--disable-query-history', 'Disable query history for the selected database').hideHelp().default(false))
+        .addOption(new Option('--query-history-window-days <number>', 'Query-history lookback window')
+        .argParser(positiveInteger)
+        .hideHelp())
+        .addOption(new Option('--query-history-min-executions <number>', 'Minimum executions for a query-history template')
+        .argParser(positiveInteger)
+        .hideHelp())
+        .addOption(new Option('--query-history-service-account-pattern <pattern>', 'Query-history service-account regex; repeatable')
+        .argParser((value, previous) => [...previous, value])
+        .default([])
+        .hideHelp())
+        .addOption(new Option('--query-history-redaction-pattern <pattern>', 'Query-history SQL-literal redaction regex; repeatable')
+        .argParser((value, previous) => [...previous, value])
+        .default([])
+        .hideHelp())
+        .addOption(new Option('--skip-databases', 'Leave database setup incomplete; KTX cannot work until a database is added')
+        .hideHelp()
+        .default(false))
+        .addOption(new Option('--source <type>', 'Source connector type').argParser(sourceType).hideHelp())
+        .addOption(new Option('--source-connection-id <id>', 'Connection id for source setup').hideHelp())
+        .addOption(new Option('--source-path <path>', 'Local source path for dbt, MetricFlow, or LookML').hideHelp())
+        .addOption(new Option('--source-git-url <url>', 'Git URL for dbt, MetricFlow, or LookML').hideHelp())
+        .addOption(new Option('--source-branch <branch>', 'Git branch for source setup').hideHelp())
+        .addOption(new Option('--source-subpath <path>', 'Repo subpath for source setup').hideHelp())
+        .addOption(new Option('--source-auth-token-ref <ref>', 'env: or file: credential ref for source repo auth').hideHelp())
+        .addOption(new Option('--source-url <url>', 'Source service URL for Metabase or Looker').hideHelp())
+        .addOption(new Option('--source-api-key-ref <ref>', 'env: or file: API key ref for Metabase or Notion').hideHelp())
+        .addOption(new Option('--source-client-id <id>', 'Looker client id').hideHelp())
+        .addOption(new Option('--source-client-secret-ref <ref>', 'env: or file: Looker client secret ref').hideHelp())
+        .addOption(new Option('--source-warehouse-connection-id <id>', 'Mapped warehouse connection id').hideHelp())
+        .addOption(new Option('--source-project-name <name>', 'dbt project name override').hideHelp())
+        .addOption(new Option('--source-profiles-path <path>', 'dbt profiles path').hideHelp())
+        .addOption(new Option('--source-target <target>', 'dbt target or source-specific mapping target').hideHelp())
+        .addOption(new Option('--metabase-database-id <id>', 'Metabase database id to map').argParser(positiveNumber).hideHelp())
+        .addOption(new Option('--notion-crawl-mode <mode>', 'Notion crawl mode')
+        .choices(['all_accessible', 'selected_roots'])
+        .hideHelp())
+        .addOption(new Option('--notion-root-page-id <id>', 'Notion root page id; repeatable')
+        .argParser((value, previous) => [...previous, value])
+        .default([])
+        .hideHelp())
+        .addOption(new Option('--skip-sources', 'Mark optional source setup complete with no sources').hideHelp().default(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.llmBackend &&
+            options.llmBackend !== 'anthropic' &&
+            (options.anthropicApiKeyEnv || options.anthropicApiKeyFile)) {
+            context.io.stderr.write('Anthropic API key flags are only valid with --llm-backend anthropic.\n');
+            context.setExitCode(1);
+            return;
+        }
+        if (options.llmBackend && options.llmBackend !== 'vertex' && (options.vertexProject || options.vertexLocation)) {
+            context.io.stderr.write('Vertex AI flags are only valid with --llm-backend vertex.\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.enableQueryHistory && options.disableQueryHistory) {
+            context.io.stderr.write('Choose only one query-history action: --enable-query-history or --disable-query-history.\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;
+        }
+        if (options.local && options.global) {
+            context.io.stderr.write('Choose only one agent scope: --local or --global.\n');
+            context.setExitCode(1);
+            return;
+        }
+        if (options.local && options.target && options.target !== 'claude-code') {
+            context.io.stderr.write('--local is only supported with --target claude-code.\n');
+            context.setExitCode(1);
+            return;
+        }
+        const mode = options.new ? 'new' : options.existing ? 'existing' : 'auto';
+        const resolvedAgentScope = options.local ? 'local' : options.global ? 'global' : 'project';
+        await runSetupArgs(context, {
+            command: 'run',
+            projectDir: resolveCommandProjectDir(command),
+            mode,
+            agents: options.agents === true,
+            ...(options.target ? { target: options.target } : {}),
+            agentScope: resolvedAgentScope,
+            skipAgents: options.skipAgents === true,
+            inputMode: options.input === false ? 'disabled' : 'auto',
+            yes: options.yes === true,
+            cliVersion: context.packageInfo.version,
+            ...(options.llmBackend ? { llmBackend: options.llmBackend } : {}),
+            ...(options.anthropicApiKeyEnv ? { anthropicApiKeyEnv: options.anthropicApiKeyEnv } : {}),
+            ...(options.anthropicApiKeyFile ? { anthropicApiKeyFile: options.anthropicApiKeyFile } : {}),
+            ...(options.anthropicModel ? { anthropicModel: options.anthropicModel } : {}),
+            ...(options.vertexProject ? { vertexProject: options.vertexProject } : {}),
+            ...(options.vertexLocation ? { vertexLocation: options.vertexLocation } : {}),
+            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.enableQueryHistory ? { enableQueryHistory: true } : {}),
+            ...(options.disableQueryHistory ? { disableQueryHistory: true } : {}),
+            ...(options.queryHistoryWindowDays !== undefined ? { queryHistoryWindowDays: options.queryHistoryWindowDays } : {}),
+            ...(options.queryHistoryMinExecutions !== undefined
+                ? { queryHistoryMinExecutions: options.queryHistoryMinExecutions }
+                : {}),
+            ...(options.queryHistoryServiceAccountPattern.length > 0
+                ? { queryHistoryServiceAccountPatterns: options.queryHistoryServiceAccountPattern }
+                : {}),
+            ...(options.queryHistoryRedactionPattern.length > 0
+                ? { queryHistoryRedactionPatterns: options.queryHistoryRedactionPattern }
+                : {}),
+            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),
+        });
+    });
+}

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,130 @@
+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, search, validate, or query 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('search')
+        .description('Search semantic-layer sources')
+        .argument('<query>', 'Search query')
+        .option('--connection-id <id>', 'KTX connection id')
+        .option('--limit <number>', 'Maximum search results', parsePositiveIntegerOption)
+        .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 (query, options, command) => {
+        await runSlArgs(context, {
+            command: 'search',
+            projectDir: resolveCommandProjectDir(command),
+            connectionId: options.connectionId,
+            query,
+            ...(options.limit !== undefined ? { limit: options.limit } : {}),
+            output: options.output,
+            json: options.json,
+        });
+    });
+    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('query')
+        .description('Compile or execute a semantic-layer query')
+        .option('--connection-id <id>', 'KTX connection id')
+        .option('--query-file <path>', 'JSON semantic-layer query file')
+        .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 && !options.queryFile) {
+            throw new Error('sl query requires at least one --measure');
+        }
+        const args = slQueryCommandSchema.parse({
+            command: 'query',
+            projectDir: resolveCommandProjectDir(command),
+            connectionId: options.connectionId,
+            ...(options.queryFile
+                ? { queryFile: options.queryFile }
+                : {
+                    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,47 @@
+import { resolveCommandProjectDir, resolveCommandProjectDirOverride } from '../cli-program.js';
+import { findNearestKtxProjectDir } from '../project-resolver.js';
+function outputMode(options) {
+    return options.json === true ? 'json' : 'plain';
+}
+function inputMode(options) {
+    return options.input === false ? { inputMode: 'disabled' } : {};
+}
+export function registerStatusCommands(program, context) {
+    program
+        .command('status')
+        .description('Check current KTX setup and project readiness')
+        .option('--json', 'Print JSON output', false)
+        .option('-v, --verbose', 'Show every check, including passing ones', false)
+        .option('--validate', 'Only validate the ktx.yaml schema; skip readiness checks', false)
+        .option('--no-input', 'Disable interactive terminal input')
+        .action(async (options, command) => {
+        const runner = context.deps.doctor ?? (await import('../doctor.js')).runKtxDoctor;
+        const explicitOrEnvProjectDir = resolveCommandProjectDirOverride(command);
+        const nearestProjectDir = explicitOrEnvProjectDir ? undefined : findNearestKtxProjectDir(process.cwd());
+        if (options.validate === true) {
+            context.setExitCode(await runner({
+                command: 'validate',
+                projectDir: resolveCommandProjectDir(command),
+                outputMode: outputMode(options),
+                ...inputMode(options),
+            }, context.io));
+            return;
+        }
+        if (!explicitOrEnvProjectDir && !nearestProjectDir) {
+            context.setExitCode(await runner({
+                command: 'setup',
+                outputMode: outputMode(options),
+                verbose: options.verbose === true,
+                ...inputMode(options),
+            }, context.io));
+            return;
+        }
+        context.setExitCode(await runner({
+            command: 'project',
+            projectDir: resolveCommandProjectDir(command),
+            outputMode: outputMode(options),
+            verbose: options.verbose === true,
+            ...inputMode(options),
+        }, context.io));
+    });
+}

package/dist/connection.d.ts

@@ -0,0 +1,28 @@
+import { type LookerClient, type MetabaseRuntimeClient, NotionClient, testRepoConnection } from '@ktx/context/ingest';
+import { type KtxLocalProject } from '@ktx/context/project';
+import type { KtxCliIo } from './index.js';
+import { createKtxCliScanConnector } from './local-scan-connectors.js';
+export type KtxConnectionArgs = {
+    command: 'list';
+    projectDir: string;
+} | {
+    command: 'test';
+    projectDir: string;
+    connectionId: string;
+} | {
+    command: 'test-all';
+    projectDir: string;
+};
+type MetabaseTestPort = Pick<MetabaseRuntimeClient, 'testConnection' | 'getDatabases' | 'cleanup'>;
+type LookerTestPort = Pick<LookerClient, 'testConnection'>;
+type NotionTestPort = Pick<NotionClient, 'retrieveBotUser'>;
+type TestRepoConnection = typeof testRepoConnection;
+export interface KtxConnectionDeps {
+    createScanConnector?: typeof createKtxCliScanConnector;
+    createMetabaseClient?: (project: KtxLocalProject, connectionId: string) => Promise<MetabaseTestPort>;
+    createLookerClient?: (project: KtxLocalProject, connectionId: string) => Promise<LookerTestPort>;
+    createNotionClient?: (project: KtxLocalProject, connectionId: string) => Promise<NotionTestPort>;
+    testRepoConnection?: TestRepoConnection;
+}
+export declare function runKtxConnection(args: KtxConnectionArgs, io?: KtxCliIo, deps?: KtxConnectionDeps): Promise<number>;
+export {};