@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/file-mutation-runtime.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateFileMutationScanDurationMs = exports.estimateFileMutationEta = exports.estimateFileMutationDurationMs = exports.estimateFileMutationDefaultDurationMs = void 0;
+exports.isFileMutationImportPostProcessEnabled = isFileMutationImportPostProcessEnabled;
+exports.readFileMutationTestDelayMs = readFileMutationTestDelayMs;
+exports.delayFileMutationForTest = delayFileMutationForTest;
+exports.maybeDelayFileMutationForTest = maybeDelayFileMutationForTest;
+exports.captureFileMutationBackgroundEnv = captureFileMutationBackgroundEnv;
+exports.withFileMutationBackgroundEnv = withFileMutationBackgroundEnv;
+exports.startFileMutationBackgroundJob = startFileMutationBackgroundJob;
+exports.formatFileMutationDuration = formatFileMutationDuration;
+const env_vars_1 = require("../config/env-vars");
+const BASE_BACKGROUND_ENV_KEYS = [
+    env_vars_1.CLI_ENV.productStorageDir,
+    env_vars_1.CLI_ENV.trace,
+    env_vars_1.CLI_ENV.traceDir,
+    env_vars_1.CLI_ENV.metrics,
+    env_vars_1.CLI_ENV.metricsDir,
+    env_vars_1.CLI_ENV.metricsTag,
+    env_vars_1.CLI_ENV.mutationImpactMetrics,
+    env_vars_1.CLI_ENV.mutationImpactStream,
+    env_vars_1.CLI_ENV.testPostMutationCyclesDelayMs,
+    env_vars_1.CLI_ENV.disableFileMutationImportPostProcess,
+    env_vars_1.CLI_ENV.disableFileMoveImportPostProcess
+];
+function isFileMutationImportPostProcessEnabled() {
+    return process.env[env_vars_1.CLI_ENV.disableFileMutationImportPostProcess] !== "1" &&
+        process.env[env_vars_1.CLI_ENV.disableFileMoveImportPostProcess] !== "1";
+}
+function readFileMutationTestDelayMs(raw, maxMs) {
+    if (!raw) {
+        return 0;
+    }
+    const delayMs = Number.parseInt(raw, 10);
+    if (!Number.isFinite(delayMs) || delayMs <= 0) {
+        return 0;
+    }
+    return Math.min(delayMs, maxMs);
+}
+async function delayFileMutationForTest(delayMs) {
+    if (delayMs <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+async function maybeDelayFileMutationForTest(raw, maxMs = 120_000) {
+    await delayFileMutationForTest(readFileMutationTestDelayMs(raw, maxMs));
+}
+function captureFileMutationBackgroundEnv(extraKeys) {
+    const env = {};
+    for (const key of uniqueStrings([...BASE_BACKGROUND_ENV_KEYS, ...extraKeys])) {
+        env[key] = process.env[key];
+    }
+    return env;
+}
+async function withFileMutationBackgroundEnv(env, callback) {
+    const previous = {};
+    for (const [key, value] of Object.entries(env)) {
+        previous[key] = process.env[key];
+        if (value === undefined) {
+            delete process.env[key];
+        }
+        else {
+            process.env[key] = value;
+        }
+    }
+    try {
+        return await callback();
+    }
+    finally {
+        for (const [key, value] of Object.entries(previous)) {
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+    }
+}
+function startFileMutationBackgroundJob(job) {
+    return new Promise((resolve, reject) => {
+        setImmediate(() => {
+            job().then(resolve, reject);
+        });
+    });
+}
+var file_mutation_eta_1 = require("../mutation/file-mutation-eta");
+Object.defineProperty(exports, "estimateFileMutationDefaultDurationMs", { enumerable: true, get: function () { return file_mutation_eta_1.estimateFileMutationDefaultDurationMs; } });
+Object.defineProperty(exports, "estimateFileMutationDurationMs", { enumerable: true, get: function () { return file_mutation_eta_1.estimateFileMutationDurationMs; } });
+Object.defineProperty(exports, "estimateFileMutationEta", { enumerable: true, get: function () { return file_mutation_eta_1.estimateFileMutationEta; } });
+Object.defineProperty(exports, "estimateFileMutationScanDurationMs", { enumerable: true, get: function () { return file_mutation_eta_1.estimateFileMutationScanDurationMs; } });
+function formatFileMutationDuration(ms) {
+    if (ms < 1_000) {
+        return "<1 sec";
+    }
+    const seconds = Math.ceil(ms / 1_000);
+    return seconds < 60 ? `~${seconds} sec` : `~${Math.ceil(seconds / 60)} min`;
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}

package/dist/commands/file-mutation-worker-apply.js

@@ -0,0 +1,180 @@
+"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.executeWorkerOwnedFileMutationRow = executeWorkerOwnedFileMutationRow;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const import_rules_1 = require("../config/import-rules");
+const file_mutation_standalone_apply_1 = require("../mutation/file-mutation-standalone-apply");
+const file_mutation_discovery_1 = require("../mutation/file-mutation-discovery");
+const file_mutation_standalone_planner_1 = require("../mutation/file-mutation-standalone-planner");
+async function executeWorkerOwnedFileMutationRow(cwd, operation, options, runtimeOptions) {
+    const validation = validateWorkerOwnedFileMutationOperation(operation);
+    if (validation)
+        return { rows: [validation] };
+    const discovery = (0, file_mutation_discovery_1.discoverFileMutationConsumers)({
+        workspaceRoot: cwd,
+        sourceFiles: [operation.sourceFile]
+    });
+    if (!discovery.complete) {
+        return { rows: [localFailureRow(operation, "FILE_MUTATION_DISCOVERY_INCOMPLETE", "Consumer discovery could not prove a complete file-mutation closure.", undefined, {
+                    discovery: summarizeDiscovery(discovery)
+                })] };
+    }
+    const plan = await (0, file_mutation_standalone_planner_1.planStandaloneFileMutation)({
+        workspaceRoot: cwd,
+        sourceFile: operation.sourceFile,
+        targetFile: operation.targetFile,
+        discovery
+    });
+    if (!plan.complete) {
+        return { rows: [localFailureRow(operation, plan.code, plan.error ?? "Standalone file mutation planning failed.", undefined, {
+                    planner: summarizePlan(plan)
+                })] };
+    }
+    const forceRequiredImportFailure = shouldFailRequiredImportUpdateForTest(operation, runtimeOptions.testFailRequiredImportUpdate);
+    const transaction = (0, file_mutation_standalone_apply_1.applyStandaloneFileMutationTransaction)({
+        workspaceRoot: cwd,
+        sourceFile: operation.sourceFile,
+        targetFile: operation.targetFile,
+        plan,
+        importRules: options.importRules ?? (0, import_rules_1.readConfigImportRules)(cwd),
+        postProcessImports: runtimeOptions.postProcessImports !== false,
+        forceFailureAfterMove: forceRequiredImportFailure
+    });
+    if (!transaction.ok) {
+        const failureCode = forceRequiredImportFailure && transaction.rollback !== "failed"
+            ? "FILE_MOVE_IMPORT_EDITS_FAILED"
+            : transaction.code;
+        return { rows: [localFailureRow(operation, failureCode, transaction.error, transaction.rollback === "failed" ? "Workspace may contain partial file-mutation state. Inspect potentiallyModifiedFiles before retrying." : undefined, {
+                    rollback: transaction.rollback,
+                    potentiallyModifiedFiles: transaction.potentiallyModifiedFiles,
+                    ...(transaction.rollbackErrors ? { rollbackErrors: transaction.rollbackErrors } : {}),
+                    planner: summarizePlan(plan)
+                })] };
+    }
+    return {
+        rows: [{
+                id: operation.id,
+                ok: true,
+                sourceFile: operation.sourceFile,
+                targetFile: operation.targetFile,
+                applied: true,
+                importEditCount: transaction.importEditCount,
+                assetImportEditCount: transaction.assetImportEditCount,
+                savedFiles: transaction.savedFiles,
+                touchedFiles: transaction.touchedFiles,
+                cleanup: transaction.cleanup,
+                importSnapshotBefore: [],
+                planner: summarizePlan(plan),
+                discovery: summarizeDiscovery(discovery)
+            }]
+    };
+}
+function validateWorkerOwnedFileMutationOperation(operation) {
+    if (operation.kind !== "fileMoveToDir" && operation.kind !== "fileRename") {
+        return localFailureRow(operation, "FILE_MUTATION_KIND_UNSUPPORTED", `Unsupported file mutation kind: ${operation.kind}`);
+    }
+    if (!fs.existsSync(operation.sourceFile)) {
+        return localFailureRow(operation, operation.kind === "fileRename" ? "FILE_RENAME_SOURCE_NOT_FOUND" : "FILE_MOVE_SOURCE_NOT_FOUND", "Source file does not exist.");
+    }
+    try {
+        if (!fs.statSync(operation.sourceFile).isFile()) {
+            return localFailureRow(operation, operation.kind === "fileRename" ? "FILE_RENAME_SOURCE_DIRECTORY_UNSUPPORTED" : "FILE_MOVE_SOURCE_DIRECTORY_UNSUPPORTED", "file mutations v1 support files only, not directories.");
+        }
+    }
+    catch (error) {
+        return localFailureRow(operation, operation.kind === "fileRename" ? "FILE_RENAME_SOURCE_STAT_FAILED" : "FILE_MOVE_SOURCE_STAT_FAILED", error instanceof Error ? error.message : String(error));
+    }
+    if (fs.existsSync(operation.targetFile)) {
+        return localFailureRow(operation, operation.kind === "fileRename" ? "FILE_RENAME_TARGET_EXISTS" : "FILE_MOVE_TARGET_EXISTS", "Target file already exists.", "Pick another target path/name or remove the target collision.");
+    }
+    if (/\.(?:css|scss)$/i.test(operation.sourceFile)) {
+        return localFailureRow(operation, operation.kind === "fileRename" ? "FILE_RENAME_SOURCE_ASSET_UNSUPPORTED" : "FILE_MOVE_SOURCE_ASSET_UNSUPPORTED", "CSS/SCSS files cannot be moved or renamed with file mutations v1.");
+    }
+    if (operation.kind === "fileRename" && !fs.existsSync(operation.targetDir)) {
+        return localFailureRow(operation, "FILE_RENAME_TARGET_DIR_NOT_FOUND", "Target parent directory does not exist.");
+    }
+    return null;
+}
+function summarizeDiscovery(discovery) {
+    return {
+        complete: discovery.complete,
+        filesScanned: discovery.filesScanned,
+        consumerCount: discovery.consumerFiles.length,
+        directConsumerCount: discovery.directConsumerFiles.length,
+        ownerCount: discovery.ownerConfigs.length,
+        edgeCount: discovery.edgeCount,
+        programBuildCount: discovery.programBuildCount,
+        durationMs: discovery.durationMs,
+        uncertainties: discovery.uncertainties
+    };
+}
+function summarizePlan(plan) {
+    return {
+        complete: plan.complete,
+        code: plan.code,
+        requiredEdgeCount: plan.requiredEdgeCount,
+        coveredRequiredEdgeCount: plan.coveredRequiredEdgeCount,
+        observedEditFileCount: plan.observedEditFileCount,
+        observedTextChangeCount: plan.observedTextChangeCount,
+        ownerResolutionCount: plan.ownerResolutionCount,
+        enabledOwnerProjectionCount: plan.enabledOwnerConfigs.length,
+        missingOwnerProjectionCount: plan.missingOwnerConfigs.length,
+        childPid: plan.childPid,
+        childRssMiB: plan.childRssMiB,
+        terminationConfirmed: plan.terminationConfirmed,
+        totalMs: plan.totalMs,
+        renameMs: plan.renameMs
+    };
+}
+function shouldFailRequiredImportUpdateForTest(operation, raw) {
+    if (!raw)
+        return false;
+    return raw === "1" || raw === operation.id || raw === path.basename(operation.sourceFile) || raw === path.basename(operation.targetFile);
+}
+function localFailureRow(operation, code, error, hint, extra = {}) {
+    return {
+        id: operation.id,
+        ok: false,
+        sourceFile: operation.sourceFile,
+        targetFile: operation.targetFile,
+        applied: false,
+        code,
+        error,
+        ...(hint ? { hint } : {}),
+        ...extra
+    };
+}

package/dist/commands/file-refactor-batch-execution-cache.js

@@ -0,0 +1,90 @@
+"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.buildFileRefactorBatchExecutionId = buildFileRefactorBatchExecutionId;
+exports.createFileRefactorBatchExecutionStatus = createFileRefactorBatchExecutionStatus;
+exports.readFileRefactorBatchExecutionStatus = readFileRefactorBatchExecutionStatus;
+exports.tryReadFileRefactorBatchExecutionStatus = tryReadFileRefactorBatchExecutionStatus;
+exports.writeFileRefactorBatchExecutionStatus = writeFileRefactorBatchExecutionStatus;
+exports.FileRefactorBatchExecutionPath = FileRefactorBatchExecutionPath;
+exports.FileRefactorBatchExecutionLastPath = FileRefactorBatchExecutionLastPath;
+const path = __importStar(require("node:path"));
+const product_storage_1 = require("../config/product-storage");
+const mutation_execution_cache_1 = require("./mutation-execution-cache");
+function buildFileRefactorBatchExecutionId() {
+    return (0, mutation_execution_cache_1.buildMutationExecutionId)();
+}
+function createFileRefactorBatchExecutionStatus(cwd, executionId, operation, plannedMoves) {
+    const now = new Date().toISOString();
+    return {
+        executionId,
+        operation,
+        cwd: path.resolve(cwd),
+        status: "running",
+        phase: "movingFile",
+        startedAt: now,
+        updatedAt: now,
+        rowCount: Math.max(1, plannedMoves.length),
+        completedRows: 0,
+        failedRows: 0,
+        notRunRows: 0,
+        filesWritten: [],
+        touchedFiles: [],
+        plannedMoves,
+        moves: [],
+        rows: [],
+        productStorageDir: (0, product_storage_1.productStorageRoot)()
+    };
+}
+function readFileRefactorBatchExecutionStatus(cwd, executionId) {
+    return (0, mutation_execution_cache_1.readMutationExecutionStatus)(cwd, executionId, FILE_REFACTOR_BATCH_EXECUTION_CACHE);
+}
+function tryReadFileRefactorBatchExecutionStatus(cwd, executionId) {
+    return (0, mutation_execution_cache_1.tryReadMutationExecutionStatus)(cwd, executionId, FILE_REFACTOR_BATCH_EXECUTION_CACHE);
+}
+function writeFileRefactorBatchExecutionStatus(cwd, status) {
+    (0, mutation_execution_cache_1.writeMutationExecutionStatus)(cwd, status, FILE_REFACTOR_BATCH_EXECUTION_CACHE);
+}
+function FileRefactorBatchExecutionPath(cwd, executionId, productStorageDir) {
+    return (0, mutation_execution_cache_1.mutationExecutionPath)(cwd, FILE_REFACTOR_BATCH_EXECUTION_CACHE.namespace, executionId, productStorageDir);
+}
+function FileRefactorBatchExecutionLastPath(cwd, productStorageDir) {
+    return (0, mutation_execution_cache_1.mutationExecutionLastPath)(cwd, FILE_REFACTOR_BATCH_EXECUTION_CACHE.namespace, productStorageDir);
+}
+const FILE_REFACTOR_BATCH_EXECUTION_CACHE = {
+    namespace: "file-refactor-batch-executions",
+    notFoundCode: "FILE_REFACTOR_BATCH_EXECUTION_NOT_FOUND",
+    notFoundLabel: "file refactor batch"
+};

package/dist/commands/file-refactor-batch-preview-cache.js

@@ -0,0 +1,125 @@
+"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.buildFileRefactorBatchPreviewId = buildFileRefactorBatchPreviewId;
+exports.buildFileRefactorBatchPreviewHash = buildFileRefactorBatchPreviewHash;
+exports.readFileRefactorBatchPreviewRecord = readFileRefactorBatchPreviewRecord;
+exports.writeFileRefactorBatchPreviewRecord = writeFileRefactorBatchPreviewRecord;
+exports.FileRefactorBatchPreviewRecordPath = FileRefactorBatchPreviewRecordPath;
+exports.readFileMoveStates = readFileMoveStates;
+exports.validateFileMoveStates = validateFileMoveStates;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const errors_1 = require("../shared/errors");
+const workspace_cache_1 = require("./workspace-cache");
+function buildFileRefactorBatchPreviewId(normalizedPayload) {
+    return `apply_${sha256(stableStringify(normalizedPayload)).slice(0, 10)}`;
+}
+function buildFileRefactorBatchPreviewHash(normalizedPayload, states, previewResult) {
+    return `sha256:${sha256(stableStringify({
+        normalizedPayload,
+        states,
+        summary: previewResult.summary,
+        operationCount: previewResult.operationCount
+    }))}`;
+}
+function readFileRefactorBatchPreviewRecord(cwd, previewId) {
+    const filePath = FileRefactorBatchPreviewRecordPath(cwd, previewId);
+    if (!fs.existsSync(filePath)) {
+        throw new errors_1.CliError("FILE_REFACTOR_BATCH_PREVIEW_NOT_FOUND", `File move preview not found: ${previewId}`, {
+            previewId,
+            expectedPath: filePath
+        });
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+function writeFileRefactorBatchPreviewRecord(cwd, record) {
+    const filePath = FileRefactorBatchPreviewRecordPath(cwd, record.previewId);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(record, null, 2)}\n`);
+}
+function FileRefactorBatchPreviewRecordPath(cwd, previewId) {
+    return (0, workspace_cache_1.workspaceCachePath)(cwd, "file-refactor-batch-previews", `${sanitizeId(previewId)}.json`);
+}
+function readFileMoveStates(operations) {
+    return operations.map((operation) => ({
+        sourceFile: operation.sourceFile,
+        sourceHash: hashFileIfExists(operation.sourceFile),
+        targetFile: operation.targetFile,
+        targetExisted: fs.existsSync(operation.targetFile),
+        targetHash: hashFileIfExists(operation.targetFile)
+    }));
+}
+function validateFileMoveStates(record) {
+    for (const state of record.states) {
+        const currentSourceHash = hashFileIfExists(state.sourceFile);
+        if (currentSourceHash !== state.sourceHash) {
+            throw new errors_1.CliError("FILE_REFACTOR_BATCH_PREVIEW_SOURCE_CHANGED", "Source file changed after file move preview. Rerun preview.", {
+                previewId: record.previewId,
+                sourceFile: state.sourceFile
+            });
+        }
+        const currentTargetExists = fs.existsSync(state.targetFile);
+        const currentTargetHash = hashFileIfExists(state.targetFile);
+        if (currentTargetExists !== state.targetExisted || currentTargetHash !== state.targetHash) {
+            throw new errors_1.CliError("FILE_REFACTOR_BATCH_PREVIEW_TARGET_CHANGED", "Target file changed after file move preview. Rerun preview.", {
+                previewId: record.previewId,
+                targetFile: state.targetFile
+            });
+        }
+    }
+}
+function hashFileIfExists(filePath) {
+    return fs.existsSync(filePath) ? sha256(fs.readFileSync(filePath)) : null;
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+        .join(",")}}`;
+}
+function sanitizeId(value) {
+    return value.replace(/[^a-z0-9_-]+/gi, "-");
+}

package/dist/commands/file-refactor-batch-worker.js

@@ -0,0 +1,54 @@
+"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 });
+const fs = __importStar(require("node:fs"));
+const file_refactor_batch_1 = require("./file-refactor-batch");
+async function main() {
+    const inputPath = process.argv[2];
+    if (!inputPath) {
+        throw new Error("file refactor batch worker expects an input path.");
+    }
+    const input = JSON.parse(fs.readFileSync(inputPath, "utf8"));
+    if (input.schemaVersion !== 1) {
+        throw new Error(`Unsupported file refactor batch worker input schema: ${String(input.schemaVersion)}`);
+    }
+    await (0, file_refactor_batch_1.runFileRefactorBatchExecutionWorker)(input);
+}
+if (require.main === module) {
+    main().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.stack || error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}