@kaelio/ktx 0.5.0 → 0.6.0

package/dist/context/sl/sl-dictionary-profile.test.d.ts

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

package/dist/context/sl/sl-dictionary-profile.test.js

@@ -1,88 +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 '../../context/project/project.js';
-import { loadLatestSlDictionaryEntries } from './sl-dictionary-profile.js';
-describe('loadLatestSlDictionaryEntries', () => {
-    let tempDir;
-    let project;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-sl-dictionary-profile-'));
-        project = await initKtxProject({ projectDir: join(tempDir, 'project') });
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('loads latest relationship-profile sample values for dictionary candidate columns', async () => {
-        await project.fileStore.writeFile('raw-sources/warehouse/live-database/sync-1/enrichment/relationship-profile.json', `${JSON.stringify({
-            connectionId: 'warehouse',
-            driver: 'postgres',
-            sqlAvailable: true,
-            queryCount: 4,
-            tables: [],
-            columns: {
-                'orders.status': {
-                    table: { catalog: null, db: 'public', name: 'orders' },
-                    column: 'status',
-                    nativeType: 'text',
-                    normalizedType: 'string',
-                    rowCount: 20,
-                    nullCount: 0,
-                    distinctCount: 3,
-                    uniquenessRatio: 0.15,
-                    nullRate: 0,
-                    sampleValues: ['paid', 'refunded', 'pending'],
-                    minTextLength: 4,
-                    maxTextLength: 8,
-                },
-                'orders.customer_id': {
-                    table: { catalog: null, db: 'public', name: 'orders' },
-                    column: 'customer_id',
-                    nativeType: 'text',
-                    normalizedType: 'string',
-                    rowCount: 20,
-                    nullCount: 0,
-                    distinctCount: 20,
-                    uniquenessRatio: 1,
-                    nullRate: 0,
-                    sampleValues: ['cus_1'],
-                    minTextLength: 5,
-                    maxTextLength: 5,
-                },
-            },
-            warnings: [],
-        }, null, 2)}\n`, 'ktx', 'ktx@example.com', 'Seed profile');
-        await project.fileStore.writeFile('raw-sources/warehouse/live-database/sync-2/enrichment/relationship-profile.json', `${JSON.stringify({
-            connectionId: 'warehouse',
-            driver: 'postgres',
-            sqlAvailable: true,
-            queryCount: 4,
-            tables: [],
-            columns: {
-                'orders.status': {
-                    table: { catalog: null, db: 'public', name: 'orders' },
-                    column: 'status',
-                    nativeType: 'text',
-                    normalizedType: 'string',
-                    rowCount: 20,
-                    nullCount: 0,
-                    distinctCount: 2,
-                    uniquenessRatio: 0.1,
-                    nullRate: 0,
-                    sampleValues: ['settled', 'voided'],
-                    minTextLength: 6,
-                    maxTextLength: 7,
-                },
-            },
-            warnings: [],
-        }, null, 2)}\n`, 'ktx', 'ktx@example.com', 'Seed newer profile');
-        await expect(loadLatestSlDictionaryEntries(project, ['warehouse'])).resolves.toEqual([
-            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'status', value: 'settled', cardinality: 2 },
-            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'status', value: 'voided', cardinality: 2 },
-        ]);
-    });
-    it('returns an empty list when no relationship profile exists', async () => {
-        await expect(loadLatestSlDictionaryEntries(project, ['warehouse'])).resolves.toEqual([]);
-    });
-});

package/dist/context/sl/sl-search.service.test.d.ts

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

package/dist/context/sl/sl-search.service.test.js

@@ -1,256 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { buildSemanticLayerSourceSearchText, SlSearchService } from './sl-search.service.js';
-describe('SlSearchService', () => {
-    it('builds search text from source, columns, measures, and joins', () => {
-        const service = new SlSearchService({ maxBatchSize: 16, computeEmbedding: vi.fn(), computeEmbeddingsBulk: vi.fn() }, {
-            upsertSources: vi.fn(),
-            getExistingSearchTexts: vi.fn(),
-            deleteStale: vi.fn(),
-            deleteByConnection: vi.fn(),
-            deleteByConnectionAndName: vi.fn(),
-            search: vi.fn(),
-        });
-        const source = {
-            name: 'orders',
-            descriptions: { user: 'Customer orders' },
-            table: 'public.orders',
-            grain: ['id'],
-            columns: [
-                { name: 'id', type: 'string' },
-                { name: 'amount', type: 'number', descriptions: { user: 'Order amount' } },
-            ],
-            measures: [{ name: 'revenue', expr: 'sum(amount)', description: 'Gross revenue' }],
-            joins: [{ to: 'customers', on: 'orders.customer_id = customers.id', relationship: 'many_to_one' }],
-        };
-        expect(service.buildSearchText(source)).toContain('orders');
-        expect(service.buildSearchText(source)).toContain('Customer orders');
-        expect(service.buildSearchText(source)).toContain('amount (number) Order amount');
-        expect(service.buildSearchText(source)).toContain('measure: revenue sum(amount) Gross revenue');
-        expect(service.buildSearchText(source)).toContain('join: customers (many_to_one)');
-    });
-    it('exports the same canonical search text builder used by SlSearchService', () => {
-        const service = new SlSearchService({ maxBatchSize: 16, computeEmbedding: vi.fn(), computeEmbeddingsBulk: vi.fn() }, {
-            upsertSources: vi.fn(),
-            getExistingSearchTexts: vi.fn(),
-            deleteStale: vi.fn(),
-            deleteByConnection: vi.fn(),
-            deleteByConnectionAndName: vi.fn(),
-            search: vi.fn(),
-        });
-        const source = {
-            name: 'orders',
-            descriptions: { user: 'Customer orders' },
-            table: 'public.orders',
-            grain: ['id'],
-            columns: [
-                {
-                    name: 'status',
-                    type: 'string',
-                    enum_values: { dbt: ['paid', 'refunded'] },
-                    constraints: { dbt: { not_null: true } },
-                },
-            ],
-            joins: [{ to: 'customers', on: 'orders.customer_id = customers.id', relationship: 'many_to_one' }],
-            measures: [{ name: 'total_revenue', expr: 'sum(revenue)', description: 'Gross revenue' }],
-            tags: { dbt: ['finance'] },
-        };
-        expect(buildSemanticLayerSourceSearchText(source)).toBe(service.buildSearchText(source));
-        expect(buildSemanticLayerSourceSearchText(source)).toContain('dbt values: paid, refunded');
-        expect(buildSemanticLayerSourceSearchText(source)).toContain('measure: total_revenue sum(revenue) Gross revenue');
-        expect(buildSemanticLayerSourceSearchText(source)).toContain('dbt tags: finance');
-    });
-    it('includes dbt enum, not_null, and unique tokens for columns', () => {
-        const service = new SlSearchService({ maxBatchSize: 16, computeEmbedding: vi.fn(), computeEmbeddingsBulk: vi.fn() }, {
-            upsertSources: vi.fn(),
-            getExistingSearchTexts: vi.fn(),
-            deleteStale: vi.fn(),
-            deleteByConnection: vi.fn(),
-            deleteByConnectionAndName: vi.fn(),
-            search: vi.fn(),
-        });
-        const source = {
-            name: 'src_orders',
-            table: 'public.orders',
-            grain: [],
-            columns: [
-                {
-                    name: 'status',
-                    type: 'string',
-                    descriptions: {},
-                    enum_values: { dbt: ['a', 'b'] },
-                    constraints: { dbt: { not_null: true, unique: true } },
-                },
-            ],
-            joins: [],
-            measures: [],
-        };
-        const text = service.buildSearchText(source);
-        expect(text).toContain('dbt values: a, b');
-        expect(text).toContain('not_null');
-        expect(text).toContain('unique');
-    });
-    it('includes dbt default time token for MetricFlow agg_time_dimension', () => {
-        const service = new SlSearchService({ maxBatchSize: 16, computeEmbedding: vi.fn(), computeEmbeddingsBulk: vi.fn() }, {
-            upsertSources: vi.fn(),
-            getExistingSearchTexts: vi.fn(),
-            deleteStale: vi.fn(),
-            deleteByConnection: vi.fn(),
-            deleteByConnectionAndName: vi.fn(),
-            search: vi.fn(),
-        });
-        const source = {
-            name: 'orders',
-            table: 'public.orders',
-            grain: ['id'],
-            columns: [{ name: 'id', type: 'number' }],
-            joins: [],
-            measures: [],
-            default_time_dimension: { dbt: 'order_date' },
-        };
-        expect(service.buildSearchText(source)).toContain('dbt default time: order_date');
-    });
-    it('includes dbt table tags and freshness from manifest-backed source', () => {
-        const service = new SlSearchService({ maxBatchSize: 16, computeEmbedding: vi.fn(), computeEmbeddingsBulk: vi.fn() }, {
-            upsertSources: vi.fn(),
-            getExistingSearchTexts: vi.fn(),
-            deleteStale: vi.fn(),
-            deleteByConnection: vi.fn(),
-            deleteByConnectionAndName: vi.fn(),
-            search: vi.fn(),
-        });
-        const source = {
-            name: 'customers',
-            table: 'jaffle.customers',
-            grain: ['id'],
-            columns: [{ name: 'id', type: 'number' }],
-            joins: [],
-            measures: [],
-            tags: { dbt: ['raw', 'core'] },
-            freshness: {
-                dbt: {
-                    loaded_at_field: 'updated_at',
-                    raw: { warn_after: { count: 12, period: 'hour' } },
-                },
-            },
-        };
-        const text = service.buildSearchText(source);
-        expect(text).toContain('dbt tags: raw, core');
-        expect(text).toContain('dbt freshness:');
-        expect(text).toContain('loaded_at=updated_at');
-        expect(text).toContain('warn_after');
-    });
-    it('includes historic SQL usage in semantic-layer search text', () => {
-        const source = {
-            name: 'orders',
-            descriptions: { user: 'Customer orders' },
-            table: 'public.orders',
-            grain: ['order_id'],
-            columns: [{ name: 'order_id', type: 'string' }],
-            joins: [],
-            measures: [],
-            usage: {
-                narrative: 'Analysts inspect paid and refunded order lifecycle trends by customer segment.',
-                frequencyTier: 'high',
-                commonFilters: ['status', 'created_at'],
-                commonGroupBys: ['customer_segment'],
-                commonJoins: [{ table: 'public.customers', on: ['customer_id'] }],
-                staleSince: '2026-05-01T00:00:00.000Z',
-            },
-        };
-        const text = buildSemanticLayerSourceSearchText(source);
-        expect(text).toContain('usage: Analysts inspect paid and refunded order lifecycle trends by customer segment.');
-        expect(text).toContain('frequency: high');
-        expect(text).toContain('commonly filtered by: status, created_at');
-        expect(text).toContain('commonly grouped by: customer_segment');
-        expect(text).toContain('commonly joined to public.customers on customer_id');
-        expect(text).toContain('stale since 2026-05-01T00:00:00.000Z');
-    });
-    it('preserves FTS snippets returned by the source index', async () => {
-        const service = new SlSearchService({
-            maxBatchSize: 16,
-            computeEmbedding: vi.fn(async () => [1, 0]),
-            computeEmbeddingsBulk: vi.fn(),
-        }, {
-            upsertSources: vi.fn(),
-            getExistingSearchTexts: vi.fn(),
-            deleteStale: vi.fn(),
-            deleteByConnection: vi.fn(),
-            deleteByConnectionAndName: vi.fn(),
-            search: vi.fn(async () => [
-                {
-                    sourceName: 'orders',
-                    rrfScore: 0.75,
-                    snippet: 'usage: paid <mark>order</mark> lifecycle',
-                },
-            ]),
-        });
-        await expect(service.search('warehouse', 'order lifecycle', 10)).resolves.toEqual([
-            {
-                sourceName: 'orders',
-                score: 0.75,
-                snippet: 'usage: paid <mark>order</mark> lifecycle',
-            },
-        ]);
-    });
-    it('indexSources reports stats and supports lexical-only indexing', async () => {
-        const repository = {
-            upsertSources: vi.fn().mockResolvedValue(undefined),
-            getExistingSearchTexts: vi.fn().mockResolvedValue(new Map([
-                ['old_source', { searchText: 'old source', hasEmbedding: true }],
-            ])),
-            deleteStale: vi.fn().mockResolvedValue(1),
-            deleteByConnection: vi.fn().mockResolvedValue(0),
-            deleteByConnectionAndName: vi.fn(),
-            search: vi.fn(),
-        };
-        const service = new SlSearchService(null, repository);
-        const source = {
-            name: 'orders',
-            table: 'public.orders',
-            grain: ['id'],
-            columns: [{ name: 'id', type: 'number' }],
-            joins: [],
-            measures: [],
-        };
-        await expect(service.indexSources('warehouse', [source])).resolves.toEqual({
-            scanned: 1,
-            updated: 1,
-            deleted: 1,
-            embeddingsRecomputed: 0,
-            embeddingsFailed: 0,
-        });
-        expect(repository.upsertSources).toHaveBeenCalledWith('warehouse', [
-            expect.objectContaining({ sourceName: 'orders', embedding: null }),
-        ]);
-    });
-    it('does not update unchanged lexical-only SL rows on repeated sync', async () => {
-        const repository = {
-            upsertSources: vi.fn().mockResolvedValue(undefined),
-            getExistingSearchTexts: vi.fn().mockResolvedValue(new Map([
-                ['orders', { searchText: 'orders. table: public.orders. id (number)', hasEmbedding: false }],
-            ])),
-            deleteStale: vi.fn().mockResolvedValue(0),
-            deleteByConnection: vi.fn().mockResolvedValue(0),
-            deleteByConnectionAndName: vi.fn(),
-            search: vi.fn(),
-        };
-        const service = new SlSearchService(null, repository);
-        const source = {
-            name: 'orders',
-            table: 'public.orders',
-            grain: ['id'],
-            columns: [{ name: 'id', type: 'number' }],
-            joins: [],
-            measures: [],
-        };
-        await expect(service.indexSources('warehouse', [source])).resolves.toEqual({
-            scanned: 1,
-            updated: 0,
-            deleted: 0,
-            embeddingsRecomputed: 0,
-            embeddingsFailed: 0,
-        });
-        expect(repository.upsertSources).toHaveBeenCalledWith('warehouse', []);
-        expect(repository.deleteStale).toHaveBeenCalledWith('warehouse', ['orders']);
-    });
-});

package/dist/context/sl/sqlite-sl-sources-index.test.d.ts

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

package/dist/context/sl/sqlite-sl-sources-index.test.js

@@ -1,175 +0,0 @@
-import { access, 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 { SqliteSlSourcesIndex } from './sqlite-sl-sources-index.js';
-describe('SqliteSlSourcesIndex', () => {
-    let tempDir;
-    let dbPath;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-sqlite-sl-index-'));
-        dbPath = join(tempDir, 'db.sqlite');
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('creates SQLite tables and searches indexed source text with FTS snippets', async () => {
-        const index = new SqliteSlSourcesIndex({ dbPath });
-        await index.upsertSources('warehouse', [
-            {
-                sourceName: 'orders',
-                searchText: 'orders table: public.orders measure: total_revenue sum(revenue) gross revenue',
-                embedding: null,
-            },
-            {
-                sourceName: 'tickets',
-                searchText: 'tickets table: public.tickets measure: ticket_count count(*) support queue',
-                embedding: null,
-            },
-        ]);
-        await expect(access(dbPath)).resolves.toBeUndefined();
-        const directResults = await index.search('warehouse', null, 'gross revenue', 10);
-        expect(directResults).toEqual([
-            expect.objectContaining({
-                sourceName: 'orders',
-                rrfScore: expect.any(Number),
-                snippet: expect.stringContaining('<mark>'),
-            }),
-        ]);
-        expect(directResults[0]?.snippet).toContain('revenue');
-        const lexicalCandidates = await index.searchLexicalCandidates({ queryText: 'gross revenue', limit: 10 });
-        expect(lexicalCandidates).toEqual([
-            expect.objectContaining({
-                id: 'warehouse/orders',
-                connectionId: 'warehouse',
-                sourceName: 'orders',
-                snippet: expect.stringContaining('<mark>'),
-            }),
-        ]);
-    });
-    it('reports existing search text and embedding presence', async () => {
-        const index = new SqliteSlSourcesIndex({ dbPath });
-        await index.upsertSources('warehouse', [
-            {
-                sourceName: 'orders',
-                searchText: 'orders gross revenue',
-                embedding: [0.1, 0.2, 0.3],
-            },
-            {
-                sourceName: 'tickets',
-                searchText: 'tickets support queue',
-                embedding: null,
-            },
-        ]);
-        await expect(index.getExistingSearchTexts('warehouse')).resolves.toEqual(new Map([
-            ['orders', { searchText: 'orders gross revenue', hasEmbedding: true }],
-            ['tickets', { searchText: 'tickets support queue', hasEmbedding: false }],
-        ]));
-    });
-    it('deletes stale, named, and connection-scoped rows from the FTS index', async () => {
-        const index = new SqliteSlSourcesIndex({ dbPath });
-        await index.upsertSources('warehouse', [
-            { sourceName: 'orders', searchText: 'orders revenue', embedding: null },
-            { sourceName: 'tickets', searchText: 'tickets support', embedding: null },
-        ]);
-        await index.upsertSources('finance', [{ sourceName: 'invoices', searchText: 'invoices revenue', embedding: null }]);
-        await index.deleteStale('warehouse', ['orders']);
-        expect(await index.search('warehouse', null, 'support', 10)).toEqual([]);
-        expect(await index.search('warehouse', null, 'revenue', 10)).toEqual([
-            expect.objectContaining({ sourceName: 'orders' }),
-        ]);
-        expect(await index.search('finance', null, 'revenue', 10)).toEqual([
-            expect.objectContaining({ sourceName: 'invoices' }),
-        ]);
-        await index.deleteByConnectionAndName('warehouse', 'orders');
-        expect(await index.search('warehouse', null, 'revenue', 10)).toEqual([]);
-        await index.deleteByConnection('finance');
-        expect(await index.search('finance', null, 'revenue', 10)).toEqual([]);
-    });
-    it('clear removes sources and dictionary rows for one connection only', async () => {
-        const index = new SqliteSlSourcesIndex({ dbPath });
-        await index.upsertSources('warehouse', [
-            { sourceName: 'orders', searchText: 'orders revenue paid', embedding: null },
-        ]);
-        await index.upsertSources('finance', [
-            { sourceName: 'invoices', searchText: 'invoices revenue paid', embedding: null },
-        ]);
-        await index.replaceDictionaryEntries('warehouse', [
-            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'status', value: 'paid', cardinality: 1 },
-        ]);
-        await index.replaceDictionaryEntries('finance', [
-            { connectionId: 'finance', sourceName: 'invoices', columnName: 'status', value: 'paid', cardinality: 1 },
-        ]);
-        await expect(index.clear('warehouse')).resolves.toBe(1);
-        expect(await index.search('warehouse', null, 'revenue', 10)).toEqual([]);
-        expect(await index.search('finance', null, 'revenue', 10)).toEqual([
-            expect.objectContaining({ sourceName: 'invoices' }),
-        ]);
-        await expect(index.searchDictionaryCandidates({ connectionIds: ['warehouse'], queryText: 'paid', limit: 10 }))
-            .resolves.toEqual([]);
-        await expect(index.searchDictionaryCandidates({ connectionIds: ['finance'], queryText: 'paid', limit: 10 }))
-            .resolves.toEqual([expect.objectContaining({ connectionId: 'finance', sourceName: 'invoices' })]);
-    });
-    it('returns lane candidates with stable connection-scoped IDs', async () => {
-        const index = new SqliteSlSourcesIndex({ dbPath });
-        await index.upsertSources('warehouse', [
-            { sourceName: 'orders', searchText: 'orders gross revenue paid status', embedding: [1, 0] },
-        ]);
-        await index.upsertSources('finance', [
-            { sourceName: 'orders', searchText: 'finance orders invoices', embedding: [0, 1] },
-        ]);
-        await expect(index.searchLexicalCandidates({ queryText: 'gross revenue', limit: 25 })).resolves.toEqual([
-            expect.objectContaining({
-                id: 'warehouse/orders',
-                connectionId: 'warehouse',
-                sourceName: 'orders',
-                rank: 1,
-                rawScore: expect.any(Number),
-            }),
-        ]);
-        await expect(index.searchSemanticCandidates({ queryEmbedding: [0, 1], limit: 25 })).resolves.toEqual([
-            expect.objectContaining({ id: 'finance/orders', connectionId: 'finance', sourceName: 'orders', rank: 1 }),
-            expect.objectContaining({ id: 'warehouse/orders', connectionId: 'warehouse', sourceName: 'orders', rank: 2 }),
-        ]);
-    });
-    it('aggregates dictionary matches to one source-level lane candidate', async () => {
-        const index = new SqliteSlSourcesIndex({ dbPath });
-        await index.replaceDictionaryEntries('warehouse', [
-            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'status', value: 'paid', cardinality: 3 },
-            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'status', value: 'refunded', cardinality: 3 },
-            { connectionId: 'warehouse', sourceName: 'orders', columnName: 'channel', value: 'paid search', cardinality: 4 },
-            {
-                connectionId: 'warehouse',
-                sourceName: 'tickets',
-                columnName: 'priority',
-                value: 'paid support',
-                cardinality: 5,
-            },
-        ]);
-        await expect(index.searchDictionaryCandidates({ queryText: 'paid', limit: 25 })).resolves.toEqual([
-            expect.objectContaining({
-                id: 'warehouse/orders',
-                connectionId: 'warehouse',
-                sourceName: 'orders',
-                rank: 1,
-                matches: [
-                    { column: 'channel', values: ['paid search'] },
-                    { column: 'status', values: ['paid'] },
-                ],
-            }),
-            expect.objectContaining({
-                id: 'warehouse/tickets',
-                connectionId: 'warehouse',
-                sourceName: 'tickets',
-                rank: 2,
-                matches: [{ column: 'priority', values: ['paid support'] }],
-            }),
-        ]);
-    });
-    it('returns an empty result for blank or punctuation-only queries', async () => {
-        const index = new SqliteSlSourcesIndex({ dbPath });
-        await index.upsertSources('warehouse', [{ sourceName: 'orders', searchText: 'orders revenue', embedding: null }]);
-        expect(await index.search('warehouse', null, '   ', 10)).toEqual([]);
-        expect(await index.search('warehouse', null, '---', 10)).toEqual([]);
-    });
-});

package/dist/context/sl/tools/connection-id-schema.test.d.ts

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

package/dist/context/sl/tools/connection-id-schema.test.js

@@ -1,14 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { slToolConnectionIdSchema } from './connection-id-schema.js';
-describe('slToolConnectionIdSchema', () => {
-    it('accepts app UUIDs and local project connection ids', () => {
-        expect(slToolConnectionIdSchema.parse('00000000-0000-4000-8000-000000000001')).toBe('00000000-0000-4000-8000-000000000001');
-        expect(slToolConnectionIdSchema.parse('warehouse')).toBe('warehouse');
-        expect(slToolConnectionIdSchema.parse('warehouse_prod-1')).toBe('warehouse_prod-1');
-    });
-    it('rejects empty, path-like, and hidden connection ids', () => {
-        for (const value of ['', '../warehouse', 'warehouse/prod', '.warehouse', 'warehouse prod']) {
-            expect(() => slToolConnectionIdSchema.parse(value)).toThrow();
-        }
-    });
-});

package/dist/context/sl/tools/sl-discover.tool.test.d.ts

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

package/dist/context/sl/tools/sl-discover.tool.test.js

@@ -1,72 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
-import { SlDiscoverTool } from './sl-discover.tool.js';
-function makeTool() {
-    const semanticLayerService = {
-        listConnectionIdsWithNames: vi.fn(async () => []),
-        loadAllSources: vi.fn(async () => ({ sources: [], loadErrors: [] })),
-    };
-    const slSearchService = {
-        search: vi.fn(async () => []),
-    };
-    const tool = new SlDiscoverTool({
-        semanticLayerService: semanticLayerService,
-        slSearchService: slSearchService,
-        authorResolver: { resolve: vi.fn() },
-    }, { maxSources: 25, minRrfScore: 0, maxDetailedSources: 5 });
-    return { tool, semanticLayerService, slSearchService };
-}
-function makeContext(overrides = {}) {
-    return {
-        sourceId: 'src',
-        messageId: 'msg',
-        userId: 'user',
-        ...overrides,
-    };
-}
-function makeSession(semanticLayerService) {
-    return {
-        connectionId: 'dbt-main',
-        isWorktreeScoped: true,
-        preHead: 'base',
-        touchedSlSources: createTouchedSlSources(),
-        actions: [],
-        semanticLayerService: semanticLayerService,
-        wikiService: {},
-        configService: {},
-        gitService: {},
-    };
-}
-describe('SlDiscoverTool - session-scoped reads', () => {
-    it('discovers sources through context.session.semanticLayerService when a session is present', async () => {
-        const { tool, semanticLayerService } = makeTool();
-        const sessionSemanticLayerService = {
-            listConnectionIdsWithNames: vi.fn().mockResolvedValue([
-                { id: 'warehouse', name: 'warehouse', connectionType: 'postgres' },
-            ]),
-            loadAllSources: vi.fn().mockResolvedValue({
-                sources: [
-                    {
-                        name: 'orders',
-                        table: 'public.orders',
-                        grain: ['order_id'],
-                        columns: [{ name: 'order_id', type: 'string' }],
-                        measures: [],
-                        joins: [],
-                    },
-                ],
-                loadErrors: [],
-            }),
-        };
-        const result = await tool.call({}, makeContext({ session: makeSession(sessionSemanticLayerService) }));
-        expect(result.structured.totalSources).toBe(1);
-        expect(result.structured.sources[0]).toMatchObject({
-            connectionId: 'warehouse',
-            name: 'orders',
-            columnCount: 1,
-        });
-        expect(sessionSemanticLayerService.listConnectionIdsWithNames).toHaveBeenCalled();
-        expect(sessionSemanticLayerService.loadAllSources).toHaveBeenCalledWith('warehouse');
-        expect(semanticLayerService.listConnectionIdsWithNames).not.toHaveBeenCalled();
-    });
-});

package/dist/context/sl/tools/sl-edit-source.tool.test.d.ts

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