create-genia-os 2.4.0 → 3.0.0

package/template/.aiox-core/development/scripts/decision-context.js

@@ -0,0 +1,228 @@
+/**
+ * Decision Tracking Context for Yolo Mode
+ *
+ * Maintains execution context and decision log during autonomous development.
+ * Used by dev agent in yolo mode to track decisions, files, tests, and metrics.
+ *
+ * @module decision-context
+ * @see .aiox-core/scripts/decision-log-generator.js - Generates final log from this context
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+/**
+ * Decision classification types (AC7)
+ */
+const DECISION_TYPES = {
+  'library-choice': 'Selecting external dependencies',
+  'architecture': 'System design and structural decisions',
+  'algorithm': 'Algorithm selection and optimization',
+  'error-handling': 'Error handling and recovery strategies',
+  'testing-strategy': 'Test approach and coverage decisions',
+  'performance': 'Performance optimization choices',
+  'security': 'Security implementation decisions',
+  'database': 'Data model and query optimization',
+};
+
+/**
+ * Priority levels for decisions (AC7)
+ */
+const PRIORITY_LEVELS = {
+  'critical': 'High-impact architectural decisions with long-term consequences',
+  'high': 'Significant technical choices affecting multiple components',
+  'medium': 'Standard implementation decisions with local impact',
+  'low': 'Minor preference decisions with minimal impact',
+};
+
+/**
+ * Decision Tracking Context
+ *
+ * Tracks all decisions, file changes, tests, and metrics during yolo mode execution.
+ */
+class DecisionContext {
+  /**
+   * Initialize decision tracking context
+   *
+   * @param {string} agentId - Agent identifier (e.g., 'dev')
+   * @param {string} storyPath - Path to story file being implemented
+   * @param {Object} options - Additional options
+   * @param {boolean} options.enabled - Whether decision logging is enabled (default: true)
+   */
+  constructor(agentId, storyPath, options = {}) {
+    this.agentId = agentId;
+    this.storyPath = storyPath;
+    this.startTime = Date.now();
+    this.endTime = null;
+    this.status = 'running';
+    this.enabled = options.enabled !== false;
+
+    // Core tracking arrays
+    this.decisions = [];
+    this.filesModified = [];
+    this.testsRun = [];
+    this.metrics = {
+      agentLoadTime: options.agentLoadTime || 0,
+      taskExecutionTime: 0,
+    };
+
+    // Capture git commit for rollback (AC5)
+    try {
+      this.commitBefore = execSync('git rev-parse HEAD').toString().trim();
+    } catch (error) {
+      this.commitBefore = 'unknown';
+      console.warn('Warning: Could not capture git commit hash:', error.message);
+    }
+  }
+
+  /**
+   * Record an autonomous decision (AC2, AC7)
+   *
+   * @param {Object} decision - Decision details
+   * @param {string} decision.description - What decision was made
+   * @param {string} decision.reason - Why this choice was made
+   * @param {string[]} decision.alternatives - Other options considered
+   * @param {string} decision.type - Decision type (from DECISION_TYPES)
+   * @param {string} decision.priority - Priority level (from PRIORITY_LEVELS)
+   * @returns {Object} The recorded decision with timestamp
+   */
+  recordDecision({ description, reason, alternatives = [], type = 'architecture', priority = 'medium' }) {
+    if (!this.enabled) return null;
+
+    // Validate decision type and priority
+    if (!DECISION_TYPES[type]) {
+      console.warn(`Warning: Unknown decision type "${type}", using "architecture"`);
+      type = 'architecture';
+    }
+    if (!PRIORITY_LEVELS[priority]) {
+      console.warn(`Warning: Unknown priority level "${priority}", using "medium"`);
+      priority = 'medium';
+    }
+
+    const decision = {
+      timestamp: Date.now(),
+      description,
+      reason,
+      alternatives: Array.isArray(alternatives) ? alternatives : [],
+      type,
+      priority,
+    };
+
+    this.decisions.push(decision);
+    return decision;
+  }
+
+  /**
+   * Track a file modification (AC2)
+   *
+   * @param {string} filePath - Path to modified file
+   * @param {string} action - Action performed ('created', 'modified', 'deleted')
+   */
+  trackFile(filePath, action = 'modified') {
+    if (!this.enabled) return;
+
+    const normalizedPath = path.normalize(filePath);
+
+    // Avoid duplicates - update existing entry if path already tracked
+    const existingIndex = this.filesModified.findIndex(f =>
+      (typeof f === 'string' ? f : f.path) === normalizedPath,
+    );
+
+    if (existingIndex >= 0) {
+      if (typeof this.filesModified[existingIndex] === 'string') {
+        this.filesModified[existingIndex] = { path: normalizedPath, action };
+      } else {
+        this.filesModified[existingIndex].action = action;
+      }
+    } else {
+      this.filesModified.push({ path: normalizedPath, action });
+    }
+  }
+
+  /**
+   * Track test execution (AC2)
+   *
+   * @param {Object} test - Test details
+   * @param {string} test.name - Test file or suite name
+   * @param {boolean} test.passed - Whether test passed
+   * @param {number} test.duration - Execution time in ms
+   * @param {string} test.error - Error message if failed
+   */
+  trackTest({ name, passed, duration, error }) {
+    if (!this.enabled) return;
+
+    this.testsRun.push({
+      name,
+      passed,
+      duration: duration || 0,
+      error: error || null,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * Update execution metrics (AC2, AC8)
+   *
+   * @param {Object} metrics - Metrics to update
+   * @param {number} metrics.agentLoadTime - Agent initialization time in ms
+   * @param {number} metrics.taskExecutionTime - Task execution time in ms
+   */
+  updateMetrics(metrics) {
+    if (!this.enabled) return;
+    this.metrics = { ...this.metrics, ...metrics };
+  }
+
+  /**
+   * Mark execution as complete
+   *
+   * @param {string} status - Final status ('completed', 'failed', 'cancelled')
+   */
+  complete(status = 'completed') {
+    this.endTime = Date.now();
+    this.status = status;
+    this.metrics.taskExecutionTime = this.endTime - this.startTime;
+  }
+
+  /**
+   * Get context as plain object for decision log generation
+   *
+   * @returns {Object} Context data
+   */
+  toObject() {
+    return {
+      agentId: this.agentId,
+      storyPath: this.storyPath,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      status: this.status,
+      decisions: this.decisions,
+      filesModified: this.filesModified,
+      testsRun: this.testsRun,
+      metrics: this.metrics,
+      commitBefore: this.commitBefore,
+    };
+  }
+
+  /**
+   * Get summary statistics
+   *
+   * @returns {Object} Summary stats
+   */
+  getSummary() {
+    return {
+      decisionsCount: this.decisions.length,
+      filesModifiedCount: this.filesModified.length,
+      testsRunCount: this.testsRun.length,
+      testsPassed: this.testsRun.filter(t => t.passed).length,
+      testsFailed: this.testsRun.filter(t => !t.passed).length,
+      duration: this.endTime ? this.endTime - this.startTime : Date.now() - this.startTime,
+      status: this.status,
+    };
+  }
+}
+
+module.exports = {
+  DecisionContext,
+  DECISION_TYPES,
+  PRIORITY_LEVELS,
+};

package/template/.aiox-core/development/scripts/decision-log-generator.js

@@ -0,0 +1,293 @@
+/**
+ * Decision Log Generator for AIOX Framework
+ *
+ * Generates decision logs for yolo mode execution to track autonomous
+ * decisions, files modified, tests run, and rollback information.
+ *
+ * @module decision-log-generator
+ * @version 1.0.0
+ * @created 2025-01-16 (Story 6.1.2.6)
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * Calculates duration between start and end time
+ *
+ * @param {Object} context - Execution context
+ * @returns {string} Formatted duration string
+ */
+function calculateDuration(context) {
+  if (!context.endTime) {
+    const elapsed = Date.now() - context.startTime;
+    return formatDuration(elapsed) + ' (in progress)';
+  }
+
+  const duration = context.endTime - context.startTime;
+  return formatDuration(duration);
+}
+
+/**
+ * Formats milliseconds into human-readable duration
+ *
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Formatted duration
+ */
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    const remainingMinutes = minutes % 60;
+    return `${hours}h ${remainingMinutes}m`;
+  } else if (minutes > 0) {
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+  } else {
+    return `${seconds}s`;
+  }
+}
+
+/**
+ * Generates markdown list of key decisions (ADR format - AC3, AC7)
+ *
+ * @param {Array} decisions - Array of decision objects
+ * @returns {string} Formatted markdown list
+ */
+function generateDecisionsList(decisions) {
+  if (!decisions || decisions.length === 0) {
+    return '*No autonomous decisions recorded.*';
+  }
+
+  let markdown = '';
+  decisions.forEach((decision, index) => {
+    markdown += `### Decision ${index + 1}: ${decision.description}\n\n`;
+    markdown += `**Timestamp:** ${new Date(decision.timestamp).toISOString()}\n\n`;
+
+    // Decision classification (AC7)
+    if (decision.type) {
+      markdown += `**Type:** ${decision.type}\n\n`;
+    }
+    if (decision.priority) {
+      markdown += `**Priority:** ${decision.priority}\n\n`;
+    }
+
+    markdown += `**Reason:** ${decision.reason}\n\n`;
+
+    if (decision.alternatives && decision.alternatives.length > 0) {
+      markdown += '**Alternatives Considered:**\n';
+      decision.alternatives.forEach(alt => {
+        markdown += `- ${alt}\n`;
+      });
+      markdown += '\n';
+    }
+
+    markdown += '---\n\n';
+  });
+
+  return markdown;
+}
+
+/**
+ * Generates markdown list of files modified
+ *
+ * @param {Array} filesModified - Array of file paths
+ * @returns {string} Formatted markdown list
+ */
+function generateFilesList(filesModified) {
+  if (!filesModified || filesModified.length === 0) {
+    return '*No files modified.*';
+  }
+
+  let markdown = '';
+  filesModified.forEach(file => {
+    const fileName = typeof file === 'string' ? file : file.path;
+    const action = file.action || 'modified';
+    markdown += `- \`${fileName}\` (${action})\n`;
+  });
+
+  return markdown;
+}
+
+/**
+ * Generates markdown list of tests run
+ *
+ * @param {Array} testsRun - Array of test objects
+ * @returns {string} Formatted markdown list
+ */
+function generateTestsList(testsRun) {
+  if (!testsRun || testsRun.length === 0) {
+    return '*No tests recorded.*';
+  }
+
+  let markdown = '';
+  testsRun.forEach(test => {
+    const status = test.passed ? '✅ PASS' : '❌ FAIL';
+    markdown += `- ${status}: \`${test.name}\``;
+
+    if (test.duration) {
+      markdown += ` (${test.duration}ms)`;
+    }
+
+    if (!test.passed && test.error) {
+      markdown += `\n  - Error: ${test.error}`;
+    }
+
+    markdown += '\n';
+  });
+
+  return markdown;
+}
+
+/**
+ * Generates markdown list of files for rollback
+ *
+ * @param {Array} filesModified - Array of file paths
+ * @returns {string} Formatted markdown list
+ */
+function generateRollbackFilesList(filesModified) {
+  if (!filesModified || filesModified.length === 0) {
+    return '*No files to rollback.*';
+  }
+
+  let markdown = '';
+  filesModified.forEach(file => {
+    const fileName = typeof file === 'string' ? file : file.path;
+    markdown += `- ${fileName}\n`;
+  });
+
+  return markdown;
+}
+
+/**
+ * Generates decision log for yolo mode execution
+ *
+ * @param {string} storyId - Story ID (e.g., "6.1.2.6")
+ * @param {Object} context - Execution context
+ * @param {string} context.agentId - Agent ID executing the story
+ * @param {string} context.storyPath - Path to story file
+ * @param {number} context.startTime - Start timestamp
+ * @param {number} [context.endTime] - End timestamp
+ * @param {string} context.status - Execution status
+ * @param {Array} [context.decisions] - Array of decision objects
+ * @param {Array} [context.filesModified] - Array of file paths modified
+ * @param {Array} [context.testsRun] - Array of test results
+ * @param {Object} [context.metrics] - Performance metrics
+ * @param {string} [context.commitBefore] - Git commit hash before execution
+ * @returns {Promise<string>} Path to decision log file
+ */
+async function generateDecisionLog(storyId, context) {
+  // Ensure .ai directory exists
+  const aiDir = '.ai';
+  try {
+    await fs.access(aiDir);
+  } catch (_error) {
+    await fs.mkdir(aiDir, { recursive: true });
+  }
+
+  const logPath = path.join(aiDir, `decision-log-${storyId}.md`);
+
+  // Format timestamps
+  const startTime = new Date(context.startTime).toISOString();
+  const endTime = context.endTime ? new Date(context.endTime).toISOString() : 'In Progress';
+
+  // ADR-compliant template structure (AC3)
+  const template = `# Decision Log: Story ${storyId}
+
+**Generated:** ${new Date().toISOString()}
+**Agent:** ${context.agentId}
+**Mode:** Yolo (Autonomous Development)
+**Story:** ${context.storyPath}
+**Rollback:** \`git reset --hard ${context.commitBefore || 'HEAD'}\`
+
+---
+
+## Context
+
+**Story Implementation:** ${storyId}
+**Execution Time:** ${calculateDuration(context)}
+**Status:** ${context.status}
+**Started:** ${startTime}
+**Completed:** ${endTime}
+
+**Files Modified:** ${context.filesModified?.length || 0} files
+**Tests Run:** ${context.testsRun?.length || 0} tests
+**Decisions Made:** ${context.decisions?.length || 0} autonomous decisions
+
+---
+
+## Decisions Made
+
+${generateDecisionsList(context.decisions)}
+
+---
+
+## Rationale & Alternatives
+
+The decisions above were made autonomously during yolo mode development. Each decision includes:
+- The specific choice made (Decision)
+- Why that choice was optimal (Reason)
+- What other options were considered (Alternatives)
+- Classification by type and priority (AC7)
+
+---
+
+## Implementation Changes
+
+### Files Modified
+
+${generateFilesList(context.filesModified)}
+
+### Test Results
+
+${generateTestsList(context.testsRun)}
+
+---
+
+## Consequences & Rollback
+
+### Rollback Instructions
+
+If you need to undo these changes:
+
+\`\`\`bash
+# Full rollback to state before execution
+git reset --hard ${context.commitBefore || 'HEAD'}
+
+# Selective file rollback
+git checkout ${context.commitBefore || 'HEAD'} -- <file-path>
+\`\`\`
+
+### Affected Files
+
+${generateRollbackFilesList(context.filesModified)}
+
+### Performance Impact
+
+${context.metrics ? `
+- Agent Load Time: ${context.metrics.agentLoadTime || 'N/A'}ms
+- Task Execution Time: ${context.metrics.taskExecutionTime || 'N/A'}ms
+- Logging Overhead: Minimal (async, non-blocking)
+` : '*No performance metrics recorded.*'}
+
+---
+
+*This is an Architecture Decision Record (ADR) auto-generated by AIOX Decision Logging System*
+*Story 6.1.2.6.2 - Decision Log Automation Infrastructure*
+`;
+
+  await fs.writeFile(logPath, template, 'utf8');
+
+  return logPath;
+}
+
+module.exports = {
+  generateDecisionLog,
+  calculateDuration,
+  generateDecisionsList,
+  generateFilesList,
+  generateTestsList,
+  generateRollbackFilesList,
+};