aios-core 2.1.0

package/.aios-core/core/elicitation/session-manager.js

@@ -0,0 +1,320 @@
+/**
+ * Elicitation Session Manager
+ * Handles saving and loading elicitation sessions
+ *
+ * @module core/elicitation/session-manager
+ * @migrated Story 2.2 - Core Module Creation
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const crypto = require('crypto');
+
+class ElicitationSessionManager {
+  constructor(sessionDir = '.aios-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');
+  }
+
+  /**
+   * Validate sessionId format to prevent path traversal attacks
+   * @param {string} sessionId - Session ID to validate
+   * @returns {boolean} True if valid hex format
+   * @private
+   */
+  isValidSessionId(sessionId) {
+    // SessionId must be a 16-character hex string (from crypto.randomBytes(8).toString('hex'))
+    return typeof sessionId === 'string' && /^[a-f0-9]{16}$/i.test(sessionId);
+  }
+
+  /**
+   * Get session file path
+   * @param {string} sessionId - Session ID
+   * @returns {string} Session file path
+   * @throws {Error} If sessionId format is invalid (path traversal prevention)
+   * @private
+   */
+  getSessionPath(sessionId) {
+    // Security: Validate sessionId format to prevent path traversal attacks
+    if (!this.isValidSessionId(sessionId)) {
+      throw new Error(`Invalid sessionId format: ${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;

package/.aios-core/core/elicitation/task-elicitation.js

@@ -0,0 +1,281 @@
+/**
+ * Task Creation Elicitation Workflow
+ * Progressive disclosure for creating new tasks
+ */
+
+const taskElicitationSteps = [
+  {
+    title: 'Basic Task Information',
+    description: 'Define the fundamental details of your task',
+    help: 'A task is a reusable workflow that an agent can execute. It should have a clear purpose and outcome.',
+    questions: [
+      {
+        type: 'input',
+        name: 'taskId',
+        message: 'What is the task ID?',
+        examples: ['analyze-data', 'generate-report', 'validate-code'],
+        validate: (input) => {
+          if (!input) return 'Task ID is required';
+          if (!/^[a-z][a-z0-9-]*$/.test(input)) {
+            return 'ID must be lowercase with hyphens only';
+          }
+          return true;
+        },
+      },
+      {
+        type: 'input',
+        name: 'taskTitle',
+        message: 'What is the task title?',
+        examples: ['Analyze Data Set', 'Generate Status Report', 'Validate Code Quality'],
+        smartDefault: {
+          type: 'fromAnswer',
+          source: 'taskId',
+          transform: (id) => id.split('-').map(w => 
+            w.charAt(0).toUpperCase() + w.slice(1),
+          ).join(' '),
+        },
+      },
+      {
+        type: 'input',
+        name: 'agentName',
+        message: 'Which agent will own this task?',
+        examples: ['data-analyst', 'report-generator', 'code-reviewer'],
+      },
+      {
+        type: 'input',
+        name: 'taskDescription',
+        message: 'Describe the task purpose (2-3 sentences):',
+        validate: (input) => input.length > 10 || 'Please provide a meaningful description',
+      },
+    ],
+    required: ['taskId', 'taskTitle', 'agentName', 'taskDescription'],
+  },
+
+  {
+    title: 'Task Context & Prerequisites',
+    description: 'Define what\'s needed before the task can run',
+    questions: [
+      {
+        type: 'confirm',
+        name: 'requiresContext',
+        message: 'Does this task require specific context or input?',
+        default: true,
+      },
+      {
+        type: 'input',
+        name: 'contextDescription',
+        message: 'What context/input is required?',
+        when: (answers) => answers.requiresContext,
+        examples: ['Data file path and format', 'Project configuration', 'User preferences'],
+      },
+      {
+        type: 'checkbox',
+        name: 'prerequisites',
+        message: 'Select prerequisites for this task:',
+        choices: [
+          'Valid file path provided',
+          'Required permissions granted',
+          'Dependencies installed',
+          'Configuration loaded',
+          'Previous task completed',
+          'User authentication',
+          'Network connectivity',
+        ],
+      },
+      {
+        type: 'input',
+        name: 'customPrerequisites',
+        message: 'Any additional prerequisites? (comma-separated):',
+        filter: (input) => input ? input.split(',').map(p => p.trim()) : [],
+      },
+    ],
+  },
+
+  {
+    title: 'Task Workflow',
+    description: 'Define how the task should be executed',
+    questions: [
+      {
+        type: 'confirm',
+        name: 'isInteractive',
+        message: 'Is this an interactive task (requires user input)?',
+        default: false,
+      },
+      {
+        type: 'list',
+        name: 'workflowType',
+        message: 'What type of workflow is this?',
+        choices: [
+          { name: 'Sequential - Steps run in order', value: 'sequential' },
+          { name: 'Conditional - Steps depend on conditions', value: 'conditional' },
+          { name: 'Iterative - Steps may repeat', value: 'iterative' },
+          { name: 'Parallel - Some steps run simultaneously', value: 'parallel' },
+        ],
+        default: 'sequential',
+      },
+      {
+        type: 'input',
+        name: 'stepCount',
+        message: 'How many main steps does this task have?',
+        default: '3',
+        validate: (input) => {
+          const num = parseInt(input);
+          return (num > 0 && num <= 10) || 'Please enter a number between 1 and 10';
+        },
+        filter: (input) => parseInt(input),
+      },
+    ],
+  },
+
+  {
+    title: 'Define Task Steps',
+    description: 'Specify each step in the workflow',
+    questions: [
+      {
+        type: 'input',
+        name: 'steps',
+        message: 'This will be handled dynamically based on stepCount',
+        // Note: In implementation, this would generate dynamic questions
+        // based on the stepCount from previous step
+      },
+    ],
+    validators: [
+      {
+        type: 'custom',
+        validate: (_answers) => {
+          // This would be implemented to collect step details
+          return true;
+        },
+      },
+    ],
+  },
+
+  {
+    title: 'Output & Success Criteria',
+    description: 'Define what the task produces and how to measure success',
+    questions: [
+      {
+        type: 'input',
+        name: 'outputDescription',
+        message: 'What does this task output/produce?',
+        examples: ['Analysis report in markdown', 'Validated data file', 'Test results summary'],
+      },
+      {
+        type: 'list',
+        name: 'outputFormat',
+        message: 'What format is the output?',
+        choices: [
+          'Text/Markdown',
+          'JSON',
+          'YAML',
+          'CSV',
+          'HTML',
+          'File(s)',
+          'Console output',
+          'Other',
+        ],
+      },
+      {
+        type: 'input',
+        name: 'outputFormatCustom',
+        message: 'Specify the output format:',
+        when: (answers) => answers.outputFormat === 'Other',
+      },
+      {
+        type: 'checkbox',
+        name: 'successCriteria',
+        message: 'Select success criteria:',
+        choices: [
+          'All steps completed without errors',
+          'Output file(s) created successfully',
+          'Validation checks passed',
+          'Performance within limits',
+          'User confirmation received',
+          'Tests passed',
+        ],
+      },
+    ],
+    required: ['outputDescription'],
+  },
+
+  {
+    title: 'Error Handling',
+    description: 'Configure how the task handles errors',
+    questions: [
+      {
+        type: 'list',
+        name: 'errorStrategy',
+        message: 'How should the task handle errors?',
+        choices: [
+          { name: 'Fail fast - Stop on first error', value: 'fail-fast' },
+          { name: 'Collect errors - Continue and report all', value: 'collect' },
+          { name: 'Retry - Attempt recovery', value: 'retry' },
+          { name: 'Fallback - Use alternative approach', value: 'fallback' },
+        ],
+        default: 'fail-fast',
+      },
+      {
+        type: 'input',
+        name: 'retryCount',
+        message: 'How many retry attempts?',
+        when: (answers) => answers.errorStrategy === 'retry',
+        default: '3',
+        validate: (input) => {
+          const num = parseInt(input);
+          return (num > 0 && num <= 5) || 'Please enter 1-5';
+        },
+      },
+      {
+        type: 'checkbox',
+        name: 'commonErrors',
+        message: 'Select common errors to handle:',
+        choices: [
+          'File not found',
+          'Permission denied',
+          'Invalid format',
+          'Network timeout',
+          'Resource busy',
+          'Validation failed',
+          'Dependency missing',
+        ],
+      },
+    ],
+  },
+
+  {
+    title: 'Security & Validation',
+    description: 'Configure security checks and validation',
+    condition: { field: 'taskId', operator: 'exists' },
+    questions: [
+      {
+        type: 'confirm',
+        name: 'enableSecurityChecks',
+        message: 'Enable security validation for inputs?',
+        default: true,
+      },
+      {
+        type: 'checkbox',
+        name: 'securityChecks',
+        message: 'Select security checks to apply:',
+        when: (answers) => answers.enableSecurityChecks,
+        choices: [
+          'Input sanitization',
+          'Path traversal prevention',
+          'Command injection prevention',
+          'File type validation',
+          'Size limits',
+          'Rate limiting',
+        ],
+        default: ['Input sanitization', 'Path traversal prevention'],
+      },
+      {
+        type: 'confirm',
+        name: 'enableExamples',
+        message: 'Would you like to add usage examples?',
+        default: false,
+      },
+    ],
+  },
+];
+
+module.exports = taskElicitationSteps;