aios-core 1.0.0

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

@@ -0,0 +1,302 @@
+/**
+ * @fileoverview Unit tests for WorkflowRegistry
+ * @story WIS-2 - Workflow Registry Enhancement
+ */
+
+'use strict';
+
+const path = require('path');
+const {
+  WorkflowRegistry,
+  createWorkflowRegistry,
+  DEFAULT_CACHE_TTL
+} = require('../registry/workflow-registry');
+
+describe('WorkflowRegistry', () => {
+  let registry;
+
+  beforeEach(() => {
+    registry = createWorkflowRegistry();
+  });
+
+  afterEach(() => {
+    registry.invalidateCache();
+  });
+
+  describe('constructor', () => {
+    it('should create registry with default options', () => {
+      expect(registry.cacheTTL).toBe(DEFAULT_CACHE_TTL);
+      expect(registry.cache).toBeNull();
+    });
+
+    it('should accept custom cache TTL', () => {
+      const customRegistry = createWorkflowRegistry({ cacheTTL: 1000 });
+      expect(customRegistry.cacheTTL).toBe(1000);
+    });
+
+    it('should accept custom patterns path', () => {
+      const customPath = '/custom/path.yaml';
+      const customRegistry = createWorkflowRegistry({ patternsPath: customPath });
+      expect(customRegistry.patternsPath).toBe(customPath);
+    });
+  });
+
+  describe('loadWorkflows()', () => {
+    it('should load workflow patterns from file', () => {
+      const workflows = registry.loadWorkflows();
+      expect(workflows).toBeDefined();
+      expect(typeof workflows).toBe('object');
+    });
+
+    it('should return 10 workflows', () => {
+      const workflows = registry.loadWorkflows();
+      const names = Object.keys(workflows);
+      expect(names.length).toBe(10);
+    });
+
+    it('should include story_development workflow', () => {
+      const workflows = registry.loadWorkflows();
+      expect(workflows.story_development).toBeDefined();
+    });
+
+    it('should include epic_creation workflow', () => {
+      const workflows = registry.loadWorkflows();
+      expect(workflows.epic_creation).toBeDefined();
+    });
+
+    it('should cache loaded workflows', () => {
+      const workflows1 = registry.loadWorkflows();
+      const workflows2 = registry.loadWorkflows();
+      expect(workflows1).toBe(workflows2);
+    });
+
+    it('should throw error for invalid file path', () => {
+      const badRegistry = createWorkflowRegistry({
+        patternsPath: '/nonexistent/path.yaml'
+      });
+      expect(() => badRegistry.loadWorkflows()).toThrow('Workflow patterns file not found');
+    });
+  });
+
+  describe('isCacheValid()', () => {
+    it('should return false when cache is null', () => {
+      expect(registry.isCacheValid()).toBe(false);
+    });
+
+    it('should return true after loading workflows', () => {
+      registry.loadWorkflows();
+      expect(registry.isCacheValid()).toBe(true);
+    });
+
+    it('should return false after invalidation', () => {
+      registry.loadWorkflows();
+      registry.invalidateCache();
+      expect(registry.isCacheValid()).toBe(false);
+    });
+  });
+
+  describe('getWorkflowNames()', () => {
+    it('should return array of workflow names', () => {
+      const names = registry.getWorkflowNames();
+      expect(Array.isArray(names)).toBe(true);
+      expect(names.length).toBe(10);
+    });
+
+    it('should include expected workflows', () => {
+      const names = registry.getWorkflowNames();
+      expect(names).toContain('story_development');
+      expect(names).toContain('epic_creation');
+      expect(names).toContain('backlog_management');
+      expect(names).toContain('architecture_review');
+      expect(names).toContain('git_workflow');
+      expect(names).toContain('database_workflow');
+      expect(names).toContain('code_quality_workflow');
+      expect(names).toContain('documentation_workflow');
+      expect(names).toContain('ux_workflow');
+      expect(names).toContain('research_workflow');
+    });
+  });
+
+  describe('getWorkflow()', () => {
+    it('should return workflow by name', () => {
+      const workflow = registry.getWorkflow('epic_creation');
+      expect(workflow).toBeDefined();
+      expect(workflow.description).toBeDefined();
+    });
+
+    it('should return null for unknown workflow', () => {
+      const workflow = registry.getWorkflow('nonexistent');
+      expect(workflow).toBeNull();
+    });
+
+    it('should include transitions in workflow', () => {
+      const workflow = registry.getWorkflow('epic_creation');
+      expect(workflow.transitions).toBeDefined();
+      expect(typeof workflow.transitions).toBe('object');
+    });
+  });
+
+  describe('matchWorkflow()', () => {
+    it('should match workflow from command history', () => {
+      const commands = ['create-epic', 'create-story'];
+      const match = registry.matchWorkflow(commands);
+
+      expect(match).not.toBeNull();
+      expect(match.name).toBe('epic_creation');
+    });
+
+    it('should return best matching workflow', () => {
+      const commands = ['validate-story-draft', 'develop', 'review-qa'];
+      const match = registry.matchWorkflow(commands);
+
+      expect(match).not.toBeNull();
+      expect(match.name).toBe('story_development');
+    });
+
+    it('should return null for empty commands', () => {
+      const match = registry.matchWorkflow([]);
+      expect(match).toBeNull();
+    });
+
+    it('should return null for unmatched commands', () => {
+      const match = registry.matchWorkflow(['random-cmd', 'another-random']);
+      expect(match).toBeNull();
+    });
+
+    it('should include score in match result', () => {
+      const match = registry.matchWorkflow(['create-epic', 'create-story']);
+      expect(match.score).toBeGreaterThanOrEqual(2);
+    });
+
+    it('should include matched commands', () => {
+      const match = registry.matchWorkflow(['create-epic', 'create-story']);
+      expect(match.matchedCommands).toBeDefined();
+      expect(Array.isArray(match.matchedCommands)).toBe(true);
+    });
+  });
+
+  describe('getTransitions()', () => {
+    it('should return transitions for valid state', () => {
+      const transition = registry.getTransitions('epic_creation', 'epic_drafted');
+
+      expect(transition).not.toBeNull();
+      expect(transition.trigger).toBeDefined();
+      expect(transition.confidence).toBeDefined();
+      expect(transition.next_steps).toBeDefined();
+    });
+
+    it('should return null for unknown state', () => {
+      const transition = registry.getTransitions('epic_creation', 'unknown_state');
+      expect(transition).toBeNull();
+    });
+
+    it('should return null for unknown workflow', () => {
+      const transition = registry.getTransitions('unknown_workflow', 'any_state');
+      expect(transition).toBeNull();
+    });
+
+    it('should return empty array for workflow without transitions', () => {
+      const result = registry.getAllTransitions('nonexistent');
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('getNextSteps()', () => {
+    it('should return sorted next steps', () => {
+      const steps = registry.getNextSteps('epic_creation', 'epic_drafted');
+
+      expect(Array.isArray(steps)).toBe(true);
+      expect(steps.length).toBeGreaterThan(0);
+      expect(steps[0].priority).toBeLessThanOrEqual(steps[1]?.priority || 99);
+    });
+
+    it('should include command and description', () => {
+      const steps = registry.getNextSteps('epic_creation', 'epic_drafted');
+
+      expect(steps[0].command).toBeDefined();
+      expect(steps[0].description).toBeDefined();
+    });
+
+    it('should return empty array for unknown state', () => {
+      const steps = registry.getNextSteps('epic_creation', 'unknown_state');
+      expect(steps).toEqual([]);
+    });
+  });
+
+  describe('findCurrentState()', () => {
+    it('should find state from command', () => {
+      const state = registry.findCurrentState('epic_creation', 'create-epic completed');
+      expect(state).toBe('epic_drafted');
+    });
+
+    it('should find state without "completed" suffix', () => {
+      const state = registry.findCurrentState('epic_creation', 'create-epic');
+      expect(state).toBe('epic_drafted');
+    });
+
+    it('should return null for unknown command', () => {
+      const state = registry.findCurrentState('epic_creation', 'random-command');
+      expect(state).toBeNull();
+    });
+
+    it('should return null for unknown workflow', () => {
+      const state = registry.findCurrentState('unknown', 'create-epic');
+      expect(state).toBeNull();
+    });
+  });
+
+  describe('getWorkflowsByAgent()', () => {
+    it('should return workflows for agent', () => {
+      const workflows = registry.getWorkflowsByAgent('@po');
+
+      expect(Array.isArray(workflows)).toBe(true);
+      expect(workflows.length).toBeGreaterThan(0);
+    });
+
+    it('should handle agent without @ prefix', () => {
+      const workflows = registry.getWorkflowsByAgent('po');
+      expect(workflows.length).toBeGreaterThan(0);
+    });
+
+    it('should return empty array for unknown agent', () => {
+      const workflows = registry.getWorkflowsByAgent('@unknown');
+      expect(workflows).toEqual([]);
+    });
+  });
+
+  describe('getStats()', () => {
+    it('should return registry statistics', () => {
+      const stats = registry.getStats();
+
+      expect(stats.totalWorkflows).toBe(10);
+      expect(stats.workflowsWithTransitions).toBe(10);
+      expect(stats.totalTransitions).toBeGreaterThan(0);
+    });
+
+    it('should report cache status', () => {
+      registry.loadWorkflows();
+      const stats = registry.getStats();
+
+      expect(stats.cacheValid).toBe(true);
+      expect(stats.cacheAge).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('normalizeCommand()', () => {
+    it('should normalize command strings', () => {
+      expect(registry.normalizeCommand('CREATE-EPIC')).toBe('create-epic');
+      expect(registry.normalizeCommand('*create-epic')).toBe('create-epic');
+      expect(registry.normalizeCommand('create-epic completed')).toBe('create-epic');
+    });
+
+    it('should handle null input', () => {
+      expect(registry.normalizeCommand(null)).toBe('');
+    });
+  });
+
+  describe('DEFAULT_CACHE_TTL', () => {
+    it('should be 5 minutes', () => {
+      expect(DEFAULT_CACHE_TTL).toBe(5 * 60 * 1000);
+    });
+  });
+});

package/.aios-core/workflow-intelligence/engine/confidence-scorer.js

@@ -0,0 +1,305 @@
+/**
+ * @module ConfidenceScorer
+ * @description Confidence scoring algorithm for workflow suggestions
+ * @story WIS-2 - Workflow Registry Enhancement
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/**
+ * Scoring weights for confidence calculation
+ * @type {Object}
+ */
+const SCORING_WEIGHTS = {
+  COMMAND_MATCH: 0.40,
+  AGENT_MATCH: 0.25,
+  HISTORY_DEPTH: 0.20,
+  PROJECT_STATE: 0.15
+};
+
+/**
+ * ConfidenceScorer class for calculating workflow suggestion confidence
+ */
+class ConfidenceScorer {
+  /**
+   * Create a ConfidenceScorer instance
+   * @param {Object} options - Configuration options
+   * @param {Object} options.weights - Custom scoring weights
+   */
+  constructor(options = {}) {
+    this.weights = { ...SCORING_WEIGHTS, ...options.weights };
+    this.validateWeights();
+  }
+
+  /**
+   * Validate that weights sum to 1.0
+   * @throws {Error} If weights don't sum to 1.0
+   */
+  validateWeights() {
+    const sum = Object.values(this.weights).reduce((a, b) => a + b, 0);
+    if (Math.abs(sum - 1.0) > 0.001) {
+      throw new Error(`Scoring weights must sum to 1.0, got ${sum}`);
+    }
+  }
+
+  /**
+   * Calculate confidence score for a suggestion given context
+   * @param {Object} suggestion - The workflow suggestion
+   * @param {string} suggestion.trigger - Command or condition that triggers transition
+   * @param {string[]} suggestion.agentSequence - Expected agent sequence
+   * @param {string[]} suggestion.keyCommands - Key commands for this workflow
+   * @param {Object} context - Current session context
+   * @param {string} context.lastCommand - Last executed command
+   * @param {string[]} context.lastCommands - Recent command history
+   * @param {string} context.agentId - Current active agent
+   * @param {Object} context.projectState - Current project state
+   * @returns {number} Normalized score between 0.0 and 1.0
+   */
+  score(suggestion, context) {
+    if (!suggestion || !context) {
+      return 0;
+    }
+
+    const commandMatch = this.matchCommand(suggestion.trigger, context.lastCommand);
+    const agentMatch = this.matchAgent(suggestion.agentSequence, context.agentId);
+    const historyDepth = this.matchHistory(suggestion.keyCommands, context.lastCommands);
+    const projectState = this.matchProjectState(suggestion, context.projectState);
+
+    const rawScore = (
+      commandMatch * this.weights.COMMAND_MATCH +
+      agentMatch * this.weights.AGENT_MATCH +
+      historyDepth * this.weights.HISTORY_DEPTH +
+      projectState * this.weights.PROJECT_STATE
+    );
+
+    return this.normalize(rawScore);
+  }
+
+  /**
+   * Match command trigger against last executed command
+   * @param {string} trigger - Expected trigger command
+   * @param {string} lastCommand - Last executed command
+   * @returns {number} Match score 0.0-1.0
+   */
+  matchCommand(trigger, lastCommand) {
+    if (!trigger || !lastCommand) {
+      return 0;
+    }
+
+    const normalizedTrigger = this.normalizeCommand(trigger);
+    const normalizedLast = this.normalizeCommand(lastCommand);
+
+    // Exact match
+    if (normalizedTrigger === normalizedLast) {
+      return 1.0;
+    }
+
+    // Trigger contains the command
+    if (normalizedTrigger.includes(normalizedLast)) {
+      return 0.9;
+    }
+
+    // Command contains trigger keyword
+    if (normalizedLast.includes(normalizedTrigger.split(' ')[0])) {
+      return 0.7;
+    }
+
+    // Partial word match
+    const triggerWords = normalizedTrigger.split(/[\s-_]+/);
+    const lastWords = normalizedLast.split(/[\s-_]+/);
+    const commonWords = triggerWords.filter(w => lastWords.includes(w));
+
+    if (commonWords.length > 0) {
+      return 0.5 * (commonWords.length / Math.max(triggerWords.length, 1));
+    }
+
+    return 0;
+  }
+
+  /**
+   * Match agent sequence against current agent
+   * @param {string[]} agentSequence - Expected agent sequence
+   * @param {string} currentAgent - Current active agent
+   * @returns {number} Match score 0.0-1.0
+   */
+  matchAgent(agentSequence, currentAgent) {
+    if (!agentSequence || !currentAgent) {
+      return 0;
+    }
+
+    const normalizedAgent = currentAgent.replace('@', '').toLowerCase();
+
+    // Check if current agent is in the sequence
+    const agentIndex = agentSequence.findIndex(
+      agent => agent.toLowerCase() === normalizedAgent
+    );
+
+    if (agentIndex === -1) {
+      return 0;
+    }
+
+    // Higher score for agents later in sequence (workflow is progressing)
+    const progressScore = (agentIndex + 1) / agentSequence.length;
+
+    // Bonus for being the expected next agent
+    if (agentIndex === 0) {
+      return 0.6 + (progressScore * 0.4);
+    }
+
+    return progressScore;
+  }
+
+  /**
+   * Match command history against key workflow commands
+   * @param {string[]} keyCommands - Key commands for the workflow
+   * @param {string[]} lastCommands - Recent command history
+   * @returns {number} Match score 0.0-1.0
+   */
+  matchHistory(keyCommands, lastCommands) {
+    if (!keyCommands || !lastCommands || keyCommands.length === 0) {
+      return 0;
+    }
+
+    const normalizedKeys = keyCommands.map(cmd => this.normalizeCommand(cmd));
+    const normalizedHistory = lastCommands.map(cmd => this.normalizeCommand(cmd));
+
+    let matchCount = 0;
+    let recentBonus = 0;
+
+    for (let i = 0; i < normalizedHistory.length; i++) {
+      const historyCmd = normalizedHistory[i];
+
+      for (const keyCmd of normalizedKeys) {
+        if (historyCmd.includes(keyCmd) || keyCmd.includes(historyCmd)) {
+          matchCount++;
+
+          // Recent commands get higher weight (decay factor)
+          const recency = 1 - (i / normalizedHistory.length);
+          recentBonus += recency * 0.1;
+          break;
+        }
+      }
+    }
+
+    const baseScore = Math.min(matchCount / keyCommands.length, 1.0);
+    return Math.min(baseScore + recentBonus, 1.0);
+  }
+
+  /**
+   * Match suggestion against project state
+   * @param {Object} suggestion - The workflow suggestion
+   * @param {Object} projectState - Current project state
+   * @returns {number} Match score 0.0-1.0
+   */
+  matchProjectState(suggestion, projectState) {
+    if (!suggestion || !projectState) {
+      return 0.5; // Neutral score when state unknown
+    }
+
+    let score = 0.5;
+    const factors = [];
+
+    // Check if story is in progress
+    if (projectState.activeStory) {
+      factors.push(0.2);
+    }
+
+    // Check if uncommitted changes exist
+    if (projectState.hasUncommittedChanges) {
+      // Git-related suggestions get higher score
+      if (suggestion.trigger?.includes('git') ||
+          suggestion.trigger?.includes('commit') ||
+          suggestion.trigger?.includes('push')) {
+        factors.push(0.3);
+      }
+    }
+
+    // Check if tests are failing
+    if (projectState.failingTests) {
+      // QA-related suggestions get higher score
+      if (suggestion.trigger?.includes('test') ||
+          suggestion.trigger?.includes('qa') ||
+          suggestion.trigger?.includes('fix')) {
+        factors.push(0.3);
+      }
+    }
+
+    // Check current workflow phase
+    if (projectState.workflowPhase && suggestion.phase) {
+      if (projectState.workflowPhase === suggestion.phase) {
+        factors.push(0.2);
+      }
+    }
+
+    return Math.min(score + factors.reduce((a, b) => a + b, 0), 1.0);
+  }
+
+  /**
+   * Normalize a command string for comparison
+   * @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();
+  }
+
+  /**
+   * Normalize score to 0.0-1.0 range
+   * @param {number} score - Raw score
+   * @returns {number} Normalized score
+   */
+  normalize(score) {
+    return Math.max(0, Math.min(1, score));
+  }
+
+  /**
+   * Calculate scores for multiple suggestions and rank them
+   * @param {Object[]} suggestions - Array of suggestions
+   * @param {Object} context - Current session context
+   * @returns {Object[]} Sorted suggestions with scores
+   */
+  rankSuggestions(suggestions, context) {
+    if (!suggestions || suggestions.length === 0) {
+      return [];
+    }
+
+    return suggestions
+      .map(suggestion => ({
+        ...suggestion,
+        score: this.score(suggestion, context)
+      }))
+      .sort((a, b) => b.score - a.score);
+  }
+
+  /**
+   * Get scoring weights
+   * @returns {Object} Current scoring weights
+   */
+  getWeights() {
+    return { ...this.weights };
+  }
+}
+
+/**
+ * Create a new ConfidenceScorer instance
+ * @param {Object} options - Configuration options
+ * @returns {ConfidenceScorer} New scorer instance
+ */
+function createConfidenceScorer(options = {}) {
+  return new ConfidenceScorer(options);
+}
+
+module.exports = {
+  ConfidenceScorer,
+  createConfidenceScorer,
+  SCORING_WEIGHTS
+};