aios-core 1.0.0

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

@@ -0,0 +1,327 @@
+/**
+ * @module workflow-intelligence
+ * @description Workflow Intelligence System (WIS) public API
+ * @story WIS-2 - Workflow Registry Enhancement
+ * @story WIS-4 - Wave Analysis Engine
+ * @version 1.1.0
+ *
+ * @example
+ * const wis = require('./.aios-core/workflow-intelligence');
+ *
+ * // Get workflow suggestions
+ * const suggestions = wis.getSuggestions({
+ *   lastCommand: 'create-story',
+ *   lastCommands: ['create-epic', 'create-story'],
+ *   agentId: '@sm'
+ * });
+ *
+ * // Find matching workflow
+ * const workflow = wis.matchWorkflow(['create-epic', 'create-story']);
+ *
+ * // Get next steps for a state
+ * const nextSteps = wis.getNextSteps('epic_creation', 'stories_created');
+ *
+ * // Analyze waves for parallel execution (WIS-4)
+ * const waves = wis.analyzeWaves('story_development');
+ * console.log(waves.waves); // Wave groupings
+ * console.log(waves.criticalPath); // Critical path
+ */
+
+'use strict';
+
+const {
+  WorkflowRegistry,
+  createWorkflowRegistry,
+  DEFAULT_CACHE_TTL,
+  DEFAULT_PATTERNS_PATH
+} = require('./registry/workflow-registry');
+
+const {
+  ConfidenceScorer,
+  createConfidenceScorer,
+  SCORING_WEIGHTS
+} = require('./engine/confidence-scorer');
+
+const {
+  SuggestionEngine,
+  createSuggestionEngine,
+  SUGGESTION_CACHE_TTL,
+  LOW_CONFIDENCE_THRESHOLD
+} = require('./engine/suggestion-engine');
+
+const {
+  WaveAnalyzer,
+  CircularDependencyError,
+  createWaveAnalyzer,
+  analyzeWaves,
+  DEFAULT_TASK_DURATIONS
+} = require('./engine/wave-analyzer');
+
+const outputFormatter = require('./engine/output-formatter');
+
+// Learning module (WIS-5)
+let learningModule = null;
+try {
+  learningModule = require('./learning');
+} catch (error) {
+  // Learning module not yet available
+  learningModule = null;
+}
+
+/**
+ * Singleton instances for default usage
+ */
+let defaultRegistry = null;
+let defaultScorer = null;
+
+/**
+ * Get or create the default registry instance
+ * @returns {WorkflowRegistry} Default registry instance
+ */
+function getDefaultRegistry() {
+  if (!defaultRegistry) {
+    defaultRegistry = createWorkflowRegistry();
+  }
+  return defaultRegistry;
+}
+
+/**
+ * Get or create the default scorer instance
+ * @returns {ConfidenceScorer} Default scorer instance
+ */
+function getDefaultScorer() {
+  if (!defaultScorer) {
+    defaultScorer = createConfidenceScorer();
+  }
+  return defaultScorer;
+}
+
+/**
+ * Get workflow suggestions with confidence scores
+ * @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 {Object[]} Ranked suggestions with scores
+ */
+function getSuggestions(context) {
+  if (!context) {
+    return [];
+  }
+
+  const registry = getDefaultRegistry();
+  const scorer = getDefaultScorer();
+
+  // Find matching workflow
+  const commands = context.lastCommands || (context.lastCommand ? [context.lastCommand] : []);
+  const match = registry.matchWorkflow(commands);
+
+  if (!match) {
+    return [];
+  }
+
+  // Find current state
+  const currentState = registry.findCurrentState(match.name, context.lastCommand);
+
+  if (!currentState) {
+    // Return first state's suggestions if we can't determine current state
+    const transitions = registry.getAllTransitions(match.name);
+    const firstState = Object.keys(transitions)[0];
+
+    if (!firstState) {
+      return [];
+    }
+
+    return formatSuggestions(
+      registry.getNextSteps(match.name, firstState),
+      match,
+      firstState,
+      scorer,
+      context
+    );
+  }
+
+  // Get next steps for current state
+  const nextSteps = registry.getNextSteps(match.name, currentState);
+
+  return formatSuggestions(nextSteps, match, currentState, scorer, context);
+}
+
+/**
+ * Format and score suggestions
+ * @param {Object[]} nextSteps - Raw next steps from registry
+ * @param {Object} match - Workflow match info
+ * @param {string} state - Current state
+ * @param {ConfidenceScorer} scorer - Scorer instance
+ * @param {Object} context - Session context
+ * @returns {Object[]} Formatted and scored suggestions
+ */
+function formatSuggestions(nextSteps, match, state, scorer, context) {
+  if (!nextSteps || nextSteps.length === 0) {
+    return [];
+  }
+
+  const transition = getDefaultRegistry().getTransitions(match.name, state);
+  const baseConfidence = transition?.confidence || 0.5;
+
+  return nextSteps.map(step => {
+    const suggestion = {
+      command: step.command,
+      args_template: step.args_template,
+      description: step.description,
+      priority: step.priority,
+      workflow: match.name,
+      state: state,
+      trigger: transition?.trigger,
+      agentSequence: match.workflow.agent_sequence,
+      keyCommands: match.workflow.key_commands
+    };
+
+    // Calculate confidence score
+    const score = scorer.score(suggestion, context);
+
+    // Blend base confidence with calculated score
+    const finalScore = (baseConfidence * 0.4) + (score * 0.6);
+
+    return {
+      ...suggestion,
+      confidence: Math.round(finalScore * 100) / 100
+    };
+  }).sort((a, b) => b.confidence - a.confidence);
+}
+
+/**
+ * Match command history to a workflow
+ * @param {string[]} commands - Command history
+ * @returns {Object|null} Matching workflow or null
+ */
+function matchWorkflow(commands) {
+  return getDefaultRegistry().matchWorkflow(commands);
+}
+
+/**
+ * Get next steps for a workflow state
+ * @param {string} workflowName - Workflow name
+ * @param {string} state - Current state
+ * @returns {Object[]} Next step suggestions
+ */
+function getNextSteps(workflowName, state) {
+  return getDefaultRegistry().getNextSteps(workflowName, state);
+}
+
+/**
+ * Get transitions for a workflow state
+ * @param {string} workflowName - Workflow name
+ * @param {string} state - Current state
+ * @returns {Object|null} Transition or null
+ */
+function getTransitions(workflowName, state) {
+  return getDefaultRegistry().getTransitions(workflowName, state);
+}
+
+/**
+ * Get a workflow by name
+ * @param {string} name - Workflow name
+ * @returns {Object|null} Workflow or null
+ */
+function getWorkflow(name) {
+  return getDefaultRegistry().getWorkflow(name);
+}
+
+/**
+ * Get all workflow names
+ * @returns {string[]} Workflow names
+ */
+function getWorkflowNames() {
+  return getDefaultRegistry().getWorkflowNames();
+}
+
+/**
+ * Get workflows by agent
+ * @param {string} agentId - Agent identifier
+ * @returns {Object[]} Workflows involving this agent
+ */
+function getWorkflowsByAgent(agentId) {
+  return getDefaultRegistry().getWorkflowsByAgent(agentId);
+}
+
+/**
+ * Find current state based on last command
+ * @param {string} workflowName - Workflow name
+ * @param {string} lastCommand - Last command
+ * @returns {string|null} Current state or null
+ */
+function findCurrentState(workflowName, lastCommand) {
+  return getDefaultRegistry().findCurrentState(workflowName, lastCommand);
+}
+
+/**
+ * Get registry statistics
+ * @returns {Object} Statistics
+ */
+function getStats() {
+  return getDefaultRegistry().getStats();
+}
+
+/**
+ * Invalidate registry cache
+ */
+function invalidateCache() {
+  if (defaultRegistry) {
+    defaultRegistry.invalidateCache();
+  }
+}
+
+/**
+ * Reset singleton instances (for testing)
+ */
+function reset() {
+  defaultRegistry = null;
+  defaultScorer = null;
+}
+
+module.exports = {
+  // High-level API
+  getSuggestions,
+  matchWorkflow,
+  getNextSteps,
+  getTransitions,
+  getWorkflow,
+  getWorkflowNames,
+  getWorkflowsByAgent,
+  findCurrentState,
+  getStats,
+  invalidateCache,
+  reset,
+
+  // Wave Analysis API (WIS-4)
+  analyzeWaves,
+  createWaveAnalyzer,
+
+  // Pattern Learning API (WIS-5)
+  learning: learningModule,
+
+  // Factory functions
+  createWorkflowRegistry,
+  createConfidenceScorer,
+  createSuggestionEngine,
+
+  // Classes (for advanced usage)
+  WorkflowRegistry,
+  ConfidenceScorer,
+  SuggestionEngine,
+  WaveAnalyzer,
+  CircularDependencyError,
+
+  // Output formatting (for *next task)
+  outputFormatter,
+
+  // Constants
+  SCORING_WEIGHTS,
+  DEFAULT_CACHE_TTL,
+  DEFAULT_PATTERNS_PATH,
+  SUGGESTION_CACHE_TTL,
+  LOW_CONFIDENCE_THRESHOLD,
+  DEFAULT_TASK_DURATIONS
+};

package/.aios-core/workflow-intelligence/learning/capture-hook.js

@@ -0,0 +1,147 @@
+/**
+ * @module CaptureHook
+ * @description Task completion hook for pattern capture
+ * @story WIS-5 - Pattern Capture (Internal)
+ * @version 1.0.0
+ *
+ * @example
+ * // In task completion flow
+ * const { onTaskComplete } = require('./workflow-intelligence/learning/capture-hook');
+ * await onTaskComplete('develop', { sessionId: 'abc123', agentId: '@dev' });
+ */
+
+'use strict';
+
+const { createPatternCapture } = require('./pattern-capture');
+const { createPatternValidator } = require('./pattern-validator');
+const { createPatternStore } = require('./pattern-store');
+
+/**
+ * Singleton instances
+ */
+let capture = null;
+let validator = null;
+let store = null;
+
+/**
+ * Check if pattern capture is enabled
+ * @returns {boolean} True if enabled
+ */
+function isEnabled() {
+  return process.env.AIOS_PATTERN_CAPTURE !== 'false';
+}
+
+/**
+ * Get or create singleton instances
+ */
+function getInstances() {
+  if (!capture) {
+    capture = createPatternCapture();
+  }
+  if (!validator) {
+    validator = createPatternValidator();
+  }
+  if (!store) {
+    store = createPatternStore();
+  }
+  return { capture, validator, store };
+}
+
+/**
+ * Handle task completion event (non-blocking)
+ * @param {string} taskName - Name of completed task
+ * @param {Object} context - Task context
+ * @returns {Promise<Object>} Capture result
+ */
+async function onTaskComplete(taskName, context = {}) {
+  if (!isEnabled()) {
+    return { success: false, reason: 'disabled' };
+  }
+
+  try {
+    const { capture: cap, validator: val, store: st } = getInstances();
+    const result = await cap.onTaskComplete(taskName, context);
+
+    if (result.captured && result.pattern) {
+      // Validate and store
+      const validation = val.validate(result.pattern);
+
+      if (validation.valid) {
+        st.save(result.pattern);
+        return {
+          success: true,
+          action: 'stored',
+          patternId: result.pattern.id
+        };
+      } else {
+        return {
+          success: false,
+          reason: 'validation_failed',
+          errors: validation.errors
+        };
+      }
+    }
+
+    return {
+      success: false,
+      reason: result.reason || 'not_captured'
+    };
+  } catch (error) {
+    // Silent failure - capture is non-critical
+    if (process.env.AIOS_DEBUG === 'true') {
+      console.debug('[PatternCapture] Hook failed:', error.message);
+    }
+    return {
+      success: false,
+      reason: 'error',
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Mark session as failed (for error handling)
+ * @param {string} sessionId - Session identifier
+ */
+function markSessionFailed(sessionId) {
+  if (!isEnabled()) return;
+
+  try {
+    const { capture: cap } = getInstances();
+    cap.markSessionFailed(sessionId);
+  } catch (error) {
+    // Ignore errors
+  }
+}
+
+/**
+ * Clear session buffer
+ * @param {string} sessionId - Optional session ID
+ */
+function clearSession(sessionId) {
+  if (!isEnabled()) return;
+
+  try {
+    const { capture: cap } = getInstances();
+    cap.clearSession(sessionId);
+  } catch (error) {
+    // Ignore errors
+  }
+}
+
+/**
+ * Reset singleton instances (for testing)
+ */
+function reset() {
+  capture = null;
+  validator = null;
+  store = null;
+}
+
+module.exports = {
+  onTaskComplete,
+  markSessionFailed,
+  clearSession,
+  isEnabled,
+  reset
+};

package/.aios-core/workflow-intelligence/learning/index.js

@@ -0,0 +1,230 @@
+/**
+ * @module learning
+ * @description Pattern Learning module for Workflow Intelligence System
+ * @story WIS-5 - Pattern Capture (Internal)
+ * @version 1.0.0
+ *
+ * @example
+ * const learning = require('./.aios-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');
+
+/**
+ * Singleton instances for default usage
+ */
+let defaultCapture = null;
+let defaultValidator = null;
+let defaultStore = 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;
+}
+
+/**
+ * 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;
+}
+
+module.exports = {
+  // High-level API
+  captureAndStore,
+  getLearnedPatterns,
+  findMatchingPatterns,
+  getStats,
+  reset,
+
+  // Singleton accessors
+  getDefaultCapture,
+  getDefaultValidator,
+  getDefaultStore,
+
+  // Factory functions
+  createPatternCapture,
+  createPatternValidator,
+  createPatternStore,
+
+  // Classes (for advanced usage)
+  PatternCapture,
+  PatternValidator,
+  PatternStore,
+
+  // Constants
+  DEFAULT_MIN_SEQUENCE_LENGTH,
+  KEY_WORKFLOW_COMMANDS,
+  DEFAULT_VALIDATION_RULES,
+  KNOWN_COMMANDS,
+  DEFAULT_STORAGE_PATH,
+  DEFAULT_MAX_PATTERNS,
+  DEFAULT_PRUNE_THRESHOLD,
+  PATTERN_STATUS
+};