@kaelio/ktx 0.5.0 → 0.7.0

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

@@ -1,184 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTouchedSlSources, hasTouchedSlSource } from '../../../context/tools/touched-sl-sources.js';
-import { SlEditSourceTool } from './sl-edit-source.tool.js';
-function makeTool(overrides = {}) {
-    const semanticLayerService = {
-        readSourceFile: vi.fn().mockResolvedValue({
-            content: 'name: orders\ntable: public.orders\ngrain: [id]\ncolumns:\n  - name: id\n    type: string\nmeasures: []\njoins: []\n',
-        }),
-        validateWithProposedSource: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
-        writeSource: vi.fn().mockResolvedValue({ commitHash: 'c1' }),
-        loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
-        deleteSource: vi.fn().mockResolvedValue(undefined),
-        isManifestBacked: vi.fn().mockResolvedValue(false),
-        ...overrides.semanticLayerService,
-    };
-    const slSearchService = {
-        indexSources: vi.fn().mockResolvedValue(undefined),
-        ...overrides.slSearchService,
-    };
-    const tool = new SlEditSourceTool({
-        semanticLayerService: semanticLayerService,
-        slSearchService: slSearchService,
-        authorResolver: { resolve: vi.fn().mockResolvedValue({ name: 'T U', email: 't@u.com' }) },
-    });
-    return { tool, semanticLayerService, slSearchService };
-}
-const baseContext = { sourceId: 's', messageId: 'm', userId: 'u' };
-function makeSession(overrides = {}) {
-    return {
-        connectionId: '11111111-1111-1111-1111-111111111111',
-        isWorktreeScoped: true,
-        preHead: 'base',
-        touchedSlSources: createTouchedSlSources(),
-        actions: [],
-        semanticLayerService: {
-            readSourceFile: vi.fn().mockResolvedValue({
-                content: 'name: orders\ntable: public.orders\ngrain: [id]\ncolumns:\n  - name: id\n    type: string\nmeasures: []\njoins: []\n',
-            }),
-            validateWithProposedSource: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
-            writeSource: vi.fn().mockResolvedValue({ commitHash: 'c1' }),
-            loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
-        },
-        wikiService: {},
-        configService: {},
-        gitService: {},
-        ...overrides,
-    };
-}
-describe('SlEditSourceTool — session gating', () => {
-    it('skips slSearchService.indexSources when session is worktree-scoped', async () => {
-        const { tool, slSearchService } = makeTool();
-        const session = makeSession();
-        const context = { ...baseContext, session };
-        const result = await tool.call({
-            connectionId: session.connectionId,
-            sourceName: 'orders',
-            yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
-        }, context);
-        expect(result.structured.success).toBe(true);
-        expect(slSearchService.indexSources).not.toHaveBeenCalled();
-        expect(hasTouchedSlSource(session.touchedSlSources, session.connectionId, 'orders')).toBe(true);
-        expect(session.actions).toContainEqual(expect.objectContaining({ target: 'sl', key: 'orders' }));
-    });
-    it('records cross-connection SL edits with targetConnectionId', async () => {
-        const { tool } = makeTool();
-        const session = makeSession({ connectionId: '11111111-1111-4111-8111-111111111111' });
-        const warehouseConnectionId = '22222222-2222-4222-8222-222222222222';
-        const context = { ...baseContext, session };
-        const result = await tool.call({
-            connectionId: warehouseConnectionId,
-            sourceName: 'orders',
-            yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
-        }, context);
-        expect(result.structured.success).toBe(true);
-        expect(hasTouchedSlSource(session.touchedSlSources, warehouseConnectionId, 'orders')).toBe(true);
-        expect(session.actions).toContainEqual(expect.objectContaining({
-            target: 'sl',
-            type: 'updated',
-            key: 'orders',
-            targetConnectionId: warehouseConnectionId,
-        }));
-    });
-    it('rejects session-scoped edits outside allowed target connections', async () => {
-        const { tool } = makeTool();
-        const session = makeSession({
-            allowedConnectionNames: new Set(['warehouse']),
-        });
-        const context = { ...baseContext, session };
-        const result = await tool.call({
-            connectionId: 'finance',
-            sourceName: 'orders',
-            yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
-        }, context);
-        expect(result.structured.success).toBe(false);
-        expect(result.markdown).toContain('connectionId "finance" is outside this ingest session');
-        expect(session.actions).toEqual([]);
-    });
-    it('indexes normally when no session is present', async () => {
-        const { tool, slSearchService } = makeTool();
-        const result = await tool.call({
-            connectionId: '11111111-1111-1111-1111-111111111111',
-            sourceName: 'orders',
-            yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
-        }, baseContext);
-        expect(result.structured.success).toBe(true);
-        expect(slSearchService.indexSources).toHaveBeenCalledTimes(1);
-    });
-    it('uses session.semanticLayerService when session is present', async () => {
-        const { tool } = makeTool();
-        const session = makeSession();
-        const context = { ...baseContext, session };
-        await tool.call({
-            connectionId: session.connectionId,
-            sourceName: 'orders',
-            yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
-        }, context);
-        expect(session.semanticLayerService.writeSource).toHaveBeenCalled();
-    });
-    it('fills missing descriptions when an ingest session edits a source', async () => {
-        const { tool } = makeTool();
-        const session = makeSession({
-            ingest: { runId: 'run-1', jobId: 'job-1', syncId: 'sync-1', sourceKey: 'dbt' },
-        });
-        const context = { ...baseContext, session };
-        const result = await tool.call({
-            connectionId: session.connectionId,
-            sourceName: 'orders',
-            yaml_edits: [{ oldText: 'measures: []', newText: 'measures: []' }],
-        }, context);
-        expect(result.structured.success).toBe(true);
-        expect(session.semanticLayerService.writeSource).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-            descriptions: { ktx: expect.stringContaining('orders') },
-            columns: [
-                expect.objectContaining({
-                    descriptions: { ktx: expect.stringContaining('Identifier') },
-                }),
-            ],
-        }), expect.any(String), expect.any(String), expect.any(String));
-    });
-});
-describe('SlEditSourceTool — manifest-backed source without overlay', () => {
-    it('returns a directed hint pointing at sl_write_source + overlay shape', async () => {
-        const { tool, semanticLayerService } = makeTool({
-            semanticLayerService: {
-                readSourceFile: vi.fn().mockRejectedValue(new Error('ENOENT')),
-                isManifestBacked: vi.fn().mockResolvedValue(true),
-            },
-        });
-        const result = await tool.call({
-            connectionId: '11111111-1111-1111-1111-111111111111',
-            sourceName: 'CONSIGNMENTS',
-            yaml_edits: [{ oldText: 'measures: []', newText: 'measures:\n  - name: aav_count\n    expr: count(*)' }],
-        }, baseContext);
-        expect(result.structured.success).toBe(false);
-        expect(semanticLayerService.isManifestBacked).toHaveBeenCalledWith('11111111-1111-1111-1111-111111111111', 'CONSIGNMENTS');
-        expect(semanticLayerService.writeSource).not.toHaveBeenCalled();
-        const joinedErrors = (result.structured.errors ?? []).join('\n');
-        expect(joinedErrors).toContain('CONSIGNMENTS');
-        expect(joinedErrors).toContain('manifest');
-        expect(joinedErrors).toContain('sl_write_source');
-        expect(joinedErrors).toContain('overlay');
-        // Overlay shape: name plus overlay-only fields.
-        expect(joinedErrors).toContain('measures');
-        expect(joinedErrors).toContain('segments');
-        expect(joinedErrors).toContain('column_overrides');
-    });
-    it('still returns the plain "Source not found" error for truly-missing names', async () => {
-        const { tool, semanticLayerService } = makeTool({
-            semanticLayerService: {
-                readSourceFile: vi.fn().mockRejectedValue(new Error('ENOENT')),
-                isManifestBacked: vi.fn().mockResolvedValue(false),
-            },
-        });
-        const result = await tool.call({
-            connectionId: '11111111-1111-1111-1111-111111111111',
-            sourceName: 'does_not_exist',
-            yaml_edits: [{ oldText: 'x', newText: 'y' }],
-        }, baseContext);
-        expect(result.structured.success).toBe(false);
-        expect(result.structured.errors).toEqual(['Source not found. Use sl_write_source to create it.']);
-        expect(semanticLayerService.isManifestBacked).toHaveBeenCalledTimes(1);
-        expect(semanticLayerService.writeSource).not.toHaveBeenCalled();
-    });
-});

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

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

package/dist/context/sl/tools/sl-read-source.tool.session.test.js

@@ -1,55 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
-import { SlReadSourceTool } from './sl-read-source.tool.js';
-function makeTool(overrides = {}) {
-    const semanticLayerService = {
-        readSourceFile: vi.fn().mockResolvedValue({ content: 'name: foo_default\n', path: 'default' }),
-        ...overrides.semanticLayerService,
-    };
-    const tool = new SlReadSourceTool({
-        semanticLayerService: semanticLayerService,
-        slSearchService: {},
-        authorResolver: { resolve: vi.fn() },
-    });
-    return { tool, semanticLayerService };
-}
-function makeContext(overrides = {}) {
-    return {
-        sourceId: 'src',
-        messageId: 'msg',
-        userId: 'user',
-        ...overrides,
-    };
-}
-function makeSession(overrides = {}) {
-    return {
-        connectionId: '11111111-1111-1111-1111-111111111111',
-        isWorktreeScoped: true,
-        preHead: 'base',
-        touchedSlSources: createTouchedSlSources(),
-        actions: [],
-        semanticLayerService: {
-            readSourceFile: vi.fn().mockResolvedValue({ content: 'name: foo_session\n', path: 'session' }),
-        },
-        wikiService: {},
-        configService: {},
-        gitService: {},
-        ...overrides,
-    };
-}
-describe('SlReadSourceTool - session-scoped reads', () => {
-    it('reads through context.session.semanticLayerService when a session is present', async () => {
-        const { tool, semanticLayerService } = makeTool();
-        const session = makeSession();
-        const result = await tool.call({ connectionId: '11111111-1111-1111-1111-111111111111', sourceName: 'foo' }, makeContext({ session }));
-        expect(session.semanticLayerService.readSourceFile).toHaveBeenCalledWith('11111111-1111-1111-1111-111111111111', 'foo');
-        expect(semanticLayerService.readSourceFile).not.toHaveBeenCalled();
-        expect(result.structured.yaml).toContain('foo_session');
-    });
-    it('reads through the default service when no session is present', async () => {
-        const { tool, semanticLayerService } = makeTool();
-        const result = await tool.call({ connectionId: '11111111-1111-1111-1111-111111111111', sourceName: 'foo' }, makeContext());
-        expect(semanticLayerService.readSourceFile).toHaveBeenCalledWith('11111111-1111-1111-1111-111111111111', 'foo');
-        expect(result.structured.yaml).toContain('foo_default');
-    });
-});

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

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

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

@@ -1,57 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTouchedSlSources, hasTouchedSlSource } from '../../../context/tools/touched-sl-sources.js';
-import { SlRollbackTool } from './sl-rollback.tool.js';
-function makeSession(overrides = {}) {
-    return {
-        connectionId: 'conn-1',
-        isWorktreeScoped: true,
-        preHead: 'base',
-        touchedSlSources: createTouchedSlSources([{ connectionId: 'conn-1', sourceName: 'orders' }]),
-        actions: [{ target: 'sl', type: 'updated', key: 'orders', detail: 'x' }],
-        semanticLayerService: {},
-        wikiService: {},
-        configService: {
-            writeFile: vi.fn().mockResolvedValue(undefined),
-            deleteFile: vi.fn().mockResolvedValue(undefined),
-        },
-        gitService: { getFileAtCommit: vi.fn().mockResolvedValue('pre: content') },
-        ...overrides,
-    };
-}
-describe('SlRollbackTool', () => {
-    const connections = {
-        getConnectionById: vi.fn(),
-        listEnabledConnections: vi.fn(),
-        executeQuery: vi.fn(),
-    };
-    it('errors when context.session is absent', async () => {
-        const tool = new SlRollbackTool({}, connections, 1);
-        const context = { sourceId: 's', messageId: 'm', userId: 'u' };
-        const result = await tool.call({ sourceName: 'orders' }, context);
-        expect(result.structured.success).toBe(false);
-        expect(result.markdown).toMatch(/session/i);
-    });
-    it('errors when session has no connectionId (wiki-only turn)', async () => {
-        const tool = new SlRollbackTool({}, connections, 1);
-        const session = makeSession({ connectionId: null });
-        const context = { sourceId: 's', messageId: 'm', userId: 'u', session };
-        const result = await tool.call({ sourceName: 'orders' }, context);
-        expect(result.structured.success).toBe(false);
-        expect(result.markdown).toMatch(/connection-scoped session/i);
-        // Session state untouched
-        expect(hasTouchedSlSource(session.touchedSlSources, 'conn-1', 'orders')).toBe(true);
-        expect(session.gitService.getFileAtCommit).not.toHaveBeenCalled();
-    });
-    it('restores the source content from preHead, clears touched set, prunes actions', async () => {
-        const slSourcesRepository = { deleteByConnectionAndName: vi.fn().mockResolvedValue(undefined) };
-        const tool = new SlRollbackTool(slSourcesRepository, connections, 1);
-        const session = makeSession();
-        const context = { sourceId: 's', messageId: 'm', userId: 'u', session };
-        const result = await tool.call({ sourceName: 'orders' }, context);
-        expect(result.structured.success).toBe(true);
-        expect(session.gitService.getFileAtCommit).toHaveBeenCalledWith(expect.stringContaining('orders.yaml'), 'base');
-        expect(session.configService.writeFile).toHaveBeenCalled();
-        expect(hasTouchedSlSource(session.touchedSlSources, 'conn-1', 'orders')).toBe(false);
-        expect(session.actions).toEqual([]);
-    });
-});

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

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

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

@@ -1,54 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
-import { SlValidateTool, validateSemanticLayerEndpoint } from './sl-validate.tool.js';
-describe('validateSemanticLayerEndpoint', () => {
-    it('uses the connection warehouse dialect, not hardcoded postgres', async () => {
-        const serviceMock = {
-            validateSourcesForConnection: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
-        };
-        await validateSemanticLayerEndpoint('conn-1', serviceMock);
-        expect(serviceMock.validateSourcesForConnection).toHaveBeenCalledWith('conn-1');
-    });
-    it('short-circuits when there are no validatable sources', async () => {
-        const serviceMock = {
-            validateSourcesForConnection: vi.fn().mockResolvedValue({ errors: [], warnings: [] }),
-        };
-        const result = await validateSemanticLayerEndpoint('conn-1', serviceMock);
-        expect(result).toEqual({ errors: [], warnings: [] });
-    });
-});
-describe('SlValidateTool — session-aware touched-set filtering', () => {
-    it('when session present, only returns errors/warnings that mention touched sources', async () => {
-        const sources = [
-            { name: 'orders', table: 'x.orders', grain: ['id'], columns: [], joins: [], measures: [] },
-            { name: 'customers', table: 'x.customers', grain: ['id'], columns: [], joins: [], measures: [] },
-        ];
-        const serviceMock = {
-            loadAllSources: vi.fn().mockResolvedValue({ sources, loadErrors: [] }),
-            validateSourcesForConnection: vi.fn().mockResolvedValue({
-                errors: ['orders: missing join target', 'customers: invalid grain'],
-                warnings: ['orders: disconnected-components warning'],
-            }),
-        };
-        const tool = new SlValidateTool({
-            semanticLayerService: serviceMock,
-            slSearchService: {},
-            authorResolver: { resolve: vi.fn() },
-        });
-        const session = {
-            connectionId: 'conn-1',
-            isWorktreeScoped: true,
-            preHead: null,
-            touchedSlSources: createTouchedSlSources([{ connectionId: 'conn-1', sourceName: 'orders' }]),
-            actions: [],
-            semanticLayerService: serviceMock,
-            wikiService: {},
-            configService: {},
-            gitService: {},
-        };
-        const context = { sourceId: 's', messageId: 'm', userId: 'u', session };
-        const result = await tool.call({ connectionId: 'conn-1' }, context);
-        expect(result.structured.validationErrors).toEqual(['orders: missing join target']);
-        expect(result.structured.validationWarnings).toEqual(['orders: disconnected-components warning']);
-    });
-});

package/dist/context/sl/tools/sl-warehouse-validation.test.d.ts

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

package/dist/context/sl/tools/sl-warehouse-validation.test.js

@@ -1,136 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { validateSingleSource } from './sl-warehouse-validation.js';
-function makeDeps(opts) {
-    return {
-        semanticLayerService: {
-            readSourceFile: vi.fn().mockResolvedValue({ content: opts.sourceYaml, path: 'x' }),
-            isManifestBacked: vi.fn().mockResolvedValue(false),
-            listManifestSourceNames: vi.fn().mockResolvedValue([]),
-            loadSource: vi.fn().mockResolvedValue(null),
-            loadAllSources: vi.fn().mockResolvedValue({ sources: [], loadErrors: [] }),
-            validatePhysicalTableReferences: vi.fn().mockResolvedValue([]),
-        },
-        connections: {
-            executeQuery: opts.executeQuery,
-            getConnectionById: vi.fn().mockResolvedValue({ id: 'conn-1', name: 'conn-1', connectionType: 'bigquery' }),
-            listEnabledConnections: vi.fn().mockResolvedValue([]),
-        },
-        configService: {},
-        gitService: {},
-        slSourcesRepository: { deleteByConnectionAndName: vi.fn().mockResolvedValue(undefined) },
-        probeRowCount: 1,
-    };
-}
-describe('validateSingleSource warehouse dry-run', () => {
-    it('surfaces warehouse error when dry-run fails on unknown column', async () => {
-        const yaml = `name: fct_arr_delta
-source_type: sql
-sql: |
-  SELECT * FROM analytics.fct_arr_delta WHERE date_date < CURRENT_DATE()
-grain: [date_date]
-columns:
-  - name: date_date
-    type: time
-measures:
-  - name: count_delta_events
-    expr: count(*)
-joins: []
-`;
-        const executeQuery = vi.fn().mockRejectedValue(new Error('Unrecognized name: date_date at [1:42]'));
-        const deps = makeDeps({ sourceYaml: yaml, executeQuery });
-        const result = await validateSingleSource(deps, 'conn-1', 'fct_arr_delta');
-        expect(result.errors.join('\n')).toMatch(/Unrecognized name: date_date/);
-        expect(result.errors.join('\n')).toMatch(/embedded sql dry-run failed/);
-    });
-    it('flags declared columns missing from the dry-run result', async () => {
-        const yaml = `name: fct_arr_delta
-source_type: sql
-sql: |
-  SELECT date, customer_id FROM analytics.fct_arr_delta
-columns:
-  - name: date_date
-    type: time
-  - name: customer_id
-    type: string
-measures:
-  - name: count_delta
-    expr: count(*)
-joins: []
-grain: [customer_id]
-`;
-        const executeQuery = vi.fn().mockResolvedValue({
-            headers: ['date', 'customer_id'],
-            rows: [],
-            totalRows: 0,
-            error: null,
-        });
-        const deps = makeDeps({ sourceYaml: yaml, executeQuery });
-        const result = await validateSingleSource(deps, 'conn-1', 'fct_arr_delta');
-        expect(result.errors.join('\n')).toMatch(/declared columns absent from sql result — date_date/);
-        expect(result.errors.join('\n')).toMatch(/warehouse returned:/);
-    });
-    it('passes cleanly when dry-run succeeds and declared columns match', async () => {
-        const yaml = `name: lab_results
-source_type: sql
-sql: |
-  SELECT lab_order_id, admin_user_id FROM analytics.raw_lab_results
-grain: [lab_order_id]
-columns:
-  - name: lab_order_id
-    type: string
-  - name: admin_user_id
-    type: string
-measures:
-  - name: count_lab_results
-    expr: count(lab_order_id)
-joins: []
-`;
-        const executeQuery = vi.fn().mockResolvedValue({
-            headers: ['lab_order_id', 'admin_user_id'],
-            rows: [],
-            totalRows: 0,
-            error: null,
-        });
-        const deps = makeDeps({ sourceYaml: yaml, executeQuery });
-        const result = await validateSingleSource(deps, 'conn-1', 'lab_results');
-        expect(result.errors).toEqual([]);
-    });
-    it('uses LIMIT 1 (not LIMIT 0) so runtime policies fire', async () => {
-        const yaml = `name: foo
-source_type: sql
-sql: |
-  SELECT a FROM analytics.bar
-grain: [a]
-columns:
-  - {name: a, type: string}
-measures: []
-joins: []
-`;
-        const executeQuery = vi.fn().mockResolvedValue({ headers: ['a'], rows: [], totalRows: 0, error: null });
-        const deps = makeDeps({ sourceYaml: yaml, executeQuery });
-        await validateSingleSource(deps, 'conn-1', 'foo');
-        const probeSql = executeQuery.mock.calls[0][1];
-        expect(probeSql).toMatch(/LIMIT 1\b/);
-        expect(probeSql).not.toMatch(/LIMIT 0\b/);
-    });
-    it('adds physical manifest errors for table-backed sources', async () => {
-        const yaml = `name: int_active_contract_arr
-table: orbit_analytics.int_active_contract_arr
-grain: [contract_id]
-columns:
-  - {name: contract_id, type: string}
-  - {name: arr_cents, type: number}
-measures:
-  - {name: arr, expr: sum(arr_cents)}
-joins: []
-`;
-        const executeQuery = vi.fn();
-        const deps = makeDeps({ sourceYaml: yaml, executeQuery });
-        deps.semanticLayerService.validatePhysicalTableReferences.mockResolvedValue([
-            'int_active_contract_arr.yaml: declared column(s) absent from physical table: arr_cents',
-        ]);
-        const result = await validateSingleSource(deps, 'conn-1', 'int_active_contract_arr');
-        expect(result.errors).toContain('int_active_contract_arr.yaml: declared column(s) absent from physical table: arr_cents');
-        expect(executeQuery).not.toHaveBeenCalled();
-    });
-});

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

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