@oamm/textor 1.0.13 → 1.0.14

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 });
 }
@@ -1796,29 +1788,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 +1938,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 +1958,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 +1969,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 +1980,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 +1991,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 +2002,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 +2014,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 +2025,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 +2037,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 +2048,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 +2059,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 +2872,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 +2926,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 +2959,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 +2970,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 +2982,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 +2994,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 +3005,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 +3016,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 +3027,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 +3038,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 +3049,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 +3060,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);
@@ -3987,6 +3999,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;