@kaelio/ktx 0.4.0 → 0.5.0

package/node_modules/@ktx/context/dist/scan/warehouse-catalog.test.js

@@ -1,158 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { initKtxProject } from '../project/index.js';
-import { WarehouseCatalogService } from './warehouse-catalog.js';
-describe('WarehouseCatalogService', () => {
-    let tempDir;
-    let project;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-warehouse-catalog-'));
-        project = await initKtxProject({ projectDir: join(tempDir, 'project') });
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    async function seedLiveDatabaseScan(connectionId = 'warehouse', syncId = 'sync-2', driver = 'postgres') {
-        const root = `raw-sources/${connectionId}/live-database/${syncId}`;
-        const tableRef = {
-            catalog: driver === 'bigquery' ? 'analytics' : null,
-            db: driver === 'sqlite' ? null : 'public',
-            name: 'orders',
-        };
-        await project.fileStore.writeFile(`${root}/connection.json`, JSON.stringify({ connectionId, driver, extractedAt: '2026-05-12T00:00:00.000Z' }, null, 2), 'ktx', 'ktx@example.com', 'seed connection');
-        await project.fileStore.writeFile(`${root}/tables/orders.json`, JSON.stringify({
-            catalog: tableRef.catalog,
-            db: tableRef.db,
-            name: tableRef.name,
-            kind: 'table',
-            comment: 'Customer orders',
-            estimatedRows: 12,
-            columns: [
-                {
-                    name: 'id',
-                    nativeType: 'integer',
-                    normalizedType: 'integer',
-                    dimensionType: 'number',
-                    nullable: false,
-                    primaryKey: true,
-                    comment: 'Order id',
-                },
-                {
-                    name: 'status',
-                    nativeType: 'text',
-                    normalizedType: 'text',
-                    dimensionType: 'string',
-                    nullable: false,
-                    primaryKey: false,
-                    comment: 'Order status',
-                },
-            ],
-            foreignKeys: [],
-        }, null, 2), 'ktx', 'ktx@example.com', 'seed orders');
-        await project.fileStore.writeFile(`${root}/enrichment/relationship-profile.json`, JSON.stringify({
-            connectionId,
-            driver,
-            sqlAvailable: true,
-            queryCount: 3,
-            tables: [{ table: { catalog: tableRef.catalog, db: tableRef.db, name: tableRef.name }, rowCount: 12 }],
-            columns: {
-                'orders.status': {
-                    table: { catalog: tableRef.catalog, db: tableRef.db, name: tableRef.name },
-                    column: 'status',
-                    nativeType: 'text',
-                    normalizedType: 'text',
-                    rowCount: 12,
-                    nullCount: 0,
-                    distinctCount: 2,
-                    uniquenessRatio: 0.1667,
-                    nullRate: 0,
-                    sampleValues: ['paid', 'refunded'],
-                    minTextLength: 4,
-                    maxTextLength: 8,
-                },
-            },
-            warnings: [],
-        }, null, 2), 'ktx', 'ktx@example.com', 'seed profile');
-    }
-    it('finds the latest sync and merges table schema with relationship profile values', async () => {
-        await seedLiveDatabaseScan('warehouse', 'sync-1');
-        await seedLiveDatabaseScan('warehouse', 'sync-2');
-        const catalog = new WarehouseCatalogService({ fileStore: project.fileStore });
-        await expect(catalog.getLatestSyncId('warehouse')).resolves.toBe('sync-2');
-        const detail = await catalog.getTable({ connectionId: 'warehouse', catalog: null, db: 'public', name: 'orders' });
-        expect(detail).toMatchObject({
-            connectionId: 'warehouse',
-            display: 'public.orders',
-            rowCount: 12,
-            columns: [
-                { name: 'id', nativeType: 'integer', primaryKey: true },
-                { name: 'status', nativeType: 'text', sampleValues: ['paid', 'refunded'], distinctCount: 2 },
-            ],
-        });
-        expect(detail).not.toHaveProperty(['connection', 'Name'].join(''));
-        const hits = await catalog.searchByName('warehouse', 'orders', 5);
-        expect(hits[0]).toMatchObject({
-            kind: 'table',
-            connectionId: 'warehouse',
-            display: 'public.orders',
-        });
-        expect(hits[0]).not.toHaveProperty(['connection', 'Name'].join(''));
-    });
-    it('returns scanAvailable=false when no live-database scan exists', async () => {
-        const catalog = new WarehouseCatalogService({ fileStore: project.fileStore });
-        await expect(catalog.getTable({ connectionId: 'missing', catalog: null, db: 'public', name: 'orders' })).resolves.toBeNull();
-        await expect(catalog.hasScan('missing')).resolves.toBe(false);
-    });
-    it('resolves postgres display strings and returns closest candidates for missing tables', async () => {
-        await seedLiveDatabaseScan();
-        const catalog = new WarehouseCatalogService({ fileStore: project.fileStore });
-        await expect(catalog.resolveDisplay('warehouse', 'public.orders')).resolves.toMatchObject({
-            resolved: { catalog: null, db: 'public', name: 'orders' },
-            candidates: [],
-            dialect: 'postgres',
-        });
-        await expect(catalog.resolveDisplay('warehouse', 'public.orderz')).resolves.toMatchObject({
-            resolved: null,
-            candidates: [{ name: 'orders' }],
-        });
-    });
-    it('treats two-part BigQuery identifiers as ambiguous instead of guessing', async () => {
-        await seedLiveDatabaseScan('warehouse', 'sync-bigquery', 'bigquery');
-        const catalog = new WarehouseCatalogService({ fileStore: project.fileStore });
-        await expect(catalog.resolveDisplay('warehouse', 'public.orders')).resolves.toMatchObject({
-            resolved: null,
-            dialect: 'bigquery',
-        });
-    });
-    it('resolves postgres column display strings without treating the column as a table', async () => {
-        await seedLiveDatabaseScan();
-        const catalog = new WarehouseCatalogService({ fileStore: project.fileStore });
-        await expect(catalog.resolveDisplayTarget('warehouse', 'public.orders.status')).resolves.toMatchObject({
-            resolved: { catalog: null, db: 'public', name: 'orders', column: 'status' },
-            candidates: [],
-            dialect: 'postgres',
-        });
-    });
-    it('resolves BigQuery column display strings with four parts', async () => {
-        await seedLiveDatabaseScan('warehouse', 'sync-bigquery', 'bigquery');
-        const catalog = new WarehouseCatalogService({ fileStore: project.fileStore });
-        await expect(catalog.resolveDisplayTarget('warehouse', 'analytics.public.orders.status')).resolves.toMatchObject({
-            resolved: { catalog: 'analytics', db: 'public', name: 'orders', column: 'status' },
-            candidates: [],
-            dialect: 'bigquery',
-        });
-    });
-    it('searches table names, column names, comments, and descriptions', async () => {
-        await seedLiveDatabaseScan();
-        const catalog = new WarehouseCatalogService({ fileStore: project.fileStore });
-        await expect(catalog.searchByName('warehouse', 'status', 10)).resolves.toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                kind: 'column',
-                ref: expect.objectContaining({ db: 'public', name: 'orders', column: 'status' }),
-                matchedOn: 'name',
-            }),
-        ]));
-    });
-});

package/node_modules/@ktx/context/dist/search/backend-conformance.test.d.ts

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

package/node_modules/@ktx/context/dist/search/backend-conformance.test.js

@@ -1,408 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, it } from 'vitest';
-import { SqliteContextEvidenceStore } from '../ingest/context-evidence/index.js';
-import { initKtxProject } from '../project/index.js';
-import { searchLocalSlSources, writeLocalSlSource } from '../sl/local-sl.js';
-import { searchLocalKnowledgePages, writeLocalKnowledgePage, } from '../wiki/local-knowledge.js';
-import { assertSearchBackendCapabilities, assertSearchBackendConformanceCase, } from './backend-conformance.js';
-const SQLITE_SEARCH_CAPABILITIES = {
-    fts: true,
-    vector: false,
-    fuzzy: false,
-    jsonSearch: true,
-    arraySearch: false,
-};
-const ORDERS_YAML = [
-    'name: orders',
-    'table: public.orders',
-    'grain:',
-    '  - order_id',
-    'columns:',
-    '  - name: order_id',
-    '    type: string',
-    '  - name: revenue',
-    '    type: number',
-    'measures:',
-    '  - name: total_revenue',
-    '    expr: sum(revenue)',
-    '',
-].join('\n');
-const FINANCE_ORDERS_YAML = [
-    'name: orders',
-    'descriptions:',
-    '  user: Finance orders used for invoice reconciliation.',
-    'table: finance.orders',
-    'grain:',
-    '  - order_id',
-    'columns:',
-    '  - name: order_id',
-    '    type: string',
-    '  - name: invoice_status',
-    '    type: string',
-    '',
-].join('\n');
-class FakeEmbeddingPort {
-    maxBatchSize = 16;
-    async computeEmbedding(text) {
-        return text.toLowerCase().includes('semantic revenue') ? [1, 0] : [0, 1];
-    }
-    async computeEmbeddingsBulk(texts) {
-        return Promise.all(texts.map((text) => this.computeEmbedding(text)));
-    }
-}
-function toSlConformanceResult(result) {
-    return {
-        id: `${result.connectionId}/${result.name}`,
-        score: result.score ?? 0,
-        matchReasons: result.matchReasons ?? [],
-        lanes: result.lanes,
-        dictionaryMatches: result.dictionaryMatches,
-    };
-}
-function toWikiConformanceResult(result) {
-    return {
-        id: result.key,
-        score: result.score,
-        matchReasons: result.matchReasons,
-        lanes: result.lanes,
-    };
-}
-function toContextConformanceResult(result) {
-    return {
-        id: `${result.externalId}:${result.stableCitationKey}`,
-        score: result.score,
-        matchReasons: result.matchReasons ?? [],
-        lanes: result.lanes,
-    };
-}
-async function seedSemanticLayerProject(project) {
-    await writeLocalSlSource(project, {
-        connectionId: 'warehouse',
-        sourceName: 'orders',
-        yaml: ORDERS_YAML,
-    });
-    await writeLocalSlSource(project, {
-        connectionId: 'finance',
-        sourceName: 'orders',
-        yaml: FINANCE_ORDERS_YAML,
-    });
-    await project.fileStore.writeFile('raw-sources/warehouse/live-database/sync-1/enrichment/relationship-profile.json', `${JSON.stringify({
-        connectionId: 'warehouse',
-        driver: 'postgres',
-        sqlAvailable: true,
-        queryCount: 2,
-        tables: [],
-        columns: {
-            'orders.status': {
-                table: { catalog: null, db: 'public', name: 'orders' },
-                column: 'status',
-                nativeType: 'text',
-                normalizedType: 'string',
-                rowCount: 10,
-                nullCount: 0,
-                distinctCount: 2,
-                uniquenessRatio: 0.2,
-                nullRate: 0,
-                sampleValues: ['paid', 'refunded'],
-                minTextLength: 4,
-                maxTextLength: 8,
-            },
-        },
-        warnings: [],
-    }, null, 2)}\n`, 'ktx', 'ktx@example.com', 'Seed dictionary profile');
-}
-async function seedWikiProject(project) {
-    await writeLocalKnowledgePage(project, {
-        key: 'metrics-revenue',
-        scope: 'GLOBAL',
-        summary: 'Semantic revenue definition',
-        content: 'Revenue is recognized when an order is paid.',
-        tags: ['finance'],
-        refs: ['semantic-layer/warehouse/orders.yaml'],
-        slRefs: ['orders'],
-    });
-    await writeLocalKnowledgePage(project, {
-        key: 'support-escalations',
-        scope: 'GLOBAL',
-        summary: 'Support escalation process',
-        content: 'Escalations move urgent support tickets to the operations queue.',
-        tags: ['operations'],
-    });
-}
-async function seedContextDocument(subject, input = {}) {
-    const runId = input.runId ?? 'run-1';
-    const syncId = input.syncId ?? 'sync-1';
-    const externalId = input.externalId ?? 'page-1';
-    const title = input.title ?? 'Revenue Policy';
-    const rawPath = input.rawPath ?? `pages/${externalId}/page.md`;
-    const doc = await subject.upsertDocument({
-        runId,
-        connectionId: 'conn-1',
-        sourceKey: 'notion',
-        externalId,
-        externalParentId: null,
-        databaseId: null,
-        dataSourceId: null,
-        title,
-        path: `Company Handbook / ${title}`,
-        url: `https://notion.test/${externalId}`,
-        objectType: 'page',
-        lastEditedAt: new Date('2026-04-30T10:00:00.000Z'),
-        lastEditedBy: 'user-1',
-        rawPath,
-        syncId,
-        contentHash: `hash-${externalId}`,
-        publishState: input.publishState ?? 'published',
-        metadata: input.metadata ?? {},
-    });
-    await subject.replaceChunks(doc.id, [
-        {
-            chunkKey: 'intro',
-            headingPath: ['Policy'],
-            ordinal: 0,
-            content: input.content ?? `${title} requires approval from the accountable owner.`,
-            searchText: input.searchText ?? `${title} approval accountable owner`,
-            embedding: input.embedding ?? [1, 0, 0],
-            tokenCount: 8,
-            citation: {
-                source: 'notion',
-                pageId: externalId,
-                title,
-                syncId,
-                rawPath,
-            },
-            stableCitationKey: `notion:${externalId}:intro`,
-            syncId,
-            contentHash: `chunk-${externalId}`,
-        },
-    ]);
-    const read = await subject.readDocumentByExternalId('conn-1', 'notion', externalId, runId);
-    if (!read) {
-        throw new Error(`seeded document ${externalId} was not readable`);
-    }
-    return { documentId: doc.id, chunkId: read.chunks[0].id };
-}
-describe('SQLite hybrid search backend conformance', () => {
-    let tempDir;
-    let project;
-    let dbPath;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-search-conformance-'));
-        project = await initKtxProject({ projectDir: join(tempDir, 'project') });
-        dbPath = join(tempDir, '.ktx', 'db.sqlite');
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('documents SQLite search backend capabilities', () => {
-        assertSearchBackendCapabilities({
-            backendName: 'sqlite',
-            capabilities: SQLITE_SEARCH_CAPABILITIES,
-            expected: {
-                fts: true,
-                vector: false,
-                fuzzy: false,
-                jsonSearch: true,
-                arraySearch: false,
-            },
-        });
-    });
-    it('keeps semantic-layer global ranking, dictionary evidence, and token fallback stable', async () => {
-        await seedSemanticLayerProject(project);
-        const global = await searchLocalSlSources(project, { query: 'orders', limit: 5 });
-        assertSearchBackendConformanceCase({
-            backendName: 'sqlite',
-            surface: 'semantic-layer',
-            caseName: 'global source ranking',
-            results: global.map(toSlConformanceResult),
-            expectedTopIds: ['finance/orders', 'warehouse/orders'],
-            expectedReasonsById: {
-                'finance/orders': ['lexical'],
-                'warehouse/orders': ['lexical'],
-            },
-            expectedLanes: {
-                lexical: { status: 'available' },
-                semantic: { status: 'skipped', reason: 'embedding_unconfigured' },
-            },
-        });
-        const dictionary = await searchLocalSlSources(project, {
-            connectionId: 'warehouse',
-            query: 'refunded',
-            limit: 5,
-        });
-        assertSearchBackendConformanceCase({
-            backendName: 'sqlite',
-            surface: 'semantic-layer',
-            caseName: 'dictionary source evidence',
-            results: dictionary.map(toSlConformanceResult),
-            expectedTopIds: ['warehouse/orders'],
-            expectedReasonsById: {
-                'warehouse/orders': ['dictionary'],
-            },
-            expectedLanes: {
-                dictionary: { status: 'available' },
-                semantic: { status: 'skipped', reason: 'embedding_unconfigured' },
-            },
-            expectedDictionaryMatchesById: {
-                'warehouse/orders': [{ column: 'status', values: ['refunded'] }],
-            },
-        });
-        const token = await searchLocalSlSources(project, {
-            connectionId: 'warehouse',
-            query: 'orders---',
-            limit: 5,
-        });
-        assertSearchBackendConformanceCase({
-            backendName: 'sqlite',
-            surface: 'semantic-layer',
-            caseName: 'token fallback reason',
-            results: token.map(toSlConformanceResult),
-            expectedTopIds: ['warehouse/orders'],
-            expectedReasonsById: {
-                'warehouse/orders': ['token'],
-            },
-            expectedLanes: {
-                token: { status: 'available' },
-            },
-        });
-    });
-    it('keeps wiki lexical, semantic, and token behavior stable', async () => {
-        await seedWikiProject(project);
-        const lexical = await searchLocalKnowledgePages(project, {
-            query: 'paid order',
-            userId: 'local',
-            limit: 5,
-        });
-        assertSearchBackendConformanceCase({
-            backendName: 'sqlite',
-            surface: 'wiki',
-            caseName: 'lexical page ranking',
-            results: lexical.map(toWikiConformanceResult),
-            expectedTopIds: ['metrics-revenue'],
-            expectedReasonsById: {
-                'metrics-revenue': ['lexical'],
-            },
-            expectedLanes: {
-                lexical: { status: 'available' },
-                semantic: { status: 'skipped', reason: 'embedding_unconfigured' },
-            },
-        });
-        const semantic = await searchLocalKnowledgePages(project, {
-            query: 'semantic revenue',
-            userId: 'local',
-            limit: 5,
-            embeddingService: new FakeEmbeddingPort(),
-        });
-        assertSearchBackendConformanceCase({
-            backendName: 'sqlite',
-            surface: 'wiki',
-            caseName: 'semantic page ranking',
-            results: semantic.map(toWikiConformanceResult),
-            expectedTopIds: ['metrics-revenue'],
-            expectedReasonsById: {
-                'metrics-revenue': ['semantic'],
-            },
-            expectedLanes: {
-                semantic: { status: 'available' },
-            },
-        });
-        const token = await searchLocalKnowledgePages(project, {
-            query: 'paid---',
-            userId: 'local',
-            limit: 5,
-        });
-        assertSearchBackendConformanceCase({
-            backendName: 'sqlite',
-            surface: 'wiki',
-            caseName: 'token page fallback',
-            results: token.map(toWikiConformanceResult),
-            expectedTopIds: ['metrics-revenue'],
-            expectedReasonsById: {
-                'metrics-revenue': ['token'],
-            },
-            expectedLanes: {
-                token: { status: 'available' },
-            },
-        });
-    });
-    it('keeps context-evidence lane fusion and token fallback stable', async () => {
-        const subject = new SqliteContextEvidenceStore({ dbPath });
-        await seedContextDocument(subject, {
-            externalId: 'page-discount',
-            title: 'Enterprise Discount Policy',
-            content: 'Enterprise discounts require finance approval before quote approval.',
-            searchText: 'enterprise discount finance approval quote',
-            embedding: [1, 0, 0],
-        });
-        await seedContextDocument(subject, {
-            externalId: 'page-owner',
-            title: 'Accountable Owner Policy',
-            content: 'Every policy has an accountable owner and review date.',
-            searchText: 'accountable owner review date',
-            embedding: [0.95, 0.05, 0],
-        });
-        await seedContextDocument(subject, {
-            externalId: 'page-expense',
-            title: 'Expense Policy',
-            content: 'Expense reimbursement requires receipt review.',
-            searchText: 'expense reimbursement receipt review',
-            embedding: [0, 1, 0],
-        });
-        const fused = await subject.searchRRF({
-            connectionId: 'conn-1',
-            sourceKey: 'notion',
-            queryEmbedding: [1, 0, 0],
-            queryText: 'enterprise discount approval',
-            limit: 2,
-            includeDeleted: false,
-        });
-        assertSearchBackendConformanceCase({
-            backendName: 'sqlite',
-            surface: 'context-evidence',
-            caseName: 'chunk lane fusion',
-            results: fused.map(toContextConformanceResult),
-            expectedTopIds: ['page-discount:notion:page-discount:intro'],
-            expectedReasonsById: {
-                'page-discount:notion:page-discount:intro': ['lexical', 'semantic', 'token'],
-            },
-            expectedLanes: {
-                lexical: { status: 'available' },
-                semantic: { status: 'available' },
-                token: { status: 'available' },
-            },
-        });
-        const tokenSubject = new SqliteContextEvidenceStore({ dbPath: join(tempDir, 'token.sqlite') });
-        await seedContextDocument(tokenSubject, {
-            externalId: 'page-cpp',
-            title: 'C++ Warehouse Notes',
-            content: 'C++ parser notes for warehouse extraction.',
-            searchText: 'C++ parser warehouse extraction',
-            embedding: null,
-        });
-        const token = await tokenSubject.searchRRF({
-            connectionId: 'conn-1',
-            sourceKey: 'notion',
-            queryEmbedding: null,
-            queryText: '++',
-            limit: 5,
-            includeDeleted: false,
-        });
-        assertSearchBackendConformanceCase({
-            backendName: 'sqlite',
-            surface: 'context-evidence',
-            caseName: 'fts-empty token fallback',
-            results: token.map(toContextConformanceResult),
-            expectedTopIds: ['page-cpp:notion:page-cpp:intro'],
-            expectedReasonsById: {
-                'page-cpp:notion:page-cpp:intro': ['token'],
-            },
-            expectedLanes: {
-                lexical: { status: 'skipped', reason: 'fts_query_empty' },
-                semantic: { status: 'skipped', reason: 'embedding_unconfigured' },
-                token: { status: 'available' },
-            },
-        });
-    });
-});

package/node_modules/@ktx/context/dist/search/discover.d.ts

@@ -1,30 +0,0 @@
-import type { KtxEmbeddingPort } from '../core/index.js';
-import type { KtxLocalProject } from '../project/index.js';
-import type { KtxTableRef } from '../scan/index.js';
-export type KtxDiscoverDataKind = 'wiki' | 'sl_source' | 'sl_measure' | 'sl_dimension' | 'table' | 'column';
-export type KtxDiscoverDataMatchedOn = 'name' | 'display' | 'description' | 'comment' | 'expr' | 'sample_value' | 'body';
-export interface KtxDiscoverDataInput {
-    query: string;
-    connectionId?: string;
-    kinds?: KtxDiscoverDataKind[];
-    limit?: number;
-}
-export interface KtxDiscoverDataRef {
-    kind: KtxDiscoverDataKind;
-    id: string;
-    score: number;
-    summary: string | null;
-    snippet: string | null;
-    matchedOn: KtxDiscoverDataMatchedOn;
-    connectionId?: string;
-    tableRef?: KtxTableRef;
-    columnName?: string;
-}
-export type KtxDiscoverDataResponse = KtxDiscoverDataRef[];
-export interface KtxDiscoverDataServiceOptions {
-    userId?: string;
-    embeddingService?: KtxEmbeddingPort | null;
-}
-export declare function createKtxDiscoverDataService(project: KtxLocalProject, options?: KtxDiscoverDataServiceOptions): {
-    search(input: KtxDiscoverDataInput): Promise<KtxDiscoverDataResponse>;
-};