@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/file-rename.js

@@ -0,0 +1,1053 @@
+"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.runFileRename = runFileRename;
+exports.runFileRenameExecutionWorker = runFileRenameExecutionWorker;
+exports.readCachedFileRenameExecution = readCachedFileRenameExecution;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const zod_1 = require("zod");
+const env_vars_1 = require("../config/env-vars");
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const inspect_cycles_1 = require("./inspect-cycles");
+const mutation_eta_1 = require("./mutation-eta");
+const file_rename_preview_cache_1 = require("./file-rename-preview-cache");
+const file_rename_execution_cache_1 = require("./file-rename-execution-cache");
+const file_mutation_runtime_1 = require("./file-mutation-runtime");
+const mutation_execution_cache_1 = require("./mutation-execution-cache");
+const mutate_child_execution_1 = require("./mutate-child-execution");
+const file_mutation_worker_apply_1 = require("./file-mutation-worker-apply");
+const file_impact_scan_1 = require("../mutation/file-impact-scan");
+const runtime_lifecycle_1 = require("../session/runtime-lifecycle");
+const FileRenamePayloadSchema = zod_1.z.object({
+    base: zod_1.z.string().min(1),
+    renames: zod_1.z.array(zod_1.z.object({
+        source: zod_1.z.string().min(1),
+        target: zod_1.z.string().min(1)
+    })).min(1),
+    execute: zod_1.z.boolean().optional()
+});
+async function runFileRename(cwd, rawPayload, options = {}, restArgs = []) {
+    const runtimeOptions = readFileRenameRuntimeOptions();
+    const action = restArgs[0] ?? "preview";
+    if (action === "help" || action === "--help") {
+        return FileRenameHelp();
+    }
+    if (action === "apply") {
+        const previewId = restArgs[1];
+        if (!previewId || previewId.startsWith("--")) {
+            throw new errors_1.CliError("FILE_RENAME_PREVIEW_ID_REQUIRED", "file rename apply expects a preview id.", {
+                usage: "aib file rename apply <previewId>"
+            });
+        }
+        return applyFileRenamePreview(cwd, previewId, options, runtimeOptions);
+    }
+    if (action !== "preview" && action !== "execute" && action !== "validate") {
+        throw new errors_1.CliError("UNKNOWN_FILE_RENAME_COMMAND", `Unknown file rename command: ${action}`, {
+            availableCommands: ["preview", "apply", "execute", "validate", "help"]
+        });
+    }
+    const payload = FileRenamePayloadSchema.parse(rawPayload);
+    if (action === "execute" && readFileRenameSyncWaitMs() > 0) {
+        return runFileRenamePayloadWithExecution(cwd, {
+            ...payload,
+            execute: true
+        }, options, "execute", readFileRenameSyncWaitMs(), runtimeOptions);
+    }
+    return runFileRenamePayload(cwd, {
+        ...payload,
+        execute: action === "execute"
+    }, options, action, runtimeOptions);
+}
+async function applyFileRenamePreview(cwd, previewId, options, runtimeOptions) {
+    const record = (0, file_rename_preview_cache_1.readFileRenamePreviewRecord)(cwd, previewId);
+    (0, file_rename_preview_cache_1.validateFileMoveStates)(record);
+    const payload = FileRenamePayloadSchema.parse({
+        ...record.normalizedPayload,
+        execute: true
+    });
+    const syncWaitMs = readFileRenameSyncWaitMs();
+    if (syncWaitMs > 0) {
+        return runFileRenamePayloadWithExecution(cwd, payload, options, "apply", syncWaitMs, runtimeOptions, previewId);
+    }
+    const result = await runFileRenamePayload(cwd, payload, options, "apply", runtimeOptions, previewId);
+    return result.ok === false
+        ? (0, agent_text_1.attachAgentText)({ ...result, next: "Fix the file rename request and rerun preview." }, formatFileRenameAgentText({ ...result, next: "Fix the file rename request and rerun preview." }))
+        : result;
+}
+async function runFileRenamePayloadWithExecution(cwd, payload, options, action, syncWaitMs, runtimeOptions, previewIdFromApply) {
+    const normalized = normalizePayload(cwd, payload, true);
+    const executionId = (0, file_rename_execution_cache_1.buildFileRenameExecutionId)();
+    const operation = `file.rename.${action}`;
+    const etaEstimate = (0, file_mutation_runtime_1.estimateFileMutationEta)(buildFileMutationEtaInput(cwd, normalized.operations));
+    const estimatedDurationMs = etaEstimate.selectedMs;
+    const status = (0, file_rename_execution_cache_1.createFileRenameExecutionStatus)(cwd, executionId, operation, buildPlannedMoves(cwd, normalized.operations));
+    (0, file_rename_execution_cache_1.writeFileRenameExecutionStatus)(cwd, status);
+    const startedAtMs = Date.now();
+    const backgroundEnv = captureFileRenameBackgroundEnv();
+    const workerInputPath = writeFileRenameWorkerInput(cwd, executionId, {
+        schemaVersion: 1,
+        cwd,
+        payload,
+        normalized,
+        options: serializeResolveTargetInstanceOptions(options),
+        action,
+        runtimeOptions,
+        executionId,
+        status,
+        previewIdFromApply: previewIdFromApply ?? null
+    });
+    const workerPid = startFileRenameWorkerProcess(cwd, workerInputPath, backgroundEnv);
+    if (workerPid === null) {
+        return failFileRenameWorkerStart(cwd, status, "FILE_RENAME_WORKER_START_FAILED", "File rename worker did not publish a process id.");
+    }
+    const publicationFailure = await (0, mutate_child_execution_1.awaitFileMutationWorkerPublication)({
+        cwd,
+        executionId,
+        kind: "file.rename",
+        operation,
+        workerPid
+    });
+    if (publicationFailure) {
+        return publicationFailure;
+    }
+    const result = await waitForFileRenameWorkerResult(cwd, executionId, syncWaitMs);
+    if (result) {
+        return result;
+    }
+    const finalStatus = (0, file_rename_execution_cache_1.tryReadFileRenameExecutionStatus)(cwd, executionId);
+    if (finalStatus && finalStatus.status !== "running") {
+        return isObject(finalStatus.result)
+            ? finalStatus.result
+            : readCachedFileRenameExecution(cwd, executionId);
+    }
+    return buildFileRenameStillRunningResponse(cwd, executionId, operation, workerPid, estimatedDurationMs, Date.now() - startedAtMs, etaEstimate);
+}
+async function runFileRenameExecutionWorker(input) {
+    const status = input.status;
+    status.workerPid = process.pid;
+    (0, file_rename_execution_cache_1.writeFileRenameExecutionStatus)(input.cwd, status);
+    try {
+        const result = await executeFileRenameOperations(input.cwd, input.normalized, input.action, input.options, input.runtimeOptions, input.executionId, status, input.previewIdFromApply ?? undefined);
+        const rows = readFileRenameRows(result);
+        status.status = result.ok === false ? "failed" : "completed";
+        status.phase = "completed";
+        status.completedRows = result.ok === false ? rows.filter((row) => row.ok !== false).length : status.rowCount;
+        status.failedRows = result.ok === false ? rows.filter((row) => row.ok === false).length : 0;
+        status.notRunRows = result.ok === false ? Math.max(0, status.rowCount - rows.length) : 0;
+        status.filesWritten = readStringArray(result.filesWritten);
+        status.touchedFiles = readStringArray(result.touchedFiles);
+        status.moves = Array.isArray(result.renames) ? result.renames.filter(isObject) : [];
+        status.rows = rows;
+        if (isObject(result.postMutation)) {
+            status.postMutation = result.postMutation;
+        }
+        status.result = result;
+        if (result.ok === false) {
+            status.error = readString(result.code) ?? readFirstFailedCode(rows) ?? "FILE_RENAME_FAILED";
+        }
+        (0, file_rename_execution_cache_1.writeFileRenameExecutionStatus)(input.cwd, status);
+        return result;
+    }
+    catch (error) {
+        status.status = "failed";
+        status.phase = "completed";
+        status.failedRows = Math.max(1, status.failedRows);
+        status.notRunRows = Math.max(0, status.rowCount - status.completedRows - status.failedRows);
+        status.error = error instanceof Error ? error.message : String(error);
+        (0, file_rename_execution_cache_1.writeFileRenameExecutionStatus)(input.cwd, status);
+        throw error;
+    }
+}
+function writeFileRenameWorkerInput(cwd, executionId, input) {
+    const filePath = path.join(fileRenameWorkerDir(cwd, executionId), "worker-input.json");
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(tmpPath, `${JSON.stringify(input, null, 2)}\n`);
+    fs.renameSync(tmpPath, filePath);
+    return filePath;
+}
+function fileRenameWorkerDir(cwd, executionId) {
+    return path.join(cwd, ".tmp", "aib-file-rename-workers", executionId.replace(/[^a-z0-9_-]+/gi, "-"));
+}
+function startFileRenameWorkerProcess(cwd, inputPath, envPatch) {
+    const env = { ...process.env };
+    for (const [key, value] of Object.entries(envPatch)) {
+        if (value === undefined) {
+            delete env[key];
+        }
+        else {
+            env[key] = value;
+        }
+    }
+    const child = (0, node_child_process_1.spawn)(process.execPath, [path.join(__dirname, "file-rename-worker.js"), inputPath], {
+        cwd,
+        env,
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+    });
+    child.on("error", () => undefined);
+    (0, runtime_lifecycle_1.trackSessionOwnedProcess)(child, "file-rename-worker");
+    child.unref();
+    return child.pid ?? null;
+}
+async function waitForFileRenameWorkerResult(cwd, executionId, syncWaitMs) {
+    if (syncWaitMs <= 0) {
+        return null;
+    }
+    const deadline = Date.now() + syncWaitMs;
+    while (Date.now() < deadline) {
+        const status = (0, file_rename_execution_cache_1.tryReadFileRenameExecutionStatus)(cwd, executionId);
+        if (status && isFinalFileRenameWorkerStatus(status)) {
+            return isObject(status.result)
+                ? status.result
+                : readCachedFileRenameExecution(cwd, executionId);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    const finalStatus = (0, file_rename_execution_cache_1.tryReadFileRenameExecutionStatus)(cwd, executionId);
+    if (finalStatus && isFinalFileRenameWorkerStatus(finalStatus)) {
+        return isObject(finalStatus.result)
+            ? finalStatus.result
+            : readCachedFileRenameExecution(cwd, executionId);
+    }
+    return null;
+}
+function isFinalFileRenameWorkerStatus(status) {
+    return isObject(status.result) || status.phase === "completed";
+}
+function serializeResolveTargetInstanceOptions(options) {
+    return {
+        ...(options.metricsEnabled !== undefined ? { metricsEnabled: options.metricsEnabled } : {}),
+        ...(options.importRules ? { importRules: options.importRules } : {}),
+        ...(options.mutationComments ? { mutationComments: options.mutationComments } : {})
+    };
+}
+async function runFileRenamePayload(cwd, payload, options, action, runtimeOptions, previewIdFromApply, executionId, normalizedFromExecution) {
+    await (0, file_mutation_runtime_1.maybeDelayFileMutationForTest)(process.env[env_vars_1.CLI_ENV.testFileRenameDelayMs]);
+    const normalized = normalizedFromExecution ?? normalizePayload(cwd, payload, action === "execute" || action === "apply");
+    const result = normalized.execute
+        ? await executeFileRenameOperations(cwd, normalized, action === "apply" ? "apply" : "execute", options, runtimeOptions, executionId, undefined, previewIdFromApply)
+        : buildLocalFileRenamePreviewResult(normalized.operations);
+    const response = compactFileRenameResponse(cwd, result, normalized, action, previewIdFromApply, executionId);
+    if ((action === "preview" || action === "validate") && response.ok !== false) {
+        const previewId = (0, file_rename_preview_cache_1.buildFileRenamePreviewId)(normalized.normalizedPayload);
+        const states = (0, file_rename_preview_cache_1.readFileMoveStates)(normalized.operations);
+        const previewHash = (0, file_rename_preview_cache_1.buildFileRenamePreviewHash)(normalized.normalizedPayload, states, response);
+        (0, file_rename_preview_cache_1.writeFileRenamePreviewRecord)(cwd, {
+            previewId,
+            previewHash,
+            createdAt: new Date().toISOString(),
+            cwd: path.resolve(cwd),
+            normalizedPayload: normalized.normalizedPayload,
+            states,
+            previewResult: response
+        });
+        response.previewId = previewId;
+        response.next = `aib file rename apply ${previewId}`;
+    }
+    return (0, agent_text_1.attachAgentText)(response, formatFileRenameAgentText(response));
+}
+async function executeFileRenameOperations(cwd, normalized, action, options, runtimeOptions, executionId, status, previewIdFromApply) {
+    const rawRows = [];
+    const filesWritten = new Set();
+    const touchedFiles = new Set();
+    const importSnapshotBefore = [];
+    const preMutationCycles = runPostMutationCyclesSnapshot(cwd, normalized.operations.map((operation) => operation.sourceFile));
+    let cleanup = [];
+    let postMutation = null;
+    for (const operation of normalized.operations) {
+        if (status) {
+            status.phase = "movingFile";
+            status.status = "running";
+            persistFileRenameExecutionProgress(cwd, status, rawRows, filesWritten, touchedFiles);
+            await yieldToEventLoop();
+        }
+        const rowResult = await (0, file_mutation_worker_apply_1.executeWorkerOwnedFileMutationRow)(cwd, operation, options, runtimeOptions);
+        const row = Array.isArray(rowResult.rows) && isObject(rowResult.rows[0])
+            ? rowResult.rows[0]
+            : localFailureRow(operation, "FILE_RENAME_FAILED", "Extension did not return a file rename row.");
+        rawRows.push(row);
+        for (const savedFile of collectStringArray(row.savedFiles)) {
+            filesWritten.add(path.normalize(savedFile));
+        }
+        for (const touchedFile of collectStringArray(row.touchedFiles)) {
+            touchedFiles.add(path.normalize(touchedFile));
+        }
+        for (const snapshot of collectImportSnapshots(row.importSnapshotBefore)) {
+            importSnapshotBefore.push(snapshot);
+        }
+        for (const cleanupRow of collectImportSnapshots(row.cleanup)) {
+            cleanup.push(cleanupRow);
+        }
+        if (status) {
+            persistFileRenameExecutionProgress(cwd, status, rawRows, filesWritten, touchedFiles);
+            await yieldToEventLoop();
+        }
+        if (row.ok === false) {
+            break;
+        }
+        await (0, file_mutation_runtime_1.delayFileMutationForTest)(runtimeOptions.testRowDelayMs);
+    }
+    const rowsOk = rawRows.every((row) => row.ok !== false) && rawRows.length === normalized.operations.length;
+    const cleanupOk = cleanup.every((row) => row.ok !== false);
+    if (rowsOk && cleanupOk) {
+        if (status) {
+            status.phase = "postMutation.cycles";
+            persistFileRenameExecutionProgress(cwd, status, rawRows, filesWritten, touchedFiles);
+            await yieldToEventLoop();
+        }
+        await maybeDelayPostMutationCycles(runtimeOptions.testPostMutationCyclesDelayMs);
+        const postMutationFocusFiles = uniqueStrings([...Array.from(touchedFiles), ...Array.from(filesWritten)]);
+        const postMutationCycles = runPostMutationCyclesSnapshot(cwd, postMutationFocusFiles);
+        postMutation = {
+            cycles: diffPostMutationCycles(preMutationCycles, postMutationCycles, new Set(formatCycleFocusFiles(cwd, postMutationFocusFiles)))
+        };
+    }
+    const rawResult = compactObject({
+        ...(!rowsOk || !cleanupOk ? { ok: false } : {}),
+        operation: "fileMutation",
+        execute: true,
+        rowCount: normalized.operations.length,
+        appliedCount: rawRows.filter((row) => row.applied === true).length,
+        savedFiles: Array.from(filesWritten),
+        touchedFiles: Array.from(touchedFiles),
+        cleanup,
+        rows: rawRows,
+        postMutation
+    });
+    const response = compactFileRenameResponse(cwd, rawResult, normalized, action, previewIdFromApply, executionId);
+    return (0, agent_text_1.attachAgentText)(response, formatFileRenameAgentText(response));
+}
+function persistFileRenameExecutionProgress(cwd, status, rawRows, filesWritten, touchedFiles) {
+    const compactRows = rawRows.map((row) => compactRow(cwd, row));
+    status.rows = compactRows;
+    status.completedRows = compactRows.filter((row) => row.ok !== false).length;
+    status.failedRows = compactRows.filter((row) => row.ok === false).length;
+    status.notRunRows = status.failedRows > 0 ? Math.max(0, status.rowCount - compactRows.length) : 0;
+    status.filesWritten = Array.from(filesWritten).sort((left, right) => left.localeCompare(right)).map((file) => formatRelativePath(cwd, file));
+    status.touchedFiles = Array.from(touchedFiles).sort((left, right) => left.localeCompare(right)).map((file) => formatRelativePath(cwd, file));
+    if (status.failedRows > 0) {
+        status.status = "failed";
+        status.error = readFirstFailedCode(compactRows) ?? "FILE_RENAME_FAILED";
+    }
+    (0, file_rename_execution_cache_1.writeFileRenameExecutionStatus)(cwd, status);
+}
+function readCachedFileRenameExecution(cwd, executionId) {
+    const status = (0, file_rename_execution_cache_1.readFileRenameExecutionStatus)(cwd, executionId);
+    const response = {
+        operation: "execution.status",
+        executionId: status.executionId,
+        status: status.status,
+        phase: status.phase,
+        summary: buildFileRenameExecutionSummary(status),
+        progress: `${status.completedRows}/${status.rowCount}`,
+        filesWritten: status.filesWritten,
+        touchedFiles: status.touchedFiles,
+        ...(status.postMutation ? { postMutation: status.postMutation } : {}),
+        updatedAt: status.updatedAt,
+        ...(status.error ? { error: status.error } : {})
+    };
+    return (0, agent_text_1.attachAgentText)(response, formatFileRenameExecutionStatusText(status));
+}
+function buildFileRenameStillRunningResponse(cwd, executionId, operation, workerPid, estimatedDurationMs, elapsedMs, estimate = null) {
+    const status = (0, file_rename_execution_cache_1.readFileRenameExecutionStatus)(cwd, executionId);
+    const estimatedRemainingMs = Math.max(0, estimatedDurationMs - elapsedMs);
+    const eta = (0, mutation_eta_1.buildMutationEtaHint)(status.executionId, estimatedRemainingMs);
+    const response = {
+        operation: "execution.status",
+        executionId: status.executionId,
+        childExecutionKind: "file.rename",
+        childOperation: operation,
+        childCacheNamespace: file_rename_execution_cache_1.FILE_RENAME_EXECUTION_NAMESPACE,
+        childWorkerPid: workerPid,
+        status: status.status,
+        phase: status.phase,
+        summary: buildFileRenameExecutionSummary(status),
+        progress: `${status.completedRows}/${status.rowCount}`,
+        filesWritten: status.filesWritten,
+        touchedFiles: status.touchedFiles,
+        ...(status.postMutation ? { postMutation: status.postMutation } : {}),
+        updatedAt: status.updatedAt,
+        ...(estimate ? { eta: estimate } : {}),
+        estimatedRemainingMs: eta.estimatedRemainingMs,
+        suggestedFirstCheckMs: eta.suggestedFirstCheckMs,
+        next: eta.next
+    };
+    return (0, agent_text_1.attachAgentText)(response, formatFileRenameStillRunningText(operation, status, eta));
+}
+function failFileRenameWorkerStart(cwd, status, code, error) {
+    const result = {
+        ok: false,
+        operation: status.operation,
+        executionId: status.executionId,
+        code,
+        error,
+        filesWritten: [],
+        filesTouched: []
+    };
+    status.status = "failed";
+    status.phase = "completed";
+    status.failedRows = Math.max(1, status.failedRows);
+    status.notRunRows = Math.max(0, status.rowCount - status.completedRows - status.failedRows);
+    status.error = code;
+    status.result = result;
+    (0, file_rename_execution_cache_1.writeFileRenameExecutionStatus)(cwd, status);
+    return result;
+}
+function formatFileRenameStillRunningText(operation, status, eta) {
+    return [
+        `${operation} ${status.executionId}`,
+        buildFileRenameExecutionSummary(status),
+        formatFileRenamePhaseLine(status),
+        ...(0, mutation_eta_1.formatMutationEtaLines)(eta)
+    ].join("\n");
+}
+function formatFileRenameExecutionStatusText(status) {
+    const lines = [
+        buildFileRenameExecutionSummary(status)
+    ];
+    if (status.status === "running") {
+        lines.push(formatFileRenamePhaseLine(status));
+        return lines.join("\n");
+    }
+    appendExecutionRenameLines(lines, status);
+    const failedRows = status.rows.filter((row) => row.ok === false);
+    const firstFailed = failedRows[0];
+    if (firstFailed) {
+        const code = readString(firstFailed.code) ?? status.error ?? "FILE_RENAME_FAILED";
+        lines.push(`code: ${code}`);
+        if (typeof firstFailed.error === "string") {
+            lines.push(firstFailed.error);
+        }
+        if (typeof firstFailed.rollback === "string") {
+            lines.push(`rollback: ${firstFailed.rollback}`);
+        }
+        if (typeof firstFailed.hint === "string") {
+            lines.push(`hint: ${firstFailed.hint}`);
+        }
+        lines.push("failed:");
+        for (const row of failedRows) {
+            lines.push(`${readString(row.source) ?? "source"} -> ${readString(row.target) ?? "target"}`);
+        }
+    }
+    else if (status.error) {
+        lines.push(status.error);
+    }
+    appendExecutionNotRunLines(lines, status);
+    if (status.filesWritten.length > 0) {
+        appendFilesWrittenLines(lines, status.filesWritten, status.plannedMoves.map((move) => move.target));
+    }
+    if (isObject(status.postMutation) && isObject(status.postMutation.cycles)) {
+        appendPostMutationCyclesText(lines, status.postMutation.cycles);
+    }
+    if (status.status === "failed") {
+        lines.push("next: Fix failed rename row and rerun file.rename preview.");
+    }
+    return lines.join("\n");
+}
+function formatFileRenamePhaseLine(status) {
+    if (status.phase === "postProcessImports") {
+        return "updating imports";
+    }
+    if (status.phase === "postMutation.cycles") {
+        return "checking cycles";
+    }
+    return "renaming files";
+}
+function buildFileRenameExecutionSummary(status) {
+    const percent = Math.floor((Math.max(0, status.completedRows) / Math.max(1, status.rowCount)) * 100);
+    if (status.status === "completed") {
+        return `completed, ${status.completedRows}/${status.rowCount} rows, ${percent}% files, ${status.filesWritten.length} files written`;
+    }
+    if (status.status === "failed") {
+        const parts = [
+            `failed, ${status.completedRows}/${status.rowCount} rows, ${percent}% files`,
+            `${status.failedRows} failed`
+        ];
+        if (status.notRunRows > 0) {
+            parts.push(`${status.notRunRows} not run`);
+        }
+        parts.push(`${status.filesWritten.length} files written`);
+        return parts.join(", ");
+    }
+    return `in progress, ${status.completedRows}/${status.rowCount} rows, ${percent}% files`;
+}
+function normalizePayload(cwd, payload, execute) {
+    const baseDir = resolveInsideCwd(cwd, payload.base);
+    const operations = [];
+    const seenTargets = new Set();
+    for (const rename of payload.renames) {
+        const sourceFile = resolveSourceFile(cwd, baseDir, rename.source);
+        assertInsideCwd(cwd, sourceFile, "FILE_RENAME_SOURCE_OUTSIDE_CWD");
+        const targetFile = resolveRenameTargetFile(cwd, baseDir, sourceFile, rename.target);
+        assertInsideCwd(cwd, targetFile, "FILE_RENAME_TARGET_OUTSIDE_CWD");
+        const targetKey = normalizeKey(targetFile);
+        if (seenTargets.has(targetKey)) {
+            throw new errors_1.CliError("FILE_RENAME_DUPLICATE_TARGET", "Several file renames resolve to the same target.", {
+                targetFile: formatRelativePath(cwd, targetFile)
+            });
+        }
+        seenTargets.add(targetKey);
+        operations.push({
+            id: `rename-${operations.length + 1}`,
+            kind: "fileRename",
+            sourceFile,
+            targetDir: path.dirname(targetFile),
+            targetFile,
+            execute
+        });
+    }
+    if (operations.length === 0) {
+        throw new errors_1.CliError("FILE_RENAME_ROWS_REQUIRED", "file rename expects at least one rename pair.");
+    }
+    return {
+        execute,
+        baseDir,
+        operations,
+        normalizedPayload: {
+            base: baseDir,
+            renames: normalizedPayloadRenames(operations),
+            execute
+        }
+    };
+}
+function buildLocalFileRenamePreviewResult(operations) {
+    const rows = [];
+    for (const operation of operations) {
+        if (rows.some((row) => row.ok === false)) {
+            break;
+        }
+        rows.push(validateLocalMoveOperation(operation));
+    }
+    const ok = rows.every((row) => row.ok !== false) && rows.length === operations.length;
+    return {
+        ...(ok ? {} : { ok: false }),
+        operation: "fileMutation",
+        execute: false,
+        rowCount: operations.length,
+        appliedCount: 0,
+        savedFiles: [],
+        rows
+    };
+}
+function validateLocalMoveOperation(operation) {
+    if (operation.kind !== "fileRename") {
+        return localFailureRow(operation, "FILE_MUTATION_KIND_UNSUPPORTED", `Unsupported file mutation kind: ${operation.kind}`);
+    }
+    if (!fs.existsSync(operation.sourceFile)) {
+        return localFailureRow(operation, "FILE_RENAME_SOURCE_NOT_FOUND", "Source file does not exist.");
+    }
+    try {
+        const stat = fs.statSync(operation.sourceFile);
+        if (!stat.isFile()) {
+            return localFailureRow(operation, "FILE_RENAME_SOURCE_DIRECTORY_UNSUPPORTED", "file rename v1 supports files only, not directories.");
+        }
+    }
+    catch (error) {
+        return localFailureRow(operation, "FILE_RENAME_SOURCE_STAT_FAILED", error instanceof Error ? error.message : String(error));
+    }
+    if (fs.existsSync(operation.targetFile)) {
+        return localFailureRow(operation, "FILE_RENAME_TARGET_EXISTS", "Target file already exists.", "Pick another target directory/name or remove the target collision.");
+    }
+    if (isCssLikeAsset(operation.sourceFile)) {
+        return localFailureRow(operation, "FILE_RENAME_SOURCE_ASSET_UNSUPPORTED", "CSS/SCSS files cannot be renamed with file rename v1.");
+    }
+    if (!fs.existsSync(operation.targetDir)) {
+        return localFailureRow(operation, "FILE_RENAME_TARGET_DIR_NOT_FOUND", "Target parent directory does not exist.");
+    }
+    return {
+        id: operation.id,
+        ok: true,
+        sourceFile: operation.sourceFile,
+        targetFile: operation.targetFile,
+        applied: false
+    };
+}
+function localFailureRow(operation, code, error, hint) {
+    return {
+        id: operation.id,
+        ok: false,
+        sourceFile: operation.sourceFile,
+        targetFile: operation.targetFile,
+        applied: false,
+        code,
+        error,
+        ...(hint ? { hint } : {})
+    };
+}
+function isCssLikeAsset(filePath) {
+    return [".css", ".scss"].includes(path.extname(filePath).toLowerCase());
+}
+function normalizedPayloadRenames(operations) {
+    return operations.map((operation) => ({
+        source: operation.sourceFile,
+        target: operation.targetFile
+    }));
+}
+function resolveSourceFile(cwd, baseDir, rawPath) {
+    const trimmed = rawPath.trim();
+    if (path.isAbsolute(trimmed)) {
+        return path.normalize(trimmed);
+    }
+    const baseRelative = path.normalize(path.resolve(baseDir, trimmed));
+    if (fs.existsSync(baseRelative)) {
+        return baseRelative;
+    }
+    const cwdRelative = path.normalize(path.resolve(cwd, trimmed));
+    if (fs.existsSync(cwdRelative)) {
+        return cwdRelative;
+    }
+    return baseRelative;
+}
+function resolveRenameTargetFile(cwd, baseDir, sourceFile, rawTarget) {
+    const trimmed = rawTarget.trim();
+    if (path.isAbsolute(trimmed)) {
+        return path.normalize(trimmed);
+    }
+    if (trimmed.includes("/") || trimmed.includes("\\")) {
+        return path.normalize(path.resolve(baseDir, trimmed));
+    }
+    return path.normalize(path.resolve(path.dirname(sourceFile), trimmed));
+}
+function resolveInsideCwd(cwd, rawPath) {
+    const resolved = path.normalize(path.isAbsolute(rawPath) ? rawPath : path.resolve(cwd, rawPath));
+    assertInsideCwd(cwd, resolved, "FILE_RENAME_PATH_OUTSIDE_CWD");
+    return resolved;
+}
+function assertInsideCwd(cwd, filePath, code) {
+    const root = path.resolve(cwd);
+    const relative = path.relative(root, filePath);
+    if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+        return;
+    }
+    throw new errors_1.CliError(code, "File move paths must stay inside the current workspace.", {
+        cwd: root,
+        filePath
+    });
+}
+function compactFileRenameResponse(cwd, raw, normalized, action, previewIdFromApply, executionId) {
+    const rows = Array.isArray(raw.rows)
+        ? raw.rows.filter(isObject).map((row) => compactRow(cwd, row))
+        : [];
+    const ok = raw.ok !== false && rows.every((row) => row.ok !== false);
+    const renamedFiles = collectRows(rows, "target");
+    const filesWritten = collectExistingFiles(cwd, collectStringArray(raw.savedFiles)).map((file) => formatRelativePath(cwd, file));
+    const operation = action === "apply"
+        ? "file.rename.apply"
+        : normalized.execute
+            ? "file.rename.execute"
+            : "file.rename.preview";
+    const response = compactObject({
+        ...(ok ? {} : { ok: false }),
+        operation,
+        executionId: executionId ?? null,
+        base: formatRelativePath(cwd, normalized.baseDir),
+        operationCount: normalized.operations.length,
+        summary: ok
+            ? normalized.execute
+                ? `${normalized.operations.length} ${plural(normalized.operations.length, "file", "files")} renamed, ${filesWritten.length} ${plural(filesWritten.length, "file", "files")} written`
+                : `${normalized.operations.length} ${plural(normalized.operations.length, "file", "files")} ready`
+            : buildFailureSummary(rows, normalized.operations.length, normalized.execute || action === "apply"),
+        renames: formatRenamePairs(cwd, normalized.operations),
+        ...(normalized.execute || action === "apply" ? { filesWritten, filesRenamed: renamedFiles } : {}),
+        ...(isObject(raw.postMutation) ? { postMutation: raw.postMutation } : {}),
+        rows: ok ? null : rows,
+        previewId: previewIdFromApply ?? null
+    });
+    return response;
+}
+function compactRow(cwd, row) {
+    return compactObject({
+        id: readString(row.id),
+        ok: row.ok !== false,
+        source: formatRelativePath(cwd, readString(row.sourceFile) ?? ""),
+        target: formatRelativePath(cwd, readString(row.targetFile) ?? ""),
+        applied: typeof row.applied === "boolean" ? row.applied : null,
+        rollback: readString(row.rollback),
+        savedFiles: compactList(collectStringArray(row.savedFiles).map((file) => formatRelativePath(cwd, file)), 5),
+        code: readString(row.code),
+        error: readString(row.error),
+        hint: readString(row.hint)
+    });
+}
+function formatRenamePairs(cwd, operations) {
+    return operations.map((operation) => ({
+        source: formatRelativePath(cwd, operation.sourceFile),
+        target: formatRelativePath(cwd, operation.targetFile)
+    }));
+}
+function buildFailureSummary(rows, total, executed) {
+    const failed = rows.filter((row) => row.ok === false).length;
+    const notRun = Math.max(0, total - rows.length);
+    if (!executed) {
+        const checked = Math.min(total, rows.length);
+        return `${total} ${plural(total, "file", "files")}, validation blocked at row ${checked}`;
+    }
+    return `${total} ${plural(total, "file", "files")}, ${failed} failed${notRun > 0 ? `, ${notRun} not run` : ""}`;
+}
+function buildPlannedMoves(cwd, operations) {
+    return operations.map((operation) => ({
+        source: formatRelativePath(cwd, operation.sourceFile),
+        target: formatRelativePath(cwd, operation.targetFile),
+        targetDir: formatRelativePath(cwd, operation.targetDir)
+    }));
+}
+function readFileRenameRows(result) {
+    return Array.isArray(result.rows) ? result.rows.filter(isObject) : [];
+}
+function buildFileMutationEtaInput(cwd, operations) {
+    const targetDirs = new Set(operations.map((operation) => operation.targetDir));
+    let dirsToCreate = 0;
+    for (const targetDir of targetDirs) {
+        if (!fs.existsSync(targetDir)) {
+            dirsToCreate += 1;
+        }
+    }
+    const impact = (0, file_impact_scan_1.estimateFileMutationImpact)(cwd, operations.map((operation) => operation.sourceFile));
+    return {
+        rowCount: operations.length,
+        targetDirCount: targetDirs.size,
+        dirsToCreate,
+        importingFileCount: impact.importingFileCount,
+        importStatementCount: impact.importStatementCount,
+        barrelExportCount: impact.barrelExportCount,
+        sourceFileCount: impact.sourceFileCount,
+        existingSourceFileCount: impact.existingSourceFileCount,
+        scanTruncated: impact.truncated
+    };
+}
+function readFirstFailedCode(rows) {
+    const failed = rows.find((row) => row.ok === false);
+    return failed ? readString(failed.code) : null;
+}
+function appendExecutionRenameLines(lines, status) {
+    const completedSources = new Set(status.rows.filter((row) => row.ok !== false).map((row) => readString(row.source)).filter((value) => Boolean(value)));
+    const pairs = [];
+    for (const move of status.plannedMoves) {
+        if (status.status !== "completed" && !completedSources.has(move.source)) {
+            continue;
+        }
+        pairs.push(`${move.source} -> ${move.target}`);
+    }
+    if (pairs.length === 0) {
+        return;
+    }
+    lines.push("renames:");
+    for (const pair of pairs) {
+        lines.push(pair);
+    }
+}
+function appendExecutionNotRunLines(lines, status) {
+    if (status.notRunRows <= 0) {
+        return;
+    }
+    const seenSources = new Set(status.rows.map((row) => readString(row.source)).filter((value) => Boolean(value)));
+    const notRun = status.plannedMoves.filter((move) => !seenSources.has(move.source));
+    if (notRun.length === 0) {
+        return;
+    }
+    lines.push("not run:");
+    for (const move of notRun) {
+        lines.push(move.source);
+    }
+}
+function readFileRenameSyncWaitMs() {
+    return (0, mutation_execution_cache_1.readMutationSyncWaitMs)(process.env[env_vars_1.CLI_ENV.fileRenameSyncWaitMs], 120_000);
+}
+function readFileRenameRuntimeOptions() {
+    return {
+        postProcessImports: (0, file_mutation_runtime_1.isFileMutationImportPostProcessEnabled)(),
+        testFailRequiredImportUpdate: readString(process.env[env_vars_1.CLI_ENV.testFileRenameFailImports]),
+        testRowDelayMs: (0, file_mutation_runtime_1.readFileMutationTestDelayMs)(process.env[env_vars_1.CLI_ENV.testFileRenameRowDelayMs], 60_000),
+        testImportPostProcessDelayMs: (0, file_mutation_runtime_1.readFileMutationTestDelayMs)(process.env[env_vars_1.CLI_ENV.testFileRenameImportsDelayMs], 60_000),
+        testPostMutationCyclesDelayMs: (0, file_mutation_runtime_1.readFileMutationTestDelayMs)(process.env[env_vars_1.CLI_ENV.testPostMutationCyclesDelayMs], 60_000)
+    };
+}
+function captureFileRenameBackgroundEnv() {
+    return (0, file_mutation_runtime_1.captureFileMutationBackgroundEnv)([
+        env_vars_1.CLI_ENV.testFileRenameDelayMs,
+        env_vars_1.CLI_ENV.testFileRenameRowDelayMs,
+        env_vars_1.CLI_ENV.testFileRenameImportsDelayMs,
+        env_vars_1.CLI_ENV.testFileRenameFailImports
+    ]);
+}
+function formatFileRenameAgentText(response) {
+    const operation = readString(response.operation);
+    if (!operation?.startsWith("file.rename.")) {
+        return null;
+    }
+    const lines = [];
+    const previewId = readString(response.previewId);
+    const executionId = readString(response.executionId);
+    lines.push(response.ok === false
+        ? `${operation} failed`
+        : previewId && operation === "file.rename.preview"
+            ? `${operation} ${previewId}`
+            : executionId && (operation === "file.rename.apply" || operation === "file.rename.execute")
+                ? `${operation} ${executionId}`
+                : operation);
+    if (typeof response.summary === "string") {
+        lines.push(response.summary);
+    }
+    const renames = Array.isArray(response.renames) ? response.renames.filter(isObject) : [];
+    if (renames.length > 0 && response.ok !== false) {
+        lines.push("renames:");
+        for (const rename of renames) {
+            const source = readString(rename.source);
+            const target = readString(rename.target);
+            if (source && target) {
+                lines.push(`${source} -> ${target}`);
+            }
+        }
+    }
+    appendFailureLines(lines, response);
+    const filesWritten = Array.isArray(response.filesWritten) ? response.filesWritten : [];
+    if (filesWritten.length > 0) {
+        appendFilesWrittenLines(lines, filesWritten, Array.isArray(response.filesRenamed) ? response.filesRenamed : []);
+    }
+    if (isObject(response.postMutation) && isObject(response.postMutation.cycles)) {
+        appendPostMutationCyclesText(lines, response.postMutation.cycles);
+    }
+    if (typeof response.next === "string") {
+        lines.push(`next: ${response.next}`);
+    }
+    return lines.join("\n");
+}
+function appendFailureLines(lines, response) {
+    if (response.ok !== false || !Array.isArray(response.rows)) {
+        return;
+    }
+    const failed = response.rows.filter(isObject).find((row) => row.ok === false);
+    if (!failed) {
+        return;
+    }
+    lines.push("failed:");
+    lines.push(`${readString(failed.source) ?? "source"} -> ${readString(failed.target) ?? "target"}`);
+    lines.push(`code: ${readString(failed.code) ?? "FILE_RENAME_FAILED"}`);
+    if (typeof failed.error === "string") {
+        lines.push(failed.error);
+    }
+    if (typeof failed.rollback === "string") {
+        lines.push(`rollback: ${failed.rollback}`);
+    }
+    if (typeof failed.hint === "string") {
+        lines.push(`hint: ${failed.hint}`);
+    }
+}
+function FileRenameHelp() {
+    return {
+        ok: true,
+        command: "file rename",
+        usage: "aib file rename preview --stdin | aib file rename execute --stdin | aib file rename apply <previewId>",
+        dsl: [
+            "@base packages/agent-project-tooling/src",
+            "rename workspace-runner-cli.ts->cli.ts workspace-runner-command-hints.ts->command-hints.ts"
+        ],
+        notes: [
+            "preview validates planned file renames without writing.",
+            "execute renames files and updates TypeScript imports.",
+            "apply uses the cached preview id and refuses stale source/target state."
+        ]
+    };
+}
+function collectRows(rows, field) {
+    return rows.map((row) => readString(row[field])).filter((value) => Boolean(value));
+}
+function collectStringArray(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function collectImportSnapshots(value) {
+    return Array.isArray(value) ? value.filter(isObject) : [];
+}
+function runPostMutationCyclesSnapshot(cwd, files) {
+    const existingFiles = formatCycleFocusFiles(cwd, files).filter((file) => fs.existsSync(resolveCliFilePath(cwd, file)));
+    if (existingFiles.length === 0) {
+        return {
+            op: "cycles",
+            componentCount: 0,
+            components: []
+        };
+    }
+    const args = ["cycles"];
+    for (const file of existingFiles) {
+        args.push("--files", file);
+    }
+    args.push("--detail", "imports", "--limit", "50");
+    return (0, inspect_cycles_1.runInspectCycles)(cwd, args, undefined);
+}
+function diffPostMutationCycles(prePayload, postPayload, touchedFiles) {
+    const preKeys = new Set(readCycleComponents(prePayload).map(cycleComponentKey));
+    const newOrChanged = readCycleComponents(postPayload).filter((component) => readStringArray(component.files).some((file) => touchedFiles.has(file)) &&
+        !preKeys.has(cycleComponentKey(component)));
+    return {
+        status: newOrChanged.length > 0 ? "new-or-changed" : "none",
+        detail: "imports",
+        newOrChangedCount: newOrChanged.length,
+        preComponentCount: readNumber(prePayload.componentCount),
+        postComponentCount: readNumber(postPayload.componentCount),
+        components: newOrChanged
+    };
+}
+function readCycleComponents(payload) {
+    return (Array.isArray(payload.components) ? payload.components : [])
+        .filter(isObject)
+        .map((component) => ({
+        kind: readString(component.kind) ?? "mixed",
+        files: readStringArray(component.files).sort(),
+        chain: readString(component.chain) ?? "",
+        ...(isObject(component.cycle) ? { cycle: component.cycle } : {}),
+        imports: readCycleImports(component)
+    }));
+}
+function readCycleImports(component) {
+    const cycle = isObject(component.cycle) ? component.cycle : {};
+    return readStringArray(cycle.imports);
+}
+function cycleComponentKey(component) {
+    return `${readString(component.kind) ?? "mixed"}:${readStringArray(component.files).sort().join("|")}`;
+}
+function formatCycleFocusFiles(cwd, files) {
+    return uniqueStrings(files.map((file) => formatRelativePath(cwd, resolveCliFilePath(cwd, file))));
+}
+function resolveCliFilePath(cwd, file) {
+    return path.normalize(path.isAbsolute(file) ? file : path.resolve(cwd, file));
+}
+function readStringArray(value) {
+    return collectStringArray(value);
+}
+function collectExistingFiles(cwd, files) {
+    return files.filter((file) => {
+        const resolved = path.isAbsolute(file) ? file : path.resolve(cwd, file);
+        return fs.existsSync(resolved);
+    });
+}
+function compactList(items, limit) {
+    const unique = Array.from(new Set(items)).sort((left, right) => left.localeCompare(right));
+    const visible = unique.slice(0, limit);
+    const hidden = unique.length - visible.length;
+    return hidden > 0 ? [...visible, `+ ${hidden} more`] : visible;
+}
+function formatInlineList(values, limit) {
+    const visible = values.slice(0, limit);
+    const hidden = values.length - visible.length;
+    return hidden > 0 ? `${visible.join(", ")}, + ${hidden} more` : visible.join(", ");
+}
+function appendFilesWrittenLines(lines, values, movedTargets) {
+    const files = values.filter((value) => typeof value === "string");
+    if (files.length === 0) {
+        return;
+    }
+    const moved = new Set(movedTargets.filter((value) => typeof value === "string"));
+    const movedFiles = files.filter((file) => moved.has(file));
+    const referenceFiles = files.filter((file) => !moved.has(file));
+    const visibleReferenceFiles = referenceFiles.slice(0, 8);
+    const hiddenReferenceFiles = referenceFiles.length - visibleReferenceFiles.length;
+    lines.push("filesWritten:");
+    for (const file of [...movedFiles, ...visibleReferenceFiles]) {
+        lines.push(file);
+    }
+    if (hiddenReferenceFiles > 0) {
+        lines.push(`+ ${hiddenReferenceFiles} reference ${plural(hiddenReferenceFiles, "file", "files")}`);
+    }
+}
+function appendPostMutationCyclesText(lines, cycles) {
+    lines.push("cycles:");
+    const count = readNumber(cycles.newOrChangedCount);
+    if (count === 0) {
+        lines.push("no new/changed cycles involving touched files");
+        return;
+    }
+    const components = Array.isArray(cycles.components) ? cycles.components.filter(isObject) : [];
+    lines.push(formatPostMutationCycleSummary(count, components));
+    components.forEach((component, index) => {
+        (0, inspect_cycles_1.appendCycleComponentText)(lines, component, {
+            detail: "imports",
+            prefix: components.length === 1 ? "" : `${index + 1}. `,
+            indent: components.length === 1 ? "" : "   "
+        });
+    });
+}
+function formatPostMutationCycleSummary(count, components) {
+    const kinds = components.map((component) => readString(component.kind) ?? "mixed");
+    const uniqueKinds = Array.from(new Set(kinds));
+    const kindText = uniqueKinds.length === 1 ? `${uniqueKinds[0]} ` : "";
+    return `${count} new/changed ${kindText}${count === 1 ? "cycle" : "cycles"} involving touched files`;
+}
+function plural(count, one, many) {
+    return count === 1 ? one : many;
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+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);
+    }));
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeKey(filePath) {
+    const normalized = path.normalize(filePath);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function yieldToEventLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+}
+async function maybeDelayPostMutationCycles(delayMs) {
+    if (delayMs <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function formatRelativePath(cwd, filePath) {
+    if (!filePath) {
+        return "";
+    }
+    return path.relative(cwd, filePath).replace(/\\/g, "/");
+}