sumulige-claude 1.0.9 → 1.0.11

package/tests/marketplace.test.js

@@ -0,0 +1,304 @@
+/**
+ * Marketplace 模块单元测试
+ */
+
+const fs = require('fs');
+const path = require('path');
+const mockFs = require('mock-fs');
+const sinon = require('sinon');
+
+// 在 mock 之前加载模块
+const marketplace = require('../lib/marketplace');
+
+// 手动实现 parseSimpleYaml 用于测试（与模块中相同的实现）
+function parseSimpleYaml(content) {
+  const result = { skills: [] };
+  let currentSection = null;
+  let currentSkill = null;
+  let currentKey = null;
+
+  content.split('\n').forEach(line => {
+    const trimmed = line.trim();
+    const indent = line.search(/\S/);
+
+    // Skip empty lines and comments
+    if (!trimmed || trimmed.startsWith('#')) {
+      return;
+    }
+
+    // Version
+    if (trimmed.startsWith('version:')) {
+      result.version = parseInt(trimmed.split(':')[1].trim());
+      return;
+    }
+
+    // Skills array starts
+    if (trimmed === 'skills:') {
+      currentSection = 'skills';
+      return;
+    }
+
+    // New skill entry (starts with -)
+    if (trimmed.startsWith('- name:')) {
+      if (currentSkill) {
+        result.skills.push(currentSkill);
+      }
+      currentSkill = { name: trimmed.split(':')[1].trim() };
+      return;
+    }
+
+    // Skill properties
+    if (currentSection === 'skills' && currentSkill) {
+      // Determine nesting level by indent
+      const isTopLevel = indent === 2;
+
+      if (isTopLevel) {
+        const match = trimmed.match(/^([\w-]+):\s*(.*)$/);
+        if (match) {
+          currentKey = match[1];
+          let value = match[2].trim();
+
+          // Handle arrays
+          if (value === '[]') {
+            value = [];
+          } else if (value === 'true') {
+            value = true;
+          } else if (value === 'false') {
+            value = false;
+          } else if (value.startsWith('"') || value.startsWith("'")) {
+            value = value.slice(1, -1);
+          }
+
+          // Initialize nested objects for special keys
+          if (['source', 'target', 'author', 'sync'].includes(currentKey)) {
+            currentSkill[currentKey] = {};
+            // Store the value for potential later use
+            currentSkill[currentKey]._value = value;
+          } else {
+            currentSkill[currentKey] = value;
+          }
+        }
+      } else if (currentKey) {
+        // Nested property
+        const match = trimmed.match(/^([\w-]+):\s*(.*)$/);
+        if (match) {
+          let value = match[2].trim();
+          if (value === 'true') value = true;
+          if (value === 'false') value = false;
+          if (value === '[]') value = [];
+          currentSkill[currentKey][match[1]] = value;
+        }
+      }
+    }
+  });
+
+  // Push last skill
+  if (currentSkill) {
+    result.skills.push(currentSkill);
+  }
+
+  return result;
+}
+
+describe('Marketplace Module', () => {
+  let consoleLogStub;
+  let execSyncStub;
+
+  beforeEach(() => {
+    jest.resetModules();
+    // Mock 文件系统，保留项目目录
+    mockFs({
+      '/project': {
+        'sources.yaml': `version: 1
+skills:
+  - name: test-skill
+    description: "A test skill"
+    native: true
+  - name: external-skill
+    description: "External skill"
+    source:
+      repo: owner/repo`,
+        '.claude-plugin': {
+          'marketplace.json': JSON.stringify({
+            plugins: [],
+            metadata: {
+              skill_count: 2,
+              categories: {
+                tools: { name: 'CLI 工具', icon: '🔧' }
+              }
+            }
+          })
+        },
+        'config': {
+          'skill-categories.json': JSON.stringify({
+            tools: { name: 'CLI 工具', icon: '🔧' },
+            workflow: { name: '工作流编排', icon: '🎼' }
+          })
+        }
+      }
+    }, {
+      // 不 mock 项目的 lib 目录
+      [path.join(__dirname, '../lib')]: true
+    });
+
+    // Stub console.log to avoid actual output
+    consoleLogStub = sinon.stub(console, 'log');
+  });
+
+  afterEach(() => {
+    mockFs.restore();
+    if (consoleLogStub) consoleLogStub.restore();
+    if (execSyncStub) execSyncStub.restore();
+  });
+
+  describe('parseSimpleYaml', () => {
+    it('should parse version number', () => {
+      const yaml = `version: 1
+skills:
+  - name: test-skill`;
+
+      const result = parseSimpleYaml(yaml);
+
+      expect(result.version).toBe(1);
+    });
+
+    it('should parse skill names', () => {
+      const yaml = `skills:
+  - name: skill-one
+  - name: skill-two
+  - name: skill-three`;
+
+      const result = parseSimpleYaml(yaml);
+
+      expect(result.skills).toHaveLength(3);
+      expect(result.skills[0].name).toBe('skill-one');
+      expect(result.skills[1].name).toBe('skill-two');
+      expect(result.skills[2].name).toBe('skill-three');
+    });
+
+    it('should handle empty skills array', () => {
+      const yaml = `version: 1`;
+
+      const result = parseSimpleYaml(yaml);
+
+      expect(result.skills).toEqual([]);
+    });
+
+    it('should skip comments', () => {
+      const yaml = `# Comment
+skills:
+  # Another comment
+  - name: test`;
+
+      const result = parseSimpleYaml(yaml);
+
+      expect(result.skills).toHaveLength(1);
+      expect(result.skills[0].name).toBe('test');
+    });
+
+    it('should handle empty lines', () => {
+      const yaml = `skills:
+
+  - name: test
+
+  - name: test2`;
+
+      const result = parseSimpleYaml(yaml);
+
+      expect(result.skills).toHaveLength(2);
+    });
+  });
+
+  describe('marketplaceCommands', () => {
+    describe('marketplace:list', () => {
+      it('should be a function', () => {
+        expect(typeof marketplace.marketplaceCommands['marketplace:list']).toBe('function');
+      });
+
+      it('should output to console', () => {
+        marketplace.marketplaceCommands['marketplace:list']();
+
+        expect(consoleLogStub.called).toBe(true);
+      });
+    });
+
+    describe('marketplace:install', () => {
+      it('should show usage when no skill name provided', () => {
+        marketplace.marketplaceCommands['marketplace:install']();
+
+        expect(consoleLogStub.called).toBe(true);
+        const output = consoleLogStub.args.flat().join(' ');
+        expect(output).toContain('Usage');
+      });
+    });
+
+    describe('marketplace:sync', () => {
+      it('should be a function', () => {
+        expect(typeof marketplace.marketplaceCommands['marketplace:sync']).toBe('function');
+      });
+
+      it('should output sync message', () => {
+        marketplace.marketplaceCommands['marketplace:sync']();
+
+        expect(consoleLogStub.called).toBe(true);
+      });
+    });
+
+    describe('marketplace:add', () => {
+      it('should show usage when no repo provided', () => {
+        marketplace.marketplaceCommands['marketplace:add']();
+
+        expect(consoleLogStub.called).toBe(true);
+        const output = consoleLogStub.args.flat().join(' ');
+        expect(output).toContain('Usage');
+      });
+
+      it('should validate repo format', () => {
+        marketplace.marketplaceCommands['marketplace:add']('invalid-repo-format');
+
+        const output = consoleLogStub.args.flat().join(' ');
+        expect(output).toContain('Invalid');
+      });
+    });
+
+    describe('marketplace:remove', () => {
+      it('should show usage when no skill name provided', () => {
+        marketplace.marketplaceCommands['marketplace:remove']();
+
+        expect(consoleLogStub.called).toBe(true);
+        const output = consoleLogStub.args.flat().join(' ');
+        expect(output).toContain('Usage');
+      });
+    });
+
+    describe('marketplace:status', () => {
+      it('should be a function', () => {
+        expect(typeof marketplace.marketplaceCommands['marketplace:status']).toBe('function');
+      });
+
+      it('should output status information', () => {
+        marketplace.marketplaceCommands['marketplace:status']();
+
+        expect(consoleLogStub.called).toBe(true);
+      });
+    });
+  });
+
+  describe('exports', () => {
+    it('should export marketplaceCommands object', () => {
+      expect(marketplace.marketplaceCommands).toBeDefined();
+      expect(typeof marketplace.marketplaceCommands).toBe('object');
+    });
+
+    it('should export all marketplace commands', () => {
+      const commands = marketplace.marketplaceCommands;
+
+      expect(commands['marketplace:list']).toBeDefined();
+      expect(commands['marketplace:install']).toBeDefined();
+      expect(commands['marketplace:sync']).toBeDefined();
+      expect(commands['marketplace:add']).toBeDefined();
+      expect(commands['marketplace:remove']).toBeDefined();
+      expect(commands['marketplace:status']).toBeDefined();
+    });
+  });
+});

package/tests/migrations.test.js

@@ -0,0 +1,187 @@
+/**
+ * Migrations 模块单元测试
+ */
+
+const fs = require('fs');
+const path = require('path');
+const mockFs = require('mock-fs');
+
+// 在 mock 之前加载模块
+const migrations = require('../lib/migrations');
+
+describe('Migrations Module', () => {
+  let originalFs = { ...fs };
+
+  beforeEach(() => {
+    // Mock 文件系统，保留一些必要的路径
+    mockFs({
+      '/test-project': {
+        '.claude': {}
+      }
+    }, {
+      // 不 mock 项目的 lib 目录
+      [path.join(__dirname, '../lib')]: true
+    });
+  });
+
+  afterEach(() => {
+    mockFs.restore();
+  });
+
+  describe('getProjectVersion', () => {
+    it('should return 1.0.0 when version file does not exist', () => {
+      const version = migrations.getProjectVersion('/test-project');
+      expect(version).toBe('1.0.0');
+    });
+
+    it('should read version from file', () => {
+      const versionFile = path.join('/test-project', '.claude', '.version');
+      fs.writeFileSync(versionFile, '1.0.5\n');
+
+      const version = migrations.getProjectVersion('/test-project');
+      expect(version).toBe('1.0.5');
+    });
+
+    it('should trim whitespace from version', () => {
+      const versionFile = path.join('/test-project', '.claude', '.version');
+      fs.writeFileSync(versionFile, '  1.0.8  \n');
+
+      const version = migrations.getProjectVersion('/test-project');
+      expect(version).toBe('1.0.8');
+    });
+
+    it('should return 1.0.0 on read error', () => {
+      const version = migrations.getProjectVersion('/nonexistent');
+      expect(version).toBe('1.0.0');
+    });
+  });
+
+  describe('setProjectVersion', () => {
+    it('should write version to file', () => {
+      migrations.setProjectVersion('/test-project', '1.0.7');
+
+      const versionFile = path.join('/test-project', '.claude', '.version');
+      expect(fs.existsSync(versionFile)).toBe(true);
+
+      const content = fs.readFileSync(versionFile, 'utf-8');
+      expect(content.trim()).toBe('1.0.7');
+    });
+
+    it('should add newline after version', () => {
+      migrations.setProjectVersion('/test-project', '1.0.9');
+
+      const versionFile = path.join('/test-project', '.claude', '.version');
+      const content = fs.readFileSync(versionFile, 'utf-8');
+      expect(content).toBe('1.0.9\n');
+    });
+
+    it('should create .claude directory if not exists', () => {
+      // 注意：setProjectVersion 不会自动创建目录
+      // 需要先创建目录
+      fs.mkdirSync(path.join('/new-project', '.claude'), { recursive: true });
+      migrations.setProjectVersion('/new-project', '1.0.1');
+
+      const versionFile = path.join('/new-project', '.claude', '.version');
+      expect(fs.existsSync(versionFile)).toBe(true);
+    });
+  });
+
+  describe('compareVersions', () => {
+    it('should return -1 when v1 < v2', () => {
+      expect(migrations.compareVersions('1.0.0', '1.0.1')).toBe(-1);
+      expect(migrations.compareVersions('1.0.0', '1.1.0')).toBe(-1);
+      expect(migrations.compareVersions('1.0.0', '2.0.0')).toBe(-1);
+    });
+
+    it('should return 1 when v1 > v2', () => {
+      expect(migrations.compareVersions('1.0.1', '1.0.0')).toBe(1);
+      expect(migrations.compareVersions('1.1.0', '1.0.0')).toBe(1);
+      expect(migrations.compareVersions('2.0.0', '1.0.0')).toBe(1);
+    });
+
+    it('should return 0 when v1 === v2', () => {
+      expect(migrations.compareVersions('1.0.0', '1.0.0')).toBe(0);
+      expect(migrations.compareVersions('1.5.10', '1.5.10')).toBe(0);
+    });
+
+    it('should handle version comparison correctly', () => {
+      // Patch version comparison
+      expect(migrations.compareVersions('1.0.5', '1.0.10')).toBe(-1);
+      expect(migrations.compareVersions('1.0.10', '1.0.5')).toBe(1);
+
+      // Minor version comparison
+      expect(migrations.compareVersions('1.5.0', '1.10.0')).toBe(-1);
+
+      // Major version comparison
+      expect(migrations.compareVersions('2.0.0', '10.0.0')).toBe(-1);
+    });
+
+    it('should handle version strings with different formats', () => {
+      expect(migrations.compareVersions('1', '1.0.0')).toBe(0);
+      expect(migrations.compareVersions('1.0', '1.0.0')).toBe(0);
+    });
+  });
+
+  describe('runMigrations', () => {
+    it('should return success when already at latest version', () => {
+      // 设置当前版本为最新
+      migrations.setProjectVersion('/test-project', migrations.TEMPLATE_VERSION);
+
+      const result = migrations.runMigrations('/test-project', true);
+
+      expect(result.success).toBe(true);
+      expect(result.migrations).toEqual([]);
+      expect(result.currentVersion).toBe(migrations.TEMPLATE_VERSION);
+    });
+
+    it('should return success when version is newer than template', () => {
+      // 设置一个未来版本
+      migrations.setProjectVersion('/test-project', '2.0.0');
+
+      const result = migrations.runMigrations('/test-project', true);
+
+      expect(result.success).toBe(true);
+      expect(result.migrations).toEqual([]);
+    });
+
+    it('should return correct structure when pending migrations exist', () => {
+      // 设置旧版本
+      migrations.setProjectVersion('/test-project', '1.0.0');
+
+      // 创建需要迁移的 settings.json
+      const settingsFile = path.join('/test-project', '.claude', 'settings.json');
+      fs.writeFileSync(
+        settingsFile,
+        JSON.stringify({ matcher: {}, hooks: [] }, null, 2)
+      );
+
+      const result = migrations.runMigrations('/test-project', true);
+
+      expect(result).toBeDefined();
+      expect(typeof result.success).toBe('boolean');
+      expect(result.currentVersion).toBeDefined();
+    });
+
+    it('should handle missing settings.json gracefully', () => {
+      migrations.setProjectVersion('/test-project', '1.0.0');
+
+      const result = migrations.runMigrations('/test-project', true);
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('exports', () => {
+    it('should export TEMPLATE_VERSION constant', () => {
+      expect(migrations.TEMPLATE_VERSION).toBeDefined();
+      expect(typeof migrations.TEMPLATE_VERSION).toBe('string');
+    });
+
+    it('should export all functions', () => {
+      expect(typeof migrations.getProjectVersion).toBe('function');
+      expect(typeof migrations.setProjectVersion).toBe('function');
+      expect(typeof migrations.compareVersions).toBe('function');
+      expect(typeof migrations.runMigrations).toBe('function');
+    });
+  });
+});

package/tests/utils.test.js

@@ -0,0 +1,167 @@
+/**
+ * Utils 模块单元测试
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const utils = require('../lib/utils');
+
+describe('Utils Module', () => {
+  describe('copyRecursive', () => {
+    let tempSrc, tempDest;
+
+    beforeEach(() => {
+      // 创建临时测试目录
+      tempSrc = path.join(os.tmpdir(), 'test-src-' + Date.now());
+      tempDest = path.join(os.tmpdir(), 'test-dest-' + Date.now());
+      fs.mkdirSync(tempSrc, { recursive: true });
+    });
+
+    afterEach(() => {
+      // 清理临时目录
+      if (fs.existsSync(tempSrc)) {
+        fs.rmSync(tempSrc, { recursive: true, force: true });
+      }
+      if (fs.existsSync(tempDest)) {
+        fs.rmSync(tempDest, { recursive: true, force: true });
+      }
+    });
+
+    it('should return 0 when source does not exist', () => {
+      const nonExistent = path.join(os.tmpdir(), 'non-existent-' + Date.now());
+      const count = utils.copyRecursive(nonExistent, tempDest);
+
+      expect(count).toBe(0);
+    });
+
+    it('should copy files recursively', () => {
+      // 创建测试文件结构
+      fs.mkdirSync(path.join(tempSrc, 'subdir'));
+      fs.writeFileSync(path.join(tempSrc, 'file1.txt'), 'content1');
+      fs.writeFileSync(path.join(tempSrc, 'subdir', 'file2.txt'), 'content2');
+
+      const count = utils.copyRecursive(tempSrc, tempDest);
+
+      expect(count).toBe(2);
+      expect(fs.existsSync(path.join(tempDest, 'file1.txt'))).toBe(true);
+      expect(fs.existsSync(path.join(tempDest, 'subdir', 'file2.txt'))).toBe(true);
+    });
+
+    it('should set execute permission for script files', () => {
+      fs.writeFileSync(path.join(tempSrc, 'test.sh'), '#!/bin/bash\necho test');
+      fs.writeFileSync(path.join(tempSrc, 'test.cjs'), 'console.log("test");');
+      fs.writeFileSync(path.join(tempSrc, 'test.txt'), 'plain text');
+
+      utils.copyRecursive(tempSrc, tempDest);
+
+      // 检查 .sh 文件权限
+      const shStats = fs.statSync(path.join(tempDest, 'test.sh'));
+      const cjsStats = fs.statSync(path.join(tempDest, 'test.cjs'));
+      const txtStats = fs.statSync(path.join(tempDest, 'test.txt'));
+
+      // 检查执行权限 (0o755 的执行位)
+      expect(shStats.mode & 0o111).toBeTruthy();
+      expect(cjsStats.mode & 0o111).toBeTruthy();
+      // txt 文件不应该有执行权限
+      expect(txtStats.mode & 0o111).toBeFalsy();
+    });
+
+    it('should not overwrite when overwrite=false', () => {
+      fs.writeFileSync(path.join(tempSrc, 'file.txt'), 'new content');
+      fs.mkdirSync(tempDest, { recursive: true });
+      fs.writeFileSync(path.join(tempDest, 'file.txt'), 'old content');
+
+      const count = utils.copyRecursive(tempSrc, tempDest, false);
+
+      expect(count).toBe(0);
+      const content = fs.readFileSync(path.join(tempDest, 'file.txt'), 'utf-8');
+      expect(content).toBe('old content');
+    });
+
+    it('should overwrite when overwrite=true', () => {
+      fs.writeFileSync(path.join(tempSrc, 'file.txt'), 'new content');
+      fs.mkdirSync(tempDest, { recursive: true });
+      fs.writeFileSync(path.join(tempDest, 'file.txt'), 'old content');
+
+      const count = utils.copyRecursive(tempSrc, tempDest, true);
+
+      expect(count).toBe(1);
+      const content = fs.readFileSync(path.join(tempDest, 'file.txt'), 'utf-8');
+      expect(content).toBe('new content');
+    });
+  });
+
+  describe('ensureDir', () => {
+    it('should create directory if not exists', () => {
+      const tempDir = path.join(os.tmpdir(), 'test-ensure-' + Date.now());
+
+      utils.ensureDir(tempDir);
+
+      expect(fs.existsSync(tempDir)).toBe(true);
+
+      // 清理
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it('should not error if directory already exists', () => {
+      const tempDir = path.join(os.tmpdir(), 'test-ensure-' + Date.now());
+      fs.mkdirSync(tempDir, { recursive: true });
+
+      expect(() => utils.ensureDir(tempDir)).not.toThrow();
+
+      // 清理
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it('should create nested directories', () => {
+      const tempDir = path.join(os.tmpdir(), 'test-nested-' + Date.now(), 'level1', 'level2', 'level3');
+
+      utils.ensureDir(tempDir);
+
+      expect(fs.existsSync(tempDir)).toBe(true);
+
+      // 清理
+      fs.rmSync(path.join(os.tmpdir(), 'test-nested-' + Date.now()), { recursive: true, force: true });
+    });
+  });
+
+  describe('toTitleCase', () => {
+    it('should convert string to title case', () => {
+      expect(utils.toTitleCase('hello world')).toBe('Hello World');
+      expect(utils.toTitleCase('foo-bar')).toBe('Foo-Bar');
+    });
+
+    it('should handle single word', () => {
+      expect(utils.toTitleCase('hello')).toBe('Hello');
+    });
+
+    it('should handle empty string', () => {
+      expect(utils.toTitleCase('')).toBe('');
+    });
+
+    it('should handle already capitalized string', () => {
+      expect(utils.toTitleCase('Hello World')).toBe('Hello World');
+    });
+
+    it('should handle strings with multiple spaces', () => {
+      expect(utils.toTitleCase('hello   world')).toBe('Hello   World');
+    });
+
+    it('should preserve special characters', () => {
+      // 下划线 _ 是单词字符(\w)，所以 _t 中的 t 前面没有单词边界
+      expect(utils.toTitleCase('hello-world_test')).toBe('Hello-World_test');
+      // 连字符 - 不是单词字符，所以后面的字母会被大写
+      expect(utils.toTitleCase('hello-world test')).toBe('Hello-World Test');
+    });
+  });
+
+  describe('exports', () => {
+    it('should export all functions', () => {
+      expect(typeof utils.copyRecursive).toBe('function');
+      expect(typeof utils.ensureDir).toBe('function');
+      expect(typeof utils.toTitleCase).toBe('function');
+    });
+  });
+});