create-byan-agent 2.0.1 → 2.1.1

package/install/src/byan-v2/generation/profile-template.js

@@ -0,0 +1,113 @@
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+
+class ProfileTemplate {
+  static render(template, data) {
+    let result = template;
+    
+    const placeholders = this.extractPlaceholders(template);
+    
+    for (const placeholder of placeholders) {
+      const value = this.resolvePlaceholder(placeholder, data);
+      
+      if (value !== undefined && value !== null) {
+        const regex = new RegExp(`\\{\\{${placeholder.replace(/\./g, '\\.')}\\}\\}`, 'g');
+        result = result.replace(regex, value);
+      }
+    }
+    
+    return result;
+  }
+
+  static loadTemplate(templateName) {
+    const templatesDir = path.join(__dirname, 'templates');
+    const templatePath = path.join(templatesDir, `${templateName}.md`);
+    
+    if (!fs.existsSync(templatePath)) {
+      throw new Error(`Template not found: ${templateName}`);
+    }
+    
+    return fs.readFileSync(templatePath, 'utf-8');
+  }
+
+  static renderFromFile(templateName, data) {
+    const template = this.loadTemplate(templateName);
+    return this.render(template, data);
+  }
+
+  static validateTemplate(template, requiredPlaceholders = []) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: []
+    };
+
+    const frontmatterMatch = template.match(/^---\n([\s\S]*?)\n---/);
+    
+    if (!frontmatterMatch) {
+      result.valid = false;
+      result.errors.push('Missing YAML frontmatter');
+      return result;
+    }
+
+    try {
+      yaml.load(frontmatterMatch[1]);
+    } catch (e) {
+      result.valid = false;
+      result.errors.push(`Invalid YAML frontmatter: ${e.message}`);
+      return result;
+    }
+
+    const templatePlaceholders = this.extractPlaceholders(template);
+    
+    for (const required of requiredPlaceholders) {
+      if (!templatePlaceholders.includes(required)) {
+        result.warnings.push(`Missing required placeholder: ${required}`);
+      }
+    }
+
+    const xmlMatch = template.match(/```xml\n([\s\S]*?)\n```/);
+    if (xmlMatch) {
+      const xmlContent = xmlMatch[1];
+      const openTags = (xmlContent.match(/<(\w+)[^>]*>/g) || []).map(tag => tag.match(/<(\w+)/)[1]);
+      const closeTags = (xmlContent.match(/<\/(\w+)>/g) || []).map(tag => tag.match(/<\/(\w+)>/)[1]);
+      
+      if (openTags.length !== closeTags.length) {
+        result.warnings.push('Potentially malformed XML: tag count mismatch');
+      }
+    }
+
+    return result;
+  }
+
+  static extractPlaceholders(template) {
+    const regex = /\{\{([^}]+)\}\}/g;
+    const matches = [];
+    let match;
+    
+    while ((match = regex.exec(template)) !== null) {
+      if (!matches.includes(match[1])) {
+        matches.push(match[1]);
+      }
+    }
+    
+    return matches;
+  }
+
+  static resolvePlaceholder(path, data) {
+    const parts = path.split('.');
+    let current = data;
+    
+    for (const part of parts) {
+      if (current === undefined || current === null) {
+        return undefined;
+      }
+      current = current[part];
+    }
+    
+    return current;
+  }
+}
+
+module.exports = ProfileTemplate;

package/install/src/byan-v2/generation/templates/default-agent.md

@@ -0,0 +1,49 @@
+---
+name: "{{agent_name}}"
+description: "{{description}}"
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+```xml
+<agent id="{{agent_id}}" name="{{agent_name}}" title="{{title}}" icon="{{icon}}">
+<activation critical="MANDATORY">
+  <step n="1">Load persona from current file</step>
+  <step n="2">Load config from {project-root}/_bmad/{{module}}/config.yaml - store {user_name}, {communication_language}, {output_folder}</step>
+  <step n="3">Show greeting using {user_name} in {communication_language}</step>
+  <step n="4">Inform about `/bmad-help` command</step>
+  <step n="5">WAIT for user input</step>
+  <rules>
+    <r>Communicate in {communication_language}</r>
+    <r>Stay in character until EXIT</r>
+    <r>Apply Merise Agile + TDD + 64 mantras</r>
+  </rules>
+</activation>
+
+<persona>
+  <role>{{role}}</role>
+  <identity>{{identity}}</identity>
+  <communication_style>{{communication_style}}</communication_style>
+  
+  <principles>
+{{principles}}
+  </principles>
+</persona>
+
+<knowledge_base>
+{{knowledge_base}}
+</knowledge_base>
+
+<capabilities>
+{{capabilities}}
+</capabilities>
+
+<anti_patterns>
+{{anti_patterns}}
+</anti_patterns>
+
+<exit_protocol>
+  EXIT: Save state → Summarize → Next steps → File locations → Remind reactivation → Return control
+</exit_protocol>
+</agent>
+```

package/install/src/byan-v2/generation/templates/test-template.md

@@ -0,0 +1 @@
+Agent: {{agent_name}}, Role: {{role}}

package/install/src/byan-v2/index.js

@@ -0,0 +1,199 @@
+const SessionState = require('./context/session-state');
+const TaskRouter = require('./dispatcher/task-router');
+const StateMachine = require('./orchestrator/state-machine');
+const InterviewState = require('./orchestrator/interview-state');
+const AnalysisState = require('./orchestrator/analysis-state');
+const GenerationState = require('./orchestrator/generation-state');
+const Logger = require('./observability/logger');
+const MetricsCollector = require('./observability/metrics-collector');
+const crypto = require('crypto');
+
+class ByanV2 {
+  constructor(config = {}) {
+    this.config = this._loadConfig(config);
+    
+    if (config.sessionState) {
+      this.sessionState = config.sessionState;
+    } else {
+      const sessionId = this.config.sessionId || crypto.randomUUID();
+      this.sessionState = new SessionState(sessionId);
+    }
+    
+    if (config.logger) {
+      this.logger = config.logger;
+    } else {
+      this.logger = new Logger();
+    }
+    
+    this.metrics = new MetricsCollector();
+    this.dispatcher = new TaskRouter();
+    
+    const ErrorTracker = require('./observability/error-tracker');
+    this.errorTracker = new ErrorTracker();
+    
+    if (config.stateMachine) {
+      this.stateMachine = config.stateMachine;
+    } else {
+      this.stateMachine = new StateMachine({
+        logger: this.logger,
+        errorTracker: this.errorTracker
+      });
+      
+      this.interviewState = new InterviewState(this.sessionState);
+      this.analysisState = new AnalysisState(this.sessionState);
+      this.generationState = new GenerationState(this.sessionState);
+    }
+  }
+
+  _loadConfig(customConfig) {
+    const defaults = {
+      maxQuestions: 12,
+      complexityThresholds: {
+        low: 30,
+        medium: 60
+      },
+      outputDir: './_bmad-output/bmb-creations',
+      env: customConfig.env || (process.env.GITHUB_COPILOT ? 'copilot' : 'standalone')
+    };
+
+    return { ...defaults, ...customConfig };
+  }
+
+  isCopilotContext() {
+    return this.config.env === 'copilot' || process.env.GITHUB_COPILOT === 'true';
+  }
+
+  async startSession() {
+    this.logger.info('Starting BYAN session', {
+      event: 'session_start',
+      sessionId: this.sessionState.sessionId
+    });
+
+    this.metrics.increment('sessionsStarted');
+
+    await this.stateMachine.transition('INTERVIEW');
+
+    this.logger.info('State transition', {
+      event: 'state_transition',
+      from: 'INIT',
+      to: 'INTERVIEW'
+    });
+
+    return this.sessionState.sessionId;
+  }
+
+  async getNextQuestion() {
+    const currentState = this.stateMachine.getCurrentState();
+    
+    if (currentState.name !== 'INTERVIEW') {
+      throw new Error('Not in INTERVIEW state');
+    }
+
+    const question = this.interviewState.askNextQuestion();
+    
+    this.metrics.increment('questionsAsked');
+
+    return typeof question === 'string' ? question : question?.text || question;
+  }
+
+  async submitResponse(response) {
+    if (!response || response.trim().length === 0) {
+      this.metrics.increment('errors');
+      throw new Error('Response cannot be empty');
+    }
+
+    const sanitized = response.substring(0, 100);
+    this.logger.info('User response received', {
+      event: 'response_submitted',
+      response: sanitized
+    });
+
+    const currentState = this.stateMachine.getCurrentState();
+    
+    if (currentState.name === 'INTERVIEW') {
+      const isComplete = this.interviewState.processResponse(response);
+      
+      if (isComplete) {
+        await this.stateMachine.transition('ANALYSIS');
+        
+        this.logger.info('State transition', {
+          event: 'state_transition',
+          from: 'INTERVIEW',
+          to: 'ANALYSIS'
+        });
+      }
+    }
+
+    return { success: true };
+  }
+
+  async generateProfile() {
+    const currentState = this.stateMachine.getCurrentState();
+    
+    if (currentState.name === 'INTERVIEW') {
+      await this.stateMachine.transition('ANALYSIS');
+      await this.stateMachine.transition('GENERATION');
+    } else if (currentState.name === 'ANALYSIS') {
+      await this.stateMachine.transition('GENERATION');
+    } else if (currentState.name !== 'GENERATION') {
+      this.metrics.increment('errors');
+      throw new Error('Cannot generate profile in current state');
+    }
+
+    this.logger.info('Generating agent profile', {
+      event: 'profile_generation_start'
+    });
+
+    const profile = await this.generationState.generateProfile();
+
+    this.metrics.increment('profilesGenerated');
+
+    await this.stateMachine.transition('COMPLETED');
+
+    this.logger.info('Profile generation complete', {
+      event: 'profile_generation_complete'
+    });
+
+    return profile;
+  }
+
+  async endSession() {
+    const currentState = this.stateMachine.getCurrentState();
+    
+    if (currentState.name !== 'COMPLETED' && currentState.name !== 'ERROR') {
+      // Force transition through states if needed
+      if (currentState.name === 'INTERVIEW') {
+        await this.stateMachine.transition('ANALYSIS');
+        await this.stateMachine.transition('GENERATION');
+      } else if (currentState.name === 'ANALYSIS') {
+        await this.stateMachine.transition('GENERATION');
+      }
+      
+      if (this.stateMachine.getCurrentState().name === 'GENERATION') {
+        await this.stateMachine.transition('COMPLETED');
+      }
+    }
+
+    this.logger.info('Session ended', {
+      event: 'session_end',
+      sessionId: this.sessionState.sessionId
+    });
+
+    return { success: true };
+  }
+
+  getMetricsSummary() {
+    return this.metrics.getSummary();
+  }
+
+  async getSessionSummary() {
+    return {
+      sessionId: this.sessionState.sessionId,
+      questionsAsked: this.sessionState.userResponses.length,
+      state: this.stateMachine.getCurrentState().name,
+      timestamp: new Date().toISOString()
+    };
+  }
+}
+
+module.exports = ByanV2;

package/install/src/byan-v2/observability/error-tracker.js

@@ -0,0 +1,105 @@
+/**
+ * ErrorTracker - Track and store errors with context
+ * 
+ * Error Types:
+ * - ROUTING_ERROR: Errors during task routing
+ * - EXECUTION_ERROR: Errors during task execution
+ * - VALIDATION_ERROR: Errors during validation
+ * 
+ * Features:
+ * - Store up to maxErrors (default 100) in FIFO order
+ * - Track error type, message, stack, context, timestamp
+ * - Filter errors by type
+ * - Get error statistics
+ * 
+ * Methods:
+ * - trackError(errorData)
+ * - getErrors()
+ * - getErrorsByType(type)
+ * - getErrorStats()
+ * - clearErrors()
+ */
+
+class ErrorTracker {
+  constructor(options = {}) {
+    this.maxErrors = options.maxErrors || 100;
+    this.errors = [];
+  }
+
+  /**
+   * Track an error with full context
+   * @param {Object} errorData - Error data with type, message, error, context
+   */
+  trackError(errorData) {
+    if (!errorData) return;
+
+    const { type, message, error, context } = errorData;
+
+    // Build error entry
+    const errorEntry = {
+      type,
+      message: message || error?.message,
+      stack: error?.stack,
+      context,
+      timestamp: new Date().toISOString()
+    };
+
+    // Add to errors array
+    this.errors.push(errorEntry);
+
+    // Enforce max size (FIFO)
+    if (this.errors.length > this.maxErrors) {
+      this.errors.shift(); // Remove oldest
+    }
+  }
+
+  /**
+   * Get all tracked errors
+   * @returns {Array} Array of error objects
+   */
+  getErrors() {
+    // Return copy to prevent external modification
+    return [...this.errors];
+  }
+
+  /**
+   * Get errors filtered by type
+   * @param {string} type - Error type to filter by
+   * @returns {Array} Array of errors matching type
+   */
+  getErrorsByType(type) {
+    return this.errors.filter(error => error.type === type);
+  }
+
+  /**
+   * Get error statistics
+   * @returns {Object} Statistics with total and breakdown by type
+   */
+  getErrorStats() {
+    const stats = {
+      total: this.errors.length,
+      byType: {
+        ROUTING_ERROR: 0,
+        EXECUTION_ERROR: 0,
+        VALIDATION_ERROR: 0
+      }
+    };
+
+    this.errors.forEach(error => {
+      if (stats.byType[error.type] !== undefined) {
+        stats.byType[error.type]++;
+      }
+    });
+
+    return stats;
+  }
+
+  /**
+   * Clear all tracked errors
+   */
+  clearErrors() {
+    this.errors = [];
+  }
+}
+
+module.exports = ErrorTracker;

package/install/src/byan-v2/observability/logger.js

@@ -0,0 +1,154 @@
+/**
+ * Logger - Winston-based structured logging
+ * 
+ * Features:
+ * - JSON format logging
+ * - File + Console output
+ * - Methods: logTaskRouting(), logTaskExecution(), logError()
+ */
+
+const winston = require('winston');
+const fs = require('fs');
+const path = require('path');
+
+class Logger {
+  constructor(options = {}) {
+    const {
+      logDir = path.join(process.cwd(), 'logs'),
+      logFile = 'byan.log',
+      consoleOutput = true,
+      level = 'info'
+    } = options;
+
+    this.logDir = logDir;
+    this.logFile = logFile;
+    this.logPath = path.join(logDir, logFile);
+
+    // Ensure log directory exists
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    // Configure transports
+    const transports = [
+      new winston.transports.File({
+        filename: this.logPath,
+        format: winston.format.json()
+      })
+    ];
+
+    if (consoleOutput) {
+      transports.push(
+        new winston.transports.Console({
+          format: winston.format.combine(
+            winston.format.colorize(),
+            winston.format.simple()
+          )
+        })
+      );
+    }
+
+    // Create Winston logger
+    this.logger = winston.createLogger({
+      level,
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.json()
+      ),
+      transports
+    });
+  }
+
+  /**
+   * Log task routing decision
+   * @param {Object} routingData - Routing decision data
+   */
+  logTaskRouting(routingData) {
+    if (!routingData) return;
+
+    const { task, executor, complexity, canFallback, reasoning } = routingData;
+
+    this.logger.info('Task routing decision', {
+      taskType: task?.type,
+      prompt: task?.prompt,
+      metadata: task?.metadata,
+      executor,
+      complexity,
+      canFallback,
+      reasoning
+    });
+  }
+
+  /**
+   * Log task execution result
+   * @param {Object} executionData - Execution result data
+   */
+  logTaskExecution(executionData) {
+    if (!executionData) return;
+
+    const { task, executor, duration, success, result, error, tokens } = executionData;
+
+    this.logger.info('Task execution completed', {
+      taskType: task?.type,
+      prompt: task?.prompt,
+      executor,
+      duration,
+      success,
+      result,
+      error,
+      tokens
+    });
+  }
+
+  /**
+   * Log error with context
+   * @param {Object} errorData - Error data with type, message, error, context
+   */
+  logError(errorData) {
+    if (!errorData) return;
+
+    const { type, message, error, context } = errorData;
+
+    this.logger.error(message || 'Error occurred', {
+      errorType: type,
+      stack: error?.stack,
+      context
+    });
+  }
+
+  /**
+   * Generic info log
+   * @param {string} message - Log message
+   * @param {Object} data - Additional data
+   */
+  info(message, data = {}) {
+    this.logger.info(message, data);
+  }
+
+  /**
+   * Generic warn log
+   * @param {string} message - Log message
+   * @param {Object} data - Additional data
+   */
+  warn(message, data = {}) {
+    this.logger.warn(message, data);
+  }
+
+  /**
+   * Generic error log
+   * @param {string} message - Log message
+   * @param {Object} data - Additional data
+   */
+  error(message, data = {}) {
+    this.logger.error(message, data);
+  }
+
+  /**
+   * Close logger and flush transports
+   */
+  close() {
+    this.logger.close();
+  }
+}
+
+module.exports = Logger;