@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/context/dist/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/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/postgres-pgss-reader.test.d.ts

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

package/node_modules/@ktx/context/dist/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/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/projection.d.ts

@@ -1,24 +0,0 @@
-import type { MemoryAction } from '../../../memory/index.js';
-import type { FinalizationOverrideReplay } from '../../types.js';
-export interface HistoricSqlProjectionInput {
-    workdir: string;
-    connectionId: string;
-    syncId: string;
-    runId: string;
-    overrideReplay?: FinalizationOverrideReplay;
-}
-export interface HistoricSqlProjectionResult {
-    tableUsageMerged: number;
-    staleTablesMarked: number;
-    patternPagesWritten: number;
-    stalePatternPagesMarked: number;
-    archivedPatternPages: number;
-    touchedSources: Array<{
-        connectionId: string;
-        sourceName: string;
-    }>;
-    changedWikiPageKeys: string[];
-    actions: MemoryAction[];
-    warnings: string[];
-}
-export declare function projectHistoricSqlEvidence(input: HistoricSqlProjectionInput): Promise<HistoricSqlProjectionResult>;

package/node_modules/@ktx/context/dist/ingest/adapters/historic-sql/projection.js

@@ -1,320 +0,0 @@
-import { access, mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises';
-import { dirname, join, relative } from 'node:path';
-import YAML from 'yaml';
-import { rawSourcesDirForSync } from '../../raw-sources-paths.js';
-import { mergeUsagePreservingExternal } from '../live-database/manifest.js';
-import { historicSqlEvidenceEnvelopeSchema } from './evidence.js';
-import { stagedManifestSchema } from './types.js';
-function safeKnowledgeSlug(value) {
-    return value.toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
-}
-async function pathExists(path) {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function walkFiles(root) {
-    if (!(await pathExists(root)))
-        return [];
-    const result = [];
-    async function visit(dir) {
-        const entries = await readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const absolute = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                await visit(absolute);
-            }
-            else if (entry.isFile()) {
-                result.push(relative(root, absolute).replace(/\\/g, '/'));
-            }
-        }
-    }
-    await visit(root);
-    return result.sort();
-}
-async function readJson(path) {
-    return JSON.parse(await readFile(path, 'utf-8'));
-}
-async function writeYamlAtomic(path, value) {
-    await mkdir(dirname(path), { recursive: true });
-    const tmp = `${path}.tmp`;
-    await writeFile(tmp, YAML.stringify(value, { indent: 2, lineWidth: 0, version: '1.1' }), 'utf-8');
-    await rename(tmp, path);
-}
-function tableSourceName(tableRef) {
-    return tableRef.split('.').filter(Boolean).at(-1) ?? tableRef;
-}
-function staleUsage(fetchedAt) {
-    return {
-        narrative: 'No recent historic SQL usage was observed in the latest snapshot.',
-        frequencyTier: 'unused',
-        commonFilters: [],
-        commonGroupBys: [],
-        commonJoins: [],
-        staleSince: fetchedAt,
-    };
-}
-async function loadEvidence(workdir, runId) {
-    const root = join(workdir, '.ktx/ingest-evidence/historic-sql', runId);
-    const files = await walkFiles(root);
-    const evidence = [];
-    for (const file of files.filter((candidate) => candidate.endsWith('.json'))) {
-        evidence.push(historicSqlEvidenceEnvelopeSchema.parse(await readJson(join(root, file))));
-    }
-    return evidence;
-}
-function renderPatternMarkdown(pattern) {
-    return [
-        `# ${pattern.pattern.title}`,
-        '',
-        pattern.pattern.narrative,
-        '',
-        '## Representative SQL',
-        '',
-        '```sql',
-        pattern.pattern.definitionSql,
-        '```',
-        '',
-        '## Tables',
-        '',
-        ...pattern.pattern.tablesInvolved.map((table) => `- ${table}`),
-        '',
-        '## Constituent Templates',
-        '',
-        ...pattern.pattern.constituentTemplateIds.map((id) => `- ${id}`),
-        '',
-    ].join('\n');
-}
-function overlapRatio(left, right) {
-    const rightSet = new Set(right);
-    const intersection = left.filter((value) => rightSet.has(value)).length;
-    return left.length === 0 ? 0 : intersection / left.length;
-}
-function parseMarkdownPage(key, path, raw) {
-    const match = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-    if (!match)
-        return null;
-    return {
-        key,
-        path,
-        frontmatter: (YAML.parse(match[1] ?? '') ?? {}),
-        content: match[2] ?? '',
-    };
-}
-function isHistoricPatternPage(page) {
-    const tags = Array.isArray(page.frontmatter.tags) ? page.frontmatter.tags : [];
-    return (page.frontmatter.source === 'historic-sql' &&
-        tags.includes('historic-sql') &&
-        tags.includes('pattern'));
-}
-function isArchivedPatternPage(page) {
-    const tags = Array.isArray(page.frontmatter.tags) ? page.frontmatter.tags : [];
-    return tags.includes('archived');
-}
-function stringArray(value) {
-    return Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : [];
-}
-function renderMarkdownPage(frontmatter, content) {
-    let yaml = YAML.stringify(frontmatter, { indent: 2, lineWidth: 0 }).trimEnd();
-    const staleSince = frontmatter.stale_since;
-    if (typeof staleSince === 'string') {
-        yaml = yaml.replace(`stale_since: ${staleSince}`, `stale_since: "${staleSince}"`);
-    }
-    return `---\n${yaml}\n---\n\n${content.trim()}\n`;
-}
-function existingPageSignals(page) {
-    return [...stringArray(page.frontmatter.tables), ...stringArray(page.frontmatter.fingerprints)];
-}
-function shouldArchive(staleSince, fetchedAt, days) {
-    if (typeof staleSince !== 'string')
-        return false;
-    const staleTime = Date.parse(staleSince);
-    const fetchedTime = Date.parse(fetchedAt);
-    if (!Number.isFinite(staleTime) || !Number.isFinite(fetchedTime))
-        return false;
-    return fetchedTime - staleTime > days * 24 * 60 * 60 * 1000;
-}
-async function loadPatternPages(root) {
-    const files = await walkFiles(root);
-    const pages = [];
-    for (const file of files.filter((candidate) => candidate.endsWith('.md'))) {
-        if (file.includes('/')) {
-            continue;
-        }
-        const key = file.replace(/\.md$/, '');
-        const path = join(root, file);
-        const page = parseMarkdownPage(key, path, await readFile(path, 'utf-8'));
-        if (page) {
-            pages.push(page);
-        }
-    }
-    return pages;
-}
-function historicSqlFlatKey(slug) {
-    return `historic-sql-${safeKnowledgeSlug(slug)}`;
-}
-async function currentStagedTables(rawDir) {
-    const tablesRoot = join(rawDir, 'tables');
-    const files = await walkFiles(tablesRoot);
-    const tables = new Set();
-    for (const file of files.filter((candidate) => candidate.endsWith('.json'))) {
-        const value = await readJson(join(tablesRoot, file));
-        if (typeof value === 'object' && value !== null && 'table' in value && typeof value.table === 'string') {
-            tables.add(value.table);
-        }
-    }
-    return tables;
-}
-export async function projectHistoricSqlEvidence(input) {
-    const result = {
-        tableUsageMerged: 0,
-        staleTablesMarked: 0,
-        patternPagesWritten: 0,
-        stalePatternPagesMarked: 0,
-        archivedPatternPages: 0,
-        touchedSources: [],
-        changedWikiPageKeys: [],
-        actions: [],
-        warnings: [],
-    };
-    const touchedKeys = new Set();
-    const rawDir = join(input.workdir, rawSourcesDirForSync(input.connectionId, 'historic-sql', input.syncId));
-    const manifest = stagedManifestSchema.parse(await readJson(join(rawDir, 'manifest.json')));
-    const currentTables = await currentStagedTables(rawDir);
-    const evidence = await loadEvidence(input.workdir, input.runId);
-    if (input.overrideReplay && evidence.length === 0) {
-        result.warnings.push('historic-sql finalization skipped stale/archive cleanup during override replay without current-run evidence');
-        return result;
-    }
-    if (evidence.length === 0) {
-        result.warnings.push('historic-sql finalization skipped because no current-run evidence was emitted');
-        return result;
-    }
-    const tableEvidence = evidence.filter((entry) => entry.kind === 'table_usage');
-    const patternEvidence = evidence.filter((entry) => entry.kind === 'pattern');
-    const schemaRoot = join(input.workdir, 'semantic-layer', input.connectionId, '_schema');
-    for (const file of (await walkFiles(schemaRoot)).filter((candidate) => candidate.endsWith('.yaml') || candidate.endsWith('.yml'))) {
-        const path = join(schemaRoot, file);
-        const before = await readFile(path, 'utf-8');
-        const shard = (YAML.parse(before) ?? {});
-        if (!shard.tables)
-            continue;
-        for (const [tableName, entry] of Object.entries(shard.tables)) {
-            const tableRef = entry.table ?? tableName;
-            const matchingEvidence = tableEvidence.find((candidate) => candidate.table === tableRef || tableSourceName(candidate.table) === tableName);
-            if (matchingEvidence) {
-                const merged = mergeUsagePreservingExternal(entry.usage, matchingEvidence.usage);
-                if (JSON.stringify(entry.usage ?? null) !== JSON.stringify(merged ?? null)) {
-                    entry.usage = merged;
-                    result.tableUsageMerged += 1;
-                    const sourceName = tableSourceName(matchingEvidence.table);
-                    const key = `${input.connectionId}:${sourceName}`;
-                    if (!touchedKeys.has(key)) {
-                        touchedKeys.add(key);
-                        result.touchedSources.push({ connectionId: input.connectionId, sourceName });
-                    }
-                    result.actions.push({
-                        target: 'sl',
-                        type: 'updated',
-                        key: sourceName,
-                        targetConnectionId: input.connectionId,
-                        detail: `Merged historic-SQL usage for ${matchingEvidence.table}`,
-                        rawPaths: [matchingEvidence.rawPath],
-                    });
-                }
-            }
-            else if (entry.usage && !currentTables.has(tableRef)) {
-                const merged = mergeUsagePreservingExternal(entry.usage, staleUsage(manifest.fetchedAt));
-                if (JSON.stringify(entry.usage ?? null) !== JSON.stringify(merged ?? null)) {
-                    entry.usage = merged;
-                    result.staleTablesMarked += 1;
-                    const sourceName = tableSourceName(tableRef);
-                    const key = `${input.connectionId}:${sourceName}`;
-                    if (!touchedKeys.has(key)) {
-                        touchedKeys.add(key);
-                        result.touchedSources.push({ connectionId: input.connectionId, sourceName });
-                    }
-                    result.actions.push({
-                        target: 'sl',
-                        type: 'updated',
-                        key: sourceName,
-                        targetConnectionId: input.connectionId,
-                        detail: `Marked historic-SQL usage stale for ${tableRef}`,
-                    });
-                }
-            }
-        }
-        const after = YAML.stringify(shard, { indent: 2, lineWidth: 0, version: '1.1' });
-        if (after !== before) {
-            await writeYamlAtomic(path, shard);
-        }
-    }
-    const wikiRoot = join(input.workdir, 'wiki/global');
-    await mkdir(wikiRoot, { recursive: true });
-    const allPages = await loadPatternPages(wikiRoot);
-    const activePages = allPages.filter((page) => !isArchivedPatternPage(page));
-    const patternPages = activePages.filter(isHistoricPatternPage);
-    const writtenKeys = new Set();
-    for (const pattern of patternEvidence) {
-        const incomingSignals = [...pattern.pattern.tablesInvolved, ...pattern.pattern.constituentTemplateIds];
-        const reusable = patternPages.find((page) => overlapRatio(incomingSignals, existingPageSignals(page)) >= 0.6);
-        const key = reusable?.key ?? historicSqlFlatKey(pattern.pattern.slug);
-        const pagePath = join(wikiRoot, `${key}.md`);
-        const frontmatter = {
-            summary: pattern.pattern.title,
-            tags: ['historic-sql', 'pattern'],
-            refs: [],
-            sl_refs: pattern.pattern.slRefs,
-            usage_mode: 'auto',
-            source: 'historic-sql',
-            tables: pattern.pattern.tablesInvolved,
-            representative_sql: pattern.pattern.definitionSql,
-            fingerprints: pattern.pattern.constituentTemplateIds,
-        };
-        await mkdir(dirname(pagePath), { recursive: true });
-        await writeFile(pagePath, renderMarkdownPage(frontmatter, renderPatternMarkdown(pattern)), 'utf-8');
-        writtenKeys.add(key);
-        result.patternPagesWritten += 1;
-        result.changedWikiPageKeys.push(key);
-        result.actions.push({
-            target: 'wiki',
-            type: reusable ? 'updated' : 'created',
-            key,
-            detail: `Projected historic-SQL pattern ${pattern.pattern.title}`,
-            rawPaths: [pattern.rawPath],
-        });
-    }
-    for (const page of patternPages) {
-        if (writtenKeys.has(page.key))
-            continue;
-        if (shouldArchive(page.frontmatter.stale_since, manifest.fetchedAt, manifest.staleArchiveAfterDays)) {
-            const tags = [...new Set([...stringArray(page.frontmatter.tags), 'archived'])];
-            await writeFile(page.path, renderMarkdownPage({ ...page.frontmatter, tags, archived_since: manifest.fetchedAt }, page.content), 'utf-8');
-            result.archivedPatternPages += 1;
-            result.changedWikiPageKeys.push(page.key);
-            result.actions.push({
-                target: 'wiki',
-                type: 'updated',
-                key: page.key,
-                detail: `Archived stale historic-SQL pattern page ${page.key}`,
-            });
-            continue;
-        }
-        const tags = [...new Set([...stringArray(page.frontmatter.tags), 'stale'])];
-        await writeFile(page.path, renderMarkdownPage({ ...page.frontmatter, tags, stale_since: manifest.fetchedAt }, page.content), 'utf-8');
-        result.stalePatternPagesMarked += 1;
-        result.changedWikiPageKeys.push(page.key);
-        result.actions.push({
-            target: 'wiki',
-            type: 'updated',
-            key: page.key,
-            detail: `Marked historic-SQL pattern page ${page.key} stale`,
-        });
-    }
-    result.changedWikiPageKeys = [...new Set(result.changedWikiPageKeys)].sort();
-    return result;
-}

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

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