create-byan-agent 2.0.1 → 2.1.0

package/install/lib/yanstaller/wizard.js

@@ -0,0 +1,109 @@
+/**
+ * WIZARD Module
+ * 
+ * Post-installation wizard with 3 options: Create agent / Test / Exit.
+ * 
+ * Phase 7: 16h development
+ * 
+ * @module yanstaller/wizard
+ */
+
+const inquirer = require('inquirer');
+const logger = require('../utils/logger');
+
+/**
+ * Show post-install wizard
+ * 
+ * @param {import('./installer').InstallConfig} config - Installation config
+ * @returns {Promise<void>}
+ */
+async function show(config) {
+  logger.success('\n✅ BYAN installed successfully!\n');
+  
+  const choices = [
+    { name: '🎨 Create your first agent (BYAN interview)', value: 'create' },
+    { name: '🧪 Test an installed agent', value: 'test' },
+    { name: '🚪 Exit (start using BYAN)', value: 'exit' }
+  ];
+  
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do next?',
+      choices
+    }
+  ]);
+  
+  switch (answer.action) {
+    case 'create':
+      await launchByanInterview();
+      break;
+    case 'test':
+      await testAgent(config);
+      break;
+    case 'exit':
+      showExitMessage(config);
+      break;
+  }
+}
+
+/**
+ * Launch BYAN intelligent interview
+ * 
+ * @returns {Promise<void>}
+ */
+async function launchByanInterview() {
+  logger.info('\nLaunching BYAN intelligent interview...');
+  // TODO: Exec `@bmad-agent-byan` or similar
+  logger.info('To create an agent, run: @bmad-agent-byan');
+}
+
+/**
+ * Test installed agent
+ * 
+ * @param {import('./installer').InstallConfig} config - Installation config
+ * @returns {Promise<void>}
+ */
+async function testAgent(config) {
+  const agentChoices = config.agents.map(name => ({
+    name: `@bmad-agent-${name}`,
+    value: name
+  }));
+  
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'agent',
+      message: 'Which agent would you like to test?',
+      choices: agentChoices
+    }
+  ]);
+  
+  logger.info(`\nTo activate ${answer.agent}, run: @bmad-agent-${answer.agent}`);
+}
+
+/**
+ * Show exit message with next steps
+ * 
+ * @param {import('./installer').InstallConfig} config - Installation config
+ */
+function showExitMessage(config) {
+  logger.info('\n🎉 You\'re all set! Here\'s how to get started:\n');
+  logger.info('1. Activate an agent:');
+  logger.info('   @bmad-agent-byan    (Create new agents)');
+  logger.info('   @bmad-agent-bmm-pm  (Project management)');
+  logger.info('   @bmad-agent-bmm-dev (Development)\n');
+  logger.info('2. Get help anytime:');
+  logger.info('   /bmad-help\n');
+  logger.info('3. Documentation:');
+  logger.info('   Check _bmad/README.md\n');
+  logger.info('Happy building! 🚀\n');
+}
+
+module.exports = {
+  show,
+  launchByanInterview,
+  testAgent,
+  showExitMessage
+};

package/install/package-npm.json

@@ -0,0 +1,55 @@
+{
+  "name": "@yan/create-byan-agent",
+  "version": "1.0.0",
+  "description": "NPX installer for BYAN - Builder of YAN agent creator. Generates specialized AI agents using Merise Agile + TDD methodology with 64 mantras.",
+  "main": "bin/create-byan-agent.js",
+  "bin": {
+    "create-byan-agent": "./bin/create-byan-agent.js"
+  },
+  "scripts": {
+    "start": "node bin/create-byan-agent.js",
+    "test": "echo \"Tests coming soon\" && exit 0"
+  },
+  "keywords": [
+    "byan",
+    "agent",
+    "creator",
+    "ai",
+    "bmad",
+    "merise",
+    "tdd",
+    "copilot",
+    "vscode",
+    "claude",
+    "codex",
+    "zero-trust",
+    "mantras",
+    "agent-builder"
+  ],
+  "author": "Yan <yan@example.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yan/byan.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yan/byan/issues"
+  },
+  "homepage": "https://github.com/yan/byan#readme",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "inquirer": "^8.2.5",
+    "fs-extra": "^11.2.0",
+    "js-yaml": "^4.1.0",
+    "ora": "^5.4.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/install/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "create-byan-agent",
+  "version": "2.0.2",
+  "description": "Create custom AI agents in 15 minutes through intelligent interviews. GitHub Copilot CLI, VSCode, Claude Code compatible. 64 quality mantras applied automatically.",
+  "bin": {
+    "create-byan-agent": "bin/create-byan-agent-v2.js"
+  },
+  "scripts": {
+    "start": "node bin/create-byan-agent-v2.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "keywords": [
+    "ai-agent",
+    "agent-creator",
+    "intelligent-interview",
+    "github-copilot",
+    "copilot-cli",
+    "vscode-extension",
+    "claude-code",
+    "code-generation",
+    "developer-tools",
+    "automation",
+    "merise-agile",
+    "tdd",
+    "quality-mantras",
+    "agent-builder",
+    "conversational-ai"
+  ],
+  "author": "Yan",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Yan-Acadenice/BYAN.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Yan-Acadenice/BYAN/issues"
+  },
+  "homepage": "https://github.com/Yan-Acadenice/BYAN#readme",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^8.2.5",
+    "js-yaml": "^4.1.0",
+    "ora": "^5.4.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
+}

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;