musubi-sdd 3.0.1 → 3.5.1

package/src/orchestration/pattern-registry.js

@@ -0,0 +1,319 @@
+/**
+ * PatternRegistry - Registry for orchestration patterns
+ * 
+ * Manages pattern lifecycle and provides pattern discovery
+ */
+
+const { PatternType } = require('./orchestration-engine');
+
+/**
+ * Pattern metadata
+ */
+class PatternMetadata {
+  constructor(options = {}) {
+    this.name = options.name || '';
+    this.type = options.type || PatternType.SEQUENTIAL;
+    this.description = options.description || '';
+    this.version = options.version || '1.0.0';
+    this.author = options.author || 'MUSUBI';
+    this.tags = options.tags || [];
+    this.useCases = options.useCases || [];
+    this.complexity = options.complexity || 'medium'; // low, medium, high
+    this.supportsParallel = options.supportsParallel || false;
+    this.requiresHuman = options.requiresHuman || false;
+  }
+
+  matches(criteria = {}) {
+    if (criteria.type && this.type !== criteria.type) return false;
+    if (criteria.complexity && this.complexity !== criteria.complexity) return false;
+    if (criteria.supportsParallel !== undefined && 
+        this.supportsParallel !== criteria.supportsParallel) return false;
+    if (criteria.requiresHuman !== undefined && 
+        this.requiresHuman !== criteria.requiresHuman) return false;
+    if (criteria.tags && criteria.tags.length > 0) {
+      if (!criteria.tags.some(t => this.tags.includes(t))) return false;
+    }
+    return true;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      type: this.type,
+      description: this.description,
+      version: this.version,
+      author: this.author,
+      tags: this.tags,
+      useCases: this.useCases,
+      complexity: this.complexity,
+      supportsParallel: this.supportsParallel,
+      requiresHuman: this.requiresHuman
+    };
+  }
+}
+
+/**
+ * Base pattern class
+ */
+class BasePattern {
+  constructor(metadata = {}) {
+    this.metadata = new PatternMetadata(metadata);
+  }
+
+  /**
+   * Execute the pattern
+   * @param {ExecutionContext} context - Execution context
+   * @param {OrchestrationEngine} engine - Orchestration engine
+   * @returns {Promise<any>} Execution result
+   */
+  async execute(context, engine) {
+    throw new Error('Pattern must implement execute method');
+  }
+
+  /**
+   * Validate pattern can execute with given context
+   * @param {ExecutionContext} context - Execution context
+   * @param {OrchestrationEngine} engine - Orchestration engine
+   * @returns {object} Validation result
+   */
+  validate(context, engine) {
+    return { valid: true, errors: [] };
+  }
+
+  /**
+   * Get pattern name
+   * @returns {string} Pattern name
+   */
+  getName() {
+    return this.metadata.name;
+  }
+
+  /**
+   * Get pattern metadata
+   * @returns {PatternMetadata} Pattern metadata
+   */
+  getMetadata() {
+    return this.metadata;
+  }
+}
+
+/**
+ * PatternRegistry - Central registry for patterns
+ */
+class PatternRegistry {
+  constructor() {
+    this.patterns = new Map();
+    this.metadata = new Map();
+  }
+
+  /**
+   * Register a pattern
+   * @param {string} name - Pattern name
+   * @param {BasePattern|object} pattern - Pattern implementation
+   * @param {object} metadata - Optional metadata override
+   * @returns {PatternRegistry} This registry for chaining
+   */
+  register(name, pattern, metadata = {}) {
+    if (!pattern) {
+      throw new Error(`Pattern '${name}' cannot be null`);
+    }
+
+    // Validate pattern has execute method
+    if (typeof pattern.execute !== 'function') {
+      throw new Error(`Pattern '${name}' must have an execute method`);
+    }
+
+    this.patterns.set(name, pattern);
+
+    // Extract or create metadata
+    const patternMeta = pattern.metadata || pattern.getMetadata?.() || {};
+    this.metadata.set(name, new PatternMetadata({
+      name,
+      ...patternMeta,
+      ...metadata
+    }));
+
+    return this;
+  }
+
+  /**
+   * Unregister a pattern
+   * @param {string} name - Pattern name
+   * @returns {boolean} True if pattern was removed
+   */
+  unregister(name) {
+    this.metadata.delete(name);
+    return this.patterns.delete(name);
+  }
+
+  /**
+   * Get a pattern by name
+   * @param {string} name - Pattern name
+   * @returns {object|null} Pattern or null
+   */
+  get(name) {
+    return this.patterns.get(name) || null;
+  }
+
+  /**
+   * Check if a pattern exists
+   * @param {string} name - Pattern name
+   * @returns {boolean} True if pattern exists
+   */
+  has(name) {
+    return this.patterns.has(name);
+  }
+
+  /**
+   * Get pattern metadata
+   * @param {string} name - Pattern name
+   * @returns {PatternMetadata|null} Metadata or null
+   */
+  getMetadata(name) {
+    return this.metadata.get(name) || null;
+  }
+
+  /**
+   * List all pattern names
+   * @returns {string[]} Pattern names
+   */
+  list() {
+    return Array.from(this.patterns.keys());
+  }
+
+  /**
+   * Find patterns matching criteria
+   * @param {object} criteria - Search criteria
+   * @returns {object[]} Matching patterns with metadata
+   */
+  find(criteria = {}) {
+    const results = [];
+    
+    for (const [name, pattern] of this.patterns) {
+      const meta = this.metadata.get(name);
+      if (meta && meta.matches(criteria)) {
+        results.push({
+          name,
+          pattern,
+          metadata: meta
+        });
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Find the best pattern for a task
+   * @param {string} task - Task description
+   * @returns {string|null} Best pattern name
+   */
+  findBestPattern(task) {
+    const taskLower = task.toLowerCase();
+    
+    // Check for parallel keywords
+    if (taskLower.includes('parallel') || 
+        taskLower.includes('concurrent') ||
+        taskLower.includes('simultaneous')) {
+      const swarm = this.find({ supportsParallel: true });
+      if (swarm.length > 0) return swarm[0].name;
+    }
+    
+    // Check for sequential keywords
+    if (taskLower.includes('sequential') || 
+        taskLower.includes('step by step') ||
+        taskLower.includes('one by one')) {
+      if (this.has(PatternType.SEQUENTIAL)) return PatternType.SEQUENTIAL;
+    }
+    
+    // Check for collaboration keywords
+    if (taskLower.includes('discuss') || 
+        taskLower.includes('review') ||
+        taskLower.includes('collaborate')) {
+      if (this.has(PatternType.GROUP_CHAT)) return PatternType.GROUP_CHAT;
+    }
+    
+    // Check for nested/hierarchical keywords
+    if (taskLower.includes('break down') || 
+        taskLower.includes('decompose') ||
+        taskLower.includes('hierarchical')) {
+      if (this.has(PatternType.NESTED)) return PatternType.NESTED;
+    }
+    
+    // Check for human validation keywords
+    if (taskLower.includes('validate') || 
+        taskLower.includes('approve') ||
+        taskLower.includes('review')) {
+      if (this.has(PatternType.HUMAN_IN_LOOP)) return PatternType.HUMAN_IN_LOOP;
+    }
+    
+    // Default to auto pattern
+    if (this.has(PatternType.AUTO)) return PatternType.AUTO;
+    
+    // Fall back to sequential
+    if (this.has(PatternType.SEQUENTIAL)) return PatternType.SEQUENTIAL;
+    
+    // Return first available pattern
+    const patterns = this.list();
+    return patterns.length > 0 ? patterns[0] : null;
+  }
+
+  /**
+   * Register all patterns with an orchestration engine
+   * @param {OrchestrationEngine} engine - Engine to register with
+   */
+  registerWithEngine(engine) {
+    for (const [name, pattern] of this.patterns) {
+      engine.registerPattern(name, pattern);
+    }
+  }
+
+  /**
+   * Get registry summary
+   * @returns {object} Summary of registered patterns
+   */
+  getSummary() {
+    const summary = {
+      total: this.patterns.size,
+      patterns: [],
+      byType: {},
+      byComplexity: {}
+    };
+
+    for (const [name, meta] of this.metadata) {
+      summary.patterns.push(meta.toJSON());
+      
+      // Count by type
+      summary.byType[meta.type] = (summary.byType[meta.type] || 0) + 1;
+      
+      // Count by complexity
+      summary.byComplexity[meta.complexity] = 
+        (summary.byComplexity[meta.complexity] || 0) + 1;
+    }
+
+    return summary;
+  }
+
+  /**
+   * Clear all patterns
+   */
+  clear() {
+    this.patterns.clear();
+    this.metadata.clear();
+  }
+}
+
+/**
+ * Create a default registry with built-in patterns
+ * @returns {PatternRegistry} Registry with default patterns
+ */
+function createDefaultRegistry() {
+  return new PatternRegistry();
+}
+
+module.exports = {
+  PatternRegistry,
+  PatternMetadata,
+  BasePattern,
+  createDefaultRegistry
+};

package/src/orchestration/patterns/auto.js

@@ -0,0 +1,386 @@
+/**
+ * AutoPattern - Automatic skill selection pattern
+ * 
+ * Analyzes the task and automatically selects the most appropriate
+ * skill to execute. Uses skill metadata and keywords for matching.
+ */
+
+const { BasePattern } = require('../pattern-registry');
+const { PatternType, ExecutionContext, ExecutionStatus } = require('../orchestration-engine');
+
+/**
+ * Skill match confidence levels
+ */
+const ConfidenceLevel = {
+  HIGH: 'high',     // >= 0.8
+  MEDIUM: 'medium', // >= 0.5
+  LOW: 'low',       // >= 0.3
+  NONE: 'none'      // < 0.3
+};
+
+/**
+ * AutoPattern - Automatic skill selection and execution
+ */
+class AutoPattern extends BasePattern {
+  constructor(options = {}) {
+    super({
+      name: PatternType.AUTO,
+      type: PatternType.AUTO,
+      description: 'Automatically select and execute the best skill for a task',
+      version: '1.0.0',
+      tags: ['intelligent', 'automatic', 'routing'],
+      useCases: [
+        'Dynamic task routing',
+        'Intelligent skill selection',
+        'Natural language task processing'
+      ],
+      complexity: 'medium',
+      supportsParallel: false,
+      requiresHuman: false
+    });
+
+    this.options = {
+      minConfidence: options.minConfidence || 0.3,
+      fallbackSkill: options.fallbackSkill || null,
+      multiMatch: options.multiMatch || false, // Execute multiple matching skills
+      maxMatches: options.maxMatches || 3,
+      ...options
+    };
+
+    // Skill category keywords for classification
+    this.categoryKeywords = {
+      requirements: ['requirement', 'need', 'user story', 'feature', 'specification', 'ears'],
+      design: ['design', 'architecture', 'component', 'diagram', 'c4', 'uml'],
+      implementation: ['implement', 'code', 'develop', 'build', 'create', 'programming'],
+      testing: ['test', 'qa', 'quality', 'verify', 'validate', 'bug'],
+      documentation: ['document', 'doc', 'readme', 'guide', 'tutorial'],
+      devops: ['deploy', 'ci', 'cd', 'pipeline', 'infrastructure', 'kubernetes'],
+      security: ['security', 'vulnerability', 'authentication', 'authorization'],
+      performance: ['performance', 'optimize', 'benchmark', 'profiling'],
+      analysis: ['analyze', 'review', 'assess', 'evaluate', 'audit'],
+      research: ['research', 'investigate', 'explore', 'study']
+    };
+  }
+
+  /**
+   * Validate the execution context
+   * @param {ExecutionContext} context - Execution context
+   * @param {OrchestrationEngine} engine - Orchestration engine
+   * @returns {object} Validation result
+   */
+  validate(context, engine) {
+    const errors = [];
+
+    if (!context.task && !context.input?.task) {
+      errors.push('Auto pattern requires a task description');
+    }
+
+    if (engine.listSkills().length === 0) {
+      errors.push('No skills registered with engine');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Execute auto pattern - select and run best skill
+   * @param {ExecutionContext} context - Execution context
+   * @param {OrchestrationEngine} engine - Orchestration engine
+   * @returns {Promise<object>} Execution result
+   */
+  async execute(context, engine) {
+    const validation = this.validate(context, engine);
+    if (!validation.valid) {
+      throw new Error(`Validation failed: ${validation.errors.join(', ')}`);
+    }
+
+    const task = context.task || context.input?.task || '';
+    const input = context.input?.skillInput || context.input || {};
+
+    engine.emit('autoPatternStarted', {
+      context,
+      task
+    });
+
+    // Find matching skills
+    const matches = this._findMatchingSkills(task, engine);
+    
+    engine.emit('autoPatternMatched', {
+      context,
+      task,
+      matches: matches.map(m => ({ skill: m.skill, confidence: m.confidence }))
+    });
+
+    if (matches.length === 0) {
+      // No matches found
+      if (this.options.fallbackSkill && engine.getSkill(this.options.fallbackSkill)) {
+        engine.emit('autoPatternFallback', {
+          context,
+          fallbackSkill: this.options.fallbackSkill
+        });
+        
+        return this._executeSingleSkill(
+          this.options.fallbackSkill, 
+          input, 
+          context, 
+          engine,
+          { confidence: 0, reason: 'fallback' }
+        );
+      }
+      
+      throw new Error(`No matching skill found for task: ${task}`);
+    }
+
+    // Execute based on configuration
+    if (this.options.multiMatch && matches.length > 1) {
+      return this._executeMultipleSkills(matches, input, context, engine);
+    }
+
+    // Execute best match
+    const bestMatch = matches[0];
+    return this._executeSingleSkill(
+      bestMatch.skill,
+      input,
+      context,
+      engine,
+      bestMatch
+    );
+  }
+
+  /**
+   * Find matching skills for a task
+   * @private
+   */
+  _findMatchingSkills(task, engine) {
+    const taskLower = task.toLowerCase();
+    const words = this._tokenize(taskLower);
+    const matches = [];
+
+    for (const skillName of engine.listSkills()) {
+      const skill = engine.getSkill(skillName);
+      const score = this._calculateMatchScore(taskLower, words, skillName, skill);
+      
+      if (score >= this.options.minConfidence) {
+        matches.push({
+          skill: skillName,
+          confidence: score,
+          confidenceLevel: this._getConfidenceLevel(score),
+          matchedKeywords: this._getMatchedKeywords(taskLower, skill)
+        });
+      }
+    }
+
+    // Sort by confidence descending
+    matches.sort((a, b) => b.confidence - a.confidence);
+
+    // Limit matches
+    return matches.slice(0, this.options.maxMatches);
+  }
+
+  /**
+   * Calculate match score for a skill
+   * @private
+   */
+  _calculateMatchScore(taskLower, words, skillName, skill) {
+    let score = 0;
+    let maxScore = 0;
+
+    // Skill name match
+    maxScore += 0.3;
+    const skillNameLower = skillName.toLowerCase().replace(/-/g, ' ');
+    if (taskLower.includes(skillNameLower)) {
+      score += 0.3;
+    } else {
+      // Partial name match
+      const nameWords = skillNameLower.split(' ');
+      const matchedNameWords = nameWords.filter(w => taskLower.includes(w));
+      score += 0.3 * (matchedNameWords.length / nameWords.length);
+    }
+
+    // Keywords match
+    const keywords = skill?.keywords || [];
+    if (keywords.length > 0) {
+      maxScore += 0.4;
+      const matchedKeywords = keywords.filter(k => 
+        taskLower.includes(k.toLowerCase())
+      );
+      score += 0.4 * (matchedKeywords.length / keywords.length);
+    }
+
+    // Category match
+    maxScore += 0.2;
+    const categories = skill?.categories || [];
+    for (const category of categories) {
+      const categoryKw = this.categoryKeywords[category] || [];
+      if (categoryKw.some(kw => taskLower.includes(kw))) {
+        score += 0.2;
+        break;
+      }
+    }
+
+    // Description match
+    const description = skill?.description || '';
+    if (description) {
+      maxScore += 0.1;
+      const descWords = this._tokenize(description.toLowerCase());
+      const commonWords = words.filter(w => descWords.includes(w));
+      score += 0.1 * Math.min(1, commonWords.length / 3);
+    }
+
+    // Normalize score
+    return maxScore > 0 ? score / maxScore : 0;
+  }
+
+  /**
+   * Get confidence level from score
+   * @private
+   */
+  _getConfidenceLevel(score) {
+    if (score >= 0.8) return ConfidenceLevel.HIGH;
+    if (score >= 0.5) return ConfidenceLevel.MEDIUM;
+    if (score >= 0.3) return ConfidenceLevel.LOW;
+    return ConfidenceLevel.NONE;
+  }
+
+  /**
+   * Get matched keywords
+   * @private
+   */
+  _getMatchedKeywords(taskLower, skill) {
+    const keywords = skill?.keywords || [];
+    return keywords.filter(k => taskLower.includes(k.toLowerCase()));
+  }
+
+  /**
+   * Tokenize text into words
+   * @private
+   */
+  _tokenize(text) {
+    return text
+      .split(/\s+/)
+      .map(w => w.replace(/[^\w]/g, ''))
+      .filter(w => w.length > 2);
+  }
+
+  /**
+   * Execute a single skill
+   * @private
+   */
+  async _executeSingleSkill(skillName, input, context, engine, matchInfo) {
+    const stepContext = new ExecutionContext({
+      task: `Auto-selected: ${skillName}`,
+      skill: skillName,
+      input,
+      parentId: context.id,
+      metadata: {
+        pattern: PatternType.AUTO,
+        confidence: matchInfo.confidence,
+        confidenceLevel: matchInfo.confidenceLevel,
+        matchedKeywords: matchInfo.matchedKeywords
+      }
+    });
+
+    context.children.push(stepContext);
+
+    try {
+      stepContext.start();
+      const output = await engine.executeSkill(skillName, input, context);
+      stepContext.complete(output);
+
+      engine.emit('autoPatternCompleted', {
+        context,
+        selectedSkill: skillName,
+        confidence: matchInfo.confidence,
+        output
+      });
+
+      return {
+        selectedSkill: skillName,
+        confidence: matchInfo.confidence,
+        confidenceLevel: matchInfo.confidenceLevel,
+        output,
+        multiMatch: false
+      };
+
+    } catch (error) {
+      stepContext.fail(error);
+      throw error;
+    }
+  }
+
+  /**
+   * Execute multiple matching skills
+   * @private
+   */
+  async _executeMultipleSkills(matches, input, context, engine) {
+    const results = [];
+
+    for (const match of matches) {
+      const stepContext = new ExecutionContext({
+        task: `Auto-selected (multi): ${match.skill}`,
+        skill: match.skill,
+        input,
+        parentId: context.id,
+        metadata: {
+          pattern: PatternType.AUTO,
+          confidence: match.confidence,
+          multiMatch: true
+        }
+      });
+
+      context.children.push(stepContext);
+
+      try {
+        stepContext.start();
+        const output = await engine.executeSkill(match.skill, input, context);
+        stepContext.complete(output);
+
+        results.push({
+          skill: match.skill,
+          confidence: match.confidence,
+          status: ExecutionStatus.COMPLETED,
+          output
+        });
+
+      } catch (error) {
+        stepContext.fail(error);
+        results.push({
+          skill: match.skill,
+          confidence: match.confidence,
+          status: ExecutionStatus.FAILED,
+          error: error.message
+        });
+      }
+    }
+
+    engine.emit('autoPatternCompleted', {
+      context,
+      results,
+      multiMatch: true
+    });
+
+    return {
+      selectedSkills: matches.map(m => m.skill),
+      results,
+      multiMatch: true
+    };
+  }
+}
+
+/**
+ * Create an auto pattern with custom options
+ * @param {object} options - Pattern options
+ * @returns {AutoPattern} Auto pattern instance
+ */
+function createAutoPattern(options = {}) {
+  return new AutoPattern(options);
+}
+
+module.exports = {
+  AutoPattern,
+  ConfidenceLevel,
+  createAutoPattern
+};