@oamm/textor 1.0.3 → 1.0.5

package/README.md

@@ -269,6 +269,16 @@ pnpm textor upgrade-config
 **Options:**
 - `--dry-run`: Print the upgraded config without writing it.
 
+### normalize-state
+Normalize `.textor/state.json` to use project-relative paths (helpful when moving between machines).
+
+```bash
+pnpm textor normalize-state
+```
+
+**Options:**
+- `--dry-run`: Print the normalized state without writing it.
+
 ## 🏗️ Technical Architecture
 
 Textor is designed with enterprise-grade robustness, moving beyond simple scaffolding to provide a reliable refactoring engine.
@@ -456,7 +466,7 @@ You can customize the code generated by Textor by providing your own templates.
 
 1.  Create the `.textor/templates/` directory if it doesn't exist.
 2.  Create a file named according to the table below (e.g., `feature.astro` or `component.tsx`).
-3.  Use `{{variable}}` placeholders in your template. Textor will automatically replace them when generating files.
+3.  Use `{{variable}}` or `__variable__` placeholders in your template. Textor will automatically replace them when generating files. Using `__variable__` (e.g., `__componentName__`) is recommended for TypeScript/JavaScript templates as it is a valid identifier and avoids "broken code" warnings in your IDE.
 
 ### Supported Templates
 
@@ -485,15 +495,38 @@ You can customize the code generated by Textor by providing your own templates.
 ### Variables Description
 
 - `{{componentName}}`: The PascalCase name of the feature or component (e.g., `UserCatalog`).
+- `{{componentNameCamel}}`: camelCase version of the name (e.g., `userCatalog`).
+- `{{componentNameKebab}}`: kebab-case version of the name (e.g., `user-catalog`).
+- `{{componentNameSnake}}`: snake_case version of the name (e.g., `user_catalog`).
+- `{{componentNameUpper}}`: SCREAMING_SNAKE_CASE version of the name (e.g., `USER_CATALOG`).
 - `{{hookName}}`: The camelCase name of the generated hook (e.g., `useUserCatalog`).
 - `{{componentPath}}`: Relative path to the component file (useful for imports in tests or stories).
 - `{{featureComponentName}}`: The name of the feature component as imported in a route.
-- `{{featureImportPath}}`: The import path for the feature component.
+- `{{featureComponentNameCamel}}`, `{{featureComponentNameKebab}}`, `{{featureComponentNameSnake}}`, `{{featureComponentNameUpper}}`, `{{featureComponentNamePascal}}`: Case variations for the feature component name.
 - `{{layoutName}}`: The name of the layout component being used.
+- `{{layoutNameCamel}}`, `{{layoutNameKebab}}`, `{{layoutNameSnake}}`, `{{layoutNameUpper}}`, `{{layoutNamePascal}}`: Case variations for the layout name.
 - `{{layoutImportPath}}`: The import path for the layout component.
 - `{{scriptImportPath}}`: Relative path to the client-side script entry point.
 - `{{componentExtension}}`: The file extension of the component (e.g., `.astro` or `.tsx`).
 
+### Example: Custom Route Template (`.textor/templates/route.ts`)
+
+If you are using a custom routing library and want your templates to be valid TypeScript:
+
+```typescript
+/**
+ * @generated by Textor
+ * Route: {{featureComponentName}}
+ */
+import { defineRoute } from "my-router";
+import __featureComponentName__ from "{{featureImportPath}}";
+
+export const __featureComponentName__Route = defineRoute({
+  path: "/__featureComponentNameKebab__",
+  component: __featureComponentName__
+});
+```
+
 ### Example: Custom Feature Template (`.textor/templates/feature.astro`)
 
 ```astro

package/dist/bin/textor.js

@@ -454,12 +454,15 @@ function getEffectiveOptions(cmdOptions, config, type) {
 async function initCommand(options) {
   try {
     const configPath = await saveConfig(DEFAULT_CONFIG, options.force);
-    
-    console.log('✓ Textor configuration created at:', configPath);
-    console.log('\nDefault configuration:');
-    console.log(JSON.stringify(DEFAULT_CONFIG, null, 2));
-    console.log('\nYou can now use Textor commands like:');
-    console.log('  textor add-section /users users/catalog --layout Main');
+    const quiet = options?.quiet || process.env.NODE_ENV === 'test' || process.env.TEXTOR_QUIET === '1';
+
+    if (!quiet) {
+      console.log('Textor configuration created at:', configPath);
+      console.log('\nDefault configuration:');
+      console.log(JSON.stringify(DEFAULT_CONFIG, null, 2));
+      console.log('\nYou can now use Textor commands like:');
+      console.log('  textor add-section /users users/catalog --layout Main');
+    }
   } catch (error) {
     console.error('Error:', error.message);
     process.exit(1);
@@ -479,6 +482,28 @@ function toPascalCase(input) {
     .join('');
 }
 
+function toCamelCase(input) {
+  const pascal = toPascalCase(input);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+function toKebabCase(input) {
+  return input
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+    .replace(/[_\s/\\-]+/g, '-')
+    .toLowerCase()
+    .replace(/^-+|-+$/g, '');
+}
+
+function toSnakeCase(input) {
+  return toKebabCase(input).replace(/-/g, '_');
+}
+
+function toScreamingSnakeCase(input) {
+  return toSnakeCase(input).toUpperCase();
+}
+
 function getFeatureComponentName(featurePath) {
   return toPascalCase(featurePath);
 }
@@ -1044,12 +1069,30 @@ function resolvePatternedPath(baseDir, pattern, data, fallback, label) {
   return secureJoin(baseDir, fileName);
 }
 
+function enrichData(data) {
+  const enriched = { ...data };
+  const nameKeys = ['componentName', 'featureComponentName', 'layoutName'];
+  for (const key of nameKeys) {
+    if (data[key] && typeof data[key] === 'string') {
+      enriched[`${key}Camel`] = toCamelCase(data[key]);
+      enriched[`${key}Kebab`] = toKebabCase(data[key]);
+      enriched[`${key}Snake`] = toSnakeCase(data[key]);
+      enriched[`${key}Upper`] = toScreamingSnakeCase(data[key]);
+      enriched[`${key}Pascal`] = toPascalCase(data[key]);
+    }
+  }
+  return enriched;
+}
+
 function getTemplateOverride(templateName, extension, data = {}) {
   const overridePath = path.join(process.cwd(), '.textor', 'templates', `${templateName}${extension}`);
   if (existsSync(overridePath)) {
     let content = readFileSync(overridePath, 'utf-8');
-    for (const [key, value] of Object.entries(data)) {
-      content = content.replace(new RegExp(`{{${key}}}`, 'g'), () => value || '');
+    const finalData = enrichData(data);
+    for (const [key, value] of Object.entries(finalData)) {
+      const replacement = () => value || '';
+      content = content.replace(new RegExp(`{{${key}}}`, 'g'), replacement);
+      content = content.replace(new RegExp(`__${key}__`, 'g'), replacement);
     }
     return content;
   }
@@ -1063,8 +1106,8 @@ function getTemplateOverride(templateName, extension, data = {}) {
  * - featureImportPath: Path to import the feature component
  * - featureComponentName: Name of the feature component
  */
-function generateRouteTemplate(layoutName, layoutImportPath, featureImportPath, featureComponentName) {
-  const override = getTemplateOverride('route', '.astro', {
+function generateRouteTemplate(layoutName, layoutImportPath, featureImportPath, featureComponentName, extension = '.astro') {
+  const override = getTemplateOverride('route', extension, {
     layoutName,
     layoutImportPath,
     featureImportPath,
@@ -1097,9 +1140,9 @@ import ${featureComponentName} from '${featureImportPath}';
  * - componentName: Name of the feature component
  * - scriptImportPath: Path to the feature's client-side script
  */
-function generateFeatureTemplate(componentName, scriptImportPath, framework = 'astro') {
-  const extension = framework === 'astro' ? '.astro' : '.tsx';
-  const override = getTemplateOverride('feature', extension, { componentName, scriptImportPath });
+function generateFeatureTemplate(componentName, scriptImportPath, framework = 'astro', extension) {
+  const templateExtension = extension || (framework === 'astro' ? '.astro' : '.tsx');
+  const override = getTemplateOverride('feature', templateExtension, { componentName, scriptImportPath });
   if (override) return override;
 
   if (framework === 'react') {
@@ -1144,9 +1187,9 @@ function generateScriptsIndexTemplate() {
  * Component Template Variables:
  * - componentName: Name of the component
  */
-function generateComponentTemplate(componentName, framework = 'react') {
-  const extension = framework === 'astro' ? '.astro' : '.tsx';
-  const override = getTemplateOverride('component', extension, { componentName });
+function generateComponentTemplate(componentName, framework = 'react', extension) {
+  const templateExtension = extension || (framework === 'astro' ? '.astro' : '.tsx');
+  const override = getTemplateOverride('component', templateExtension, { componentName });
   if (override) return override;
 
   if (framework === 'react') {
@@ -1458,6 +1501,7 @@ async function loadState() {
     const content = await readFile(statePath, 'utf-8');
     const state = JSON.parse(content);
     if (!state.files) state.files = {};
+    normalizeStatePaths(state);
     return state;
   } catch (error) {
     return { sections: [], components: [], files: {} };
@@ -1507,24 +1551,62 @@ async function registerFile(filePath, { kind, template, hash, templateVersion =
 
 async function addSectionToState(section) {
   const state = await loadState();
+  const normalizedSection = { ...section };
+  if (normalizedSection.featurePath) {
+    normalizedSection.featurePath = normalizeStatePath(normalizedSection.featurePath);
+  }
   // Avoid duplicates by route OR by featurePath if route is null
-  if (section.route) {
-    state.sections = state.sections.filter(s => s.route !== section.route);
+  if (normalizedSection.route) {
+    state.sections = state.sections.filter(s => s.route !== normalizedSection.route);
   } else {
-    state.sections = state.sections.filter(s => s.featurePath !== section.featurePath || s.route);
+    state.sections = state.sections.filter(s => s.featurePath !== normalizedSection.featurePath || s.route);
   }
-  state.sections.push(section);
+  state.sections.push(normalizedSection);
   await saveState(state);
 }
 
 async function addComponentToState(component) {
   const state = await loadState();
+  const normalizedComponent = { ...component };
+  if (normalizedComponent.path) {
+    normalizedComponent.path = normalizeStatePath(normalizedComponent.path);
+  }
   // Avoid duplicates by name
-  state.components = state.components.filter(c => c.name !== component.name);
-  state.components.push(component);
+  state.components = state.components.filter(c => c.name !== normalizedComponent.name);
+  state.components.push(normalizedComponent);
   await saveState(state);
 }
 
+function normalizeStatePath(filePath) {
+  if (!filePath || typeof filePath !== 'string') return filePath;
+  const relative = path.isAbsolute(filePath)
+    ? path.relative(process.cwd(), filePath)
+    : filePath;
+  return relative.replace(/\\/g, '/');
+}
+
+function normalizeStatePaths(state) {
+  if (!state || typeof state !== 'object') return;
+  if (Array.isArray(state.sections)) {
+    state.sections = state.sections.map(section => {
+      if (!section || typeof section !== 'object') return section;
+      if (!section.featurePath) return section;
+      const normalized = normalizeStatePath(section.featurePath);
+      if (normalized === section.featurePath) return section;
+      return { ...section, featurePath: normalized };
+    });
+  }
+  if (Array.isArray(state.components)) {
+    state.components = state.components.map(component => {
+      if (!component || typeof component !== 'object') return component;
+      if (!component.path) return component;
+      const normalized = normalizeStatePath(component.path);
+      if (normalized === component.path) return component;
+      return { ...component, path: normalized };
+    });
+  }
+}
+
 function findSection(state, identifier) {
   return state.sections.find(s => s.route === identifier || s.name === identifier || s.featurePath === identifier);
 }
@@ -1950,13 +2032,14 @@ async function addSectionCommand(route, featurePath, options) {
           options.layout,
           layoutImportPath,
           featureImportPath,
-          featureComponentName
+          featureComponentName,
+          routeExtension
         );
         routeSignature = getSignature(config, 'astro');
       }
     }
     
-    const featureContent = generateFeatureTemplate(featureComponentName, scriptImportPath, framework);
+    const featureContent = generateFeatureTemplate(featureComponentName, scriptImportPath, framework, config.naming.featureExtension);
     
     const writtenFiles = [];
 
@@ -3021,7 +3104,7 @@ async function createComponentCommand(componentName, options) {
     if (shouldCreateServices) await ensureDir(servicesDirInside);
     if (shouldCreateSchemas) await ensureDir(schemasDirInside);
     
-    const componentContent = generateComponentTemplate(normalizedName, framework);
+    const componentContent = generateComponentTemplate(normalizedName, framework, config.naming.componentExtension);
     const signature = getSignature(config, config.naming.componentExtension === '.astro' ? 'astro' : 'tsx');
 
     const componentHash = await writeFileWithSignature(
@@ -3298,7 +3381,7 @@ async function removeComponentCommand(identifier, options) {
     let componentDir;
 
     if (component) {
-        componentDir = component.path;
+        componentDir = path.resolve(process.cwd(), component.path);
     } else {
         // Fallback: try to guess path if not in state
         const componentsRoot = path.resolve(process.cwd(), config.paths.components);
@@ -3324,13 +3407,14 @@ async function removeComponentCommand(identifier, options) {
       await cleanupEmptyDirs(path.dirname(componentDir), path.join(process.cwd(), config.paths.components));
       
       // Unregister files
-      const dirPrefix = path.relative(process.cwd(), componentDir).replace(/\\/g, '/') + '/';
+      const relComponentPath = path.relative(process.cwd(), componentDir).replace(/\\/g, '/');
+      const dirPrefix = relComponentPath + '/';
       for (const f in state.files) {
         if (f.startsWith(dirPrefix)) {
           delete state.files[f];
         }
       }
-      state.components = state.components.filter(c => c.name !== identifier && c.path !== componentDir);
+      state.components = state.components.filter(c => c.name !== identifier && c.path !== relComponentPath);
       await saveState(state);
     } else if (result.message) {
       console.log(`⚠ Skipped: ${componentDir}`);
@@ -4032,6 +4116,27 @@ async function upgradeConfigCommand(options) {
   }
 }
 
+async function normalizeStateCommand(options) {
+  try {
+    const state = await loadState();
+
+    if (options.dryRun) {
+      console.log('Dry run - normalized state:');
+      console.log(JSON.stringify(state, null, 2));
+      return;
+    }
+
+    await saveState(state);
+    console.log('State normalized successfully.');
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
 const program = new Command();
 
 program
@@ -4043,6 +4148,7 @@ program
   .command('init')
   .description('Initialize Textor configuration')
   .option('--force', 'Overwrite existing configuration')
+  .option('--quiet', 'Skip printing full default configuration')
   .action(initCommand);
 
 program
@@ -4157,5 +4263,11 @@ program
   .option('--dry-run', 'Show the upgraded config without writing to disk')
   .action(upgradeConfigCommand);
 
+program
+  .command('normalize-state')
+  .description('Normalize state paths to be project-relative')
+  .option('--dry-run', 'Show the normalized state without writing to disk')
+  .action(normalizeStateCommand);
+
 program.parse();
 //# sourceMappingURL=textor.js.map

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

@@ -421,11 +421,14 @@ function getEffectiveOptions(cmdOptions, config, type) {
 async function initCommand(options) {
     try {
         const configPath = await saveConfig(DEFAULT_CONFIG, options.force);
-        console.log('✓ Textor configuration created at:', configPath);
-        console.log('\nDefault configuration:');
-        console.log(JSON.stringify(DEFAULT_CONFIG, null, 2));
-        console.log('\nYou can now use Textor commands like:');
-        console.log('  textor add-section /users users/catalog --layout Main');
+        const quiet = options?.quiet || process.env.NODE_ENV === 'test' || process.env.TEXTOR_QUIET === '1';
+        if (!quiet) {
+            console.log('Textor configuration created at:', configPath);
+            console.log('\nDefault configuration:');
+            console.log(JSON.stringify(DEFAULT_CONFIG, null, 2));
+            console.log('\nYou can now use Textor commands like:');
+            console.log('  textor add-section /users users/catalog --layout Main');
+        }
     }
     catch (error) {
         console.error('Error:', error.message);
@@ -445,6 +448,24 @@ function toPascalCase(input) {
     })
         .join('');
 }
+function toCamelCase(input) {
+    const pascal = toPascalCase(input);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toKebabCase(input) {
+    return input
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .replace(/[_\s/\\-]+/g, '-')
+        .toLowerCase()
+        .replace(/^-+|-+$/g, '');
+}
+function toSnakeCase(input) {
+    return toKebabCase(input).replace(/-/g, '_');
+}
+function toScreamingSnakeCase(input) {
+    return toSnakeCase(input).toUpperCase();
+}
 function getFeatureComponentName(featurePath) {
     return toPascalCase(featurePath);
 }
@@ -900,12 +921,29 @@ function resolvePatternedPath(baseDir, pattern, data, fallback, label) {
     return secureJoin(baseDir, fileName);
 }
 
+function enrichData(data) {
+    const enriched = { ...data };
+    const nameKeys = ['componentName', 'featureComponentName', 'layoutName'];
+    for (const key of nameKeys) {
+        if (data[key] && typeof data[key] === 'string') {
+            enriched[`${key}Camel`] = toCamelCase(data[key]);
+            enriched[`${key}Kebab`] = toKebabCase(data[key]);
+            enriched[`${key}Snake`] = toSnakeCase(data[key]);
+            enriched[`${key}Upper`] = toScreamingSnakeCase(data[key]);
+            enriched[`${key}Pascal`] = toPascalCase(data[key]);
+        }
+    }
+    return enriched;
+}
 function getTemplateOverride(templateName, extension, data = {}) {
     const overridePath = path.join(process.cwd(), '.textor', 'templates', `${templateName}${extension}`);
     if (fs.existsSync(overridePath)) {
         let content = fs.readFileSync(overridePath, 'utf-8');
-        for (const [key, value] of Object.entries(data)) {
-            content = content.replace(new RegExp(`{{${key}}}`, 'g'), () => value || '');
+        const finalData = enrichData(data);
+        for (const [key, value] of Object.entries(finalData)) {
+            const replacement = () => value || '';
+            content = content.replace(new RegExp(`{{${key}}}`, 'g'), replacement);
+            content = content.replace(new RegExp(`__${key}__`, 'g'), replacement);
         }
         return content;
     }
@@ -918,8 +956,8 @@ function getTemplateOverride(templateName, extension, data = {}) {
  * - featureImportPath: Path to import the feature component
  * - featureComponentName: Name of the feature component
  */
-function generateRouteTemplate(layoutName, layoutImportPath, featureImportPath, featureComponentName) {
-    const override = getTemplateOverride('route', '.astro', {
+function generateRouteTemplate(layoutName, layoutImportPath, featureImportPath, featureComponentName, extension = '.astro') {
+    const override = getTemplateOverride('route', extension, {
         layoutName,
         layoutImportPath,
         featureImportPath,
@@ -950,9 +988,9 @@ import ${featureComponentName} from '${featureImportPath}';
  * - componentName: Name of the feature component
  * - scriptImportPath: Path to the feature's client-side script
  */
-function generateFeatureTemplate(componentName, scriptImportPath, framework = 'astro') {
-    const extension = framework === 'astro' ? '.astro' : '.tsx';
-    const override = getTemplateOverride('feature', extension, { componentName, scriptImportPath });
+function generateFeatureTemplate(componentName, scriptImportPath, framework = 'astro', extension) {
+    const templateExtension = extension || (framework === 'astro' ? '.astro' : '.tsx');
+    const override = getTemplateOverride('feature', templateExtension, { componentName, scriptImportPath });
     if (override)
         return override;
     if (framework === 'react') {
@@ -993,9 +1031,9 @@ function generateScriptsIndexTemplate() {
  * Component Template Variables:
  * - componentName: Name of the component
  */
-function generateComponentTemplate(componentName, framework = 'react') {
-    const extension = framework === 'astro' ? '.astro' : '.tsx';
-    const override = getTemplateOverride('component', extension, { componentName });
+function generateComponentTemplate(componentName, framework = 'react', extension) {
+    const templateExtension = extension || (framework === 'astro' ? '.astro' : '.tsx');
+    const override = getTemplateOverride('component', templateExtension, { componentName });
     if (override)
         return override;
     if (framework === 'react') {
@@ -1291,6 +1329,7 @@ async function loadState() {
         const state = JSON.parse(content);
         if (!state.files)
             state.files = {};
+        normalizeStatePaths(state);
         return state;
     }
     catch (error) {
@@ -1331,23 +1370,67 @@ async function registerFile(filePath, { kind, template, hash, templateVersion =
 }
 async function addSectionToState(section) {
     const state = await loadState();
+    const normalizedSection = { ...section };
+    if (normalizedSection.featurePath) {
+        normalizedSection.featurePath = normalizeStatePath(normalizedSection.featurePath);
+    }
     // Avoid duplicates by route OR by featurePath if route is null
-    if (section.route) {
-        state.sections = state.sections.filter(s => s.route !== section.route);
+    if (normalizedSection.route) {
+        state.sections = state.sections.filter(s => s.route !== normalizedSection.route);
     }
     else {
-        state.sections = state.sections.filter(s => s.featurePath !== section.featurePath || s.route);
+        state.sections = state.sections.filter(s => s.featurePath !== normalizedSection.featurePath || s.route);
     }
-    state.sections.push(section);
+    state.sections.push(normalizedSection);
     await saveState(state);
 }
 async function addComponentToState(component) {
     const state = await loadState();
+    const normalizedComponent = { ...component };
+    if (normalizedComponent.path) {
+        normalizedComponent.path = normalizeStatePath(normalizedComponent.path);
+    }
     // Avoid duplicates by name
-    state.components = state.components.filter(c => c.name !== component.name);
-    state.components.push(component);
+    state.components = state.components.filter(c => c.name !== normalizedComponent.name);
+    state.components.push(normalizedComponent);
     await saveState(state);
 }
+function normalizeStatePath(filePath) {
+    if (!filePath || typeof filePath !== 'string')
+        return filePath;
+    const relative = path.isAbsolute(filePath)
+        ? path.relative(process.cwd(), filePath)
+        : filePath;
+    return relative.replace(/\\/g, '/');
+}
+function normalizeStatePaths(state) {
+    if (!state || typeof state !== 'object')
+        return;
+    if (Array.isArray(state.sections)) {
+        state.sections = state.sections.map(section => {
+            if (!section || typeof section !== 'object')
+                return section;
+            if (!section.featurePath)
+                return section;
+            const normalized = normalizeStatePath(section.featurePath);
+            if (normalized === section.featurePath)
+                return section;
+            return { ...section, featurePath: normalized };
+        });
+    }
+    if (Array.isArray(state.components)) {
+        state.components = state.components.map(component => {
+            if (!component || typeof component !== 'object')
+                return component;
+            if (!component.path)
+                return component;
+            const normalized = normalizeStatePath(component.path);
+            if (normalized === component.path)
+                return component;
+            return { ...component, path: normalized };
+        });
+    }
+}
 function findSection(state, identifier) {
     return state.sections.find(s => s.route === identifier || s.name === identifier || s.featurePath === identifier);
 }
@@ -1675,11 +1758,11 @@ async function addSectionCommand(route, featurePath, options) {
                 routeSignature = getSignature(config, 'typescript');
             }
             else {
-                routeContent = generateRouteTemplate(options.layout, layoutImportPath, featureImportPath, featureComponentName);
+                routeContent = generateRouteTemplate(options.layout, layoutImportPath, featureImportPath, featureComponentName, routeExtension);
                 routeSignature = getSignature(config, 'astro');
             }
         }
-        const featureContent = generateFeatureTemplate(featureComponentName, scriptImportPath, framework);
+        const featureContent = generateFeatureTemplate(featureComponentName, scriptImportPath, framework, config.naming.featureExtension);
         const writtenFiles = [];
         if (routeFilePath) {
             const routeHash = await writeFileWithSignature(routeFilePath, routeContent, routeSignature, config.hashing?.normalization);
@@ -2511,7 +2594,7 @@ async function createComponentCommand(componentName, options) {
             await ensureDir(servicesDirInside);
         if (shouldCreateSchemas)
             await ensureDir(schemasDirInside);
-        const componentContent = generateComponentTemplate(normalizedName, framework);
+        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, {
@@ -2712,7 +2795,7 @@ async function removeComponentCommand(identifier, options) {
         const component = findComponent(state, identifier);
         let componentDir;
         if (component) {
-            componentDir = component.path;
+            componentDir = path.resolve(process.cwd(), component.path);
         }
         else {
             // Fallback: try to guess path if not in state
@@ -2735,13 +2818,14 @@ async function removeComponentCommand(identifier, options) {
             console.log(`✓ Deleted component: ${componentDir}/`);
             await cleanupEmptyDirs(path.dirname(componentDir), path.join(process.cwd(), config.paths.components));
             // Unregister files
-            const dirPrefix = path.relative(process.cwd(), componentDir).replace(/\\/g, '/') + '/';
+            const relComponentPath = path.relative(process.cwd(), componentDir).replace(/\\/g, '/');
+            const dirPrefix = relComponentPath + '/';
             for (const f in state.files) {
                 if (f.startsWith(dirPrefix)) {
                     delete state.files[f];
                 }
             }
-            state.components = state.components.filter(c => c.name !== identifier && c.path !== componentDir);
+            state.components = state.components.filter(c => c.name !== identifier && c.path !== relComponentPath);
             await saveState(state);
         }
         else if (result.message) {
@@ -3376,12 +3460,33 @@ async function upgradeConfigCommand(options) {
     }
 }
 
+async function normalizeStateCommand(options) {
+    try {
+        const state = await loadState();
+        if (options.dryRun) {
+            console.log('Dry run - normalized state:');
+            console.log(JSON.stringify(state, null, 2));
+            return;
+        }
+        await saveState(state);
+        console.log('State normalized successfully.');
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+
 exports.addSectionCommand = addSectionCommand;
 exports.adoptCommand = adoptCommand;
 exports.createComponentCommand = createComponentCommand;
 exports.initCommand = initCommand;
 exports.listSectionsCommand = listSectionsCommand;
 exports.moveSectionCommand = moveSectionCommand;
+exports.normalizeStateCommand = normalizeStateCommand;
 exports.removeComponentCommand = removeComponentCommand;
 exports.removeSectionCommand = removeSectionCommand;
 exports.statusCommand = statusCommand;