aios-core 1.0.0

package/.aios-core/workflow-intelligence/learning/pattern-validator.js

@@ -0,0 +1,309 @@
+/**
+ * @module PatternValidator
+ * @description Validates workflow patterns before storage
+ * @story WIS-5 - Pattern Capture (Internal)
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/**
+ * Default validation rules
+ * @type {Object}
+ */
+const DEFAULT_VALIDATION_RULES = {
+  minSequenceLength: 3,
+  maxSequenceLength: 10,
+  minOccurrences: 2,
+  minSuccessRate: 0.8,
+  requiredKeyCommands: [
+    'develop',
+    'review-qa',
+    'create-story',
+    'validate-story-draft',
+    'apply-qa-fixes',
+    'run-tests'
+  ],
+  similarityThreshold: 0.85 // For fuzzy duplicate detection
+};
+
+/**
+ * Known AIOS task registry commands
+ * @type {Set<string>}
+ */
+const KNOWN_COMMANDS = new Set([
+  'develop',
+  'develop-yolo',
+  'develop-interactive',
+  'develop-preflight',
+  'review-qa',
+  'apply-qa-fixes',
+  'run-tests',
+  'create-story',
+  'create-next-story',
+  'validate-story-draft',
+  'create-pr',
+  'push',
+  'backlog-debt',
+  'help',
+  'exit',
+  'guide',
+  'explain',
+  'session-info',
+  'load-full',
+  'clear-cache',
+  'patterns',
+  'next'
+]);
+
+/**
+ * PatternValidator class for validating pattern quality
+ */
+class PatternValidator {
+  /**
+   * Create a PatternValidator instance
+   * @param {Object} options - Configuration options
+   * @param {Object} options.rules - Custom validation rules
+   */
+  constructor(options = {}) {
+    this.rules = { ...DEFAULT_VALIDATION_RULES, ...options.rules };
+  }
+
+  /**
+   * Validate a pattern against all rules
+   * @param {Object} pattern - Pattern to validate
+   * @returns {Object} Validation result with valid flag and reasons
+   */
+  validate(pattern) {
+    const errors = [];
+    const warnings = [];
+
+    // Check required fields
+    if (!pattern) {
+      return { valid: false, errors: ['Pattern is null or undefined'], warnings: [] };
+    }
+
+    if (!pattern.sequence || !Array.isArray(pattern.sequence)) {
+      return { valid: false, errors: ['Missing or invalid sequence'], warnings: [] };
+    }
+
+    // Rule 1: Minimum sequence length
+    if (pattern.sequence.length < this.rules.minSequenceLength) {
+      errors.push(
+        `Sequence too short: ${pattern.sequence.length} < minimum ${this.rules.minSequenceLength}`
+      );
+    }
+
+    // Rule 2: Maximum sequence length
+    if (pattern.sequence.length > this.rules.maxSequenceLength) {
+      warnings.push(
+        `Sequence unusually long: ${pattern.sequence.length} > ${this.rules.maxSequenceLength}`
+      );
+    }
+
+    // Rule 3: Minimum occurrences for promotion
+    if (pattern.occurrences !== undefined && pattern.occurrences < this.rules.minOccurrences) {
+      warnings.push(
+        `Low occurrences: ${pattern.occurrences} < minimum ${this.rules.minOccurrences} for promotion`
+      );
+    }
+
+    // Rule 4: Minimum success rate
+    if (pattern.successRate !== undefined && pattern.successRate < this.rules.minSuccessRate) {
+      errors.push(
+        `Success rate too low: ${(pattern.successRate * 100).toFixed(1)}% < ${(this.rules.minSuccessRate * 100).toFixed(1)}%`
+      );
+    }
+
+    // Rule 5: Must contain at least one key workflow command
+    const hasKeyCommand = pattern.sequence.some(cmd =>
+      this.rules.requiredKeyCommands.some(key => cmd.includes(key))
+    );
+    if (!hasKeyCommand) {
+      errors.push('Sequence must contain at least one key workflow command');
+    }
+
+    // Rule 6: All commands should exist in AIOS task registry
+    const unknownCommands = pattern.sequence.filter(cmd => !this._isKnownCommand(cmd));
+    if (unknownCommands.length > 0) {
+      warnings.push(`Unknown commands: ${unknownCommands.join(', ')}`);
+    }
+
+    // Rule 7: No duplicate consecutive commands
+    const hasDuplicateConsecutive = pattern.sequence.some(
+      (cmd, i) => i > 0 && cmd === pattern.sequence[i - 1]
+    );
+    if (hasDuplicateConsecutive) {
+      warnings.push('Pattern contains duplicate consecutive commands');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors: errors,
+      warnings: warnings,
+      reason: errors.length > 0 ? errors.join('; ') : null
+    };
+  }
+
+  /**
+   * Check if a pattern is a duplicate of existing patterns
+   * @param {Object} pattern - Pattern to check
+   * @param {Object[]} existingPatterns - Existing patterns to compare against
+   * @returns {Object} Duplicate check result
+   */
+  isDuplicate(pattern, existingPatterns) {
+    if (!existingPatterns || existingPatterns.length === 0) {
+      return { isDuplicate: false };
+    }
+
+    for (const existing of existingPatterns) {
+      // Exact match check first
+      if (this._isExactMatch(pattern.sequence, existing.sequence)) {
+        return {
+          isDuplicate: true,
+          duplicateOf: existing.id,
+          similarity: 1.0,
+          exact: true
+        };
+      }
+
+      // Then similarity check
+      const similarity = this._calculateSimilarity(pattern.sequence, existing.sequence);
+
+      if (similarity >= this.rules.similarityThreshold) {
+        return {
+          isDuplicate: true,
+          duplicateOf: existing.id,
+          similarity: similarity
+        };
+      }
+    }
+
+    return { isDuplicate: false };
+  }
+
+  /**
+   * Check if pattern meets minimum threshold for promotion
+   * @param {Object} pattern - Pattern to check
+   * @returns {Object} Threshold check result
+   */
+  meetsMinimumThreshold(pattern) {
+    const meetsOccurrences = pattern.occurrences >= this.rules.minOccurrences;
+    const meetsSuccessRate = pattern.successRate >= this.rules.minSuccessRate;
+
+    return {
+      meetsThreshold: meetsOccurrences && meetsSuccessRate,
+      meetsOccurrences: meetsOccurrences,
+      meetsSuccessRate: meetsSuccessRate,
+      currentOccurrences: pattern.occurrences,
+      requiredOccurrences: this.rules.minOccurrences,
+      currentSuccessRate: pattern.successRate,
+      requiredSuccessRate: this.rules.minSuccessRate
+    };
+  }
+
+  /**
+   * Get current validation rules
+   * @returns {Object} Current validation rules
+   */
+  getValidationRules() {
+    return { ...this.rules };
+  }
+
+  /**
+   * Update validation rules
+   * @param {Object} newRules - New rules to merge
+   */
+  updateRules(newRules) {
+    this.rules = { ...this.rules, ...newRules };
+  }
+
+  /**
+   * Check if a command is known in the AIOS task registry
+   * @param {string} command - Command to check
+   * @returns {boolean} True if command is known
+   * @private
+   */
+  _isKnownCommand(command) {
+    const normalized = command.toLowerCase().replace(/^\*/, '').trim();
+
+    // Direct match
+    if (KNOWN_COMMANDS.has(normalized)) {
+      return true;
+    }
+
+    // Prefix match (e.g., "develop-yolo" starts with known "develop")
+    for (const known of KNOWN_COMMANDS) {
+      if (normalized.startsWith(known) || known.startsWith(normalized)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Calculate similarity between two sequences using Jaccard similarity
+   * @param {string[]} seq1 - First sequence
+   * @param {string[]} seq2 - Second sequence
+   * @returns {number} Similarity score (0-1)
+   * @private
+   */
+  _calculateSimilarity(seq1, seq2) {
+    if (!seq1 || !seq2 || seq1.length === 0 || seq2.length === 0) {
+      return 0;
+    }
+
+    const set1 = new Set(seq1);
+    const set2 = new Set(seq2);
+
+    // Jaccard similarity
+    const intersection = new Set([...set1].filter(x => set2.has(x)));
+    const union = new Set([...set1, ...set2]);
+
+    const jaccardSimilarity = intersection.size / union.size;
+
+    // Order similarity (for sequence patterns, order matters)
+    let orderScore = 0;
+    const minLen = Math.min(seq1.length, seq2.length);
+    for (let i = 0; i < minLen; i++) {
+      if (seq1[i] === seq2[i]) {
+        orderScore++;
+      }
+    }
+    const orderSimilarity = orderScore / Math.max(seq1.length, seq2.length);
+
+    // Combined score (weighted average)
+    return (jaccardSimilarity * 0.4) + (orderSimilarity * 0.6);
+  }
+
+  /**
+   * Check if two sequences are exactly the same
+   * @param {string[]} seq1 - First sequence
+   * @param {string[]} seq2 - Second sequence
+   * @returns {boolean} True if exact match
+   * @private
+   */
+  _isExactMatch(seq1, seq2) {
+    if (seq1.length !== seq2.length) {
+      return false;
+    }
+    return seq1.every((cmd, i) => cmd === seq2[i]);
+  }
+}
+
+/**
+ * Create a new PatternValidator instance
+ * @param {Object} options - Configuration options
+ * @returns {PatternValidator} New instance
+ */
+function createPatternValidator(options = {}) {
+  return new PatternValidator(options);
+}
+
+module.exports = {
+  PatternValidator,
+  createPatternValidator,
+  DEFAULT_VALIDATION_RULES,
+  KNOWN_COMMANDS
+};

package/.aios-core/workflow-intelligence/registry/workflow-registry.js

@@ -0,0 +1,358 @@
+/**
+ * @module WorkflowRegistry
+ * @description Registry for loading and managing workflow patterns
+ * @story WIS-2 - Workflow Registry Enhancement
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * Default cache TTL in milliseconds (5 minutes)
+ * @type {number}
+ */
+const DEFAULT_CACHE_TTL = 5 * 60 * 1000;
+
+/**
+ * Default path to workflow patterns file
+ * @type {string}
+ */
+const DEFAULT_PATTERNS_PATH = path.join(
+  __dirname,
+  '../../data/workflow-patterns.yaml'
+);
+
+/**
+ * WorkflowRegistry class for managing workflow patterns
+ */
+class WorkflowRegistry {
+  /**
+   * Create a WorkflowRegistry instance
+   * @param {Object} options - Configuration options
+   * @param {string} options.patternsPath - Path to workflow-patterns.yaml
+   * @param {number} options.cacheTTL - Cache time-to-live in milliseconds
+   */
+  constructor(options = {}) {
+    this.patternsPath = options.patternsPath || DEFAULT_PATTERNS_PATH;
+    this.cacheTTL = options.cacheTTL || DEFAULT_CACHE_TTL;
+    this.cache = null;
+    this.cacheTimestamp = null;
+  }
+
+  /**
+   * Load workflows from YAML file with caching
+   * @returns {Object} Loaded workflow patterns
+   * @throws {Error} If file cannot be read or parsed
+   */
+  loadWorkflows() {
+    // Check if cache is valid
+    if (this.isCacheValid()) {
+      return this.cache;
+    }
+
+    try {
+      const content = fs.readFileSync(this.patternsPath, 'utf8');
+      const parsed = yaml.load(content);
+
+      if (!parsed || !parsed.workflows) {
+        throw new Error('Invalid workflow patterns file: missing workflows key');
+      }
+
+      this.cache = parsed.workflows;
+      this.cacheTimestamp = Date.now();
+
+      return this.cache;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`Workflow patterns file not found: ${this.patternsPath}`);
+      }
+      throw new Error(`Failed to load workflow patterns: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if cache is still valid
+   * @returns {boolean} True if cache is valid
+   */
+  isCacheValid() {
+    if (!this.cache || !this.cacheTimestamp) {
+      return false;
+    }
+    return (Date.now() - this.cacheTimestamp) < this.cacheTTL;
+  }
+
+  /**
+   * Invalidate the cache
+   */
+  invalidateCache() {
+    this.cache = null;
+    this.cacheTimestamp = null;
+  }
+
+  /**
+   * Get all workflow names
+   * @returns {string[]} Array of workflow names
+   */
+  getWorkflowNames() {
+    const workflows = this.loadWorkflows();
+    return Object.keys(workflows);
+  }
+
+  /**
+   * Get a specific workflow by name
+   * @param {string} name - Workflow name
+   * @returns {Object|null} Workflow object or null if not found
+   */
+  getWorkflow(name) {
+    const workflows = this.loadWorkflows();
+    return workflows[name] || null;
+  }
+
+  /**
+   * Match command history to find the best matching workflow
+   * @param {string[]} commands - Recent command history
+   * @returns {Object|null} Best matching workflow with score, or null
+   */
+  matchWorkflow(commands) {
+    if (!commands || commands.length === 0) {
+      return null;
+    }
+
+    const workflows = this.loadWorkflows();
+    const normalizedCommands = commands.map(cmd => this.normalizeCommand(cmd));
+
+    let bestMatch = null;
+    let bestScore = 0;
+
+    for (const [name, workflow] of Object.entries(workflows)) {
+      const score = this.calculateWorkflowMatch(workflow, normalizedCommands);
+
+      if (score > bestScore && score >= (workflow.trigger_threshold ?? 2)) {
+        bestScore = score;
+        bestMatch = {
+          name,
+          workflow,
+          score,
+          matchedCommands: this.getMatchedCommands(workflow, normalizedCommands)
+        };
+      }
+    }
+
+    return bestMatch;
+  }
+
+  /**
+   * Calculate match score between workflow and command history
+   * @param {Object} workflow - Workflow definition
+   * @param {string[]} commands - Normalized command history
+   * @returns {number} Match score
+   */
+  calculateWorkflowMatch(workflow, commands) {
+    if (!workflow.key_commands) {
+      return 0;
+    }
+
+    const keyCommands = workflow.key_commands.map(cmd => this.normalizeCommand(cmd));
+    let matches = 0;
+
+    for (const cmd of commands) {
+      for (const keyCmd of keyCommands) {
+        if (cmd.includes(keyCmd) || keyCmd.includes(cmd)) {
+          matches++;
+          break;
+        }
+      }
+    }
+
+    return matches;
+  }
+
+  /**
+   * Get commands that matched from history
+   * @param {Object} workflow - Workflow definition
+   * @param {string[]} commands - Normalized command history
+   * @returns {string[]} Matched commands
+   */
+  getMatchedCommands(workflow, commands) {
+    if (!workflow.key_commands) {
+      return [];
+    }
+
+    const keyCommands = workflow.key_commands.map(cmd => this.normalizeCommand(cmd));
+    const matched = [];
+
+    for (const cmd of commands) {
+      for (const keyCmd of keyCommands) {
+        if (cmd.includes(keyCmd) || keyCmd.includes(cmd)) {
+          matched.push(cmd);
+          break;
+        }
+      }
+    }
+
+    return matched;
+  }
+
+  /**
+   * Get transitions for a workflow state
+   * @param {string} workflowName - Name of the workflow
+   * @param {string} state - Current state in the workflow
+   * @returns {Object|null} Transition object or null if not found
+   */
+  getTransitions(workflowName, state) {
+    const workflow = this.getWorkflow(workflowName);
+
+    if (!workflow || !workflow.transitions) {
+      return null;
+    }
+
+    return workflow.transitions[state] || null;
+  }
+
+  /**
+   * Get all available transitions for a workflow
+   * @param {string} workflowName - Name of the workflow
+   * @returns {Object} All transitions for the workflow
+   */
+  getAllTransitions(workflowName) {
+    const workflow = this.getWorkflow(workflowName);
+
+    if (!workflow || !workflow.transitions) {
+      return {};
+    }
+
+    return workflow.transitions;
+  }
+
+  /**
+   * Get next steps for a workflow state
+   * @param {string} workflowName - Name of the workflow
+   * @param {string} state - Current state
+   * @returns {Object[]} Array of next step suggestions
+   */
+  getNextSteps(workflowName, state) {
+    const transition = this.getTransitions(workflowName, state);
+
+    if (!transition || !transition.next_steps) {
+      return [];
+    }
+
+    return transition.next_steps.sort((a, b) => (a.priority || 99) - (b.priority || 99));
+  }
+
+  /**
+   * Find current state based on last command
+   * @param {string} workflowName - Name of the workflow
+   * @param {string} lastCommand - Last executed command
+   * @returns {string|null} Current state or null if not found
+   */
+  findCurrentState(workflowName, lastCommand) {
+    const workflow = this.getWorkflow(workflowName);
+
+    if (!workflow || !workflow.transitions) {
+      return null;
+    }
+
+    const normalizedCmd = this.normalizeCommand(lastCommand);
+
+    for (const [state, transition] of Object.entries(workflow.transitions)) {
+      if (transition.trigger) {
+        const normalizedTrigger = this.normalizeCommand(transition.trigger);
+        if (normalizedCmd.includes(normalizedTrigger) ||
+            normalizedTrigger.includes(normalizedCmd)) {
+          return state;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get workflows by agent
+   * @param {string} agentId - Agent identifier
+   * @returns {Object[]} Workflows involving this agent
+   */
+  getWorkflowsByAgent(agentId) {
+    const workflows = this.loadWorkflows();
+    const normalizedAgent = agentId.replace('@', '').toLowerCase();
+    const results = [];
+
+    for (const [name, workflow] of Object.entries(workflows)) {
+      if (workflow.agent_sequence) {
+        const hasAgent = workflow.agent_sequence.some(
+          agent => agent.toLowerCase() === normalizedAgent
+        );
+        if (hasAgent) {
+          results.push({ name, workflow });
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Normalize a command string for matching
+   * @param {string} command - Command to normalize
+   * @returns {string} Normalized command
+   */
+  normalizeCommand(command) {
+    if (!command) return '';
+
+    return command
+      .toLowerCase()
+      .replace(/\s+completed\s*$/i, '')
+      .replace(/\s+successfully\s*$/i, '')
+      .replace(/^\*/, '')
+      .replace(/['"]/g, '')
+      .trim();
+  }
+
+  /**
+   * Get registry statistics
+   * @returns {Object} Statistics about the registry
+   */
+  getStats() {
+    const workflows = this.loadWorkflows();
+    const workflowNames = Object.keys(workflows);
+
+    let totalTransitions = 0;
+    let workflowsWithTransitions = 0;
+
+    for (const workflow of Object.values(workflows)) {
+      if (workflow.transitions) {
+        workflowsWithTransitions++;
+        totalTransitions += Object.keys(workflow.transitions).length;
+      }
+    }
+
+    return {
+      totalWorkflows: workflowNames.length,
+      workflowsWithTransitions,
+      totalTransitions,
+      cacheValid: this.isCacheValid(),
+      cacheAge: this.cacheTimestamp ? Date.now() - this.cacheTimestamp : null
+    };
+  }
+}
+
+/**
+ * Create a new WorkflowRegistry instance
+ * @param {Object} options - Configuration options
+ * @returns {WorkflowRegistry} New registry instance
+ */
+function createWorkflowRegistry(options = {}) {
+  return new WorkflowRegistry(options);
+}
+
+module.exports = {
+  WorkflowRegistry,
+  createWorkflowRegistry,
+  DEFAULT_CACHE_TTL,
+  DEFAULT_PATTERNS_PATH
+};