@oamm/textor 1.0.13 → 1.0.14

package/dist/index.d.ts

@@ -53,4 +53,13 @@ declare function pruneMissingCommand(options?: {
  */
 declare function renameCommand(type: any, oldName: any, newName: any, options: any): Promise<void>;
 
-export { addSectionCommand, adoptCommand, createComponentCommand, initCommand, listSectionsCommand, moveSectionCommand, normalizeStateCommand, pruneMissingCommand, removeComponentCommand, removeSectionCommand, renameCommand, statusCommand, syncCommand, upgradeConfigCommand, validateStateCommand };
+/**
+ * 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
+ */
+declare function addItemCommand(itemType: string, targetName: string, options: any): Promise<void>;
+
+export { addItemCommand, addSectionCommand, adoptCommand, createComponentCommand, initCommand, listSectionsCommand, moveSectionCommand, normalizeStateCommand, pruneMissingCommand, removeComponentCommand, removeSectionCommand, renameCommand, statusCommand, syncCommand, upgradeConfigCommand, validateStateCommand };

package/dist/index.js

@@ -635,14 +635,6 @@ async function safeDelete(filePath, options = {}) {
     await unlink(filePath);
     return { deleted: true };
 }
-async function ensureNotExists(filePath, force = false) {
-    if (existsSync(filePath)) {
-        if (!force) {
-            throw new Error(`File already exists: ${filePath}\n` +
-                `Use --force to overwrite.`);
-        }
-    }
-}
 async function ensureDir(dirPath) {
     await mkdir(dirPath, { recursive: true });
 }
@@ -1794,29 +1786,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 = 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 && existsSync(indexFilePath))
+                console.log(`  - Skipping existing index: ${indexFilePath}`);
+            if (shouldCreateContext && existsSync(contextFilePath))
+                console.log(`  - Skipping existing context: ${contextFilePath}`);
+            if (shouldCreateHooks && existsSync(hookFilePath))
+                console.log(`  - Skipping existing hook: ${hookFilePath}`);
+            if (shouldCreateTests && existsSync(testFilePath))
+                console.log(`  - Skipping existing test: ${testFilePath}`);
+            if (shouldCreateTypes && existsSync(typesFilePath))
+                console.log(`  - Skipping existing types: ${typesFilePath}`);
+            if (shouldCreateApi && existsSync(apiFilePath))
+                console.log(`  - Skipping existing api: ${apiFilePath}`);
+            if (shouldCreateServices && existsSync(servicesFilePath))
+                console.log(`  - Skipping existing services: ${servicesFilePath}`);
+            if (shouldCreateSchemas && existsSync(schemasFilePath))
+                console.log(`  - Skipping existing schemas: ${schemasFilePath}`);
+            if (shouldCreateReadme && existsSync(readmeFilePath))
+                console.log(`  - Skipping existing readme: ${readmeFilePath}`);
+            if (shouldCreateStories && existsSync(storiesFilePath))
+                console.log(`  - Skipping existing stories: ${storiesFilePath}`);
+            if (shouldCreateScriptsDir && existsSync(scriptsIndexPath))
+                console.log(`  - Skipping existing scripts: ${scriptsIndexPath}`);
+        }
         let layoutImportPath = null;
         const cliProps = options.prop || {};
         const rawLayoutProps = { ...configLayoutProps, ...cliProps };
@@ -1938,15 +1936,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 && (!existsSync(scriptsIndexPath) || options.force)) {
             const hash = await writeFileWithSignature(scriptsIndexPath, generateScriptsIndexTemplate(), getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(scriptsIndexPath, {
                 kind: 'feature-file',
@@ -1956,7 +1956,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(scriptsIndexPath);
         }
-        if (shouldCreateIndex) {
+        if (shouldCreateIndex && (!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, {
@@ -1967,7 +1967,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(indexFilePath);
         }
-        if (shouldCreateApi) {
+        if (shouldCreateApi && (!existsSync(apiFilePath) || options.force)) {
             const apiContent = generateApiTemplate(featureComponentName);
             const hash = await writeFileWithSignature(apiFilePath, apiContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(apiFilePath, {
@@ -1978,7 +1978,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(apiFilePath);
         }
-        if (shouldCreateServices) {
+        if (shouldCreateServices && (!existsSync(servicesFilePath) || options.force)) {
             const servicesContent = generateServiceTemplate(featureComponentName);
             const hash = await writeFileWithSignature(servicesFilePath, servicesContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(servicesFilePath, {
@@ -1989,7 +1989,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(servicesFilePath);
         }
-        if (shouldCreateSchemas) {
+        if (shouldCreateSchemas && (!existsSync(schemasFilePath) || options.force)) {
             const schemasContent = generateSchemaTemplate(featureComponentName);
             const hash = await writeFileWithSignature(schemasFilePath, schemasContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(schemasFilePath, {
@@ -2000,7 +2000,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(schemasFilePath);
         }
-        if (shouldCreateHooks) {
+        if (shouldCreateHooks && (!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);
@@ -2012,7 +2012,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(hookFilePath);
         }
-        if (shouldCreateContext) {
+        if (shouldCreateContext && (!existsSync(contextFilePath) || options.force)) {
             const contextContent = generateContextTemplate(featureComponentName);
             const hash = await writeFileWithSignature(contextFilePath, contextContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(contextFilePath, {
@@ -2023,7 +2023,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(contextFilePath);
         }
-        if (shouldCreateTests) {
+        if (shouldCreateTests && (!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);
@@ -2035,7 +2035,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(testFilePath);
         }
-        if (shouldCreateTypes) {
+        if (shouldCreateTypes && (!existsSync(typesFilePath) || options.force)) {
             const typesContent = generateTypesTemplate(featureComponentName);
             const hash = await writeFileWithSignature(typesFilePath, typesContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(typesFilePath, {
@@ -2046,7 +2046,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(typesFilePath);
         }
-        if (shouldCreateReadme) {
+        if (shouldCreateReadme && (!existsSync(readmeFilePath) || options.force)) {
             const readmeContent = generateReadmeTemplate(featureComponentName);
             const hash = await writeFileWithSignature(readmeFilePath, readmeContent, getSignature(config, 'astro'), config.hashing?.normalization);
             await registerFile(readmeFilePath, {
@@ -2057,7 +2057,7 @@ async function addSectionCommand(route, featurePath, options) {
             });
             writtenFiles.push(readmeFilePath);
         }
-        if (shouldCreateStories) {
+        if (shouldCreateStories && (!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);
@@ -2870,30 +2870,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 = 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 (existsSync(indexFilePath))
+                console.log(`  - Skipping existing index: ${indexFilePath}`);
+            if (shouldCreateContext && existsSync(contextFilePath))
+                console.log(`  - Skipping existing context: ${contextFilePath}`);
+            if (shouldCreateHook && existsSync(hookFilePath))
+                console.log(`  - Skipping existing hook: ${hookFilePath}`);
+            if (shouldCreateTests && existsSync(testFilePath))
+                console.log(`  - Skipping existing test: ${testFilePath}`);
+            if (shouldCreateConfig && existsSync(configFilePath))
+                console.log(`  - Skipping existing config: ${configFilePath}`);
+            if (shouldCreateConstants && existsSync(constantsFilePath))
+                console.log(`  - Skipping existing constants: ${constantsFilePath}`);
+            if (shouldCreateTypes && existsSync(typesFilePath))
+                console.log(`  - Skipping existing types: ${typesFilePath}`);
+            if (shouldCreateApi && existsSync(apiFilePath))
+                console.log(`  - Skipping existing api: ${apiFilePath}`);
+            if (shouldCreateServices && existsSync(servicesFilePath))
+                console.log(`  - Skipping existing services: ${servicesFilePath}`);
+            if (shouldCreateSchemas && existsSync(schemasFilePath))
+                console.log(`  - Skipping existing schemas: ${schemasFilePath}`);
+            if (shouldCreateReadme && existsSync(readmeFilePath))
+                console.log(`  - Skipping existing readme: ${readmeFilePath}`);
+            if (shouldCreateStories && existsSync(storiesFilePath))
+                console.log(`  - Skipping existing stories: ${storiesFilePath}`);
+        }
         await ensureDir(componentDir);
         if (shouldCreateSubComponentsDir)
             await ensureDir(subComponentsDir);
@@ -2917,24 +2924,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 (!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 && (!existsSync(typesFilePath) || options.force)) {
             const typesContent = generateTypesTemplate(normalizedName);
             const hash = await writeFileWithSignature(typesFilePath, typesContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(typesFilePath, {
@@ -2945,7 +2957,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(typesFilePath);
         }
-        if (shouldCreateContext) {
+        if (shouldCreateContext && (!existsSync(contextFilePath) || options.force)) {
             const contextContent = generateContextTemplate(normalizedName);
             const hash = await writeFileWithSignature(contextFilePath, contextContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(contextFilePath, {
@@ -2956,7 +2968,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(contextFilePath);
         }
-        if (shouldCreateHook) {
+        if (shouldCreateHook && (!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);
@@ -2968,7 +2980,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(hookFilePath);
         }
-        if (shouldCreateTests) {
+        if (shouldCreateTests && (!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);
@@ -2980,7 +2992,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(testFilePath);
         }
-        if (shouldCreateConfig) {
+        if (shouldCreateConfig && (!existsSync(configFilePath) || options.force)) {
             const configContent = generateConfigTemplate(normalizedName);
             const hash = await writeFileWithSignature(configFilePath, configContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(configFilePath, {
@@ -2991,7 +3003,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(configFilePath);
         }
-        if (shouldCreateConstants) {
+        if (shouldCreateConstants && (!existsSync(constantsFilePath) || options.force)) {
             const constantsContent = generateConstantsTemplate(normalizedName);
             const hash = await writeFileWithSignature(constantsFilePath, constantsContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(constantsFilePath, {
@@ -3002,7 +3014,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(constantsFilePath);
         }
-        if (shouldCreateApi) {
+        if (shouldCreateApi && (!existsSync(apiFilePath) || options.force)) {
             const apiContent = generateApiTemplate(normalizedName);
             const hash = await writeFileWithSignature(apiFilePath, apiContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(apiFilePath, {
@@ -3013,7 +3025,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(apiFilePath);
         }
-        if (shouldCreateServices) {
+        if (shouldCreateServices && (!existsSync(servicesFilePath) || options.force)) {
             const servicesContent = generateServiceTemplate(normalizedName);
             const hash = await writeFileWithSignature(servicesFilePath, servicesContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(servicesFilePath, {
@@ -3024,7 +3036,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(servicesFilePath);
         }
-        if (shouldCreateSchemas) {
+        if (shouldCreateSchemas && (!existsSync(schemasFilePath) || options.force)) {
             const schemasContent = generateSchemaTemplate(normalizedName);
             const hash = await writeFileWithSignature(schemasFilePath, schemasContent, getSignature(config, 'typescript'), config.hashing?.normalization);
             await registerFile(schemasFilePath, {
@@ -3035,7 +3047,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(schemasFilePath);
         }
-        if (shouldCreateReadme) {
+        if (shouldCreateReadme && (!existsSync(readmeFilePath) || options.force)) {
             const readmeContent = generateReadmeTemplate(normalizedName);
             const hash = await writeFileWithSignature(readmeFilePath, readmeContent, getSignature(config, 'astro'), config.hashing?.normalization);
             await registerFile(readmeFilePath, {
@@ -3046,7 +3058,7 @@ async function createComponentCommand(componentName, options) {
             });
             writtenFiles.push(readmeFilePath);
         }
-        if (shouldCreateStories) {
+        if (shouldCreateStories && (!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);
@@ -3985,5 +3997,59 @@ async function renameComponent(oldName, newName, options) {
     console.log(`✓ Renamed component ${normalizedOldName} to ${normalizedNewName}`);
 }
 
-export { addSectionCommand, adoptCommand, createComponentCommand, initCommand, listSectionsCommand, moveSectionCommand, normalizeStateCommand, pruneMissingCommand, removeComponentCommand, removeSectionCommand, renameCommand, statusCommand, syncCommand, upgradeConfigCommand, validateStateCommand };
+/**
+ * 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;
+    }
+}
+
+export { addItemCommand, addSectionCommand, adoptCommand, createComponentCommand, initCommand, listSectionsCommand, moveSectionCommand, normalizeStateCommand, pruneMissingCommand, removeComponentCommand, removeSectionCommand, renameCommand, statusCommand, syncCommand, upgradeConfigCommand, validateStateCommand };
 //# sourceMappingURL=index.js.map