create-byan-agent 2.6.2 → 2.7.0

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

@@ -1,79 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,232 +0,0 @@
-/**
- * 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

@@ -1,221 +0,0 @@
-/**
- * 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;