@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/mutate-execution-status.js

@@ -0,0 +1,598 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCachedMutateExecution = readCachedMutateExecution;
+exports.buildCachedMutateExecutionResponseForStatus = buildCachedMutateExecutionResponseForStatus;
+exports.buildExecuteExecutionGroups = buildExecuteExecutionGroups;
+exports.buildApplyExecutionGroups = buildApplyExecutionGroups;
+exports.markMutateGroupRunning = markMutateGroupRunning;
+exports.markMutateGroupDelegated = markMutateGroupDelegated;
+exports.markMutateGroupFinished = markMutateGroupFinished;
+exports.markMutateGroupsNotRun = markMutateGroupsNotRun;
+exports.finalizeMutateStatusRows = finalizeMutateStatusRows;
+exports.markMutateGroupSemanticProgress = markMutateGroupSemanticProgress;
+exports.markMutateGroupApplying = markMutateGroupApplying;
+exports.buildMutateStillRunningResponse = buildMutateStillRunningResponse;
+exports.selectMutatePollingPolicy = selectMutatePollingPolicy;
+exports.buildMutateStillRunningResponseForStatus = buildMutateStillRunningResponseForStatus;
+exports.formatMutateStillRunningText = formatMutateStillRunningText;
+exports.formatMutateExecutionStatusText = formatMutateExecutionStatusText;
+exports.buildMutateExecutionSummary = buildMutateExecutionSummary;
+exports.formatMutatePhaseLine = formatMutatePhaseLine;
+exports.estimateSegmentRows = estimateSegmentRows;
+exports.buildMutatePlan = buildMutatePlan;
+exports.readPlanGroupRowCount = readPlanGroupRowCount;
+exports.readPlanGroupInputRowCount = readPlanGroupInputRowCount;
+exports.readPlanGroupDeclarationCount = readPlanGroupDeclarationCount;
+exports.readPlanGroupEstimateMs = readPlanGroupEstimateMs;
+exports.readPlanGroupEta = readPlanGroupEta;
+exports.estimateResponseRows = estimateResponseRows;
+exports.estimateResponseCompletedRows = estimateResponseCompletedRows;
+exports.estimateResponseFailedRows = estimateResponseFailedRows;
+exports.readResponseRows = readResponseRows;
+exports.collectFilesWritten = collectFilesWritten;
+exports.collectFilesTouched = collectFilesTouched;
+exports.collectResponsesFilesWritten = collectResponsesFilesWritten;
+exports.collectResponsesFilesTouched = collectResponsesFilesTouched;
+exports.mergeMutateStatusFiles = mergeMutateStatusFiles;
+exports.readMutatePhase = readMutatePhase;
+exports.estimateMutateDurationMs = estimateMutateDurationMs;
+exports.readMutateSyncWaitMs = readMutateSyncWaitMs;
+exports.maybeDelayMutateForTest = maybeDelayMutateForTest;
+exports.startMutateBackgroundJob = startMutateBackgroundJob;
+exports.maybeDeferMutateBackgroundWorkForStatus = maybeDeferMutateBackgroundWorkForStatus;
+exports.formatDuration = formatDuration;
+const agent_text_1 = require("../shared/agent-text");
+const env_vars_1 = require("../config/env-vars");
+const runtime_lifecycle_1 = require("../session/runtime-lifecycle");
+const semantic_mutation_runtime_1 = require("../mutation/semantic-mutation-runtime");
+const mutation_estimate_1 = require("../mutation/mutation-estimate");
+const mutation_plan_1 = require("../mutation/mutation-plan");
+const mutate_domain_adapters_1 = require("./mutate-domain-adapters");
+const mutate_execution_cache_1 = require("./mutate-execution-cache");
+const mutation_execution_cache_1 = require("./mutation-execution-cache");
+const mutation_eta_1 = require("./mutation-eta");
+const rename_polling_policy_1 = require("./rename-polling-policy");
+const mutate_output_values_1 = require("./mutate-output-values");
+function readCachedMutateExecution(cwd, executionId, options = {}) {
+    const status = (0, mutate_execution_cache_1.readMutateExecutionStatus)(cwd, executionId);
+    if ((status.status === "completed" || status.status === "failed") && status.result) {
+        return attachTerminalMutateExecutionIdentity(status);
+    }
+    return buildCachedMutateExecutionResponseForStatus(status, options);
+}
+function attachTerminalMutateExecutionIdentity(status) {
+    const result = status.result ?? {};
+    const childExecutionIds = status.groups
+        .map((group) => group.executionId)
+        .filter((value) => typeof value === "string" && value.length > 0);
+    if (childExecutionIds.length === 0) {
+        return result;
+    }
+    const identityLine = `${status.operation} ${status.executionId} ${status.status}`;
+    const existingText = (0, agent_text_1.readAgentText)(result);
+    const lines = existingText ? existingText.split(/\r?\n/) : [];
+    if (lines[0]?.startsWith(`${status.operation} `)) {
+        lines[0] = identityLine;
+    }
+    else {
+        lines.unshift(identityLine);
+    }
+    return (0, agent_text_1.attachAgentText)({
+        ...result,
+        executionId: status.executionId,
+        childExecutionIds
+    }, lines.join("\n"));
+}
+function buildCachedMutateExecutionResponseForStatus(status, options = {}) {
+    const repeatedEta = buildRepeatedRenameStatusEta(status, options.nowMs ?? Date.now());
+    const response = {
+        operation: "execution.status",
+        executionId: status.executionId,
+        status: status.status,
+        phase: status.phase,
+        summary: buildMutateExecutionSummary(status),
+        progress: `${status.processedRows ?? status.completedRows}/${status.rowCount}`,
+        ...(status.declarationCount !== undefined ? {
+            declarationProgress: `${status.processedDeclarations ?? 0}/${status.declarationCount}`
+        } : {}),
+        filesWritten: status.filesWritten,
+        filesTouched: status.filesTouched,
+        potentiallyModifiedFiles: status.potentiallyModifiedFiles ?? [],
+        groups: status.groups,
+        updatedAt: status.updatedAt,
+        ...(status.error ? { error: status.error } : {}),
+        ...(repeatedEta ? {
+            suggestedNextCheckMs: rename_polling_policy_1.RENAME_SURVIVAL_POLL_DELAY_MS,
+            next: repeatedEta.next
+        } : {})
+    };
+    return (0, agent_text_1.attachAgentText)(response, formatMutateExecutionStatusText(status, {
+        includeOperationHeader: options.includeOperationHeader === true,
+        ...(repeatedEta ? { next: repeatedEta.next } : {})
+    }));
+}
+function buildExecuteExecutionGroups(segments, plan) {
+    return segments.map((segment, index) => buildExecutionGroup(segment, index, plan, readPlanGroupEstimateMs(plan, index) ?? (0, mutate_domain_adapters_1.estimateMutateSegmentDurationMs)(segment)));
+}
+function buildApplyExecutionGroups(intentSegments, previewSegments, plan) {
+    return intentSegments.map((segment, index) => ({
+        ...buildExecutionGroup(segment, index, plan, readPlanGroupEstimateMs(plan, index) ?? (0, mutate_domain_adapters_1.estimateMutateSegmentDurationMs)(segment)),
+        ...(previewSegments[index]?.childId ? { executionId: previewSegments[index].childId } : {}),
+        summary: (0, mutate_output_values_1.readSummary)(previewSegments[index]?.response),
+        filesTouched: previewSegments[index]?.response ? collectFilesTouched(previewSegments[index].response) : []
+    }));
+}
+function buildExecutionGroup(segment, index, plan, estimatedDurationMs) {
+    const semantic = segment.kind === "semantic";
+    const declarationCount = semantic
+        ? readPlanGroupDeclarationCount(plan, index) ?? (0, semantic_mutation_runtime_1.estimateSemanticMutationRowCount)({ requests: (0, mutate_output_values_1.readObjectArray)(segment.requests) })
+        : undefined;
+    return {
+        index: index + 1,
+        kind: String(segment.kind ?? "unknown"),
+        rowCount: readPlanGroupInputRowCount(plan, index) ?? estimateSegmentInputRows(segment),
+        processedRows: 0,
+        ...(declarationCount !== undefined ? {
+            declarationCount,
+            processedDeclarations: 0,
+            failedDeclarations: 0
+        } : {}),
+        estimatedDurationMs,
+        ...(readPlanGroupEta(plan, index) ? { eta: readPlanGroupEta(plan, index) } : {}),
+        completedRows: 0,
+        failedRows: 0,
+        status: "pending"
+    };
+}
+function markMutateGroupRunning(cwd, status, index) {
+    if (!status) {
+        return;
+    }
+    const group = status.groups[index];
+    if (!group) {
+        return;
+    }
+    group.status = "running";
+    status.status = "running";
+    status.phase = readMutatePhase(group.kind);
+    status.currentGroupIndex = group.index;
+    (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+}
+function markMutateGroupDelegated(cwd, status, index, childExecutionId) {
+    if (!status) {
+        return;
+    }
+    const group = status.groups[index];
+    if (!group) {
+        return;
+    }
+    group.status = "running";
+    group.executionId = childExecutionId;
+    status.status = "running";
+    status.currentGroupIndex = group.index;
+    finalizeMutateStatusRows(status);
+    (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+}
+function markMutateGroupFinished(cwd, status, index, response) {
+    if (!status) {
+        return;
+    }
+    if (response.operation === "execution.status" && response.status === "running" && typeof response.executionId === "string") {
+        markMutateGroupDelegated(cwd, status, index, response.executionId);
+        return;
+    }
+    const group = status.groups[index];
+    if (!group) {
+        return;
+    }
+    const failed = response.ok === false;
+    group.status = failed ? "failed" : "completed";
+    group.processedRows = group.rowCount;
+    if (failed) {
+        const knownFailedRows = Math.min(group.rowCount, Math.max(1, group.failedRows, estimateResponseFailedRows(response)));
+        group.failedRows = knownFailedRows;
+        group.completedRows = Math.max(0, group.rowCount - knownFailedRows);
+    }
+    else {
+        group.completedRows = group.rowCount;
+        group.failedRows = 0;
+    }
+    if (group.declarationCount !== undefined) {
+        group.processedDeclarations = group.declarationCount;
+        group.failedDeclarations = failed
+            ? Math.min(group.declarationCount, Math.max(group.failedDeclarations ?? 0, estimateResponseFailedRows(response)))
+            : 0;
+    }
+    group.summary = (0, mutate_output_values_1.readSummary)(response);
+    group.filesWritten = collectFilesWritten(response);
+    group.filesTouched = collectFilesTouched(response);
+    group.potentiallyModifiedFiles = (0, mutate_output_values_1.readStringArray)(response.potentiallyModifiedFiles);
+    delete group.applyPhase;
+    mergeMutateStatusFiles(status, response);
+    finalizeMutateStatusRows(status);
+    (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+}
+function markMutateGroupsNotRun(cwd, status, startIndex) {
+    if (!status) {
+        return;
+    }
+    for (let index = startIndex; index < status.groups.length; index += 1) {
+        const group = status.groups[index];
+        if (group && group.status === "pending") {
+            group.status = "notRun";
+        }
+    }
+    finalizeMutateStatusRows(status);
+    (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+}
+function finalizeMutateStatusRows(status) {
+    status.completedGroups = status.groups.filter((group) => group.status === "completed").length;
+    status.failedGroups = status.groups.filter((group) => group.status === "failed").length;
+    status.notRunGroups = status.groups.filter((group) => group.status === "notRun").length;
+    status.completedRows = status.groups.reduce((sum, group) => sum + group.completedRows, 0);
+    status.processedRows = status.groups.reduce((sum, group) => sum + Math.min(group.rowCount, group.processedRows ?? group.completedRows + group.failedRows), 0);
+    status.failedRows = status.groups.reduce((sum, group) => sum + group.failedRows, 0);
+    status.notRunRows = status.groups
+        .filter((group) => group.status === "notRun")
+        .reduce((sum, group) => sum + group.rowCount, 0);
+    status.filesWritten = (0, mutate_output_values_1.uniqueStrings)(status.filesWritten);
+    status.filesTouched = (0, mutate_output_values_1.uniqueStrings)(status.filesTouched);
+    status.potentiallyModifiedFiles = (0, mutate_output_values_1.uniqueStrings)(status.groups.flatMap((group) => group.potentiallyModifiedFiles ?? []));
+    const declarationGroups = status.groups.filter((group) => group.declarationCount !== undefined);
+    if (declarationGroups.length > 0) {
+        status.declarationCount = declarationGroups.reduce((sum, group) => sum + (group.declarationCount ?? 0), 0);
+        status.processedDeclarations = declarationGroups.reduce((sum, group) => sum + Math.min(group.declarationCount ?? 0, group.processedDeclarations ?? 0), 0);
+        status.failedDeclarations = declarationGroups.reduce((sum, group) => sum + (group.failedDeclarations ?? 0), 0);
+    }
+}
+function markMutateGroupSemanticProgress(cwd, status, index, progress) {
+    if (!status)
+        return;
+    const group = status.groups[index];
+    if (!group || group.declarationCount === undefined)
+        return;
+    group.processedRows = Math.min(group.rowCount, (group.processedRows ?? 0) + Math.max(0, progress.finalizedRows));
+    group.completedRows = Math.min(group.rowCount, group.completedRows + Math.max(0, progress.finalizedRows - progress.failedRows));
+    group.failedRows = Math.min(group.rowCount, group.failedRows + Math.max(0, progress.failedRows));
+    group.processedDeclarations = Math.min(group.declarationCount, (group.processedDeclarations ?? 0) + Math.max(0, progress.finalizedDeclarations));
+    group.failedDeclarations = Math.min(group.declarationCount, (group.failedDeclarations ?? 0) + Math.max(0, progress.failedDeclarations));
+    finalizeMutateStatusRows(status);
+    (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+}
+function markMutateGroupApplying(cwd, status, index, writeSet) {
+    if (!status) {
+        return;
+    }
+    const group = status.groups[index];
+    if (!group) {
+        return;
+    }
+    const exactWriteSet = (0, mutate_output_values_1.uniqueStrings)([...writeSet]);
+    group.status = "running";
+    group.applyPhase = "applying";
+    group.plannedWriteSet = exactWriteSet;
+    group.potentiallyModifiedFiles = exactWriteSet;
+    status.phase = "applying";
+    status.status = "running";
+    status.currentGroupIndex = group.index;
+    finalizeMutateStatusRows(status);
+    (0, mutate_execution_cache_1.writeMutateExecutionStatus)(cwd, status);
+}
+function buildMutateStillRunningResponse(cwd, executionId, operation, estimatedDurationMs, elapsedMs, syncWaitMs) {
+    const status = (0, mutate_execution_cache_1.readMutateExecutionStatus)(cwd, executionId);
+    return buildMutateStillRunningResponseForStatus(status, operation, estimatedDurationMs, elapsedMs, syncWaitMs);
+}
+function selectMutatePollingPolicy(segments) {
+    return (0, rename_polling_policy_1.countRenameOnlySemanticRows)(segments) !== null ? rename_polling_policy_1.RENAME_SURVIVAL_POLLING_POLICY : undefined;
+}
+function buildMutateStillRunningResponseForStatus(status, operation, estimatedDurationMs, elapsedMs, syncWaitMs) {
+    const estimatedRemainingMs = Math.max(0, estimatedDurationMs - elapsedMs);
+    const selectedDelayMs = status.pollingPolicy === rename_polling_policy_1.RENAME_SURVIVAL_POLLING_POLICY
+        ? (0, rename_polling_policy_1.selectRenamePollingDelayMs)({ estimatedDurationMs, elapsedMs, syncWaitMs })
+        : estimatedRemainingMs;
+    const eta = (0, mutation_eta_1.buildMutationEtaHint)(status.executionId, selectedDelayMs);
+    const response = {
+        operation: "execution.status",
+        executionId: status.executionId,
+        status: status.status,
+        phase: status.phase,
+        summary: buildMutateExecutionSummary(status),
+        progress: `${status.processedRows ?? status.completedRows}/${status.rowCount}`,
+        ...(status.declarationCount !== undefined ? {
+            declarationProgress: `${status.processedDeclarations ?? 0}/${status.declarationCount}`
+        } : {}),
+        filesWritten: status.filesWritten,
+        filesTouched: status.filesTouched,
+        potentiallyModifiedFiles: status.potentiallyModifiedFiles ?? [],
+        groups: status.groups,
+        updatedAt: status.updatedAt,
+        estimatedRemainingMs: eta.estimatedRemainingMs,
+        suggestedFirstCheckMs: eta.suggestedFirstCheckMs,
+        next: eta.next
+    };
+    return (0, agent_text_1.attachAgentText)(response, formatMutateStillRunningText(operation, status, eta));
+}
+function formatMutateStillRunningText(operation, status, eta) {
+    return [
+        `${operation} ${status.executionId}`,
+        buildMutateExecutionSummary(status),
+        formatMutatePhaseLine(status),
+        ...(0, mutation_eta_1.formatMutationEtaLines)(eta)
+    ].join("\n");
+}
+function formatMutateExecutionStatusText(status, options = {}) {
+    const lines = [];
+    if (options.includeOperationHeader && status.status === "running") {
+        lines.push(`${status.operation} ${status.executionId}`);
+    }
+    lines.push(buildMutateExecutionSummary(status));
+    if (status.status === "running") {
+        lines.push(formatMutatePhaseLine(status));
+    }
+    if (options.next && status.status === "running") {
+        lines.push(`next: ${options.next}`);
+    }
+    if (status.error) {
+        lines.push(status.error);
+    }
+    return lines.join("\n");
+}
+function buildRepeatedRenameStatusEta(status, nowMs) {
+    if (status.status !== "running" || status.pollingPolicy !== rename_polling_policy_1.RENAME_SURVIVAL_POLLING_POLICY) {
+        return null;
+    }
+    const startedAtMs = Date.parse(status.startedAt);
+    if (!Number.isFinite(startedAtMs) || !Number.isFinite(nowMs) || nowMs - startedAtMs < rename_polling_policy_1.STANDARD_RENAME_SYNC_WAIT_MS) {
+        return null;
+    }
+    return (0, mutation_eta_1.buildMutationEtaHint)(status.executionId, rename_polling_policy_1.RENAME_SURVIVAL_POLL_DELAY_MS);
+}
+function buildMutateExecutionSummary(status) {
+    if (status.status === "completed") {
+        return `completed, ${status.completedRows}/${status.rowCount} rows, ${status.completedGroups}/${status.groupCount} groups, ${status.filesWritten.length} files written`;
+    }
+    if (status.status === "failed") {
+        const parts = [
+            `failed, ${status.completedRows}/${status.rowCount} rows`,
+            `${status.failedGroups} failed`
+        ];
+        if (status.notRunGroups > 0) {
+            parts.push(`${status.notRunGroups} not run`);
+        }
+        return parts.join(", ");
+    }
+    const parts = [
+        `in progress, ${status.processedRows ?? status.completedRows}/${status.rowCount} rows`
+    ];
+    if (status.declarationCount !== undefined) {
+        parts.push(`${status.processedDeclarations ?? 0}/${status.declarationCount} declarations`);
+    }
+    parts.push(`${status.completedGroups}/${status.groupCount} groups`);
+    return parts.join(", ");
+}
+function formatMutatePhaseLine(status) {
+    if (status.phase === "file") {
+        return "moving/renaming files";
+    }
+    if (status.phase === "modulePlan") {
+        return "moving declarations";
+    }
+    if (status.phase === "imports.normalize") {
+        return "normalizing imports";
+    }
+    if (status.phase === "imports.rebase") {
+        return "rebasing imports";
+    }
+    if (status.phase === "declaration") {
+        return "applying declaration mutations";
+    }
+    return "applying semantic mutations";
+}
+function estimateSegmentRows(segment) {
+    if (segment.kind === "semantic") {
+        const renameRows = (0, rename_polling_policy_1.countRenameOnlySemanticRows)([segment]);
+        if (renameRows !== null) {
+            return renameRows;
+        }
+        return (0, semantic_mutation_runtime_1.estimateSemanticMutationRowCount)({ requests: (0, mutate_output_values_1.readObjectArray)(segment.requests) });
+    }
+    if (segment.kind === "file") {
+        return Math.max(1, (0, mutate_output_values_1.readObjectArray)(segment.operations).length);
+    }
+    if (segment.kind === "modulePlan") {
+        return Math.max(1, (0, mutate_output_values_1.readObjectArray)(segment.modules).length);
+    }
+    if (segment.kind === "imports.normalize" || segment.kind === "imports.rebase") {
+        return 1;
+    }
+    if (segment.kind === "declaration") {
+        const request = (0, mutate_output_values_1.isObject)(segment.request) ? segment.request : {};
+        return Math.max(1, (0, mutate_output_values_1.readStringArray)(request.files).length || (0, mutate_output_values_1.readStringArray)(request.selectors).length || 1);
+    }
+    return 1;
+}
+function estimateSegmentInputRows(segment) {
+    if (segment.kind === "semantic") {
+        return Math.max(1, (0, mutate_output_values_1.readObjectArray)(segment.requests).length);
+    }
+    return estimateSegmentRows(segment);
+}
+function buildMutatePlan(cwd, operation, segments) {
+    return (0, mutation_plan_1.buildMutationPlanFromSegments)({
+        cwd,
+        operation,
+        segments
+    });
+}
+function readPlanGroupRowCount(plan, index) {
+    const groups = Array.isArray(plan?.groups) ? plan.groups.filter(mutate_output_values_1.isObject) : [];
+    const rows = Array.isArray(groups[index]?.rows) ? groups[index].rows : [];
+    return rows.length > 0 ? rows.length : null;
+}
+function readPlanGroupInputRowCount(plan, index) {
+    const groups = Array.isArray(plan?.groups) ? plan.groups.filter(mutate_output_values_1.isObject) : [];
+    const value = groups[index]?.inputRowCount;
+    return typeof value === "number" && value > 0 ? value : null;
+}
+function readPlanGroupDeclarationCount(plan, index) {
+    const groups = Array.isArray(plan?.groups) ? plan.groups.filter(mutate_output_values_1.isObject) : [];
+    const value = groups[index]?.declarationCount;
+    return typeof value === "number" && value > 0 ? value : readPlanGroupRowCount(plan, index);
+}
+function readPlanGroupEstimateMs(plan, index) {
+    const groups = Array.isArray(plan?.groups) ? plan.groups.filter(mutate_output_values_1.isObject) : [];
+    const group = groups[index];
+    if (!group) {
+        return null;
+    }
+    if (group.domain === "file" && (0, mutate_output_values_1.isObject)(group.eta) && typeof group.eta.selectedMs === "number" && group.eta.selectedMs > 0) {
+        return group.eta.selectedMs;
+    }
+    if (!(0, mutate_output_values_1.isObject)(group.estimate)) {
+        return null;
+    }
+    if (typeof group.estimate.semanticSelectedDurationMs === "number" && group.estimate.semanticSelectedDurationMs > 0) {
+        return group.estimate.semanticSelectedDurationMs;
+    }
+    return (0, mutation_estimate_1.estimateMutationPlanDurationMs)(group.estimate);
+}
+function readPlanGroupEta(plan, index) {
+    const groups = Array.isArray(plan?.groups) ? plan.groups.filter(mutate_output_values_1.isObject) : [];
+    const group = groups[index];
+    return (0, mutate_output_values_1.isObject)(group?.eta) ? group.eta : null;
+}
+function estimateResponseRows(response) {
+    const responseRows = readResponseRows(response);
+    return Math.max(1, responseRows.length);
+}
+function estimateResponseCompletedRows(response) {
+    const rows = readResponseRows(response);
+    if (rows.length === 0) {
+        return response.ok === false ? 0 : 1;
+    }
+    return rows.filter((row) => row.ok !== false).length;
+}
+function estimateResponseFailedRows(response) {
+    const rows = readResponseRows(response);
+    if (rows.length === 0) {
+        return response.ok === false ? 1 : 0;
+    }
+    return rows.filter((row) => row.ok === false).length;
+}
+function readResponseRows(response) {
+    const nested = (0, mutate_output_values_1.isObject)(response?.response) ? response.response : null;
+    if (Array.isArray(nested?.rows)) {
+        return nested.rows.filter(mutate_output_values_1.isObject);
+    }
+    if (Array.isArray(response?.rows)) {
+        return response.rows.filter(mutate_output_values_1.isObject);
+    }
+    return [];
+}
+function collectFilesWritten(response) {
+    const direct = (0, mutate_output_values_1.readStringArray)(response.filesWritten);
+    const nested = (0, mutate_output_values_1.isObject)(response.response) ? collectFilesWritten(response.response) : [];
+    const rows = readResponseRows(response);
+    return (0, mutate_output_values_1.uniqueStrings)([
+        ...direct,
+        ...nested,
+        ...rows.flatMap((row) => [
+            ...(0, mutate_output_values_1.readStringArray)(row.savedFiles),
+            ...(0, mutate_output_values_1.readStringArray)(row.filesWritten)
+        ])
+    ]);
+}
+function collectFilesTouched(response) {
+    const direct = [
+        ...(0, mutate_output_values_1.readStringArray)(response.filesTouched),
+        ...(0, mutate_output_values_1.readStringArray)(response.filesChanged),
+        ...(0, mutate_output_values_1.readStringArray)(response.filesMoved),
+        ...(0, mutate_output_values_1.readStringArray)(response.filesRenamed),
+        ...(0, mutate_output_values_1.readStringArray)(response.files)
+    ];
+    const nested = (0, mutate_output_values_1.isObject)(response.response) ? collectFilesTouched(response.response) : [];
+    const rows = readResponseRows(response);
+    return (0, mutate_output_values_1.uniqueStrings)([
+        ...direct,
+        ...nested,
+        ...rows.flatMap((row) => [
+            ...(0, mutate_output_values_1.readStringArray)(row.savedFiles),
+            ...(0, mutate_output_values_1.readStringArray)(row.filesWritten),
+            ...(0, mutate_output_values_1.readStringArray)(row.filesTouched),
+            ...(0, mutate_output_values_1.readStringArray)(row.filesChanged)
+        ])
+    ]).filter((file) => !file.startsWith("+"));
+}
+function collectResponsesFilesWritten(responses) {
+    return (0, mutate_output_values_1.uniqueStrings)(responses.flatMap((response) => collectFilesWritten(response)));
+}
+function collectResponsesFilesTouched(responses) {
+    return (0, mutate_output_values_1.uniqueStrings)(responses.flatMap((response) => collectFilesTouched(response)));
+}
+function mergeMutateStatusFiles(status, response) {
+    status.filesWritten = (0, mutate_output_values_1.uniqueStrings)([...status.filesWritten, ...collectFilesWritten(response)]);
+    status.filesTouched = (0, mutate_output_values_1.uniqueStrings)([...status.filesTouched, ...collectFilesTouched(response)]);
+}
+function readMutatePhase(kind) {
+    if (kind === "file") {
+        return "file";
+    }
+    if (kind === "modulePlan") {
+        return "modulePlan";
+    }
+    if (kind === "imports.normalize" || kind === "imports.rebase") {
+        return kind;
+    }
+    if (kind === "declaration") {
+        return "declaration";
+    }
+    if (kind === "exports.object") {
+        return "exports.object";
+    }
+    return "semantic";
+}
+function estimateMutateDurationMs(status) {
+    if (typeof status.estimatedDurationMs === "number" && status.estimatedDurationMs > 0) {
+        return Math.max(status.estimatedDurationMs, 5_000);
+    }
+    const groupEstimate = status.groups.reduce((sum, group) => sum + (group.estimatedDurationMs ?? 0), 0);
+    if (groupEstimate > 0) {
+        return Math.max(groupEstimate, 5_000);
+    }
+    return 12_000 + Math.max(1, status.rowCount) * 2_000;
+}
+function readMutateSyncWaitMs() {
+    return (0, mutation_execution_cache_1.readMutationSyncWaitMs)(process.env[env_vars_1.CLI_ENV.mutateSyncWaitMs], 120_000);
+}
+async function maybeDelayMutateForTest() {
+    const raw = process.env[env_vars_1.CLI_ENV.testMutateDelayMs];
+    if (!raw) {
+        return;
+    }
+    const delayMs = Number.parseInt(raw, 10);
+    if (!Number.isFinite(delayMs) || delayMs <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, Math.min(delayMs, 120_000)));
+}
+function startMutateBackgroundJob(job) {
+    return (0, runtime_lifecycle_1.trackSessionBackgroundPromise)(new Promise((resolve, reject) => {
+        setImmediate(() => {
+            job().then(resolve, reject);
+        });
+    }), "mutate-background");
+}
+async function maybeDeferMutateBackgroundWorkForStatus(syncWaitMs, segments) {
+    if (syncWaitMs <= 0 || syncWaitMs > 5_000 || !segments.some((segment) => segment.kind !== "file")) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, syncWaitMs + 25));
+}
+function formatDuration(milliseconds) {
+    const seconds = Math.max(1, Math.round(milliseconds / 1000));
+    if (seconds < 60) {
+        return `~${seconds} sec`;
+    }
+    const minutes = Math.max(1, Math.round(seconds / 60));
+    return `~${minutes} min`;
+}