@kaelio/ktx 0.4.1 → 0.5.0

package/dist/scan.test.js

@@ -1,7 +1,7 @@
 import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { initKtxProject } from '@ktx/context/project';
+import { initKtxProject } from './context/project/project.js';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { createCliScanProgress, runKtxScan } from './scan.js';
 const sqlServerExtractSchema = vi.hoisted(() => vi.fn(async (connectionId) => ({
@@ -66,11 +66,14 @@ const snowflakeExtractSchema = vi.hoisted(() => vi.fn(async (connectionId) => ({
 })));
 const createSnowflakeLiveDatabaseIntrospection = vi.hoisted(() => vi.fn(() => ({ extractSchema: snowflakeExtractSchema })));
 const isKtxSnowflakeConnectionConfig = vi.hoisted(() => vi.fn((connection) => connection?.driver === 'snowflake'));
+const snowflakeConnectorInstances = vi.hoisted(() => []);
 const KtxSnowflakeScanConnector = vi.hoisted(() => class {
     id;
     driver = 'snowflake';
+    cleanup = vi.fn(async () => undefined);
     constructor(options) {
         this.id = `snowflake:${options.connectionId}`;
+        snowflakeConnectorInstances.push(this);
     }
 });
 const postgresExtractSchema = vi.hoisted(() => vi.fn(async (connectionId) => ({
@@ -88,26 +91,34 @@ const KtxPostgresScanConnector = vi.hoisted(() => class {
         this.id = `postgres:${options.connectionId}`;
     }
 });
-vi.mock('@ktx/connector-sqlserver', () => ({
-    createSqlServerLiveDatabaseIntrospection,
+vi.mock('./connectors/sqlserver/connector.js', () => ({
     isKtxSqlServerConnectionConfig,
     KtxSqlServerScanConnector,
 }));
-vi.mock('@ktx/connector-bigquery', () => ({
-    createBigQueryLiveDatabaseIntrospection,
+vi.mock('./connectors/sqlserver/live-database-introspection.js', () => ({
+    createSqlServerLiveDatabaseIntrospection,
+}));
+vi.mock('./connectors/bigquery/connector.js', () => ({
     isKtxBigQueryConnectionConfig,
     KtxBigQueryScanConnector,
 }));
-vi.mock('@ktx/connector-snowflake', () => ({
-    createSnowflakeLiveDatabaseIntrospection,
+vi.mock('./connectors/bigquery/live-database-introspection.js', () => ({
+    createBigQueryLiveDatabaseIntrospection,
+}));
+vi.mock('./connectors/snowflake/connector.js', () => ({
     isKtxSnowflakeConnectionConfig,
     KtxSnowflakeScanConnector,
 }));
-vi.mock('@ktx/connector-postgres', () => ({
-    createPostgresLiveDatabaseIntrospection,
+vi.mock('./connectors/snowflake/live-database-introspection.js', () => ({
+    createSnowflakeLiveDatabaseIntrospection,
+}));
+vi.mock('./connectors/postgres/connector.js', () => ({
     isKtxPostgresConnectionConfig,
     KtxPostgresScanConnector,
 }));
+vi.mock('./connectors/postgres/live-database-introspection.js', () => ({
+    createPostgresLiveDatabaseIntrospection,
+}));
 function makeIo(options = {}) {
     let stdout = '';
     let stderr = '';
@@ -244,6 +255,7 @@ describe('runKtxScan', () => {
         tempDir = await mkdtemp(join(tmpdir(), 'ktx-cli-scan-'));
     });
     afterEach(async () => {
+        vi.unstubAllEnvs();
         await rm(tempDir, { recursive: true, force: true });
     });
     it('runs structural scans and prints a dev-friendly plain summary', async () => {
@@ -294,6 +306,35 @@ describe('runKtxScan', () => {
         expect(io.stdout()).not.toContain('+1');
         expect(io.stdout()).not.toContain('/~');
     });
+    it('emits debug telemetry for completed scans without project paths', async () => {
+        vi.stubEnv('KTX_TELEMETRY_DEBUG', '1');
+        vi.stubEnv('CI', '');
+        await initKtxProject({ projectDir: tempDir });
+        const runLocalScan = vi.fn(async () => ({
+            runId: 'scan-run-1',
+            status: 'done',
+            done: true,
+            connectionId: 'warehouse',
+            mode: 'structural',
+            dryRun: false,
+            syncId: 'sync-1',
+            report,
+        }));
+        const io = makeIo({ isTTY: true });
+        const code = await runKtxScan({
+            command: 'run',
+            projectDir: tempDir,
+            connectionId: 'warehouse',
+            mode: 'structural',
+            detectRelationships: false,
+            dryRun: false,
+            databaseIntrospectionUrl: 'http://127.0.0.1:8765',
+        }, io.io, { runLocalScan, createLocalIngestAdapters: noLocalIngestAdapters });
+        expect(code).toBe(0);
+        expect(io.stderr()).toContain('"event":"scan_completed"');
+        expect(io.stderr()).toContain('"tableCount"');
+        expect(io.stderr()).not.toContain(tempDir);
+    });
     it('passes KTX daemon options to local ingest adapters when no explicit daemon URL is set', async () => {
         await initKtxProject({ projectDir: tempDir });
         const createLocalIngestAdapters = vi.fn(() => []);
@@ -328,6 +369,41 @@ describe('runKtxScan', () => {
             },
         });
     });
+    it('uses runtime IO when resolving managed embedding runtime', async () => {
+        await initKtxProject({ projectDir: tempDir });
+        const runLocalScan = vi.fn(async (_input) => ({
+            runId: 'scan-run-1',
+            status: 'done',
+            done: true,
+            connectionId: 'warehouse',
+            mode: 'structural',
+            dryRun: false,
+            syncId: 'sync-1',
+            report,
+        }));
+        const resolveEmbeddingProvider = vi.fn(async () => ({ kind: 'disabled' }));
+        const io = makeIo();
+        const runtimeIo = makeIo({ isTTY: true });
+        await expect(runKtxScan({
+            command: 'run',
+            projectDir: tempDir,
+            connectionId: 'warehouse',
+            mode: 'structural',
+            detectRelationships: false,
+            dryRun: false,
+            cliVersion: '0.2.0',
+            runtimeInstallPolicy: 'auto',
+        }, io.io, {
+            runLocalScan,
+            createLocalIngestAdapters: noLocalIngestAdapters,
+            runtimeIo: runtimeIo.io,
+            resolveEmbeddingProvider,
+        })).resolves.toBe(0);
+        expect(resolveEmbeddingProvider).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
+            installPolicy: 'auto',
+            io: runtimeIo.io,
+        }));
+    });
     it('explains warnings, capability gaps, and relationships in human scan summaries', async () => {
         await initKtxProject({ projectDir: tempDir });
         const runLocalScan = vi.fn(async (_input) => ({
@@ -753,6 +829,69 @@ describe('runKtxScan', () => {
         }));
         await rm(tempProject, { recursive: true, force: true });
     });
+    it('cleans up a constructed scan connector after an enriched scan succeeds', async () => {
+        await initKtxProject({ projectDir: tempDir });
+        await writeFile(join(tempDir, 'ktx.yaml'), [
+            'connections:',
+            '  warehouse:',
+            '    driver: snowflake',
+            '    account: acct',
+            '    warehouse: WH',
+            '    database: ANALYTICS',
+            '    schema_name: PUBLIC',
+            '    username: reader',
+            '    password: env:SNOWFLAKE_PASSWORD',
+            '',
+        ].join('\n'), 'utf-8');
+        snowflakeConnectorInstances.length = 0;
+        const runLocalScan = vi.fn(async () => ({
+            runId: 'scan-run-cleanup',
+            status: 'done',
+            done: true,
+            connectionId: 'warehouse',
+            mode: 'enriched',
+            dryRun: false,
+            syncId: 'sync-1',
+            report: { ...report, mode: 'enriched' },
+        }));
+        await expect(runKtxScan({
+            command: 'run',
+            projectDir: tempDir,
+            connectionId: 'warehouse',
+            mode: 'enriched',
+            detectRelationships: false,
+            dryRun: false,
+        }, makeIo().io, { runLocalScan, createLocalIngestAdapters: noLocalIngestAdapters })).resolves.toBe(0);
+        expect(snowflakeConnectorInstances[0]?.cleanup).toHaveBeenCalledTimes(1);
+    });
+    it('cleans up a constructed scan connector after runLocalScan throws', async () => {
+        await initKtxProject({ projectDir: tempDir });
+        await writeFile(join(tempDir, 'ktx.yaml'), [
+            'connections:',
+            '  warehouse:',
+            '    driver: snowflake',
+            '    account: acct',
+            '    warehouse: WH',
+            '    database: ANALYTICS',
+            '    schema_name: PUBLIC',
+            '    username: reader',
+            '    password: env:SNOWFLAKE_PASSWORD',
+            '',
+        ].join('\n'), 'utf-8');
+        snowflakeConnectorInstances.length = 0;
+        const runLocalScan = vi.fn(async () => {
+            throw new Error('scan failed');
+        });
+        await expect(runKtxScan({
+            command: 'run',
+            projectDir: tempDir,
+            connectionId: 'warehouse',
+            mode: 'relationships',
+            detectRelationships: true,
+            dryRun: false,
+        }, makeIo().io, { runLocalScan, createLocalIngestAdapters: noLocalIngestAdapters })).resolves.toBe(1);
+        expect(snowflakeConnectorInstances[0]?.cleanup).toHaveBeenCalledTimes(1);
+    });
     it('routes standalone postgres scans through the native connector before daemon fallback', async () => {
         const tempProject = await mkdtemp(join(tmpdir(), 'ktx-scan-cli-native-postgres-'));
         await initKtxProject({ projectDir: tempProject });

package/dist/setup-agents.d.ts

@@ -2,6 +2,7 @@ import type { KtxCliIo } from './cli-runtime.js';
 import { type KtxSetupPromptOption } from './setup-prompts.js';
 export type KtxAgentTarget = 'claude-code' | 'claude-desktop' | 'codex' | 'cursor' | 'opencode' | 'universal';
 export type KtxAgentScope = 'project' | 'global' | 'local';
+/** @internal */
 export type KtxAgentInstallMode = 'mcp' | 'mcp-cli';
 export interface KtxSetupAgentsArgs {
     projectDir: string;
@@ -56,9 +57,9 @@ export interface KtxAgentInstallManifest {
     }>;
 }
 type InstallEntry = KtxAgentInstallManifest['entries'][number];
+/** @internal */
 export declare function createAgentNextActionsLineFormatter(stdout: KtxCliIo['stdout']): (line: string) => string;
-export declare function collectClaudeDesktopForwardedEnv(source: NodeJS.ProcessEnv): Record<string, string>;
-export declare function agentInstallManifestPath(projectDir: string): string;
+/** @internal */
 export declare function plannedKtxAgentFiles(input: {
     projectDir: string;
     target: KtxAgentTarget;
@@ -66,8 +67,9 @@ export declare function plannedKtxAgentFiles(input: {
     mode: KtxAgentInstallMode;
 }): InstallEntry[];
 export declare function readKtxAgentInstallManifest(projectDir: string): Promise<KtxAgentInstallManifest | null>;
+/** @internal */
 export declare function removeKtxAgentInstall(projectDir: string, io: KtxCliIo): Promise<number>;
-export interface KtxSetupAgentsPromptAdapter {
+interface KtxSetupAgentsPromptAdapter {
     select(options: {
         message: string;
         options: KtxSetupPromptOption[];
@@ -83,10 +85,12 @@ export interface KtxSetupAgentsDeps {
     prompts?: KtxSetupAgentsPromptAdapter;
 }
 export declare function targetDisplayName(target: string): string;
+/** @internal */
 export interface InstallSummaryEntry {
     title: string;
     lines: string[];
 }
+/** @internal */
 export declare function formatInstallSummaryLines(installs: Array<{
     target: KtxAgentTarget;
     scope: KtxAgentScope;

package/dist/setup-agents.js

@@ -4,7 +4,9 @@ import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { styleText } from 'node:util';
 import { log, outro } from '@clack/prompts';
-import { loadKtxProject, markKtxSetupStateStepComplete, serializeKtxProjectConfig, } from '@ktx/context/project';
+import { loadKtxProject } from './context/project/project.js';
+import { markKtxSetupStateStepComplete } from './context/project/setup-config.js';
+import { serializeKtxProjectConfig } from './context/project/config.js';
 import { strToU8, zipSync } from 'fflate';
 import { createKtxSetupPromptAdapter, createKtxSetupUiAdapter, } from './setup-prompts.js';
 import { readKtxMcpDaemonStatus } from './managed-mcp-daemon.js';
@@ -37,6 +39,7 @@ function writeSetupOutro(io, message) {
 }
 const STEP_HEADING_RE = /^(\d+)\. (.+)$/;
 const ACTION_MARKER_RE = /^(RUN|PASTE|USE|OPEN):$/;
+/** @internal */
 export function createAgentNextActionsLineFormatter(stdout) {
     const maybeHasColors = stdout.hasColors;
     const supportsColor = typeof maybeHasColors === 'function' && Boolean(maybeHasColors.call(stdout));
@@ -197,7 +200,7 @@ function claudeDesktopConfigPath() {
     return { path, jsonPath: ['mcpServers', 'ktx'] };
 }
 const CLAUDE_DESKTOP_FORWARDED_ENV_KEYS = ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY'];
-export function collectClaudeDesktopForwardedEnv(source) {
+function collectClaudeDesktopForwardedEnv(source) {
     const captured = {};
     for (const [key, value] of Object.entries(source)) {
         if (value === undefined || value === '')
@@ -270,7 +273,7 @@ function plannedMcpJsonEntries(input) {
     }
     return [];
 }
-export function agentInstallManifestPath(projectDir) {
+function agentInstallManifestPath(projectDir) {
     return join(resolve(projectDir), '.ktx/agents/install-manifest.json');
 }
 function claudeDesktopAnalyticsSkillBundlePath(projectDir) {
@@ -282,6 +285,7 @@ function claudeDesktopAdminSkillBundlePath(projectDir) {
 function claudeDesktopLauncherPath(projectDir) {
     return join(resolve(projectDir), '.ktx/agents/claude/ktx-plugin-runner.sh');
 }
+/** @internal */
 export function plannedKtxAgentFiles(input) {
     const withAdminCli = input.mode === 'mcp-cli';
     if (input.scope === 'global') {
@@ -582,6 +586,7 @@ function mergeManifest(projectDir, existing, installs, entries) {
         entries: [...entryMap.values()],
     };
 }
+/** @internal */
 export async function removeKtxAgentInstall(projectDir, io) {
     const manifest = await readKtxAgentInstallManifest(projectDir);
     if (!manifest) {
@@ -676,6 +681,7 @@ function formatInlinePath(path) {
     }
     return path;
 }
+/** @internal */
 export function formatInstallSummaryLines(installs, entries, projectDir) {
     const entriesByTarget = new Map();
     for (const install of installs) {

package/dist/setup-agents.test.js

@@ -1,7 +1,7 @@
 import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { readKtxSetupState } from '@ktx/context/project';
+import { readKtxSetupState } from './context/project/setup-config.js';
 import { strFromU8, unzipSync } from 'fflate';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { createAgentNextActionsLineFormatter, formatInstallSummaryLines, plannedKtxAgentFiles, readKtxAgentInstallManifest, removeKtxAgentInstall, runKtxSetupAgentsStep, } from './setup-agents.js';
@@ -303,7 +303,7 @@ describe('setup agents', () => {
             entries: expect.arrayContaining([{ kind: 'json-key', path: join(tempDir, '.mcp.json'), jsonPath: ['mcpServers', 'ktx'] }]),
         });
     });
-    it('prompts for MCP-first client agent connection mode in interactive setup', async () => {
+    it('prompts for MCP-first agent client connection mode in interactive setup', async () => {
         const io = makeIo();
         const prompts = {
             select: vi.fn(async ({ message }) => (message.startsWith('Where') ? 'project' : 'mcp')),

package/dist/setup-context.d.ts

@@ -2,7 +2,8 @@ import type { KtxCliIo } from './cli-runtime.js';
 import type { KtxManagedPythonInstallPolicy } from './managed-python-command.js';
 import { type ContextBuildSourceProgressUpdate, runContextBuild } from './context-build-view.js';
 import { type KtxSetupPromptOption } from './setup-prompts.js';
-export type KtxSetupContextBuildStatus = 'not_started' | 'completed' | 'failed' | 'stale';
+type KtxSetupContextBuildStatus = 'not_started' | 'completed' | 'failed' | 'stale';
+/** @internal */
 export interface KtxSetupContextCommands {
     build: string;
     status: string;
@@ -30,7 +31,7 @@ export interface KtxSetupContextStatusSummary {
     retryCommand?: string;
     detail?: string;
 }
-export interface KtxSetupContextReadiness {
+interface KtxSetupContextReadiness {
     ready: boolean;
     agentContextReady: boolean;
     semanticSearchReady: boolean;
@@ -63,7 +64,7 @@ export interface KtxSetupContextStepArgs {
     cliVersion?: string;
     runtimeInstallPolicy?: KtxManagedPythonInstallPolicy;
 }
-export interface KtxSetupContextPromptAdapter {
+interface KtxSetupContextPromptAdapter {
     select(options: {
         message: string;
         options: KtxSetupPromptOption[];
@@ -77,10 +78,13 @@ export interface KtxSetupContextDeps {
     runContextBuild?: typeof runContextBuild;
     verifyContextReady?: (projectDir: string) => Promise<KtxSetupContextReadiness>;
 }
-export declare function contextBuildCommands(projectDir: string, runId?: string): KtxSetupContextCommands;
+/** @internal */
+export declare function contextBuildCommands(projectDir: string): KtxSetupContextCommands;
 export declare function readKtxSetupContextState(projectDir: string): Promise<KtxSetupContextState>;
+/** @internal */
 export declare function writeKtxSetupContextState(projectDir: string, state: KtxSetupContextState): Promise<void>;
 export declare function setupContextStatusFromState(state: KtxSetupContextState, options?: {
     completedStep: boolean;
 }): KtxSetupContextStatusSummary;
 export declare function runKtxSetupContextStep(args: KtxSetupContextStepArgs, io: KtxCliIo, deps?: KtxSetupContextDeps): Promise<KtxSetupContextResult>;
+export {};

package/dist/setup-context.js

@@ -1,7 +1,9 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { access, mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { loadKtxProject, markKtxSetupStateStepComplete, readKtxSetupState, serializeKtxProjectConfig, } from '@ktx/context/project';
+import { loadKtxProject } from './context/project/project.js';
+import { markKtxSetupStateStepComplete, readKtxSetupState } from './context/project/setup-config.js';
+import { serializeKtxProjectConfig } from './context/project/config.js';
 import { buildPublicIngestPlan } from './public-ingest.js';
 import { databaseContextDepth, } from './ingest-depth.js';
 import { ensureSetupDatabaseContextDepths } from './setup-database-context-depth.js';
@@ -25,7 +27,8 @@ async function pathExists(path) {
         return false;
     }
 }
-export function contextBuildCommands(projectDir, runId) {
+/** @internal */
+export function contextBuildCommands(projectDir) {
     const resolvedProjectDir = resolve(projectDir);
     return {
         build: `ktx setup --project-dir ${resolvedProjectDir}`,
@@ -74,7 +77,7 @@ function normalizeState(projectDir, value) {
         retryableFailedTargets: Array.isArray(record.retryableFailedTargets)
             ? record.retryableFailedTargets.filter((item) => typeof item === 'string')
             : [],
-        commands: contextBuildCommands(projectDir, runId),
+        commands: contextBuildCommands(projectDir),
         ...(typeof record.failureReason === 'string' ? { failureReason: record.failureReason } : {}),
         ...(normalizeSourceProgress(record.sourceProgress) ? { sourceProgress: normalizeSourceProgress(record.sourceProgress) } : {}),
     };
@@ -128,12 +131,13 @@ export async function readKtxSetupContextState(projectDir) {
     }
     return normalizeState(projectDir, JSON.parse(await readFile(filePath, 'utf-8')));
 }
+/** @internal */
 export async function writeKtxSetupContextState(projectDir, state) {
     const resolvedProjectDir = resolve(projectDir);
     await mkdir(join(resolvedProjectDir, '.ktx', 'setup'), { recursive: true });
     const normalized = normalizeState(resolvedProjectDir, {
         ...state,
-        commands: contextBuildCommands(resolvedProjectDir, state.runId),
+        commands: contextBuildCommands(resolvedProjectDir),
     });
     await writeFile(statePath(resolvedProjectDir), `${JSON.stringify(normalized, null, 2)}\n`, 'utf-8');
 }
@@ -201,8 +205,11 @@ async function readJsonFile(path) {
     try {
         return JSON.parse(await readFile(path, 'utf-8'));
     }
-    catch {
-        return null;
+    catch (error) {
+        if (error instanceof Error && error.code === 'ENOENT') {
+            return null;
+        }
+        throw new Error(`Failed to read JSON file ${path}: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 async function readLatestScanReport(projectDir, connectionId) {
@@ -381,7 +388,7 @@ async function runBuild(args, io, deps, project, targets) {
         reportIds: [],
         artifactPaths: [],
         retryableFailedTargets: [],
-        commands: contextBuildCommands(args.projectDir, runId),
+        commands: contextBuildCommands(args.projectDir),
         failureReason: 'Previous foreground context build did not finish. Rerun setup or ktx ingest.',
     };
     await writeKtxSetupContextState(args.projectDir, incompleteState);
@@ -481,7 +488,7 @@ async function completeExistingContext(args, io, deps, targets) {
         reportIds: [],
         artifactPaths: [],
         retryableFailedTargets: [],
-        commands: contextBuildCommands(args.projectDir, runId),
+        commands: contextBuildCommands(args.projectDir),
     });
     writeExistingContextSuccess(readiness, io);
     return { status: 'ready', projectDir: args.projectDir, runId };

package/dist/setup-context.test.js

@@ -1,7 +1,8 @@
 import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { buildDefaultKtxProjectConfig, parseKtxProjectConfig, readKtxSetupState, serializeKtxProjectConfig, writeKtxSetupState, } from '@ktx/context/project';
+import { buildDefaultKtxProjectConfig, parseKtxProjectConfig, serializeKtxProjectConfig } from './context/project/config.js';
+import { readKtxSetupState, writeKtxSetupState } from './context/project/setup-config.js';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { contextBuildCommands, readKtxSetupContextState, runKtxSetupContextStep, writeKtxSetupContextState, } from './setup-context.js';
 function makeIo() {
@@ -149,7 +150,7 @@ describe('setup context build state', () => {
             reportIds: [],
             artifactPaths: [],
             retryableFailedTargets: [],
-            commands: contextBuildCommands(tempDir, 'setup-context-local-abc123'),
+            commands: contextBuildCommands(tempDir),
             failureReason: 'Previous foreground context build did not finish. Rerun setup or ktx ingest.',
             sourceProgress: [
                 {
@@ -473,7 +474,7 @@ describe('setup context build state', () => {
             reportIds: [],
             artifactPaths: [],
             retryableFailedTargets: [],
-            commands: contextBuildCommands(tempDir, 'setup-context-local-stale'),
+            commands: contextBuildCommands(tempDir),
             failureReason: 'Previous foreground context build did not finish. Rerun setup or ktx ingest.',
         });
         const io = makeIo();

package/dist/setup-database-context-depth.d.ts

@@ -1,4 +1,5 @@
-import { type KtxLocalProject, type KtxProjectConnectionConfig } from '@ktx/context/project';
+import { type KtxLocalProject } from './context/project/project.js';
+import { type KtxProjectConnectionConfig } from './context/project/config.js';
 import type { KtxSetupPromptOption } from './setup-prompts.js';
 export interface KtxSetupDatabaseContextDepthArgs {
     inputMode: 'auto' | 'disabled';

package/dist/setup-database-context-depth.js

@@ -1,5 +1,6 @@
 import { writeFile } from 'node:fs/promises';
-import { loadKtxProject, serializeKtxProjectConfig, } from '@ktx/context/project';
+import { loadKtxProject } from './context/project/project.js';
+import { serializeKtxProjectConfig } from './context/project/config.js';
 import { databaseContextDepth, deepReadinessGaps, isDatabaseDriver, normalizeConnectionDriver, recommendedDatabaseContextDepth, withDatabaseContextDepth, } from './ingest-depth.js';
 function databaseConnectionsNeedingDepth(project) {
     return Object.entries(project.config.connections)

package/dist/setup-databases.d.ts

@@ -1,5 +1,5 @@
-import type { HistoricSqlDialect } from '@ktx/context/ingest';
-import type { KtxTableListEntry } from '@ktx/context/scan';
+import type { HistoricSqlDialect } from './context/ingest/adapters/historic-sql/types.js';
+import type { KtxTableListEntry } from './context/scan/types.js';
 import type { KtxCliIo } from './cli-runtime.js';
 import { type DatabaseScopePickResult, type PickDatabaseScopeArgs } from './database-tree-picker.js';
 import { type KtxSetupPromptOption } from './setup-prompts.js';
@@ -37,6 +37,7 @@ export type KtxSetupDatabasesResult = {
     status: 'failed';
     projectDir: string;
 };
+/** @internal */
 export interface KtxSetupDatabasesPromptAdapter {
     multiselect(options: {
         message: string;
@@ -48,6 +49,14 @@ export interface KtxSetupDatabasesPromptAdapter {
         message: string;
         options: KtxSetupPromptOption[];
     }): Promise<string>;
+    autocompleteMultiselect(options: {
+        message: string;
+        options: KtxSetupPromptOption[];
+        placeholder?: string;
+        required?: boolean;
+        maxItems?: number;
+        initialValues?: string[];
+    }): Promise<string[]>;
     text(options: {
         message: string;
         placeholder?: string;