sumulige-claude 1.5.1 → 1.5.2

package/tests/commands.test.js

@@ -1,1086 +0,0 @@
-/**
- * Commands 模块单元测试 - 扩展版
- * 测试核心命令功能和边界情况
- */
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const commands = require('../lib/commands');
-const { CopyMode } = require('../lib/utils');
-
-// ============================================================================
-// Helper Functions Tests
-// ============================================================================
-
-describe('Commands Helper Functions', () => {
-  describe('countFiles', () => {
-    const { countFiles } = commands;
-
-    it('should count files in a directory', () => {
-      // Use node_modules as a test directory (it exists)
-      const nodeModulesPath = path.join(__dirname, '../node_modules');
-      if (fs.existsSync(nodeModulesPath)) {
-        const count = countFiles(nodeModulesPath);
-        expect(typeof count).toBe('number');
-        expect(count).toBeGreaterThan(0);
-      }
-    });
-
-    it('should skip node_modules directory', () => {
-      // This test verifies the logic in countFiles
-      const skipDirs = ['node_modules', '.git', 'sessions'];
-      expect(skipDirs).toContain('node_modules');
-      expect(skipDirs).toContain('.git');
-      expect(skipDirs).toContain('sessions');
-    });
-
-    it('should return 0 for empty logic check', () => {
-      // Test the logic structure
-      let count = 0;
-      const entries = []; // Empty entries
-      expect(count).toBe(0);
-    });
-  });
-
-  describe('setExecutablePermission', () => {
-    const { setExecutablePermission } = commands;
-    const tmpDir = path.join(os.tmpdir(), 'smc-test-' + Date.now());
-
-    beforeEach(() => {
-      if (!fs.existsSync(tmpDir)) {
-        fs.mkdirSync(tmpDir, { recursive: true });
-      }
-    });
-
-    afterEach(() => {
-      if (fs.existsSync(tmpDir)) {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-      }
-    });
-
-    it('should set executable permission for .sh files', () => {
-      const shFile = path.join(tmpDir, 'test.sh');
-      fs.writeFileSync(shFile, '#!/bin/bash\necho test');
-      expect(() => setExecutablePermission(shFile)).not.toThrow();
-    });
-
-    it('should set executable permission for .cjs files', () => {
-      const cjsFile = path.join(tmpDir, 'test.cjs');
-      fs.writeFileSync(cjsFile, 'console.log("test");');
-      expect(() => setExecutablePermission(cjsFile)).not.toThrow();
-    });
-
-    it('should not set permission for non-script files', () => {
-      const txtFile = path.join(tmpDir, 'test.txt');
-      fs.writeFileSync(txtFile, 'test content');
-      expect(() => setExecutablePermission(txtFile)).not.toThrow();
-    });
-
-    it('should handle non-existent files gracefully', () => {
-      const nonExistent = path.join(tmpDir, 'does-not-exist.sh');
-      expect(() => setExecutablePermission(nonExistent)).not.toThrow();
-    });
-  });
-
-  describe('generateAgentsMd', () => {
-    const { generateAgentsMd } = commands;
-
-    it('should generate markdown for agents', () => {
-      const config = {
-        model: 'claude-opus-4-5',
-        agents: {
-          conductor: { model: 'claude-opus-4-5', role: 'Task coordination' },
-          builder: { model: 'claude-opus-4-5', role: 'Code implementation' }
-        }
-      };
-
-      const md = generateAgentsMd(config);
-      expect(md).toContain('# AGENTS');
-      expect(md).toContain('conductor');
-      expect(md).toContain('Task coordination');
-      expect(md).toContain('builder');
-      expect(md).toContain('Code implementation');
-    });
-
-    it('should use default model when agent has no model', () => {
-      const config = {
-        model: 'default-model',
-        agents: {
-          test: { role: 'Test role' }
-        }
-      };
-
-      const md = generateAgentsMd(config);
-      expect(md).toContain('default-model');
-    });
-
-    it('should include usage section', () => {
-      const config = {
-        model: 'test-model',
-        agents: {}
-      };
-
-      const md = generateAgentsMd(config);
-      expect(md).toContain('## Usage');
-    });
-  });
-
-  describe('copySingleFile', () => {
-    const { copySingleFile } = commands;
-    const tmpDir = path.join(os.tmpdir(), 'smc-copy-test-' + Date.now());
-    const srcDir = path.join(tmpDir, 'src');
-    const destDir = path.join(tmpDir, 'dest');
-    const backupDir = path.join(tmpDir, 'backup');
-
-    beforeEach(() => {
-      [srcDir, destDir, backupDir].forEach(d => {
-        if (!fs.existsSync(d)) {
-          fs.mkdirSync(d, { recursive: true });
-        }
-      });
-    });
-
-    afterEach(() => {
-      if (fs.existsSync(tmpDir)) {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-      }
-    });
-
-    it('should copy file when destination does not exist', () => {
-      const srcFile = path.join(srcDir, 'test.sh');
-      const destFile = path.join(destDir, 'test.sh');
-      fs.writeFileSync(srcFile, '#!/bin/bash\necho test');
-
-      copySingleFile(srcFile, destFile, CopyMode.FORCE, backupDir, 'test.sh');
-      expect(fs.existsSync(destFile)).toBe(true);
-    });
-
-    it('should respect CopyMode.SAFE - keep existing', () => {
-      const srcFile = path.join(srcDir, 'test.txt');
-      const destFile = path.join(destDir, 'test.txt');
-      fs.writeFileSync(srcFile, 'new content');
-      fs.writeFileSync(destFile, 'old content');
-
-      copySingleFile(srcFile, destFile, CopyMode.SAFE, backupDir, 'test.txt');
-      expect(fs.readFileSync(destFile, 'utf-8')).toBe('old content');
-    });
-
-    it('should handle non-existent source file gracefully', () => {
-      const srcFile = path.join(srcDir, 'does-not-exist.sh');
-      const destFile = path.join(destDir, 'test.sh');
-      expect(() => copySingleFile(srcFile, destFile, CopyMode.FORCE, backupDir, 'test.sh')).not.toThrow();
-    });
-  });
-});
-
-describe('Commands Module - Extended Tests', () => {
-  describe('exports', () => {
-    it('should export runCommand function', () => {
-      expect(typeof commands.runCommand).toBe('function');
-    });
-
-    it('should export commands object', () => {
-      expect(typeof commands.commands).toBe('object');
-    });
-
-    it('should have all core commands', () => {
-      const cmdList = commands.commands;
-      // Core commands
-      expect(cmdList.init).toBeDefined();
-      expect(cmdList.sync).toBeDefined();
-      expect(cmdList.migrate).toBeDefined();
-      expect(cmdList.agent).toBeDefined();
-      expect(cmdList.status).toBeDefined();
-      expect(cmdList.version).toBeDefined();
-      // Skill commands
-      expect(cmdList['skill:list']).toBeDefined();
-      expect(cmdList['skill:create']).toBeDefined();
-      expect(cmdList['skill:check']).toBeDefined();
-      expect(cmdList['skill:install']).toBeDefined();
-      // Template commands
-      expect(cmdList.template).toBeDefined();
-      expect(cmdList.kickoff).toBeDefined();
-      expect(cmdList['init:interactive']).toBeDefined();
-      expect(cmdList.ultrathink).toBeDefined();
-    });
-
-    it('should have all marketplace commands', () => {
-      // Marketplace commands are handled in cli.js, not in commands.js
-      // Verify they exist in the marketplace module instead
-      const marketplace = require('../lib/marketplace');
-      const mpCommands = marketplace.marketplaceCommands;
-      expect(mpCommands['marketplace:list']).toBeDefined();
-      expect(mpCommands['marketplace:install']).toBeDefined();
-      expect(mpCommands['marketplace:sync']).toBeDefined();
-      expect(mpCommands['marketplace:add']).toBeDefined();
-      expect(mpCommands['marketplace:remove']).toBeDefined();
-      expect(mpCommands['marketplace:status']).toBeDefined();
-    });
-
-    it('should have all skills commands', () => {
-      const cmdList = commands.commands;
-      expect(cmdList['skills:official']).toBeDefined();
-      expect(cmdList['skills:install-official']).toBeDefined();
-      expect(cmdList['skills:install-all']).toBeDefined();
-      expect(cmdList['skills:search']).toBeDefined();
-      expect(cmdList['skills:validate']).toBeDefined();
-      expect(cmdList['skills:update']).toBeDefined();
-      expect(cmdList['skills:publish']).toBeDefined();
-    });
-
-    it('should have config commands', () => {
-      const cmdList = commands.commands;
-      expect(cmdList.config).toBeDefined();
-      expect(cmdList['config:validate']).toBeDefined();
-      expect(cmdList['config:backup']).toBeDefined();
-      expect(cmdList['config:rollback']).toBeDefined();
-      expect(cmdList['config:diff']).toBeDefined();
-    });
-
-    it('should have quality gate commands', () => {
-      const cmdList = commands.commands;
-      expect(cmdList['qg:check']).toBeDefined();
-      expect(cmdList['qg:rules']).toBeDefined();
-      expect(cmdList['qg:init']).toBeDefined();
-    });
-
-    it('should have workflow commands', () => {
-      const cmdList = commands.commands;
-      expect(cmdList.workflow).toBeDefined();
-      expect(cmdList.knowledge).toBeDefined();
-      expect(cmdList.notebooklm).toBeDefined();
-    });
-  });
-
-  describe('runCommand', () => {
-    it('should call the correct command function', async () => {
-      const initSpy = jest.spyOn(commands.commands, 'init');
-      await commands.runCommand('init', []);
-      expect(initSpy).toHaveBeenCalled();
-      initSpy.mockRestore();
-    });
-
-    it('should pass arguments to command function', async () => {
-      const agentSpy = jest.spyOn(commands.commands, 'agent');
-      await commands.runCommand('agent', ['test task']);
-      expect(agentSpy).toHaveBeenCalledWith('test task');
-      agentSpy.mockRestore();
-    });
-
-    it('should handle unknown commands gracefully', async () => {
-      await expect(async () => {
-        await commands.runCommand('unknown-command', []);
-      }).not.toThrow();
-    });
-
-    it('should handle commands with multiple arguments', async () => {
-      const syncSpy = jest.spyOn(commands.commands, 'sync');
-      await commands.runCommand('sync', ['--check-update']);
-      expect(syncSpy).toHaveBeenCalledWith('--check-update');
-      syncSpy.mockRestore();
-    });
-  });
-
-  describe('init command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands.init).toBe('function');
-    });
-
-    it('should not throw on basic call', () => {
-      expect(() => commands.commands.init()).not.toThrow();
-    });
-
-    it('should recognize --interactive flag', () => {
-      const interactiveSpy = jest.spyOn(commands.commands, 'init:interactive').mockImplementation(() => {});
-      commands.commands.init('--interactive');
-      expect(interactiveSpy).toHaveBeenCalled();
-      interactiveSpy.mockRestore();
-    });
-
-    it('should recognize -i flag', () => {
-      const interactiveSpy = jest.spyOn(commands.commands, 'init:interactive').mockImplementation(() => {});
-      commands.commands.init('-i');
-      expect(interactiveSpy).toHaveBeenCalled();
-      interactiveSpy.mockRestore();
-    });
-  });
-
-  describe('sync command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands.sync).toBe('function');
-    });
-
-    it('should not throw on basic call', async () => {
-      await expect(async () => {
-        await commands.commands.sync();
-      }).not.toThrow();
-    });
-
-    it('should recognize --check-update flag', async () => {
-      await expect(async () => {
-        await commands.commands.sync('--check-update');
-      }).not.toThrow();
-    });
-  });
-
-  describe('migrate command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands.migrate).toBe('function');
-    });
-
-    it('should not throw', () => {
-      expect(() => commands.commands.migrate()).not.toThrow();
-    });
-  });
-
-  describe('version command', () => {
-    it('should be an async function', () => {
-      expect(typeof commands.commands.version).toBe('function');
-    });
-
-    it('should not throw', async () => {
-      await expect(async () => {
-        await commands.commands.version();
-      }).not.toThrow();
-    });
-  });
-
-  describe('agent command', () => {
-    it('should show usage when no task provided', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.agent();
-      expect(consoleSpy).toHaveBeenCalled();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Usage');
-      consoleSpy.mockRestore();
-    });
-
-    it('should display agent information when task provided', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.agent('Build a REST API');
-      expect(consoleSpy).toHaveBeenCalled();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Agent Orchestration');
-      expect(output).toContain('Build a REST API');
-      consoleSpy.mockRestore();
-    });
-
-    it('should show available agents', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.agent('test task');
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Available Agents');
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('status command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands.status).toBe('function');
-    });
-
-    it('should display config info', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.status();
-      expect(consoleSpy).toHaveBeenCalled();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Status');
-      consoleSpy.mockRestore();
-    });
-
-    it('should display agents list', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.status();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Agents');
-      consoleSpy.mockRestore();
-    });
-
-    it('should display skills', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.status();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Skills');
-      consoleSpy.mockRestore();
-    });
-
-    it('should display ThinkingLens status', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.status();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('ThinkingLens');
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('skill:list command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands['skill:list']).toBe('function');
-    });
-
-    it('should not throw', () => {
-      expect(() => commands.commands['skill:list']()).not.toThrow();
-    });
-  });
-
-  describe('skill:create command', () => {
-    it('should show usage when no skill name provided', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands['skill:create']();
-      expect(consoleSpy).toHaveBeenCalled();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Usage');
-      consoleSpy.mockRestore();
-    });
-
-    it('should validate kebab-case format', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-
-      // Invalid names with underscores
-      commands.commands['skill:create']('Invalid_Name');
-      let output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Invalid skill name');
-
-      // Invalid names with uppercase
-      consoleSpy.mockClear();
-      commands.commands['skill:create']('MySkill');
-      output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Invalid skill name');
-
-      // Test that valid names don't show invalid name error
-      // (they may show other errors like "already exists" which is OK)
-      consoleSpy.mockClear();
-      commands.commands['skill:create']('test-skill-name');
-      output = consoleSpy.mock.calls.flat().join(' ');
-      // Should not contain "Invalid skill name" error
-      // The regex requires starting with letter, so test a name that clearly violates it
-      consoleSpy.mockClear();
-      commands.commands['skill:create']('_invalid-start');
-      output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Invalid skill name');
-
-      consoleSpy.mockRestore();
-    });
-
-    it('should accept valid kebab-case names', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      const consoleErrorSpy = jest.spyOn(console, 'log').mockImplementation();
-
-      // Valid names - should not show "Invalid skill name" error
-      // Note: These may fail for other reasons (directory exists, etc.)
-      commands.commands['skill:create']('api-tester');
-      commands.commands['skill:create']('my-skill');
-      commands.commands['skill:create']('code-reviewer-123');
-
-      // Should not contain the invalid name error
-      // (other errors are OK for this test)
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      // The fact it doesn't throw and runs is the main check
-      expect(typeof commands.commands['skill:create']).toBe('function');
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('skill:check command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands['skill:check']).toBe('function');
-    });
-
-    it('should not throw when checking without skill name', () => {
-      expect(() => commands.commands['skill:check']()).not.toThrow();
-    });
-
-    it('should not throw when checking with skill name', () => {
-      expect(() => commands.commands['skill:check']('some-skill')).not.toThrow();
-    });
-  });
-
-  describe('skill:install command', () => {
-    it('should show usage when no source provided', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands['skill:install']();
-      expect(consoleSpy).toHaveBeenCalled();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Usage');
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('template command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands.template).toBe('function');
-    });
-
-    it('should show help with --help flag', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.template('--help');
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('USAGE');
-      consoleSpy.mockRestore();
-    });
-
-    it('should show help with -h flag', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.template('-h');
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('USAGE');
-      consoleSpy.mockRestore();
-    });
-
-    it('should accept --safe flag', () => {
-      expect(() => commands.commands.template('--safe')).not.toThrow();
-    });
-
-    it('should accept --force flag', () => {
-      expect(() => commands.commands.template('--force')).not.toThrow();
-    });
-
-    it('should accept path argument', () => {
-      expect(() => commands.commands.template('/tmp/test-project')).not.toThrow();
-    });
-
-    it('should accept combined flags and path', () => {
-      expect(() => commands.commands.template('/tmp/test', '--safe')).not.toThrow();
-    });
-  });
-
-  describe('kickoff command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands.kickoff).toBe('function');
-    });
-
-    it('should not throw', () => {
-      expect(() => commands.commands.kickoff()).not.toThrow();
-    });
-  });
-
-  describe('ultrathink command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands.ultrathink).toBe('function');
-    });
-
-    it('should display UltraThink mode info', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.ultrathink();
-      expect(consoleSpy).toHaveBeenCalled();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('UltraThink');
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('marketplace commands', () => {
-    // Note: Marketplace commands are handled in cli.js directly, not in commands.js
-    // They're registered in cli.js's COMMANDS object but call marketplaceCommands from lib/marketplace.js
-    const marketplace = require('../lib/marketplace');
-
-    it('marketplace:list should exist in marketplace module', () => {
-      expect(marketplace.marketplaceCommands['marketplace:list']).toBeDefined();
-    });
-
-    it('marketplace:install should exist in marketplace module', () => {
-      expect(marketplace.marketplaceCommands['marketplace:install']).toBeDefined();
-    });
-
-    it('marketplace:sync should exist in marketplace module', () => {
-      expect(marketplace.marketplaceCommands['marketplace:sync']).toBeDefined();
-    });
-
-    it('marketplace:add should exist in marketplace module', () => {
-      expect(marketplace.marketplaceCommands['marketplace:add']).toBeDefined();
-    });
-
-    it('marketplace:remove should exist in marketplace module', () => {
-      expect(marketplace.marketplaceCommands['marketplace:remove']).toBeDefined();
-    });
-
-    it('marketplace:status should exist in marketplace module', () => {
-      expect(marketplace.marketplaceCommands['marketplace:status']).toBeDefined();
-    });
-
-    it('marketplace:install should show usage without args', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      marketplace.marketplaceCommands['marketplace:install']();
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-
-    it('marketplace:add should show usage without args', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      marketplace.marketplaceCommands['marketplace:add']();
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-
-    it('marketplace:remove should show usage without args', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      marketplace.marketplaceCommands['marketplace:remove']();
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('skills commands', () => {
-    it('skills:official should be a function', () => {
-      expect(typeof commands.commands['skills:official']).toBe('function');
-    });
-
-    it('skills:install-official should be a function', () => {
-      expect(typeof commands.commands['skills:install-official']).toBe('function');
-    });
-
-    it('skills:install-all should be a function', () => {
-      expect(typeof commands.commands['skills:install-all']).toBe('function');
-    });
-
-    it('skills:search should be a function', () => {
-      expect(typeof commands.commands['skills:search']).toBe('function');
-    });
-
-    it('skills:validate should be a function', () => {
-      expect(typeof commands.commands['skills:validate']).toBe('function');
-    });
-
-    it('skills:update should be a function', () => {
-      expect(typeof commands.commands['skills:update']).toBe('function');
-    });
-
-    it('skills:publish should be a function', () => {
-      expect(typeof commands.commands['skills:publish']).toBe('function');
-    });
-
-    it('skills:search should show usage without args', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands['skills:search']();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Usage');
-      consoleSpy.mockRestore();
-    });
-
-    it('skills:install-official should show usage without args', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands['skills:install-official']();
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('config commands', () => {
-    it('config should be a function', () => {
-      expect(typeof commands.commands.config).toBe('function');
-    });
-
-    it('config:validate should be a function', () => {
-      expect(typeof commands.commands['config:validate']).toBe('function');
-    });
-
-    it('config:backup should be a function', () => {
-      expect(typeof commands.commands['config:backup']).toBe('function');
-    });
-
-    it('config:rollback should be a function', () => {
-      expect(typeof commands.commands['config:rollback']).toBe('function');
-    });
-
-    it('config:diff should be a function', () => {
-      expect(typeof commands.commands['config:diff']).toBe('function');
-    });
-
-    it('config:validate should not throw', () => {
-      expect(() => commands.commands['config:validate']()).not.toThrow();
-    });
-
-    it('config:backup should not throw', () => {
-      expect(() => commands.commands['config:backup']()).not.toThrow();
-    });
-  });
-
-  describe('quality gate commands', () => {
-    let exitSpy;
-
-    beforeEach(() => {
-      // Mock process.exit to prevent test suite termination
-      exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
-    });
-
-    afterEach(() => {
-      if (exitSpy) exitSpy.mockRestore();
-    });
-
-    it('qg:check should be a function', () => {
-      expect(typeof commands.commands['qg:check']).toBe('function');
-    });
-
-    it('qg:rules should be a function', () => {
-      expect(typeof commands.commands['qg:rules']).toBe('function');
-    });
-
-    it('qg:init should be a function', () => {
-      expect(typeof commands.commands['qg:init']).toBe('function');
-    });
-
-    it('qg:check should call process.exit', async () => {
-      await commands.commands['qg:check']();
-      expect(exitSpy).toHaveBeenCalled();
-    });
-
-    it('qg:rules should not throw', () => {
-      expect(() => commands.commands['qg:rules']()).not.toThrow();
-    });
-
-    it('qg:init should not throw', () => {
-      expect(() => commands.commands['qg:init']()).not.toThrow();
-    });
-  });
-
-  describe('workflow commands', () => {
-    it('workflow should be an async function', () => {
-      expect(typeof commands.commands.workflow).toBe('function');
-    });
-
-    it('knowledge should be an async function', () => {
-      expect(typeof commands.commands.knowledge).toBe('function');
-    });
-
-    it('notebooklm should be an async function', () => {
-      expect(typeof commands.commands.notebooklm).toBe('function');
-    });
-
-    it('workflow should not throw', async () => {
-      await expect(async () => {
-        await commands.commands.workflow();
-      }).not.toThrow();
-    });
-
-    it('workflow should show usage without args', async () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      await commands.commands.workflow();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('Usage');
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('changelog command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands.changelog).toBe('function');
-    });
-
-    it('should not throw', () => {
-      expect(() => commands.commands.changelog()).not.toThrow();
-    });
-
-    it('should show usage without proper git context', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.changelog();
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('doctor command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands.doctor).toBe('function');
-    });
-
-    it('should not throw', () => {
-      expect(() => commands.commands.doctor()).not.toThrow();
-    });
-
-    it('should display health info', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.doctor();
-      expect(consoleSpy).toHaveBeenCalled();
-      const output = consoleSpy.mock.calls.flat().join(' ');
-      expect(output).toContain('SMC') || expect(output).toContain('Health');
-      consoleSpy.mockRestore();
-    });
-  });
-
-  // ============================================================================
-  // Additional Command Coverage Tests
-  // ============================================================================
-
-  describe('init:interactive command', () => {
-    it('should be a function', () => {
-      expect(typeof commands.commands['init:interactive']).toBe('function');
-    });
-  });
-
-  describe('CopyMode enum', () => {
-    it('should have BACKUP constant', () => {
-      expect(CopyMode.BACKUP).toBeDefined();
-    });
-
-    it('should have SAFE constant', () => {
-      expect(CopyMode.SAFE).toBeDefined();
-    });
-
-    it('should have FORCE constant', () => {
-      expect(CopyMode.FORCE).toBeDefined();
-    });
-
-    it('should have different values for each mode', () => {
-      expect(CopyMode.BACKUP).not.toBe(CopyMode.SAFE);
-      expect(CopyMode.SAFE).not.toBe(CopyMode.FORCE);
-      expect(CopyMode.BACKUP).not.toBe(CopyMode.FORCE);
-    });
-  });
-
-  describe('runCommand edge cases', () => {
-    it('should handle command with undefined args', async () => {
-      await expect(async () => {
-        await commands.runCommand('version', undefined);
-      }).not.toThrow();
-    });
-
-    it('should handle command with empty args array', async () => {
-      await expect(async () => {
-        await commands.runCommand('version', []);
-      }).not.toThrow();
-    });
-
-    it('should handle command with single string arg', async () => {
-      await expect(async () => {
-        await commands.runCommand('status', []);
-      }).not.toThrow();
-    });
-  });
-
-  describe('version command details', () => {
-    it('should output version with v prefix', async () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      await commands.commands.version();
-      expect(consoleSpy).toHaveBeenCalled();
-      const output = consoleSpy.mock.calls[0][0];
-      expect(output).toMatch(/^v\d+\.\d+\.\d+/);
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('sync command variations', () => {
-    it('should handle empty args', async () => {
-      await expect(async () => {
-        await commands.commands.sync();
-      }).not.toThrow();
-    });
-
-    it('should handle force flag', async () => {
-      await expect(async () => {
-        await commands.commands.sync('--force');
-      }).not.toThrow();
-    });
-  });
-
-  describe('migrate command details', () => {
-    it('should handle with --dry-run flag', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.migrate('--dry-run');
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('skill:list details', () => {
-    it('should output skills information', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands['skill:list']();
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('agent command details', () => {
-    it('should handle empty task gracefully', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.agent('');
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle multi-word task', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.agent('build a rest api with authentication');
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('template command edge cases', () => {
-    it('should handle path with spaces', () => {
-      expect(() => commands.commands.template('/tmp/test project')).not.toThrow();
-    });
-
-    it('should handle multiple flags', () => {
-      expect(() => commands.commands.template('--safe', '--force')).not.toThrow();
-    });
-
-    it('should handle path before flags', () => {
-      expect(() => commands.commands.template('/tmp/test', '--safe')).not.toThrow();
-    });
-  });
-
-  describe('changelog command variations', () => {
-    it('should handle --help flag', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.changelog('--help');
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('knowledge command', () => {
-    it('should be async function', () => {
-      expect(typeof commands.commands.knowledge).toBe('function');
-    });
-
-    it('should handle no args', async () => {
-      await expect(async () => {
-        await commands.commands.knowledge();
-      }).not.toThrow();
-    });
-  });
-
-  describe('notebooklm command', () => {
-    it('should be async function', () => {
-      expect(typeof commands.commands.notebooklm).toBe('function');
-    });
-
-    it('should handle no args', async () => {
-      await expect(async () => {
-        await commands.commands.notebooklm();
-      }).not.toThrow();
-    });
-  });
-
-  // ============================================================================
-  // Skills Commands Detailed Tests
-  // ============================================================================
-
-  describe('skills:official command', () => {
-    it('should not throw', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      expect(() => commands.commands['skills:official']()).not.toThrow();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('skills:validate command', () => {
-    it('should not throw', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      expect(() => commands.commands['skills:validate']()).not.toThrow();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('skills:update command', () => {
-    it('should not throw', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      expect(() => commands.commands['skills:update']()).not.toThrow();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('skills:publish command', () => {
-    it('should not throw', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      expect(() => commands.commands['skills:publish']()).not.toThrow();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('skills:install-all command', () => {
-    it('should not throw', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      expect(() => commands.commands['skills:install-all']()).not.toThrow();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  // ============================================================================
-  // Config Commands Detailed Tests
-  // ============================================================================
-
-  describe('config:rollback command', () => {
-    it('should not throw', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      expect(() => commands.commands['config:rollback']()).not.toThrow();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('config:diff command', () => {
-    it('should not throw', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      expect(() => commands.commands['config:diff']()).not.toThrow();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('config command (main)', () => {
-    it('should not throw', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      expect(() => commands.commands.config()).not.toThrow();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  // ============================================================================
-  // Skill Command Edge Cases
-  // ============================================================================
-
-  describe('skill:install with source', () => {
-    it('should handle source argument', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands['skill:install']('https://github.com/owner/repo');
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle file:// source', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands['skill:install']('file:///path/to/skill');
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('skill:check with skill name', () => {
-    it('should handle skill name argument', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands['skill:check']('test-skill');
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle skill with kebab-case name', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands['skill:check']('my-test-skill-123');
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  // ============================================================================
-  // Additional Edge Cases
-  // ============================================================================
-
-  describe('kickoff with arguments', () => {
-    it('should handle project name argument', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      expect(() => commands.commands.kickoff('my-project')).not.toThrow();
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('status with flags', () => {
-    it('should handle --verbose flag', () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-      commands.commands.status('--verbose');
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-  });
-});