@kaelio/ktx 0.0.0 → 0.1.0-rc.1

package/dist/managed-local-embeddings.js

@@ -0,0 +1,49 @@
+import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV, } from '@ktx/context';
+import { ensureManagedPythonCommandRuntime, } from './managed-python-command.js';
+import { startManagedPythonDaemon } from './managed-python-daemon.js';
+export function managedLocalEmbeddingProjectConfig(input) {
+    return {
+        backend: 'sentence-transformers',
+        model: input.model,
+        dimensions: input.dimensions,
+        sentenceTransformers: {
+            base_url: MANAGED_SENTENCE_TRANSFORMERS_BASE_URL,
+            pathPrefix: '',
+        },
+    };
+}
+export function managedLocalEmbeddingHealthConfig(input) {
+    return {
+        backend: 'sentence-transformers',
+        model: input.model,
+        dimensions: input.dimensions,
+        sentenceTransformers: {
+            baseURL: input.baseUrl,
+            pathPrefix: '',
+        },
+    };
+}
+export async function ensureManagedLocalEmbeddingsDaemon(options) {
+    const ensureRuntime = options.ensureRuntime ?? ensureManagedPythonCommandRuntime;
+    const startDaemon = options.startDaemon ?? startManagedPythonDaemon;
+    await ensureRuntime({
+        cliVersion: options.cliVersion,
+        installPolicy: options.installPolicy,
+        io: options.io,
+        feature: 'local-embeddings',
+    });
+    const daemon = await startDaemon({
+        cliVersion: options.cliVersion,
+        projectDir: options.projectDir,
+        features: ['local-embeddings'],
+        force: false,
+    });
+    const verb = daemon.status === 'started' ? 'Started' : 'Using';
+    options.io.stderr.write(`${verb} KTX local embeddings daemon: ${daemon.baseUrl}\n`);
+    return {
+        baseUrl: daemon.baseUrl,
+        env: {
+            [MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV]: daemon.baseUrl,
+        },
+    };
+}

package/dist/managed-local-embeddings.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,161 @@
+import { describe, expect, it, vi } from 'vitest';
+import { MANAGED_SENTENCE_TRANSFORMERS_BASE_URL, MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV, } from '@ktx/context';
+import { ensureManagedLocalEmbeddingsDaemon, managedLocalEmbeddingHealthConfig, managedLocalEmbeddingProjectConfig, } from './managed-local-embeddings.js';
+function makeIo() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        io: {
+            stdout: {
+                write: (chunk) => {
+                    stdout += chunk;
+                },
+            },
+            stderr: {
+                write: (chunk) => {
+                    stderr += chunk;
+                },
+            },
+        },
+        stdout: () => stdout,
+        stderr: () => stderr,
+    };
+}
+function runtime() {
+    return {
+        layout: {
+            cliVersion: '0.2.0',
+            runtimeRoot: '/runtime',
+            versionDir: '/runtime/0.2.0',
+            venvDir: '/runtime/0.2.0/.venv',
+            manifestPath: '/runtime/0.2.0/manifest.json',
+            installLogPath: '/runtime/0.2.0/install.log',
+            assetDir: '/assets/python',
+            assetManifestPath: '/assets/python/manifest.json',
+            pythonPath: '/runtime/0.2.0/.venv/bin/python',
+            daemonPath: '/runtime/0.2.0/.venv/bin/ktx-daemon',
+        },
+        manifest: {
+            schemaVersion: 1,
+            cliVersion: '0.2.0',
+            installedAt: '2026-05-11T00:00:00.000Z',
+            asset: {
+                schemaVersion: 1,
+                distributionName: 'kaelio-ktx',
+                normalizedName: 'kaelio_ktx',
+                version: '0.2.0',
+                wheel: {
+                    file: 'kaelio_ktx-0.2.0-py3-none-any.whl',
+                    sha256: 'a'.repeat(64),
+                    bytes: 123,
+                },
+            },
+            features: ['core', 'local-embeddings'],
+            python: {
+                executable: '/runtime/0.2.0/.venv/bin/python',
+                daemonExecutable: '/runtime/0.2.0/.venv/bin/ktx-daemon',
+            },
+            installLog: '/runtime/0.2.0/install.log',
+        },
+    };
+}
+function daemonResult(status = 'reused') {
+    return {
+        status,
+        layout: {
+            ...runtime().layout,
+            projectDir: '/work/proj',
+            daemonStateDir: '/work/proj/.ktx/runtime',
+            daemonStatePath: '/work/proj/.ktx/runtime/daemon.json',
+            daemonStdoutPath: '/work/proj/.ktx/runtime/daemon.stdout.log',
+            daemonStderrPath: '/work/proj/.ktx/runtime/daemon.stderr.log',
+        },
+        baseUrl: 'http://127.0.0.1:61234',
+        state: {
+            schemaVersion: 1,
+            pid: 12345,
+            host: '127.0.0.1',
+            port: 61234,
+            version: '0.2.0',
+            features: ['core', 'local-embeddings'],
+            startedAt: '2026-05-11T00:00:00.000Z',
+            stdoutLog: '/work/proj/.ktx/runtime/daemon.stdout.log',
+            stderrLog: '/work/proj/.ktx/runtime/daemon.stderr.log',
+        },
+    };
+}
+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 managed daemon URL for the immediate health check', () => {
+        expect(managedLocalEmbeddingHealthConfig({
+            baseUrl: 'http://127.0.0.1:61234',
+            model: 'all-MiniLM-L6-v2',
+            dimensions: 384,
+        })).toEqual({
+            backend: 'sentence-transformers',
+            model: 'all-MiniLM-L6-v2',
+            dimensions: 384,
+            sentenceTransformers: { baseURL: 'http://127.0.0.1:61234', pathPrefix: '' },
+        });
+    });
+});
+describe('ensureManagedLocalEmbeddingsDaemon', () => {
+    it('ensures the local-embeddings feature and starts the managed daemon', async () => {
+        const io = makeIo();
+        const ensureRuntime = vi.fn(async () => runtime());
+        const startDaemon = vi.fn(async () => daemonResult('started'));
+        await expect(ensureManagedLocalEmbeddingsDaemon({
+            cliVersion: '0.2.0',
+            projectDir: '/work/proj',
+            installPolicy: 'auto',
+            io: io.io,
+            ensureRuntime,
+            startDaemon,
+        })).resolves.toEqual({
+            baseUrl: 'http://127.0.0.1:61234',
+            env: {
+                [MANAGED_SENTENCE_TRANSFORMERS_BASE_URL_ENV]: 'http://127.0.0.1:61234',
+            },
+        });
+        expect(ensureRuntime).toHaveBeenCalledWith({
+            cliVersion: '0.2.0',
+            installPolicy: 'auto',
+            io: io.io,
+            feature: 'local-embeddings',
+        });
+        expect(startDaemon).toHaveBeenCalledWith({
+            cliVersion: '0.2.0',
+            projectDir: '/work/proj',
+            features: ['local-embeddings'],
+            force: false,
+        });
+        expect(io.stderr()).toContain('Started KTX local embeddings daemon: http://127.0.0.1:61234');
+    });
+    it('reuses an already running daemon without reporting a new start', async () => {
+        const io = makeIo();
+        await ensureManagedLocalEmbeddingsDaemon({
+            cliVersion: '0.2.0',
+            projectDir: '/work/proj',
+            installPolicy: 'prompt',
+            io: io.io,
+            ensureRuntime: vi.fn(async () => runtime()),
+            startDaemon: vi.fn(async () => daemonResult('reused')),
+        });
+        expect(io.stderr()).toContain('Using KTX local embeddings daemon: http://127.0.0.1:61234');
+    });
+});

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

@@ -0,0 +1,73 @@
+export interface KtxMcpDaemonState {
+    schemaVersion: 1;
+    pid: number;
+    host: string;
+    port: number;
+    tokenAuth: boolean;
+    projectDir: string;
+    startedAt: string;
+    logPath: string;
+}
+export interface KtxMcpDaemonChild {
+    pid?: number;
+    unref(): void;
+}
+export type KtxMcpDaemonStatus = {
+    kind: 'stopped';
+    detail: string;
+} | {
+    kind: 'running';
+    detail: string;
+    state: KtxMcpDaemonState;
+    url: string;
+} | {
+    kind: 'stale';
+    detail: string;
+    state?: KtxMcpDaemonState;
+};
+export declare function mcpDaemonLayout(projectDir: string): {
+    statePath: string;
+    logPath: string;
+};
+declare function defaultSpawnDaemon(command: string, args: string[], options: {
+    detached: boolean;
+    stdio: ['ignore', number, number];
+    env: NodeJS.ProcessEnv;
+}): KtxMcpDaemonChild;
+export declare function startKtxMcpDaemon(options: {
+    projectDir: string;
+    cliVersion: string;
+    host: string;
+    port: number;
+    token?: string;
+    allowedHosts: string[];
+    allowedOrigins: string[];
+    binPath: string;
+    processAlive?: (pid: number) => boolean;
+    portAvailable?: (host: string, port: number) => Promise<boolean>;
+    spawnDaemon?: typeof defaultSpawnDaemon;
+    now?: () => Date;
+}): Promise<{
+    status: 'started';
+    state: KtxMcpDaemonState;
+    url: string;
+}>;
+export declare function readKtxMcpDaemonStatus(options: {
+    projectDir: string;
+    processAlive?: (pid: number) => boolean;
+    fetchHealth?: (state: KtxMcpDaemonState) => Promise<{
+        ok: boolean;
+        body: unknown;
+        detail?: string;
+    }>;
+}): Promise<KtxMcpDaemonStatus>;
+export declare function stopKtxMcpDaemon(options: {
+    projectDir: string;
+    processAlive?: (pid: number) => boolean;
+    killProcess?: (pid: number, signal: NodeJS.Signals) => void;
+    stopGraceMs?: number;
+    pollIntervalMs?: number;
+}): Promise<{
+    status: 'stopped' | 'already-stopped';
+}>;
+export {};

package/dist/managed-mcp-daemon.js

@@ -0,0 +1,183 @@
+import { spawn } from 'node:child_process';
+import { mkdir, open, readFile, rm, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { dirname, join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { z } from 'zod';
+const stateSchema = z.object({
+    schemaVersion: z.literal(1),
+    pid: z.number().int().positive(),
+    host: z.string().min(1),
+    port: z.number().int().min(1).max(65535),
+    tokenAuth: z.boolean(),
+    projectDir: z.string().min(1),
+    startedAt: z.string().min(1),
+    logPath: z.string().min(1),
+});
+export function mcpDaemonLayout(projectDir) {
+    return {
+        statePath: join(projectDir, '.ktx/mcp.json'),
+        logPath: join(projectDir, '.ktx/logs/mcp.log'),
+    };
+}
+function defaultProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultKillProcess(pid, signal) {
+    try {
+        process.kill(pid, signal);
+    }
+    catch (error) {
+        if (error.code !== 'ESRCH') {
+            throw error;
+        }
+    }
+}
+async function readState(projectDir) {
+    try {
+        return stateSchema.parse(JSON.parse(await readFile(mcpDaemonLayout(projectDir).statePath, 'utf8')));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function writeState(projectDir, state) {
+    const { statePath } = mcpDaemonLayout(projectDir);
+    await mkdir(dirname(statePath), { recursive: true });
+    await writeFile(statePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+async function defaultPortAvailable(host, port) {
+    return await new Promise((resolve) => {
+        const server = createServer();
+        server.once('error', () => resolve(false));
+        server.listen(port, host, () => server.close(() => resolve(true)));
+    });
+}
+function defaultSpawnDaemon(command, args, options) {
+    return spawn(command, args, options);
+}
+async function defaultFetchHealth(state) {
+    try {
+        const response = await fetch(`http://${state.host}:${state.port}/health`, {
+            headers: { host: `${state.host}:${state.port}` },
+        });
+        const body = await response.json();
+        return { ok: response.ok, body, detail: response.ok ? undefined : `HTTP ${response.status}` };
+    }
+    catch (error) {
+        return { ok: false, body: null, detail: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function startKtxMcpDaemon(options) {
+    const existing = await readState(options.projectDir).catch(() => undefined);
+    const processAlive = options.processAlive ?? defaultProcessAlive;
+    if (existing && processAlive(existing.pid)) {
+        throw new Error(`KTX MCP daemon is already recorded at http://${existing.host}:${existing.port}/mcp`);
+    }
+    const portAvailable = options.portAvailable ?? defaultPortAvailable;
+    if (!(await portAvailable(options.host, options.port))) {
+        throw new Error(`Port ${options.port} is already in use. Choose another port with --port <n>.`);
+    }
+    const { logPath } = mcpDaemonLayout(options.projectDir);
+    await mkdir(dirname(logPath), { recursive: true });
+    const log = await open(logPath, 'a');
+    try {
+        const args = [
+            options.binPath,
+            '--project-dir',
+            options.projectDir,
+            'mcp',
+            'serve-internal',
+            '--host',
+            options.host,
+            '--port',
+            String(options.port),
+            ...options.allowedHosts.flatMap((host) => ['--allowed-host', host]),
+            ...options.allowedOrigins.flatMap((origin) => ['--allowed-origin', origin]),
+        ];
+        const child = (options.spawnDaemon ?? defaultSpawnDaemon)(process.execPath, args, {
+            detached: true,
+            stdio: ['ignore', log.fd, log.fd],
+            env: {
+                ...process.env,
+                KTX_CLI_VERSION: options.cliVersion,
+                ...(options.token ? { KTX_MCP_TOKEN: options.token } : {}),
+            },
+        });
+        if (!child.pid) {
+            throw new Error('Failed to start KTX MCP daemon: child process pid was not available.');
+        }
+        child.unref();
+        const state = {
+            schemaVersion: 1,
+            pid: child.pid,
+            host: options.host,
+            port: options.port,
+            tokenAuth: Boolean(options.token),
+            projectDir: options.projectDir,
+            startedAt: (options.now ?? (() => new Date()))().toISOString(),
+            logPath,
+        };
+        await writeState(options.projectDir, state);
+        return { status: 'started', state, url: `http://${state.host}:${state.port}/mcp` };
+    }
+    finally {
+        await log.close();
+    }
+}
+export async function readKtxMcpDaemonStatus(options) {
+    let state;
+    try {
+        state = await readState(options.projectDir);
+    }
+    catch (error) {
+        return { kind: 'stale', detail: `MCP daemon state is invalid: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (!state) {
+        return { kind: 'stopped', detail: `No MCP daemon state at ${mcpDaemonLayout(options.projectDir).statePath}` };
+    }
+    const processAlive = options.processAlive ?? defaultProcessAlive;
+    if (!processAlive(state.pid)) {
+        return { kind: 'stale', detail: `MCP daemon process ${state.pid} is not running`, state };
+    }
+    const health = await (options.fetchHealth ?? defaultFetchHealth)(state);
+    if (!health.ok) {
+        return { kind: 'stale', detail: health.detail ?? 'MCP daemon health check failed', state };
+    }
+    return {
+        kind: 'running',
+        detail: `KTX MCP daemon running at http://${state.host}:${state.port}/mcp`,
+        state,
+        url: `http://${state.host}:${state.port}/mcp`,
+    };
+}
+export async function stopKtxMcpDaemon(options) {
+    const state = await readState(options.projectDir);
+    const { statePath } = mcpDaemonLayout(options.projectDir);
+    if (!state) {
+        return { status: 'already-stopped' };
+    }
+    const processAlive = options.processAlive ?? defaultProcessAlive;
+    const killProcess = options.killProcess ?? defaultKillProcess;
+    if (processAlive(state.pid)) {
+        killProcess(state.pid, 'SIGTERM');
+        const deadline = Date.now() + (options.stopGraceMs ?? 10_000);
+        while (Date.now() <= deadline && processAlive(state.pid)) {
+            await delay(options.pollIntervalMs ?? 100);
+        }
+        if (processAlive(state.pid)) {
+            killProcess(state.pid, 'SIGKILL');
+        }
+    }
+    await rm(statePath, { force: true });
+    return { status: 'stopped' };
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/managed-mcp-daemon.test.js

@@ -0,0 +1,104 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mcpDaemonLayout, readKtxMcpDaemonStatus, startKtxMcpDaemon, stopKtxMcpDaemon, } from './managed-mcp-daemon.js';
+function child(pid = 4242) {
+    return { pid, unref: vi.fn() };
+}
+function state(projectDir, overrides = {}) {
+    return {
+        schemaVersion: 1,
+        pid: 4242,
+        host: '127.0.0.1',
+        port: 7878,
+        tokenAuth: false,
+        projectDir,
+        startedAt: '2026-05-14T00:00:00.000Z',
+        logPath: join(projectDir, '.ktx/logs/mcp.log'),
+        ...overrides,
+    };
+}
+describe('managed MCP daemon lifecycle', () => {
+    let tempDir;
+    let projectDir;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-mcp-daemon-'));
+        projectDir = join(tempDir, 'project');
+        await mkdir(projectDir, { recursive: true });
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    it('uses the spec state and log paths', () => {
+        expect(mcpDaemonLayout(projectDir)).toEqual({
+            statePath: join(projectDir, '.ktx/mcp.json'),
+            logPath: join(projectDir, '.ktx/logs/mcp.log'),
+        });
+    });
+    it('starts a detached child and writes state without the token value', async () => {
+        const spawnDaemon = vi.fn(() => child(5555));
+        await startKtxMcpDaemon({
+            projectDir,
+            cliVersion: '0.0.0-test',
+            host: '0.0.0.0',
+            port: 7879,
+            token: 'secret-token',
+            allowedHosts: ['mcp.example.test'],
+            allowedOrigins: ['https://mcp.example.test'],
+            binPath: '/repo/packages/cli/dist/bin.js',
+            spawnDaemon,
+            processAlive: vi.fn(() => false),
+            portAvailable: vi.fn(async () => true),
+            now: () => new Date('2026-05-14T00:00:00.000Z'),
+        });
+        expect(spawnDaemon).toHaveBeenCalledWith(process.execPath, [
+            '/repo/packages/cli/dist/bin.js',
+            '--project-dir',
+            projectDir,
+            'mcp',
+            'serve-internal',
+            '--host',
+            '0.0.0.0',
+            '--port',
+            '7879',
+            '--allowed-host',
+            'mcp.example.test',
+            '--allowed-origin',
+            'https://mcp.example.test',
+        ], expect.objectContaining({
+            detached: true,
+            env: expect.objectContaining({ KTX_MCP_TOKEN: 'secret-token' }),
+        }));
+        expect(JSON.stringify(JSON.parse(await readFile(join(projectDir, '.ktx/mcp.json'), 'utf8')))).not.toContain('secret-token');
+    });
+    it('reports running when the process is alive and health passes', async () => {
+        await mkdir(join(projectDir, '.ktx'), { recursive: true });
+        await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir), null, 2)}\n`);
+        const status = await readKtxMcpDaemonStatus({
+            projectDir,
+            processAlive: vi.fn(() => true),
+            fetchHealth: vi.fn(async () => ({ ok: true, body: { status: 'ok', projectDir, port: 7878 } })),
+        });
+        expect(status.kind).toBe('running');
+        if (status.kind !== 'running') {
+            throw new Error(`Expected running status, received ${status.kind}`);
+        }
+        expect(status.url).toBe('http://127.0.0.1:7878/mcp');
+    });
+    it('stops a recorded daemon and removes state', async () => {
+        await mkdir(join(projectDir, '.ktx'), { recursive: true });
+        await writeFile(join(projectDir, '.ktx/mcp.json'), `${JSON.stringify(state(projectDir), null, 2)}\n`);
+        const alive = new Set([4242]);
+        const killProcess = vi.fn((pid) => alive.delete(pid));
+        await expect(stopKtxMcpDaemon({
+            projectDir,
+            processAlive: vi.fn((pid) => alive.has(pid)),
+            killProcess,
+            stopGraceMs: 1,
+            pollIntervalMs: 1,
+        })).resolves.toEqual({ status: 'stopped' });
+        expect(killProcess).toHaveBeenCalledWith(4242, 'SIGTERM');
+        await expect(readFile(join(projectDir, '.ktx/mcp.json'), 'utf8')).rejects.toThrow();
+    });
+});

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

@@ -0,0 +1,29 @@
+import { createPythonSemanticLayerComputePort, type KtxSemanticLayerComputePort } from '@ktx/context/daemon';
+import type { KtxCliIo } from './cli-runtime.js';
+import { type InstalledKtxRuntimeManifest, type KtxRuntimeFeature, type ManagedPythonRuntimeInstallOptions, type ManagedPythonRuntimeInstallResult, type ManagedPythonRuntimeLayout, type ManagedPythonRuntimeLayoutOptions, type ManagedPythonRuntimeStatus } from './managed-python-runtime.js';
+export type KtxManagedPythonInstallPolicy = 'prompt' | 'auto' | 'never';
+export declare function runtimeInstallPolicyFromFlags(options: {
+    yes?: boolean;
+    input?: boolean;
+}): KtxManagedPythonInstallPolicy;
+export interface ManagedPythonCommandRuntime {
+    layout: ManagedPythonRuntimeLayout;
+    manifest: InstalledKtxRuntimeManifest;
+}
+export interface ManagedPythonCommandDeps {
+    readStatus?: (options: ManagedPythonRuntimeLayoutOptions) => Promise<ManagedPythonRuntimeStatus>;
+    installRuntime?: (options: ManagedPythonRuntimeInstallOptions) => Promise<ManagedPythonRuntimeInstallResult>;
+    confirmInstall?: (message: string, io: KtxCliIo) => Promise<boolean>;
+}
+export interface ManagedPythonCommandOptions extends ManagedPythonCommandDeps {
+    cliVersion: string;
+    installPolicy: KtxManagedPythonInstallPolicy;
+    io: KtxCliIo;
+    feature?: KtxRuntimeFeature;
+}
+export interface ManagedPythonSemanticLayerComputeOptions extends ManagedPythonCommandOptions {
+    createPythonCompute?: typeof createPythonSemanticLayerComputePort;
+}
+export declare function managedRuntimeInstallCommand(feature: KtxRuntimeFeature): string;
+export declare function ensureManagedPythonCommandRuntime(options: ManagedPythonCommandOptions): Promise<ManagedPythonCommandRuntime>;
+export declare function createManagedPythonSemanticLayerComputePort(options: ManagedPythonSemanticLayerComputeOptions): Promise<KtxSemanticLayerComputePort>;

package/dist/managed-python-command.js

@@ -0,0 +1,77 @@
+import { createPythonSemanticLayerComputePort } from '@ktx/context/daemon';
+import { createClackPromptAdapter } from './clack.js';
+import { installManagedPythonRuntime, readManagedPythonRuntimeStatus, } from './managed-python-runtime.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');
+    }
+    if (options.yes === true) {
+        return 'auto';
+    }
+    return options.input === false ? 'never' : 'prompt';
+}
+export function managedRuntimeInstallCommand(feature) {
+    return feature === 'local-embeddings'
+        ? 'ktx dev runtime install --feature local-embeddings --yes'
+        : 'ktx dev runtime install --yes';
+}
+function installPrompt(feature) {
+    const label = feature === 'local-embeddings' ? 'local embeddings Python runtime' : 'core Python runtime';
+    return `KTX needs to install the ${label}. This downloads Python dependencies with uv. Continue?`;
+}
+function runtimeRequiredMessage(feature) {
+    return `KTX Python runtime is required for this command. Run: ${managedRuntimeInstallCommand(feature)}`;
+}
+function hasFeature(manifest, feature) {
+    return manifest.features.includes(feature);
+}
+async function defaultConfirmInstall(message, io) {
+    if (io.stdout.isTTY !== true) {
+        return false;
+    }
+    const prompts = createClackPromptAdapter();
+    return await prompts.confirm({ message, initialValue: true });
+}
+export async function ensureManagedPythonCommandRuntime(options) {
+    const feature = options.feature ?? 'core';
+    const readStatus = options.readStatus ?? readManagedPythonRuntimeStatus;
+    const installRuntime = options.installRuntime ?? installManagedPythonRuntime;
+    const status = await readStatus({ cliVersion: options.cliVersion });
+    if (status.kind === 'ready' && status.manifest && hasFeature(status.manifest, feature)) {
+        return { layout: status.layout, manifest: status.manifest };
+    }
+    if (options.installPolicy === 'never') {
+        throw new Error(runtimeRequiredMessage(feature));
+    }
+    if (options.installPolicy === 'prompt') {
+        const confirmInstall = options.confirmInstall ?? defaultConfirmInstall;
+        const confirmed = await confirmInstall(installPrompt(feature), options.io);
+        if (!confirmed) {
+            throw new Error(`KTX Python runtime installation was cancelled. Run: ${managedRuntimeInstallCommand(feature)}`);
+        }
+    }
+    options.io.stderr.write(`Installing KTX Python runtime (${feature}) with uv...\n`);
+    const installed = await installRuntime({
+        cliVersion: options.cliVersion,
+        features: [feature],
+        force: false,
+    });
+    options.io.stderr.write(`KTX Python runtime ready: ${installed.layout.versionDir}\n`);
+    return { layout: installed.layout, manifest: installed.manifest };
+}
+export async function createManagedPythonSemanticLayerComputePort(options) {
+    const runtime = await ensureManagedPythonCommandRuntime({
+        cliVersion: options.cliVersion,
+        installPolicy: options.installPolicy,
+        io: options.io,
+        feature: 'core',
+        ...(options.readStatus ? { readStatus: options.readStatus } : {}),
+        ...(options.installRuntime ? { installRuntime: options.installRuntime } : {}),
+        ...(options.confirmInstall ? { confirmInstall: options.confirmInstall } : {}),
+    });
+    const createPythonCompute = options.createPythonCompute ?? createPythonSemanticLayerComputePort;
+    return createPythonCompute({
+        command: runtime.manifest.python.daemonExecutable,
+        args: [],
+    });
+}