@oamm/textor 1.0.0

package/dist/index.cjs

@@ -0,0 +1,3202 @@
+'use strict';
+
+var promises = require('fs/promises');
+var fs = require('fs');
+var path = require('path');
+var crypto = require('crypto');
+var child_process = require('child_process');
+var util = require('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 (!fs.existsSync(configPath)) {
+        throw new Error(`Textor configuration not found at ${configPath}\n` +
+            `Run 'textor init' to create it.`);
+    }
+    try {
+        const content = await promises.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 (fs.existsSync(configPath) && !force) {
+        throw new Error(`Configuration already exists at ${configPath}\n` +
+            `Use --force to overwrite.`);
+    }
+    validateConfig(config);
+    const configDir = getConfigDir();
+    if (!fs.existsSync(configDir)) {
+        await promises.mkdir(configDir, { recursive: true });
+    }
+    await promises.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 = util.promisify(child_process.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 crypto.createHash('sha256').update(normalizedContent).digest('hex');
+}
+async function isTextorGenerated(filePath, customSignatures = []) {
+    if (!fs.existsSync(filePath)) {
+        return false;
+    }
+    try {
+        const content = await promises.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 promises.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 (!fs.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 promises.unlink(filePath);
+    return { deleted: true };
+}
+async function ensureNotExists(filePath, force = false) {
+    if (fs.existsSync(filePath)) {
+        if (!force) {
+            throw new Error(`File already exists: ${filePath}\n` +
+                `Use --force to overwrite.`);
+        }
+    }
+}
+async function ensureDir(dirPath) {
+    await promises.mkdir(dirPath, { recursive: true });
+}
+async function isSafeToDeleteDir(dirPath, stateFiles = {}, options = {}) {
+    try {
+        const files = await promises.readdir(dirPath);
+        const results = await Promise.all(files.map(async (file) => {
+            const filePath = path.join(dirPath, file);
+            const stats = await promises.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 (!fs.existsSync(dirPath)) {
+        return { deleted: false, reason: 'not-found' };
+    }
+    const isSafe = force || await isSafeToDeleteDir(dirPath, stateFiles, options);
+    if (isSafe) {
+        await promises.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 promises.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 (!fs.existsSync(filePath)) {
+        return;
+    }
+    let content = await promises.readFile(filePath, 'utf-8');
+    content = content.replace(new RegExp(oldPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), newPath);
+    await promises.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 (!fs.existsSync(fromPath)) {
+        throw new Error(`Source file not found: ${fromPath}`);
+    }
+    if (fs.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 promises.rename(fromPath, toPath);
+    await updateSignature(toPath, fromPath, toPath);
+    // Return new hash because updateSignature might have changed it
+    const content = await promises.readFile(toPath, 'utf-8');
+    return calculateHash(content, normalization);
+}
+async function isEmptyDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        return true;
+    }
+    const files = await promises.readdir(dirPath);
+    return files.length === 0;
+}
+async function scanDirectory(dir, fileSet) {
+    const files = await promises.readdir(dir);
+    for (const file of files) {
+        const fullPath = path.join(dir, file);
+        const stats = await promises.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 promises.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 (fs.existsSync(overridePath)) {
+        let content = fs.readFileSync(overridePath, 'utf-8');
+        for (const [key, value] of Object.entries(data)) {
+            content = content.replace(new RegExp(`{{${key}}}`, 'g'), () => value || '');
+        }
+        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 (!fs.existsSync(statePath)) {
+        return { sections: [], components: [], files: {} };
+    }
+    try {
+        const content = await promises.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 (!fs.existsSync(dir)) {
+            await promises.mkdir(dir, { recursive: true });
+        }
+        const tempPath = statePath + '.' + Math.random().toString(36).slice(2) + '.tmp';
+        const content = JSON.stringify(state, null, 2);
+        const handle = await promises.open(tempPath, 'w');
+        await handle.writeFile(content, 'utf-8');
+        await handle.sync();
+        await handle.close();
+        await promises.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 = util.promisify(child_process.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 (fs.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 (fs.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 (!fs.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 promises.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 (!fs.existsSync(filePath))
+        return;
+    let content = await promises.readFile(filePath, 'utf-8');
+    const oldDir = path.dirname(oldFilePath);
+    const newDir = path.dirname(newFilePath);
+    if (oldDir === newDir)
+        return;
+    // Find all relative imports
+    const relativeImportRegex = /from\s+['"](\.\.?\/[^'"]+)['"]/g;
+    let match;
+    const replacements = [];
+    while ((match = relativeImportRegex.exec(content)) !== null) {
+        const relativePath = match[1];
+        const absoluteTarget = path.resolve(oldDir, relativePath);
+        const newRelativePath = getRelativeImportPath(newFilePath, absoluteTarget);
+        replacements.push({
+            full: match[0],
+            oldRel: relativePath,
+            newRel: newRelativePath
+        });
+    }
+    for (const repl of replacements) {
+        content = content.replace(repl.full, `from '${repl.newRel}'`);
+    }
+    await promises.writeFile(filePath, content, 'utf-8');
+}
+
+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 promises.readFile(toRoutePath, 'utf-8');
+                content = content.replace(new RegExp(`<${fromFeatureComponentName}`, 'g'), `<${toFeatureComponentName}`);
+                content = content.replace(new RegExp(`</${fromFeatureComponentName}`, 'g'), `</${toFeatureComponentName}`);
+                await promises.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 (fs.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 promises.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 promises.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 (!fs.existsSync(fromPath)) {
+        throw new Error(`Source directory not found: ${fromPath}`);
+    }
+    if (fs.existsSync(toPath) && !options.force) {
+        throw new Error(`Destination already exists: ${toPath}\n` +
+            `Use --force to overwrite.`);
+    }
+    await ensureDir(toPath);
+    const entries = await promises.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 promises.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 promises.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 promises.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 promises.readdir(fromPath);
+    if (remainingFiles.length === 0) {
+        await promises.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 (!fs.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 (fs.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 (fs.existsSync(path.join(featureDir, 'README.md')))
+                            capabilities.push('Docs');
+                        const storiesFile = (await promises.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 promises.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 (fs.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 (fs.existsSync(path.join(componentDir, 'README.md')))
+                    capabilities.push('Docs');
+                const storiesFile = (await promises.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 promises.readdir(dir);
+    const exts = Array.isArray(extensions) ? extensions : [extensions];
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        const stats = await promises.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 (!fs.existsSync(fullPath)) {
+                results.missing.push(relativePath);
+                continue;
+            }
+            const content = await promises.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 (fs.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 (!fs.existsSync(fullPath)) {
+                results.missing.push(relativePath);
+                continue;
+            }
+            diskFiles.delete(relativePath);
+            const content = await promises.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 (fs.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 (!fs.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 promises.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 promises.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 (fs.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 (fs.existsSync(fullPath)) {
+                await scanDirectoryOrFile(fullPath, untrackedFiles, state);
+            }
+            // 2. Try as component name
+            const compPath = path.join(roots.components, identifier);
+            if (fs.existsSync(compPath)) {
+                await scanDirectoryOrFile(compPath, untrackedFiles, state);
+            }
+            // 3. Try as feature name
+            const featPath = path.join(roots.features, identifier);
+            if (fs.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 (fs.existsSync(pagePath)) {
+                await scanDirectoryOrFile(pagePath, untrackedFiles, state);
+            }
+            const nestedPagePath = path.join(roots.pages, cleanRoute, config.routing?.indexFile || 'index.astro');
+            if (fs.existsSync(nestedPagePath)) {
+                await scanDirectoryOrFile(nestedPagePath, untrackedFiles, state);
+            }
+            filesToAdopt = Array.from(untrackedFiles);
+            if (filesToAdopt.length === 0 && !fs.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 promises.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 promises.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 promises.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);
+        }
+    }
+}
+
+exports.addSectionCommand = addSectionCommand;
+exports.adoptCommand = adoptCommand;
+exports.createComponentCommand = createComponentCommand;
+exports.initCommand = initCommand;
+exports.listSectionsCommand = listSectionsCommand;
+exports.moveSectionCommand = moveSectionCommand;
+exports.removeComponentCommand = removeComponentCommand;
+exports.removeSectionCommand = removeSectionCommand;
+exports.statusCommand = statusCommand;
+exports.syncCommand = syncCommand;
+exports.validateStateCommand = validateStateCommand;
+//# sourceMappingURL=index.cjs.map