@kaelio/ktx 0.13.1 → 0.15.0

package/dist/context/wiki/tools/wiki-write.tool.js

@@ -27,6 +27,10 @@ const wikiWriteInputSchema = z.object({
     tags: z.array(z.string()).optional(),
     refs: z.array(z.string()).optional(),
     sl_refs: z.array(z.string()).optional(),
+    connections: z
+        .union([z.string(), z.array(z.string())])
+        .optional()
+        .describe('Connection ids this page applies to. Set [connectionId] on database-specific pages (with a connection-distinctive key); omit or leave empty for org-wide content. REPLACE semantics like tags.'),
     source: z.string().optional(),
     intent: z.string().optional(),
     tables: z.array(z.string()).optional(),
@@ -124,6 +128,28 @@ Keys must be flat file names, not directory paths. Use tags/source frontmatter f
         const resolvedTags = input.tags === undefined ? existingFm?.tags : input.tags;
         const resolvedRefs = input.refs === undefined ? existingFm?.refs : input.refs;
         const resolvedSlRefs = input.sl_refs === undefined ? existingFm?.sl_refs : input.sl_refs;
+        const incomingConnections = input.connections === undefined
+            ? undefined
+            : typeof input.connections === 'string'
+                ? [input.connections]
+                : input.connections;
+        const resolvedConnections = incomingConnections === undefined ? existingFm?.connections : incomingConnections;
+        // Data-loss guard: page keys are a flat global namespace, so a write whose
+        // incoming connection scope is disjoint from an existing same-key page would
+        // silently overwrite a different connection's page. Surface it instead.
+        const existingConnections = existingFm?.connections ?? [];
+        if (existing &&
+            incomingConnections !== undefined &&
+            incomingConnections.length > 0 &&
+            existingConnections.length > 0 &&
+            !incomingConnections.some((id) => existingConnections.includes(id))) {
+            return {
+                markdown: `Error: page "${input.key}" already exists scoped to a different connection ` +
+                    `(connections: ${existingConnections.join(', ')}); writing it for ${incomingConnections.join(', ')} ` +
+                    `would overwrite that page. Use a connection-distinctive key (e.g. "${input.key}_${incomingConnections[0]}").`,
+                structured: { success: false, key: input.key },
+            };
+        }
         let finalContent;
         const finalFm = {
             summary: input.summary,
@@ -132,6 +158,7 @@ Keys must be flat file names, not directory paths. Use tags/source frontmatter f
             tags: resolvedTags,
             refs: resolvedRefs,
             sl_refs: resolvedSlRefs,
+            connections: resolvedConnections,
             source: input.source === undefined ? existingFm?.source : input.source,
             intent: input.intent === undefined ? existingFm?.intent : input.intent,
             tables: input.tables === undefined ? existingFm?.tables : input.tables,

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

@@ -14,6 +14,12 @@ export interface WikiFrontmatter {
     tags?: string[];
     refs?: string[];
     sl_refs?: string[];
+    /**
+     * Connection ids this page applies to. Absent or empty ⇒ unscoped: the page
+     * applies to all connections. Additive metadata, orthogonal to GLOBAL/USER
+     * scope; it does not namespace page keys.
+     */
+    connections?: string[];
     usage_mode: 'always' | 'auto' | 'never';
     sort_order?: number;
     source?: string;

package/dist/context-build-view.d.ts

@@ -48,6 +48,9 @@ export interface ContextBuildArgs {
     scanMode?: Extract<KtxPublicIngestArgs, {
         command: 'run';
     }>['scanMode'];
+    stages?: Extract<KtxPublicIngestArgs, {
+        command: 'run';
+    }>['stages'];
     detectRelationships?: boolean;
     cliVersion?: string;
     runtimeInstallPolicy?: KtxManagedPythonInstallPolicy;

package/dist/context-build-view.js

@@ -750,6 +750,7 @@ export async function runContextBuild(project, args, io, deps = {}) {
         ...(args.queryHistory ? { queryHistory: args.queryHistory } : {}),
         ...(args.queryHistoryWindowDays !== undefined ? { queryHistoryWindowDays: args.queryHistoryWindowDays } : {}),
         ...(args.scanMode ? { scanMode: args.scanMode } : {}),
+        ...(args.stages ? { stages: args.stages } : {}),
         ...(args.detectRelationships !== undefined ? { detectRelationships: args.detectRelationships } : {}),
         ...(args.cliVersion ? { cliVersion: args.cliVersion } : {}),
         ...(args.runtimeInstallPolicy ? { runtimeInstallPolicy: args.runtimeInstallPolicy } : {}),

package/dist/knowledge.d.ts

@@ -5,6 +5,7 @@ export type KtxKnowledgeArgs = {
     command: 'list';
     projectDir: string;
     userId: string;
+    connectionId?: string;
     output?: string;
     json?: boolean;
     cliVersion: string;
@@ -13,6 +14,7 @@ export type KtxKnowledgeArgs = {
     projectDir: string;
     query: string;
     userId: string;
+    connectionId?: string;
     output?: string;
     json?: boolean;
     limit?: number;

package/dist/knowledge.js

@@ -1,5 +1,6 @@
 import { KtxIngestEmbeddingPortAdapter } from './context/llm/embedding-port.js';
 import { loadKtxProject } from './context/project/project.js';
+import { assertConfiguredConnectionId } from './context/connections/configured-connections.js';
 import { listLocalKnowledgePages, readLocalKnowledgePage, searchLocalKnowledgePages as defaultSearchLocalKnowledgePages, } from './context/wiki/local-knowledge.js';
 import { resolveProjectEmbeddingProvider, } from './embedding-resolution.js';
 import { resolveOutputMode } from './io/mode.js';
@@ -57,7 +58,13 @@ export async function runKtxKnowledge(args, io = process, deps = {}) {
     try {
         const project = await loadKtxProject({ projectDir: args.projectDir });
         if (args.command === 'list') {
-            const pages = await listLocalKnowledgePages(project, { userId: args.userId });
+            const connectionId = args.connectionId === undefined
+                ? undefined
+                : assertConfiguredConnectionId(project.config.connections, args.connectionId);
+            const pages = await listLocalKnowledgePages(project, {
+                userId: args.userId,
+                ...(connectionId !== undefined ? { connectionId } : {}),
+            });
             const mode = resolveOutputMode({ explicit: args.output, json: args.json, io });
             printList({
                 rows: pages,
@@ -82,6 +89,9 @@ export async function runKtxKnowledge(args, io = process, deps = {}) {
             return 0;
         }
         if (args.command === 'search') {
+            const connectionId = args.connectionId === undefined
+                ? undefined
+                : assertConfiguredConnectionId(project.config.connections, args.connectionId);
             const embeddingService = await wikiSearchEmbeddingService(project, deps, { cliVersion: args.cliVersion }, io);
             const search = deps.searchLocalKnowledgePages ?? defaultSearchLocalKnowledgePages;
             const results = await search(project, {
@@ -89,6 +99,7 @@ export async function runKtxKnowledge(args, io = process, deps = {}) {
                 userId: args.userId,
                 embeddingService,
                 limit: args.limit,
+                ...(connectionId !== undefined ? { connectionId } : {}),
             });
             await emitTelemetryEvent({
                 name: 'wiki_query_completed',

package/dist/local-adapters.js

@@ -92,6 +92,17 @@ function createKtxCliLiveDatabaseIntrospection(project, options = {}) {
     return {
         async extractSchema(connectionId, options) {
             const connection = project.config.connections[connectionId];
+            if (String(connection?.driver ?? '').toLowerCase() === 'mongodb') {
+                const { createMongoDbLiveDatabaseIntrospection } = await import('./connectors/mongodb/live-database-introspection.js');
+                const { isKtxMongoDbConnectionConfig } = await import('./connectors/mongodb/connector.js');
+                if (!isKtxMongoDbConnectionConfig(connection)) {
+                    return daemon.extractSchema(connectionId, options);
+                }
+                const mongodb = createMongoDbLiveDatabaseIntrospection({
+                    connections: project.config.connections,
+                });
+                return mongodb.extractSchema(connectionId, options);
+            }
             if (isKtxPostgresConnectionConfig(connection)) {
                 return postgres.extractSchema(connectionId, options);
             }

package/dist/mcp-http-server.js

@@ -4,6 +4,7 @@ import { loadKtxProject } from './context/project/project.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { getKtxCliPackageInfo } from './cli-runtime.js';
+import { createMcpLogger, serializeMcpError } from './context/mcp/logger.js';
 import { createKtxMcpServerFactory } from './mcp-server-factory.js';
 const DEFAULT_ALLOWED_HOSTS = ['localhost', '127.0.0.1', '::1'];
 function isLoopbackHost(host) {
@@ -121,12 +122,16 @@ export async function runKtxMcpHttpServer(options) {
     const project = options.createMcpServer === undefined
         ? await (options.loadProject ?? loadKtxProject)({ projectDir: options.projectDir })
         : undefined;
+    // One logger per process, shared by the tool layer (via the factory) and the
+    // transport lifecycle below. Falls back to a no-op sink for programmatic callers.
+    const logger = createMcpLogger(options.io ?? { stdout: { write() { } }, stderr: { write() { } } });
     const createMcpServer = options.createMcpServer ??
         (await createKtxMcpServerFactory({
             project: project,
             projectDir: options.projectDir,
             cliVersion: options.cliVersion ?? getKtxCliPackageInfo().version,
             io: options.io,
+            logger,
         }));
     const sessions = new Map();
     async function newTransport() {
@@ -135,6 +140,7 @@ export async function runKtxMcpHttpServer(options) {
             sessionIdGenerator: () => randomUUID(),
             onsessioninitialized: (sessionId) => {
                 sessions.set(sessionId, transport);
+                logger.info({ sessionId }, 'session.open');
             },
             onsessionclosed: (sessionId) => {
                 sessions.delete(sessionId);
@@ -143,14 +149,21 @@ export async function runKtxMcpHttpServer(options) {
             allowedOrigins: config.allowedOrigins,
             enableDnsRebindingProtection: true,
         });
+        // onclose is the universal session-end signal (clean DELETE and dropped connection both
+        // close the transport), so session.close is logged here rather than in onsessionclosed.
         transport.onclose = () => {
             if (transport.sessionId) {
                 sessions.delete(transport.sessionId);
+                logger.info({ sessionId: transport.sessionId }, 'session.close');
             }
         };
+        transport.onerror = (error) => {
+            logger.error({ ...(transport.sessionId ? { sessionId: transport.sessionId } : {}), err: serializeMcpError(error) }, 'transport.error');
+        };
         await createMcpServer().connect(transport);
         return transport;
     }
+    const startedAt = performance.now();
     const server = createServer(async (req, res) => {
         const path = requestPath(req);
         const auth = isMcpRequestAuthorized({ path, headers: req.headers }, config);
@@ -160,7 +173,8 @@ export async function runKtxMcpHttpServer(options) {
         }
         if (path === '/health' && req.method === 'GET') {
             const port = listenerPort(server, config.port);
-            writeJson(res, 200, { status: 'ok', projectDir: options.projectDir, port });
+            const uptimeMs = Math.round(performance.now() - startedAt);
+            writeJson(res, 200, { status: 'ok', projectDir: options.projectDir, port, uptimeMs });
             return;
         }
         if (path !== '/mcp' || !['POST', 'GET', 'DELETE'].includes(req.method ?? '')) {

package/dist/mcp-server-factory.d.ts

@@ -1,3 +1,4 @@
+import type { KtxMcpLogger } from './context/mcp/logger.js';
 import type { KtxLocalProject } from './context/project/project.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { KtxCliIo } from './cli-runtime.js';
@@ -6,4 +7,5 @@ export declare function createKtxMcpServerFactory(input: {
     projectDir: string;
     cliVersion: string;
     io?: KtxCliIo;
+    logger?: KtxMcpLogger;
 }): Promise<() => McpServer>;

package/dist/mcp-server-factory.js

@@ -2,6 +2,7 @@ import { KtxIngestEmbeddingPortAdapter } from './context/llm/embedding-port.js';
 import { createDefaultKtxMcpServer } from './context/mcp/server.js';
 import { createLocalProjectMcpContextPorts } from './context/mcp/local-project-ports.js';
 import { createLocalProjectMemoryIngest } from './context/memory/local-memory.js';
+import { assertConfiguredConnectionId } from './context/connections/configured-connections.js';
 import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
 import { createKtxCliScanConnector } from './local-scan-connectors.js';
@@ -47,11 +48,23 @@ export async function createKtxMcpServerFactory(input) {
     });
     let memoryIngest;
     try {
-        memoryIngest = createLocalProjectMemoryIngest(input.project, {
+        const baseMemoryIngest = createLocalProjectMemoryIngest(input.project, {
             semanticLayerCompute,
             queryExecutor,
             embeddingProvider,
         });
+        // Validate the explicit connectionId argument here so a typo is rejected with the
+        // configured ids before the ingest run starts; persisted page scope is validated
+        // separately (warn-only) and must not fail.
+        memoryIngest = {
+            ingest: (ingestInput) => {
+                if (ingestInput.connectionId !== undefined) {
+                    assertConfiguredConnectionId(input.project.config.connections, ingestInput.connectionId);
+                }
+                return baseMemoryIngest.ingest(ingestInput);
+            },
+            status: (runId) => baseMemoryIngest.status(runId),
+        };
     }
     catch (error) {
         io.stderr.write(`ktx MCP memory_ingest disabled: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -62,6 +75,7 @@ export async function createKtxMcpServerFactory(input) {
         userContext: { userId: 'local' },
         projectDir: input.projectDir,
         io,
+        ...(input.logger ? { logger: input.logger } : {}),
         contextTools: {
             ...contextTools,
             ...(memoryIngest ? { memoryIngest } : {}),

package/dist/mcp-stdio-server.js

@@ -2,6 +2,7 @@ import process from 'node:process';
 import { loadKtxProject } from './context/project/project.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { getKtxCliPackageInfo } from './cli-runtime.js';
+import { createMcpLogger, serializeMcpError } from './context/mcp/logger.js';
 import { createKtxMcpServerFactory } from './mcp-server-factory.js';
 export async function runKtxMcpStdioServer(options) {
     const project = options.createMcpServer === undefined
@@ -11,12 +12,15 @@ export async function runKtxMcpStdioServer(options) {
         stdout: { write() { } },
         stderr: options.io?.stderr ?? process.stderr,
     };
+    // stdout is reserved for JSON-RPC, so the logger writes to stderr only.
+    const logger = createMcpLogger(protocolIo);
     const createMcpServer = options.createMcpServer ??
         (await createKtxMcpServerFactory({
             project: project,
             projectDir: options.projectDir,
             cliVersion: options.cliVersion ?? getKtxCliPackageInfo().version,
             io: protocolIo,
+            logger,
         }));
     const stdin = options.stdin ?? process.stdin;
     const transport = new StdioServerTransport(stdin, options.stdout);
@@ -35,13 +39,17 @@ export async function runKtxMcpStdioServer(options) {
                 settle(() => reject(error instanceof Error ? error : new Error(String(error))));
             });
         };
-        transport.onclose = () => settle(resolve);
+        transport.onclose = () => {
+            logger.info({}, 'session.close');
+            settle(resolve);
+        };
         transport.onerror = (error) => {
-            options.io?.stderr.write(`ktx MCP stdio transport error: ${error.message}\n`);
+            logger.error({ err: serializeMcpError(error) }, 'transport.error');
             settle(() => reject(error));
         };
         stdin.once('end', closeTransport);
         stdin.once('close', closeTransport);
+        logger.info({}, 'session.open');
         createMcpServer().connect(transport).catch((error) => {
             settle(() => reject(error instanceof Error ? error : new Error(String(error))));
         });

package/dist/notion-page-picker.js

@@ -7,7 +7,7 @@ profileMark('module:notion-page-picker');
 const NOTION_PICKER_PAGE_CAP = 5000;
 const NOTION_SCRIPTED_MODE_HINT = 'Notion picker requires a TTY. Use --no-input --notion-root-page-id <UUID> for scripted mode.';
 function assertSafeNotionPickerConnectionId(connectionId) {
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(connectionId)) {
+    if (!/^[a-zA-Z0-9_][a-zA-Z0-9_-]*$/.test(connectionId)) {
         throw new Error(`Unsafe connection id: ${connectionId}`);
     }
 }

package/dist/prompts/memory_agent_external_ingest.md

@@ -19,6 +19,8 @@ A single artifact typically produces multiple actions: one SL source per table/v
 
 <scope>
 All wiki writes go to the GLOBAL scope - they will be visible to every user of this ktx project. Phrase wiki pages as objective business knowledge, not personal preference. The `wiki_write` tool handles scope selection automatically for external ingest.
+
+When a `connectionId` is shown in the prompt context, tag database-specific pages with `connections: [<that id>]` and give them connection-distinctive keys (`orders_sales_db`, not `orders`) so same-concept pages from other databases do not collide or pollute each other's searches. Leave `connections` empty for org-wide knowledge that applies across every database. See the `wiki_capture` skill's "Connection scoping" section.
 </scope>
 
 <do_not>

package/dist/public-ingest.d.ts

@@ -5,7 +5,7 @@ import type { KtxIngestArgs, KtxIngestDeps, KtxIngestProgressUpdate } from './in
 import { type KtxManagedPythonInstallPolicy, type ManagedPythonCommandRuntime } from './managed-python-command.js';
 import type { KtxRuntimeFeature } from './managed-python-runtime.js';
 import type { KtxScanArgs, KtxScanDeps } from './scan.js';
-import type { KtxTableRef } from './context/scan/types.js';
+import type { KtxScanEnrichmentStage, KtxTableRef } from './context/scan/types.js';
 type KtxPublicIngestStepName = 'database-schema' | 'query-history' | 'source-ingest' | 'memory-update';
 type KtxPublicIngestStepStatus = 'done' | 'skipped' | 'failed' | 'not-run';
 type KtxPublicIngestInputMode = 'auto' | 'disabled';
@@ -23,6 +23,7 @@ export type KtxPublicIngestArgs = {
     scanMode?: Extract<KtxScanArgs, {
         command: 'run';
     }>['mode'];
+    stages?: KtxScanEnrichmentStage[];
     detectRelationships?: boolean;
     cliVersion?: string;
     runtimeInstallPolicy?: KtxManagedPythonInstallPolicy;
@@ -95,6 +96,7 @@ interface KtxPublicContextBuildArgs {
     scanMode?: Extract<KtxScanArgs, {
         command: 'run';
     }>['mode'];
+    stages?: KtxScanEnrichmentStage[];
     detectRelationships?: boolean;
     cliVersion?: string;
     runtimeInstallPolicy?: KtxManagedPythonInstallPolicy;

package/dist/public-ingest.js

@@ -17,9 +17,11 @@ const sourceAdapterByDriver = new Map([
     ['local_metabase', 'metabase'],
     ['looker', 'looker'],
     ['notion', 'notion'],
+    ['gdrive', 'gdrive'],
     ['metricflow', 'metricflow'],
     ['dbt', 'dbt'],
     ['lookml', 'lookml'],
+    ['sigma', 'sigma'],
 ]);
 export function publicProgressMessage(message, target) {
     let current = message;
@@ -612,6 +614,7 @@ async function runIngestTargetSteps(target, args, io, deps, project) {
             mode: 'enriched',
             detectRelationships: target.detectRelationships === true,
             dryRun: false,
+            ...(args.stages ? { stages: args.stages } : {}),
             ...(args.cliVersion ? { cliVersion: args.cliVersion } : {}),
             ...(args.runtimeInstallPolicy ? { runtimeInstallPolicy: args.runtimeInstallPolicy } : {}),
         };
@@ -764,6 +767,7 @@ export async function runKtxPublicIngest(args, io, deps = {}) {
                 ...(args.queryHistory ? { queryHistory: args.queryHistory } : {}),
                 ...(args.queryHistoryWindowDays !== undefined ? { queryHistoryWindowDays: args.queryHistoryWindowDays } : {}),
                 ...(args.scanMode ? { scanMode: args.scanMode } : {}),
+                ...(args.stages ? { stages: args.stages } : {}),
                 ...(args.detectRelationships !== undefined ? { detectRelationships: args.detectRelationships } : {}),
                 ...(args.cliVersion ? { cliVersion: args.cliVersion } : {}),
                 ...(args.runtimeInstallPolicy ? { runtimeInstallPolicy: args.runtimeInstallPolicy } : {}),

package/dist/scan.d.ts

@@ -1,4 +1,4 @@
-import type { KtxProgressPort, KtxScanMode } from './context/scan/types.js';
+import type { KtxProgressPort, KtxScanEnrichmentStage, KtxScanMode } from './context/scan/types.js';
 import { runLocalScan } from './context/scan/local-scan.js';
 import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import type { KtxCliIo } from './index.js';
@@ -11,6 +11,8 @@ export interface KtxScanArgs {
     mode: KtxScanMode;
     detectRelationships: boolean;
     dryRun: boolean;
+    /** Enrichment stages to (re)run; omit to run all eligible stages. */
+    stages?: KtxScanEnrichmentStage[];
     databaseIntrospectionUrl?: string;
     cliVersion?: string;
     runtimeInstallPolicy?: KtxManagedPythonInstallPolicy;

package/dist/scan.js

@@ -134,8 +134,14 @@ function describeWarningGroup(code, count) {
             return `${count} LLM relationship ${plural(count, 'proposal')} failed.`;
         case 'scan_enrichment_backend_not_configured':
             return 'Scan enrichment backend is not configured; AI stages were skipped.';
+        case 'enrichment_stage_skipped':
+            return `${count} requested ${plural(count, 'enrichment stage')} could not run (prerequisite missing).`;
+        case 'enrichment_stage_stale':
+            return `${count} enrichment ${plural(count, 'stage')} are stale after a selective run; re-run them to refresh.`;
         case 'credential_redacted':
             return `${count} ${plural(count, 'credential')} were redacted from scan output.`;
+        case 'object_introspection_failed':
+            return `${count} ${plural(count, 'object')} skipped during introspection (broken or inaccessible objects were excluded; the rest were ingested).`;
         default:
             return `${count} ${plural(count, 'warning')} (${code})`;
     }
@@ -272,6 +278,7 @@ export async function runKtxScan(args, io = process, deps = {}) {
                 connectionId: args.connectionId,
                 mode: args.mode,
                 detectRelationships: args.detectRelationships,
+                ...(args.stages ? { stages: args.stages } : {}),
                 dryRun: args.dryRun,
                 trigger: 'cli',
                 databaseIntrospectionUrl: args.databaseIntrospectionUrl,

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';
+export type KtxSetupDatabaseDriver = 'sqlite' | 'postgres' | 'mysql' | 'clickhouse' | 'sqlserver' | 'bigquery' | 'snowflake' | 'mongodb';
 export interface KtxSetupDatabasesArgs {
     projectDir: string;
     inputMode: 'auto' | 'disabled';

package/dist/setup-databases.js

@@ -37,6 +37,7 @@ const DRIVER_OPTIONS = [
     { value: 'mysql', label: 'MySQL' },
     { value: 'clickhouse', label: 'ClickHouse' },
     { value: 'sqlserver', label: 'SQL Server' },
+    { value: 'mongodb', label: 'MongoDB' },
     { value: 'sqlite', label: 'SQLite' },
 ];
 const DRIVER_LABELS = Object.fromEntries(DRIVER_OPTIONS.map((option) => [option.value, option.label]));
@@ -53,6 +54,7 @@ const DEFAULT_CONNECTION_IDS = {
     sqlserver: 'sqlserver-warehouse',
     bigquery: 'bigquery-warehouse',
     snowflake: 'snowflake-warehouse',
+    mongodb: 'mongodb-source',
 };
 const SUGGESTED_SCOPE_PATTERN = /^(mart|prod|analytics|core|dim|fact|gold)(_|$)/i;
 const EXCLUDED_SCOPE_PATTERN = /^(information_schema|pg_catalog|pg_toast|_airbyte_|mysql$|performance_schema$|sys$)/i;
@@ -85,6 +87,13 @@ const SCOPE_DISCOVERY_SPECS = {
         configArrayField: 'databases',
         suggest: defaultSuggest,
     },
+    mongodb: {
+        noun: 'database',
+        nounPlural: 'databases',
+        promptLabel: 'MongoDB databases',
+        configArrayField: 'databases',
+        suggest: defaultSuggest,
+    },
     sqlserver: {
         noun: 'schema',
         nounPlural: 'schemas',
@@ -152,7 +161,7 @@ function unique(values) {
     return [...new Set(values.filter((value) => value.trim().length > 0))];
 }
 function assertSafeDatabaseConnectionId(connectionId) {
-    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(connectionId)) {
+    if (!/^[a-zA-Z0-9_][a-zA-Z0-9_-]*$/.test(connectionId)) {
         throw new Error(`Unsafe connection id: ${connectionId}`);
     }
 }
@@ -496,6 +505,31 @@ async function buildUrlConnectionConfig(input) {
         return result;
     }
 }
+async function buildMongoConnectionConfig(input) {
+    if (input.args.inputMode === 'disabled' && !input.args.databaseUrl)
+        return null;
+    const rawUrl = input.args.databaseUrl ??
+        (await promptText(input.prompts, 'MongoDB connection URL\nFor example mongodb+srv://user:pass@cluster.example.net/app.', // pragma: allowlist secret
+        stringConfigField(input.existingConnection, 'url')));
+    if (rawUrl === undefined)
+        return 'back';
+    if (!rawUrl)
+        return null;
+    const url = normalizeInputReference(rawUrl);
+    const scope = scriptedScopeConfigForDriver('mongodb', input.args.databaseSchemas);
+    if (url.startsWith('env:') || url.startsWith('file:')) {
+        return { driver: 'mongodb', url, ...scope };
+    }
+    if (urlHasCredentials(url)) {
+        const ref = await writeProjectLocalSecretReference({
+            projectDir: input.args.projectDir,
+            fileName: `${input.connectionId}-url`,
+            value: url,
+        });
+        return { driver: 'mongodb', url: ref, ...scope };
+    }
+    return { driver: 'mongodb', url, ...scope };
+}
 async function buildConnectionConfig(input) {
     const { driver, args, prompts } = input;
     if (driver === 'sqlite') {
@@ -516,6 +550,14 @@ async function buildConnectionConfig(input) {
             existingConnection: input.existingConnection,
         });
     }
+    if (driver === 'mongodb') {
+        return await buildMongoConnectionConfig({
+            connectionId: input.connectionId,
+            args,
+            prompts,
+            existingConnection: input.existingConnection,
+        });
+    }
     if (driver === 'bigquery') {
         const credentialsPath = await promptText(prompts, 'Path to service account JSON file', displayFileReference(stringConfigField(input.existingConnection, 'credentials_json')));
         if (credentialsPath === undefined)

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';
+export type KtxSetupSourceType = 'dbt' | 'metricflow' | 'metabase' | 'looker' | 'lookml' | 'notion' | 'sigma' | 'gdrive';
 export interface KtxSetupSourcesArgs {
     projectDir: string;
     inputMode: 'auto' | 'disabled';
@@ -25,6 +25,9 @@ export interface KtxSetupSourcesArgs {
     metabaseDatabaseId?: number;
     notionCrawlMode?: 'all_accessible' | 'selected_roots';
     notionRootPageIds?: string[];
+    gdriveServiceAccountKeyRef?: string;
+    gdriveFolderId?: string;
+    gdriveRecursive?: boolean;
     runInitialSourceIngest: boolean;
     skipSources: boolean;
 }
@@ -96,6 +99,8 @@ 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: {
         sourceUrl: string;