aios-core 2.1.0

package/src/wizard/questions.js

@@ -0,0 +1,249 @@
+/**
+ * Wizard Questions Definitions
+ * 
+ * Modular question system for AIOS installation wizard
+ * Questions from Stories 1.3-1.6 will be added here
+ * 
+ * @module wizard/questions
+ */
+
+const { colors } = require('../utils/aios-colors');
+const { createInquirerValidator, validateProjectType } = require('./validators');
+
+/**
+ * Get project type question (Story 1.3)
+ * This is a placeholder - full implementation in Story 1.3
+ * 
+ * @returns {Object} Inquirer question object
+ */
+function getProjectTypeQuestion() {
+  return {
+    type: 'list',
+    name: 'projectType',
+    message: colors.primary('What type of project are you setting up?'),
+    choices: [
+      {
+        name: colors.highlight('Greenfield') + colors.dim(' (new project from scratch)'),
+        value: 'greenfield',
+      },
+      {
+        name: 'Brownfield' + colors.dim(' (existing project integration)'),
+        value: 'brownfield',
+      },
+    ],
+    default: 0,
+    validate: createInquirerValidator(validateProjectType),
+  };
+}
+
+/**
+ * Get IDE selection questions (Story 1.4)
+ *
+ * @returns {Object[]} Array of inquirer question objects
+ */
+function getIDEQuestions() {
+  const { getIDESelectionQuestion } = require('./ide-selector');
+  return [getIDESelectionQuestion()];
+}
+
+/**
+ * Get package manager selection question (Story 1.7)
+ *
+ * @param {string} detectedPM - Auto-detected package manager
+ * @returns {Object} Inquirer question object
+ */
+function getPackageManagerQuestion(detectedPM = 'npm') {
+  return {
+    type: 'list',
+    name: 'packageManager',
+    message: colors.primary('Which package manager should be used?'),
+    choices: [
+      {
+        name: detectedPM === 'npm'
+          ? colors.highlight('npm') + colors.dim(' (detected)')
+          : 'npm',
+        value: 'npm',
+      },
+      {
+        name: detectedPM === 'yarn'
+          ? colors.highlight('yarn') + colors.dim(' (detected)')
+          : 'yarn',
+        value: 'yarn',
+      },
+      {
+        name: detectedPM === 'pnpm'
+          ? colors.highlight('pnpm') + colors.dim(' (detected)')
+          : 'pnpm',
+        value: 'pnpm',
+      },
+      {
+        name: detectedPM === 'bun'
+          ? colors.highlight('bun') + colors.dim(' (detected)')
+          : 'bun',
+        value: 'bun',
+      },
+    ],
+    default: ['npm', 'yarn', 'pnpm', 'bun'].indexOf(detectedPM) || 0,
+  };
+}
+
+/**
+ * Get MCP selection questions (Story 1.5 / 1.8 Integration)
+ *
+ * @returns {Object[]} Array of inquirer question objects
+ */
+function getMCPQuestions() {
+  return [
+    {
+      type: 'checkbox',
+      name: 'selectedMCPs',
+      message: colors.primary('Select MCPs to install (project-level):'),
+      choices: [
+        {
+          name: colors.highlight('Browser (Puppeteer)') + colors.dim(' - Web automation and testing'),
+          value: 'browser',
+          checked: true,
+        },
+        {
+          name: colors.highlight('Context7') + colors.dim(' - Library documentation search'),
+          value: 'context7',
+          checked: true,
+        },
+        {
+          name: colors.highlight('Exa') + colors.dim(' - Advanced web search'),
+          value: 'exa',
+          checked: true,
+        },
+        {
+          name: colors.highlight('Desktop Commander') + colors.dim(' - File system access'),
+          value: 'desktop-commander',
+          checked: true,
+        },
+      ],
+      validate: () => {
+        // Allow empty selection (user can skip MCP installation)
+        return true;
+      },
+    },
+    // Note: API keys are configured later via aios-master or directly in .env
+  ];
+}
+
+/**
+ * Get environment configuration questions (Story 1.6)
+ *
+ * DESIGN NOTE: Environment configuration uses its own prompt system
+ * via @clack/prompts in packages/installer/src/config/configure-environment.js
+ *
+ * API key prompts are NOT part of wizard questions to keep the
+ * environment module self-contained and testable independently.
+ *
+ * The wizard calls configureEnvironment() directly after IDE selection
+ * in src/wizard/index.js (Task 1.6.7)
+ *
+ * @returns {Object[]} Empty array - prompts handled in environment module
+ */
+function getEnvironmentQuestions() {
+  // Environment config prompts handled in configure-environment.js
+  // No wizard questions needed for this story
+  return [];
+}
+
+/**
+ * Get Expansion Pack selection questions
+ *
+ * Available expansion packs for v2.1:
+ * - expansion-creator: Tools to create custom expansion packs
+ * - etl: ETL pipeline for knowledge base creation
+ *
+ * @returns {Object[]} Array of inquirer question objects
+ */
+function getExpansionPackQuestions() {
+  return [
+    {
+      type: 'checkbox',
+      name: 'selectedExpansionPacks',
+      message: colors.primary('Select Expansion Packs to install (optional):'),
+      choices: [
+        {
+          name: colors.highlight('expansion-creator') + colors.dim(' - Tools to create custom expansion packs'),
+          value: 'expansion-creator',
+          checked: false,
+        },
+        {
+          name: colors.highlight('etl') + colors.dim(' - ETL pipeline for knowledge base creation'),
+          value: 'etl',
+          checked: false,
+        },
+      ],
+      validate: () => {
+        // Allow empty selection (user can skip expansion pack installation)
+        return true;
+      },
+    },
+  ];
+}
+
+/**
+ * Build complete question sequence
+ * Allows conditional questions based on previous answers
+ *
+ * @param {Object} context - Context with previous answers
+ * @returns {Object[]} Array of questions
+ */
+function buildQuestionSequence(_context = {}) {
+  const questions = [];
+
+  // Story 1.2: Foundation (project type only)
+  questions.push(getProjectTypeQuestion());
+
+  // Story 1.4: IDE Selection
+  questions.push(...getIDEQuestions());
+
+  // Story 1.5/1.8: MCP Selection
+  questions.push(...getMCPQuestions());
+
+  // Expansion Pack Selection (v2.1)
+  questions.push(...getExpansionPackQuestions());
+
+  // Story 1.7: Package Manager - Auto-detected (no question needed)
+  // The wizard will auto-detect and use the appropriate package manager
+  // See detectPackageManager() in dependency-installer.js
+
+  // Story 1.6: Environment Configuration
+  // Note: Env config prompts handled directly in configureEnvironment()
+  // See src/wizard/index.js integration (after IDE config step)
+
+  // Future: Conditional questions based on projectType
+  // if (context.projectType === 'greenfield') { ... }
+
+  return questions;
+}
+
+/**
+ * Get question by ID
+ * Useful for testing individual questions
+ * 
+ * @param {string} questionId - Question identifier
+ * @returns {Object|null} Question object or null if not found
+ */
+function getQuestionById(questionId) {
+  const questionMap = {
+    'projectType': getProjectTypeQuestion(),
+    // Future questions will be added here
+  };
+
+  return questionMap[questionId] || null;
+}
+
+module.exports = {
+  getProjectTypeQuestion,
+  getIDEQuestions,
+  getMCPQuestions,
+  getExpansionPackQuestions,
+  getEnvironmentQuestions,
+  getPackageManagerQuestion,
+  buildQuestionSequence,
+  getQuestionById,
+};
+

package/src/wizard/validation/index.js

@@ -0,0 +1,120 @@
+/**
+ * AIOS Installation Validation Module
+ * Story 1.8: Installation Validation
+ *
+ * Validates installation and provides comprehensive reporting
+ *
+ * @module wizard/validation
+ * @version 1.0.0
+ */
+
+const { validateFiles } = require('./validators/file-structure-validator');
+const { validateConfigs } = require('./validators/config-validator');
+const { validateMCPs } = require('./validators/mcp-health-checker');
+const { validateDependencies } = require('./validators/dependency-validator');
+const { generateReport } = require('./report-generator');
+const { offerTroubleshooting } = require('./troubleshooting-system');
+
+/**
+ * Main validation function
+ *
+ * @param {Object} installationContext - Installation context from wizard
+ * @param {Object} installationContext.files - File paths to validate
+ * @param {Object} installationContext.configs - Configuration objects
+ * @param {Object} installationContext.mcps - MCP installation results
+ * @param {Object} installationContext.dependencies - Dependency installation results
+ * @param {Function} onProgress - Progress callback (optional)
+ * @returns {Promise<Object>} Validation report
+ */
+async function validateInstallation(installationContext, onProgress = () => {}) {
+  const validationResults = {
+    timestamp: new Date().toISOString(),
+    components: {},
+    errors: [],
+    warnings: [],
+    overallStatus: 'unknown',
+  };
+
+  try {
+    // Phase 1: File Structure Validation (Task 1.8.1)
+    onProgress({ step: 'files', message: 'Validating file structure...', progress: 0 });
+    validationResults.components.files = await validateFiles(installationContext.files);
+
+    // Phase 2: Configuration Validation (Task 1.8.2)
+    onProgress({ step: 'configs', message: 'Validating configurations...', progress: 25 });
+    validationResults.components.configs = await validateConfigs(installationContext.configs);
+
+    // Phase 3: MCP Health Checks (Task 1.8.3)
+    if (installationContext.mcps) {
+      onProgress({ step: 'mcps', message: 'Running MCP health checks...', progress: 50 });
+      validationResults.components.mcps = await validateMCPs(installationContext.mcps);
+    }
+
+    // Phase 4: Dependency Validation (Task 1.8.4)
+    onProgress({ step: 'dependencies', message: 'Validating dependencies...', progress: 75 });
+    validationResults.components.dependencies = await validateDependencies(
+      installationContext.dependencies,
+    );
+
+    // Aggregate errors and warnings
+    for (const [component, result] of Object.entries(validationResults.components)) {
+      if (result.errors) {
+        validationResults.errors.push(...result.errors.map(e => ({ component, ...e })));
+      }
+      if (result.warnings) {
+        validationResults.warnings.push(...result.warnings.map(w => ({ component, ...w })));
+      }
+    }
+
+    // Determine overall status
+    const criticalErrors = validationResults.errors.filter(e => e.severity === 'critical');
+    if (criticalErrors.length > 0) {
+      validationResults.overallStatus = 'failed';
+    } else if (validationResults.errors.length > 0) {
+      validationResults.overallStatus = 'partial';
+    } else if (validationResults.warnings.length > 0) {
+      validationResults.overallStatus = 'warning';
+    } else {
+      validationResults.overallStatus = 'success';
+    }
+
+    onProgress({ step: 'complete', message: 'Validation complete', progress: 100 });
+
+    return validationResults;
+  } catch (error) {
+    validationResults.overallStatus = 'error';
+    validationResults.errors.push({
+      component: 'validation',
+      severity: 'critical',
+      message: `Validation failed: ${error.message}`,
+      details: error.stack,
+    });
+
+    return validationResults;
+  }
+}
+
+/**
+ * Display validation report to user
+ *
+ * @param {Object} validationResults - Results from validateInstallation
+ */
+async function displayValidationReport(validationResults) {
+  const report = await generateReport(validationResults);
+  console.log(report);
+}
+
+/**
+ * Offer troubleshooting for errors
+ *
+ * @param {Array} errors - Array of error objects
+ */
+async function provideTroubleshooting(errors) {
+  await offerTroubleshooting(errors);
+}
+
+module.exports = {
+  validateInstallation,
+  displayValidationReport,
+  provideTroubleshooting,
+};

package/src/wizard/validation/report-generator.js

@@ -0,0 +1,269 @@
+/**
+ * Validation Report Generator
+ * Task 1.8.5: Generates comprehensive validation report
+ *
+ * @module wizard/validation/report-generator
+ */
+
+const chalk = require('chalk');
+
+/**
+ * Generate formatted validation report
+ *
+ * @param {Object} validationResults - Results from validateInstallation
+ * @returns {Promise<string>} Formatted report
+ */
+async function generateReport(validationResults) {
+  const lines = [];
+
+  // Header
+  lines.push('');
+  lines.push(chalk.bold.cyan('═══════════════════════════════════════════════'));
+  lines.push(chalk.bold.cyan('🔍 Installation Validation Report'));
+  lines.push(chalk.bold.cyan('═══════════════════════════════════════════════'));
+  lines.push('');
+
+  // File Structure Section
+  if (validationResults.components.files) {
+    const fileResults = validationResults.components.files;
+    lines.push(formatComponentSection('IDE Configuration', fileResults, 'IDE Config'));
+    lines.push(formatComponentSection('Environment Configuration', fileResults, 'Environment'));
+    lines.push(formatComponentSection('Core Configuration', fileResults, 'Core Config'));
+    if (fileResults.checks.some(c => c.component === 'MCP Config')) {
+      lines.push(formatComponentSection('MCP Configuration', fileResults, 'MCP Config'));
+    }
+  }
+
+  // MCP Health Checks Section
+  if (validationResults.components.mcps && validationResults.components.mcps.healthChecks) {
+    lines.push(formatMCPSection(validationResults.components.mcps));
+  }
+
+  // Dependencies Section
+  if (validationResults.components.dependencies) {
+    lines.push(formatDependenciesSection(validationResults.components.dependencies));
+  }
+
+  // Overall Status
+  lines.push('');
+  lines.push(chalk.bold('═══════════════════════════════════════════════'));
+  lines.push(formatOverallStatus(validationResults));
+  lines.push(chalk.bold('═══════════════════════════════════════════════'));
+
+  // Warnings Section
+  if (validationResults.warnings.length > 0) {
+    lines.push('');
+    lines.push(chalk.bold.yellow(`⚠️  Warnings (${validationResults.warnings.length}):`));
+    validationResults.warnings.forEach(warning => {
+      lines.push(chalk.yellow(`  - ${warning.message}`));
+      if (warning.solution) {
+        lines.push(chalk.dim(`    Solution: ${warning.solution}`));
+      }
+    });
+  }
+
+  // Errors Section
+  if (validationResults.errors.length > 0) {
+    lines.push('');
+    lines.push(chalk.bold.red(`❌ Errors (${validationResults.errors.length}):`));
+    validationResults.errors.forEach(error => {
+      lines.push(chalk.red(`  - ${error.message}`));
+      if (error.solution) {
+        lines.push(chalk.dim(`    Solution: ${error.solution}`));
+      }
+    });
+  }
+
+  // Next Steps
+  if (validationResults.overallStatus === 'success') {
+    lines.push('');
+    lines.push(chalk.bold.green('✅ Next Steps:'));
+    lines.push(chalk.green('  1. Configure API keys in .env (if skipped)'));
+    lines.push(chalk.green('  2. Run your first AIOS command: aios --help'));
+    lines.push(chalk.green('  3. Start coding! 🚀'));
+  } else if (validationResults.overallStatus === 'warning') {
+    lines.push('');
+    lines.push(chalk.bold.yellow('⚠️  Next Steps:'));
+    lines.push(chalk.yellow('  1. Review warnings above'));
+    lines.push(chalk.yellow('  2. Fix recommended issues'));
+    lines.push(chalk.yellow('  3. Re-run validation if needed'));
+  } else if (validationResults.overallStatus === 'partial' || validationResults.overallStatus === 'failed') {
+    lines.push('');
+    lines.push(chalk.bold.red('❌ Next Steps:'));
+    lines.push(chalk.red('  1. Review errors above'));
+    lines.push(chalk.red('  2. Fix critical issues'));
+    lines.push(chalk.red('  3. Re-run installation: npx @allfluence/aios@latest init'));
+  }
+
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Format a component section
+ * @private
+ */
+function formatComponentSection(title, componentResults, componentName) {
+  const checks = componentResults.checks.filter(c => c.component === componentName);
+
+  if (checks.length === 0) return '';
+
+  const allSuccess = checks.every(c => c.status === 'success');
+  const icon = allSuccess ? chalk.green('✅') : chalk.yellow('⚠️');
+
+  const lines = [
+    `${icon} ${chalk.bold(title)}`,
+  ];
+
+  checks.forEach(check => {
+    const statusIcon = check.status === 'success' ? chalk.green('✓') : chalk.yellow('⚠');
+    const message = check.file
+      ? `${check.message} (${check.file})`
+      : check.message;
+    lines.push(`  ${statusIcon} ${message}`);
+  });
+
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Format MCP section
+ * @private
+ */
+function formatMCPSection(mcpResults) {
+  const healthChecks = mcpResults.healthChecks;
+
+  if (!healthChecks || healthChecks.length === 0) {
+    return chalk.dim('  MCPs not installed (skipped)\n');
+  }
+
+  const totalMCPs = healthChecks.length;
+  const healthyMCPs = healthChecks.filter(h => h.status === 'success').length;
+  const warningMCPs = healthChecks.filter(h => h.status === 'warning').length;
+  const failedMCPs = healthChecks.filter(h => h.status === 'failed').length;
+
+  const icon = healthyMCPs === totalMCPs
+    ? chalk.green('✅')
+    : healthyMCPs > 0
+      ? chalk.yellow('⚠️')
+      : chalk.red('❌');
+
+  const lines = [
+    `${icon} ${chalk.bold('MCP Installation')} (${healthyMCPs}/${totalMCPs} healthy${warningMCPs > 0 ? `, ${warningMCPs} warnings` : ''}${failedMCPs > 0 ? `, ${failedMCPs} failed` : ''})`,
+  ];
+
+  healthChecks.forEach(health => {
+    let statusIcon, statusText;
+
+    switch (health.status) {
+      case 'success':
+        statusIcon = chalk.green('✓');
+        statusText = chalk.green(health.message);
+        break;
+      case 'warning':
+        statusIcon = chalk.yellow('⚠');
+        statusText = chalk.yellow(health.message);
+        break;
+      case 'failed':
+        statusIcon = chalk.red('✗');
+        statusText = chalk.red(health.message);
+        break;
+      case 'skipped':
+        statusIcon = chalk.dim('-');
+        statusText = chalk.dim(health.message);
+        break;
+      default:
+        statusIcon = '?';
+        statusText = health.message;
+    }
+
+    const responseTime = health.responseTime
+      ? chalk.dim(` (${health.responseTime}ms)`)
+      : '';
+
+    lines.push(`  ${statusIcon} ${health.mcp} - ${statusText}${responseTime}`);
+  });
+
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Format dependencies section
+ * @private
+ */
+function formatDependenciesSection(depsResults) {
+  const allSuccess = depsResults.checks.every(c => c.status === 'success' || c.status === 'skipped');
+  const icon = allSuccess ? chalk.green('✅') : chalk.yellow('⚠️');
+
+  const lines = [
+    `${icon} ${chalk.bold('Dependencies')}`,
+  ];
+
+  depsResults.checks.forEach(check => {
+    let statusIcon, statusText;
+
+    switch (check.status) {
+      case 'success':
+        statusIcon = chalk.green('✓');
+        statusText = check.message;
+        break;
+      case 'skipped':
+        statusIcon = chalk.dim('-');
+        statusText = chalk.dim(check.message);
+        break;
+      default:
+        statusIcon = chalk.yellow('⚠');
+        statusText = check.message;
+    }
+
+    lines.push(`  ${statusIcon} ${check.component}: ${statusText}`);
+  });
+
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Format overall status
+ * @private
+ */
+function formatOverallStatus(validationResults) {
+  const status = validationResults.overallStatus;
+  const errorCount = validationResults.errors.length;
+  const warningCount = validationResults.warnings.length;
+
+  switch (status) {
+    case 'success':
+      return chalk.bold.green(
+        `Overall Status: ✅ SUCCESS${warningCount > 0 ? ` (${warningCount} warning${warningCount !== 1 ? 's' : ''})` : ''}`,
+      );
+
+    case 'warning':
+      return chalk.bold.yellow(
+        `Overall Status: ⚠️  SUCCESS WITH WARNINGS (${warningCount} warning${warningCount !== 1 ? 's' : ''})`,
+      );
+
+    case 'partial':
+      return chalk.bold.yellow(
+        `Overall Status: ⚠️  PARTIAL SUCCESS (${errorCount} error${errorCount !== 1 ? 's' : ''}, ${warningCount} warning${warningCount !== 1 ? 's' : ''})`,
+      );
+
+    case 'failed':
+      return chalk.bold.red(
+        `Overall Status: ❌ FAILED (${errorCount} error${errorCount !== 1 ? 's' : ''})`,
+      );
+
+    default:
+      return chalk.bold.gray('Overall Status: ❓ UNKNOWN');
+  }
+}
+
+module.exports = {
+  generateReport,
+};