aios-core 1.0.0

package/.aios-core/utils/aios-validator.js

@@ -0,0 +1,25 @@
+/**
+ * AIOS Validator - Re-export from canonical location
+ *
+ * @deprecated Use require('../infrastructure/scripts/aios-validator') directly
+ * @module utils/aios-validator
+ *
+ * This file re-exports from the canonical location in infrastructure/scripts/
+ * for backward compatibility with CI workflows.
+ *
+ * Migration note:
+ * - Canonical location: .aios-core/infrastructure/scripts/aios-validator.js
+ * - This file exists for backward compatibility with existing CI workflows
+ * - New code should import from infrastructure/scripts/aios-validator directly
+ */
+
+'use strict';
+
+// Re-export from canonical location
+module.exports = require('../infrastructure/scripts/aios-validator');
+
+// CLI Interface - delegate to canonical location
+if (require.main === module) {
+  // Pass through to the original script
+  require('../infrastructure/scripts/aios-validator');
+}

package/.aios-core/workflow-intelligence/__tests__/confidence-scorer.test.js

@@ -0,0 +1,334 @@
+/**
+ * @fileoverview Unit tests for ConfidenceScorer
+ * @story WIS-2 - Workflow Registry Enhancement
+ */
+
+'use strict';
+
+const {
+  ConfidenceScorer,
+  createConfidenceScorer,
+  SCORING_WEIGHTS
+} = require('../engine/confidence-scorer');
+
+describe('ConfidenceScorer', () => {
+  let scorer;
+
+  beforeEach(() => {
+    scorer = createConfidenceScorer();
+  });
+
+  describe('constructor', () => {
+    it('should create scorer with default weights', () => {
+      const weights = scorer.getWeights();
+      expect(weights.COMMAND_MATCH).toBe(0.40);
+      expect(weights.AGENT_MATCH).toBe(0.25);
+      expect(weights.HISTORY_DEPTH).toBe(0.20);
+      expect(weights.PROJECT_STATE).toBe(0.15);
+    });
+
+    it('should accept custom weights', () => {
+      const customScorer = createConfidenceScorer({
+        weights: {
+          COMMAND_MATCH: 0.50,
+          AGENT_MATCH: 0.20,
+          HISTORY_DEPTH: 0.15,
+          PROJECT_STATE: 0.15
+        }
+      });
+      const weights = customScorer.getWeights();
+      expect(weights.COMMAND_MATCH).toBe(0.50);
+    });
+
+    it('should throw error if weights do not sum to 1.0', () => {
+      expect(() => {
+        createConfidenceScorer({
+          weights: {
+            COMMAND_MATCH: 0.50,
+            AGENT_MATCH: 0.50,
+            HISTORY_DEPTH: 0.20,
+            PROJECT_STATE: 0.15
+          }
+        });
+      }).toThrow('Scoring weights must sum to 1.0');
+    });
+  });
+
+  describe('score()', () => {
+    it('should return 0 for null suggestion', () => {
+      const result = scorer.score(null, { lastCommand: 'test' });
+      expect(result).toBe(0);
+    });
+
+    it('should return 0 for null context', () => {
+      const result = scorer.score({ trigger: 'test' }, null);
+      expect(result).toBe(0);
+    });
+
+    it('should return high score for exact command match', () => {
+      const suggestion = {
+        trigger: 'create-epic',
+        agentSequence: ['po', 'sm'],
+        keyCommands: ['create-epic', 'create-story']
+      };
+      const context = {
+        lastCommand: 'create-epic',
+        lastCommands: ['create-epic'],
+        agentId: '@po',
+        projectState: {}
+      };
+
+      const result = scorer.score(suggestion, context);
+      // Score is composed of: command(40%) + agent(25%) + history(20%) + state(15%)
+      expect(result).toBeGreaterThanOrEqual(0.70);
+    });
+
+    it('should return medium score for partial command match', () => {
+      const suggestion = {
+        trigger: 'create-epic',
+        agentSequence: ['po', 'sm'],
+        keyCommands: ['create-epic', 'create-story']
+      };
+      const context = {
+        lastCommand: 'create-story',
+        lastCommands: ['create-story'],
+        agentId: '@sm',
+        projectState: {}
+      };
+
+      const result = scorer.score(suggestion, context);
+      expect(result).toBeGreaterThan(0.40);
+      expect(result).toBeLessThan(0.80);
+    });
+
+    it('should return low score for no command match', () => {
+      const suggestion = {
+        trigger: 'create-epic',
+        agentSequence: ['po', 'sm'],
+        keyCommands: ['create-epic', 'create-story']
+      };
+      const context = {
+        lastCommand: 'push',
+        lastCommands: ['push'],
+        agentId: '@devops',
+        projectState: {}
+      };
+
+      const result = scorer.score(suggestion, context);
+      expect(result).toBeLessThanOrEqual(0.30);
+    });
+
+    it('should return normalized score between 0 and 1', () => {
+      const suggestion = { trigger: 'any', agentSequence: [], keyCommands: [] };
+      const context = { lastCommand: 'any', lastCommands: [], agentId: '' };
+
+      const result = scorer.score(suggestion, context);
+      expect(result).toBeGreaterThanOrEqual(0);
+      expect(result).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('matchCommand()', () => {
+    it('should return 1.0 for exact match', () => {
+      const result = scorer.matchCommand('create-epic', 'create-epic');
+      expect(result).toBe(1.0);
+    });
+
+    it('should return 1.0 when normalized trigger equals command', () => {
+      // "create-epic completed" normalizes to "create-epic"
+      const result = scorer.matchCommand('create-epic completed', 'create-epic');
+      expect(result).toBe(1.0);
+    });
+
+    it('should return partial score for keyword match', () => {
+      const result = scorer.matchCommand('create-epic', 'create-story');
+      // Both share "create" word, so partial match
+      expect(result).toBeGreaterThan(0);
+      expect(result).toBeLessThan(1);
+    });
+
+    it('should return 0 for no match', () => {
+      const result = scorer.matchCommand('create-epic', 'push');
+      expect(result).toBe(0);
+    });
+
+    it('should handle null trigger', () => {
+      const result = scorer.matchCommand(null, 'test');
+      expect(result).toBe(0);
+    });
+
+    it('should handle null command', () => {
+      const result = scorer.matchCommand('test', null);
+      expect(result).toBe(0);
+    });
+  });
+
+  describe('matchAgent()', () => {
+    it('should return high score for first agent in sequence', () => {
+      const result = scorer.matchAgent(['po', 'sm', 'dev'], '@po');
+      expect(result).toBeGreaterThan(0.6);
+    });
+
+    it('should return higher score for later agents', () => {
+      const result1 = scorer.matchAgent(['po', 'sm', 'dev'], '@po');
+      const result2 = scorer.matchAgent(['po', 'sm', 'dev'], '@dev');
+      expect(result2).toBeGreaterThan(result1);
+    });
+
+    it('should return 0 for agent not in sequence', () => {
+      const result = scorer.matchAgent(['po', 'sm'], '@devops');
+      expect(result).toBe(0);
+    });
+
+    it('should handle agent with @ prefix', () => {
+      const result = scorer.matchAgent(['po'], '@po');
+      expect(result).toBeGreaterThan(0);
+    });
+
+    it('should handle null agent sequence', () => {
+      const result = scorer.matchAgent(null, '@po');
+      expect(result).toBe(0);
+    });
+  });
+
+  describe('matchHistory()', () => {
+    it('should return high score when history matches key commands', () => {
+      const keyCommands = ['create-epic', 'create-story'];
+      const history = ['create-epic', 'create-story', 'validate'];
+
+      const result = scorer.matchHistory(keyCommands, history);
+      expect(result).toBeGreaterThan(0.8);
+    });
+
+    it('should give recency bonus for recent commands', () => {
+      const keyCommands = ['create-epic'];
+      const historyRecent = ['create-epic', 'other', 'another'];
+      const historyOld = ['other', 'another', 'create-epic'];
+
+      const resultRecent = scorer.matchHistory(keyCommands, historyRecent);
+      const resultOld = scorer.matchHistory(keyCommands, historyOld);
+
+      // Recent should get higher score due to recency bonus
+      expect(resultRecent).toBeGreaterThanOrEqual(resultOld);
+    });
+
+    it('should return 0 for no matching commands', () => {
+      const keyCommands = ['create-epic'];
+      const history = ['push', 'commit'];
+
+      const result = scorer.matchHistory(keyCommands, history);
+      expect(result).toBe(0);
+    });
+
+    it('should handle empty history', () => {
+      const result = scorer.matchHistory(['test'], []);
+      expect(result).toBe(0);
+    });
+
+    it('should handle empty key commands', () => {
+      const result = scorer.matchHistory([], ['test']);
+      expect(result).toBe(0);
+    });
+  });
+
+  describe('matchProjectState()', () => {
+    it('should return neutral score for empty state', () => {
+      const result = scorer.matchProjectState({}, {});
+      expect(result).toBe(0.5);
+    });
+
+    it('should boost score for git-related suggestions when uncommitted changes', () => {
+      const suggestion = { trigger: 'git commit' };
+      const state = { hasUncommittedChanges: true };
+
+      const result = scorer.matchProjectState(suggestion, state);
+      expect(result).toBeGreaterThan(0.5);
+    });
+
+    it('should boost score for test suggestions when tests failing', () => {
+      const suggestion = { trigger: 'run tests' };
+      const state = { failingTests: true };
+
+      const result = scorer.matchProjectState(suggestion, state);
+      expect(result).toBeGreaterThan(0.5);
+    });
+
+    it('should return 0.5 for null project state', () => {
+      const result = scorer.matchProjectState({}, null);
+      expect(result).toBe(0.5);
+    });
+  });
+
+  describe('normalizeCommand()', () => {
+    it('should convert to lowercase', () => {
+      const result = scorer.normalizeCommand('CREATE-EPIC');
+      expect(result).toBe('create-epic');
+    });
+
+    it('should remove "completed" suffix', () => {
+      const result = scorer.normalizeCommand('create-epic completed');
+      expect(result).toBe('create-epic');
+    });
+
+    it('should remove "successfully" suffix', () => {
+      const result = scorer.normalizeCommand('create-epic successfully');
+      expect(result).toBe('create-epic');
+    });
+
+    it('should remove * prefix', () => {
+      const result = scorer.normalizeCommand('*create-epic');
+      expect(result).toBe('create-epic');
+    });
+
+    it('should handle null', () => {
+      const result = scorer.normalizeCommand(null);
+      expect(result).toBe('');
+    });
+  });
+
+  describe('rankSuggestions()', () => {
+    it('should return empty array for empty suggestions', () => {
+      const result = scorer.rankSuggestions([], {});
+      expect(result).toEqual([]);
+    });
+
+    it('should rank suggestions by score descending', () => {
+      const suggestions = [
+        { trigger: 'push', agentSequence: ['devops'] },
+        { trigger: 'create-epic', agentSequence: ['po'] }
+      ];
+      const context = {
+        lastCommand: 'create-epic',
+        lastCommands: ['create-epic'],
+        agentId: '@po'
+      };
+
+      const result = scorer.rankSuggestions(suggestions, context);
+      expect(result[0].trigger).toBe('create-epic');
+      expect(result[0].score).toBeGreaterThan(result[1].score);
+    });
+
+    it('should add score property to each suggestion', () => {
+      const suggestions = [{ trigger: 'test' }];
+      const context = { lastCommand: 'test' };
+
+      const result = scorer.rankSuggestions(suggestions, context);
+      expect(result[0]).toHaveProperty('score');
+      expect(typeof result[0].score).toBe('number');
+    });
+  });
+
+  describe('SCORING_WEIGHTS constant', () => {
+    it('should have correct default weights', () => {
+      expect(SCORING_WEIGHTS.COMMAND_MATCH).toBe(0.40);
+      expect(SCORING_WEIGHTS.AGENT_MATCH).toBe(0.25);
+      expect(SCORING_WEIGHTS.HISTORY_DEPTH).toBe(0.20);
+      expect(SCORING_WEIGHTS.PROJECT_STATE).toBe(0.15);
+    });
+
+    it('should sum to 1.0', () => {
+      const sum = Object.values(SCORING_WEIGHTS).reduce((a, b) => a + b, 0);
+      expect(sum).toBe(1.0);
+    });
+  });
+});

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

@@ -0,0 +1,337 @@
+/**
+ * @fileoverview Integration tests for Workflow Intelligence System
+ * @story WIS-2 - Workflow Registry Enhancement
+ */
+
+'use strict';
+
+const wis = require('../index');
+
+describe('Workflow Intelligence System Integration', () => {
+  beforeEach(() => {
+    wis.reset();
+  });
+
+  afterEach(() => {
+    wis.invalidateCache();
+  });
+
+  describe('Context → Workflow Match → Scored Suggestions flow', () => {
+    it('should provide scored suggestions for epic creation context', () => {
+      // Need 2 matching commands to meet trigger_threshold
+      const context = {
+        lastCommand: 'create-story',
+        lastCommands: ['create-epic', 'create-story'],
+        agentId: '@po',
+        projectState: {}
+      };
+
+      const suggestions = wis.getSuggestions(context);
+
+      expect(Array.isArray(suggestions)).toBe(true);
+      expect(suggestions.length).toBeGreaterThan(0);
+      expect(suggestions[0]).toHaveProperty('command');
+      expect(suggestions[0]).toHaveProperty('confidence');
+      expect(suggestions[0].workflow).toBe('epic_creation');
+    });
+
+    it('should provide scored suggestions for story development context', () => {
+      const context = {
+        lastCommand: 'validate-story-draft',
+        lastCommands: ['validate-story-draft', 'develop'],
+        agentId: '@po',
+        projectState: {}
+      };
+
+      const suggestions = wis.getSuggestions(context);
+
+      expect(suggestions.length).toBeGreaterThan(0);
+      expect(suggestions[0].workflow).toBe('story_development');
+    });
+
+    it('should return empty array for unrecognized context', () => {
+      const context = {
+        lastCommand: 'random-unknown-command',
+        lastCommands: ['random-unknown-command'],
+        agentId: '@unknown',
+        projectState: {}
+      };
+
+      const suggestions = wis.getSuggestions(context);
+      expect(suggestions).toEqual([]);
+    });
+
+    it('should rank suggestions by confidence', () => {
+      const context = {
+        lastCommand: 'create-story',
+        lastCommands: ['create-epic', 'create-story'],
+        agentId: '@sm',
+        projectState: {}
+      };
+
+      const suggestions = wis.getSuggestions(context);
+
+      if (suggestions.length > 1) {
+        expect(suggestions[0].confidence).toBeGreaterThanOrEqual(suggestions[1].confidence);
+      }
+    });
+
+    it('should include workflow and state information', () => {
+      // Need 2 matching commands to meet trigger_threshold
+      const context = {
+        lastCommand: 'create-story',
+        lastCommands: ['create-epic', 'create-story'],
+        agentId: '@po',
+        projectState: {}
+      };
+
+      const suggestions = wis.getSuggestions(context);
+
+      expect(suggestions[0].workflow).toBe('epic_creation');
+      expect(suggestions[0].state).toBeDefined();
+    });
+  });
+
+  describe('End-to-end workflow navigation', () => {
+    it('should navigate through epic creation workflow', () => {
+      // Need 2 commands to meet trigger_threshold
+      const context1 = {
+        lastCommand: 'create-story',
+        lastCommands: ['create-epic', 'create-story'],
+        agentId: '@po',
+        projectState: {}
+      };
+
+      const suggestions1 = wis.getSuggestions(context1);
+      // Should suggest validation after stories created
+      expect(suggestions1.some(s =>
+        s.command === 'validate-story-draft' || s.command === 'create-next-story'
+      )).toBe(true);
+
+      // Step 2: After validation
+      const context2 = {
+        lastCommand: 'validate-story-draft',
+        lastCommands: ['create-epic', 'create-story', 'validate-story-draft'],
+        agentId: '@sm',
+        projectState: {}
+      };
+
+      const suggestions2 = wis.getSuggestions(context2);
+      expect(suggestions2.some(s =>
+        s.command === 'analyze-impact' || s.command === 'develop'
+      )).toBe(true);
+    });
+
+    it('should navigate through story development workflow', () => {
+      // Step 1: Story validated - need 2 commands to meet trigger threshold
+      const context1 = {
+        lastCommand: 'validate-story-draft',
+        lastCommands: ['validate-story-draft', 'develop'],
+        agentId: '@po',
+        projectState: {}
+      };
+
+      const suggestions1 = wis.getSuggestions(context1);
+      if (suggestions1.length > 0) {
+        const hasDevelopCommand = suggestions1.some(s =>
+          s.command.includes('develop') || s.command.includes('review')
+        );
+        expect(hasDevelopCommand).toBe(true);
+      }
+    });
+
+    it('should navigate through database workflow', () => {
+      // Need 2 commands to meet trigger threshold
+      const context = {
+        lastCommand: 'db-schema-audit',
+        lastCommands: ['db-domain-modeling', 'db-schema-audit'],
+        agentId: '@data-engineer',
+        projectState: {}
+      };
+
+      const suggestions = wis.getSuggestions(context);
+      expect(suggestions.length).toBeGreaterThan(0);
+      expect(suggestions[0].workflow).toBe('database_workflow');
+    });
+  });
+
+  describe('Multi-agent workflow support', () => {
+    it('should support multiple agents in epic creation', () => {
+      const poWorkflows = wis.getWorkflowsByAgent('@po');
+      const smWorkflows = wis.getWorkflowsByAgent('@sm');
+
+      const epicInPo = poWorkflows.some(w => w.name === 'epic_creation');
+      const epicInSm = smWorkflows.some(w => w.name === 'epic_creation');
+
+      expect(epicInPo).toBe(true);
+      expect(epicInSm).toBe(true);
+    });
+
+    it('should support agent transitions within workflow', () => {
+      // PO validates story - need 2 matching commands
+      const poContext = {
+        lastCommand: 'validate-story-draft',
+        lastCommands: ['validate-story-draft', 'develop'],
+        agentId: '@po',
+        projectState: {}
+      };
+
+      const poSuggestions = wis.getSuggestions(poContext);
+      expect(poSuggestions.length).toBeGreaterThan(0);
+
+      // Dev implements
+      const devContext = {
+        lastCommand: 'develop',
+        lastCommands: ['validate-story-draft', 'develop'],
+        agentId: '@dev',
+        projectState: {}
+      };
+
+      const devSuggestions = wis.getSuggestions(devContext);
+      expect(devSuggestions.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Public API completeness', () => {
+    it('should expose matchWorkflow function', () => {
+      const match = wis.matchWorkflow(['create-epic', 'create-story']);
+      expect(match).not.toBeNull();
+      expect(match.name).toBe('epic_creation');
+    });
+
+    it('should expose getNextSteps function', () => {
+      const steps = wis.getNextSteps('epic_creation', 'epic_drafted');
+      expect(Array.isArray(steps)).toBe(true);
+      expect(steps.length).toBeGreaterThan(0);
+    });
+
+    it('should expose getTransitions function', () => {
+      const transition = wis.getTransitions('epic_creation', 'epic_drafted');
+      expect(transition).not.toBeNull();
+      expect(transition.trigger).toBeDefined();
+    });
+
+    it('should expose getWorkflow function', () => {
+      const workflow = wis.getWorkflow('epic_creation');
+      expect(workflow).not.toBeNull();
+      expect(workflow.description).toBeDefined();
+    });
+
+    it('should expose getWorkflowNames function', () => {
+      const names = wis.getWorkflowNames();
+      expect(names.length).toBe(10);
+    });
+
+    it('should expose getWorkflowsByAgent function', () => {
+      const workflows = wis.getWorkflowsByAgent('@po');
+      expect(workflows.length).toBeGreaterThan(0);
+    });
+
+    it('should expose findCurrentState function', () => {
+      const state = wis.findCurrentState('epic_creation', 'create-epic');
+      expect(state).toBe('epic_drafted');
+    });
+
+    it('should expose getStats function', () => {
+      const stats = wis.getStats();
+      expect(stats.totalWorkflows).toBe(10);
+      expect(stats.workflowsWithTransitions).toBe(10);
+    });
+
+    it('should expose factory functions', () => {
+      expect(typeof wis.createWorkflowRegistry).toBe('function');
+      expect(typeof wis.createConfidenceScorer).toBe('function');
+    });
+
+    it('should expose class constructors', () => {
+      expect(wis.WorkflowRegistry).toBeDefined();
+      expect(wis.ConfidenceScorer).toBeDefined();
+    });
+
+    it('should expose constants', () => {
+      expect(wis.SCORING_WEIGHTS).toBeDefined();
+      expect(wis.DEFAULT_CACHE_TTL).toBeDefined();
+    });
+  });
+
+  describe('Cache behavior', () => {
+    it('should use cache for repeated calls', () => {
+      const stats1 = wis.getStats();
+      expect(stats1.cacheValid).toBe(true);
+
+      const stats2 = wis.getStats();
+      expect(stats2.cacheValid).toBe(true);
+      expect(stats2.cacheAge).toBeGreaterThanOrEqual(stats1.cacheAge);
+    });
+
+    it('should invalidate cache when requested', () => {
+      wis.getStats(); // Populate cache
+      wis.invalidateCache();
+
+      // Force reload
+      wis.reset();
+      const stats = wis.getStats();
+      expect(stats.cacheAge).toBeLessThan(100); // Fresh cache
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle missing context gracefully', () => {
+      const suggestions = wis.getSuggestions({});
+      expect(Array.isArray(suggestions)).toBe(true);
+    });
+
+    it('should handle null context', () => {
+      // This should not throw and return empty array
+      const result = wis.getSuggestions(null);
+      expect(result).toEqual([]);
+    });
+
+    it('should return empty for invalid workflow name', () => {
+      const steps = wis.getNextSteps('invalid_workflow', 'any_state');
+      expect(steps).toEqual([]);
+    });
+  });
+
+  describe('All 10 workflows have transitions', () => {
+    const workflows = [
+      'story_development',
+      'epic_creation',
+      'backlog_management',
+      'architecture_review',
+      'git_workflow',
+      'database_workflow',
+      'code_quality_workflow',
+      'documentation_workflow',
+      'ux_workflow',
+      'research_workflow'
+    ];
+
+    workflows.forEach(workflowName => {
+      it(`${workflowName} should have transitions defined`, () => {
+        const workflow = wis.getWorkflow(workflowName);
+        expect(workflow.transitions).toBeDefined();
+        expect(Object.keys(workflow.transitions).length).toBeGreaterThanOrEqual(2);
+      });
+
+      it(`${workflowName} should have at least 2 states`, () => {
+        const workflow = wis.getWorkflow(workflowName);
+        const stateCount = Object.keys(workflow.transitions).length;
+        expect(stateCount).toBeGreaterThanOrEqual(2);
+      });
+
+      it(`${workflowName} transitions should have required fields`, () => {
+        const workflow = wis.getWorkflow(workflowName);
+
+        Object.entries(workflow.transitions).forEach(([state, transition]) => {
+          expect(transition.trigger).toBeDefined();
+          expect(transition.confidence).toBeDefined();
+          expect(transition.confidence).toBeGreaterThanOrEqual(0);
+          expect(transition.confidence).toBeLessThanOrEqual(1);
+          expect(transition.next_steps).toBeDefined();
+          expect(Array.isArray(transition.next_steps)).toBe(true);
+        });
+      });
+    });
+  });
+});