@oamm/textor 1.0.12 → 1.0.14

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 === '/') {
@@ -715,17 +716,6 @@ async function safeDelete(filePath, options = {}) {
   return { deleted: true };
 }
 
-async function ensureNotExists(filePath, force = false) {
-  if (existsSync(filePath)) {
-    if (!force) {
-      throw new Error(
-        `File already exists: ${filePath}\n` +
-        `Use --force to overwrite.`
-      );
-    }
-  }
-}
-
 async function ensureDir(dirPath) {
   await mkdir(dirPath, { recursive: true });
 }
@@ -832,6 +822,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` +
@@ -2076,19 +2071,25 @@ async function addSectionCommand(route, featurePath, options) {
       }
     }
 
-    await ensureNotExists(featureFilePath, options.force);
-    
-    if (shouldCreateIndex) await ensureNotExists(indexFilePath, options.force);
-    if (shouldCreateContext) await ensureNotExists(contextFilePath, options.force);
-    if (shouldCreateHooks) await ensureNotExists(hookFilePath, options.force);
-    if (shouldCreateTests) await ensureNotExists(testFilePath, options.force);
-    if (shouldCreateTypes) await ensureNotExists(typesFilePath, options.force);
-    if (shouldCreateApi) await ensureNotExists(apiFilePath, options.force);
-    if (shouldCreateServices) await ensureNotExists(servicesFilePath, options.force);
-    if (shouldCreateSchemas) await ensureNotExists(schemasFilePath, options.force);
-    if (shouldCreateReadme) await ensureNotExists(readmeFilePath, options.force);
-    if (shouldCreateStories) await ensureNotExists(storiesFilePath, options.force);
-    if (shouldCreateScriptsDir) await ensureNotExists(scriptsIndexPath, options.force);
+    const featureExists = existsSync(featureFilePath);
+    if (featureExists && !options.force) {
+        console.log(`ℹ Feature already exists at ${featureFilePath}. Entering additive mode.`);
+    }
+
+    // Check sub-items only if not in force mode
+    if (!options.force) {
+        if (shouldCreateIndex && existsSync(indexFilePath)) console.log(`  - Skipping existing index: ${indexFilePath}`);
+        if (shouldCreateContext && existsSync(contextFilePath)) console.log(`  - Skipping existing context: ${contextFilePath}`);
+        if (shouldCreateHooks && existsSync(hookFilePath)) console.log(`  - Skipping existing hook: ${hookFilePath}`);
+        if (shouldCreateTests && existsSync(testFilePath)) console.log(`  - Skipping existing test: ${testFilePath}`);
+        if (shouldCreateTypes && existsSync(typesFilePath)) console.log(`  - Skipping existing types: ${typesFilePath}`);
+        if (shouldCreateApi && existsSync(apiFilePath)) console.log(`  - Skipping existing api: ${apiFilePath}`);
+        if (shouldCreateServices && existsSync(servicesFilePath)) console.log(`  - Skipping existing services: ${servicesFilePath}`);
+        if (shouldCreateSchemas && existsSync(schemasFilePath)) console.log(`  - Skipping existing schemas: ${schemasFilePath}`);
+        if (shouldCreateReadme && existsSync(readmeFilePath)) console.log(`  - Skipping existing readme: ${readmeFilePath}`);
+        if (shouldCreateStories && existsSync(storiesFilePath)) console.log(`  - Skipping existing stories: ${storiesFilePath}`);
+        if (shouldCreateScriptsDir && existsSync(scriptsIndexPath)) console.log(`  - Skipping existing scripts: ${scriptsIndexPath}`);
+    }
     
     let layoutImportPath = null;
     const cliProps = options.prop || {};
@@ -2229,21 +2230,23 @@ async function addSectionCommand(route, featurePath, options) {
 
     const featureSignature = getSignature(config, config.naming.featureExtension === '.astro' ? 'astro' : 'tsx');
 
-    const featureHash = await writeFileWithSignature(
-      featureFilePath,
-      featureContent,
-      featureSignature,
-      config.hashing?.normalization
-    );
-    await registerFile(featureFilePath, { 
-      kind: 'feature', 
-      template: 'feature', 
-      hash: featureHash,
-      owner: normalizedRoute 
-    });
-    writtenFiles.push(featureFilePath);
+    if (!featureExists || options.force) {
+      const featureHash = await writeFileWithSignature(
+        featureFilePath,
+        featureContent,
+        featureSignature,
+        config.hashing?.normalization
+      );
+      await registerFile(featureFilePath, { 
+        kind: 'feature', 
+        template: 'feature', 
+        hash: featureHash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(featureFilePath);
+    }
 
-    if (shouldCreateScriptsDir) {
+    if (shouldCreateScriptsDir && (!existsSync(scriptsIndexPath) || options.force)) {
       const hash = await writeFileWithSignature(
         scriptsIndexPath,
         generateScriptsIndexTemplate(),
@@ -2259,7 +2262,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(scriptsIndexPath);
     }
 
-    if (shouldCreateIndex) {
+    if (shouldCreateIndex && (!existsSync(indexFilePath) || options.force)) {
       const indexContent = generateIndexTemplate(featureComponentName, config.naming.featureExtension);
       const hash = await writeFileWithSignature(
         indexFilePath,
@@ -2276,7 +2279,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(indexFilePath);
     }
 
-    if (shouldCreateApi) {
+    if (shouldCreateApi && (!existsSync(apiFilePath) || options.force)) {
       const apiContent = generateApiTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         apiFilePath, 
@@ -2293,7 +2296,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(apiFilePath);
     }
 
-    if (shouldCreateServices) {
+    if (shouldCreateServices && (!existsSync(servicesFilePath) || options.force)) {
       const servicesContent = generateServiceTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         servicesFilePath, 
@@ -2310,7 +2313,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(servicesFilePath);
     }
 
-    if (shouldCreateSchemas) {
+    if (shouldCreateSchemas && (!existsSync(schemasFilePath) || options.force)) {
       const schemasContent = generateSchemaTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         schemasFilePath, 
@@ -2327,7 +2330,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(schemasFilePath);
     }
 
-    if (shouldCreateHooks) {
+    if (shouldCreateHooks && (!existsSync(hookFilePath) || options.force)) {
       const hookName = getHookFunctionName(featureComponentName);
       const hookContent = generateHookTemplate(featureComponentName, hookName);
       const hash = await writeFileWithSignature(
@@ -2345,7 +2348,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(hookFilePath);
     }
 
-    if (shouldCreateContext) {
+    if (shouldCreateContext && (!existsSync(contextFilePath) || options.force)) {
       const contextContent = generateContextTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         contextFilePath, 
@@ -2362,7 +2365,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(contextFilePath);
     }
 
-    if (shouldCreateTests) {
+    if (shouldCreateTests && (!existsSync(testFilePath) || options.force)) {
       const relativeFeaturePath = `./${path.basename(featureFilePath)}`;
       const testContent = generateTestTemplate(featureComponentName, relativeFeaturePath);
       const hash = await writeFileWithSignature(
@@ -2380,7 +2383,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(testFilePath);
     }
 
-    if (shouldCreateTypes) {
+    if (shouldCreateTypes && (!existsSync(typesFilePath) || options.force)) {
       const typesContent = generateTypesTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         typesFilePath, 
@@ -2397,7 +2400,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(typesFilePath);
     }
 
-    if (shouldCreateReadme) {
+    if (shouldCreateReadme && (!existsSync(readmeFilePath) || options.force)) {
       const readmeContent = generateReadmeTemplate(featureComponentName);
       const hash = await writeFileWithSignature(
         readmeFilePath, 
@@ -2414,7 +2417,7 @@ async function addSectionCommand(route, featurePath, options) {
       writtenFiles.push(readmeFilePath);
     }
 
-    if (shouldCreateStories) {
+    if (shouldCreateStories && (!existsSync(storiesFilePath) || options.force)) {
       const relativePath = `./${path.basename(featureFilePath)}`;
       const storiesContent = generateStoriesTemplate(featureComponentName, relativePath);
       const hash = await writeFileWithSignature(
@@ -2751,6 +2754,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).
  * 
@@ -2779,45 +2998,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) {
@@ -2847,14 +3080,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);
@@ -2865,97 +3100,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);
+          }
+        }
       }
     }
     
@@ -2982,15 +3227,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 => {
@@ -3001,6 +3249,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({
@@ -3023,216 +3280,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();
@@ -3387,20 +3434,26 @@ async function createComponentCommand(componentName, options) {
       return;
     }
     
-    await ensureNotExists(componentFilePath, options.force);
-    await ensureNotExists(indexFilePath, options.force);
-    
-    if (shouldCreateContext) await ensureNotExists(contextFilePath, options.force);
-    if (shouldCreateHook) await ensureNotExists(hookFilePath, options.force);
-    if (shouldCreateTests) await ensureNotExists(testFilePath, options.force);
-    if (shouldCreateConfig) await ensureNotExists(configFilePath, options.force);
-    if (shouldCreateConstants) await ensureNotExists(constantsFilePath, options.force);
-    if (shouldCreateTypes) await ensureNotExists(typesFilePath, options.force);
-    if (shouldCreateApi) await ensureNotExists(apiFilePath, options.force);
-    if (shouldCreateServices) await ensureNotExists(servicesFilePath, options.force);
-    if (shouldCreateSchemas) await ensureNotExists(schemasFilePath, options.force);
-    if (shouldCreateReadme) await ensureNotExists(readmeFilePath, options.force);
-    if (shouldCreateStories) await ensureNotExists(storiesFilePath, options.force);
+    const componentExists = existsSync(componentFilePath);
+    if (componentExists && !options.force) {
+        console.log(`ℹ Component already exists at ${componentFilePath}. Entering additive mode.`);
+    }
+
+    // Check sub-items only if not in force mode
+    if (!options.force) {
+        if (existsSync(indexFilePath)) console.log(`  - Skipping existing index: ${indexFilePath}`);
+        if (shouldCreateContext && existsSync(contextFilePath)) console.log(`  - Skipping existing context: ${contextFilePath}`);
+        if (shouldCreateHook && existsSync(hookFilePath)) console.log(`  - Skipping existing hook: ${hookFilePath}`);
+        if (shouldCreateTests && existsSync(testFilePath)) console.log(`  - Skipping existing test: ${testFilePath}`);
+        if (shouldCreateConfig && existsSync(configFilePath)) console.log(`  - Skipping existing config: ${configFilePath}`);
+        if (shouldCreateConstants && existsSync(constantsFilePath)) console.log(`  - Skipping existing constants: ${constantsFilePath}`);
+        if (shouldCreateTypes && existsSync(typesFilePath)) console.log(`  - Skipping existing types: ${typesFilePath}`);
+        if (shouldCreateApi && existsSync(apiFilePath)) console.log(`  - Skipping existing api: ${apiFilePath}`);
+        if (shouldCreateServices && existsSync(servicesFilePath)) console.log(`  - Skipping existing services: ${servicesFilePath}`);
+        if (shouldCreateSchemas && existsSync(schemasFilePath)) console.log(`  - Skipping existing schemas: ${schemasFilePath}`);
+        if (shouldCreateReadme && existsSync(readmeFilePath)) console.log(`  - Skipping existing readme: ${readmeFilePath}`);
+        if (shouldCreateStories && existsSync(storiesFilePath)) console.log(`  - Skipping existing stories: ${storiesFilePath}`);
+    }
     
     await ensureDir(componentDir);
     
@@ -3418,37 +3471,42 @@ async function createComponentCommand(componentName, options) {
     const componentContent = generateComponentTemplate(normalizedName, framework, config.naming.componentExtension);
     const signature = getSignature(config, config.naming.componentExtension === '.astro' ? 'astro' : 'tsx');
 
-    const componentHash = await writeFileWithSignature(
-      componentFilePath,
-      componentContent,
-      signature,
-      config.hashing?.normalization
-    );
-    await registerFile(componentFilePath, { 
-      kind: 'component', 
-      template: 'component', 
-      hash: componentHash,
-      owner: normalizedName 
-    });
+    const writtenFiles = [];
+
+    if (!componentExists || options.force) {
+      const componentHash = await writeFileWithSignature(
+        componentFilePath,
+        componentContent,
+        signature,
+        config.hashing?.normalization
+      );
+      await registerFile(componentFilePath, { 
+        kind: 'component', 
+        template: 'component', 
+        hash: componentHash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(componentFilePath);
+    }
     
-    const writtenFiles = [componentFilePath];
-
-    const indexContent = generateIndexTemplate(normalizedName, config.naming.componentExtension);
-    const indexHash = await writeFileWithSignature(
-      indexFilePath,
-      indexContent,
-      getSignature(config, 'typescript'),
-      config.hashing?.normalization
-    );
-    await registerFile(indexFilePath, { 
-      kind: 'component-file', 
-      template: 'index', 
-      hash: indexHash,
-      owner: normalizedName 
-    });
-    writtenFiles.push(indexFilePath);
+    if (!existsSync(indexFilePath) || options.force) {
+      const indexContent = generateIndexTemplate(normalizedName, config.naming.componentExtension);
+      const indexHash = await writeFileWithSignature(
+        indexFilePath,
+        indexContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(indexFilePath, { 
+        kind: 'component-file', 
+        template: 'index', 
+        hash: indexHash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(indexFilePath);
+    }
     
-    if (shouldCreateTypes) {
+    if (shouldCreateTypes && (!existsSync(typesFilePath) || options.force)) {
       const typesContent = generateTypesTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         typesFilePath,
@@ -3465,7 +3523,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(typesFilePath);
     }
     
-    if (shouldCreateContext) {
+    if (shouldCreateContext && (!existsSync(contextFilePath) || options.force)) {
       const contextContent = generateContextTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         contextFilePath,
@@ -3482,7 +3540,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(contextFilePath);
     }
     
-    if (shouldCreateHook) {
+    if (shouldCreateHook && (!existsSync(hookFilePath) || options.force)) {
       const hookName = getHookFunctionName(normalizedName);
       const hookContent = generateHookTemplate(normalizedName, hookName);
       const hash = await writeFileWithSignature(
@@ -3500,7 +3558,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(hookFilePath);
     }
     
-    if (shouldCreateTests) {
+    if (shouldCreateTests && (!existsSync(testFilePath) || options.force)) {
       const relativeComponentPath = `../${normalizedName}${config.naming.componentExtension}`;
       const testContent = generateTestTemplate(normalizedName, relativeComponentPath);
       const hash = await writeFileWithSignature(
@@ -3518,7 +3576,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(testFilePath);
     }
     
-    if (shouldCreateConfig) {
+    if (shouldCreateConfig && (!existsSync(configFilePath) || options.force)) {
       const configContent = generateConfigTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         configFilePath,
@@ -3535,7 +3593,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(configFilePath);
     }
     
-    if (shouldCreateConstants) {
+    if (shouldCreateConstants && (!existsSync(constantsFilePath) || options.force)) {
       const constantsContent = generateConstantsTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         constantsFilePath,
@@ -3552,7 +3610,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(constantsFilePath);
     }
 
-    if (shouldCreateApi) {
+    if (shouldCreateApi && (!existsSync(apiFilePath) || options.force)) {
       const apiContent = generateApiTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         apiFilePath,
@@ -3569,7 +3627,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(apiFilePath);
     }
 
-    if (shouldCreateServices) {
+    if (shouldCreateServices && (!existsSync(servicesFilePath) || options.force)) {
       const servicesContent = generateServiceTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         servicesFilePath,
@@ -3586,7 +3644,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(servicesFilePath);
     }
 
-    if (shouldCreateSchemas) {
+    if (shouldCreateSchemas && (!existsSync(schemasFilePath) || options.force)) {
       const schemasContent = generateSchemaTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         schemasFilePath,
@@ -3603,7 +3661,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(schemasFilePath);
     }
 
-    if (shouldCreateReadme) {
+    if (shouldCreateReadme && (!existsSync(readmeFilePath) || options.force)) {
       const readmeContent = generateReadmeTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         readmeFilePath,
@@ -3620,7 +3678,7 @@ async function createComponentCommand(componentName, options) {
       writtenFiles.push(readmeFilePath);
     }
 
-    if (shouldCreateStories) {
+    if (shouldCreateStories && (!existsSync(storiesFilePath) || options.force)) {
       const relativePath = `./${normalizedName}${config.naming.componentExtension}`;
       const storiesContent = generateStoriesTemplate(normalizedName, relativePath);
       const hash = await writeFileWithSignature(
@@ -4551,6 +4609,166 @@ async function pruneMissingCommand(options = {}) {
   }
 }
 
+/**
+ * Add a new item (hook, api, service, etc.) to an existing feature or component.
+ * 
+ * @param {string} itemType The type of item to add (e.g., 'api', 'hook', 'service')
+ * @param {string} targetName The name of the feature or component
+ * @param {Object} options Additional options from Commander
+ */
+async function addItemCommand(itemType, targetName, options) {
+  try {
+    const state = await loadState();
+    
+    // Normalize itemType
+    let normalizedItem = itemType.toLowerCase();
+    if (normalizedItem === 'test') normalizedItem = 'tests';
+    if (normalizedItem === 'service') normalizedItem = 'services';
+    if (normalizedItem === 'schema') normalizedItem = 'schemas';
+    if (normalizedItem === 'hook') normalizedItem = 'hooks'; // for add-section
+
+    // Try to find as section (feature) first
+    let section = findSection(state, targetName);
+    let component = findComponent(state, targetName);
+    
+    // If not found by exact name, try to find by featurePath or part of it
+    if (!section && !component) {
+        section = state.sections.find(s => s.featurePath === targetName || s.featurePath.endsWith('/' + targetName));
+    }
+
+    if (!section && !component) {
+      throw new Error(`Target not found in state: "${targetName}". Please use "add-section" or "create-component" directly if it's not managed by Textor.`);
+    }
+
+    const flags = { [normalizedItem]: true };
+    // Also set singular for create-component which uses 'hook'
+    if (normalizedItem === 'hooks') flags.hook = true;
+
+    if (section) {
+      console.log(`ℹ Adding ${normalizedItem} to feature: ${section.featurePath}`);
+      return await addSectionCommand(undefined, section.featurePath, { ...options, ...flags });
+    }
+    
+    if (component) {
+      console.log(`ℹ Adding ${normalizedItem} to component: ${component.name}`);
+      // For create-component, we might need to be careful with flags that are on by default
+      // but getEffectiveOptions should handle it if we pass them explicitly as true.
+      return await createComponentCommand(component.name, { ...options, ...flags });
+    }
+  } 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}`);
+}
+
 const program = new Command();
 
 program
@@ -4696,5 +4914,21 @@ 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
+  .command('add <item> <target>')
+  .description('Add a sub-item (api, hook, test, etc.) to an existing feature or component')
+  .option('--force', 'Overwrite existing files')
+  .option('--dry-run', 'Show what would be created without creating')
+  .action(addItemCommand);
+
 program.parse();
 //# sourceMappingURL=textor.js.map