vibe-fabric 0.1.0 → 0.3.0

package/dist/cli/commands/init.js

@@ -7,7 +7,9 @@ import { existsSync } from 'fs';
 import { isValidProjectName, getProjectNameError } from '../../types/config.js';
 import { validateGitHubToken, discoverGitHubToken, isGhCliInstalled, isClaudeCodeInstalled, isUvInstalled, } from '../../core/github.js';
 import { createPlanningHub, isInsideVibeProject } from '../../core/project.js';
-import { isVibeProject } from '../../core/config.js';
+import { isVibeProject, loadConfig, saveConfig } from '../../core/config.js';
+import { getClaudeRecommendation, createPlannedRepo, addPlannedReposToConfig, formatTechStack, captureRequirementsWithClaude, saveDraftPrd, } from '../../core/planning.js';
+import { loadSetupState, saveSetupState, clearSetupState, createSetupState, hasSetupState, setCurrentStep, markStepCompleted, setDescription, setRecommendation, setPlannedRepos, setRequirements, getStepDisplayName, } from '../../core/state.js';
 export class InitCommand extends Command {
     static paths = [['init']];
     static usage = Command.Usage({
@@ -40,11 +42,24 @@ export class InitCommand extends Command {
     projectPath = Option.String('--path,-p', {
         description: 'Create project at specified path',
     });
+    resume = Option.Boolean('--resume,-r', false, {
+        description: 'Resume interrupted setup',
+    });
+    noCapture = Option.Boolean('--no-capture', false, {
+        description: 'Skip requirement capture (new project)',
+    });
+    noPrd = Option.Boolean('--no-prd', false, {
+        description: 'Skip PRD generation',
+    });
     async execute() {
         this.context.stdout.write('\n');
         this.context.stdout.write(chalk.bold.blue('  VIBE-FABRIC') + chalk.gray(' - AI-Collaborative Development\n'));
         this.context.stdout.write(chalk.gray('  ─'.repeat(25)) + '\n\n');
         try {
+            // Handle resume mode
+            if (this.resume) {
+                return await this.handleResume();
+            }
             // Step 1: Check prerequisites
             await this.checkPrerequisites();
             // Step 2: Get project name
@@ -61,8 +76,15 @@ export class InitCommand extends Command {
             const token = await this.setupGitHubAuth();
             // Step 7: Create planning hub
             await this.createHub(finalPath, name, projectType, token);
-            // Step 8: Show success message
-            this.showSuccess(finalPath, name);
+            // Step 8: For new projects, run the planning workflow
+            if (projectType === 'new') {
+                const { plannedRepos, requirements } = await this.runNewProjectWorkflow(finalPath, name);
+                this.showNewProjectSuccess(finalPath, name, plannedRepos, requirements);
+            }
+            else {
+                // Step 9: Show success message for existing projects
+                this.showSuccess(finalPath, name);
+            }
             return 0;
         }
         catch (error) {
@@ -74,6 +96,151 @@ export class InitCommand extends Command {
             return 1;
         }
     }
+    /**
+     * Handle resume mode
+     */
+    async handleResume() {
+        // Look for state file in current directory or specified path
+        const searchPath = this.projectPath
+            ? path.resolve(this.projectPath)
+            : process.cwd();
+        // Check if there's a state file here
+        if (!hasSetupState(searchPath)) {
+            this.context.stderr.write(chalk.red('  No interrupted setup found.\n'));
+            this.context.stdout.write(chalk.gray('  Run `vibe init` to start a new setup.\n\n'));
+            return 1;
+        }
+        const state = await loadSetupState(searchPath);
+        if (!state) {
+            this.context.stderr.write(chalk.red('  Setup state file is corrupted.\n'));
+            this.context.stdout.write(chalk.gray('  Run `vibe init` to start a new setup.\n\n'));
+            return 1;
+        }
+        this.context.stdout.write(chalk.bold.cyan('  RESUMING SETUP\n'));
+        this.context.stdout.write(chalk.gray('  ─'.repeat(25)) + '\n\n');
+        this.context.stdout.write(`  Project: ${chalk.cyan(state.projectName)}\n`);
+        this.context.stdout.write(`  Type: ${chalk.cyan(state.projectType)}\n`);
+        this.context.stdout.write(`  Last step: ${chalk.yellow(getStepDisplayName(state.currentStep))}\n\n`);
+        const resumeConfirm = await confirm({
+            message: 'Continue from where you left off?',
+            default: true,
+        });
+        if (!resumeConfirm) {
+            const restart = await confirm({
+                message: 'Start over with a fresh setup?',
+                default: false,
+            });
+            if (restart) {
+                await clearSetupState(searchPath);
+                this.context.stdout.write(chalk.gray('\n  State cleared. Run `vibe init` to start fresh.\n\n'));
+            }
+            return 1;
+        }
+        return await this.continueFromState(state);
+    }
+    /**
+     * Continue setup from saved state
+     */
+    async continueFromState(state) {
+        try {
+            switch (state.currentStep) {
+                case 'requirement-capture':
+                    return await this.continueFromRequirementCapture(state);
+                case 'prd-generation':
+                    return await this.continueFromPrdGeneration(state);
+                case 'repo-planning':
+                    // Re-run repo planning if we stopped there
+                    if (state.data.recommendation && state.data.description) {
+                        const confirmedRepos = await this.handleRecommendations(state.projectPath, state.data.description, state.data.recommendation);
+                        if (confirmedRepos.length > 0) {
+                            const spinner = ora('Creating planned repositories...').start();
+                            for (const repo of confirmedRepos) {
+                                await createPlannedRepo(state.projectPath, repo);
+                            }
+                            await addPlannedReposToConfig(state.projectPath, confirmedRepos);
+                            spinner.succeed(`Created ${confirmedRepos.length} planned repositories`);
+                            // Update state
+                            let updatedState = setPlannedRepos(state, confirmedRepos);
+                            updatedState = markStepCompleted(updatedState, 'repo-planning');
+                            updatedState = setCurrentStep(updatedState, 'requirement-capture');
+                            await saveSetupState(updatedState);
+                            // Continue to requirement capture
+                            return await this.continueFromRequirementCapture(updatedState);
+                        }
+                    }
+                    // Fallback to showing success
+                    await clearSetupState(state.projectPath);
+                    this.showNewProjectSuccess(state.projectPath, state.projectName, [], undefined);
+                    return 0;
+                default:
+                    // For other steps, just show success - hub is created
+                    await clearSetupState(state.projectPath);
+                    if (state.projectType === 'new') {
+                        this.showNewProjectSuccess(state.projectPath, state.projectName, state.data.plannedRepos || [], state.data.requirements);
+                    }
+                    else {
+                        this.showSuccess(state.projectPath, state.projectName);
+                    }
+                    return 0;
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'USER_CANCELLED') {
+                this.context.stdout.write(chalk.yellow('\nSetup cancelled. State saved for resume.\n'));
+                return 1;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Continue from requirement capture step
+     */
+    async continueFromRequirementCapture(state) {
+        if (!state.data.description || !state.data.plannedRepos) {
+            await clearSetupState(state.projectPath);
+            this.showNewProjectSuccess(state.projectPath, state.projectName, [], undefined);
+            return 0;
+        }
+        // Ask about requirement capture
+        const result = await this.runRequirementCaptureStep(state.projectPath, state.projectName, state.data.description, state.data.plannedRepos);
+        if (result.requirements) {
+            let updatedState = setRequirements(state, result.requirements);
+            updatedState = markStepCompleted(updatedState, 'requirement-capture');
+            updatedState = setCurrentStep(updatedState, 'prd-generation');
+            await saveSetupState(updatedState);
+            return await this.continueFromPrdGeneration(updatedState);
+        }
+        // Skipped or no requirements - complete
+        await clearSetupState(state.projectPath);
+        this.showNewProjectSuccess(state.projectPath, state.projectName, state.data.plannedRepos, undefined);
+        return 0;
+    }
+    /**
+     * Continue from PRD generation step
+     */
+    async continueFromPrdGeneration(state) {
+        if (!state.data.requirements || !state.data.description) {
+            await clearSetupState(state.projectPath);
+            this.showNewProjectSuccess(state.projectPath, state.projectName, state.data.plannedRepos || [], undefined);
+            return 0;
+        }
+        // Generate and save PRD
+        if (!this.noPrd) {
+            const spinner = ora('Generating draft PRD...').start();
+            try {
+                const prdPath = await saveDraftPrd(state.projectPath, state.projectName, state.data.description, state.data.requirements);
+                spinner.succeed(`Draft PRD saved to ${chalk.cyan(prdPath)}`);
+            }
+            catch (error) {
+                spinner.fail('Failed to generate PRD');
+                this.context.stderr.write(chalk.yellow(`  Warning: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+            }
+        }
+        // Complete
+        await clearSetupState(state.projectPath);
+        this.showNewProjectSuccess(state.projectPath, state.projectName, state.data.plannedRepos || [], state.data.requirements);
+        return 0;
+    }
     /**
      * Check prerequisites (Claude Code, UV)
      */
@@ -242,5 +409,494 @@ export class InitCommand extends Command {
         this.context.stdout.write(chalk.gray('  4. vibe scope         # Create work scopes\n\n'));
         this.context.stdout.write(chalk.gray('  Run ') + chalk.cyan('vibe --help') + chalk.gray(' for all commands.\n\n'));
     }
+    /**
+     * Run new project workflow: capture description, get recommendations, plan repos, capture requirements
+     */
+    async runNewProjectWorkflow(projectPath, projectName) {
+        this.context.stdout.write('\n');
+        this.context.stdout.write(chalk.bold.cyan('  NEW PROJECT PLANNING\n'));
+        this.context.stdout.write(chalk.gray('  ─'.repeat(25)) + '\n\n');
+        // Initialize state for resume functionality
+        let state = createSetupState(projectName, projectPath, 'new');
+        state = setCurrentStep(state, 'description-capture');
+        await saveSetupState(state);
+        // Step 1: Capture project description
+        const description = await this.captureProjectDescription();
+        state = setDescription(state, description);
+        state = markStepCompleted(state, 'description-capture');
+        state = setCurrentStep(state, 'claude-recommendation');
+        await saveSetupState(state);
+        // Save description to config
+        const config = await loadConfig(projectPath);
+        if (config) {
+            config.project.description = description;
+            await saveConfig(projectPath, config);
+        }
+        // Step 2: Get Claude recommendations
+        let recommendation = null;
+        let attemptCount = 0;
+        const maxAttempts = 3;
+        while (attemptCount < maxAttempts) {
+            const spinner = ora('Claude is analyzing your project and recommending structure...').start();
+            try {
+                recommendation = await getClaudeRecommendation(projectPath, description);
+                spinner.succeed('Received recommendations from Claude');
+                if (recommendation) {
+                    state = setRecommendation(state, recommendation);
+                }
+                state = markStepCompleted(state, 'claude-recommendation');
+                state = setCurrentStep(state, 'repo-planning');
+                await saveSetupState(state);
+                break;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                spinner.fail(`Failed to get recommendations: ${errorMessage}`);
+                attemptCount++;
+                if (attemptCount < maxAttempts) {
+                    const retry = await confirm({
+                        message: 'Would you like to retry?',
+                        default: true,
+                    });
+                    if (!retry) {
+                        throw new Error('USER_CANCELLED');
+                    }
+                }
+                else {
+                    this.context.stderr.write(chalk.red(`  Error: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+                    throw new Error('Failed to get Claude recommendations after multiple attempts');
+                }
+            }
+        }
+        if (!recommendation || recommendation.repos.length === 0) {
+            this.context.stdout.write(chalk.yellow('\n  No repositories recommended. You can add repos manually later.\n'));
+            await clearSetupState(projectPath);
+            return { plannedRepos: [] };
+        }
+        // Step 3: Display and confirm recommendations
+        const confirmedRepos = await this.handleRecommendations(projectPath, description, recommendation);
+        if (confirmedRepos.length === 0) {
+            this.context.stdout.write(chalk.yellow('\n  No repositories planned. You can add repos manually later.\n'));
+            await clearSetupState(projectPath);
+            return { plannedRepos: [] };
+        }
+        // Step 4: Create planned repos
+        const spinner = ora('Creating planned repositories...').start();
+        try {
+            for (const repo of confirmedRepos) {
+                await createPlannedRepo(projectPath, repo);
+            }
+            await addPlannedReposToConfig(projectPath, confirmedRepos);
+            spinner.succeed(`Created ${confirmedRepos.length} planned repositories`);
+            state = setPlannedRepos(state, confirmedRepos);
+            state = markStepCompleted(state, 'repo-planning');
+            state = setCurrentStep(state, 'requirement-capture');
+            await saveSetupState(state);
+        }
+        catch (error) {
+            spinner.fail('Failed to create planned repositories');
+            throw error;
+        }
+        // Step 5: Requirement capture (optional)
+        const result = await this.runRequirementCaptureStep(projectPath, projectName, description, confirmedRepos);
+        if (result.requirements) {
+            state = setRequirements(state, result.requirements);
+            state = markStepCompleted(state, 'requirement-capture');
+            state = setCurrentStep(state, 'prd-generation');
+            await saveSetupState(state);
+            // Step 6: PRD generation (optional)
+            if (!this.noPrd) {
+                const prdSpinner = ora('Generating draft PRD...').start();
+                try {
+                    const prdPath = await saveDraftPrd(projectPath, projectName, description, result.requirements);
+                    prdSpinner.succeed(`Draft PRD saved to ${chalk.cyan(prdPath)}`);
+                    state = markStepCompleted(state, 'prd-generation');
+                }
+                catch (error) {
+                    prdSpinner.fail('Failed to generate PRD');
+                    this.context.stderr.write(chalk.yellow(`  Warning: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+                }
+            }
+        }
+        // Cleanup state on successful completion
+        await clearSetupState(projectPath);
+        return { plannedRepos: confirmedRepos, requirements: result.requirements };
+    }
+    /**
+     * Run the requirement capture step
+     */
+    async runRequirementCaptureStep(_projectPath, _projectName, description, repos) {
+        // Skip if --no-capture flag is set
+        if (this.noCapture) {
+            this.context.stdout.write(chalk.gray('\n  Skipping requirement capture (--no-capture).\n'));
+            return {};
+        }
+        this.context.stdout.write('\n');
+        this.context.stdout.write(chalk.bold.green('  ┌─────────────────────────────────────────────────────────┐\n'));
+        this.context.stdout.write(chalk.bold.green('  │') + chalk.bold(' Requirement Capture (Optional)') + chalk.bold.green('                          │\n'));
+        this.context.stdout.write(chalk.bold.green('  └─────────────────────────────────────────────────────────┘\n'));
+        this.context.stdout.write('\n');
+        this.context.stdout.write(chalk.gray('  Claude will help you:\n'));
+        this.context.stdout.write(chalk.gray('  - Define user stories\n'));
+        this.context.stdout.write(chalk.gray('  - Identify key features\n'));
+        this.context.stdout.write(chalk.gray('  - Establish technical requirements\n\n'));
+        const captureRequirements = await confirm({
+            message: 'Would you like to capture initial requirements?',
+            default: true,
+        });
+        if (!captureRequirements) {
+            this.context.stdout.write(chalk.gray('\n  Skipping requirement capture. You can use `vibe prd` later.\n'));
+            return {};
+        }
+        // Capture requirements with Claude
+        let requirements = null;
+        let attemptCount = 0;
+        const maxAttempts = 3;
+        while (attemptCount < maxAttempts) {
+            const spinner = ora('Claude is capturing requirements...').start();
+            try {
+                requirements = await captureRequirementsWithClaude(description, repos);
+                spinner.succeed('Requirements captured successfully');
+                // Display captured requirements summary
+                if (requirements) {
+                    this.displayRequirementsSummary(requirements);
+                }
+                break;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                spinner.fail(`Failed to capture requirements: ${errorMessage}`);
+                attemptCount++;
+                if (attemptCount < maxAttempts) {
+                    const retry = await confirm({
+                        message: 'Would you like to retry?',
+                        default: true,
+                    });
+                    if (!retry) {
+                        this.context.stdout.write(chalk.gray('\n  Skipping requirements. You can use `vibe prd` later.\n'));
+                        return {};
+                    }
+                }
+                else {
+                    this.context.stdout.write(chalk.yellow('\n  Could not capture requirements. You can use `vibe prd` later.\n'));
+                    return {};
+                }
+            }
+        }
+        return { requirements: requirements || undefined };
+    }
+    /**
+     * Display a summary of captured requirements
+     */
+    displayRequirementsSummary(requirements) {
+        this.context.stdout.write('\n');
+        this.context.stdout.write(chalk.bold('  Captured Requirements Summary:\n\n'));
+        // User stories
+        this.context.stdout.write(chalk.cyan(`  User Stories: ${requirements.userStories.length}\n`));
+        for (const story of requirements.userStories.slice(0, 3)) {
+            this.context.stdout.write(chalk.gray(`    - ${story.id}: ${story.title}\n`));
+        }
+        if (requirements.userStories.length > 3) {
+            this.context.stdout.write(chalk.gray(`    ... and ${requirements.userStories.length - 3} more\n`));
+        }
+        // Features
+        const mustHave = requirements.features.filter((f) => f.priority === 'must-have').length;
+        const shouldHave = requirements.features.filter((f) => f.priority === 'should-have').length;
+        const niceToHave = requirements.features.filter((f) => f.priority === 'nice-to-have').length;
+        this.context.stdout.write(chalk.cyan(`\n  Features: ${requirements.features.length}\n`));
+        this.context.stdout.write(chalk.gray(`    - Must-have: ${mustHave}\n`));
+        this.context.stdout.write(chalk.gray(`    - Should-have: ${shouldHave}\n`));
+        this.context.stdout.write(chalk.gray(`    - Nice-to-have: ${niceToHave}\n`));
+        // Technical requirements
+        this.context.stdout.write(chalk.cyan(`\n  Technical Requirements: ${requirements.technicalRequirements.length}\n`));
+        // Non-functional requirements
+        this.context.stdout.write(chalk.cyan(`  Non-Functional Requirements: ${requirements.nonFunctionalRequirements.length}\n`));
+        this.context.stdout.write('\n');
+    }
+    /**
+     * Capture project description from user
+     */
+    async captureProjectDescription() {
+        this.context.stdout.write(chalk.bold('  Describe your project\n'));
+        this.context.stdout.write(chalk.gray('  Tell me about what you\'re building so I can recommend a tech stack.\n\n'));
+        // Main description
+        const summary = await input({
+            message: 'What are you building? (1-2 sentences)',
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Description is required';
+                if (value.length < 10)
+                    return 'Please provide more detail';
+                return true;
+            },
+        });
+        // Optional: goals
+        const wantsGoals = await confirm({
+            message: 'Would you like to add specific goals?',
+            default: false,
+        });
+        let goals;
+        if (wantsGoals) {
+            const goalsInput = await input({
+                message: 'List your goals (comma-separated):',
+            });
+            goals = goalsInput
+                .split(',')
+                .map((g) => g.trim())
+                .filter((g) => g.length > 0);
+        }
+        // Optional: constraints
+        const wantsConstraints = await confirm({
+            message: 'Any technical constraints or preferences?',
+            default: false,
+        });
+        let constraints;
+        if (wantsConstraints) {
+            const constraintsInput = await input({
+                message: 'List constraints (comma-separated, e.g., "must use PostgreSQL, needs SSO"):',
+            });
+            constraints = constraintsInput
+                .split(',')
+                .map((c) => c.trim())
+                .filter((c) => c.length > 0);
+        }
+        // Optional: target users
+        const targetUsers = await input({
+            message: 'Who are the target users? (optional, press Enter to skip):',
+        });
+        return {
+            summary,
+            goals,
+            constraints,
+            targetUsers: targetUsers || undefined,
+        };
+    }
+    /**
+     * Handle displaying and confirming recommendations
+     */
+    async handleRecommendations(projectPath, description, recommendation) {
+        // Display recommendations
+        this.displayRecommendations(recommendation);
+        // Get user choice
+        const choice = await this.getRecommendationChoice();
+        switch (choice) {
+            case 'confirm':
+                return recommendation.repos;
+            case 'modify':
+                return await this.modifyRecommendations(recommendation);
+            case 'restart':
+                // Recursively restart the recommendation process
+                const spinner = ora('Getting new recommendations from Claude...').start();
+                try {
+                    const newRec = await getClaudeRecommendation(projectPath, description);
+                    spinner.succeed('Received new recommendations');
+                    if (newRec && newRec.repos.length > 0) {
+                        return await this.handleRecommendations(projectPath, description, newRec);
+                    }
+                    return [];
+                }
+                catch (error) {
+                    spinner.fail('Failed to get recommendations');
+                    throw error;
+                }
+        }
+    }
+    /**
+     * Display Claude's recommendations
+     */
+    displayRecommendations(recommendation) {
+        this.context.stdout.write('\n');
+        this.context.stdout.write(chalk.bold.green('  ┌─────────────────────────────────────────────────────────┐\n'));
+        this.context.stdout.write(chalk.bold.green('  │') + chalk.bold(' Recommended Structure') + chalk.bold.green('                                    │\n'));
+        this.context.stdout.write(chalk.bold.green('  └─────────────────────────────────────────────────────────┘\n'));
+        this.context.stdout.write('\n');
+        recommendation.repos.forEach((repo, i) => {
+            this.context.stdout.write(chalk.bold(`  ${i + 1}. ${repo.name}`) + chalk.gray(` (${repo.structure.type})\n`));
+            this.context.stdout.write(chalk.gray(`     ${repo.description}\n`));
+            this.context.stdout.write(chalk.cyan(`     Stack: `) + formatTechStack(repo.techStack) + '\n');
+            if (repo.structure.features.length > 0) {
+                this.context.stdout.write(chalk.cyan(`     Features: `) + repo.structure.features.join(', ') + '\n');
+            }
+            this.context.stdout.write('\n');
+        });
+        this.context.stdout.write(chalk.gray('  Rationale: ') + recommendation.rationale + '\n\n');
+    }
+    /**
+     * Get user's choice on how to handle recommendations
+     */
+    async getRecommendationChoice() {
+        const choice = await select({
+            message: 'How would you like to proceed?',
+            choices: [
+                {
+                    value: 'confirm',
+                    name: 'Confirm - Use this structure',
+                    description: 'Accept the recommended repositories',
+                },
+                {
+                    value: 'modify',
+                    name: 'Modify - Select which repos to keep',
+                    description: 'Choose specific repos from the list',
+                },
+                {
+                    value: 'restart',
+                    name: 'Start Over - Get new recommendations',
+                    description: 'Provide more context to Claude',
+                },
+            ],
+        });
+        return choice;
+    }
+    /**
+     * Let user modify recommended repos
+     */
+    async modifyRecommendations(recommendation) {
+        const selectedRepos = [];
+        for (const repo of recommendation.repos) {
+            const keep = await confirm({
+                message: `Keep "${repo.name}" (${formatTechStack(repo.techStack)})?`,
+                default: true,
+            });
+            if (keep) {
+                // Allow modifying the name/alias
+                const alias = await input({
+                    message: `  Alias for ${repo.name}:`,
+                    default: repo.alias,
+                    validate: (value) => {
+                        if (!value.trim())
+                            return 'Alias is required';
+                        if (!/^[a-z][a-z0-9-]*$/.test(value)) {
+                            return 'Alias must be lowercase, start with letter, use only letters, numbers, hyphens';
+                        }
+                        if (selectedRepos.some((r) => r.alias === value)) {
+                            return 'Alias already used';
+                        }
+                        return true;
+                    },
+                });
+                selectedRepos.push({
+                    ...repo,
+                    alias,
+                });
+            }
+        }
+        // Ask if they want to add any custom repos
+        const addMore = await confirm({
+            message: 'Would you like to add any additional repositories?',
+            default: false,
+        });
+        if (addMore) {
+            await this.addCustomRepos(selectedRepos);
+        }
+        return selectedRepos;
+    }
+    /**
+     * Let user add custom repos
+     */
+    async addCustomRepos(repos) {
+        let addingMore = true;
+        while (addingMore) {
+            const alias = await input({
+                message: 'Repository alias:',
+                validate: (value) => {
+                    if (!value.trim())
+                        return 'Alias is required';
+                    if (!/^[a-z][a-z0-9-]*$/.test(value)) {
+                        return 'Alias must be lowercase, start with letter, use only letters, numbers, hyphens';
+                    }
+                    if (repos.some((r) => r.alias === value)) {
+                        return 'Alias already used';
+                    }
+                    return true;
+                },
+            });
+            const name = await input({
+                message: 'Repository name:',
+                default: alias,
+            });
+            const description = await input({
+                message: 'Description:',
+                validate: (value) => (value.trim() ? true : 'Description is required'),
+            });
+            const structureType = await select({
+                message: 'Type:',
+                choices: [
+                    { value: 'backend', name: 'Backend API' },
+                    { value: 'frontend', name: 'Frontend App' },
+                    { value: 'fullstack', name: 'Fullstack' },
+                    { value: 'library', name: 'Library/Package' },
+                    { value: 'service', name: 'Microservice' },
+                    { value: 'cli', name: 'CLI Tool' },
+                ],
+            });
+            const language = await input({
+                message: 'Primary language:',
+                default: 'typescript',
+            });
+            const framework = await input({
+                message: 'Framework (optional):',
+            });
+            repos.push({
+                alias,
+                name,
+                description,
+                visibility: 'private',
+                techStack: {
+                    language,
+                    framework: framework || undefined,
+                },
+                structure: {
+                    type: structureType,
+                    features: [],
+                },
+            });
+            addingMore = await confirm({
+                message: 'Add another repository?',
+                default: false,
+            });
+        }
+    }
+    /**
+     * Show success message for new projects with planned repos
+     */
+    showNewProjectSuccess(projectPath, name, plannedRepos, requirements) {
+        this.context.stdout.write('\n');
+        this.context.stdout.write(chalk.green.bold('  ✓ Success!\n\n'));
+        this.context.stdout.write(chalk.bold('  Planning hub created at:\n'));
+        this.context.stdout.write(`  ${chalk.cyan(projectPath)}\n\n`);
+        if (plannedRepos.length > 0) {
+            this.context.stdout.write(chalk.bold('  Planned repositories:\n'));
+            for (const repo of plannedRepos) {
+                this.context.stdout.write(`  ${chalk.cyan('○')} ${repo.name} ` +
+                    chalk.gray(`(${formatTechStack(repo.techStack)})\n`));
+            }
+            this.context.stdout.write('\n');
+        }
+        if (requirements) {
+            this.context.stdout.write(chalk.bold('  Requirements captured:\n'));
+            this.context.stdout.write(chalk.gray(`  - ${requirements.userStories.length} user stories\n`));
+            this.context.stdout.write(chalk.gray(`  - ${requirements.features.length} features\n`));
+            this.context.stdout.write(chalk.gray(`  - Draft PRD saved to docs/prd/requirements-draft.md\n\n`));
+        }
+        this.context.stdout.write(chalk.bold('  Next steps:\n'));
+        this.context.stdout.write(chalk.gray(`  1. cd ${name}\n`));
+        if (plannedRepos.length > 0) {
+            this.context.stdout.write(chalk.gray('  2. vibe repo create --all   # Create repos on GitHub\n'));
+            if (requirements) {
+                this.context.stdout.write(chalk.gray('  3. vibe prd                 # Refine the draft PRD\n'));
+            }
+            else {
+                this.context.stdout.write(chalk.gray('  3. vibe prd                 # Define requirements\n'));
+            }
+            this.context.stdout.write(chalk.gray('  4. vibe scope               # Create work scopes\n\n'));
+        }
+        else {
+            this.context.stdout.write(chalk.gray('  2. vibe repo add      # Add repositories\n'));
+            this.context.stdout.write(chalk.gray('  3. vibe prd           # Create requirements\n'));
+            this.context.stdout.write(chalk.gray('  4. vibe scope         # Create work scopes\n\n'));
+        }
+        this.context.stdout.write(chalk.gray('  Run ') + chalk.cyan('vibe status') + chalk.gray(' to see planned vs active repos.\n'));
+        this.context.stdout.write(chalk.gray('  Run ') + chalk.cyan('vibe --help') + chalk.gray(' for all commands.\n\n'));
+    }
 }
 //# sourceMappingURL=init.js.map