sumulige-claude 1.2.0 → 1.3.0

package/tests/sync-external.test.js

@@ -0,0 +1,214 @@
+/**
+ * Sync External Skills 脚本单元测试
+ * 测试外部技能同步功能
+ */
+
+const path = require('path');
+
+describe('Sync External Skills', () => {
+  describe('YAML parsing', () => {
+    it('should parse valid sources.yaml structure', () => {
+      const yamlStructure = {
+        version: 1,
+        skills: [
+          {
+            name: 'test-skill',
+            description: 'A test skill',
+            native: true
+          },
+          {
+            name: 'external-skill',
+            description: 'External skill',
+            source: {
+              repo: 'owner/repo',
+              ref: 'main',
+              path: '/skills/external'
+            },
+            target: {
+              path: 'template/.claude/skills/external-skill'
+            }
+          }
+        ]
+      };
+
+      expect(yamlStructure.version).toBeDefined();
+      expect(yamlStructure.skills).toBeInstanceOf(Array);
+      expect(yamlStructure.skills[0].name).toBe('test-skill');
+      expect(yamlStructure.skills[0].native).toBe(true);
+      expect(yamlStructure.skills[1].source?.repo).toBe('owner/repo');
+    });
+
+    it('should handle skills array', () => {
+      const skills = [
+        { name: 'skill1', native: true },
+        { name: 'skill2', source: { repo: 'owner/repo' } }
+      ];
+
+      expect(skills).toHaveLength(2);
+      expect(skills[0].name).toBe('skill1');
+      expect(skills[1].name).toBe('skill2');
+    });
+
+    it('should parse boolean native field', () => {
+      const nativeSkill = { native: true };
+      const externalSkill = { native: false };
+
+      expect(nativeSkill.native).toBe(true);
+      expect(externalSkill.native).toBe(false);
+    });
+
+    it('should parse nested source configuration', () => {
+      const source = {
+        repo: 'owner/repo',
+        ref: 'main',
+        path: '/path/to/skill'
+      };
+
+      expect(source.repo).toBe('owner/repo');
+      expect(source.ref).toBe('main');
+      expect(source.path).toBe('/path/to/skill');
+    });
+
+    it('should parse sync configuration', () => {
+      const sync = {
+        include: ['*.md', '*.json'],
+        exclude: ['node_modules', '*.lock']
+      };
+
+      expect(sync.include).toContain('*.md');
+      expect(sync.exclude).toContain('node_modules');
+    });
+  });
+
+  describe('File pattern matching', () => {
+    it('should match include patterns', () => {
+      const include = ['*.md', '*.json'];
+
+      // .md file matches
+      const mdRegex = new RegExp(include[0].replace('*', '.*'));
+      expect(mdRegex.test('file.md')).toBe(true);
+      expect(mdRegex.test('file.txt')).toBe(false);
+
+      // .json file matches
+      const jsonRegex = new RegExp(include[1].replace('*', '.*'));
+      expect(jsonRegex.test('file.json')).toBe(true);
+      expect(jsonRegex.test('file.txt')).toBe(false);
+    });
+
+    it('should match exclude patterns', () => {
+      const exclude = ['node_modules', '*.lock'];
+
+      // node_modules exclusion
+      const nmRegex = new RegExp(exclude[0].replace('*', '.*'));
+      expect(nmRegex.test('node_modules')).toBe(true);
+      expect(nmRegex.test('src')).toBe(false);
+
+      // .lock exclusion
+      const lockRegex = new RegExp(exclude[1].replace('*', '.*'));
+      expect(lockRegex.test('package-lock.json')).toBe(true);
+      expect(lockRegex.test('package.json')).toBe(false);
+    });
+  });
+
+  describe('Git operations', () => {
+    it('should construct correct git clone command', () => {
+      const repo = 'owner/repo';
+      const ref = 'main';
+      const targetDir = '/tmp/test';
+
+      const expectedUrl = `https://github.com/${repo}.git`;
+      const command = `git clone --depth 1 --branch ${ref} ${expectedUrl} ${targetDir}`;
+
+      expect(command).toContain('git clone');
+      expect(command).toContain('--depth 1');
+      expect(command).toContain('--branch main');
+      expect(command).toContain('https://github.com/owner/repo.git');
+    });
+  });
+
+  describe('Source JSON structure', () => {
+    it('should create valid JSON structure', () => {
+      const skill = {
+        name: 'test-skill',
+        description: 'A test skill',
+        source: {
+          repo: 'owner/repo',
+          path: '/skills/test',
+          ref: 'main'
+        },
+        author: 'Test Author',
+        license: 'MIT',
+        homepage: 'https://example.com',
+        verified: true
+      };
+
+      const expectedFields = ['name', 'description', 'source', 'author', 'license', 'homepage', 'verified'];
+      expectedFields.forEach(field => {
+        expect(skill).toHaveProperty(field);
+      });
+    });
+
+    it('should include synced_at timestamp', () => {
+      const sourceJson = {
+        name: 'test-skill',
+        source: {
+          repo: 'owner/repo',
+          ref: 'main',
+          synced_at: new Date().toISOString()
+        }
+      };
+
+      expect(sourceJson.source.synced_at).toBeDefined();
+      expect(new Date(sourceJson.source.synced_at)).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('Sync logic', () => {
+    it('should skip native skills', () => {
+      const nativeSkill = { name: 'native-skill', native: true };
+      const shouldSkip = nativeSkill.native === true;
+
+      expect(shouldSkip).toBe(true);
+    });
+
+    it('should require source.repo for external skills', () => {
+      const externalSkill = { name: 'external-skill' };
+      const hasRepo = externalSkill.source?.repo;
+
+      expect(hasRepo).toBeUndefined();
+    });
+
+    it('should validate required fields', () => {
+      const validSkill = {
+        name: 'test',
+        source: { repo: 'owner/repo' },
+        target: { path: '/path' }
+      };
+
+      expect(validSkill.name).toBeDefined();
+      expect(validSkill.source?.repo).toBeDefined();
+      expect(validSkill.target?.path).toBeDefined();
+    });
+  });
+
+  describe('File paths', () => {
+    it('should have correct sources.yaml path', () => {
+      const sourcesPath = path.join(__dirname, '..', 'sources.yaml');
+      expect(sourcesPath).toContain('sources.yaml');
+    });
+
+    it('should have correct skills directory path', () => {
+      const skillsDir = path.join(__dirname, '..', 'template', '.claude', 'skills');
+      expect(skillsDir).toContain('template');
+      expect(skillsDir).toContain('.claude');
+      expect(skillsDir).toContain('skills');
+    });
+
+    it('should construct correct temp directory path', () => {
+      const skillName = 'test-skill';
+      const tmpDir = path.join(__dirname, '..', '.tmp', skillName);
+      expect(tmpDir).toContain('.tmp');
+      expect(tmpDir).toContain('test-skill');
+    });
+  });
+});

package/tests/update-registry.test.js

@@ -0,0 +1,251 @@
+/**
+ * Update Registry 脚本单元测试
+ * 测试市场注册表生成功能
+ */
+
+const path = require('path');
+
+describe('Update Registry Script', () => {
+  describe('findSkillDirs', () => {
+    it('should identify skill directories with SKILL.md', () => {
+      const hasSkillFile = 'SKILL.md';
+      expect(hasSkillFile).toBe('SKILL.md');
+    });
+
+    it('should identify skill directories with metadata.yaml', () => {
+      const hasMetadata = 'metadata.yaml';
+      expect(hasMetadata).toBe('metadata.yaml');
+    });
+
+    it('should identify skill directories with .source.json', () => {
+      const hasSourceJson = '.source.json';
+      expect(hasSourceJson).toBe('.source.json');
+    });
+
+    it('should skip template directory', () => {
+      const skipDirs = ['template', 'examples', '__tests__'];
+      expect(skipDirs).toContain('template');
+      expect(skipDirs).toContain('examples');
+      expect(skipDirs).toContain('__tests__');
+    });
+
+    it('should not skip regular skill directories', () => {
+      const skipDirs = ['template', 'examples', '__tests__'];
+      expect(skipDirs).not.toContain('my-skill');
+      expect(skipDirs).not.toContain('code-reviewer');
+    });
+  });
+
+  describe('parseMetadata', () => {
+    it('should parse simple key-value pairs', () => {
+      const yamlContent = `
+name: test-skill
+description: A test skill
+version: 1.0.0
+      `;
+
+      expect(yamlContent).toContain('name:');
+      expect(yamlContent).toContain('description:');
+      expect(yamlContent).toContain('version:');
+    });
+
+    it('should parse boolean values', () => {
+      const yamlTrue = 'enabled: true';
+      const yamlFalse = 'enabled: false';
+
+      expect(yamlTrue).toContain('true');
+      expect(yamlFalse).toContain('false');
+    });
+
+    it('should parse array values', () => {
+      const yamlArray = 'tags: [tag1, tag2, tag3]';
+      const yamlEmptyArray = 'tags: []';
+
+      expect(yamlArray).toContain('[');
+      expect(yamlEmptyArray).toBe('tags: []');
+    });
+
+    it('should skip comments', () => {
+      const yamlWithComments = `
+# This is a comment
+name: test-skill
+# Another comment
+description: Test
+      `;
+
+      const lines = yamlWithComments.split('\n').filter(l => l.trim() && !l.trim().startsWith('#'));
+      expect(lines.length).toBe(2);
+    });
+
+    it('should handle empty YAML', () => {
+      const emptyYaml = '';
+      expect(emptyYaml).toBe('');
+    });
+  });
+
+  describe('parseSourceJson', () => {
+    it('should parse valid JSON', () => {
+      const json = {
+        name: 'test-skill',
+        source: {
+          repo: 'owner/repo',
+          ref: 'main'
+        },
+        synced_at: '2024-01-01T00:00:00.000Z'
+      };
+
+      expect(json.name).toBe('test-skill');
+      expect(json.source.repo).toBe('owner/repo');
+      expect(json.source.ref).toBe('main');
+    });
+
+    it('should handle missing .source.json', () => {
+      const missing = null;
+      expect(missing).toBeNull();
+    });
+  });
+
+  describe('getSkillDescription', () => {
+    it('should extract first non-heading paragraph', () => {
+      const content = `
+# Test Skill
+
+This is the description of the skill.
+
+More details here.
+      `;
+
+      const lines = content.split('\n').filter(l => l.trim() && !l.trim().startsWith('#'));
+      expect(lines[0].trim()).toBe('This is the description of the skill.');
+    });
+
+    it('should skip HTML comments and headings', () => {
+      const content = `
+<!-- This is a comment -->
+# Title
+
+This is real content.
+      `;
+
+      const lines = content.split('\n').filter(l => {
+        const trimmed = l.trim();
+        return trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('>') && !trimmed.startsWith('<!--');
+      });
+      expect(lines[0]).toContain('This is real content');
+    });
+
+    it('should handle empty content', () => {
+      const emptyContent = '';
+      const lines = emptyContent.split('\n').filter(l => l.trim());
+      expect(lines.length).toBe(0);
+    });
+  });
+
+  describe('getSkillCategory', () => {
+    it('should return default category when no match', () => {
+      const pathParts = ['some', 'random', 'path'];
+      const categories = { tools: { name: 'Tools' } };
+
+      const found = pathParts.some(part => categories[part]);
+      expect(found).toBe(false);
+    });
+
+    it('should find category in path', () => {
+      const pathParts = ['tools', 'skill-name'];
+      const categories = { tools: { name: 'Tools' } };
+
+      const found = pathParts.find(part => categories[part]);
+      expect(found).toBe('tools');
+    });
+
+    it('should default to tools category', () => {
+      const defaultCategory = 'tools';
+      expect(defaultCategory).toBe('tools');
+    });
+  });
+
+  describe('generateRegistry structure', () => {
+    it('should have required top-level fields', () => {
+      const registry = {
+        name: 'smc-skills',
+        description: 'Test registry',
+        homepage: 'https://github.com/test/test',
+        owner: { name: 'test' },
+        plugins: [],
+        metadata: {}
+      };
+
+      expect(registry).toHaveProperty('name');
+      expect(registry).toHaveProperty('description');
+      expect(registry).toHaveProperty('homepage');
+      expect(registry).toHaveProperty('owner');
+      expect(registry).toHaveProperty('plugins');
+      expect(registry).toHaveProperty('metadata');
+    });
+
+    it('should create plugin with skills array', () => {
+      const plugin = {
+        name: 'smc-skills',
+        description: 'Test plugin',
+        source: './',
+        skills: ['./skills/skill1', './skills/skill2'],
+        skill_list: [
+          { name: 'skill1', path: './skills/skill1' },
+          { name: 'skill2', path: './skills/skill2' }
+        ]
+      };
+
+      expect(plugin.skills).toHaveLength(2);
+      expect(plugin.skill_list).toHaveLength(2);
+    });
+
+    it('should include metadata with generated_at timestamp', () => {
+      const metadata = {
+        version: '1.0.0',
+        generated_at: new Date().toISOString(),
+        skill_count: 10,
+        categories: {}
+      };
+
+      expect(metadata.generated_at).toBeDefined();
+      expect(new Date(metadata.generated_at)).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('File paths', () => {
+    it('should have correct marketplace.json path', () => {
+      const marketplacePath = path.join(__dirname, '..', '.claude-plugin', 'marketplace.json');
+      expect(marketplacePath).toContain('.claude-plugin');
+      expect(marketplacePath).toContain('marketplace.json');
+    });
+
+    it('should have correct skills directory path', () => {
+      const skillsDir = path.join(__dirname, '..', 'template', '.claude', 'skills');
+      expect(skillsDir).toContain('template');
+      expect(skillsDir).toContain('.claude');
+      expect(skillsDir).toContain('skills');
+    });
+
+    it('should have correct categories file path', () => {
+      const categoriesPath = path.join(__dirname, '..', 'config', 'skill-categories.json');
+      expect(categoriesPath).toContain('config');
+      expect(categoriesPath).toContain('skill-categories.json');
+    });
+  });
+
+  describe('getPackageVersion', () => {
+    it('should return version from package.json', () => {
+      const pkg = {
+        name: 'test-package',
+        version: '1.2.3'
+      };
+
+      expect(pkg.version).toBe('1.2.3');
+    });
+
+    it('should return default version when not found', () => {
+      const defaultVersion = '1.0.0';
+      expect(defaultVersion).toBe('1.0.0');
+    });
+  });
+});

package/tests/utils.test.js

@@ -31,9 +31,9 @@ describe('Utils Module', () => {
 
     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);
+      const result = utils.copyRecursive(nonExistent, tempDest);
 
-      expect(count).toBe(0);
+      expect(result).toEqual({ copied: 0, skipped: 0, backedup: 0 });
     });
 
     it('should copy files recursively', () => {
@@ -42,9 +42,11 @@ describe('Utils Module', () => {
       fs.writeFileSync(path.join(tempSrc, 'file1.txt'), 'content1');
       fs.writeFileSync(path.join(tempSrc, 'subdir', 'file2.txt'), 'content2');
 
-      const count = utils.copyRecursive(tempSrc, tempDest);
+      const result = utils.copyRecursive(tempSrc, tempDest);
 
-      expect(count).toBe(2);
+      expect(result.copied).toBe(2);
+      expect(result.skipped).toBe(0);
+      expect(result.backedup).toBe(0);
       expect(fs.existsSync(path.join(tempDest, 'file1.txt'))).toBe(true);
       expect(fs.existsSync(path.join(tempDest, 'subdir', 'file2.txt'))).toBe(true);
     });
@@ -73,9 +75,10 @@ describe('Utils Module', () => {
       fs.mkdirSync(tempDest, { recursive: true });
       fs.writeFileSync(path.join(tempDest, 'file.txt'), 'old content');
 
-      const count = utils.copyRecursive(tempSrc, tempDest, false);
+      const result = utils.copyRecursive(tempSrc, tempDest, false);
 
-      expect(count).toBe(0);
+      expect(result.copied).toBe(0);
+      expect(result.skipped).toBe(1);
       const content = fs.readFileSync(path.join(tempDest, 'file.txt'), 'utf-8');
       expect(content).toBe('old content');
     });
@@ -85,9 +88,10 @@ describe('Utils Module', () => {
       fs.mkdirSync(tempDest, { recursive: true });
       fs.writeFileSync(path.join(tempDest, 'file.txt'), 'old content');
 
-      const count = utils.copyRecursive(tempSrc, tempDest, true);
+      const result = utils.copyRecursive(tempSrc, tempDest, true);
 
-      expect(count).toBe(1);
+      expect(result.copied).toBe(1);
+      expect(result.skipped).toBe(0);
       const content = fs.readFileSync(path.join(tempDest, 'file.txt'), 'utf-8');
       expect(content).toBe('new content');
     });