@kaelio/ktx 0.14.0 → 0.16.0

package/dist/context/scan/types.d.ts

@@ -1,5 +1,5 @@
 import type { KtxTableRefKey } from './table-ref.js';
-export type KtxConnectionDriver = 'sqlite' | 'postgres' | 'sqlserver' | 'bigquery' | 'snowflake' | 'mysql' | 'clickhouse' | 'mongodb';
+export type KtxConnectionDriver = 'sqlite' | 'duckdb' | 'postgres' | 'sqlserver' | 'bigquery' | 'snowflake' | 'mysql' | 'clickhouse' | 'athena' | 'mongodb';
 /** Canonical scan-mode registry. Runtime validation derives its allowlist here. */
 export declare const KTX_SCAN_MODES: readonly ["structural", "relationships", "enriched"];
 export type KtxScanMode = (typeof KTX_SCAN_MODES)[number];

package/dist/context/sl/local-query.js

@@ -1,15 +1,31 @@
 import { isSqlQueryableDriver } from '../connections/dialects.js';
 import { FEDERATED_CONNECTION_ID } from '../connections/federation.js';
+import { connectionQueryPolicy, restrictedFederatedMemberIds } from '../connections/query-policy.js';
 import { resolveRequiredConnectionId } from '../connections/resolve-connection.js';
 import { sqlAnalysisDialectForDriver } from '../sql-analysis/dialect.js';
 import { loadLocalSlSourceRecords } from './local-sl.js';
 import { toResolvedWire } from './semantic-layer.service.js';
 import { assertSafeConnectionId } from './source-files.js';
 const COMPILE_ONLY_REASON = 'Local semantic-layer query compiled SQL but no data-source execution adapter is configured.';
-const FEDERATED_SL_QUERY_UNSUPPORTED = `Semantic-layer queries are per-connection and cannot target the federated connection '${FEDERATED_CONNECTION_ID}'. ` +
-    `Run a cross-database query as read-only SQL instead — ktx sql -c ${FEDERATED_CONNECTION_ID} "SELECT ..." or the sql_execution tool — ` +
-    'using catalog-qualified table names (connectionId.schema.table, or connectionId.table for sqlite; ' +
-    'double-quote ids that are not bare identifiers, e.g. "books-db".public.books).';
+const FEDERATED_SL_QUERY_PREFIX = `Semantic-layer queries are per-connection and cannot target the federated connection '${FEDERATED_CONNECTION_ID}'. `;
+// The raw-SQL fallback is only valid when federated raw SQL is allowed; when a
+// member is restricted (query_policy: semantic-layer-only), assertRawSqlAllowed
+// rejects the same path, so directing the agent there would burn a guaranteed
+// failure. Derive the message from the restricted-member set instead.
+function federatedSlQueryUnsupportedMessage(project) {
+    const restricted = restrictedFederatedMemberIds(project.config, project.projectDir);
+    if (restricted.length > 0) {
+        return (FEDERATED_SL_QUERY_PREFIX +
+            `Cross-database SQL through '${FEDERATED_CONNECTION_ID}' is also disabled because member connection(s) ` +
+            `${restricted.map((id) => `'${id}'`).join(', ')} are restricted to semantic-layer queries ` +
+            '(query_policy: semantic-layer-only). Query each connection on its own through the semantic layer ' +
+            '(the sl_query tool or `ktx sl query` with its connection id).');
+    }
+    return (FEDERATED_SL_QUERY_PREFIX +
+        `Run a cross-database query as read-only SQL instead — ktx sql -c ${FEDERATED_CONNECTION_ID} "SELECT ..." or the sql_execution tool — ` +
+        'using catalog-qualified table names (connectionId.schema.table, or connectionId.table for sqlite; ' +
+        'double-quote ids that are not bare identifiers, e.g. "books-db".public.books).');
+}
 function resolveLocalConnectionId(project, requested) {
     return assertSafeConnectionId(resolveRequiredConnectionId(project.config, requested));
 }
@@ -39,7 +55,7 @@ function headersFromColumns(columns) {
 }
 export async function compileLocalSlQuery(project, options) {
     if (options.connectionId === FEDERATED_CONNECTION_ID) {
-        throw new Error(FEDERATED_SL_QUERY_UNSUPPORTED);
+        throw new Error(federatedSlQueryUnsupportedMessage(project));
     }
     await options.onProgress?.({ progress: 0, message: 'Compiling query' });
     const connectionId = resolveLocalConnectionId(project, options.connectionId);
@@ -50,11 +66,12 @@ export async function compileLocalSlQuery(project, options) {
     }
     const dialect = sqlAnalysisDialectForDriver(driver);
     const sources = await loadComputableSources(project, connectionId);
+    const predefinedMeasuresOnly = connectionQueryPolicy(project.config.connections[connectionId]) === 'semantic-layer-only';
     await options.onProgress?.({ progress: 0.3, message: 'Generating SQL' });
     const response = await options.compute.query({
         sources,
         dialect,
-        query: options.query,
+        query: { ...options.query, predefined_measures_only: predefinedMeasuresOnly },
     });
     if (!options.execute) {
         await options.onProgress?.({ progress: 1, message: 'Fetched 0 rows' });

package/dist/context/sl/semantic-layer.service.d.ts

@@ -147,10 +147,6 @@ export declare class SemanticLayerService {
             descriptions: Record<string, string>;
         }>;
     }>;
-    /**
-     * All callers should use this instead of maintaining their own dialect maps.
-     */
-    static mapDialect(connectionType: string): string;
     /**
      * Execute a semantic layer query: load composed sources, generate SQL via
      * the python SL engine, and execute the generated SQL against the data source.

package/dist/context/sl/semantic-layer.service.js

@@ -1,5 +1,6 @@
 import YAML from 'yaml';
 import { noopLogger } from '../../context/core/config.js';
+import { dialectForConnectionType } from '../connections/connection-type-dialect.js';
 import { normalizeSemanticLayerDescriptions } from './description-normalization.js';
 import { isOverlaySource, resolvedSourceSchema, sourceDefinitionSchema, sourceOverlaySchema } from './schemas.js';
 import { isSlYamlPath, resolveSlSourceFile, slDeclaredSourceName, slSourceFilePath } from './source-files.js';
@@ -572,7 +573,7 @@ export class SemanticLayerService {
         if (!connection) {
             throw new Error(`Data source not found: ${connectionId}`);
         }
-        return SemanticLayerService.mapDialect(connection.connectionType);
+        return dialectForConnectionType(connection.connectionType);
     }
     async listFilesForConnection(connectionId) {
         const dir = `${SL_DIR_PREFIX}/${connectionId}`;
@@ -937,24 +938,6 @@ export class SemanticLayerService {
         }
         return { columns, tables };
     }
-    /**
-     * All callers should use this instead of maintaining their own dialect maps.
-     */
-    static mapDialect(connectionType) {
-        const normalized = connectionType.toUpperCase();
-        const map = {
-            POSTGRES: 'postgres',
-            BIGQUERY: 'bigquery',
-            SNOWFLAKE: 'snowflake',
-            MYSQL: 'mysql',
-            SQLSERVER: 'tsql',
-            SQLITE: 'sqlite',
-            DUCKDB: 'duckdb',
-            CLICKHOUSE: 'clickhouse',
-            DATABRICKS: 'databricks',
-        };
-        return map[normalized] ?? 'postgres';
-    }
     /**
      * Execute a semantic layer query: load composed sources, generate SQL via
      * the python SL engine, and execute the generated SQL against the data source.
@@ -980,7 +963,7 @@ export class SemanticLayerService {
         if (!connection) {
             throw new Error(`Data source not found: ${connectionId}`);
         }
-        const dialect = SemanticLayerService.mapDialect(connection.connectionType);
+        const dialect = dialectForConnectionType(connection.connectionType);
         // 3. Generate SQL via python SL engine
         const { data: slResult, error: slError } = await this.python.query({
             sources: sources.map(toResolvedWire),

package/dist/context/sl/tools/sl-warehouse-validation.d.ts

@@ -1,7 +1,7 @@
 import type { GitService } from '../../../context/core/git.service.js';
 import type { KtxFileStorePort } from '../../../context/core/file-store.js';
 import type { SlConnectionCatalogPort, SlSourcesIndexPort } from '../ports.js';
-import { SemanticLayerService } from '../semantic-layer.service.js';
+import type { SemanticLayerService } from '../semantic-layer.service.js';
 export interface SlValidationDeps {
     semanticLayerService: SemanticLayerService;
     connections: SlConnectionCatalogPort;

package/dist/context/sl/tools/sl-warehouse-validation.js

@@ -1,14 +1,14 @@
 import YAML from 'yaml';
 import { SYSTEM_GIT_AUTHOR } from '../../../context/tools/authors.js';
+import { dialectForConnectionType } from '../../connections/connection-type-dialect.js';
 import { sourceOverlaySchema } from '../schemas.js';
-import { SemanticLayerService } from '../semantic-layer.service.js';
 import { resolveSlSourceFile, slSourceFilePath } from '../source-files.js';
 import { sourceDefinitionSchema } from './base-semantic-layer.tool.js';
 function resolveDialect(warehouse) {
     if (!warehouse) {
         return null;
     }
-    return SemanticLayerService.mapDialect(warehouse);
+    return dialectForConnectionType(warehouse);
 }
 function wrapWithZeroRowQuery(sql, dialect) {
     if (dialect === 'tsql') {

package/dist/context/sl/types.d.ts

@@ -115,6 +115,7 @@ export interface SemanticLayerQueryInput {
     }>;
     limit?: number;
     include_empty?: boolean;
+    predefined_measures_only?: boolean;
 }
 export interface SemanticLayerQueryExecutionResult {
     sql: string;

package/dist/context/sql-analysis/dialect-notes.d.ts

@@ -1,6 +1,6 @@
 import type { SqlAnalysisDialect } from './ports.js';
 /** @internal Dialects with an authored ./dialects/<dialect>.md file. */
-export declare const DIALECTS_WITH_NOTES: readonly ["postgres", "mysql", "snowflake", "bigquery", "sqlite", "clickhouse", "tsql"];
+export declare const DIALECTS_WITH_NOTES: readonly ["postgres", "mysql", "snowflake", "bigquery", "sqlite", "duckdb", "clickhouse", "tsql", "athena"];
 /**
  * SQL syntax notes for a resolved dialect. Falls back to `postgres` — the
  * resolver's own default for unrecognized drivers — so any SQL connection yields

package/dist/context/sql-analysis/dialect-notes.js

@@ -4,8 +4,7 @@ import { fileURLToPath } from 'node:url';
 // dialect), served by the sql_dialect_notes MCP tool. They are package-internal:
 // copy-runtime-assets.mjs ships them to dist, and they are never installed onto an
 // agent target. The set covers every dialect reachable from a configured warehouse
-// driver; duckdb/databricks are intentionally absent because no connector produces
-// them.
+// driver; databricks is intentionally absent because no connector produces it.
 /** @internal Dialects with an authored ./dialects/<dialect>.md file. */
 export const DIALECTS_WITH_NOTES = [
     'postgres',
@@ -13,8 +12,10 @@ export const DIALECTS_WITH_NOTES = [
     'snowflake',
     'bigquery',
     'sqlite',
+    'duckdb',
     'clickhouse',
     'tsql',
+    'athena',
 ];
 const notesCache = new Map();
 function readDialectNotes(dialect) {

package/dist/context/sql-analysis/dialect.js

@@ -14,6 +14,7 @@ const SQLGLOT_DIALECTS = {
     duckdb: 'duckdb',
     clickhouse: 'clickhouse',
     databricks: 'databricks',
+    athena: 'athena',
 };
 export function sqlAnalysisDialectForDriver(driver) {
     return SQLGLOT_DIALECTS[(driver ?? '').toLowerCase()] ?? 'postgres';

package/dist/context/sql-analysis/dialects/athena.md

@@ -0,0 +1,12 @@
+**athena** SQL conventions (Trino engine over the Glue Data Catalog):
+- **FQTN:** `database.table` (e.g. `analytics.orders`); a bare `table` resolves against the query's default database. Cross-catalog is `catalog.database.table` (e.g. `awsdatacatalog.analytics.orders`).
+- **Identifiers:** case-insensitive and folded to lowercase; double-quote (`"Name"`) to keep case, spaces, or a reserved word. String literals use single quotes only.
+- **Date/time:** native `DATE`/`TIMESTAMP`. Bucket with `date_trunc('month', ts)`, pull parts with `EXTRACT(YEAR FROM ts)`, shift with `date_add('day', -30, current_date)`, difference with `date_diff('day', a, b)`, and format with `date_format(ts, '%Y-%m')`. Parse text with `date_parse(str, '%Y-%m-%d')` or `from_iso8601_timestamp(str)`; `current_date` / `now()` are available.
+- **Top-N / windows:** Athena has no `QUALIFY` — wrap the window in a subquery and filter it: `SELECT * FROM (SELECT ..., ROW_NUMBER() OVER (PARTITION BY key ORDER BY x DESC) AS rn FROM t) WHERE rn = 1` returns one row per key. Use `ORDER BY ... LIMIT n` for a global top-N, and paginate with `OFFSET m LIMIT n` (offset first — `LIMIT n OFFSET m` is a syntax error).
+- **Series:** `CROSS JOIN UNNEST(sequence(DATE '2023-01-01', DATE '2023-12-01', INTERVAL '1' MONTH)) AS s(d)` expands a generated array into a date spine (use `sequence(1, 12)` for integers), then `LEFT JOIN` the aggregated facts onto it so empty periods still appear.
+- **Rolling window over time:** a native `RANGE` frame spans real dates and tolerates gaps — `AVG(amount) OVER (ORDER BY day RANGE BETWEEN INTERVAL '29' DAY PRECEDING AND CURRENT ROW)` is a trailing 30-day average without a spine; guard minimum periods with `COUNT(*) OVER (<same frame>)`.
+- **Approximate aggregates:** `approx_distinct(x)` for cardinality and `approx_percentile(x, 0.5)` for quantiles are far cheaper than exact `COUNT(DISTINCT ...)` on large scans.
+- **Arrays & maps:** explode with `CROSS JOIN UNNEST(arr) AS t(x)` (add `WITH ORDINALITY` for an index); build with `array_agg(x)`, join with `array_join(arr, ',')`, index 1-based (`arr[1]`), and read a map with `element_at(m, key)`.
+- **Safe cast:** `TRY_CAST(x AS DOUBLE)` yields `NULL` for a value that does not parse instead of raising, so counting residual `NULL`s catches an encoding the sample missed; `TRY(expr)` swallows other runtime errors.
+- **Integer division:** `/` between integers truncates (`5 / 2` → `2`); cast an operand (`x / CAST(y AS DOUBLE)`) to keep the fraction, and round only in the final projection.
+- **JSON:** `json_extract_scalar(col, '$.a.b')` returns varchar, `json_extract(col, '$.a')` returns json; cast a JSON string with `CAST(json_parse(col) AS ...)`.

package/dist/context/sql-analysis/dialects/duckdb.md

@@ -0,0 +1,10 @@
+**duckdb** SQL conventions:
+- **FQTN:** `schema.table` within one database (e.g. `main.orders`); a bare `table` resolves against `main`. A second, attached database is `db.schema.table` (e.g. `sales.main.orders`).
+- **Identifiers:** case-insensitive; double-quote (`"Name"`) to keep a name with spaces or a reserved word.
+- **Date/time:** native `DATE`/`TIMESTAMP`. Bucket with `date_trunc('month', ts)`, pull parts with `EXTRACT(YEAR FROM ts)`, format with `strftime(ts, '%Y-%m')`, and use `CURRENT_DATE`; cast text with `col::DATE` (or `TRY_CAST(col AS DATE)` to null bad values).
+- **Series:** `FROM generate_series(DATE '2023-01-01', DATE '2023-12-01', INTERVAL 1 MONTH) AS s(d)` builds a date spine (use `range(...)` for integers), then `LEFT JOIN` the aggregated facts onto it so empty periods still appear.
+- **Rolling window over time:** a native calendar-range frame spans real dates and tolerates gaps — `AVG(amount) OVER (ORDER BY day RANGE BETWEEN INTERVAL 29 DAYS PRECEDING AND CURRENT ROW)` is a trailing 30-day average without a spine; guard minimum periods with `COUNT(*) OVER (<same frame>)`.
+- **Integer division:** unlike postgres, `/` is true division (`5 / 2` → `2.5`), so a ratio keeps its fraction; use `//` for floor division (`5 // 2` → `2`) when you want the integer quotient, and round only in the final projection.
+- **Safe cast:** duckdb has `TRY_CAST` — `TRY_CAST(x AS DOUBLE)` yields `NULL` for a value that does not parse instead of raising, so counting residual `NULL`s among non-sentinel rows catches an encoding the sample missed without a regex guard.
+- **Top-N / windows:** filter a window inline with `QUALIFY` — `SELECT ... QUALIFY ROW_NUMBER() OVER (PARTITION BY key ORDER BY x DESC) = 1` returns one row per key without a wrapping CTE; use `ORDER BY ... LIMIT n` for a global top-N.
+- **JSON / semi-structured:** `col->'k'` returns JSON, `col->>'k'` returns text, deep path `json_extract(col, '$.a.b')`; duckdb also has native `STRUCT`, `LIST`, and `MAP` — read a struct field with `col.field` and a list element with `col[1]` (1-indexed).

package/dist/local-adapters.js

@@ -1,3 +1,5 @@
+import { createAthenaLiveDatabaseIntrospection } from './connectors/athena/live-database-introspection.js';
+import { isKtxAthenaConnectionConfig } from './connectors/athena/connector.js';
 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';
@@ -9,6 +11,8 @@ import { isKtxPostgresConnectionConfig } from './connectors/postgres/connector.j
 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 { createDuckDbLiveDatabaseIntrospection } from './connectors/duckdb/live-database-introspection.js';
+import { isKtxDuckDbConnectionConfig } from './connectors/duckdb/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';
@@ -74,6 +78,10 @@ function createKtxCliLiveDatabaseIntrospection(project, options = {}) {
         projectDir: project.projectDir,
         connections: project.config.connections,
     });
+    const duckdb = createDuckDbLiveDatabaseIntrospection({
+        projectDir: project.projectDir,
+        connections: project.config.connections,
+    });
     const mysql = createMysqlLiveDatabaseIntrospection({
         connections: project.config.connections,
     });
@@ -89,6 +97,9 @@ function createKtxCliLiveDatabaseIntrospection(project, options = {}) {
     const bigquery = createBigQueryLiveDatabaseIntrospection({
         connections: project.config.connections,
     });
+    const athena = createAthenaLiveDatabaseIntrospection({
+        connections: project.config.connections,
+    });
     return {
         async extractSchema(connectionId, options) {
             const connection = project.config.connections[connectionId];
@@ -109,6 +120,9 @@ function createKtxCliLiveDatabaseIntrospection(project, options = {}) {
             if (isKtxSqliteConnectionConfig(connection)) {
                 return sqlite.extractSchema(connectionId, options);
             }
+            if (isKtxDuckDbConnectionConfig(connection)) {
+                return duckdb.extractSchema(connectionId, options);
+            }
             if (isKtxMysqlConnectionConfig(connection)) {
                 return mysql.extractSchema(connectionId, options);
             }
@@ -121,6 +135,9 @@ function createKtxCliLiveDatabaseIntrospection(project, options = {}) {
             if (isKtxBigQueryConnectionConfig(connection)) {
                 return bigquery.extractSchema(connectionId, options);
             }
+            if (isKtxAthenaConnectionConfig(connection)) {
+                return athena.extractSchema(connectionId, options);
+            }
             if (hasSnowflakeDriver(connection)) {
                 const { createSnowflakeLiveDatabaseIntrospection } = await import('./connectors/snowflake/live-database-introspection.js');
                 const { isKtxSnowflakeConnectionConfig } = await import('./connectors/snowflake/connector.js');

package/dist/public-ingest.js

@@ -21,6 +21,7 @@ const sourceAdapterByDriver = new Map([
     ['metricflow', 'metricflow'],
     ['dbt', 'dbt'],
     ['lookml', 'lookml'],
+    ['sigma', 'sigma'],
 ]);
 export function publicProgressMessage(message, target) {
     let current = message;

package/dist/setup-databases.d.ts

@@ -9,7 +9,7 @@ import { type DatabaseScopePickResult, type PickDatabaseScopeArgs } from './data
 import type { KtxManagedPythonInstallPolicy } from './managed-python-command.js';
 import type { ManagedPythonCoreDaemonOptions } from './managed-python-http.js';
 import { type KtxSetupPromptOption } from './setup-prompts.js';
-export type KtxSetupDatabaseDriver = 'sqlite' | 'postgres' | 'mysql' | 'clickhouse' | 'sqlserver' | 'bigquery' | 'snowflake' | 'mongodb';
+export type KtxSetupDatabaseDriver = 'sqlite' | 'duckdb' | 'postgres' | 'mysql' | 'clickhouse' | 'sqlserver' | 'bigquery' | 'snowflake' | 'athena' | 'mongodb';
 export interface KtxSetupDatabasesArgs {
     projectDir: string;
     inputMode: 'auto' | 'disabled';

package/dist/setup-databases.js

@@ -37,8 +37,10 @@ const DRIVER_OPTIONS = [
     { value: 'mysql', label: 'MySQL' },
     { value: 'clickhouse', label: 'ClickHouse' },
     { value: 'sqlserver', label: 'SQL Server' },
+    { value: 'athena', label: 'Amazon Athena' },
     { value: 'mongodb', label: 'MongoDB' },
     { value: 'sqlite', label: 'SQLite' },
+    { value: 'duckdb', label: 'DuckDB' },
 ];
 const DRIVER_LABELS = Object.fromEntries(DRIVER_OPTIONS.map((option) => [option.value, option.label]));
 const HISTORIC_SQL_DIALECT_BY_DRIVER = {
@@ -48,12 +50,14 @@ const HISTORIC_SQL_DIALECT_BY_DRIVER = {
 };
 const DEFAULT_CONNECTION_IDS = {
     sqlite: 'sqlite-local',
+    duckdb: 'duckdb-local',
     postgres: 'postgres-warehouse',
     mysql: 'mysql-warehouse',
     clickhouse: 'clickhouse-warehouse',
     sqlserver: 'sqlserver-warehouse',
     bigquery: 'bigquery-warehouse',
     snowflake: 'snowflake-warehouse',
+    athena: 'athena-warehouse',
     mongodb: 'mongodb-source',
 };
 const SUGGESTED_SCOPE_PATTERN = /^(mart|prod|analytics|core|dim|fact|gold)(_|$)/i;
@@ -118,6 +122,13 @@ const SCOPE_DISCOVERY_SPECS = {
         configSingleField: 'schema_name',
         suggest: defaultSuggest,
     },
+    athena: {
+        noun: 'database',
+        nounPlural: 'databases',
+        promptLabel: 'Glue databases',
+        configArrayField: 'databases',
+        suggest: defaultSuggest,
+    },
 };
 const DRIVER_CONNECTION_DEFAULTS = {
     postgres: { port: '5432' },
@@ -541,6 +552,15 @@ async function buildConnectionConfig(input) {
             return 'back';
         return path ? { driver: 'sqlite', path } : null;
     }
+    if (driver === 'duckdb') {
+        if (args.inputMode === 'disabled' && !args.databaseUrl)
+            return null;
+        const path = args.databaseUrl ??
+            (await promptText(prompts, 'DuckDB database file\nEnter a relative or absolute path, for example ./warehouse.duckdb.', stringConfigField(input.existingConnection, 'path')));
+        if (path === undefined)
+            return 'back';
+        return path ? { driver: 'duckdb', path } : null;
+    }
     if (driver === 'postgres' || driver === 'mysql' || driver === 'clickhouse' || driver === 'sqlserver') {
         return await buildUrlConnectionConfig({
             driver,
@@ -664,6 +684,34 @@ async function buildConnectionConfig(input) {
             ...(role ? { role } : {}),
         };
     }
+    if (driver === 'athena') {
+        if (args.inputMode === 'disabled' && !args.databaseUrl)
+            return null;
+        const region = await promptText(prompts, 'AWS region\nFor example us-east-1.', stringConfigField(input.existingConnection, 'region'));
+        if (region === undefined)
+            return 'back';
+        if (!region)
+            return null;
+        const s3StagingDir = await promptText(prompts, 'S3 staging directory\nAthena writes query results here. For example s3://my-bucket/athena-results/.', stringConfigField(input.existingConnection, 's3_staging_dir'));
+        if (s3StagingDir === undefined)
+            return 'back';
+        if (!s3StagingDir)
+            return null;
+        const workgroup = await promptText(prompts, 'Athena workgroup (optional)\nPress Enter to use the default workgroup "primary".', stringConfigField(input.existingConnection, 'workgroup'));
+        if (workgroup === undefined)
+            return 'back';
+        const catalog = await promptText(prompts, 'Glue Data Catalog name (optional)\nPress Enter to use the default "AwsDataCatalog".', stringConfigField(input.existingConnection, 'catalog'));
+        if (catalog === undefined)
+            return 'back';
+        return {
+            driver: 'athena',
+            region,
+            s3_staging_dir: s3StagingDir,
+            ...(workgroup ? { workgroup } : {}),
+            ...(catalog ? { catalog } : {}),
+            ...scriptedScopeConfigForDriver('athena', args.databaseSchemas),
+        };
+    }
     throw new Error(`Unsupported database driver: ${driver}`);
 }
 async function maybeApplyHistoricSqlConfig(input) {
@@ -1031,9 +1079,11 @@ async function maybeConfigureDatabaseScope(input) {
     const project = await loadKtxProject({ projectDir: input.projectDir });
     const connection = project.config.connections[input.connectionId];
     const driver = normalizeDriver(connection?.driver);
-    if (!driver || driver === 'sqlite')
+    const spec = driver ? SCOPE_DISCOVERY_SPECS[driver] : undefined;
+    // Drivers with no scope spec are single-namespace (sqlite, duckdb): there is no
+    // schema to choose, so skip the scope picker and ingest every table.
+    if (!driver || !spec)
         return okValidateResult();
-    const spec = SCOPE_DISCOVERY_SPECS[driver];
     const existingTables = connection?.enabled_tables;
     const hasExistingTables = Array.isArray(existingTables) && existingTables.length > 0;
     const existingScope = spec ? configuredScopeValues(connection, spec) : [];

package/dist/setup-sources.d.ts

@@ -3,7 +3,7 @@ import { type KtxProjectConnectionConfig } from './context/project/config.js';
 import type { KtxCliIo } from './cli-runtime.js';
 import { pickNotionRootPages } from './notion-page-picker.js';
 import { type KtxSetupPromptOption } from './setup-prompts.js';
-export type KtxSetupSourceType = 'dbt' | 'metricflow' | 'metabase' | 'looker' | 'lookml' | 'notion' | 'gdrive';
+export type KtxSetupSourceType = 'dbt' | 'metricflow' | 'metabase' | 'looker' | 'lookml' | 'notion' | 'sigma' | 'gdrive';
 export interface KtxSetupSourcesArgs {
     projectDir: string;
     inputMode: 'auto' | 'disabled';
@@ -99,6 +99,7 @@ export interface KtxSetupSourcesDeps {
     validateLooker?: (projectDir: string, connectionId: string) => Promise<SourceValidationResult>;
     validateLookml?: (connection: KtxProjectConnectionConfig) => Promise<SourceValidationResult>;
     validateNotion?: (connection: KtxProjectConnectionConfig) => Promise<SourceValidationResult>;
+    validateSigma?: (connection: KtxProjectConnectionConfig) => Promise<SourceValidationResult>;
     validateGdrive?: (connection: KtxProjectConnectionConfig) => Promise<SourceValidationResult>;
     pickNotionRootPages?: typeof pickNotionRootPages;
     discoverMetabaseDatabases?: (args: {

package/dist/setup-sources.js

@@ -10,6 +10,8 @@ import { createGoogleDocsClients, verifyGdriveFolderAndCountDocs, } from './cont
 import { gdriveServiceAccountKeySchema } from './context/ingest/adapters/gdrive/types.js';
 import { cloneOrPull, testRepoConnection } from './context/ingest/repo-fetch.js';
 import { DEFAULT_METABASE_CLIENT_CONFIG, MetabaseClient } from './context/ingest/adapters/metabase/client.js';
+import { DEFAULT_SIGMA_CLIENT_CONFIG, DefaultSigmaClient } from './context/ingest/adapters/sigma/client.js';
+import { sigmaRuntimeConfigFromLocalConnection } from './context/ingest/adapters/sigma/local-sigma.adapter.js';
 import { discoverMetabaseDatabases } from './context/ingest/adapters/metabase/mapping.js';
 import { loadDbtSchemaFiles } from './context/ingest/dbt-shared/schema-files.js';
 import { loadProjectInfo } from './context/ingest/dbt-shared/project-vars.js';
@@ -38,6 +40,7 @@ const SOURCE_OPTIONS = [
     { value: 'metricflow', label: 'MetricFlow' },
     { value: 'looker', label: 'Looker' },
     { value: 'lookml', label: 'LookML' },
+    { value: 'sigma', label: 'Sigma Computing' },
     { value: 'gdrive', label: 'Google Drive' },
 ];
 const SOURCE_LABELS = Object.fromEntries(SOURCE_OPTIONS.map((option) => [option.value, option.label]));
@@ -124,6 +127,7 @@ const SOURCE_CREDENTIAL_FLAG = {
     notion: { field: 'sourceAuthTokenRef', flag: '--source-auth-token-ref' },
     metabase: { field: 'sourceApiKeyRef', flag: '--source-api-key-ref' },
     looker: { field: 'sourceClientSecretRef', flag: '--source-client-secret-ref' },
+    sigma: { field: 'sourceClientSecretRef', flag: '--source-client-secret-ref' },
     gdrive: { field: null, flag: '--gdrive-service-account-key-ref' },
 };
 const ALL_SOURCE_CREDENTIAL_FLAGS = [
@@ -422,6 +426,17 @@ function buildNotionConnection(args) {
         max_knowledge_updates_per_run: 20,
     };
 }
+function buildSigmaConnection(args) {
+    if (!args.sourceClientId) {
+        throw new Error('Missing Sigma client id: pass --source-client-id.');
+    }
+    return {
+        driver: 'sigma',
+        api_url: args.sourceUrl ?? 'https://api.sigmacomputing.com',
+        client_id: args.sourceClientId,
+        client_secret_ref: credentialRef(args.sourceClientSecretRef, 'Sigma client secret ref'),
+    };
+}
 function buildGdriveConnection(args) {
     const folderId = args.gdriveFolderId?.trim();
     if (!folderId) {
@@ -544,6 +559,24 @@ async function defaultValidateNotion(connection) {
     }
     return { ok: true, detail: `roots=${roots.length}` };
 }
+async function defaultValidateSigma(connection) {
+    try {
+        const runtimeConfig = sigmaRuntimeConfigFromLocalConnection('sigma-main', connection);
+        const client = new DefaultSigmaClient(runtimeConfig, DEFAULT_SIGMA_CLIENT_CONFIG);
+        try {
+            const result = await client.testConnection();
+            return result.success
+                ? { ok: true, detail: 'Sigma API connection verified' }
+                : { ok: false, message: result.error ?? 'Sigma connection test failed' };
+        }
+        finally {
+            await client.cleanup();
+        }
+    }
+    catch (err) {
+        return { ok: false, message: err instanceof Error ? err.message : String(err) };
+    }
+}
 async function defaultValidateGdrive(connection) {
     const config = parseGdriveConnectionConfig(connection);
     const keyText = await resolveGdriveServiceAccountKey(config.service_account_key_ref);
@@ -1110,6 +1143,45 @@ async function promptForInteractiveSource(args, source, prompts, io, deps, defau
             },
         ]);
     }
+    if (source === 'sigma') {
+        return await runSourcePromptSteps(initialState, () => [
+            ...connectionSteps,
+            async (state) => {
+                const sourceUrl = await promptText(prompts, {
+                    message: 'Sigma API URL',
+                    initialValue: state.sourceUrl ?? 'https://api.sigmacomputing.com',
+                });
+                if (sourceUrl === undefined)
+                    return 'back';
+                state.sourceUrl = sourceUrl;
+                return 'next';
+            },
+            async (state) => {
+                const sourceClientId = await promptText(prompts, {
+                    message: 'Sigma client ID',
+                    ...(state.sourceClientId ? { initialValue: state.sourceClientId } : {}),
+                });
+                if (sourceClientId === undefined)
+                    return 'back';
+                state.sourceClientId = sourceClientId;
+                return 'next';
+            },
+            async (state) => {
+                const ref = await chooseSourceCredentialRef({
+                    prompts,
+                    projectDir: args.projectDir,
+                    label: 'Sigma client secret',
+                    envName: 'SIGMA_CLIENT_SECRET',
+                    secretFileName: `${state.sourceConnectionId ?? 'sigma-main'}-client-secret`,
+                    existingRef: state.sourceClientSecretRef,
+                });
+                if (ref === 'back')
+                    return 'back';
+                state.sourceClientSecretRef = ref;
+                return 'next';
+            },
+        ]);
+    }
     if (source === 'notion') {
         return await runSourcePromptSteps(initialState, (state) => [
             ...connectionSteps,
@@ -1355,6 +1427,12 @@ function sourceArgsFromExistingConnection(input) {
         }
         return sourceArgs;
     }
+    if (input.source === 'sigma') {
+        sourceArgs.sourceUrl = stringField(input.connection.api_url) ?? undefined;
+        sourceArgs.sourceClientId = stringField(input.connection.client_id) ?? undefined;
+        sourceArgs.sourceClientSecretRef = stringField(input.connection.client_secret_ref) ?? undefined;
+        return sourceArgs;
+    }
     if (input.source === 'gdrive') {
         sourceArgs.gdriveServiceAccountKeyRef = stringField(input.connection.service_account_key_ref);
         sourceArgs.gdriveFolderId = stringField(input.connection.folder_id);
@@ -1488,6 +1566,9 @@ function buildConnection(source, args) {
     if (source === 'lookml') {
         return buildLookmlConnection(args);
     }
+    if (source === 'sigma') {
+        return buildSigmaConnection(args);
+    }
     if (source === 'notion') {
         return buildNotionConnection(args);
     }
@@ -1511,6 +1592,9 @@ async function validateSource(source, args, deps) {
     if (source === 'lookml') {
         return await (deps.validateLookml ?? defaultValidateLookml)(args.connection);
     }
+    if (source === 'sigma') {
+        return await (deps.validateSigma ?? defaultValidateSigma)(args.connection);
+    }
     if (source === 'notion') {
         return await (deps.validateNotion ?? defaultValidateNotion)(args.connection);
     }