@kaelio/ktx 0.4.1 → 0.5.0

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,6 +1,7 @@
-import { KtxIngestEmbeddingPortAdapter } from '@ktx/context';
-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';
@@ -31,9 +32,10 @@ export async function createKtxMcpServerFactory(input) {
         cliVersion: input.cliVersion,
         io,
     });
-    const embeddingService = resolution.kind === 'configured' || resolution.kind === 'managed-running' || resolution.kind === 'managed-started'
-        ? new KtxIngestEmbeddingPortAdapter(resolution.provider)
+    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,
@@ -45,15 +47,21 @@ export async function createKtxMcpServerFactory(input) {
     });
     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;

package/dist/memory-flow-hud.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryFlowReplayInput } from '@ktx/context/ingest/memory-flow';
+import type { MemoryFlowReplayInput } from './context/ingest/memory-flow/types.js';
 import { type ReactNode } from 'react';
 interface HudTheme {
     text: string;

package/dist/memory-flow-interactive.d.ts

@@ -1,4 +1,4 @@
-import { type MemoryFlowInteractionCommand, type MemoryFlowInteractionState, type MemoryFlowReplayInput } from '@ktx/context/ingest';
+import type { MemoryFlowInteractionCommand, MemoryFlowInteractionState, MemoryFlowReplayInput } from './context/ingest/memory-flow/types.js';
 interface KtxMemoryFlowKey {
     name?: string;
     ctrl?: boolean;
@@ -24,6 +24,7 @@ interface KtxMemoryFlowInteractiveIo {
 interface RenderMemoryFlowInteractiveOptions {
     prepareKeypressEvents?(stdin: KtxMemoryFlowStdin): void;
 }
+/** @internal */
 export declare function memoryFlowCommandForKey(chunk: string, search: MemoryFlowInteractionState['search'], key: KtxMemoryFlowKey): MemoryFlowInteractionCommand | null;
 export declare function renderMemoryFlowInteractively(input: MemoryFlowReplayInput, io: KtxMemoryFlowInteractiveIo, options?: RenderMemoryFlowInteractiveOptions): Promise<void>;
 export {};

package/dist/memory-flow-interactive.js

@@ -1,8 +1,11 @@
 import { emitKeypressEvents } from 'node:readline';
-import { buildMemoryFlowViewModel, createInitialMemoryFlowInteractionState, reduceMemoryFlowInteractionState, renderMemoryFlowInteractive, } from '@ktx/context/ingest';
+import { buildMemoryFlowViewModel } from './context/ingest/memory-flow/view-model.js';
+import { createInitialMemoryFlowInteractionState, reduceMemoryFlowInteractionState } from './context/ingest/memory-flow/interaction.js';
+import { renderMemoryFlowInteractive } from './context/ingest/memory-flow/interactive-render.js';
 function defaultPrepareKeypressEvents(stdin) {
     emitKeypressEvents(stdin);
 }
+/** @internal */
 export function memoryFlowCommandForKey(chunk, search, key) {
     if (search.editing) {
         if (key.name === 'escape')

package/dist/memory-flow-tui.d.ts

@@ -1,4 +1,4 @@
-import { type MemoryFlowInteractionCommand, type MemoryFlowInteractionState, type MemoryFlowReplayInput } from '@ktx/context/ingest';
+import type { MemoryFlowInteractionCommand, MemoryFlowInteractionState, MemoryFlowReplayInput } from './context/ingest/memory-flow/types.js';
 import { type ReactNode } from 'react';
 export interface KtxMemoryFlowTuiIo {
     stdin?: {
@@ -19,13 +19,14 @@ export interface MemoryFlowTuiLiveSession {
     close(): void;
     isClosed(): boolean;
 }
+/** @internal */
 export interface MemoryFlowInkInstance {
     rerender(tree: ReactNode): void;
     unmount(): void;
     waitUntilExit(): Promise<void>;
     clear?(): void;
 }
-export interface MemoryFlowInkRenderOptions {
+interface MemoryFlowInkRenderOptions {
     stdin?: KtxMemoryFlowTuiIo['stdin'];
     stdout: KtxMemoryFlowTuiIo['stdout'];
     stderr: KtxMemoryFlowTuiIo['stderr'];
@@ -69,7 +70,9 @@ interface MemoryFlowTuiAppProps {
     showBoot?: boolean;
 }
 export declare function sanitizeMemoryFlowTuiError(error: unknown): string;
+/** @internal */
 export declare function memoryFlowCommandForInkInput(input: string, key: InkKey, search?: MemoryFlowInteractionState['search']): MemoryFlowInteractionCommand | null;
+/** @internal */
 export declare function MemoryFlowTuiApp(props: MemoryFlowTuiAppProps): ReactNode;
 export declare function renderMemoryFlowTui(input: MemoryFlowReplayInput, io: KtxMemoryFlowTuiIo, options?: RenderMemoryFlowTuiOptions): Promise<boolean>;
 export declare function startLiveMemoryFlowTui(input: MemoryFlowReplayInput, io: KtxMemoryFlowTuiIo, options?: StartLiveMemoryFlowTuiOptions): Promise<MemoryFlowTuiLiveSession | null>;

package/dist/memory-flow-tui.js

@@ -1,6 +1,7 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 /* @jsxImportSource react */
-import { buildMemoryFlowViewModel, createInitialMemoryFlowInteractionState, findMemoryFlowSearchMatches, reduceMemoryFlowInteractionState, selectedMemoryFlowColumn, selectedMemoryFlowDetails, } from '@ktx/context/ingest';
+import { buildMemoryFlowViewModel } from './context/ingest/memory-flow/view-model.js';
+import { createInitialMemoryFlowInteractionState, findMemoryFlowSearchMatches, reduceMemoryFlowInteractionState, selectedMemoryFlowColumn, selectedMemoryFlowDetails, } from './context/ingest/memory-flow/interaction.js';
 import { Box, Text, render as renderInkRuntime, useApp, useInput } from 'ink';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { ActivityFeed, Hud, Logo, } from './memory-flow-hud.js';
@@ -50,6 +51,7 @@ export function sanitizeMemoryFlowTuiError(error) {
         .replace(/[a-z][a-z0-9+.-]*:\/\/[^\s]+/gi, '[redacted-url]')
         .replace(/\b(api[_-]?key|password|token|secret)=\S+/gi, '[redacted]');
 }
+/** @internal */
 export function memoryFlowCommandForInkInput(input, key, search = { editing: false, query: '', matchIndex: 0 }) {
     if (search.editing) {
         if (key.escape)
@@ -150,6 +152,7 @@ function TrustIssues(props) {
     }
     return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: props.theme.warning, children: "Validation notes" }), props.view.trustIssues.slice(0, 4).map((issue) => (_jsxs(Text, { color: issue.severity === 'failed' ? props.theme.failed : props.theme.warning, children: [issue.severity === 'failed' ? 'FAILED' : 'WARNING', " ", humanizeDemoText(issue.title), ":", ' ', humanizeDemoText(issue.detail)] }, `${issue.severity}-${issue.title}`)))] }));
 }
+/** @internal */
 export function MemoryFlowTuiApp(props) {
     const app = useApp();
     const totalEvents = props.input.events.length;

package/dist/next-steps.d.ts

@@ -1,3 +1,4 @@
+/** @internal */
 export declare const KTX_CONTEXT_BUILD_COMMANDS: readonly [{
     readonly command: "ktx ingest";
     readonly description: "Build or refresh agent-ready context from all configured connections";
@@ -15,6 +16,7 @@ export declare const KTX_NEXT_STEP_DIRECT_COMMANDS: readonly [{
     readonly command: "ktx wiki";
     readonly description: "Inspect generated wiki pages";
 }];
+/** @internal */
 export declare const KTX_NEXT_STEP_COMMANDS: readonly [{
     readonly command: "ktx status --json";
     readonly description: "Verify project setup and context readiness";
@@ -25,7 +27,6 @@ export declare const KTX_NEXT_STEP_COMMANDS: readonly [{
     readonly command: "ktx wiki";
     readonly description: "Inspect generated wiki pages";
 }];
-export declare const KTX_NEXT_STEP_COMMAND_WIDTH: number;
 export interface KtxSetupNextStepState {
     setupReady: boolean;
     hasContextTargets: boolean;

package/dist/next-steps.js

@@ -1,3 +1,4 @@
+/** @internal */
 export const KTX_CONTEXT_BUILD_COMMANDS = [
     {
         command: 'ktx ingest',
@@ -22,8 +23,9 @@ export const KTX_NEXT_STEP_DIRECT_COMMANDS = [
         description: 'Inspect generated wiki pages',
     },
 ];
+/** @internal */
 export const KTX_NEXT_STEP_COMMANDS = [...KTX_NEXT_STEP_DIRECT_COMMANDS];
-export const KTX_NEXT_STEP_COMMAND_WIDTH = Math.max(...[...KTX_CONTEXT_BUILD_COMMANDS, ...KTX_NEXT_STEP_COMMANDS].map((step) => step.command.length));
+const KTX_NEXT_STEP_COMMAND_WIDTH = Math.max(...[...KTX_CONTEXT_BUILD_COMMANDS, ...KTX_NEXT_STEP_COMMANDS].map((step) => step.command.length));
 function commandLines(commands, indent) {
     return commands.map((step) => `${indent}$ ${step.command.padEnd(KTX_NEXT_STEP_COMMAND_WIDTH)}  ${step.description}`);
 }

package/dist/notion-page-picker.d.ts

@@ -1,5 +1,5 @@
-import { type NotionApi } from '@ktx/context/ingest';
-import type { KtxProjectConnectionConfig } from '@ktx/context/project';
+import { type NotionApi } from './context/ingest/adapters/notion/notion-client.js';
+import type { KtxProjectConnectionConfig } from './context/project/config.js';
 import type { KtxCliIo } from './cli-runtime.js';
 import { type PickerState, type TreePickerNodeInput } from './tree-picker-state.js';
 import { type TreePickerChrome, type TreePickerResult, type TreePickerTuiIo } from './tree-picker-tui.js';
@@ -7,6 +7,7 @@ export interface PickNotionRootPagesArgs {
     connectionId: string;
     connection: KtxProjectConnectionConfig;
 }
+/** @internal */
 export type NotionPickerApi = Pick<NotionApi, 'search' | 'retrieveBotUser'>;
 export type NotionRootPagePickResult = {
     kind: 'selected';
@@ -22,8 +23,11 @@ export interface NotionRootPagePickerDeps {
     createNotionApi?: (authToken: string) => NotionPickerApi;
     renderPicker?: (chrome: TreePickerChrome, initialState: PickerState, io: TreePickerTuiIo) => Promise<TreePickerResult>;
 }
+/** @internal */
 export declare function normalizeNotionPageId(value: string): string;
+/** @internal */
 export declare function notionPickerPageFromSearchResult(result: Record<string, unknown>): TreePickerNodeInput;
+/** @internal */
 export declare function discoverNotionPickerPages(api: NotionPickerApi, options?: {
     cap?: number;
 }): Promise<{
@@ -31,5 +35,6 @@ export declare function discoverNotionPickerPages(api: NotionPickerApi, options?
     cappedAtCount: number | null;
     warnings: string[];
 }>;
+/** @internal */
 export declare function resolveNotionWorkspaceLabel(api: NotionPickerApi, connectionId: string): Promise<string>;
 export declare function pickNotionRootPages(args: PickNotionRootPagesArgs, io?: KtxCliIo, deps?: NotionRootPagePickerDeps): Promise<NotionRootPagePickResult>;

package/dist/notion-page-picker.js

@@ -1,5 +1,5 @@
-import { resolveNotionConnectionAuthToken } from '@ktx/context/connections';
-import { NotionClient } from '@ktx/context/ingest';
+import { resolveNotionConnectionAuthToken } from './context/connections/notion-config.js';
+import { NotionClient } from './context/ingest/adapters/notion/notion-client.js';
 import { profileMark } from './startup-profile.js';
 import { buildInitialState, buildPickerTree, flattenSelection, } from './tree-picker-state.js';
 import { renderTreePickerTui, } from './tree-picker-tui.js';
@@ -11,6 +11,7 @@ function assertSafeNotionPickerConnectionId(connectionId) {
         throw new Error(`Unsafe connection id: ${connectionId}`);
     }
 }
+/** @internal */
 export function normalizeNotionPageId(value) {
     const trimmed = value.trim();
     const compact = trimmed.includes('-') ? trimmed.replace(/-/g, '') : trimmed;
@@ -63,6 +64,7 @@ function extractParentPageId(page) {
     }
     return normalizeNotionPageId(parent.page_id);
 }
+/** @internal */
 export function notionPickerPageFromSearchResult(result) {
     const id = typeof result.id === 'string' ? normalizeNotionPageId(result.id) : '';
     if (!id) {
@@ -75,6 +77,7 @@ export function notionPickerPageFromSearchResult(result) {
         parentId: extractParentPageId(result),
     };
 }
+/** @internal */
 export async function discoverNotionPickerPages(api, options = {}) {
     const cap = options.cap ?? NOTION_PICKER_PAGE_CAP;
     const pages = [];
@@ -110,6 +113,7 @@ export async function discoverNotionPickerPages(api, options = {}) {
     }
     return { pages, cappedAtCount: cap, warnings };
 }
+/** @internal */
 export async function resolveNotionWorkspaceLabel(api, connectionId) {
     try {
         const bot = (await api.retrieveBotUser());

package/dist/print-command-tree.js

@@ -1,5 +1,6 @@
 import { fileURLToPath } from 'node:url';
 import { buildKtxProgram } from './cli-program.js';
+import { getKtxCliPackageInfo } from './cli-runtime.js';
 import { formatCommandTree, walkCommandTree } from './command-tree.js';
 function silentIo() {
     return {
@@ -7,18 +8,11 @@ function silentIo() {
         stderr: { write: () => { } },
     };
 }
-function stubPackageInfo() {
-    return {
-        name: '@ktx/cli',
-        version: '0.0.0-docs',
-        contextPackageName: '@ktx/context',
-    };
-}
 export function renderKtxCommandTree() {
     const program = buildKtxProgram({
         io: silentIo(),
         deps: {},
-        packageInfo: stubPackageInfo(),
+        packageInfo: getKtxCliPackageInfo(),
         runInit: async () => 0,
     });
     return formatCommandTree(walkCommandTree(program));

package/dist/prompt-navigation.d.ts

@@ -1,3 +1,4 @@
+/** @internal */
 export declare function withMenuOptionSpacing(message: string): string;
 export declare function withMenuOptionsSpacing<T extends {
     message: string;

package/dist/prompt-navigation.js

@@ -34,6 +34,7 @@ function withTextInputBodySpacing(message) {
     }
     return `${title}\n\n${bodyLines.join('\n')}`;
 }
+/** @internal */
 export function withMenuOptionSpacing(message) {
     if (!message.includes('\n') || message.endsWith('\n')) {
         return message;