@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/exports-star-expand-apply.js

@@ -0,0 +1,373 @@
+"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.persistExportsStarPreview = persistExportsStarPreview;
+exports.persistExportsStarCollapsePreview = persistExportsStarCollapsePreview;
+exports.applyPersistedExportsStarPreview = applyPersistedExportsStarPreview;
+exports.executeCurrentExportsStarBatch = executeCurrentExportsStarBatch;
+exports.executeCurrentExportsStarCollapseBatch = executeCurrentExportsStarCollapseBatch;
+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 exports_star_preview_cache_1 = require("../commands/exports-star-preview-cache");
+const exports_star_expand_preview_1 = require("./exports-star-expand-preview");
+const exports_star_collapse_preview_1 = require("./exports-star-collapse-preview");
+function persistExportsStarPreview(cwd, intents, results) {
+    return persistPreview(cwd, "expand", intents, results);
+}
+function persistExportsStarCollapsePreview(cwd, intents, results) {
+    return persistPreview(cwd, "collapse", intents, results);
+}
+function persistPreview(cwd, operation, intents, results) {
+    if (!results.some((result) => result.plannedCount > 0))
+        return null;
+    const normalizedIntents = intents.map((intent) => normalizeIntent(operation, intent));
+    const fileHashes = collectFileHashes(results);
+    const evidenceHashes = collectEvidenceHashes(cwd, results);
+    const previewId = (0, exports_star_preview_cache_1.buildExportsStarPreviewId)(normalizedIntents, fileHashes, evidenceHashes);
+    const base = {
+        schemaVersion: 1,
+        kind: operation === "collapse" ? "semantic-exports-star-collapse-preview" : "semantic-exports-star-expand-preview",
+        plannerVersion: 1,
+        previewId,
+        cwd: path.resolve(cwd),
+        workspaceRealpath: fs.realpathSync(path.resolve(cwd)),
+        normalizedIntents,
+        fileHashes,
+        evidenceHashes,
+        barrelResults: results
+    };
+    (0, exports_star_preview_cache_1.writeExportsStarPreviewRecord)(cwd, {
+        ...base,
+        previewHash: (0, exports_star_preview_cache_1.buildExportsStarPreviewHash)(base),
+        createdAt: new Date().toISOString()
+    });
+    return previewId;
+}
+function applyPersistedExportsStarPreview(cwd, previewId, options = {}) {
+    const validated = readAndValidateRecord(cwd, previewId);
+    if (validated.ok === false)
+        return validated.response;
+    const record = validated.record;
+    const operation = operationFromRecord(record);
+    const code = (suffix) => operation === "collapse" ? `EXPORTS_STAR_COLLAPSE_PREVIEW_${suffix}` : `EXPORTS_STAR_PREVIEW_${suffix}`;
+    const fail = (errorCode, error, details) => tagOperation(failure("mutate.apply", errorCode, error, details, previewId), operation);
+    if (record.appliedAt) {
+        return fail(code("ALREADY_APPLIED"), "Exports star preview was already applied.", {
+            previewId,
+            appliedAt: record.appliedAt,
+            appliedFiles: record.appliedFiles ?? []
+        });
+    }
+    const drift = firstHashDrift(cwd, { ...record.evidenceHashes, ...record.fileHashes });
+    if (drift) {
+        return fail(code("STALE"), "Relevant exports.star evidence changed after preview.", drift);
+    }
+    const parsed = readIntents(record.normalizedIntents);
+    if (!parsed || parsed.operation !== operation) {
+        return fail(code("INVALID"), "Exports star preview intent is invalid.", { reason: "normalizedIntents" });
+    }
+    const current = planBatch(cwd, operation, parsed.intents, options.semanticContextPool);
+    const persisted = record.barrelResults;
+    const planDrift = compareReviewedPlans(persisted, current, operation);
+    if (planDrift) {
+        return fail(code("STALE"), "Exports star semantic plan changed after preview.", planDrift);
+    }
+    const response = commitResults(cwd, current, "mutate.apply", options, previewId);
+    if (response.ok !== false) {
+        (0, exports_star_preview_cache_1.writeExportsStarPreviewRecord)(cwd, {
+            ...record,
+            appliedAt: new Date().toISOString(),
+            appliedFiles: readStringArray(response.filesWritten)
+        });
+    }
+    return response;
+}
+function executeCurrentExportsStarBatch(cwd, intents, options = {}) {
+    const results = planBatch(cwd, "expand", intents, options.semanticContextPool);
+    return commitResults(cwd, results, "mutate.execute", options);
+}
+function executeCurrentExportsStarCollapseBatch(cwd, intents, options = {}) {
+    const results = planBatch(cwd, "collapse", intents, options.semanticContextPool);
+    return commitResults(cwd, results, "mutate.execute", options);
+}
+function commitResults(cwd, results, operation, options, previewId) {
+    const planned = results.filter((result) => result.plannedCount > 0);
+    const retained = results.flatMap((result) => result.retained);
+    const collapse = results.some((result) => result.operation === "exports.star.collapse.preview");
+    if (planned.length === 0) {
+        return {
+            ok: true,
+            operation,
+            ...(collapse ? { exportsStarOperation: "collapse" } : {}),
+            ...(previewId ? { previewId } : {}),
+            applyAvailable: false,
+            plannedCount: 0,
+            retainedCount: retained.length,
+            retained: retained,
+            filesTouched: [],
+            filesWritten: [],
+            results: results
+        };
+    }
+    const preflight = validateWriteSet(cwd, planned);
+    if (preflight.ok === false) {
+        return tagOperation(failure(operation, "EXPORTS_STAR_PLAN_INVALID", "Exports star plan failed commit preflight.", preflight.details, previewId), collapse ? "collapse" : "expand");
+    }
+    const edits = planned.flatMap((result) => result.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) {
+        return tagOperation(failure(operation, "EXPORTS_STAR_WRITE_FAILED", "Exports star files could not be committed.", {
+            executorCode: applied.code,
+            error: applied.error,
+            recovery: applied.recovery ?? { strategy: "preflight-and-rollback", status: "not-started" }
+        }, previewId, applied.recovery?.status === "failed" ? applied.recovery.attemptedFiles.map((file) => repoPath(cwd, file)) : []), collapse ? "collapse" : "expand");
+    }
+    const filesWritten = planned.flatMap((result) => result.filesTouched);
+    return {
+        ok: true,
+        operation,
+        ...(collapse ? { exportsStarOperation: "collapse" } : {}),
+        ...(previewId ? { previewId } : {}),
+        applyAvailable: false,
+        partial: retained.length > 0,
+        plannedCount: planned.reduce((sum, result) => sum + result.plannedCount, 0),
+        retainedCount: retained.length,
+        retained: retained,
+        filesTouched: filesWritten,
+        filesWritten,
+        recovery: applied.recovery,
+        results: results
+    };
+}
+function validateWriteSet(cwd, results) {
+    const originals = new Map();
+    const seen = new Set();
+    for (const result of results) {
+        const hashes = new Map(result.beforeHashes.map((item) => [item.file, item.beforeHash]));
+        for (const edit of result.edits) {
+            const key = canonicalPath(edit.file);
+            if (seen.has(key))
+                return { ok: false, details: { reason: "duplicateWriteTarget", file: edit.file } };
+            seen.add(key);
+            const absolute = path.resolve(cwd, edit.file);
+            if (!isContained(cwd, absolute) || !fs.existsSync(absolute)) {
+                return { ok: false, details: { reason: "fileOutsideWorkspaceOrMissing", file: edit.file } };
+            }
+            const containment = realpathContainment(cwd, absolute, edit.file);
+            if (containment)
+                return { ok: false, details: containment };
+            const text = fs.readFileSync(absolute, "utf8");
+            if (edit.start !== 0 || edit.end !== text.length || sha256(text) !== hashes.get(edit.file)) {
+                return { ok: false, details: { reason: "editOrBeforeHashChanged", file: edit.file } };
+            }
+            originals.set(path.normalize(absolute), text);
+        }
+    }
+    return { ok: true, originalTexts: originals };
+}
+function readAndValidateRecord(cwd, previewId) {
+    let record;
+    try {
+        record = (0, exports_star_preview_cache_1.readExportsStarPreviewRecord)(cwd, previewId);
+    }
+    catch (error) {
+        return { ok: false, response: failure("mutate.apply", "EXPORTS_STAR_PREVIEW_NOT_FOUND", error instanceof Error ? error.message : String(error), { previewId }, previewId) };
+    }
+    const operation = operationFromRecord(record);
+    const code = (suffix) => operation === "collapse" ? `EXPORTS_STAR_COLLAPSE_PREVIEW_${suffix}` : `EXPORTS_STAR_PREVIEW_${suffix}`;
+    const invalid = record.schemaVersion !== 1 ? "schemaVersion"
+        : record.kind !== "semantic-exports-star-expand-preview" && record.kind !== "semantic-exports-star-collapse-preview" ? "kind"
+            : record.plannerVersion !== 1 ? "plannerVersion"
+                : record.previewId !== previewId ? "previewId"
+                    : canonicalPath(record.cwd) !== canonicalPath(cwd) ? "cwd"
+                        : !Array.isArray(record.normalizedIntents) || !Array.isArray(record.barrelResults) ? "plan"
+                            : !isStringRecord(record.fileHashes) || !isStringRecord(record.evidenceHashes) ? "hashes"
+                                : null;
+    if (invalid)
+        return { ok: false, response: tagOperation(failure("mutate.apply", code("INVALID"), "Exports star preview artifact schema is invalid.", { previewId, reason: invalid }, previewId), operation) };
+    let currentRealpath;
+    try {
+        currentRealpath = fs.realpathSync(path.resolve(cwd));
+    }
+    catch {
+        currentRealpath = "";
+    }
+    if (canonicalPath(record.workspaceRealpath) !== canonicalPath(currentRealpath)) {
+        return { ok: false, response: tagOperation(failure("mutate.apply", code("INVALID"), "Exports star preview workspace identity changed.", { previewId, reason: "workspaceRealpath" }, previewId), operation) };
+    }
+    const { previewHash: _hash, createdAt: _created, appliedAt: _appliedAt, appliedFiles: _appliedFiles, ...base } = record;
+    if (record.previewHash !== (0, exports_star_preview_cache_1.buildExportsStarPreviewHash)(base)) {
+        return { ok: false, response: tagOperation(failure("mutate.apply", code("INVALID"), "Exports star preview artifact integrity check failed.", { previewId, reason: "previewHash" }, previewId), operation) };
+    }
+    return { ok: true, record };
+}
+function compareReviewedPlans(persisted, current, operation) {
+    if (persisted.length !== current.length)
+        return { reason: "barrelCount" };
+    for (let index = 0; index < persisted.length; index += 1) {
+        const expected = persisted[index];
+        const actual = current[index];
+        if (operation === "expand" && expected.plannedCount === 0)
+            continue;
+        if (expected.plannedCount === 0 && (actual.plannedCount !== 0 || expected.semanticFingerprint !== actual.semanticFingerprint)) {
+            return { reason: "retainedSemanticEvidenceChanged", index, sourceFile: expected.sourceFile, previewSemanticFingerprint: expected.semanticFingerprint, currentSemanticFingerprint: actual.semanticFingerprint };
+        }
+        if (expected.plannedCount === 0)
+            continue;
+        if (actual.plannedCount === 0 || expected.semanticFingerprint !== actual.semanticFingerprint ||
+            (0, exports_star_preview_cache_1.stableExportsStarStringify)(expected.edits) !== (0, exports_star_preview_cache_1.stableExportsStarStringify)(actual.edits) ||
+            (0, exports_star_preview_cache_1.stableExportsStarStringify)(expected.beforeHashes) !== (0, exports_star_preview_cache_1.stableExportsStarStringify)(actual.beforeHashes)) {
+            return { reason: "semanticFingerprintOrEditsChanged", index, sourceFile: expected.sourceFile, previewSemanticFingerprint: expected.semanticFingerprint, currentSemanticFingerprint: actual.semanticFingerprint };
+        }
+    }
+    return null;
+}
+function planBatch(cwd, operation, intents, pool) {
+    if (operation === "collapse") {
+        const session = new exports_star_collapse_preview_1.ExportsStarCollapsePreviewSession(cwd, pool);
+        try {
+            return intents.map((intent) => session.plan(intent));
+        }
+        finally {
+            session.dispose();
+        }
+    }
+    const session = new exports_star_expand_preview_1.ExportsStarPreviewSession(cwd, pool);
+    try {
+        return intents.map((intent) => session.plan(intent));
+    }
+    finally {
+        session.dispose();
+    }
+}
+function collectFileHashes(results) {
+    return Object.fromEntries(results.flatMap((result) => result.beforeHashes.map((item) => [item.file, item.beforeHash])).sort(([a], [b]) => a.localeCompare(b)));
+}
+function collectEvidenceHashes(cwd, results) {
+    const files = new Set();
+    for (const result of results.filter((item) => item.plannedCount > 0)) {
+        for (const owner of result.owners)
+            files.add(owner);
+        let directory = path.dirname(path.resolve(cwd, result.sourceFile));
+        const root = path.resolve(cwd);
+        while (isContained(root, directory)) {
+            const packageFile = path.join(directory, "package.json");
+            if (fs.existsSync(packageFile))
+                files.add(repoPath(cwd, packageFile));
+            if (canonicalPath(directory) === canonicalPath(root))
+                break;
+            directory = path.dirname(directory);
+        }
+    }
+    return Object.fromEntries([...files].sort().map((file) => [file, sha256(fs.readFileSync(path.resolve(cwd, file)))]));
+}
+function firstHashDrift(cwd, hashes) {
+    for (const [file, expected] of Object.entries(hashes).sort(([a], [b]) => a.localeCompare(b))) {
+        const absolute = path.resolve(cwd, file);
+        if (!isContained(cwd, absolute) || !fs.existsSync(absolute))
+            return { reason: "evidenceMissingOrOutsideWorkspace", file };
+        const containment = realpathContainment(cwd, absolute, file);
+        if (containment)
+            return containment;
+        if (sha256(fs.readFileSync(absolute)) !== expected)
+            return { reason: "evidenceHashChanged", file };
+    }
+    return null;
+}
+function normalizeIntent(operation, intent) {
+    return {
+        operation: `exports.star.${operation}`,
+        sourceFile: intent.sourceFile.replace(/\\/g, "/"),
+        selectors: [...new Set(intent.selectors ?? [])],
+        ...(operation === "expand" ? { namespaceShape: intent.namespaceShape ?? "retain" } : {})
+    };
+}
+function readIntents(values) {
+    const operations = [...new Set(values.map((value) => value.operation))];
+    const operation = operations.length === 1 && operations[0] === "exports.star.collapse" ? "collapse"
+        : operations.length === 1 && operations[0] === "exports.star.expand" ? "expand"
+            : null;
+    if (!operation)
+        return null;
+    const intents = values.map((value) => ({
+        sourceFile: typeof value.sourceFile === "string" ? value.sourceFile : "",
+        selectors: readStringArray(value.selectors),
+        ...(operation === "expand" ? { namespaceShape: value.namespaceShape === "allow" ? "allow" : "retain" } : {})
+    }));
+    return intents.every((intent) => intent.sourceFile.length > 0) ? { operation, intents } : null;
+}
+function operationFromRecord(record) {
+    return record.kind === "semantic-exports-star-collapse-preview" || (Array.isArray(record.normalizedIntents) && record.normalizedIntents.some((intent) => intent?.operation === "exports.star.collapse"))
+        ? "collapse"
+        : "expand";
+}
+function realpathContainment(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 failure(operation, code, error, details, previewId, filesWritten = []) {
+    const recovery = details.recovery && typeof details.recovery === "object" && !Array.isArray(details.recovery)
+        ? details.recovery
+        : null;
+    return { ok: false, operation, code, ...(previewId ? { previewId } : {}), error, details, ...(recovery ? { recovery } : {}), filesTouched: [], filesWritten };
+}
+function tagOperation(response, operation) {
+    return operation === "collapse" ? { ...response, exportsStarOperation: "collapse" } : response;
+}
+function isStringRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) && Object.entries(value).every(([key, item]) => key.length > 0 && typeof item === "string");
+}
+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 repoPath(root, file) { return path.relative(root, file).replace(/\\/g, "/"); }
+function sha256(value) { return crypto.createHash("sha256").update(value).digest("hex"); }
+function readStringArray(value) { return Array.isArray(value) ? value.filter((item) => typeof item === "string") : []; }