@oamm/textor 1.0.5 → 1.0.7

package/README.md

@@ -370,7 +370,8 @@ The .textor/config.json file allows full control over the tool's behavior.
     "createTypes": false,
     "createReadme": false,
     "createStories": false,
-    "createIndex": false
+    "createIndex": false,
+    "layout": "Main"
   },
   "components": {
     "framework": "react",

package/dist/bin/textor.js

@@ -36,10 +36,12 @@ const CURRENT_CONFIG_VERSION = 2;
  * @property {string} signatures.typescript
  * @property {string} signatures.javascript
  * @property {Object} features
+ * @property {string} features.framework
  * @property {string} features.entry
  * @property {boolean} features.createSubComponentsDir
  * @property {boolean} features.createScriptsDir
  * @property {string} features.scriptsIndexFile
+ * @property {string} features.layout
  * @property {Object} components
  * @property {boolean} components.createSubComponentsDir
  * @property {boolean} components.createContext
@@ -105,7 +107,8 @@ const DEFAULT_CONFIG = {
     createTypes: false,
     createReadme: false,
     createStories: false,
-    createIndex: false
+    createIndex: false,
+    layout: 'Main'
   },
   components: {
     framework: 'react',
@@ -1794,6 +1797,7 @@ async function addSectionCommand(route, featurePath, options) {
     
     const {
       framework,
+      layout,
       createSubComponentsDir: shouldCreateSubComponentsDir,
       createScriptsDir: shouldCreateScriptsDir,
       createApi: shouldCreateApi,
@@ -1965,7 +1969,13 @@ async function addSectionCommand(route, featurePath, options) {
         }
 
         // Update imports in the moved file
-        await updateImportsInFile(reorg.to, reorg.from, reorg.to);
+        await updateImportsInFile$1(reorg.to, reorg.from, reorg.to);
+        
+        // Update hash in state after import updates
+        if (state.files[newRelative]) {
+          const content = await readFile(reorg.to, 'utf-8');
+          state.files[newRelative].hash = calculateHash(content, config.hashing?.normalization);
+        }
         
         console.log(`✓ Reorganized ${oldRelative} to ${newRelative}`);
       }
@@ -1988,11 +1998,11 @@ async function addSectionCommand(route, featurePath, options) {
     if (shouldCreateScriptsDir) await ensureNotExists(scriptsIndexPath, options.force);
     
     let layoutImportPath = null;
-    if (routeFilePath && options.layout !== 'none') {
+    if (routeFilePath && layout !== 'none') {
       if (config.importAliases.layouts) {
-        layoutImportPath = `${config.importAliases.layouts}/${options.layout}.astro`;
+        layoutImportPath = `${config.importAliases.layouts}/${layout}.astro`;
       } else {
-        const layoutFilePath = secureJoin(layoutsRoot, `${options.layout}.astro`);
+        const layoutFilePath = secureJoin(layoutsRoot, `${layout}.astro`);
         layoutImportPath = getRelativeImportPath(routeFilePath, layoutFilePath);
       }
     }
@@ -2029,7 +2039,7 @@ async function addSectionCommand(route, featurePath, options) {
         routeSignature = getSignature(config, 'typescript');
       } else {
         routeContent = generateRouteTemplate(
-          options.layout,
+          layout,
           layoutImportPath,
           featureImportPath,
           featureComponentName,
@@ -2301,7 +2311,7 @@ async function addSectionCommand(route, featurePath, options) {
       name: options.name || featureComponentName,
       route: normalizedRoute,
       featurePath: normalizedFeaturePath,
-      layout: options.layout,
+      layout: layout,
       extension: routeExtension
     });
 
@@ -2318,7 +2328,7 @@ async function addSectionCommand(route, featurePath, options) {
   }
 }
 
-async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
+async function updateImportsInFile$1(filePath, oldFilePath, newFilePath) {
   if (!existsSync(filePath)) return;
   
   let content = await readFile(filePath, 'utf-8');
@@ -2361,33 +2371,43 @@ async function removeSectionCommand(route, featurePath, options) {
 
     const state = await loadState();
     
-    let targetRoute = route;
-    let targetFeaturePath = featurePath;
     let section = findSection(state, route);
+    if (!section && featurePath) {
+      section = findSection(state, featurePath);
+    }
+
+    const targetRoute = section ? section.route : route;
+    const targetFeaturePath = section ? section.featurePath : featurePath;
 
     if (!targetFeaturePath) {
-      if (section) {
-        targetRoute = section.route;
-        targetFeaturePath = section.featurePath;
-      } else {
-        throw new Error(`Section not found for identifier: ${route}. Please provide both route and featurePath.`);
-      }
+      throw new Error(`Section not found for identifier: ${route}. Please provide both route and featurePath.`);
     }
     
     const normalizedRoute = normalizeRoute(targetRoute);
     const normalizedFeaturePath = featureToDirectoryPath(targetFeaturePath);
     
-    const routeExtension = (section && section.extension) || config.naming.routeExtension;
-    const routeFileName = routeToFilePath(normalizedRoute, {
-      extension: routeExtension,
-      mode: config.routing.mode,
-      indexFile: config.routing.indexFile
-    });
-    
     const pagesRoot = resolvePath(config, 'pages');
     const featuresRoot = resolvePath(config, 'features');
+
+    // Find route file in state if possible
+    let routeFilePath = null;
+    const routeRelPath = Object.keys(state.files).find(f => {
+      const data = state.files[f];
+      return data.kind === 'route' && data.owner === normalizedRoute;
+    });
+
+    if (routeRelPath) {
+      routeFilePath = path.resolve(process.cwd(), routeRelPath);
+    } else {
+      const routeExtension = (section && section.extension) || config.naming.routeExtension;
+      const routeFileName = routeToFilePath(normalizedRoute, {
+        extension: routeExtension,
+        mode: config.routing.mode,
+        indexFile: config.routing.indexFile
+      });
+      routeFilePath = secureJoin(pagesRoot, routeFileName);
+    }
     
-    const routeFilePath = secureJoin(pagesRoot, routeFileName);
     const featureDirPath = secureJoin(featuresRoot, normalizedFeaturePath);
     
     const deletedFiles = [];
@@ -2474,8 +2494,67 @@ async function removeSectionCommand(route, featurePath, options) {
     }
     
     if (deletedFiles.length === 0 && deletedDirs.length === 0 && skippedFiles.length === 0) {
-      console.log('No files to delete.');
+      if (section) {
+        console.log(`✓ Section ${normalizedRoute} removed from state (files were already missing on disk).`);
+        state.sections = state.sections.filter(s => s.route !== normalizedRoute);
+        await saveState(state);
+      } else {
+        console.log('No files to delete.');
+      }
     } else {
+      // Reorganization (Flattening)
+      if (!options.keepRoute && deletedFiles.length > 0 && config.routing.mode === 'flat') {
+        const routeParts = normalizedRoute.split('/').filter(Boolean);
+        if (routeParts.length > 1) {
+          for (let i = routeParts.length - 1; i >= 1; i--) {
+            const parentRoute = '/' + routeParts.slice(0, i).join('/');
+            const parentDirName = routeParts.slice(0, i).join('/');
+            const parentDirPath = secureJoin(pagesRoot, parentDirName);
+            
+            if (existsSync(parentDirPath)) {
+              const filesInDir = await readdir(parentDirPath);
+              
+              if (filesInDir.length === 1) {
+                const loneFile = filesInDir[0];
+                const ext = path.extname(loneFile);
+                const indexFile = ext === '.astro' ? config.routing.indexFile : `index${ext}`;
+                
+                if (loneFile === indexFile) {
+                  const loneFilePath = path.join(parentDirPath, loneFile);
+                  const oldRelative = path.relative(process.cwd(), loneFilePath).replace(/\\/g, '/');
+
+                  if (state.files[oldRelative] && state.files[oldRelative].kind === 'route') {
+                    const flatFileName = routeToFilePath(parentRoute, {
+                      extension: ext,
+                      mode: 'flat'
+                    });
+                    const flatFilePath = secureJoin(pagesRoot, flatFileName);
+                      
+                    if (!existsSync(flatFilePath)) {
+                      await rename(loneFilePath, flatFilePath);
+                        
+                      const newRelative = path.relative(process.cwd(), flatFilePath).replace(/\\/g, '/');
+                        
+                      state.files[newRelative] = { ...state.files[oldRelative] };
+                      delete state.files[oldRelative];
+                        
+                      await updateImportsInFile(flatFilePath, loneFilePath, flatFilePath);
+
+                      // Update hash in state after import updates
+                      const content = await readFile(flatFilePath, 'utf-8');
+                      state.files[newRelative].hash = calculateHash(content, config.hashing?.normalization);
+
+                      console.log(`✓ Reorganized ${oldRelative} to ${newRelative} (flattened)`);
+                      await cleanupEmptyDirs(parentDirPath, pagesRoot);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
       state.sections = state.sections.filter(s => s.route !== normalizedRoute);
       await saveState(state);
     }
@@ -2489,6 +2568,39 @@ async function removeSectionCommand(route, featurePath, options) {
   }
 }
 
+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');
+}
+
 /**
  * Move a section (route + feature).
  * 
@@ -3402,9 +3514,13 @@ async function removeComponentCommand(identifier, options) {
       owner: identifier
     });
     
-    if (result.deleted) {
-      console.log(`✓ Deleted component: ${componentDir}/`);
-      await cleanupEmptyDirs(path.dirname(componentDir), path.join(process.cwd(), config.paths.components));
+    if (result.deleted || (result.reason === 'not-found' && component)) {
+      if (result.deleted) {
+        console.log(`✓ Deleted component: ${componentDir}/`);
+        await cleanupEmptyDirs(path.dirname(componentDir), path.join(process.cwd(), config.paths.components));
+      } else {
+        console.log(`✓ Component ${identifier} removed from state (directory was already missing on disk).`);
+      }
       
       // Unregister files
       const relComponentPath = path.relative(process.cwd(), componentDir).replace(/\\/g, '/');
@@ -4155,7 +4271,7 @@ program
   .command('add-section [route] [featurePath]')
   .description('Create a route + feature binding (route optional for standalone features)')
   .option('--preset <name>', 'Scaffolding preset (minimal, standard, senior)')
-  .option('--layout <name>', 'Layout component name (use "none" for no layout)', 'Main')
+  .option('--layout <name>', 'Layout component name (use "none" for no layout)')
   .option('--name <name>', 'Section name for state tracking')
   .option('--endpoint', 'Create an API endpoint (.ts) instead of an Astro page')
   .option('--api', 'Create api directory')

package/dist/bin/textor.js.map

@@ -1 +1 @@
-{"version":3,"file":"textor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"textor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index.cjs

@@ -35,10 +35,12 @@ const CURRENT_CONFIG_VERSION = 2;
  * @property {string} signatures.typescript
  * @property {string} signatures.javascript
  * @property {Object} features
+ * @property {string} features.framework
  * @property {string} features.entry
  * @property {boolean} features.createSubComponentsDir
  * @property {boolean} features.createScriptsDir
  * @property {string} features.scriptsIndexFile
+ * @property {string} features.layout
  * @property {Object} components
  * @property {boolean} components.createSubComponentsDir
  * @property {boolean} components.createContext
@@ -103,7 +105,8 @@ const DEFAULT_CONFIG = {
         createTypes: false,
         createReadme: false,
         createStories: false,
-        createIndex: false
+        createIndex: false,
+        layout: 'Main'
     },
     components: {
         framework: 'react',
@@ -1590,7 +1593,7 @@ async function addSectionCommand(route, featurePath, options) {
         const apiDirInside = secureJoin(featureDirPath, 'api');
         const servicesDirInside = secureJoin(featureDirPath, 'services');
         const schemasDirInside = secureJoin(featureDirPath, 'schemas');
-        const { framework, createSubComponentsDir: shouldCreateSubComponentsDir, createScriptsDir: shouldCreateScriptsDir, createApi: shouldCreateApi, createServices: shouldCreateServices, createSchemas: shouldCreateSchemas, createHooks: shouldCreateHooks, createContext: shouldCreateContext, createTests: shouldCreateTests, createTypes: shouldCreateTypes, createReadme: shouldCreateReadme, createStories: shouldCreateStories, createIndex: shouldCreateIndex } = effectiveOptions;
+        const { framework, layout, createSubComponentsDir: shouldCreateSubComponentsDir, createScriptsDir: shouldCreateScriptsDir, createApi: shouldCreateApi, createServices: shouldCreateServices, createSchemas: shouldCreateSchemas, createHooks: shouldCreateHooks, createContext: shouldCreateContext, createTests: shouldCreateTests, createTypes: shouldCreateTypes, createReadme: shouldCreateReadme, createStories: shouldCreateStories, createIndex: shouldCreateIndex } = effectiveOptions;
         const featurePatterns = config.filePatterns?.features || {};
         const patternData = {
             componentName: featureComponentName,
@@ -1687,7 +1690,12 @@ async function addSectionCommand(route, featurePath, options) {
                     delete state.files[oldRelative];
                 }
                 // Update imports in the moved file
-                await updateImportsInFile(reorg.to, reorg.from, reorg.to);
+                await updateImportsInFile$1(reorg.to, reorg.from, reorg.to);
+                // Update hash in state after import updates
+                if (state.files[newRelative]) {
+                    const content = await promises.readFile(reorg.to, 'utf-8');
+                    state.files[newRelative].hash = calculateHash(content, config.hashing?.normalization);
+                }
                 console.log(`✓ Reorganized ${oldRelative} to ${newRelative}`);
             }
             await saveState(state);
@@ -1718,12 +1726,12 @@ async function addSectionCommand(route, featurePath, options) {
         if (shouldCreateScriptsDir)
             await ensureNotExists(scriptsIndexPath, options.force);
         let layoutImportPath = null;
-        if (routeFilePath && options.layout !== 'none') {
+        if (routeFilePath && layout !== 'none') {
             if (config.importAliases.layouts) {
-                layoutImportPath = `${config.importAliases.layouts}/${options.layout}.astro`;
+                layoutImportPath = `${config.importAliases.layouts}/${layout}.astro`;
             }
             else {
-                const layoutFilePath = secureJoin(layoutsRoot, `${options.layout}.astro`);
+                const layoutFilePath = secureJoin(layoutsRoot, `${layout}.astro`);
                 layoutImportPath = getRelativeImportPath(routeFilePath, layoutFilePath);
             }
         }
@@ -1758,7 +1766,7 @@ async function addSectionCommand(route, featurePath, options) {
                 routeSignature = getSignature(config, 'typescript');
             }
             else {
-                routeContent = generateRouteTemplate(options.layout, layoutImportPath, featureImportPath, featureComponentName, routeExtension);
+                routeContent = generateRouteTemplate(layout, layoutImportPath, featureImportPath, featureComponentName, routeExtension);
                 routeSignature = getSignature(config, 'astro');
             }
         }
@@ -1959,7 +1967,7 @@ async function addSectionCommand(route, featurePath, options) {
             name: options.name || featureComponentName,
             route: normalizedRoute,
             featurePath: normalizedFeaturePath,
-            layout: options.layout,
+            layout: layout,
             extension: routeExtension
         });
         if (config.git?.stageChanges) {
@@ -1974,7 +1982,7 @@ async function addSectionCommand(route, featurePath, options) {
         throw error;
     }
 }
-async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
+async function updateImportsInFile$1(filePath, oldFilePath, newFilePath) {
     if (!fs.existsSync(filePath))
         return;
     let content = await promises.readFile(filePath, 'utf-8');
@@ -2009,29 +2017,37 @@ async function removeSectionCommand(route, featurePath, options) {
             throw new Error('Git repository is not clean. Please commit or stash your changes before proceeding.');
         }
         const state = await loadState();
-        let targetRoute = route;
-        let targetFeaturePath = featurePath;
         let section = findSection(state, route);
+        if (!section && featurePath) {
+            section = findSection(state, featurePath);
+        }
+        const targetRoute = section ? section.route : route;
+        const targetFeaturePath = section ? section.featurePath : featurePath;
         if (!targetFeaturePath) {
-            if (section) {
-                targetRoute = section.route;
-                targetFeaturePath = section.featurePath;
-            }
-            else {
-                throw new Error(`Section not found for identifier: ${route}. Please provide both route and featurePath.`);
-            }
+            throw new Error(`Section not found for identifier: ${route}. Please provide both route and featurePath.`);
         }
         const normalizedRoute = normalizeRoute(targetRoute);
         const normalizedFeaturePath = featureToDirectoryPath(targetFeaturePath);
-        const routeExtension = (section && section.extension) || config.naming.routeExtension;
-        const routeFileName = routeToFilePath(normalizedRoute, {
-            extension: routeExtension,
-            mode: config.routing.mode,
-            indexFile: config.routing.indexFile
-        });
         const pagesRoot = resolvePath(config, 'pages');
         const featuresRoot = resolvePath(config, 'features');
-        const routeFilePath = secureJoin(pagesRoot, routeFileName);
+        // Find route file in state if possible
+        let routeFilePath = null;
+        const routeRelPath = Object.keys(state.files).find(f => {
+            const data = state.files[f];
+            return data.kind === 'route' && data.owner === normalizedRoute;
+        });
+        if (routeRelPath) {
+            routeFilePath = path.resolve(process.cwd(), routeRelPath);
+        }
+        else {
+            const routeExtension = (section && section.extension) || config.naming.routeExtension;
+            const routeFileName = routeToFilePath(normalizedRoute, {
+                extension: routeExtension,
+                mode: config.routing.mode,
+                indexFile: config.routing.indexFile
+            });
+            routeFilePath = secureJoin(pagesRoot, routeFileName);
+        }
         const featureDirPath = secureJoin(featuresRoot, normalizedFeaturePath);
         const deletedFiles = [];
         const skippedFiles = [];
@@ -2106,9 +2122,58 @@ async function removeSectionCommand(route, featurePath, options) {
             });
         }
         if (deletedFiles.length === 0 && deletedDirs.length === 0 && skippedFiles.length === 0) {
-            console.log('No files to delete.');
+            if (section) {
+                console.log(`✓ Section ${normalizedRoute} removed from state (files were already missing on disk).`);
+                state.sections = state.sections.filter(s => s.route !== normalizedRoute);
+                await saveState(state);
+            }
+            else {
+                console.log('No files to delete.');
+            }
         }
         else {
+            // Reorganization (Flattening)
+            if (!options.keepRoute && deletedFiles.length > 0 && config.routing.mode === 'flat') {
+                const routeParts = normalizedRoute.split('/').filter(Boolean);
+                if (routeParts.length > 1) {
+                    for (let i = routeParts.length - 1; i >= 1; i--) {
+                        const parentRoute = '/' + routeParts.slice(0, i).join('/');
+                        const parentDirName = routeParts.slice(0, i).join('/');
+                        const parentDirPath = secureJoin(pagesRoot, parentDirName);
+                        if (fs.existsSync(parentDirPath)) {
+                            const filesInDir = await promises.readdir(parentDirPath);
+                            if (filesInDir.length === 1) {
+                                const loneFile = filesInDir[0];
+                                const ext = path.extname(loneFile);
+                                const indexFile = ext === '.astro' ? config.routing.indexFile : `index${ext}`;
+                                if (loneFile === indexFile) {
+                                    const loneFilePath = path.join(parentDirPath, loneFile);
+                                    const oldRelative = path.relative(process.cwd(), loneFilePath).replace(/\\/g, '/');
+                                    if (state.files[oldRelative] && state.files[oldRelative].kind === 'route') {
+                                        const flatFileName = routeToFilePath(parentRoute, {
+                                            extension: ext,
+                                            mode: 'flat'
+                                        });
+                                        const flatFilePath = secureJoin(pagesRoot, flatFileName);
+                                        if (!fs.existsSync(flatFilePath)) {
+                                            await promises.rename(loneFilePath, flatFilePath);
+                                            const newRelative = path.relative(process.cwd(), flatFilePath).replace(/\\/g, '/');
+                                            state.files[newRelative] = { ...state.files[oldRelative] };
+                                            delete state.files[oldRelative];
+                                            await updateImportsInFile(flatFilePath, loneFilePath, flatFilePath);
+                                            // Update hash in state after import updates
+                                            const content = await promises.readFile(flatFilePath, 'utf-8');
+                                            state.files[newRelative].hash = calculateHash(content, config.hashing?.normalization);
+                                            console.log(`✓ Reorganized ${oldRelative} to ${newRelative} (flattened)`);
+                                            await cleanupEmptyDirs(parentDirPath, pagesRoot);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
             state.sections = state.sections.filter(s => s.route !== normalizedRoute);
             await saveState(state);
         }
@@ -2121,6 +2186,33 @@ async function removeSectionCommand(route, featurePath, options) {
         throw error;
     }
 }
+async function updateImportsInFile(filePath, oldFilePath, newFilePath) {
+    if (!fs.existsSync(filePath))
+        return;
+    let content = await promises.readFile(filePath, 'utf-8');
+    const oldDir = path.dirname(oldFilePath);
+    const newDir = path.dirname(newFilePath);
+    if (oldDir === newDir)
+        return;
+    // Find all relative imports
+    const relativeImportRegex = /from\s+['"](\.\.?\/[^'"]+)['"]/g;
+    let match;
+    const replacements = [];
+    while ((match = relativeImportRegex.exec(content)) !== null) {
+        const relativePath = match[1];
+        const absoluteTarget = path.resolve(oldDir, relativePath);
+        const newRelativePath = getRelativeImportPath(newFilePath, absoluteTarget);
+        replacements.push({
+            full: match[0],
+            oldRel: relativePath,
+            newRel: newRelativePath
+        });
+    }
+    for (const repl of replacements) {
+        content = content.replace(repl.full, `from '${repl.newRel}'`);
+    }
+    await promises.writeFile(filePath, content, 'utf-8');
+}
 
 /**
  * Move a section (route + feature).
@@ -2814,9 +2906,14 @@ async function removeComponentCommand(identifier, options) {
             normalization: config.hashing?.normalization,
             owner: identifier
         });
-        if (result.deleted) {
-            console.log(`✓ Deleted component: ${componentDir}/`);
-            await cleanupEmptyDirs(path.dirname(componentDir), path.join(process.cwd(), config.paths.components));
+        if (result.deleted || (result.reason === 'not-found' && component)) {
+            if (result.deleted) {
+                console.log(`✓ Deleted component: ${componentDir}/`);
+                await cleanupEmptyDirs(path.dirname(componentDir), path.join(process.cwd(), config.paths.components));
+            }
+            else {
+                console.log(`✓ Component ${identifier} removed from state (directory was already missing on disk).`);
+            }
             // Unregister files
             const relComponentPath = path.relative(process.cwd(), componentDir).replace(/\\/g, '/');
             const dirPrefix = relComponentPath + '/';