tools-cc 1.0.6 → 1.0.8

package/tests/commands/export.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import { handleExport } from '../../src/commands/export';
+import { initProject, useSource } from '../../src/core/project';
+import { GLOBAL_CONFIG_DIR } from '../../src/utils/path';
+
+describe('handleExport', () => {
+  const testProjectDir = path.join(__dirname, '../fixtures/test-export-cmd-project');
+  const testSourceDir = path.join(__dirname, '../fixtures/test-export-cmd-source');
+  const exportFilePath = path.join(__dirname, '../fixtures/test-export-cmd.json');
+  const globalExportPath = path.join(__dirname, '../fixtures/test-global-export-cmd.json');
+
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    // Create test source
+    await fs.ensureDir(path.join(testSourceDir, 'skills', 'test-skill'));
+    await fs.writeFile(path.join(testSourceDir, 'skills', 'test-skill', 'test.md'), '# test skill');
+
+    // Create project directory
+    await fs.ensureDir(testProjectDir);
+
+    // Spy on console.log
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(async () => {
+    await fs.remove(testProjectDir);
+    await fs.remove(testSourceDir);
+    await fs.remove(exportFilePath);
+    await fs.remove(globalExportPath);
+    consoleLogSpy.mockRestore();
+  });
+
+  it('should export project config to default path', async () => {
+    // Initialize project with a source
+    await initProject(testProjectDir);
+    await useSource('test-source', testSourceDir, testProjectDir);
+
+    // Change to project directory for the test
+    const originalCwd = process.cwd();
+    process.chdir(testProjectDir);
+
+    try {
+      await handleExport({});
+
+      // Check default export file was created
+      const defaultExportPath = path.join(testProjectDir, '.toolscc-export.json');
+      expect(await fs.pathExists(defaultExportPath)).toBe(true);
+
+      // Verify file content
+      const exported = await fs.readJson(defaultExportPath);
+      expect(exported.version).toBe('1.0');
+      expect(exported.type).toBe('project');
+
+      // Verify console output
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining('✓ Project config exported to:')
+      );
+
+      // Cleanup
+      await fs.remove(defaultExportPath);
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('should export project config to custom path', async () => {
+    await initProject(testProjectDir);
+    await useSource('test-source', testSourceDir, testProjectDir);
+
+    const originalCwd = process.cwd();
+    process.chdir(testProjectDir);
+
+    try {
+      await handleExport({ output: exportFilePath });
+
+      expect(await fs.pathExists(exportFilePath)).toBe(true);
+
+      const exported = await fs.readJson(exportFilePath);
+      expect(exported.version).toBe('1.0');
+      expect(exported.type).toBe('project');
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('should export global config with --global flag', async () => {
+    const originalCwd = process.cwd();
+    process.chdir(testProjectDir);
+
+    try {
+      await handleExport({ global: true, output: globalExportPath });
+
+      expect(await fs.pathExists(globalExportPath)).toBe(true);
+
+      const exported = await fs.readJson(globalExportPath);
+      expect(exported.version).toBe('1.0');
+      expect(exported.type).toBe('global');
+      expect(exported.config).toBeDefined();
+      expect(exported.config.sourcesDir).toBeDefined();
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+
+  it('should throw error when exporting non-initialized project', async () => {
+    const originalCwd = process.cwd();
+    process.chdir(testProjectDir);
+
+    try {
+      // Don't initialize project
+      await expect(handleExport({ output: exportFilePath }))
+        .rejects.toThrow();
+    } finally {
+      process.chdir(originalCwd);
+    }
+  });
+});

package/tests/commands/use.test.ts

@@ -0,0 +1,326 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import { ExportConfig } from '../../src/types/config';
+
+// Mock inquirer to avoid interactive prompts in tests
+vi.mock('inquirer', () => ({
+  default: {
+    prompt: vi.fn()
+  }
+}));
+
+import inquirer from 'inquirer';
+
+describe('handleUse Command - parseSourcePath', () => {
+  it('should parse full path with type and item', async () => {
+    const { parseSourcePath } = await import('../../src/utils/parsePath');
+
+    const result = parseSourcePath('my-skills/skills/a-skill');
+    expect(result).toEqual({
+      sourceName: 'my-skills',
+      type: 'skills',
+      itemName: 'a-skill'
+    });
+  });
+
+  it('should parse source name only', async () => {
+    const { parseSourcePath } = await import('../../src/utils/parsePath');
+
+    const result = parseSourcePath('my-skills');
+    expect(result).toEqual({
+      sourceName: 'my-skills'
+    });
+  });
+
+  it('should parse commands path', async () => {
+    const { parseSourcePath } = await import('../../src/utils/parsePath');
+
+    const result = parseSourcePath('my-source/commands/test-cmd');
+    expect(result).toEqual({
+      sourceName: 'my-source',
+      type: 'commands',
+      itemName: 'test-cmd'
+    });
+  });
+
+  it('should parse agents path', async () => {
+    const { parseSourcePath } = await import('../../src/utils/parsePath');
+
+    const result = parseSourcePath('my-source/agents/reviewer');
+    expect(result).toEqual({
+      sourceName: 'my-source',
+      type: 'agents',
+      itemName: 'reviewer'
+    });
+  });
+
+  it('should handle invalid type gracefully', async () => {
+    const { parseSourcePath } = await import('../../src/utils/parsePath');
+
+    const result = parseSourcePath('my-source/invalid/item');
+    expect(result).toEqual({
+      sourceName: 'my-source'
+    });
+  });
+
+  it('should handle empty string', async () => {
+    const { parseSourcePath } = await import('../../src/utils/parsePath');
+
+    const result = parseSourcePath('');
+    expect(result).toEqual({
+      sourceName: ''
+    });
+  });
+
+  it('should handle path without item name', async () => {
+    const { parseSourcePath } = await import('../../src/utils/parsePath');
+
+    const result = parseSourcePath('my-source/skills');
+    expect(result).toEqual({
+      sourceName: 'my-source'
+    });
+  });
+});
+
+describe('handleUse Command - buildSelectionFromPaths', () => {
+  it('should build selection from multiple paths', async () => {
+    const { buildSelectionFromPaths } = await import('../../src/utils/parsePath');
+
+    const result = buildSelectionFromPaths([
+      'my-skills/skills/a-skill',
+      'my-skills/skills/b-skill',
+      'my-skills/commands/test-cmd'
+    ]);
+
+    expect(result).toEqual({
+      'my-skills': {
+        skills: ['a-skill', 'b-skill'],
+        commands: ['test-cmd'],
+        agents: []
+      }
+    });
+  });
+
+  it('should use wildcard for whole source', async () => {
+    const { buildSelectionFromPaths } = await import('../../src/utils/parsePath');
+
+    const result = buildSelectionFromPaths(['my-skills']);
+
+    expect(result).toEqual({
+      'my-skills': {
+        skills: ['*'],
+        commands: ['*'],
+        agents: ['*']
+      }
+    });
+  });
+
+  it('should handle multiple sources', async () => {
+    const { buildSelectionFromPaths } = await import('../../src/utils/parsePath');
+
+    const result = buildSelectionFromPaths([
+      'source-a/skills/skill1',
+      'source-b/commands/cmd1'
+    ]);
+
+    expect(result).toEqual({
+      'source-a': {
+        skills: ['skill1'],
+        commands: [],
+        agents: []
+      },
+      'source-b': {
+        skills: [],
+        commands: ['cmd1'],
+        agents: []
+      }
+    });
+  });
+
+  it('should deduplicate items', async () => {
+    const { buildSelectionFromPaths } = await import('../../src/utils/parsePath');
+
+    const result = buildSelectionFromPaths([
+      'my-skills/skills/a-skill',
+      'my-skills/skills/a-skill', // duplicate
+    ]);
+
+    expect(result['my-skills'].skills).toEqual(['a-skill']);
+    expect(result['my-skills'].skills.length).toBe(1);
+  });
+
+  it('should handle empty array', async () => {
+    const { buildSelectionFromPaths } = await import('../../src/utils/parsePath');
+
+    const result = buildSelectionFromPaths([]);
+    expect(result).toEqual({});
+  });
+
+  it('should handle mixed whole-source and partial paths', async () => {
+    const { buildSelectionFromPaths } = await import('../../src/utils/parsePath');
+
+    // When whole source is specified, it should override partial selections
+    const result = buildSelectionFromPaths([
+      'my-skills/skills/a-skill',
+      'my-skills', // whole source should overwrite
+    ]);
+
+    expect(result['my-skills']).toEqual({
+      skills: ['*'],
+      commands: ['*'],
+      agents: ['*']
+    });
+  });
+});
+
+describe('handleUse Command - integration tests', () => {
+  // Use unique directory for each test to avoid conflicts
+  let testId = 0;
+  const getTestDir = (name: string) => path.join(__dirname, '../fixtures', `use-test-${testId}-${name}`);
+
+  beforeEach(() => {
+    testId++;
+  });
+
+  afterEach(async () => {
+    // Cleanup all test directories
+    for (let i = 1; i <= testId; i++) {
+      try {
+        await fs.remove(path.join(__dirname, '../fixtures', `use-test-${i}-project`));
+        await fs.remove(path.join(__dirname, '../fixtures', `use-test-${i}-source`));
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+  });
+
+  it('should handle dot mode on non-initialized project', async () => {
+    const projectDir = getTestDir('project');
+    await fs.ensureDir(projectDir);
+
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const originalCwd = process.cwd();
+    process.chdir(projectDir);
+
+    try {
+      const { handleUse } = await import('../../src/commands/use');
+      await handleUse(['.'], {});
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Project not initialized')
+      );
+    } finally {
+      process.chdir(originalCwd);
+      consoleLogSpy.mockRestore();
+      await fs.remove(projectDir);
+    }
+  });
+
+  it('should handle dot mode with initialized project', async () => {
+    const projectDir = getTestDir('project');
+    const sourceDir = getTestDir('source');
+
+    await fs.ensureDir(projectDir);
+    await fs.ensureDir(path.join(sourceDir, 'skills', 'test-skill'));
+    await fs.writeFile(path.join(sourceDir, 'skills', 'test-skill', 'test.md'), '# test');
+
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const originalCwd = process.cwd();
+    process.chdir(projectDir);
+
+    try {
+      const { initProject, useSource } = await import('../../src/core/project');
+      const { handleUse } = await import('../../src/commands/use');
+
+      // Initialize and add a source
+      await initProject(projectDir);
+      await useSource('test-source', sourceDir, projectDir);
+
+      // Now use dot mode
+      await handleUse(['.'], {});
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Using existing sources')
+      );
+    } finally {
+      process.chdir(originalCwd);
+      consoleLogSpy.mockRestore();
+      await fs.remove(projectDir);
+      await fs.remove(sourceDir);
+    }
+  });
+
+  it('should handle config import mode', async () => {
+    const projectDir = getTestDir('project');
+    const sourceDir = getTestDir('source');
+    const configPath = getTestDir('import-config.json');
+
+    await fs.ensureDir(projectDir);
+    await fs.ensureDir(path.join(sourceDir, 'skills', 'test-skill'));
+    await fs.writeFile(path.join(sourceDir, 'skills', 'test-skill', 'test.md'), '# test');
+
+    // Create export config
+    const exportConfig: ExportConfig = {
+      version: '1.0',
+      type: 'project',
+      config: {
+        sources: {
+          'imported-source': {
+            skills: ['test-skill'],
+            commands: [],
+            agents: []
+          }
+        },
+        links: []
+      },
+      exportedAt: new Date().toISOString()
+    };
+    await fs.writeJson(configPath, exportConfig, { spaces: 2 });
+
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    const originalCwd = process.cwd();
+    process.chdir(projectDir);
+
+    try {
+      const { initProject } = await import('../../src/core/project');
+      const { handleUse } = await import('../../src/commands/use');
+
+      await initProject(projectDir);
+
+      // Mock the getSourcePath to return our test source
+      const originalGetSourcePath = (await import('../../src/core/source')).getSourcePath;
+      vi.mock('../../src/core/source', async (importOriginal) => {
+        const mod = await importOriginal();
+        return {
+          ...mod,
+          getSourcePath: async (name: string) => {
+            if (name === 'imported-source') return sourceDir;
+            return originalGetSourcePath(name, '');
+          }
+        };
+      });
+
+      // Direct test of importProjectConfig
+      const { importProjectConfig } = await import('../../src/core/project');
+      await importProjectConfig(configPath, projectDir, async (name) => {
+        if (name === 'imported-source') return sourceDir;
+        throw new Error(`Unknown source: ${name}`);
+      });
+
+      // Verify config was imported
+      const config = await fs.readJson(path.join(projectDir, '.toolscc', 'config.json'));
+      expect(config.sources['imported-source']).toBeDefined();
+
+    } finally {
+      process.chdir(originalCwd);
+      consoleLogSpy.mockRestore();
+      await fs.remove(projectDir);
+      await fs.remove(sourceDir);
+      await fs.remove(configPath);
+    }
+  });
+});

package/tests/core/config.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import { loadGlobalConfig, saveGlobalConfig } from '../../src/core/config';
+
+describe('Config Module', () => {
+  const testConfigDir = path.join(__dirname, '../fixtures/.tools-cc');
+
+  beforeEach(async () => {
+    await fs.ensureDir(testConfigDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(testConfigDir);
+  });
+
+  it('should create default config if not exists', async () => {
+    const config = await loadGlobalConfig(testConfigDir);
+    expect(config.sourcesDir).toBeDefined();
+    expect(config.sources).toEqual({});
+  });
+
+  it('should save and load config correctly', async () => {
+    const testConfig = {
+      sourcesDir: '/test/sources',
+      sources: {
+        'test-source': { type: 'git' as const, url: 'https://github.com/test/repo.git' }
+      }
+    };
+    
+    await saveGlobalConfig(testConfig, testConfigDir);
+    const loaded = await loadGlobalConfig(testConfigDir);
+    
+    expect(loaded.sourcesDir).toBe('/test/sources');
+    expect(loaded.sources['test-source'].type).toBe('git');
+  });
+});

package/tests/core/manifest.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import { loadManifest, scanSource } from '../../src/core/manifest';
+
+describe('Manifest Module', () => {
+  const testSourceDir = path.join(__dirname, '../fixtures/test-source');
+
+  beforeEach(async () => {
+    await fs.ensureDir(path.join(testSourceDir, 'skills', 'test-skill'));
+    await fs.ensureDir(path.join(testSourceDir, 'commands'));
+    await fs.ensureDir(path.join(testSourceDir, 'agents'));
+  });
+
+  afterEach(async () => {
+    await fs.remove(testSourceDir);
+  });
+
+  it('should scan source directory without manifest', async () => {
+    const manifest = await scanSource(testSourceDir);
+    expect(manifest.name).toBe(path.basename(testSourceDir));
+    expect(manifest.skills).toContain('test-skill');
+  });
+
+  it('should load existing manifest', async () => {
+    const manifestPath = path.join(testSourceDir, 'manifest.json');
+    await fs.writeJson(manifestPath, {
+      name: 'custom-name',
+      version: '2.0.0',
+      skills: ['skill1']
+    });
+
+    const manifest = await loadManifest(testSourceDir);
+    expect(manifest.name).toBe('custom-name');
+    expect(manifest.version).toBe('2.0.0');
+  });
+});