tools-cc 1.0.7 → 1.0.8

package/tests/types/config.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect } from 'vitest';
+import {
+  isSourceSelection,
+  normalizeProjectConfig,
+  SourceSelection,
+  ProjectConfig,
+  LegacyProjectConfig,
+  ExportConfig,
+  GlobalExportConfig
+} from '../../src/types/config';
+
+describe('SourceSelection', () => {
+  describe('isSourceSelection', () => {
+    it('should return true for valid SourceSelection object', () => {
+      const valid: SourceSelection = {
+        skills: ['skill1'],
+        commands: ['cmd1'],
+        agents: ['agent1']
+      };
+      expect(isSourceSelection(valid)).toBe(true);
+    });
+
+    it('should return true for empty arrays', () => {
+      const empty: SourceSelection = {
+        skills: [],
+        commands: [],
+        agents: []
+      };
+      expect(isSourceSelection(empty)).toBe(true);
+    });
+
+    it('should return true for wildcard selection', () => {
+      const wildcard: SourceSelection = {
+        skills: ['*'],
+        commands: ['*'],
+        agents: ['*']
+      };
+      expect(isSourceSelection(wildcard)).toBe(true);
+    });
+
+    it('should return false for null', () => {
+      expect(isSourceSelection(null)).toBe(false);
+    });
+
+    it('should return false for undefined', () => {
+      expect(isSourceSelection(undefined)).toBe(false);
+    });
+
+    it('should return false for non-object values', () => {
+      expect(isSourceSelection('string')).toBe(false);
+      expect(isSourceSelection(123)).toBe(false);
+      expect(isSourceSelection(true)).toBe(false);
+    });
+
+    it('should return false for object missing skills', () => {
+      const invalid = {
+        commands: ['cmd1'],
+        agents: ['agent1']
+      };
+      expect(isSourceSelection(invalid)).toBe(false);
+    });
+
+    it('should return false for object missing commands', () => {
+      const invalid = {
+        skills: ['skill1'],
+        agents: ['agent1']
+      };
+      expect(isSourceSelection(invalid)).toBe(false);
+    });
+
+    it('should return false for object missing agents', () => {
+      const invalid = {
+        skills: ['skill1'],
+        commands: ['cmd1']
+      };
+      expect(isSourceSelection(invalid)).toBe(false);
+    });
+
+    it('should return false for object with non-array skills', () => {
+      const invalid = {
+        skills: 'not-array',
+        commands: ['cmd1'],
+        agents: ['agent1']
+      };
+      expect(isSourceSelection(invalid)).toBe(false);
+    });
+
+    it('should return false for object with non-array commands', () => {
+      const invalid = {
+        skills: ['skill1'],
+        commands: 123,
+        agents: ['agent1']
+      };
+      expect(isSourceSelection(invalid)).toBe(false);
+    });
+
+    it('should return false for object with non-array agents', () => {
+      const invalid = {
+        skills: ['skill1'],
+        commands: ['cmd1'],
+        agents: null
+      };
+      expect(isSourceSelection(invalid)).toBe(false);
+    });
+  });
+});
+
+describe('normalizeProjectConfig', () => {
+  describe('LegacyProjectConfig conversion', () => {
+    it('should convert legacy string array sources to Record format', () => {
+      const legacy: LegacyProjectConfig = {
+        sources: ['source1', 'source2'],
+        links: ['iflow', 'claude']
+      };
+
+      const result = normalizeProjectConfig(legacy);
+
+      expect(result.sources).toEqual({
+        source1: { skills: ['*'], commands: ['*'], agents: ['*'] },
+        source2: { skills: ['*'], commands: ['*'], agents: ['*'] }
+      });
+      expect(result.links).toEqual(['iflow', 'claude']);
+    });
+
+    it('should handle empty legacy sources array', () => {
+      const legacy: LegacyProjectConfig = {
+        sources: [],
+        links: []
+      };
+
+      const result = normalizeProjectConfig(legacy);
+
+      expect(result.sources).toEqual({});
+      expect(result.links).toEqual([]);
+    });
+
+    it('should preserve links from legacy config', () => {
+      const legacy: LegacyProjectConfig = {
+        sources: ['source1'],
+        links: ['iflow', 'claude', 'codebuddy']
+      };
+
+      const result = normalizeProjectConfig(legacy);
+
+      expect(result.links).toEqual(['iflow', 'claude', 'codebuddy']);
+    });
+  });
+
+  describe('ProjectConfig passthrough', () => {
+    it('should return ProjectConfig as-is when already in new format', () => {
+      const newConfig: ProjectConfig = {
+        sources: {
+          source1: { skills: ['skill1'], commands: ['cmd1'], agents: ['agent1'] }
+        },
+        links: ['iflow']
+      };
+
+      const result = normalizeProjectConfig(newConfig);
+
+      expect(result).toEqual(newConfig);
+    });
+
+    it('should handle partial selection in new format', () => {
+      const newConfig: ProjectConfig = {
+        sources: {
+          source1: { skills: ['skill1', 'skill2'], commands: [], agents: ['*'] }
+        },
+        links: ['claude']
+      };
+
+      const result = normalizeProjectConfig(newConfig);
+
+      expect(result).toEqual(newConfig);
+    });
+
+    it('should handle multiple sources with different selections', () => {
+      const newConfig: ProjectConfig = {
+        sources: {
+          source1: { skills: ['*'], commands: ['*'], agents: ['*'] },
+          source2: { skills: ['skill-a'], commands: [], agents: ['agent-x'] }
+        },
+        links: ['iflow', 'opencode']
+      };
+
+      const result = normalizeProjectConfig(newConfig);
+
+      expect(result).toEqual(newConfig);
+    });
+  });
+});
+
+describe('ExportConfig', () => {
+  describe('type structure', () => {
+    it('should allow creating ExportConfig with project config', () => {
+      const exportConfig: ExportConfig = {
+        version: '1.0.0',
+        type: 'project',
+        config: {
+          sources: {
+            source1: { skills: ['*'], commands: ['*'], agents: ['*'] }
+          },
+          links: ['iflow']
+        },
+        exportedAt: '2026-02-28T00:00:00Z'
+      };
+
+      expect(exportConfig.type).toBe('project');
+      expect(exportConfig.version).toBe('1.0.0');
+    });
+  });
+});
+
+describe('GlobalExportConfig', () => {
+  describe('type structure', () => {
+    it('should allow creating GlobalExportConfig with global config', () => {
+      const globalExportConfig: GlobalExportConfig = {
+        version: '1.0.0',
+        type: 'global',
+        config: {
+          sourcesDir: '~/.tools-cc/sources',
+          sources: {
+            source1: { type: 'git', url: 'https://github.com/example/skills' }
+          }
+        },
+        exportedAt: '2026-02-28T00:00:00Z'
+      };
+
+      expect(globalExportConfig.type).toBe('global');
+      expect(globalExportConfig.config.sourcesDir).toBe('~/.tools-cc/sources');
+    });
+  });
+});

package/tests/utils/parsePath.test.ts

@@ -0,0 +1,235 @@
+import { describe, it, expect } from 'vitest';
+import { parseSourcePath, buildSelectionFromPaths, ParsedSourcePath } from '../../src/utils/parsePath';
+import { SourceSelection } from '../../src/types/config';
+
+describe('parseSourcePath', () => {
+  describe('whole source', () => {
+    it('should parse source name only', () => {
+      const result = parseSourcePath('my-skills');
+      expect(result).toEqual({
+        sourceName: 'my-skills'
+      });
+    });
+
+    it('should parse source name with hyphens', () => {
+      const result = parseSourcePath('my-awesome-skills');
+      expect(result).toEqual({
+        sourceName: 'my-awesome-skills'
+      });
+    });
+
+    it('should parse source name with underscores', () => {
+      const result = parseSourcePath('my_skills_repo');
+      expect(result).toEqual({
+        sourceName: 'my_skills_repo'
+      });
+    });
+  });
+
+  describe('specific skill', () => {
+    it('should parse skill path', () => {
+      const result = parseSourcePath('my-skills/skills/a-skill');
+      expect(result).toEqual({
+        sourceName: 'my-skills',
+        type: 'skills',
+        itemName: 'a-skill'
+      });
+    });
+
+    it('should parse skill path with underscores', () => {
+      const result = parseSourcePath('my-skills/skills/my_awesome_skill');
+      expect(result).toEqual({
+        sourceName: 'my-skills',
+        type: 'skills',
+        itemName: 'my_awesome_skill'
+      });
+    });
+  });
+
+  describe('specific command', () => {
+    it('should parse command path', () => {
+      const result = parseSourcePath('my-skills/commands/test');
+      expect(result).toEqual({
+        sourceName: 'my-skills',
+        type: 'commands',
+        itemName: 'test'
+      });
+    });
+
+    it('should parse command path with hyphens', () => {
+      const result = parseSourcePath('tools/commands/my-command');
+      expect(result).toEqual({
+        sourceName: 'tools',
+        type: 'commands',
+        itemName: 'my-command'
+      });
+    });
+  });
+
+  describe('specific agent', () => {
+    it('should parse agent path', () => {
+      const result = parseSourcePath('other/agents/reviewer');
+      expect(result).toEqual({
+        sourceName: 'other',
+        type: 'agents',
+        itemName: 'reviewer'
+      });
+    });
+  });
+
+  describe('invalid paths', () => {
+    it('should return sourceName only for invalid type', () => {
+      const result = parseSourcePath('my-skills/invalid/item');
+      expect(result).toEqual({
+        sourceName: 'my-skills'
+      });
+    });
+
+    it('should return sourceName only for incomplete path', () => {
+      const result = parseSourcePath('my-skills/skills');
+      expect(result).toEqual({
+        sourceName: 'my-skills'
+      });
+    });
+
+    it('should handle empty string', () => {
+      const result = parseSourcePath('');
+      expect(result).toEqual({
+        sourceName: ''
+      });
+    });
+
+    it('should handle path with too many segments', () => {
+      const result = parseSourcePath('my-skills/skills/a/b/c');
+      expect(result).toEqual({
+        sourceName: 'my-skills',
+        type: 'skills',
+        itemName: 'a'
+      });
+    });
+  });
+});
+
+describe('buildSelectionFromPaths', () => {
+  it('should build selection from single skill path', () => {
+    const paths = ['my-skills/skills/a-skill'];
+    const result = buildSelectionFromPaths(paths);
+    
+    expect(result).toEqual({
+      'my-skills': {
+        skills: ['a-skill'],
+        commands: [],
+        agents: []
+      }
+    });
+  });
+
+  it('should build selection from multiple skills in same source', () => {
+    const paths = ['my-skills/skills/a', 'my-skills/skills/b'];
+    const result = buildSelectionFromPaths(paths);
+    
+    expect(result).toEqual({
+      'my-skills': {
+        skills: ['a', 'b'],
+        commands: [],
+        agents: []
+      }
+    });
+  });
+
+  it('should build selection from mixed types', () => {
+    const paths = [
+      'my-skills/skills/a',
+      'my-skills/skills/b',
+      'my-skills/commands/test'
+    ];
+    const result = buildSelectionFromPaths(paths);
+    
+    expect(result).toEqual({
+      'my-skills': {
+        skills: ['a', 'b'],
+        commands: ['test'],
+        agents: []
+      }
+    });
+  });
+
+  it('should build selection from multiple sources', () => {
+    const paths = [
+      'source-a/skills/skill1',
+      'source-b/commands/cmd1',
+      'source-b/agents/agent1'
+    ];
+    const result = buildSelectionFromPaths(paths);
+    
+    expect(result).toEqual({
+      'source-a': {
+        skills: ['skill1'],
+        commands: [],
+        agents: []
+      },
+      'source-b': {
+        skills: [],
+        commands: ['cmd1'],
+        agents: ['agent1']
+      }
+    });
+  });
+
+  it('should handle whole source path (no type/item)', () => {
+    const paths = ['my-skills'];
+    const result = buildSelectionFromPaths(paths);
+    
+    expect(result).toEqual({
+      'my-skills': {
+        skills: ['*'],
+        commands: ['*'],
+        agents: ['*']
+      }
+    });
+  });
+
+  it('should handle mixed whole and partial source paths', () => {
+    const paths = [
+      'source-a',
+      'source-b/skills/skill1',
+      'source-b/commands/cmd1'
+    ];
+    const result = buildSelectionFromPaths(paths);
+    
+    expect(result).toEqual({
+      'source-a': {
+        skills: ['*'],
+        commands: ['*'],
+        agents: ['*']
+      },
+      'source-b': {
+        skills: ['skill1'],
+        commands: ['cmd1'],
+        agents: []
+      }
+    });
+  });
+
+  it('should handle empty array', () => {
+    const result = buildSelectionFromPaths([]);
+    expect(result).toEqual({});
+  });
+
+  it('should deduplicate items', () => {
+    const paths = [
+      'my-skills/skills/a',
+      'my-skills/skills/a',
+      'my-skills/skills/b'
+    ];
+    const result = buildSelectionFromPaths(paths);
+    
+    expect(result).toEqual({
+      'my-skills': {
+        skills: ['a', 'b'],
+        commands: [],
+        agents: []
+      }
+    });
+  });
+});