@kaelio/ktx 0.1.0-rc.5 → 0.1.0

package/node_modules/@ktx/context/dist/ingest/isolated-diff/git-patch.test.js

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+import { assertPatchAllowedForWorkUnit, parsePatchTouchedPaths, textArtifactRoots } from './git-patch.js';
+describe('isolated diff patch contract', () => {
+    it('parses touched paths from no-rename git patches', () => {
+        const patch = [
+            'diff --git a/wiki/global/a.md b/wiki/global/a.md',
+            'index 1111111..2222222 100644',
+            '--- a/wiki/global/a.md',
+            '+++ b/wiki/global/a.md',
+            '@@ -1 +1 @@',
+            '-old',
+            '+new',
+            'diff --git a/semantic-layer/c1/orders.yaml b/semantic-layer/c1/orders.yaml',
+            'new file mode 100644',
+            '--- /dev/null',
+            '+++ b/semantic-layer/c1/orders.yaml',
+            '@@ -0,0 +1 @@',
+            '+name: orders',
+            '',
+        ].join('\n');
+        expect(parsePatchTouchedPaths(patch)).toEqual([
+            {
+                path: 'wiki/global/a.md',
+                oldPath: 'wiki/global/a.md',
+                newPath: 'wiki/global/a.md',
+                mode: '100644',
+                binary: false,
+            },
+            {
+                path: 'semantic-layer/c1/orders.yaml',
+                oldPath: 'semantic-layer/c1/orders.yaml',
+                newPath: 'semantic-layer/c1/orders.yaml',
+                mode: '100644',
+                binary: false,
+            },
+        ]);
+    });
+    it('rejects semantic-layer paths for slDisallowed work units', () => {
+        const patch = 'diff --git a/semantic-layer/c1/orders.yaml b/semantic-layer/c1/orders.yaml\nindex 1..2 100644\n';
+        expect(() => assertPatchAllowedForWorkUnit({
+            unitKey: 'lookml-mismatch',
+            patch,
+            slDisallowed: true,
+        })).toThrow(/slDisallowed WorkUnit lookml-mismatch touched semantic-layer\/c1\/orders.yaml/);
+    });
+    it('rejects semantic-layer paths outside allowed target connections', () => {
+        const patch = 'diff --git a/semantic-layer/finance/orders.yaml b/semantic-layer/finance/orders.yaml\nindex 1..2 100644\n';
+        expect(() => assertPatchAllowedForWorkUnit({
+            unitKey: 'wu-finance',
+            patch,
+            slDisallowed: false,
+            allowedTargetConnectionIds: new Set(['warehouse']),
+        })).toThrow(/semantic-layer target connection not allowed: semantic-layer\/finance\/orders.yaml \(finance\); allowed: warehouse/);
+    });
+    it('rejects executable and binary changes under known text artifact roots', () => {
+        expect(textArtifactRoots).toEqual(['wiki/', 'semantic-layer/']);
+        const executablePatch = 'diff --git a/wiki/global/a.md b/wiki/global/a.md\nold mode 100644\nnew mode 100755\nindex 1..2\n';
+        expect(() => assertPatchAllowedForWorkUnit({
+            unitKey: 'wu-1',
+            patch: executablePatch,
+            slDisallowed: false,
+        })).toThrow(/unexpected executable mode under wiki\/global\/a.md/);
+        const binaryPatch = [
+            'diff --git a/semantic-layer/c1/orders.yaml b/semantic-layer/c1/orders.yaml',
+            'index 1111111..2222222 100644',
+            'GIT binary patch',
+            'literal 0',
+            '',
+        ].join('\n');
+        expect(() => assertPatchAllowedForWorkUnit({
+            unitKey: 'wu-2',
+            patch: binaryPatch,
+            slDisallowed: false,
+        })).toThrow(/unexpected binary patch under semantic-layer\/c1\/orders.yaml/);
+    });
+});

package/node_modules/@ktx/context/dist/ingest/isolated-diff/patch-integrator.d.ts

@@ -0,0 +1,58 @@
+import type { GitService } from '../../core/index.js';
+import type { FinalGateRepairResult } from '../final-gate-repair.js';
+import type { IngestTraceWriter } from '../ingest-trace.js';
+import type { TextualConflictResolutionResult } from './textual-conflict-resolver.js';
+export type PatchIntegrationTextualResolution = {
+    status: 'repaired';
+    attempts: number;
+    changedPaths: string[];
+} | {
+    status: 'failed';
+    attempts: number;
+    reason: string;
+};
+export type PatchIntegrationResult = {
+    status: 'accepted';
+    commitSha: string;
+    touchedPaths: string[];
+    textualResolution?: PatchIntegrationTextualResolution;
+    gateRepair?: FinalGateRepairResult;
+} | {
+    status: 'textual_conflict';
+    reason: string;
+    touchedPaths: string[];
+    textualResolution?: PatchIntegrationTextualResolution;
+    gateRepair?: FinalGateRepairResult;
+} | {
+    status: 'semantic_conflict';
+    reason: string;
+    touchedPaths: string[];
+    textualResolution?: PatchIntegrationTextualResolution;
+    gateRepair?: FinalGateRepairResult;
+};
+export interface IntegrateWorkUnitPatchInput {
+    unitKey: string;
+    patchPath: string;
+    integrationGit: GitService;
+    trace: IngestTraceWriter;
+    author: {
+        name: string;
+        email: string;
+    };
+    slDisallowed: boolean;
+    allowedTargetConnectionIds: ReadonlySet<string>;
+    validateAppliedTree(touchedPaths: string[]): Promise<void>;
+    resolveTextualConflict?(input: {
+        unitKey: string;
+        patchPath: string;
+        touchedPaths: string[];
+        reason: string;
+    }): Promise<TextualConflictResolutionResult>;
+    repairGateFailure?(input: {
+        unitKey: string;
+        patchPath: string;
+        touchedPaths: string[];
+        reason: string;
+    }): Promise<FinalGateRepairResult>;
+}
+export declare function integrateWorkUnitPatch(input: IntegrateWorkUnitPatchInput): Promise<PatchIntegrationResult>;

package/node_modules/@ktx/context/dist/ingest/isolated-diff/patch-integrator.js

@@ -0,0 +1,223 @@
+import { readFile } from 'node:fs/promises';
+import { traceTimed } from '../ingest-trace.js';
+import { assertPatchAllowedForWorkUnit, parsePatchTouchedPaths } from './git-patch.js';
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function integrateWorkUnitPatch(input) {
+    const preApplyHead = await input.integrationGit.revParseHead();
+    const patch = await readFile(input.patchPath, 'utf-8');
+    const touchedPaths = parsePatchTouchedPaths(patch).map((entry) => entry.path);
+    if (touchedPaths.length === 0) {
+        await input.trace.event('debug', 'integration', 'patch_noop_accepted', {
+            unitKey: input.unitKey,
+            patchPath: input.patchPath,
+            patchBytes: Buffer.byteLength(patch),
+        });
+        return { status: 'accepted', commitSha: preApplyHead ?? '', touchedPaths };
+    }
+    try {
+        assertPatchAllowedForWorkUnit({
+            unitKey: input.unitKey,
+            patch,
+            slDisallowed: input.slDisallowed,
+            allowedTargetConnectionIds: input.allowedTargetConnectionIds,
+        });
+    }
+    catch (error) {
+        await input.trace.event('error', 'integration', 'patch_policy_rejected', {
+            unitKey: input.unitKey,
+            patchPath: input.patchPath,
+            touchedPaths,
+            allowedTargetConnectionIds: [...input.allowedTargetConnectionIds].sort(),
+            reason: errorMessage(error),
+        });
+        return {
+            status: 'textual_conflict',
+            reason: errorMessage(error),
+            touchedPaths,
+        };
+    }
+    try {
+        await traceTimed(input.trace, 'integration', 'patch_apply', { unitKey: input.unitKey, patchPath: input.patchPath, touchedPaths }, async () => {
+            await input.integrationGit.applyPatchFile3WayIndex(input.patchPath);
+            await input.integrationGit.assertWorktreeClean();
+        });
+    }
+    catch (error) {
+        if (preApplyHead) {
+            await input.integrationGit.resetHardTo(preApplyHead);
+        }
+        const reason = errorMessage(error);
+        await input.trace.event('error', 'integration', 'patch_textual_conflict', {
+            unitKey: input.unitKey,
+            patchPath: input.patchPath,
+            touchedPaths,
+            reason,
+        });
+        if (!input.resolveTextualConflict) {
+            return {
+                status: 'textual_conflict',
+                reason,
+                touchedPaths,
+            };
+        }
+        const textualResolution = await input.resolveTextualConflict({
+            unitKey: input.unitKey,
+            patchPath: input.patchPath,
+            touchedPaths,
+            reason,
+        });
+        if (textualResolution.status === 'failed') {
+            if (preApplyHead) {
+                await input.integrationGit.resetHardTo(preApplyHead);
+            }
+            return {
+                status: 'textual_conflict',
+                reason: textualResolution.reason,
+                touchedPaths,
+                textualResolution,
+            };
+        }
+        try {
+            await traceTimed(input.trace, 'integration', 'semantic_gate_after_textual_resolution', { unitKey: input.unitKey, touchedPaths: textualResolution.changedPaths }, async () => {
+                await input.validateAppliedTree(textualResolution.changedPaths);
+            });
+        }
+        catch (semanticError) {
+            if (preApplyHead) {
+                await input.integrationGit.resetHardTo(preApplyHead);
+            }
+            await input.trace.event('error', 'integration', 'patch_semantic_conflict_after_textual_resolution', {
+                unitKey: input.unitKey,
+                patchPath: input.patchPath,
+                touchedPaths: textualResolution.changedPaths,
+                reason: errorMessage(semanticError),
+            });
+            return {
+                status: 'semantic_conflict',
+                reason: errorMessage(semanticError),
+                touchedPaths: textualResolution.changedPaths,
+                textualResolution,
+            };
+        }
+        const commit = await input.integrationGit.commitFiles(textualResolution.changedPaths, `ingest: resolve WorkUnit ${input.unitKey} conflict`, input.author.name, input.author.email);
+        if (!commit.created) {
+            if (preApplyHead) {
+                await input.integrationGit.resetHardTo(preApplyHead);
+            }
+            const noChangeReason = 'textual resolver produced no committable changes';
+            await input.trace.event('error', 'integration', 'textual_conflict_resolver_noop', {
+                unitKey: input.unitKey,
+                patchPath: input.patchPath,
+                touchedPaths: textualResolution.changedPaths,
+            });
+            return {
+                status: 'textual_conflict',
+                reason: noChangeReason,
+                touchedPaths: textualResolution.changedPaths,
+                textualResolution,
+            };
+        }
+        await input.trace.event('debug', 'integration', 'patch_accepted_after_textual_resolution', {
+            unitKey: input.unitKey,
+            commitSha: commit.commitHash,
+            touchedPaths: textualResolution.changedPaths,
+            attempts: textualResolution.attempts,
+        });
+        return {
+            status: 'accepted',
+            commitSha: commit.commitHash,
+            touchedPaths: textualResolution.changedPaths,
+            textualResolution,
+        };
+    }
+    try {
+        await traceTimed(input.trace, 'integration', 'semantic_gate', { unitKey: input.unitKey, touchedPaths }, async () => {
+            await input.validateAppliedTree(touchedPaths);
+        });
+    }
+    catch (error) {
+        const reason = errorMessage(error);
+        await input.trace.event('error', 'integration', 'patch_semantic_conflict', {
+            unitKey: input.unitKey,
+            patchPath: input.patchPath,
+            touchedPaths,
+            reason,
+        });
+        if (input.repairGateFailure) {
+            const gateRepair = await input.repairGateFailure({
+                unitKey: input.unitKey,
+                patchPath: input.patchPath,
+                touchedPaths,
+                reason,
+            });
+            if (gateRepair.status === 'failed') {
+                if (preApplyHead) {
+                    await input.integrationGit.resetHardTo(preApplyHead);
+                }
+                return {
+                    status: 'semantic_conflict',
+                    reason: gateRepair.reason,
+                    touchedPaths,
+                    gateRepair,
+                };
+            }
+            try {
+                await traceTimed(input.trace, 'integration', 'semantic_gate_after_gate_repair', { unitKey: input.unitKey, touchedPaths: gateRepair.changedPaths }, async () => {
+                    await input.validateAppliedTree(gateRepair.changedPaths);
+                });
+            }
+            catch (repairValidationError) {
+                if (preApplyHead) {
+                    await input.integrationGit.resetHardTo(preApplyHead);
+                }
+                return {
+                    status: 'semantic_conflict',
+                    reason: errorMessage(repairValidationError),
+                    touchedPaths: gateRepair.changedPaths,
+                    gateRepair,
+                };
+            }
+            const commit = await input.integrationGit.commitFiles(gateRepair.changedPaths, `ingest: repair WorkUnit ${input.unitKey} gates`, input.author.name, input.author.email);
+            if (!commit.created) {
+                if (preApplyHead) {
+                    await input.integrationGit.resetHardTo(preApplyHead);
+                }
+                return {
+                    status: 'semantic_conflict',
+                    reason: 'gate repair produced no committable changes',
+                    touchedPaths: gateRepair.changedPaths,
+                    gateRepair,
+                };
+            }
+            await input.trace.event('debug', 'integration', 'patch_accepted_after_gate_repair', {
+                unitKey: input.unitKey,
+                commitSha: commit.commitHash,
+                touchedPaths: gateRepair.changedPaths,
+                attempts: gateRepair.attempts,
+            });
+            return {
+                status: 'accepted',
+                commitSha: commit.commitHash,
+                touchedPaths: gateRepair.changedPaths,
+                gateRepair,
+            };
+        }
+        if (preApplyHead) {
+            await input.integrationGit.resetHardTo(preApplyHead);
+        }
+        return {
+            status: 'semantic_conflict',
+            reason,
+            touchedPaths,
+        };
+    }
+    const commit = await input.integrationGit.commitStaged(`ingest: accept WorkUnit ${input.unitKey}`, input.author.name, input.author.email);
+    await input.trace.event('debug', 'integration', 'patch_accepted', {
+        unitKey: input.unitKey,
+        commitSha: commit.commitHash,
+        touchedPaths,
+    });
+    return { status: 'accepted', commitSha: commit.commitHash, touchedPaths };
+}

package/node_modules/@ktx/context/dist/ingest/isolated-diff/patch-integrator.test.d.ts

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