@oamm/textor 1.0.13 → 1.0.16

package/dist/index.cjs

@@ -637,14 +637,6 @@ async function safeDelete(filePath, options = {}) {
     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 });
 }
@@ -1544,18 +1536,26 @@ function reconstructSections(state, config) {
     // 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 routeFile = section.route ? 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
-        });
+        }) : true;
         // 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, '/') + '/'));
+        const hasFeatureFiles = section.featurePath ? Object.keys(files).some(f => {
+            const normalizedF = f.replace(/\\/g, '/');
+            const featPath = section.featurePath.replace(/\\/g, '/');
+            return normalizedF.startsWith(featPath + '/') ||
+                normalizedF.startsWith(featuresRoot + '/' + featPath + '/');
+        }) : false;
         return routeFile && hasFeatureFiles;
     });
     const sections = new Map();
-    validSections.forEach(s => sections.set(s.route, s));
+    validSections.forEach(s => {
+        const key = s.route || `feature:${s.featurePath}`;
+        sections.set(key, s);
+    });
     // Try to discover new sections
     for (const filePath in files) {
         const normalizedPath = filePath.replace(/\\/g, '/');
@@ -1796,29 +1796,35 @@ async function addSectionCommand(route, featurePath, options) {
                 }
             }
         }
-        await ensureNotExists(featureFilePath, options.force);
-        if (shouldCreateIndex)
-            await ensureNotExists(indexFilePath, options.force);
-        if (shouldCreateContext)
-            await ensureNotExists(contextFilePath, options.force);
-        if (shouldCreateHooks)
-            await ensureNotExists(hookFilePath, options.force);
-        if (shouldCreateTests)
-            await ensureNotExists(testFilePath, options.force);
-        if (shouldCreateTypes)
-            await ensureNotExists(typesFilePath, options.force);
-        if (shouldCreateApi)
-            await ensureNotExists(apiFilePath, options.force);
-        if (shouldCreateServices)
-            await ensureNotExists(servicesFilePath, options.force);
-        if (shouldCreateSchemas)
-            await ensureNotExists(schemasFilePath, options.force);
-        if (shouldCreateReadme)
-            await ensureNotExists(readmeFilePath, options.force);
-        if (shouldCreateStories)
-            await ensureNotExists(storiesFilePath, options.force);
-        if (shouldCreateScriptsDir)
-            await ensureNotExists(scriptsIndexPath, options.force);
+        const featureExists = fs.existsSync(featureFilePath);
+        if (featureExists && !options.force) {
+            console.log(`ℹ Feature already exists at ${featureFilePath}. Entering additive mode.`);
+        }
+        // Check sub-items only if not in force mode
+        if (!options.force) {
+            if (shouldCreateIndex && fs.existsSync(indexFilePath))
+                console.log(`  - Skipping existing index: ${indexFilePath}`);
+            if (shouldCreateContext && fs.existsSync(contextFilePath))
+                console.log(`  - Skipping existing context: ${contextFilePath}`);
+            if (shouldCreateHooks && fs.existsSync(hookFilePath))
+                console.log(`  - Skipping existing hook: ${hookFilePath}`);
+            if (shouldCreateTests && fs.existsSync(testFilePath))
+                console.log(`  - Skipping existing test: ${testFilePath}`);
+            if (shouldCreateTypes && fs.existsSync(typesFilePath))
+                console.log(`  - Skipping existing types: ${typesFilePath}`);
+            if (shouldCreateApi && fs.existsSync(apiFilePath))
+                console.log(`  - Skipping existing api: ${apiFilePath}`);
+            if (shouldCreateServices && fs.existsSync(servicesFilePath))
+                console.log(`  - Skipping existing services: ${servicesFilePath}`);
+            if (shouldCreateSchemas && fs.existsSync(schemasFilePath))
+                console.log(`  - Skipping existing schemas: ${schemasFilePath}`);
+            if (shouldCreateReadme && fs.existsSync(readmeFilePath))
+                console.log(`  - Skipping existing readme: ${readmeFilePath}`);
+            if (shouldCreateStories && fs.existsSync(storiesFilePath))
+                console.log(`  - Skipping existing stories: ${storiesFilePath}`);
+            if (shouldCreateScriptsDir && fs.existsSync(scriptsIndexPath))
+                console.log(`  - Skipping existing scripts: ${scriptsIndexPath}`);
+        }
         let layoutImportPath = null;
         const cliProps = options.prop || {};
         const rawLayoutProps = { ...configLayoutProps, ...cliProps };
@@ -1940,15 +1946,17 @@ async function addSectionCommand(route, featurePath, options) {
         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) {
+        if (!featureExists || options.force) {
+            const featureHash = await writeFileWithSignature(featureFilePath, featureContent, featureSignature, config.hashing?.normalization);
+            await registerFile(featureFilePath, {
+                kind: 'feature',
+                template: 'feature',
+                hash: featureHash,
+                owner: normalizedRoute
+            });
+            writtenFiles.push(featureFilePath);
+        }
+        if (shouldCreateScriptsDir && (!fs.existsSync(scriptsIndexPath) || options.force)) {
             const hash = await writeFileWithSignature(scriptsIndexPath, generateScriptsIndexTemplate(), getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(scriptsIndexPath, {
                 kind: 'feature-file',
@@ -1958,7 +1966,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(scriptsIndexPath);
         }
-        if (shouldCreateIndex) {
+        if (shouldCreateIndex && (!fs.existsSync(indexFilePath) || options.force)) {
             const indexContent = generateIndexTemplate(featureComponentName, config.naming.featureExtension);
             const hash = await writeFileWithSignature(indexFilePath, indexContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(indexFilePath, {
@@ -1969,7 +1977,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(indexFilePath);
         }
-        if (shouldCreateApi) {
+        if (shouldCreateApi && (!fs.existsSync(apiFilePath) || options.force)) {
             const apiContent = generateApiTemplate(featureComponentName);
             const hash = await writeFileWithSignature(apiFilePath, apiContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(apiFilePath, {
@@ -1980,7 +1988,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(apiFilePath);
         }
-        if (shouldCreateServices) {
+        if (shouldCreateServices && (!fs.existsSync(servicesFilePath) || options.force)) {
             const servicesContent = generateServiceTemplate(featureComponentName);
             const hash = await writeFileWithSignature(servicesFilePath, servicesContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(servicesFilePath, {
@@ -1991,7 +1999,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(servicesFilePath);
         }
-        if (shouldCreateSchemas) {
+        if (shouldCreateSchemas && (!fs.existsSync(schemasFilePath) || options.force)) {
             const schemasContent = generateSchemaTemplate(featureComponentName);
             const hash = await writeFileWithSignature(schemasFilePath, schemasContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(schemasFilePath, {
@@ -2002,7 +2010,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(schemasFilePath);
         }
-        if (shouldCreateHooks) {
+        if (shouldCreateHooks && (!fs.existsSync(hookFilePath) || options.force)) {
             const hookName = getHookFunctionName(featureComponentName);
             const hookContent = generateHookTemplate(featureComponentName, hookName);
             const hash = await writeFileWithSignature(hookFilePath, hookContent, getSignature(config, 'typescript'), config.hashing?.normalization);
@@ -2014,7 +2022,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(hookFilePath);
         }
-        if (shouldCreateContext) {
+        if (shouldCreateContext && (!fs.existsSync(contextFilePath) || options.force)) {
             const contextContent = generateContextTemplate(featureComponentName);
             const hash = await writeFileWithSignature(contextFilePath, contextContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(contextFilePath, {
@@ -2025,7 +2033,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(contextFilePath);
         }
-        if (shouldCreateTests) {
+        if (shouldCreateTests && (!fs.existsSync(testFilePath) || options.force)) {
             const relativeFeaturePath = `./${path.basename(featureFilePath)}`;
             const testContent = generateTestTemplate(featureComponentName, relativeFeaturePath);
             const hash = await writeFileWithSignature(testFilePath, testContent, getSignature(config, 'typescript'), config.hashing?.normalization);
@@ -2037,7 +2045,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(testFilePath);
         }
-        if (shouldCreateTypes) {
+        if (shouldCreateTypes && (!fs.existsSync(typesFilePath) || options.force)) {
             const typesContent = generateTypesTemplate(featureComponentName);
             const hash = await writeFileWithSignature(typesFilePath, typesContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(typesFilePath, {
@@ -2048,7 +2056,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(typesFilePath);
         }
-        if (shouldCreateReadme) {
+        if (shouldCreateReadme && (!fs.existsSync(readmeFilePath) || options.force)) {
             const readmeContent = generateReadmeTemplate(featureComponentName);
             const hash = await writeFileWithSignature(readmeFilePath, readmeContent, getSignature(config, 'astro'), config.hashing?.normalization);
             await registerFile(readmeFilePath, {
@@ -2059,7 +2067,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(readmeFilePath);
         }
-        if (shouldCreateStories) {
+        if (shouldCreateStories && (!fs.existsSync(storiesFilePath) || options.force)) {
             const relativePath = `./${path.basename(featureFilePath)}`;
             const storiesContent = generateStoriesTemplate(featureComponentName, relativePath);
             const hash = await writeFileWithSignature(storiesFilePath, storiesContent, getSignature(config, 'typescript'), config.hashing?.normalization);
@@ -2872,30 +2880,37 @@ async function createComponentCommand(componentName, options) {
                 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);
+        const componentExists = fs.existsSync(componentFilePath);
+        if (componentExists && !options.force) {
+            console.log(`ℹ Component already exists at ${componentFilePath}. Entering additive mode.`);
+        }
+        // Check sub-items only if not in force mode
+        if (!options.force) {
+            if (fs.existsSync(indexFilePath))
+                console.log(`  - Skipping existing index: ${indexFilePath}`);
+            if (shouldCreateContext && fs.existsSync(contextFilePath))
+                console.log(`  - Skipping existing context: ${contextFilePath}`);
+            if (shouldCreateHook && fs.existsSync(hookFilePath))
+                console.log(`  - Skipping existing hook: ${hookFilePath}`);
+            if (shouldCreateTests && fs.existsSync(testFilePath))
+                console.log(`  - Skipping existing test: ${testFilePath}`);
+            if (shouldCreateConfig && fs.existsSync(configFilePath))
+                console.log(`  - Skipping existing config: ${configFilePath}`);
+            if (shouldCreateConstants && fs.existsSync(constantsFilePath))
+                console.log(`  - Skipping existing constants: ${constantsFilePath}`);
+            if (shouldCreateTypes && fs.existsSync(typesFilePath))
+                console.log(`  - Skipping existing types: ${typesFilePath}`);
+            if (shouldCreateApi && fs.existsSync(apiFilePath))
+                console.log(`  - Skipping existing api: ${apiFilePath}`);
+            if (shouldCreateServices && fs.existsSync(servicesFilePath))
+                console.log(`  - Skipping existing services: ${servicesFilePath}`);
+            if (shouldCreateSchemas && fs.existsSync(schemasFilePath))
+                console.log(`  - Skipping existing schemas: ${schemasFilePath}`);
+            if (shouldCreateReadme && fs.existsSync(readmeFilePath))
+                console.log(`  - Skipping existing readme: ${readmeFilePath}`);
+            if (shouldCreateStories && fs.existsSync(storiesFilePath))
+                console.log(`  - Skipping existing stories: ${storiesFilePath}`);
+        }
         await ensureDir(componentDir);
         if (shouldCreateSubComponentsDir)
             await ensureDir(subComponentsDir);
@@ -2919,24 +2934,29 @@ async function createComponentCommand(componentName, options) {
             await ensureDir(schemasDirInside);
         const componentContent = generateComponentTemplate(normalizedName, framework, config.naming.componentExtension);
         const signature = getSignature(config, config.naming.componentExtension === '.astro' ? 'astro' : 'tsx');
-        const componentHash = await writeFileWithSignature(componentFilePath, componentContent, signature, config.hashing?.normalization);
-        await registerFile(componentFilePath, {
-            kind: 'component',
-            template: 'component',
-            hash: componentHash,
-            owner: normalizedName
-        });
-        const writtenFiles = [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 writtenFiles = [];
+        if (!componentExists || options.force) {
+            const componentHash = await writeFileWithSignature(componentFilePath, componentContent, signature, config.hashing?.normalization);
+            await registerFile(componentFilePath, {
+                kind: 'component',
+                template: 'component',
+                hash: componentHash,
+                owner: normalizedName
+            });
+            writtenFiles.push(componentFilePath);
+        }
+        if (!fs.existsSync(indexFilePath) || options.force) {
+            const indexContent = generateIndexTemplate(normalizedName, config.naming.componentExtension);
+            const indexHash = await writeFileWithSignature(indexFilePath, indexContent, getSignature(config, 'typescript'), config.hashing?.normalization);
+            await registerFile(indexFilePath, {
+                kind: 'component-file',
+                template: 'index',
+                hash: indexHash,
+                owner: normalizedName
+            });
+            writtenFiles.push(indexFilePath);
+        }
+        if (shouldCreateTypes && (!fs.existsSync(typesFilePath) || options.force)) {
             const typesContent = generateTypesTemplate(normalizedName);
             const hash = await writeFileWithSignature(typesFilePath, typesContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(typesFilePath, {
@@ -2947,7 +2967,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(typesFilePath);
         }
-        if (shouldCreateContext) {
+        if (shouldCreateContext && (!fs.existsSync(contextFilePath) || options.force)) {
             const contextContent = generateContextTemplate(normalizedName);
             const hash = await writeFileWithSignature(contextFilePath, contextContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(contextFilePath, {
@@ -2958,7 +2978,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(contextFilePath);
         }
-        if (shouldCreateHook) {
+        if (shouldCreateHook && (!fs.existsSync(hookFilePath) || options.force)) {
             const hookName = getHookFunctionName(normalizedName);
             const hookContent = generateHookTemplate(normalizedName, hookName);
             const hash = await writeFileWithSignature(hookFilePath, hookContent, getSignature(config, 'typescript'), config.hashing?.normalization);
@@ -2970,7 +2990,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(hookFilePath);
         }
-        if (shouldCreateTests) {
+        if (shouldCreateTests && (!fs.existsSync(testFilePath) || options.force)) {
             const relativeComponentPath = `../${normalizedName}${config.naming.componentExtension}`;
             const testContent = generateTestTemplate(normalizedName, relativeComponentPath);
             const hash = await writeFileWithSignature(testFilePath, testContent, getSignature(config, 'typescript'), config.hashing?.normalization);
@@ -2982,7 +3002,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(testFilePath);
         }
-        if (shouldCreateConfig) {
+        if (shouldCreateConfig && (!fs.existsSync(configFilePath) || options.force)) {
             const configContent = generateConfigTemplate(normalizedName);
             const hash = await writeFileWithSignature(configFilePath, configContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(configFilePath, {
@@ -2993,7 +3013,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(configFilePath);
         }
-        if (shouldCreateConstants) {
+        if (shouldCreateConstants && (!fs.existsSync(constantsFilePath) || options.force)) {
             const constantsContent = generateConstantsTemplate(normalizedName);
             const hash = await writeFileWithSignature(constantsFilePath, constantsContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(constantsFilePath, {
@@ -3004,7 +3024,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(constantsFilePath);
         }
-        if (shouldCreateApi) {
+        if (shouldCreateApi && (!fs.existsSync(apiFilePath) || options.force)) {
             const apiContent = generateApiTemplate(normalizedName);
             const hash = await writeFileWithSignature(apiFilePath, apiContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(apiFilePath, {
@@ -3015,7 +3035,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(apiFilePath);
         }
-        if (shouldCreateServices) {
+        if (shouldCreateServices && (!fs.existsSync(servicesFilePath) || options.force)) {
             const servicesContent = generateServiceTemplate(normalizedName);
             const hash = await writeFileWithSignature(servicesFilePath, servicesContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(servicesFilePath, {
@@ -3026,7 +3046,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(servicesFilePath);
         }
-        if (shouldCreateSchemas) {
+        if (shouldCreateSchemas && (!fs.existsSync(schemasFilePath) || options.force)) {
             const schemasContent = generateSchemaTemplate(normalizedName);
             const hash = await writeFileWithSignature(schemasFilePath, schemasContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(schemasFilePath, {
@@ -3037,7 +3057,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(schemasFilePath);
         }
-        if (shouldCreateReadme) {
+        if (shouldCreateReadme && (!fs.existsSync(readmeFilePath) || options.force)) {
             const readmeContent = generateReadmeTemplate(normalizedName);
             const hash = await writeFileWithSignature(readmeFilePath, readmeContent, getSignature(config, 'astro'), config.hashing?.normalization);
             await registerFile(readmeFilePath, {
@@ -3048,7 +3068,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(readmeFilePath);
         }
-        if (shouldCreateStories) {
+        if (shouldCreateStories && (!fs.existsSync(storiesFilePath) || options.force)) {
             const relativePath = `./${normalizedName}${config.naming.componentExtension}`;
             const storiesContent = generateStoriesTemplate(normalizedName, relativePath);
             const hash = await writeFileWithSignature(storiesFilePath, storiesContent, getSignature(config, 'typescript'), config.hashing?.normalization);
@@ -3626,7 +3646,24 @@ async function syncCommand(options) {
     }
 }
 
-async function adoptCommand(identifier, options) {
+async function adoptCommand(kind, arg2, arg3, options) {
+    // Handle cases where options is in a different position due to variable arguments
+    if (typeof kind === 'object' && kind !== null && !Array.isArray(kind)) {
+        options = kind;
+        kind = undefined;
+        arg2 = undefined;
+        arg3 = undefined;
+    }
+    else if (typeof arg2 === 'object' && arg2 !== null && !Array.isArray(arg2)) {
+        options = arg2;
+        arg2 = undefined;
+        arg3 = undefined;
+    }
+    else if (typeof arg3 === 'object' && arg3 !== null && !Array.isArray(arg3)) {
+        options = arg3;
+        arg3 = undefined;
+    }
+    options = options || {};
     try {
         const config = await loadConfig();
         const state = await loadState();
@@ -3636,6 +3673,9 @@ async function adoptCommand(identifier, options) {
             components: resolvePath(config, 'components')
         };
         let filesToAdopt = [];
+        let identifier = kind;
+        let customName = null;
+        let sourcePath = null;
         if (!identifier && options.all) {
             // Adopt all untracked files in all roots
             const managedFiles = new Set();
@@ -3646,6 +3686,46 @@ async function adoptCommand(identifier, options) {
             }
             filesToAdopt = Array.from(managedFiles).filter(f => !state.files[f]);
         }
+        else if (kind === 'component' && arg2) {
+            const componentName = arg2;
+            const untrackedFiles = new Set();
+            const compPath = path.join(roots.components, componentName);
+            if (fs.existsSync(compPath)) {
+                await scanDirectoryOrFile(compPath, untrackedFiles, state);
+            }
+            else {
+                throw new Error(`Component directory not found: ${compPath}`);
+            }
+            filesToAdopt = Array.from(untrackedFiles);
+        }
+        else if (kind === 'feature' && arg2 && arg3) {
+            sourcePath = arg2;
+            customName = arg3;
+            const targetPath = path.join(roots.features, customName);
+            const absoluteSource = path.resolve(process.cwd(), sourcePath);
+            const absoluteTarget = path.resolve(targetPath);
+            if (fs.existsSync(absoluteSource)) {
+                if (!options.dryRun && absoluteSource !== absoluteTarget) {
+                    if (!fs.existsSync(path.dirname(absoluteTarget))) {
+                        await promises.mkdir(path.dirname(absoluteTarget), { recursive: true });
+                    }
+                    console.log(`Moving files from ${sourcePath} to ${path.relative(process.cwd(), targetPath)}...`);
+                    await promises.rename(absoluteSource, absoluteTarget);
+                    sourcePath = path.relative(process.cwd(), targetPath);
+                }
+                else if (options.dryRun && absoluteSource !== absoluteTarget) {
+                    console.log(`Dry run: would move files from ${sourcePath} to ${path.relative(process.cwd(), targetPath)}`);
+                    sourcePath = path.relative(process.cwd(), targetPath);
+                }
+                const untrackedFiles = new Set();
+                const fullPath = absoluteSource !== absoluteTarget && !options.dryRun ? absoluteTarget : absoluteSource;
+                await scanDirectoryOrFile(fullPath, untrackedFiles, state);
+                filesToAdopt = Array.from(untrackedFiles);
+            }
+            else {
+                throw new Error(`Source path not found: ${absoluteSource}`);
+            }
+        }
         else if (identifier) {
             const untrackedFiles = new Set();
             // 1. Try as direct path
@@ -3987,6 +4067,61 @@ async function renameComponent(oldName, newName, options) {
     console.log(`✓ Renamed component ${normalizedOldName} to ${normalizedNewName}`);
 }
 
+/**
+ * Add a new item (hook, api, service, etc.) to an existing feature or component.
+ *
+ * @param {string} itemType The type of item to add (e.g., 'api', 'hook', 'service')
+ * @param {string} targetName The name of the feature or component
+ * @param {Object} options Additional options from Commander
+ */
+async function addItemCommand(itemType, targetName, options) {
+    try {
+        const state = await loadState();
+        // Normalize itemType
+        let normalizedItem = itemType.toLowerCase();
+        if (normalizedItem === 'test')
+            normalizedItem = 'tests';
+        if (normalizedItem === 'service')
+            normalizedItem = 'services';
+        if (normalizedItem === 'schema')
+            normalizedItem = 'schemas';
+        if (normalizedItem === 'hook')
+            normalizedItem = 'hooks'; // for add-section
+        // Try to find as section (feature) first
+        let section = findSection(state, targetName);
+        let component = findComponent(state, targetName);
+        // If not found by exact name, try to find by featurePath or part of it
+        if (!section && !component) {
+            section = state.sections.find(s => s.featurePath === targetName || s.featurePath.endsWith('/' + targetName));
+        }
+        if (!section && !component) {
+            throw new Error(`Target not found in state: "${targetName}". Please use "add-section" or "create-component" directly if it's not managed by Textor.`);
+        }
+        const flags = { [normalizedItem]: true };
+        // Also set singular for create-component which uses 'hook'
+        if (normalizedItem === 'hooks')
+            flags.hook = true;
+        if (section) {
+            console.log(`ℹ Adding ${normalizedItem} to feature: ${section.featurePath}`);
+            return await addSectionCommand(undefined, section.featurePath, { ...options, ...flags });
+        }
+        if (component) {
+            console.log(`ℹ Adding ${normalizedItem} to component: ${component.name}`);
+            // For create-component, we might need to be careful with flags that are on by default
+            // but getEffectiveOptions should handle it if we pass them explicitly as true.
+            return await createComponentCommand(component.name, { ...options, ...flags });
+        }
+    }
+    catch (error) {
+        console.error('Error:', error.message);
+        if (typeof process.exit === 'function' && process.env.NODE_ENV !== 'test') {
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+
+exports.addItemCommand = addItemCommand;
 exports.addSectionCommand = addSectionCommand;
 exports.adoptCommand = adoptCommand;
 exports.createComponentCommand = createComponentCommand;