@oamm/textor 1.0.12 → 1.0.13

package/dist/index.cjs

@@ -6,6 +6,7 @@ var path = require('path');
 var crypto = require('crypto');
 var child_process = require('child_process');
 var util = require('util');
+var readline = require('readline');
 
 const CONFIG_DIR$1 = '.textor';
 const CONFIG_FILE = 'config.json';
@@ -497,6 +498,8 @@ function normalizeRoute(route) {
 }
 function routeToFilePath(route, options = {}) {
     const { extension = '.astro', mode = 'flat', indexFile = 'index.astro' } = options;
+    if (!route)
+        return null;
     const normalized = normalizeRoute(route);
     if (normalized === '/') {
         return indexFile;
@@ -715,6 +718,10 @@ async function safeMove(fromPath, toPath, options = {}) {
     if (!fs.existsSync(fromPath)) {
         throw new Error(`Source file not found: ${fromPath}`);
     }
+    if (path.resolve(fromPath) === path.resolve(toPath)) {
+        const content = await promises.readFile(toPath, 'utf-8');
+        return calculateHash(content, normalization);
+    }
     if (fs.existsSync(toPath) && !force) {
         throw new Error(`Destination already exists: ${toPath}\n` +
             `Use --force to overwrite.`);
@@ -2350,6 +2357,189 @@ async function updateImportsInFile$1(filePath, oldFilePath, newFilePath) {
     await promises.writeFile(filePath, content, 'utf-8');
 }
 
+/**
+ * Updates relative imports in a file after it has been moved.
+ */
+async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
+    if (!fs.existsSync(filePath))
+        return;
+    let content = await promises.readFile(filePath, 'utf-8');
+    const oldDir = path.dirname(oldFilePath);
+    const newDir = path.dirname(newFilePath);
+    if (oldDir === newDir)
+        return;
+    // Find all relative imports
+    const relativeImportRegex = /from\s+['"](\.\.?\/[^'"]+)['"]/g;
+    let match;
+    const replacements = [];
+    while ((match = relativeImportRegex.exec(content)) !== null) {
+        const relativePath = match[1];
+        const absoluteTarget = path.resolve(oldDir, relativePath);
+        const newRelativePath = getRelativeImportPath(newFilePath, absoluteTarget);
+        replacements.push({
+            full: match[0],
+            oldRel: relativePath,
+            newRel: newRelativePath
+        });
+    }
+    for (const repl of replacements) {
+        content = content.replace(repl.full, `from '${repl.newRel}'`);
+    }
+    await promises.writeFile(filePath, content, 'utf-8');
+}
+/**
+ * Moves a directory and its contents, renaming files and updating internal content/imports.
+ */
+async function moveDirectory(fromPath, toPath, state, config, options = {}) {
+    const { fromName, toName, owner = null, signatures = [] } = options;
+    if (!fs.existsSync(fromPath)) {
+        throw new Error(`Source directory not found: ${fromPath}`);
+    }
+    if (fs.existsSync(toPath) && !options.force) {
+        throw new Error(`Destination already exists: ${toPath}\n` +
+            `Use --force to overwrite.`);
+    }
+    await ensureDir(toPath);
+    const entries = await promises.readdir(fromPath);
+    for (const entry of entries) {
+        let targetEntry = entry;
+        // Rename files if they match the component name
+        if (fromName && toName && fromName !== toName) {
+            if (entry.includes(fromName)) {
+                targetEntry = entry.replace(fromName, toName);
+            }
+        }
+        const fromEntryPath = path.join(fromPath, entry);
+        const toEntryPath = path.join(toPath, targetEntry);
+        const stats = await promises.stat(fromEntryPath);
+        if (stats.isDirectory()) {
+            await moveDirectory(fromEntryPath, toEntryPath, state, config, options);
+        }
+        else {
+            const normalizedFromRelative = path.relative(process.cwd(), fromEntryPath).replace(/\\/g, '/');
+            const fileState = state.files[normalizedFromRelative];
+            const newHash = await safeMove(fromEntryPath, toEntryPath, {
+                force: options.force,
+                expectedHash: fileState?.hash,
+                acceptChanges: options.acceptChanges,
+                normalization: config.hashing?.normalization,
+                owner,
+                actualOwner: fileState?.owner,
+                signatures
+            });
+            // Update internal content (signatures, component names) if renaming
+            if (fromName && toName && fromName !== toName) {
+                let content = await promises.readFile(toEntryPath, 'utf-8');
+                let hasChanged = false;
+                // Simple replacement of component names
+                if (content.includes(fromName)) {
+                    content = content.replace(new RegExp(fromName, 'g'), toName);
+                    hasChanged = true;
+                }
+                // Also handle lowercase class names if any
+                const fromLower = fromName.toLowerCase();
+                const toLower = toName.toLowerCase();
+                if (content.includes(fromLower)) {
+                    content = content.replace(new RegExp(fromLower, 'g'), toLower);
+                    hasChanged = true;
+                }
+                if (hasChanged) {
+                    await promises.writeFile(toEntryPath, content, 'utf-8');
+                    // Re-calculate hash after content update
+                    const updatedHash = calculateHash(content, config.hashing?.normalization);
+                    const normalizedToRelative = path.relative(process.cwd(), toEntryPath).replace(/\\/g, '/');
+                    if (fileState) {
+                        state.files[normalizedToRelative] = { ...fileState, hash: updatedHash };
+                        delete state.files[normalizedFromRelative];
+                    }
+                }
+                else {
+                    // Update state for each file moved normally
+                    const normalizedToRelative = path.relative(process.cwd(), toEntryPath).replace(/\\/g, '/');
+                    if (fileState) {
+                        state.files[normalizedToRelative] = { ...fileState, hash: newHash };
+                        delete state.files[normalizedFromRelative];
+                    }
+                }
+            }
+            else {
+                // Update state for each file moved normally
+                const normalizedToRelative = path.relative(process.cwd(), toEntryPath).replace(/\\/g, '/');
+                if (fileState) {
+                    state.files[normalizedToRelative] = { ...fileState, hash: newHash };
+                    delete state.files[normalizedFromRelative];
+                }
+            }
+        }
+    }
+    const remainingFiles = await promises.readdir(fromPath);
+    if (remainingFiles.length === 0) {
+        await promises.rmdir(fromPath);
+    }
+}
+/**
+ * Scans the project and replaces imports of a moved/renamed item.
+ */
+async function scanAndReplaceImports(config, state, fromInfo, toInfo, options) {
+    const { fromPath: fromItemPath, fromName, type } = fromInfo;
+    const { toPath: toItemPath, toName } = toInfo;
+    const allFiles = new Set();
+    await scanDirectory(process.cwd(), allFiles);
+    const rootPath = resolvePath(config, type === 'component' ? 'components' : 'features');
+    for (const relPath of allFiles) {
+        const fullPath = path.resolve(process.cwd(), relPath);
+        // Skip the moved directory itself
+        const toFullPath = path.resolve(toItemPath);
+        if (fullPath.startsWith(toFullPath))
+            continue;
+        let content = await promises.readFile(fullPath, 'utf-8');
+        let changed = false;
+        const aliasBase = config.importAliases[type === 'component' ? 'components' : 'features'];
+        const ext = type === 'component' ? '' : (config.naming.featureExtension === '.astro' ? '.astro' : '');
+        if (aliasBase) {
+            const oldAlias = `${aliasBase}/${fromItemPath}`;
+            const newAlias = `${aliasBase}/${toItemPath}`;
+            const oldFullImport = `from '${oldAlias}/${fromName}${ext}'`;
+            const newFullImport = `from '${newAlias}/${toName}${ext}'`;
+            if (content.includes(oldFullImport)) {
+                content = content.replace(new RegExp(oldFullImport.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newFullImport);
+                changed = true;
+            }
+            else if (content.includes(oldAlias)) {
+                content = content.replace(new RegExp(oldAlias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newAlias);
+                changed = true;
+            }
+        }
+        else {
+            const oldDir = path.resolve(rootPath, fromItemPath);
+            const newDir = path.resolve(rootPath, toItemPath);
+            const oldRelPath = getRelativeImportPath(fullPath, oldDir);
+            const newRelPath = getRelativeImportPath(fullPath, newDir);
+            const oldImport = `'${oldRelPath}/${fromName}${ext}'`;
+            const newImport = `'${newRelPath}/${toName}${ext}'`;
+            if (content.includes(oldImport)) {
+                content = content.replace(new RegExp(oldImport.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newImport);
+                changed = true;
+            }
+        }
+        if (fromName !== toName && changed) {
+            content = content.replace(new RegExp(`\\b${fromName}\\b`, 'g'), toName);
+        }
+        if (changed) {
+            if (options.dryRun) {
+                console.log(`  [Scan] Would update imports in ${relPath}`);
+            }
+            else {
+                await promises.writeFile(fullPath, content, 'utf-8');
+                console.log(`  [Scan] Updated imports in ${relPath}`);
+                if (state.files[relPath]) {
+                    state.files[relPath].hash = calculateHash(content, config.hashing?.normalization);
+                }
+            }
+        }
+    }
+}
+
 /**
  * Move a section (route + feature).
  *
@@ -2374,40 +2564,53 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
         let actualFromFeature = fromFeature;
         let actualToRoute = toRoute;
         let actualToFeature = toFeature;
-        // Shift arguments if using state
+        // Shift arguments if using state or if called with fewer arguments
         if (!toRoute && fromRoute && fromFeature) {
             // textor move-section /old-route /new-route
-            const section = findSection(state, fromRoute);
+            actualFromRoute = fromRoute;
+            actualToRoute = fromFeature;
+            actualFromFeature = undefined;
+            actualToFeature = undefined;
+        }
+        // Lookup missing info from state
+        if (actualFromRoute && !actualFromFeature) {
+            const section = findSection(state, actualFromRoute);
             if (section) {
-                actualFromRoute = section.route;
                 actualFromFeature = section.featurePath;
-                actualToRoute = fromFeature; // the second argument was actually the new route
-                actualToFeature = toRoute; // which is null
-                // If toFeature is not provided, try to derive it from the new route
-                if (!actualToFeature && actualToRoute) {
-                    const oldRouteParts = actualFromRoute.split('/').filter(Boolean);
-                    const newRouteParts = actualToRoute.split('/').filter(Boolean);
-                    const oldFeatureParts = actualFromFeature.split('/').filter(Boolean);
-                    // If the feature path starts with the old route parts, replace them
-                    // We compare case-insensitively or via PascalCase to be more helpful
-                    let match = true;
-                    for (let i = 0; i < oldRouteParts.length; i++) {
-                        const routePart = oldRouteParts[i].toLowerCase();
-                        const featurePart = oldFeatureParts[i] ? oldFeatureParts[i].toLowerCase() : null;
-                        if (featurePart !== routePart) {
-                            match = false;
-                            break;
-                        }
-                    }
-                    if (match && oldRouteParts.length > 0) {
-                        actualToFeature = [...newRouteParts, ...oldFeatureParts.slice(oldRouteParts.length)].join('/');
-                    }
-                    else {
-                        // Otherwise just keep it the same
-                        actualToFeature = actualFromFeature;
-                    }
+            }
+        }
+        else if (!actualFromRoute && actualFromFeature) {
+            const section = findSection(state, actualFromFeature);
+            if (section) {
+                actualFromRoute = section.route;
+            }
+        }
+        // If toFeature is not provided, try to derive it from the new route if route moved
+        if (!actualToFeature && actualToRoute && actualFromRoute && actualFromRoute !== actualToRoute && actualFromFeature) {
+            const oldRouteParts = actualFromRoute.split('/').filter(Boolean);
+            const newRouteParts = actualToRoute.split('/').filter(Boolean);
+            const oldFeatureParts = actualFromFeature.split('/').filter(Boolean);
+            let match = true;
+            for (let i = 0; i < oldRouteParts.length; i++) {
+                const routePart = oldRouteParts[i].toLowerCase();
+                const featurePart = oldFeatureParts[i] ? oldFeatureParts[i].toLowerCase() : null;
+                if (featurePart !== routePart) {
+                    match = false;
+                    break;
                 }
             }
+            if (match && oldRouteParts.length > 0) {
+                actualToFeature = [...newRouteParts, ...oldFeatureParts.slice(oldRouteParts.length)].join('/');
+            }
+            else {
+                actualToFeature = actualFromFeature;
+            }
+        }
+        else if (!actualToFeature) {
+            actualToFeature = actualFromFeature;
+        }
+        if (!actualToRoute) {
+            actualToRoute = actualFromRoute;
         }
         const isRouteOnly = options.keepFeature || (!actualToFeature && actualToRoute && !actualFromFeature);
         if (isRouteOnly && !actualToRoute) {
@@ -2432,12 +2635,14 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
             mode: config.routing.mode,
             indexFile: config.routing.indexFile
         });
-        const fromRoutePath = secureJoin(pagesRoot, fromRouteFile);
-        const toRoutePath = secureJoin(pagesRoot, toRouteFile);
+        const fromRoutePath = fromRouteFile ? secureJoin(pagesRoot, fromRouteFile) : null;
+        const toRoutePath = toRouteFile ? secureJoin(pagesRoot, toRouteFile) : null;
         const movedFiles = [];
         if (options.dryRun) {
             console.log('Dry run - would move:');
-            console.log(`  Route: ${fromRoutePath} -> ${toRoutePath}`);
+            if (fromRoutePath && toRoutePath && fromRoutePath !== toRoutePath) {
+                console.log(`  Route: ${fromRoutePath} -> ${toRoutePath}`);
+            }
             if (!isRouteOnly && normalizedFromFeature && normalizedToFeature) {
                 const fromFeaturePath = secureJoin(featuresRoot, normalizedFromFeature);
                 const toFeaturePath = secureJoin(featuresRoot, normalizedToFeature);
@@ -2445,81 +2650,90 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
             }
             return;
         }
-        const normalizedFromRouteRelative = path.relative(process.cwd(), fromRoutePath).replace(/\\/g, '/');
-        const routeFileState = state.files[normalizedFromRouteRelative];
-        const newRouteHash = await safeMove(fromRoutePath, toRoutePath, {
-            force: options.force,
-            expectedHash: routeFileState?.hash,
-            acceptChanges: options.acceptChanges,
-            owner: normalizedFromRoute,
-            actualOwner: routeFileState?.owner,
-            signatures: configSignatures
-        });
-        movedFiles.push({ from: fromRoutePath, to: toRoutePath });
-        // Update state for moved route file
-        const normalizedToRouteRelative = path.relative(process.cwd(), toRoutePath).replace(/\\/g, '/');
-        if (routeFileState) {
-            state.files[normalizedToRouteRelative] = { ...routeFileState, hash: newRouteHash };
-            delete state.files[normalizedFromRouteRelative];
-        }
-        // Update imports in the moved route file
-        const targetFeature = normalizedToFeature || normalizedFromFeature;
-        if (targetFeature) {
-            const fromFeatureDirPath = secureJoin(featuresRoot, normalizedFromFeature);
-            const toFeatureDirPath = secureJoin(featuresRoot, targetFeature);
-            const fromFeatureComponentName = getFeatureComponentName(normalizedFromFeature);
-            const toFeatureComponentName = getFeatureComponentName(targetFeature);
-            // First, update all relative imports in the file because it moved
-            await updateImportsInFile(toRoutePath, fromRoutePath, toRoutePath);
-            let content = await promises.readFile(toRoutePath, 'utf-8');
-            let changed = false;
-            // Update component name in JSX tags
-            if (fromFeatureComponentName !== toFeatureComponentName) {
-                content = content.replace(new RegExp(`<${fromFeatureComponentName}`, 'g'), `<${toFeatureComponentName}`);
-                content = content.replace(new RegExp(`</${fromFeatureComponentName}`, 'g'), `</${toFeatureComponentName}`);
-                changed = true;
+        let normalizedToRouteRelative = null;
+        if (fromRoutePath && toRoutePath) {
+            const normalizedFromRouteRelative = path.relative(process.cwd(), fromRoutePath).replace(/\\/g, '/');
+            const routeFileState = state.files[normalizedFromRouteRelative];
+            const newRouteHash = await safeMove(fromRoutePath, toRoutePath, {
+                force: options.force,
+                expectedHash: routeFileState?.hash,
+                acceptChanges: options.acceptChanges,
+                owner: normalizedFromRoute,
+                actualOwner: routeFileState?.owner,
+                signatures: configSignatures
+            });
+            if (fromRoutePath !== toRoutePath) {
+                movedFiles.push({ from: fromRoutePath, to: toRoutePath });
+            }
+            // Update state for moved route file
+            normalizedToRouteRelative = path.relative(process.cwd(), toRoutePath).replace(/\\/g, '/');
+            if (routeFileState) {
+                state.files[normalizedToRouteRelative] = { ...routeFileState, hash: newRouteHash };
+                if (fromRoutePath !== toRoutePath) {
+                    delete state.files[normalizedFromRouteRelative];
+                }
             }
-            if (config.importAliases.features) {
-                const oldAliasPath = `${config.importAliases.features}/${normalizedFromFeature}`;
-                const newAliasPath = `${config.importAliases.features}/${targetFeature}`;
-                // Flexible regex to match import identifier and path with alias
-                const importRegex = new RegExp(`(import\\s+)(${fromFeatureComponentName})(\\s+from\\s+['"])${oldAliasPath}(/[^'"]+)?(['"])`, 'g');
-                if (importRegex.test(content)) {
-                    content = content.replace(importRegex, (match, p1, p2, p3, subPath, p5) => {
-                        let newSubPath = subPath || '';
-                        if (subPath && subPath.includes(fromFeatureComponentName)) {
-                            newSubPath = subPath.replace(fromFeatureComponentName, toFeatureComponentName);
-                        }
-                        return `${p1}${toFeatureComponentName}${p3}${newAliasPath}${newSubPath}${p5}`;
-                    });
+            // Update imports in the route file (even if it didn't move, as feature might have)
+            const targetFeature = normalizedToFeature || normalizedFromFeature;
+            if (targetFeature && fs.existsSync(toRoutePath)) {
+                const fromFeatureDirPath = secureJoin(featuresRoot, normalizedFromFeature);
+                const toFeatureDirPath = secureJoin(featuresRoot, targetFeature);
+                const fromFeatureComponentName = getFeatureComponentName(normalizedFromFeature);
+                const toFeatureComponentName = getFeatureComponentName(targetFeature);
+                // First, update all relative imports in the file because it moved (or stayed)
+                await updateImportsInFile(toRoutePath, fromRoutePath, toRoutePath);
+                let content = await promises.readFile(toRoutePath, 'utf-8');
+                let changed = false;
+                // Update component name in JSX tags
+                if (fromFeatureComponentName !== toFeatureComponentName) {
+                    content = content.replace(new RegExp(`<${fromFeatureComponentName}`, 'g'), `<${toFeatureComponentName}`);
+                    content = content.replace(new RegExp(`</${fromFeatureComponentName}`, 'g'), `</${toFeatureComponentName}`);
                     changed = true;
                 }
-                else if (content.includes(oldAliasPath)) {
-                    // Fallback for path only replacement
-                    content = content.replace(new RegExp(oldAliasPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newAliasPath);
-                    changed = true;
+                if (config.importAliases.features) {
+                    const oldAliasPath = `${config.importAliases.features}/${normalizedFromFeature}`;
+                    const newAliasPath = `${config.importAliases.features}/${targetFeature}`;
+                    // Flexible regex to match import identifier and path with alias
+                    const importRegex = new RegExp(`(import\\s+)(${fromFeatureComponentName})(\\s+from\\s+['"])${oldAliasPath}(/[^'"]+)?(['"])`, 'g');
+                    if (importRegex.test(content)) {
+                        content = content.replace(importRegex, (match, p1, p2, p3, subPath, p5) => {
+                            let newSubPath = subPath || '';
+                            if (subPath && subPath.includes(fromFeatureComponentName)) {
+                                newSubPath = subPath.replace(fromFeatureComponentName, toFeatureComponentName);
+                            }
+                            return `${p1}${toFeatureComponentName}${p3}${newAliasPath}${newSubPath}${p5}`;
+                        });
+                        changed = true;
+                    }
+                    else if (content.includes(oldAliasPath)) {
+                        // Fallback for path only replacement
+                        content = content.replace(new RegExp(oldAliasPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newAliasPath);
+                        changed = true;
+                    }
                 }
-            }
-            else {
-                const oldRelativeDir = getRelativeImportPath(toRoutePath, fromFeatureDirPath);
-                const newRelativeDir = getRelativeImportPath(toRoutePath, toFeatureDirPath);
-                // Flexible regex for relative imports
-                const relImportRegex = new RegExp(`(import\\s+)(${fromFeatureComponentName})(\\s+from\\s+['"])${oldRelativeDir}(/[^'"]+)?(['"])`, 'g');
-                if (relImportRegex.test(content)) {
-                    content = content.replace(relImportRegex, (match, p1, p2, p3, subPath, p5) => {
-                        let newSubPath = subPath || '';
-                        if (subPath && subPath.includes(fromFeatureComponentName)) {
-                            newSubPath = subPath.replace(fromFeatureComponentName, toFeatureComponentName);
-                        }
-                        return `${p1}${toFeatureComponentName}${p3}${newRelativeDir}${newSubPath}${p5}`;
-                    });
-                    changed = true;
+                else {
+                    const oldRelativeDir = getRelativeImportPath(toRoutePath, fromFeatureDirPath);
+                    const newRelativeDir = getRelativeImportPath(toRoutePath, toFeatureDirPath);
+                    // Flexible regex for relative imports
+                    const relImportRegex = new RegExp(`(import\\s+)(${fromFeatureComponentName})(\\s+from\\s+['"])${oldRelativeDir}(/[^'"]+)?(['"])`, 'g');
+                    if (relImportRegex.test(content)) {
+                        content = content.replace(relImportRegex, (match, p1, p2, p3, subPath, p5) => {
+                            let newSubPath = subPath || '';
+                            if (subPath && subPath.includes(fromFeatureComponentName)) {
+                                newSubPath = subPath.replace(fromFeatureComponentName, toFeatureComponentName);
+                            }
+                            return `${p1}${toFeatureComponentName}${p3}${newRelativeDir}${newSubPath}${p5}`;
+                        });
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    await promises.writeFile(toRoutePath, content, 'utf-8');
+                    // Update hash in state after changes
+                    if (state.files[normalizedToRouteRelative]) {
+                        state.files[normalizedToRouteRelative].hash = calculateHash(content, config.hashing?.normalization);
+                    }
                 }
-            }
-            if (changed) {
-                await promises.writeFile(toRoutePath, content, 'utf-8');
-                // Update hash in state after changes
-                state.files[normalizedToRouteRelative].hash = calculateHash(content, config.hashing?.normalization);
             }
         }
         if (!isRouteOnly && normalizedFromFeature && normalizedToFeature && normalizedFromFeature !== normalizedToFeature) {
@@ -2541,14 +2755,17 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
         }
         if (options.scan && (normalizedFromFeature || normalizedToFeature)) {
             await scanAndReplaceImports(config, state, {
-                fromFeaturePath: normalizedFromFeature,
-                fromComponentName: getFeatureComponentName(normalizedFromFeature)
+                fromPath: normalizedFromFeature,
+                fromName: getFeatureComponentName(normalizedFromFeature),
+                type: 'feature'
             }, {
-                toFeaturePath: normalizedToFeature || normalizedFromFeature,
-                toComponentName: getFeatureComponentName(normalizedToFeature || normalizedFromFeature)
+                toPath: normalizedToFeature || normalizedFromFeature,
+                toName: getFeatureComponentName(normalizedToFeature || normalizedFromFeature)
             }, options);
         }
-        await cleanupEmptyDirs(path.dirname(fromRoutePath), pagesRoot);
+        if (fromRoutePath && toRoutePath && fromRoutePath !== toRoutePath) {
+            await cleanupEmptyDirs(path.dirname(fromRoutePath), pagesRoot);
+        }
         console.log('✓ Moved:');
         movedFiles.forEach(item => {
             console.log(`  ${item.from}`);
@@ -2556,6 +2773,14 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
         });
         if (movedFiles.length > 0) {
             const existingSection = fromSection;
+            // Update ownership in state if route moved
+            if (normalizedFromRoute && normalizedToRoute && normalizedFromRoute !== normalizedToRoute) {
+                for (const f in state.files) {
+                    if (state.files[f].owner === normalizedFromRoute) {
+                        state.files[f].owner = normalizedToRoute;
+                    }
+                }
+            }
             // Update section data in state
             state.sections = state.sections.filter(s => s.route !== normalizedFromRoute);
             state.sections.push({
@@ -2576,182 +2801,6 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
         throw error;
     }
 }
-async function scanAndReplaceImports(config, state, fromInfo, toInfo, options) {
-    const { fromFeaturePath, fromComponentName } = fromInfo;
-    const { toFeaturePath, toComponentName } = toInfo;
-    const allFiles = new Set();
-    await scanDirectory(process.cwd(), allFiles);
-    const featuresRoot = resolvePath(config, 'features');
-    for (const relPath of allFiles) {
-        const fullPath = path.join(process.cwd(), relPath);
-        // Skip the moved directory itself as it was already handled
-        if (fullPath.startsWith(path.resolve(toFeaturePath)))
-            continue;
-        let content = await promises.readFile(fullPath, 'utf-8');
-        let changed = false;
-        const ext = config.naming.featureExtension === '.astro' ? '.astro' : '';
-        // Handle Aliases
-        if (config.importAliases.features) {
-            const oldAlias = `${config.importAliases.features}/${fromFeaturePath}`;
-            const newAlias = `${config.importAliases.features}/${toFeaturePath}`;
-            // Update component name and path if both changed
-            const oldFullImport = `from '${oldAlias}/${fromComponentName}${ext}'`;
-            const newFullImport = `from '${newAlias}/${toComponentName}${ext}'`;
-            if (content.includes(oldFullImport)) {
-                content = content.replace(new RegExp(oldFullImport.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newFullImport);
-                changed = true;
-            }
-            else if (content.includes(oldAlias)) {
-                content = content.replace(new RegExp(oldAlias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newAlias);
-                changed = true;
-            }
-        }
-        else {
-            // Handle Relative Imports (more complex)
-            // This is best-effort: we look for imports that resolve to the old feature path
-            const fromFeatureDir = secureJoin(featuresRoot, fromFeaturePath);
-            const toFeatureDir = secureJoin(featuresRoot, toFeaturePath);
-            const oldRelPath = getRelativeImportPath(fullPath, fromFeatureDir);
-            const newRelPath = getRelativeImportPath(fullPath, toFeatureDir);
-            const oldImport = `'${oldRelPath}/${fromComponentName}${ext}'`;
-            const newImport = `'${newRelPath}/${toComponentName}${ext}'`;
-            if (content.includes(oldImport)) {
-                content = content.replace(new RegExp(oldImport.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newImport);
-                changed = true;
-            }
-        }
-        // Update component name in JSX and imports if it changed
-        if (fromComponentName !== toComponentName && changed) {
-            content = content.replace(new RegExp(`\\b${fromComponentName}\\b`, 'g'), toComponentName);
-        }
-        if (changed) {
-            if (options.dryRun) {
-                console.log(`  [Scan] Would update imports in ${relPath}`);
-            }
-            else {
-                await promises.writeFile(fullPath, content, 'utf-8');
-                console.log(`  [Scan] Updated imports in ${relPath}`);
-                // Update state hash if this file is managed
-                if (state.files[relPath]) {
-                    state.files[relPath].hash = calculateHash(content, config.hashing?.normalization);
-                }
-            }
-        }
-    }
-}
-async function moveDirectory(fromPath, toPath, state, config, options = {}) {
-    const { fromName, toName, owner = null } = options;
-    if (!fs.existsSync(fromPath)) {
-        throw new Error(`Source directory not found: ${fromPath}`);
-    }
-    if (fs.existsSync(toPath) && !options.force) {
-        throw new Error(`Destination already exists: ${toPath}\n` +
-            `Use --force to overwrite.`);
-    }
-    await ensureDir(toPath);
-    const entries = await promises.readdir(fromPath);
-    for (const entry of entries) {
-        let targetEntry = entry;
-        // Rename files if they match the component name
-        if (fromName && toName && fromName !== toName) {
-            if (entry.includes(fromName)) {
-                targetEntry = entry.replace(fromName, toName);
-            }
-        }
-        const fromEntryPath = path.join(fromPath, entry);
-        const toEntryPath = path.join(toPath, targetEntry);
-        const stats = await promises.stat(fromEntryPath);
-        if (stats.isDirectory()) {
-            await moveDirectory(fromEntryPath, toEntryPath, state, config, options);
-        }
-        else {
-            const normalizedFromRelative = path.relative(process.cwd(), fromEntryPath).replace(/\\/g, '/');
-            const fileState = state.files[normalizedFromRelative];
-            const newHash = await safeMove(fromEntryPath, toEntryPath, {
-                force: options.force,
-                expectedHash: fileState?.hash,
-                acceptChanges: options.acceptChanges,
-                normalization: config.hashing?.normalization,
-                owner,
-                actualOwner: fileState?.owner
-            });
-            // Update internal content (signatures, component names) if renaming
-            if (fromName && toName && fromName !== toName) {
-                let content = await promises.readFile(toEntryPath, 'utf-8');
-                let hasChanged = false;
-                // Simple replacement of component names
-                if (content.includes(fromName)) {
-                    content = content.replace(new RegExp(fromName, 'g'), toName);
-                    hasChanged = true;
-                }
-                // Also handle lowercase class names if any
-                const fromLower = fromName.toLowerCase();
-                const toLower = toName.toLowerCase();
-                if (content.includes(fromLower)) {
-                    content = content.replace(new RegExp(fromLower, 'g'), toLower);
-                    hasChanged = true;
-                }
-                if (hasChanged) {
-                    await promises.writeFile(toEntryPath, content, 'utf-8');
-                    // Re-calculate hash after content update
-                    const updatedHash = calculateHash(content, config.hashing?.normalization);
-                    const normalizedToRelative = path.relative(process.cwd(), toEntryPath).replace(/\\/g, '/');
-                    if (fileState) {
-                        state.files[normalizedToRelative] = { ...fileState, hash: updatedHash };
-                        delete state.files[normalizedFromRelative];
-                    }
-                }
-                else {
-                    // Update state for each file moved normally
-                    const normalizedToRelative = path.relative(process.cwd(), toEntryPath).replace(/\\/g, '/');
-                    if (fileState) {
-                        state.files[normalizedToRelative] = { ...fileState, hash: newHash };
-                        delete state.files[normalizedFromRelative];
-                    }
-                }
-            }
-            else {
-                // Update state for each file moved normally
-                const normalizedToRelative = path.relative(process.cwd(), toEntryPath).replace(/\\/g, '/');
-                if (fileState) {
-                    state.files[normalizedToRelative] = { ...fileState, hash: newHash };
-                    delete state.files[normalizedFromRelative];
-                }
-            }
-        }
-    }
-    const remainingFiles = await promises.readdir(fromPath);
-    if (remainingFiles.length === 0) {
-        await promises.rmdir(fromPath);
-    }
-}
-async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
-    if (!fs.existsSync(filePath))
-        return;
-    let content = await promises.readFile(filePath, 'utf-8');
-    const oldDir = path.dirname(oldFilePath);
-    const newDir = path.dirname(newFilePath);
-    if (oldDir === newDir)
-        return;
-    // Find all relative imports
-    const relativeImportRegex = /from\s+['"](\.\.?\/[^'"]+)['"]/g;
-    let match;
-    const replacements = [];
-    while ((match = relativeImportRegex.exec(content)) !== null) {
-        const relativePath = match[1];
-        const absoluteTarget = path.resolve(oldDir, relativePath);
-        const newRelativePath = getRelativeImportPath(newFilePath, absoluteTarget);
-        replacements.push({
-            full: match[0],
-            oldRel: relativePath,
-            newRel: newRelativePath
-        });
-    }
-    for (const repl of replacements) {
-        content = content.replace(repl.full, `from '${repl.newRel}'`);
-    }
-    await promises.writeFile(filePath, content, 'utf-8');
-}
 
 async function createComponentCommand(componentName, options) {
     try {
@@ -3794,6 +3843,150 @@ async function normalizeStateCommand(options) {
     }
 }
 
+/**
+ * Removes missing references from Textor state.
+ * @param {Object} options
+ * @param {boolean} options.dryRun
+ * @param {boolean} options.yes
+ */
+async function pruneMissingCommand(options = {}) {
+    try {
+        const config = await loadConfig();
+        const state = await loadState();
+        const results = await getProjectStatus(config, state);
+        if (results.missing.length === 0) {
+            console.log('No missing references found.');
+            return;
+        }
+        console.log(`Found ${results.missing.length} missing references:`);
+        results.missing.forEach(f => console.log(`  - ${f}`));
+        if (options.dryRun) {
+            console.log('\nDry run: no changes applied to state.');
+            return;
+        }
+        if (!options.yes && options.interactive !== false && process.stdin.isTTY && process.env.NODE_ENV !== 'test') {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const confirmed = await new Promise(resolve => {
+                rl.question('\nDo you want to proceed with pruning? (y/N) ', (answer) => {
+                    rl.close();
+                    resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+                });
+            });
+            if (!confirmed) {
+                console.log('Aborted.');
+                return;
+            }
+        }
+        for (const relPath of results.missing) {
+            delete state.files[relPath];
+        }
+        // Reconstruct metadata
+        state.components = reconstructComponents(state.files, config);
+        state.sections = reconstructSections(state, config);
+        await saveState(state);
+        console.log(`\n✓ Successfully removed ${results.missing.length} missing references from state.`);
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+
+/**
+ * Dispatcher for rename commands.
+ */
+async function renameCommand(type, oldName, newName, options) {
+    try {
+        if (!type || !oldName || !newName) {
+            throw new Error('Usage: textor rename <route|feature|component> <oldName> <newName>');
+        }
+        if (type === 'route' || type === 'path') {
+            const normalizedOld = normalizeRoute(oldName);
+            const normalizedNew = normalizeRoute(newName);
+            // By default, move-section will try to move the feature if it matches the route.
+            // For a simple "rename route", we might want to keep that behavior or not.
+            // Usually "rename route" means just the URL/file.
+            return await moveSectionCommand(normalizedOld, undefined, normalizedNew, undefined, options);
+        }
+        if (type === 'feature') {
+            const state = await loadState();
+            const normalizedOld = featureToDirectoryPath(oldName);
+            const normalizedNew = featureToDirectoryPath(newName);
+            const section = findSection(state, normalizedOld);
+            if (section) {
+                // If it's a managed section, move it using section logic
+                return await moveSectionCommand(section.route, section.featurePath, section.route, normalizedNew, options);
+            }
+            else {
+                // Standalone feature move
+                return await moveSectionCommand(undefined, normalizedOld, undefined, normalizedNew, options);
+            }
+        }
+        if (type === 'component') {
+            return await renameComponent(oldName, newName, options);
+        }
+        throw new Error(`Unknown rename type: ${type}. Supported types: route, feature, component.`);
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+/**
+ * Specialized logic for renaming shared components.
+ */
+async function renameComponent(oldName, newName, options) {
+    const config = await loadConfig();
+    const state = await loadState();
+    const normalizedOldName = normalizeComponentName(oldName);
+    const normalizedNewName = normalizeComponentName(newName);
+    const component = findComponent(state, normalizedOldName);
+    const componentsRoot = resolvePath(config, 'components');
+    const fromPath = component
+        ? path.resolve(process.cwd(), component.path)
+        : path.join(componentsRoot, normalizedOldName);
+    const toPath = path.join(componentsRoot, normalizedNewName);
+    if (options.dryRun) {
+        console.log(`Dry run - would rename component: ${normalizedOldName} -> ${normalizedNewName}`);
+        console.log(`  Path: ${fromPath} -> ${toPath}`);
+        return;
+    }
+    const signatures = Object.values(config.signatures || {});
+    await moveDirectory(fromPath, toPath, state, config, {
+        ...options,
+        fromName: normalizedOldName,
+        toName: normalizedNewName,
+        signatures
+    });
+    if (options.scan) {
+        await scanAndReplaceImports(config, state, {
+            fromPath: normalizedOldName,
+            fromName: normalizedOldName,
+            type: 'component'
+        }, {
+            toPath: normalizedNewName,
+            toName: normalizedNewName
+        }, options);
+    }
+    await cleanupEmptyDirs(path.dirname(fromPath), componentsRoot);
+    // Update state metadata
+    if (component) {
+        component.name = normalizedNewName;
+        component.path = path.relative(process.cwd(), toPath).replace(/\\/g, '/');
+    }
+    await saveState(state);
+    console.log(`✓ Renamed component ${normalizedOldName} to ${normalizedNewName}`);
+}
+
 exports.addSectionCommand = addSectionCommand;
 exports.adoptCommand = adoptCommand;
 exports.createComponentCommand = createComponentCommand;
@@ -3801,8 +3994,10 @@ exports.initCommand = initCommand;
 exports.listSectionsCommand = listSectionsCommand;
 exports.moveSectionCommand = moveSectionCommand;
 exports.normalizeStateCommand = normalizeStateCommand;
+exports.pruneMissingCommand = pruneMissingCommand;
 exports.removeComponentCommand = removeComponentCommand;
 exports.removeSectionCommand = removeSectionCommand;
+exports.renameCommand = renameCommand;
 exports.statusCommand = statusCommand;
 exports.syncCommand = syncCommand;
 exports.upgradeConfigCommand = upgradeConfigCommand;