@kaelio/ktx 0.4.0 → 0.5.0

package/dist/embedding-resolution.test.js

@@ -0,0 +1,132 @@
+import { describe, expect, it, vi } from 'vitest';
+import { buildDefaultKtxProjectConfig } from './context/project/config.js';
+import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
+function projectWithConfig(config) {
+    return {
+        projectDir: '/work/proj',
+        configPath: '/work/proj/ktx.yaml',
+        config,
+        coreConfig: {},
+        git: {},
+        fileStore: {},
+    };
+}
+function withManagedEmbedding(config, base_url) {
+    return {
+        ...config,
+        ingest: {
+            ...config.ingest,
+            embeddings: {
+                backend: 'sentence-transformers',
+                model: 'all-MiniLM-L6-v2',
+                dimensions: 384,
+                ...(base_url === undefined
+                    ? {}
+                    : { sentenceTransformers: { base_url, pathPrefix: '' } }),
+            },
+        },
+    };
+}
+const noopIo = {
+    stdout: { write: (_chunk) => { } },
+    stderr: { write: (_chunk) => { } },
+};
+const fakeDaemon = {
+    baseUrl: 'http://127.0.0.1:51234',
+    stdoutLog: '/tmp/o',
+    stderrLog: '/tmp/e',
+};
+describe('resolveProjectEmbeddingProvider', () => {
+    it('returns disabled when backend is none', async () => {
+        const project = projectWithConfig(buildDefaultKtxProjectConfig());
+        const result = await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
+            cliVersion: '0.5.0',
+            io: noopIo,
+        });
+        expect(result.kind).toBe('disabled');
+    });
+    it('returns a configured provider when base_url is explicit', async () => {
+        const project = projectWithConfig(withManagedEmbedding(buildDefaultKtxProjectConfig(), 'http://my-st:8080'));
+        const createKtxEmbeddingProvider = vi.fn(() => ({ id: 'fake' }));
+        const result = await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
+            cliVersion: '0.5.0',
+            io: noopIo,
+            createKtxEmbeddingProvider,
+        });
+        expect(result.kind).toBe('configured');
+        expect(createKtxEmbeddingProvider).toHaveBeenCalledOnce();
+    });
+    it('connects to the running managed daemon when base_url is omitted', async () => {
+        const project = projectWithConfig(withManagedEmbedding(buildDefaultKtxProjectConfig(), undefined));
+        const tryUseManaged = vi.fn(async () => fakeDaemon);
+        const createKtxEmbeddingProvider = vi.fn(() => ({ id: 'fake' }));
+        const ensureManaged = vi.fn(async () => fakeDaemon);
+        const result = await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
+            cliVersion: '0.5.0',
+            io: noopIo,
+            createKtxEmbeddingProvider,
+            tryUseManagedDaemon: tryUseManaged,
+            ensureManagedDaemon: ensureManaged,
+        });
+        expect(result.kind).toBe('managed-running');
+        expect(tryUseManaged).toHaveBeenCalledOnce();
+        expect(ensureManaged).not.toHaveBeenCalled();
+    });
+    it('passes pathPrefix="" to the embedding provider when targeting the managed daemon', async () => {
+        const project = projectWithConfig(withManagedEmbedding(buildDefaultKtxProjectConfig(), undefined));
+        const tryUseManaged = vi.fn(async () => fakeDaemon);
+        const createKtxEmbeddingProvider = vi.fn(() => ({ id: 'fake' }));
+        await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
+            cliVersion: '0.5.0',
+            io: noopIo,
+            createKtxEmbeddingProvider,
+            tryUseManagedDaemon: tryUseManaged,
+        });
+        expect(createKtxEmbeddingProvider).toHaveBeenCalledWith(expect.objectContaining({
+            sentenceTransformers: expect.objectContaining({
+                baseURL: fakeDaemon.baseUrl,
+                pathPrefix: '',
+            }),
+        }));
+    });
+    it('returns managed-unavailable when no daemon is running and mode is use-if-running', async () => {
+        const project = projectWithConfig(withManagedEmbedding(buildDefaultKtxProjectConfig(), ''));
+        const tryUseManaged = vi.fn(async () => null);
+        const ensureManaged = vi.fn(async () => fakeDaemon);
+        const result = await resolveProjectEmbeddingProvider(project, {
+            mode: 'use-if-running',
+            cliVersion: '0.5.0',
+            io: noopIo,
+            tryUseManagedDaemon: tryUseManaged,
+            ensureManagedDaemon: ensureManaged,
+        });
+        expect(result.kind).toBe('managed-unavailable');
+        expect(ensureManaged).not.toHaveBeenCalled();
+    });
+    it('starts the managed daemon when mode is ensure', async () => {
+        const project = projectWithConfig(withManagedEmbedding(buildDefaultKtxProjectConfig(), undefined));
+        const tryUseManaged = vi.fn(async () => null);
+        const ensureManaged = vi.fn(async () => fakeDaemon);
+        const createKtxEmbeddingProvider = vi.fn(() => ({ id: 'fake' }));
+        const result = await resolveProjectEmbeddingProvider(project, {
+            mode: 'ensure',
+            installPolicy: 'auto',
+            cliVersion: '0.5.0',
+            io: noopIo,
+            createKtxEmbeddingProvider,
+            tryUseManagedDaemon: tryUseManaged,
+            ensureManagedDaemon: ensureManaged,
+        });
+        expect(result.kind).toBe('managed-started');
+        expect(ensureManaged).toHaveBeenCalledWith({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+            installPolicy: 'auto',
+            io: noopIo,
+        });
+    });
+});

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export { runKtxRuntime, type KtxRuntimeArgs, type KtxRuntimeDeps } from './runti
 export { runKtxSql, type KtxSqlArgs, type KtxSqlDeps } from './sql.js';
 export { allocateDaemonPort, readManagedPythonDaemonStatus, stopAllManagedPythonDaemons, startManagedPythonDaemon, stopManagedPythonDaemon, } from './managed-python-daemon.js';
 export type { ManagedPythonDaemonProcessInfo, ManagedPythonDaemonStartResult, ManagedPythonDaemonState, ManagedPythonDaemonStatus, ManagedPythonDaemonStopAllEntry, ManagedPythonDaemonStopAllFailure, ManagedPythonDaemonStopAllResult, ManagedPythonDaemonStopResult, } from './managed-python-daemon.js';
-export { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, managedLocalEmbeddingProjectConfig, type ManagedLocalEmbeddingsDaemon, type ManagedLocalEmbeddingsOptions, } from './managed-local-embeddings.js';
+export { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, type ManagedLocalEmbeddingsDaemon, type ManagedLocalEmbeddingsOptions, } from './managed-local-embeddings.js';
 export type { KtxMemoryFlowTuiIo, MemoryFlowTuiLiveSession } from './memory-flow-tui.js';
 export { renderMemoryFlowTui, sanitizeMemoryFlowTuiError, startLiveMemoryFlowTui, } from './memory-flow-tui.js';
 export { rendererUnavailableVizFallback, resolveVizFallback, warnVizFallbackOnce } from './viz-fallback.js';

package/dist/index.js

@@ -7,7 +7,7 @@ export { runKtxSetupSourcesStep } from './setup-sources.js';
 export { runKtxRuntime } from './runtime.js';
 export { runKtxSql } from './sql.js';
 export { allocateDaemonPort, readManagedPythonDaemonStatus, stopAllManagedPythonDaemons, startManagedPythonDaemon, stopManagedPythonDaemon, } from './managed-python-daemon.js';
-export { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, managedLocalEmbeddingProjectConfig, } from './managed-local-embeddings.js';
+export { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, } from './managed-local-embeddings.js';
 export { renderMemoryFlowTui, sanitizeMemoryFlowTuiError, startLiveMemoryFlowTui, } from './memory-flow-tui.js';
 export { rendererUnavailableVizFallback, resolveVizFallback, warnVizFallbackOnce } from './viz-fallback.js';
 profileMark('module:index');

package/dist/index.test.js

@@ -2,10 +2,12 @@ import { mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 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 { getKtxCliPackageInfo, packageInfoFromJson, rendererUnavailableVizFallback, renderMemoryFlowTui, resolveVizFallback, runKtxCli, sanitizeMemoryFlowTuiError, startLiveMemoryFlowTui, warnVizFallbackOnce, } from './index.js';
 const require = createRequire(import.meta.url);
+const cliPackageJson = require('@kaelio/ktx/package.json');
+const cliVersion = cliPackageJson.version;
 function makeIo(options = {}) {
     let stdout = '';
     let stderr = '';
@@ -28,19 +30,19 @@ function makeIo(options = {}) {
     };
 }
 describe('getKtxCliPackageInfo', () => {
-    it('identifies the CLI package and its context dependency', () => {
+    it('identifies the CLI package', () => {
         expect(getKtxCliPackageInfo()).toEqual({
-            name: '@ktx/cli',
-            version: '0.0.0-private',
-            contextPackageName: '@ktx/context',
+            name: '@kaelio/ktx',
+            version: cliVersion,
         });
     });
     it('exports package metadata for package managers and runtime diagnostics', () => {
-        const packageJson = require('@ktx/cli/package.json');
+        const packageJson = require('@kaelio/ktx/package.json');
         expect(packageJson).toMatchObject({
-            name: '@ktx/cli',
-            version: '0.0.0-private',
+            name: '@kaelio/ktx',
+            version: cliVersion,
         });
+        expect(cliVersion).toMatch(/^\d+\.\d+\.\d+/);
     });
     it('normalizes public package metadata from package.json contents', () => {
         expect(packageInfoFromJson({
@@ -49,7 +51,6 @@ describe('getKtxCliPackageInfo', () => {
         })).toEqual({
             name: '@kaelio/ktx',
             version: '0.1.0',
-            contextPackageName: '@ktx/context',
         });
     });
 });
@@ -86,7 +87,7 @@ describe('runKtxCli', () => {
     it('prints version information', async () => {
         const testIo = makeIo();
         await expect(runKtxCli(['--version'], testIo.io)).resolves.toBe(0);
-        expect(testIo.stdout()).toBe('@ktx/cli 0.0.0-private\n');
+        expect(testIo.stdout()).toBe(`@kaelio/ktx ${cliVersion}\n`);
         expect(testIo.stderr()).toBe('');
     });
     it('prints the public command surface in root help', async () => {
@@ -114,41 +115,41 @@ describe('runKtxCli', () => {
         const listIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, 'wiki', '--json'], listIo.io, { knowledge }))
             .resolves.toBe(0);
-        expect(knowledge).toHaveBeenCalledWith({
+        expect(knowledge).toHaveBeenCalledWith(expect.objectContaining({
             command: 'list',
             projectDir: tempDir,
             userId: 'local',
             json: true,
-        }, listIo.io);
+        }), listIo.io);
         const searchIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, 'wiki', 'revenue', '--limit', '5'], searchIo.io, { knowledge })).resolves.toBe(0);
-        expect(knowledge).toHaveBeenLastCalledWith({
+        expect(knowledge).toHaveBeenLastCalledWith(expect.objectContaining({
             command: 'search',
             projectDir: tempDir,
             query: 'revenue',
             userId: 'local',
             json: false,
             limit: 5,
-        }, searchIo.io);
+        }), searchIo.io);
         const debugSearchIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, '--debug', 'wiki', 'revenue'], debugSearchIo.io, { knowledge })).resolves.toBe(0);
-        expect(knowledge).toHaveBeenLastCalledWith({
+        expect(knowledge).toHaveBeenLastCalledWith(expect.objectContaining({
             command: 'search',
             projectDir: tempDir,
             query: 'revenue',
             userId: 'local',
             json: false,
             debug: true,
-        }, debugSearchIo.io);
+        }), debugSearchIo.io);
         const multiWordIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, 'wiki', 'revenue', 'policy'], multiWordIo.io, { knowledge })).resolves.toBe(0);
-        expect(knowledge).toHaveBeenLastCalledWith({
+        expect(knowledge).toHaveBeenLastCalledWith(expect.objectContaining({
             command: 'search',
             projectDir: tempDir,
             query: 'revenue policy',
             userId: 'local',
             json: false,
-        }, multiWordIo.io);
+        }), multiWordIo.io);
     });
     it('rejects unknown write-style flags on the flattened wiki and sl commands', async () => {
         const knowledge = vi.fn(async () => 0);
@@ -166,7 +167,7 @@ describe('runKtxCli', () => {
         const sl = vi.fn(async () => 0);
         const searchIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, 'sl', 'revenue', '--connection-id', 'warehouse', '--limit', '5', '--json'], searchIo.io, { sl })).resolves.toBe(0);
-        expect(sl).toHaveBeenCalledWith({
+        expect(sl).toHaveBeenCalledWith(expect.objectContaining({
             command: 'search',
             projectDir: tempDir,
             connectionId: 'warehouse',
@@ -174,16 +175,16 @@ describe('runKtxCli', () => {
             limit: 5,
             json: true,
             output: undefined,
-        }, searchIo.io);
+        }), searchIo.io);
         const bareIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, 'sl', '--connection-id', 'warehouse', '--json'], bareIo.io, { sl })).resolves.toBe(0);
-        expect(sl).toHaveBeenLastCalledWith({
+        expect(sl).toHaveBeenLastCalledWith(expect.objectContaining({
             command: 'list',
             projectDir: tempDir,
             connectionId: 'warehouse',
             json: true,
             output: undefined,
-        }, bareIo.io);
+        }), bareIo.io);
         const unknownIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, 'sl', '--query', 'revenue'], unknownIo.io, { sl })).resolves.toBe(1);
         expect(unknownIo.stderr()).toContain("unknown option '--query'");
@@ -206,32 +207,32 @@ describe('runKtxCli', () => {
         await expect(runKtxCli(['admin', 'runtime', 'prune', '--dry-run'], pruneIo.io, { runtime })).resolves.toBe(1);
         expect(runtime).toHaveBeenNthCalledWith(1, {
             command: 'install',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             feature: 'local-embeddings',
             force: true,
         }, installIo.io);
         expect(runtime).toHaveBeenNthCalledWith(2, {
             command: 'start',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             projectDir: expect.any(String),
             feature: 'local-embeddings',
             force: true,
         }, startIo.io);
         expect(runtime).toHaveBeenNthCalledWith(3, {
             command: 'stop',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             projectDir: expect.any(String),
             all: false,
         }, stopIo.io);
         expect(runtime).toHaveBeenNthCalledWith(4, {
             command: 'stop',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             projectDir: expect.any(String),
             all: true,
         }, stopAllIo.io);
         expect(runtime).toHaveBeenNthCalledWith(5, {
             command: 'status',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             json: true,
         }, statusIo.io);
         expect(runtime).toHaveBeenCalledTimes(5);
@@ -278,7 +279,7 @@ describe('runKtxCli', () => {
         expect(sl).toHaveBeenLastCalledWith(expect.objectContaining({
             command: 'query',
             projectDir: tempDir,
-            cliVersion: '0.0.0-private',
+            cliVersion,
             runtimeInstallPolicy: 'prompt',
             query: expect.objectContaining({ measures: ['orders.order_count'], dimensions: [] }),
         }), promptIo.io);
@@ -287,13 +288,13 @@ describe('runKtxCli', () => {
             sl,
         })).resolves.toBe(0);
         expect(sl).toHaveBeenLastCalledWith(expect.objectContaining({
-            cliVersion: '0.0.0-private',
+            cliVersion,
             runtimeInstallPolicy: 'auto',
         }), autoIo.io);
         const noInputIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, 'sl', 'query', '--measure', 'orders.order_count', '--no-input'], noInputIo.io, { sl })).resolves.toBe(0);
         expect(sl).toHaveBeenLastCalledWith(expect.objectContaining({
-            cliVersion: '0.0.0-private',
+            cliVersion,
             runtimeInstallPolicy: 'never',
         }), noInputIo.io);
     });
@@ -403,7 +404,7 @@ describe('runKtxCli', () => {
                 skipAgents: false,
                 inputMode: 'auto',
                 yes: false,
-                cliVersion: '0.0.0-private',
+                cliVersion,
                 skipLlm: false,
                 skipEmbeddings: false,
                 databaseSchemas: [],
@@ -512,7 +513,7 @@ describe('runKtxCli', () => {
             inputMode: 'disabled',
             depth: 'fast',
             queryHistory: 'default',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             runtimeInstallPolicy: 'never',
         }, testIo.io);
         expect(testIo.stderr()).toBe(`Project: ${tempDir}\n`);
@@ -531,7 +532,7 @@ describe('runKtxCli', () => {
             inputMode: 'auto',
             depth: 'deep',
             queryHistory: 'default',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             runtimeInstallPolicy: 'prompt',
         }, testIo.io);
         expect(testIo.stderr()).toBe('');
@@ -580,7 +581,7 @@ describe('runKtxCli', () => {
             json: false,
             inputMode: 'disabled',
             queryHistory: 'default',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             runtimeInstallPolicy: 'never',
         }, testIo.io);
     });
@@ -751,7 +752,7 @@ describe('runKtxCli', () => {
         const statusIo = makeIo();
         await expect(runKtxCli(['--project-dir', tempDir, 'status', '--json', '--no-input'], statusIo.io, { setup, doctor })).resolves.toBe(0);
         expect(setup).not.toHaveBeenCalled();
-        expect(doctor).toHaveBeenCalledWith({ command: 'project', projectDir: tempDir, outputMode: 'json', inputMode: 'disabled', verbose: false }, statusIo.io);
+        expect(doctor).toHaveBeenCalledWith({ command: 'project', projectDir: tempDir, outputMode: 'json', inputMode: 'disabled', verbose: false, fast: false }, statusIo.io);
         expect(statusIo.stderr()).toBe('');
     });
     it('routes top-level status without a project to setup doctor checks', async () => {
@@ -798,7 +799,7 @@ describe('runKtxCli', () => {
             command: 'run',
             projectDir: tempDir,
             inputMode: 'disabled',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             anthropicApiKeyEnv: 'ANTHROPIC_API_KEY', // pragma: allowlist secret
             llmModel: 'claude-sonnet-4-6',
             skipLlm: false,
@@ -825,7 +826,7 @@ describe('runKtxCli', () => {
             command: 'run',
             projectDir: tempDir,
             inputMode: 'disabled',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             llmBackend: 'vertex',
             vertexProject: 'local-gcp-project',
             vertexLocation: 'us-east5',
@@ -850,7 +851,7 @@ describe('runKtxCli', () => {
             command: 'run',
             projectDir: tempDir,
             inputMode: 'disabled',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             llmBackend: 'claude-code',
             llmModel: 'opus',
             skipLlm: false,
@@ -925,7 +926,7 @@ describe('runKtxCli', () => {
             projectDir: '/tmp/project',
             inputMode: 'disabled',
             yes: true,
-            cliVersion: '0.0.0-private',
+            cliVersion,
             skipLlm: true,
             skipEmbeddings: true,
             databaseDrivers: ['postgres'],
@@ -1143,7 +1144,7 @@ describe('runKtxCli', () => {
             queryFile: '/tmp/query.json',
             execute: false,
             format: 'json',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             runtimeInstallPolicy: 'auto',
         }, autoIo.io);
         expect(sl).toHaveBeenNthCalledWith(2, {
@@ -1153,7 +1154,7 @@ describe('runKtxCli', () => {
             queryFile: '/tmp/query.json',
             execute: false,
             format: 'json',
-            cliVersion: '0.0.0-private',
+            cliVersion,
             runtimeInstallPolicy: 'never',
         }, neverIo.io);
         expect(conflictIo.stderr()).toContain('Choose only one runtime install mode: --yes or --no-input');

package/dist/ingest-depth.d.ts

@@ -1,4 +1,4 @@
-import type { KtxProjectConfig, KtxProjectConnectionConfig } from '@ktx/context/project';
+import type { KtxProjectConfig, KtxProjectConnectionConfig } from './context/project/config.js';
 export type KtxDatabaseContextDepth = 'fast' | 'deep';
 export declare function normalizeConnectionDriver(connection: KtxProjectConnectionConfig): string;
 export declare function isDatabaseDriver(driver: string): boolean;

package/dist/ingest-query-executor.d.ts

@@ -1,5 +1,5 @@
-import type { KtxSqlQueryExecutorPort } from '@ktx/context/connections';
-import type { KtxLocalProject } from '@ktx/context/project';
+import type { KtxSqlQueryExecutorPort } from './context/connections/query-executor.js';
+import type { KtxLocalProject } from './context/project/project.js';
 import { createKtxCliScanConnector } from './local-scan-connectors.js';
 type CreateConnector = typeof createKtxCliScanConnector;
 export interface KtxCliIngestQueryExecutorDeps {

package/dist/ingest-query-executor.test.js

@@ -1,4 +1,4 @@
-import { createKtxConnectorCapabilities } from '@ktx/context/scan';
+import { createKtxConnectorCapabilities } from './context/scan/types.js';
 import { describe, expect, it, vi } from 'vitest';
 import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
 function project() {

package/dist/ingest-report-file.d.ts

@@ -1,2 +1,2 @@
-import { type IngestReportSnapshot } from '@ktx/context/ingest';
+import type { IngestReportSnapshot } from './context/ingest/reports.js';
 export declare function readIngestReportSnapshotFile(reportFile: string): Promise<IngestReportSnapshot>;

package/dist/ingest-report-file.js

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { parseIngestReportSnapshot } from '@ktx/context/ingest';
+import { parseIngestReportSnapshot } from './context/ingest/report-snapshot.js';
 export async function readIngestReportSnapshotFile(reportFile) {
     const raw = await readFile(reportFile, 'utf-8');
     let parsed;

package/dist/ingest.d.ts

@@ -1,6 +1,7 @@
-import { type RunLocalIngestOptions, runLocalIngest, runLocalMetabaseIngest } from '@ktx/context/ingest';
-import type { KtxSqlQueryExecutorPort } from '@ktx/context/connections';
-import { type KtxLocalProject } from '@ktx/context/project';
+import { type RunLocalIngestOptions, runLocalIngest, runLocalMetabaseIngest } from './context/ingest/local-ingest.js';
+import type { KtxSqlQueryExecutorPort } from './context/connections/query-executor.js';
+import { type KtxLocalProject } from './context/project/project.js';
+import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import { readIngestReportSnapshotFile } from './ingest-report-file.js';
 import { createKtxCliLocalIngestAdapters } from './local-adapters.js';
 import type { KtxManagedPythonInstallPolicy } from './managed-python-command.js';
@@ -51,6 +52,7 @@ export interface KtxIngestDeps {
     now?: () => Date;
     createAdapters?: typeof createKtxCliLocalIngestAdapters;
     createQueryExecutor?: (project: KtxLocalProject) => KtxSqlQueryExecutorPort;
+    resolveEmbeddingProvider?: typeof resolveProjectEmbeddingProvider;
     runLocalIngest?: typeof runLocalIngest;
     runLocalMetabaseIngest?: typeof runLocalMetabaseIngest;
     readReportFile?: typeof readIngestReportSnapshotFile;

package/dist/ingest.js

@@ -1,5 +1,13 @@
-import { buildMemoryFlowViewModel, createMemoryFlowLiveBuffer, formatMemoryFlowFinalSummary, getLatestLocalIngestStatus, getLocalIngestStatus, ingestReportToMemoryFlowReplay, renderMemoryFlowReplay, runLocalIngest, runLocalMetabaseIngest, savedMemoryCountsForReport, sanitizeMemoryFlowError, } from '@ktx/context/ingest';
-import { loadKtxCliProject } from './cli-project.js';
+import { buildMemoryFlowViewModel } from './context/ingest/memory-flow/view-model.js';
+import { createMemoryFlowLiveBuffer, sanitizeMemoryFlowError } from './context/ingest/memory-flow/live-buffer.js';
+import { formatMemoryFlowFinalSummary } from './context/ingest/memory-flow/summary.js';
+import { getLatestLocalIngestStatus, getLocalIngestStatus, runLocalIngest, runLocalMetabaseIngest } from './context/ingest/local-ingest.js';
+import { savedMemoryCountsForReport } from './context/ingest/reports.js';
+import { ingestReportToMemoryFlowReplay } from './context/ingest/memory-flow/events.js';
+import { renderMemoryFlowReplay } from './context/ingest/memory-flow/render.js';
+import { loadKtxProject } from './context/project/project.js';
+import { getKtxCliPackageInfo } from './cli-runtime.js';
+import { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
 import { readIngestReportSnapshotFile } from './ingest-report-file.js';
 import { createCliOperationalLogger } from './io/logger.js';
@@ -470,16 +478,17 @@ async function writeReportRecord(report, outputMode, io, options = {}) {
 }
 export async function runKtxIngest(args, io = process, deps = {}) {
     try {
-        const cliVersion = args.command === 'run' ? args.cliVersion : undefined;
-        const runtimeInstallPolicy = args.command === 'run' ? args.runtimeInstallPolicy : undefined;
-        const project = await loadKtxCliProject({
-            projectDir: args.projectDir,
-            cliVersion: cliVersion ?? '0.0.0-private',
-            installPolicy: runtimeInstallPolicy ?? 'never',
-            io,
-        });
+        const project = await loadKtxProject({ projectDir: args.projectDir });
         const env = deps.env ?? process.env;
         if (args.command === 'run') {
+            const resolveEmbeddingProvider = deps.resolveEmbeddingProvider ?? resolveProjectEmbeddingProvider;
+            const resolution = await resolveEmbeddingProvider(project, {
+                mode: 'ensure',
+                installPolicy: args.runtimeInstallPolicy ?? 'never',
+                cliVersion: args.cliVersion ?? getKtxCliPackageInfo().version,
+                io: deps.runtimeIo ?? io,
+            });
+            const embeddingProvider = resolution.kind === 'disabled' || resolution.kind === 'managed-unavailable' ? null : resolution.provider;
             const ingestProject = args.allowImplicitAdapter && !project.config.ingest.adapters.includes(args.adapter)
                 ? {
                     ...project,
@@ -550,6 +559,7 @@ export async function runKtxIngest(args, io = process, deps = {}) {
                         queryExecutor,
                         trigger: 'manual_resync',
                         jobIdFactory: deps.jobIdFactory,
+                        embeddingProvider,
                         ...(memoryFlow ? { memoryFlow } : {}),
                         ...(progress ? { progress } : {}),
                     });
@@ -617,6 +627,7 @@ export async function runKtxIngest(args, io = process, deps = {}) {
                     ...localIngestOptions,
                     queryExecutor,
                     pullConfigOptions: adapterOptions,
+                    embeddingProvider,
                     ...(args.debugLlmRequestFile ? { llmDebugRequestFile: args.debugLlmRequestFile } : {}),
                     ...(memoryFlow ? { memoryFlow } : {}),
                 });

package/dist/ingest.test-utils.d.ts

@@ -1,6 +1,13 @@
 import { EventEmitter } from 'node:events';
-import type { AgentRunnerPort, RunLoopParams } from '@ktx/context';
-import { type ChunkResult, type FetchContext, type IngestReportSnapshot, type LocalIngestResult, type LookerMappingClient, type LookerRuntimeClient, type LookerTableIdentifierParser, type MemoryFlowEventSink, type MetabaseClientFactory, type MetabaseRuntimeClient, type RunLocalIngestOptions, type SourceAdapter, type SqliteBundleIngestStore } from '@ktx/context/ingest';
+import type { AgentRunnerPort, RunLoopParams } from './context/llm/runtime-port.js';
+import { type LocalIngestResult, type RunLocalIngestOptions } from './context/ingest/local-ingest.js';
+import type { ChunkResult, FetchContext, SourceAdapter } from './context/ingest/types.js';
+import type { IngestReportSnapshot } from './context/ingest/reports.js';
+import type { LookerMappingClient, LookerTableIdentifierParser } from './context/ingest/adapters/looker/mapping.js';
+import type { LookerRuntimeClient } from './context/ingest/adapters/looker/fetch.js';
+import type { MemoryFlowEventSink } from './context/ingest/memory-flow/types.js';
+import type { MetabaseClientFactory, MetabaseRuntimeClient } from './context/ingest/adapters/metabase/client-port.js';
+import type { SqliteBundleIngestStore } from './context/ingest/sqlite-bundle-ingest-store.js';
 import { vi } from 'vitest';
 export declare function makeIo(options?: {
     isTTY?: boolean;

package/dist/ingest.test-utils.js

@@ -1,8 +1,11 @@
 import { EventEmitter } from 'node:events';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { KtxYamlMetabaseSourceStateReader, LocalMetabaseDiscoveryCache, MetabaseSourceAdapter, getLocalIngestStatus, } from '@ktx/context/ingest';
-import { ktxLocalStateDbPath, loadKtxProject } from '@ktx/context/project';
+import { KtxYamlMetabaseSourceStateReader, LocalMetabaseDiscoveryCache } from './context/ingest/adapters/metabase/local-source-state-store.js';
+import { MetabaseSourceAdapter } from './context/ingest/adapters/metabase/metabase.adapter.js';
+import { getLocalIngestStatus } from './context/ingest/local-ingest.js';
+import { ktxLocalStateDbPath } from './context/project/local-state-db.js';
+import { loadKtxProject } from './context/project/project.js';
 import { expect, vi } from 'vitest';
 import { runKtxIngest } from './ingest.js';
 export function makeIo(options = {}) {
@@ -571,7 +574,8 @@ export function localFakeBundleReport(jobId, overrides = {}) {
     };
 }
 export async function localBundleStore(projectDir, ids) {
-    const { SqliteBundleIngestStore } = await import('@ktx/context/ingest');
+    const { SqliteBundleIngestStore } = await import('./context/ingest/sqlite-bundle-ingest-store.js');
+    ;
     const project = await loadKtxProject({ projectDir });
     return new SqliteBundleIngestStore({
         dbPath: ktxLocalStateDbPath(project),