ai-flow-dev 2.2.1 → 2.2.4

package/dist/cli.js

@@ -13,40 +13,73 @@ const __dirname = dirname(__filename);
 const ROOT_DIR = path.resolve(__dirname, '..');
 const program = new Command();
 const AI_TOOLS = [
-    {
-        name: 'GitHub Copilot',
-        value: 'copilot',
-        description: '',
-    },
-    {
-        name: 'Claude Code',
-        value: 'claude',
-        description: '',
-    },
-    {
-        name: 'Cursor',
-        value: 'cursor',
-        description: '',
-    },
-    {
-        name: 'Gemini',
-        value: 'gemini',
-        description: '',
+    { name: 'GitHub Copilot', value: 'copilot', description: '' },
+    { name: 'Claude Code', value: 'claude', description: '' },
+    { name: 'Cursor', value: 'cursor', description: '' },
+    { name: 'Gemini', value: 'gemini', description: '' },
+    { name: 'Antigravity', value: 'antigravity', description: '' },
+    { name: 'All AI Tools', value: 'all', description: '' },
+];
+const SLASH_COMMANDS = [
+    { name: '/flow-build', desc: 'Full documentation flow' },
+    { name: '/flow-work', desc: 'Development orchestrator (feature, refactor, fix, resume)' },
+    { name: '/flow-check', desc: 'Combined code review & testing workflow' },
+    { name: '/flow-commit', desc: 'Atomic commits (Conventional Commits)' },
+    { name: '/flow-docs-sync', desc: 'Sincronización de documentación' },
+];
+const PROJECT_PHASES = {
+    backend: {
+        label: 'Backend',
+        phases: [
+            'fase 0: Context Discovery (proyectos existentes)',
+            'fase 1: Discovery & Business',
+            'fase 2: Data Architecture',
+            'fase 3: System Architecture',
+            'fase 4: Security & Auth',
+            'fase 5: Code Standards',
+            'fase 6: Testing',
+            'fase 7: Operations + Tools',
+            'fase 8: Project Setup & Final Docs',
+            'fase 9: Implementation Roadmap (opcional)',
+            'fase 10: User Stories Generation (opcional)',
+        ],
     },
-    {
-        name: 'Antigravity',
-        value: 'antigravity',
-        description: '',
+    frontend: {
+        label: 'Frontend',
+        phases: [
+            'fase 0: Context Discovery (proyectos existentes)',
+            'fase 1: Discovery & UX',
+            'fase 2: Components & Framework',
+            'fase 3: State Management',
+            'fase 4: Styling & Design',
+            'fase 5: Code Standards',
+            'fase 6: Testing',
+            'fase 7: Deployment',
+            'fase 8: Project Setup & Final Docs',
+            'fase 9: Implementation Roadmap (opcional)',
+            'fase 10: User Stories Generation (opcional)',
+        ],
     },
-    {
-        name: 'All AI Tools',
-        value: 'all',
-        description: '',
+    mobile: {
+        label: 'Mobile',
+        phases: [
+            'fase 0: Context Discovery (proyectos existentes)',
+            'fase 1: Platform & Framework Selection',
+            'fase 2: Navigation & Architecture',
+            'fase 3: State & Data Management',
+            'fase 4: Permissions & Native Features',
+            'fase 5: Code Standards',
+            'fase 6: Testing Strategy',
+            'fase 7: Store Deployment',
+            'fase 8: Project Setup & Final Documentation',
+            'fase 9: Implementation Roadmap (opcional)',
+            'fase 10: User Stories Generation (opcional)',
+        ],
     },
-];
-// Read package.json for version
-const packageJsonPath = path.join(__dirname, '..', 'package.json');
-const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+};
+// Read package.json for version (Sync for top-level usage)
+const packageJsonPath = path.join(ROOT_DIR, 'package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
 const PKG_VERSION = packageJson.version;
 const EXIT = {
     OK: 0,
@@ -75,23 +108,21 @@ function fsErrorMessage(e) {
     const msg = anyErr && anyErr.message ? String(anyErr.message) : String(e);
     return `${code}: ${msg}`;
 }
-async function selectAITool(providedTool) {
-    if (providedTool) {
-        const tool = AI_TOOLS.find((t) => t.value === providedTool);
-        if (!tool) {
-            console.error(chalk.red(`❌ Invalid AI tool: ${providedTool}`));
-            console.log(chalk.yellow('Available options: claude, cursor, copilot, gemini, antigravity, all'));
-            process.exit(EXIT.INVALID_ARGS);
-        }
-        return providedTool === 'all'
-            ? ['claude', 'cursor', 'copilot', 'gemini', 'antigravity']
-            : [providedTool];
-    }
-    // If no TTY available (non-interactive mode, e.g., in tests), default to copilot
-    if (!process.stdin.isTTY) {
-        return ['copilot'];
+function getProjectTypeLabel(type) {
+    switch (type) {
+        case 'backend':
+            return 'Backend';
+        case 'frontend':
+            return 'Frontend';
+        case 'fullstack':
+            return 'Full Stack';
+        case 'mobile':
+            return 'Mobile';
+        default:
+            return type;
     }
-    // Display banner
+}
+function printBanner() {
     console.log('\n');
     console.log(chalk.cyan('    ╔═══════════════════════════════════════════════════════════════════╗'));
     console.log(chalk.cyan('    ║') +
@@ -134,19 +165,75 @@ async function selectAITool(providedTool) {
         chalk.cyan('║'));
     console.log(chalk.cyan('    ╚═══════════════════════════════════════════════════════════════════╝'));
     console.log('\n');
-    console.log(chalk.white('    📂 Project Setup'));
+    console.log(chalk.white('    📂 Project Context'));
     console.log(chalk.gray('    ────────────────────────────────────────────────────────────────────'));
     console.log(chalk.gray(`    Working Directory: ${process.cwd()}`));
-    console.log(chalk.gray('    Version: 2.2.0'));
+    console.log(chalk.gray(`    Version: ${PKG_VERSION}`));
     console.log('\n');
+}
+function printAvailableCommands(projectType) {
+    console.log(chalk.white('Available slash commands:'));
+    for (const cmd of SLASH_COMMANDS) {
+        console.log(chalk.gray(`  ${cmd.name.padEnd(25)} - ${cmd.desc}`));
+    }
+    const phasesInfo = PROJECT_PHASES[projectType === 'fullstack' ? 'backend' : projectType];
+    if (phasesInfo) {
+        console.log(chalk.gray(`\n  Fases disponibles (${phasesInfo.label}):`));
+        for (const phase of phasesInfo.phases) {
+            console.log(chalk.gray(`    ${phase}`));
+        }
+    }
+}
+function printNextSteps(config) {
+    const toolsText = config.aiTools.length === 1
+        ? config.aiTools[0]
+        : `${config.aiTools.slice(0, -1).join(', ')} and ${config.aiTools[config.aiTools.length - 1]}`;
+    console.log(chalk.white('\nNext steps:'));
+    if (config.projectType === 'fullstack') {
+        const aiToolName = config.aiTools.includes('claude')
+            ? 'Claude Code'
+            : config.aiTools.includes('cursor')
+                ? 'Cursor'
+                : toolsText;
+        console.log(chalk.cyan(`  1. Open your AI tool (${aiToolName})`));
+        console.log(chalk.cyan('  2. Backend Prompts:  /backend-flow-build'));
+        console.log(chalk.cyan('  3. Frontend Prompts: /frontend-flow-build'));
+        console.log(chalk.gray('     Each will guide you through up to 11 phases (0-10)\n'));
+    }
+    else {
+        const aiToolName = config.aiTools.includes('claude')
+            ? 'Claude Code'
+            : config.aiTools.includes('cursor')
+                ? 'Cursor'
+                : config.aiTools.includes('antigravity')
+                    ? 'Antigravity'
+                    : toolsText;
+        console.log(chalk.cyan(`  1. Open ${aiToolName}`));
+        console.log(chalk.cyan('  2. Run: /flow-build'));
+        console.log(chalk.gray('     This will guide you through up to 11 phases (0-10)\n'));
+    }
+    printAvailableCommands(config.projectType);
+}
+async function selectAITool(providedTool) {
+    if (providedTool) {
+        const tool = AI_TOOLS.find((t) => t.value === providedTool);
+        if (!tool) {
+            console.error(chalk.red(`❌ Invalid AI tool: ${providedTool}`));
+            console.log(chalk.yellow('Available options: claude, cursor, copilot, gemini, antigravity, all'));
+            process.exit(EXIT.INVALID_ARGS);
+        }
+        return providedTool === 'all'
+            ? ['claude', 'cursor', 'copilot', 'gemini', 'antigravity']
+            : [providedTool];
+    }
+    if (!process.stdin.isTTY)
+        return ['copilot'];
+    printBanner();
     console.log(chalk.white('    🤖 Select your AI development tool:'));
     console.log(chalk.gray('    ────────────────────────────────────────────────────────────────────'));
     const selectedTool = await select({
         message: 'Select your AI tool:',
-        choices: AI_TOOLS.map((tool) => ({
-            name: tool.name,
-            value: tool.value,
-        })),
+        choices: AI_TOOLS.map((tool) => ({ name: tool.name, value: tool.value })),
         default: 'copilot',
     });
     return selectedTool === 'all'
@@ -154,7 +241,6 @@ async function selectAITool(providedTool) {
         : [selectedTool];
 }
 async function selectProjectType(providedType) {
-    // v1.4.0: Backend, Frontend, Fullstack, and Mobile supported
     if (providedType) {
         const valid = ['backend', 'frontend', 'fullstack', 'mobile'];
         if (!valid.includes(providedType)) {
@@ -164,11 +250,8 @@ async function selectProjectType(providedType) {
         }
         return providedType;
     }
-    // If no TTY available (non-interactive mode, e.g., in tests), default to backend
-    if (!process.stdin.isTTY) {
+    if (!process.stdin.isTTY)
         return 'backend';
-    }
-    // v1.4.0: Interactive selection for backend/frontend/fullstack/mobile
     const projectType = await select({
         message: 'What type of project are you building?',
         choices: [
@@ -182,14 +265,12 @@ async function selectProjectType(providedType) {
     return projectType;
 }
 async function checkIfInitialized(targetPath) {
-    const bootstrapPath = path.join(targetPath, '.ai-flow');
-    return await fs.pathExists(bootstrapPath);
+    return await fs.pathExists(path.join(targetPath, '.ai-flow'));
 }
 async function createBootstrapStructure(targetPath, aiTools, projectType = 'backend', dryRun, verbose) {
     const spinner = ora('Creating .ai-flow structure...').start();
     try {
         const bootstrapPath = path.join(targetPath, '.ai-flow');
-        // Create core directories
         if (dryRun) {
             spinner.succeed('Created .ai-flow structure (dry-run)');
             return;
@@ -199,19 +280,16 @@ async function createBootstrapStructure(targetPath, aiTools, projectType = 'back
         await fs.ensureDir(path.join(bootstrapPath, 'prompts'));
         await fs.ensureDir(path.join(bootstrapPath, 'templates', 'docs'));
         await fs.ensureDir(path.join(bootstrapPath, 'templates', 'specs'));
-        // Create config file with new projectType field
         const config = {
             version: PKG_VERSION,
-            aiTools: aiTools,
+            aiTools,
             createdAt: new Date().toISOString(),
-            projectType: projectType,
-            // Deprecated fields for backward compatibility
+            projectType,
             backend: projectType === 'backend' || projectType === 'fullstack',
             frontend: projectType === 'frontend' || projectType === 'fullstack',
             mobile: projectType === 'mobile',
         };
         await fs.writeJSON(path.join(bootstrapPath, 'core', 'config.json'), config, { spaces: 2 });
-        logVerbose(`Wrote ${path.join(bootstrapPath, 'core', 'config.json')}`, verbose);
         spinner.succeed('Created .ai-flow structure');
     }
     catch (error) {
@@ -222,109 +300,80 @@ async function createBootstrapStructure(targetPath, aiTools, projectType = 'back
 async function copyTemplates(targetPath, projectType = 'backend', aiTools = [], dryRun, verbose) {
     const spinner = ora('Copying templates to .ai-flow/templates/...').start();
     try {
-        // Templates are copied WITHOUT rendering to .ai-flow/templates/
-        // Phase 8 will render them to project root
         if (dryRun) {
             spinner.succeed('Templates copied (dry-run)');
             return;
         }
-        await assertDirWritable(targetPath);
         const destTemplatesPath = path.join(targetPath, '.ai-flow', 'templates');
-        // Find all .template.md and .template files in a directory and subfolders
         const walk = async (dir) => {
             let files = [];
             for (const entry of await fs.readdir(dir)) {
                 const fullPath = path.join(dir, entry);
                 const stat = await fs.stat(fullPath);
-                if (stat.isDirectory()) {
+                if (stat.isDirectory())
                     files = files.concat(await walk(fullPath));
-                }
-                else if (entry.endsWith('.template.md') || entry.endsWith('.template')) {
+                else if (entry.endsWith('.template.md') || entry.endsWith('.template'))
                     files.push(fullPath);
-                }
             }
             return files;
         };
-        // Collect template files from project-type-specific directories
         const templateSources = [];
-        // Always include root templates (AGENT.template.md)
-        const rootTemplatesSource = path.join(ROOT_DIR, 'templates');
         const processedFiles = new Map();
-        // Only scan root level files (not subdirectories)
-        const allRootItems = await fs.readdir(rootTemplatesSource);
-        for (const item of allRootItems) {
+        const rootTemplatesSource = path.join(ROOT_DIR, 'templates');
+        for (const item of await fs.readdir(rootTemplatesSource)) {
             const fullPath = path.join(rootTemplatesSource, item);
-            const stat = await fs.stat(fullPath);
-            if (stat.isFile() && item.endsWith('.template.md')) {
+            if ((await fs.stat(fullPath)).isFile() && item.endsWith('.template.md')) {
                 processedFiles.set(item, { file: fullPath, base: rootTemplatesSource });
             }
         }
-        // Include project-type-specific templates
-        if (projectType === 'backend') {
-            const backendSource = path.join(ROOT_DIR, 'templates', 'backend');
-            templateSources.push({ source: backendSource, base: backendSource });
-        }
-        else if (projectType === 'frontend') {
-            const frontendSource = path.join(ROOT_DIR, 'templates', 'frontend');
-            templateSources.push({ source: frontendSource, base: frontendSource });
-        }
+        if (projectType === 'backend')
+            templateSources.push({
+                source: path.join(ROOT_DIR, 'templates', 'backend'),
+                base: path.join(ROOT_DIR, 'templates', 'backend'),
+            });
+        else if (projectType === 'frontend')
+            templateSources.push({
+                source: path.join(ROOT_DIR, 'templates', 'frontend'),
+                base: path.join(ROOT_DIR, 'templates', 'frontend'),
+            });
         else if (projectType === 'fullstack') {
-            // v1.3.0: Copy both backend and frontend templates
-            // Priority: fullstack-specific templates > backend templates > frontend templates
             const fullstackSource = path.join(ROOT_DIR, 'templates', 'fullstack');
-            const backendSource = path.join(ROOT_DIR, 'templates', 'backend');
-            const frontendSource = path.join(ROOT_DIR, 'templates', 'frontend');
-            // Check if fullstack templates directory exists
-            const fullstackExists = await fs.pathExists(fullstackSource);
-            if (fullstackExists) {
-                templateSources.push({
-                    source: fullstackSource,
-                    base: fullstackSource,
-                });
-            }
-            // Backend templates (used as base for conflicts)
-            templateSources.push({ source: backendSource, base: backendSource });
-            // Frontend templates (will overwrite only if not in fullstack and not conflicting with backend)
-            templateSources.push({ source: frontendSource, base: frontendSource });
-        }
-        else if (projectType === 'mobile') {
-            // v1.4.0: Copy mobile templates
-            const mobileSource = path.join(ROOT_DIR, 'templates', 'mobile');
-            templateSources.push({ source: mobileSource, base: mobileSource });
+            if (await fs.pathExists(fullstackSource))
+                templateSources.push({ source: fullstackSource, base: fullstackSource });
+            templateSources.push({
+                source: path.join(ROOT_DIR, 'templates', 'backend'),
+                base: path.join(ROOT_DIR, 'templates', 'backend'),
+            });
+            templateSources.push({
+                source: path.join(ROOT_DIR, 'templates', 'frontend'),
+                base: path.join(ROOT_DIR, 'templates', 'frontend'),
+            });
         }
-        // Walk all source directories and collect template files
-        // For fullstack, use a Map to track processed files (priority: root > fullstack > backend > frontend)
+        else if (projectType === 'mobile')
+            templateSources.push({
+                source: path.join(ROOT_DIR, 'templates', 'mobile'),
+                base: path.join(ROOT_DIR, 'templates', 'mobile'),
+            });
         for (const { source, base } of templateSources) {
-            const files = await walk(source);
-            for (const file of files) {
+            for (const file of await walk(source)) {
                 const relPath = path.relative(base, file);
-                // Only add if not already processed (first occurrence wins)
-                if (!processedFiles.has(relPath)) {
+                if (!processedFiles.has(relPath))
                     processedFiles.set(relPath, { file, base });
-                }
             }
         }
-        // Copy each template WITHOUT rendering to .ai-flow/templates/
         for (const [relPath, { file: templateFile }] of processedFiles) {
-            // Skip AI tool-specific config files if the tool is not selected
             const fileName = path.basename(relPath);
             if (fileName === '.clauderules.template' &&
                 !aiTools.includes('claude') &&
-                !aiTools.includes('all')) {
-                logVerbose(`Skipping ${relPath} (Claude not selected)`, verbose);
+                !aiTools.includes('all'))
                 continue;
-            }
             if (fileName === '.cursorrules.template' &&
                 !aiTools.includes('cursor') &&
-                !aiTools.includes('all')) {
-                logVerbose(`Skipping ${relPath} (Cursor not selected)`, verbose);
+                !aiTools.includes('all'))
                 continue;
-            }
-            // Preserve original file structure with .template extension
             const destPath = path.join(destTemplatesPath, relPath);
             await fs.ensureDir(path.dirname(destPath));
             await fs.copy(templateFile, destPath);
-            logVerbose(`Copied ${relPath}`, verbose);
         }
         spinner.succeed('Templates copied');
     }
@@ -344,7 +393,6 @@ async function copyPrompts(targetPath, dryRun, verbose) {
         }
         await assertDirWritable(promptsTarget);
         await fs.copy(promptsSource, promptsTarget);
-        logVerbose(`Copied prompts to ${promptsTarget}`, verbose);
         spinner.succeed('Master prompts copied');
     }
     catch (error) {
@@ -355,16 +403,12 @@ async function copyPrompts(targetPath, dryRun, verbose) {
 async function setupSlashCommands(targetPath, aiTools, projectType = 'backend', dryRun, verbose) {
     const spinner = ora('Setting up slash commands...').start();
     try {
-        // Determine which prompt directories to copy from
         const promptSources = [];
-        if (projectType === 'backend') {
+        if (projectType === 'backend')
             promptSources.push({ dir: 'backend' });
-        }
-        else if (projectType === 'frontend') {
+        else if (projectType === 'frontend')
             promptSources.push({ dir: 'frontend' });
-        }
         else if (projectType === 'fullstack') {
-            // For fullstack, copy both with prefixes
             promptSources.push({ dir: 'backend', prefix: 'backend-' });
             promptSources.push({ dir: 'frontend', prefix: 'frontend-' });
         }
@@ -374,7 +418,6 @@ async function setupSlashCommands(targetPath, aiTools, projectType = 'backend',
         for (const { dir, prefix } of promptSources) {
             const promptsSource = path.join(ROOT_DIR, 'prompts', dir);
             const allFiles = await fs.readdir(promptsSource);
-            // Filter markdown files, excluding internal logic files (they are loaded by main commands)
             const files = allFiles.filter((file) => {
                 const isMarkdown = file.endsWith('.md');
                 const isInternalPhase = file.match(/^flow-build-phase-\d+.*\.md$/);
@@ -383,82 +426,31 @@ async function setupSlashCommands(targetPath, aiTools, projectType = 'backend',
                 return isMarkdown && !isInternalPhase && !isInternalWork && !isInternalCheck;
             });
             for (const tool of aiTools) {
+                let commandsTarget = '';
+                let extension = '.md';
                 if (tool === 'copilot') {
-                    // Copilot: prompts in .github/prompts with .prompt.md suffix
-                    const promptsTarget = path.join(targetPath, '.github', 'prompts');
-                    if (!dryRun) {
-                        await assertDirWritable(promptsTarget);
-                        await fs.ensureDir(promptsTarget);
-                    }
-                    for (const file of files) {
-                        const srcFile = path.join(promptsSource, file);
-                        const base = file.replace(/\.md$/, '');
-                        const destName = prefix ? `${prefix}${base}.prompt.md` : `${base}.prompt.md`;
-                        const destFile = path.join(promptsTarget, destName);
-                        if (!dryRun)
-                            await fs.copyFile(srcFile, destFile);
-                        logVerbose(`Installed ${destFile}`, verbose);
-                    }
-                }
-                else if (tool === 'claude') {
-                    const commandsTarget = path.join(targetPath, '.claude', 'commands');
-                    if (!dryRun) {
-                        await assertDirWritable(commandsTarget);
-                        await fs.ensureDir(commandsTarget);
-                    }
-                    for (const file of files) {
-                        const srcFile = path.join(promptsSource, file);
-                        const destName = prefix ? `${prefix}${file}` : file;
-                        const destFile = path.join(commandsTarget, destName);
-                        if (!dryRun)
-                            await fs.copyFile(srcFile, destFile);
-                        logVerbose(`Installed ${destFile}`, verbose);
-                    }
-                }
-                else if (tool === 'cursor') {
-                    const commandsTarget = path.join(targetPath, '.cursor', 'commands');
-                    if (!dryRun) {
-                        await assertDirWritable(commandsTarget);
-                        await fs.ensureDir(commandsTarget);
-                    }
-                    for (const file of files) {
-                        const srcFile = path.join(promptsSource, file);
-                        const destName = prefix ? `${prefix}${file}` : file;
-                        const destFile = path.join(commandsTarget, destName);
-                        if (!dryRun)
-                            await fs.copyFile(srcFile, destFile);
-                        logVerbose(`Installed ${destFile}`, verbose);
-                    }
+                    commandsTarget = path.join(targetPath, '.github', 'prompts');
+                    extension = '.prompt.md';
                 }
-                else if (tool === 'gemini') {
-                    const commandsTarget = path.join(targetPath, '.gemini', 'commands');
-                    if (!dryRun) {
-                        await assertDirWritable(commandsTarget);
-                        await fs.ensureDir(commandsTarget);
-                    }
-                    for (const file of files) {
-                        const srcFile = path.join(promptsSource, file);
-                        const destName = prefix ? `${prefix}${file}` : file;
-                        const destFile = path.join(commandsTarget, destName);
-                        if (!dryRun)
-                            await fs.copyFile(srcFile, destFile);
-                        logVerbose(`Installed ${destFile}`, verbose);
-                    }
+                else if (tool === 'claude')
+                    commandsTarget = path.join(targetPath, '.claude', 'commands');
+                else if (tool === 'cursor')
+                    commandsTarget = path.join(targetPath, '.cursor', 'commands');
+                else if (tool === 'gemini')
+                    commandsTarget = path.join(targetPath, '.gemini', 'commands');
+                else if (tool === 'antigravity')
+                    commandsTarget = path.join(targetPath, '.agent', 'workflows');
+                if (!dryRun && commandsTarget) {
+                    await assertDirWritable(commandsTarget);
+                    await fs.ensureDir(commandsTarget);
                 }
-                else if (tool === 'antigravity') {
-                    const workflowsTarget = path.join(targetPath, '.agent', 'workflows');
-                    if (!dryRun) {
-                        await assertDirWritable(workflowsTarget);
-                        await fs.ensureDir(workflowsTarget);
-                    }
-                    for (const file of files) {
-                        const srcFile = path.join(promptsSource, file);
-                        const destName = prefix ? `${prefix}${file}` : file;
-                        const destFile = path.join(workflowsTarget, destName);
-                        if (!dryRun)
-                            await fs.copyFile(srcFile, destFile);
-                        logVerbose(`Installed ${destFile}`, verbose);
-                    }
+                for (const file of files) {
+                    const srcFile = path.join(promptsSource, file);
+                    const base = file.replace(/\.md$/, '');
+                    const destName = prefix ? `${prefix}${base}${extension}` : `${base}${extension}`;
+                    const destFile = path.join(commandsTarget, destName);
+                    if (!dryRun)
+                        await fs.copyFile(srcFile, destFile);
                 }
             }
         }
@@ -471,41 +463,27 @@ async function setupSlashCommands(targetPath, aiTools, projectType = 'backend',
 }
 async function initializeProject(targetPath, aiTool, projectType, projectName, projectDescription, flags) {
     try {
-        // Check if already initialized
-        const isInitialized = await checkIfInitialized(targetPath);
-        if (isInitialized) {
+        if (await checkIfInitialized(targetPath)) {
             console.log(chalk.yellow('\n⚠️  Project already initialized with AI Flow'));
             let reinitialize = false;
-            if (process.stdin.isTTY) {
-                reinitialize = await confirm({
-                    message: 'Do you want to reinitialize?',
-                    default: false,
-                });
-            }
+            if (process.stdin.isTTY)
+                reinitialize = await confirm({ message: 'Do you want to reinitialize?', default: false });
             if (!reinitialize) {
                 console.log(chalk.blue('Initialization cancelled'));
                 return;
             }
         }
-        // Select AI tools
         const aiTools = await selectAITool(aiTool);
-        // Select project type (v1.2.0: backend or frontend)
         const selectedProjectType = await selectProjectType(projectType);
-        // Infer project name from directory
         const inferredName = path
             .basename(targetPath)
             .split('-')
             .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
             .join(' ');
-        // Request minimal project data only if not provided
         if (projectName && !isValidName(projectName)) {
             console.error(chalk.red('Invalid project name'));
             process.exit(EXIT.INVALID_ARGS);
         }
-        if (projectDescription && !isValidDescription(projectDescription)) {
-            console.error(chalk.red('Invalid project description'));
-            process.exit(EXIT.INVALID_ARGS);
-        }
         let finalProjectName = projectName;
         if (!finalProjectName) {
             if (process.stdin.isTTY) {
@@ -515,131 +493,23 @@ async function initializeProject(targetPath, aiTool, projectType, projectName, p
                     validate: (input) => isValidName(input) || 'Enter 2-100 chars: letters, numbers, space, - _ .',
                 });
             }
-            else {
+            else
                 finalProjectName = inferredName;
-            }
         }
         console.log(chalk.cyan('\n📦 Initializing AI Flow...\n'));
-        // Create structure
         await createBootstrapStructure(targetPath, aiTools, selectedProjectType, flags?.dryRun, flags?.verbose);
         await copyTemplates(targetPath, selectedProjectType, aiTools, flags?.dryRun, flags?.verbose);
         await copyPrompts(targetPath, flags?.dryRun, flags?.verbose);
         await setupSlashCommands(targetPath, aiTools, selectedProjectType, flags?.dryRun, flags?.verbose);
-        const modeText = flags?.dryRun ? 'DRY-RUN' : 'WRITE';
         console.log(chalk.green('\n✅ AI Flow initialized successfully!'));
         console.log(chalk.white('\nSummary:'));
-        console.log(chalk.gray(`  Project: ${finalProjectName}`));
-        console.log(chalk.gray(`  Version: ${PKG_VERSION}`));
+        console.log(chalk.gray(`  Project:   ${finalProjectName}`));
+        console.log(chalk.gray(`  Version:   ${PKG_VERSION}`));
         console.log(chalk.gray(`  Directory: ${targetPath}`));
-        console.log(chalk.gray(`  Tools: ${aiTools.join(', ')}`));
-        console.log(chalk.gray(`  Mode: ${modeText}`));
-        console.log(chalk.white('\nNext steps:\n'));
-        const toolsText = aiTools.length === 1
-            ? aiTools[0]
-            : `${aiTools.slice(0, -1).join(', ')} and ${aiTools[aiTools.length - 1]}`;
-        if (selectedProjectType === 'fullstack') {
-            if (aiTools.includes('claude')) {
-                console.log(chalk.cyan('  1. Open Claude Code'));
-                console.log(chalk.cyan('  2. Run: /backend-flow-build (for backend documentation)'));
-                console.log(chalk.cyan('  3. Run: /frontend-flow-build (for frontend documentation)'));
-                console.log(chalk.gray('     Each will guide you through up to 11 phases (0-10)\n'));
-            }
-            else if (aiTools.includes('cursor')) {
-                console.log(chalk.cyan('  1. Open Cursor'));
-                console.log(chalk.cyan('  2. Run: /backend-flow-build (for backend documentation)'));
-                console.log(chalk.cyan('  3. Run: /frontend-flow-build (for frontend documentation)'));
-                console.log(chalk.gray('     Each will guide you through up to 11 phases (0-10)\n'));
-            }
-            else {
-                console.log(chalk.cyan(`  1. Open your AI tool (${toolsText})`));
-                console.log(chalk.cyan('  2. Run: /backend-flow-build (for backend documentation)'));
-                console.log(chalk.cyan('  3. Run: /frontend-flow-build (for frontend documentation)'));
-                console.log(chalk.gray('     Each will guide you through up to 11 phases (0-10)\n'));
-            }
-            console.log(chalk.white('Available slash commands:'));
-            console.log(chalk.gray('  Backend commands:'));
-            console.log(chalk.gray('    /backend-flow-build                - Flujo completo (9 fases en orden)'));
-            console.log(chalk.gray('    /backend-flow-build fase N         - Fase específica (0-9)'));
-            console.log(chalk.gray('    /backend-flow-docs-sync            - Update backend documentation\n'));
-            console.log(chalk.gray('  Frontend commands:'));
-            console.log(chalk.gray('    /frontend-flow-build               - Flujo completo (8 fases en orden)'));
-            console.log(chalk.gray('    /frontend-flow-build fase N        - Fase específica (0-8)'));
-            console.log(chalk.gray('    /frontend-flow-docs-sync           - Update frontend documentation\n'));
-        }
-        else if (selectedProjectType === 'mobile') {
-            if (aiTools.includes('claude')) {
-                console.log(chalk.cyan('  1. Open Claude Code'));
-                console.log(chalk.cyan('  2. Run: /flow-build'));
-                console.log(chalk.gray('     This will start the 9-phase interactive setup\n'));
-            }
-            else if (aiTools.includes('cursor')) {
-                console.log(chalk.cyan('  1. Open Cursor'));
-                console.log(chalk.cyan('  2. Run: /flow-build'));
-                console.log(chalk.gray('     This will start the 9-phase interactive setup\n'));
-            }
-            else {
-                console.log(chalk.cyan(`  1. Open your AI tool (${toolsText})`));
-                console.log(chalk.cyan('  2. Run: /flow-build'));
-                console.log(chalk.gray('     This will start the 9-phase interactive setup\n'));
-            }
-            console.log(chalk.white('Available slash commands:'));
-            console.log(chalk.gray('  /flow-build                - Flujo completo (8 fases en orden)'));
-            console.log(chalk.gray('  /flow-build fase N         - Fase específica (0-8: Discovery, Platform, Navigation, State, Permissions, Standards, Testing, Deployment)'));
-            console.log(chalk.gray('  /flow-docs-sync            - Update documentation when code changes\n'));
-        }
-        else {
-            if (aiTools.includes('claude')) {
-                console.log(chalk.cyan('  1. Open Claude Code'));
-                console.log(chalk.cyan('  2. Run: /flow-build'));
-                console.log(chalk.gray('     This will guide you through up to 11 phases (0-10)\n'));
-            }
-            else if (aiTools.includes('cursor')) {
-                console.log(chalk.cyan('  1. Open Cursor'));
-                console.log(chalk.cyan('  2. Run: /flow-build'));
-                console.log(chalk.gray('     This will guide you through up to 11 phases (0-10)\n'));
-            }
-            else if (aiTools.includes('antigravity')) {
-                console.log(chalk.cyan('  1. Use Antigravity commands'));
-                console.log(chalk.cyan('  2. Run: /flow-build'));
-                console.log(chalk.gray('     This will guide you through up to 11 phases (0-10)\n'));
-            }
-            else {
-                console.log(chalk.cyan(`  1. Open your AI tool (${toolsText})`));
-                console.log(chalk.cyan('  2. Run: /flow-build'));
-                console.log(chalk.gray('     This will guide you through up to 11 phases (0-10)\n'));
-            }
-            console.log(chalk.white('Available slash commands:'));
-            console.log(chalk.gray('  /flow-build                - Flujo completo (todas las fases en orden)'));
-            console.log(chalk.gray('  /flow-build fase N         - Fase específica (ver lista de fases abajo)'));
-            console.log(chalk.gray('  /flow-docs-sync            - Update documentation when code changes\n'));
-            if (selectedProjectType === 'backend') {
-                console.log(chalk.gray('\n  Fases disponibles (Backend):'));
-                console.log(chalk.gray('    fase 0: Context Discovery (proyectos existentes)'));
-                console.log(chalk.gray('    fase 1: Discovery & Business'));
-                console.log(chalk.gray('    fase 2: Data Architecture'));
-                console.log(chalk.gray('    fase 3: System Architecture'));
-                console.log(chalk.gray('    fase 4: Security & Auth'));
-                console.log(chalk.gray('    fase 5: Code Standards'));
-                console.log(chalk.gray('    fase 6: Testing'));
-                console.log(chalk.gray('    fase 7: Operations + Tools'));
-                console.log(chalk.gray('    fase 8: Project Setup & Final Docs'));
-                console.log(chalk.gray('    fase 9: Implementation Roadmap (opcional)'));
-                console.log(chalk.gray('    fase 10: User Stories Generation (opcional)'));
-            }
-            else {
-                console.log(chalk.gray('\n  Fases disponibles (Frontend):'));
-                console.log(chalk.gray('    fase 0: Context Discovery (proyectos existentes)'));
-                console.log(chalk.gray('    fase 1: Discovery & UX'));
-                console.log(chalk.gray('    fase 2: Components & Framework'));
-                console.log(chalk.gray('    fase 3: State Management'));
-                console.log(chalk.gray('    fase 4: Styling & Design'));
-                console.log(chalk.gray('    fase 5: Code Standards'));
-                console.log(chalk.gray('    fase 6: Testing'));
-                console.log(chalk.gray('    fase 7: Deployment'));
-                console.log(chalk.gray('    fase 8: Project Setup & Final Docs'));
-            }
-            console.log(chalk.gray('  /flow-docs-sync                  - Update documentation when code changes\n'));
-        }
+        console.log(chalk.gray(`  Tools:     ${aiTools.join(', ')}`));
+        console.log(chalk.gray(`  Type:      ${getProjectTypeLabel(selectedProjectType)} (${selectedProjectType})`));
+        console.log(chalk.gray(`  Mode:      ${flags?.dryRun ? 'DRY-RUN' : 'WRITE'}`));
+        printNextSteps({ aiTools, projectType: selectedProjectType });
         if (flags?.dryRun) {
             console.log(chalk.yellow('⚠️ Dry-run: no files were written. Run again without --dry-run to apply changes.\n'));
         }
@@ -653,36 +523,28 @@ async function initializeProject(targetPath, aiTool, projectType, projectName, p
 // CLI Commands
 program
     .name('ai-flow')
-    .description('AI-powered development workflow from idea to production. Generate specs, plan features, and build with AI assistance.')
+    .description('AI-powered development workflow from idea to production.')
     .version(PKG_VERSION);
 program
     .command('init')
     .description('Initialize AI Flow in current directory')
     .argument('[path]', 'Target directory (defaults to current directory)', '.')
-    .option('--ai <tool>', 'AI tool to use (claude, cursor, copilot, gemini, antigravity, all)')
-    .option('--type <type>', 'Project type (backend, frontend, fullstack, mobile)')
-    .option('--name <name>', 'Project name (skip interactive prompt)')
-    .option('--description <desc>', 'Project description (skip interactive prompt)')
-    .option('--verbose', 'Enable verbose logging')
+    .option('--ai <tool>', 'AI tool to use')
+    .option('--type <type>', 'Project type')
+    .option('--name <name>', 'Project name')
+    .option('--description <desc>', 'Project description')
     .option('--dry-run', 'Simulate without writing files')
     .action(async (targetPath, options) => {
-    const absolutePath = path.resolve(targetPath);
-    const flags = {
-        dryRun: options.dryRun === true,
-        verbose: options.verbose === true,
-    };
-    await initializeProject(absolutePath, options.ai, options.type, options.name, options.description, flags);
+    await initializeProject(path.resolve(targetPath), options.ai, options.type, options.name, options.description, { dryRun: !!options.dryRun });
 });
 program
     .command('check')
     .description('Check if current directory is initialized')
     .action(async () => {
-    const isInitialized = await checkIfInitialized(process.cwd());
-    if (isInitialized) {
+    if (await checkIfInitialized(process.cwd())) {
         console.log(chalk.green('✅ Project is initialized with AI Flow'));
         const configPath = path.join(process.cwd(), '.ai-flow', 'core', 'config.json');
         const config = await fs.readJSON(configPath);
-        // Detect project type (support both old and new config format)
         const projectType = config.projectType ||
             (config.backend && !config.frontend
                 ? 'backend'
@@ -691,70 +553,12 @@ program
                     : config.mobile
                         ? 'mobile'
                         : 'backend');
-        const projectTypeDisplay = projectType === 'backend'
-            ? '🔧 Backend'
-            : projectType === 'frontend'
-                ? '🎨 Frontend'
-                : projectType === 'fullstack'
-                    ? '🚀 Full Stack'
-                    : projectType === 'mobile'
-                        ? '📱 Mobile'
-                        : '🔧 Backend';
         console.log(chalk.white('\nConfiguration:'));
         console.log(chalk.gray(`  Version: ${config.version}`));
-        console.log(chalk.gray(`  Project Type: ${projectTypeDisplay}`));
+        console.log(chalk.gray(`  Project Type: ${getProjectTypeLabel(projectType)} (${projectType})`));
         console.log(chalk.gray(`  AI Tools: ${config.aiTools.join(', ')}`));
         console.log(chalk.gray(`  Created: ${new Date(config.createdAt).toLocaleString()}`));
-        console.log(chalk.gray(`  Working Dir: ${process.cwd()}`));
-        // Show correct prompts path based on project type
-        if (projectType === 'fullstack') {
-            const backendPromptsPath = path.join(process.cwd(), '.ai-flow', 'prompts', 'backend', 'flow-build.md');
-            const frontendPromptsPath = path.join(process.cwd(), '.ai-flow', 'prompts', 'frontend', 'flow-build.md');
-            console.log(chalk.gray(`  Backend Prompts: ${backendPromptsPath}`));
-            console.log(chalk.gray(`  Frontend Prompts: ${frontendPromptsPath}`));
-        }
-        else {
-            const promptsPath = path.join(process.cwd(), '.ai-flow', 'prompts', projectType, 'flow-build.md');
-            console.log(chalk.gray(`  Prompts: ${promptsPath}`));
-        }
-        console.log(chalk.white('\nNext steps:'));
-        if (projectType === 'fullstack') {
-            if (config.aiTools.includes('claude')) {
-                console.log(chalk.cyan('  1. Open Claude Code'));
-                console.log(chalk.cyan('  2. Run: /backend-flow-build (for backend documentation)'));
-                console.log(chalk.cyan('  3. Run: /frontend-flow-build (for frontend documentation)'));
-            }
-            else if (config.aiTools.includes('cursor')) {
-                console.log(chalk.cyan('  1. Open Cursor'));
-                console.log(chalk.cyan('  2. Run: /backend-flow-build (for backend documentation)'));
-                console.log(chalk.cyan('  3. Run: /frontend-flow-build (for frontend documentation)'));
-            }
-            else {
-                const toolsText = config.aiTools.length === 1
-                    ? config.aiTools[0]
-                    : `${config.aiTools.slice(0, -1).join(', ')} and ${config.aiTools[config.aiTools.length - 1]}`;
-                console.log(chalk.cyan(`  1. Open your AI tool (${toolsText})`));
-                console.log(chalk.cyan('  2. Run: /backend-flow-build (for backend documentation)'));
-                console.log(chalk.cyan('  3. Run: /frontend-flow-build (for frontend documentation)'));
-            }
-        }
-        else {
-            if (config.aiTools.includes('claude')) {
-                console.log(chalk.cyan('  1. Open Claude Code'));
-                console.log(chalk.cyan('  2. Run: /flow-build'));
-            }
-            else if (config.aiTools.includes('cursor')) {
-                console.log(chalk.cyan('  1. Open Cursor'));
-                console.log(chalk.cyan('  2. Run: /flow-build'));
-            }
-            else {
-                const toolsText = config.aiTools.length === 1
-                    ? config.aiTools[0]
-                    : `${config.aiTools.slice(0, -1).join(', ')} and ${config.aiTools[config.aiTools.length - 1]}`;
-                console.log(chalk.cyan(`  1. Open your AI tool (${toolsText})`));
-                console.log(chalk.cyan('  2. Run: /flow-build'));
-            }
-        }
+        printNextSteps({ aiTools: config.aiTools, projectType });
     }
     else {
         console.log(chalk.yellow('⚠️  Project is not initialized'));