@automaton-labs/aib 0.0.6 → 0.0.8

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

@@ -0,0 +1,478 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSemanticMutationEngine = runSemanticMutationEngine;
+const errors_1 = require("../shared/errors");
+const refactor_batch_builder_1 = require("../commands/refactor-batch-builder");
+const import_rules_1 = require("../config/import-rules");
+const env_vars_1 = require("../config/env-vars");
+const mutation_comments_1 = require("../config/mutation-comments");
+const resolve_1 = require("../config/resolve");
+const semantic_rename_standalone_engine_1 = require("./semantic-rename-standalone-engine");
+const semantic_move_standalone_engine_1 = require("./semantic-move-standalone-engine");
+const semantic_move_metrics_1 = require("./semantic-move-metrics");
+async function runSemanticMutationEngine(cwd, payload, options, operation, dependencies = {
+    runRenameBatch: semantic_rename_standalone_engine_1.runStandaloneSemanticRenameBatch,
+    runMoveBatch: semantic_move_standalone_engine_1.runStandaloneSemanticMoveBatch
+}) {
+    const semanticMoveDivergences = [];
+    const packageManifestImpacts = [];
+    const localBatch = (0, refactor_batch_builder_1.buildExtensionRefactorBatchPayload)(payload, (0, resolve_1.resolveCliConfig)(null), {
+        cwd,
+        importRules: (0, import_rules_1.importRulesToJson)(options.importRules ?? (0, import_rules_1.readConfigImportRules)(cwd)),
+        mutationComments: (0, mutation_comments_1.mutationCommentsPolicyToJson)(options.mutationComments ?? (0, mutation_comments_1.readConfigMutationComments)(cwd)),
+        renameDirectApply: process.env[env_vars_1.CLI_ENV.semanticRenameDirectApply] !== "0"
+    });
+    if (containsRenameOperation(localBatch.payload)) {
+        const rawResponse = await runRenameAwareBatch(cwd, localBatch, options, operation, dependencies, semanticMoveDivergences, packageManifestImpacts);
+        return buildEngineResult(cwd, operation, localBatch, rawResponse, semanticMoveDivergences, packageManifestImpacts);
+    }
+    if (containsMoveOperation(localBatch.payload)) {
+        const rawResponse = await runMoveBatchWithMetrics(cwd, localBatch, options, operation, dependencies, semanticMoveDivergences, packageManifestImpacts);
+        return buildEngineResult(cwd, operation, localBatch, rawResponse, semanticMoveDivergences, packageManifestImpacts);
+    }
+    throw new errors_1.CliError("SEMANTIC_MUTATION_KIND_UNSUPPORTED", "Semantic mutation batch contains no standalone rename or move operation.");
+}
+async function runRenameAwareBatch(cwd, builtBatch, options, operation, dependencies, semanticMoveDivergences, packageManifestImpacts) {
+    const operations = readOperations(builtBatch.payload);
+    const firstNonRename = operations.findIndex((item) => item.kind !== "renameSymbol");
+    const renameInternal = options.semanticContextPool
+        ? { semanticContextPool: options.semanticContextPool }
+        : undefined;
+    if (firstNonRename < 0) {
+        return dependencies.runRenameBatch(cwd, builtBatch, options.semanticRenameExecutionEvidence, undefined, renameInternal);
+    }
+    if (firstNonRename === 0 || operations.slice(firstNonRename).some((item) => item.kind === "renameSymbol")) {
+        return dependencies.runRenameBatch(cwd, builtBatch, options.semanticRenameExecutionEvidence, undefined, renameInternal);
+    }
+    const renameBatch = subsetBatch(builtBatch, operations.slice(0, firstNonRename));
+    const deferredBatch = subsetBatch(builtBatch, operations.slice(firstNonRename));
+    const renameResponse = await dependencies.runRenameBatch(cwd, renameBatch, options.semanticRenameExecutionEvidence, undefined, renameInternal);
+    if (renameResponse.batchOk !== true) {
+        return combineBatchResponses(renameResponse, skippedBatchResponse(operations.slice(firstNonRename)));
+    }
+    // Remote config overrides are intentionally disabled. Building this mixed request once with the
+    // Local effective config keeps standalone rename and move on one exact row set.
+    const deferredResponse = operations.slice(firstNonRename).some((item) => item.kind === "moveRefactor")
+        ? await runMoveBatchWithMetrics(cwd, deferredBatch, options, operation, dependencies, semanticMoveDivergences, packageManifestImpacts)
+        : unsupportedSemanticBatch();
+    return combineBatchResponses(renameResponse, deferredResponse);
+}
+async function runMoveBatchWithMetrics(cwd, builtBatch, options, operation, dependencies, semanticMoveDivergences, packageManifestImpacts) {
+    const metrics = (0, semantic_move_metrics_1.createSemanticMovePhaseMetrics)({
+        enabled: options.metricsEnabled === true,
+        cwd,
+        operation,
+        ...(options.semanticMoveMetricsExecutionId ? { executionId: options.semanticMoveMetricsExecutionId } : {})
+    });
+    try {
+        return await dependencies.runMoveBatch(cwd, builtBatch, options.semanticMoveExecutionEvidence, undefined, metrics, {
+            ...(options.semanticContextPool ? { semanticContextPool: options.semanticContextPool } : {}),
+            onDivergence: (divergence) => semanticMoveDivergences.push(divergence),
+            onPlan: (plan) => packageManifestImpacts.push(...(plan.packageManifestImpacts ?? []))
+        });
+    }
+    catch (error) {
+        metrics?.finish({
+            ok: false,
+            code: error instanceof Error ? error.name : "SEMANTIC_MOVE_UNEXPECTED_FAILURE",
+            entityCount: 0,
+            ownerConfigCount: 0,
+            editFileCount: 0,
+            textChangeCount: 0
+        });
+        throw error;
+    }
+}
+function unsupportedSemanticBatch() {
+    throw new errors_1.CliError("SEMANTIC_MUTATION_KIND_UNSUPPORTED", "Semantic mutation batch contains an unsupported internal operation kind.");
+}
+function readOperations(payload) {
+    return Array.isArray(payload.operations)
+        ? payload.operations.filter(isJsonObject).map((operation, index) => ({
+            id: readString(operation.id) ?? `row-${index + 1}`,
+            kind: readString(operation.kind) ?? "operation",
+            body: isJsonObject(operation.body) ? operation.body : {}
+        }))
+        : [];
+}
+function subsetBatch(builtBatch, operations) {
+    return {
+        payload: {
+            ...builtBatch.payload,
+            operations: operations.map((item) => ({ id: item.id, kind: item.kind, body: item.body }))
+        },
+        summary: builtBatch.summary
+    };
+}
+function skippedBatchResponse(operations) {
+    const rows = operations.map((operation, index) => {
+        const error = "Skipped because the preceding standalone rename transaction failed.";
+        return {
+            index: index + 1,
+            id: operation.id,
+            kind: operation.kind,
+            planned: true,
+            attempted: false,
+            outcome: "skipped",
+            ok: false,
+            skipped: true,
+            applied: false,
+            touchedFiles: [],
+            savedFiles: [],
+            error,
+            skipReason: error,
+            response: { ok: false, code: "BATCH_ROW_SKIPPED", error, skipped: true }
+        };
+    });
+    return {
+        ok: true,
+        operation: "refactorBatch",
+        batchOk: false,
+        batchStatus: "completedWithErrors",
+        requestedOperationCount: rows.length,
+        plannedOperationCount: rows.length,
+        attemptedRowCount: 0,
+        rowCount: rows.length,
+        passedRowCount: 0,
+        failedRowCount: 0,
+        skippedRowCount: rows.length,
+        rows
+    };
+}
+function combineBatchResponses(first, second) {
+    const firstRows = Array.isArray(first.rows) ? first.rows.filter(isJsonObject) : [];
+    const secondRows = Array.isArray(second.rows) ? second.rows.filter(isJsonObject) : [];
+    const rows = [...firstRows, ...secondRows].map((row, index) => ({ ...row, index: index + 1 }));
+    const failedRows = rows.filter((row) => row.ok === false && row.skipped !== true);
+    const skippedRows = rows.filter((row) => row.skipped === true);
+    const batchOk = first.batchOk === true && second.batchOk === true && failedRows.length === 0 && skippedRows.length === 0;
+    return {
+        ok: true,
+        operation: "refactorBatch",
+        contract: {
+            version: 2,
+            execution: "sequential-groups",
+            continueOnError: false,
+            rollback: "rename-group-only",
+            transactional: false
+        },
+        execution: "sequential-groups",
+        continueOnError: false,
+        batchOk,
+        batchStatus: batchOk ? "completed" : "completedWithErrors",
+        requestedOperationCount: rows.length,
+        plannedOperationCount: rows.length,
+        attemptedRowCount: rows.filter((row) => row.attempted === true).length,
+        rowCount: rows.length,
+        passedRowCount: rows.filter((row) => row.ok === true).length,
+        failedRowCount: failedRows.length,
+        skippedRowCount: skippedRows.length,
+        guidance: batchOk ? null : (first.guidance ?? second.guidance ?? null),
+        providerLimitations: [
+            ...(Array.isArray(first.providerLimitations) ? first.providerLimitations : []),
+            ...(Array.isArray(second.providerLimitations) ? second.providerLimitations : [])
+        ],
+        rows,
+        ...(typeof first.code === "string" ? { code: first.code } : typeof second.code === "string" ? { code: second.code } : {}),
+        ...(typeof first.error === "string" ? { error: first.error } : typeof second.error === "string" ? { error: second.error } : {}),
+        ...(typeof first.rollback === "string" ? { rollback: first.rollback } : {}),
+        ...(Array.isArray(first.potentiallyModifiedFiles)
+            ? { potentiallyModifiedFiles: first.potentiallyModifiedFiles }
+            : {}),
+        ...(Array.isArray(first.rollbackErrors) ? { rollbackErrors: first.rollbackErrors } : {}),
+        ...(isJsonObject(first.planner) ? { planner: first.planner } : {})
+    };
+}
+function buildEngineResult(cwd, operation, builtBatch, rawResponse, semanticMoveDivergences, packageManifestImpacts) {
+    const response = summarizeSemanticMutationResponse(cwd, rawResponse);
+    const result = {
+        ok: response.batchOk === true,
+        ...(response.batchOk === true ? {} : { code: readString(response.code) ?? "REFACTOR_BATCH_FAILED" }),
+        operation,
+        builder: builtBatch.summary,
+        response,
+        ...(typeof response.rollback === "string" ? { rollback: response.rollback } : {}),
+        ...(Array.isArray(response.potentiallyModifiedFiles)
+            ? { potentiallyModifiedFiles: response.potentiallyModifiedFiles }
+            : {}),
+        ...(Array.isArray(response.rollbackErrors) ? { rollbackErrors: response.rollbackErrors } : {})
+    };
+    return {
+        builtBatch,
+        response,
+        result,
+        internal: {
+            semanticMoveDivergences: [...semanticMoveDivergences],
+            packageManifestImpacts: uniquePackageManifestImpacts(packageManifestImpacts)
+        }
+    };
+}
+function uniquePackageManifestImpacts(impacts) {
+    return [...new Map(impacts.map((impact) => [JSON.stringify(impact), impact])).values()];
+}
+function containsRenameOperation(payload) {
+    return Array.isArray(payload.operations) && payload.operations.some((operation) => operation !== null && typeof operation === "object" && !Array.isArray(operation) && operation.kind === "renameSymbol");
+}
+function containsMoveOperation(payload) {
+    return Array.isArray(payload.operations) && payload.operations.some((operation) => operation !== null && typeof operation === "object" && !Array.isArray(operation) && operation.kind === "moveRefactor");
+}
+function summarizeSemanticMutationResponse(cwd, response) {
+    const rows = Array.isArray(response.rows)
+        ? response.rows.map((row) => summarizeRow(cwd, row))
+        : [];
+    return {
+        ok: response.ok === true,
+        operation: readString(response.operation),
+        contract: response.contract ?? null,
+        execution: readString(response.execution),
+        continueOnError: response.continueOnError === true,
+        batchOk: response.batchOk === true,
+        batchStatus: readString(response.batchStatus),
+        requestedOperationCount: readNumber(response.requestedOperationCount),
+        plannedOperationCount: readNumber(response.plannedOperationCount),
+        attemptedRowCount: readNumber(response.attemptedRowCount),
+        rowCount: readNumber(response.rowCount),
+        passedRowCount: readNumber(response.passedRowCount),
+        failedRowCount: readNumber(response.failedRowCount),
+        skippedRowCount: readNumber(response.skippedRowCount),
+        guidance: response.guidance ?? null,
+        providerLimitations: summarizeProviderLimitations(response.providerLimitations),
+        manualExtractionRequired: summarizeManualExtractionRows(rows),
+        rows,
+        ...(readString(response.code) ? { code: readString(response.code) } : {}),
+        ...(readString(response.error) ? { error: readString(response.error) } : {}),
+        ...(readString(response.rollback) ? { rollback: readString(response.rollback) } : {}),
+        ...(Array.isArray(response.potentiallyModifiedFiles)
+            ? { potentiallyModifiedFiles: readStringArray(response.potentiallyModifiedFiles).map((file) => compactPath(cwd, file)) }
+            : {}),
+        ...(Array.isArray(response.rollbackErrors) ? { rollbackErrors: readStringArray(response.rollbackErrors) } : {}),
+        ...(response._metrics ? { _metrics: response._metrics } : {})
+    };
+}
+function summarizeRow(cwd, rawRow) {
+    if (!rawRow || typeof rawRow !== "object" || Array.isArray(rawRow)) {
+        return {
+            ok: false,
+            error: "Invalid batch row shape."
+        };
+    }
+    const row = rawRow;
+    const nestedResponse = summarizeNestedResponse(cwd, row.response);
+    const nestedOperationSummary = isJsonObject(nestedResponse?.operationSummary) ? nestedResponse.operationSummary : null;
+    const nestedLocationPreview = isJsonObject(nestedResponse?.locationPreview) ? nestedResponse.locationPreview : null;
+    const touchedFiles = readStringArray(row.touchedFiles);
+    const fallbackTouchedFiles = readStringArray(nestedOperationSummary?.changedFiles);
+    const fallbackLocationFiles = readStringArray(nestedLocationPreview?.files);
+    if (row.skipped === true) {
+        return compactObject({
+            index: readNumber(row.index),
+            id: readString(row.id),
+            kind: readString(row.kind),
+            planned: row.planned === true,
+            attempted: false,
+            outcome: readString(row.outcome),
+            skipped: true,
+            skipReason: readString(row.skipReason),
+            error: readString(row.error)
+        });
+    }
+    return compactObject({
+        index: readNumber(row.index),
+        id: readString(row.id),
+        kind: readString(row.kind),
+        planned: row.planned === true,
+        attempted: row.attempted === true,
+        outcome: readString(row.outcome),
+        ok: row.ok === true,
+        statusCode: readNumber(row.statusCode),
+        durationMs: readNumber(row.durationMs),
+        applied: row.applied === true,
+        touchedFiles: (touchedFiles.length > 0 ? touchedFiles : fallbackTouchedFiles.length > 0 ? fallbackTouchedFiles : fallbackLocationFiles).map((file) => compactPath(cwd, file)),
+        savedFiles: readStringArray(row.savedFiles).map((file) => compactPath(cwd, file)),
+        error: readString(row.error),
+        availableSelectors: readStringArray(row.availableSelectors),
+        deferredRetry: summarizeDeferredRetry(row.deferredRetry),
+        providerLimitation: summarizeProviderLimitation(row.providerLimitation),
+        response: nestedResponse
+    });
+}
+function summarizeDeferredRetry(value) {
+    if (!isJsonObject(value)) {
+        return null;
+    }
+    return compactObject({
+        attemptedBeforeSuccess: readNumber(value.attemptedBeforeSuccess),
+        reason: readString(value.reason),
+        codes: readStringArray(value.codes)
+    });
+}
+function summarizeProviderLimitations(value) {
+    return Array.isArray(value)
+        ? value.filter(isJsonObject).map(summarizeProviderLimitation).filter((item) => item !== null)
+        : [];
+}
+function summarizeProviderLimitation(value) {
+    if (!isJsonObject(value)) {
+        return null;
+    }
+    return compactObject({
+        index: readNumber(value.index),
+        id: readString(value.id),
+        kind: readString(value.kind),
+        code: readString(value.code),
+        retryable: typeof value.retryable === "boolean" ? value.retryable : null,
+        continueTail: typeof value.continueTail === "boolean" ? value.continueTail : null
+    });
+}
+function summarizeManualExtractionRows(rows) {
+    return rows
+        .filter((row) => isManualExtractionRow(row))
+        .map((row) => compactObject({
+        index: readNumber(row.index),
+        id: readString(row.id),
+        kind: readString(row.kind),
+        code: readString(row.response && isJsonObject(row.response) ? row.response.code : null),
+        reason: readManualExtractionReason(row),
+        retryable: false
+    }));
+}
+function isManualExtractionRow(row) {
+    if (row.outcome === "manualExtractionRequired") {
+        return true;
+    }
+    const response = isJsonObject(row.response) ? row.response : null;
+    const code = readString(response?.code);
+    const error = readString(row.error) ?? readString(response?.error) ?? "";
+    return code === "TS_MOVE_TO_FILE_UNSUPPORTED_BY_ENGINE" ||
+        (code === "TS_MOVE_TO_FILE_REFACTOR_FAILED" && /Changes overlap/i.test(error));
+}
+function readManualExtractionReason(row) {
+    const response = isJsonObject(row.response) ? row.response : null;
+    const code = readString(response?.code);
+    const error = readString(row.error) ?? readString(response?.error) ?? "";
+    if (code === "TS_MOVE_TO_FILE_UNSUPPORTED_BY_ENGINE") {
+        return "providerUnsupported";
+    }
+    if (code === "TS_MOVE_TO_FILE_REFACTOR_FAILED" && /Changes overlap/i.test(error)) {
+        return "changesOverlapAfterDeferredRetry";
+    }
+    return null;
+}
+function compactPath(cwd, filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    const cwdNormalized = cwd.replace(/\\/g, "/").replace(/\/$/, "");
+    const lower = normalized.toLowerCase();
+    const cwdLower = cwdNormalized.toLowerCase();
+    return lower.startsWith(`${cwdLower}/`) ? normalized.slice(cwdNormalized.length + 1) : normalized;
+}
+function summarizeNestedResponse(cwd, value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const response = value;
+    return compactObject({
+        ok: response.ok === true,
+        code: readString(response.code),
+        errorCode: readString(response.errorCode),
+        error: readString(response.error),
+        hint: readString(response.hint),
+        execute: typeof response.execute === "boolean" ? response.execute : null,
+        applied: typeof response.applied === "boolean" ? response.applied : null,
+        operationSummary: summarizeNestedOperationSummary(response.operationSummary),
+        locationPreview: summarizeNestedLocationPreview(cwd, response.locationPreview)
+    });
+}
+function summarizeNestedOperationSummary(value) {
+    if (!isJsonObject(value)) {
+        return null;
+    }
+    return compactObject({
+        operation: readString(value.operation),
+        editCount: readNumber(value.editCount),
+        changedFiles: readStringArray(value.changedFiles)
+    });
+}
+function summarizeNestedLocationPreview(cwd, value) {
+    if (!isJsonObject(value)) {
+        return null;
+    }
+    const fileCounts = countLocationFiles(cwd, value);
+    return compactObject({
+        locationCount: readNumber(value.locationCount),
+        files: readStringArray(value.files),
+        fileCounts
+    });
+}
+function countLocationFiles(cwd, value) {
+    const providedCounts = readStringArray(value.fileCounts);
+    if (providedCounts.length > 0) {
+        return compactProvidedFileCounts(cwd, providedCounts);
+    }
+    const counts = new Map();
+    const locations = Array.isArray(value.locations) ? value.locations.filter(isJsonObject) : [];
+    for (const location of locations) {
+        const file = readLocationFile(location);
+        if (!file) {
+            continue;
+        }
+        const compactFile = compactPath(cwd, file);
+        counts.set(compactFile, (counts.get(compactFile) ?? 0) + 1);
+    }
+    if (counts.size === 0) {
+        for (const file of readStringArray(value.files)) {
+            const compactFile = compactPath(cwd, file);
+            counts.set(compactFile, (counts.get(compactFile) ?? 0) + 1);
+        }
+    }
+    return Array.from(counts.entries())
+        .sort((left, right) => left[0].localeCompare(right[0]))
+        .map(([file, count]) => `${file} x${count}`);
+}
+function compactProvidedFileCounts(cwd, items) {
+    const counts = new Map();
+    for (const item of items) {
+        const match = /^(.*) x(\d+)$/.exec(item);
+        if (!match) {
+            continue;
+        }
+        const file = compactPath(cwd, match[1]);
+        const key = file.toLowerCase();
+        const previous = counts.get(key);
+        counts.set(key, {
+            file: previous?.file ?? file,
+            count: (previous?.count ?? 0) + Number(match[2])
+        });
+    }
+    return Array.from(counts.values())
+        .sort((left, right) => left.file.localeCompare(right.file))
+        .map(({ file, count }) => `${file} x${count}`);
+}
+function readLocationFile(location) {
+    for (const key of ["fileName", "file", "path", "sourceFile"]) {
+        const value = location[key];
+        if (typeof value === "string" && value.length > 0) {
+            return value;
+        }
+    }
+    return null;
+}
+function isJsonObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" ? value : null;
+}
+function readNumber(value) {
+    return typeof value === "number" ? value : null;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function compactObject(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => {
+        if (value === null || value === undefined) {
+            return false;
+        }
+        return !(Array.isArray(value) && value.length === 0);
+    }));
+}