create-genia-os 2.4.0 → 3.0.0

package/template/.aiox-core/workflow-intelligence/learning/index.js

@@ -0,0 +1,305 @@
+/**
+ * @module learning
+ * @description Pattern Learning module for Workflow Intelligence System
+ * @story WIS-5 - Pattern Capture (Internal)
+ * @version 1.0.0
+ *
+ * @example
+ * const learning = require('./.aiox-core/workflow-intelligence/learning');
+ *
+ * // Capture a session pattern
+ * const capture = learning.createPatternCapture();
+ * const result = capture.captureSession({
+ *   commands: ['validate-story-draft', 'develop', 'review-qa'],
+ *   agentSequence: ['po', 'dev', 'qa'],
+ *   success: true,
+ *   timestamp: Date.now()
+ * });
+ *
+ * // Validate the pattern
+ * const validator = learning.createPatternValidator();
+ * const validation = validator.validate(result.pattern);
+ *
+ * // Store if valid
+ * if (validation.valid) {
+ *   const store = learning.createPatternStore();
+ *   store.save(result.pattern);
+ * }
+ */
+
+'use strict';
+
+const {
+  PatternCapture,
+  createPatternCapture,
+  DEFAULT_MIN_SEQUENCE_LENGTH,
+  KEY_WORKFLOW_COMMANDS,
+} = require('./pattern-capture');
+
+const {
+  PatternValidator,
+  createPatternValidator,
+  DEFAULT_VALIDATION_RULES,
+  KNOWN_COMMANDS,
+} = require('./pattern-validator');
+
+const {
+  PatternStore,
+  createPatternStore,
+  DEFAULT_STORAGE_PATH,
+  DEFAULT_MAX_PATTERNS,
+  DEFAULT_PRUNE_THRESHOLD,
+  PATTERN_STATUS,
+} = require('./pattern-store');
+
+const {
+  GotchaRegistry,
+  DEFAULT_CONFIG: GOTCHA_DEFAULT_CONFIG,
+  GOTCHA_SCHEMA,
+} = require('./gotcha-registry');
+
+const {
+  QAFeedbackProcessor,
+  DEFAULT_CONFIG: QA_FEEDBACK_DEFAULT_CONFIG,
+} = require('./qa-feedback');
+
+const {
+  SemanticSearch,
+  createSemanticSearch,
+  DEFAULT_CONFIG: SEMANTIC_SEARCH_DEFAULT_CONFIG,
+} = require('./semantic-search');
+
+/**
+ * Singleton instances for default usage
+ */
+let defaultCapture = null;
+let defaultValidator = null;
+let defaultStore = null;
+let defaultGotchaRegistry = null;
+let defaultQAFeedbackProcessor = null;
+let defaultSemanticSearch = null;
+
+/**
+ * Get or create the default PatternCapture instance
+ * @returns {PatternCapture} Default capture instance
+ */
+function getDefaultCapture() {
+  if (!defaultCapture) {
+    defaultCapture = createPatternCapture();
+  }
+  return defaultCapture;
+}
+
+/**
+ * Get or create the default PatternValidator instance
+ * @returns {PatternValidator} Default validator instance
+ */
+function getDefaultValidator() {
+  if (!defaultValidator) {
+    defaultValidator = createPatternValidator();
+  }
+  return defaultValidator;
+}
+
+/**
+ * Get or create the default PatternStore instance
+ * @returns {PatternStore} Default store instance
+ */
+function getDefaultStore() {
+  if (!defaultStore) {
+    defaultStore = createPatternStore();
+  }
+  return defaultStore;
+}
+
+/**
+ * Get or create the default GotchaRegistry instance
+ * @param {Object} options - Options for GotchaRegistry
+ * @returns {GotchaRegistry} Default gotcha registry instance
+ */
+function getDefaultGotchaRegistry(options = {}) {
+  if (!defaultGotchaRegistry) {
+    defaultGotchaRegistry = new GotchaRegistry(options);
+  }
+  return defaultGotchaRegistry;
+}
+
+/**
+ * Get or create the default QAFeedbackProcessor instance
+ * @param {Object} options - Options for QAFeedbackProcessor
+ * @returns {QAFeedbackProcessor} Default QA feedback processor instance
+ */
+function getDefaultQAFeedbackProcessor(options = {}) {
+  if (!defaultQAFeedbackProcessor) {
+    // Inject gotcha registry and pattern store
+    defaultQAFeedbackProcessor = new QAFeedbackProcessor({
+      ...options,
+      gotchaRegistry: getDefaultGotchaRegistry(),
+      patternStore: getDefaultStore(),
+    });
+  }
+  return defaultQAFeedbackProcessor;
+}
+
+/**
+ * Get or create the default SemanticSearch instance
+ * @param {Object} options - Options for SemanticSearch
+ * @returns {SemanticSearch} Default semantic search instance
+ */
+function getDefaultSemanticSearch(options = {}) {
+  if (!defaultSemanticSearch) {
+    defaultSemanticSearch = createSemanticSearch(options);
+  }
+  return defaultSemanticSearch;
+}
+
+/**
+ * Capture and store a pattern in one operation
+ * @param {Object} sessionData - Session data
+ * @returns {Object} Result with captured and stored status
+ */
+function captureAndStore(sessionData) {
+  const capture = getDefaultCapture();
+  const validator = getDefaultValidator();
+  const store = getDefaultStore();
+
+  // Capture
+  const captureResult = capture.captureSession(sessionData);
+
+  if (!captureResult.valid) {
+    return {
+      success: false,
+      stage: 'capture',
+      reason: captureResult.reason,
+    };
+  }
+
+  // Validate
+  const validation = validator.validate(captureResult.pattern);
+
+  if (!validation.valid) {
+    return {
+      success: false,
+      stage: 'validation',
+      reason: validation.reason,
+      errors: validation.errors,
+    };
+  }
+
+  // Check for duplicates
+  const existingPatterns = store.load().patterns;
+  const duplicateCheck = validator.isDuplicate(captureResult.pattern, existingPatterns);
+
+  if (duplicateCheck.isDuplicate) {
+    // Update existing pattern instead
+    const existing = existingPatterns.find((p) => p.id === duplicateCheck.duplicateOf);
+    if (existing) {
+      store.save(existing); // This will increment occurrences
+      return {
+        success: true,
+        action: 'merged',
+        patternId: existing.id,
+      };
+    }
+  }
+
+  // Store
+  const storeResult = store.save(captureResult.pattern);
+
+  return {
+    success: true,
+    action: storeResult.action,
+    pattern: storeResult.pattern,
+  };
+}
+
+/**
+ * Get learned patterns for suggestions
+ * @param {Object} options - Options
+ * @param {boolean} options.activeOnly - Only return active/promoted patterns
+ * @returns {Object[]} Patterns
+ */
+function getLearnedPatterns(options = {}) {
+  const store = getDefaultStore();
+
+  if (options.activeOnly) {
+    return store.getActivePatterns();
+  }
+
+  return store.load().patterns;
+}
+
+/**
+ * Find patterns matching a command sequence
+ * @param {string[]} sequence - Command sequence to match
+ * @returns {Object[]} Matching patterns
+ */
+function findMatchingPatterns(sequence) {
+  const store = getDefaultStore();
+  return store.findSimilar(sequence);
+}
+
+/**
+ * Get pattern learning statistics
+ * @returns {Object} Statistics
+ */
+function getStats() {
+  return getDefaultStore().getStats();
+}
+
+/**
+ * Reset singleton instances (for testing)
+ */
+function reset() {
+  defaultCapture = null;
+  defaultValidator = null;
+  defaultStore = null;
+  defaultGotchaRegistry = null;
+  defaultQAFeedbackProcessor = null;
+  defaultSemanticSearch = null;
+}
+
+module.exports = {
+  // High-level API
+  captureAndStore,
+  getLearnedPatterns,
+  findMatchingPatterns,
+  getStats,
+  reset,
+
+  // Singleton accessors
+  getDefaultCapture,
+  getDefaultValidator,
+  getDefaultStore,
+  getDefaultGotchaRegistry,
+  getDefaultQAFeedbackProcessor,
+  getDefaultSemanticSearch,
+
+  // Factory functions
+  createPatternCapture,
+  createPatternValidator,
+  createPatternStore,
+  createSemanticSearch,
+
+  // Classes (for advanced usage)
+  PatternCapture,
+  PatternValidator,
+  PatternStore,
+  GotchaRegistry,
+  QAFeedbackProcessor,
+  SemanticSearch,
+
+  // Constants
+  DEFAULT_MIN_SEQUENCE_LENGTH,
+  KEY_WORKFLOW_COMMANDS,
+  DEFAULT_VALIDATION_RULES,
+  KNOWN_COMMANDS,
+  DEFAULT_STORAGE_PATH,
+  DEFAULT_MAX_PATTERNS,
+  DEFAULT_PRUNE_THRESHOLD,
+  PATTERN_STATUS,
+  GOTCHA_DEFAULT_CONFIG,
+  GOTCHA_SCHEMA,
+  QA_FEEDBACK_DEFAULT_CONFIG,
+  SEMANTIC_SEARCH_DEFAULT_CONFIG,
+};

package/template/.aiox-core/workflow-intelligence/learning/pattern-capture.js

@@ -0,0 +1,329 @@
+/**
+ * @module PatternCapture
+ * @description Captures workflow patterns from user sessions
+ * @story WIS-5 - Pattern Capture (Internal)
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+
+/**
+ * Default minimum sequence length for pattern capture
+ * @type {number}
+ */
+const DEFAULT_MIN_SEQUENCE_LENGTH = 3;
+
+/**
+ * Key workflow commands that trigger pattern capture
+ * @type {string[]}
+ */
+const KEY_WORKFLOW_COMMANDS = [
+  'develop',
+  'review-qa',
+  'apply-qa-fixes',
+  'validate-story-draft',
+  'create-story',
+  'create-next-story',
+  'run-tests',
+  'create-pr',
+];
+
+/**
+ * PatternCapture class for capturing workflow patterns from sessions
+ */
+class PatternCapture {
+  /**
+   * Create a PatternCapture instance
+   * @param {Object} options - Configuration options
+   * @param {number} options.minSequenceLength - Minimum sequence length (default: 3)
+   * @param {string[]} options.keyCommands - Commands that trigger capture
+   * @param {boolean} options.enabled - Whether capture is enabled
+   */
+  constructor(options = {}) {
+    this.minSequenceLength = options.minSequenceLength || DEFAULT_MIN_SEQUENCE_LENGTH;
+    this.keyCommands = options.keyCommands || KEY_WORKFLOW_COMMANDS;
+    this.enabled = options.enabled !== false && process.env.AIOX_PATTERN_CAPTURE !== 'false';
+    this.sessionBuffer = new Map(); // Track ongoing sessions
+  }
+
+  /**
+   * Capture a completed session as a pattern
+   * @param {Object} sessionData - Session data to capture
+   * @param {string[]} sessionData.agentSequence - Sequence of agents used
+   * @param {string[]} sessionData.commands - Sequence of commands executed
+   * @param {boolean} sessionData.success - Whether workflow completed successfully
+   * @param {number} sessionData.timestamp - Session timestamp
+   * @param {string} sessionData.sessionId - Unique session identifier
+   * @returns {Object} Captured pattern with validity info
+   */
+  captureSession(sessionData) {
+    if (!this.enabled) {
+      return { valid: false, reason: 'Pattern capture disabled' };
+    }
+
+    if (!sessionData || !sessionData.commands) {
+      return { valid: false, reason: 'Invalid session data' };
+    }
+
+    // Only capture successful workflows
+    if (!sessionData.success) {
+      return { valid: false, reason: 'Workflow not successful' };
+    }
+
+    // Check minimum sequence length
+    if (sessionData.commands.length < this.minSequenceLength) {
+      return {
+        valid: false,
+        reason: `Sequence too short (${sessionData.commands.length} < ${this.minSequenceLength})`,
+      };
+    }
+
+    // Extract normalized command sequence
+    const sequence = this._normalizeCommands(sessionData.commands);
+    const agents = this._normalizeAgents(sessionData.agentSequence || []);
+
+    // Build pattern object
+    const pattern = {
+      id: crypto.randomUUID(),
+      sequence: sequence,
+      agents: agents,
+      occurrences: 1,
+      successRate: 1.0,
+      firstSeen: new Date(sessionData.timestamp || Date.now()).toISOString(),
+      lastSeen: new Date(sessionData.timestamp || Date.now()).toISOString(),
+      sessionId: sessionData.sessionId || crypto.randomUUID(),
+      workflow: this._detectWorkflow(sequence),
+      status: 'pending',
+    };
+
+    return {
+      valid: true,
+      pattern: pattern,
+      sequence: sequence,
+    };
+  }
+
+  /**
+   * Extract pattern candidates from command history
+   * @param {string[]} commandHistory - Full command history
+   * @returns {Object[]} Array of pattern candidates
+   */
+  extractPatterns(commandHistory) {
+    if (!commandHistory || commandHistory.length < this.minSequenceLength) {
+      return [];
+    }
+
+    const patterns = [];
+    const normalized = this._normalizeCommands(commandHistory);
+
+    // Use sliding window to find subsequences
+    for (let length = this.minSequenceLength; length <= Math.min(normalized.length, 7); length++) {
+      for (let i = 0; i <= normalized.length - length; i++) {
+        const subsequence = normalized.slice(i, i + length);
+
+        // Only include if it contains at least one key command
+        if (this._containsKeyCommand(subsequence)) {
+          patterns.push({
+            sequence: subsequence,
+            startIndex: i,
+            length: length,
+          });
+        }
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * Get the minimum sequence length setting
+   * @returns {number} Minimum sequence length
+   */
+  getMinimumSequenceLength() {
+    return this.minSequenceLength;
+  }
+
+  /**
+   * Handle task completion event
+   * @param {string} taskName - Name of completed task
+   * @param {Object} context - Task context
+   * @returns {Promise<Object>} Capture result
+   */
+  async onTaskComplete(taskName, context) {
+    if (!this.enabled) {
+      return { captured: false, reason: 'disabled' };
+    }
+
+    const sessionId = context.sessionId || 'default';
+
+    // Get or create session buffer
+    if (!this.sessionBuffer.has(sessionId)) {
+      this.sessionBuffer.set(sessionId, {
+        commands: [],
+        agents: [],
+        startTime: Date.now(),
+        success: true,
+      });
+    }
+
+    const session = this.sessionBuffer.get(sessionId);
+
+    // Add command to buffer
+    const normalizedTask = this._normalizeCommand(taskName);
+    session.commands.push(normalizedTask);
+
+    // Track agent if provided
+    if (context.agentId) {
+      const normalizedAgent = context.agentId.replace('@', '');
+      if (!session.agents.includes(normalizedAgent)) {
+        session.agents.push(normalizedAgent);
+      }
+    }
+
+    // Check if this is a workflow-ending command
+    if (this._isWorkflowEnd(normalizedTask)) {
+      const result = this.captureSession({
+        commands: session.commands,
+        agentSequence: session.agents,
+        success: session.success,
+        timestamp: Date.now(),
+        sessionId: sessionId,
+      });
+
+      // Clear session buffer
+      this.sessionBuffer.delete(sessionId);
+
+      return {
+        captured: result.valid,
+        pattern: result.pattern,
+        reason: result.reason,
+      };
+    }
+
+    return { captured: false, reason: 'workflow_in_progress' };
+  }
+
+  /**
+   * Mark current session as failed
+   * @param {string} sessionId - Session identifier
+   */
+  markSessionFailed(sessionId) {
+    const session = this.sessionBuffer.get(sessionId || 'default');
+    if (session) {
+      session.success = false;
+    }
+  }
+
+  /**
+   * Clear session buffer
+   * @param {string} sessionId - Session identifier (optional, clears all if not provided)
+   */
+  clearSession(sessionId) {
+    if (sessionId) {
+      this.sessionBuffer.delete(sessionId);
+    } else {
+      this.sessionBuffer.clear();
+    }
+  }
+
+  /**
+   * Normalize command name
+   * @param {string} command - Command to normalize
+   * @returns {string} Normalized command
+   * @private
+   */
+  _normalizeCommand(command) {
+    if (!command) return '';
+    return command
+      .replace(/^\*/, '') // Remove * prefix
+      .replace(/-/g, '-') // Keep hyphens
+      .toLowerCase()
+      .trim();
+  }
+
+  /**
+   * Normalize array of commands
+   * @param {string[]} commands - Commands to normalize
+   * @returns {string[]} Normalized commands
+   * @private
+   */
+  _normalizeCommands(commands) {
+    return commands.map((cmd) => this._normalizeCommand(cmd)).filter((cmd) => cmd.length > 0);
+  }
+
+  /**
+   * Normalize array of agent IDs
+   * @param {string[]} agents - Agent IDs to normalize
+   * @returns {string[]} Normalized agent IDs
+   * @private
+   */
+  _normalizeAgents(agents) {
+    return agents
+      .map((agent) => agent.replace('@', '').toLowerCase().trim())
+      .filter((agent) => agent.length > 0);
+  }
+
+  /**
+   * Check if sequence contains at least one key workflow command
+   * @param {string[]} sequence - Command sequence
+   * @returns {boolean} True if contains key command
+   * @private
+   */
+  _containsKeyCommand(sequence) {
+    return sequence.some((cmd) => this.keyCommands.some((key) => cmd.includes(key)));
+  }
+
+  /**
+   * Detect workflow type from command sequence
+   * @param {string[]} sequence - Command sequence
+   * @returns {string|null} Detected workflow name or null
+   * @private
+   */
+  _detectWorkflow(sequence) {
+    const joined = sequence.join(' ');
+
+    if (joined.includes('develop') && (joined.includes('review-qa') || joined.includes('qa'))) {
+      return 'story_development';
+    }
+    if (joined.includes('create-story') || joined.includes('validate-story')) {
+      return 'story_creation';
+    }
+    if (joined.includes('create-epic')) {
+      return 'epic_creation';
+    }
+    if (joined.includes('create-pr') || joined.includes('push')) {
+      return 'deployment';
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if command indicates end of workflow
+   * @param {string} command - Command to check
+   * @returns {boolean} True if workflow-ending command
+   * @private
+   */
+  _isWorkflowEnd(command) {
+    const endCommands = ['create-pr', 'push', 'deploy', 'complete', 'done', 'finish'];
+    return endCommands.some((end) => command.includes(end));
+  }
+}
+
+/**
+ * Create a new PatternCapture instance
+ * @param {Object} options - Configuration options
+ * @returns {PatternCapture} New instance
+ */
+function createPatternCapture(options = {}) {
+  return new PatternCapture(options);
+}
+
+module.exports = {
+  PatternCapture,
+  createPatternCapture,
+  DEFAULT_MIN_SEQUENCE_LENGTH,
+  KEY_WORKFLOW_COMMANDS,
+};