@oamm/textor 1.0.14 → 1.0.16

package/dist/index.d.ts

@@ -31,7 +31,7 @@ declare function statusCommand(): Promise<void>;
 
 declare function syncCommand(options: any): Promise<void>;
 
-declare function adoptCommand(identifier: any, options: any): Promise<void>;
+declare function adoptCommand(kind: any, arg2: any, arg3: any, options: any): Promise<void>;
 
 declare function upgradeConfigCommand(options: any): Promise<void>;
 

package/dist/index.js

@@ -1534,18 +1534,26 @@ function reconstructSections(state, config) {
     // Keep existing sections if their files still exist
     const validSections = (state.sections || []).filter(section => {
         // Check if route file exists in state.files
-        const routeFile = Object.keys(files).find(f => {
+        const routeFile = section.route ? Object.keys(files).find(f => {
             const normalizedF = f.replace(/\\/g, '/');
             const routePath = section.route === '/' ? 'index' : section.route.slice(1);
             return normalizedF.startsWith(pagesRoot + '/' + routePath + '.') ||
                 normalizedF === pagesRoot + '/' + routePath + '/index.astro'; // nested mode
-        });
+        }) : true;
         // Check if feature directory has at least one file in state.files
-        const hasFeatureFiles = Object.keys(files).some(f => f.replace(/\\/g, '/').startsWith(section.featurePath.replace(/\\/g, '/') + '/'));
+        const hasFeatureFiles = section.featurePath ? Object.keys(files).some(f => {
+            const normalizedF = f.replace(/\\/g, '/');
+            const featPath = section.featurePath.replace(/\\/g, '/');
+            return normalizedF.startsWith(featPath + '/') ||
+                normalizedF.startsWith(featuresRoot + '/' + featPath + '/');
+        }) : false;
         return routeFile && hasFeatureFiles;
     });
     const sections = new Map();
-    validSections.forEach(s => sections.set(s.route, s));
+    validSections.forEach(s => {
+        const key = s.route || `feature:${s.featurePath}`;
+        sections.set(key, s);
+    });
     // Try to discover new sections
     for (const filePath in files) {
         const normalizedPath = filePath.replace(/\\/g, '/');
@@ -3636,7 +3644,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();
@@ -3646,6 +3671,9 @@ async function adoptCommand(identifier, options) {
             components: resolvePath(config, 'components')
         };
         let filesToAdopt = [];
+        let identifier = kind;
+        let customName = null;
+        let sourcePath = null;
         if (!identifier && options.all) {
             // Adopt all untracked files in all roots
             const managedFiles = new Set();
@@ -3656,6 +3684,46 @@ async function adoptCommand(identifier, options) {
             }
             filesToAdopt = Array.from(managedFiles).filter(f => !state.files[f]);
         }
+        else if (kind === 'component' && arg2) {
+            const componentName = arg2;
+            const untrackedFiles = new Set();
+            const compPath = path.join(roots.components, componentName);
+            if (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();
             // 1. Try as direct path