create-byan-agent 2.7.6 → 2.7.7

package/install/src/byan-v2/dispatcher/task-tool-interface-mock.js

@@ -0,0 +1,134 @@
+/**
+ * MockTaskToolInterface - Test double for TaskToolInterface
+ * 
+ * Simulates GitHub Copilot Task Tool behavior for testing:
+ * - Predefined responses
+ * - Configurable delays
+ * - Call history tracking
+ * - Error simulation
+ */
+
+const VALID_AGENT_TYPES = ['task', 'explore', 'general-purpose'];
+
+class MockTaskToolInterface {
+  constructor(options = {}) {
+    this.delay = options.delay !== undefined ? options.delay : this._randomDelay();
+    this.responses = options.responses || {};
+    this.behavior = options.behavior || null;
+    this.callHistory = [];
+    this.maxRetries = options.maxRetries !== undefined ? options.maxRetries : 1;
+  }
+
+  /**
+   * Mock delegateTask - simulates Task Tool call
+   */
+  async delegateTask(taskPrompt, agentType) {
+    // Validation (same as real implementation)
+    if (!taskPrompt || taskPrompt.trim() === '') {
+      throw new Error('taskPrompt cannot be empty');
+    }
+
+    if (!agentType) {
+      throw new Error('agentType is required');
+    }
+
+    if (!VALID_AGENT_TYPES.includes(agentType)) {
+      throw new Error(`Invalid agent type: ${agentType}. Valid types: ${VALID_AGENT_TYPES.join(', ')}`);
+    }
+
+    // Record call
+    const call = {
+      prompt: taskPrompt,
+      agentType: agentType,
+      timestamp: Date.now()
+    };
+    this.callHistory.push(call);
+
+    // Simulate delay
+    await this._sleep(this.delay);
+
+    // Use custom behavior if provided (with retry logic for transient errors)
+    if (this.behavior) {
+      const TRANSIENT_ERRORS = ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED'];
+      let lastError;
+      
+      for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+        try {
+          return this.behavior(taskPrompt, agentType);
+        } catch (error) {
+          lastError = error;
+          
+          // Only retry on transient errors and if we have retries left
+          const isTransient = TRANSIENT_ERRORS.some(errCode => error.message.includes(errCode));
+          if (isTransient && attempt < this.maxRetries) {
+            await this._sleep(this.delay);
+            continue;
+          }
+          
+          // Non-transient error or out of retries - throw immediately
+          break;
+        }
+      }
+      
+      throw lastError;
+    }
+
+    // Check for predefined response
+    if (this.responses[taskPrompt]) {
+      return this.responses[taskPrompt];
+    }
+
+    // Generate default response
+    return this._generateDefaultResponse(taskPrompt, agentType);
+  }
+
+  /**
+   * Generate realistic mock response
+   */
+  _generateDefaultResponse(taskPrompt, agentType) {
+    const outputMap = {
+      'task': `Task completed: ${taskPrompt}`,
+      'explore': `Exploration results for: ${taskPrompt}`,
+      'general-purpose': `General analysis: ${taskPrompt}`
+    };
+
+    return {
+      output: outputMap[agentType] || `Response for: ${taskPrompt}`,
+      metadata: {
+        tokens: Math.floor(Math.random() * 1000) + 100,
+        duration: Math.floor(Math.random() * 2000) + 500,
+        agentType: agentType
+      }
+    };
+  }
+
+  /**
+   * Random delay between 100-500ms
+   */
+  _randomDelay() {
+    return Math.floor(Math.random() * 400) + 100;
+  }
+
+  /**
+   * Sleep utility
+   */
+  _sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Get call history
+   */
+  getCallHistory() {
+    return [...this.callHistory];
+  }
+
+  /**
+   * Clear call history
+   */
+  clearHistory() {
+    this.callHistory = [];
+  }
+}
+
+module.exports = MockTaskToolInterface;

package/install/src/byan-v2/dispatcher/task-tool-interface.js

@@ -0,0 +1,123 @@
+/**
+ * TaskToolInterface - Interface to GitHub Copilot CLI Task Tool
+ * 
+ * IMPORTANT: GitHub Copilot CLI does NOT expose a programmatic API for Task Tool.
+ * This is a conceptual interface for BYAN v2.0 architecture design.
+ * 
+ * In production, this would:
+ * 1. Use future Copilot SDK when available
+ * 2. Or shell out to `gh copilot` CLI commands
+ * 3. Or use inter-process communication with Copilot CLI
+ * 
+ * For MVP, this is a stub with comprehensive tests using MockTaskToolInterface.
+ */
+
+const VALID_AGENT_TYPES = ['task', 'explore', 'general-purpose'];
+const DEFAULT_TIMEOUT = 30000; // 30 seconds
+const TRANSIENT_ERRORS = ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED'];
+
+class TaskToolInterface {
+  constructor(options = {}) {
+    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+    this.maxRetries = options.maxRetries || 1;
+  }
+
+  /**
+   * Delegate task to GitHub Copilot agent via Task Tool
+   * 
+   * @param {string} taskPrompt - The task description for the agent
+   * @param {string} agentType - Agent type: 'task', 'explore', or 'general-purpose'
+   * @returns {Promise<{output: string, metadata: {tokens: number, duration: number}}>}
+   */
+  async delegateTask(taskPrompt, agentType) {
+    // Validation
+    if (!taskPrompt || taskPrompt.trim() === '') {
+      throw new Error('taskPrompt cannot be empty');
+    }
+
+    if (!agentType) {
+      throw new Error('agentType is required');
+    }
+
+    if (!VALID_AGENT_TYPES.includes(agentType)) {
+      throw new Error(`Invalid agent type: ${agentType}. Valid types: ${VALID_AGENT_TYPES.join(', ')}`);
+    }
+
+    // Attempt execution with retry logic
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        return await this._executeTaskWithTimeout(taskPrompt, agentType);
+      } catch (error) {
+        lastError = error;
+        
+        // Only retry on transient errors and if we have retries left
+        const isTransient = TRANSIENT_ERRORS.some(errCode => error.message.includes(errCode));
+        if (isTransient && attempt < this.maxRetries) {
+          continue;
+        }
+        
+        // Non-transient error or out of retries - throw immediately
+        break;
+      }
+    }
+
+    throw lastError;
+  }
+
+  async _executeTaskWithTimeout(taskPrompt, agentType) {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error(`Task execution timeout after ${this.timeout}ms`));
+      }, this.timeout);
+
+      // TODO: Actual implementation would call Copilot Task Tool here
+      // For now, this is a stub that throws to force use of Mock in tests
+      clearTimeout(timeoutId);
+      reject(new Error('TaskToolInterface is a stub. Use MockTaskToolInterface for testing.'));
+    });
+  }
+
+  /**
+   * Build the call syntax for Task Tool (documentation)
+   * Format: Uses GitHub Copilot CLI agent invocation syntax
+   * 
+   * @param {string} prompt - Task prompt
+   * @param {string} agentType - Agent type
+   * @returns {string} - Call syntax string
+   */
+  static buildTaskCallSyntax(prompt, agentType) {
+    // Escape and sanitize prompt
+    const sanitizedPrompt = prompt
+      .replace(/\n/g, ' ')
+      .replace(/"/g, '\\"');
+
+    // Documented syntax format (conceptual - actual CLI syntax may vary)
+    return `@${agentType} "${sanitizedPrompt}"`;
+  }
+
+  /**
+   * Get documentation for Task Tool call syntax
+   * @returns {string} - Documentation
+   */
+  static getCallSyntaxDocumentation() {
+    return `
+GitHub Copilot CLI Task Tool Syntax (Conceptual):
+
+@<agent_type> "<prompt>"
+
+Where:
+- agent_type: 'task' | 'explore' | 'general-purpose'
+- prompt: Natural language task description
+
+Examples:
+- @task "Run all unit tests and report results"
+- @explore "Find all API endpoint definitions"
+- @general-purpose "Refactor authentication logic"
+
+Note: Actual implementation depends on Copilot CLI SDK availability.
+    `.trim();
+  }
+}
+
+module.exports = TaskToolInterface;

package/install/src/byan-v2/generation/agent-profile-validator.js

@@ -0,0 +1,113 @@
+const yaml = require('js-yaml');
+
+class AgentProfileValidator {
+  validate(profileContent) {
+    const result = {
+      valid: true,
+      errors: [],
+      warnings: []
+    };
+
+    if (!this.checkFileSize(profileContent)) {
+      result.valid = false;
+      result.errors.push('Profile exceeds 50KB size limit');
+      return result;
+    }
+
+    const frontmatterResult = this.validateYamlFrontmatter(profileContent);
+    if (!frontmatterResult.valid) {
+      result.valid = false;
+      result.errors.push(...frontmatterResult.errors);
+      return result;
+    }
+
+    const { data } = frontmatterResult;
+
+    if (!data.name) {
+      result.valid = false;
+      result.errors.push('Missing required field: name');
+    } else if (!this.validateNameFormat(data.name)) {
+      result.valid = false;
+      result.errors.push('Invalid name format (use lowercase, alphanumeric, hyphens only)');
+    }
+
+    if (!data.description) {
+      result.valid = false;
+      result.errors.push('Missing required field: description');
+    } else if (!this.validateDescriptionLength(data.description)) {
+      result.valid = false;
+      result.errors.push('Description must be 10-200 characters');
+    }
+
+    if (this.detectEmojis(profileContent)) {
+      result.warnings.push('Emoji detected (Mantra IA-23: Zero Emoji Pollution)');
+    }
+
+    if (!this.hasCapabilitiesSection(profileContent)) {
+      result.warnings.push('No capabilities section found');
+    }
+
+    return result;
+  }
+
+  validateYamlFrontmatter(content) {
+    const result = {
+      valid: true,
+      errors: [],
+      data: null
+    };
+
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    
+    if (!match) {
+      result.valid = false;
+      result.errors.push('Missing YAML frontmatter');
+      return result;
+    }
+
+    try {
+      result.data = yaml.load(match[1]);
+    } catch (e) {
+      result.valid = false;
+      result.errors.push(`Invalid YAML: ${e.message}`);
+    }
+
+    return result;
+  }
+
+  validateNameFormat(name) {
+    if (!name || name.length === 0) {
+      return false;
+    }
+
+    const validNameRegex = /^[a-z0-9-]+$/;
+    return validNameRegex.test(name);
+  }
+
+  validateDescriptionLength(description) {
+    if (!description) {
+      return false;
+    }
+
+    const len = description.length;
+    return len >= 10 && len <= 200;
+  }
+
+  detectEmojis(text) {
+    const emojiRegex = /[\u{1F300}-\u{1F9FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]/u;
+    return emojiRegex.test(text);
+  }
+
+  checkFileSize(content) {
+    const sizeInBytes = Buffer.byteLength(content, 'utf-8');
+    const maxSize = 50 * 1024;
+    return sizeInBytes <= maxSize;
+  }
+
+  hasCapabilitiesSection(content) {
+    const capabilitiesRegex = /^#{1,3}\s+(Capabilit(y|ies))/mi;
+    return capabilitiesRegex.test(content);
+  }
+}
+
+module.exports = AgentProfileValidator;

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}/_byan/{{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}}