create-byan-agent 2.7.4 → 2.7.7

package/install/src/byan-v2/context/copilot-context.js

@@ -0,0 +1,79 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function getCopilotContext() {
+  const context = {
+    projectRoot: getProjectRoot(),
+    userName: getUserName(),
+    workingDir: getWorkingDir(),
+    gitBranch: getGitBranch()
+  };
+
+  return context;
+}
+
+function getProjectRoot() {
+  if (process.env.GITHUB_WORKSPACE) {
+    return process.env.GITHUB_WORKSPACE;
+  }
+  
+  if (process.env.PWD) {
+    return process.env.PWD;
+  }
+  
+  return process.cwd();
+}
+
+function getUserName() {
+  if (process.env.COPILOT_USER_NAME) {
+    return process.env.COPILOT_USER_NAME;
+  }
+
+  const projectRoot = getProjectRoot();
+  const configPath = path.join(projectRoot, '.github', 'copilot', 'config.yaml');
+  
+  if (fs.existsSync(configPath)) {
+    try {
+      const configContent = fs.readFileSync(configPath, 'utf8');
+      const userNameMatch = configContent.match(/user_name:\s*(.+)/);
+      if (userNameMatch && userNameMatch[1]) {
+        return userNameMatch[1].trim();
+      }
+    } catch (error) {
+      // Fallback to next option
+    }
+  }
+
+  if (process.env.USER) {
+    return process.env.USER;
+  }
+
+  try {
+    return os.userInfo().username;
+  } catch (error) {
+    return 'unknown';
+  }
+}
+
+function getWorkingDir() {
+  if (process.env.PWD) {
+    return process.env.PWD;
+  }
+  
+  return process.cwd();
+}
+
+function getGitBranch() {
+  if (process.env.GITHUB_REF_NAME) {
+    return process.env.GITHUB_REF_NAME;
+  }
+  
+  if (process.env.GIT_BRANCH) {
+    return process.env.GIT_BRANCH;
+  }
+  
+  return '';
+}
+
+module.exports = getCopilotContext;

package/install/src/byan-v2/context/session-state.js

@@ -0,0 +1,98 @@
+const crypto = require('crypto');
+
+class SessionState {
+  constructor() {
+    this.sessionId = crypto.randomUUID();
+    this.currentState = 'INTERVIEW';
+    this.questionHistory = [];
+    this.userResponses = [];
+    this.analysisResults = {};
+    this.agentProfileDraft = {};
+    this.context = {};
+  }
+
+  addQuestion(question) {
+    this.questionHistory.push({
+      question,
+      timestamp: Date.now()
+    });
+  }
+
+  addResponse(questionId, response) {
+    this.userResponses.push({
+      questionId,
+      response,
+      timestamp: Date.now()
+    });
+  }
+
+  setAnalysisResults(data) {
+    this.analysisResults = data;
+  }
+
+  getCurrentState() {
+    return this.currentState;
+  }
+
+  mergeContext(copilotContext) {
+    this.context = copilotContext;
+  }
+
+  transitionTo(newState) {
+    const validStates = ['INTERVIEW', 'ANALYSIS', 'GENERATION'];
+    
+    if (!validStates.includes(newState)) {
+      throw new Error(`Invalid state: ${newState}`);
+    }
+
+    const validTransitions = {
+      'INTERVIEW': ['ANALYSIS'],
+      'ANALYSIS': ['GENERATION'],
+      'GENERATION': []
+    };
+
+    if (!validTransitions[this.currentState].includes(newState)) {
+      throw new Error(`Invalid state transition from ${this.currentState} to ${newState}`);
+    }
+
+    if (this.currentState === 'INTERVIEW' && newState === 'ANALYSIS') {
+      if (this.userResponses.length < 5) {
+        throw new Error('Cannot transition from INTERVIEW to ANALYSIS: requires at least 5 responses');
+      }
+    }
+
+    if (this.currentState === 'ANALYSIS' && newState === 'GENERATION') {
+      if (!this.analysisResults || Object.keys(this.analysisResults).length === 0) {
+        throw new Error('Cannot transition from ANALYSIS to GENERATION: analysisResults cannot be empty');
+      }
+    }
+
+    this.currentState = newState;
+  }
+
+  toJSON() {
+    return {
+      sessionId: this.sessionId,
+      currentState: this.currentState,
+      questionHistory: this.questionHistory,
+      userResponses: this.userResponses,
+      analysisResults: this.analysisResults,
+      agentProfileDraft: this.agentProfileDraft,
+      context: this.context
+    };
+  }
+
+  static fromJSON(data) {
+    const state = new SessionState();
+    state.sessionId = data.sessionId;
+    state.currentState = data.currentState;
+    state.questionHistory = data.questionHistory || [];
+    state.userResponses = data.userResponses || [];
+    state.analysisResults = data.analysisResults || {};
+    state.agentProfileDraft = data.agentProfileDraft || {};
+    state.context = data.context || {};
+    return state;
+  }
+}
+
+module.exports = SessionState;

package/install/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/install/src/byan-v2/dispatcher/local-executor.js

@@ -0,0 +1,221 @@
+/**
+ * LocalExecutor - Story 3.1
+ * Handles high-complexity tasks (>60) locally without delegation
+ * 
+ * Integrates:
+ * - Logger: Log execution start/completion
+ * - MetricsCollector: Track execution metrics
+ * - ErrorTracker: Track errors
+ */
+
+const Logger = require('../observability/logger');
+const ErrorTracker = require('../observability/error-tracker');
+const MetricsCollector = require('../observability/metrics-collector');
+
+class LocalExecutor {
+  constructor() {
+    this.logger = new Logger();
+    this.errorTracker = new ErrorTracker();
+    this.metricsCollector = new MetricsCollector();
+  }
+
+  /**
+   * AC2: Execute task locally without delegation
+   * AC3: Returns { output, tokens, duration, executor: 'local' }
+   * 
+   * @param {Object} task - Task object { type, prompt, complexity, metadata? }
+   * @returns {Promise<Object>} Execution result
+   */
+  async execute(task) {
+    const startTime = Date.now();
+
+    try {
+      // AC6: Validate task
+      if (!task || typeof task !== 'object') {
+        const error = new Error('Task must be a valid object');
+        this.errorTracker.track({
+          error,
+          component: 'LocalExecutor',
+          operation: 'execute',
+          task
+        });
+        throw error;
+      }
+
+      // AC5: Log execution start
+      this.logger.info('Local execution started', {
+        type: task.type,
+        complexity: task.complexity,
+        promptLength: task.prompt?.length || 0
+      });
+
+      // AC2: Process task locally (no delegation)
+      const output = await this._processTaskLocally(task);
+
+      // Calculate metrics
+      const duration = Date.now() - startTime;
+      const tokens = this._estimateTokens(task.prompt, output);
+
+      // AC3: Build result object
+      const result = {
+        output,
+        tokens,
+        duration,
+        executor: 'local'
+      };
+
+      // AC4: Record metrics
+      this.metricsCollector.recordTaskExecution({
+        executor: 'local',
+        duration,
+        tokens,
+        success: true,
+        taskType: task.type,
+        complexity: task.complexity
+      });
+
+      // AC5: Log completion
+      this.logger.info('Local execution completed', {
+        duration,
+        tokens,
+        outputLength: output.length
+      });
+
+      return result;
+
+    } catch (error) {
+      const duration = Date.now() - startTime;
+
+      // AC6: Track error
+      this.errorTracker.track({
+        error,
+        component: 'LocalExecutor',
+        operation: 'execute',
+        task,
+        duration
+      });
+
+      // Record failed execution
+      this.metricsCollector.recordTaskExecution({
+        executor: 'local',
+        duration,
+        tokens: 0,
+        success: false,
+        error: error.message
+      });
+
+      throw error;
+    }
+  }
+
+  /**
+   * Process task using BYAN's expertise
+   * Simulates local processing for analysis/generation tasks
+   * @private
+   */
+  async _processTaskLocally(task) {
+    const { type, prompt, metadata = {} } = task;
+
+    // Simulate processing based on task type
+    switch (type) {
+      case 'analysis':
+        return this._processAnalysisTask(prompt, metadata);
+      
+      case 'generation':
+        return this._processGenerationTask(prompt, metadata);
+      
+      case 'task':
+      case 'general-purpose':
+        return this._processGeneralTask(prompt, metadata);
+      
+      default:
+        return this._processGenericTask(prompt, metadata);
+    }
+  }
+
+  /**
+   * Process analysis tasks (extract requirements, patterns)
+   * @private
+   */
+  _processAnalysisTask(prompt, metadata) {
+    // Simulated analysis output
+    const analysis = {
+      type: 'analysis',
+      input: prompt,
+      findings: [
+        'Identified key requirements from prompt',
+        'Detected patterns and themes',
+        'Extracted structured information'
+      ],
+      context: metadata.context || {},
+      timestamp: new Date().toISOString()
+    };
+
+    return JSON.stringify(analysis, null, 2);
+  }
+
+  /**
+   * Process generation tasks (create agent profiles, content)
+   * @private
+   */
+  _processGenerationTask(prompt, metadata) {
+    // Simulated generation output
+    const generation = {
+      type: 'generation',
+      prompt,
+      generated: 'Generated content based on requirements',
+      metadata: metadata,
+      timestamp: new Date().toISOString()
+    };
+
+    return JSON.stringify(generation, null, 2);
+  }
+
+  /**
+   * Process general/task type tasks
+   * @private
+   */
+  _processGeneralTask(prompt, metadata) {
+    const result = {
+      type: 'general',
+      input: prompt,
+      output: 'Processed task locally with full BYAN expertise',
+      metadata,
+      timestamp: new Date().toISOString()
+    };
+
+    return JSON.stringify(result, null, 2);
+  }
+
+  /**
+   * Process generic tasks (fallback)
+   * @private
+   */
+  _processGenericTask(prompt, metadata) {
+    const result = {
+      type: 'generic',
+      input: prompt || '',
+      output: 'Processed with local executor',
+      metadata,
+      timestamp: new Date().toISOString()
+    };
+
+    return JSON.stringify(result, null, 2);
+  }
+
+  /**
+   * Estimate token count from input/output
+   * Simple heuristic: ~1.3 tokens per word
+   * @private
+   */
+  _estimateTokens(prompt = '', output = '') {
+    const promptWords = prompt.split(/\s+/).filter(w => w.length > 0).length;
+    const outputWords = output.split(/\s+/).filter(w => w.length > 0).length;
+    
+    // Rough token estimation
+    const totalWords = promptWords + outputWords;
+    return Math.ceil(totalWords * 1.3);
+  }
+}
+
+module.exports = LocalExecutor;