create-byan-agent 2.0.1 → 2.1.0

package/src/byan-v2/dispatcher/complexity-scorer.js

@@ -0,0 +1,232 @@
+/**
+ * ComplexityScorer - Calculate task complexity score (0-100)
+ * 
+ * Scoring factors:
+ * - Factor 1: Token count (max 30 points)
+ * - Factor 2: Task type (max 80 points)
+ * - Factor 3: Context size (max 20 points)
+ * - Factor 4: Keywords (max 25 points)
+ * 
+ * Total score is capped at 100 points.
+ */
+
+class ComplexityScorer {
+  constructor() {
+    // Task type patterns with base scores
+    this.taskTypePatterns = {
+      exploration: {
+        keywords: ['explore', 'find', 'list', 'show', 'search', 'get', 'read', 'view', 'display', 'check'],
+        baseScore: 15
+      },
+      implementation: {
+        keywords: ['implement', 'create', 'build', 'write', 'develop', 'code', 'add', 'generate'],
+        baseScore: 45
+      },
+      analysis: {
+        keywords: ['analyze', 'design', 'architect', 'evaluate', 'review', 'assess', 'plan', 'strategy'],
+        baseScore: 75
+      }
+    };
+
+    // Keyword complexity weights
+    this.keywordWeights = {
+      simple: {
+        keywords: ['list', 'show', 'find', 'get', 'read', 'basic', 'simple'],
+        score: 7
+      },
+      medium: {
+        keywords: ['refactor', 'optimize', 'implement', 'integrate', 'update', 'modify'],
+        score: 17
+      },
+      critical: {
+        keywords: ['security', 'performance', 'architecture', 'scalability', 'critical', 'mission-critical'],
+        score: 25
+      }
+    };
+  }
+
+  /**
+   * Calculate overall complexity score for a task
+   * @param {Object} task - Task object with prompt and context
+   * @returns {number} - Complexity score (0-100)
+   */
+  calculateComplexity(task) {
+    if (!task || !task.prompt || task.prompt.trim() === '') {
+      throw new Error('prompt is required');
+    }
+
+    const tokenScore = this._calculateTokenScore(task.prompt);
+    const taskTypeScore = this._calculateTaskTypeScore(task);
+    const contextScore = this._calculateContextScore(task.context || {});
+    const keywordScore = this._calculateKeywordScore(task.prompt);
+
+    // Combine scores (token + type + context + keyword)
+    // Note: These can theoretically exceed 100, so we cap it
+    const totalScore = tokenScore + taskTypeScore + contextScore + keywordScore;
+
+    return Math.min(100, Math.max(0, totalScore));
+  }
+
+  /**
+   * Factor 1: Token count scoring (max 30 points)
+   * < 10 tokens: 0 points
+   * 10-200 tokens: scale linearly 0-30
+   * > 200 tokens: 30 points
+   */
+  _calculateTokenScore(prompt) {
+    const tokenCount = this._estimateTokenCount(prompt);
+
+    if (tokenCount < 10) return 0;
+    if (tokenCount >= 200) return 30;
+
+    // Linear scaling between 10 and 200 tokens
+    return Math.round((tokenCount - 10) / 190 * 30);
+  }
+
+  /**
+   * Estimate token count (simple word-based approximation)
+   */
+  _estimateTokenCount(text) {
+    return text.trim().split(/\s+/).length;
+  }
+
+  /**
+   * Factor 2: Task type scoring (max 80 points)
+   */
+  _calculateTaskTypeScore(task) {
+    const prompt = task.prompt.toLowerCase();
+    
+    // Check explicit type if provided
+    if (task.type) {
+      const typeMap = {
+        'exploration': 15,
+        'implementation': 45,
+        'analysis': 75
+      };
+      return typeMap[task.type] || 45;
+    }
+
+    // Infer type from keywords
+    for (const [typeName, typeData] of Object.entries(this.taskTypePatterns)) {
+      const hasKeyword = typeData.keywords.some(keyword => {
+        const regex = new RegExp(`\\b${keyword}\\b`, 'i');
+        return regex.test(prompt);
+      });
+
+      if (hasKeyword) {
+        return typeData.baseScore;
+      }
+    }
+
+    // Default to medium complexity if no pattern matches
+    return 45;
+  }
+
+  /**
+   * Factor 3: Context size scoring (max 20 points)
+   */
+  _calculateContextScore(context) {
+    if (!context || Object.keys(context).length === 0) {
+      return 0;
+    }
+
+    // Calculate context complexity based on:
+    // - Number of top-level keys
+    // - Depth of nesting
+    // - Total property count
+
+    const propertyCount = this._countProperties(context);
+    const nestingDepth = this._calculateNestingDepth(context);
+    const topLevelKeys = Object.keys(context).length;
+
+    // Scoring formula:
+    // - Small context (< 5 properties): 5-10 points
+    // - Medium context (5-15 properties): 10-15 points
+    // - Large context (> 15 properties): 15-20 points
+
+    let score = 0;
+
+    if (propertyCount < 5) {
+      score = 7;
+    } else if (propertyCount < 15) {
+      score = 12;
+    } else {
+      score = 17;
+    }
+
+    // Add bonus for deep nesting (max +3)
+    if (nestingDepth > 2) {
+      score += Math.min(3, nestingDepth - 2);
+    }
+
+    return Math.min(20, score);
+  }
+
+  /**
+   * Count total properties in an object (including nested)
+   */
+  _countProperties(obj, visited = new Set()) {
+    if (!obj || typeof obj !== 'object' || visited.has(obj)) {
+      return 0;
+    }
+
+    visited.add(obj);
+    let count = 0;
+
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        count++;
+        if (typeof obj[key] === 'object' && obj[key] !== null) {
+          count += this._countProperties(obj[key], visited);
+        }
+      }
+    }
+
+    return count;
+  }
+
+  /**
+   * Calculate maximum nesting depth of an object
+   */
+  _calculateNestingDepth(obj, visited = new Set()) {
+    if (!obj || typeof obj !== 'object' || visited.has(obj)) {
+      return 0;
+    }
+
+    visited.add(obj);
+    let maxDepth = 0;
+
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key) && typeof obj[key] === 'object' && obj[key] !== null) {
+        const depth = this._calculateNestingDepth(obj[key], visited);
+        maxDepth = Math.max(maxDepth, depth);
+      }
+    }
+
+    return maxDepth + 1;
+  }
+
+  /**
+   * Factor 4: Keyword scoring (max 25 points)
+   */
+  _calculateKeywordScore(prompt) {
+    const promptLower = prompt.toLowerCase();
+    let maxScore = 0;
+
+    // Check each keyword category (take highest matching score)
+    for (const [category, data] of Object.entries(this.keywordWeights)) {
+      const hasKeyword = data.keywords.some(keyword => {
+        const regex = new RegExp(`\\b${keyword}\\b`, 'i');
+        return regex.test(promptLower);
+      });
+
+      if (hasKeyword) {
+        maxScore = Math.max(maxScore, data.score);
+      }
+    }
+
+    return maxScore;
+  }
+}
+
+module.exports = ComplexityScorer;

package/src/byan-v2/dispatcher/five-whys-analyzer.js

@@ -0,0 +1,310 @@
+/**
+ * FiveWhysAnalyzer - Root cause analysis through 5 WHYs technique
+ * 
+ * MANTRAS: KISS, DRY, SOLID, Zero Emoji (IA-23)
+ * 
+ * Features:
+ * - Pain point detection in user responses
+ * - Sequential WHY questioning (1-5 depth)
+ * - Root cause extraction
+ * - Analysis export with metadata
+ */
+
+const Logger = require('../observability/logger');
+
+class FiveWhysAnalyzer {
+  constructor(sessionState, logger) {
+    this.sessionState = sessionState;
+    this.logger = logger || new Logger({ logDir: 'logs', logFile: 'five-whys.log' });
+    
+    this.depth = 0;
+    this.maxDepth = 5;
+    this.responses = [];
+    this.painPoints = [];
+    this.rootCause = null;
+    this.active = false;
+    
+    this.painKeywords = [
+      'problem', 'issue', 'challenge', 'difficult', 'slow', 'complex',
+      'error', 'fail', 'break', 'bug', 'struggle', 'hard', 'confusing',
+      'frustrating', 'annoying', 'painful', 'blocking', 'stuck'
+    ];
+  }
+
+  start(initialResponse) {
+    if (!initialResponse || typeof initialResponse !== 'string') {
+      return { needsWhys: false, reason: 'Invalid response' };
+    }
+
+    const detected = this._detectPainPoints(initialResponse);
+    
+    if (!detected.hasPainPoints) {
+      this.logger.info('No pain points detected', { response: initialResponse.substring(0, 100) });
+      return { needsWhys: false, reason: 'No pain points detected' };
+    }
+
+    this.active = true;
+    this.painPoints = detected.painPoints;
+    this.responses.push({
+      depth: 0,
+      question: 'initial',
+      answer: initialResponse,
+      painPoints: detected.painPoints
+    });
+
+    this.logger.info('5 Whys started', { painPoints: detected.painPoints });
+
+    return {
+      needsWhys: true,
+      painPoints: detected.painPoints,
+      firstQuestion: this.askNext()
+    };
+  }
+
+  _detectPainPoints(text) {
+    const lowerText = text.toLowerCase();
+    const foundPoints = [];
+
+    for (const keyword of this.painKeywords) {
+      if (lowerText.includes(keyword)) {
+        const index = lowerText.indexOf(keyword);
+        const context = text.substring(Math.max(0, index - 20), Math.min(text.length, index + 50));
+        foundPoints.push({ keyword, context: context.trim() });
+      }
+    }
+
+    return {
+      hasPainPoints: foundPoints.length > 0,
+      painPoints: foundPoints,
+      confidence: Math.min(1.0, foundPoints.length / 3)
+    };
+  }
+
+  askNext() {
+    if (!this.active) {
+      return null;
+    }
+
+    if (this.depth >= this.maxDepth) {
+      return null;
+    }
+
+    this.depth++;
+
+    const questions = [
+      'Why is this a problem for you?',
+      'Why does this happen?',
+      'Why is that the case?',
+      'Why does that matter?',
+      'What is the underlying reason?'
+    ];
+
+    const question = this.depth === 1 
+      ? 'Why is this a problem for you?'
+      : questions[Math.min(this.depth - 1, questions.length - 1)];
+
+    return {
+      depth: this.depth,
+      question,
+      prompt: `${question} (${this.depth}/5)`
+    };
+  }
+
+  processAnswer(answer) {
+    if (!this.active) {
+      return { valid: false, reason: 'Analyzer not active' };
+    }
+
+    if (!answer || typeof answer !== 'string' || answer.trim().length < 10) {
+      return { valid: false, reason: 'Answer too short or invalid' };
+    }
+
+    this.responses.push({
+      depth: this.depth,
+      question: `Why #${this.depth}`,
+      answer: answer.trim(),
+      timestamp: new Date().toISOString()
+    });
+
+    const rootCauseAnalysis = this._analyzeForRootCause(answer);
+    
+    if (rootCauseAnalysis.isRootCause && this.depth >= 3) {
+      this.rootCause = rootCauseAnalysis;
+      this.active = false;
+      this.logger.info('Root cause identified early', { 
+        depth: this.depth, 
+        rootCause: rootCauseAnalysis.statement 
+      });
+      
+      return {
+        valid: true,
+        rootCauseFound: true,
+        analysis: rootCauseAnalysis,
+        nextQuestion: null
+      };
+    }
+
+    if (this.depth >= this.maxDepth) {
+      this.rootCause = this._extractRootCause();
+      this.active = false;
+      this.logger.info('5 Whys completed', { 
+        depth: this.depth, 
+        rootCause: this.rootCause.statement 
+      });
+      
+      return {
+        valid: true,
+        completed: true,
+        rootCause: this.rootCause,
+        nextQuestion: null
+      };
+    }
+
+    return {
+      valid: true,
+      nextQuestion: this.askNext()
+    };
+  }
+
+  _analyzeForRootCause(answer) {
+    const lowerAnswer = answer.toLowerCase();
+    
+    const rootCauseIndicators = [
+      'because', 'fundamental', 'core', 'underlying', 'root',
+      'lack of', 'missing', 'no process', 'no system', 'unclear',
+      'not defined', 'never', 'always', 'since beginning'
+    ];
+
+    let indicatorCount = 0;
+    for (const indicator of rootCauseIndicators) {
+      if (lowerAnswer.includes(indicator)) {
+        indicatorCount++;
+      }
+    }
+
+    const isRootCause = indicatorCount >= 2 || (indicatorCount >= 1 && answer.length > 100);
+    const confidence = Math.min(1.0, (indicatorCount * 0.3) + (answer.length / 500));
+
+    return {
+      isRootCause,
+      confidence,
+      statement: answer.trim(),
+      depth: this.depth,
+      indicators: indicatorCount
+    };
+  }
+
+  _extractRootCause() {
+    if (this.responses.length < 2) {
+      return {
+        statement: 'Insufficient data for root cause analysis',
+        confidence: 0.0,
+        category: 'unknown',
+        actionItems: []
+      };
+    }
+
+    const lastResponses = this.responses.slice(-2);
+    const deepestAnswer = lastResponses[lastResponses.length - 1].answer;
+    
+    const category = this._categorizeRootCause(deepestAnswer);
+    const actionItems = this._extractActionItems(deepestAnswer);
+    const confidence = this._calculateConfidence(this.depth, deepestAnswer);
+
+    return {
+      statement: deepestAnswer,
+      confidence,
+      category,
+      actionItems,
+      depth: this.depth
+    };
+  }
+
+  _categorizeRootCause(statement) {
+    const lowerStatement = statement.toLowerCase();
+    
+    const categories = {
+      technical: ['code', 'system', 'software', 'hardware', 'infrastructure', 'api', 'database'],
+      process: ['process', 'workflow', 'procedure', 'method', 'approach', 'way we'],
+      resource: ['time', 'money', 'budget', 'people', 'team', 'resource', 'capacity'],
+      knowledge: ['know', 'understand', 'learn', 'training', 'documentation', 'experience', 'skill']
+    };
+
+    for (const [category, keywords] of Object.entries(categories)) {
+      for (const keyword of keywords) {
+        if (lowerStatement.includes(keyword)) {
+          return category;
+        }
+      }
+    }
+
+    return 'general';
+  }
+
+  _extractActionItems(statement) {
+    const actionKeywords = [
+      'need to', 'should', 'must', 'have to', 'require',
+      'implement', 'create', 'build', 'fix', 'improve'
+    ];
+
+    const sentences = statement.split(/[.!?]+/).filter(s => s.trim().length > 0);
+    const actions = [];
+
+    for (const sentence of sentences) {
+      const lowerSentence = sentence.toLowerCase();
+      for (const keyword of actionKeywords) {
+        if (lowerSentence.includes(keyword)) {
+          actions.push(sentence.trim());
+          break;
+        }
+      }
+    }
+
+    return actions.slice(0, 3);
+  }
+
+  _calculateConfidence(depth, statement) {
+    let confidence = 0.5;
+    
+    confidence += (depth / this.maxDepth) * 0.3;
+    
+    if (statement.length > 50) confidence += 0.1;
+    if (statement.length > 100) confidence += 0.1;
+    
+    return Math.min(1.0, confidence);
+  }
+
+  isComplete() {
+    return !this.active;
+  }
+
+  getRootCause() {
+    return this.rootCause;
+  }
+
+  getDepth() {
+    return this.depth;
+  }
+
+  getResponses() {
+    return [...this.responses];
+  }
+
+  export() {
+    return {
+      version: '1.0.0',
+      createdAt: new Date().toISOString(),
+      painPoints: this.painPoints,
+      depth: this.depth,
+      responses: this.responses,
+      rootCause: this.rootCause,
+      metadata: {
+        completed: this.isComplete(),
+        maxDepth: this.maxDepth,
+        responseCount: this.responses.length
+      }
+    };
+  }
+}
+
+module.exports = FiveWhysAnalyzer;