@oamm/textor 1.0.13 → 1.0.16

package/README.md

@@ -209,6 +209,25 @@ pnpm textor rename component Header SiteHeader
 
 Use `--scan` to update imports across the entire project.
 
+### add
+Add a new sub-item (api, hook, test, etc.) to an existing feature or component. This command is additive and will not overwrite existing files unless `--force` is used.
+
+```bash
+# Add API to an existing feature
+pnpm textor add api auth/login
+
+# Add hooks to an existing component
+pnpm textor add hook Button
+
+# Add tests and readme to a feature
+pnpm textor add test auth/login
+pnpm textor add readme auth/login
+```
+
+Textor automatically detects if the target is a feature or a component based on its state.
+
+You can also use the original `add-section` or `create-component` commands with the same flags to add items; they now also support additive mode.
+
 ### remove-section / remove-component
 Safely remove Textor-managed modules.
 
@@ -257,6 +276,8 @@ Adopt untracked files into Textor's state and add the Textor signature to them.
 
 ```bash
 pnpm textor adopt <path-or-identifier> [options]
+pnpm textor adopt component <name> [options]
+pnpm textor adopt feature <path> <name> [options]
 ```
 
 **Options:**
@@ -268,6 +289,12 @@ pnpm textor adopt <path-or-identifier> [options]
 # Adopt a specific component directory
 pnpm textor adopt src/components/MyNewButton
 
+# Adopt a component by its name
+pnpm textor adopt component MyNewButton
+
+# Adopt a directory as a new feature (moves files to src/features/my-feat)
+pnpm textor adopt feature path/to/legacy-code my-feat
+
 # Adopt a section by its route
 pnpm textor adopt /users
 

package/dist/bin/textor.js

@@ -716,17 +716,6 @@ async function safeDelete(filePath, options = {}) {
   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 });
 }
@@ -1732,23 +1721,29 @@ 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) {
@@ -2082,19 +2077,25 @@ 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 || {};
@@ -2235,21 +2236,23 @@ async function addSectionCommand(route, featurePath, options) {
 
     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 (!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) {
+    if (shouldCreateScriptsDir && (!existsSync(scriptsIndexPath) || options.force)) {
       const hash = await writeFileWithSignature(
         scriptsIndexPath,
         generateScriptsIndexTemplate(),
@@ -2265,7 +2268,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,
@@ -2282,7 +2285,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, 
@@ -2299,7 +2302,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, 
@@ -2316,7 +2319,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, 
@@ -2333,7 +2336,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(
@@ -2351,7 +2354,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, 
@@ -2368,7 +2371,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(
@@ -2386,7 +2389,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, 
@@ -2403,7 +2406,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, 
@@ -2420,7 +2423,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(
@@ -3437,20 +3440,26 @@ async function createComponentCommand(componentName, options) {
       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);
     
@@ -3468,37 +3477,42 @@ async function createComponentCommand(componentName, options) {
     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 = [];
+
+    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);
+    }
     
-    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 (!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) {
+    if (shouldCreateTypes && (!existsSync(typesFilePath) || options.force)) {
       const typesContent = generateTypesTemplate(normalizedName);
       const hash = await writeFileWithSignature(
         typesFilePath,
@@ -3515,7 +3529,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,
@@ -3532,7 +3546,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(
@@ -3550,7 +3564,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(
@@ -3568,7 +3582,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,
@@ -3585,7 +3599,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,
@@ -3602,7 +3616,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,
@@ -3619,7 +3633,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,
@@ -3636,7 +3650,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,
@@ -3653,7 +3667,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,
@@ -3670,7 +3684,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(
@@ -4305,7 +4319,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();
@@ -4317,6 +4348,9 @@ async function adoptCommand(identifier, options) {
     };
 
     let filesToAdopt = [];
+    let identifier = kind;
+    let customName = null;
+    let sourcePath = null;
 
     if (!identifier && options.all) {
       // Adopt all untracked files in all roots
@@ -4327,6 +4361,43 @@ 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 (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 (existsSync(absoluteSource)) {
+        if (!options.dryRun && absoluteSource !== absoluteTarget) {
+          if (!existsSync(path.dirname(absoluteTarget))) {
+            await mkdir(path.dirname(absoluteTarget), { recursive: true });
+          }
+          console.log(`Moving files from ${sourcePath} to ${path.relative(process.cwd(), targetPath)}...`);
+          await 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();
       
@@ -4601,6 +4672,61 @@ async function pruneMissingCommand(options = {}) {
   }
 }
 
+/**
+ * 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;
+  }
+}
+
 /**
  * Dispatcher for rename commands.
  */
@@ -4825,7 +4951,7 @@ program
   .action(syncCommand);
 
 program
-  .command('adopt [path]')
+  .command('adopt [kind] [arg2] [arg3]')
   .description('Adopt untracked files into Textor state, adding signatures')
   .option('--all', 'Adopt all untracked files in managed directories')
   .option('--dry-run', 'Show what would be adopted without applying')
@@ -4860,5 +4986,12 @@ program
   .option('--dry-run', 'Show what would be renamed without applying')
   .action(renameCommand);
 
+program
+  .command('add <item> <target>')
+  .description('Add a sub-item (api, hook, test, etc.) to an existing feature or component')
+  .option('--force', 'Overwrite existing files')
+  .option('--dry-run', 'Show what would be created without creating')
+  .action(addItemCommand);
+
 program.parse();
 //# sourceMappingURL=textor.js.map

package/dist/bin/textor.js.map

@@ -1 +1 @@
-{"version":3,"file":"textor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"textor.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}