@oamm/textor 1.0.0

package/dist/bin/textor.js

@@ -0,0 +1,3819 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { mkdir, writeFile, readFile, unlink, rm, rmdir, rename, readdir, stat, open } from 'fs/promises';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { createHash } from 'crypto';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const CONFIG_DIR$1 = '.textor';
+const CONFIG_FILE = 'config.json';
+
+/**
+ * @typedef {Object} TextorConfig
+ * @property {Object} paths
+ * @property {string} paths.pages
+ * @property {string} paths.features
+ * @property {string} paths.components
+ * @property {string} paths.layouts
+ * @property {Object} routing
+ * @property {string} routing.mode
+ * @property {string} routing.indexFile
+ * @property {Object} importAliases
+ * @property {string} importAliases.layouts
+ * @property {string} importAliases.features
+ * @property {Object} naming
+ * @property {string} naming.routeExtension
+ * @property {string} naming.featureExtension
+ * @property {string} naming.componentExtension
+ * @property {string} naming.hookExtension
+ * @property {string} naming.testExtension
+ * @property {Object} signatures
+ * @property {string} signatures.astro
+ * @property {string} signatures.typescript
+ * @property {string} signatures.javascript
+ * @property {Object} features
+ * @property {string} features.entry
+ * @property {boolean} features.createSubComponentsDir
+ * @property {boolean} features.createScriptsDir
+ * @property {string} features.scriptsIndexFile
+ * @property {Object} components
+ * @property {boolean} components.createSubComponentsDir
+ * @property {boolean} components.createContext
+ * @property {boolean} components.createHook
+ * @property {boolean} components.createTests
+ * @property {boolean} components.createConfig
+ * @property {boolean} components.createConstants
+ * @property {boolean} components.createTypes
+ * @property {Object} formatting
+ * @property {string} formatting.tool
+ * @property {Object} git
+ * @property {boolean} git.requireCleanRepo
+ * @property {boolean} git.stageChanges
+ * @property {Object} presets
+ * @property {string} defaultPreset
+ */
+
+/**
+ * Default configuration for Textor
+ * @type {TextorConfig}
+ */
+const DEFAULT_CONFIG = {
+  paths: {
+    pages: 'src/pages',
+    features: 'src/features',
+    components: 'src/components',
+    layouts: 'src/layouts'
+  },
+  routing: {
+    mode: 'flat', // 'flat' | 'nested'
+    indexFile: 'index.astro'
+  },
+  importAliases: {},
+  naming: {
+    routeExtension: '.astro',
+    featureExtension: '.astro',
+    componentExtension: '.tsx',
+    hookExtension: '.ts',
+    testExtension: '.test.tsx'
+  },
+  signatures: {
+    astro: '<!-- @generated by Textor -->',
+    typescript: '// @generated by Textor',
+    javascript: '// @generated by Textor',
+    tsx: '// @generated by Textor'
+  },
+  features: {
+    framework: 'astro',
+    entry: 'pascal', // 'index' | 'pascal'
+    createSubComponentsDir: true,
+    createScriptsDir: true,
+    scriptsIndexFile: 'scripts/index.ts',
+    createApi: false,
+    createServices: false,
+    createSchemas: false,
+    createHooks: false,
+    createContext: false,
+    createTests: false,
+    createTypes: false,
+    createReadme: false,
+    createStories: false,
+    createIndex: false
+  },
+  components: {
+    framework: 'react',
+    createSubComponentsDir: true,
+    createContext: true,
+    createHook: true,
+    createTests: true,
+    createConfig: true,
+    createConstants: true,
+    createTypes: true,
+    createApi: false,
+    createServices: false,
+    createSchemas: false,
+    createReadme: false,
+    createStories: false
+  },
+  formatting: {
+    tool: 'none' // 'prettier' | 'biome' | 'none'
+  },
+  hashing: {
+    normalization: 'normalizeEOL', // 'none' | 'normalizeEOL' | 'stripGeneratedRegions'
+    useMarkers: false
+  },
+  git: {
+    requireCleanRepo: false,
+    stageChanges: false
+  },
+  kindRules: [],
+  presets: {
+    minimal: {
+      features: {
+        createSubComponentsDir: false,
+        createScriptsDir: false
+      },
+      components: {
+        createSubComponentsDir: false,
+        createContext: false,
+        createHook: false,
+        createTests: false,
+        createConfig: false,
+        createConstants: false,
+        createTypes: false
+      }
+    },
+    standard: {
+      features: {
+        createSubComponentsDir: true,
+        createScriptsDir: true
+      },
+      components: {
+        createSubComponentsDir: true,
+        createContext: true,
+        createHook: true,
+        createTests: true,
+        createConfig: true,
+        createConstants: true,
+        createTypes: true
+      }
+    },
+    senior: {
+      features: {
+        createSubComponentsDir: true,
+        createScriptsDir: true,
+        createApi: true,
+        createServices: true,
+        createSchemas: true,
+        createHooks: true,
+        createContext: true,
+        createTests: true,
+        createTypes: true,
+        createReadme: true,
+        createStories: true,
+        createIndex: true
+      },
+      components: {
+        createSubComponentsDir: true,
+        createContext: true,
+        createHook: true,
+        createTests: true,
+        createConfig: true,
+        createConstants: true,
+        createTypes: true,
+        createApi: true,
+        createServices: true,
+        createSchemas: true,
+        createReadme: true,
+        createStories: true
+      }
+    }
+  },
+  defaultPreset: 'standard'
+};
+
+/**
+ * Gets the absolute path to the .textor directory.
+ * @returns {string}
+ */
+function getConfigDir() {
+  return path.join(process.cwd(), CONFIG_DIR$1);
+}
+
+/**
+ * Gets the absolute path to the config.json file.
+ * @returns {string}
+ */
+function getConfigPath() {
+  return path.join(getConfigDir(), CONFIG_FILE);
+}
+
+/**
+ * Loads the configuration from config.json and merges it with DEFAULT_CONFIG.
+ * @returns {Promise<TextorConfig>}
+ * @throws {Error} If configuration not found or invalid
+ */
+async function loadConfig() {
+  const configPath = getConfigPath();
+  
+  if (!existsSync(configPath)) {
+    throw new Error(
+      `Textor configuration not found at ${configPath}\n` +
+      `Run 'textor init' to create it.`
+    );
+  }
+
+  try {
+    const content = await readFile(configPath, 'utf-8');
+    const config = JSON.parse(content);
+    const merged = deepMerge(DEFAULT_CONFIG, config);
+    validateConfig(merged);
+    return merged;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Failed to parse config: Invalid JSON at ${configPath}`);
+    }
+    throw new Error(`Failed to load config: ${error.message}`);
+  }
+}
+
+/**
+ * Saves the configuration to config.json.
+ * @param {TextorConfig} config Configuration to save
+ * @param {boolean} [force=false] Whether to overwrite existing config
+ * @returns {Promise<string>} Path to the saved config file
+ * @throws {Error} If config exists and force is false
+ */
+async function saveConfig(config, force = false) {
+  const configPath = getConfigPath();
+  
+  if (existsSync(configPath) && !force) {
+    throw new Error(
+      `Configuration already exists at ${configPath}\n` +
+      `Use --force to overwrite.`
+    );
+  }
+
+  validateConfig(config);
+
+  const configDir = getConfigDir();
+  if (!existsSync(configDir)) {
+    await mkdir(configDir, { recursive: true });
+  }
+
+  await writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  return configPath;
+}
+
+/**
+ * Deeply merges source object into target object.
+ * @param {Object} target 
+ * @param {Object} source 
+ * @returns {Object} Merged object
+ */
+function deepMerge(target, source) {
+  const result = { ...target };
+  
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        result[key] = deepMerge(target[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Validates the configuration object structure.
+ * @param {any} config 
+ * @throws {Error} If config is invalid
+ */
+function validateConfig(config) {
+  if (!config || typeof config !== 'object') {
+    throw new Error('Invalid configuration: must be an object');
+  }
+
+  const requiredSections = ['paths', 'naming', 'signatures', 'importAliases'];
+  for (const section of requiredSections) {
+    if (!config[section] || typeof config[section] !== 'object') {
+      throw new Error(`Invalid configuration: missing or invalid "${section}" section`);
+    }
+  }
+
+  if (config.kindRules && !Array.isArray(config.kindRules)) {
+    throw new Error('Invalid configuration: "kindRules" must be an array');
+  }
+
+  // Validate paths are strings
+  for (const [key, value] of Object.entries(config.paths)) {
+    if (typeof value !== 'string') {
+      throw new Error(`Invalid configuration: "paths.${key}" must be a string`);
+    }
+  }
+
+  // Validate naming extensions start with dot
+  for (const [key, value] of Object.entries(config.naming)) {
+    if (typeof value === 'string' && !value.startsWith('.') && value !== '') {
+      throw new Error(`Invalid configuration: "naming.${key}" should start with a dot (e.g., ".astro")`);
+    }
+  }
+}
+
+/**
+ * Resolves a configured path key to an absolute path.
+ * @param {TextorConfig} config 
+ * @param {keyof TextorConfig['paths']} pathKey 
+ * @returns {string}
+ */
+function resolvePath(config, pathKey) {
+  const configuredPath = config.paths[pathKey];
+  if (!configuredPath) {
+    throw new Error(`Path "${pathKey}" not found in configuration`);
+  }
+  return path.resolve(process.cwd(), configuredPath);
+}
+
+/**
+ * Merges CLI options, preset defaults, and global config.
+ * @param {Object} cmdOptions 
+ * @param {TextorConfig} config 
+ * @param {'features' | 'components'} type 
+ */
+function getEffectiveOptions(cmdOptions, config, type) {
+  const presetName = cmdOptions.preset || config.defaultPreset || 'standard';
+  const preset = config.presets[presetName] || config.presets['standard'] || {};
+  const presetTypeOptions = preset[type] || {};
+  const configTypeOptions = config[type] || {};
+
+  const merged = { ...configTypeOptions, ...presetTypeOptions };
+
+  // Explicit CLI flags should override
+  // Commander uses camelCase for flags like --no-sub-components-dir -> subComponentsDir
+  for (const key in merged) {
+    if (cmdOptions[key] !== undefined) {
+      merged[key] = cmdOptions[key];
+    } else if (key.startsWith('create')) {
+      // Try mapping short flags to "create" prefix
+      // e.g., CLI --api (cmdOptions.api) -> config createApi
+      const shortKey = key.slice(6).charAt(0).toLowerCase() + key.slice(7);
+      if (cmdOptions[shortKey] !== undefined) {
+        merged[key] = cmdOptions[shortKey];
+      }
+    }
+  }
+
+  return merged;
+}
+
+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');
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+function toPascalCase(input) {
+  return input
+    .split(/[/\\_-]/)
+    .filter(Boolean)
+    .map(segment => {
+      if (segment === segment.toUpperCase() && segment.length > 1) {
+        segment = segment.toLowerCase();
+      }
+      return segment.charAt(0).toUpperCase() + segment.slice(1);
+    })
+    .join('');
+}
+
+function getFeatureComponentName(featurePath) {
+  return toPascalCase(featurePath);
+}
+
+function getHookFunctionName(componentName) {
+  return 'use' + componentName;
+}
+
+function getHookFileName(componentName, extension = '.ts') {
+  return getHookFunctionName(componentName) + extension;
+}
+
+function normalizeComponentName(name) {
+  return toPascalCase(name);
+}
+
+function normalizeRoute(route) {
+  let normalized = route.trim();
+  
+  if (!normalized.startsWith('/')) {
+    normalized = '/' + normalized;
+  }
+  
+  if (normalized.length > 1 && normalized.endsWith('/')) {
+    normalized = normalized.slice(0, -1);
+  }
+  
+  return normalized;
+}
+
+function routeToFilePath(route, options = {}) {
+  const { extension = '.astro', mode = 'flat', indexFile = 'index.astro' } = options;
+  const normalized = normalizeRoute(route);
+  
+  if (normalized === '/') {
+    return indexFile;
+  }
+  
+  const routePath = normalized.slice(1);
+  if (mode === 'nested') {
+    return path.join(routePath, indexFile);
+  }
+  
+  return routePath + extension;
+}
+
+function featureToDirectoryPath(featurePath) {
+  return featurePath.replace(/^\/+/, '').replace(/\/+$/, '');
+}
+
+function getFeatureFileName(featurePath, options = {}) {
+  const { extension = '.astro', strategy = 'index' } = options;
+  if (strategy === 'pascal') {
+    return getFeatureComponentName(featurePath) + extension;
+  }
+  return 'index' + extension;
+}
+
+/**
+ * Calculates a relative import path from one file to another.
+ * @param {string} fromFile The absolute path of the file containing the import
+ * @param {string} toFile The absolute path of the file being imported
+ * @returns {string} The relative import path
+ */
+function getRelativeImportPath(fromFile, toFile) {
+  let relativePath = path.relative(path.dirname(fromFile), toFile);
+  
+  // Convert backslashes to forward slashes for imports
+  relativePath = relativePath.split(path.sep).join('/');
+  
+  // Ensure it starts with ./ or ../
+  if (!relativePath.startsWith('.')) {
+    relativePath = './' + relativePath;
+  }
+  
+  return relativePath;
+}
+
+const execAsync$1 = promisify(exec);
+
+function calculateHash(content, normalization = 'normalizeEOL') {
+  let normalizedContent = content;
+  
+  if (normalization === 'stripGeneratedRegions') {
+    // Extract all content between :begin and :end markers
+    const beginMarker = /@generated by Textor:begin/g;
+    const endMarker = /@generated by Textor:end/g;
+    
+    const regions = [];
+    let match;
+    const beginIndices = [];
+    while ((match = beginMarker.exec(content)) !== null) {
+      beginIndices.push(match.index + match[0].length);
+    }
+    
+    const endIndices = [];
+    while ((match = endMarker.exec(content)) !== null) {
+      endIndices.push(match.index);
+    }
+    
+    if (beginIndices.length > 0 && beginIndices.length === endIndices.length) {
+      for (let i = 0; i < beginIndices.length; i++) {
+        regions.push(content.slice(beginIndices[i], endIndices[i]));
+      }
+      normalizedContent = regions.join('\n');
+    }
+    // Fall back to full content if markers are missing or mismatched
+  }
+
+  if (normalization === 'normalizeEOL' || normalization === 'stripGeneratedRegions') {
+    normalizedContent = normalizedContent.replace(/\r\n/g, '\n');
+  }
+  
+  return createHash('sha256').update(normalizedContent).digest('hex');
+}
+
+async function isTextorGenerated(filePath, customSignatures = []) {
+  if (!existsSync(filePath)) {
+    return false;
+  }
+
+  try {
+    const content = await readFile(filePath, 'utf-8');
+    const signatures = ['@generated by Textor', ...customSignatures];
+    return signatures.some(sig => content.includes(sig));
+  } catch {
+    return false;
+  }
+}
+
+async function verifyFileIntegrity(filePath, expectedHash, options = {}) {
+  const { 
+    force = false, 
+    acceptChanges = false, 
+    normalization = 'normalizeEOL',
+    owner = null,
+    actualOwner = null
+  } = options;
+  
+  if (force) return { valid: true };
+
+  if (owner && actualOwner && owner !== actualOwner) {
+    return {
+      valid: false,
+      reason: 'wrong-owner',
+      message: `Refusing to operate on ${filePath} - owned by ${actualOwner}, but requested by ${owner}. Use --force to override.`
+    };
+  }
+
+  const isGenerated = await isTextorGenerated(filePath);
+  if (!isGenerated) {
+    return { 
+      valid: false, 
+      reason: 'not-generated', 
+      message: `Refusing to operate on ${filePath} - not generated by Textor. Use --force to override.` 
+    };
+  }
+
+  if (!expectedHash) {
+    return {
+      valid: false,
+      reason: 'not-in-state',
+      message: `Refusing to operate on ${filePath} - not found in Textor state. Use --force to override.`
+    };
+  }
+
+  if (!acceptChanges) {
+    const content = await readFile(filePath, 'utf-8');
+    const currentHash = calculateHash(content, normalization);
+    if (currentHash !== expectedHash) {
+      return {
+        valid: false,
+        reason: 'hash-mismatch',
+        message: `Refusing to operate on ${filePath} - content has been modified. Use --accept-changes or --force to override.`
+      };
+    }
+  }
+
+  return { valid: true };
+}
+
+async function safeDelete(filePath, options = {}) {
+  const { force = false, expectedHash = null, acceptChanges = false, owner = null, actualOwner = null } = options;
+  
+  if (!existsSync(filePath)) {
+    return { deleted: false, reason: 'not-found' };
+  }
+  
+  const integrity = await verifyFileIntegrity(filePath, expectedHash, { 
+    force, 
+    acceptChanges,
+    owner,
+    actualOwner
+  });
+  if (!integrity.valid) {
+    return { deleted: false, reason: integrity.reason, message: integrity.message };
+  }
+
+  await unlink(filePath);
+  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 });
+}
+
+async function isSafeToDeleteDir(dirPath, stateFiles = {}, options = {}) {
+  try {
+    const files = await readdir(dirPath);
+    
+    const results = await Promise.all(
+      files.map(async file => {
+        const filePath = path.join(dirPath, file);
+        const stats = await stat(filePath);
+        
+        if (stats.isDirectory()) {
+          return await isSafeToDeleteDir(filePath, stateFiles, options);
+        }
+        
+        const normalizedPath = path.relative(process.cwd(), filePath).replace(/\\/g, '/');
+        const fileState = stateFiles[normalizedPath];
+        const integrity = await verifyFileIntegrity(filePath, fileState?.hash, {
+          ...options,
+          actualOwner: fileState?.owner
+        });
+        return integrity.valid;
+      })
+    );
+
+    return results.every(Boolean);
+  } catch {
+    return false;
+  }
+}
+
+async function safeDeleteDir(dirPath, options = {}) {
+  const { force = false, stateFiles = {} } = options;
+  if (!existsSync(dirPath)) {
+    return { deleted: false, reason: 'not-found' };
+  }
+
+  const isSafe = force || await isSafeToDeleteDir(dirPath, stateFiles, options);
+  
+  if (isSafe) {
+    await rm(dirPath, { recursive: true, force: true });
+    return { deleted: true };
+  }
+
+  return {
+    deleted: false,
+    reason: 'contains-non-generated-or-modified',
+    message: `Directory contains non-generated or modified files: ${dirPath}. Use --force to override.`
+  };
+}
+
+async function writeFileWithSignature(filePath, content, signature, normalization = 'normalizeEOL') {
+  await ensureDir(path.dirname(filePath));
+  
+  let finalContent = signature + '\n' + content;
+  
+  if (signature.includes(':begin')) {
+    const endSignature = signature.replace(':begin', ':end');
+    finalContent = signature + '\n' + content + '\n' + endSignature;
+  }
+
+  await writeFile(filePath, finalContent, 'utf-8');
+  
+  return calculateHash(finalContent, normalization);
+}
+
+function getSignature(config, type) {
+  const base = config.signatures[type] || config.signatures.typescript;
+  if (config.hashing?.useMarkers) {
+    return base.replace('Textor', 'Textor:begin');
+  }
+  return base;
+}
+
+async function updateSignature(filePath, oldPath, newPath) {
+  if (!existsSync(filePath)) {
+    return;
+  }
+
+  let content = await readFile(filePath, 'utf-8');
+  
+  content = content.replace(
+    new RegExp(oldPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'),
+    newPath
+  );
+  
+  await writeFile(filePath, content, 'utf-8');
+}
+
+async function safeMove(fromPath, toPath, options = {}) {
+  const { 
+    force = false, 
+    expectedHash = null, 
+    acceptChanges = false, 
+    normalization = 'normalizeEOL',
+    owner = null,
+    actualOwner = null
+  } = options;
+  
+  if (!existsSync(fromPath)) {
+    throw new Error(`Source file not found: ${fromPath}`);
+  }
+
+  if (existsSync(toPath) && !force) {
+    throw new Error(
+      `Destination already exists: ${toPath}\n` +
+      `Use --force to overwrite.`
+    );
+  }
+
+  const integrity = await verifyFileIntegrity(fromPath, expectedHash, { 
+    force, 
+    acceptChanges, 
+    normalization,
+    owner,
+    actualOwner
+  });
+  if (!integrity.valid) {
+    throw new Error(integrity.message);
+  }
+
+  await ensureDir(path.dirname(toPath));
+  await rename(fromPath, toPath);
+  
+  await updateSignature(toPath, fromPath, toPath);
+  
+  // Return new hash because updateSignature might have changed it
+  const content = await readFile(toPath, 'utf-8');
+  return calculateHash(content, normalization);
+}
+
+async function isEmptyDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    return true;
+  }
+
+  const files = await readdir(dirPath);
+  return files.length === 0;
+}
+
+async function scanDirectory(dir, fileSet) {
+  const files = await readdir(dir);
+  for (const file of files) {
+    const fullPath = path.join(dir, file);
+    const stats = await stat(fullPath);
+    if (stats.isDirectory()) {
+      if (file === 'node_modules' || file === '.git' || file === '.textor') continue;
+      await scanDirectory(fullPath, fileSet);
+    } else {
+      const relativePath = path.relative(process.cwd(), fullPath).replace(/\\/g, '/');
+      fileSet.add(relativePath);
+    }
+  }
+}
+
+function inferKind(filePath, config) {
+  const normalizedFilePath = path.resolve(filePath).replace(/\\/g, '/');
+  const relativeFromCwd = path.relative(process.cwd(), normalizedFilePath).replace(/\\/g, '/');
+
+  // Check kindRules first (precedence)
+  if (config.kindRules && Array.isArray(config.kindRules)) {
+    for (const rule of config.kindRules) {
+      if (rule.match && rule.kind) {
+        // Simple glob-to-regex conversion for ** and *
+        const regexStr = rule.match
+          .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex special chars
+          .replace(/\*\*/g, '(.+)')             // ** matches anything
+          .replace(/\*/g, '([^/]+)');            // * matches one segment
+        
+        const regex = new RegExp(`^${regexStr}$`);
+        if (regex.test(relativeFromCwd) || regex.test(normalizedFilePath)) {
+          return rule.kind;
+        }
+      }
+    }
+  }
+
+  const pagesRoot = path.resolve(process.cwd(), config.paths.pages || 'src/pages').replace(/\\/g, '/');
+  const featuresRoot = path.resolve(process.cwd(), config.paths.features || 'src/features').replace(/\\/g, '/');
+  const componentsRoot = path.resolve(process.cwd(), config.paths.components || 'src/components').replace(/\\/g, '/');
+
+  const ext = path.extname(normalizedFilePath);
+
+  if (normalizedFilePath.startsWith(pagesRoot)) {
+    if (ext === '.ts' || ext === '.js') return 'endpoint';
+    return 'route';
+  }
+
+  if (normalizedFilePath.startsWith(featuresRoot)) {
+    const relativePath = path.relative(featuresRoot, normalizedFilePath).replace(/\\/g, '/');
+    const parts = relativePath.split('/');
+    
+    // If it's directly in the features root
+    if (parts.length === 1) return 'feature';
+
+    const fileName = parts[parts.length - 1];
+    const featureDir = path.dirname(relativePath).replace(/\\/g, '/');
+    
+    // Main feature file can be FeatureName.astro or index.astro
+    const featureName = toPascalCase(featureDir);
+    const possiblePascalName = featureName + (config.naming.featureExtension || '.astro');
+    const possibleIndexName = 'index' + (config.naming.featureExtension || '.astro');
+    
+    if (path.dirname(relativePath) !== '.' && (fileName === possiblePascalName || fileName === possibleIndexName)) {
+      // It's in the top level of its feature directory
+      if (parts.length === (featureDir.split('/').length + 1)) {
+        return 'feature';
+      }
+    }
+    
+    return 'feature-file';
+  }
+
+  if (normalizedFilePath.startsWith(componentsRoot)) {
+    const relativePath = path.relative(componentsRoot, normalizedFilePath).replace(/\\/g, '/');
+    const parts = relativePath.split('/');
+    
+    if (parts.length === 1) return 'component';
+    
+    const componentDir = parts[0];
+    const fileName = parts[parts.length - 1];
+    const componentName = toPascalCase(componentDir);
+    
+    const possibleComponentName = componentName + (config.naming.componentExtension || '.tsx');
+    const possibleIndexName = 'index' + (config.naming.componentExtension || '.tsx');
+    
+    if (parts.length === 2 && (fileName === possibleComponentName || fileName === possibleIndexName)) {
+      return 'component';
+    }
+    
+    return 'component-file';
+  }
+
+  return 'unknown';
+}
+
+/**
+ * Safely joins path segments and ensures the result is within the basePath.
+ * @param {string} basePath The base directory that must contain the result
+ * @param {...string} segments Path segments to join
+ * @returns {string} The joined path
+ * @throws {Error} If a path traversal attempt is detected
+ */
+function secureJoin(basePath, ...segments) {
+  const joinedPath = path.join(basePath, ...segments);
+  const resolvedBase = path.resolve(basePath);
+  const resolvedJoined = path.resolve(joinedPath);
+  
+  const relative = path.relative(resolvedBase, resolvedJoined);
+  
+  if (relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw new Error(`Security error: Path traversal attempt detected: ${joinedPath} is outside of ${basePath}`);
+  }
+  
+  return joinedPath;
+}
+
+async function cleanupEmptyDirs(dirPath, rootPath) {
+  const normalizedDir = path.resolve(dirPath);
+  const normalizedRoot = path.resolve(rootPath);
+  
+  if (normalizedDir === normalizedRoot || !normalizedDir.startsWith(normalizedRoot)) {
+    return;
+  }
+
+  if (await isEmptyDir(normalizedDir)) {
+    await rmdir(normalizedDir);
+    await cleanupEmptyDirs(path.dirname(normalizedDir), rootPath);
+  }
+}
+
+/**
+ * Formats a list of files using the specified tool.
+ * @param {string[]} filePaths 
+ * @param {'prettier' | 'biome' | 'none'} tool 
+ */
+async function formatFiles(filePaths, tool) {
+    if (tool === 'none' || !filePaths.length) return;
+    
+    // Quote paths to handle spaces
+    const paths = filePaths.map(p => `"${p}"`).join(' ');
+    
+    if (tool === 'prettier') {
+        try {
+            await execAsync$1(`npx prettier --write ${paths}`);
+        } catch (error) {
+            // Silently fail if prettier is not available or fails
+        }
+    } else if (tool === 'biome') {
+        try {
+            await execAsync$1(`npx biome format --write ${paths}`);
+        } catch (error) {
+            // Silently fail
+        }
+    }
+}
+
+var filesystem = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  calculateHash: calculateHash,
+  cleanupEmptyDirs: cleanupEmptyDirs,
+  ensureDir: ensureDir,
+  ensureNotExists: ensureNotExists,
+  formatFiles: formatFiles,
+  getSignature: getSignature,
+  inferKind: inferKind,
+  isEmptyDir: isEmptyDir,
+  isTextorGenerated: isTextorGenerated,
+  safeDelete: safeDelete,
+  safeDeleteDir: safeDeleteDir,
+  safeMove: safeMove,
+  scanDirectory: scanDirectory,
+  secureJoin: secureJoin,
+  updateSignature: updateSignature,
+  verifyFileIntegrity: verifyFileIntegrity,
+  writeFileWithSignature: writeFileWithSignature
+});
+
+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 || '');
+    }
+    return content;
+  }
+  return null;
+}
+
+/**
+ * Route Template Variables:
+ * - layoutName: The name of the layout component
+ * - layoutImportPath: Path to import the layout
+ * - featureImportPath: Path to import the feature component
+ * - featureComponentName: Name of the feature component
+ */
+function generateRouteTemplate(layoutName, layoutImportPath, featureImportPath, featureComponentName) {
+  const override = getTemplateOverride('route', '.astro', {
+    layoutName,
+    layoutImportPath,
+    featureImportPath,
+    featureComponentName
+  });
+  if (override) return override;
+
+  if (layoutName === 'none') {
+    return `---
+import ${featureComponentName} from '${featureImportPath}';
+---
+
+<${featureComponentName} />
+`;
+  }
+
+  return `---
+import ${layoutName} from '${layoutImportPath}';
+import ${featureComponentName} from '${featureImportPath}';
+---
+
+<${layoutName}>
+  <${featureComponentName} />
+</${layoutName}>
+`;
+}
+
+/**
+ * Feature Template Variables:
+ * - 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 });
+  if (override) return override;
+
+  if (framework === 'react') {
+    return `export type ${componentName}Props = {
+  // Add props here
+}
+
+export default function ${componentName}({ }: ${componentName}Props) {
+  return (
+    <div className="${componentName.toLowerCase()}">
+      <h1>${componentName}</h1>
+    </div>
+  );
+}
+`;
+  }
+
+  const scriptTag = scriptImportPath ? `\n<script src="${scriptImportPath}"></script>` : '';
+
+  return `---
+// Feature: ${componentName}
+---
+
+<div class="${componentName.toLowerCase()}">
+  <h1>${componentName}</h1>
+</div>${scriptTag}
+`;
+}
+
+/**
+ * Scripts Index Template (no variables)
+ */
+function generateScriptsIndexTemplate() {
+  const override = getTemplateOverride('scripts-index', '.ts');
+  if (override) return override;
+
+  return `export {};
+`;
+}
+
+/**
+ * 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 });
+  if (override) return override;
+
+  if (framework === 'react') {
+    return `export type ${componentName}Props = {
+  // Add props here
+}
+
+export default function ${componentName}({ }: ${componentName}Props) {
+  return (
+    <div className="${componentName.toLowerCase()}">
+      {/* ${componentName} implementation */}
+    </div>
+  );
+}
+`;
+  }
+
+  return `---
+export type Props = {
+  // Add props here
+}
+
+const props = Astro.props;
+---
+
+<div class="${componentName.toLowerCase()}">
+  <!-- ${componentName} implementation -->
+</div>
+`;
+}
+
+/**
+ * Hook Template Variables:
+ * - componentName: Name of the component
+ * - hookName: Name of the hook function (e.g., useButton)
+ */
+function generateHookTemplate(componentName, hookName) {
+  const override = getTemplateOverride('hook', '.ts', { componentName, hookName });
+  if (override) return override;
+
+  return `import { useState } from 'react';
+
+export function ${hookName}() {
+  // Add hook logic here
+  
+  return {
+    // Return hook values
+  };
+}
+`;
+}
+
+/**
+ * Context Template Variables:
+ * - componentName: Name of the component
+ */
+function generateContextTemplate(componentName) {
+  const override = getTemplateOverride('context', '.tsx', { componentName });
+  if (override) return override;
+
+  return `import { createContext, useContext } from 'react';
+
+//@ts-ignore
+type ${componentName}ContextValue = {
+  // Add context value types here
+}
+
+const ${componentName}Context = createContext<${componentName}ContextValue | undefined>(undefined);
+
+export function ${componentName}Provider({ children }: { children: React.ReactNode }) {
+  const value: ${componentName}ContextValue = {
+    // Provide context values
+  };
+
+  return (
+    <${componentName}Context.Provider value={value}>
+      {children}
+    </${componentName}Context.Provider>
+  );
+}
+
+export function use${componentName}Context() {
+  const context = useContext(${componentName}Context);
+  if (context === undefined) {
+    throw new Error('use${componentName}Context must be used within ${componentName}Provider');
+  }
+  return context;
+}
+`;
+}
+
+/**
+ * Test Template Variables:
+ * - componentName: Name of the component
+ * - componentPath: Relative path to the component file
+ */
+function generateTestTemplate(componentName, componentPath) {
+  const override = getTemplateOverride('test', '.tsx', { componentName, componentPath });
+  if (override) return override;
+
+  return `import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import ${componentName} from '${componentPath}';
+
+describe('${componentName}', () => {
+  it('renders without crashing', () => {
+    render(<${componentName} />);
+    expect(screen.getByText('${componentName}')).toBeInTheDocument();
+  });
+});
+`;
+}
+
+/**
+ * Config Template Variables:
+ * - componentName: Name of the component
+ */
+function generateConfigTemplate(componentName) {
+  const override = getTemplateOverride('config', '.ts', { componentName });
+  if (override) return override;
+
+  return `export const ${componentName}Config = {
+  // Add configuration here
+};
+`;
+}
+
+/**
+ * Constants Template Variables:
+ * - componentName: Name of the component
+ */
+function generateConstantsTemplate(componentName) {
+  const override = getTemplateOverride('constants', '.ts', { componentName });
+  if (override) return override;
+
+  return `export const ${componentName.toUpperCase()}_CONSTANTS = {
+  // Add constants here
+};
+`;
+}
+
+/**
+ * Index Template Variables:
+ * - componentName: Name of the component
+ * - componentExtension: File extension of the component
+ */
+function generateIndexTemplate(componentName, componentExtension) {
+  const override = getTemplateOverride('index', '.ts', { componentName, componentExtension });
+  if (override) return override;
+
+  return `export { default as ${componentName} } from './${componentName}${componentExtension}';
+export * from './types';
+`;
+}
+
+/**
+ * Types Template Variables:
+ * - componentName: Name of the component
+ */
+function generateTypesTemplate(componentName) {
+  const override = getTemplateOverride('types', '.ts', { componentName });
+  if (override) return override;
+
+  return `export type ${componentName}Props = {
+  // Add props types here
+};
+`;
+}
+
+/**
+ * API Template Variables:
+ * - componentName: Name of the component
+ */
+function generateApiTemplate(componentName) {
+  const override = getTemplateOverride('api', '.ts', { componentName });
+  if (override) return override;
+
+  return `export function GET({ params, request }) {
+  return new Response(
+    JSON.stringify({
+      name: "${componentName}",
+      url: "https://astro.build/",
+    }),
+  );
+}
+`;
+}
+
+/**
+ * Endpoint Template Variables:
+ * - componentName: Name of the component
+ */
+function generateEndpointTemplate(componentName) {
+  const override = getTemplateOverride('endpoint', '.ts', { componentName });
+  if (override) return override;
+
+  return `export function GET({ params, request }) {
+  return new Response(
+    JSON.stringify({
+      name: "${componentName}",
+      url: "https://astro.build/",
+    }),
+  );
+}
+`;
+}
+
+/**
+ * Service Template Variables:
+ * - componentName: Name of the component
+ */
+function generateServiceTemplate(componentName) {
+  const override = getTemplateOverride('service', '.ts', { componentName });
+  if (override) return override;
+
+  return `// ${componentName} business logic and transformers
+export async function get${componentName}Data() {
+  // Encapsulated logic for data processing
+  return [];
+}
+
+export function transform${componentName}Data(data: any) {
+  // Domain-specific data transformations
+  return data;
+}
+`;
+}
+
+/**
+ * Schema Template Variables:
+ * - componentName: Name of the component
+ */
+function generateSchemaTemplate(componentName) {
+  const override = getTemplateOverride('schema', '.ts', { componentName });
+  if (override) return override;
+
+  return `import { z } from 'zod';
+
+export const ${componentName}Schema = z.object({
+  id: z.string().uuid(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime().optional(),
+});
+
+export type ${componentName} = z.infer<typeof ${componentName}Schema>;
+`;
+}
+
+/**
+ * Readme Template Variables:
+ * - componentName: Name of the component
+ */
+function generateReadmeTemplate(componentName) {
+  const override = getTemplateOverride('readme', '.md', { componentName });
+  if (override) return override;
+
+  return `# ${componentName}
+
+## Description
+Brief description of what this feature/component does.
+
+## Props/Usage
+How to use this and what are its requirements.
+`;
+}
+
+/**
+ * Stories Template Variables:
+ * - componentName: Name of the component
+ * - componentPath: Relative path to the component file
+ */
+function generateStoriesTemplate(componentName, componentPath) {
+  const override = getTemplateOverride('stories', '.tsx', { componentName, componentPath });
+  if (override) return override;
+
+  return `import type { Meta, StoryObj } from '@storybook/react';
+import ${componentName} from '${componentPath}';
+
+const meta: Meta<typeof ${componentName}> = {
+  title: 'Components/${componentName}',
+  component: ${componentName},
+};
+
+export default meta;
+type Story = StoryObj<typeof ${componentName}>;
+
+export const Default: Story = {
+  args: {
+    // Default props
+  },
+};
+`;
+}
+
+const CONFIG_DIR = '.textor';
+const STATE_FILE = 'state.json';
+
+function getStatePath() {
+  return path.join(process.cwd(), CONFIG_DIR, STATE_FILE);
+}
+
+async function loadState() {
+  const statePath = getStatePath();
+  if (!existsSync(statePath)) {
+    return { sections: [], components: [], files: {} };
+  }
+
+  try {
+    const content = await readFile(statePath, 'utf-8');
+    const state = JSON.parse(content);
+    if (!state.files) state.files = {};
+    return state;
+  } catch (error) {
+    return { sections: [], components: [], files: {} };
+  }
+}
+
+let saveQueue = Promise.resolve();
+
+async function saveState(state) {
+  const result = saveQueue.then(async () => {
+    const statePath = getStatePath();
+    const dir = path.dirname(statePath);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    
+    const tempPath = statePath + '.' + Math.random().toString(36).slice(2) + '.tmp';
+    const content = JSON.stringify(state, null, 2);
+    
+    const handle = await open(tempPath, 'w');
+    await handle.writeFile(content, 'utf-8');
+    await handle.sync();
+    await handle.close();
+
+    await rename(tempPath, statePath);
+  });
+  
+  saveQueue = result.catch(() => {});
+  return result;
+}
+
+async function registerFile(filePath, { kind, template, hash, templateVersion = '1.0.0', owner = null }) {
+  const state = await loadState();
+  const normalizedPath = path.relative(process.cwd(), filePath).replace(/\\/g, '/');
+  
+  state.files[normalizedPath] = {
+    kind,
+    template,
+    hash,
+    templateVersion,
+    owner,
+    timestamp: new Date().toISOString()
+  };
+  
+  await saveState(state);
+}
+
+async function addSectionToState(section) {
+  const state = await loadState();
+  // Avoid duplicates by route
+  state.sections = state.sections.filter(s => s.route !== section.route);
+  state.sections.push(section);
+  await saveState(state);
+}
+
+async function addComponentToState(component) {
+  const state = await loadState();
+  // Avoid duplicates by name
+  state.components = state.components.filter(c => c.name !== component.name);
+  state.components.push(component);
+  await saveState(state);
+}
+
+function findSection(state, identifier) {
+  return state.sections.find(s => s.route === identifier || s.name === identifier || s.featurePath === identifier);
+}
+
+function findComponent(state, name) {
+  return state.components.find(c => c.name === name);
+}
+
+function reconstructComponents(files, config) {
+  const componentsRoot = (config.paths.components || 'src/components').replace(/\\/g, '/');
+  const components = new Map();
+
+  for (const filePath in files) {
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    if (normalizedPath === componentsRoot || normalizedPath.startsWith(componentsRoot + '/')) {
+      const relativePath = normalizedPath === componentsRoot ? '' : normalizedPath.slice(componentsRoot.length + 1);
+      if (relativePath === '') continue; // skip the root itself if it's in files for some reason
+      
+      const parts = relativePath.split('/');
+      if (parts.length >= 1) {
+        const componentName = parts[0];
+        const componentPath = `${componentsRoot}/${componentName}`;
+        if (!components.has(componentName)) {
+          components.set(componentName, {
+            name: componentName,
+            path: componentPath
+          });
+        }
+      }
+    }
+  }
+
+  return Array.from(components.values());
+}
+
+function reconstructSections(state, config) {
+  const pagesRoot = (config.paths.pages || 'src/pages').replace(/\\/g, '/');
+  const featuresRoot = (config.paths.features || 'src/features').replace(/\\/g, '/');
+  const files = state.files;
+  
+  // Keep existing sections if their files still exist
+  const validSections = (state.sections || []).filter(section => {
+    // Check if route file exists in state.files
+    const routeFile = Object.keys(files).find(f => {
+      const normalizedF = f.replace(/\\/g, '/');
+      const routePath = section.route === '/' ? 'index' : section.route.slice(1);
+      return normalizedF.startsWith(pagesRoot + '/' + routePath + '.') || 
+             normalizedF === pagesRoot + '/' + routePath + '/index.astro'; // nested mode
+    });
+
+    // Check if feature directory has at least one file in state.files
+    const hasFeatureFiles = Object.keys(files).some(f => 
+      f.replace(/\\/g, '/').startsWith(section.featurePath.replace(/\\/g, '/') + '/')
+    );
+
+    return routeFile && hasFeatureFiles;
+  });
+
+  const sections = new Map();
+  validSections.forEach(s => sections.set(s.route, s));
+
+  // Try to discover new sections
+  for (const filePath in files) {
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    if (normalizedPath.startsWith(pagesRoot + '/')) {
+      const relativePath = normalizedPath.slice(pagesRoot.length + 1);
+      const route = '/' + relativePath.replace(/\.(astro|ts|js|tsx|jsx)$/, '').replace(/\/index$/, '');
+      const finalRoute = route === '' ? '/' : route;
+
+      if (!sections.has(finalRoute)) {
+        // Try to find a matching feature by name
+        const routeName = path.basename(finalRoute === '/' ? 'index' : finalRoute);
+        // Look for a directory in features with same name or similar
+        const possibleFeaturePath = Object.keys(files).find(f => {
+           const nf = f.replace(/\\/g, '/');
+           return nf.startsWith(featuresRoot + '/') && nf.includes('/' + routeName + '/');
+        });
+
+        if (possibleFeaturePath) {
+           const featurePathParts = possibleFeaturePath.replace(/\\/g, '/').split('/');
+           const featuresBase = path.basename(featuresRoot);
+           const featureIndex = featurePathParts.indexOf(featuresBase) + 1;
+           
+           if (featureIndex > 0 && featureIndex < featurePathParts.length) {
+             const featureName = featurePathParts[featureIndex];
+             const featurePath = `${featuresRoot}/${featureName}`;
+
+             sections.set(finalRoute, {
+               name: featureName,
+               route: finalRoute,
+               featurePath: featurePath,
+               extension: path.extname(filePath)
+             });
+           }
+        }
+      }
+    }
+  }
+
+  return Array.from(sections.values());
+}
+
+const execAsync = promisify(exec);
+
+async function isRepoClean() {
+  try {
+    const { stdout } = await execAsync('git status --porcelain');
+    return stdout.trim() === '';
+  } catch (error) {
+    // If not a git repo, we consider it clean or at least we can't check
+    return true;
+  }
+}
+
+async function stageFiles(filePaths) {
+  if (!filePaths.length) return;
+  try {
+    const paths = filePaths.map(p => `"${p}"`).join(' ');
+    await execAsync(`git add ${paths}`);
+  } catch (error) {
+    // Ignore errors if git is not available
+  }
+}
+
+async function addSectionCommand(route, featurePath, options) {
+  try {
+    const config = await loadConfig();
+    const effectiveOptions = getEffectiveOptions(options, config, 'features');
+    
+    const normalizedRoute = normalizeRoute(route);
+    const normalizedFeaturePath = featureToDirectoryPath(featurePath);
+    
+    const pagesRoot = resolvePath(config, 'pages');
+    const featuresRoot = resolvePath(config, 'features');
+    const layoutsRoot = resolvePath(config, 'layouts');
+    
+    const routeExtension = options.endpoint ? '.ts' : config.naming.routeExtension;
+    
+    // Check if we should use nested mode even if config says flat
+    // (because the directory already exists, suggesting it should be an index file)
+    let effectiveRoutingMode = config.routing.mode;
+    if (effectiveRoutingMode === 'flat') {
+      const routeDirName = routeToFilePath(normalizedRoute, {
+        extension: '',
+        mode: 'flat'
+      });
+      const routeDirPath = secureJoin(pagesRoot, routeDirName);
+      if (existsSync(routeDirPath)) {
+        effectiveRoutingMode = 'nested';
+      }
+    }
+
+    const routeFileName = routeToFilePath(normalizedRoute, {
+      extension: routeExtension,
+      mode: effectiveRoutingMode,
+      indexFile: config.routing.indexFile
+    });
+    
+    const featureComponentName = getFeatureComponentName(normalizedFeaturePath);
+    const featureFileName = getFeatureFileName(normalizedFeaturePath, {
+      extension: config.naming.featureExtension,
+      strategy: effectiveOptions.entry
+    });
+    
+    const routeFilePath = secureJoin(pagesRoot, routeFileName);
+    const featureDirPath = secureJoin(featuresRoot, normalizedFeaturePath);
+    const featureFilePath = secureJoin(featureDirPath, featureFileName);
+    const scriptsIndexPath = secureJoin(featureDirPath, config.features.scriptsIndexFile);
+    const subComponentsDir = secureJoin(featureDirPath, 'sub-components');
+    const testsDir = secureJoin(featureDirPath, '__tests__');
+    const contextDirInside = secureJoin(featureDirPath, 'context');
+    const hooksDirInside = secureJoin(featureDirPath, 'hooks');
+    const typesDirInside = secureJoin(featureDirPath, 'types');
+    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 indexFilePath = path.join(featureDirPath, 'index.ts');
+    const contextFilePath = path.join(contextDirInside, `${featureComponentName}Context.tsx`);
+    const hookFilePath = path.join(hooksDirInside, getHookFileName(featureComponentName, config.naming.hookExtension));
+    const testFilePath = path.join(testsDir, `${featureComponentName}${config.naming.testExtension}`);
+    const typesFilePath = path.join(typesDirInside, 'index.ts');
+    const apiFilePath = path.join(apiDirInside, 'index.ts');
+    const servicesFilePath = path.join(servicesDirInside, 'index.ts');
+    const schemasFilePath = path.join(schemasDirInside, 'index.ts');
+    const readmeFilePath = path.join(featureDirPath, 'README.md');
+    const storiesFilePath = path.join(featureDirPath, `${featureComponentName}.stories.tsx`);
+
+    const routeParts = normalizedRoute.split('/').filter(Boolean);
+    const reorganizations = [];
+
+    if (routeParts.length > 1 && config.routing.mode === 'flat') {
+      const possibleExtensions = ['.astro', '.ts', '.js', '.md', '.mdx', '.html'];
+      for (let i = 1; i < routeParts.length; i++) {
+        const parentRoute = '/' + routeParts.slice(0, i).join('/');
+        
+        for (const ext of possibleExtensions) {
+          const parentRouteFileName = routeToFilePath(parentRoute, {
+            extension: ext,
+            mode: 'flat'
+          });
+          const parentRouteFilePath = secureJoin(pagesRoot, parentRouteFileName);
+          
+          if (existsSync(parentRouteFilePath)) {
+            const indexFile = ext === '.astro' ? config.routing.indexFile : `index${ext}`;
+            const newParentRouteFileName = routeToFilePath(parentRoute, {
+              extension: ext,
+              mode: 'nested',
+              indexFile: indexFile
+            });
+            const newParentRouteFilePath = secureJoin(pagesRoot, newParentRouteFileName);
+            
+            if (!existsSync(newParentRouteFilePath)) {
+              reorganizations.push({
+                from: parentRouteFilePath,
+                to: newParentRouteFilePath,
+                route: parentRoute
+              });
+            }
+          }
+        }
+      }
+    }
+
+    if (options.dryRun) {
+      console.log('Dry run - would create:');
+      console.log(`  Route: ${routeFilePath}`);
+      console.log(`  Feature: ${featureFilePath}`);
+
+      for (const reorg of reorganizations) {
+        console.log(`  Reorganize: ${reorg.from} -> ${reorg.to}`);
+      }
+      
+      if (shouldCreateIndex) console.log(`  Index: ${indexFilePath}`);
+      if (shouldCreateSubComponentsDir) console.log(`  Sub-components: ${subComponentsDir}/`);
+      if (shouldCreateScriptsDir) console.log(`  Scripts: ${scriptsIndexPath}`);
+      if (shouldCreateApi) console.log(`  Api: ${apiFilePath}`);
+      if (shouldCreateServices) console.log(`  Services: ${servicesFilePath}`);
+      if (shouldCreateSchemas) console.log(`  Schemas: ${schemasFilePath}`);
+      if (shouldCreateHooks) console.log(`  Hooks: ${hookFilePath}`);
+      if (shouldCreateContext) console.log(`  Context: ${contextFilePath}`);
+      if (shouldCreateTests) console.log(`  Tests: ${testFilePath}`);
+      if (shouldCreateTypes) console.log(`  Types: ${typesFilePath}`);
+      if (shouldCreateReadme) console.log(`  Readme: ${readmeFilePath}`);
+      if (shouldCreateStories) console.log(`  Stories: ${storiesFilePath}`);
+      
+      return;
+    }
+
+    if (reorganizations.length > 0) {
+      const state = await loadState();
+      for (const reorg of reorganizations) {
+        await ensureDir(path.dirname(reorg.to));
+        await rename(reorg.from, reorg.to);
+        
+        const oldRelative = path.relative(process.cwd(), reorg.from).replace(/\\/g, '/');
+        const newRelative = path.relative(process.cwd(), reorg.to).replace(/\\/g, '/');
+        
+        if (state.files[oldRelative]) {
+          state.files[newRelative] = { ...state.files[oldRelative] };
+          delete state.files[oldRelative];
+        }
+
+        // Update imports in the moved file
+        await updateImportsInFile(reorg.to, reorg.from, reorg.to);
+        
+        console.log(`✓ Reorganized ${oldRelative} to ${newRelative}`);
+      }
+      await saveState(state);
+    }
+
+    await ensureNotExists(routeFilePath, options.force);
+    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);
+    
+    let layoutImportPath = null;
+    if (options.layout !== 'none') {
+      if (config.importAliases.layouts) {
+        layoutImportPath = `${config.importAliases.layouts}/${options.layout}.astro`;
+      } else {
+        const layoutFilePath = secureJoin(layoutsRoot, `${options.layout}.astro`);
+        layoutImportPath = getRelativeImportPath(routeFilePath, layoutFilePath);
+      }
+    }
+
+    let featureImportPath;
+    if (config.importAliases.features) {
+      const entryPart = effectiveOptions.entry === 'index' ? '' : `/${featureComponentName}`;
+      // In Astro, we can often omit the extension for .tsx files, but not for .astro files if using aliases sometimes.
+      // However, to be safe, we use the configured extension.
+      featureImportPath = `${config.importAliases.features}/${normalizedFeaturePath}${entryPart}${config.naming.featureExtension}`;
+    } else {
+      const relativeFeatureFile = getRelativeImportPath(routeFilePath, featureFilePath);
+      // Remove extension for import
+      featureImportPath = relativeFeatureFile.replace(/\.[^/.]+$/, '');
+    }
+    
+    let scriptImportPath;
+    if (shouldCreateScriptsDir) {
+      scriptImportPath = getRelativeImportPath(featureFilePath, scriptsIndexPath);
+    }
+
+    let routeContent;
+    let routeSignature;
+    
+    if (options.endpoint) {
+      routeContent = generateEndpointTemplate(featureComponentName);
+      routeSignature = getSignature(config, 'typescript');
+    } else {
+      routeContent = generateRouteTemplate(
+        options.layout,
+        layoutImportPath,
+        featureImportPath,
+        featureComponentName
+      );
+      routeSignature = getSignature(config, 'astro');
+    }
+    
+    const featureContent = generateFeatureTemplate(featureComponentName, scriptImportPath, framework);
+    
+    const routeHash = await writeFileWithSignature(
+      routeFilePath,
+      routeContent,
+      routeSignature,
+      config.hashing?.normalization
+    );
+    await registerFile(routeFilePath, { 
+      kind: 'route', 
+      template: options.endpoint ? 'endpoint' : 'route', 
+      hash: routeHash,
+      owner: normalizedRoute 
+    });
+    
+    const writtenFiles = [routeFilePath];
+
+    await ensureDir(featureDirPath);
+    
+    if (shouldCreateSubComponentsDir) await ensureDir(subComponentsDir);
+    if (shouldCreateApi) await ensureDir(apiDirInside);
+    if (shouldCreateServices) await ensureDir(servicesDirInside);
+    if (shouldCreateSchemas) await ensureDir(schemasDirInside);
+    if (shouldCreateHooks) await ensureDir(hooksDirInside);
+    if (shouldCreateContext) await ensureDir(contextDirInside);
+    if (shouldCreateTests) await ensureDir(testsDir);
+    if (shouldCreateTypes) await ensureDir(typesDirInside);
+
+    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 (shouldCreateScriptsDir) {
+      const hash = await writeFileWithSignature(
+        scriptsIndexPath,
+        generateScriptsIndexTemplate(),
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(scriptsIndexPath, { 
+        kind: 'feature-file', 
+        template: 'scripts-index', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(scriptsIndexPath);
+    }
+
+    if (shouldCreateIndex) {
+      const indexContent = generateIndexTemplate(featureComponentName, config.naming.featureExtension);
+      const hash = await writeFileWithSignature(
+        indexFilePath,
+        indexContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(indexFilePath, { 
+        kind: 'feature-file', 
+        template: 'index', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(indexFilePath);
+    }
+
+    if (shouldCreateApi) {
+      const apiContent = generateApiTemplate(featureComponentName);
+      const hash = await writeFileWithSignature(
+        apiFilePath, 
+        apiContent, 
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(apiFilePath, { 
+        kind: 'feature-file', 
+        template: 'api', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(apiFilePath);
+    }
+
+    if (shouldCreateServices) {
+      const servicesContent = generateServiceTemplate(featureComponentName);
+      const hash = await writeFileWithSignature(
+        servicesFilePath, 
+        servicesContent, 
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(servicesFilePath, { 
+        kind: 'feature-file', 
+        template: 'service', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(servicesFilePath);
+    }
+
+    if (shouldCreateSchemas) {
+      const schemasContent = generateSchemaTemplate(featureComponentName);
+      const hash = await writeFileWithSignature(
+        schemasFilePath, 
+        schemasContent, 
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(schemasFilePath, { 
+        kind: 'feature-file', 
+        template: 'schema', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(schemasFilePath);
+    }
+
+    if (shouldCreateHooks) {
+      const hookName = getHookFunctionName(featureComponentName);
+      const hookContent = generateHookTemplate(featureComponentName, hookName);
+      const hash = await writeFileWithSignature(
+        hookFilePath, 
+        hookContent, 
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(hookFilePath, { 
+        kind: 'feature-file', 
+        template: 'hook', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(hookFilePath);
+    }
+
+    if (shouldCreateContext) {
+      const contextContent = generateContextTemplate(featureComponentName);
+      const hash = await writeFileWithSignature(
+        contextFilePath, 
+        contextContent, 
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(contextFilePath, { 
+        kind: 'feature-file', 
+        template: 'context', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(contextFilePath);
+    }
+
+    if (shouldCreateTests) {
+      const relativeFeaturePath = `./${path.basename(featureFilePath)}`;
+      const testContent = generateTestTemplate(featureComponentName, relativeFeaturePath);
+      const hash = await writeFileWithSignature(
+        testFilePath, 
+        testContent, 
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(testFilePath, { 
+        kind: 'feature-file', 
+        template: 'test', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(testFilePath);
+    }
+
+    if (shouldCreateTypes) {
+      const typesContent = generateTypesTemplate(featureComponentName);
+      const hash = await writeFileWithSignature(
+        typesFilePath, 
+        typesContent, 
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(typesFilePath, { 
+        kind: 'feature-file', 
+        template: 'types', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(typesFilePath);
+    }
+
+    if (shouldCreateReadme) {
+      const readmeContent = generateReadmeTemplate(featureComponentName);
+      const hash = await writeFileWithSignature(
+        readmeFilePath, 
+        readmeContent, 
+        getSignature(config, 'astro'),
+        config.hashing?.normalization
+      );
+      await registerFile(readmeFilePath, { 
+        kind: 'feature-file', 
+        template: 'readme', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(readmeFilePath);
+    }
+
+    if (shouldCreateStories) {
+      const relativePath = `./${path.basename(featureFilePath)}`;
+      const storiesContent = generateStoriesTemplate(featureComponentName, relativePath);
+      const hash = await writeFileWithSignature(
+        storiesFilePath, 
+        storiesContent, 
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(storiesFilePath, { 
+        kind: 'feature-file', 
+        template: 'stories', 
+        hash,
+        owner: normalizedRoute 
+      });
+      writtenFiles.push(storiesFilePath);
+    }
+    
+    // Formatting
+    if (config.formatting.tool !== 'none') {
+        await formatFiles(writtenFiles, config.formatting.tool);
+    }
+
+    console.log('✓ Section created successfully:');
+    console.log(`  Route: ${routeFilePath}`);
+    console.log(`  Feature: ${featureFilePath}`);
+    
+    if (shouldCreateIndex) console.log(`  Index: ${indexFilePath}`);
+    if (shouldCreateSubComponentsDir) console.log(`  Sub-components: ${subComponentsDir}/`);
+    if (shouldCreateScriptsDir) console.log(`  Scripts: ${scriptsIndexPath}`);
+    if (shouldCreateApi) console.log(`  Api: ${apiFilePath}`);
+    if (shouldCreateServices) console.log(`  Services: ${servicesFilePath}`);
+    if (shouldCreateSchemas) console.log(`  Schemas: ${schemasFilePath}`);
+    if (shouldCreateHooks) console.log(`  Hooks: ${hookFilePath}`);
+    if (shouldCreateContext) console.log(`  Context: ${contextFilePath}`);
+    if (shouldCreateTests) console.log(`  Tests: ${testFilePath}`);
+    if (shouldCreateTypes) console.log(`  Types: ${typesFilePath}`);
+    if (shouldCreateReadme) console.log(`  Readme: ${readmeFilePath}`);
+    if (shouldCreateStories) console.log(`  Stories: ${storiesFilePath}`);
+    
+    await addSectionToState({
+      name: options.name || featureComponentName,
+      route: normalizedRoute,
+      featurePath: normalizedFeaturePath,
+      layout: options.layout,
+      extension: routeExtension
+    });
+
+    if (config.git?.stageChanges) {
+      await stageFiles(writtenFiles);
+    }
+    
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+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 removeSectionCommand(route, featurePath, options) {
+  try {
+    const config = await loadConfig();
+
+    if (config.git?.requireCleanRepo && !await isRepoClean()) {
+      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 (!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.`);
+      }
+    }
+    
+    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);
+    const featureDirPath = secureJoin(featuresRoot, normalizedFeaturePath);
+    
+    const deletedFiles = [];
+    const skippedFiles = [];
+    const deletedDirs = [];
+    
+    if (options.dryRun) {
+      console.log('Dry run - would delete:');
+      
+      if (!options.keepRoute) {
+        console.log(`  Route: ${routeFilePath}`);
+      }
+      
+      if (!options.keepFeature) {
+        console.log(`  Feature: ${featureDirPath}/`);
+      }
+      
+      return;
+    }
+    
+    if (!options.keepRoute) {
+      const normalizedPath = path.relative(process.cwd(), routeFilePath).replace(/\\/g, '/');
+      const fileState = state.files[normalizedPath];
+      const result = await safeDelete(routeFilePath, {
+        force: options.force,
+        expectedHash: fileState?.hash,
+        acceptChanges: options.acceptChanges,
+        normalization: config.hashing?.normalization,
+        owner: normalizedRoute,
+        actualOwner: fileState?.owner
+      });
+      
+      if (result.deleted) {
+        deletedFiles.push(routeFilePath);
+        delete state.files[normalizedPath];
+      } else if (result.message) {
+        skippedFiles.push({ path: routeFilePath, reason: result.message });
+      }
+    }
+    
+    if (!options.keepFeature) {
+      const result = await safeDeleteDir(featureDirPath, {
+        force: options.force,
+        stateFiles: state.files,
+        acceptChanges: options.acceptChanges,
+        normalization: config.hashing?.normalization,
+        owner: normalizedRoute
+      });
+      
+      if (result.deleted) {
+        deletedDirs.push(featureDirPath);
+        // Unregister all files that were in this directory
+        const dirPrefix = path.relative(process.cwd(), featureDirPath).replace(/\\/g, '/') + '/';
+        for (const f in state.files) {
+          if (f.startsWith(dirPrefix)) {
+            delete state.files[f];
+          }
+        }
+      } else if (result.message) {
+        skippedFiles.push({ path: featureDirPath, reason: result.message });
+      }
+    }
+    
+    if (!options.keepRoute && deletedFiles.includes(routeFilePath)) {
+      await cleanupEmptyDirs(path.dirname(routeFilePath), pagesRoot);
+    }
+    
+    if (!options.keepFeature && deletedDirs.includes(featureDirPath)) {
+      await cleanupEmptyDirs(path.dirname(featureDirPath), featuresRoot);
+    }
+    
+    if (deletedFiles.length > 0 || deletedDirs.length > 0) {
+      console.log('✓ Deleted:');
+      deletedFiles.forEach(file => console.log(`  ${file}`));
+      deletedDirs.forEach(dir => console.log(`  ${dir}/`));
+    }
+    
+    if (skippedFiles.length > 0) {
+      console.log('\n⚠ Skipped:');
+      skippedFiles.forEach(item => {
+        console.log(`  ${item.path}`);
+        console.log(`    Reason: ${item.reason}`);
+      });
+    }
+    
+    if (deletedFiles.length === 0 && deletedDirs.length === 0 && skippedFiles.length === 0) {
+      console.log('No files to delete.');
+    } else {
+      state.sections = state.sections.filter(s => s.route !== normalizedRoute);
+      await saveState(state);
+    }
+    
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Move a section (route + feature).
+ * 
+ * SCOPE GUARANTEES:
+ * - Automatically updates imports in the moved route file.
+ * - Automatically updates internal imports/references within the moved feature directory.
+ * - Repo-wide scan for import updates is available via the --scan flag.
+ * 
+ * NON-GOALS (What it won't rewrite):
+ * - String literals (unless they match the component name exactly in a JSX context).
+ * - Markdown documentation (except for those registered in state).
+ * - Dynamic imports with complex template literals.
+ */
+async function moveSectionCommand(fromRoute, fromFeature, toRoute, toFeature, options) {
+  try {
+    const config = await loadConfig();
+
+    if (config.git?.requireCleanRepo && !await isRepoClean()) {
+      throw new Error('Git repository is not clean. Please commit or stash your changes before proceeding.');
+    }
+
+    const state = await loadState();
+
+    let actualFromRoute = fromRoute;
+    let actualFromFeature = fromFeature;
+    let actualToRoute = toRoute;
+    let actualToFeature = toFeature;
+
+    // Shift arguments if using state
+    if (!toRoute && fromRoute && fromFeature) {
+        // textor move-section /old-route /new-route
+        const section = findSection(state, fromRoute);
+        if (section) {
+            actualFromRoute = section.route;
+            actualFromFeature = section.featurePath;
+            actualToRoute = fromFeature; // the second argument was actually the new route
+            actualToFeature = toRoute; // which is null
+            
+            // If toFeature is not provided, try to derive it from the new route
+            if (!actualToFeature && actualToRoute) {
+                const oldRouteParts = actualFromRoute.split('/').filter(Boolean);
+                const newRouteParts = actualToRoute.split('/').filter(Boolean);
+                const oldFeatureParts = actualFromFeature.split('/').filter(Boolean);
+                
+                // If the feature path starts with the old route parts, replace them
+                // We compare case-insensitively or via PascalCase to be more helpful
+                let match = true;
+                for (let i = 0; i < oldRouteParts.length; i++) {
+                    const routePart = oldRouteParts[i].toLowerCase();
+                    const featurePart = oldFeatureParts[i] ? oldFeatureParts[i].toLowerCase() : null;
+                    
+                    if (featurePart !== routePart) {
+                        match = false;
+                        break;
+                    }
+                }
+                
+                if (match && oldRouteParts.length > 0) {
+                    actualToFeature = [...newRouteParts, ...oldFeatureParts.slice(oldRouteParts.length)].join('/');
+                } else {
+                    // Otherwise just keep it the same
+                    actualToFeature = actualFromFeature;
+                }
+            }
+        }
+    }
+
+    const isRouteOnly = options.keepFeature || (!actualToFeature && actualToRoute && !actualFromFeature);
+    
+    if (isRouteOnly && !actualToRoute) {
+      throw new Error('Destination route required for route-only move');
+    }
+    
+    const normalizedFromRoute = normalizeRoute(actualFromRoute);
+    const normalizedToRoute = normalizeRoute(actualToRoute);
+    const normalizedFromFeature = actualFromFeature ? featureToDirectoryPath(actualFromFeature) : null;
+    const normalizedToFeature = actualToFeature ? featureToDirectoryPath(actualToFeature) : null;
+    
+    const pagesRoot = resolvePath(config, 'pages');
+    const featuresRoot = resolvePath(config, 'features');
+    
+    const fromSection = findSection(state, actualFromRoute);
+    const routeExtension = (fromSection && fromSection.extension) || config.naming.routeExtension;
+    
+    const fromRouteFile = routeToFilePath(normalizedFromRoute, {
+      extension: routeExtension,
+      mode: config.routing.mode,
+      indexFile: config.routing.indexFile
+    });
+    const toRouteFile = routeToFilePath(normalizedToRoute, {
+      extension: routeExtension,
+      mode: config.routing.mode,
+      indexFile: config.routing.indexFile
+    });
+    
+    const fromRoutePath = secureJoin(pagesRoot, fromRouteFile);
+    const toRoutePath = secureJoin(pagesRoot, toRouteFile);
+    
+    const movedFiles = [];
+    
+    if (options.dryRun) {
+      console.log('Dry run - would move:');
+      console.log(`  Route: ${fromRoutePath} -> ${toRoutePath}`);
+      
+      if (!isRouteOnly && normalizedFromFeature && normalizedToFeature) {
+        const fromFeaturePath = secureJoin(featuresRoot, normalizedFromFeature);
+        const toFeaturePath = secureJoin(featuresRoot, normalizedToFeature);
+        console.log(`  Feature: ${fromFeaturePath} -> ${toFeaturePath}`);
+      }
+      
+      return;
+    }
+    
+    const normalizedFromRouteRelative = path.relative(process.cwd(), fromRoutePath).replace(/\\/g, '/');
+    const routeFileState = state.files[normalizedFromRouteRelative];
+
+    const newRouteHash = await safeMove(fromRoutePath, toRoutePath, {
+      force: options.force,
+      expectedHash: routeFileState?.hash,
+      acceptChanges: options.acceptChanges,
+      owner: normalizedFromRoute,
+      actualOwner: routeFileState?.owner
+    });
+    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);
+
+      // Update component name in JSX
+      if (fromFeatureComponentName !== toFeatureComponentName) {
+        let content = await readFile(toRoutePath, 'utf-8');
+        content = content.replace(
+          new RegExp(`<${fromFeatureComponentName}`, 'g'),
+          `<${toFeatureComponentName}`
+        );
+        content = content.replace(
+          new RegExp(`</${fromFeatureComponentName}`, 'g'),
+          `</${toFeatureComponentName}`
+        );
+        await writeFile(toRoutePath, content, 'utf-8');
+      }
+
+      if (config.importAliases.features) {
+        if (normalizedFromFeature !== targetFeature) {
+          const oldAliasPath = `${config.importAliases.features}/${normalizedFromFeature}`;
+          const newAliasPath = `${config.importAliases.features}/${targetFeature}`;
+          
+          // Replace both the path and the component name if they are different
+          await updateSignature(toRoutePath, 
+            `import ${fromFeatureComponentName} from '${oldAliasPath}/${fromFeatureComponentName}'`, 
+            `import ${toFeatureComponentName} from '${newAliasPath}/${toFeatureComponentName}'`
+          );
+          
+          // Fallback for prefix only replacement
+          await updateSignature(toRoutePath, oldAliasPath, newAliasPath);
+        } else if (fromFeatureComponentName !== toFeatureComponentName) {
+          // Name changed but path didn't
+          const aliasPath = `${config.importAliases.features}/${targetFeature}`;
+          await updateSignature(toRoutePath,
+            `import ${fromFeatureComponentName} from '${aliasPath}/${fromFeatureComponentName}'`,
+            `import ${toFeatureComponentName} from '${aliasPath}/${toFeatureComponentName}'`
+          );
+        }
+      } else {
+        const oldRelativeDir = getRelativeImportPath(fromRoutePath, fromFeatureDirPath);
+        const newRelativeDir = getRelativeImportPath(toRoutePath, toFeatureDirPath);
+        
+        const oldImportPath = `import ${fromFeatureComponentName} from '${oldRelativeDir}/${fromFeatureComponentName}'`;
+        const newImportPath = `import ${toFeatureComponentName} from '${newRelativeDir}/${toFeatureComponentName}'`;
+        
+        if (oldImportPath !== newImportPath) {
+          await updateSignature(toRoutePath, oldImportPath, newImportPath);
+        }
+      }
+    }
+    
+    if (!isRouteOnly && normalizedFromFeature && normalizedToFeature && normalizedFromFeature !== normalizedToFeature) {
+      const fromFeaturePath = secureJoin(featuresRoot, normalizedFromFeature);
+      const toFeaturePath = secureJoin(featuresRoot, normalizedToFeature);
+      
+      const fromFeatureComponentName = getFeatureComponentName(normalizedFromFeature);
+      const toFeatureComponentName = getFeatureComponentName(normalizedToFeature);
+      
+      if (existsSync(fromFeaturePath)) {
+        await moveDirectory(fromFeaturePath, toFeaturePath, state, config, {
+          ...options,
+          fromName: fromFeatureComponentName,
+          toName: toFeatureComponentName,
+          owner: normalizedFromRoute
+        });
+        movedFiles.push({ from: fromFeaturePath, to: toFeaturePath });
+        
+        await cleanupEmptyDirs(path.dirname(fromFeaturePath), featuresRoot);
+      }
+    }
+
+    if (options.scan && (normalizedFromFeature || normalizedToFeature)) {
+      await scanAndReplaceImports(config, state, {
+        fromFeaturePath: normalizedFromFeature,
+        fromComponentName: getFeatureComponentName(normalizedFromFeature)
+      }, {
+        toFeaturePath: normalizedToFeature || normalizedFromFeature,
+        toComponentName: getFeatureComponentName(normalizedToFeature || normalizedFromFeature)
+      }, options);
+    }
+    
+    await cleanupEmptyDirs(path.dirname(fromRoutePath), pagesRoot);
+    
+    console.log('✓ Moved:');
+    movedFiles.forEach(item => {
+      console.log(`  ${item.from}`);
+      console.log(`  -> ${item.to}`);
+    });
+
+    if (movedFiles.length > 0) {
+      const existingSection = fromSection;
+      
+      // Update section data in state
+      state.sections = state.sections.filter(s => s.route !== normalizedFromRoute);
+      state.sections.push({
+        name: existingSection ? existingSection.name : getFeatureComponentName(normalizedToFeature || normalizedFromFeature),
+        route: normalizedToRoute,
+        featurePath: normalizedToFeature || normalizedFromFeature,
+        layout: existingSection ? existingSection.layout : 'Main',
+        extension: routeExtension
+      });
+      
+      await saveState(state);
+    }
+    
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+async function scanAndReplaceImports(config, state, fromInfo, toInfo, options) {
+  const { fromFeaturePath, fromComponentName } = fromInfo;
+  const { toFeaturePath, toComponentName } = toInfo;
+  
+  const allFiles = new Set();
+  const { scanDirectory, calculateHash } = await Promise.resolve().then(function () { return filesystem; });
+  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;
+
+    // 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}'`;
+      const newFullImport = `from '${newAlias}/${toComponentName}'`;
+      
+      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}'`;
+      const newImport = `'${newRelPath}/${toComponentName}'`;
+      
+      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 { calculateHash } = await Promise.resolve().then(function () { return filesystem; });
+           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 createComponentCommand(componentName, options) {
+  try {
+    const config = await loadConfig();
+    const effectiveOptions = getEffectiveOptions(options, config, 'components');
+    
+    const normalizedName = normalizeComponentName(componentName);
+    
+    const componentsRoot = resolvePath(config, 'components');
+    
+    const componentDir = secureJoin(componentsRoot, normalizedName);
+    const subComponentsDir = secureJoin(componentDir, 'sub-components');
+    const testsDir = secureJoin(componentDir, '__tests__');
+    const configDirInside = secureJoin(componentDir, 'config');
+    const constantsDirInside = secureJoin(componentDir, 'constants');
+    const contextDirInside = secureJoin(componentDir, 'context');
+    const hooksDirInside = secureJoin(componentDir, 'hooks');
+    const typesDirInside = secureJoin(componentDir, 'types');
+    const apiDirInside = secureJoin(componentDir, 'api');
+    const servicesDirInside = secureJoin(componentDir, 'services');
+    const schemasDirInside = secureJoin(componentDir, 'schemas');
+    
+    const {
+      framework,
+      createContext: shouldCreateContext,
+      createHook: shouldCreateHook,
+      createTests: shouldCreateTests,
+      createConfig: shouldCreateConfig,
+      createConstants: shouldCreateConstants,
+      createTypes: shouldCreateTypes,
+      createSubComponentsDir: shouldCreateSubComponentsDir,
+      createApi: shouldCreateApi,
+      createServices: shouldCreateServices,
+      createSchemas: shouldCreateSchemas,
+      createReadme: shouldCreateReadme,
+      createStories: shouldCreateStories
+    } = effectiveOptions;
+    
+    const componentFilePath = path.join(componentDir, `${normalizedName}${config.naming.componentExtension}`);
+    const indexFilePath = path.join(componentDir, 'index.ts');
+    const contextFilePath = path.join(contextDirInside, `${normalizedName}Context.tsx`);
+    const hookFilePath = path.join(hooksDirInside, getHookFileName(normalizedName, config.naming.hookExtension));
+    const testFilePath = path.join(testsDir, `${normalizedName}${config.naming.testExtension}`);
+    const configFilePath = path.join(configDirInside, 'index.ts');
+    const constantsFilePath = path.join(constantsDirInside, 'index.ts');
+    const typesFilePath = path.join(typesDirInside, 'index.ts');
+    const apiFilePath = path.join(apiDirInside, 'index.ts');
+    const servicesFilePath = path.join(servicesDirInside, 'index.ts');
+    const schemasFilePath = path.join(schemasDirInside, 'index.ts');
+    const readmeFilePath = path.join(componentDir, 'README.md');
+    const storiesFilePath = path.join(componentDir, `${normalizedName}.stories.tsx`);
+    
+    if (options.dryRun) {
+      console.log('Dry run - would create:');
+      console.log(`  Component: ${componentFilePath}`);
+      console.log(`  Index: ${indexFilePath}`);
+      
+      if (shouldCreateContext) console.log(`  Context: ${contextFilePath}`);
+      if (shouldCreateHook) console.log(`  Hook: ${hookFilePath}`);
+      if (shouldCreateTests) console.log(`  Tests: ${testFilePath}`);
+      if (shouldCreateConfig) console.log(`  Config: ${configFilePath}`);
+      if (shouldCreateConstants) console.log(`  Constants: ${constantsFilePath}`);
+      if (shouldCreateTypes) console.log(`  Types: ${typesFilePath}`);
+      if (shouldCreateApi) console.log(`  Api: ${apiFilePath}`);
+      if (shouldCreateServices) console.log(`  Services: ${servicesFilePath}`);
+      if (shouldCreateSchemas) console.log(`  Schemas: ${schemasFilePath}`);
+      if (shouldCreateReadme) console.log(`  Readme: ${readmeFilePath}`);
+      if (shouldCreateStories) console.log(`  Stories: ${storiesFilePath}`);
+      if (shouldCreateSubComponentsDir) console.log(`  Sub-components: ${subComponentsDir}/`);
+      
+      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);
+    
+    await ensureDir(componentDir);
+    
+    if (shouldCreateSubComponentsDir) await ensureDir(subComponentsDir);
+    if (shouldCreateContext) await ensureDir(contextDirInside);
+    if (shouldCreateHook) await ensureDir(hooksDirInside);
+    if (shouldCreateTests) await ensureDir(testsDir);
+    if (shouldCreateConfig) await ensureDir(configDirInside);
+    if (shouldCreateConstants) await ensureDir(constantsDirInside);
+    if (shouldCreateTypes) await ensureDir(typesDirInside);
+    if (shouldCreateApi) await ensureDir(apiDirInside);
+    if (shouldCreateServices) await ensureDir(servicesDirInside);
+    if (shouldCreateSchemas) await ensureDir(schemasDirInside);
+    
+    const componentContent = generateComponentTemplate(normalizedName, framework);
+    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 = [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 (shouldCreateTypes) {
+      const typesContent = generateTypesTemplate(normalizedName);
+      const hash = await writeFileWithSignature(
+        typesFilePath,
+        typesContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(typesFilePath, { 
+        kind: 'component-file', 
+        template: 'types', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(typesFilePath);
+    }
+    
+    if (shouldCreateContext) {
+      const contextContent = generateContextTemplate(normalizedName);
+      const hash = await writeFileWithSignature(
+        contextFilePath,
+        contextContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(contextFilePath, { 
+        kind: 'component-file', 
+        template: 'context', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(contextFilePath);
+    }
+    
+    if (shouldCreateHook) {
+      const hookName = getHookFunctionName(normalizedName);
+      const hookContent = generateHookTemplate(normalizedName, hookName);
+      const hash = await writeFileWithSignature(
+        hookFilePath,
+        hookContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(hookFilePath, { 
+        kind: 'component-file', 
+        template: 'hook', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(hookFilePath);
+    }
+    
+    if (shouldCreateTests) {
+      const relativeComponentPath = `../${normalizedName}${config.naming.componentExtension}`;
+      const testContent = generateTestTemplate(normalizedName, relativeComponentPath);
+      const hash = await writeFileWithSignature(
+        testFilePath,
+        testContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(testFilePath, { 
+        kind: 'component-file', 
+        template: 'test', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(testFilePath);
+    }
+    
+    if (shouldCreateConfig) {
+      const configContent = generateConfigTemplate(normalizedName);
+      const hash = await writeFileWithSignature(
+        configFilePath,
+        configContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(configFilePath, { 
+        kind: 'component-file', 
+        template: 'config', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(configFilePath);
+    }
+    
+    if (shouldCreateConstants) {
+      const constantsContent = generateConstantsTemplate(normalizedName);
+      const hash = await writeFileWithSignature(
+        constantsFilePath,
+        constantsContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(constantsFilePath, { 
+        kind: 'component-file', 
+        template: 'constants', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(constantsFilePath);
+    }
+
+    if (shouldCreateApi) {
+      const apiContent = generateApiTemplate(normalizedName);
+      const hash = await writeFileWithSignature(
+        apiFilePath,
+        apiContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(apiFilePath, { 
+        kind: 'component-file', 
+        template: 'api', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(apiFilePath);
+    }
+
+    if (shouldCreateServices) {
+      const servicesContent = generateServiceTemplate(normalizedName);
+      const hash = await writeFileWithSignature(
+        servicesFilePath,
+        servicesContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(servicesFilePath, { 
+        kind: 'component-file', 
+        template: 'service', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(servicesFilePath);
+    }
+
+    if (shouldCreateSchemas) {
+      const schemasContent = generateSchemaTemplate(normalizedName);
+      const hash = await writeFileWithSignature(
+        schemasFilePath,
+        schemasContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(schemasFilePath, { 
+        kind: 'component-file', 
+        template: 'schema', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(schemasFilePath);
+    }
+
+    if (shouldCreateReadme) {
+      const readmeContent = generateReadmeTemplate(normalizedName);
+      const hash = await writeFileWithSignature(
+        readmeFilePath,
+        readmeContent,
+        getSignature(config, 'astro'),
+        config.hashing?.normalization
+      );
+      await registerFile(readmeFilePath, { 
+        kind: 'component-file', 
+        template: 'readme', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(readmeFilePath);
+    }
+
+    if (shouldCreateStories) {
+      const relativePath = `./${normalizedName}${config.naming.componentExtension}`;
+      const storiesContent = generateStoriesTemplate(normalizedName, relativePath);
+      const hash = await writeFileWithSignature(
+        storiesFilePath,
+        storiesContent,
+        getSignature(config, 'typescript'),
+        config.hashing?.normalization
+      );
+      await registerFile(storiesFilePath, { 
+        kind: 'component-file', 
+        template: 'stories', 
+        hash,
+        owner: normalizedName 
+      });
+      writtenFiles.push(storiesFilePath);
+    }
+    
+    // Formatting
+    if (config.formatting.tool !== 'none') {
+        await formatFiles(writtenFiles, config.formatting.tool);
+    }
+    
+    console.log('✓ Component created successfully:');
+    console.log(`  Component: ${componentFilePath}`);
+    console.log(`  Index: ${indexFilePath}`);
+    
+    if (shouldCreateContext) console.log(`  Context: ${contextFilePath}`);
+    if (shouldCreateHook) console.log(`  Hook: ${hookFilePath}`);
+    if (shouldCreateTests) console.log(`  Tests: ${testFilePath}`);
+    if (shouldCreateConfig) console.log(`  Config: ${configFilePath}`);
+    if (shouldCreateConstants) console.log(`  Constants: ${constantsFilePath}`);
+    if (shouldCreateTypes) console.log(`  Types: ${typesFilePath}`);
+    if (shouldCreateApi) console.log(`  Api: ${apiFilePath}`);
+    if (shouldCreateServices) console.log(`  Services: ${servicesFilePath}`);
+    if (shouldCreateSchemas) console.log(`  Schemas: ${schemasFilePath}`);
+    if (shouldCreateReadme) console.log(`  Readme: ${readmeFilePath}`);
+    if (shouldCreateStories) console.log(`  Stories: ${storiesFilePath}`);
+    if (shouldCreateSubComponentsDir) console.log(`  Sub-components: ${subComponentsDir}/`);
+    
+    await addComponentToState({
+      name: normalizedName,
+      path: componentDir
+    });
+
+    if (config.git?.stageChanges) {
+      await stageFiles(writtenFiles);
+    }
+    
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+async function removeComponentCommand(identifier, options) {
+  try {
+    const config = await loadConfig();
+
+    if (config.git?.requireCleanRepo && !await isRepoClean()) {
+      throw new Error('Git repository is not clean. Please commit or stash your changes before proceeding.');
+    }
+
+    const state = await loadState();
+    
+    const component = findComponent(state, identifier);
+    let componentDir;
+
+    if (component) {
+        componentDir = component.path;
+    } else {
+        // Fallback: try to guess path if not in state
+        const componentsRoot = path.resolve(process.cwd(), config.paths.components);
+        componentDir = secureJoin(componentsRoot, identifier);
+    }
+    
+    if (options.dryRun) {
+      console.log('Dry run - would delete:');
+      console.log(`  Component directory: ${componentDir}/`);
+      return;
+    }
+    
+    const result = await safeDeleteDir(componentDir, {
+      force: options.force,
+      stateFiles: state.files,
+      acceptChanges: options.acceptChanges,
+      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));
+      
+      // Unregister files
+      const dirPrefix = path.relative(process.cwd(), componentDir).replace(/\\/g, '/') + '/';
+      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);
+      await saveState(state);
+    } else if (result.message) {
+      console.log(`⚠ Skipped: ${componentDir}`);
+      console.log(`    Reason: ${result.message}`);
+    } else {
+      console.log(`Component not found at ${componentDir}`);
+    }
+    
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+async function listSectionsCommand() {
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+    const pagesRoot = resolvePath(config, 'pages');
+    
+    console.log('Managed Sections:');
+    
+    if (!existsSync(pagesRoot)) {
+      console.log('  No pages directory found.');
+    } else {
+      const extensions = [config.naming.routeExtension, '.ts', '.js'];
+      const sections = await findGeneratedFiles(pagesRoot, extensions);
+      
+      if (sections.length === 0) {
+        console.log('  No Textor-managed sections found.');
+      } else {
+        for (const section of sections) {
+          const relativePath = path.relative(pagesRoot, section).replace(/\\/g, '/');
+          const route = '/' + relativePath
+            .replace(/\.[^/.]+$/, ''); // Remove extension
+          
+          const stateSection = state.sections.find(s => s.route === route);
+          const name = stateSection ? stateSection.name : route;
+          
+          console.log(`  - ${name} [${route}] (${relativePath})`);
+          
+          if (stateSection) {
+              console.log(`    Feature: ${stateSection.featurePath}`);
+              console.log(`    Layout: ${stateSection.layout}`);
+              
+              // Check for senior architecture folders/files
+              const featuresRoot = resolvePath(config, 'features');
+              const featureDir = path.join(featuresRoot, stateSection.featurePath);
+              const capabilities = [];
+              
+              const checkDir = (subDir, label) => {
+                  if (existsSync(path.join(featureDir, subDir))) capabilities.push(label);
+              };
+              
+              checkDir('api', 'API');
+              checkDir('services', 'Services');
+              checkDir('schemas', 'Schemas');
+              checkDir('hooks', 'Hooks');
+              checkDir('context', 'Context');
+              checkDir('types', 'Types');
+              checkDir('scripts', 'Scripts');
+              checkDir('sub-components', 'Sub-components');
+              checkDir('__tests__', 'Tests');
+              
+              if (existsSync(path.join(featureDir, 'README.md'))) capabilities.push('Docs');
+              
+              const storiesFile = (await readdir(featureDir).catch(() => []))
+                  .find(f => f.endsWith('.stories.tsx') || f.endsWith('.stories.jsx'));
+              if (storiesFile) capabilities.push('Stories');
+
+              if (capabilities.length > 0) {
+                  console.log(`    Architecture: ${capabilities.join(', ')}`);
+              }
+          } else {
+            // Try to extract feature path from the file content
+            const content = await readFile(section, 'utf-8');
+            const featureImportMatch = content.match(/import\s+\w+\s+from\s+'([^']+)'/g);
+            if (featureImportMatch) {
+              for (const match of featureImportMatch) {
+                const pathMatch = match.match(/'([^']+)'/);
+                if (pathMatch) {
+                  console.log(`    Import: ${pathMatch[1]}`);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (state.components && state.components.length > 0) {
+      console.log('\nManaged Components:');
+      for (const component of state.components) {
+        console.log(`  - ${component.name} (${path.relative(process.cwd(), component.path)})`);
+        
+        const componentDir = component.path;
+        const capabilities = [];
+        
+        const checkDir = (subDir, label) => {
+            if (existsSync(path.join(componentDir, subDir))) capabilities.push(label);
+        };
+        
+        checkDir('api', 'API');
+        checkDir('services', 'Services');
+        checkDir('schemas', 'Schemas');
+        checkDir('hooks', 'Hooks');
+        checkDir('context', 'Context');
+        checkDir('types', 'Types');
+        checkDir('sub-components', 'Sub-components');
+        checkDir('__tests__', 'Tests');
+        checkDir('config', 'Config');
+        checkDir('constants', 'Constants');
+        
+        if (existsSync(path.join(componentDir, 'README.md'))) capabilities.push('Docs');
+        
+        const storiesFile = (await readdir(componentDir).catch(() => []))
+            .find(f => f.endsWith('.stories.tsx') || f.endsWith('.stories.jsx'));
+        if (storiesFile) capabilities.push('Stories');
+
+        if (capabilities.length > 0) {
+            console.log(`    Architecture: ${capabilities.join(', ')}`);
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+async function findGeneratedFiles(dir, extensions) {
+  const results = [];
+  const entries = await readdir(dir);
+  const exts = Array.isArray(extensions) ? extensions : [extensions];
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry);
+    const stats = await stat(fullPath);
+
+    if (stats.isDirectory()) {
+      results.push(...await findGeneratedFiles(fullPath, exts));
+    } else if (exts.some(ext => entry.endsWith(ext))) {
+      if (await isTextorGenerated(fullPath)) {
+        results.push(fullPath);
+      }
+    }
+  }
+
+  return results;
+}
+
+async function validateStateCommand(options) {
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+    const results = {
+      missing: [],
+      modified: [],
+      valid: 0
+    };
+
+    const files = Object.keys(state.files);
+    
+    for (const relativePath of files) {
+      const fullPath = path.join(process.cwd(), relativePath);
+      const fileData = state.files[relativePath];
+      
+      if (!existsSync(fullPath)) {
+        results.missing.push(relativePath);
+        continue;
+      }
+      
+      const content = await readFile(fullPath, 'utf-8');
+      const currentHash = calculateHash(content, config.hashing?.normalization);
+      
+      if (currentHash !== fileData.hash) {
+        results.modified.push({
+          path: relativePath,
+          newHash: currentHash
+        });
+      } else {
+        results.valid++;
+      }
+    }
+
+    console.log('State Validation Results:');
+    console.log(`  Valid files: ${results.valid}`);
+    
+    if (results.missing.length > 0) {
+      console.log(`\n  Missing files: ${results.missing.length}`);
+      results.missing.forEach(f => console.log(`    - ${f}`));
+    }
+    
+    if (results.modified.length > 0) {
+      console.log(`\n  Modified files: ${results.modified.length}`);
+      results.modified.forEach(f => console.log(`    - ${f.path}`));
+    }
+    
+    if (options.fix) {
+      let fixedCount = 0;
+      
+      // Fix modified files if they still have the Textor signature
+      for (const mod of results.modified) {
+        const fullPath = path.join(process.cwd(), mod.path);
+        if (await isTextorGenerated(fullPath)) {
+          state.files[mod.path].hash = mod.newHash;
+          fixedCount++;
+        }
+      }
+      
+      // Remove missing files from state
+      for (const miss of results.missing) {
+        delete state.files[miss];
+        fixedCount++;
+      }
+      
+      if (fixedCount > 0) {
+        await saveState(state);
+        console.log(`\n✓ Fixed ${fixedCount} entries in state.`);
+      } else {
+        console.log('\nNothing to fix or missing signatures on modified files.');
+      }
+    } else if (results.missing.length > 0 || results.modified.length > 0) {
+      console.log('\nRun with --fix to synchronize state with reality (requires Textor signature to be present).');
+    } else {
+      console.log('\n✓ State is perfectly in sync.');
+    }
+
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+async function statusCommand() {
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+    
+    const results = {
+      missing: [],
+      modified: [],
+      untracked: [], // Has signature, not in state
+      orphaned: [],  // No signature, not in state
+      synced: 0
+    };
+
+    const roots = [
+      resolvePath(config, 'pages'),
+      resolvePath(config, 'features'),
+      resolvePath(config, 'components')
+    ].map(p => path.resolve(p));
+
+    const diskFiles = new Set();
+    const configSignatures = Object.values(config.signatures || {});
+
+    for (const root of roots) {
+      if (existsSync(root)) {
+        await scanDirectory(root, diskFiles);
+      }
+    }
+
+    // 1. Check state files against disk
+    for (const relativePath in state.files) {
+      const fullPath = path.join(process.cwd(), relativePath);
+      
+      if (!existsSync(fullPath)) {
+        results.missing.push(relativePath);
+        continue;
+      }
+
+      diskFiles.delete(relativePath);
+
+      const content = await readFile(fullPath, 'utf-8');
+      const currentHash = calculateHash(content, config.hashing?.normalization);
+      const fileData = state.files[relativePath];
+
+      if (currentHash !== fileData.hash) {
+        results.modified.push(relativePath);
+      } else {
+        results.synced++;
+      }
+    }
+
+    // 2. Check remaining disk files
+    for (const relativePath of diskFiles) {
+      const fullPath = path.join(process.cwd(), relativePath);
+      const isGenerated = await isTextorGenerated(fullPath, configSignatures);
+      
+      if (isGenerated) {
+        results.untracked.push(relativePath);
+      } else {
+        results.orphaned.push(relativePath);
+      }
+    }
+
+    // Reporting
+    console.log('Textor Status Report:');
+    console.log(`  Synced files: ${results.synced}`);
+    
+    if (results.modified.length > 0) {
+      console.log(`\n  MODIFIED (In state, but content changed): ${results.modified.length}`);
+      results.modified.forEach(f => console.log(`    ~ ${f}`));
+    }
+    
+    if (results.missing.length > 0) {
+      console.log(`\n  MISSING (In state, but not on disk): ${results.missing.length}`);
+      results.missing.forEach(f => console.log(`    - ${f}`));
+    }
+
+    if (results.untracked.length > 0) {
+      console.log(`\n  UNTRACKED (On disk with signature, not in state): ${results.untracked.length}`);
+      results.untracked.forEach(f => console.log(`    + ${f}`));
+    }
+
+    if (results.orphaned.length > 0) {
+      console.log(`\n  ORPHANED (On disk without signature, in managed folder): ${results.orphaned.length}`);
+      results.orphaned.forEach(f => console.log(`    ? ${f}`));
+    }
+
+    if (results.modified.length === 0 && results.missing.length === 0 && results.untracked.length === 0) {
+      console.log('\n✓ Project is perfectly synchronized with state.');
+    } else {
+      console.log('\nUse "textor sync" to reconcile state with disk.');
+    }
+
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+async function syncCommand(options) {
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+    const results = {
+      added: [],
+      updated: [],
+      missing: [],
+      untouched: 0
+    };
+
+    const roots = [
+      resolvePath(config, 'pages'),
+      resolvePath(config, 'features'),
+      resolvePath(config, 'components')
+    ].map(p => path.resolve(p));
+
+    const managedFiles = new Set();
+    const configSignatures = Object.values(config.signatures || {});
+
+    for (const root of roots) {
+      if (existsSync(root)) {
+        await scanDirectory(root, managedFiles);
+      } else {
+        const relativeRoot = path.relative(process.cwd(), root).replace(/\\/g, '/');
+        console.log(`  Warning: Managed directory not found: ${relativeRoot}`);
+      }
+    }
+
+    const stateFiles = Object.keys(state.files);
+    let changed = false;
+    
+    // 1. Check files in state
+    for (const relativePath of stateFiles) {
+      const fullPath = path.join(process.cwd(), relativePath);
+      
+      if (!existsSync(fullPath)) {
+        results.missing.push(relativePath);
+        continue;
+      }
+
+      managedFiles.delete(relativePath); // Remove from managedFiles so we don't process it again in step 2
+
+      const content = await readFile(fullPath, 'utf-8');
+      const currentHash = calculateHash(content, config.hashing?.normalization);
+      const fileData = state.files[relativePath];
+
+      if (currentHash !== fileData.hash) {
+        const isGenerated = await isTextorGenerated(fullPath, configSignatures);
+        if (isGenerated || options.force) {
+          results.updated.push({ path: relativePath, newHash: currentHash });
+        }
+      } else {
+        results.untouched++;
+      }
+    }
+
+    // 2. Check files on disk not in state
+    let ignoredCount = 0;
+    for (const relativePath of managedFiles) {
+      const fullPath = path.join(process.cwd(), relativePath);
+      const isGenerated = await isTextorGenerated(fullPath, configSignatures);
+      
+      if (isGenerated || options.includeAll) {
+        const content = await readFile(fullPath, 'utf-8');
+        const hash = calculateHash(content, config.hashing?.normalization);
+        results.added.push({ path: relativePath, hash });
+      } else {
+        ignoredCount++;
+      }
+    }
+
+    if (results.added.length > 0 || results.updated.length > 0 || results.missing.length > 0) {
+      changed = true;
+    }
+
+    // Reporting
+    console.log('Sync Analysis:');
+    console.log(`  Untouched files: ${results.untouched}`);
+    
+    if (ignoredCount > 0 && !options.includeAll) {
+      console.log(`  Ignored non-generated files: ${ignoredCount} (use --include-all to track them)`);
+    }
+    
+    if (results.added.length > 0) {
+      console.log(`\n  New files to track: ${results.added.length}`);
+      results.added.forEach(f => console.log(`    + ${f.path}`));
+    }
+    
+    if (results.updated.length > 0) {
+      console.log(`\n  Modified files to update: ${results.updated.length}`);
+      results.updated.forEach(f => console.log(`    ~ ${f.path}`));
+    }
+    
+    if (results.missing.length > 0) {
+      console.log(`\n  Missing files to remove from state: ${results.missing.length}`);
+      results.missing.forEach(f => console.log(`    - ${f}`));
+    }
+
+    if (options.dryRun) {
+      console.log('\nDry run: no changes applied.');
+      return;
+    }
+
+    if (results.added.length > 0) {
+      for (const file of results.added) {
+        state.files[file.path] = {
+          kind: inferKind(file.path, config),
+          hash: file.hash,
+          timestamp: new Date().toISOString(),
+          synced: true
+        };
+      }
+    }
+
+    if (results.updated.length > 0) {
+      for (const file of results.updated) {
+        state.files[file.path].hash = file.newHash;
+        state.files[file.path].timestamp = new Date().toISOString();
+        state.files[file.path].synced = true;
+      }
+    }
+
+    if (results.missing.length > 0) {
+      for (const relPath of results.missing) {
+        delete state.files[relPath];
+      }
+    }
+
+    if (changed) {
+      // 3. Reconstruct components and sections
+      state.components = reconstructComponents(state.files, config);
+      state.sections = reconstructSections(state, config);
+
+      await saveState(state);
+      console.log(`\n✓ State synchronized successfully (${results.added.length} added, ${results.updated.length} updated, ${results.missing.length} removed).`);
+    } else {
+      // Even if no files changed, check if metadata needs reconstruction
+      const newComponents = reconstructComponents(state.files, config);
+      const newSections = reconstructSections(state, config);
+      
+      const componentsEqual = JSON.stringify(newComponents) === JSON.stringify(state.components || []);
+      const sectionsEqual = JSON.stringify(newSections) === JSON.stringify(state.sections || []);
+
+      if (!componentsEqual || !sectionsEqual) {
+        state.components = newComponents;
+        state.sections = newSections;
+        await saveState(state);
+        console.log('\n✓ Metadata (components/sections) reconstructed.');
+      } else {
+        console.log('\n✓ Everything is already in sync.');
+      }
+    }
+
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+        process.exit(1);
+    }
+    throw error;
+  }
+}
+
+async function adoptCommand(identifier, options) {
+  try {
+    const config = await loadConfig();
+    const state = await loadState();
+
+    const roots = {
+      pages: resolvePath(config, 'pages'),
+      features: resolvePath(config, 'features'),
+      components: resolvePath(config, 'components')
+    };
+
+    let filesToAdopt = [];
+
+    if (!identifier && options.all) {
+      // Adopt all untracked files in all roots
+      const managedFiles = new Set();
+      for (const root of Object.values(roots)) {
+        if (existsSync(root)) {
+          await scanDirectory(root, managedFiles);
+        }
+      }
+      filesToAdopt = Array.from(managedFiles).filter(f => !state.files[f]);
+    } else if (identifier) {
+      const untrackedFiles = new Set();
+      
+      // 1. Try as direct path
+      const fullPath = path.resolve(process.cwd(), identifier);
+      if (existsSync(fullPath)) {
+        await scanDirectoryOrFile(fullPath, untrackedFiles, state);
+      }
+      
+      // 2. Try as component name
+      const compPath = path.join(roots.components, identifier);
+      if (existsSync(compPath)) {
+        await scanDirectoryOrFile(compPath, untrackedFiles, state);
+      }
+
+      // 3. Try as feature name
+      const featPath = path.join(roots.features, identifier);
+      if (existsSync(featPath)) {
+        await scanDirectoryOrFile(featPath, untrackedFiles, state);
+      }
+      
+      // 4. Try as route or page name
+      const cleanRoute = identifier.startsWith('/') ? identifier.slice(1) : identifier;
+      const pagePath = path.join(roots.pages, cleanRoute + (config.naming?.routeExtension || '.astro'));
+      if (existsSync(pagePath)) {
+        await scanDirectoryOrFile(pagePath, untrackedFiles, state);
+      }
+      const nestedPagePath = path.join(roots.pages, cleanRoute, config.routing?.indexFile || 'index.astro');
+      if (existsSync(nestedPagePath)) {
+        await scanDirectoryOrFile(nestedPagePath, untrackedFiles, state);
+      }
+
+      filesToAdopt = Array.from(untrackedFiles);
+
+      if (filesToAdopt.length === 0 && !existsSync(fullPath)) {
+        throw new Error(`Could not find any untracked files for identifier: ${identifier}`);
+      }
+    } else {
+      throw new Error('Please provide a path/identifier or use --all');
+    }
+
+    // Filter to ensure all files are within managed roots
+    const rootPaths = Object.values(roots).map(p => path.resolve(p));
+    filesToAdopt = filesToAdopt.filter(relPath => {
+      const fullPath = path.resolve(process.cwd(), relPath);
+      return rootPaths.some(root => fullPath.startsWith(root));
+    });
+
+    if (filesToAdopt.length === 0) {
+      console.log('No untracked files found to adopt.');
+      return;
+    }
+
+    console.log(`Found ${filesToAdopt.length} files to adopt...`);
+    let adoptedCount = 0;
+
+    for (const relPath of filesToAdopt) {
+      const success = await adoptFile(relPath, config, state, options);
+      if (success) adoptedCount++;
+    }
+
+    if (adoptedCount > 0 && !options.dryRun) {
+      state.components = reconstructComponents(state.files, config);
+      state.sections = reconstructSections(state, config);
+      await saveState(state);
+      console.log(`\n✓ Successfully adopted ${adoptedCount} files.`);
+    } else if (options.dryRun) {
+      console.log(`\nDry run: would adopt ${adoptedCount} files.`);
+    }
+
+  } catch (error) {
+    console.error('Error:', error.message);
+    if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+async function adoptFile(relPath, config, state, options) {
+  const fullPath = path.join(process.cwd(), relPath);
+  const content = await readFile(fullPath, 'utf-8');
+  
+  const ext = path.extname(relPath);
+  let signature = '';
+  if (ext === '.astro') signature = config.signatures.astro;
+  else if (ext === '.ts' || ext === '.tsx') signature = config.signatures.typescript;
+  else if (ext === '.js' || ext === '.jsx') signature = config.signatures.javascript;
+
+  let finalContent = content;
+
+  if (signature && !content.includes(signature)) {
+    if (options.dryRun) {
+      console.log(`  ~ Would add signature to ${relPath}`);
+    } else {
+      finalContent = signature + '\n' + content;
+      await writeFile(fullPath, finalContent, 'utf-8');
+      console.log(`  + Added signature and adopting: ${relPath}`);
+    }
+  } else {
+    if (options.dryRun) {
+      console.log(`  + Would adopt (already has signature or no signature for ext): ${relPath}`);
+    } else {
+      console.log(`  + Adopting: ${relPath}`);
+    }
+  }
+
+  if (!options.dryRun) {
+    const hash = calculateHash(finalContent, config.hashing?.normalization);
+    state.files[relPath] = {
+      kind: inferKind(relPath, config),
+      hash: hash,
+      timestamp: new Date().toISOString(),
+      synced: true
+    };
+  }
+
+  return true;
+}
+
+async function scanDirectoryOrFile(fullPath, fileSet, state) {
+  if ((await stat(fullPath)).isDirectory()) {
+    const dirFiles = new Set();
+    await scanDirectory(fullPath, dirFiles);
+    for (const f of dirFiles) {
+      if (!state.files[f]) fileSet.add(f);
+    }
+  } else {
+    const relPath = path.relative(process.cwd(), fullPath).replace(/\\/g, '/');
+    if (!state.files[relPath]) {
+      fileSet.add(relPath);
+    }
+  }
+}
+
+const program = new Command();
+
+program
+  .name('textor')
+  .description('Safe, deterministic scaffolding and refactoring tool for Astro projects')
+  .version('1.0.0');
+
+program
+  .command('init')
+  .description('Initialize Textor configuration')
+  .option('--force', 'Overwrite existing configuration')
+  .action(initCommand);
+
+program
+  .command('add-section <route> <featurePath>')
+  .description('Create a route + feature binding')
+  .option('--preset <name>', 'Scaffolding preset (minimal, standard, senior)')
+  .option('--layout <name>', 'Layout component name (use "none" for no layout)', 'Main')
+  .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')
+  .option('--services', 'Create services directory')
+  .option('--schemas', 'Create schemas directory')
+  .option('--hooks', 'Create hooks directory')
+  .option('--context', 'Create context directory')
+  .option('--tests', 'Create tests directory')
+  .option('--types', 'Create types directory')
+  .option('--readme', 'Create README.md')
+  .option('--stories', 'Create Storybook stories')
+  .option('--index', 'Create index.ts')
+  .option('--no-sub-components-dir', 'Skip creating sub-components directory')
+  .option('--no-scripts-dir', 'Skip creating scripts directory')
+  .option('--dry-run', 'Show what would be created without creating')
+  .option('--force', 'Overwrite existing files')
+  .action(addSectionCommand);
+
+program
+  .command('remove-section <route> [featurePath]')
+  .description('Remove a section (featurePath optional if using state)')
+  .option('--keep-feature', 'Keep the feature module')
+  .option('--keep-route', 'Keep the route file')
+  .option('--accept-changes', 'Allow removal of modified files')
+  .option('--dry-run', 'Show what would be deleted without deleting')
+  .option('--force', 'Delete files even if not generated by Textor')
+  .action(removeSectionCommand);
+
+program
+  .command('move-section')
+  .description('Move a section')
+  .argument('<fromRoute>', 'Source route or section name')
+  .argument('<fromFeatureOrToRoute>', 'Source feature path OR Destination route (if using state)')
+  .argument('[toRoute]', 'Destination route')
+  .argument('[toFeature]', 'Destination feature path')
+  .option('--keep-feature', 'Only move route, not feature')
+  .option('--accept-changes', 'Allow moving of modified files')
+  .option('--scan', 'Enable repo-wide import updates')
+  .option('--force', 'Overwrite existing files')
+  .option('--dry-run', 'Show what would be moved without moving')
+  .action(moveSectionCommand);
+
+program
+  .command('create-component <componentName>')
+  .description('Create a reusable UI component')
+  .option('--preset <name>', 'Scaffolding preset (minimal, standard, senior)')
+  .option('--api', 'Create api directory')
+  .option('--services', 'Create services directory')
+  .option('--schemas', 'Create schemas directory')
+  .option('--readme', 'Create README.md')
+  .option('--stories', 'Create Storybook stories')
+  .option('--no-context', 'Skip creating context file')
+  .option('--no-hook', 'Skip creating hook file')
+  .option('--no-tests', 'Skip creating test file')
+  .option('--no-types', 'Skip creating types file')
+  .option('--no-config', 'Skip creating config file')
+  .option('--no-constants', 'Skip creating constants file')
+  .option('--no-sub-components-dir', 'Skip creating sub-components directory')
+  .option('--dry-run', 'Show what would be created without creating')
+  .option('--force', 'Overwrite existing files')
+  .action(createComponentCommand);
+
+program
+  .command('remove-component <name>')
+  .description('Remove a reusable UI component')
+  .option('--accept-changes', 'Allow removal of modified files')
+  .option('--dry-run', 'Show what would be deleted without deleting')
+  .option('--force', 'Delete files even if not generated by Textor')
+  .action(removeComponentCommand);
+
+program
+  .command('list-sections')
+  .description('List all Textor-managed sections')
+  .action(listSectionsCommand);
+
+program
+  .command('status')
+  .description('Show drift between state and disk')
+  .action(statusCommand);
+
+program
+  .command('validate-state')
+  .description('Validate that the state file matches the project files')
+  .option('--fix', 'Try to fix state by re-hashing modified files (requires signatures to match)')
+  .action(validateStateCommand);
+
+program
+  .command('sync')
+  .description('Synchronize the state with the actual files in managed directories')
+  .option('--include-all', 'Include all files in managed directories, even without Textor signature')
+  .option('--force', 'Update hashes for modified files even without Textor signature')
+  .option('--dry-run', 'Show what would be changed without applying')
+  .action(syncCommand);
+
+program
+  .command('adopt [path]')
+  .description('Adopt untracked files into Textor state, adding signatures')
+  .option('--all', 'Adopt all untracked files in managed directories')
+  .option('--dry-run', 'Show what would be adopted without applying')
+  .action(adoptCommand);
+
+program.parse();
+//# sourceMappingURL=textor.js.map