@testspectra/cli 1.0.70 → 1.1.0-rc.0

package/dist/refactor/index.d.ts

@@ -0,0 +1 @@
+export * from './refactor-engine.js';

package/dist/refactor/index.js

@@ -0,0 +1 @@
+export * from './refactor-engine.js';

package/dist/refactor/refactor-engine.d.ts

@@ -0,0 +1,50 @@
+export type RefactorType = 'page-object' | 'step' | 'action' | 'fixture';
+export interface RenameOptions {
+    workspaceRoot: string;
+    type: RefactorType;
+    oldName: string;
+    newName: string;
+    dryRun?: boolean;
+    skipPathRename?: boolean;
+}
+export interface RefactorResult {
+    status: 'success' | 'failed';
+    entityType: RefactorType;
+    oldSymbol: string;
+    newSymbol: string;
+    modifiedFiles: string[];
+    occurrencesReplaced: number;
+    renamedPaths?: Array<{
+        from: string;
+        to: string;
+    }>;
+    error?: string;
+}
+export declare const ENTITY_NAMING_RULES: Record<RefactorType, {
+    regex: RegExp;
+    convention: string;
+}>;
+export declare const SUPPORTED_FIXTURE_EXTENSIONS: string[];
+export declare class RefactorEngine {
+    /**
+     * Deterministically parses testing entity type and symbol name from a filesystem path.
+     * Supports directory paths, file paths, and paths with trailing slashes.
+     */
+    static parseEntityFromPath(filePath: string): {
+        type: RefactorType;
+        symbol: string;
+    } | null;
+    /**
+     * Deterministically parses source and target paths, validates entity types,
+     * and executes symbol refactoring across the workspace.
+     */
+    static renameFromPaths(options: {
+        workspaceRoot: string;
+        fromPath: string;
+        toPath: string;
+        dryRun?: boolean;
+        skipPathRename?: boolean;
+    }): Promise<RefactorResult>;
+    private static findFiles;
+    static renameSymbol(options: RenameOptions): Promise<RefactorResult>;
+}

package/dist/refactor/refactor-engine.js

@@ -0,0 +1,587 @@
+import fs from 'fs';
+import path from 'path';
+import { TypeGenerator } from '../generator/type-generator.js';
+export const ENTITY_NAMING_RULES = {
+    'page-object': {
+        regex: /^[A-Z][a-zA-Z0-9]*$/,
+        convention: 'PascalCase (e.g. "LoginPage", "AuthPage")',
+    },
+    step: {
+        regex: /^[a-z][a-zA-Z0-9]*$/,
+        convention: 'camelCase (e.g. "loginUser", "loginAsAdmin")',
+    },
+    action: {
+        regex: /^[a-z][a-zA-Z0-9]*$/,
+        convention: 'camelCase (e.g. "customSwipe", "swipeTop")',
+    },
+    fixture: {
+        regex: /^[a-z][a-zA-Z0-9_]*$/,
+        convention: 'camelCase or snake_case starting with lowercase (e.g. "users", "apiPayloads", "user_accounts")',
+    },
+};
+export const SUPPORTED_FIXTURE_EXTENSIONS = ['.json', '.csv', '.yaml', '.yml', '.ts', '.js'];
+export class RefactorEngine {
+    /**
+     * Deterministically parses testing entity type and symbol name from a filesystem path.
+     * Supports directory paths, file paths, and paths with trailing slashes.
+     */
+    static parseEntityFromPath(filePath) {
+        if (!filePath || typeof filePath !== 'string')
+            return null;
+        const normalized = filePath.replace(/\\/g, '/').replace(/\/+$/, '');
+        const parts = normalized.split('/').filter(Boolean);
+        // 1. Page Objects: page-objects/<name> or page-objects/<name>/web.ts or page-objects/<name>.ts
+        const poIdx = parts.findIndex((p) => p === 'page-objects');
+        if (poIdx !== -1 && poIdx + 1 < parts.length) {
+            const rawSymbol = parts[poIdx + 1];
+            const symbol = path.parse(rawSymbol).name;
+            if (symbol)
+                return { type: 'page-object', symbol };
+        }
+        // 2. Steps: support/steps/<name> or steps/<name> or steps/<name>/step.md or steps/<name>.ts
+        const stepIdx = parts.findIndex((p) => p === 'steps');
+        if (stepIdx !== -1 && stepIdx + 1 < parts.length) {
+            const rawSymbol = parts[stepIdx + 1];
+            const symbol = path.parse(rawSymbol).name;
+            if (symbol)
+                return { type: 'step', symbol };
+        }
+        // 3. Actions: support/actions/<name> or actions/<name> or actions/<name>/action.ts or actions/<name>.ts
+        const actionIdx = parts.findIndex((p) => p === 'actions');
+        if (actionIdx !== -1 && actionIdx + 1 < parts.length) {
+            const rawSymbol = parts[actionIdx + 1];
+            const symbol = path.parse(rawSymbol).name;
+            if (symbol)
+                return { type: 'action', symbol };
+        }
+        // 4. Fixtures: fixtures/<name>.<ext> or fixtures/nested/<name>.<ext> or fixtures/<name>
+        const fixIdx = parts.findIndex((p) => p === 'fixtures');
+        if (fixIdx !== -1 && fixIdx + 1 < parts.length) {
+            const lastPart = parts[parts.length - 1];
+            const symbol = path.parse(lastPart).name;
+            if (symbol)
+                return { type: 'fixture', symbol };
+        }
+        return null;
+    }
+    /**
+     * Deterministically parses source and target paths, validates entity types,
+     * and executes symbol refactoring across the workspace.
+     */
+    static async renameFromPaths(options) {
+        const { workspaceRoot, fromPath, toPath, dryRun, skipPathRename } = options;
+        if (!fromPath || !toPath) {
+            return {
+                status: 'failed',
+                entityType: 'page-object',
+                oldSymbol: fromPath || '',
+                newSymbol: toPath || '',
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: 'Both source and target paths must be specified for path-based refactoring.',
+            };
+        }
+        const fromParsed = RefactorEngine.parseEntityFromPath(fromPath);
+        if (!fromParsed) {
+            return {
+                status: 'failed',
+                entityType: 'page-object',
+                oldSymbol: fromPath,
+                newSymbol: toPath,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Unable to determine entity type from source path: "${fromPath}". Path must be within page-objects/, support/steps/, support/actions/, or fixtures/.`,
+            };
+        }
+        const toParsed = RefactorEngine.parseEntityFromPath(toPath);
+        if (!toParsed) {
+            return {
+                status: 'failed',
+                entityType: fromParsed.type,
+                oldSymbol: fromParsed.symbol,
+                newSymbol: toPath,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Unable to determine entity type from target path: "${toPath}". Path must be within page-objects/, support/steps/, support/actions/, or fixtures/.`,
+            };
+        }
+        if (fromParsed.type !== toParsed.type) {
+            return {
+                status: 'failed',
+                entityType: fromParsed.type,
+                oldSymbol: fromParsed.symbol,
+                newSymbol: toParsed.symbol,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Entity type mismatch: source is "${fromParsed.type}" but target is "${toParsed.type}". Cross-entity refactoring is not supported.`,
+            };
+        }
+        return RefactorEngine.renameSymbol({
+            workspaceRoot,
+            type: fromParsed.type,
+            oldName: fromParsed.symbol,
+            newName: toParsed.symbol,
+            dryRun,
+            skipPathRename,
+        });
+    }
+    static findFiles(dir, extensions) {
+        const results = [];
+        if (!fs.existsSync(dir))
+            return results;
+        function walk(currentDir) {
+            const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name === 'node_modules' ||
+                    entry.name === 'dist' ||
+                    entry.name === '.git' ||
+                    entry.name === '.testspectra') {
+                    continue;
+                }
+                const fullPath = path.join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(fullPath);
+                }
+                else if (entry.isFile()) {
+                    if (extensions.some((ext) => entry.name.endsWith(ext))) {
+                        results.push(fullPath);
+                    }
+                }
+            }
+        }
+        walk(dir);
+        return results;
+    }
+    static async renameSymbol(options) {
+        const { workspaceRoot, type, oldName, newName, dryRun = false, skipPathRename = false } = options;
+        if (!oldName || !newName || oldName === newName) {
+            return {
+                status: 'failed',
+                entityType: type,
+                oldSymbol: oldName,
+                newSymbol: newName,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: 'Invalid or identical old/new symbol names',
+            };
+        }
+        let targetOldName = oldName;
+        let targetNewName = newName;
+        if (type === 'fixture') {
+            const parsedOld = path.parse(oldName);
+            if (parsedOld.ext && SUPPORTED_FIXTURE_EXTENSIONS.includes(parsedOld.ext.toLowerCase())) {
+                targetOldName = parsedOld.name;
+            }
+            const parsedNew = path.parse(newName);
+            if (parsedNew.ext && SUPPORTED_FIXTURE_EXTENSIONS.includes(parsedNew.ext.toLowerCase())) {
+                targetNewName = parsedNew.name;
+            }
+        }
+        const rule = ENTITY_NAMING_RULES[type];
+        if (rule && !rule.regex.test(targetNewName)) {
+            return {
+                status: 'failed',
+                entityType: type,
+                oldSymbol: oldName,
+                newSymbol: newName,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Invalid new symbol name "${targetNewName}". Symbol name for ${type} must follow ${rule.convention}.`,
+            };
+        }
+        // Phase 1: Determine file operations and replacement patterns
+        const plannedRenames = [];
+        const plannedEdits = [];
+        let oldSymbol = targetOldName;
+        let newSymbol = targetNewName;
+        const fixtureDirs = [
+            path.join(workspaceRoot, 'fixtures'),
+            path.join(workspaceRoot, 'support', 'fixtures'),
+            path.join(workspaceRoot, 'shared', 'fixtures'),
+        ];
+        function findFixtureFiles(dir) {
+            const files = [];
+            if (!fs.existsSync(dir))
+                return files;
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name !== 'node_modules' && entry.name !== '.git') {
+                        files.push(...findFixtureFiles(fullPath));
+                    }
+                }
+                else if (entry.isFile()) {
+                    const ext = path.extname(entry.name).toLowerCase();
+                    if (SUPPORTED_FIXTURE_EXTENSIONS.includes(ext)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+            return files;
+        }
+        // 1. Target Directory / File Discovery for Source Entity
+        if (type === 'page-object') {
+            oldSymbol = targetOldName;
+            newSymbol = targetNewName;
+            const targetPoDir = path.join(workspaceRoot, 'page-objects', targetNewName);
+            const poDir = path.join(workspaceRoot, 'page-objects', targetOldName);
+            if (fs.existsSync(poDir)) {
+                plannedRenames.push({ from: poDir, to: targetPoDir });
+            }
+            else if (skipPathRename && fs.existsSync(targetPoDir)) {
+                plannedRenames.push({ from: poDir, to: targetPoDir });
+            }
+        }
+        else if (type === 'step') {
+            oldSymbol = `Step.${targetOldName}`;
+            newSymbol = `Step.${targetNewName}`;
+            const stepCandidates = [
+                path.join(workspaceRoot, 'support', 'steps', targetOldName),
+                path.join(workspaceRoot, 'steps', targetOldName),
+            ];
+            for (const cand of stepCandidates) {
+                if (fs.existsSync(cand)) {
+                    const parent = path.dirname(cand);
+                    plannedRenames.push({ from: cand, to: path.join(parent, targetNewName) });
+                }
+                else if (skipPathRename) {
+                    const parent = path.dirname(cand);
+                    const targetCand = path.join(parent, targetNewName);
+                    if (fs.existsSync(targetCand)) {
+                        plannedRenames.push({ from: cand, to: targetCand });
+                    }
+                }
+            }
+        }
+        else if (type === 'action') {
+            oldSymbol = `Spectra.${targetOldName}`;
+            newSymbol = `Spectra.${targetNewName}`;
+            const actionCandidates = [
+                path.join(workspaceRoot, 'support', 'actions', targetOldName),
+                path.join(workspaceRoot, 'actions', targetOldName),
+            ];
+            for (const cand of actionCandidates) {
+                if (fs.existsSync(cand)) {
+                    const parent = path.dirname(cand);
+                    plannedRenames.push({ from: cand, to: path.join(parent, targetNewName) });
+                }
+                else if (skipPathRename) {
+                    const parent = path.dirname(cand);
+                    const targetCand = path.join(parent, targetNewName);
+                    if (fs.existsSync(targetCand)) {
+                        plannedRenames.push({ from: cand, to: targetCand });
+                    }
+                }
+            }
+        }
+        else if (type === 'fixture') {
+            oldSymbol = `Fixture.${targetOldName}`;
+            newSymbol = `Fixture.${targetNewName}`;
+            for (const dir of fixtureDirs) {
+                const fixtureFiles = findFixtureFiles(dir);
+                for (const file of fixtureFiles) {
+                    const parsed = path.parse(file);
+                    if (parsed.name === targetOldName) {
+                        plannedRenames.push({
+                            from: file,
+                            to: path.join(parsed.dir, `${targetNewName}${parsed.ext}`),
+                        });
+                    }
+                    else if (skipPathRename && parsed.name === targetNewName) {
+                        plannedRenames.push({
+                            from: path.join(parsed.dir, `${targetOldName}${parsed.ext}`),
+                            to: file,
+                        });
+                    }
+                }
+            }
+        }
+        // 2. Scan Codebases and AST replacements in memory
+        const searchDirs = [
+            path.join(workspaceRoot, 'specs'),
+            path.join(workspaceRoot, 'suites'),
+            path.join(workspaceRoot, 'page-objects'),
+            path.join(workspaceRoot, 'support'),
+            path.join(workspaceRoot, 'steps'),
+            path.join(workspaceRoot, 'actions'),
+            path.join(workspaceRoot, 'global-hooks'),
+            path.join(workspaceRoot, 'packages'),
+            path.join(workspaceRoot, 'apps'),
+            path.join(workspaceRoot, 'shared'),
+        ];
+        const allCodeFiles = searchDirs.flatMap((dir) => this.findFiles(dir, ['.ts', '.js', '.md']));
+        const uniqueFiles = Array.from(new Set(allCodeFiles));
+        let totalOccurrences = 0;
+        for (const filePath of uniqueFiles) {
+            const originalContent = fs.readFileSync(filePath, 'utf-8');
+            let modified = originalContent;
+            let count = 0;
+            if (type === 'page-object') {
+                // Replace `class OldName` -> `class NewName`
+                const classReg = new RegExp(`\\bclass\\s+${oldName}\\b`, 'g');
+                const classMatches = (modified.match(classReg) || []).length;
+                if (classMatches > 0) {
+                    modified = modified.replace(classReg, `class ${newName}`);
+                    count += classMatches;
+                }
+                // Replace `new OldName` -> `new NewName` (e.g. `export default new OldName()`, `new OldName(...)`)
+                const newReg = new RegExp(`\\bnew\\s+${oldName}\\b`, 'g');
+                const newMatches = (modified.match(newReg) || []).length;
+                if (newMatches > 0) {
+                    modified = modified.replace(newReg, `new ${newName}`);
+                    count += newMatches;
+                }
+                // Replace `export default OldName` -> `export default NewName`
+                const exportDefaultReg = new RegExp(`\\bexport\\s+default\\s+${oldName}\\b`, 'g');
+                const exportDefaultMatches = (modified.match(exportDefaultReg) || []).length;
+                if (exportDefaultMatches > 0) {
+                    modified = modified.replace(exportDefaultReg, `export default ${newName}`);
+                    count += exportDefaultMatches;
+                }
+                // Replace `OldName.` -> `NewName.`
+                const refReg = new RegExp(`\\b${oldName}\\.`, 'g');
+                const refMatches = (modified.match(refReg) || []).length;
+                if (refMatches > 0) {
+                    modified = modified.replace(refReg, `${newName}.`);
+                    count += refMatches;
+                }
+            }
+            else if (type === 'step') {
+                // Replace `Step.oldStep(` -> `Step.newStep(`
+                const stepCallReg = new RegExp(`\\bStep\\.${oldName}\\b`, 'g');
+                const stepCallMatches = (modified.match(stepCallReg) || []).length;
+                if (stepCallMatches > 0) {
+                    modified = modified.replace(stepCallReg, `Step.${newName}`);
+                    count += stepCallMatches;
+                }
+                // Replace `@step:oldStep` -> `@step:newStep` in markdown specs
+                const directiveReg = new RegExp(`@step:${oldName}\\b`, 'g');
+                const dirMatches = (modified.match(directiveReg) || []).length;
+                if (dirMatches > 0) {
+                    modified = modified.replace(directiveReg, `@step:${newName}`);
+                    count += dirMatches;
+                }
+            }
+            else if (type === 'action') {
+                // Replace `Spectra.oldAction(` -> `Spectra.newAction(`
+                const actionReg = new RegExp(`\\bSpectra\\.${oldName}\\b`, 'g');
+                const actionMatches = (modified.match(actionReg) || []).length;
+                if (actionMatches > 0) {
+                    modified = modified.replace(actionReg, `Spectra.${newName}`);
+                    count += actionMatches;
+                }
+            }
+            else if (type === 'fixture') {
+                // Replace `Fixture.oldFixture` -> `Fixture.newFixture`
+                const fixReg = new RegExp(`\\bFixture\\.${targetOldName}\\b`, 'g');
+                const fixMatches = (modified.match(fixReg) || []).length;
+                if (fixMatches > 0) {
+                    modified = modified.replace(fixReg, `Fixture.${targetNewName}`);
+                    count += fixMatches;
+                }
+                // Also replace file references with supported extensions (e.g. 'users.csv', 'users.yaml', etc.)
+                const extPattern = SUPPORTED_FIXTURE_EXTENSIONS.map((e) => e.replace('.', '')).join('|');
+                const fixFileReg = new RegExp(`(?<!Fixture\\.)\\b${targetOldName}\\.(${extPattern})\\b`, 'g');
+                const fixFileMatches = (modified.match(fixFileReg) || []).length;
+                if (fixFileMatches > 0) {
+                    modified = modified.replace(fixFileReg, `${targetNewName}.$1`);
+                    count += fixFileMatches;
+                }
+            }
+            if (count > 0) {
+                totalOccurrences += count;
+                plannedEdits.push({
+                    filePath,
+                    originalContent,
+                    newContent: modified,
+                    count,
+                });
+            }
+        }
+        // Source Existence Guard:
+        // If no filesystem files/directories match the source symbol AND no code occurrences were found,
+        // the source symbol does not exist anywhere in the workspace.
+        if (plannedRenames.length === 0 && totalOccurrences === 0) {
+            return {
+                status: 'failed',
+                entityType: type,
+                oldSymbol,
+                newSymbol,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Source ${type} "${oldName}" was not found in the workspace (no matching files or symbol occurrences).`,
+            };
+        }
+        // Target Collision Guards (Priority 2 - checked only if source entity exists and skipPathRename is false)
+        if (!skipPathRename) {
+            if (type === 'page-object') {
+                const targetPoDir = path.join(workspaceRoot, 'page-objects', targetNewName);
+                if (fs.existsSync(targetPoDir)) {
+                    return {
+                        status: 'failed',
+                        entityType: type,
+                        oldSymbol,
+                        newSymbol,
+                        modifiedFiles: [],
+                        occurrencesReplaced: 0,
+                        error: `Target page-object "${targetNewName}" already exists at "${path.relative(workspaceRoot, targetPoDir)}"`,
+                    };
+                }
+            }
+            else if (type === 'step') {
+                const targetStepCandidates = [
+                    path.join(workspaceRoot, 'support', 'steps', targetNewName),
+                    path.join(workspaceRoot, 'steps', targetNewName),
+                ];
+                for (const cand of targetStepCandidates) {
+                    if (fs.existsSync(cand)) {
+                        return {
+                            status: 'failed',
+                            entityType: type,
+                            oldSymbol,
+                            newSymbol,
+                            modifiedFiles: [],
+                            occurrencesReplaced: 0,
+                            error: `Target step "${targetNewName}" already exists at "${path.relative(workspaceRoot, cand)}"`,
+                        };
+                    }
+                }
+            }
+            else if (type === 'action') {
+                const targetActionCandidates = [
+                    path.join(workspaceRoot, 'support', 'actions', targetNewName),
+                    path.join(workspaceRoot, 'actions', targetNewName),
+                ];
+                for (const cand of targetActionCandidates) {
+                    if (fs.existsSync(cand)) {
+                        return {
+                            status: 'failed',
+                            entityType: type,
+                            oldSymbol,
+                            newSymbol,
+                            modifiedFiles: [],
+                            occurrencesReplaced: 0,
+                            error: `Target action "${targetNewName}" already exists at "${path.relative(workspaceRoot, cand)}"`,
+                        };
+                    }
+                }
+            }
+            else if (type === 'fixture') {
+                for (const dir of fixtureDirs) {
+                    const fixtureFiles = findFixtureFiles(dir);
+                    for (const file of fixtureFiles) {
+                        const parsed = path.parse(file);
+                        if (parsed.name === targetNewName) {
+                            return {
+                                status: 'failed',
+                                entityType: type,
+                                oldSymbol,
+                                newSymbol,
+                                modifiedFiles: [],
+                                occurrencesReplaced: 0,
+                                error: `Target fixture "${targetNewName}" already exists at "${path.relative(workspaceRoot, file)}"`,
+                            };
+                        }
+                    }
+                }
+            }
+            // Universal pre-commit collision guard
+            for (const rn of plannedRenames) {
+                if (fs.existsSync(rn.to)) {
+                    return {
+                        status: 'failed',
+                        entityType: type,
+                        oldSymbol,
+                        newSymbol,
+                        modifiedFiles: [],
+                        occurrencesReplaced: 0,
+                        error: `Target destination already exists on disk: "${path.relative(workspaceRoot, rn.to)}"`,
+                    };
+                }
+            }
+        }
+        if (dryRun) {
+            return {
+                status: 'success',
+                entityType: type,
+                oldSymbol,
+                newSymbol,
+                modifiedFiles: plannedEdits.map((e) => path.relative(workspaceRoot, e.filePath)),
+                occurrencesReplaced: totalOccurrences,
+                renamedPaths: plannedRenames,
+            };
+        }
+        // Phase 2: Atomic Flush & Rollback Guard
+        const modifiedFilesWritten = [];
+        const originalSnapshots = new Map();
+        try {
+            // 1. Write file edits
+            for (const edit of plannedEdits) {
+                originalSnapshots.set(edit.filePath, edit.originalContent);
+                fs.writeFileSync(edit.filePath, edit.newContent, 'utf-8');
+                modifiedFilesWritten.push(edit.filePath);
+            }
+            // 2. Perform path renames (directories and files)
+            if (!skipPathRename) {
+                for (const rn of plannedRenames) {
+                    if (fs.existsSync(rn.from)) {
+                        const parent = path.dirname(rn.to);
+                        if (!fs.existsSync(parent))
+                            fs.mkdirSync(parent, { recursive: true });
+                        fs.renameSync(rn.from, rn.to);
+                    }
+                }
+            }
+            // 3. Automatically regenerate ambient declarations post-refactor
+            TypeGenerator.generateAll(workspaceRoot);
+            const typesDir = path.join(workspaceRoot, '.testspectra', 'types');
+            if (fs.existsSync(typesDir)) {
+                if (fs.existsSync(path.join(typesDir, 'web.d.ts'))) {
+                    modifiedFilesWritten.push(path.join(typesDir, 'web.d.ts'));
+                }
+                if (fs.existsSync(path.join(typesDir, 'fixtures.d.ts'))) {
+                    modifiedFilesWritten.push(path.join(typesDir, 'fixtures.d.ts'));
+                }
+            }
+            return {
+                status: 'success',
+                entityType: type,
+                oldSymbol,
+                newSymbol,
+                modifiedFiles: Array.from(new Set(modifiedFilesWritten.map((p) => path.relative(workspaceRoot, p)))),
+                occurrencesReplaced: totalOccurrences,
+                renamedPaths: plannedRenames,
+            };
+        }
+        catch (ioErr) {
+            // ROLLBACK GUARD: Restore all modified files from original snapshots
+            for (const [filePath, orig] of originalSnapshots.entries()) {
+                try {
+                    fs.writeFileSync(filePath, orig, 'utf-8');
+                }
+                catch { }
+            }
+            // Reverse path renames
+            if (!skipPathRename) {
+                for (const rn of plannedRenames) {
+                    if (fs.existsSync(rn.to)) {
+                        try {
+                            fs.renameSync(rn.to, rn.from);
+                        }
+                        catch { }
+                    }
+                }
+            }
+            return {
+                status: 'failed',
+                entityType: type,
+                oldSymbol,
+                newSymbol,
+                modifiedFiles: [],
+                occurrencesReplaced: 0,
+                error: `Atomic rollback executed due to I/O error: ${ioErr.message}`,
+            };
+        }
+    }
+}

package/dist/reporter/__tests__/semantic-formatter.test.d.ts

@@ -0,0 +1 @@
+export {};