@kaelio/ktx 0.5.0 → 0.7.0

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

@@ -1,43 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { historicSqlEvidenceEnvelopeSchema, historicSqlEvidencePath, historicSqlPatternEvidenceSchema, historicSqlTableUsageEvidenceSchema, } from './evidence.js';
-describe('historic-sql evidence contracts', () => {
-    it('validates table usage evidence emitted by table digest WorkUnits', () => {
-        const parsed = historicSqlTableUsageEvidenceSchema.parse({
-            kind: 'table_usage',
-            connectionId: 'warehouse',
-            table: 'public.orders',
-            rawPath: 'tables/public.orders.json',
-            usage: {
-                narrative: 'Orders are repeatedly queried for paid/refunded lifecycle analysis.',
-                frequencyTier: 'high',
-                commonFilters: ['status', 'created_at'],
-                commonGroupBys: ['status'],
-                commonJoins: [{ table: 'public.customers', on: ['customer_id'] }],
-                staleSince: null,
-            },
-        });
-        expect(parsed.table).toBe('public.orders');
-        expect(parsed.usage.frequencyTier).toBe('high');
-    });
-    it('validates pattern evidence emitted by the patterns WorkUnit', () => {
-        const parsed = historicSqlPatternEvidenceSchema.parse(historicSqlEvidenceEnvelopeSchema.parse({
-            kind: 'pattern',
-            connectionId: 'warehouse',
-            rawPath: 'patterns-input.json',
-            pattern: {
-                slug: 'order-lifecycle-analysis',
-                title: 'Order Lifecycle Analysis',
-                narrative: 'Analysts compare order status changes by customer segment.',
-                definitionSql: 'select status, count(*) from public.orders group by status',
-                tablesInvolved: ['public.orders', 'public.customers'],
-                slRefs: ['orders', 'customers'],
-                constituentTemplateIds: ['pg:1', 'pg:2'],
-            },
-        }));
-        expect(parsed.kind).toBe('pattern');
-        expect(parsed.pattern.slug).toBe('order-lifecycle-analysis');
-    });
-    it('builds a stable ignored evidence path from run and WorkUnit identity', () => {
-        expect(historicSqlEvidencePath('run-1', 'historic-sql-table-public-orders')).toBe('.ktx/ingest-evidence/historic-sql/run-1/historic-sql-table-public-orders.json');
-    });
-});

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

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

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

@@ -1,98 +0,0 @@
-import { mkdtemp } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { HistoricSqlSourceAdapter } from './historic-sql.adapter.js';
-async function tempDir() {
-    return mkdtemp(join(tmpdir(), 'historic-sql-adapter-'));
-}
-const sqlAnalysis = {
-    async analyzeForFingerprint() {
-        throw new Error('analyzeForFingerprint must not be used');
-    },
-    async analyzeBatch() {
-        return new Map();
-    },
-    async validateReadOnly() {
-        return { ok: true };
-    },
-};
-const reader = {
-    async probe() {
-        return { warnings: [], info: [] };
-    },
-    async *fetchAggregated() { },
-};
-describe('HistoricSqlSourceAdapter', () => {
-    it('declares canonical adapter metadata', () => {
-        const adapter = new HistoricSqlSourceAdapter({ sqlAnalysis, reader, queryClient: {} });
-        expect(adapter.source).toBe('historic-sql');
-        expect(adapter.skillNames).toEqual(['historic_sql_table_digest', 'historic_sql_patterns']);
-        expect(adapter.reconcileSkillNames).toEqual([]);
-        expect(adapter.evidenceIndexing).toBeUndefined();
-        expect(adapter.triageSupported).toBe(false);
-    });
-    it('fetches a unified aggregate snapshot and emits unified WorkUnits', async () => {
-        const stagedDir = await tempDir();
-        const aggregateReader = {
-            async probe() {
-                return { warnings: [], info: [] };
-            },
-            async *fetchAggregated() {
-                yield {
-                    templateId: 'pg:1',
-                    canonicalSql: 'select o.status, count(*) from public.orders o join public.customers c on c.id = o.customer_id group by o.status',
-                    dialect: 'postgres',
-                    stats: {
-                        executions: 25,
-                        distinctUsers: 3,
-                        firstSeen: '2026-05-01T00:00:00.000Z',
-                        lastSeen: '2026-05-11T00:00:00.000Z',
-                        p50RuntimeMs: 10,
-                        p95RuntimeMs: 20,
-                        errorRate: 0,
-                        rowsProduced: 10,
-                    },
-                    topUsers: [{ user: 'analyst', executions: 25 }],
-                };
-            },
-        };
-        const batchSqlAnalysis = {
-            async analyzeForFingerprint() {
-                throw new Error('analyzeForFingerprint must not be used');
-            },
-            async analyzeBatch() {
-                return new Map([
-                    [
-                        'pg:1',
-                        {
-                            tablesTouched: ['public.orders', 'public.customers'],
-                            columnsByClause: { select: ['status'], join: ['customer_id', 'id'], groupBy: ['status'] },
-                        },
-                    ],
-                ]);
-            },
-            async validateReadOnly() {
-                return { ok: true };
-            },
-        };
-        const adapter = new HistoricSqlSourceAdapter({
-            sqlAnalysis: batchSqlAnalysis,
-            reader: aggregateReader,
-            queryClient: {},
-            now: () => new Date('2026-05-11T00:00:00.000Z'),
-        });
-        await adapter.fetch({ dialect: 'postgres', minExecutions: 5 }, stagedDir, {
-            connectionId: 'warehouse',
-            sourceKey: 'historic-sql',
-        });
-        await expect(adapter.detect(stagedDir)).resolves.toBe(true);
-        await expect(adapter.chunk(stagedDir)).resolves.toMatchObject({
-            workUnits: [
-                { unitKey: 'historic-sql-table-public-customers' },
-                { unitKey: 'historic-sql-table-public-orders' },
-                { unitKey: 'historic-sql-patterns-part-0001' },
-            ],
-        });
-    });
-});

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

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

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

@@ -1,235 +0,0 @@
-import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import YAML from 'yaml';
-import { initKtxProject, loadKtxProject } from '../../../../context/project/project.js';
-import { searchLocalSlSources } from '../../../sl/local-sl.js';
-import { searchLocalKnowledgePages } from '../../../wiki/local-knowledge.js';
-import { runLocalIngest } from '../../local-ingest.js';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { HistoricSqlSourceAdapter } from './historic-sql.adapter.js';
-class AcceptanceHistoricSqlReader {
-    async probe() {
-        return { warnings: [], info: [] };
-    }
-    async *fetchAggregated(_client, _window, _config) {
-        yield {
-            templateId: 'pg:orders-lifecycle',
-            canonicalSql: 'select o.status, c.segment, count(*) from public.orders o join public.customers c on c.id = o.customer_id where o.status = $1 group by o.status, c.segment',
-            dialect: 'postgres',
-            stats: {
-                executions: 42,
-                distinctUsers: 4,
-                firstSeen: '2026-05-01T00:00:00.000Z',
-                lastSeen: '2026-05-11T00:00:00.000Z',
-                p50RuntimeMs: 18,
-                p95RuntimeMs: 84,
-                errorRate: 0,
-                rowsProduced: 420,
-            },
-            topUsers: [{ user: 'analyst@example.test', executions: 42 }],
-        };
-    }
-}
-class HistoricSqlAcceptanceAgentRunner {
-    runLoop = vi.fn(async (params) => {
-        if (params.telemetryTags?.operationName !== 'ingest-bundle-wu') {
-            return { stopReason: 'natural' };
-        }
-        const emitEvidence = params.toolSet.emit_historic_sql_evidence;
-        if (!emitEvidence?.execute) {
-            throw new Error('emit_historic_sql_evidence tool was not available to the historic-SQL WorkUnit');
-        }
-        if (params.telemetryTags.unitKey === 'historic-sql-table-public-orders') {
-            const result = await emitEvidence.execute({
-                kind: 'table_usage',
-                table: 'public.orders',
-                rawPath: 'tables/public.orders.json',
-                usage: {
-                    narrative: 'Analysts repeatedly inspect paid order lifecycle by customer segment.',
-                    frequencyTier: 'high',
-                    commonFilters: ['status'],
-                    commonGroupBys: ['status', 'segment'],
-                    commonJoins: [{ table: 'public.customers', on: ['customer_id', 'id'] }],
-                    staleSince: null,
-                },
-            });
-            if (!result.markdown.includes('Recorded historic-SQL table_usage evidence')) {
-                throw new Error(`Unexpected orders evidence result: ${result.markdown}`);
-            }
-        }
-        if (params.telemetryTags.unitKey === 'historic-sql-table-public-customers') {
-            const result = await emitEvidence.execute({
-                kind: 'table_usage',
-                table: 'public.customers',
-                rawPath: 'tables/public.customers.json',
-                usage: {
-                    narrative: 'Customers provide segment context for paid order lifecycle analysis.',
-                    frequencyTier: 'mid',
-                    commonFilters: [],
-                    commonGroupBys: ['segment'],
-                    commonJoins: [{ table: 'public.orders', on: ['id', 'customer_id'] }],
-                    staleSince: null,
-                },
-            });
-            if (!result.markdown.includes('Recorded historic-SQL table_usage evidence')) {
-                throw new Error(`Unexpected customers evidence result: ${result.markdown}`);
-            }
-        }
-        if (params.telemetryTags.unitKey === 'historic-sql-patterns-part-0001') {
-            const result = await emitEvidence.execute({
-                kind: 'pattern',
-                rawPath: 'patterns-input/part-0001.json',
-                pattern: {
-                    slug: 'paid-order-lifecycle',
-                    title: 'Paid Order Lifecycle',
-                    narrative: 'Analysts join orders and customers to compare paid order lifecycle by segment.',
-                    definitionSql: 'select o.status, c.segment, count(*) from public.orders o join public.customers c on c.id = o.customer_id group by o.status, c.segment',
-                    tablesInvolved: ['public.orders', 'public.customers'],
-                    slRefs: ['orders', 'customers'],
-                    constituentTemplateIds: ['pg:orders-lifecycle'],
-                },
-            });
-            if (!result.markdown.includes('Recorded historic-SQL pattern evidence')) {
-                throw new Error(`Unexpected pattern evidence result: ${result.markdown}`);
-            }
-        }
-        return { stopReason: 'natural' };
-    });
-}
-function acceptanceSqlAnalysis() {
-    return {
-        analyzeForFingerprint: async () => {
-            throw new Error('analyzeForFingerprint should not be used by unified historic-SQL ingest');
-        },
-        analyzeBatch: vi.fn(async (items, _dialect) => {
-            return new Map(items.map((item) => [
-                item.id,
-                {
-                    tablesTouched: ['public.orders', 'public.customers'],
-                    columnsByClause: {
-                        select: ['status', 'segment'],
-                        where: ['status'],
-                        join: ['customer_id', 'id'],
-                        groupBy: ['status', 'segment'],
-                    },
-                },
-            ]));
-        }),
-        validateReadOnly: vi.fn(async () => ({ ok: true })),
-    };
-}
-async function writeHistoricSqlProject(project) {
-    await writeFile(join(project.projectDir, 'ktx.yaml'), [
-        'connections:',
-        '  warehouse:',
-        '    driver: postgres',
-        '    context:',
-        '      queryHistory:',
-        '        enabled: true',
-        '        minExecutions: 2',
-        'ingest:',
-        '  adapters:',
-        '    - historic-sql',
-        '  embeddings:',
-        '    backend: none',
-        'storage:',
-        '  state: sqlite',
-        '  search: sqlite-fts5',
-        '  git:',
-        '    auto_commit: false',
-        '    author: KTX Test <system@ktx.local>',
-        '',
-    ].join('\n'), 'utf-8');
-    const loaded = await loadKtxProject({ projectDir: project.projectDir });
-    await loaded.fileStore.writeFile('semantic-layer/warehouse/_schema/public.yaml', YAML.stringify({
-        tables: {
-            orders: {
-                table: 'public.orders',
-                columns: [
-                    { name: 'id', type: 'string' },
-                    { name: 'status', type: 'string' },
-                    { name: 'customer_id', type: 'string' },
-                ],
-            },
-            customers: {
-                table: 'public.customers',
-                columns: [
-                    { name: 'id', type: 'string' },
-                    { name: 'segment', type: 'string' },
-                ],
-            },
-        },
-    }), 'KTX Test', 'system@ktx.local', 'Seed schema shard');
-    return loaded;
-}
-describe('historic-SQL local ingest retrieval acceptance', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-historic-sql-acceptance-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('projects table and pattern evidence into semantic-layer and wiki retrieval surfaces', async () => {
-        const initialized = await initKtxProject({ projectDir: join(tempDir, 'project') });
-        const project = await writeHistoricSqlProject(initialized);
-        const sqlAnalysis = acceptanceSqlAnalysis();
-        const agentRunner = new HistoricSqlAcceptanceAgentRunner();
-        const adapter = new HistoricSqlSourceAdapter({
-            reader: new AcceptanceHistoricSqlReader(),
-            queryClient: {},
-            sqlAnalysis,
-            now: () => new Date('2026-05-11T00:00:00.000Z'),
-        });
-        const result = await runLocalIngest({
-            project,
-            adapters: [adapter],
-            adapter: 'historic-sql',
-            connectionId: 'warehouse',
-            jobId: 'historic-sql-retrieval-acceptance',
-            agentRunner,
-        });
-        expect(sqlAnalysis.analyzeBatch).toHaveBeenCalledTimes(1);
-        expect(result.result.failedWorkUnits).toEqual([]);
-        expect(result.result.workUnitCount).toBe(3);
-        expect(agentRunner.runLoop).toHaveBeenCalledTimes(3);
-        const finalization = result.report.body.finalization;
-        expect(finalization).toBeDefined();
-        if (!finalization) {
-            throw new Error('Expected historic-SQL finalization result');
-        }
-        expect(finalization).toMatchObject({
-            sourceKey: 'historic-sql',
-            status: 'success',
-            result: {
-                tableUsageMerged: 2,
-                patternPagesWritten: 1,
-            },
-        });
-        expect(finalization.declaredTouchedSources).toEqual(expect.arrayContaining([
-            { connectionId: 'warehouse', sourceName: 'customers' },
-            { connectionId: 'warehouse', sourceName: 'orders' },
-        ]));
-        await expect(readFile(join(project.projectDir, 'semantic-layer/warehouse/_schema/public.yaml'), 'utf-8')).resolves
-            .toContain('Analysts repeatedly inspect paid order lifecycle by customer segment.');
-        await expect(readFile(join(project.projectDir, 'wiki/global/historic-sql-paid-order-lifecycle.md'), 'utf-8'))
-            .resolves.toContain('Paid Order Lifecycle');
-        const reloaded = await loadKtxProject({ projectDir: project.projectDir });
-        await expect(searchLocalSlSources(reloaded, { connectionId: 'warehouse', query: 'paid order lifecycle', limit: 5 })).resolves.toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                name: 'orders',
-                frequencyTier: 'high',
-                snippet: expect.stringContaining('<mark>'),
-                matchReasons: expect.arrayContaining(['lexical']),
-            }),
-        ]));
-        await expect(searchLocalKnowledgePages(reloaded, { query: 'paid order lifecycle', userId: 'local', limit: 5 })).resolves.toEqual([
-            expect.objectContaining({
-                key: 'historic-sql-paid-order-lifecycle',
-                summary: 'Paid Order Lifecycle',
-                matchReasons: expect.arrayContaining(['lexical']),
-            }),
-        ]);
-    });
-});

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

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

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

@@ -1,68 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { HISTORIC_SQL_PATTERN_WORKUNIT_MAX_BYTES, isHistoricSqlPatternInputShardPath, serializedStagedPatternsInputByteLength, splitHistoricSqlPatternInputs, } from './pattern-inputs.js';
-function template(id, tablesTouched, canonicalSql = 'select 1') {
-    return {
-        id,
-        canonicalSql,
-        tablesTouched,
-        executionsBucket: '10-100',
-        distinctUsersBucket: '2-5',
-        dialect: 'postgres',
-    };
-}
-describe('historic-SQL pattern input sharding', () => {
-    it('keeps the audit input complete while sharding only cross-table pattern candidates', () => {
-        const largeSql = `select * from public.orders join public.customers on true where marker = '${'x'.repeat(260)}'`;
-        const input = {
-            templates: [
-                template('single-table-orders', ['public.orders']),
-                template('orders-customers-2', ['public.orders', 'public.customers'], largeSql),
-                template('orders-customers-1', ['public.customers', 'public.orders'], largeSql),
-                template('orders-customers-payments', ['public.orders', 'public.customers', 'public.payments'], largeSql),
-            ],
-        };
-        const result = splitHistoricSqlPatternInputs(input, { maxBytes: 760 });
-        expect(result.auditInput.templates.map((entry) => entry.id)).toEqual([
-            'orders-customers-1',
-            'orders-customers-2',
-            'orders-customers-payments',
-            'single-table-orders',
-        ]);
-        expect(result.shards.length).toBeGreaterThan(1);
-        expect(result.shards.map((shard) => shard.path)).toEqual([
-            'patterns-input/part-0001.json',
-            'patterns-input/part-0002.json',
-            'patterns-input/part-0003.json',
-        ]);
-        expect(result.shards.flatMap((shard) => shard.input.templates.map((entry) => entry.id))).toEqual([
-            'orders-customers-payments',
-            'orders-customers-1',
-            'orders-customers-2',
-        ]);
-        expect(result.shards.every((shard) => shard.byteLength <= 760)).toBe(true);
-        expect(result.shards.flatMap((shard) => shard.input.templates).some((entry) => entry.id === 'single-table-orders')).toBe(false);
-        expect(result.warnings).toEqual([]);
-    });
-    it('omits a single oversized template from shards and reports a manifest warning', () => {
-        const input = {
-            templates: [
-                template('oversized-cross-table', ['public.orders', 'public.customers'], `select * from public.orders join public.customers on true where payload = '${'x'.repeat(500)}'`),
-            ],
-        };
-        const result = splitHistoricSqlPatternInputs(input, { maxBytes: 240 });
-        expect(result.auditInput.templates.map((entry) => entry.id)).toEqual(['oversized-cross-table']);
-        expect(result.shards).toEqual([]);
-        expect(result.warnings).toEqual(['patterns_input_template_too_large:oversized-cross-table']);
-    });
-    it('recognizes only generated pattern shard paths', () => {
-        expect(isHistoricSqlPatternInputShardPath('patterns-input/part-0001.json')).toBe(true);
-        expect(isHistoricSqlPatternInputShardPath('patterns-input/part-0012.json')).toBe(true);
-        expect(isHistoricSqlPatternInputShardPath('patterns-input.json')).toBe(false);
-        expect(isHistoricSqlPatternInputShardPath('patterns-input/part-1.json')).toBe(false);
-        expect(isHistoricSqlPatternInputShardPath('patterns-input/readme.md')).toBe(false);
-    });
-    it('uses a production byte budget below read_raw_file maximum size', () => {
-        expect(HISTORIC_SQL_PATTERN_WORKUNIT_MAX_BYTES).toBeLessThan(120_000);
-        expect(serializedStagedPatternsInputByteLength({ templates: [] })).toBeGreaterThan(0);
-    });
-});

package/dist/context/ingest/adapters/historic-sql/postgres-pgss-reader.test.d.ts

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

package/dist/context/ingest/adapters/historic-sql/postgres-pgss-reader.test.js

@@ -1,205 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { HistoricSqlExtensionMissingError, HistoricSqlGrantsMissingError, HistoricSqlVersionUnsupportedError, } from './errors.js';
-import { PostgresPgssReader } from './postgres-pgss-reader.js';
-function queryClient(results) {
-    const executeQuery = vi.fn(async (_query, _params) => {
-        const next = results.shift();
-        if (!next) {
-            throw new Error('unexpected query');
-        }
-        if (next instanceof Error) {
-            throw next;
-        }
-        return next;
-    });
-    return { executeQuery };
-}
-function executedSql(client, index) {
-    const call = client.executeQuery.mock.calls[index];
-    if (!call) {
-        throw new Error(`expected query client call ${index}`);
-    }
-    return call[0];
-}
-describe('PostgresPgssReader aggregate path', () => {
-    it('probes version, extension presence, grants, and tracking state', async () => {
-        const client = queryClient([
-            {
-                headers: ['server_version_num', 'server_version'],
-                rows: [[160004, 'PostgreSQL 16.4 on x86_64-apple-darwin']],
-            },
-            { headers: ['?column?'], rows: [[1]] },
-            { headers: ['has_role'], rows: [[true]] },
-            { headers: ['track'], rows: [['top']] },
-            { headers: ['max'], rows: [['5000']] },
-        ]);
-        const reader = new PostgresPgssReader();
-        await expect(reader.probe(client)).resolves.toEqual({
-            pgServerVersion: 'PostgreSQL 16.4 on x86_64-apple-darwin',
-            warnings: [],
-            info: [],
-        });
-        expect(executedSql(client, 0)).toContain("current_setting('server_version_num')::int");
-        expect(executedSql(client, 1)).toBe('SELECT 1 FROM pg_stat_statements LIMIT 1');
-        expect(executedSql(client, 2)).toBe("SELECT pg_has_role(current_user, 'pg_read_all_stats', 'USAGE') AS has_role");
-        expect(executedSql(client, 3)).toBe("SELECT current_setting('pg_stat_statements.track') AS track");
-        expect(executedSql(client, 4)).toBe("SELECT current_setting('pg_stat_statements.max') AS max");
-    });
-    it('rejects PostgreSQL versions older than 14 without probing the extension', async () => {
-        const client = queryClient([
-            {
-                headers: ['server_version_num', 'server_version'],
-                rows: [[130012, 'PostgreSQL 13.12']],
-            },
-        ]);
-        const reader = new PostgresPgssReader();
-        const promise = reader.probe(client);
-        await expect(promise).rejects.toMatchObject({
-            name: 'HistoricSqlVersionUnsupportedError',
-            dialect: 'postgres',
-            detectedVersion: 'PostgreSQL 13.12',
-            minimumVersion: 'PostgreSQL 14',
-        });
-        await expect(promise).rejects.toBeInstanceOf(HistoricSqlVersionUnsupportedError);
-        expect(client.executeQuery).toHaveBeenCalledTimes(1);
-    });
-    it('maps a missing pg_stat_statements relation to HistoricSqlExtensionMissingError', async () => {
-        const client = queryClient([
-            {
-                headers: ['server_version_num', 'server_version'],
-                rows: [[160004, 'PostgreSQL 16.4']],
-            },
-            new Error('relation "pg_stat_statements" does not exist'),
-        ]);
-        const reader = new PostgresPgssReader();
-        const promise = reader.probe(client);
-        await expect(promise).rejects.toMatchObject({
-            name: 'HistoricSqlExtensionMissingError',
-            dialect: 'postgres',
-        });
-        await expect(promise).rejects.toBeInstanceOf(HistoricSqlExtensionMissingError);
-    });
-    it('maps pg_stat_statements preload failures to HistoricSqlExtensionMissingError with preload remediation', async () => {
-        const client = queryClient([
-            {
-                headers: ['server_version_num', 'server_version'],
-                rows: [[160004, 'PostgreSQL 16.4']],
-            },
-            new Error('pg_stat_statements must be loaded via shared_preload_libraries'),
-        ]);
-        const reader = new PostgresPgssReader();
-        const promise = reader.probe(client);
-        await expect(promise).rejects.toMatchObject({
-            name: 'HistoricSqlExtensionMissingError',
-            dialect: 'postgres',
-            message: 'pg_stat_statements is installed but not loaded via shared_preload_libraries.',
-            remediation: expect.stringContaining("shared_preload_libraries includes 'pg_stat_statements'"),
-        });
-        await expect(promise).rejects.toBeInstanceOf(HistoricSqlExtensionMissingError);
-    });
-    it('maps missing pg_read_all_stats membership to HistoricSqlGrantsMissingError', async () => {
-        const client = queryClient([
-            {
-                headers: ['server_version_num', 'server_version'],
-                rows: [[160004, 'PostgreSQL 16.4']],
-            },
-            { headers: ['?column?'], rows: [[1]] },
-            { headers: ['has_role'], rows: [[false]] },
-        ]);
-        const reader = new PostgresPgssReader();
-        const promise = reader.probe(client);
-        await expect(promise).rejects.toMatchObject({
-            name: 'HistoricSqlGrantsMissingError',
-            dialect: 'postgres',
-            remediation: 'GRANT pg_read_all_stats TO <connection role>;',
-        });
-        await expect(promise).rejects.toBeInstanceOf(HistoricSqlGrantsMissingError);
-    });
-    it('returns a warning instead of failing when pg_stat_statements.track is none', async () => {
-        const client = queryClient([
-            {
-                headers: ['server_version_num', 'server_version'],
-                rows: [[160004, 'PostgreSQL 16.4']],
-            },
-            { headers: ['?column?'], rows: [[1]] },
-            { headers: ['has_role'], rows: [[true]] },
-            { headers: ['track'], rows: [['none']] },
-            { headers: ['max'], rows: [['5000']] },
-        ]);
-        const reader = new PostgresPgssReader();
-        await expect(reader.probe(client)).resolves.toEqual({
-            pgServerVersion: 'PostgreSQL 16.4',
-            warnings: [
-                "pg_stat_statements.track is none; set it to top or all in the Postgres parameter group or config",
-            ],
-            info: [],
-        });
-    });
-    it('returns an info note when pg_stat_statements.max is below the recommended floor', async () => {
-        const client = queryClient([
-            {
-                headers: ['server_version_num', 'server_version'],
-                rows: [[160004, 'PostgreSQL 16.4']],
-            },
-            { headers: ['?column?'], rows: [[1]] },
-            { headers: ['has_role'], rows: [[true]] },
-            { headers: ['track'], rows: [['top']] },
-            { headers: ['max'], rows: [['1000']] },
-        ]);
-        const reader = new PostgresPgssReader();
-        await expect(reader.probe(client)).resolves.toEqual({
-            pgServerVersion: 'PostgreSQL 16.4',
-            warnings: [],
-            info: [
-                'pg_stat_statements.max is 1000; set it to at least 5000 to reduce query-template eviction churn',
-            ],
-        });
-    });
-    it('aggregates pg_stat_statements rows by queryid and query', async () => {
-        const executeQuery = vi.fn(async (sql, params) => {
-            if (sql.includes('pg_stat_statements_info')) {
-                return { headers: ['stats_reset', 'dealloc'], rows: [['2026-05-01T00:00:00.000Z', 1]] };
-            }
-            expect(sql).toContain('GROUP BY queryid, query');
-            expect(sql).toContain('HAVING SUM(calls) >= $1');
-            expect(params).toEqual([5]);
-            return {
-                headers: ['template_id', 'canonical_sql', 'executions', 'distinct_users', 'mean_ms', 'rows_produced', 'top_users'],
-                rows: [
-                    [
-                        '123',
-                        'select status from public.orders',
-                        '42',
-                        '3',
-                        '11.5',
-                        '100',
-                        JSON.stringify([{ user: 'analyst', executions: 40 }]),
-                    ],
-                ],
-            };
-        });
-        const reader = new PostgresPgssReader();
-        const rows = [];
-        for await (const row of reader.fetchAggregated({ executeQuery }, { start: new Date('2026-02-10T00:00:00.000Z'), end: new Date('2026-05-11T00:00:00.000Z') }, { dialect: 'postgres', minExecutions: 5, enabledTables: [], filters: { dropTrivialProbes: true }, redactionPatterns: [], staleArchiveAfterDays: 90 })) {
-            rows.push(row);
-        }
-        expect(rows).toEqual([
-            {
-                templateId: '123',
-                canonicalSql: 'select status from public.orders',
-                dialect: 'postgres',
-                stats: {
-                    executions: 42,
-                    distinctUsers: 3,
-                    firstSeen: '2026-05-01T00:00:00.000Z',
-                    lastSeen: '2026-05-11T00:00:00.000Z',
-                    p50RuntimeMs: 11.5,
-                    p95RuntimeMs: 11.5,
-                    errorRate: 0,
-                    rowsProduced: 100,
-                },
-                topUsers: [{ user: 'analyst', executions: 40 }],
-            },
-        ]);
-    });
-});

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

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