aios-core 3.7.0 → 3.9.1

package/.aios-core/scripts/session-context-loader.js

@@ -1,265 +1,24 @@
 /**
- * Session Context Loader - Multi-Agent Session Continuity
+ * Session Context Loader - Re-export from canonical location
  *
- * Provides session context when transitioning between agents.
- * Solves the problem: "@po approved story, @dev doesn't know about it"
+ * @deprecated Use require('../core/session/context-loader') directly
+ * @module scripts/session-context-loader
  *
- * Features:
- * - Detects previous agent in session
- * - Tracks last N commands
- * - Identifies active workflow
- * - Provides natural language summary for new agent
+ * This file re-exports SessionContextLoader from its canonical location
+ * in core/session/context-loader.js for backward compatibility.
  *
- * Part of Story 6.1.2.5 UX Improvements
+ * Migration note (WIS-3):
+ * - Canonical location: .aios-core/core/session/context-loader.js
+ * - This file exists for backward compatibility with existing imports
+ * - New code should import from core/session/context-loader directly
  */
 
-const fs = require('fs');
-const path = require('path');
-const ContextDetector = require('../core/session/context-detector');
+'use strict';
 
-const SESSION_STATE_PATH = path.join(process.cwd(), '.aios', 'session-state.json');
-const MAX_COMMANDS_HISTORY = 10;
+// Re-export from canonical location
+const SessionContextLoader = require('../core/session/context-loader');
 
-class SessionContextLoader {
-  constructor() {
-    this.detector = new ContextDetector();
-    this.sessionStatePath = SESSION_STATE_PATH;
-  }
-
-  /**
-   * Load session context for current agent activation
-   *
-   * @param {string} currentAgentId - ID of agent being activated
-   * @returns {Object} Session context
-   */
-  loadContext(currentAgentId) {
-    // Pass sessionStatePath to detector so it uses the correct file (important for testing)
-    const sessionType = this.detector.detectSessionType([], this.sessionStatePath);
-    const sessionState = this.loadSessionState();
-
-    if (sessionType === 'new') {
-      // Fresh session - no context
-      return {
-        sessionType: 'new',
-        message: null,
-        previousAgent: null,
-        lastCommands: [],
-        workflowActive: null,
-      };
-    }
-
-    // Extract context information
-    const previousAgent = this.getPreviousAgent(sessionState, currentAgentId);
-    const lastCommands = sessionState.lastCommands || [];
-    const workflowActive = sessionState.workflowActive || null;
-
-    // Generate natural language summary
-    const message = this.generateContextMessage({
-      sessionType,
-      previousAgent,
-      lastCommands,
-      workflowActive,
-      currentAgentId,
-    });
-
-    return {
-      sessionType,
-      message,
-      previousAgent,
-      lastCommands,
-      workflowActive,
-      currentStory: sessionState.currentStory || null,
-      sessionId: sessionState.sessionId,
-      sessionStartTime: sessionState.startTime,
-    };
-  }
-
-  /**
-   * Load session state from file
-   *
-   * @returns {Object} Session state
-   */
-  loadSessionState() {
-    try {
-      if (!fs.existsSync(this.sessionStatePath)) {
-        return {};
-      }
-
-      const content = fs.readFileSync(this.sessionStatePath, 'utf8');
-      return JSON.parse(content);
-    } catch (error) {
-      console.warn('[SessionContext] Failed to load session state:', error.message);
-      return {};
-    }
-  }
-
-  /**
-   * Get previous agent from session
-   *
-   * @param {Object} sessionState - Session state
-   * @param {string} currentAgentId - Current agent ID
-   * @returns {Object|null} Previous agent info
-   */
-  getPreviousAgent(sessionState, currentAgentId) {
-    const agentSequence = sessionState.agentSequence || [];
-
-    if (agentSequence.length === 0) {
-      return null;
-    }
-
-    // Get last agent that's different from current
-    for (let i = agentSequence.length - 1; i >= 0; i--) {
-      const agent = agentSequence[i];
-      if (agent.agentId !== currentAgentId) {
-        return {
-          agentId: agent.agentId,
-          agentName: agent.agentName,
-          activatedAt: agent.activatedAt,
-          lastCommand: agent.lastCommand,
-        };
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Generate natural language context message
-   *
-   * @param {Object} context - Context data
-   * @returns {string|null} Context message
-   */
-  generateContextMessage(context) {
-    const { sessionType, previousAgent, lastCommands, workflowActive } = context;
-
-    if (sessionType === 'new') {
-      return null;
-    }
-
-    const parts = [];
-
-    // Previous agent context
-    if (previousAgent) {
-      const agentName = previousAgent.agentName || previousAgent.agentId;
-      const minutesAgo = Math.floor((Date.now() - previousAgent.activatedAt) / 60000);
-      const timeAgo = minutesAgo < 1 ? 'just now' : minutesAgo === 1 ? '1 minute ago' : `${minutesAgo} minutes ago`;
-
-      parts.push(`📍 **Session Context**: Continuing from @${previousAgent.agentId} (${agentName}) activated ${timeAgo}`);
-
-      if (previousAgent.lastCommand) {
-        parts.push(`   Last action: *${previousAgent.lastCommand}`);
-      }
-    }
-
-    // Recent commands
-    if (lastCommands.length > 0) {
-      const recentCmds = lastCommands.slice(-5).join(', *');
-      parts.push(`   Recent commands: *${recentCmds}`);
-    }
-
-    // Active workflow
-    if (workflowActive) {
-      parts.push(`   ⚡ Active Workflow: ${workflowActive}`);
-    }
-
-    return parts.length > 0 ? parts.join('\n') : null;
-  }
-
-  /**
-   * Update session state with current agent
-   *
-   * @param {string} agentId - Agent ID
-   * @param {string} agentName - Agent name
-   * @param {string} lastCommand - Last command executed
-   * @param {Object} options - Update options
-   */
-  updateSession(agentId, agentName, lastCommand = null, options = {}) {
-    try {
-      const sessionState = this.loadSessionState();
-
-      // Initialize if new session
-      if (!sessionState.sessionId) {
-        sessionState.sessionId = `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        sessionState.startTime = Date.now();
-      }
-
-      // Update activity timestamp
-      sessionState.lastActivity = Date.now();
-
-      // Update agent sequence
-      if (!sessionState.agentSequence) {
-        sessionState.agentSequence = [];
-      }
-
-      sessionState.agentSequence.push({
-        agentId,
-        agentName,
-        activatedAt: Date.now(),
-        lastCommand,
-      });
-
-      // Keep last 20 agent activations
-      if (sessionState.agentSequence.length > 20) {
-        sessionState.agentSequence = sessionState.agentSequence.slice(-20);
-      }
-
-      // Update command history
-      if (lastCommand) {
-        if (!sessionState.lastCommands) {
-          sessionState.lastCommands = [];
-        }
-
-        sessionState.lastCommands.push(lastCommand);
-
-        // Keep last N commands
-        if (sessionState.lastCommands.length > MAX_COMMANDS_HISTORY) {
-          sessionState.lastCommands = sessionState.lastCommands.slice(-MAX_COMMANDS_HISTORY);
-        }
-      }
-
-      // Update workflow status
-      if (options.workflowActive !== undefined) {
-        sessionState.workflowActive = options.workflowActive;
-      }
-
-      // Save to file
-      this.detector.updateSessionState(sessionState, this.sessionStatePath);
-    } catch (error) {
-      console.warn('[SessionContext] Failed to update session:', error.message);
-    }
-  }
-
-  /**
-   * Clear session (start fresh)
-   */
-  clearSession() {
-    try {
-      if (fs.existsSync(this.sessionStatePath)) {
-        fs.unlinkSync(this.sessionStatePath);
-      }
-    } catch (error) {
-      console.warn('[SessionContext] Failed to clear session:', error.message);
-    }
-  }
-
-  /**
-   * Format context for display in agent greeting
-   *
-   * @param {string} currentAgentId - Current agent ID
-   * @returns {string} Formatted context message
-   */
-  formatForGreeting(currentAgentId) {
-    const context = this.loadContext(currentAgentId);
-
-    if (!context.message) {
-      return '';
-    }
-
-    return `\n${context.message}\n`;
-  }
-}
-
-// CLI Interface
+// CLI Interface (preserved for backward compatibility)
 if (require.main === module) {
   const loader = new SessionContextLoader();
   const command = process.argv[2];

package/.aios-core/scripts/test-template-system.js

@@ -34,7 +34,7 @@ class TestTemplateSystem {
       console.log(chalk.green('✅ Test template system initialized'));
       return true;
 
-    } catch (_error) {
+    } catch (error) {
       console.error(chalk.red(`Failed to initialize test template system: ${error.message}`));
       throw error;
     }
@@ -121,7 +121,7 @@ class TestTemplateSystem {
       console.log(chalk.green(`✅ Custom template created: ${templateName}`));
       return templateWrapper;
 
-    } catch (_error) {
+    } catch (error) {
       console.error(chalk.red(`Failed to create custom template: ${error.message}`));
       throw error;
     }
@@ -136,7 +136,7 @@ class TestTemplateSystem {
     try {
       const content = await fs.readFile(templatePath, 'utf-8');
       return JSON.parse(content);
-    } catch (_error) {
+    } catch {
       // Template file doesn't exist
       return null;
     }
@@ -837,14 +837,14 @@ afterAll(async () => {
           const templateKey = path.basename(templateFile, '.template.js');
           
           this.templateCache.set(templateKey, template);
-        } catch (_error) {
+        } catch (error) {
           console.warn(chalk.yellow(`Failed to load template ${templateFile}: ${error.message}`));
         }
       }
 
       console.log(chalk.gray(`Loaded ${this.templateCache.size} template(s)`));
 
-    } catch (_error) {
+    } catch (error) {
       console.warn(chalk.yellow(`Failed to load templates: ${error.message}`));
     }
   }
@@ -872,7 +872,7 @@ afterAll(async () => {
           templateFiles.push(path.join(this.templatesDir, entry.name));
         }
       }
-    } catch (_error) {
+    } catch {
       // Templates directory doesn't exist yet
     }
 

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);
+    });
+  });
+});