aios-core 2.1.0

package/src/wizard/ide-selector.js

@@ -0,0 +1,84 @@
+/**
+ * IDE Selector Module
+ *
+ * Story 1.4: IDE Selection
+ * Provides multi-select IDE prompt for wizard
+ *
+ * @module wizard/ide-selector
+ */
+
+const inquirer = require('inquirer');
+const { getIDEChoices, getIDEKeys } = require('../config/ide-configs');
+const { colors } = require('../utils/aios-colors');
+
+/**
+ * Validate IDE selection (at least one required)
+ * @param {string[]} selectedIDEs - Array of selected IDE keys
+ * @returns {boolean|string} True if valid, error message if invalid
+ */
+function validateIDESelection(selectedIDEs) {
+  if (!Array.isArray(selectedIDEs)) {
+    return 'Invalid selection format';
+  }
+
+  if (selectedIDEs.length === 0) {
+    return 'Please select at least one IDE';
+  }
+
+  // Validate all selected IDEs are valid
+  const validIDEs = getIDEKeys();
+  const invalidIDEs = selectedIDEs.filter(ide => !validIDEs.includes(ide));
+
+  if (invalidIDEs.length > 0) {
+    return `Invalid IDE selections: ${invalidIDEs.join(', ')}`;
+  }
+
+  return true;
+}
+
+/**
+ * Prompt user to select IDEs
+ *
+ * AC1: Multi-select prompt with 6 IDEs
+ *
+ * @returns {Promise<string[]>} Array of selected IDE keys
+ *
+ * @example
+ * const selectedIDEs = await selectIDEs();
+ * console.log(selectedIDEs); // ['cursor', 'windsurf']
+ */
+async function selectIDEs() {
+  const { selectedIDEs } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'selectedIDEs',
+      message: colors.primary('Select IDE(s) for AIOS configuration:') + colors.dim('\n  (Use spacebar to select, enter to confirm)'),
+      choices: getIDEChoices(),
+      validate: validateIDESelection,
+      pageSize: 10,
+    },
+  ]);
+
+  return selectedIDEs;
+}
+
+/**
+ * Get IDE selection question for wizard integration
+ * @returns {Object} Inquirer question object
+ */
+function getIDESelectionQuestion() {
+  return {
+    type: 'checkbox',
+    name: 'selectedIDEs',
+    message: colors.primary('Select IDE(s) for AIOS configuration:') + colors.dim('\n  (Use spacebar to select, enter to confirm)'),
+    choices: getIDEChoices(),
+    validate: validateIDESelection,
+    pageSize: 10,
+  };
+}
+
+module.exports = {
+  selectIDEs,
+  validateIDESelection,
+  getIDESelectionQuestion,
+};

package/src/wizard/index.js

@@ -0,0 +1,589 @@
+/**
+ * AIOS Interactive Wizard - Main Entry Point
+ *
+ * Story 1.2: Interactive Wizard Foundation
+ * Provides core wizard functionality with visual feedback and navigation
+ *
+ * @module wizard
+ */
+
+const inquirer = require('inquirer');
+const path = require('path');
+const fse = require('fs-extra');
+const { buildQuestionSequence } = require('./questions');
+const {
+  showWelcome,
+  showCompletion,
+  showCancellation,
+} = require('./feedback');
+const { generateIDEConfigs, showSuccessSummary } = require('./ide-config-generator');
+const { getIDEConfig } = require('../config/ide-configs');
+const { configureEnvironment } = require('../../packages/installer/src/config/configure-environment');
+const { installDependencies, hasExistingDependencies } = require('../installer/dependency-installer');
+const { installAiosCore, hasPackageJson, createBasicPackageJson } = require('../installer/aios-core-installer');
+const { installProjectMCPs } = require('../../bin/modules/mcp-installer');
+const {
+  validateInstallation,
+  displayValidationReport,
+  provideTroubleshooting,
+} = require('./validation');
+const {
+  installLLMRouting,
+  isLLMRoutingInstalled,
+  getInstallationSummary
+} = require('../../.aios-core/infrastructure/scripts/llm-routing/install-llm-routing');
+
+/**
+ * Generate AntiGravity workflow content for expansion pack agents
+ * @param {string} agentName - Agent name (e.g., 'data-collector')
+ * @param {string} packName - Expansion pack name (e.g., 'etl')
+ * @returns {string} Workflow file content
+ */
+function generateExpansionPackWorkflow(agentName, packName) {
+  const displayName = agentName.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+
+  return `---
+description: Ativa o agente ${displayName} (${packName})
+---
+
+# Ativação do Agente ${displayName}
+
+**Expansion Pack:** ${packName}
+
+**INSTRUÇÕES CRÍTICAS PARA O ANTIGRAVITY:**
+
+1. Leia COMPLETAMENTE o arquivo \`.antigravity/agents/${packName}/${agentName}.md\`
+2. Siga EXATAMENTE as \`activation-instructions\` definidas no bloco YAML do agente
+3. Adote a persona conforme definido no agente
+4. Execute a saudação conforme \`greeting_levels\` definido no agente
+5. **MANTENHA esta persona até receber o comando \`*exit\`**
+6. Responda aos comandos com prefixo \`*\` conforme definido no agente
+7. Siga as regras globais do projeto em \`.antigravity/rules.md\`
+
+**Comandos disponíveis:** Use \`*help\` para ver todos os comandos do agente.
+`;
+}
+
+/**
+ * Handle Ctrl+C gracefully
+ */
+let cancellationRequested = false;
+let sigintHandlerAdded = false;
+
+function setupCancellationHandler() {
+  // Prevent adding multiple listeners (MaxListeners warning fix)
+  if (sigintHandlerAdded) {
+    return;
+  }
+
+  // Increase limit to prevent warning during testing
+  process.setMaxListeners(15);
+  
+  const handleSigint = async () => {
+    if (cancellationRequested) {
+      // Second Ctrl+C - force exit
+      console.log('\nForce exit');
+      process.exit(0);
+    }
+
+    cancellationRequested = true;
+    
+    console.log('\n');
+    const { confirmCancel } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'confirmCancel',
+        message: 'Are you sure you want to cancel installation?',
+        default: false,
+      },
+    ]);
+
+    if (confirmCancel) {
+      showCancellation();
+      process.exit(0);
+    } else {
+      cancellationRequested = false;
+      console.log('Continuing installation...\n');
+      // Note: inquirer will resume automatically
+    }
+  };
+
+  process.on('SIGINT', handleSigint);
+  sigintHandlerAdded = true;
+}
+
+/**
+ * Main wizard execution function
+ * 
+ * @returns {Promise<Object>} Wizard answers object
+ * 
+ * @example
+ * const { runWizard } = require('./src/wizard');
+ * const answers = await runWizard();
+ * console.log(answers.projectType); // 'greenfield' or 'brownfield'
+ */
+async function runWizard() {
+  try {
+    // Setup graceful cancellation
+    setupCancellationHandler();
+
+    // Show welcome message with AIOS branding
+    showWelcome();
+
+    // Build question sequence
+    const questions = buildQuestionSequence();
+
+    // Performance tracking (AC: < 100ms per question)
+    const startTime = Date.now();
+
+    // Run wizard with inquirer
+    const answers = await inquirer.prompt(questions);
+
+    // Log performance metrics
+    const duration = Date.now() - startTime;
+    const avgTimePerQuestion = questions.length > 0 ? duration / questions.length : 0;
+
+    if (avgTimePerQuestion > 100) {
+      console.warn(`Warning: Average question response time (${avgTimePerQuestion.toFixed(0)}ms) exceeds 100ms target`);
+    }
+
+    // Story 1.4: Install AIOS core framework (agents, tasks, workflows, templates)
+    console.log('\n📦 Installing AIOS core framework...');
+    let aiosCoreResult = null;
+    try {
+      aiosCoreResult = await installAiosCore({
+        targetDir: process.cwd(),
+        onProgress: (status) => {
+          // Silent progress - spinner handles feedback
+        },
+      });
+
+      if (aiosCoreResult.success) {
+        console.log(`✅ AIOS core installed (${aiosCoreResult.installedFolders.length} folders)`);
+        console.log(`   - Agents: ${aiosCoreResult.installedFolders.includes('agents') ? '✓' : '⨉'}`);
+        console.log(`   - Tasks: ${aiosCoreResult.installedFolders.includes('tasks') ? '✓' : '⨉'}`);
+        console.log(`   - Workflows: ${aiosCoreResult.installedFolders.includes('workflows') ? '✓' : '⨉'}`);
+        console.log(`   - Templates: ${aiosCoreResult.installedFolders.includes('templates') ? '✓' : '⨉'}`);
+      }
+      answers.aiosCoreInstalled = true;
+      answers.aiosCoreResult = aiosCoreResult;
+    } catch (error) {
+      console.error('\n⚠️  AIOS core installation failed:', error.message);
+      answers.aiosCoreInstalled = false;
+    }
+
+    // Install Expansion Packs if selected
+    if (answers.selectedExpansionPacks && answers.selectedExpansionPacks.length > 0) {
+      console.log('\n🎁 Installing Expansion Packs...');
+
+      // Detect source expansion-packs directory (npm package location)
+      const possibleSourceDirs = [
+        path.join(__dirname, '..', '..', 'expansion-packs'),
+        path.join(__dirname, '..', '..', '..', 'expansion-packs'),
+        path.join(process.cwd(), 'node_modules', 'aios-fullstack', 'expansion-packs'),
+      ];
+
+      let sourceExpansionDir = null;
+      for (const dir of possibleSourceDirs) {
+        if (fse.existsSync(dir)) {
+          sourceExpansionDir = dir;
+          break;
+        }
+      }
+
+      if (sourceExpansionDir) {
+        const targetExpansionDir = path.join(process.cwd(), 'expansion-packs');
+        await fse.ensureDir(targetExpansionDir);
+
+        const installedPacks = [];
+        const failedPacks = [];
+
+        for (const pack of answers.selectedExpansionPacks) {
+          const sourcePack = path.join(sourceExpansionDir, pack);
+          const targetPack = path.join(targetExpansionDir, pack);
+
+          try {
+            if (fse.existsSync(sourcePack)) {
+              await fse.copy(sourcePack, targetPack);
+              installedPacks.push(pack);
+              console.log(`   ✅ ${pack}`);
+            } else {
+              failedPacks.push({ pack, reason: 'not found' });
+              console.log(`   ⚠️  ${pack} - not found in source`);
+            }
+          } catch (packError) {
+            failedPacks.push({ pack, reason: packError.message });
+            console.log(`   ⚠️  ${pack} - ${packError.message}`);
+          }
+        }
+
+        answers.expansionPacksInstalled = installedPacks.length > 0;
+        answers.expansionPacksResult = {
+          installed: installedPacks,
+          failed: failedPacks,
+          targetDir: targetExpansionDir,
+        };
+
+        if (installedPacks.length > 0) {
+          console.log(`\n✅ Expansion Packs installed (${installedPacks.length}/${answers.selectedExpansionPacks.length})`);
+        }
+      } else {
+        console.log('   ⚠️  Expansion packs source directory not found');
+        answers.expansionPacksInstalled = false;
+      }
+    }
+
+    // Story 1.4: Generate IDE configs if IDEs were selected
+    let ideConfigResult = null;
+    if (answers.selectedIDEs && answers.selectedIDEs.length > 0) {
+      ideConfigResult = await generateIDEConfigs(answers.selectedIDEs, answers);
+
+      if (ideConfigResult.success) {
+        showSuccessSummary(ideConfigResult);
+      } else {
+        console.error('\n⚠️  Some IDE configurations could not be created:');
+        if (ideConfigResult.errors) {
+          ideConfigResult.errors.forEach(err => {
+            console.error(`  - ${err.ide || 'Unknown'}: ${err.error}`);
+          });
+        }
+      }
+
+      // Install expansion pack agents to each selected IDE
+      if (answers.expansionPacksResult && answers.expansionPacksResult.installed.length > 0) {
+        console.log('\n📦 Installing expansion pack agents to IDEs...');
+
+        for (const packName of answers.expansionPacksResult.installed) {
+          const packAgentsDir = path.join(answers.expansionPacksResult.targetDir, packName, 'agents');
+
+          if (await fse.pathExists(packAgentsDir)) {
+            const agentFiles = (await fse.readdir(packAgentsDir)).filter(f => f.endsWith('.md'));
+
+            if (agentFiles.length > 0) {
+              for (const ideKey of answers.selectedIDEs) {
+                const ideConfig = getIDEConfig(ideKey);
+                if (!ideConfig || !ideConfig.agentFolder) continue;
+
+                const isAntiGravity = ideConfig.specialConfig && ideConfig.specialConfig.type === 'antigravity';
+
+                // Determine target folder for this expansion pack
+                let targetFolder;
+                if (isAntiGravity) {
+                  // AntiGravity: workflows go to .agent/workflows/{packName}/
+                  targetFolder = path.join(process.cwd(), ideConfig.agentFolder, packName);
+                  // Also need to copy actual agents to .antigravity/agents/{packName}/
+                  const agentsTargetFolder = path.join(process.cwd(), ideConfig.specialConfig.agentsFolder, packName);
+                  await fse.ensureDir(agentsTargetFolder);
+
+                  for (const agentFile of agentFiles) {
+                    const sourcePath = path.join(packAgentsDir, agentFile);
+                    const agentName = agentFile.replace('.md', '');
+
+                    // Create workflow file
+                    const workflowContent = generateExpansionPackWorkflow(agentName, packName);
+                    await fse.ensureDir(targetFolder);
+                    await fse.writeFile(path.join(targetFolder, agentFile), workflowContent, 'utf8');
+
+                    // Copy actual agent
+                    await fse.copy(sourcePath, path.join(agentsTargetFolder, agentFile));
+                  }
+                } else {
+                  // Other IDEs: copy directly to agentFolder/{packName}/
+                  targetFolder = path.join(process.cwd(), ideConfig.agentFolder, packName);
+                  await fse.ensureDir(targetFolder);
+
+                  for (const agentFile of agentFiles) {
+                    await fse.copy(
+                      path.join(packAgentsDir, agentFile),
+                      path.join(targetFolder, agentFile),
+                    );
+                  }
+                }
+              }
+              console.log(`   ✅ ${packName}: ${agentFiles.length} agents installed to ${answers.selectedIDEs.length} IDE(s)`);
+            }
+          }
+        }
+      }
+    }
+
+    // Story 1.6: Environment Configuration
+    console.log('\n📝 Configuring environment...');
+
+    try {
+      const envResult = await configureEnvironment({
+        targetDir: process.cwd(),
+        projectType: answers.projectType || 'greenfield',
+        selectedIDEs: answers.selectedIDEs || [],
+        mcpServers: answers.mcpServers || [],
+        skipPrompts: false,  // Interactive mode
+      });
+
+      if (envResult.envCreated && envResult.coreConfigCreated) {
+        console.log('\n✅ Environment configuration complete!');
+        console.log('  - .env file created');
+        console.log('  - .env.example file created');
+        console.log('  - .aios-core/core-config.yaml created');
+        if (envResult.gitignoreUpdated) {
+          console.log('  - .gitignore updated');
+        }
+      }
+
+      // Store env config result for downstream stories
+      answers.envConfigured = true;
+      answers.envResult = envResult;
+
+    } catch (error) {
+      console.error('\n⚠️  Environment configuration failed:');
+      console.error(`  ${error.message}`);
+
+      // Ask user if they want to continue without env config
+      const { continueWithoutEnv } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'continueWithoutEnv',
+          message: 'Continue installation without environment configuration?',
+          default: false,
+        },
+      ]);
+
+      if (!continueWithoutEnv) {
+        throw new Error('Installation cancelled - environment configuration required');
+      }
+
+      answers.envConfigured = false;
+      console.log('\n⚠️  Continuing without environment configuration...');
+    }
+
+    // Story 1.7: Dependency Installation
+    // Check if package.json exists first (greenfield projects won't have one)
+    const { detectPackageManager } = require('../installer/dependency-installer');
+    const projectPath = process.cwd();
+    const packageJsonExists = await hasPackageJson(projectPath);
+
+    if (!packageJsonExists) {
+      // Greenfield project - no package.json, skip dependency installation
+      console.log('\n📦 Dependency installation...');
+      console.log('   ℹ️  No package.json found (greenfield project)');
+      console.log('   💡 Dependencies will be installed when you add a package.json');
+      answers.depsInstalled = true; // Mark as success since there's nothing to install
+      answers.depsResult = { success: true, skipped: true, reason: 'no-package-json' };
+      answers.packageManager = detectPackageManager();
+    } else {
+      // Brownfield project or existing project - has package.json
+      console.log('\n📦 Installing dependencies...');
+
+      // Auto-detect package manager (no longer asked as question)
+      const detectedPM = detectPackageManager();
+      answers.packageManager = detectedPM;
+
+      try {
+        const depsResult = await installDependencies({
+          packageManager: detectedPM,
+          projectPath: projectPath,
+        });
+
+        if (depsResult.success) {
+          if (depsResult.offlineMode) {
+            console.log('✅ Using existing dependencies (offline mode)');
+          } else {
+            console.log(`✅ Dependencies installed with ${depsResult.packageManager}!`);
+          }
+          answers.depsInstalled = true;
+          answers.depsResult = depsResult;
+        } else {
+          console.error('\n⚠️  Dependency installation failed:');
+          console.error(`  ${depsResult.errorMessage}`);
+          console.error(`  Solution: ${depsResult.solution}`);
+
+          // Ask user if they want to retry
+          const { retryDeps } = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'retryDeps',
+              message: 'Retry dependency installation?',
+              default: true,
+            },
+          ]);
+
+          if (retryDeps) {
+            // Recursive retry with exponential backoff (built into installDependencies)
+            const retryResult = await installDependencies({
+              packageManager: answers.packageManager,
+              projectPath: projectPath,
+            });
+
+            if (retryResult.success) {
+              console.log(`\n✅ Dependencies installed with ${retryResult.packageManager}!`);
+              answers.depsInstalled = true;
+              answers.depsResult = retryResult;
+            } else {
+              console.log('\n⚠️  Installation still failed. You can run `npm install` manually later.');
+              answers.depsInstalled = false;
+              answers.depsResult = retryResult;
+            }
+          } else {
+            console.log('\n⚠️  Skipping dependency installation. Run manually with `npm install`.');
+            answers.depsInstalled = false;
+            answers.depsResult = depsResult;
+          }
+        }
+      } catch (error) {
+        console.error('\n⚠️  Dependency installation error:', error.message);
+        answers.depsInstalled = false;
+      }
+    }
+
+    // Story 1.5/1.8: MCP Installation
+    if (answers.selectedMCPs && answers.selectedMCPs.length > 0) {
+      console.log('\n🔌 Installing MCPs...');
+
+      try {
+        const mcpResult = await installProjectMCPs({
+          selectedMCPs: answers.selectedMCPs,
+          projectPath: process.cwd(),
+          apiKeys: answers.exaApiKey ? { EXA_API_KEY: answers.exaApiKey } : {},
+          onProgress: (status) => {
+            if (status.mcp) {
+              console.log(`  [${status.mcp}] ${status.message}`);
+            } else {
+              console.log(`  ${status.message}`);
+            }
+          },
+        });
+
+        if (mcpResult.success) {
+          const successCount = Object.values(mcpResult.installedMCPs).filter(r => r.status === 'success').length;
+          console.log(`\n✅ MCPs installed successfully! (${successCount}/${answers.selectedMCPs.length})`);
+          console.log(`   Configuration: ${mcpResult.configPath}`);
+        } else {
+          console.error('\n⚠️  Some MCPs failed to install:');
+          mcpResult.errors.forEach(err => console.error(`  - ${err}`));
+          console.log('\n💡 Check .aios/install-errors.log for details');
+        }
+
+        // Store MCP result for validation
+        answers.mcpsInstalled = mcpResult.success;
+        answers.mcpResult = mcpResult;
+
+      } catch (error) {
+        console.error('\n⚠️  MCP installation error:', error.message);
+        answers.mcpsInstalled = false;
+      }
+    }
+
+    // Story 6.7: LLM Routing Installation
+    console.log('\n🚀 Installing LLM Routing commands...');
+    try {
+      // Check if already installed
+      if (isLLMRoutingInstalled()) {
+        console.log('   ℹ️  LLM Routing already installed');
+        answers.llmRoutingInstalled = true;
+        answers.llmRoutingResult = { success: true, alreadyInstalled: true };
+      } else {
+        const llmResult = installLLMRouting({
+          projectRoot: process.cwd(),
+          onProgress: (msg) => console.log(`   ${msg}`),
+          onError: (msg) => console.error(`   ${msg}`)
+        });
+
+        if (llmResult.success) {
+          console.log('\n✅ LLM Routing installed!');
+          console.log('   • claude-max  → Uses Claude Max subscription');
+          console.log('   • claude-free → Uses DeepSeek (~$0.14/M tokens)');
+          console.log('\n   💡 For claude-free, add DEEPSEEK_API_KEY to your .env');
+          answers.llmRoutingInstalled = true;
+          answers.llmRoutingResult = llmResult;
+        } else {
+          console.error('\n⚠️  LLM Routing installation had errors:');
+          llmResult.errors.forEach(err => console.error(`   - ${err}`));
+          answers.llmRoutingInstalled = false;
+          answers.llmRoutingResult = llmResult;
+        }
+      }
+    } catch (error) {
+      console.error('\n⚠️  LLM Routing error:', error.message);
+      answers.llmRoutingInstalled = false;
+    }
+
+    // Story 1.8: Installation Validation
+    console.log('\n🔍 Validating installation...\n');
+
+    try {
+      const validation = await validateInstallation(
+        {
+          files: {
+            ideConfigs: ideConfigResult?.files || [],
+            env: '.env',
+            coreConfig: '.aios-core/core-config.yaml',
+            mcpConfig: '.mcp.json',
+          },
+          configs: {
+            env: answers.envResult,
+            mcps: answers.mcpResult,
+            coreConfig: '.aios-core/core-config.yaml',
+          },
+          mcps: answers.mcpResult,
+          dependencies: answers.depsResult,
+        },
+        (status) => {
+          console.log(`  [${status.step}] ${status.message}`);
+        },
+      );
+
+      // Display validation report
+      await displayValidationReport(validation);
+
+      // Offer troubleshooting if there are errors
+      if (validation.errors && validation.errors.length > 0) {
+        await provideTroubleshooting(validation.errors);
+      }
+
+      // Store validation result
+      answers.validationResult = validation;
+    } catch (error) {
+      console.error('\n⚠️  Validation failed:', error.message);
+      console.log('Installation may be incomplete. Check logs in .aios/ directory.');
+    }
+
+    // Show completion
+    showCompletion();
+
+    return answers;
+  } catch (error) {
+    if (error.isTtyError) {
+      console.error('Error: Prompt couldn\'t be rendered in the current environment');
+    } else {
+      console.error('Wizard error:', error.message);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Answer object schema (for integration documentation)
+ *
+ * @typedef {Object} WizardAnswers
+ * @property {string} projectType - 'greenfield' or 'brownfield' (Story 1.3)
+ * @property {string[]} [selectedIDEs] - Selected IDEs array (Story 1.4)
+ * @property {string[]} [mcpServers] - Selected MCP servers (Story 1.5)
+ * @property {boolean} [envConfigured] - Whether env config succeeded (Story 1.6)
+ * @property {Object} [envResult] - Environment configuration result (Story 1.6)
+ * @property {boolean} envResult.envCreated - .env file created
+ * @property {boolean} envResult.envExampleCreated - .env.example file created
+ * @property {boolean} envResult.coreConfigCreated - core-config.yaml created
+ * @property {boolean} envResult.gitignoreUpdated - .gitignore updated
+ * @property {Array<string>} envResult.errors - Any errors encountered
+ * @property {string} packageManager - Selected package manager (Story 1.7)
+ * @property {boolean} [depsInstalled] - Whether dependencies installed successfully (Story 1.7)
+ * @property {Object} [depsResult] - Dependency installation result (Story 1.7)
+ * @property {boolean} depsResult.success - Installation succeeded
+ * @property {boolean} [depsResult.offlineMode] - Used existing node_modules
+ * @property {string} depsResult.packageManager - Package manager used
+ * @property {string} [depsResult.error] - Error message if failed
+ */
+
+module.exports = {
+  runWizard,
+};
+