@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/context/dist/scan/relationship-review-apply.test.js

@@ -1,321 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { initKtxProject } from '../project/index.js';
-import { describe, expect, it, vi } from 'vitest';
-import { applyLocalScanRelationshipReviewDecisions } from './relationship-review-apply.js';
-const acceptedDecisionArtifact = {
-    connectionId: 'warehouse',
-    runId: 'scan-run-a',
-    syncId: 'sync-a',
-    generatedAt: '2026-05-07T12:00:00.000Z',
-    decisions: [
-        {
-            candidateId: 'orders:orders.customer_id->customers:customers.id',
-            decision: 'accepted',
-            previousStatus: 'review',
-            connectionId: 'warehouse',
-            runId: 'scan-run-a',
-            syncId: 'sync-a',
-            decidedAt: '2026-05-07T12:01:00.000Z',
-            reviewer: 'Andrey',
-            note: 'Customer link is valid.',
-            from: {
-                tableId: 'public.orders',
-                columnIds: ['public.orders.customer_id'],
-                table: { catalog: null, db: 'public', name: 'orders' },
-                columns: ['customer_id'],
-            },
-            to: {
-                tableId: 'public.customers',
-                columnIds: ['public.customers.id'],
-                table: { catalog: null, db: 'public', name: 'customers' },
-                columns: ['id'],
-            },
-            relationshipType: 'many_to_one',
-            source: 'deterministic_name',
-            score: 0.81,
-            confidence: 0.81,
-            pkScore: 0.93,
-            fkScore: 0.81,
-            reasons: ['review_threshold'],
-        },
-        {
-            candidateId: 'orders:orders.note_id->notes:notes.id',
-            decision: 'rejected',
-            previousStatus: 'review',
-            connectionId: 'warehouse',
-            runId: 'scan-run-a',
-            syncId: 'sync-a',
-            decidedAt: '2026-05-07T12:02:00.000Z',
-            reviewer: 'Andrey',
-            note: null,
-            from: {
-                tableId: 'public.orders',
-                columnIds: ['public.orders.note_id'],
-                table: { catalog: null, db: 'public', name: 'orders' },
-                columns: ['note_id'],
-            },
-            to: {
-                tableId: 'public.notes',
-                columnIds: ['public.notes.id'],
-                table: { catalog: null, db: 'public', name: 'notes' },
-                columns: ['id'],
-            },
-            relationshipType: 'many_to_one',
-            source: 'embedding_similarity',
-            score: 0.7,
-            confidence: 0.7,
-            pkScore: 0.7,
-            fkScore: 0.7,
-            reasons: ['review_threshold'],
-        },
-    ],
-};
-const artifacts = {
-    runId: 'scan-run-a',
-    connectionId: 'warehouse',
-    syncId: 'sync-a',
-    report: {
-        connectionId: 'warehouse',
-        driver: 'postgres',
-        syncId: 'sync-a',
-        runId: 'scan-run-a',
-        trigger: 'cli',
-        mode: 'relationships',
-        dryRun: false,
-        artifactPaths: {
-            rawSourcesDir: 'raw-sources/warehouse/live-database/sync-a',
-            reportPath: 'raw-sources/warehouse/live-database/sync-a/scan-report.json',
-            manifestShards: ['semantic-layer/warehouse/_schema/public.yaml'],
-            enrichmentArtifacts: ['raw-sources/warehouse/live-database/sync-a/enrichment/relationships.json'],
-        },
-        diffSummary: {
-            tablesAdded: 0,
-            tablesModified: 0,
-            tablesDeleted: 0,
-            tablesUnchanged: 2,
-            columnsAdded: 0,
-            columnsModified: 0,
-            columnsDeleted: 0,
-        },
-        manifestShardsWritten: 1,
-        structuralSyncStats: {
-            tablesCreated: 0,
-            tablesUpdated: 0,
-            tablesDeleted: 0,
-            columnsCreated: 0,
-            columnsUpdated: 0,
-            columnsDeleted: 0,
-        },
-        enrichment: {
-            dataDictionary: 'skipped',
-            tableDescriptions: 'skipped',
-            columnDescriptions: 'skipped',
-            embeddings: 'skipped',
-            deterministicRelationships: 'completed',
-            llmRelationshipValidation: 'skipped',
-            statisticalValidation: 'completed',
-        },
-        capabilityGaps: [],
-        warnings: [],
-        relationships: { accepted: 0, review: 1, rejected: 1, skipped: 0 },
-        enrichmentState: { resumedStages: [], completedStages: ['relationships'], failedStages: [] },
-        createdAt: '2026-05-07T12:00:00.000Z',
-    },
-    relationships: {
-        connectionId: 'warehouse',
-        accepted: [],
-        review: [],
-        rejected: [],
-        skipped: [],
-    },
-    diagnostics: null,
-    profile: null,
-    paths: {
-        relationships: 'raw-sources/warehouse/live-database/sync-a/enrichment/relationships.json',
-        diagnostics: null,
-        profile: null,
-    },
-};
-const snapshot = {
-    connectionId: 'warehouse',
-    driver: 'postgres',
-    extractedAt: '2026-05-07T12:00:00.000Z',
-    scope: { schemas: ['public'] },
-    metadata: {},
-    tables: [
-        {
-            catalog: null,
-            db: 'public',
-            name: 'customers',
-            kind: 'table',
-            comment: null,
-            estimatedRows: 2,
-            foreignKeys: [],
-            columns: [
-                {
-                    name: 'id',
-                    nativeType: 'integer',
-                    normalizedType: 'integer',
-                    dimensionType: 'number',
-                    nullable: false,
-                    primaryKey: false,
-                    comment: null,
-                },
-            ],
-        },
-        {
-            catalog: null,
-            db: 'public',
-            name: 'orders',
-            kind: 'table',
-            comment: null,
-            estimatedRows: 2,
-            foreignKeys: [],
-            columns: [
-                {
-                    name: 'customer_id',
-                    nativeType: 'integer',
-                    normalizedType: 'integer',
-                    dimensionType: 'number',
-                    nullable: false,
-                    primaryKey: false,
-                    comment: null,
-                },
-            ],
-        },
-    ],
-};
-async function projectWithDecisions(decisions = acceptedDecisionArtifact) {
-    const tempDir = await mkdtemp(join(tmpdir(), 'ktx-relationship-review-apply-'));
-    const project = await initKtxProject({
-        projectDir: join(tempDir, 'project'),
-    });
-    await project.fileStore.writeFile('raw-sources/warehouse/live-database/sync-a/enrichment/relationship-review-decisions.json', `${JSON.stringify(decisions)}\n`, 'ktx', 'ktx@example.com', 'Seed relationship review decisions');
-    return { project, tempDir };
-}
-function manifestResult() {
-    return {
-        manifestShards: ['semantic-layer/warehouse/_schema/public.yaml'],
-        manifestShardsWritten: 1,
-    };
-}
-describe('relationship review apply', () => {
-    it('previews all accepted decisions without writing manifest shards', async () => {
-        const { project, tempDir } = await projectWithDecisions();
-        const writeLocalScanManifestShards = vi.fn(async () => manifestResult());
-        try {
-            const result = await applyLocalScanRelationshipReviewDecisions(project, {
-                runId: 'scan-run-a',
-                applyAllAccepted: true,
-                dryRun: true,
-                readLocalScanRelationshipArtifacts: vi.fn(async () => artifacts),
-                readLocalScanStructuralSnapshot: vi.fn(async () => snapshot),
-                writeLocalScanManifestShards,
-            });
-            expect(result).toMatchObject({
-                runId: 'scan-run-a',
-                connectionId: 'warehouse',
-                syncId: 'sync-a',
-                dryRun: true,
-                selectedDecisions: 1,
-                appliedRelationships: 1,
-                manifestShards: [],
-                manifestShardsWritten: 0,
-            });
-            expect(result.relationships[0]).toMatchObject({
-                id: 'orders:orders.customer_id->customers:customers.id',
-                source: 'manual',
-                relationshipType: 'many_to_one',
-                confidence: 1,
-            });
-            expect(writeLocalScanManifestShards).not.toHaveBeenCalled();
-        }
-        finally {
-            await rm(tempDir, { recursive: true, force: true });
-        }
-    });
-    it('writes selected accepted decisions as manual manifest relationships', async () => {
-        const { project, tempDir } = await projectWithDecisions();
-        const readLocalScanStructuralSnapshot = vi.fn(async () => snapshot);
-        const writeLocalScanManifestShards = vi.fn(async () => manifestResult());
-        try {
-            const result = await applyLocalScanRelationshipReviewDecisions(project, {
-                runId: 'scan-run-a',
-                candidateIds: ['orders:orders.customer_id->customers:customers.id'],
-                readLocalScanRelationshipArtifacts: vi.fn(async () => artifacts),
-                readLocalScanStructuralSnapshot,
-                writeLocalScanManifestShards,
-            });
-            expect(readLocalScanStructuralSnapshot).toHaveBeenCalledWith({
-                project: expect.any(Object),
-                connectionId: 'warehouse',
-                driver: 'postgres',
-                rawSourcesDir: 'raw-sources/warehouse/live-database/sync-a',
-                extractedAtFallback: '2026-05-07T12:00:00.000Z',
-            });
-            expect(writeLocalScanManifestShards).toHaveBeenCalledWith({
-                project: expect.any(Object),
-                connectionId: 'warehouse',
-                syncId: 'sync-a',
-                driver: 'postgres',
-                snapshot,
-                dryRun: false,
-                relationshipUpdate: {
-                    connectionId: 'warehouse',
-                    accepted: [
-                        expect.objectContaining({
-                            id: 'orders:orders.customer_id->customers:customers.id',
-                            source: 'manual',
-                            from: expect.objectContaining({ columns: ['customer_id'] }),
-                            to: expect.objectContaining({ columns: ['id'] }),
-                        }),
-                    ],
-                    rejected: [],
-                    skipped: [],
-                },
-            });
-            expect(result.manifestShardsWritten).toBe(1);
-        }
-        finally {
-            await rm(tempDir, { recursive: true, force: true });
-        }
-    });
-    it('rejects ambiguous apply selection input', async () => {
-        const { project, tempDir } = await projectWithDecisions();
-        try {
-            await expect(applyLocalScanRelationshipReviewDecisions(project, {
-                runId: 'scan-run-a',
-                readLocalScanRelationshipArtifacts: vi.fn(async () => artifacts),
-            })).rejects.toThrow('Pass --all-accepted or at least one --candidate to choose review decisions to apply');
-            await expect(applyLocalScanRelationshipReviewDecisions(project, {
-                runId: 'scan-run-a',
-                applyAllAccepted: true,
-                candidateIds: ['orders:orders.customer_id->customers:customers.id'],
-                readLocalScanRelationshipArtifacts: vi.fn(async () => artifacts),
-            })).rejects.toThrow('Use either --all-accepted or --candidate, not both');
-        }
-        finally {
-            await rm(tempDir, { recursive: true, force: true });
-        }
-    });
-    it('refuses rejected decisions and missing candidate ids', async () => {
-        const { project, tempDir } = await projectWithDecisions();
-        try {
-            await expect(applyLocalScanRelationshipReviewDecisions(project, {
-                runId: 'scan-run-a',
-                candidateIds: ['orders:orders.note_id->notes:notes.id'],
-                readLocalScanRelationshipArtifacts: vi.fn(async () => artifacts),
-            })).rejects.toThrow('Relationship review decision "orders:orders.note_id->notes:notes.id" is rejected, not accepted');
-            await expect(applyLocalScanRelationshipReviewDecisions(project, {
-                runId: 'scan-run-a',
-                candidateIds: ['missing'],
-                readLocalScanRelationshipArtifacts: vi.fn(async () => artifacts),
-            })).rejects.toThrow('Relationship review decision "missing" was not found for scan run "scan-run-a"');
-        }
-        finally {
-            await rm(tempDir, { recursive: true, force: true });
-        }
-    });
-});

package/node_modules/@ktx/context/dist/scan/relationship-review-decisions.d.ts

@@ -1,46 +0,0 @@
-import type { KtxLocalProject } from '../project/index.js';
-import type { KtxRelationshipType } from './enrichment-types.js';
-import type { KtxRelationshipArtifactEndpoint } from './relationship-diagnostics.js';
-import type { KtxResolvedRelationshipStatus } from './relationship-graph-resolver.js';
-export type KtxRelationshipReviewDecisionValue = 'accepted' | 'rejected';
-export interface WriteLocalScanRelationshipReviewDecisionInput {
-    runId: string;
-    candidateId: string;
-    decision: KtxRelationshipReviewDecisionValue;
-    reviewer: string;
-    note: string | null;
-    decidedAt?: string;
-}
-export interface KtxRelationshipReviewDecisionEntry {
-    candidateId: string;
-    decision: KtxRelationshipReviewDecisionValue;
-    previousStatus: KtxResolvedRelationshipStatus;
-    connectionId: string;
-    runId: string;
-    syncId: string;
-    decidedAt: string;
-    reviewer: string;
-    note: string | null;
-    from: KtxRelationshipArtifactEndpoint;
-    to: KtxRelationshipArtifactEndpoint;
-    relationshipType: KtxRelationshipType;
-    source: string;
-    score: number | null;
-    confidence: number;
-    pkScore: number | null;
-    fkScore: number | null;
-    reasons: string[];
-}
-export interface KtxRelationshipReviewDecisionArtifact {
-    connectionId: string;
-    runId: string;
-    syncId: string;
-    generatedAt: string;
-    decisions: KtxRelationshipReviewDecisionEntry[];
-}
-export interface WriteLocalScanRelationshipReviewDecisionResult {
-    path: string;
-    decision: KtxRelationshipReviewDecisionEntry;
-    artifact: KtxRelationshipReviewDecisionArtifact;
-}
-export declare function writeLocalScanRelationshipReviewDecision(project: KtxLocalProject, input: WriteLocalScanRelationshipReviewDecisionInput): Promise<WriteLocalScanRelationshipReviewDecisionResult | null>;

package/node_modules/@ktx/context/dist/scan/relationship-review-decisions.js

@@ -1,92 +0,0 @@
-import { readLocalScanRelationshipArtifacts } from './relationship-artifacts.js';
-const LOCAL_AUTHOR = 'ktx';
-const LOCAL_AUTHOR_EMAIL = 'ktx@example.com';
-const DECISIONS_FILE = 'relationship-review-decisions.json';
-function reviewDecisionPath(relationshipsPath) {
-    return relationshipsPath.replace(/relationships\.json$/u, DECISIONS_FILE);
-}
-function allCandidateEdges(result) {
-    if (!result) {
-        return [];
-    }
-    return [...result.relationships.accepted, ...result.relationships.review, ...result.relationships.rejected];
-}
-async function readExistingDecisions(project, path, fallback) {
-    try {
-        const raw = await project.fileStore.readFile(path);
-        const parsed = JSON.parse(raw.content);
-        return {
-            connectionId: parsed.connectionId,
-            runId: parsed.runId,
-            syncId: parsed.syncId,
-            generatedAt: parsed.generatedAt,
-            decisions: Array.isArray(parsed.decisions) ? parsed.decisions : [],
-        };
-    }
-    catch {
-        return { ...fallback, decisions: [] };
-    }
-}
-function decisionEntry(input) {
-    return {
-        candidateId: input.candidate.id,
-        decision: input.decision,
-        previousStatus: input.candidate.status,
-        connectionId: input.connectionId,
-        runId: input.runId,
-        syncId: input.syncId,
-        decidedAt: input.decidedAt,
-        reviewer: input.reviewer,
-        note: input.note,
-        from: input.candidate.from,
-        to: input.candidate.to,
-        relationshipType: input.candidate.relationshipType,
-        source: input.candidate.source,
-        score: input.candidate.score,
-        confidence: input.candidate.confidence,
-        pkScore: input.candidate.pkScore,
-        fkScore: input.candidate.fkScore,
-        reasons: [...input.candidate.reasons],
-    };
-}
-function upsertDecision(existing, next) {
-    return [...existing.filter((item) => item.candidateId !== next.candidateId), next].sort((left, right) => left.candidateId.localeCompare(right.candidateId));
-}
-export async function writeLocalScanRelationshipReviewDecision(project, input) {
-    const artifacts = await readLocalScanRelationshipArtifacts(project, input.runId);
-    if (!artifacts) {
-        return null;
-    }
-    const candidate = allCandidateEdges(artifacts).find((edge) => edge.id === input.candidateId);
-    if (!candidate) {
-        throw new Error(`Relationship candidate "${input.candidateId}" was not found in scan run "${input.runId}"`);
-    }
-    const decidedAt = input.decidedAt ?? new Date().toISOString();
-    const path = reviewDecisionPath(artifacts.paths.relationships);
-    const fallback = {
-        connectionId: artifacts.connectionId,
-        runId: artifacts.runId,
-        syncId: artifacts.syncId,
-        generatedAt: decidedAt,
-    };
-    const existing = await readExistingDecisions(project, path, fallback);
-    const decision = decisionEntry({
-        candidate,
-        connectionId: artifacts.connectionId,
-        runId: artifacts.runId,
-        syncId: artifacts.syncId,
-        decision: input.decision,
-        reviewer: input.reviewer,
-        note: input.note,
-        decidedAt,
-    });
-    const artifact = {
-        connectionId: artifacts.connectionId,
-        runId: artifacts.runId,
-        syncId: artifacts.syncId,
-        generatedAt: decidedAt,
-        decisions: upsertDecision(existing.decisions, decision),
-    };
-    await project.fileStore.writeFile(path, `${JSON.stringify(artifact, null, 2)}\n`, LOCAL_AUTHOR, LOCAL_AUTHOR_EMAIL, `scan(live-database): record relationship review decision runId=${input.runId}`);
-    return { path, decision, artifact };
-}

package/node_modules/@ktx/context/dist/scan/relationship-review-decisions.test.d.ts

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