@kaelio/ktx 0.4.0 → 0.5.0

package/dist/managed-local-embeddings.test.js

@@ -1,6 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
-import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL } from '@ktx/context';
-import { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, managedLocalEmbeddingProjectConfig, } from './managed-local-embeddings.js';
+import { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, tryUseManagedLocalEmbeddingsDaemon, } from './managed-local-embeddings.js';
 function makeIo() {
     let stdout = '';
     let stderr = '';
@@ -84,22 +83,6 @@ function daemonResult(status = 'reused') {
         },
     };
 }
-describe('managedLocalEmbeddingProjectConfig', () => {
-    it('uses a stable managed runtime marker instead of a random daemon port', () => {
-        expect(managedLocalEmbeddingProjectConfig({
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 384,
-        })).toEqual({
-            backend: 'sentence-transformers',
-            model: 'all-MiniLM-L6-v2',
-            dimensions: 384,
-            sentenceTransformers: {
-                base_url: MANAGED_SENTENCE_TRANSFORMERS_BASE_URL,
-                pathPrefix: '',
-            },
-        });
-    });
-});
 describe('managedLocalEmbeddingHealthConfig', () => {
     it('uses the active KTX daemon URL for the immediate health check', () => {
         expect(managedLocalEmbeddingHealthConfig({
@@ -158,3 +141,89 @@ describe('ensureManagedLocalEmbeddingsDaemon', () => {
         expect(io.stderr()).toContain('Using KTX daemon: http://127.0.0.1:61234');
     });
 });
+describe('tryUseManagedLocalEmbeddingsDaemon', () => {
+    it('returns the daemon when one is running and healthy', async () => {
+        const readStatus = vi.fn(async () => ({
+            kind: 'running',
+            detail: 'ok',
+            layout: {},
+            state: {
+                schemaVersion: 1,
+                pid: 123,
+                host: '127.0.0.1',
+                port: 4321,
+                version: '0.5.0',
+                features: ['local-embeddings'],
+                startedAt: '2026-05-21T00:00:00Z',
+                stdoutLog: '/tmp/stdout.log',
+                stderrLog: '/tmp/stderr.log',
+            },
+            baseUrl: 'http://127.0.0.1:4321',
+        }));
+        const result = await tryUseManagedLocalEmbeddingsDaemon({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+            readStatus,
+        });
+        expect(result).toEqual({
+            baseUrl: 'http://127.0.0.1:4321',
+            stdoutLog: '/tmp/stdout.log',
+            stderrLog: '/tmp/stderr.log',
+        });
+        expect(readStatus).toHaveBeenCalledWith({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+        });
+    });
+    it('returns null when no daemon state exists', async () => {
+        const readStatus = vi.fn(async () => ({
+            kind: 'stopped',
+            detail: 'no state',
+            layout: {},
+        }));
+        const result = await tryUseManagedLocalEmbeddingsDaemon({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+            readStatus,
+        });
+        expect(result).toBeNull();
+    });
+    it('returns null when daemon is stale', async () => {
+        const readStatus = vi.fn(async () => ({
+            kind: 'stale',
+            detail: 'process gone',
+            layout: {},
+        }));
+        const result = await tryUseManagedLocalEmbeddingsDaemon({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+            readStatus,
+        });
+        expect(result).toBeNull();
+    });
+    it('rejects daemons that do not advertise local-embeddings', async () => {
+        const readStatus = vi.fn(async () => ({
+            kind: 'running',
+            detail: 'ok',
+            layout: {},
+            state: {
+                schemaVersion: 1,
+                pid: 123,
+                host: '127.0.0.1',
+                port: 4321,
+                version: '0.5.0',
+                features: ['core'],
+                startedAt: '2026-05-21T00:00:00Z',
+                stdoutLog: '/tmp/stdout.log',
+                stderrLog: '/tmp/stderr.log',
+            },
+            baseUrl: 'http://127.0.0.1:4321',
+        }));
+        const result = await tryUseManagedLocalEmbeddingsDaemon({
+            cliVersion: '0.5.0',
+            projectDir: '/work/proj',
+            readStatus,
+        });
+        expect(result).toBeNull();
+    });
+});

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

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

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

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

package/dist/managed-python-command.js

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

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

@@ -41,7 +41,7 @@ export interface ManagedPythonDaemonProcessInfo {
     pid: number;
     command: string;
 }
-export type ManagedPythonDaemonStopAllSource = 'state' | 'process';
+type ManagedPythonDaemonStopAllSource = 'state' | 'process';
 export interface ManagedPythonDaemonStopAllEntry {
     pid: number;
     source: ManagedPythonDaemonStopAllSource;
@@ -60,22 +60,25 @@ export interface ManagedPythonDaemonStopAllResult {
     failed: ManagedPythonDaemonStopAllFailure[];
     scanErrors: string[];
 }
+/** @internal */
 export interface ManagedPythonDaemonChild {
     pid?: number;
     unref(): void;
 }
+/** @internal */
 export type ManagedPythonDaemonSpawn = (command: string, args: string[], options: {
     detached: boolean;
     stdio: ['ignore', number, number];
     env: NodeJS.ProcessEnv;
 }) => ManagedPythonDaemonChild;
+/** @internal */
 export type ManagedPythonDaemonFetch = (url: string) => Promise<{
     ok: boolean;
     status: number;
     json(): Promise<unknown>;
     text(): Promise<string>;
 }>;
-export type ManagedPythonDaemonKillProcess = (pid: number, signal?: NodeJS.Signals) => void;
+type ManagedPythonDaemonKillProcess = (pid: number, signal?: NodeJS.Signals) => void;
 export interface ManagedPythonDaemonStartOptions extends ManagedPythonDaemonLayoutOptions {
     features: KtxRuntimeFeature[];
     force?: boolean;
@@ -110,3 +113,4 @@ export declare function allocateDaemonPort(): Promise<number>;
 export declare function startManagedPythonDaemon(options: ManagedPythonDaemonStartOptions): Promise<ManagedPythonDaemonStartResult>;
 export declare function stopManagedPythonDaemon(options: ManagedPythonDaemonStopOptions): Promise<ManagedPythonDaemonStopResult>;
 export declare function stopAllManagedPythonDaemons(options: ManagedPythonDaemonStopAllOptions): Promise<ManagedPythonDaemonStopAllResult>;
+export {};

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

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

package/dist/managed-python-http.js

@@ -1,8 +1,8 @@
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { URL } from 'node:url';
-import { createDaemonLookerTableIdentifierParser, } from '@ktx/context/ingest';
-import { createHttpSqlAnalysisPort, } from '@ktx/context/sql-analysis';
+import { createDaemonLookerTableIdentifierParser } from './context/ingest/adapters/looker/daemon-table-identifier-parser.js';
+import { createHttpSqlAnalysisPort } from './context/sql-analysis/http-sql-analysis-port.js';
 import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
 import { startManagedPythonDaemon } from './managed-python-daemon.js';
 function normalizedBaseUrl(baseUrl) {
@@ -15,7 +15,7 @@ function parseJsonObject(raw, path) {
     }
     return parsed;
 }
-export async function postManagedDaemonJson(baseUrl, path, payload) {
+async function postManagedDaemonJson(baseUrl, path, payload) {
     return await new Promise((resolve, reject) => {
         const target = new URL(path.replace(/^\//, ''), normalizedBaseUrl(baseUrl));
         const body = JSON.stringify(payload);
@@ -49,6 +49,7 @@ export async function postManagedDaemonJson(baseUrl, path, payload) {
         request.end(body);
     });
 }
+/** @internal */
 export function createManagedPythonDaemonBaseUrlResolver(options) {
     let cachedBaseUrl;
     return async () => {
@@ -81,6 +82,7 @@ function isRequestJsonOnly(options) {
 function isResolveBaseUrlOnly(options) {
     return 'resolveBaseUrl' in options;
 }
+/** @internal */
 export function createManagedDaemonHttpJsonRunner(options) {
     if (isRequestJsonOnly(options)) {
         return options.requestJson;

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

@@ -15,7 +15,7 @@ declare const runtimeAssetManifestSchema: z.ZodObject<{
         bytes: z.ZodNumber;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export type KtxRuntimeAssetManifest = z.infer<typeof runtimeAssetManifestSchema>;
+type KtxRuntimeAssetManifest = z.infer<typeof runtimeAssetManifestSchema>;
 declare const installedRuntimeManifestSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     cliVersion: z.ZodString;
@@ -72,6 +72,7 @@ export interface ManagedPythonDaemonLayout extends ManagedPythonRuntimeLayout {
     daemonStdoutPath: string;
     daemonStderrPath: string;
 }
+/** @internal */
 export interface ManagedRuntimeAsset {
     manifest: KtxRuntimeAssetManifest;
     wheelPath: string;
@@ -98,7 +99,7 @@ export interface ManagedPythonRuntimeInstallResult {
     asset: ManagedRuntimeAsset;
     manifest: InstalledKtxRuntimeManifest;
 }
-export type ManagedPythonRuntimeStatusKind = 'missing' | 'ready' | 'mismatched' | 'broken';
+type ManagedPythonRuntimeStatusKind = 'missing' | 'ready' | 'mismatched' | 'broken';
 export interface ManagedPythonRuntimeStatus {
     kind: ManagedPythonRuntimeStatusKind;
     detail: string;
@@ -112,9 +113,12 @@ export interface ManagedPythonRuntimeDoctorCheck {
     detail: string;
     fix?: string;
 }
+/** @internal */
 export declare const MISSING_UV_RUNTIME_INSTALL_MESSAGE = "uv is required to install the KTX Python runtime. KTX does not download uv automatically. Install uv, make sure it is on PATH, and retry: ktx admin runtime install --yes";
+/** @internal */
 export declare function managedPythonRuntimeLayout(options: ManagedPythonRuntimeLayoutOptions): ManagedPythonRuntimeLayout;
 export declare function managedPythonDaemonLayout(options: ManagedPythonDaemonLayoutOptions): ManagedPythonDaemonLayout;
+/** @internal */
 export declare function verifyRuntimeAsset(input: {
     assetDir: string;
 }): Promise<ManagedRuntimeAsset>;

package/dist/managed-python-runtime.js

@@ -32,6 +32,7 @@ const installedRuntimeManifestSchema = z.object({
     }),
     installLog: z.string().min(1),
 });
+/** @internal */
 export const MISSING_UV_RUNTIME_INSTALL_MESSAGE = 'uv is required to install the KTX Python runtime. KTX does not download uv automatically. Install uv, make sure it is on PATH, and retry: ktx admin runtime install --yes';
 function defaultAssetDir() {
     return fileURLToPath(new URL('../assets/python/', import.meta.url));
@@ -48,6 +49,7 @@ function executablePath(venvDir, platform, name) {
     }
     return join(venvDir, 'bin', name);
 }
+/** @internal */
 export function managedPythonRuntimeLayout(options) {
     const platform = options.platform ?? process.platform;
     const env = options.env ?? process.env;
@@ -130,6 +132,7 @@ function parseRequiresPythonFromWheel(input) {
         minimumVersion: `${minimumMatch[1]}.${minimumMatch[2]}`,
     };
 }
+/** @internal */
 export async function verifyRuntimeAsset(input) {
     const manifestPath = join(input.assetDir, 'manifest.json');
     let manifestData;

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

@@ -1,7 +1,7 @@
 import { type IncomingHttpHeaders, type Server } from 'node:http';
-import { loadKtxProject } from '@ktx/context/project';
+import { loadKtxProject } from './context/project/project.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { KtxCliIo } from './cli-runtime.js';
+import { type KtxCliIo } from './cli-runtime.js';
 export interface McpSecurityConfigInput {
     host: string;
     port: number;
@@ -16,6 +16,7 @@ export interface McpSecurityConfig {
     allowedHosts: string[];
     allowedOrigins: string[];
 }
+/** @internal */
 export type McpAuthorizationResult = {
     ok: true;
 } | {
@@ -23,8 +24,10 @@ export type McpAuthorizationResult = {
     status: 401 | 403;
     message: string;
 };
+/** @internal */
 export declare function normalizeHostHeader(value: string): string;
 export declare function buildMcpSecurityConfig(input: McpSecurityConfigInput): McpSecurityConfig;
+/** @internal */
 export declare function isMcpRequestAuthorized(request: {
     path: string;
     headers: IncomingHttpHeaders | Record<string, string | undefined>;

package/dist/mcp-http-server.js

@@ -1,14 +1,16 @@
 import { randomUUID } from 'node:crypto';
 import { createServer } from 'node:http';
-import { loadKtxProject } from '@ktx/context/project';
+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 { createKtxMcpServerFactory } from './mcp-server-factory.js';
 const DEFAULT_ALLOWED_HOSTS = ['localhost', '127.0.0.1', '::1'];
 function isLoopbackHost(host) {
     const normalized = normalizeHostHeader(host);
     return normalized === 'localhost' || normalized === '127.0.0.1' || normalized === '::1';
 }
+/** @internal */
 export function normalizeHostHeader(value) {
     const trimmed = value.trim().toLowerCase();
     if (trimmed.startsWith('[')) {
@@ -57,6 +59,7 @@ function headerValue(headers, name) {
     const value = headers[name.toLowerCase()];
     return Array.isArray(value) ? value[0] : value;
 }
+/** @internal */
 export function isMcpRequestAuthorized(request, config) {
     const host = headerValue(request.headers, 'host');
     if (!host || !config.allowedHosts.includes(normalizeHostHeader(host))) {
@@ -122,7 +125,7 @@ export async function runKtxMcpHttpServer(options) {
         (await createKtxMcpServerFactory({
             project: project,
             projectDir: options.projectDir,
-            cliVersion: options.cliVersion ?? '0.0.0-private',
+            cliVersion: options.cliVersion ?? getKtxCliPackageInfo().version,
             io: options.io,
         }));
     const sessions = new Map();

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

@@ -1,4 +1,4 @@
-import type { KtxLocalProject } from '@ktx/context/project';
+import type { KtxLocalProject } from './context/project/project.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { KtxCliIo } from './cli-runtime.js';
 export declare function createKtxMcpServerFactory(input: {

package/dist/mcp-server-factory.js

@@ -1,5 +1,8 @@
-import { createDefaultKtxMcpServer, createLocalProjectMcpContextPorts } from '@ktx/context/mcp';
-import { createLocalProjectMemoryIngest } from '@ktx/context/memory';
+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 { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
 import { createKtxCliIngestQueryExecutor } from './ingest-query-executor.js';
 import { createKtxCliScanConnector } from './local-scan-connectors.js';
 import { createManagedPythonSemanticLayerComputePort } from './managed-python-command.js';
@@ -24,25 +27,41 @@ export async function createKtxMcpServerFactory(input) {
         installPolicy: 'auto',
         io,
     });
+    const resolution = await resolveProjectEmbeddingProvider(input.project, {
+        mode: 'use-if-running',
+        cliVersion: input.cliVersion,
+        io,
+    });
+    const embeddingProvider = resolution.kind === 'configured' || resolution.kind === 'managed-running' || resolution.kind === 'managed-started'
+        ? resolution.provider
+        : null;
+    const embeddingService = embeddingProvider ? new KtxIngestEmbeddingPortAdapter(embeddingProvider) : null;
     const contextTools = createLocalProjectMcpContextPorts(input.project, {
         semanticLayerCompute,
         queryExecutor,
         sqlAnalysis,
+        embeddingService,
         localScan: {
             createConnector: async (connectionId) => createKtxCliScanConnector(input.project, connectionId),
         },
     });
     let memoryIngest;
     try {
-        memoryIngest = createLocalProjectMemoryIngest(input.project, { semanticLayerCompute, queryExecutor });
+        memoryIngest = createLocalProjectMemoryIngest(input.project, {
+            semanticLayerCompute,
+            queryExecutor,
+            embeddingProvider,
+        });
     }
     catch (error) {
-        input.io?.stderr.write(`KTX MCP memory_ingest disabled: ${error instanceof Error ? error.message : String(error)}\n`);
+        io.stderr.write(`KTX MCP memory_ingest disabled: ${error instanceof Error ? error.message : String(error)}\n`);
     }
     return () => createDefaultKtxMcpServer({
         name: 'ktx',
         version: input.cliVersion,
         userContext: { userId: 'local' },
+        projectDir: input.projectDir,
+        io,
         contextTools: {
             ...contextTools,
             ...(memoryIngest ? { memoryIngest } : {}),

package/dist/mcp-server-factory.test.js

@@ -0,0 +1,142 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+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 { resolveProjectEmbeddingProvider } from './embedding-resolution.js';
+import { createKtxCliScanConnector } from './local-scan-connectors.js';
+import { createKtxMcpServerFactory } from './mcp-server-factory.js';
+const mocks = vi.hoisted(() => ({
+    queryExecutor: { execute: vi.fn() },
+    semanticLayerCompute: { validateSources: vi.fn(), generateSources: vi.fn(), query: vi.fn() },
+    sqlAnalysis: { analyzeForFingerprint: vi.fn(), analyzeBatch: vi.fn(), validateReadOnly: vi.fn() },
+    memoryIngest: { ingest: vi.fn(), status: vi.fn(), waitForRun: vi.fn() },
+}));
+vi.mock('./context/llm/embedding-port.js', () => ({
+    KtxIngestEmbeddingPortAdapter: class {
+        provider;
+        maxBatchSize;
+        constructor(provider) {
+            this.provider = provider;
+            this.maxBatchSize = provider.maxBatchSize;
+        }
+        computeEmbedding(text) {
+            return this.provider.embed(text);
+        }
+        computeEmbeddingsBulk(texts) {
+            return this.provider.embedMany(texts);
+        }
+    },
+}));
+vi.mock('./context/mcp/server.js', () => ({
+    createDefaultKtxMcpServer: vi.fn(() => ({ kind: 'mcp-server' })),
+}));
+vi.mock('./context/mcp/local-project-ports.js', () => ({
+    createLocalProjectMcpContextPorts: vi.fn(() => ({ context_tool: { name: 'context_tool' } })),
+}));
+vi.mock('./context/memory/local-memory.js', () => ({
+    createLocalProjectMemoryIngest: vi.fn(() => mocks.memoryIngest),
+}));
+vi.mock('./embedding-resolution.js', () => ({
+    resolveProjectEmbeddingProvider: vi.fn(),
+}));
+vi.mock('./ingest-query-executor.js', () => ({
+    createKtxCliIngestQueryExecutor: vi.fn(() => mocks.queryExecutor),
+}));
+vi.mock('./local-scan-connectors.js', () => ({
+    createKtxCliScanConnector: vi.fn(() => ({ source: 'fake-scan-connector' })),
+}));
+vi.mock('./managed-python-command.js', () => ({
+    createManagedPythonSemanticLayerComputePort: vi.fn(async () => mocks.semanticLayerCompute),
+}));
+vi.mock('./managed-python-http.js', () => ({
+    createManagedDaemonSqlAnalysisPort: vi.fn(() => mocks.sqlAnalysis),
+}));
+const project = {
+    projectDir: '/work/project',
+    configPath: '/work/project/ktx.yaml',
+    config: {},
+    coreConfig: {},
+    git: {},
+    fileStore: {},
+};
+const io = {
+    stdout: { write: vi.fn() },
+    stderr: { write: vi.fn() },
+};
+describe('createKtxMcpServerFactory', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('passes a resolved embedding provider to MCP context ports and memory ingest', async () => {
+        const provider = {
+            maxBatchSize: 4,
+            embed: vi.fn(async () => [0.2, 0.4]),
+            embedMany: vi.fn(async () => [[0.2, 0.4]]),
+        };
+        vi.mocked(resolveProjectEmbeddingProvider).mockResolvedValue({ kind: 'configured', provider });
+        const factory = await createKtxMcpServerFactory({
+            project: project,
+            projectDir: project.projectDir,
+            cliVersion: '0.5.0',
+            io,
+        });
+        const contextOptions = vi.mocked(createLocalProjectMcpContextPorts).mock.calls[0][1];
+        await expect(contextOptions.embeddingService.computeEmbedding('gross revenue')).resolves.toEqual([0.2, 0.4]);
+        await expect(contextOptions.embeddingService.computeEmbeddingsBulk(['gross revenue'])).resolves.toEqual([[0.2, 0.4]]);
+        await expect(contextOptions.localScan.createConnector('warehouse')).resolves.toEqual({
+            source: 'fake-scan-connector',
+        });
+        expect(provider.embed).toHaveBeenCalledWith('gross revenue');
+        expect(provider.embedMany).toHaveBeenCalledWith(['gross revenue']);
+        expect(createKtxCliScanConnector).toHaveBeenCalledWith(project, 'warehouse');
+        expect(contextOptions).toMatchObject({
+            queryExecutor: mocks.queryExecutor,
+            semanticLayerCompute: mocks.semanticLayerCompute,
+            sqlAnalysis: mocks.sqlAnalysis,
+        });
+        expect(createLocalProjectMemoryIngest).toHaveBeenCalledWith(project, expect.objectContaining({
+            embeddingProvider: provider,
+            queryExecutor: mocks.queryExecutor,
+            semanticLayerCompute: mocks.semanticLayerCompute,
+        }));
+        expect(factory()).toEqual({ kind: 'mcp-server' });
+        expect(createDefaultKtxMcpServer).toHaveBeenCalledWith(expect.objectContaining({
+            contextTools: expect.objectContaining({
+                context_tool: { name: 'context_tool' },
+                memoryIngest: mocks.memoryIngest,
+            }),
+        }));
+    });
+    it('uses null embedding ports when no configured provider is available', async () => {
+        vi.mocked(resolveProjectEmbeddingProvider).mockResolvedValue({ kind: 'managed-unavailable' });
+        await createKtxMcpServerFactory({
+            project: project,
+            projectDir: project.projectDir,
+            cliVersion: '0.5.0',
+            io,
+        });
+        expect(vi.mocked(createLocalProjectMcpContextPorts).mock.calls[0][1]).toMatchObject({
+            embeddingService: null,
+        });
+        expect(createLocalProjectMemoryIngest).toHaveBeenCalledWith(project, expect.objectContaining({
+            embeddingProvider: null,
+        }));
+    });
+    it('omits memory ingest and logs when memory ingest construction fails', async () => {
+        vi.mocked(resolveProjectEmbeddingProvider).mockResolvedValue({ kind: 'disabled' });
+        vi.mocked(createLocalProjectMemoryIngest).mockImplementationOnce(() => {
+            throw new Error('missing local memory prerequisites');
+        });
+        const factory = await createKtxMcpServerFactory({
+            project: project,
+            projectDir: project.projectDir,
+            cliVersion: '0.5.0',
+            io,
+        });
+        factory();
+        expect(io.stderr.write).toHaveBeenCalledWith('KTX MCP memory_ingest disabled: missing local memory prerequisites\n');
+        expect(createDefaultKtxMcpServer).toHaveBeenCalledWith(expect.objectContaining({
+            contextTools: { context_tool: { name: 'context_tool' } },
+        }));
+    });
+});

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

@@ -1,7 +1,7 @@
 import type { Readable, Writable } from 'node:stream';
-import { loadKtxProject } from '@ktx/context/project';
+import { loadKtxProject } from './context/project/project.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { KtxCliIo } from './cli-runtime.js';
+import { type KtxCliIo } from './cli-runtime.js';
 export interface RunKtxMcpStdioServerOptions {
     projectDir: string;
     cliVersion?: string;

package/dist/mcp-stdio-server.js

@@ -1,6 +1,7 @@
 import process from 'node:process';
-import { loadKtxProject } from '@ktx/context/project';
+import { loadKtxProject } from './context/project/project.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { getKtxCliPackageInfo } from './cli-runtime.js';
 import { createKtxMcpServerFactory } from './mcp-server-factory.js';
 export async function runKtxMcpStdioServer(options) {
     const project = options.createMcpServer === undefined
@@ -8,13 +9,13 @@ export async function runKtxMcpStdioServer(options) {
         : undefined;
     const protocolIo = {
         stdout: { write() { } },
-        stderr: options.io?.stderr ?? { write() { } },
+        stderr: options.io?.stderr ?? process.stderr,
     };
     const createMcpServer = options.createMcpServer ??
         (await createKtxMcpServerFactory({
             project: project,
             projectDir: options.projectDir,
-            cliVersion: options.cliVersion ?? '0.0.0-private',
+            cliVersion: options.cliVersion ?? getKtxCliPackageInfo().version,
             io: protocolIo,
         }));
     const stdin = options.stdin ?? process.stdin;