create-genia-os 2.4.0 → 3.0.0

package/template/.aiox-core/development/scripts/elicitation-engine.js

@@ -0,0 +1,385 @@
+/**
+ * Interactive Elicitation Engine for AIOX-FULLSTACK
+ * Handles progressive disclosure and contextual validation for component creation
+ * @module elicitation-engine
+ */
+
+const inquirer = require('inquirer');
+const fs = require('fs-extra');
+const path = require('path');
+const SecurityChecker = require('./security-checker');
+const ElicitationSessionManager = require('./elicitation-session-manager');
+const chalk = require('chalk');
+
+class ElicitationEngine {
+  constructor() {
+    this.securityChecker = new SecurityChecker();
+    this.sessionManager = new ElicitationSessionManager();
+    this.sessionData = {};
+    this.sessionFile = null;
+  }
+
+  /**
+   * Start a new elicitation session
+   * @param {string} componentType - Type of component being created
+   * @param {Object} options - Session options
+   */
+  async startSession(componentType, options = {}) {
+    this.sessionData = {
+      componentType,
+      startTime: new Date().toISOString(),
+      answers: {},
+      currentStep: 0,
+      options
+    };
+    
+    if (options.saveSession) {
+      this.sessionFile = path.join(
+        process.cwd(), 
+        '.aiox-sessions', 
+        `${componentType}-${Date.now()}.json`
+      );
+      await fs.ensureDir(path.dirname(this.sessionFile));
+    }
+  }
+
+  /**
+   * Run progressive elicitation workflow
+   * @param {Array} steps - Array of elicitation steps
+   * @returns {Promise<Object>} Collected answers
+   */
+  async runProgressive(steps) {
+    // If mocked, return mocked answers immediately
+    if (this.isMocked) {
+      this.isMocked = false;
+      return this.mockedAnswers;
+    }
+    
+    console.log(chalk.blue(`\n🚀 Starting ${this.sessionData.componentType} creation wizard...\n`));
+    
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      this.sessionData.currentStep = i;
+      
+      // Show step header
+      console.log(chalk.yellow(`\n📋 Step ${i + 1}/${steps.length}: ${step.title}`));
+      if (step.description) {
+        console.log(chalk.gray(step.description));
+      }
+      
+      // Check if step should be shown based on previous answers
+      if (step.condition && !this.evaluateCondition(step.condition)) {
+        continue;
+      }
+      
+      // Run step questions
+      const stepAnswers = await this.runStep(step);
+      Object.assign(this.sessionData.answers, stepAnswers);
+      
+      // Save session after each step
+      if (this.sessionFile) {
+        await this.saveSession();
+      }
+      
+      // Allow early exit if requested
+      if (stepAnswers._exit) {
+        console.log(chalk.yellow('\n⚠️  Elicitation cancelled by user'));
+        return null;
+      }
+    }
+    
+    return this.sessionData.answers;
+  }
+
+  /**
+   * Run a single elicitation step
+   * @private
+   */
+  async runStep(step) {
+    const questions = step.questions.map(q => this.enhanceQuestion(q, step));
+    
+    // Add contextual help if available
+    if (step.help) {
+      questions.unshift({
+        type: 'confirm',
+        name: '_showHelp',
+        message: 'Would you like to see help for this step?',
+        default: false
+      });
+    }
+    
+    const answers = await inquirer.prompt(questions);
+    
+    // Show help if requested
+    if (answers._showHelp && step.help) {
+      console.log(chalk.cyan('\n💡 ' + step.help));
+      delete answers._showHelp;
+      return this.runStep(step); // Re-run the step
+    }
+    
+    // Validate answers
+    const validation = await this.validateStepAnswers(answers, step);
+    if (!validation.valid) {
+      console.log(chalk.red('\n❌ Validation errors:'));
+      validation.errors.forEach(err => console.log(chalk.red(`  - ${err}`)));
+      return this.runStep(step); // Re-run the step
+    }
+    
+    return answers;
+  }
+
+  /**
+   * Enhance a question with smart defaults and validation
+   * @private
+   */
+  enhanceQuestion(question, step) {
+    const enhanced = { ...question };
+    
+    // Add smart defaults based on previous answers
+    if (question.smartDefault) {
+      enhanced.default = this.getSmartDefault(question.smartDefault);
+    }
+    
+    // Add validation with security checks
+    const originalValidate = enhanced.validate;
+    enhanced.validate = async (input) => {
+      // Type validation
+      if (typeof input !== 'string' && question.type === 'input') {
+        return 'Invalid input type';
+      }
+      
+      // Security validation using the refactored SecurityChecker
+      // Note: SecurityChecker.checkCode expects string input for validation
+      const securityResult = this.securityChecker.checkCode(String(input));
+      if (!securityResult.valid) {
+        return `Security check failed: ${securityResult.errors[0]?.message || 'Invalid input'}`;
+      }
+      
+      // Original validation
+      if (originalValidate) {
+        const result = await originalValidate(input);
+        if (result !== true) return result;
+      }
+      
+      // Step-specific validation
+      if (step.validation && step.validation[question.name]) {
+        const validator = step.validation[question.name];
+        const result = await this.runValidator(validator, input);
+        if (result !== true) return result;
+      }
+      
+      return true;
+    };
+    
+    // Add examples to message if available
+    if (question.examples && question.examples.length > 0) {
+      enhanced.message += chalk.gray(` (e.g., ${question.examples.join(', ')})`);
+    }
+    
+    return enhanced;
+  }
+
+  /**
+   * Get smart default value based on previous answers
+   * @private
+   */
+  getSmartDefault(smartDefaultConfig) {
+    const { type, source, transform } = smartDefaultConfig;
+    
+    switch (type) {
+      case 'fromAnswer':
+        const value = this.sessionData.answers[source];
+        return transform ? transform(value) : value;
+        
+      case 'generated':
+        return this.generateDefault(smartDefaultConfig);
+        
+      case 'conditional':
+        const condition = this.evaluateCondition(smartDefaultConfig.condition);
+        return condition ? smartDefaultConfig.ifTrue : smartDefaultConfig.ifFalse;
+        
+      default:
+        return undefined;
+    }
+  }
+
+  /**
+   * Generate a default value
+   * @private
+   */
+  generateDefault(config) {
+    switch (config.generator) {
+      case 'kebabCase':
+        const source = this.sessionData.answers[config.source] || '';
+        return source.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+        
+      case 'timestamp':
+        return new Date().toISOString();
+        
+      case 'version':
+        return '1.0.0';
+        
+      default:
+        return '';
+    }
+  }
+
+  /**
+   * Evaluate a condition based on answers
+   * @private
+   */
+  evaluateCondition(condition) {
+    const { field, operator, value } = condition;
+    const fieldValue = this.sessionData.answers[field];
+    
+    switch (operator) {
+      case 'equals':
+        return fieldValue === value;
+      case 'notEquals':
+        return fieldValue !== value;
+      case 'includes':
+        return Array.isArray(fieldValue) && fieldValue.includes(value);
+      case 'exists':
+        return fieldValue !== undefined && fieldValue !== null;
+      default:
+        return true;
+    }
+  }
+
+  /**
+   * Validate step answers
+   * @private
+   */
+  async validateStepAnswers(answers, step) {
+    const errors = [];
+    
+    // Check required fields
+    if (step.required) {
+      for (const field of step.required) {
+        if (!answers[field]) {
+          errors.push(`${field} is required`);
+        }
+      }
+    }
+    
+    // Run custom validators
+    if (step.validators) {
+      for (const validator of step.validators) {
+        const result = await this.runValidator(validator, answers);
+        if (result !== true) {
+          errors.push(result);
+        }
+      }
+    }
+    
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Run a validator function
+   * @private
+   */
+  async runValidator(validator, value) {
+    if (typeof validator === 'function') {
+      return validator(value);
+    }
+    
+    if (typeof validator === 'object') {
+      switch (validator.type) {
+        case 'regex':
+          const regex = new RegExp(validator.pattern);
+          return regex.test(value) || validator.message;
+          
+        case 'length':
+          if (validator.min && value.length < validator.min) {
+            return `Must be at least ${validator.min} characters`;
+          }
+          if (validator.max && value.length > validator.max) {
+            return `Must be at most ${validator.max} characters`;
+          }
+          return true;
+          
+        case 'unique':
+          const exists = await this.checkExists(validator.path, value);
+          return !exists || `${value} already exists`;
+          
+        default:
+          return true;
+      }
+    }
+    
+    return true;
+  }
+
+  /**
+   * Check if a component already exists
+   * @private
+   */
+  async checkExists(pathTemplate, name) {
+    const filePath = pathTemplate.replace('{name}', name);
+    return fs.pathExists(filePath);
+  }
+
+  /**
+   * Save current session to file
+   * @private
+   */
+  async saveSession() {
+    if (this.sessionFile) {
+      await fs.writeJson(this.sessionFile, this.sessionData, { spaces: 2 });
+    }
+  }
+
+  /**
+   * Load a saved session
+   * @param {string} sessionPath - Path to session file
+   */
+  async loadSession(sessionPath) {
+    this.sessionData = await fs.readJson(sessionPath);
+    this.sessionFile = sessionPath;
+    return this.sessionData;
+  }
+
+  /**
+   * Get session summary
+   * @returns {Object} Summary of current session
+   */
+  getSessionSummary() {
+    return {
+      componentType: this.sessionData.componentType,
+      completedSteps: this.sessionData.currentStep + 1,
+      answers: Object.keys(this.sessionData.answers).length,
+      duration: this.sessionData.startTime ? 
+        Date.now() - new Date(this.sessionData.startTime).getTime() : 0
+    };
+  }
+
+  /**
+   * Mock a session with predefined answers for batch creation
+   * @param {Object} answers - Predefined answers
+   */
+  async mockSession(answers) {
+    this.mockedAnswers = answers;
+    this.isMocked = true;
+  }
+
+  /**
+   * Complete elicitation session
+   * @param {string} status - Completion status
+   */
+  async completeSession(status) {
+    if (this.currentSession) {
+      this.currentSession.status = status;
+      this.currentSession.completedAt = new Date().toISOString();
+      
+      if (this.currentSession.saveSession) {
+        await this.sessionManager.saveSession(this.currentSession);
+      }
+    }
+  }
+}
+
+module.exports = ElicitationEngine;

package/template/.aiox-core/development/scripts/elicitation-session-manager.js

@@ -0,0 +1,300 @@
+/**
+ * Elicitation Session Manager
+ * Handles saving and loading elicitation sessions
+ * @module elicitation-session-manager
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const crypto = require('crypto');
+
+class ElicitationSessionManager {
+  constructor(sessionDir = '.aiox-sessions') {
+    this.sessionDir = path.resolve(process.cwd(), sessionDir);
+    this.activeSession = null;
+  }
+
+  /**
+   * Initialize session storage
+   */
+  async init() {
+    await fs.ensureDir(this.sessionDir);
+  }
+
+  /**
+   * Create a new session
+   * @param {string} type - Component type (agent, task, workflow)
+   * @param {Object} metadata - Additional session metadata
+   * @returns {Promise<string>} Session ID
+   */
+  async createSession(type, metadata = {}) {
+    const sessionId = this.generateSessionId();
+    const session = {
+      id: sessionId,
+      type,
+      version: '1.0',
+      created: new Date().toISOString(),
+      updated: new Date().toISOString(),
+      status: 'active',
+      currentStep: 0,
+      totalSteps: 0,
+      answers: {},
+      metadata: {
+        ...metadata,
+        user: process.env.USER || 'unknown',
+        hostname: require('os').hostname()
+      }
+    };
+
+    this.activeSession = session;
+    await this.saveSession(session);
+    
+    return sessionId;
+  }
+
+  /**
+   * Save current session state
+   * @param {Object} session - Session data to save
+   */
+  async saveSession(session = null) {
+    const sessionToSave = session || this.activeSession;
+    if (!sessionToSave) {
+      throw new Error('No active session to save');
+    }
+
+    sessionToSave.updated = new Date().toISOString();
+    
+    const sessionPath = this.getSessionPath(sessionToSave.id);
+    await fs.writeJson(sessionPath, sessionToSave, { spaces: 2 });
+  }
+
+  /**
+   * Load an existing session
+   * @param {string} sessionId - Session ID to load
+   * @returns {Promise<Object>} Session data
+   */
+  async loadSession(sessionId) {
+    const sessionPath = this.getSessionPath(sessionId);
+    
+    if (!await fs.pathExists(sessionPath)) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    const session = await fs.readJson(sessionPath);
+    this.activeSession = session;
+    
+    return session;
+  }
+
+  /**
+   * Update session answers
+   * @param {Object} answers - New answers to merge
+   * @param {number} stepIndex - Current step index
+   */
+  async updateAnswers(answers, stepIndex = null) {
+    if (!this.activeSession) {
+      throw new Error('No active session');
+    }
+
+    // Merge answers
+    Object.assign(this.activeSession.answers, answers);
+    
+    // Update step index if provided
+    if (stepIndex !== null) {
+      this.activeSession.currentStep = stepIndex;
+    }
+
+    await this.saveSession();
+  }
+
+  /**
+   * List all sessions
+   * @param {Object} filters - Filter options
+   * @returns {Promise<Array>} List of sessions
+   */
+  async listSessions(filters = {}) {
+    const files = await fs.readdir(this.sessionDir);
+    const sessions = [];
+
+    for (const file of files) {
+      if (file.endsWith('.json')) {
+        try {
+          const sessionPath = path.join(this.sessionDir, file);
+          const session = await fs.readJson(sessionPath);
+          
+          // Apply filters
+          if (filters.type && session.type !== filters.type) continue;
+          if (filters.status && session.status !== filters.status) continue;
+          if (filters.after && new Date(session.created) < new Date(filters.after)) continue;
+          
+          sessions.push({
+            id: session.id,
+            type: session.type,
+            created: session.created,
+            updated: session.updated,
+            status: session.status,
+            progress: session.totalSteps > 0 ? 
+              Math.round((session.currentStep / session.totalSteps) * 100) : 0
+          });
+        } catch (_error) {
+          // Skip invalid session files
+          console.warn(`Invalid session file: ${file}`);
+        }
+      }
+    }
+
+    // Sort by updated date (newest first)
+    sessions.sort((a, b) => new Date(b.updated) - new Date(a.updated));
+    
+    return sessions;
+  }
+
+  /**
+   * Resume a session
+   * @param {string} sessionId - Session ID to resume
+   * @returns {Promise<Object>} Session data with resume info
+   */
+  async resumeSession(sessionId) {
+    const session = await this.loadSession(sessionId);
+    
+    // Calculate resume information
+    const resumeInfo = {
+      ...session,
+      resumeFrom: session.currentStep,
+      completedSteps: Object.keys(session.answers).length,
+      remainingSteps: session.totalSteps - session.currentStep,
+      percentComplete: session.totalSteps > 0 ? 
+        Math.round((session.currentStep / session.totalSteps) * 100) : 0
+    };
+
+    return resumeInfo;
+  }
+
+  /**
+   * Complete a session
+   * @param {string} result - Completion result (success, cancelled, error)
+   */
+  async completeSession(result = 'success') {
+    if (!this.activeSession) {
+      throw new Error('No active session');
+    }
+
+    this.activeSession.status = 'completed';
+    this.activeSession.completedAt = new Date().toISOString();
+    this.activeSession.result = result;
+    
+    await this.saveSession();
+    
+    // Move to completed directory if success
+    if (result === 'success') {
+      const completedDir = path.join(this.sessionDir, 'completed');
+      await fs.ensureDir(completedDir);
+      
+      const oldPath = this.getSessionPath(this.activeSession.id);
+      const newPath = path.join(completedDir, path.basename(oldPath));
+      
+      await fs.move(oldPath, newPath, { overwrite: true });
+    }
+
+    this.activeSession = null;
+  }
+
+  /**
+   * Delete a session
+   * @param {string} sessionId - Session ID to delete
+   */
+  async deleteSession(sessionId) {
+    const sessionPath = this.getSessionPath(sessionId);
+    const completedPath = path.join(this.sessionDir, 'completed', `${sessionId}.json`);
+    
+    // Check both active and completed directories
+    if (await fs.pathExists(sessionPath)) {
+      await fs.remove(sessionPath);
+    } else if (await fs.pathExists(completedPath)) {
+      await fs.remove(completedPath);
+    } else {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    // Clear active session if it matches
+    if (this.activeSession && this.activeSession.id === sessionId) {
+      this.activeSession = null;
+    }
+  }
+
+  /**
+   * Export session data
+   * @param {string} sessionId - Session ID to export
+   * @param {string} format - Export format (json, yaml)
+   * @returns {Promise<string>} Exported data
+   */
+  async exportSession(sessionId, format = 'json') {
+    const session = await this.loadSession(sessionId);
+    
+    switch (format) {
+      case 'json':
+        return JSON.stringify(session, null, 2);
+        
+      case 'yaml':
+        const yaml = require('js-yaml');
+        return yaml.dump(session);
+        
+      default:
+        throw new Error(`Unsupported export format: ${format}`);
+    }
+  }
+
+  /**
+   * Clean up old sessions
+   * @param {number} daysOld - Delete sessions older than this many days
+   */
+  async cleanupOldSessions(daysOld = 30) {
+    const sessions = await this.listSessions();
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+    
+    let deletedCount = 0;
+    
+    for (const session of sessions) {
+      if (new Date(session.updated) < cutoffDate && session.status !== 'active') {
+        await this.deleteSession(session.id);
+        deletedCount++;
+      }
+    }
+    
+    return deletedCount;
+  }
+
+  /**
+   * Generate a unique session ID
+   * @private
+   */
+  generateSessionId() {
+    return crypto.randomBytes(8).toString('hex');
+  }
+
+  /**
+   * Get session file path
+   * @private
+   */
+  getSessionPath(sessionId) {
+    return path.join(this.sessionDir, `${sessionId}.json`);
+  }
+
+  /**
+   * Get active session
+   * @returns {Object|null} Active session or null
+   */
+  getActiveSession() {
+    return this.activeSession;
+  }
+
+  /**
+   * Clear active session
+   */
+  clearActiveSession() {
+    this.activeSession = null;
+  }
+}
+
+module.exports = ElicitationSessionManager;