create-byan-agent 2.0.1 → 2.1.1

package/install/__tests__/platforms/copilot-cli.test.js

@@ -0,0 +1,118 @@
+/**
+ * Copilot CLI Platform Tests
+ * 
+ * Tests for install/lib/platforms/copilot-cli.js
+ */
+
+const copilotCli = require('../../lib/platforms/copilot-cli');
+const fileUtils = require('../../lib/utils/file-utils');
+const { execSync } = require('child_process');
+const path = require('path');
+
+// Mock dependencies
+jest.mock('child_process');
+jest.mock('../../lib/utils/file-utils');
+
+describe('Copilot CLI Platform', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('detect() - CLI installed', () => {
+    it('should return true when github-copilot-cli command exists', async () => {
+      // Mock successful command
+      execSync.mockReturnValue('');
+
+      const result = await copilotCli.detect();
+
+      expect(result).toBe(true);
+      expect(execSync).toHaveBeenCalledWith('which github-copilot-cli', expect.any(Object));
+    });
+  });
+
+  describe('detect() - Directory exists', () => {
+    it('should return true when .github/agents/ directory exists', async () => {
+      // Mock command fails but directory exists
+      execSync.mockImplementation(() => {
+        throw new Error('command not found');
+      });
+      fileUtils.exists.mockResolvedValue(true);
+
+      const result = await copilotCli.detect();
+
+      expect(result).toBe(true);
+      expect(fileUtils.exists).toHaveBeenCalledWith('.github/agents');
+    });
+  });
+
+  describe('detect() - Neither exists', () => {
+    it('should return false when command and directory both missing', async () => {
+      // Mock both checks fail
+      execSync.mockImplementation(() => {
+        throw new Error('command not found');
+      });
+      fileUtils.exists.mockResolvedValue(false);
+
+      const result = await copilotCli.detect();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('detect() - Timeout protection', () => {
+    it('should have timeout protection implemented via Promise.race', async () => {
+      // This test verifies timeout exists in code, not that it triggers
+      // (testing actual 10s timeout would make tests too slow)
+      
+      // Normal fast detection should work fine
+      execSync.mockReturnValue('');
+
+      const result = await copilotCli.detect();
+
+      expect(result).toBe(true);
+      
+      // Verify detect() returns quickly (not hanging)
+      // If timeout logic exists, function completes immediately when detection succeeds
+    });
+  });
+
+  describe('getPath()', () => {
+    it('should return .github/agents directory path', () => {
+      expect(copilotCli.getPath()).toBe('.github/agents');
+    });
+  });
+
+  describe('name property', () => {
+    it('should have correct platform name', () => {
+      expect(copilotCli.name).toBe('GitHub Copilot CLI');
+    });
+  });
+
+  describe('install()', () => {
+    const mockFileUtils = require('../../lib/utils/file-utils');
+    
+    beforeEach(() => {
+      jest.clearAllMocks();
+      mockFileUtils.ensureDir.mockResolvedValue();
+      mockFileUtils.writeFile.mockResolvedValue();
+    });
+
+    it('should create .github/agents directory and install agents', async () => {
+      const result = await copilotCli.install('/project', ['agent1', 'agent2'], {});
+      
+      expect(mockFileUtils.ensureDir).toHaveBeenCalledWith(
+        path.join('/project', '.github', 'agents')
+      );
+      expect(mockFileUtils.writeFile).toHaveBeenCalledTimes(2);
+      expect(result).toEqual({ success: true, installed: 2 });
+    });
+
+    it('should handle empty agent list', async () => {
+      const result = await copilotCli.install('/project', [], {});
+      
+      expect(mockFileUtils.ensureDir).toHaveBeenCalled();
+      expect(mockFileUtils.writeFile).not.toHaveBeenCalled();
+      expect(result).toEqual({ success: true, installed: 0 });
+    });
+  });
+});

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

@@ -0,0 +1,67 @@
+/**
+ * VSCode Platform Tests
+ * 
+ * Tests for install/lib/platforms/vscode.js
+ */
+
+const vscode = require('../../lib/platforms/vscode');
+const copilotCli = require('../../lib/platforms/copilot-cli');
+
+// Mock copilot-cli module
+jest.mock('../../lib/platforms/copilot-cli');
+
+describe('VSCode Platform', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('detect()', () => {
+    it('should call copilot-cli.detect() and return its result', async () => {
+      // Mock copilot-cli.detect to return true
+      copilotCli.detect.mockResolvedValue(true);
+
+      const result = await vscode.detect();
+
+      expect(result).toBe(true);
+      expect(copilotCli.detect).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return false when copilot-cli.detect returns false', async () => {
+      copilotCli.detect.mockResolvedValue(false);
+
+      const result = await vscode.detect();
+
+      expect(result).toBe(false);
+      expect(copilotCli.detect).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('install()', () => {
+    it('should call copilot-cli.install with same arguments', async () => {
+      const mockResult = { success: true, installed: 5 };
+      copilotCli.install.mockResolvedValue(mockResult);
+
+      const result = await vscode.install('/project', ['agent1', 'agent2'], {});
+
+      expect(result).toEqual(mockResult);
+      expect(copilotCli.install).toHaveBeenCalledWith('/project', ['agent1', 'agent2'], {});
+    });
+  });
+
+  describe('getPath()', () => {
+    it('should call copilot-cli.getPath and return its result', () => {
+      copilotCli.getPath.mockReturnValue('.github/agents');
+
+      const result = vscode.getPath();
+
+      expect(result).toBe('.github/agents');
+      expect(copilotCli.getPath).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('name property', () => {
+    it('should have correct platform name', () => {
+      expect(vscode.name).toBe('VSCode Copilot Extension');
+    });
+  });
+});

package/install/__tests__/utils/file-utils.test.js

@@ -0,0 +1,87 @@
+/**
+ * File Utils Tests
+ * 
+ * Tests for install/lib/utils/file-utils.js
+ */
+
+const fileUtils = require('../../lib/utils/file-utils');
+const fs = require('fs-extra');
+const path = require('path');
+
+jest.mock('fs-extra');
+
+describe('File Utils', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('exists()', () => {
+    it('should return true when path exists', async () => {
+      fs.pathExists.mockResolvedValue(true);
+      
+      const result = await fileUtils.exists('/some/path');
+      
+      expect(result).toBe(true);
+      expect(fs.pathExists).toHaveBeenCalledWith('/some/path');
+    });
+
+    it('should return false when path does not exist', async () => {
+      fs.pathExists.mockResolvedValue(false);
+      
+      const result = await fileUtils.exists('/missing/path');
+      
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('readFile()', () => {
+    it('should read file content as UTF-8', async () => {
+      fs.readFile.mockResolvedValue('file content');
+      
+      const result = await fileUtils.readFile('/path/file.txt');
+      
+      expect(result).toBe('file content');
+      expect(fs.readFile).toHaveBeenCalledWith('/path/file.txt', 'utf8');
+    });
+  });
+
+  describe('writeFile()', () => {
+    it('should write file content as UTF-8', async () => {
+      fs.writeFile.mockResolvedValue();
+      
+      await fileUtils.writeFile('/path/file.txt', 'content');
+      
+      expect(fs.writeFile).toHaveBeenCalledWith('/path/file.txt', 'content', 'utf8');
+    });
+  });
+
+  describe('ensureDir()', () => {
+    it('should create directory if not exists', async () => {
+      fs.ensureDir.mockResolvedValue();
+      
+      await fileUtils.ensureDir('/some/dir');
+      
+      expect(fs.ensureDir).toHaveBeenCalledWith('/some/dir');
+    });
+  });
+
+  describe('copy()', () => {
+    it('should copy source to destination', async () => {
+      fs.copy.mockResolvedValue();
+      
+      await fileUtils.copy('/src', '/dest');
+      
+      expect(fs.copy).toHaveBeenCalledWith('/src', '/dest');
+    });
+  });
+
+  describe('remove()', () => {
+    it('should remove path', async () => {
+      fs.remove.mockResolvedValue();
+      
+      await fileUtils.remove('/path');
+      
+      expect(fs.remove).toHaveBeenCalledWith('/path');
+    });
+  });
+});

package/install/__tests__/utils/git-detector.test.js

@@ -0,0 +1,80 @@
+/**
+ * Git Detector Tests
+ * 
+ * Tests for install/lib/utils/git-detector.js
+ */
+
+const gitDetector = require('../../lib/utils/git-detector');
+const { execSync } = require('child_process');
+
+// Mock child_process
+jest.mock('child_process');
+
+describe('Git Detector', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('detect() - Git installed', () => {
+    it('should detect Git and extract version when installed', async () => {
+      // Mock successful git command
+      execSync.mockReturnValue('git version 2.34.1\n');
+
+      const result = await gitDetector.detect();
+
+      expect(result).toEqual({
+        installed: true,
+        version: '2.34.1'
+      });
+
+      expect(execSync).toHaveBeenCalledWith('git --version', { encoding: 'utf8' });
+    });
+
+    it('should handle different Git version formats', async () => {
+      // Test various git version output formats
+      execSync.mockReturnValue('git version 2.40.0');
+
+      const result = await gitDetector.detect();
+
+      expect(result.installed).toBe(true);
+      expect(result.version).toBe('2.40.0');
+    });
+  });
+
+  describe('detect() - Git not installed', () => {
+    it('should return installed: false when Git command fails', async () => {
+      // Mock command failure (Git not installed)
+      execSync.mockImplementation(() => {
+        throw new Error('command not found: git');
+      });
+
+      const result = await gitDetector.detect();
+
+      expect(result).toEqual({
+        installed: false,
+        version: null
+      });
+    });
+  });
+
+  describe('detect() - Error handling', () => {
+    it('should handle malformed git version output gracefully', async () => {
+      // Mock unexpected output format
+      execSync.mockReturnValue('some weird output without version');
+
+      const result = await gitDetector.detect();
+
+      expect(result.installed).toBe(true);
+      expect(result.version).toBeNull(); // Version extraction failed but Git exists
+    });
+
+    it('should handle empty output', async () => {
+      execSync.mockReturnValue('');
+
+      const result = await gitDetector.detect();
+
+      expect(result.installed).toBe(true);
+      expect(result.version).toBeNull();
+    });
+  });
+});

package/install/__tests__/utils/logger.test.js

@@ -0,0 +1,83 @@
+/**
+ * Logger Tests
+ * 
+ * Tests for install/lib/utils/logger.js
+ */
+
+const logger = require('../../lib/utils/logger');
+
+// Mock chalk
+jest.mock('chalk', () => ({
+  green: jest.fn((text) => `GREEN:${text}`),
+  red: jest.fn((text) => `RED:${text}`),
+  yellow: jest.fn((text) => `YELLOW:${text}`),
+  blue: jest.fn((text) => `BLUE:${text}`),
+  gray: jest.fn((text) => `GRAY:${text}`)
+}));
+
+describe('Logger', () => {
+  let consoleLogSpy;
+  let consoleErrorSpy;
+
+  beforeEach(() => {
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  describe('success()', () => {
+    it('should log success message in green', () => {
+      logger.success('Test success');
+      
+      expect(consoleLogSpy).toHaveBeenCalledWith('GREEN:✓', 'Test success');
+    });
+  });
+
+  describe('error()', () => {
+    it('should log error message in red', () => {
+      logger.error('Test error');
+      
+      expect(consoleErrorSpy).toHaveBeenCalledWith('RED:✖', 'Test error');
+    });
+  });
+
+  describe('warn()', () => {
+    it('should log warning message in yellow', () => {
+      logger.warn('Test warning');
+      
+      expect(consoleLogSpy).toHaveBeenCalledWith('YELLOW:⚠', 'Test warning');
+    });
+  });
+
+  describe('info()', () => {
+    it('should log info message in blue', () => {
+      logger.info('Test info');
+      
+      expect(consoleLogSpy).toHaveBeenCalledWith('BLUE:ℹ', 'Test info');
+    });
+  });
+
+  describe('debug()', () => {
+    it('should log debug message in gray when DEBUG env is set', () => {
+      process.env.DEBUG = 'true';
+      
+      logger.debug('Test debug');
+      
+      expect(consoleLogSpy).toHaveBeenCalledWith('GRAY:[DEBUG]', 'Test debug');
+      
+      delete process.env.DEBUG;
+    });
+
+    it('should not log when DEBUG env is not set', () => {
+      delete process.env.DEBUG;
+      
+      logger.debug('Test debug');
+      
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
+  });
+});

package/install/__tests__/utils/node-detector.test.js

@@ -0,0 +1,71 @@
+/**
+ * Node Detector Tests
+ * 
+ * Tests for install/lib/utils/node-detector.js
+ */
+
+const nodeDetector = require('../../lib/utils/node-detector');
+
+describe('Node Detector', () => {
+  describe('detect()', () => {
+    it('should detect Node.js version without v prefix', () => {
+      const result = nodeDetector.detect();
+      
+      expect(typeof result).toBe('string');
+      expect(result).not.toMatch(/^v/); // No 'v' prefix
+      expect(result).toMatch(/^\d+\.\d+\.\d+/); // Semver format
+    });
+  });
+
+  describe('compareVersions()', () => {
+    it('should return 0 for equal versions', () => {
+      expect(nodeDetector.compareVersions('18.0.0', '18.0.0')).toBe(0);
+      expect(nodeDetector.compareVersions('20.5.1', '20.5.1')).toBe(0);
+    });
+
+    it('should return 1 when first version is greater', () => {
+      expect(nodeDetector.compareVersions('19.0.0', '18.0.0')).toBe(1);
+      expect(nodeDetector.compareVersions('18.1.0', '18.0.0')).toBe(1);
+      expect(nodeDetector.compareVersions('18.0.1', '18.0.0')).toBe(1);
+    });
+
+    it('should return -1 when first version is less', () => {
+      expect(nodeDetector.compareVersions('18.0.0', '19.0.0')).toBe(-1);
+      expect(nodeDetector.compareVersions('18.0.0', '18.1.0')).toBe(-1);
+      expect(nodeDetector.compareVersions('18.0.0', '18.0.1')).toBe(-1);
+    });
+
+    it('should handle version suffixes correctly by stripping them', () => {
+      // These should all compare equal after suffix removal
+      expect(nodeDetector.compareVersions('18.0.0-beta', '18.0.0')).toBe(0);
+      expect(nodeDetector.compareVersions('18.0.0', '18.0.0-beta')).toBe(0);
+      expect(nodeDetector.compareVersions('18.0.0-rc1', '18.0.0-beta')).toBe(0);
+      
+      // These should compare correctly after suffix removal
+      expect(nodeDetector.compareVersions('19.0.0-beta', '18.0.0')).toBe(1);
+      expect(nodeDetector.compareVersions('18.0.0-rc1', '19.0.0')).toBe(-1);
+    });
+  });
+
+  describe('meetsRequirement()', () => {
+    it('should return true when current version meets requirement', () => {
+      expect(nodeDetector.meetsRequirement('18.0.0', '18.0.0')).toBe(true);
+      expect(nodeDetector.meetsRequirement('19.0.0', '18.0.0')).toBe(true);
+      expect(nodeDetector.meetsRequirement('18.1.0', '18.0.0')).toBe(true);
+    });
+
+    it('should return false when current version does not meet requirement', () => {
+      expect(nodeDetector.meetsRequirement('17.9.9', '18.0.0')).toBe(false);
+      expect(nodeDetector.meetsRequirement('16.0.0', '18.0.0')).toBe(false);
+    });
+
+    it('should handle version suffixes correctly', () => {
+      // 18.0.0-beta should still meet 18.0.0 requirement (same base version)
+      expect(nodeDetector.meetsRequirement('18.0.0-beta', '18.0.0')).toBe(true);
+      expect(nodeDetector.meetsRequirement('19.0.0-rc1', '18.0.0')).toBe(true);
+      
+      // 17.9.9-beta should not meet 18.0.0 requirement
+      expect(nodeDetector.meetsRequirement('17.9.9-beta', '18.0.0')).toBe(false);
+    });
+  });
+});

package/install/__tests__/utils/os-detector.test.js

@@ -0,0 +1,63 @@
+/**
+ * OS Detector Tests
+ * 
+ * Tests for install/lib/utils/os-detector.js
+ */
+
+const osDetector = require('../../lib/utils/os-detector');
+const os = require('os');
+
+describe('OS Detector', () => {
+  describe('detect()', () => {
+    it('should detect operating system with name, version, and platform', () => {
+      const result = osDetector.detect();
+      
+      expect(result).toHaveProperty('name');
+      expect(result).toHaveProperty('version');
+      expect(result).toHaveProperty('platform');
+      
+      expect(typeof result.name).toBe('string');
+      expect(typeof result.version).toBe('string');
+      expect(typeof result.platform).toBe('string');
+      
+      // Validate name is one of expected values
+      expect(['windows', 'macos', 'linux', 'unknown']).toContain(result.name);
+      
+      // Platform should match os.platform()
+      expect(result.platform).toBe(os.platform());
+      
+      // Version should match os.release()
+      expect(result.version).toBe(os.release());
+    });
+  });
+
+  describe('isWindows()', () => {
+    it('should return true on Windows, false otherwise', () => {
+      const result = osDetector.isWindows();
+      const expected = os.platform() === 'win32';
+      
+      expect(result).toBe(expected);
+      expect(typeof result).toBe('boolean');
+    });
+  });
+
+  describe('isMacOS()', () => {
+    it('should return true on macOS, false otherwise', () => {
+      const result = osDetector.isMacOS();
+      const expected = os.platform() === 'darwin';
+      
+      expect(result).toBe(expected);
+      expect(typeof result).toBe('boolean');
+    });
+  });
+
+  describe('isLinux()', () => {
+    it('should return true on Linux, false otherwise', () => {
+      const result = osDetector.isLinux();
+      const expected = os.platform() === 'linux';
+      
+      expect(result).toBe(expected);
+      expect(typeof result).toBe('boolean');
+    });
+  });
+});

package/install/__tests__/utils/yaml-utils.test.js

@@ -0,0 +1,85 @@
+/**
+ * YAML Utils Tests
+ * 
+ * Tests for install/lib/utils/yaml-utils.js
+ */
+
+const yamlUtils = require('../../lib/utils/yaml-utils');
+const fileUtils = require('../../lib/utils/file-utils');
+
+jest.mock('../../lib/utils/file-utils');
+
+describe('YAML Utils', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('parse()', () => {
+    it('should parse valid YAML string', () => {
+      const yamlString = 'name: test\nvalue: 123';
+      
+      const result = yamlUtils.parse(yamlString);
+      
+      expect(result).toEqual({ name: 'test', value: 123 });
+    });
+  });
+
+  describe('dump()', () => {
+    it('should dump object to YAML string', () => {
+      const obj = { name: 'test', value: 123 };
+      
+      const result = yamlUtils.dump(obj);
+      
+      expect(result).toContain('name: test');
+      expect(result).toContain('value: 123');
+    });
+  });
+
+  describe('readYAML()', () => {
+    it('should read and parse YAML file', async () => {
+      fileUtils.readFile.mockResolvedValue('name: test\nvalue: 123');
+      
+      const result = await yamlUtils.readYAML('/path/file.yaml');
+      
+      expect(fileUtils.readFile).toHaveBeenCalledWith('/path/file.yaml');
+      expect(result).toEqual({ name: 'test', value: 123 });
+    });
+  });
+
+  describe('writeYAML()', () => {
+    it('should dump and write YAML file', async () => {
+      fileUtils.writeFile.mockResolvedValue();
+      
+      await yamlUtils.writeYAML('/path/file.yaml', { name: 'test', value: 123 });
+      
+      expect(fileUtils.writeFile).toHaveBeenCalledWith(
+        '/path/file.yaml',
+        expect.stringContaining('name: test')
+      );
+    });
+  });
+
+  describe('extractFrontmatter()', () => {
+    it('should extract frontmatter and content from markdown', () => {
+      const markdown = `---
+name: test
+value: 123
+---
+# Content here`;
+      
+      const result = yamlUtils.extractFrontmatter(markdown);
+      
+      expect(result.frontmatter).toEqual({ name: 'test', value: 123 });
+      expect(result.content).toBe('# Content here');
+    });
+
+    it('should return null frontmatter when no frontmatter exists', () => {
+      const markdown = '# Content without frontmatter';
+      
+      const result = yamlUtils.extractFrontmatter(markdown);
+      
+      expect(result.frontmatter).toBeNull();
+      expect(result.content).toBe(markdown);
+    });
+  });
+});