create-byan-agent 2.0.0 → 2.1.0

package/.github/agents/bmad-agent-byan-v2.md

@@ -0,0 +1,44 @@
+---
+name: 'byan-v2'
+description: 'BYAN v2.0 - Intelligent agent creator through structured interviews (12 questions, 15 min). Powered by Merise Agile + TDD + 64 mantras.'
+---
+
+# BYAN v2.0 - Builder of YAN
+
+**This is a lightweight stub. Full agent definition in:**
+- **GitHub Copilot**: `.github/copilot/agents/byan-v2.md`
+- **Source code**: `src/byan-v2/`
+
+## Quick Start
+
+```bash
+# In Copilot CLI
+@byan-v2 create agent
+
+# Or programmatically
+const ByanV2 = require('./src/byan-v2');
+const byan = new ByanV2();
+await byan.startSession();
+```
+
+## Architecture
+
+**4-Phase Interview:**
+1. CONTEXT → Project & goals
+2. BUSINESS → Domain & constraints
+3. AGENT_NEEDS → Capabilities & style
+4. VALIDATION → Confirmation
+
+**State Machine:**
+```
+INIT → INTERVIEW → ANALYSIS → GENERATION → COMPLETED
+```
+
+## Resources
+
+- Full doc: `README-BYAN-V2.md`
+- API: `API-BYAN-V2.md`
+- Tests: `__tests__/byan-v2/` (881/881 passing)
+- Demo: `demo-byan-v2-simple.js`
+
+**Ready?** Type `@byan-v2 help` to start!

package/.github/agents/bmad-agent-marc.md

@@ -1,6 +1,6 @@
 ---
 name: 'marc'
-description: 'MARC - GitHub Copilot CLI integration specialist. Expert in custom agents, MCP servers, and agent profile validation.'
+description: 'MARC - GitHub Copilot CLI & SDK integration specialist. Expert in custom agents, MCP servers, SDK implementation, and agent profile validation.'
 ---
 
 ## Commands
@@ -12,8 +12,11 @@ description: 'MARC - GitHub Copilot CLI integration specialist. Expert in custom
 - Test /agent detection and invocation
 - Create and fix agent stubs for BMAD agents
 - Configure MCP servers for GitHub Copilot CLI
+- Guide SDK implementation (Python, TypeScript, Go, .NET)
 - Troubleshoot agent loading issues
-- Apply GitHub Copilot CLI best practices
+- Apply GitHub Copilot CLI & SDK best practices
+- BYOK (Bring Your Own Key) configuration
+- Custom tools, agents, and skills development
 
 ## What I DON'T Do (Boundaries)
 - Never modify agent personas without validation
@@ -25,7 +28,25 @@ description: 'MARC - GitHub Copilot CLI integration specialist. Expert in custom
 ## Quick Start
 1. Ask me to validate agent detection
 2. Request stub creation or fixes
-3. Troubleshoot agent loading issues
+3. Get guidance on Copilot SDK implementation
+4. Troubleshoot agent loading issues
+
+## Copilot SDK (Technical Preview)
+**Install:**
+- Node.js: `npm install @github/copilot-sdk`
+- Python: `pip install github-copilot-sdk`
+- Go: `go get github.com/github/copilot-sdk/go`
+- .NET: `dotnet add package GitHub.Copilot.SDK`
+
+**Features:**
+- Embed Copilot agentic workflows in your app
+- Custom agents, skills, and tools
+- BYOK support (no GitHub auth required)
+- Production-tested agent runtime
+
+**Resources:**
+- Repo: https://github.com/github/copilot-sdk
+- Cookbook: github.com/github/awesome-copilot/cookbook/copilot-sdk
 
 ---
 
@@ -68,7 +89,10 @@ You must fully embody this agent's persona and follow all activation instruction
 - Test agent invocation
 - Optimize context usage
 - Troubleshoot agent loading
-- GitHub Copilot CLI best practices
+- GitHub Copilot CLI & SDK best practices
+- Guide SDK implementation (Python, TypeScript, Go, .NET)
+- BYOK configuration
+- Custom tools, agents, and skills development
 </capabilities>
 </agent>
 ```

package/__tests__/byan-v2/dispatcher/five-whys-analyzer.test.js

@@ -0,0 +1,473 @@
+/**
+ * FiveWhysAnalyzer Tests
+ * MANTRAS: KISS, DRY, SOLID, Zero Emoji
+ */
+
+const FiveWhysAnalyzer = require('../../../src/byan-v2/dispatcher/five-whys-analyzer');
+const SessionState = require('../../../src/byan-v2/context/session-state');
+const Logger = require('../../../src/byan-v2/observability/logger');
+
+describe('FiveWhysAnalyzer', () => {
+  let sessionState;
+  let logger;
+  let analyzer;
+
+  beforeEach(() => {
+    sessionState = new SessionState();
+    logger = new Logger({ logDir: 'logs', logFile: 'test-five-whys.log' });
+    analyzer = new FiveWhysAnalyzer(sessionState, logger);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with sessionState and logger', () => {
+      expect(analyzer.sessionState).toBe(sessionState);
+      expect(analyzer.logger).toBe(logger);
+      expect(analyzer.depth).toBe(0);
+      expect(analyzer.maxDepth).toBe(5);
+      expect(analyzer.responses).toEqual([]);
+    });
+
+    it('should create default logger if not provided', () => {
+      const analyzerNoLogger = new FiveWhysAnalyzer(sessionState);
+      expect(analyzerNoLogger.logger).toBeDefined();
+    });
+  });
+
+  describe('start()', () => {
+    it('should detect pain points and start analysis', () => {
+      const response = 'Our deployment process is slow and error-prone, causing major problems for the team.';
+      const result = analyzer.start(response);
+
+      expect(result.needsWhys).toBe(true);
+      expect(result.painPoints.length).toBeGreaterThan(0);
+      expect(result.firstQuestion).toBeDefined();
+      expect(result.firstQuestion.depth).toBe(1);
+      expect(analyzer.active).toBe(true);
+    });
+
+    it('should not start if no pain points detected', () => {
+      const response = 'Everything is working perfectly and smoothly.';
+      const result = analyzer.start(response);
+
+      expect(result.needsWhys).toBe(false);
+      expect(result.reason).toContain('No pain points');
+      expect(analyzer.active).toBe(false);
+    });
+
+    it('should reject invalid input', () => {
+      const result = analyzer.start(null);
+      expect(result.needsWhys).toBe(false);
+      expect(result.reason).toContain('Invalid');
+    });
+
+    it('should detect multiple pain keywords', () => {
+      const response = 'The system is slow, complex, and has frequent errors that are difficult to debug.';
+      const result = analyzer.start(response);
+
+      expect(result.painPoints.length).toBeGreaterThanOrEqual(4);
+    });
+  });
+
+  describe('_detectPainPoints()', () => {
+    it('should detect single pain keyword', () => {
+      const result = analyzer._detectPainPoints('We have a problem with the API');
+      
+      expect(result.hasPainPoints).toBe(true);
+      expect(result.painPoints.length).toBe(1);
+      expect(result.painPoints[0].keyword).toBe('problem');
+    });
+
+    it('should detect multiple pain keywords', () => {
+      const result = analyzer._detectPainPoints('The slow system causes errors and is difficult to fix');
+      
+      expect(result.hasPainPoints).toBe(true);
+      expect(result.painPoints.length).toBeGreaterThanOrEqual(3);
+    });
+
+    it('should return false for positive text', () => {
+      const result = analyzer._detectPainPoints('Everything works great and users are happy');
+      
+      expect(result.hasPainPoints).toBe(false);
+      expect(result.painPoints.length).toBe(0);
+    });
+
+    it('should calculate confidence score', () => {
+      const result = analyzer._detectPainPoints('We struggle with complex issues and errors');
+      
+      expect(result.confidence).toBeGreaterThan(0);
+      expect(result.confidence).toBeLessThanOrEqual(1.0);
+    });
+  });
+
+  describe('askNext()', () => {
+    beforeEach(() => {
+      analyzer.start('We have a slow deployment problem that is blocking releases.');
+    });
+
+    it('should return first WHY question', () => {
+      const question = analyzer.askNext();
+
+      expect(question).toBeDefined();
+      expect(question.depth).toBe(2);
+      expect(question.question).toContain('Why');
+      expect(question.prompt).toContain('2/5');
+    });
+
+    it('should increment depth with each call', () => {
+      const q1 = analyzer.askNext();
+      const result = analyzer.processAnswer('Because our CI/CD pipeline is not automated properly.');
+      
+      expect(result.nextQuestion.depth).toBe(3);
+    });
+
+    it('should return null when max depth reached', () => {
+      for (let i = 0; i < 5; i++) {
+        analyzer.askNext();
+        if (i < 4) {
+          analyzer.processAnswer('Because of reason ' + i);
+        }
+      }
+
+      const question = analyzer.askNext();
+      expect(question).toBeNull();
+    });
+
+    it('should return null when not active', () => {
+      analyzer.active = false;
+      const question = analyzer.askNext();
+      expect(question).toBeNull();
+    });
+  });
+
+  describe('processAnswer()', () => {
+    beforeEach(() => {
+      analyzer.start('The deployment process is slow and causes problems.');
+    });
+
+    it('should accept valid answer', () => {
+      analyzer.askNext();
+      const result = analyzer.processAnswer('Because we do not have automated testing in place.');
+
+      expect(result.valid).toBe(true);
+      expect(analyzer.responses.length).toBe(2);
+    });
+
+    it('should reject too short answer', () => {
+      analyzer.askNext();
+      const result = analyzer.processAnswer('Short');
+
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('short');
+    });
+
+    it('should reject null answer', () => {
+      analyzer.askNext();
+      const result = analyzer.processAnswer(null);
+
+      expect(result.valid).toBe(false);
+    });
+
+    it('should detect root cause early at depth 3+', () => {
+      analyzer.askNext();
+      const r1 = analyzer.processAnswer('Because our team does not have proper CI/CD setup yet.');
+      
+      const r2 = analyzer.processAnswer('Because we are still learning and figuring things out.');
+      
+      const result = analyzer.processAnswer('Because there is no fundamental process in place and the underlying lack of documentation has always been an issue since the beginning.');
+
+      expect(result.rootCauseFound).toBe(true);
+      expect(analyzer.isComplete()).toBe(true);
+    });
+
+    it('should complete after 5 WHYs', () => {
+      analyzer.askNext();
+      for (let i = 0; i < 4; i++) {
+        const result = analyzer.processAnswer(`This is just answer number ${i + 1} explaining our situation.`);
+        
+        if (i === 3) {
+          expect(result.completed).toBe(true);
+          expect(result.rootCause).toBeDefined();
+        }
+      }
+    });
+
+    it('should return next question if not complete', () => {
+      analyzer.askNext();
+      const result = analyzer.processAnswer('Because we do not have proper tools.');
+
+      expect(result.nextQuestion).toBeDefined();
+      expect(result.nextQuestion.depth).toBe(3);
+    });
+  });
+
+  describe('_analyzeForRootCause()', () => {
+    it('should detect root cause indicators', () => {
+      const answer = 'The fundamental problem is the lack of proper process and underlying infrastructure issues.';
+      const result = analyzer._analyzeForRootCause(answer);
+
+      expect(result.isRootCause).toBe(true);
+      expect(result.confidence).toBeGreaterThan(0.5);
+      expect(result.indicators).toBeGreaterThanOrEqual(2);
+    });
+
+    it('should not detect root cause without indicators', () => {
+      const answer = 'We just need more time.';
+      const result = analyzer._analyzeForRootCause(answer);
+
+      expect(result.isRootCause).toBe(false);
+    });
+
+    it('should consider answer length in confidence', () => {
+      const shortAnswer = 'Because of lack of time.';
+      const longAnswer = 'Because we have a fundamental lack of proper documentation and processes in place, which has been an underlying issue since the project started, and there is no clear system for knowledge sharing.';
+
+      const shortResult = analyzer._analyzeForRootCause(shortAnswer);
+      const longResult = analyzer._analyzeForRootCause(longAnswer);
+
+      expect(longResult.confidence).toBeGreaterThan(shortResult.confidence);
+    });
+  });
+
+  describe('_extractRootCause()', () => {
+    beforeEach(() => {
+      analyzer.start('We have deployment problems.');
+      for (let i = 0; i < 5; i++) {
+        analyzer.askNext();
+        analyzer.processAnswer(`This is response number ${i + 1} explaining the underlying issue with our process and lack of proper training.`);
+      }
+    });
+
+    it('should extract root cause from last response', () => {
+      const rootCause = analyzer._extractRootCause();
+
+      expect(rootCause.statement).toBeDefined();
+      expect(rootCause.confidence).toBeGreaterThan(0);
+      expect(rootCause.category).toBeDefined();
+    });
+
+    it('should categorize root cause', () => {
+      const rootCause = analyzer._extractRootCause();
+
+      expect(['technical', 'process', 'resource', 'knowledge', 'general']).toContain(rootCause.category);
+    });
+
+    it('should extract action items', () => {
+      const rootCause = analyzer._extractRootCause();
+
+      expect(Array.isArray(rootCause.actionItems)).toBe(true);
+    });
+  });
+
+  describe('_categorizeRootCause()', () => {
+    it('should categorize as technical', () => {
+      const category = analyzer._categorizeRootCause('Our database system is causing performance issues.');
+      expect(category).toBe('technical');
+    });
+
+    it('should categorize as process', () => {
+      const category = analyzer._categorizeRootCause('We lack a proper workflow and procedure for deployments.');
+      expect(category).toBe('process');
+    });
+
+    it('should categorize as resource', () => {
+      const category = analyzer._categorizeRootCause('The team does not have enough time or budget to implement this.');
+      expect(category).toBe('resource');
+    });
+
+    it('should categorize as knowledge', () => {
+      const category = analyzer._categorizeRootCause('Nobody understands how this works and we lack proper documentation.');
+      expect(category).toBe('knowledge');
+    });
+
+    it('should default to general', () => {
+      const category = analyzer._categorizeRootCause('This is a generic problem.');
+      expect(category).toBe('general');
+    });
+  });
+
+  describe('_extractActionItems()', () => {
+    it('should extract action items from statement', () => {
+      const statement = 'We need to implement better testing. We should create documentation. We must improve the process.';
+      const actions = analyzer._extractActionItems(statement);
+
+      expect(actions.length).toBeGreaterThan(0);
+      expect(actions.length).toBeLessThanOrEqual(3);
+    });
+
+    it('should return empty array if no actions found', () => {
+      const statement = 'This is just a description without any actions.';
+      const actions = analyzer._extractActionItems(statement);
+
+      expect(Array.isArray(actions)).toBe(true);
+    });
+
+    it('should limit to 3 action items', () => {
+      const statement = 'We need to implement A. We should create B. We must improve C. We have to build D. We require E.';
+      const actions = analyzer._extractActionItems(statement);
+
+      expect(actions.length).toBeLessThanOrEqual(3);
+    });
+  });
+
+  describe('_calculateConfidence()', () => {
+    it('should calculate confidence based on depth', () => {
+      const conf1 = analyzer._calculateConfidence(1, 'Short answer');
+      const conf5 = analyzer._calculateConfidence(5, 'Short answer');
+
+      expect(conf5).toBeGreaterThan(conf1);
+    });
+
+    it('should consider statement length', () => {
+      const confShort = analyzer._calculateConfidence(3, 'Short');
+      const confLong = analyzer._calculateConfidence(3, 'This is a much longer statement that provides more context and detail about the situation.');
+
+      expect(confLong).toBeGreaterThan(confShort);
+    });
+
+    it('should not exceed 1.0', () => {
+      const conf = analyzer._calculateConfidence(5, 'Very long statement'.repeat(20));
+
+      expect(conf).toBeLessThanOrEqual(1.0);
+    });
+  });
+
+  describe('isComplete()', () => {
+    it('should return false initially', () => {
+      expect(analyzer.isComplete()).toBe(true);
+    });
+
+    it('should return false when active', () => {
+      analyzer.start('We have a deployment problem.');
+      expect(analyzer.isComplete()).toBe(false);
+    });
+
+    it('should return true when max depth reached', () => {
+      analyzer.start('We have a problem.');
+      for (let i = 0; i < 5; i++) {
+        analyzer.askNext();
+        analyzer.processAnswer('Because of reason ' + i);
+      }
+
+      expect(analyzer.isComplete()).toBe(true);
+    });
+
+    it('should return true when root cause found early', () => {
+      analyzer.start('We have issues.');
+      analyzer.askNext();
+      analyzer.processAnswer('Because of something.');
+      analyzer.askNext();
+      analyzer.processAnswer('Because of something else.');
+      analyzer.askNext();
+      analyzer.processAnswer('The fundamental underlying lack of process has been the core issue since the beginning.');
+
+      expect(analyzer.isComplete()).toBe(true);
+    });
+  });
+
+  describe('getRootCause()', () => {
+    it('should return null initially', () => {
+      expect(analyzer.getRootCause()).toBeNull();
+    });
+
+    it('should return root cause after completion', () => {
+      analyzer.start('We have deployment problems.');
+      for (let i = 0; i < 5; i++) {
+        analyzer.askNext();
+        analyzer.processAnswer('Because of underlying reason ' + i);
+      }
+
+      const rootCause = analyzer.getRootCause();
+      expect(rootCause).toBeDefined();
+      expect(rootCause.statement).toBeDefined();
+    });
+  });
+
+  describe('getDepth()', () => {
+    it('should return 0 initially', () => {
+      expect(analyzer.getDepth()).toBe(0);
+    });
+
+    it('should return current depth', () => {
+      analyzer.start('We have problems.');
+      analyzer.askNext();
+      analyzer.processAnswer('Because of reasons.');
+
+      expect(analyzer.getDepth()).toBe(3);
+    });
+  });
+
+  describe('getResponses()', () => {
+    it('should return empty array initially', () => {
+      expect(analyzer.getResponses()).toEqual([]);
+    });
+
+    it('should return copy of responses array', () => {
+      analyzer.start('Problem detected.');
+      const responses = analyzer.getResponses();
+      responses.push({ fake: true });
+
+      expect(analyzer.getResponses().length).toBe(1);
+    });
+
+    it('should return all responses', () => {
+      analyzer.start('We have deployment problems that are slow and cause errors.');
+      analyzer.askNext();
+      analyzer.processAnswer('Because our automation is not working properly.');
+      analyzer.processAnswer('Because we do not have proper testing in place.');
+
+      const responses = analyzer.getResponses();
+      expect(responses.length).toBe(3);
+    });
+  });
+
+  describe('export()', () => {
+    it('should export analysis with metadata', () => {
+      analyzer.start('We have a deployment problem that causes errors.');
+      analyzer.askNext();
+      analyzer.processAnswer('Because we lack proper automation.');
+
+      const exported = analyzer.export();
+
+      expect(exported.version).toBe('1.0.0');
+      expect(exported.createdAt).toBeDefined();
+      expect(exported.painPoints).toBeDefined();
+      expect(exported.depth).toBeGreaterThan(0);
+      expect(exported.responses).toBeDefined();
+      expect(exported.metadata).toBeDefined();
+    });
+
+    it('should include completion status', () => {
+      analyzer.start('Problem.');
+      const exported = analyzer.export();
+
+      expect(exported.metadata.completed).toBe(false);
+    });
+
+    it('should include all responses', () => {
+      analyzer.start('We have a deployment problem that is blocking our releases.');
+      analyzer.askNext();
+      analyzer.processAnswer('Because we lack proper automation tools.');
+
+      const exported = analyzer.export();
+      expect(exported.responses.length).toBe(2);
+    });
+  });
+
+  describe('performance', () => {
+    it('should detect pain points in less than 50ms', () => {
+      const start = Date.now();
+      analyzer._detectPainPoints('We have multiple slow problems that are difficult to fix and cause errors.');
+      const duration = Date.now() - start;
+
+      expect(duration).toBeLessThan(50);
+    });
+
+    it('should analyze root cause in less than 50ms', () => {
+      const start = Date.now();
+      analyzer._analyzeForRootCause('The fundamental underlying lack of proper process and documentation has been the core issue.');
+      const duration = Date.now() - start;
+
+      expect(duration).toBeLessThan(50);
+    });
+  });
+});