wogiflow 1.0.11 → 1.0.13

package/lib/unified-wizard.js

@@ -91,10 +91,15 @@ class UnifiedWizard {
     this.rl = null;
     this.config = {
       projectName: '',
-      projectType: '', // 'new' | 'existing'
+      description: '',
       cli: 'claude',
+      projectState: '',
+      goals: [],
+      documentation: [], // Array of {type, inputType, content, summary}
+      planningDocs: [],  // Roadmap, issue tracker, etc.
+      // Legacy fields for backward compatibility
+      projectType: '',
       strictMode: true,
-      importPath: null,
       stackSelections: null,
       scanFindings: null
     };
@@ -103,6 +108,7 @@ class UnifiedWizard {
 
   /**
    * Run the unified wizard
+   * New flow: CLI first → basics → docs → state → goals → planning → summary → AI handoff
    */
   async run() {
     this.rl = readline.createInterface({
@@ -114,44 +120,33 @@ class UnifiedWizard {
       // Step 1: Welcome
       this.printWelcome();
 
-      // Step 2: Project name
-      await this.askProjectName();
+      // Step 2: CLI selection (FIRST)
+      await this.askCLI();
 
-      // Step 3: New or existing project?
-      await this.askProjectType();
+      // Step 3: Project name
+      await this.askProjectName();
 
-      // Step 4: Import config option (for solo devs)
-      const imported = await this.askImportConfig();
-      if (imported) {
-        await this.finalizeSetup();
-        return this.config;
-      }
+      // Step 4: Description (short or documentation)
+      await this.askDescription();
 
-      // Step 5: Branch based on project type
-      if (this.config.projectType === 'new') {
-        await this.runStackWizard();
-      } else {
-        await this.runProjectScanner();
-      }
+      // Step 5: Project state
+      await this.askProjectState();
 
-      // Step 6: CLI preference
-      await this.askCLIPreference();
+      // Step 6: Goals (multi-select)
+      await this.askGoals();
 
-      // Step 7: Strict mode
-      await this.askStrictMode();
+      // Step 7: Planning documents
+      await this.askPlanningDocs();
 
       // Step 8: Show summary and confirm
-      const confirmed = await this.showSummaryAndConfirm();
+      const confirmed = await this.showSummary();
       if (!confirmed) {
-        console.log(c('yellow', '\nSetup cancelled. Run `flow init` to try again.\n'));
+        console.log(c('yellow', '\nSetup cancelled. Run `npx flow onboard` to try again.\n'));
         return null;
       }
 
-      // Step 9: Create everything
-      await this.finalizeSetup();
-
-      // Step 10: Success
-      this.printSuccess();
+      // Step 9: Create structure and handoff to AI
+      await this.finalizeAndHandoff();
 
       return this.config;
 
@@ -315,10 +310,301 @@ class UnifiedWizard {
     });
   }
 
+  /**
+   * Single-select with arrow key navigation
+   * @param {string} question - The question to ask
+   * @param {Array} options - Array of {key, label, description?} objects
+   * @param {string} defaultKey - Default selected key
+   * @returns {Promise<string>} Selected key
+   */
+  askSingleSelect(question, options, defaultKey = null) {
+    return new Promise((resolve) => {
+      // Fallback if no TTY
+      if (!process.stdin.isTTY || !process.stdin.setRawMode) {
+        console.log(`\n${question}\n`);
+        options.forEach((opt, i) => {
+          const marker = opt.key === defaultKey ? '>' : ' ';
+          console.log(`  ${marker} (${i + 1}) ${opt.label}${opt.description ? ` - ${opt.description}` : ''}`);
+        });
+        return this.ask('Your choice (number)', '1').then(answer => {
+          const num = parseInt(answer, 10);
+          if (num >= 1 && num <= options.length) {
+            resolve(options[num - 1].key);
+          } else {
+            resolve(defaultKey || options[0].key);
+          }
+        });
+      }
+
+      let selectedIndex = defaultKey ? options.findIndex(o => o.key === defaultKey) : 0;
+      if (selectedIndex < 0) selectedIndex = 0;
+
+      const render = () => {
+        // Move cursor up to redraw (except first render)
+        process.stdout.write(`\x1b[${options.length}A\x1b[J`);
+        options.forEach((opt, i) => {
+          const selected = i === selectedIndex;
+          const marker = selected ? c('cyan', '❯') : ' ';
+          const radio = selected ? c('green', '●') : '○';
+          const label = selected ? c('bold', opt.label) : opt.label;
+          const desc = opt.description ? c('dim', ` - ${opt.description}`) : '';
+          console.log(`  ${marker} ${radio} ${label}${desc}`);
+        });
+        process.stdout.write(c('dim', '\n  [↑↓ to move, Enter to select]'));
+      };
+
+      console.log(`\n${question}\n`);
+      // Initial render (print blank lines first)
+      options.forEach(() => console.log(''));
+      console.log('');
+      render();
+
+      this.rl.pause();
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+
+      const cleanup = () => {
+        process.stdin.setRawMode(false);
+        process.stdin.removeListener('data', onKey);
+        this.rl.resume();
+      };
+
+      const onKey = (key) => {
+        const seq = key.toString();
+
+        // Arrow up
+        if (seq === '\x1b[A' || seq === 'k') {
+          selectedIndex = (selectedIndex - 1 + options.length) % options.length;
+          render();
+          return;
+        }
+
+        // Arrow down
+        if (seq === '\x1b[B' || seq === 'j') {
+          selectedIndex = (selectedIndex + 1) % options.length;
+          render();
+          return;
+        }
+
+        // Enter
+        if (seq === '\r' || seq === '\n') {
+          cleanup();
+          process.stdout.write('\x1b[K\n'); // Clear hint line
+          resolve(options[selectedIndex].key);
+          return;
+        }
+
+        // Ctrl+C
+        if (seq === '\x03') {
+          cleanup();
+          process.stdout.write('\n');
+          process.exit();
+        }
+      };
+
+      process.stdin.on('data', onKey);
+    });
+  }
+
+  /**
+   * Multi-select with checkbox toggle (space to toggle, enter to confirm)
+   * @param {string} question - The question to ask
+   * @param {Array} options - Array of {key, label, description?, default?} objects
+   * @returns {Promise<string[]>} Array of selected keys
+   */
+  askMultiSelect(question, options) {
+    return new Promise((resolve) => {
+      // Fallback if no TTY
+      if (!process.stdin.isTTY || !process.stdin.setRawMode) {
+        console.log(`\n${question}\n`);
+        options.forEach((opt, i) => {
+          const checked = opt.default ? '[x]' : '[ ]';
+          console.log(`  ${checked} (${i + 1}) ${opt.label}${opt.description ? ` - ${opt.description}` : ''}`);
+        });
+        return this.ask('Select (comma-separated numbers)', '').then(answer => {
+          if (!answer) {
+            resolve(options.filter(o => o.default).map(o => o.key));
+            return;
+          }
+          const nums = answer.split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n));
+          resolve(nums.filter(n => n >= 1 && n <= options.length).map(n => options[n - 1].key));
+        });
+      }
+
+      let cursorIndex = 0;
+      const selected = new Set(options.filter(o => o.default).map(o => o.key));
+
+      const render = () => {
+        // Move cursor up to redraw
+        process.stdout.write(`\x1b[${options.length}A\x1b[J`);
+        options.forEach((opt, i) => {
+          const isCursor = i === cursorIndex;
+          const isSelected = selected.has(opt.key);
+          const cursor = isCursor ? c('cyan', '❯') : ' ';
+          const checkbox = isSelected ? c('green', '☑') : '☐';
+          const label = isCursor ? c('bold', opt.label) : opt.label;
+          const desc = opt.description ? c('dim', ` - ${opt.description}`) : '';
+          console.log(`  ${cursor} ${checkbox} ${label}${desc}`);
+        });
+        process.stdout.write(c('dim', '\n  [↑↓ move, Space toggle, Enter done]'));
+      };
+
+      console.log(`\n${question}\n`);
+      // Initial render
+      options.forEach(() => console.log(''));
+      console.log('');
+      render();
+
+      this.rl.pause();
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+
+      const cleanup = () => {
+        process.stdin.setRawMode(false);
+        process.stdin.removeListener('data', onKey);
+        this.rl.resume();
+      };
+
+      const onKey = (key) => {
+        const seq = key.toString();
+
+        // Arrow up
+        if (seq === '\x1b[A' || seq === 'k') {
+          cursorIndex = (cursorIndex - 1 + options.length) % options.length;
+          render();
+          return;
+        }
+
+        // Arrow down
+        if (seq === '\x1b[B' || seq === 'j') {
+          cursorIndex = (cursorIndex + 1) % options.length;
+          render();
+          return;
+        }
+
+        // Space - toggle
+        if (seq === ' ') {
+          const key = options[cursorIndex].key;
+          if (selected.has(key)) {
+            selected.delete(key);
+          } else {
+            selected.add(key);
+          }
+          render();
+          return;
+        }
+
+        // Enter - confirm
+        if (seq === '\r' || seq === '\n') {
+          cleanup();
+          process.stdout.write('\x1b[K\n');
+          resolve(Array.from(selected));
+          return;
+        }
+
+        // Ctrl+C
+        if (seq === '\x03') {
+          cleanup();
+          process.stdout.write('\n');
+          process.exit();
+        }
+      };
+
+      process.stdin.on('data', onKey);
+    });
+  }
+
+  /**
+   * Ask for document input - either paste content or link to file
+   * @param {string} docType - Name of the document type (e.g., "PRD", "README")
+   * @returns {Promise<{type: 'paste'|'link', content: string, summary: string}>}
+   */
+  async askDocumentInput(docType) {
+    // First ask: paste or link?
+    const inputType = await this.askSingleSelect(
+      `How do you want to provide the ${docType}?`,
+      [
+        { key: 'paste', label: 'Paste content', description: 'Paste the document content directly' },
+        { key: 'link', label: 'Link to file', description: 'Provide a file path' }
+      ],
+      'paste'
+    );
+
+    if (inputType === 'link') {
+      const filePath = await this.ask(`File path for ${docType}`);
+      if (!filePath) {
+        return { type: 'link', content: '', summary: '[no file provided]' };
+      }
+
+      // Validate file exists
+      const resolvedPath = path.resolve(this.projectRoot, filePath);
+      if (!isPathWithinProject(resolvedPath, this.projectRoot)) {
+        console.log(c('yellow', '  Path must be within project directory'));
+        return { type: 'link', content: '', summary: '[invalid path]' };
+      }
+
+      try {
+        fs.accessSync(resolvedPath, fs.constants.R_OK);
+        return { type: 'link', content: resolvedPath, summary: `[linked - ${filePath}]` };
+      } catch {
+        console.log(c('yellow', '  File not found or not readable'));
+        return { type: 'link', content: '', summary: '[file not found]' };
+      }
+    }
+
+    // Paste mode - multi-line input
+    console.log(c('dim', `\nPaste ${docType} content (press Enter twice on empty line when done):\n`));
+
+    return new Promise((resolve) => {
+      const lines = [];
+      let emptyLineCount = 0;
+
+      const lineHandler = (line) => {
+        if (line === '') {
+          emptyLineCount++;
+          if (emptyLineCount >= 2) {
+            this.rl.removeListener('line', lineHandler);
+            const content = lines.join('\n');
+            const lineCount = lines.length;
+            const summary = `[pasted - ${lineCount} line${lineCount !== 1 ? 's' : ''}]`;
+            console.log(c('green', `  ${summary}\n`));
+            resolve({ type: 'paste', content, summary });
+            return;
+          }
+        } else {
+          emptyLineCount = 0;
+        }
+        lines.push(line);
+      };
+
+      this.rl.on('line', lineHandler);
+    });
+  }
+
   // ============================================
-  // STEP IMPLEMENTATIONS
+  // STEP IMPLEMENTATIONS (New Flow)
   // ============================================
 
+  /**
+   * Step 2: Ask CLI selection (FIRST question)
+   */
+  async askCLI() {
+    const cliOptions = Object.entries(SUPPORTED_CLIS).map(([key, value]) => ({
+      key,
+      label: value.name,
+      description: value.description
+    }));
+
+    this.config.cli = await this.askSingleSelect(
+      'Which AI CLI are you using?',
+      cliOptions,
+      'claude'
+    );
+  }
+
+  /**
+   * Step 3: Ask project name
+   */
   async askProjectName() {
     // Try to detect from package.json
     const packageJsonPath = path.join(this.projectRoot, 'package.json');
@@ -341,6 +627,259 @@ class UnifiedWizard {
     this.config.projectName = await this.askWithPlaceholder('Project name', detectedName);
   }
 
+  /**
+   * Step 4: Ask for description (short or documentation)
+   */
+  async askDescription() {
+    const hasDocsChoice = await this.askSingleSelect(
+      'How would you like to describe your project?',
+      [
+        { key: 'short', label: 'Short description', description: '1-2 sentences' },
+        { key: 'docs', label: 'I have documentation', description: 'PRD, README, specs, etc.' }
+      ],
+      'short'
+    );
+
+    if (hasDocsChoice === 'short') {
+      this.config.description = await this.ask('What does this project do? (1-2 sentences)');
+      return;
+    }
+
+    // Documentation flow
+    const docTypes = await this.askMultiSelect(
+      'What documentation do you have?',
+      [
+        { key: 'prd', label: 'PRD / Product Spec' },
+        { key: 'readme', label: 'README' },
+        { key: 'architecture', label: 'Architecture docs' },
+        { key: 'api', label: 'API documentation' },
+        { key: 'other', label: 'Other' }
+      ]
+    );
+
+    if (docTypes.length === 0) {
+      // Fallback to short description
+      this.config.description = await this.ask('What does this project do? (1-2 sentences)');
+      return;
+    }
+
+    // For each selected doc type, get input
+    const docTypeNames = {
+      prd: 'PRD / Product Spec',
+      readme: 'README',
+      architecture: 'Architecture docs',
+      api: 'API documentation',
+      other: 'Other documentation'
+    };
+
+    for (const docType of docTypes) {
+      const docName = docTypeNames[docType] || docType;
+      const input = await this.askDocumentInput(docName);
+      this.config.documentation.push({
+        type: docType,
+        name: docName,
+        inputType: input.type,
+        content: input.content,
+        summary: input.summary
+      });
+    }
+  }
+
+  /**
+   * Step 5: Ask project state
+   */
+  async askProjectState() {
+    this.config.projectState = await this.askSingleSelect(
+      "What's your project's current state?",
+      [
+        { key: 'new', label: 'New / early development', description: 'Just starting out' },
+        { key: 'mvp', label: 'MVP / working prototype', description: 'Core features working' },
+        { key: 'production', label: 'Production with users', description: 'Live and serving users' },
+        { key: 'maintenance', label: 'Maintenance mode', description: 'Stable, minimal changes' }
+      ],
+      'mvp'
+    );
+  }
+
+  /**
+   * Step 6: Ask goals (multi-select)
+   */
+  async askGoals() {
+    this.config.goals = await this.askMultiSelect(
+      'What are you trying to accomplish with AI assistance?',
+      [
+        { key: 'features', label: 'Add new features', default: true },
+        { key: 'bugs', label: 'Fix bugs', default: true },
+        { key: 'refactor', label: 'Refactor / improve code quality' },
+        { key: 'tests', label: 'Add tests' },
+        { key: 'docs', label: 'Documentation' },
+        { key: 'performance', label: 'Performance optimization' },
+        { key: 'security', label: 'Security improvements' }
+      ]
+    );
+  }
+
+  /**
+   * Step 7: Ask about planning documents
+   */
+  async askPlanningDocs() {
+    const planningTypes = await this.askMultiSelect(
+      'Do you have any existing planning documents the AI should analyze?',
+      [
+        { key: 'roadmap', label: 'Roadmap / backlog' },
+        { key: 'issues', label: 'Issue tracker export' },
+        { key: 'techdebt', label: 'Technical debt notes' },
+        { key: 'none', label: 'None of these', default: true }
+      ]
+    );
+
+    // Filter out 'none' and store
+    this.config.planningDocs = planningTypes.filter(t => t !== 'none');
+
+    if (this.config.planningDocs.length > 0) {
+      console.log(c('dim', '\n  These will be analyzed when the AI scans your project.\n'));
+    }
+  }
+
+  /**
+   * Step 8: Show summary
+   */
+  async showSummary() {
+    const cli = SUPPORTED_CLIS[this.config.cli];
+
+    console.log('\n' + c('cyan', '═'.repeat(60)));
+    console.log(c('cyan', '  Setup Summary'));
+    console.log(c('cyan', '═'.repeat(60)) + '\n');
+
+    console.log(`  Project: ${c('bold', this.config.projectName)}`);
+    console.log(`  CLI: ${c('bold', cli.name)}`);
+    console.log(`  State: ${c('bold', this.config.projectState || 'Not specified')}`);
+
+    if (this.config.goals.length > 0) {
+      console.log(`  Goals: ${c('bold', this.config.goals.join(', '))}`);
+    }
+
+    if (this.config.documentation.length > 0) {
+      console.log(`  Documentation: ${c('bold', this.config.documentation.length + ' file(s)')}`);
+      this.config.documentation.forEach(doc => {
+        console.log(`    - ${doc.name}: ${c('dim', doc.summary)}`);
+      });
+    } else if (this.config.description) {
+      console.log(`  Description: ${c('dim', this.config.description.substring(0, 50) + (this.config.description.length > 50 ? '...' : ''))}`);
+    }
+
+    console.log('\n' + c('bold', 'Ready to let the AI analyze your project?'));
+    console.log(c('dim', 'This will create the workflow structure and prepare for AI analysis.\n'));
+
+    return await this.askYesNo('Proceed?', true);
+  }
+
+  /**
+   * Step 9: Finalize and handoff to AI
+   */
+  async finalizeAndHandoff() {
+    console.log(c('dim', '\nCreating project structure...\n'));
+
+    // Create minimal structure
+    await this.createWorkflowStructure();
+    await this.createCLIConfig();
+
+    // Save onboarding data for AI to read
+    await this.saveOnboardingData();
+
+    // Determine if running inside AI session
+    const inSession = this.detectAISession();
+
+    if (inSession) {
+      // Already in AI session - output trigger for AI to continue
+      this.printAITrigger();
+    } else {
+      // Not in session - show instructions
+      this.printHandoffInstructions();
+    }
+  }
+
+  /**
+   * Detect if running inside an AI CLI session
+   */
+  detectAISession() {
+    // Check for common environment indicators
+    return !!(
+      process.env.CLAUDE_CODE ||
+      process.env.ANTHROPIC_API_KEY ||
+      process.env.GEMINI_CLI ||
+      process.env.OPENCODE_SESSION ||
+      // Check if parent process looks like an AI CLI
+      (process.env._ && (
+        process.env._.includes('claude') ||
+        process.env._.includes('gemini') ||
+        process.env._.includes('opencode')
+      ))
+    );
+  }
+
+  /**
+   * Print trigger for AI to continue (when in session)
+   */
+  printAITrigger() {
+    console.log('\n' + c('green', '═'.repeat(60)));
+    console.log(c('green', '  ✅ Structure created!'));
+    console.log(c('green', '═'.repeat(60)) + '\n');
+
+    console.log('The AI can now analyze your project.\n');
+    console.log(c('yellow', 'AI: Please run /wogi-onboard to complete the setup by:'));
+    console.log('  • Scanning the codebase for patterns and structure');
+    console.log('  • Detecting frameworks, testing, and coding styles');
+    console.log('  • Generating component map and architecture docs');
+    console.log('  • Creating coding rules based on detected patterns\n');
+  }
+
+  /**
+   * Print handoff instructions (when not in session)
+   */
+  printHandoffInstructions() {
+    const cli = SUPPORTED_CLIS[this.config.cli];
+    const cliCommand = this.config.cli; // 'claude', 'gemini', 'opencode'
+
+    console.log('\n' + c('cyan', '╔════════════════════════════════════════════════════════════╗'));
+    console.log(c('cyan', '║') + '  ' + c('bold', 'Almost done! Start your AI CLI to complete setup.') + '         ' + c('cyan', '║'));
+    console.log(c('cyan', '╚════════════════════════════════════════════════════════════╝') + '\n');
+
+    console.log(`  Run: ${c('yellow', cliCommand)}\n`);
+
+    console.log('  The AI will:');
+    console.log('    • Scan your codebase for patterns');
+    console.log('    • Detect frameworks and coding styles');
+    console.log('    • Generate component map and architecture docs');
+    console.log('    • Ask clarifying questions if needed\n');
+  }
+
+  /**
+   * Save onboarding data for AI to read
+   */
+  async saveOnboardingData() {
+    const onboardingData = {
+      version: PACKAGE_VERSION,
+      timestamp: new Date().toISOString(),
+      projectName: this.config.projectName,
+      description: this.config.description,
+      cli: this.config.cli,
+      projectState: this.config.projectState,
+      goals: this.config.goals,
+      documentation: this.config.documentation,
+      planningDocs: this.config.planningDocs,
+      status: 'pending_ai_analysis'
+    };
+
+    const onboardingPath = path.join(this.projectRoot, '.workflow', 'state', 'onboarding.json');
+    fs.writeFileSync(onboardingPath, JSON.stringify(onboardingData, null, 2));
+    console.log('  ' + c('green', '✓') + ' Saved onboarding data for AI analysis');
+  }
+
+  // ============================================
+  // LEGACY METHODS (kept for backward compatibility)
+  // ============================================
+
   async askProjectType() {
     const choice = await this.askChoice(
       'Is this a new project or an existing codebase?',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {