@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/ingest/tools/warehouse-verification/entity-details.tool.test.js

@@ -1,146 +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 { WarehouseCatalogService } from '../../../scan/warehouse-catalog.js';
-import { EntityDetailsTool } from './entity-details.tool.js';
-describe('EntityDetailsTool', () => {
-    let tempDir;
-    let project;
-    let tool;
-    let context;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-entity-details-'));
-        project = await initKtxProject({ projectDir: join(tempDir, 'project') });
-        await seedLiveDatabaseScan();
-        tool = new EntityDetailsTool(() => new WarehouseCatalogService({ fileStore: project.fileStore }));
-        context = {
-            sourceId: 'ingest',
-            messageId: 'm1',
-            userId: 'system',
-            session: {
-                allowedConnectionNames: new Set(['warehouse']),
-            },
-        };
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    async function seedLiveDatabaseScan(connectionId = 'warehouse', syncId = 'sync-1') {
-        const root = `raw-sources/${connectionId}/live-database/${syncId}`;
-        await project.fileStore.writeFile(`${root}/connection.json`, JSON.stringify({ connectionId, driver: 'postgres', 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: null,
-            db: 'public',
-            name: 'orders',
-            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: 'postgres',
-            tables: [{ table: { catalog: null, db: 'public', name: 'orders' }, rowCount: 12 }],
-            columns: {
-                'orders.status': {
-                    table: { catalog: null, db: 'public', name: 'orders' },
-                    column: 'status',
-                    rowCount: 12,
-                    nullCount: 0,
-                    distinctCount: 2,
-                    nullRate: 0,
-                    sampleValues: ['paid', 'refunded'],
-                },
-            },
-        }, null, 2), 'ktx', 'ktx@example.com', 'seed profile');
-    }
-    it('returns scoped table detail for a display target', async () => {
-        const result = await tool.call({ connectionId: 'warehouse', targets: [{ display: 'public.orders' }] }, context);
-        expect(result.markdown).toContain('### public.orders');
-        expect(result.markdown).toContain('- status (text, nullable=false)');
-        expect(result.markdown).toContain('sample: ["paid","refunded"]');
-        expect(result.structured.scanAvailable).toBe(true);
-        expect(result.structured.resolved).toHaveLength(1);
-    });
-    it('resolves display targets that include a column name', async () => {
-        const result = await tool.call({ connectionId: 'warehouse', targets: [{ display: 'public.orders.status' }] }, context);
-        expect(result.markdown).toContain('### public.orders');
-        expect(result.markdown).toContain('- status (text, nullable=false)');
-        expect(result.markdown).not.toContain('- id (integer');
-        expect(result.structured.resolved).toHaveLength(1);
-        expect(result.structured.resolved[0]?.columns.map((column) => column.name)).toEqual(['status']);
-    });
-    it('reports missing explicit columns instead of returning an empty column list', async () => {
-        const result = await tool.call({ connectionId: 'warehouse', targets: [{ display: 'public.orders.plan_tier' }] }, context);
-        expect(result.markdown).toContain('Column not found in scan: public.orders.plan_tier');
-        expect(result.markdown).toContain('Available columns: id, status');
-        expect(result.structured.resolved).toHaveLength(0);
-        expect(result.structured.missing).toHaveLength(1);
-    });
-    it('reports missing structured table targets in model-visible markdown', async () => {
-        const result = await tool.call({
-            connectionId: 'warehouse',
-            targets: [{ catalog: null, db: 'public', name: 'orderz' }],
-        }, context);
-        expect(result.markdown).toContain('Not found in scan: public.orderz');
-        expect(result.markdown).toContain('Closest matches: orders');
-        expect(result.structured.resolved).toHaveLength(0);
-        expect(result.structured.missing).toHaveLength(1);
-    });
-    it('reports missing structured column targets in model-visible markdown', async () => {
-        const result = await tool.call({
-            connectionId: 'warehouse',
-            targets: [{ catalog: null, db: 'public', name: 'orders', column: 'plan_tier' }],
-        }, context);
-        expect(result.markdown).toContain('Column not found in scan: public.orders.plan_tier');
-        expect(result.markdown).toContain('Available columns: id, status');
-        expect(result.structured.resolved).toHaveLength(0);
-        expect(result.structured.missing).toHaveLength(1);
-    });
-    it('returns a no-scan state distinct from not found', async () => {
-        const result = await tool.call({ connectionId: 'empty', targets: [{ display: 'public.orders' }] }, { ...context, session: { ...context.session, allowedConnectionNames: new Set(['empty']) } });
-        expect(result.markdown).toContain('No live-database scan available for connection "empty"; run `ktx scan` first.');
-        expect(result.structured.scanAvailable).toBe(false);
-    });
-    it('refuses out-of-scope connections', async () => {
-        const result = await tool.call({ connectionId: 'billing', targets: [{ display: 'public.orders' }] }, context);
-        expect(result.markdown).toContain('Connection "billing" is not available to this ingest stage.');
-        expect(result.structured.scanAvailable).toBe(false);
-    });
-    it('uses connectionId as the public input field', async () => {
-        const legacyConnectionField = ['connection', 'Name'].join('');
-        expect(tool.parseInput({
-            connectionId: 'warehouse',
-            targets: [{ display: 'public.orders' }],
-        })).toEqual({
-            connectionId: 'warehouse',
-            targets: [{ display: 'public.orders' }],
-        });
-        expect(() => tool.parseInput({
-            [legacyConnectionField]: 'warehouse',
-            targets: [{ display: 'public.orders' }],
-        })).toThrow();
-    });
-});

package/dist/context/ingest/tools/warehouse-verification/sql-execution.tool.test.d.ts

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

package/dist/context/ingest/tools/warehouse-verification/sql-execution.tool.test.js

@@ -1,50 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { SqlExecutionTool } from './sql-execution.tool.js';
-describe('SqlExecutionTool', () => {
-    const connections = {
-        executeQuery: vi.fn(),
-    };
-    const tool = new SqlExecutionTool(connections);
-    const context = {
-        sourceId: 'ingest',
-        messageId: 'm1',
-        userId: 'system',
-        session: { allowedConnectionNames: new Set(['warehouse']) },
-    };
-    it('wraps read-only SQL with a capped row limit', async () => {
-        connections.executeQuery.mockResolvedValue({ headers: ['status'], rows: [['paid']], totalRows: 1 });
-        const result = await tool.call({ connectionId: 'warehouse', sql: 'select status from public.orders', rowLimit: 5 }, context);
-        expect(connections.executeQuery).toHaveBeenCalledWith('warehouse', 'select * from (select status from public.orders) as ktx_query_result limit 5');
-        expect(result.markdown).toContain('| status |');
-        expect(result.structured.wrappedSql).toContain('limit 5');
-    });
-    it.each(['insert into x values (1)', 'drop table x', 'vacuum'])('rejects mutating SQL: %s', async (sql) => {
-        connections.executeQuery.mockClear();
-        const result = await tool.call({ connectionId: 'warehouse', sql }, context);
-        expect(result.markdown).toContain('Only read-only SELECT/WITH queries can be executed locally.');
-        expect(connections.executeQuery).not.toHaveBeenCalled();
-    });
-    it('surfaces connector errors verbatim', async () => {
-        connections.executeQuery.mockRejectedValue(new Error('relation "orbit_analytics.customer" does not exist'));
-        const result = await tool.call({ connectionId: 'warehouse', sql: 'select 1 from orbit_analytics.customer', rowLimit: 1 }, context);
-        expect(result.markdown).toContain('relation "orbit_analytics.customer" does not exist');
-        expect(result.structured.error).toContain('relation "orbit_analytics.customer" does not exist');
-    });
-    it('uses connectionId as the public input field', () => {
-        const legacyConnectionField = ['connection', 'Name'].join('');
-        expect(tool.parseInput({
-            connectionId: 'warehouse',
-            sql: 'select 1',
-            rowLimit: 5,
-        })).toEqual({
-            connectionId: 'warehouse',
-            sql: 'select 1',
-            rowLimit: 5,
-        });
-        expect(() => tool.parseInput({
-            [legacyConnectionField]: 'warehouse',
-            sql: 'select 1',
-            rowLimit: 5,
-        })).toThrow();
-    });
-});

package/dist/context/ingest/wiki-body-refs.test.d.ts

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

package/dist/context/ingest/wiki-body-refs.test.js

@@ -1,138 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { findInvalidWikiBodyRefs, parseWikiBodyRefs } from './wiki-body-refs.js';
-const sources = [
-    {
-        name: 'mart_account_segments',
-        grain: ['account_id'],
-        columns: [
-            { name: 'account_id', type: 'string' },
-            { name: 'segment', type: 'string' },
-        ],
-        joins: [],
-        measures: [{ name: 'total_contract_arr', expr: 'sum(contract_arr)' }],
-        segments: [{ name: 'enterprise', expr: "segment = 'enterprise'" }],
-        table: 'analytics.mart_account_segments',
-    },
-];
-describe('wiki body refs', () => {
-    it('parses only explicit inline-code body references outside fenced blocks', () => {
-        const body = [
-            'Valid `mart_account_segments.total_contract_arr` and `source:mart_account_segments`.',
-            'Also `warehouse/mart_account_segments.segment` and `table:analytics.mart_account_segments`.',
-            'Ignore prose mart_account_segments.total_contract_arr_cents.',
-            'Ignore `single_token`.',
-            'Ignore wildcard pattern `mart_nrr_quarterly.*_arr_cents`.',
-            'Ignore condition `users.is_internal = false`.',
-            '```sql',
-            'select `mart_account_segments.total_contract_arr_cents`',
-            '```',
-        ].join('\n');
-        expect(parseWikiBodyRefs(body)).toEqual([
-            { kind: 'sl_entity', connectionId: null, sourceName: 'mart_account_segments', entityName: 'total_contract_arr' },
-            { kind: 'sl_source', connectionId: null, sourceName: 'mart_account_segments' },
-            { kind: 'sl_entity', connectionId: 'warehouse', sourceName: 'mart_account_segments', entityName: 'segment' },
-            { kind: 'table', connectionId: null, tableRef: 'analytics.mart_account_segments' },
-        ]);
-    });
-    it('rejects stale inline-code semantic-layer references', async () => {
-        const invalid = await findInvalidWikiBodyRefs({
-            pageKey: 'account-segments',
-            body: 'ARR is documented as `mart_account_segments.total_contract_arr_cents`.',
-            visibleConnectionIds: ['warehouse'],
-            loadSources: async () => sources,
-            tableExists: async () => true,
-        });
-        expect(invalid).toEqual([
-            'account-segments: unknown semantic-layer entity mart_account_segments.total_contract_arr_cents',
-        ]);
-    });
-    it('does not treat wildcard inline-code patterns as exact semantic-layer entity references', async () => {
-        const invalid = await findInvalidWikiBodyRefs({
-            pageKey: 'revenue-metrics-encoding',
-            body: 'Cents columns include `mart_nrr_quarterly.*_arr_cents` and `mart_retention_movement_breakout.*_arr_cents`.',
-            visibleConnectionIds: ['warehouse'],
-            loadSources: async () => [
-                { name: 'mart_nrr_quarterly', grain: [], columns: [], joins: [], measures: [], table: 'analytics.mart_nrr_quarterly' },
-                {
-                    name: 'mart_retention_movement_breakout',
-                    grain: [],
-                    columns: [],
-                    joins: [],
-                    measures: [],
-                    table: 'analytics.mart_retention_movement_breakout',
-                },
-            ],
-            tableExists: async () => true,
-        });
-        expect(invalid).toEqual([]);
-    });
-    it('does not treat inline-code SQL predicates as exact semantic-layer entity references', async () => {
-        const invalid = await findInvalidWikiBodyRefs({
-            pageKey: 'account-reporting-exclusions',
-            body: 'Exclude internal users with `users.is_internal = false` and test users with `users.is_test = false`.',
-            visibleConnectionIds: ['warehouse'],
-            loadSources: async () => [
-                {
-                    name: 'users',
-                    grain: [],
-                    columns: [
-                        { name: 'is_internal', type: 'boolean' },
-                        { name: 'is_test', type: 'boolean' },
-                    ],
-                    joins: [],
-                    measures: [],
-                    table: 'analytics.users',
-                },
-            ],
-            tableExists: async () => true,
-        });
-        expect(invalid).toEqual([]);
-    });
-    it('validates source, dimension, segment, measure, and table references', async () => {
-        const invalid = await findInvalidWikiBodyRefs({
-            pageKey: 'account-segments',
-            body: [
-                '`mart_account_segments.total_contract_arr`',
-                '`mart_account_segments.segment`',
-                '`mart_account_segments.enterprise`',
-                '`source:mart_account_segments`',
-                '`table:analytics.mart_account_segments`',
-            ].join('\n'),
-            visibleConnectionIds: ['warehouse'],
-            loadSources: async () => sources,
-            tableExists: async (_connectionId, tableRef) => tableRef === 'analytics.mart_account_segments',
-        });
-        expect(invalid).toEqual([]);
-    });
-    it('ignores two-part inline code when the source is not visible', async () => {
-        const invalid = await findInvalidWikiBodyRefs({
-            pageKey: 'engineering-notes',
-            body: [
-                'A version token like `node.v22` is not a semantic-layer reference.',
-                'A raw table must use `table:analytics.mart_account_segments`.',
-            ].join('\n'),
-            visibleConnectionIds: ['warehouse'],
-            loadSources: async () => sources,
-            tableExists: async (_connectionId, tableRef) => tableRef === 'analytics.mart_account_segments',
-        });
-        expect(invalid).toEqual([]);
-    });
-    it('still rejects explicit missing source and table references', async () => {
-        const invalid = await findInvalidWikiBodyRefs({
-            pageKey: 'account-segments',
-            body: [
-                '`source:missing_source`',
-                '`warehouse/source:missing_source`',
-                '`table:analytics.missing_table`',
-            ].join('\n'),
-            visibleConnectionIds: ['warehouse'],
-            loadSources: async () => sources,
-            tableExists: async () => false,
-        });
-        expect(invalid).toEqual([
-            'account-segments: unknown semantic-layer source missing_source',
-            'account-segments: unknown semantic-layer source warehouse/missing_source',
-            'account-segments: unknown raw table analytics.missing_table',
-        ]);
-    });
-});

package/dist/context/ingest/wiki-sl-ref-repair.test.d.ts

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

package/dist/context/ingest/wiki-sl-ref-repair.test.js

@@ -1,81 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { repairWikiSlRefs } from './wiki-sl-ref-repair.js';
-describe('repairWikiSlRefs', () => {
-    it('removes missing measure refs while keeping source, measure, segment, and manifest-backed refs', async () => {
-        const pages = new Map([
-            [
-                'GLOBAL:accounts-at-risk',
-                {
-                    pageKey: 'accounts-at-risk',
-                    frontmatter: {
-                        summary: 'Accounts at risk',
-                        usage_mode: 'auto',
-                        sl_refs: [
-                            'mart_customer_health',
-                            'mart_customer_health.high_risk_account_count',
-                            'mart_customer_health.medium_risk_account_count',
-                            'mart_customer_health.high_risk',
-                            'int_procurement_qualifying_actions',
-                        ],
-                    },
-                    content: 'Risk context.',
-                },
-            ],
-        ]);
-        const wikiService = {
-            readPage: vi.fn(async (scope, _scopeId, key) => pages.get(`${scope}:${key}`)),
-            writePage: vi.fn(async (scope, _scopeId, key, frontmatter, content) => {
-                pages.set(`${scope}:${key}`, { pageKey: key, frontmatter, content });
-            }),
-        };
-        const configService = {
-            listFiles: vi.fn(async () => ({
-                files: ['global/accounts-at-risk.md', 'global/historic-sql/nested-old.md'],
-            })),
-        };
-        const semanticLayerService = {
-            loadAllSources: vi.fn(async () => ({
-                sources: [
-                    {
-                        name: 'mart_customer_health',
-                        grain: [],
-                        columns: [],
-                        joins: [],
-                        measures: [{ name: 'high_risk_account_count', expr: 'count(*)' }],
-                        segments: [{ name: 'high_risk', expr: "risk_level = 'high'" }],
-                    },
-                    {
-                        name: 'int_procurement_qualifying_actions',
-                        grain: [],
-                        columns: [],
-                        joins: [],
-                        measures: [],
-                    },
-                ],
-                loadErrors: [],
-            })),
-        };
-        const result = await repairWikiSlRefs({
-            wikiService: wikiService,
-            semanticLayerService: semanticLayerService,
-            configService: configService,
-            connectionIds: ['warehouse'],
-        });
-        expect(result.repairs).toEqual([
-            {
-                pageKey: 'accounts-at-risk',
-                scope: 'GLOBAL',
-                scopeId: null,
-                removedRefs: ['mart_customer_health.medium_risk_account_count'],
-            },
-        ]);
-        expect(wikiService.writePage).toHaveBeenCalledWith('GLOBAL', null, 'accounts-at-risk', expect.objectContaining({
-            sl_refs: [
-                'mart_customer_health',
-                'mart_customer_health.high_risk_account_count',
-                'mart_customer_health.high_risk',
-                'int_procurement_qualifying_actions',
-            ],
-        }), 'Risk context.', 'System User', 'system@example.com', 'Repair semantic-layer refs: accounts-at-risk');
-    });
-});

package/dist/context/llm/ai-sdk-runtime.test.d.ts

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