@kaelio/ktx 0.4.1 → 0.6.0

package/dist/llm/types.d.ts

@@ -0,0 +1,106 @@
+import type { LanguageModel, TelemetrySettings, ToolCallRepairFunction, ToolSet } from 'ai';
+export declare const KTX_MODEL_ROLES: readonly ["default", "triage", "candidateExtraction", "curator", "reconcile", "repair"];
+export type KtxModelRole = (typeof KTX_MODEL_ROLES)[number];
+type KtxLlmBackend = 'anthropic' | 'vertex' | 'gateway' | 'claude-code';
+export type KtxPromptCacheTtl = '5m' | '1h';
+type KtxJsonValue = null | string | number | boolean | KtxJsonValue[] | {
+    [key: string]: KtxJsonValue | undefined;
+};
+export type KtxProviderOptions = Record<string, {
+    [key: string]: KtxJsonValue | undefined;
+}>;
+export interface KtxPromptCachingConfig {
+    enabled: boolean;
+    systemTtl: KtxPromptCacheTtl;
+    toolsTtl: KtxPromptCacheTtl;
+    historyTtl: KtxPromptCacheTtl;
+    cacheSystem: boolean;
+    cacheTools: boolean;
+    cacheHistory: boolean;
+    vertexFallbackTo5m: boolean;
+}
+interface KtxTokenUsageEvent {
+    source?: string;
+    modelId?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface KtxLlmConfig {
+    backend: KtxLlmBackend;
+    vertex?: {
+        project?: string;
+        location: string;
+    };
+    anthropic?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    gateway?: {
+        baseURL?: string;
+        apiKey?: string;
+    };
+    modelSlots: {
+        default: string;
+    } & Partial<Record<KtxModelRole, string>>;
+    promptCaching?: Partial<KtxPromptCachingConfig>;
+    telemetry?: {
+        experimentalTelemetry?: TelemetrySettings;
+        onTokenUsage?: (event: KtxTokenUsageEvent) => void;
+    };
+}
+export interface KtxLlmProvider {
+    getModel(role: KtxModelRole): LanguageModel;
+    getModelByName(modelId: string): LanguageModel;
+    cacheMarker(ttl: KtxPromptCacheTtl, model?: LanguageModel | string): {
+        anthropic: {
+            cacheControl: {
+                type: 'ephemeral';
+                ttl: KtxPromptCacheTtl;
+            };
+        };
+    } | undefined;
+    repairToolCallHandler(options?: {
+        source?: string;
+    }): ToolCallRepairFunction<ToolSet>;
+    thinkingProviderOptions(role: KtxModelRole, budgetTokens: number): KtxProviderOptions;
+    telemetryConfig(): TelemetrySettings | undefined;
+    promptCachingConfig(): KtxPromptCachingConfig;
+    activeBackend(): KtxLlmBackend;
+}
+type KtxEmbeddingBackend = 'openai' | 'sentence-transformers';
+interface KtxEmbeddingTokenUsageEvent {
+    backend: KtxEmbeddingBackend;
+    model: string;
+    inputCount: number;
+    totalTokens?: number;
+}
+export interface KtxEmbeddingConfig {
+    backend: KtxEmbeddingBackend;
+    model: string;
+    dimensions: number;
+    openai?: {
+        apiKey?: string;
+        baseURL?: string;
+    };
+    sentenceTransformers?: {
+        baseURL: string;
+        pathPrefix?: string;
+    };
+    batchSize?: number;
+    telemetry?: {
+        onTokenUsage?: (event: KtxEmbeddingTokenUsageEvent) => void;
+    };
+}
+export interface KtxEmbeddingProvider {
+    readonly dimensions: number;
+    readonly maxBatchSize: number;
+    embed(text: string): Promise<number[]>;
+    embedMany(texts: string[]): Promise<number[][]>;
+}
+export interface KtxPromptParts {
+    staticSystem: string;
+    dynamicSystem?: string;
+    leadingUserContext?: string;
+}
+export {};

package/dist/local-adapters.d.ts

@@ -1,6 +1,7 @@
-import { type DefaultLocalIngestAdaptersOptions, type SourceAdapter } from '@ktx/context/ingest';
-import type { KtxLocalProject } from '@ktx/context/project';
-import { type SqlAnalysisPort } from '@ktx/context/sql-analysis';
+import { type DefaultLocalIngestAdaptersOptions } from './context/ingest/local-adapters.js';
+import type { SourceAdapter } from './context/ingest/types.js';
+import type { KtxLocalProject } from './context/project/project.js';
+import type { SqlAnalysisPort } from './context/sql-analysis/ports.js';
 import { type ManagedPythonCoreDaemonOptions } from './managed-python-http.js';
 import type { KtxOperationalLogger } from './io/logger.js';
 export interface KtxCliLocalIngestAdaptersOptions extends DefaultLocalIngestAdaptersOptions {

package/dist/local-adapters.js

@@ -1,12 +1,26 @@
-import { createBigQueryLiveDatabaseIntrospection, isKtxBigQueryConnectionConfig, KtxBigQueryScanConnector, } from '@ktx/connector-bigquery';
-import { createClickHouseLiveDatabaseIntrospection, isKtxClickHouseConnectionConfig } from '@ktx/connector-clickhouse';
-import { createMysqlLiveDatabaseIntrospection, isKtxMysqlConnectionConfig } from '@ktx/connector-mysql';
-import { createPostgresLiveDatabaseIntrospection, isKtxPostgresConnectionConfig, KtxPostgresHistoricSqlQueryClient, } from '@ktx/connector-postgres';
-import { createSqliteLiveDatabaseIntrospection, isKtxSqliteConnectionConfig } from '@ktx/connector-sqlite';
-import { createSqlServerLiveDatabaseIntrospection, isKtxSqlServerConnectionConfig } from '@ktx/connector-sqlserver';
-import { BigQueryHistoricSqlQueryHistoryReader, createDaemonLiveDatabaseIntrospection, createDefaultLocalIngestAdapters, LiveDatabaseSourceAdapter, PostgresPgssReader, SnowflakeHistoricSqlQueryHistoryReader, } from '@ktx/context/ingest';
-import { createHttpSqlAnalysisPort } from '@ktx/context/sql-analysis';
+import { createBigQueryLiveDatabaseIntrospection } from './connectors/bigquery/live-database-introspection.js';
+import { isKtxBigQueryConnectionConfig, KtxBigQueryScanConnector } from './connectors/bigquery/connector.js';
+import { createClickHouseLiveDatabaseIntrospection } from './connectors/clickhouse/live-database-introspection.js';
+import { isKtxClickHouseConnectionConfig } from './connectors/clickhouse/connector.js';
+import { createMysqlLiveDatabaseIntrospection } from './connectors/mysql/live-database-introspection.js';
+import { isKtxMysqlConnectionConfig } from './connectors/mysql/connector.js';
+import { createPostgresLiveDatabaseIntrospection } from './connectors/postgres/live-database-introspection.js';
+import { isKtxPostgresConnectionConfig } from './connectors/postgres/connector.js';
+import { KtxPostgresHistoricSqlQueryClient } from './connectors/postgres/historic-sql-query-client.js';
+import { createSqliteLiveDatabaseIntrospection } from './connectors/sqlite/live-database-introspection.js';
+import { isKtxSqliteConnectionConfig } from './connectors/sqlite/connector.js';
+import { createSqlServerLiveDatabaseIntrospection } from './connectors/sqlserver/live-database-introspection.js';
+import { isKtxSqlServerConnectionConfig } from './connectors/sqlserver/connector.js';
+import { BigQueryHistoricSqlQueryHistoryReader } from './context/ingest/adapters/historic-sql/bigquery-query-history-reader.js';
+import { queryHistoryDialectForConnection } from './context/ingest/adapters/historic-sql/connection-dialect.js';
+import { createDaemonLiveDatabaseIntrospection } from './context/ingest/adapters/live-database/daemon-introspection.js';
+import { createDefaultLocalIngestAdapters } from './context/ingest/local-adapters.js';
+import { LiveDatabaseSourceAdapter } from './context/ingest/adapters/live-database/live-database.adapter.js';
+import { PostgresPgssReader } from './context/ingest/adapters/historic-sql/postgres-pgss-reader.js';
+import { SnowflakeHistoricSqlQueryHistoryReader } from './context/ingest/adapters/historic-sql/snowflake-query-history-reader.js';
+import { createHttpSqlAnalysisPort } from './context/sql-analysis/http-sql-analysis-port.js';
 import { createManagedDaemonLookerTableIdentifierParser, createManagedDaemonSqlAnalysisPort, managedDaemonDatabaseIntrospectionOptions, } from './managed-python-http.js';
+import { resolveKtxConfigReference } from './context/core/config-reference.js';
 function hasSnowflakeDriver(connection) {
     return (typeof connection === 'object' &&
         connection !== null &&
@@ -76,77 +90,43 @@ function createKtxCliLiveDatabaseIntrospection(project, options = {}) {
         connections: project.config.connections,
     });
     return {
-        async extractSchema(connectionId) {
+        async extractSchema(connectionId, options) {
             const connection = project.config.connections[connectionId];
             if (isKtxPostgresConnectionConfig(connection)) {
-                return postgres.extractSchema(connectionId);
+                return postgres.extractSchema(connectionId, options);
             }
             if (isKtxSqliteConnectionConfig(connection)) {
-                return sqlite.extractSchema(connectionId);
+                return sqlite.extractSchema(connectionId, options);
             }
             if (isKtxMysqlConnectionConfig(connection)) {
-                return mysql.extractSchema(connectionId);
+                return mysql.extractSchema(connectionId, options);
             }
             if (isKtxClickHouseConnectionConfig(connection)) {
-                return clickhouse.extractSchema(connectionId);
+                return clickhouse.extractSchema(connectionId, options);
             }
             if (isKtxSqlServerConnectionConfig(connection)) {
-                return sqlserver.extractSchema(connectionId);
+                return sqlserver.extractSchema(connectionId, options);
             }
             if (isKtxBigQueryConnectionConfig(connection)) {
-                return bigquery.extractSchema(connectionId);
+                return bigquery.extractSchema(connectionId, options);
             }
             if (hasSnowflakeDriver(connection)) {
-                const { createSnowflakeLiveDatabaseIntrospection, isKtxSnowflakeConnectionConfig } = await import('@ktx/connector-snowflake');
+                const { createSnowflakeLiveDatabaseIntrospection } = await import('./connectors/snowflake/live-database-introspection.js');
+                const { isKtxSnowflakeConnectionConfig } = await import('./connectors/snowflake/connector.js');
+                ;
                 if (!isKtxSnowflakeConnectionConfig(connection)) {
-                    return daemon.extractSchema(connectionId);
+                    return daemon.extractSchema(connectionId, options);
                 }
                 const snowflake = createSnowflakeLiveDatabaseIntrospection({
                     connections: project.config.connections,
+                    projectDir: project.projectDir,
                 });
-                return snowflake.extractSchema(connectionId);
+                return snowflake.extractSchema(connectionId, options);
             }
-            return daemon.extractSchema(connectionId);
+            return daemon.extractSchema(connectionId, options);
         },
     };
 }
-function historicSqlRecord(connection) {
-    if (connection &&
-        typeof connection === 'object' &&
-        'historicSql' in connection &&
-        typeof connection.historicSql === 'object' &&
-        connection.historicSql !== null &&
-        !Array.isArray(connection.historicSql)) {
-        return connection.historicSql;
-    }
-    return null;
-}
-function enabledHistoricSqlDialect(connection) {
-    const direct = historicSqlRecord(connection);
-    const context = connection && typeof connection === 'object' && !Array.isArray(connection)
-        ? connection.context
-        : null;
-    const queryHistory = context && typeof context === 'object' && !Array.isArray(context)
-        ? context.queryHistory
-        : null;
-    const enabled = queryHistory && typeof queryHistory === 'object' && !Array.isArray(queryHistory)
-        ? queryHistory.enabled === true
-        : direct?.enabled === true;
-    if (!enabled) {
-        return null;
-    }
-    const driver = String(connection?.driver ?? '').toLowerCase();
-    if (driver === 'postgres' || driver === 'postgresql')
-        return 'postgres';
-    if (driver === 'bigquery')
-        return 'bigquery';
-    if (driver === 'snowflake')
-        return 'snowflake';
-    const legacyDialect = String(direct?.dialect ?? '').toLowerCase();
-    return legacyDialect === 'postgres' || legacyDialect === 'bigquery' || legacyDialect === 'snowflake'
-        ? legacyDialect
-        : null;
-}
 function createEphemeralPostgresHistoricSqlClient(project, connectionId) {
     const connection = project.config.connections[connectionId];
     const inputDriver = connection?.driver ?? 'unknown';
@@ -205,6 +185,7 @@ async function createEphemeralSnowflakeHistoricSqlClient(project, connectionId,
             const connector = new connectorModule.KtxSnowflakeScanConnector({
                 connectionId,
                 connection,
+                projectDir: project.projectDir,
             });
             try {
                 const result = await connector.executeReadOnly({ connectionId, sql: query }, {});
@@ -222,7 +203,10 @@ async function createEphemeralSnowflakeHistoricSqlClient(project, connectionId,
 }
 function bigQueryProjectId(connection, env) {
     const raw = typeof connection.credentials_json === 'string' ? connection.credentials_json : '';
-    const resolved = raw.startsWith('env:') ? env[raw.slice('env:'.length)] ?? '' : raw;
+    const resolved = resolveKtxConfigReference(raw, env);
+    if (!resolved) {
+        throw new Error('Query history BigQuery connection requires credentials_json');
+    }
     const parsed = JSON.parse(resolved);
     if (typeof parsed.project_id !== 'string' || parsed.project_id.trim().length === 0) {
         throw new Error('Query history BigQuery connection requires credentials_json.project_id');
@@ -240,7 +224,7 @@ function historicSqlOptionsForLocalRun(project, options) {
         return undefined;
     }
     const connection = project.config.connections[connectionId];
-    const dialect = enabledHistoricSqlDialect(connection);
+    const dialect = queryHistoryDialectForConnection(connection);
     if (!dialect) {
         return undefined;
     }
@@ -273,7 +257,7 @@ function historicSqlOptionsForLocalRun(project, options) {
         reader: new SnowflakeHistoricSqlQueryHistoryReader(),
         queryClient: {
             async executeQuery(query) {
-                const connectorModule = await import('@ktx/connector-snowflake');
+                const connectorModule = await import('./connectors/snowflake/connector.js');
                 const client = await createEphemeralSnowflakeHistoricSqlClient(project, connectionId, connectorModule);
                 return client.executeQuery(query);
             },

package/dist/local-scan-connectors.d.ts

@@ -1,3 +1,3 @@
-import type { KtxLocalProject } from '@ktx/context/project';
-import type { KtxScanConnector } from '@ktx/context/scan';
+import type { KtxLocalProject } from './context/project/project.js';
+import type { KtxScanConnector } from './context/scan/types.js';
 export declare function createKtxCliScanConnector(project: KtxLocalProject, connectionId: string): Promise<KtxScanConnector>;

package/dist/local-scan-connectors.js

@@ -1,4 +1,5 @@
-const SUPPORTED_DRIVERS = 'sqlite, postgres, mysql, clickhouse, sqlserver, bigquery, snowflake';
+import { getDriverRegistration, listSupportedDrivers, } from './context/connections/drivers.js';
+const SUPPORTED_DRIVERS = listSupportedDrivers().join(', ');
 export async function createKtxCliScanConnector(project, connectionId) {
     const connection = project.config.connections[connectionId];
     if (!connection) {
@@ -8,47 +9,20 @@ export async function createKtxCliScanConnector(project, connectionId) {
     if (!driver) {
         throw new Error(`Connection "${connectionId}" has no \`driver\` field in ktx.yaml. Supported drivers: ${SUPPORTED_DRIVERS}.`);
     }
-    if (driver === 'sqlite' || driver === 'sqlite3') {
-        const { KtxSqliteScanConnector, isKtxSqliteConnectionConfig } = await import('@ktx/connector-sqlite');
-        if (isKtxSqliteConnectionConfig(connection)) {
-            return new KtxSqliteScanConnector({ connectionId, connection, projectDir: project.projectDir });
-        }
+    const registration = getDriverRegistration(driver);
+    if (!registration) {
+        throw new Error(`Connection "${connectionId}" uses driver "${driver}", which has no native standalone KTX scan connector. Supported drivers: ${SUPPORTED_DRIVERS}.`);
     }
-    if (driver === 'postgres' || driver === 'postgresql') {
-        const { KtxPostgresScanConnector, isKtxPostgresConnectionConfig } = await import('@ktx/connector-postgres');
-        if (isKtxPostgresConnectionConfig(connection)) {
-            return new KtxPostgresScanConnector({ connectionId, connection });
-        }
+    const connectorModule = await registration.load();
+    if (!connectorModule.isConnectionConfig(connection)) {
+        throw invalidConnectionConfigError(connectionId, driver);
     }
-    if (driver === 'mysql') {
-        const { KtxMysqlScanConnector, isKtxMysqlConnectionConfig } = await import('@ktx/connector-mysql');
-        if (isKtxMysqlConnectionConfig(connection)) {
-            return new KtxMysqlScanConnector({ connectionId, connection });
-        }
-    }
-    if (driver === 'clickhouse') {
-        const { KtxClickHouseScanConnector, isKtxClickHouseConnectionConfig } = await import('@ktx/connector-clickhouse');
-        if (isKtxClickHouseConnectionConfig(connection)) {
-            return new KtxClickHouseScanConnector({ connectionId, connection });
-        }
-    }
-    if (driver === 'sqlserver') {
-        const { KtxSqlServerScanConnector, isKtxSqlServerConnectionConfig } = await import('@ktx/connector-sqlserver');
-        if (isKtxSqlServerConnectionConfig(connection)) {
-            return new KtxSqlServerScanConnector({ connectionId, connection });
-        }
-    }
-    if (driver === 'bigquery') {
-        const { KtxBigQueryScanConnector, isKtxBigQueryConnectionConfig } = await import('@ktx/connector-bigquery');
-        if (isKtxBigQueryConnectionConfig(connection)) {
-            return new KtxBigQueryScanConnector({ connectionId, connection });
-        }
-    }
-    if (driver === 'snowflake') {
-        const { KtxSnowflakeScanConnector, isKtxSnowflakeConnectionConfig } = await import('@ktx/connector-snowflake');
-        if (isKtxSnowflakeConnectionConfig(connection)) {
-            return new KtxSnowflakeScanConnector({ connectionId, connection });
-        }
-    }
-    throw new Error(`Connection "${connectionId}" uses driver "${driver}", which has no native standalone KTX scan connector. Supported drivers: ${SUPPORTED_DRIVERS}.`);
+    return connectorModule.createScanConnector({
+        connectionId,
+        connection,
+        projectDir: project.projectDir,
+    });
+}
+function invalidConnectionConfigError(connectionId, driver) {
+    return new Error(`Connection "${connectionId}" uses driver "${driver}" but its configuration in ktx.yaml does not match the expected shape for that driver. Check the required fields for ${driver} (e.g. url/host/database).`);
 }

package/dist/managed-local-embeddings.d.ts

@@ -1,4 +1,4 @@
-import type { KtxEmbeddingConfig } from '@ktx/llm';
+import type { KtxEmbeddingConfig } from './llm/types.js';
 import type { KtxCliIo } from './cli-runtime.js';
 import { type KtxManagedPythonInstallPolicy, type ManagedPythonCommandRuntime } from './managed-python-command.js';
 import { readManagedPythonDaemonStatus, type ManagedPythonDaemonStartResult } from './managed-python-daemon.js';

package/dist/managed-local-embeddings.js

@@ -1,3 +1,4 @@
+import { writePrefixedLines } from './clack.js';
 import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
 import { readManagedPythonDaemonStatus, startManagedPythonDaemon, } from './managed-python-daemon.js';
 export function managedLocalEmbeddingHealthConfig(input) {
@@ -27,7 +28,7 @@ export async function ensureManagedLocalEmbeddingsDaemon(options) {
         force: false,
     });
     const verb = daemon.status === 'started' ? 'Started' : 'Using';
-    options.io.stderr.write(`${verb} KTX daemon: ${daemon.baseUrl}\n`);
+    writePrefixedLines((chunk) => options.io.stderr.write(chunk), `${verb} KTX daemon: ${daemon.baseUrl}`);
     return {
         baseUrl: daemon.baseUrl,
         stdoutLog: daemon.state.stdoutLog,

package/dist/managed-mcp-daemon.d.ts

@@ -8,6 +8,7 @@ export interface KtxMcpDaemonState {
     startedAt: string;
     logPath: string;
 }
+/** @internal */
 export interface KtxMcpDaemonChild {
     pid?: number;
     unref(): void;

package/dist/managed-python-command.d.ts

@@ -1,4 +1,4 @@
-import { createPythonSemanticLayerComputePort, type KtxSemanticLayerComputePort } from '@ktx/context/daemon';
+import { createPythonSemanticLayerComputePort, type KtxSemanticLayerComputePort } from './context/daemon/semantic-layer-compute.js';
 import type { KtxCliIo } from './cli-runtime.js';
 import { type KtxCliSpinner } from './clack.js';
 import { type InstalledKtxRuntimeManifest, type KtxRuntimeFeature, type ManagedPythonRuntimeInstallOptions, type ManagedPythonRuntimeInstallResult, type ManagedPythonRuntimeLayout, type ManagedPythonRuntimeLayoutOptions, type ManagedPythonRuntimeStatus } from './managed-python-runtime.js';
@@ -11,7 +11,7 @@ export interface ManagedPythonCommandRuntime {
     layout: ManagedPythonRuntimeLayout;
     manifest: InstalledKtxRuntimeManifest;
 }
-export interface ManagedPythonCommandDeps {
+interface ManagedPythonCommandDeps {
     readStatus?: (options: ManagedPythonRuntimeLayoutOptions) => Promise<ManagedPythonRuntimeStatus>;
     installRuntime?: (options: ManagedPythonRuntimeInstallOptions) => Promise<ManagedPythonRuntimeInstallResult>;
     confirmInstall?: (message: string, io: KtxCliIo) => Promise<boolean>;
@@ -25,7 +25,10 @@ export interface ManagedPythonCommandOptions extends ManagedPythonCommandDeps {
 }
 export interface ManagedPythonSemanticLayerComputeOptions extends ManagedPythonCommandOptions {
     createPythonCompute?: typeof createPythonSemanticLayerComputePort;
+    projectDir?: string;
 }
+/** @internal */
 export declare function managedRuntimeInstallCommand(feature: KtxRuntimeFeature): string;
 export declare function ensureManagedPythonCommandRuntime(options: ManagedPythonCommandOptions): Promise<ManagedPythonCommandRuntime>;
 export declare function createManagedPythonSemanticLayerComputePort(options: ManagedPythonSemanticLayerComputeOptions): Promise<KtxSemanticLayerComputePort>;
+export {};

package/dist/managed-python-command.js

@@ -1,6 +1,7 @@
-import { createPythonSemanticLayerComputePort } from '@ktx/context/daemon';
+import { createPythonSemanticLayerComputePort } from './context/daemon/semantic-layer-compute.js';
 import { createClackPromptAdapter, createStaticCliSpinner } from './clack.js';
 import { installManagedPythonRuntime, readManagedPythonRuntimeStatus, } from './managed-python-runtime.js';
+import { readExistingTelemetryProjectId } from './telemetry/identity.js';
 export function runtimeInstallPolicyFromFlags(options) {
     if (options.yes === true && options.input === false) {
         throw new Error('Choose only one runtime install mode: --yes or --no-input');
@@ -10,6 +11,7 @@ export function runtimeInstallPolicyFromFlags(options) {
     }
     return options.input === false ? 'never' : 'prompt';
 }
+/** @internal */
 export function managedRuntimeInstallCommand(feature) {
     return feature === 'local-embeddings'
         ? 'ktx admin runtime install --feature local-embeddings --yes'
@@ -78,8 +80,12 @@ export async function createManagedPythonSemanticLayerComputePort(options) {
         ...(options.spinner ? { spinner: options.spinner } : {}),
     });
     const createPythonCompute = options.createPythonCompute ?? createPythonSemanticLayerComputePort;
+    const projectId = options.projectDir
+        ? await readExistingTelemetryProjectId({ projectDir: options.projectDir })
+        : undefined;
     return createPythonCompute({
         command: runtime.manifest.python.daemonExecutable,
         args: [],
+        ...(projectId ? { projectId } : {}),
     });
 }

package/dist/managed-python-daemon.d.ts

@@ -1,4 +1,9 @@
 import { type KtxRuntimeFeature, type ManagedPythonDaemonLayout, type ManagedPythonDaemonLayoutOptions, type ManagedPythonRuntimeInstallOptions, type ManagedPythonRuntimeInstallResult } from './managed-python-runtime.js';
+export declare class ManagedPythonDaemonStartError extends Error {
+    readonly detail: string;
+    readonly stderrLog: string;
+    constructor(detail: string, stderrLog: string);
+}
 export interface ManagedPythonDaemonState {
     schemaVersion: 1;
     pid: number;
@@ -41,7 +46,7 @@ export interface ManagedPythonDaemonProcessInfo {
     pid: number;
     command: string;
 }
-export type ManagedPythonDaemonStopAllSource = 'state' | 'process';
+type ManagedPythonDaemonStopAllSource = 'state' | 'process';
 export interface ManagedPythonDaemonStopAllEntry {
     pid: number;
     source: ManagedPythonDaemonStopAllSource;
@@ -60,22 +65,25 @@ export interface ManagedPythonDaemonStopAllResult {
     failed: ManagedPythonDaemonStopAllFailure[];
     scanErrors: string[];
 }
+/** @internal */
 export interface ManagedPythonDaemonChild {
     pid?: number;
     unref(): void;
 }
+/** @internal */
 export type ManagedPythonDaemonSpawn = (command: string, args: string[], options: {
     detached: boolean;
     stdio: ['ignore', number, number];
     env: NodeJS.ProcessEnv;
 }) => ManagedPythonDaemonChild;
+/** @internal */
 export type ManagedPythonDaemonFetch = (url: string) => Promise<{
     ok: boolean;
     status: number;
     json(): Promise<unknown>;
     text(): Promise<string>;
 }>;
-export type ManagedPythonDaemonKillProcess = (pid: number, signal?: NodeJS.Signals) => void;
+type ManagedPythonDaemonKillProcess = (pid: number, signal?: NodeJS.Signals) => void;
 export interface ManagedPythonDaemonStartOptions extends ManagedPythonDaemonLayoutOptions {
     features: KtxRuntimeFeature[];
     force?: boolean;
@@ -110,3 +118,4 @@ export declare function allocateDaemonPort(): Promise<number>;
 export declare function startManagedPythonDaemon(options: ManagedPythonDaemonStartOptions): Promise<ManagedPythonDaemonStartResult>;
 export declare function stopManagedPythonDaemon(options: ManagedPythonDaemonStopOptions): Promise<ManagedPythonDaemonStopResult>;
 export declare function stopAllManagedPythonDaemons(options: ManagedPythonDaemonStopAllOptions): Promise<ManagedPythonDaemonStopAllResult>;
+export {};

package/dist/managed-python-daemon.js

@@ -4,8 +4,19 @@ import { createServer } from 'node:net';
 import { setTimeout as delay } from 'node:timers/promises';
 import { promisify } from 'node:util';
 import { z } from 'zod';
+import { describeError } from './error-message.js';
 import { installManagedPythonRuntime, managedPythonDaemonLayout, runtimeFeatureSchema, } from './managed-python-runtime.js';
 import { sanitizeChildProxyEnv } from './proxy-env.js';
+export class ManagedPythonDaemonStartError extends Error {
+    detail;
+    stderrLog;
+    constructor(detail, stderrLog) {
+        super(`KTX daemon failed to start: ${detail}. stderr: ${stderrLog}`);
+        this.name = 'ManagedPythonDaemonStartError';
+        this.detail = detail;
+        this.stderrLog = stderrLog;
+    }
+}
 const execFileAsync = promisify(execFile);
 const daemonStateSchema = z.object({
     schemaVersion: z.literal(1),
@@ -92,7 +103,7 @@ async function healthOk(input) {
         return { ok: true };
     }
     catch (error) {
-        return { ok: false, detail: error instanceof Error ? error.message : String(error) };
+        return { ok: false, detail: describeError(error) };
     }
 }
 export async function readManagedPythonDaemonStatus(options) {
@@ -173,7 +184,7 @@ async function waitForHealth(input) {
         return;
     }
     lastDetail = finalHealth.detail;
-    throw new Error(`KTX daemon failed to start: ${lastDetail}. stderr: ${input.state.stderrLog}`);
+    throw new ManagedPythonDaemonStartError(lastDetail, input.state.stderrLog);
 }
 async function removeState(layout) {
     await rm(layout.daemonStatePath, { force: true });
@@ -504,13 +515,22 @@ export async function startManagedPythonDaemon(options) {
             stdoutLog: layout.daemonStdoutPath,
             stderrLog: layout.daemonStderrPath,
         };
-        await waitForHealth({
-            state,
-            cliVersion: options.cliVersion,
-            fetch: fetchImpl,
-            timeoutMs: options.startupTimeoutMs ?? 10_000,
-            pollIntervalMs: options.pollIntervalMs ?? 100,
-        });
+        try {
+            await waitForHealth({
+                state,
+                cliVersion: options.cliVersion,
+                fetch: fetchImpl,
+                timeoutMs: options.startupTimeoutMs ?? 30_000,
+                pollIntervalMs: options.pollIntervalMs ?? 100,
+            });
+        }
+        catch (error) {
+            if (processAlive(state.pid)) {
+                killProcess(state.pid);
+            }
+            await removeState(layout);
+            throw error;
+        }
         await writeState(layout.daemonStatePath, state);
         return { status: 'started', layout, state, baseUrl: baseUrl(state) };
     }

package/dist/managed-python-http.d.ts

@@ -1,10 +1,12 @@
-import { type DaemonLiveDatabaseIntrospectionOptions, type LookerTableIdentifierParser } from '@ktx/context/ingest';
-import { type SqlAnalysisPort } from '@ktx/context/sql-analysis';
+import type { DaemonLiveDatabaseIntrospectionOptions } from './context/ingest/adapters/live-database/daemon-introspection.js';
+import type { LookerTableIdentifierParser } from './context/ingest/adapters/looker/mapping.js';
+import type { SqlAnalysisPort } from './context/sql-analysis/ports.js';
 import type { KtxCliIo } from './cli-runtime.js';
 import { type KtxManagedPythonInstallPolicy, type ManagedPythonCommandRuntime } from './managed-python-command.js';
 import { type ManagedPythonDaemonStartResult } from './managed-python-daemon.js';
+/** @internal */
 export type ManagedPythonHttpJsonRunner = (path: string, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
-export type ManagedPythonHttpPostJson = (baseUrl: string, path: string, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
+type ManagedPythonHttpPostJson = (baseUrl: string, path: string, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
 export interface ManagedPythonCoreDaemonOptions {
     cliVersion: string;
     projectDir: string;
@@ -31,9 +33,11 @@ export type ManagedPythonDaemonHttpOptions = {
 } | (ManagedPythonCoreDaemonOptions & {
     postJson?: ManagedPythonHttpPostJson;
 });
-export declare function postManagedDaemonJson(baseUrl: string, path: string, payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+/** @internal */
 export declare function createManagedPythonDaemonBaseUrlResolver(options: ManagedPythonCoreDaemonOptions): () => Promise<string>;
+/** @internal */
 export declare function createManagedDaemonHttpJsonRunner(options: ManagedPythonDaemonHttpOptions): ManagedPythonHttpJsonRunner;
 export declare function createManagedDaemonLookerTableIdentifierParser(options: ManagedPythonDaemonHttpOptions): LookerTableIdentifierParser;
 export declare function createManagedDaemonSqlAnalysisPort(options: ManagedPythonDaemonHttpOptions): SqlAnalysisPort;
 export declare function managedDaemonDatabaseIntrospectionOptions(options: ManagedPythonDaemonHttpOptions): Pick<DaemonLiveDatabaseIntrospectionOptions, 'requestJson'>;
+export {};

package/dist/managed-python-http.js

@@ -1,8 +1,9 @@
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { URL } from 'node:url';
-import { createDaemonLookerTableIdentifierParser, } from '@ktx/context/ingest';
-import { createHttpSqlAnalysisPort, } from '@ktx/context/sql-analysis';
+import { createDaemonLookerTableIdentifierParser } from './context/ingest/adapters/looker/daemon-table-identifier-parser.js';
+import { createHttpSqlAnalysisPort } from './context/sql-analysis/http-sql-analysis-port.js';
+import { writePrefixedLines } from './clack.js';
 import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
 import { startManagedPythonDaemon } from './managed-python-daemon.js';
 function normalizedBaseUrl(baseUrl) {
@@ -15,7 +16,7 @@ function parseJsonObject(raw, path) {
     }
     return parsed;
 }
-export async function postManagedDaemonJson(baseUrl, path, payload) {
+async function postManagedDaemonJson(baseUrl, path, payload) {
     return await new Promise((resolve, reject) => {
         const target = new URL(path.replace(/^\//, ''), normalizedBaseUrl(baseUrl));
         const body = JSON.stringify(payload);
@@ -49,6 +50,7 @@ export async function postManagedDaemonJson(baseUrl, path, payload) {
         request.end(body);
     });
 }
+/** @internal */
 export function createManagedPythonDaemonBaseUrlResolver(options) {
     let cachedBaseUrl;
     return async () => {
@@ -70,7 +72,7 @@ export function createManagedPythonDaemonBaseUrlResolver(options) {
             force: false,
         });
         const verb = daemon.status === 'started' ? 'Started' : 'Using existing';
-        options.io.stderr.write(`${verb} KTX daemon: ${daemon.baseUrl}\n`);
+        writePrefixedLines((chunk) => options.io.stderr.write(chunk), `${verb} KTX daemon: ${daemon.baseUrl}`);
         cachedBaseUrl = daemon.baseUrl;
         return cachedBaseUrl;
     };
@@ -81,6 +83,7 @@ function isRequestJsonOnly(options) {
 function isResolveBaseUrlOnly(options) {
     return 'resolveBaseUrl' in options;
 }
+/** @internal */
 export function createManagedDaemonHttpJsonRunner(options) {
     if (isRequestJsonOnly(options)) {
         return options.requestJson;