@oamm/textor 1.0.11 → 1.0.13

package/dist/bin/textor.js

@@ -543,6 +543,7 @@ 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 === '/') {
@@ -832,6 +833,11 @@ async function safeMove(fromPath, toPath, options = {}) {
     throw new Error(`Source file not found: ${fromPath}`);
   }
 
+  if (path.resolve(fromPath) === path.resolve(toPath)) {
+    const content = await readFile(toPath, 'utf-8');
+    return calculateHash(content, normalization);
+  }
+
   if (existsSync(toPath) && !force) {
     throw new Error(
       `Destination already exists: ${toPath}\n` +
@@ -2067,7 +2073,11 @@ async function addSectionCommand(route, featurePath, options) {
         const configSignatures = Object.values(config.signatures || {});
         const isGenerated = await isTextorGenerated(routeFilePath, configSignatures);
         if (!isGenerated && !options.force) {
-          throw new Error(`File already exists: ${routeFilePath}\nUse --force to overwrite.`);
+          if (routeFilePath.endsWith('.astro')) {
+            console.log(`⚠ File already exists and is not managed by Textor. Adopting and merging: ${routeFilePath}`);
+          } else {
+            throw new Error(`File already exists: ${routeFilePath}\nUse --force to overwrite.`);
+          }
         }
       }
     }
@@ -2747,6 +2757,222 @@ async function updateImportsInFile$1(filePath, oldFilePath, newFilePath) {
   await writeFile(filePath, content, 'utf-8');
 }
 
+/**
+ * Updates relative imports in a file after it has been moved.
+ */
+async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
+  if (!existsSync(filePath)) return;
+  
+  let content = await 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 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 (!existsSync(fromPath)) {
+    throw new Error(`Source directory not found: ${fromPath}`);
+  }
+  
+  if (existsSync(toPath) && !options.force) {
+    throw new Error(
+      `Destination already exists: ${toPath}\n` +
+      `Use --force to overwrite.`
+    );
+  }
+  
+  await ensureDir(toPath);
+  
+  const entries = await 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 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 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 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 readdir(fromPath);
+  if (remainingFiles.length === 0) {
+    await 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 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 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).
  * 
@@ -2775,45 +3001,59 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
     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
+        }
+    } 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 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;
-                }
+            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) {
@@ -2843,14 +3083,16 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
       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);
@@ -2861,97 +3103,107 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
       return;
     }
     
-    const normalizedFromRouteRelative = path.relative(process.cwd(), fromRoutePath).replace(/\\/g, '/');
-    const routeFileState = state.files[normalizedFromRouteRelative];
+    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
-    });
-    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 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;
+      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 });
       }
-
-      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;
+      
+      // 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];
         }
-      } 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}`;
-          });
+      }
+      
+      // Update imports in the route file (even if it didn't move, as feature might have)
+      const targetFeature = normalizedToFeature || normalizedFromFeature;
+      if (targetFeature && 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 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;
         }
-      }
 
-      if (changed) {
-        await writeFile(toRoutePath, content, 'utf-8');
-        // Update hash in state after changes
-        state.files[normalizedToRouteRelative].hash = calculateHash(content, config.hashing?.normalization);
+        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;
+          }
+        }
+
+        if (changed) {
+          await writeFile(toRoutePath, content, 'utf-8');
+          // Update hash in state after changes
+          if (state.files[normalizedToRouteRelative]) {
+            state.files[normalizedToRouteRelative].hash = calculateHash(content, config.hashing?.normalization);
+          }
+        }
       }
     }
     
@@ -2978,15 +3230,18 @@ 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 => {
@@ -2997,6 +3252,15 @@ 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({
@@ -3019,216 +3283,6 @@ async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, op
   }
 }
 
-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 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 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 (!existsSync(fromPath)) {
-    throw new Error(`Source directory not found: ${fromPath}`);
-  }
-  
-  if (existsSync(toPath) && !options.force) {
-    throw new Error(
-      `Destination already exists: ${toPath}\n` +
-      `Use --force to overwrite.`
-    );
-  }
-  
-  await ensureDir(toPath);
-  
-  const entries = await 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 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 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 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 readdir(fromPath);
-  if (remainingFiles.length === 0) {
-    await rmdir(fromPath);
-  }
-}
-
-async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
-  if (!existsSync(filePath)) return;
-  
-  let content = await 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 writeFile(filePath, content, 'utf-8');
-}
-
 async function createComponentCommand(componentName, options) {
   try {
     const config = await loadConfig();
@@ -4363,8 +4417,9 @@ async function adoptFile(relPath, config, state, options) {
   else if (ext === '.js' || ext === '.jsx') signature = config.signatures.javascript;
 
   let finalContent = content;
+  const shouldAddSignature = signature && !content.includes(signature) && options.signature !== false;
 
-  if (signature && !content.includes(signature)) {
+  if (shouldAddSignature) {
     if (options.dryRun) {
       console.log(`  ~ Would add signature to ${relPath}`);
     } else {
@@ -4374,9 +4429,17 @@ async function adoptFile(relPath, config, state, options) {
     }
   } else {
     if (options.dryRun) {
-      console.log(`  + Would adopt (already has signature or no signature for ext): ${relPath}`);
+      if (signature && !content.includes(signature) && options.signature === false) {
+        console.log(`  + Would adopt without signature (explicitly requested): ${relPath}`);
+      } else {
+        console.log(`  + Would adopt (already has signature or no signature for ext): ${relPath}`);
+      }
     } else {
-      console.log(`  + Adopting: ${relPath}`);
+      if (signature && !content.includes(signature) && options.signature === false) {
+        console.log(`  + Adopting without signature (explicitly requested): ${relPath}`);
+      } else {
+        console.log(`  + Adopting: ${relPath}`);
+      }
     }
   }
 
@@ -4386,7 +4449,8 @@ async function adoptFile(relPath, config, state, options) {
       kind: inferKind(relPath, config),
       hash: hash,
       timestamp: new Date().toISOString(),
-      synced: true
+      synced: true,
+      hasSignature: options.signature !== false
     };
   }
 
@@ -4537,6 +4601,111 @@ async function pruneMissingCommand(options = {}) {
   }
 }
 
+/**
+ * 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}`);
+}
+
 const program = new Command();
 
 program
@@ -4682,5 +4851,14 @@ program
   .option('--no-interactive', 'Disable interactive prompts')
   .action(pruneMissingCommand);
 
+program
+  .command('rename <type> <oldName> <newName>')
+  .description('Rename a route, feature, or component')
+  .option('--scan', 'Enable repo-wide import updates')
+  .option('--force', 'Rename even if files are modified or not generated by Textor')
+  .option('--accept-changes', 'Allow renaming of modified files')
+  .option('--dry-run', 'Show what would be renamed without applying')
+  .action(renameCommand);
+
 program.parse();
 //# sourceMappingURL=textor.js.map