@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/object-pack-semantic-apply.js

@@ -0,0 +1,507 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPersistedObjectPackSemanticPreview = applyPersistedObjectPackSemanticPreview;
+exports.executeCurrentObjectPackSemanticPlan = executeCurrentObjectPackSemanticPlan;
+exports.executeCurrentObjectUnpackSemanticPlan = executeCurrentObjectUnpackSemanticPlan;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const file_text_edit_executor_1 = require("../commands/file-text-edit-executor");
+const object_pack_preview_cache_1 = require("../commands/object-pack-preview-cache");
+const object_pack_semantic_preview_1 = require("./object-pack-semantic-preview");
+const object_unpack_semantic_preview_1 = require("./object-unpack-semantic-preview");
+function applyPersistedObjectPackSemanticPreview(cwd, previewId, options = {}) {
+    const recordResult = readAndValidateRecord(cwd, previewId);
+    if (recordResult.ok === false) {
+        return { response: recordResult.response };
+    }
+    const record = recordResult.record;
+    const kind = recordResult.kind;
+    const contract = mutationContract(kind);
+    if (record.appliedAt) {
+        return {
+            response: failure(contract.applyOperation, contract.code("PREVIEW_ALREADY_APPLIED"), `Object ${kind} preview was already applied.`, {
+                previewId,
+                appliedAt: record.appliedAt,
+                appliedFiles: record.appliedFiles ?? []
+            }, previewId)
+        };
+    }
+    const stalePrecondition = firstChangedBeforeHash(cwd, record);
+    if (stalePrecondition) {
+        return {
+            response: failure(contract.applyOperation, contract.code("PREVIEW_STALE"), `Touched file changed after object.${kind} preview.`, {
+                previewId,
+                ...stalePrecondition
+            }, previewId)
+        };
+    }
+    const input = intentFromRecord(record);
+    if (!input) {
+        return {
+            response: failure(contract.applyOperation, contract.code("PREVIEW_INVALID"), `Object ${kind} preview intent is invalid.`, {
+                previewId,
+                reason: "invalidNormalizedIntent"
+            }, previewId)
+        };
+    }
+    let current;
+    try {
+        current = planCurrent(kind, cwd, input);
+    }
+    catch (error) {
+        return {
+            response: failure(contract.applyOperation, contract.code("PREVIEW_STALE"), `Object ${kind} semantic plan could not be rebuilt safely.`, {
+                previewId,
+                reason: "semanticPlanPreflightFailed",
+                error: error instanceof Error ? error.message : String(error)
+            }, previewId)
+        };
+    }
+    if (!current.ok) {
+        return {
+            response: failure(contract.applyOperation, contract.code("PREVIEW_STALE"), `Object ${kind} semantic plan is no longer applicable.`, {
+                previewId,
+                reason: "semanticPlanRejected",
+                unsupported: current.unsupported
+            }, previewId)
+        };
+    }
+    const persisted = semanticResultFromRecord(record, kind);
+    if (!persisted || persisted.semanticFingerprint !== current.semanticFingerprint ||
+        stableStringify(persisted.edits) !== stableStringify(current.edits) ||
+        stableStringify(persisted.beforeHashes) !== stableStringify(current.beforeHashes)) {
+        return {
+            response: failure(contract.applyOperation, contract.code("PREVIEW_STALE"), `Object ${kind} semantic plan changed after preview.`, {
+                previewId,
+                reason: "semanticFingerprintOrEditsChanged",
+                previewSemanticFingerprint: persisted?.semanticFingerprint ?? null,
+                currentSemanticFingerprint: current.semanticFingerprint
+            }, previewId)
+        };
+    }
+    const committed = commitPlan(cwd, current, contract.applyOperation, options, previewId);
+    if (committed.response.ok !== false) {
+        try {
+            (0, object_pack_preview_cache_1.writeObjectPackPreviewRecord)(cwd, {
+                ...record,
+                appliedAt: new Date().toISOString(),
+                appliedFiles: current.filesTouched
+            });
+        }
+        catch (error) {
+            committed.response.cache = {
+                status: "write-failed",
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    return committed;
+}
+function executeCurrentObjectPackSemanticPlan(cwd, input, options = {}) {
+    let current;
+    try {
+        current = (0, object_pack_semantic_preview_1.planObjectPackSemanticPreview)(cwd, input);
+    }
+    catch (error) {
+        return {
+            response: failure("exports.object.pack.execute", "OBJECT_PACK_PLAN_INVALID", "Object pack semantic plan could not be built safely.", {
+                reason: "semanticPlanPreflightFailed",
+                error: error instanceof Error ? error.message : String(error)
+            })
+        };
+    }
+    if (!current.ok) {
+        return {
+            response: {
+                ...current,
+                operation: "exports.object.pack.execute"
+            }
+        };
+    }
+    return commitPlan(cwd, current, "exports.object.pack.execute", options);
+}
+function executeCurrentObjectUnpackSemanticPlan(cwd, input, options = {}) {
+    let current;
+    try {
+        current = (0, object_unpack_semantic_preview_1.planObjectUnpackSemanticPreview)(cwd, input);
+    }
+    catch (error) {
+        return {
+            response: failure("exports.object.unpack.execute", "OBJECT_UNPACK_PLAN_INVALID", "Object unpack semantic plan could not be built safely.", {
+                reason: "semanticPlanPreflightFailed",
+                error: error instanceof Error ? error.message : String(error)
+            })
+        };
+    }
+    if (!current.ok) {
+        return {
+            response: {
+                ...current,
+                operation: "exports.object.unpack.execute"
+            }
+        };
+    }
+    return commitPlan(cwd, current, "exports.object.unpack.execute", options);
+}
+function commitPlan(cwd, plan, operation, options, previewId) {
+    const kind = operation.includes(".unpack.") ? "unpack" : "pack";
+    const contract = mutationContract(kind);
+    const preflight = validatePlanForCommit(cwd, plan);
+    if (preflight.ok === false) {
+        return {
+            response: failure(operation, contract.code("PLAN_INVALID"), `Object ${kind} concrete plan failed commit preflight.`, preflight.details, previewId)
+        };
+    }
+    const edits = plan.edits.map((edit) => ({
+        fileName: path.resolve(cwd, edit.file),
+        textChanges: [{
+                span: { start: edit.start, length: edit.end - edit.start },
+                newText: edit.text
+            }]
+    }));
+    const applied = (0, file_text_edit_executor_1.applyTextOnlyFileCodeEditsDirectly)(edits, options.fsAdapter, preflight.originalTexts);
+    if (!applied.ok) {
+        const rollbackCompleted = applied.recovery?.status === "completed";
+        return {
+            response: failure(operation, contract.code("WRITE_FAILED"), `Object ${kind} files could not be committed.`, {
+                executorCode: applied.code,
+                error: applied.error,
+                recovery: applied.recovery ?? {
+                    strategy: "preflight-and-rollback",
+                    status: "not-started"
+                }
+            }, previewId, rollbackCompleted ? [] : applied.recovery?.attemptedFiles.map((file) => toRepoPath(cwd, file)) ?? [])
+        };
+    }
+    return {
+        plan,
+        response: {
+            ok: true,
+            operation,
+            ...(previewId ? { previewId } : {}),
+            sourceFile: plan.sourceFile,
+            objectCount: plan.objectCount,
+            memberCount: plan.memberCount,
+            importerCount: plan.importerCount,
+            referenceCount: plan.referenceCount,
+            objects: plan.objects,
+            importers: plan.importers,
+            semanticFingerprint: plan.semanticFingerprint,
+            filesTouched: plan.filesTouched,
+            filesWritten: plan.filesTouched,
+            recovery: applied.recovery,
+            diagnostics: plan.diagnostics,
+            cycleEvidence: plan.cycleEvidence,
+            ...(plan.partial ? {
+                partial: true,
+                requestedObjectCount: plan.requestedObjectCount,
+                requestedMemberCount: plan.requestedMemberCount,
+                retainedCount: plan.retainedCount,
+                retained: plan.retained,
+                notRun: plan.notRun
+            } : {})
+        }
+    };
+}
+function readAndValidateRecord(cwd, previewId) {
+    let record;
+    try {
+        record = (0, object_pack_preview_cache_1.readObjectPackPreviewRecord)(cwd, previewId);
+    }
+    catch (error) {
+        const code = isErrorCode(error, "OBJECT_PACK_PREVIEW_NOT_FOUND")
+            ? "OBJECT_PACK_PREVIEW_NOT_FOUND"
+            : "OBJECT_PACK_PREVIEW_INVALID";
+        return {
+            ok: false,
+            response: failure("exports.object.pack.apply", code, error instanceof Error ? error.message : String(error), { previewId }, previewId)
+        };
+    }
+    const normalizedPayload = isRecord(record.normalizedPayload) ? record.normalizedPayload : null;
+    const previewResult = isRecord(record.previewResult) ? record.previewResult : null;
+    const fileHashes = isRecord(record.fileHashes) ? record.fileHashes : null;
+    const kind = readString(normalizedPayload?.operation) === "unpack" ? "unpack" : "pack";
+    const contract = mutationContract(kind);
+    const normalizedIntentReason = normalizedPayload ? validateNormalizedObjectIntent(normalizedPayload, kind) : "normalizedPayload";
+    const concretePlanReason = previewResult ? validatePersistedConcretePlan(previewResult, kind) : "previewResult";
+    const invalidReason = record.schemaVersion !== 1
+        ? "schemaVersion"
+        : record.kind !== "semantic-object-pack-preview"
+            ? "kind"
+            : record.plannerVersion !== 1
+                ? "plannerVersion"
+                : typeof record.previewId !== "string" || record.previewId !== previewId
+                    ? "previewId"
+                    : typeof record.cwd !== "string" || canonicalPath(record.cwd) !== canonicalPath(cwd)
+                        ? "cwd"
+                        : !normalizedPayload || normalizedIntentReason
+                            ? normalizedIntentReason ?? "normalizedPayload"
+                            : !previewResult || readString(previewResult.operation) !== contract.previewOperation || previewResult.ok !== true
+                                ? "previewResult"
+                                : concretePlanReason
+                                    ? concretePlanReason
+                                    : !fileHashes || Object.entries(fileHashes).some(([file, value]) => !readString(file) || typeof value !== "string")
+                                        ? "fileHashes"
+                                        : typeof record.previewHash !== "string"
+                                            ? "previewHash"
+                                            : null;
+    if (invalidReason) {
+        return {
+            ok: false,
+            response: failure(contract.applyOperation, contract.code("PREVIEW_INVALID"), `Object ${kind} preview artifact schema is invalid.`, {
+                previewId,
+                reason: invalidReason
+            }, previewId)
+        };
+    }
+    const expectedHash = (0, object_pack_preview_cache_1.buildObjectPackPreviewHash)(record.normalizedPayload, record.fileHashes, record.previewResult);
+    if (record.previewHash !== expectedHash) {
+        return {
+            ok: false,
+            response: failure(contract.applyOperation, contract.code("PREVIEW_INVALID"), `Object ${kind} preview artifact integrity check failed.`, {
+                previewId,
+                reason: "previewHash"
+            }, previewId)
+        };
+    }
+    const persisted = semanticResultFromRecord(record, kind);
+    if (!persisted || !hasCompleteBeforeHashes(record, persisted)) {
+        return {
+            ok: false,
+            response: failure(contract.applyOperation, contract.code("PREVIEW_INVALID"), `Object ${kind} preview artifact lacks exact edits or before hashes.`, {
+                previewId,
+                reason: "concretePlan"
+            }, previewId)
+        };
+    }
+    return { ok: true, record, kind };
+}
+function validatePlanForCommit(cwd, plan) {
+    const hashes = new Map(plan.beforeHashes.map((item) => [item.file, item.beforeHash]));
+    if (hashes.size !== plan.edits.length) {
+        return { ok: false, details: { reason: "beforeHashCount", editCount: plan.edits.length, beforeHashCount: hashes.size } };
+    }
+    const originalTexts = new Map();
+    for (const edit of plan.edits) {
+        if (!hashes.has(edit.file)) {
+            return { ok: false, details: { reason: "beforeHashMissing", file: edit.file } };
+        }
+        const absolute = path.resolve(cwd, edit.file);
+        if (!isContained(cwd, absolute) || !fs.existsSync(absolute)) {
+            return { ok: false, details: { reason: "fileOutsideWorkspaceOrMissing", file: edit.file } };
+        }
+        const realpathFailure = validateCurrentRealpathContainment(cwd, absolute, edit.file);
+        if (realpathFailure) {
+            return { ok: false, details: realpathFailure };
+        }
+        const text = fs.readFileSync(absolute, "utf8");
+        if (edit.start !== 0 || edit.end !== text.length || edit.end < edit.start) {
+            return { ok: false, details: { reason: "editRange", file: edit.file, start: edit.start, end: edit.end, fileLength: text.length } };
+        }
+        if (sha256(text) !== hashes.get(edit.file)) {
+            return { ok: false, details: { reason: "beforeHashChanged", file: edit.file } };
+        }
+        originalTexts.set(path.normalize(absolute), text);
+    }
+    return { ok: true, originalTexts };
+}
+function firstChangedBeforeHash(cwd, record) {
+    for (const [file, expected] of Object.entries(record.fileHashes).sort(([left], [right]) => left.localeCompare(right))) {
+        const absolute = path.resolve(cwd, file);
+        if (!isContained(cwd, absolute) || !fs.existsSync(absolute)) {
+            return { reason: "fileOutsideWorkspaceOrMissing", file };
+        }
+        const realpathFailure = validateCurrentRealpathContainment(cwd, absolute, file);
+        if (realpathFailure) {
+            return realpathFailure;
+        }
+        if (sha256(fs.readFileSync(absolute)) !== expected) {
+            return { reason: "beforeHashChanged", file };
+        }
+    }
+    return null;
+}
+function validateCurrentRealpathContainment(cwd, absolute, file) {
+    try {
+        const realRoot = fs.realpathSync(path.resolve(cwd));
+        const realFile = fs.realpathSync(absolute);
+        return isContained(realRoot, realFile)
+            ? null
+            : { reason: "currentTargetEscapesWorkspace", file, realFile };
+    }
+    catch (error) {
+        return {
+            reason: "currentTargetRealpathUnavailable",
+            file,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function semanticResultFromRecord(record, kind) {
+    const value = record.previewResult;
+    return isRecord(value) && validatePersistedConcretePlan(value, kind) === null
+        ? value
+        : null;
+}
+function hasCompleteBeforeHashes(record, result) {
+    const edits = new Set(result.edits.map((edit) => edit.file));
+    const hashes = new Map(result.beforeHashes.map((item) => [item.file, item.beforeHash]));
+    return edits.size === result.edits.length && hashes.size === edits.size &&
+        Object.keys(record.fileHashes).length === edits.size &&
+        [...edits].every((file) => typeof hashes.get(file) === "string" && record.fileHashes[file] === hashes.get(file));
+}
+function intentFromRecord(record) {
+    const sourceFile = readString(record.normalizedPayload.sourceFile);
+    const packs = Array.isArray(record.normalizedPayload.packs)
+        ? record.normalizedPayload.packs.filter(isRecord)
+        : [];
+    if (!sourceFile || packs.length === 0) {
+        return null;
+    }
+    const rows = packs.map((pack) => ({
+        objectName: readString(pack.objectName) ?? "",
+        selectors: Array.isArray(pack.selectors) ? pack.selectors.filter((item) => typeof item === "string") : []
+    }));
+    return rows.every((row) => row.objectName.length > 0 && row.selectors.length > 0)
+        ? { sourceFile, rows }
+        : null;
+}
+function validateNormalizedObjectIntent(payload, kind) {
+    if (readString(payload.operation) !== kind || !readString(payload.sourceFile)) {
+        return "operation";
+    }
+    if (!Array.isArray(payload.packs) || payload.packs.length === 0) {
+        return "packs";
+    }
+    for (const pack of payload.packs) {
+        if (!isRecord(pack) || (pack.operation !== undefined && pack.operation !== kind) || !readString(pack.objectName) ||
+            !Array.isArray(pack.selectors) || pack.selectors.length === 0 ||
+            pack.selectors.some((selector) => !readString(selector))) {
+            return "packs";
+        }
+    }
+    return null;
+}
+function validatePersistedConcretePlan(value, kind) {
+    if (value.ok !== true || value.operation !== mutationContract(kind).previewOperation || typeof value.semanticFingerprint !== "string") {
+        return "previewResult";
+    }
+    if (!Array.isArray(value.edits) || value.edits.length === 0 || !value.edits.every(isPersistedConcreteEdit)) {
+        return "edits";
+    }
+    if (!Array.isArray(value.beforeHashes) || !value.beforeHashes.every(isPersistedBeforeHash)) {
+        return "beforeHashes";
+    }
+    return null;
+}
+function isPersistedConcreteEdit(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return Boolean(readString(value.file)) && Number.isFinite(value.start) && Number.isInteger(value.start) && value.start >= 0 &&
+        Number.isFinite(value.end) && Number.isInteger(value.end) && value.end >= value.start &&
+        typeof value.text === "string" && typeof value.reason === "string";
+}
+function isPersistedBeforeHash(value) {
+    return isRecord(value) && Boolean(readString(value.file)) && Boolean(readString(value.beforeHash));
+}
+function planCurrent(kind, cwd, input) {
+    return kind === "unpack"
+        ? (0, object_unpack_semantic_preview_1.planObjectUnpackSemanticPreview)(cwd, input)
+        : (0, object_pack_semantic_preview_1.planObjectPackSemanticPreview)(cwd, input);
+}
+function mutationContract(kind) {
+    const prefix = kind === "unpack" ? "OBJECT_UNPACK" : "OBJECT_PACK";
+    return {
+        previewOperation: `exports.object.${kind}.preview`,
+        applyOperation: `exports.object.${kind}.apply`,
+        code: (suffix) => `${prefix}_${suffix}`
+    };
+}
+function failure(operation, code, message, details, previewId, filesWritten = []) {
+    const recovery = isRecord(details.recovery) ? details.recovery : null;
+    const recoveryStatus = recovery ? readString(recovery.status) : null;
+    return {
+        ok: false,
+        operation,
+        code,
+        ...(previewId ? { previewId } : {}),
+        error: message,
+        details,
+        unsupportedCount: 1,
+        unsupported: [{ code, message }],
+        filesTouched: [],
+        filesWritten,
+        ...(recovery ? { recovery } : {}),
+        ...(recoveryStatus === "failed" ? { recoveryRequired: true } : {})
+    };
+}
+function isContained(root, file) {
+    const relative = path.relative(path.resolve(root), path.resolve(file));
+    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+function canonicalPath(value) {
+    const resolved = path.resolve(value);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function toRepoPath(root, file) {
+    return path.relative(root, file).replace(/\\/g, "/");
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+        .join(",")}}`;
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isErrorCode(error, code) {
+    return Boolean(error && typeof error === "object" && error.code === code);
+}