@kaelio/ktx 0.4.1 → 0.6.0

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

@@ -0,0 +1,323 @@
+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.rawPaths,
+                    });
+                }
+            }
+            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}`,
+                        rawPaths: ['manifest.json'],
+                    });
+                }
+            }
+        }
+        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.rawPaths,
+        });
+    }
+    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}`,
+                rawPaths: ['manifest.json'],
+            });
+            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`,
+            rawPaths: ['manifest.json'],
+        });
+    }
+    result.changedWikiPageKeys = [...new Set(result.changedWikiPageKeys)].sort();
+    return result;
+}

package/dist/context/ingest/adapters/historic-sql/skill-schemas.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const tableUsageOutputSchema: z.ZodObject<{
+    narrative: z.ZodString;
+    frequencyTier: z.ZodEnum<{
+        high: "high";
+        mid: "mid";
+        low: "low";
+        unused: "unused";
+    }>;
+    commonFilters: z.ZodArray<z.ZodString>;
+    commonGroupBys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    commonJoins: z.ZodArray<z.ZodObject<{
+        table: z.ZodString;
+        on: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    staleSince: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+}, z.core.$loose>;
+export type TableUsageOutput = z.infer<typeof tableUsageOutputSchema>;
+export declare const patternOutputSchema: z.ZodObject<{
+    slug: z.ZodString;
+    title: z.ZodString;
+    narrative: z.ZodString;
+    definitionSql: z.ZodString;
+    tablesInvolved: z.ZodArray<z.ZodString>;
+    slRefs: z.ZodArray<z.ZodString>;
+    constituentTemplateIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** @internal */
+export declare const patternsArraySchema: z.ZodArray<z.ZodObject<{
+    slug: z.ZodString;
+    title: z.ZodString;
+    narrative: z.ZodString;
+    definitionSql: z.ZodString;
+    tablesInvolved: z.ZodArray<z.ZodString>;
+    slRefs: z.ZodArray<z.ZodString>;
+    constituentTemplateIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>>;

package/dist/context/ingest/adapters/historic-sql/skill-schemas.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export const tableUsageOutputSchema = z
+    .object({
+    narrative: z.string(),
+    frequencyTier: z.enum(['high', 'mid', 'low', 'unused']),
+    commonFilters: z.array(z.string()),
+    commonGroupBys: z.array(z.string()).optional(),
+    commonJoins: z.array(z.object({
+        table: z.string(),
+        on: z.array(z.string()),
+    })),
+    staleSince: z.iso.datetime().nullable().optional(),
+})
+    .passthrough();
+export const patternOutputSchema = z.object({
+    slug: z.string(),
+    title: z.string(),
+    narrative: z.string(),
+    definitionSql: z.string(),
+    tablesInvolved: z.array(z.string()),
+    slRefs: z.array(z.string()),
+    constituentTemplateIds: z.array(z.string()),
+});
+/** @internal */
+export const patternsArraySchema = z.array(patternOutputSchema);

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

@@ -0,0 +1,13 @@
+import type { SqlAnalysisPort } from '../../../../context/sql-analysis/ports.js';
+import { type HistoricSqlReader } from './types.js';
+interface StageHistoricSqlAggregatedSnapshotInput {
+    stagedDir: string;
+    connectionId: string;
+    queryClient: unknown;
+    reader: HistoricSqlReader;
+    sqlAnalysis: SqlAnalysisPort;
+    pullConfig: unknown;
+    now?: Date;
+}
+export declare function stageHistoricSqlAggregatedSnapshot(input: StageHistoricSqlAggregatedSnapshotInput): Promise<void>;
+export {};

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

@@ -0,0 +1,183 @@
+import { z } from 'zod';
+import type { SqlAnalysisPort } from '../../../../context/sql-analysis/ports.js';
+export declare const HISTORIC_SQL_SOURCE_KEY: "historic-sql";
+declare const historicSqlDialectSchema: z.ZodEnum<{
+    postgres: "postgres";
+    bigquery: "bigquery";
+    snowflake: "snowflake";
+}>;
+export type HistoricSqlDialect = z.infer<typeof historicSqlDialectSchema>;
+export declare const historicSqlUnifiedPullConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    minExecutions: z.ZodDefault<z.ZodNumber>;
+    enabledTables: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    filters: z.ZodDefault<z.ZodObject<{
+        serviceAccounts: z.ZodOptional<z.ZodObject<{
+            patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            mode: z.ZodDefault<z.ZodEnum<{
+                exclude: "exclude";
+                include: "include";
+                "mark-only": "mark-only";
+            }>>;
+        }, z.core.$strip>>;
+        orchestrators: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                exclude: "exclude";
+                include: "include";
+                "mark-only": "mark-only";
+            }>>;
+        }, z.core.$strip>>;
+        dropTrivialProbes: z.ZodDefault<z.ZodBoolean>;
+        dropFailedBelow: z.ZodOptional<z.ZodObject<{
+            errorRate: z.ZodNumber;
+            executions: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    redactionPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    staleArchiveAfterDays: z.ZodDefault<z.ZodNumber>;
+    dialect: z.ZodEnum<{
+        bigquery: "bigquery";
+        snowflake: "snowflake";
+    }>;
+    windowDays: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    minExecutions: z.ZodDefault<z.ZodNumber>;
+    enabledTables: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    filters: z.ZodDefault<z.ZodObject<{
+        serviceAccounts: z.ZodOptional<z.ZodObject<{
+            patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            mode: z.ZodDefault<z.ZodEnum<{
+                exclude: "exclude";
+                include: "include";
+                "mark-only": "mark-only";
+            }>>;
+        }, z.core.$strip>>;
+        orchestrators: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                exclude: "exclude";
+                include: "include";
+                "mark-only": "mark-only";
+            }>>;
+        }, z.core.$strip>>;
+        dropTrivialProbes: z.ZodDefault<z.ZodBoolean>;
+        dropFailedBelow: z.ZodOptional<z.ZodObject<{
+            errorRate: z.ZodNumber;
+            executions: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    redactionPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    staleArchiveAfterDays: z.ZodDefault<z.ZodNumber>;
+    dialect: z.ZodLiteral<"postgres">;
+}, z.core.$strip>], "dialect">;
+export type HistoricSqlUnifiedPullConfig = z.infer<typeof historicSqlUnifiedPullConfigSchema>;
+export declare const aggregatedTemplateSchema: z.ZodObject<{
+    templateId: z.ZodString;
+    canonicalSql: z.ZodString;
+    dialect: z.ZodEnum<{
+        postgres: "postgres";
+        bigquery: "bigquery";
+        snowflake: "snowflake";
+    }>;
+    stats: z.ZodObject<{
+        executions: z.ZodNumber;
+        distinctUsers: z.ZodNumber;
+        firstSeen: z.ZodISODateTime;
+        lastSeen: z.ZodISODateTime;
+        p50RuntimeMs: z.ZodNullable<z.ZodNumber>;
+        p95RuntimeMs: z.ZodNullable<z.ZodNumber>;
+        errorRate: z.ZodNumber;
+        rowsProduced: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    topUsers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        user: z.ZodNullable<z.ZodString>;
+        executions: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type AggregatedTemplate = z.infer<typeof aggregatedTemplateSchema>;
+export declare const stagedTableInputSchema: z.ZodObject<{
+    table: z.ZodString;
+    stats: z.ZodObject<{
+        executionsBucket: z.ZodString;
+        distinctUsersBucket: z.ZodString;
+        errorRateBucket: z.ZodString;
+        p95RuntimeBucket: z.ZodString;
+        recencyBucket: z.ZodString;
+    }, z.core.$strip>;
+    columnsByClause: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>>;
+    observedJoins: z.ZodArray<z.ZodObject<{
+        withTable: z.ZodString;
+        on: z.ZodArray<z.ZodString>;
+        freq: z.ZodString;
+    }, z.core.$strip>>;
+    topTemplates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        canonicalSql: z.ZodString;
+        topUsers: z.ZodArray<z.ZodObject<{
+            user: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StagedTableInput = z.infer<typeof stagedTableInputSchema>;
+export declare const stagedPatternsInputSchema: z.ZodObject<{
+    templates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        canonicalSql: z.ZodString;
+        tablesTouched: z.ZodArray<z.ZodString>;
+        executionsBucket: z.ZodString;
+        distinctUsersBucket: z.ZodString;
+        dialect: z.ZodEnum<{
+            postgres: "postgres";
+            bigquery: "bigquery";
+            snowflake: "snowflake";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StagedPatternsInput = z.infer<typeof stagedPatternsInputSchema>;
+export declare const stagedManifestSchema: z.ZodObject<{
+    source: z.ZodLiteral<"historic-sql">;
+    connectionId: z.ZodString;
+    dialect: z.ZodEnum<{
+        postgres: "postgres";
+        bigquery: "bigquery";
+        snowflake: "snowflake";
+    }>;
+    fetchedAt: z.ZodISODateTime;
+    windowStart: z.ZodISODateTime;
+    windowEnd: z.ZodISODateTime;
+    snapshotRowCount: z.ZodNumber;
+    touchedTableCount: z.ZodNumber;
+    parseFailures: z.ZodNumber;
+    warnings: z.ZodArray<z.ZodString>;
+    probeWarnings: z.ZodArray<z.ZodString>;
+    staleArchiveAfterDays: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+interface HistoricSqlProbeResult {
+    warnings: string[];
+    info?: string[];
+}
+export interface HistoricSqlReader {
+    probe(client: unknown): Promise<HistoricSqlProbeResult>;
+    fetchAggregated(client: unknown, window: HistoricSqlTimeWindow, config: HistoricSqlUnifiedPullConfig): AsyncIterable<AggregatedTemplate>;
+}
+export interface HistoricSqlTimeWindow {
+    start: Date;
+    end: Date;
+}
+export interface KtxPostgresQueryClient {
+    executeQuery(sql: string, params?: unknown[]): Promise<{
+        headers: string[];
+        rows: unknown[][];
+        totalRows?: number;
+    }>;
+}
+export interface PostgresPgssProbeResult extends HistoricSqlProbeResult {
+    pgServerVersion: string;
+    warnings: string[];
+    info: string[];
+}
+export interface HistoricSqlSourceAdapterDeps {
+    sqlAnalysis: SqlAnalysisPort;
+    reader: HistoricSqlReader;
+    queryClient: unknown;
+    now?: () => Date;
+}
+export {};

package/dist/context/ingest/adapters/live-database/daemon-introspection.d.ts

@@ -0,0 +1,21 @@
+import type { KtxProjectConnectionConfig } from '../../../project/config.js';
+import type { LiveDatabaseIntrospectionPort } from './types.js';
+type KtxDaemonDatabaseIntrospectionCommand = 'database-introspect';
+type KtxDaemonDatabaseJsonRunner = (subcommand: KtxDaemonDatabaseIntrospectionCommand, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
+export type KtxDaemonDatabaseHttpJsonRunner = (path: string, payload: Record<string, unknown>) => Promise<Record<string, unknown>>;
+export interface DaemonLiveDatabaseIntrospectionOptions {
+    connections: Record<string, KtxProjectConnectionConfig>;
+    schemas?: string[];
+    statementTimeoutMs?: number;
+    connectionTimeoutSeconds?: number;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    baseUrl?: string;
+    runJson?: KtxDaemonDatabaseJsonRunner;
+    requestJson?: KtxDaemonDatabaseHttpJsonRunner;
+    now?: () => Date;
+}
+export declare function createDaemonLiveDatabaseIntrospection(options: DaemonLiveDatabaseIntrospectionOptions): LiveDatabaseIntrospectionPort;
+export {};