@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/semantic-rename-standalone-engine.js

@@ -0,0 +1,302 @@
+"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.runStandaloneSemanticRenameBatch = runStandaloneSemanticRenameBatch;
+const path = __importStar(require("node:path"));
+const workspace_root_1 = require("../config/workspace-root");
+const semantic_rename_standalone_planner_1 = require("./semantic-rename-standalone-planner");
+const semantic_rename_transaction_1 = require("./semantic-rename-transaction");
+const semantic_planner_retry_1 = require("./semantic-planner-retry");
+const file_mutation_discovery_1 = require("./file-mutation-discovery");
+const semantic_execution_progress_1 = require("./semantic-execution-progress");
+async function runStandaloneSemanticRenameBatch(cwd, builtBatch, evidence, dependencies = {
+    plan: semantic_rename_standalone_planner_1.planStandaloneSemanticRename,
+    apply: semantic_rename_transaction_1.applyStandaloneSemanticRenameTransaction
+}, internal) {
+    const startedAt = Date.now();
+    const parsed = parseRenameOperations(cwd, builtBatch.payload);
+    if (!parsed.ok) {
+        return failedBatch(parsed.operations, parsed.code, parsed.error, Date.now() - startedAt);
+    }
+    const operations = parsed.operations;
+    const progressTracker = (0, semantic_execution_progress_1.createSemanticExecutionProgressTracker)(builtBatch);
+    const sourceFiles = new Set(operations.map((operation) => pathKey(operation.sourceFile)));
+    if (sourceFiles.size !== 1) {
+        return failedBatch(operations, "SEMANTIC_RENAME_MULTI_SOURCE_UNSUPPORTED", "One atomic standalone semantic rename batch must use one exact source file.", Date.now() - startedAt);
+    }
+    const executeValues = new Set(operations.map((operation) => operation.execute));
+    if (executeValues.size !== 1) {
+        return failedBatch(operations, "SEMANTIC_RENAME_EXECUTION_MODE_MISMATCH", "Every rename row in one atomic batch must use the same execution mode.", Date.now() - startedAt);
+    }
+    if (operations[0].execute === true && !evidence) {
+        return failedBatch(operations, "SEMANTIC_RENAME_EXECUTION_EVIDENCE_REQUIRED", "Standalone semantic rename refuses writes without a durable owned execution write-set.", Date.now() - startedAt);
+    }
+    const workspaceRoot = (0, workspace_root_1.resolveWorkspaceRoot)(cwd)?.root ?? path.resolve(cwd);
+    const computeWorkspaceFingerprint = internal?.semanticContextPool
+        ? (root) => internal.semanticContextPool.withWorkspaceProjectIndex((index) => (0, file_mutation_discovery_1.computeFileMutationWorkspaceFingerprintWithProjectIndex)(index, root))
+        : undefined;
+    const plan = await (0, semantic_planner_retry_1.runSemanticPlannerWithRetry)(() => dependencies.plan({
+        workspaceRoot,
+        sourceFile: operations[0].sourceFile,
+        intents: operations.map((operation) => ({
+            id: operation.id,
+            oldName: operation.oldName,
+            newName: operation.newName
+        })),
+        ...(internal?.semanticContextPool ? { semanticContextPool: internal.semanticContextPool } : {})
+    }));
+    if (!plan.complete) {
+        return failedBatch(operations, plan.code, plan.error ?? "Standalone semantic rename planning failed.", Date.now() - startedAt, plan);
+    }
+    if (operations[0].execute !== true) {
+        return completedBatch(operations, plan, null, Date.now() - startedAt);
+    }
+    const applied = dependencies.apply({
+        workspaceRoot,
+        plan,
+        ...(computeWorkspaceFingerprint ? { computeWorkspaceFingerprint } : {}),
+        ...(evidence ? { beforeApply: (writeSet) => evidence.beforeApply(writeSet) } : {})
+    });
+    if (!applied.ok) {
+        const progress = progressTracker.finalize(operations.map((operation) => ({ id: operation.id, failed: true })));
+        if (progress)
+            evidence?.afterProgress?.(progress);
+        return failedBatch(operations, applied.code, applied.error, Date.now() - startedAt, plan, {
+            rollback: applied.rollback,
+            potentiallyModifiedFiles: applied.potentiallyModifiedFiles,
+            ...(applied.rollbackErrors ? { rollbackErrors: applied.rollbackErrors } : {})
+        });
+    }
+    const progress = progressTracker.finalize(operations.map((operation) => ({ id: operation.id, failed: false })));
+    if (progress)
+        evidence?.afterProgress?.(progress);
+    return completedBatch(operations, plan, applied, Date.now() - startedAt);
+}
+function parseRenameOperations(cwd, payload) {
+    const rawOperations = Array.isArray(payload.operations) ? payload.operations : [];
+    const operations = [];
+    for (const [index, raw] of rawOperations.entries()) {
+        if (!isObject(raw) || raw.kind !== "renameSymbol" || !isObject(raw.body)) {
+            return {
+                ok: false,
+                operations: fallbackOperations(cwd, payload),
+                code: "SEMANTIC_RENAME_BATCH_MIXED_UNSUPPORTED",
+                error: "A batch containing semantic rename cannot include IDE-owned semantic operations."
+            };
+        }
+        const id = readString(raw.id);
+        const sourceFile = readString(raw.body.sourceFile);
+        const oldName = readString(raw.body.symbolName);
+        const newName = readString(raw.body.newName);
+        if (!id || !sourceFile || !oldName || !newName || readString(raw.body.parentName)) {
+            return {
+                ok: false,
+                operations: fallbackOperations(cwd, payload),
+                code: "SEMANTIC_RENAME_ROW_UNSUPPORTED",
+                error: "Standalone semantic rename requires one top-level symbolName/newName/sourceFile row."
+            };
+        }
+        operations.push({
+            index,
+            id,
+            kind: "renameSymbol",
+            sourceFile: path.isAbsolute(sourceFile) ? path.resolve(sourceFile) : path.resolve(cwd, sourceFile),
+            oldName,
+            newName,
+            execute: raw.body.execute === true
+        });
+    }
+    if (operations.length === 0) {
+        return {
+            ok: false,
+            operations,
+            code: "SEMANTIC_RENAME_ROWS_REQUIRED",
+            error: "Standalone semantic rename expects at least one rename row."
+        };
+    }
+    return { ok: true, operations };
+}
+function fallbackOperations(cwd, payload) {
+    const rawOperations = Array.isArray(payload.operations) ? payload.operations : [];
+    return rawOperations.map((raw, index) => {
+        const operation = isObject(raw) ? raw : {};
+        const body = isObject(operation.body) ? operation.body : {};
+        const sourceFile = readString(body.sourceFile) ?? cwd;
+        return {
+            index,
+            id: readString(operation.id) ?? `row-${index + 1}`,
+            kind: readString(operation.kind) ?? "operation",
+            sourceFile: path.isAbsolute(sourceFile) ? path.resolve(sourceFile) : path.resolve(cwd, sourceFile),
+            oldName: readString(body.symbolName) ?? "",
+            newName: readString(body.newName) ?? "",
+            execute: body.execute === true
+        };
+    });
+}
+function completedBatch(operations, plan, applied, durationMs) {
+    const execute = operations[0].execute;
+    const rows = operations.map((operation) => {
+        const intent = plan.intents.find((candidate) => candidate.id === operation.id);
+        const files = unique(intent.locations.map((location) => path.normalize(location.fileName)));
+        const response = {
+            ok: true,
+            execute,
+            applied: execute,
+            sourceFile: operation.sourceFile,
+            newName: operation.newName,
+            locationPreview: locationPreview(intent.locations, operation.newName),
+            ...(execute ? { applyMode: "standaloneTextTransaction", touchedFiles: files, savedFiles: files } : {})
+        };
+        return completedRow(operation, response, durationMs / operations.length);
+    });
+    return batchEnvelope(rows, true, durationMs, {
+        code: "SEMANTIC_RENAME_PLAN_COMPLETE",
+        rollback: execute ? "not-needed" : "not-needed",
+        potentiallyModifiedFiles: [],
+        planner: plannerEvidence(plan),
+        ...(applied ? { savedFiles: applied.savedFiles, touchedFiles: applied.touchedFiles, editCount: applied.editCount } : {})
+    });
+}
+function failedBatch(operations, code, error, durationMs, plan, evidence = {}) {
+    const blockers = plan?.blockers ?? [];
+    const blocked = code === "SEMANTIC_RENAME_TARGET_COLLISION" || blockers.length > 0;
+    const rows = operations.map((operation) => completedRow(operation, {
+        ok: false,
+        code,
+        error,
+        execute: operation.execute,
+        applied: false,
+        touchedFiles: readStrings(evidence.potentiallyModifiedFiles),
+        savedFiles: [],
+        ...(blocked ? { blockers: blockers.filter((blocker) => blocker.intentId === operation.id) } : {})
+    }, operations.length > 0 ? durationMs / operations.length : durationMs, blocked ? "blocked" : "failed"));
+    return batchEnvelope(rows, false, durationMs, {
+        code,
+        error,
+        rollback: readString(evidence.rollback) ?? "not-needed",
+        potentiallyModifiedFiles: readStrings(evidence.potentiallyModifiedFiles),
+        ...(blockers.length > 0 ? { blockers } : {}),
+        ...(Array.isArray(evidence.rollbackErrors) ? { rollbackErrors: evidence.rollbackErrors } : {}),
+        ...(plan ? { planner: plannerEvidence(plan) } : {})
+    });
+}
+function completedRow(operation, response, durationMs, failedOutcome = "failed") {
+    const ok = response.ok === true && (response.execute !== true || response.applied === true);
+    return {
+        index: operation.index + 1,
+        id: operation.id,
+        kind: operation.kind,
+        planned: true,
+        attempted: true,
+        outcome: ok ? (response.applied === true ? "applied" : "validated") : failedOutcome,
+        ok,
+        statusCode: ok ? 200 : 400,
+        durationMs,
+        responseOk: ok,
+        applied: response.applied === true,
+        touchedFiles: readStrings(response.touchedFiles),
+        savedFiles: readStrings(response.savedFiles),
+        ...(typeof response.error === "string" ? { error: response.error } : {}),
+        response
+    };
+}
+function batchEnvelope(rows, ok, durationMs, extra) {
+    return {
+        ok: true,
+        operation: "refactorBatch",
+        contract: {
+            version: 2,
+            execution: "atomic",
+            continueOnError: false,
+            rollback: "verified-text-transaction",
+            transactional: true,
+            rowOutcomeValues: ["applied", "validated", "blocked", "failed"]
+        },
+        execution: "atomic",
+        continueOnError: false,
+        batchOk: ok,
+        batchStatus: ok ? "completed" : "completedWithErrors",
+        requestedOperationCount: rows.length,
+        plannedOperationCount: rows.length,
+        attemptedRowCount: rows.length,
+        rowCount: rows.length,
+        passedRowCount: ok ? rows.length : 0,
+        failedRowCount: ok ? 0 : rows.length,
+        skippedRowCount: 0,
+        durationMs,
+        guidance: ok ? null : { hint: "Fix the standalone semantic rename failure and rerun the complete group." },
+        providerLimitations: [],
+        rows,
+        ...extra
+    };
+}
+function locationPreview(locations, newName) {
+    return {
+        locationCount: locations.length,
+        locations: locations.map((location) => ({
+            fileName: location.fileName,
+            start: location.start,
+            length: location.length,
+            newText: `${location.prefixText ?? ""}${newName}${location.suffixText ?? ""}`
+        }))
+    };
+}
+function plannerEvidence(plan) {
+    return {
+        code: plan.code,
+        sourceFile: plan.sourceFile,
+        workspaceRoot: plan.workspaceRoot,
+        snapshotHash: plan.snapshotHash,
+        totalMs: plan.totalMs,
+        discovery: plan.discovery,
+        configWorkers: plan.configWorkers
+    };
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readStrings(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function pathKey(value) {
+    const resolved = path.resolve(value);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}