@kaelio/ktx 0.0.0 → 0.1.0-rc.1

package/node_modules/@ktx/context/dist/scan/entity-details.js

@@ -0,0 +1,216 @@
+import { readLocalScanStructuralSnapshot } from './local-structural-artifacts.js';
+function normalize(value) {
+    return (value ?? '').toLowerCase();
+}
+function refsEqual(left, right) {
+    return (normalize(left.catalog) === normalize(right.catalog) &&
+        normalize(left.db) === normalize(right.db) &&
+        normalize(left.name) === normalize(right.name));
+}
+function cleanIdentifierPart(part) {
+    return part.trim().replace(/^["'`\[]|["'`\]]$/g, '');
+}
+function splitDisplay(display) {
+    return display
+        .trim()
+        .split('.')
+        .map(cleanIdentifierPart)
+        .filter(Boolean);
+}
+function displayForTable(driver, table) {
+    if (driver === 'sqlite') {
+        return table.name;
+    }
+    return [table.catalog, table.db, table.name].filter((part) => Boolean(part)).join('.');
+}
+function tableRef(table) {
+    return { catalog: table.catalog, db: table.db, name: table.name };
+}
+function candidateList(driver, tables) {
+    return tables
+        .map((table) => ({
+        tableRef: tableRef(table),
+        display: displayForTable(driver, table),
+    }))
+        .sort((left, right) => left.display.localeCompare(right.display));
+}
+function parseDisplayRef(driver, display) {
+    const parts = splitDisplay(display);
+    if (driver === 'sqlite') {
+        return parts.length === 1 ? { catalog: null, db: null, name: parts[0] } : null;
+    }
+    if (driver === 'bigquery' || driver === 'snowflake' || driver === 'sqlserver') {
+        return parts.length === 3 ? { catalog: parts[0], db: parts[1], name: parts[2] } : null;
+    }
+    if (parts.length === 2) {
+        return { catalog: null, db: parts[0], name: parts[1] };
+    }
+    if (parts.length === 3) {
+        return { catalog: parts[0], db: parts[1], name: parts[2] };
+    }
+    return null;
+}
+function resolveTable(snapshot, input) {
+    if (typeof input !== 'string') {
+        const table = snapshot.tables.find((candidate) => refsEqual(candidate, input)) ?? null;
+        return table
+            ? { table }
+            : {
+                table: null,
+                error: {
+                    code: 'table_not_found',
+                    message: `Table not found in latest scan: ${displayForTable(snapshot.driver, input)}`,
+                    candidates: candidateList(snapshot.driver, snapshot.tables),
+                },
+            };
+    }
+    const parsed = parseDisplayRef(snapshot.driver, input);
+    if (parsed) {
+        const table = snapshot.tables.find((candidate) => refsEqual(candidate, parsed)) ?? null;
+        return table
+            ? { table }
+            : {
+                table: null,
+                error: {
+                    code: 'table_not_found',
+                    message: `Table not found in latest scan: ${input}`,
+                    candidates: candidateList(snapshot.driver, snapshot.tables),
+                },
+            };
+    }
+    const byName = snapshot.tables.filter((candidate) => normalize(candidate.name) === normalize(input));
+    if (byName.length === 1) {
+        return { table: byName[0] };
+    }
+    if (byName.length > 1) {
+        return {
+            table: null,
+            error: {
+                code: 'ambiguous_table',
+                message: `Table name "${input}" is ambiguous across schemas/catalogs; pass a structured table ref.`,
+                candidates: candidateList(snapshot.driver, byName),
+            },
+        };
+    }
+    return {
+        table: null,
+        error: {
+            code: 'table_not_found',
+            message: `Table not found in latest scan: ${input}`,
+            candidates: candidateList(snapshot.driver, snapshot.tables),
+        },
+    };
+}
+function toColumn(column) {
+    return {
+        name: column.name,
+        nativeType: column.nativeType,
+        normalizedType: column.normalizedType,
+        dimensionType: column.dimensionType,
+        nullable: column.nullable,
+        primaryKey: column.primaryKey,
+        comment: column.comment,
+    };
+}
+function snapshotInfo(report, snapshot) {
+    return {
+        syncId: report.syncId,
+        extractedAt: snapshot.extractedAt,
+        scanRunId: report.runId ?? null,
+    };
+}
+async function readJson(project, path) {
+    return JSON.parse((await project.fileStore.readFile(path)).content);
+}
+async function latestScan(project, connectionId) {
+    const root = `raw-sources/${connectionId}/live-database`;
+    let listed;
+    try {
+        listed = await project.fileStore.listFiles(root);
+    }
+    catch {
+        return null;
+    }
+    const reportPath = listed.files.filter((path) => path.endsWith('/scan-report.json')).sort().at(-1);
+    if (!reportPath) {
+        return null;
+    }
+    const report = await readJson(project, reportPath);
+    const rawSourcesDir = report.artifactPaths.rawSourcesDir ?? reportPath.slice(0, -'/scan-report.json'.length);
+    const snapshot = await readLocalScanStructuralSnapshot({
+        project,
+        connectionId,
+        driver: report.driver,
+        rawSourcesDir,
+        extractedAtFallback: report.createdAt,
+    });
+    return { report, snapshot };
+}
+export function createKtxEntityDetailsService(project) {
+    return {
+        async read(input) {
+            const scan = await latestScan(project, input.connectionId);
+            if (!scan) {
+                return {
+                    results: input.entities.map((entity) => ({
+                        ok: false,
+                        connectionId: input.connectionId,
+                        table: entity.table,
+                        error: {
+                            code: 'scan_missing',
+                            message: `No live-database scan found for connection "${input.connectionId}"; run \`ktx ingest ${input.connectionId}\` or \`ktx scan ${input.connectionId}\`.`,
+                        },
+                    })),
+                };
+            }
+            const info = snapshotInfo(scan.report, scan.snapshot);
+            const results = [];
+            for (const entity of input.entities) {
+                const resolved = resolveTable(scan.snapshot, entity.table);
+                if (!resolved.table) {
+                    results.push({
+                        ok: false,
+                        connectionId: input.connectionId,
+                        table: entity.table,
+                        snapshot: info,
+                        error: resolved.error,
+                    });
+                    continue;
+                }
+                const requested = new Set((entity.columns ?? []).map((column) => normalize(column)));
+                const columns = requested.size
+                    ? resolved.table.columns.filter((column) => requested.has(normalize(column.name)))
+                    : resolved.table.columns;
+                if (requested.size && columns.length !== requested.size) {
+                    const found = new Set(columns.map((column) => normalize(column.name)));
+                    const missing = [...requested].filter((column) => !found.has(column));
+                    results.push({
+                        ok: false,
+                        connectionId: input.connectionId,
+                        table: entity.table,
+                        snapshot: info,
+                        error: {
+                            code: 'column_not_found',
+                            message: `Column(s) not found on ${displayForTable(scan.snapshot.driver, resolved.table)}: ${missing.join(', ')}`,
+                            candidates: resolved.table.columns.map((column) => column.name),
+                        },
+                    });
+                    continue;
+                }
+                results.push({
+                    ok: true,
+                    connectionId: input.connectionId,
+                    tableRef: tableRef(resolved.table),
+                    display: displayForTable(scan.snapshot.driver, resolved.table),
+                    kind: resolved.table.kind,
+                    comment: resolved.table.comment,
+                    estimatedRows: resolved.table.estimatedRows,
+                    columns: columns.map(toColumn),
+                    foreignKeys: resolved.table.foreignKeys,
+                    snapshot: info,
+                });
+            }
+            return { results };
+        },
+    };
+}

package/node_modules/@ktx/context/dist/scan/entity-details.test.d.ts

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

package/node_modules/@ktx/context/dist/scan/entity-details.test.js

@@ -0,0 +1,234 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { initKtxProject } from '../project/index.js';
+import { createKtxEntityDetailsService } from './entity-details.js';
+describe('createKtxEntityDetailsService', () => {
+    let tempDir;
+    let project;
+    beforeEach(async () => {
+        tempDir = await mkdtemp(join(tmpdir(), 'ktx-entity-details-service-'));
+        project = await initKtxProject({ projectDir: join(tempDir, 'project') });
+    });
+    afterEach(async () => {
+        await rm(tempDir, { recursive: true, force: true });
+    });
+    function scanReport(input) {
+        const rawSourcesDir = `raw-sources/${input.connectionId}/live-database/${input.syncId}`;
+        return {
+            connectionId: input.connectionId,
+            driver: input.driver ?? 'postgres',
+            syncId: input.syncId,
+            runId: input.runId,
+            trigger: 'mcp',
+            mode: 'structural',
+            dryRun: false,
+            artifactPaths: {
+                rawSourcesDir,
+                reportPath: `${rawSourcesDir}/scan-report.json`,
+                manifestShards: [],
+                enrichmentArtifacts: [],
+            },
+            diffSummary: {
+                tablesAdded: 0,
+                tablesModified: 0,
+                tablesDeleted: 0,
+                tablesUnchanged: 1,
+                columnsAdded: 0,
+                columnsModified: 0,
+                columnsDeleted: 0,
+            },
+            manifestShardsWritten: 0,
+            structuralSyncStats: {
+                tablesCreated: 1,
+                tablesUpdated: 0,
+                tablesDeleted: 0,
+                columnsCreated: 0,
+                columnsUpdated: 0,
+                columnsDeleted: 0,
+            },
+            enrichment: {
+                dataDictionary: 'skipped',
+                tableDescriptions: 'skipped',
+                columnDescriptions: 'skipped',
+                embeddings: 'skipped',
+                deterministicRelationships: 'skipped',
+                llmRelationshipValidation: 'skipped',
+                statisticalValidation: 'skipped',
+            },
+            capabilityGaps: [],
+            warnings: [],
+            relationships: { accepted: 0, review: 0, rejected: 0, skipped: 0 },
+            enrichmentState: { resumedStages: [], completedStages: [], failedStages: [] },
+            createdAt: input.createdAt ?? '2026-05-14T09:00:00.000Z',
+        };
+    }
+    function ordersTable(input = {}) {
+        return {
+            catalog: null,
+            db: input.db ?? 'public',
+            name: 'orders',
+            kind: 'table',
+            comment: 'Customer orders',
+            estimatedRows: input.estimatedRows ?? 12,
+            columns: [
+                {
+                    name: 'id',
+                    nativeType: 'integer',
+                    normalizedType: 'integer',
+                    dimensionType: 'number',
+                    nullable: false,
+                    primaryKey: true,
+                    comment: 'Order id',
+                },
+                {
+                    name: 'status',
+                    nativeType: 'text',
+                    normalizedType: 'text',
+                    dimensionType: 'string',
+                    nullable: false,
+                    primaryKey: false,
+                    comment: 'Order status',
+                },
+            ],
+            foreignKeys: [
+                {
+                    fromColumn: 'customer_id',
+                    toCatalog: null,
+                    toDb: 'public',
+                    toTable: 'customers',
+                    toColumn: 'id',
+                    constraintName: 'orders_customer_id_fkey',
+                },
+            ],
+        };
+    }
+    async function seedScan(input) {
+        const connectionId = input.connectionId ?? 'warehouse';
+        const report = scanReport({
+            connectionId,
+            syncId: input.syncId,
+            runId: input.runId,
+            driver: input.driver,
+            createdAt: input.extractedAt,
+        });
+        const root = report.artifactPaths.rawSourcesDir;
+        await project.fileStore.writeFile(`${root}/connection.json`, JSON.stringify({
+            connectionId,
+            driver: report.driver,
+            extractedAt: input.extractedAt ?? report.createdAt,
+            scope: { schemas: ['public'] },
+        }, null, 2), 'ktx', 'ktx@example.com', 'seed connection');
+        for (const table of input.tables ?? [ordersTable()]) {
+            await project.fileStore.writeFile(`${root}/tables/${table.db ?? 'default'}-${table.name}.json`, JSON.stringify(table, null, 2), 'ktx', 'ktx@example.com', `seed ${table.name}`);
+        }
+        await project.fileStore.writeFile(`${root}/scan-report.json`, JSON.stringify(report, null, 2), 'ktx', 'ktx@example.com', 'seed scan report');
+    }
+    it('returns the latest scan snapshot table details for a display string', async () => {
+        await seedScan({ syncId: 'sync-1', runId: 'scan-old', extractedAt: '2026-05-14T08:00:00.000Z' });
+        await seedScan({
+            syncId: 'sync-2',
+            runId: 'scan-new',
+            extractedAt: '2026-05-14T09:00:00.000Z',
+            tables: [ordersTable({ estimatedRows: 99 })],
+        });
+        const service = createKtxEntityDetailsService(project);
+        const result = await service.read({
+            connectionId: 'warehouse',
+            entities: [{ table: 'public.orders' }],
+        });
+        expect(result.results).toHaveLength(1);
+        expect(result.results[0]).toMatchObject({
+            ok: true,
+            connectionId: 'warehouse',
+            display: 'public.orders',
+            estimatedRows: 99,
+            snapshot: {
+                syncId: 'sync-2',
+                scanRunId: 'scan-new',
+                extractedAt: '2026-05-14T09:00:00.000Z',
+            },
+            columns: [
+                { name: 'id', nativeType: 'integer', primaryKey: true },
+                { name: 'status', nativeType: 'text', nullable: false },
+            ],
+        });
+    });
+    it('filters requested columns while keeping full-table foreign keys', async () => {
+        await seedScan({ syncId: 'sync-1', runId: 'scan-1' });
+        const service = createKtxEntityDetailsService(project);
+        const result = await service.read({
+            connectionId: 'warehouse',
+            entities: [{ table: { catalog: null, db: 'public', name: 'orders' }, columns: ['status'] }],
+        });
+        expect(result.results[0]).toMatchObject({
+            ok: true,
+            columns: [{ name: 'status' }],
+            foreignKeys: [
+                {
+                    fromColumn: 'customer_id',
+                    toDb: 'public',
+                    toTable: 'customers',
+                    toColumn: 'id',
+                },
+            ],
+        });
+    });
+    it('returns a structured missing-scan error', async () => {
+        const service = createKtxEntityDetailsService(project);
+        const result = await service.read({
+            connectionId: 'warehouse',
+            entities: [{ table: 'public.orders' }],
+        });
+        expect(result.results).toEqual([
+            {
+                ok: false,
+                connectionId: 'warehouse',
+                table: 'public.orders',
+                error: {
+                    code: 'scan_missing',
+                    message: 'No live-database scan found for connection "warehouse"; run `ktx ingest warehouse` or `ktx scan warehouse`.',
+                },
+            },
+        ]);
+    });
+    it('reports ambiguous bare table names across schemas', async () => {
+        await seedScan({
+            syncId: 'sync-1',
+            runId: 'scan-1',
+            tables: [ordersTable({ db: 'public' }), ordersTable({ db: 'archive' })],
+        });
+        const service = createKtxEntityDetailsService(project);
+        const result = await service.read({
+            connectionId: 'warehouse',
+            entities: [{ table: 'orders' }],
+        });
+        expect(result.results[0]).toMatchObject({
+            ok: false,
+            error: {
+                code: 'ambiguous_table',
+                candidates: [
+                    { tableRef: { catalog: null, db: 'archive', name: 'orders' }, display: 'archive.orders' },
+                    { tableRef: { catalog: null, db: 'public', name: 'orders' }, display: 'public.orders' },
+                ],
+            },
+        });
+    });
+    it('reports missing requested columns with available column candidates', async () => {
+        await seedScan({ syncId: 'sync-1', runId: 'scan-1' });
+        const service = createKtxEntityDetailsService(project);
+        const result = await service.read({
+            connectionId: 'warehouse',
+            entities: [{ table: 'public.orders', columns: ['status', 'plan_tier'] }],
+        });
+        expect(result.results[0]).toMatchObject({
+            ok: false,
+            error: {
+                code: 'column_not_found',
+                message: 'Column(s) not found on public.orders: plan_tier',
+                candidates: ['id', 'status'],
+            },
+        });
+    });
+});

package/node_modules/@ktx/context/dist/scan/index.d.ts

@@ -0,0 +1,72 @@
+export { REDACTED_KTX_CREDENTIAL_VALUE, redactKtxCredentialEnvelope, redactKtxCredentialValue, redactKtxScanMetadata, redactKtxScanReport, redactKtxScanWarning, } from './credentials.js';
+export type { KtxDataDictionaryColumnState, KtxDataDictionarySampleDecision, KtxDataDictionarySettings, KtxDataDictionarySkipReason, } from './data-dictionary.js';
+export { defaultKtxDataDictionarySettings, isKtxDataDictionaryCandidate, shouldKtxSampleColumnForDictionary, } from './data-dictionary.js';
+export type { KtxColumnAnalysisResult, KtxColumnDescriptionPromptInput, KtxDataSourceDescriptionPromptInput, KtxDescriptionCachePort, KtxDescriptionColumn, KtxDescriptionColumnTable, KtxDescriptionGenerationSettings, KtxDescriptionGeneratorOptions, KtxDescriptionSamplingPort, KtxDescriptionTableInput, KtxGenerateColumnDescriptionsInput, KtxGenerateDataSourceDescriptionInput, KtxGenerateTableDescriptionInput, KtxTableDescriptionPromptInput, } from './description-generation.js';
+export { buildKtxColumnDescriptionPrompt, buildKtxDataSourceDescriptionPrompt, buildKtxTableDescriptionPrompt, KtxDescriptionGenerator, } from './description-generation.js';
+export type { KtxColumnEmbeddingForeignKeys, KtxColumnEmbeddingTextInput } from './embedding-text.js';
+export { buildKtxColumnEmbeddingText } from './embedding-text.js';
+export type { ComputeKtxScanEnrichmentInputHashInput, KtxScanEnrichmentCompletedStage, KtxScanEnrichmentFailedStage, KtxScanEnrichmentStageLookup, KtxScanEnrichmentStageRecord, KtxScanEnrichmentStateStore, } from './enrichment-state.js';
+export { completedKtxScanEnrichmentStateSummary, computeKtxScanEnrichmentInputHash, KTX_SCAN_ENRICHMENT_STAGES, summarizeKtxScanEnrichmentState, } from './enrichment-state.js';
+export { failedKtxScanEnrichmentSummary, ktxScanErrorMessage, skippedKtxScanEnrichmentSummary, } from './enrichment-summary.js';
+export type { KtxEntityDetailsColumn, KtxEntityDetailsErrorCode, KtxEntityDetailsErrorResult, KtxEntityDetailsInput, KtxEntityDetailsRecord, KtxEntityDetailsResponse, KtxEntityDetailsSnapshotInfo, KtxEntityDetailsTableInput, } from './entity-details.js';
+export { createKtxEntityDetailsService } from './entity-details.js';
+export type { DisplayTargetResolution, RawSchemaHit, TableDetail, WarehouseCatalogServiceDeps, } from './warehouse-catalog.js';
+export { WarehouseCatalogService } from './warehouse-catalog.js';
+export type { KtxColumnSampleUpdate, KtxDescriptionSource, KtxDescriptionUpdate, KtxEmbeddingUpdate, KtxEnrichedColumn, KtxEnrichedRelationship, KtxEnrichedSchema, KtxEnrichedTable, KtxRelationshipEndpoint, KtxRelationshipSource, KtxRelationshipType, KtxRelationshipUpdate, KtxScanMetadataStore, KtxSkippedRelationship, KtxStructuralSyncPlan, } from './enrichment-types.js';
+export type { DeterministicLocalScanEnrichmentProviderOptions, KtxLocalScanEnrichmentInput, KtxLocalScanEnrichmentProviders, KtxLocalScanEnrichmentResult, } from './local-enrichment.js';
+export { createDeterministicLocalScanEnrichmentProviders, runLocalScanEnrichment, snapshotToKtxEnrichedSchema, } from './local-enrichment.js';
+export type { WriteLocalScanEnrichmentArtifactsInput, WriteLocalScanEnrichmentArtifactsResult, WriteLocalScanManifestShardsInput, WriteLocalScanManifestShardsResult, } from './local-enrichment-artifacts.js';
+export { writeLocalScanEnrichmentArtifacts, writeLocalScanManifestShards, } from './local-enrichment-artifacts.js';
+export type { LocalScanMcpOptions, LocalScanRunResult, LocalScanStatusResponse, RunLocalScanOptions, } from './local-scan.js';
+export { filterSnapshotTables, getLocalScanReport, getLocalScanStatus, resolveEnabledTables, runLocalScan } from './local-scan.js';
+export type { ReadLocalScanStructuralSnapshotInput } from './local-structural-artifacts.js';
+export { readLocalScanStructuralSnapshot } from './local-structural-artifacts.js';
+export type { KtxEnrichmentScanPhaseResult, KtxScanOrchestratorOptions, KtxScanOrchestratorRunInput, KtxScanOrchestratorRunResult, KtxStructuralScanPhaseResult, } from './orchestrator.js';
+export { KtxScanOrchestrator } from './orchestrator.js';
+export type { KtxRelationshipArtifactStatus, ReadLocalScanRelationshipArtifactsResult, } from './relationship-artifacts.js';
+export { readLocalScanRelationshipArtifacts } from './relationship-artifacts.js';
+export type { KtxRelationshipBenchmarkReport, KtxRelationshipBenchmarkReportCase, KtxRelationshipBenchmarkReportCaseStatus, } from './relationship-benchmark-report.js';
+export { buildKtxRelationshipBenchmarkReport, formatKtxRelationshipBenchmarkReportMarkdown, } from './relationship-benchmark-report.js';
+export type { KtxRelationshipBenchmarkCaseResult, KtxRelationshipBenchmarkDetectedLink, KtxRelationshipBenchmarkDetectedPk, KtxRelationshipBenchmarkDetector, KtxRelationshipBenchmarkDetectorInput, KtxRelationshipBenchmarkDetectorResult, KtxRelationshipBenchmarkExpectedLink, KtxRelationshipBenchmarkExpectedLinks, KtxRelationshipBenchmarkExpectedPk, KtxRelationshipBenchmarkFixture, KtxRelationshipBenchmarkMetrics, KtxRelationshipBenchmarkMode, KtxRelationshipBenchmarkStatus, KtxRelationshipBenchmarkSuiteResult, KtxRelationshipBenchmarkTier, } from './relationship-benchmarks.js';
+export { currentKtxRelationshipBenchmarkDetector, ktxRelationshipBenchmarkDetectorWithLlm, KTX_RELATIONSHIP_BENCHMARK_MODES, KTX_RELATIONSHIP_BENCHMARK_TIERS, loadKtxRelationshipBenchmarkFixture, loadKtxRelationshipBenchmarkFixtures, maskKtxRelationshipBenchmarkSnapshot, runKtxRelationshipBenchmarkCase, runKtxRelationshipBenchmarkSuite, } from './relationship-benchmarks.js';
+export type { ApplyKtxRelationshipValidationBudgetInput, KtxRelationshipBudgetedCandidate, KtxRelationshipValidationBudget, KtxRelationshipValidationBudgetResult, } from './relationship-budget.js';
+export { applyKtxRelationshipValidationBudget, defaultKtxRelationshipValidationBudget, } from './relationship-budget.js';
+export type { KtxRelationshipDiscoveryCandidate, KtxRelationshipDiscoveryCandidateEvidence, KtxRelationshipDiscoveryCandidateOptions, KtxRelationshipDiscoveryCandidateSource, KtxRelationshipDiscoveryCandidateStatus, KtxRelationshipInferredTargetPk, } from './relationship-candidates.js';
+export { generateKtxRelationshipDiscoveryCandidates, inferKtxRelationshipTargetPks, mergeKtxRelationshipDiscoveryCandidates, } from './relationship-candidates.js';
+export type { DiscoverKtxCompositeRelationshipsInput, DiscoverKtxCompositeRelationshipsResult, KtxCompositePrimaryKeyCandidate, KtxCompositeRelationshipCandidate, KtxCompositeRelationshipStatus, KtxCompositeRelationshipTupleEndpoint, KtxCompositeRelationshipValidationEvidence, } from './relationship-composite-candidates.js';
+export { discoverKtxCompositeRelationships } from './relationship-composite-candidates.js';
+export type { BuildKtxRelationshipArtifactsInput, BuildKtxRelationshipDiagnosticsInput, EmptyKtxRelationshipProfileArtifactInput, KtxRelationshipArtifact, KtxRelationshipArtifactEdge, KtxRelationshipArtifactEndpoint, KtxRelationshipDiagnosticsArtifact, KtxRelationshipDiagnosticsSummary, KtxRelationshipDiagnosticsThresholds, KtxRelationshipDiagnosticsValidation, } from './relationship-diagnostics.js';
+export { buildKtxRelationshipArtifacts, buildKtxRelationshipDiagnostics, emptyKtxRelationshipProfileArtifact, } from './relationship-diagnostics.js';
+export type { BuildKtxRelationshipFeedbackCalibrationReportInput, CalibrateLocalRelationshipFeedbackLabelsInput, KtxRelationshipFeedbackCalibrationBucket, KtxRelationshipFeedbackCalibrationLabel, KtxRelationshipFeedbackCalibrationReport, } from './relationship-feedback-calibration.js';
+export { buildKtxRelationshipFeedbackCalibrationReport, calibrateLocalRelationshipFeedbackLabels, formatKtxRelationshipFeedbackCalibrationMarkdown, } from './relationship-feedback-calibration.js';
+export type { ExportLocalRelationshipFeedbackLabelsInput, ExportLocalRelationshipFeedbackLabelsResult, KtxRelationshipFeedbackDecisionFilter, KtxRelationshipFeedbackExportWarning, KtxRelationshipFeedbackLabel, } from './relationship-feedback-export.js';
+export { exportLocalRelationshipFeedbackLabels, formatKtxRelationshipFeedbackLabelsJsonl, } from './relationship-feedback-export.js';
+export { collectKtxFormalMetadataRelationships, type KtxFormalMetadataRelationshipCollection, } from './relationship-formal-metadata.js';
+export type { KtxRelationshipGraphResolutionResult, KtxRelationshipGraphResolverSettings, KtxResolvedRelationshipDiscoveryCandidate, KtxResolvedRelationshipGraphEvidence, KtxResolvedRelationshipPk, KtxResolvedRelationshipPkEvidence, KtxResolvedRelationshipStatus, ResolveKtxRelationshipGraphInput, } from './relationship-graph-resolver.js';
+export { resolveKtxRelationshipGraph } from './relationship-graph-resolver.js';
+export type { KtxRelationshipLlmProposalResult, KtxRelationshipLlmProposalSettings, ProposeKtxRelationshipCandidatesWithLlmInput, } from './relationship-llm-proposal.js';
+export { proposeKtxRelationshipCandidatesWithLlm } from './relationship-llm-proposal.js';
+export type { KtxRelationshipLocalityCandidateTable, LocalKtxRelationshipCandidateTablesInput, } from './relationship-locality.js';
+export { localCandidateTables } from './relationship-locality.js';
+export type { KtxRelationshipNormalizedName, KtxRelationshipTokenInput, } from './relationship-name-similarity.js';
+export { normalizeKtxRelationshipName, pluralizeKtxRelationshipToken, singularizeKtxRelationshipToken, tokenizeKtxRelationshipName, tokenSimilarity, } from './relationship-name-similarity.js';
+export type { DiscoverKtxRelationshipsInput, DiscoverKtxRelationshipsResult, } from './relationship-discovery.js';
+export { discoverKtxRelationships } from './relationship-discovery.js';
+export type { KtxRelationshipColumnProfile, KtxRelationshipProfileArtifact, KtxRelationshipReadOnlyExecutor, KtxRelationshipTableProfile, ProfileKtxRelationshipSchemaInput, } from './relationship-profiling.js';
+export { formatKtxRelationshipTableRef, profileKtxRelationshipSchema, quoteKtxRelationshipIdentifier, } from './relationship-profiling.js';
+export type { AppliedRelationshipReviewDecision, ApplyLocalScanRelationshipReviewDecisionsInput, ApplyLocalScanRelationshipReviewDecisionsResult, } from './relationship-review-apply.js';
+export { applyLocalScanRelationshipReviewDecisions } from './relationship-review-apply.js';
+export type { KtxRelationshipReviewDecisionArtifact, KtxRelationshipReviewDecisionEntry, KtxRelationshipReviewDecisionValue, WriteLocalScanRelationshipReviewDecisionInput, WriteLocalScanRelationshipReviewDecisionResult, } from './relationship-review-decisions.js';
+export { writeLocalScanRelationshipReviewDecision } from './relationship-review-decisions.js';
+export type { KtxRelationshipFixtureOrigin, KtxRelationshipScoreBreakdown, KtxRelationshipScoreSignal, KtxRelationshipScoreWeights, KtxRelationshipScoringCalibrationObservation, KtxRelationshipSignalVector, } from './relationship-scoring.js';
+export { calibrateWeightsFromSyntheticFixtures, defaultKtxRelationshipScoreWeights, KTX_RELATIONSHIP_SCORE_SIGNAL_KEYS, normalizeKtxRelationshipScoreWeights, scoreKtxRelationshipCandidate, } from './relationship-scoring.js';
+export type { AdviseLocalRelationshipFeedbackThresholdsInput, BuildKtxRelationshipThresholdAdviceReportInput, KtxRelationshipThresholdAdviceCandidate, KtxRelationshipThresholdAdviceReport, KtxRelationshipThresholdAdviceStatus, } from './relationship-threshold-advice.js';
+export { adviseLocalRelationshipFeedbackThresholds, buildKtxRelationshipThresholdAdviceReport, formatKtxRelationshipThresholdAdviceMarkdown, } from './relationship-threshold-advice.js';
+export type { KtxRelationshipValidationEvidence, KtxRelationshipValidationSettings, KtxValidatedRelationshipDiscoveryCandidate, KtxValidatedRelationshipStatus, ValidateKtxRelationshipDiscoveryCandidatesInput, } from './relationship-validation.js';
+export { validateKtxRelationshipDiscoveryCandidates } from './relationship-validation.js';
+export type { SqliteLocalScanEnrichmentStateStoreOptions } from './sqlite-local-enrichment-state-store.js';
+export { SqliteLocalScanEnrichmentStateStore } from './sqlite-local-enrichment-state-store.js';
+export type { KtxColumnTypeMapping } from './type-normalization.js';
+export { inferKtxDimensionType, ktxColumnTypeMappingFromNative, normalizeKtxNativeType, } from './type-normalization.js';
+export type { KtxColumnSampleInput, KtxColumnSampleResult, KtxColumnStatsInput, KtxColumnStatsResult, KtxConnectionDriver, KtxConnectorCapabilities, KtxCredentialEnvelope, KtxCredentialEnvReference, KtxCredentialFileReference, KtxEmbeddingPort, KtxEventPropertyDiscovery, KtxEventPropertyDiscoveryInput, KtxEventPropertyValuesInput, KtxEventPropertyValuesResult, KtxEventStreamDiscoveryPort, KtxEventTypeDiscovery, KtxEventTypeDiscoveryInput, KtxNetworkEndpoint, KtxNetworkTunnelPort, KtxNetworkTunnelRequest, KtxOptionalConnectorCapabilities, KtxProgressPort, KtxProgressUpdateOptions, KtxQueryResult, KtxReadOnlyQueryInput, KtxResolvedCredentialEnvelope, KtxConnectorTestResult, KtxScanArtifactPaths, KtxScanConnector, KtxScanContext, KtxScanDiffSummary, KtxScanEnrichmentStage, KtxScanEnrichmentStateSummary, KtxScanEnrichmentSummary, KtxScanInput, KtxScanLoggerPort, KtxScanMode, KtxScanRelationshipSummary, KtxScanReport, KtxScanTrigger, KtxScanWarning, KtxScanWarningCode, KtxSchemaColumn, KtxSchemaDimensionType, KtxSchemaForeignKey, KtxSchemaScope, KtxSchemaSnapshot, KtxSchemaTable, KtxSchemaTableKind, KtxStructuralSyncStats, KtxTableListEntry, KtxTableRef, KtxTableSampleInput, KtxTableSampleResult, } from './types.js';
+export { createKtxConnectorCapabilities } from './types.js';

package/node_modules/@ktx/context/dist/scan/index.js

@@ -0,0 +1,37 @@
+export { REDACTED_KTX_CREDENTIAL_VALUE, redactKtxCredentialEnvelope, redactKtxCredentialValue, redactKtxScanMetadata, redactKtxScanReport, redactKtxScanWarning, } from './credentials.js';
+export { defaultKtxDataDictionarySettings, isKtxDataDictionaryCandidate, shouldKtxSampleColumnForDictionary, } from './data-dictionary.js';
+export { buildKtxColumnDescriptionPrompt, buildKtxDataSourceDescriptionPrompt, buildKtxTableDescriptionPrompt, KtxDescriptionGenerator, } from './description-generation.js';
+export { buildKtxColumnEmbeddingText } from './embedding-text.js';
+export { completedKtxScanEnrichmentStateSummary, computeKtxScanEnrichmentInputHash, KTX_SCAN_ENRICHMENT_STAGES, summarizeKtxScanEnrichmentState, } from './enrichment-state.js';
+export { failedKtxScanEnrichmentSummary, ktxScanErrorMessage, skippedKtxScanEnrichmentSummary, } from './enrichment-summary.js';
+export { createKtxEntityDetailsService } from './entity-details.js';
+export { WarehouseCatalogService } from './warehouse-catalog.js';
+export { createDeterministicLocalScanEnrichmentProviders, runLocalScanEnrichment, snapshotToKtxEnrichedSchema, } from './local-enrichment.js';
+export { writeLocalScanEnrichmentArtifacts, writeLocalScanManifestShards, } from './local-enrichment-artifacts.js';
+export { filterSnapshotTables, getLocalScanReport, getLocalScanStatus, resolveEnabledTables, runLocalScan } from './local-scan.js';
+export { readLocalScanStructuralSnapshot } from './local-structural-artifacts.js';
+export { KtxScanOrchestrator } from './orchestrator.js';
+export { readLocalScanRelationshipArtifacts } from './relationship-artifacts.js';
+export { buildKtxRelationshipBenchmarkReport, formatKtxRelationshipBenchmarkReportMarkdown, } from './relationship-benchmark-report.js';
+export { currentKtxRelationshipBenchmarkDetector, ktxRelationshipBenchmarkDetectorWithLlm, KTX_RELATIONSHIP_BENCHMARK_MODES, KTX_RELATIONSHIP_BENCHMARK_TIERS, loadKtxRelationshipBenchmarkFixture, loadKtxRelationshipBenchmarkFixtures, maskKtxRelationshipBenchmarkSnapshot, runKtxRelationshipBenchmarkCase, runKtxRelationshipBenchmarkSuite, } from './relationship-benchmarks.js';
+export { applyKtxRelationshipValidationBudget, defaultKtxRelationshipValidationBudget, } from './relationship-budget.js';
+export { generateKtxRelationshipDiscoveryCandidates, inferKtxRelationshipTargetPks, mergeKtxRelationshipDiscoveryCandidates, } from './relationship-candidates.js';
+export { discoverKtxCompositeRelationships } from './relationship-composite-candidates.js';
+export { buildKtxRelationshipArtifacts, buildKtxRelationshipDiagnostics, emptyKtxRelationshipProfileArtifact, } from './relationship-diagnostics.js';
+export { buildKtxRelationshipFeedbackCalibrationReport, calibrateLocalRelationshipFeedbackLabels, formatKtxRelationshipFeedbackCalibrationMarkdown, } from './relationship-feedback-calibration.js';
+export { exportLocalRelationshipFeedbackLabels, formatKtxRelationshipFeedbackLabelsJsonl, } from './relationship-feedback-export.js';
+export { collectKtxFormalMetadataRelationships, } from './relationship-formal-metadata.js';
+export { resolveKtxRelationshipGraph } from './relationship-graph-resolver.js';
+export { proposeKtxRelationshipCandidatesWithLlm } from './relationship-llm-proposal.js';
+export { localCandidateTables } from './relationship-locality.js';
+export { normalizeKtxRelationshipName, pluralizeKtxRelationshipToken, singularizeKtxRelationshipToken, tokenizeKtxRelationshipName, tokenSimilarity, } from './relationship-name-similarity.js';
+export { discoverKtxRelationships } from './relationship-discovery.js';
+export { formatKtxRelationshipTableRef, profileKtxRelationshipSchema, quoteKtxRelationshipIdentifier, } from './relationship-profiling.js';
+export { applyLocalScanRelationshipReviewDecisions } from './relationship-review-apply.js';
+export { writeLocalScanRelationshipReviewDecision } from './relationship-review-decisions.js';
+export { calibrateWeightsFromSyntheticFixtures, defaultKtxRelationshipScoreWeights, KTX_RELATIONSHIP_SCORE_SIGNAL_KEYS, normalizeKtxRelationshipScoreWeights, scoreKtxRelationshipCandidate, } from './relationship-scoring.js';
+export { adviseLocalRelationshipFeedbackThresholds, buildKtxRelationshipThresholdAdviceReport, formatKtxRelationshipThresholdAdviceMarkdown, } from './relationship-threshold-advice.js';
+export { validateKtxRelationshipDiscoveryCandidates } from './relationship-validation.js';
+export { SqliteLocalScanEnrichmentStateStore } from './sqlite-local-enrichment-state-store.js';
+export { inferKtxDimensionType, ktxColumnTypeMappingFromNative, normalizeKtxNativeType, } from './type-normalization.js';
+export { createKtxConnectorCapabilities } from './types.js';

package/node_modules/@ktx/context/dist/scan/local-enrichment-artifacts.d.ts

@@ -0,0 +1,32 @@
+import type { KtxScanRelationshipConfig } from '../project/config.js';
+import type { KtxLocalProject } from '../project/index.js';
+import type { KtxLocalScanEnrichmentResult } from './local-enrichment.js';
+import type { KtxConnectionDriver, KtxSchemaSnapshot } from './types.js';
+export interface WriteLocalScanManifestShardsInput {
+    project: KtxLocalProject;
+    connectionId: string;
+    syncId: string;
+    driver: KtxConnectionDriver;
+    snapshot: KtxSchemaSnapshot;
+    dryRun: boolean;
+    descriptionUpdates?: KtxLocalScanEnrichmentResult['descriptionUpdates'];
+    relationshipUpdate?: KtxLocalScanEnrichmentResult['relationshipUpdate'];
+}
+export interface WriteLocalScanManifestShardsResult {
+    manifestShards: string[];
+    manifestShardsWritten: number;
+}
+export interface WriteLocalScanEnrichmentArtifactsInput {
+    project: KtxLocalProject;
+    connectionId: string;
+    syncId: string;
+    driver: KtxConnectionDriver;
+    enrichment: KtxLocalScanEnrichmentResult;
+    dryRun: boolean;
+    relationshipSettings?: KtxScanRelationshipConfig;
+}
+export interface WriteLocalScanEnrichmentArtifactsResult extends WriteLocalScanManifestShardsResult {
+    enrichmentArtifacts: string[];
+}
+export declare function writeLocalScanManifestShards(input: WriteLocalScanManifestShardsInput): Promise<WriteLocalScanManifestShardsResult>;
+export declare function writeLocalScanEnrichmentArtifacts(input: WriteLocalScanEnrichmentArtifactsInput): Promise<WriteLocalScanEnrichmentArtifactsResult>;