@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/daemon/semantic-layer-compute.d.ts

@@ -0,0 +1,72 @@
+import type { SemanticLayerQueryInput, SemanticLayerSource } from '../sl/index.js';
+export interface KtxSemanticLayerComputeQueryResult {
+    sql: string;
+    dialect: string;
+    columns: Array<Record<string, unknown>>;
+    plan: Record<string, unknown>;
+}
+export interface KtxSemanticLayerComputeValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    perSourceWarnings: Record<string, string[]>;
+}
+export interface KtxSemanticLayerSourceGenerationColumnInput {
+    name: string;
+    type: string;
+    primaryKey?: boolean;
+    nullable?: boolean;
+    comment?: string | null;
+}
+export interface KtxSemanticLayerSourceGenerationTableInput {
+    name: string;
+    catalog?: string | null;
+    db?: string | null;
+    comment?: string | null;
+    columns: KtxSemanticLayerSourceGenerationColumnInput[];
+}
+export interface KtxSemanticLayerSourceGenerationLinkInput {
+    fromTable: string;
+    fromColumn: string;
+    toTable: string;
+    toColumn: string;
+    relationshipType: string;
+}
+export interface KtxSemanticLayerSourceGenerationInput {
+    tables: KtxSemanticLayerSourceGenerationTableInput[];
+    links: KtxSemanticLayerSourceGenerationLinkInput[];
+    dialect?: string;
+}
+export interface KtxSemanticLayerSourceGenerationResult {
+    sources: Array<Record<string, unknown>>;
+    sourceCount: number;
+}
+export interface KtxSemanticLayerComputePort {
+    query(input: {
+        sources: Array<Record<string, unknown> | SemanticLayerSource>;
+        query: SemanticLayerQueryInput;
+        dialect: string;
+    }): Promise<KtxSemanticLayerComputeQueryResult>;
+    validateSources(input: {
+        sources: Array<Record<string, unknown> | SemanticLayerSource>;
+        dialect: string;
+        recentlyTouched?: string[];
+    }): Promise<KtxSemanticLayerComputeValidationResult>;
+    generateSources(input: KtxSemanticLayerSourceGenerationInput): Promise<KtxSemanticLayerSourceGenerationResult>;
+}
+export type KtxDaemonCommand = 'semantic-query' | 'semantic-validate' | 'semantic-generate-sources';
+export type KtxDaemonJsonRunner = (subcommand: KtxDaemonCommand, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
+export type KtxDaemonHttpJsonRunner = (path: string, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
+export interface PythonSemanticLayerComputeOptions {
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    runJson?: KtxDaemonJsonRunner;
+}
+export interface HttpSemanticLayerComputeOptions {
+    baseUrl: string;
+    requestJson?: KtxDaemonHttpJsonRunner;
+}
+export declare function createPythonSemanticLayerComputePort(options?: PythonSemanticLayerComputeOptions): KtxSemanticLayerComputePort;
+export declare function createHttpSemanticLayerComputePort(options: HttpSemanticLayerComputeOptions): KtxSemanticLayerComputePort;

package/node_modules/@ktx/context/dist/daemon/semantic-layer-compute.js

@@ -0,0 +1,191 @@
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { URL } from 'node:url';
+import { spawn } from 'node:child_process';
+function parseJsonObject(raw, subcommand) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`ktx-daemon ${subcommand} returned non-object JSON`);
+    }
+    return parsed;
+}
+function runProcessJson(options) {
+    return async (subcommand, payload) => new Promise((resolve, reject) => {
+        const child = spawn(options.command, [...options.args, subcommand], {
+            cwd: options.cwd,
+            env: { ...process.env, ...options.env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on('data', (chunk) => stdout.push(chunk));
+        child.stderr.on('data', (chunk) => stderr.push(chunk));
+        child.on('error', reject);
+        child.on('close', (code) => {
+            const stdoutText = Buffer.concat(stdout).toString('utf8').trim();
+            const stderrText = Buffer.concat(stderr).toString('utf8').trim();
+            if (code !== 0) {
+                reject(new Error(`ktx-daemon ${subcommand} failed: ${stderrText || `exit code ${code}`}`));
+                return;
+            }
+            try {
+                resolve(parseJsonObject(stdoutText, subcommand));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        child.stdin.end(`${JSON.stringify(payload)}\n`);
+    });
+}
+function normalizedBaseUrl(baseUrl) {
+    return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+}
+function postJson(baseUrl) {
+    return async (path, payload) => new Promise((resolve, reject) => {
+        const target = new URL(path.replace(/^\//, ''), normalizedBaseUrl(baseUrl));
+        const body = JSON.stringify(payload);
+        const client = target.protocol === 'https:' ? httpsRequest : httpRequest;
+        const request = client(target, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/json',
+                'content-length': Buffer.byteLength(body),
+            },
+        }, (response) => {
+            const chunks = [];
+            response.on('data', (chunk) => chunks.push(chunk));
+            response.on('end', () => {
+                const text = Buffer.concat(chunks).toString('utf8');
+                const statusCode = response.statusCode ?? 0;
+                if (statusCode < 200 || statusCode >= 300) {
+                    reject(new Error(`ktx-daemon HTTP ${path} failed with ${statusCode}: ${text}`));
+                    return;
+                }
+                try {
+                    resolve(parseJsonObject(text, path));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+        request.on('error', reject);
+        request.end(body);
+    });
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function recordArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => item !== null && typeof item === 'object' && !Array.isArray(item))
+        : [];
+}
+function sourceGenerationPayload(input) {
+    return {
+        tables: input.tables.map((table) => ({
+            name: table.name,
+            ...(table.catalog !== undefined ? { catalog: table.catalog } : {}),
+            ...(table.db !== undefined ? { db: table.db } : {}),
+            ...(table.comment !== undefined ? { comment: table.comment } : {}),
+            columns: table.columns.map((column) => ({
+                name: column.name,
+                type: column.type,
+                ...(column.primaryKey !== undefined ? { primary_key: column.primaryKey } : {}),
+                ...(column.nullable !== undefined ? { nullable: column.nullable } : {}),
+                ...(column.comment !== undefined ? { comment: column.comment } : {}),
+            })),
+        })),
+        links: input.links.map((link) => ({
+            from_table: link.fromTable,
+            from_column: link.fromColumn,
+            to_table: link.toTable,
+            to_column: link.toColumn,
+            relationship_type: link.relationshipType,
+        })),
+        dialect: input.dialect ?? 'postgres',
+    };
+}
+function sourceGenerationResult(raw) {
+    return {
+        sources: recordArray(raw.sources),
+        sourceCount: typeof raw.source_count === 'number' ? raw.source_count : recordArray(raw.sources).length,
+    };
+}
+export function createPythonSemanticLayerComputePort(options = {}) {
+    const command = options.command ?? 'python';
+    const args = options.args ?? ['-m', 'ktx_daemon'];
+    const runJson = options.runJson ?? runProcessJson({ command, args, cwd: options.cwd, env: options.env });
+    return {
+        async query(input) {
+            const raw = await runJson('semantic-query', {
+                sources: input.sources,
+                dialect: input.dialect,
+                query: input.query,
+            });
+            return {
+                sql: typeof raw.sql === 'string' ? raw.sql : '',
+                dialect: typeof raw.dialect === 'string' ? raw.dialect : input.dialect,
+                columns: recordArray(raw.columns),
+                plan: recordValue(raw.plan),
+            };
+        },
+        async validateSources(input) {
+            const raw = await runJson('semantic-validate', {
+                sources: input.sources,
+                dialect: input.dialect,
+                recently_touched: input.recentlyTouched,
+            });
+            return {
+                valid: raw.valid === true,
+                errors: stringArray(raw.errors),
+                warnings: stringArray(raw.warnings),
+                perSourceWarnings: recordValue(raw.per_source_warnings),
+            };
+        },
+        async generateSources(input) {
+            const raw = await runJson('semantic-generate-sources', sourceGenerationPayload(input));
+            return sourceGenerationResult(raw);
+        },
+    };
+}
+export function createHttpSemanticLayerComputePort(options) {
+    const requestJson = options.requestJson ?? postJson(options.baseUrl);
+    return {
+        async query(input) {
+            const raw = await requestJson('/semantic-layer/query', {
+                sources: input.sources,
+                dialect: input.dialect,
+                query: input.query,
+            });
+            return {
+                sql: typeof raw.sql === 'string' ? raw.sql : '',
+                dialect: typeof raw.dialect === 'string' ? raw.dialect : input.dialect,
+                columns: recordArray(raw.columns),
+                plan: recordValue(raw.plan),
+            };
+        },
+        async validateSources(input) {
+            const raw = await requestJson('/semantic-layer/validate', {
+                sources: input.sources,
+                dialect: input.dialect,
+                recently_touched: input.recentlyTouched,
+            });
+            return {
+                valid: raw.valid === true,
+                errors: stringArray(raw.errors),
+                warnings: stringArray(raw.warnings),
+                perSourceWarnings: recordValue(raw.per_source_warnings),
+            };
+        },
+        async generateSources(input) {
+            const raw = await requestJson('/semantic-layer/generate-sources', sourceGenerationPayload(input));
+            return sourceGenerationResult(raw);
+        },
+    };
+}

package/node_modules/@ktx/context/dist/daemon/semantic-layer-compute.test.d.ts

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

package/node_modules/@ktx/context/dist/daemon/semantic-layer-compute.test.js

@@ -0,0 +1,301 @@
+import { once } from 'node:events';
+import { createServer } from 'node:http';
+import { describe, expect, it, vi } from 'vitest';
+import { createHttpSemanticLayerComputePort, createPythonSemanticLayerComputePort } from './semantic-layer-compute.js';
+const source = {
+    name: 'orders',
+    table: 'public.orders',
+    grain: ['id'],
+    columns: [{ name: 'id', type: 'number' }],
+    joins: [],
+    measures: [{ name: 'order_count', expr: 'count(*)' }],
+};
+const sourceGenerationInput = {
+    tables: [
+        {
+            name: 'orders',
+            db: 'public',
+            comment: 'Orders table',
+            columns: [
+                { name: 'id', type: 'integer', primaryKey: true, nullable: false, comment: 'Order ID' },
+                { name: 'customer_id', type: 'integer' },
+                { name: 'amount', type: 'decimal', comment: 'Order amount' },
+            ],
+        },
+        {
+            name: 'customers',
+            db: 'public',
+            columns: [
+                { name: 'id', type: 'integer', primaryKey: true },
+                { name: 'email', type: 'varchar' },
+            ],
+        },
+    ],
+    links: [
+        {
+            fromTable: 'orders',
+            fromColumn: 'customer_id',
+            toTable: 'customers',
+            toColumn: 'id',
+            relationshipType: 'MANY_TO_ONE',
+        },
+    ],
+    dialect: 'postgres',
+};
+const sourceGenerationDaemonPayload = {
+    tables: [
+        {
+            name: 'orders',
+            db: 'public',
+            comment: 'Orders table',
+            columns: [
+                { name: 'id', type: 'integer', primary_key: true, nullable: false, comment: 'Order ID' },
+                { name: 'customer_id', type: 'integer' },
+                { name: 'amount', type: 'decimal', comment: 'Order amount' },
+            ],
+        },
+        {
+            name: 'customers',
+            db: 'public',
+            columns: [
+                { name: 'id', type: 'integer', primary_key: true },
+                { name: 'email', type: 'varchar' },
+            ],
+        },
+    ],
+    links: [
+        {
+            from_table: 'orders',
+            from_column: 'customer_id',
+            to_table: 'customers',
+            to_column: 'id',
+            relationship_type: 'MANY_TO_ONE',
+        },
+    ],
+    dialect: 'postgres',
+};
+const sourceGenerationDaemonResponse = {
+    source_count: 2,
+    sources: [
+        {
+            name: 'orders',
+            table: 'public.orders',
+            grain: ['id'],
+            columns: [{ name: 'id', type: 'number' }],
+            joins: [
+                {
+                    to: 'customers',
+                    on: 'customer_id = customers.id',
+                    relationship: 'many_to_one',
+                },
+            ],
+            measures: [{ name: 'record_count', expr: 'count(id)' }],
+        },
+    ],
+};
+describe('createPythonSemanticLayerComputePort', () => {
+    it('calls the semantic-query stdio command', async () => {
+        const runJson = vi.fn(async () => ({
+            sql: 'select count(*) from public.orders',
+            dialect: 'postgres',
+            columns: [{ name: 'orders.order_count' }],
+            plan: { sources_used: ['orders'] },
+        }));
+        const port = createPythonSemanticLayerComputePort({ runJson });
+        await expect(port.query({
+            sources: [source],
+            dialect: 'postgres',
+            query: { measures: ['orders.order_count'], dimensions: [] },
+        })).resolves.toEqual({
+            sql: 'select count(*) from public.orders',
+            dialect: 'postgres',
+            columns: [{ name: 'orders.order_count' }],
+            plan: { sources_used: ['orders'] },
+        });
+        expect(runJson).toHaveBeenCalledWith('semantic-query', {
+            sources: [source],
+            dialect: 'postgres',
+            query: { measures: ['orders.order_count'], dimensions: [] },
+        });
+    });
+    it('calls the semantic-validate stdio command', async () => {
+        const runJson = vi.fn(async () => ({
+            valid: true,
+            errors: [],
+            warnings: [],
+            per_source_warnings: {},
+        }));
+        const port = createPythonSemanticLayerComputePort({ runJson });
+        await expect(port.validateSources({
+            sources: [source],
+            dialect: 'postgres',
+            recentlyTouched: ['orders'],
+        })).resolves.toEqual({
+            valid: true,
+            errors: [],
+            warnings: [],
+            perSourceWarnings: {},
+        });
+        expect(runJson).toHaveBeenCalledWith('semantic-validate', {
+            sources: [source],
+            dialect: 'postgres',
+            recently_touched: ['orders'],
+        });
+    });
+    it('calls the semantic-generate-sources stdio command', async () => {
+        const runJson = vi.fn(async () => sourceGenerationDaemonResponse);
+        const port = createPythonSemanticLayerComputePort({ runJson });
+        await expect(port.generateSources(sourceGenerationInput)).resolves.toEqual({
+            sourceCount: 2,
+            sources: sourceGenerationDaemonResponse.sources,
+        });
+        expect(runJson).toHaveBeenCalledWith('semantic-generate-sources', sourceGenerationDaemonPayload);
+    });
+});
+describe('createHttpSemanticLayerComputePort', () => {
+    it('calls semantic query and validate HTTP endpoints through an injected runner', async () => {
+        const requestJson = vi.fn(async (path) => {
+            if (path === '/semantic-layer/query') {
+                return {
+                    sql: 'select count(*) from public.orders',
+                    dialect: 'postgres',
+                    columns: [{ name: 'orders.order_count' }],
+                    plan: { sources_used: ['orders'] },
+                };
+            }
+            return {
+                valid: true,
+                errors: [],
+                warnings: [],
+                per_source_warnings: {},
+            };
+        });
+        const port = createHttpSemanticLayerComputePort({ baseUrl: 'http://127.0.0.1:8765/', requestJson });
+        await expect(port.query({
+            sources: [source],
+            dialect: 'postgres',
+            query: { measures: ['orders.order_count'], dimensions: [] },
+        })).resolves.toEqual({
+            sql: 'select count(*) from public.orders',
+            dialect: 'postgres',
+            columns: [{ name: 'orders.order_count' }],
+            plan: { sources_used: ['orders'] },
+        });
+        await expect(port.validateSources({
+            sources: [source],
+            dialect: 'postgres',
+            recentlyTouched: ['orders'],
+        })).resolves.toEqual({
+            valid: true,
+            errors: [],
+            warnings: [],
+            perSourceWarnings: {},
+        });
+        expect(requestJson).toHaveBeenNthCalledWith(1, '/semantic-layer/query', {
+            sources: [source],
+            dialect: 'postgres',
+            query: { measures: ['orders.order_count'], dimensions: [] },
+        });
+        expect(requestJson).toHaveBeenNthCalledWith(2, '/semantic-layer/validate', {
+            sources: [source],
+            dialect: 'postgres',
+            recently_touched: ['orders'],
+        });
+    });
+    it('calls the semantic source-generation HTTP endpoint through an injected runner', async () => {
+        const requestJson = vi.fn(async () => sourceGenerationDaemonResponse);
+        const port = createHttpSemanticLayerComputePort({ baseUrl: 'http://127.0.0.1:8765/', requestJson });
+        await expect(port.generateSources(sourceGenerationInput)).resolves.toEqual({
+            sourceCount: 2,
+            sources: sourceGenerationDaemonResponse.sources,
+        });
+        expect(requestJson).toHaveBeenCalledWith('/semantic-layer/generate-sources', sourceGenerationDaemonPayload);
+    });
+    it('posts JSON to a running HTTP daemon endpoint', async () => {
+        const requests = [];
+        const server = createServer((request, response) => {
+            const chunks = [];
+            request.on('data', (chunk) => chunks.push(chunk));
+            request.on('end', () => {
+                requests.push({
+                    url: request.url,
+                    body: JSON.parse(Buffer.concat(chunks).toString('utf8')),
+                });
+                response.writeHead(200, { 'content-type': 'application/json' });
+                response.end(JSON.stringify({
+                    sql: 'select count(*) from public.orders',
+                    dialect: 'postgres',
+                    columns: [{ name: 'orders.order_count' }],
+                    plan: { sources_used: ['orders'] },
+                }));
+            });
+        });
+        server.listen(0, '127.0.0.1');
+        await once(server, 'listening');
+        try {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                throw new Error('expected TCP server address');
+            }
+            const port = createHttpSemanticLayerComputePort({ baseUrl: `http://127.0.0.1:${address.port}` });
+            await expect(port.query({
+                sources: [source],
+                dialect: 'postgres',
+                query: { measures: ['orders.order_count'], dimensions: [] },
+            })).resolves.toMatchObject({
+                sql: 'select count(*) from public.orders',
+                dialect: 'postgres',
+            });
+            expect(requests).toEqual([
+                {
+                    url: '/semantic-layer/query',
+                    body: {
+                        sources: [source],
+                        dialect: 'postgres',
+                        query: { measures: ['orders.order_count'], dimensions: [] },
+                    },
+                },
+            ]);
+        }
+        finally {
+            server.close();
+        }
+    });
+    it('posts source-generation JSON to a running HTTP daemon endpoint', async () => {
+        const requests = [];
+        const server = createServer((request, response) => {
+            const chunks = [];
+            request.on('data', (chunk) => chunks.push(chunk));
+            request.on('end', () => {
+                requests.push({
+                    url: request.url,
+                    body: JSON.parse(Buffer.concat(chunks).toString('utf8')),
+                });
+                response.writeHead(200, { 'content-type': 'application/json' });
+                response.end(JSON.stringify(sourceGenerationDaemonResponse));
+            });
+        });
+        server.listen(0, '127.0.0.1');
+        await once(server, 'listening');
+        try {
+            const address = server.address();
+            if (!address || typeof address === 'string') {
+                throw new Error('expected TCP server address');
+            }
+            const port = createHttpSemanticLayerComputePort({ baseUrl: `http://127.0.0.1:${address.port}` });
+            await expect(port.generateSources(sourceGenerationInput)).resolves.toEqual({
+                sourceCount: 2,
+                sources: sourceGenerationDaemonResponse.sources,
+            });
+            expect(requests).toEqual([
+                {
+                    url: '/semantic-layer/generate-sources',
+                    body: sourceGenerationDaemonPayload,
+                },
+            ]);
+        }
+        finally {
+            server.close();
+        }
+    });
+});

package/node_modules/@ktx/context/dist/index.d.ts

@@ -0,0 +1,21 @@
+export interface KtxContextPackageInfo {
+    name: '@ktx/context';
+    version: '0.0.0-private';
+}
+export declare const ktxContextPackageInfo: KtxContextPackageInfo;
+export * from './agent/index.js';
+export * from './core/index.js';
+export * from './daemon/index.js';
+export * from './ingest/index.js';
+export * from './llm/index.js';
+export type { CaptureSession, CaptureSignals, MemoryAgentInput, MemoryAgentResult, MemoryAgentServiceDeps, MemoryAgentSettings, MemoryAgentSourceType, MemoryCommitMessagePort, MemoryConnectionPort, MemoryFileStorePort, MemoryKnowledgeSlRefsPort, MemoryLockPort, MemorySlSourceReconcilerPort, MemoryTelemetryPort, MemoryToolSetLike, MemoryToolsetFactoryPort, } from './memory/index.js';
+export * from './project/index.js';
+export * from './prompts/index.js';
+export * from './search/index.js';
+export * from './sql-analysis/index.js';
+export type { KtxColumnAnalysisResult, KtxColumnDescriptionPromptInput, KtxColumnEmbeddingForeignKeys, KtxColumnEmbeddingTextInput, KtxColumnSampleInput, KtxColumnSampleResult, KtxColumnSampleUpdate, KtxColumnStatsInput, KtxColumnStatsResult, KtxConnectionDriver, KtxConnectorCapabilities, KtxCredentialEnvelope, KtxCredentialEnvReference, KtxCredentialFileReference, KtxDataDictionaryColumnState, KtxDataDictionarySampleDecision, KtxDataDictionarySettings, KtxDataDictionarySkipReason, KtxDataSourceDescriptionPromptInput, KtxDescriptionCachePort, KtxDescriptionColumn, KtxDescriptionColumnTable, KtxDescriptionGenerationSettings, KtxDescriptionGeneratorOptions, KtxDescriptionSource, KtxDescriptionTableInput, KtxDescriptionUpdate, KtxEmbeddingPort as KtxScanEmbeddingPort, KtxEmbeddingUpdate, KtxEnrichedColumn, KtxEnrichedRelationship, KtxEnrichedSchema, KtxEnrichedTable, KtxEnrichmentScanPhaseResult, KtxGenerateColumnDescriptionsInput, KtxGenerateDataSourceDescriptionInput, KtxGenerateTableDescriptionInput, KtxOptionalConnectorCapabilities, KtxProgressPort, KtxQueryResult as KtxScanQueryResult, KtxReadOnlyQueryInput, KtxRelationshipEndpoint, KtxRelationshipSource, KtxRelationshipType, KtxRelationshipUpdate, KtxResolvedCredentialEnvelope, KtxScanArtifactPaths, KtxScanConnector, KtxScanContext, KtxScanDiffSummary, KtxScanEnrichmentSummary, KtxScanInput, KtxScanLoggerPort, KtxScanMetadataStore, KtxScanMode, KtxScanOrchestratorOptions, KtxScanOrchestratorRunInput, KtxScanOrchestratorRunResult, KtxScanRelationshipSummary, KtxScanReport, KtxScanTrigger, KtxScanWarning, KtxScanWarningCode, KtxSchemaColumn, KtxSchemaDimensionType, KtxSchemaForeignKey, KtxSchemaScope, KtxSchemaSnapshot, KtxSchemaTable, KtxSchemaTableKind, KtxSkippedRelationship, KtxStructuralScanPhaseResult, KtxStructuralSyncPlan, KtxStructuralSyncStats, KtxTableDescriptionPromptInput, KtxTableRef, KtxTableSampleInput, KtxTableSampleResult, KtxColumnTypeMapping, } from './scan/index.js';
+export { appendKtxWordLimitInstruction, buildKtxColumnDescriptionPrompt, buildKtxColumnEmbeddingText, buildKtxDataSourceDescriptionPrompt, buildKtxTableDescriptionPrompt, createKtxConnectorCapabilities, defaultKtxDataDictionarySettings, inferKtxDimensionType, isKtxDataDictionaryCandidate, ktxColumnTypeMappingFromNative, KtxDescriptionGenerator, KtxScanOrchestrator, normalizeKtxNativeType, REDACTED_KTX_CREDENTIAL_VALUE, redactKtxCredentialEnvelope, redactKtxCredentialValue, redactKtxScanMetadata, redactKtxScanReport, redactKtxScanWarning, shouldKtxSampleColumnForDictionary, } from './scan/index.js';
+export * from './skills/index.js';
+export * from './sl/index.js';
+export * from './tools/index.js';
+export * from './wiki/index.js';

package/node_modules/@ktx/context/dist/index.js

@@ -0,0 +1,18 @@
+export const ktxContextPackageInfo = {
+    name: '@ktx/context',
+    version: '0.0.0-private',
+};
+export * from './agent/index.js';
+export * from './core/index.js';
+export * from './daemon/index.js';
+export * from './ingest/index.js';
+export * from './llm/index.js';
+export * from './project/index.js';
+export * from './prompts/index.js';
+export * from './search/index.js';
+export * from './sql-analysis/index.js';
+export { appendKtxWordLimitInstruction, buildKtxColumnDescriptionPrompt, buildKtxColumnEmbeddingText, buildKtxDataSourceDescriptionPrompt, buildKtxTableDescriptionPrompt, createKtxConnectorCapabilities, defaultKtxDataDictionarySettings, inferKtxDimensionType, isKtxDataDictionaryCandidate, ktxColumnTypeMappingFromNative, KtxDescriptionGenerator, KtxScanOrchestrator, normalizeKtxNativeType, REDACTED_KTX_CREDENTIAL_VALUE, redactKtxCredentialEnvelope, redactKtxCredentialValue, redactKtxScanMetadata, redactKtxScanReport, redactKtxScanWarning, shouldKtxSampleColumnForDictionary, } from './scan/index.js';
+export * from './skills/index.js';
+export * from './sl/index.js';
+export * from './tools/index.js';
+export * from './wiki/index.js';

package/node_modules/@ktx/context/dist/index.test.d.ts

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

package/node_modules/@ktx/context/dist/index.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest';
+import { ktxContextPackageInfo } from './index.js';
+describe('ktxContextPackageInfo', () => {
+    it('identifies the context package', () => {
+        expect(ktxContextPackageInfo).toEqual({
+            name: '@ktx/context',
+            version: '0.0.0-private',
+        });
+    });
+});

package/node_modules/@ktx/context/dist/ingest/action-identity.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryAction } from '../memory/index.js';
+export declare function actionTargetConnectionId(action: MemoryAction, runConnectionId: string): string;
+export declare function memoryActionIdentity(action: MemoryAction, runConnectionId: string): string;

package/node_modules/@ktx/context/dist/ingest/action-identity.js

@@ -0,0 +1,6 @@
+export function actionTargetConnectionId(action, runConnectionId) {
+    return action.target === 'sl' ? (action.targetConnectionId ?? runConnectionId) : runConnectionId;
+}
+export function memoryActionIdentity(action, runConnectionId) {
+    return `${action.target}:${actionTargetConnectionId(action, runConnectionId)}:${action.key}`;
+}

package/node_modules/@ktx/context/dist/ingest/action-identity.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/action-identity.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { actionTargetConnectionId, memoryActionIdentity } from './action-identity.js';
+describe('memory action target identity', () => {
+    it('keys SL actions by target connection and wiki actions by run connection', () => {
+        expect(memoryActionIdentity({ target: 'sl', type: 'created', key: 'orders', detail: '', targetConnectionId: 'warehouse-b' }, 'looker-run')).toBe('sl:warehouse-b:orders');
+        expect(memoryActionIdentity({ target: 'sl', type: 'created', key: 'orders', detail: '' }, 'warehouse-a')).toBe('sl:warehouse-a:orders');
+        expect(memoryActionIdentity({
+            target: 'wiki',
+            type: 'created',
+            key: 'knowledge/global/orders.md',
+            detail: '',
+            targetConnectionId: 'ignored',
+        }, 'looker-run')).toBe('wiki:looker-run:knowledge/global/orders.md');
+    });
+    it('resolves action target connection only for SL actions', () => {
+        expect(actionTargetConnectionId({ target: 'sl', type: 'updated', key: 'orders', detail: '', targetConnectionId: 'warehouse-b' }, 'looker-run')).toBe('warehouse-b');
+        expect(actionTargetConnectionId({ target: 'wiki', type: 'updated', key: 'orders', detail: '' }, 'looker-run')).toBe('looker-run');
+    });
+});

package/node_modules/@ktx/context/dist/ingest/adapters/dbt/chunk.d.ts

@@ -0,0 +1,7 @@
+import type { ChunkResult, DiffSet } from '../../types.js';
+import type { ParsedDbtProject } from './parse.js';
+interface ChunkOptions {
+    diffSet?: DiffSet;
+}
+export declare function chunkDbtProject(project: ParsedDbtProject, opts?: ChunkOptions): ChunkResult;
+export {};