create-byan-agent 2.0.1 → 2.1.1

package/install/UPDATE-SUMMARY.md

@@ -0,0 +1,205 @@
+# Résumé des Modifications - Package NPM v1.0.2
+
+**Date:** 2026-02-02  
+**Par:** RACHID (Expert NPM/NPX) + Yan  
+**Status:** ✅ Prêt pour publication
+
+---
+
+## 📦 Modifications Principales
+
+### 1. Nouveaux Agents Ajoutés
+
+#### RACHID - Expert NPM/NPX
+- **Fichier:** `templates/_bmad/bmb/agents/rachid.md` (7.2 KB)
+- **Stub:** `templates/.github/agents/bmad-agent-rachid.md` (1.8 KB)
+- **Capacités:**
+  - Installation BYAN via npx
+  - Validation structure _bmad
+  - Gestion dépendances npm
+  - Publication npm registry
+  - Tests npx
+  - Audits sécurité
+
+#### MARC - Expert GitHub Copilot CLI
+- **Fichier:** `templates/_bmad/bmb/agents/marc.md` (10.8 KB)
+- **Stub:** `templates/.github/agents/bmad-agent-marc.md` (1.9 KB)
+- **Capacités:**
+  - Validation .github/agents/
+  - Test détection /agent
+  - Création stubs agents
+  - Configuration MCP servers
+  - Optimisation contexte
+
+### 2. Structure Templates
+
+**Nouveau dossier:** `install/templates/`
+
+```
+templates/
+├── _bmad/
+│   └── bmb/
+│       ├── agents/                    (6 agents)
+│       │   ├── byan.md               ✅ 12.8 KB
+│       │   ├── rachid.md             ✅ 7.2 KB (NOUVEAU)
+│       │   ├── marc.md               ✅ 10.8 KB (NOUVEAU)
+│       │   ├── agent-builder.md      ✅
+│       │   ├── module-builder.md     ✅
+│       │   └── workflow-builder.md   ✅
+│       └── workflows/
+│           └── byan/
+│               ├── interview-workflow.md      ✅
+│               ├── quick-create-workflow.md   ✅
+│               ├── edit-agent-workflow.md     ✅
+│               ├── delete-agent-workflow.md   ✅
+│               ├── validate-agent-workflow.md ✅
+│               ├── templates/
+│               │   └── base-agent-template.md ✅
+│               └── data/
+│                   ├── mantras.yaml           ✅
+│                   └── templates.yaml         ✅
+└── .github/
+    └── agents/                        (24 stubs au total)
+        ├── bmad-agent-byan.md        ✅ 13.2 KB
+        ├── bmad-agent-rachid.md      ✅ 1.8 KB (NOUVEAU)
+        ├── bmad-agent-marc.md        ✅ 1.9 KB (NOUVEAU)
+        └── ... (21 autres stubs)
+```
+
+**Total fichiers:** 37 fichiers
+
+### 3. Script d'Installation Amélioré
+
+**Fichier:** `bin/create-byan-agent.js` (mise à jour de 8.4 KB → 11.6 KB)
+
+**Nouvelles fonctionnalités:**
+- ✅ Fonction `getTemplateDir()` pour résolution chemin templates
+- ✅ Copie complète depuis `templates/` vers projet
+- ✅ Création automatique `.github/agents/`
+- ✅ Vérification 10 checks (au lieu de 3)
+- ✅ Messages post-installation détaillés pour les 3 agents
+
+**Vérifications ajoutées:**
+1. Agents directory
+2. BYAN agent
+3. RACHID agent (nouveau)
+4. MARC agent (nouveau)
+5. Workflows
+6. Config
+7. GitHub agents dir (nouveau)
+8. BYAN stub (nouveau)
+9. RACHID stub (nouveau)
+10. MARC stub (nouveau)
+
+### 4. Package.json
+
+**Changements:**
+```diff
+- "version": "1.0.1"
++ "version": "1.0.2"
+
+- "description": "NPX installer for BYAN - Builder of YAN agent creator"
++ "description": "NPX installer for BYAN - Builder of YAN agent creator with RACHID and MARC"
+
+  "keywords": [
+    "byan",
+    "agent",
+    "creator",
+    ...
++   "rachid",
++   "marc",
++   "npm",
++   "deployment"
+  ]
+
+  "files": [
+    "bin/",
++   "templates/",
+    "README.md",
++   "CHANGELOG.md",
+    "LICENSE"
+  ]
+
++ "scripts": {
++   "start": "node bin/create-byan-agent.js",
++   "test": "node bin/create-byan-agent.js"
++ }
+```
+
+### 5. Documentation
+
+**Fichiers mis à jour:**
+- ✅ `README.md` - Ajout RACHID et MARC
+- ✅ `CHANGELOG.md` - Nouveau fichier avec historique complet
+- ✅ `PUBLISH-GUIDE.md` - Guide de publication npm
+
+**Sections ajoutées dans README:**
+- Section "Three Specialized Agents"
+- Instructions activation pour les 3 agents
+- Menus RACHID et MARC
+
+---
+
+## 📊 Statistiques
+
+| Métrique | Avant (v1.0.1) | Après (v1.0.2) | Diff |
+|----------|----------------|----------------|------|
+| Agents | 1 (BYAN) | 3 (BYAN, RACHID, MARC) | +2 |
+| Fichiers templates | 0 | 37 | +37 |
+| Taille package | ~10 KB | ~200 KB | +190 KB |
+| Checks validation | 3 | 10 | +7 |
+| Mots-clés npm | 9 | 13 | +4 |
+
+---
+
+## ✅ Tests Effectués
+
+- [x] `npm pack --dry-run` - Package valide
+- [x] `node bin/create-byan-agent.js --version` - Version 1.0.2
+- [x] Vérification structure templates/ - 37 fichiers
+- [x] Vérification agents: byan.md, rachid.md, marc.md présents
+- [x] Vérification workflows complets
+- [x] Vérification stubs .github/agents/
+
+---
+
+## 🚀 Prêt pour Publication
+
+### Commandes recommandées:
+
+```bash
+# 1. Audit de sécurité
+cd /home/yan/conception/install
+npm audit
+
+# 2. Test local
+npm pack
+mkdir -p /tmp/test-byan-v1.0.2
+cd /tmp/test-byan-v1.0.2
+npx /home/yan/conception/install/create-byan-agent-1.0.2.tgz
+
+# 3. Commit Git
+cd /home/yan/conception
+git add install/
+git commit -m "chore: release create-byan-agent v1.0.2"
+git tag -a v1.0.2 -m "Release v1.0.2"
+
+# 4. Publication NPM
+cd install/
+npm publish
+```
+
+---
+
+## 📝 Notes
+
+- Package compatible Node.js >=18.0.0
+- Dépendances: chalk, commander, inquirer, fs-extra, js-yaml, ora
+- License: MIT
+- Aucune vulnérabilité de sécurité connue
+
+---
+
+**Créé par:** RACHID  
+**Validé par:** Yan  
+**Date:** 2026-02-02 16:50 UTC

package/install/__tests__/integration/detection-flow.test.js

@@ -0,0 +1,154 @@
+/**
+ * Detection Flow Integration Tests
+ * 
+ * End-to-end integration tests for YANSTALLER Phase 1 Detection.
+ * These tests run on real environment (not fully mocked).
+ * 
+ * Tests verify:
+ * - Full detection flow returns valid structure
+ * - Detection handles missing platforms gracefully
+ * - Detection performance is acceptable (< 5s with timeouts)
+ */
+
+const detector = require('../../lib/yanstaller/detector');
+const osDetector = require('../../lib/utils/os-detector');
+const nodeDetector = require('../../lib/utils/node-detector');
+const gitDetector = require('../../lib/utils/git-detector');
+
+describe('Detection Flow Integration', () => {
+  describe('Full detection', () => {
+    it('should return complete detection structure with real environment', async () => {
+      const result = await detector.detect();
+      
+      // Validate structure
+      expect(result).toHaveProperty('os');
+      expect(result).toHaveProperty('osVersion');
+      expect(result).toHaveProperty('nodeVersion');
+      expect(result).toHaveProperty('hasGit');
+      expect(result).toHaveProperty('gitVersion');
+      expect(result).toHaveProperty('platforms');
+      
+      // Validate OS detection
+      expect(result.os).toBe(osDetector.detect().name);
+      expect(typeof result.osVersion).toBe('string');
+      expect(result.osVersion.length).toBeGreaterThan(0);
+      
+      // Validate Node detection
+      expect(typeof result.nodeVersion).toBe('string');
+      expect(result.nodeVersion).toMatch(/^\d+\.\d+\.\d+$/);
+      
+      // Validate Git detection
+      expect(typeof result.hasGit).toBe('boolean');
+      if (result.hasGit) {
+        expect(typeof result.gitVersion).toBe('string');
+        expect(result.gitVersion.length).toBeGreaterThan(0);
+      }
+      
+      // Validate platforms (array of 4)
+      expect(Array.isArray(result.platforms)).toBe(true);
+      expect(result.platforms).toHaveLength(4);
+      
+      // Each platform has required structure
+      result.platforms.forEach(platform => {
+        expect(platform).toHaveProperty('name');
+        expect(platform).toHaveProperty('detected');
+        expect(typeof platform.detected).toBe('boolean');
+        
+        if (platform.detected) {
+          expect(platform).toHaveProperty('path');
+          expect(typeof platform.path).toBe('string');
+        }
+      });
+    });
+
+    it('should detect platforms based on current directory structure', async () => {
+      const result = await detector.detect();
+      
+      // Count detected platforms
+      const detectedCount = result.platforms.filter(p => p.detected).length;
+      
+      // Platform detection depends on CWD and environment
+      // At minimum, structure should be valid
+      expect(detectedCount).toBeGreaterThanOrEqual(0);
+      expect(detectedCount).toBeLessThanOrEqual(4);
+    });
+  });
+
+  describe('Performance', () => {
+    it('should complete detection in under 5 seconds (with timeout protection)', async () => {
+      const startTime = Date.now();
+      
+      await detector.detect();
+      
+      const duration = Date.now() - startTime;
+      
+      // With 10s timeout per platform, worst case is ~10s
+      // Normal case should be < 5s
+      expect(duration).toBeLessThan(5000);
+    }, 6000); // Test timeout 6s (allows 5s + overhead)
+  });
+
+  describe('Node version validation', () => {
+    it('should validate current Node version meets requirement', () => {
+      const currentVersion = nodeDetector.detect();
+      const requirement = '18.0.0';
+      
+      const isValid = detector.isNodeVersionValid(currentVersion, requirement);
+      
+      // Current environment runs Node >= 18
+      expect(isValid).toBe(true);
+    });
+
+    it('should reject old Node versions', () => {
+      const isValid = detector.isNodeVersionValid('16.0.0', '18.0.0');
+      
+      expect(isValid).toBe(false);
+    });
+  });
+
+  describe('Platform detection details', () => {
+    it('should return valid structure for copilot-cli detection', async () => {
+      const platformInfo = await detector.detectPlatform('copilot-cli');
+      
+      expect(platformInfo.name).toBe('copilot-cli');
+      expect(typeof platformInfo.detected).toBe('boolean');
+      
+      // Path present only if detected
+      if (platformInfo.detected) {
+        expect(platformInfo.path).toBe('.github/agents');
+      }
+    });
+
+    it('should detect vscode platform (delegates to copilot-cli)', async () => {
+      const platformInfo = await detector.detectPlatform('vscode');
+      
+      expect(platformInfo.name).toBe('vscode');
+      // VSCode uses same path as copilot-cli
+      expect(typeof platformInfo.detected).toBe('boolean');
+    });
+
+    it('should handle unknown platform gracefully', async () => {
+      await expect(
+        detector.detectPlatform('unknown-platform')
+      ).rejects.toThrow('Unknown platform: unknown-platform');
+    });
+  });
+
+  describe('Resilience', () => {
+    it('should handle all platforms gracefully even if none detected', async () => {
+      // This test validates structure even if detection returns false
+      const result = await detector.detect();
+      
+      // All 4 platforms should be checked
+      const platformNames = result.platforms.map(p => p.name).sort();
+      expect(platformNames).toEqual(['claude', 'codex', 'copilot-cli', 'vscode']);
+      
+      // Each platform has valid structure
+      result.platforms.forEach(platform => {
+        expect(platform).toHaveProperty('name');
+        expect(platform).toHaveProperty('detected');
+        expect(typeof platform.detected).toBe('boolean');
+      });
+    });
+  });
+});

package/install/__tests__/platforms/claude-code.test.js

@@ -0,0 +1,175 @@
+/**
+ * Claude Code Platform Tests
+ * 
+ * Tests for install/lib/platforms/claude-code.js
+ */
+
+const claudeCode = require('../../lib/platforms/claude-code');
+const fileUtils = require('../../lib/utils/file-utils');
+const os = require('os');
+const path = require('path');
+
+// Mock dependencies
+jest.mock('../../lib/utils/file-utils');
+jest.mock('os');
+
+describe('Claude Code Platform', () => {
+  const mockHomedir = '/home/testuser';
+
+  // Helper to mock platform
+  function mockPlatform(platformName) {
+    os.platform.mockReturnValue(platformName);
+  }
+
+  beforeEach(() => {
+    os.homedir.mockReturnValue(mockHomedir);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('detect() - macOS', () => {
+    it('should check correct path on macOS and return true if exists', async () => {
+      os.platform.mockReturnValue('darwin');
+      fileUtils.exists.mockResolvedValue(true);
+
+      const result = await claudeCode.detect();
+
+      expect(result).toBe(true);
+      expect(fileUtils.exists).toHaveBeenCalledWith(
+        path.join(mockHomedir, 'Library/Application Support/Claude/claude_desktop_config.json')
+      );
+    });
+
+    it('should return false if config does not exist on macOS', async () => {
+      os.platform.mockReturnValue('darwin');
+      fileUtils.exists.mockResolvedValue(false);
+
+      const result = await claudeCode.detect();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('detect() - Windows', () => {
+    it('should check correct path on Windows and return true if exists', async () => {
+      os.platform.mockReturnValue('win32');
+      fileUtils.exists.mockResolvedValue(true);
+
+      const result = await claudeCode.detect();
+
+      expect(result).toBe(true);
+      expect(fileUtils.exists).toHaveBeenCalledWith(
+        path.join(mockHomedir, 'AppData/Roaming/Claude/claude_desktop_config.json')
+      );
+    });
+
+    it('should return false if config does not exist on Windows', async () => {
+      os.platform.mockReturnValue('win32');
+      fileUtils.exists.mockResolvedValue(false);
+
+      const result = await claudeCode.detect();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('detect() - Linux', () => {
+    it('should check correct path on Linux and return true if exists', async () => {
+      os.platform.mockReturnValue('linux');
+      fileUtils.exists.mockResolvedValue(true);
+
+      const result = await claudeCode.detect();
+
+      expect(result).toBe(true);
+      expect(fileUtils.exists).toHaveBeenCalledWith(
+        path.join(mockHomedir, '.config/Claude/claude_desktop_config.json')
+      );
+    });
+
+    it('should return false if config does not exist on Linux', async () => {
+      os.platform.mockReturnValue('linux');
+      fileUtils.exists.mockResolvedValue(false);
+
+      const result = await claudeCode.detect();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('detect() - Unknown OS', () => {
+    it('should return false for unsupported platform', async () => {
+      os.platform.mockReturnValue('freebsd');
+
+      const result = await claudeCode.detect();
+
+      expect(result).toBe(false);
+      expect(fileUtils.exists).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('getPath()', () => {
+    it('should return correct path for macOS', () => {
+      os.platform.mockReturnValue('darwin');
+
+      const result = claudeCode.getPath();
+
+      expect(result).toBe(
+        path.join(mockHomedir, 'Library/Application Support/Claude/claude_desktop_config.json')
+      );
+    });
+
+    it('should return correct path for Windows', () => {
+      os.platform.mockReturnValue('win32');
+
+      const result = claudeCode.getPath();
+
+      expect(result).toBe(
+        path.join(mockHomedir, 'AppData/Roaming/Claude/claude_desktop_config.json')
+      );
+    });
+
+    it('should return correct path for Linux', () => {
+      os.platform.mockReturnValue('linux');
+
+      const result = claudeCode.getPath();
+
+      expect(result).toBe(
+        path.join(mockHomedir, '.config/Claude/claude_desktop_config.json')
+      );
+    });
+
+    it('should return "unknown" for unsupported platform', () => {
+      os.platform.mockReturnValue('freebsd');
+
+      const result = claudeCode.getPath();
+
+      expect(result).toBe('unknown');
+    });
+  });
+
+  describe('name property', () => {
+    it('should have correct platform name', () => {
+      expect(claudeCode.name).toBe('Claude Code');
+    });
+  });
+
+  describe('install()', () => {
+    it('should return success for supported platforms', async () => {
+      mockPlatform('darwin');
+      
+      const result = await claudeCode.install('/project', ['agent1', 'agent2'], {});
+      
+      expect(result).toEqual({ success: true, installed: 2 });
+    });
+
+    it('should throw error for unsupported platform', async () => {
+      mockPlatform('freebsd');
+      
+      await expect(
+        claudeCode.install('/project', ['agent1'], {})
+      ).rejects.toThrow('Unsupported platform: freebsd');
+    });
+  });
+});

package/install/__tests__/platforms/codex.test.js

@@ -0,0 +1,80 @@
+/**
+ * Codex Platform Tests
+ * 
+ * Tests for install/lib/platforms/codex.js
+ */
+
+const codex = require('../../lib/platforms/codex');
+const fileUtils = require('../../lib/utils/file-utils');
+const path = require('path');
+
+// Mock fileUtils
+jest.mock('../../lib/utils/file-utils');
+
+describe('Codex Platform', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('detect() - Directory exists', () => {
+    it('should return true when .codex/prompts/ directory exists', async () => {
+      fileUtils.exists.mockResolvedValue(true);
+
+      const result = await codex.detect();
+
+      expect(result).toBe(true);
+      expect(fileUtils.exists).toHaveBeenCalledWith('.codex/prompts');
+    });
+  });
+
+  describe('detect() - Directory missing', () => {
+    it('should return false when .codex/prompts/ directory does not exist', async () => {
+      fileUtils.exists.mockResolvedValue(false);
+
+      const result = await codex.detect();
+
+      expect(result).toBe(false);
+      expect(fileUtils.exists).toHaveBeenCalledWith('.codex/prompts');
+    });
+  });
+
+  describe('getPath()', () => {
+    it('should return .codex/prompts directory path', () => {
+      expect(codex.getPath()).toBe('.codex/prompts');
+    });
+  });
+
+  describe('name property', () => {
+    it('should have correct platform name', () => {
+      expect(codex.name).toBe('Codex');
+    });
+  });
+
+  describe('install()', () => {
+    const mockFileUtils = require('../../lib/utils/file-utils');
+    
+    beforeEach(() => {
+      jest.clearAllMocks();
+      mockFileUtils.ensureDir.mockResolvedValue();
+      mockFileUtils.writeFile.mockResolvedValue();
+    });
+
+    it('should create .codex/prompts directory and install agents', async () => {
+      const result = await codex.install('/project', ['agent1', 'agent2'], {});
+      
+      expect(mockFileUtils.ensureDir).toHaveBeenCalledWith(
+        path.join('/project', '.codex', 'prompts')
+      );
+      expect(mockFileUtils.writeFile).toHaveBeenCalledTimes(2);
+      expect(result).toEqual({ success: true, installed: 2 });
+    });
+
+    it('should handle empty agent list', async () => {
+      const result = await codex.install('/project', [], {});
+      
+      expect(mockFileUtils.ensureDir).toHaveBeenCalled();
+      expect(mockFileUtils.writeFile).not.toHaveBeenCalled();
+      expect(result).toEqual({ success: true, installed: 0 });
+    });
+  });
+});