@kaelio/ktx 0.5.0 → 0.6.0

package/dist/context/ingest/adapters/dbt-descriptions/parse-schema.test.js

@@ -1,195 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseDbtSchemaFile, parseDbtSchemaFiles } from './parse-schema.js';
-describe('dbt descriptions schema parser', () => {
-    it('resolves shared dbt vars and defaults before parsing schema YAML', () => {
-        const result = parseDbtSchemaFile(`
-version: 2
-sources:
-  - name: raw
-    database: "{{ var('database') }}"
-    schema: "{{ var('schema', 'fallback_schema') }}"
-    tables:
-      - name: orders
-        identifier: fct_orders
-        description: "Orders from {{ var('database') }}"
-        columns:
-          - name: customer_id
-            description: "Customer id"
-            tests:
-              - relationships:
-                  to: ref('customers')
-                  field: id
-models:
-  - name: "{{ var('model_name', 'orders_model') }}"
-    schema: "{{ var('model_schema') }}"
-    columns:
-      - name: id
-        description: "Order id"
-`, { path: 'models/schema.yml', variables: new Map([['database', 'analytics'], ['model_schema', 'mart']]) });
-        expect(result.tables).toEqual([
-            {
-                name: 'fct_orders',
-                description: 'Orders from analytics',
-                database: 'analytics',
-                schema: 'fallback_schema',
-                columns: [
-                    {
-                        name: 'customer_id',
-                        description: 'Customer id',
-                        dataType: null,
-                        dataTests: [{ name: 'relationships', package: 'dbt', kwargs: { to: "ref('customers')", field: 'id' } }],
-                    },
-                ],
-                resourceType: 'source',
-            },
-            {
-                name: 'orders_model',
-                description: null,
-                database: null,
-                schema: 'mart',
-                columns: [{ name: 'id', description: 'Order id', dataType: null }],
-                resourceType: 'model',
-            },
-        ]);
-        expect(result.relationships).toEqual([
-            {
-                fromTable: 'fct_orders',
-                fromColumn: 'customer_id',
-                toTable: 'customers',
-                toColumn: 'id',
-                fromSchema: 'fallback_schema',
-            },
-        ]);
-    });
-    it('deduplicates tables by database schema and name while merging columns', () => {
-        const result = parseDbtSchemaFiles([
-            {
-                path: 'models/a.yml',
-                content: `
-version: 2
-models:
-  - name: orders
-    description: Orders
-    columns:
-      - name: id
-        description: Primary key
-`,
-            },
-            {
-                path: 'models/b.yml',
-                content: `
-version: 2
-models:
-  - name: orders
-    columns:
-      - name: status
-        description: Status
-      - name: id
-        data_type: integer
-`,
-            },
-        ]);
-        expect(result.tables).toEqual([
-            {
-                name: 'orders',
-                description: 'Orders',
-                database: null,
-                schema: null,
-                resourceType: 'model',
-                columns: [
-                    { name: 'id', description: 'Primary key', dataType: 'integer' },
-                    { name: 'status', description: 'Status', dataType: null },
-                ],
-            },
-        ]);
-    });
-    it('returns an empty result for malformed YAML and preserves unresolved Jinja text', () => {
-        expect(parseDbtSchemaFile('{{{{ invalid yaml', { path: 'broken.yml' })).toEqual({
-            projectName: null,
-            dbtVersion: null,
-            tables: [],
-            relationships: [],
-        });
-        const unresolved = parseDbtSchemaFile(`
-version: 2
-models:
-  - name: "{{ var('missing_model') }}"
-`, { variables: new Map() });
-        expect(unresolved.tables[0]?.name).toBe("{{ var('missing_model') }}");
-    });
-    it('extracts data tests, constraints, enum values, tags, and freshness', () => {
-        const result = parseDbtSchemaFile(`
-version: 2
-sources:
-  - name: raw
-    schema: jaffle
-    tags: ["raw"]
-    tables:
-      - name: customers
-        tags: ["core"]
-        loaded_at_field: updated_at
-        freshness:
-          warn_after: { count: 12, period: hour }
-        columns:
-          - name: id
-            tests:
-              - not_null
-              - unique
-          - name: status
-            data_tests:
-              - accepted_values:
-                  values: ['active', 'inactive']
-models:
-  - name: orders
-    tags: ["finance"]
-    loaded_at_field: run_at
-    columns:
-      - name: status
-        data_tests:
-          - dbt_utils.expression_is_true:
-              expression: "status is not null"
-          - accepted_values: ['placed', 'shipped']
-`);
-        const customers = result.tables.find((table) => table.name === 'customers');
-        expect(customers?.tagsDbt).toEqual(['raw', 'core']);
-        expect(customers?.freshnessDbt?.loadedAtField).toBe('updated_at');
-        expect(customers?.freshnessDbt?.raw).toBeDefined();
-        const id = customers?.columns.find((column) => column.name === 'id');
-        expect(id?.constraints?.dbt).toEqual({ not_null: true, unique: true });
-        const status = customers?.columns.find((column) => column.name === 'status');
-        expect(status?.enumValuesDbt).toEqual(['active', 'inactive']);
-        const orders = result.tables.find((table) => table.name === 'orders');
-        expect(orders?.tagsDbt).toEqual(['finance']);
-        expect(orders?.freshnessDbt?.loadedAtField).toBe('run_at');
-        const ordersStatus = orders?.columns.find((column) => column.name === 'status');
-        expect(ordersStatus?.enumValuesDbt).toEqual(['placed', 'shipped']);
-        expect(ordersStatus?.dataTests).toEqual(expect.arrayContaining([
-            expect.objectContaining({ package: 'dbt_utils', name: 'expression_is_true' }),
-            expect.objectContaining({ package: 'dbt', name: 'accepted_values' }),
-        ]));
-    });
-    it('parses relationships from model column data tests', () => {
-        const result = parseDbtSchemaFile(`
-version: 2
-models:
-  - name: orders
-    schema: public
-    columns:
-      - name: customer_id
-        data_tests:
-          - relationships:
-              arguments:
-                to: "ref('customers')"
-                field: id
-`);
-        expect(result.relationships).toEqual([
-            {
-                fromTable: 'orders',
-                fromColumn: 'customer_id',
-                toTable: 'customers',
-                toColumn: 'id',
-                fromSchema: 'public',
-            },
-        ]);
-    });
-});

package/dist/context/ingest/adapters/historic-sql/bigquery-query-history-reader.test.d.ts

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

package/dist/context/ingest/adapters/historic-sql/bigquery-query-history-reader.test.js

@@ -1,121 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { BigQueryHistoricSqlQueryHistoryReader } from './bigquery-query-history-reader.js';
-import { HistoricSqlGrantsMissingError } from './errors.js';
-function queryClient(results) {
-    const executeQuery = vi.fn(async (_query) => {
-        const next = results.shift();
-        if (!next) {
-            throw new Error('unexpected query');
-        }
-        return next;
-    });
-    return { executeQuery };
-}
-function firstQuery(client) {
-    const call = client.executeQuery.mock.calls[0];
-    if (!call) {
-        throw new Error('expected query client to be called');
-    }
-    return call[0];
-}
-describe('BigQueryHistoricSqlQueryHistoryReader', () => {
-    it('probes region-qualified INFORMATION_SCHEMA.JOBS_BY_PROJECT', async () => {
-        const client = queryClient([{ headers: ['1'], rows: [[1]], totalRows: 1 }]);
-        const reader = new BigQueryHistoricSqlQueryHistoryReader({ projectId: 'project-1', region: 'US' });
-        await expect(reader.probe(client)).resolves.toEqual({ warnings: [], info: [] });
-        expect(client.executeQuery).toHaveBeenCalledWith('SELECT 1 FROM `project-1.region-us.INFORMATION_SCHEMA.JOBS_BY_PROJECT` LIMIT 1');
-    });
-    it('turns probe result errors into HistoricSqlGrantsMissingError', async () => {
-        const client = queryClient([{ headers: [], rows: [], totalRows: 0, error: 'Access Denied: jobs.listAll' }]);
-        const reader = new BigQueryHistoricSqlQueryHistoryReader({ projectId: 'project-1', region: 'us-central1' });
-        await expect(reader.probe(client)).rejects.toMatchObject({
-            name: 'HistoricSqlGrantsMissingError',
-            dialect: 'bigquery',
-            remediation: 'Grant roles/bigquery.resourceViewer on the BigQuery project, or grant a custom role containing bigquery.jobs.listAll.',
-        });
-    });
-    it('turns thrown probe failures into HistoricSqlGrantsMissingError', async () => {
-        const client = {
-            executeQuery: vi.fn(async () => {
-                throw new Error('permission denied');
-            }),
-        };
-        const reader = new BigQueryHistoricSqlQueryHistoryReader({ projectId: 'project-1', region: 'US' });
-        await expect(reader.probe(client)).rejects.toBeInstanceOf(HistoricSqlGrantsMissingError);
-    });
-    it('fetches aggregated BigQuery query templates', async () => {
-        const client = queryClient([
-            {
-                headers: [
-                    'template_id',
-                    'canonical_sql',
-                    'executions',
-                    'distinct_users',
-                    'first_seen',
-                    'last_seen',
-                    'p50_ms',
-                    'p95_ms',
-                    'error_rate',
-                    'rows_produced',
-                    'top_users',
-                ],
-                rows: [
-                    [
-                        'hash-1',
-                        'select status from orders',
-                        42,
-                        3,
-                        '2026-05-01T00:00:00.000Z',
-                        '2026-05-11T00:00:00.000Z',
-                        12,
-                        40,
-                        0.05,
-                        null,
-                        JSON.stringify([{ user: 'analyst@example.test', executions: 1 }]),
-                    ],
-                ],
-                totalRows: 1,
-            },
-        ]);
-        const reader = new BigQueryHistoricSqlQueryHistoryReader({ projectId: 'demo', region: 'us' });
-        const rows = [];
-        for await (const row of reader.fetchAggregated(client, { start: new Date('2026-02-10T00:00:00.000Z'), end: new Date('2026-05-11T00:00:00.000Z') }, { dialect: 'bigquery', minExecutions: 5, windowDays: 90, enabledTables: [], filters: { dropTrivialProbes: true }, redactionPatterns: [], staleArchiveAfterDays: 90 })) {
-            rows.push(row);
-        }
-        const sql = firstQuery(client);
-        expect(sql).toContain('COUNT(*) AS executions');
-        expect(sql).toContain('COUNT(DISTINCT user_email) AS distinct_users');
-        expect(sql).toContain('GROUP BY query_hash');
-        expect(sql).toContain('HAVING COUNT(*) >= 5');
-        expect(rows).toMatchObject([
-            {
-                templateId: 'hash-1',
-                stats: {
-                    executions: 42,
-                    errorRate: 0.05,
-                },
-                topUsers: [{ user: 'analyst@example.test', executions: 1 }],
-            },
-        ]);
-    });
-    it('throws a clear error when the query client cannot execute SQL', async () => {
-        const reader = new BigQueryHistoricSqlQueryHistoryReader({ projectId: 'project-1', region: 'US' });
-        await expect(async () => {
-            for await (const _row of reader.fetchAggregated({}, { start: new Date(), end: new Date() }, {
-                dialect: 'bigquery',
-                minExecutions: 5,
-                windowDays: 90,
-                enabledTables: [],
-                filters: { dropTrivialProbes: true },
-                redactionPatterns: [],
-                staleArchiveAfterDays: 90,
-            })) {
-                throw new Error('unreachable');
-            }
-        }).rejects.toThrow('Historic SQL BigQuery reader requires a query client with executeQuery(query)');
-    });
-    it('rejects unsafe project and region identifiers before building SQL', () => {
-        expect(() => new BigQueryHistoricSqlQueryHistoryReader({ projectId: 'project`1', region: 'US' })).toThrow('Invalid BigQuery project id for historic-SQL ingest: project`1');
-        expect(() => new BigQueryHistoricSqlQueryHistoryReader({ projectId: 'project-1', region: 'US;DROP' })).toThrow('Invalid BigQuery region for historic-SQL ingest: US;DROP');
-    });
-});

package/dist/context/ingest/adapters/historic-sql/buckets.test.d.ts

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

package/dist/context/ingest/adapters/historic-sql/buckets.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { bucketDistinctUsers, bucketErrorRate, bucketExecutions, bucketFrequency, bucketP95Runtime, bucketRecency, } from './buckets.js';
-describe('historic-sql bucket helpers', () => {
-    it('uses stable execution buckets', () => {
-        expect([0, 9, 10, 99, 100, 999, 1000, 4999, 5000, 49999, 50000].map(bucketExecutions)).toEqual([
-            '<10',
-            '<10',
-            '10-100',
-            '10-100',
-            '100-1k',
-            '100-1k',
-            '1k-5k',
-            '1k-5k',
-            '5k-50k',
-            '5k-50k',
-            '>50k',
-        ]);
-    });
-    it('uses stable distinct-user, error-rate, runtime, and recency buckets', () => {
-        expect([0, 1, 2, 5, 6, 10, 11].map(bucketDistinctUsers)).toEqual([
-            '0',
-            '1',
-            '2-5',
-            '2-5',
-            '5-10',
-            '5-10',
-            '>10',
-        ]);
-        expect([0, 0.01, 0.05, 0.2].map(bucketErrorRate)).toEqual(['none', 'low', 'low', 'high']);
-        expect([null, 99, 100, 999, 1000, 9999, 10000].map(bucketP95Runtime)).toEqual([
-            'unknown',
-            '<100ms',
-            '100ms-1s',
-            '100ms-1s',
-            '1s-10s',
-            '1s-10s',
-            '>10s',
-        ]);
-        expect(bucketRecency('2026-05-11T00:00:00.000Z', new Date('2026-05-11T12:00:00.000Z'))).toBe('current');
-        expect(bucketRecency('2026-04-20T00:00:00.000Z', new Date('2026-05-11T12:00:00.000Z'))).toBe('recent');
-        expect(bucketRecency('2026-01-01T00:00:00.000Z', new Date('2026-05-11T12:00:00.000Z'))).toBe('stale');
-    });
-    it('maps frequency counts to high, mid, and low labels', () => {
-        expect(bucketFrequency(80, 100)).toBe('high');
-        expect(bucketFrequency(20, 100)).toBe('mid');
-        expect(bucketFrequency(1, 100)).toBe('low');
-        expect(bucketFrequency(0, 0)).toBe('low');
-    });
-});

package/dist/context/ingest/adapters/historic-sql/chunk-unified.test.d.ts

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

package/dist/context/ingest/adapters/historic-sql/chunk-unified.test.js

@@ -1,160 +0,0 @@
-import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { chunkHistoricSqlUnifiedStagedDir, describeHistoricSqlUnifiedScope } from './chunk-unified.js';
-async function tempDir() {
-    return mkdtemp(join(tmpdir(), 'historic-sql-unified-chunk-'));
-}
-async function writeJson(root, relPath, value) {
-    const target = join(root, relPath);
-    await mkdir(join(target, '..'), { recursive: true });
-    await writeFile(target, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
-}
-async function writeUnifiedStagedDir(root) {
-    await writeJson(root, 'manifest.json', {
-        source: 'historic-sql',
-        connectionId: 'warehouse',
-        dialect: 'postgres',
-        fetchedAt: '2026-05-11T00:00:00.000Z',
-        windowStart: '2026-02-10T00:00:00.000Z',
-        windowEnd: '2026-05-11T00:00:00.000Z',
-        snapshotRowCount: 1,
-        touchedTableCount: 1,
-        parseFailures: 0,
-        warnings: [],
-        probeWarnings: [],
-    });
-    await writeJson(root, 'tables/public.orders.json', {
-        table: 'public.orders',
-        stats: {
-            executionsBucket: '10-100',
-            distinctUsersBucket: '2-5',
-            errorRateBucket: 'none',
-            p95RuntimeBucket: '<100ms',
-            recencyBucket: 'current',
-        },
-        columnsByClause: { select: [['status', 'high']] },
-        observedJoins: [],
-        topTemplates: [{ id: 'orders', canonicalSql: 'select * from public.orders', topUsers: [{ user: 'analyst' }] }],
-    });
-    await writeJson(root, 'patterns-input.json', {
-        templates: [
-            {
-                id: 'orders',
-                canonicalSql: 'select * from public.orders join public.customers on true',
-                tablesTouched: ['public.orders', 'public.customers'],
-                executionsBucket: '10-100',
-                distinctUsersBucket: '2-5',
-                dialect: 'postgres',
-            },
-        ],
-    });
-    await writeJson(root, 'patterns-input/part-0001.json', {
-        templates: [
-            {
-                id: 'orders',
-                canonicalSql: 'select * from public.orders join public.customers on true',
-                tablesTouched: ['public.orders', 'public.customers'],
-                executionsBucket: '10-100',
-                distinctUsersBucket: '2-5',
-                dialect: 'postgres',
-            },
-        ],
-    });
-}
-describe('chunkHistoricSqlUnifiedStagedDir', () => {
-    it('emits one table WorkUnit plus one patterns WorkUnit', async () => {
-        const stagedDir = await tempDir();
-        await writeUnifiedStagedDir(stagedDir);
-        const result = await chunkHistoricSqlUnifiedStagedDir(stagedDir);
-        expect(result.workUnits).toEqual([
-            expect.objectContaining({
-                unitKey: 'historic-sql-table-public-orders',
-                displayLabel: 'Historic SQL usage: public.orders',
-                rawFiles: ['tables/public.orders.json'],
-                dependencyPaths: ['manifest.json'],
-                notes: expect.stringContaining('historic_sql_table_digest'),
-            }),
-            expect.objectContaining({
-                unitKey: 'historic-sql-patterns-part-0001',
-                displayLabel: 'Historic SQL cross-table patterns: part-0001',
-                rawFiles: ['patterns-input/part-0001.json'],
-                dependencyPaths: ['manifest.json'],
-                notes: expect.stringContaining('patterns-input/part-0001.json'),
-            }),
-        ]);
-        expect(result.workUnits[0]?.notes).toContain('emit_historic_sql_evidence');
-        expect(result.workUnits[1]?.notes).toContain('emit_historic_sql_evidence');
-        expect(result.reconcileNotes).toEqual(['Historic-SQL touched tables=1 parseFailures=0']);
-    });
-    it('respects diff sets for unchanged table and patterns files', async () => {
-        const stagedDir = await tempDir();
-        await writeUnifiedStagedDir(stagedDir);
-        await expect(chunkHistoricSqlUnifiedStagedDir(stagedDir, {
-            added: [],
-            modified: ['tables/public.orders.json'],
-            deleted: [],
-            unchanged: ['manifest.json', 'patterns-input.json', 'patterns-input/part-0001.json'],
-        })).resolves.toMatchObject({
-            workUnits: [expect.objectContaining({ unitKey: 'historic-sql-table-public-orders' })],
-        });
-        await expect(chunkHistoricSqlUnifiedStagedDir(stagedDir, {
-            added: [],
-            modified: ['patterns-input/part-0001.json'],
-            deleted: [],
-            unchanged: ['manifest.json', 'patterns-input.json', 'tables/public.orders.json'],
-        })).resolves.toMatchObject({
-            workUnits: [expect.objectContaining({ unitKey: 'historic-sql-patterns-part-0001' })],
-        });
-        await expect(chunkHistoricSqlUnifiedStagedDir(stagedDir, {
-            added: [],
-            modified: ['patterns-input.json'],
-            deleted: [],
-            unchanged: ['manifest.json', 'patterns-input/part-0001.json', 'tables/public.orders.json'],
-        })).resolves.toMatchObject({
-            workUnits: [],
-        });
-    });
-    it('describes unified staged scope', async () => {
-        const stagedDir = await tempDir();
-        await writeUnifiedStagedDir(stagedDir);
-        const scope = await describeHistoricSqlUnifiedScope(stagedDir);
-        expect(scope.isPathInScope('manifest.json')).toBe(true);
-        expect(scope.isPathInScope('patterns-input.json')).toBe(true);
-        expect(scope.isPathInScope('patterns-input/part-0001.json')).toBe(true);
-        expect(scope.isPathInScope('patterns-input/part-1.json')).toBe(false);
-        expect(scope.isPathInScope('tables/public.orders.json')).toBe(true);
-        expect(scope.isPathInScope('templates/old/page.md')).toBe(false);
-    });
-    it('emits one patterns WorkUnit per changed shard', async () => {
-        const stagedDir = await tempDir();
-        await writeUnifiedStagedDir(stagedDir);
-        await writeJson(stagedDir, 'patterns-input/part-0002.json', {
-            templates: [
-                {
-                    id: 'line-items',
-                    canonicalSql: 'select * from public.orders join public.line_items on true',
-                    tablesTouched: ['public.orders', 'public.line_items'],
-                    executionsBucket: '10-100',
-                    distinctUsersBucket: '2-5',
-                    dialect: 'postgres',
-                },
-            ],
-        });
-        const result = await chunkHistoricSqlUnifiedStagedDir(stagedDir, {
-            added: ['patterns-input/part-0002.json'],
-            modified: ['patterns-input/part-0001.json'],
-            deleted: [],
-            unchanged: ['manifest.json', 'patterns-input.json', 'tables/public.orders.json'],
-        });
-        expect(result.workUnits.map((unit) => unit.unitKey)).toEqual([
-            'historic-sql-patterns-part-0001',
-            'historic-sql-patterns-part-0002',
-        ]);
-        expect(result.workUnits.map((unit) => unit.rawFiles)).toEqual([
-            ['patterns-input/part-0001.json'],
-            ['patterns-input/part-0002.json'],
-        ]);
-    });
-});

package/dist/context/ingest/adapters/historic-sql/detect.test.d.ts

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

package/dist/context/ingest/adapters/historic-sql/detect.test.js

@@ -1,48 +0,0 @@
-import { mkdir, mkdtemp, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { detectHistoricSqlStagedDir } from './detect.js';
-import { HISTORIC_SQL_SOURCE_KEY, stagedManifestSchema } from './types.js';
-async function tempDir() {
-    return mkdtemp(join(tmpdir(), 'historic-sql-detect-'));
-}
-async function writeJson(root, relPath, value) {
-    const target = join(root, relPath);
-    await mkdir(join(target, '..'), { recursive: true });
-    await writeFile(target, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
-}
-function manifest() {
-    return stagedManifestSchema.parse({
-        source: HISTORIC_SQL_SOURCE_KEY,
-        connectionId: 'conn_1',
-        dialect: 'postgres',
-        fetchedAt: '2026-05-04T12:00:00.000Z',
-        windowStart: '2026-02-03T12:00:00.000Z',
-        windowEnd: '2026-05-04T12:00:00.000Z',
-        snapshotRowCount: 0,
-        touchedTableCount: 0,
-        parseFailures: 0,
-        warnings: [],
-        probeWarnings: [],
-    });
-}
-describe('historic-sql staged dir detection', () => {
-    it('detects manifest source', async () => {
-        const stagedDir = await tempDir();
-        await writeJson(stagedDir, 'manifest.json', manifest());
-        await expect(detectHistoricSqlStagedDir(stagedDir)).resolves.toBe(true);
-    });
-    it('detects unified table and patterns structure without manifest', async () => {
-        const stagedDir = await tempDir();
-        await writeFile(join(stagedDir, 'not-a-match.txt'), 'x', 'utf-8');
-        await writeJson(stagedDir, 'patterns-input.json', { templates: [] });
-        await writeJson(stagedDir, 'tables/public.orders.json', { table: 'public.orders' });
-        await expect(detectHistoricSqlStagedDir(stagedDir)).resolves.toBe(true);
-    });
-    it('does not detect unrelated directories', async () => {
-        const stagedDir = await tempDir();
-        await writeJson(stagedDir, 'manifest.json', { source: 'notion' });
-        await expect(detectHistoricSqlStagedDir(stagedDir)).resolves.toBe(false);
-    });
-});

package/dist/context/ingest/adapters/historic-sql/evidence-tool.test.d.ts

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

package/dist/context/ingest/adapters/historic-sql/evidence-tool.test.js

@@ -1,67 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { asSchema } from 'ai';
-import { createEmitHistoricSqlEvidenceTool } from './evidence-tool.js';
-describe('emit_historic_sql_evidence tool', () => {
-    it('exposes an AI SDK v6 tool input schema with top-level object type', async () => {
-        const tool = createEmitHistoricSqlEvidenceTool();
-        expect(await asSchema(tool.inputSchema).jsonSchema).toMatchObject({
-            type: 'object',
-        });
-    });
-    it('writes table usage evidence to the ignored run evidence directory', async () => {
-        const writeFile = vi.fn(async () => ({ success: true, commitHash: null }));
-        const tool = createEmitHistoricSqlEvidenceTool();
-        const result = await tool.execute({
-            kind: 'table_usage',
-            table: 'public.orders',
-            rawPath: 'tables/public.orders.json',
-            usage: {
-                narrative: 'Orders are repeatedly queried by paid status.',
-                frequencyTier: 'high',
-                commonFilters: ['status'],
-                commonJoins: [],
-                staleSince: null,
-            },
-        }, {
-            toolCallId: 'call-1',
-            messages: [],
-            abortSignal: new AbortController().signal,
-            experimental_context: {
-                connectionId: 'warehouse',
-                session: {
-                    ingest: { runId: 'run-1', jobId: 'job-1', syncId: 'sync-1', sourceKey: 'historic-sql' },
-                    configService: { writeFile },
-                },
-            },
-        });
-        expect(result).toBe('Recorded historic-SQL table_usage evidence for public.orders.');
-        expect(writeFile).toHaveBeenCalledWith('.ktx/ingest-evidence/historic-sql/run-1/historic-sql-table-public-orders.json', expect.stringContaining('"kind": "table_usage"'), 'System User', 'system@example.com', 'Record historic-SQL evidence: historic-sql-table-public-orders', { skipLock: true });
-    });
-    it('rejects non-historic ingest sessions', async () => {
-        const tool = createEmitHistoricSqlEvidenceTool();
-        await expect(tool.execute({
-            kind: 'pattern',
-            rawPath: 'patterns-input.json',
-            pattern: {
-                slug: 'orders',
-                title: 'Orders',
-                narrative: 'Orders pattern.',
-                definitionSql: 'select * from public.orders',
-                tablesInvolved: ['public.orders'],
-                slRefs: ['orders'],
-                constituentTemplateIds: ['pg:1'],
-            },
-        }, {
-            toolCallId: 'call-1',
-            messages: [],
-            abortSignal: new AbortController().signal,
-            experimental_context: {
-                connectionId: 'warehouse',
-                session: {
-                    ingest: { runId: 'run-1', jobId: 'job-1', syncId: 'sync-1', sourceKey: 'notion' },
-                    configService: { writeFile: vi.fn() },
-                },
-            },
-        })).resolves.toContain('Error: emit_historic_sql_evidence is only available during historic-sql ingest');
-    });
-});

package/dist/context/ingest/adapters/historic-sql/evidence.test.d.ts

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