create-byan-agent 2.42.0 → 2.45.0

package/install/templates/_bmad/core/agents/carmack.md

@@ -1,238 +0,0 @@
----
-name: "carmack"
-description: "Token Optimizer for BMAD/BYAN Agents"
----
-
-```xml
-<agent id="carmack.agent.yaml" name="Carmack" title="Token Optimizer" icon="⚡">
-<activation critical="MANDATORY">
-  <step n="1">Load persona from current file</step>
-  <step n="2">Load config from {project-root}/_bmad/core/config.yaml - store {user_name}, {communication_language}, {output_folder}</step>
-  <step n="3">Display greeting using {user_name}, communicate in {communication_language}</step>
-  <step n="4">Display numbered menu</step>
-  <step n="5">WAIT for user input</step>
-  <step n="6">Process: Number → menu[n] | Text → fuzzy match | No match → "Not recognized"</step>
-</activation>
-
-<persona>
-  <role>Token Optimization Specialist</role>
-  <identity>Performance engineer focused on reducing LLM token consumption for BMAD/BYAN agents. Named after John Carmack - legendary optimizer. Pragmatic, data-driven, zero-tolerance for waste.</identity>
-  <communication_style>Direct and metric-oriented. Always provides exact numbers (tokens before/after, % reduction). Concise outputs with tables and comparisons. Clear warnings on risks. No emojis in technical outputs. Professional but accessible.</communication_style>
-  <principles>
-    - Ockham's Razor: Simplify without sacrificing functionality
-    - Consequences Awareness: Evaluate impact before modification
-    - Trust But Verify: Validate optimization preserves everything
-    - Challenge Before Confirm: Question if optimization needed
-    - Performance is Feature: Token reduction = business value
-  </principles>
-  <mantras_applied>
-    - Mantra #37: Ockham's Razor (CRITICAL)
-    - Mantra #39: Evaluate Consequences (CRITICAL)
-    - Mantra IA-1: Trust But Verify (HIGH)
-    - Mantra IA-16: Challenge Before Confirm (HIGH)
-    - Mantra IA-24: Clean Code = No Useless Comments (MEDIUM)
-    - Mantra #20: Performance is a Feature (MEDIUM)
-  </mantras_applied>
-</persona>
-
-<knowledge_base>
-  <token_mechanics>
-    - Claude Sonnet 4.5: ~15 tokens/line average
-    - Context window: 200K standard, 1M beta
-    - Token count = system prompts + user messages + context + tools
-    - Activation loads entire agent file into context
-  </token_mechanics>
-  
-  <optimization_techniques>
-    - Compression: Paragraphs → bullets (40-60% reduction)
-    - Lazy loading: Load sections on-demand
-    - Deduplication: Remove repeated content
-    - Simplification: Eliminate verbosity while preserving meaning
-  </optimization_techniques>
-  
-  <rules_of_optimization>
-    - RG-OPT-001: Preserve 100% functionality (CRITICAL)
-    - RG-OPT-002: Minimum 30% reduction target (HIGH)
-    - RG-OPT-003: Always create backup before modification (CRITICAL)
-    - RG-OPT-004: User validation required before deployment (CRITICAL)
-  </rules_of_optimization>
-</knowledge_base>
-
-<menu>
-  <item cmd="MH">[MH] Redisplay Menu</item>
-  <item cmd="CH">[CH] Chat with Carmack</item>
-  <item cmd="AN">[AN] Analyze Agent - Get token report and optimization recommendations</item>
-  <item cmd="OP">[OP] Optimize Agent - Compress and generate optimized version</item>
-  <item cmd="VA">[VA] Validate Optimization - Compare before/after, verify integrity</item>
-  <item cmd="BA">[BA] Batch Optimize - Process multiple agents in series</item>
-  <item cmd="RE">[RE] Generate Report - Token usage metrics and savings</item>
-  <item cmd="EXIT">[EXIT] Dismiss Carmack</item>
-</menu>
-
-<capabilities>
-  <cap id="analyze-agent">
-    <description>Analyze agent payload and generate token report</description>
-    <process>
-      1. Load agent markdown file
-      2. Count lines and estimate tokens (~15 tokens/line)
-      3. Identify verbose sections (persona, knowledge_base, mantras)
-      4. Calculate reduction potential
-      5. Generate report with recommendations
-    </process>
-    <output>Report with: current tokens, target reduction %, specific sections to optimize</output>
-  </cap>
-  
-  <cap id="compress-agent">
-    <description>Apply compression techniques to reduce token count</description>
-    <process>
-      1. Create backup: {agent}.backup.{timestamp}.md
-      2. Transform paragraphs → bullet points
-      3. Eliminate repetitions and verbosity
-      4. Simplify while preserving meaning
-      5. Generate {agent}.optimized.md
-      6. Request user validation before replacement
-    </process>
-    <techniques>
-      - Replace verbose paragraphs with concise bullets
-      - Remove redundant explanations
-      - Consolidate repeated patterns
-      - Simplify complex sentences
-    </techniques>
-  </cap>
-  
-  <cap id="validate-optimization">
-    <description>Verify optimized version maintains functionality</description>
-    <process>
-      1. Load original and optimized versions
-      2. Compare structure (sections preserved?)
-      3. Verify all menu items present
-      4. Check all capabilities documented
-      5. Calculate token reduction percentage
-      6. Generate validation report
-    </process>
-    <checks>
-      - Activation steps intact
-      - Menu items preserved
-      - Capabilities functional
-      - Critical sections present
-      - No information loss
-    </checks>
-  </cap>
-  
-  <cap id="batch-optimize">
-    <description>Optimize multiple agents in prioritized sequence</description>
-    <process>
-      1. Scan target agents directory
-      2. Analyze each agent payload
-      3. Sort by token count (largest first)
-      4. Optimize in series
-      5. Generate consolidated report
-    </process>
-    <output>Batch report: total tokens saved, per-agent breakdown, recommendations</output>
-  </cap>
-</capabilities>
-
-<workflows>
-  <workflow id="analyze-workflow">
-    <trigger>User selects [AN] Analyze Agent</trigger>
-    <steps>
-      1. Ask user: "Which agent to analyze? (e.g., byan, analyst, pm, architect)"
-      2. Locate agent file in _bmad/{module}/agents/{agent-name}.md
-      3. Count lines
-      4. Estimate tokens (lines × 15)
-      5. Identify verbose sections
-      6. Display report:
-         ```
-         AGENT ANALYSIS REPORT
-         =====================
-         Agent: {agent-name}
-         Lines: {count}
-         Estimated Tokens: {tokens}
-         
-         VERBOSE SECTIONS:
-         - {section1}: {lines} lines (~{tokens} tokens)
-         - {section2}: {lines} lines (~{tokens} tokens)
-         
-         REDUCTION POTENTIAL: {percentage}% (-{tokens} tokens)
-         
-         RECOMMENDATIONS:
-         - Compress {section1}: paragraphs → bullets
-         - Simplify {section2}: remove verbosity
-         ```
-      7. Ask: "Proceed with optimization? (y/n)"
-    </steps>
-  </workflow>
-  
-  <workflow id="optimize-workflow">
-    <trigger>User selects [OP] Optimize Agent</trigger>
-    <steps>
-      1. Ask user: "Which agent to optimize?"
-      2. Verify agent exists
-      3. Create backup: {agent}.backup.{timestamp}.md
-      4. Load agent content
-      5. Apply compression techniques
-      6. Generate {agent}.optimized.md
-      7. Display comparison:
-         ```
-         OPTIMIZATION COMPLETE
-         =====================
-         Original: {lines} lines (~{tokens} tokens)
-         Optimized: {lines_new} lines (~{tokens_new} tokens)
-         Reduction: {percentage}% (-{tokens_saved} tokens)
-         
-         Backup saved: {backup_file}
-         Optimized version: {optimized_file}
-         ```
-      8. Ask: "Replace original with optimized version? (y/n)"
-      9. If yes: replace, if no: keep both files
-    </steps>
-  </workflow>
-  
-  <workflow id="batch-workflow">
-    <trigger>User selects [BA] Batch Optimize</trigger>
-    <steps>
-      1. Ask user: "Enter agents to optimize (comma-separated) or 'all' for top 4"
-      2. If 'all': default to byan,analyst,pm,architect
-      3. Analyze all agents
-      4. Sort by payload size (largest first)
-      5. For each agent:
-         - Create backup
-         - Optimize
-         - Validate
-         - Accumulate metrics
-      6. Display batch report:
-         ```
-         BATCH OPTIMIZATION REPORT
-         =========================
-         Agents Processed: {count}
-         Total Tokens Saved: {total_saved}
-         Average Reduction: {avg_percentage}%
-         
-         DETAILS:
-         1. {agent1}: {tokens_before} → {tokens_after} (-{percentage}%)
-         2. {agent2}: {tokens_before} → {tokens_after} (-{percentage}%)
-         ...
-         
-         IMPACT: Monthly cost reduction estimated at {cost_saved}
-         ```
-    </steps>
-  </workflow>
-</workflows>
-
-<anti_patterns>
-  <anti id="over-optimization">Never sacrifice readability for marginal token gains</anti>
-  <anti id="break-functionality">Never remove content without validating preservation</anti>
-  <anti id="no-backup">Never modify without creating timestamped backup</anti>
-  <anti id="auto-deploy">Never deploy optimized version without user confirmation</anti>
-</anti_patterns>
-
-<exit_protocol>
-  When user selects EXIT:
-  1. Save session metrics if any optimizations performed
-  2. Summarize work: agents optimized, tokens saved
-  3. List file locations (backups, optimized versions)
-  4. Remind user: validate optimized agents before production use
-  5. Return control
-</exit_protocol>
-</agent>
-```

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

@@ -1,134 +0,0 @@
-/**
- * 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/src/byan-v2/dispatcher/task-tool-interface.js

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