tools-cc 1.0.0

package/src/core/project.ts

@@ -0,0 +1,136 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { ProjectConfig } from '../types';
+import { loadManifest } from './manifest';
+import { getToolsccDir, getProjectConfigPath } from '../utils/path';
+
+export async function initProject(projectDir: string): Promise<void> {
+  const toolsccDir = getToolsccDir(projectDir);
+  const configFile = getProjectConfigPath(projectDir);
+  
+  // Create .toolscc directory structure
+  await fs.ensureDir(path.join(toolsccDir, 'skills'));
+  await fs.ensureDir(path.join(toolsccDir, 'commands'));
+  await fs.ensureDir(path.join(toolsccDir, 'agents'));
+  
+  // Create project config if not exists
+  if (!(await fs.pathExists(configFile))) {
+    const config: ProjectConfig = {
+      sources: [],
+      links: []
+    };
+    await fs.writeJson(configFile, config, { spaces: 2 });
+  }
+}
+
+export async function useSource(
+  sourceName: string,
+  sourceDir: string,
+  projectDir: string
+): Promise<void> {
+  // Input validation
+  if (!sourceName || !sourceName.trim()) {
+    throw new Error('Source name is required');
+  }
+  
+  // Check source directory existence
+  if (!(await fs.pathExists(sourceDir))) {
+    throw new Error(`Source directory does not exist: ${sourceDir}`);
+  }
+  
+  const toolsccDir = getToolsccDir(projectDir);
+  const manifest = await loadManifest(sourceDir);
+  
+  // Ensure project is initialized
+  await initProject(projectDir);
+  
+  // Copy/link skills (flattened with prefix)
+  const sourceSkillsDir = path.join(sourceDir, 'skills');
+  if (await fs.pathExists(sourceSkillsDir)) {
+    const skills = await fs.readdir(sourceSkillsDir);
+    for (const skill of skills) {
+      const srcPath = path.join(sourceSkillsDir, skill);
+      const destPath = path.join(toolsccDir, 'skills', `${sourceName}-${skill}`);
+      
+      // Remove existing if exists
+      await fs.remove(destPath);
+      
+      // Copy directory
+      await fs.copy(srcPath, destPath);
+    }
+  }
+  
+  // Copy commands (in subdirectory by source name)
+  const sourceCommandsDir = path.join(sourceDir, 'commands');
+  if (await fs.pathExists(sourceCommandsDir)) {
+    const destDir = path.join(toolsccDir, 'commands', sourceName);
+    await fs.remove(destDir);
+    await fs.copy(sourceCommandsDir, destDir);
+  }
+  
+  // Copy agents (in subdirectory by source name)
+  const sourceAgentsDir = path.join(sourceDir, 'agents');
+  if (await fs.pathExists(sourceAgentsDir)) {
+    const destDir = path.join(toolsccDir, 'agents', sourceName);
+    await fs.remove(destDir);
+    await fs.copy(sourceAgentsDir, destDir);
+  }
+  
+  // Update project config
+  const configFile = getProjectConfigPath(projectDir);
+  const config: ProjectConfig = await fs.readJson(configFile);
+  if (!config.sources.includes(sourceName)) {
+    config.sources.push(sourceName);
+  }
+  await fs.writeJson(configFile, config, { spaces: 2 });
+}
+
+export async function unuseSource(sourceName: string, projectDir: string): Promise<void> {
+  // Input validation
+  if (!sourceName || !sourceName.trim()) {
+    throw new Error('Source name is required');
+  }
+  
+  const toolsccDir = getToolsccDir(projectDir);
+  const configFile = getProjectConfigPath(projectDir);
+  
+  // Remove skills with prefix
+  const skillsDir = path.join(toolsccDir, 'skills');
+  if (await fs.pathExists(skillsDir)) {
+    const skills = await fs.readdir(skillsDir);
+    for (const skill of skills) {
+      if (skill.startsWith(`${sourceName}-`)) {
+        await fs.remove(path.join(skillsDir, skill));
+      }
+    }
+  }
+  
+  // Remove commands subdirectory
+  await fs.remove(path.join(toolsccDir, 'commands', sourceName));
+  
+  // Remove agents subdirectory
+  await fs.remove(path.join(toolsccDir, 'agents', sourceName));
+  
+  // Update project config with error handling
+  let config: ProjectConfig;
+  try {
+    config = await fs.readJson(configFile);
+  } catch (error) {
+    // If config file doesn't exist or is invalid, nothing to update
+    return;
+  }
+  
+  config.sources = config.sources.filter(s => s !== sourceName);
+  await fs.writeJson(configFile, config, { spaces: 2 });
+}
+
+export async function listUsedSources(projectDir: string): Promise<string[]> {
+  const configFile = getProjectConfigPath(projectDir);
+  
+  if (!(await fs.pathExists(configFile))) {
+    return [];
+  }
+  
+  const config: ProjectConfig = await fs.readJson(configFile);
+  return config.sources;
+}

package/src/core/source.ts

@@ -0,0 +1,100 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { execSync } from 'child_process';
+import { loadGlobalConfig, saveGlobalConfig } from './config';
+import { SourceConfig } from '../types';
+
+export async function addSource(
+  name: string, 
+  sourcePath: string, 
+  configDir: string
+): Promise<SourceConfig> {
+  const config = await loadGlobalConfig(configDir);
+  
+  // 判断是 git url 还是本地路径
+  const isGit = sourcePath.startsWith('http') || sourcePath.startsWith('git@');
+  
+  let sourceConfig: SourceConfig;
+  
+  if (isGit) {
+    // Clone git repo
+    const cloneDir = path.join(config.sourcesDir, name);
+    console.log(`Cloning ${sourcePath} to ${cloneDir}...`);
+    
+    await fs.ensureDir(config.sourcesDir);
+    execSync(`git clone ${sourcePath} "${cloneDir}"`, { stdio: 'inherit' });
+    
+    sourceConfig = { type: 'git', url: sourcePath };
+  } else {
+    // 本地路径
+    const absolutePath = path.resolve(sourcePath);
+    if (!(await fs.pathExists(absolutePath))) {
+      throw new Error(`Path does not exist: ${absolutePath}`);
+    }
+    sourceConfig = { type: 'local', path: absolutePath };
+  }
+  
+  config.sources[name] = sourceConfig;
+  await saveGlobalConfig(config, configDir);
+  
+  return sourceConfig;
+}
+
+export async function listSources(configDir: string): Promise<Record<string, SourceConfig>> {
+  const config = await loadGlobalConfig(configDir);
+  return config.sources;
+}
+
+export async function removeSource(name: string, configDir: string): Promise<void> {
+  const config = await loadGlobalConfig(configDir);
+  
+  if (!config.sources[name]) {
+    throw new Error(`Source not found: ${name}`);
+  }
+  
+  const source = config.sources[name];
+  
+  // 如果是 git 类型，清理克隆目录
+  if (source.type === 'git') {
+    const cloneDir = path.join(config.sourcesDir, name);
+    if (await fs.pathExists(cloneDir)) {
+      console.log(`Removing cloned directory: ${cloneDir}`);
+      await fs.remove(cloneDir);
+    }
+  }
+  
+  delete config.sources[name];
+  await saveGlobalConfig(config, configDir);
+}
+
+export async function updateSource(name: string, configDir: string): Promise<void> {
+  const config = await loadGlobalConfig(configDir);
+  const source = config.sources[name];
+  
+  if (!source) {
+    throw new Error(`Source not found: ${name}`);
+  }
+  
+  if (source.type === 'git') {
+    const cloneDir = path.join(config.sourcesDir, name);
+    console.log(`Updating ${name}...`);
+    execSync(`git -C "${cloneDir}" pull`, { stdio: 'inherit' });
+  } else {
+    console.log(`Source ${name} is local, no update needed.`);
+  }
+}
+
+export async function getSourcePath(name: string, configDir: string): Promise<string> {
+  const config = await loadGlobalConfig(configDir);
+  const source = config.sources[name];
+  
+  if (!source) {
+    throw new Error(`Source not found: ${name}`);
+  }
+  
+  if (source.type === 'local') {
+    return source.path!;
+  }
+  
+  return path.join(config.sourcesDir, name);
+}

package/src/core/symlink.ts

@@ -0,0 +1,56 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function createSymlink(
+  target: string,
+  linkPath: string,
+  force: boolean = false
+): Promise<void> {
+  // 如果目标已存在
+  if (await fs.pathExists(linkPath)) {
+    if (!force) {
+      throw new Error(`Path already exists: ${linkPath}. Use force=true to overwrite.`);
+    }
+    
+    // 检查是否已经是符号链接
+    if (await isSymlink(linkPath)) {
+      await fs.remove(linkPath);
+    } else {
+      // 是真实目录，删除
+      await fs.remove(linkPath);
+    }
+  }
+  
+  // 确保目标存在
+  if (!(await fs.pathExists(target))) {
+    throw new Error(`Target does not exist: ${target}`);
+  }
+  
+  // 创建符号链接
+  // Windows: 使用 junction (不需要管理员权限)
+  // Linux/macOS: 使用 symlink
+  const targetPath = path.resolve(target);
+  
+  if (process.platform === 'win32') {
+    // Windows: 使用 junction
+    await fs.ensureSymlink(targetPath, linkPath, 'junction');
+  } else {
+    // Linux/macOS: 使用 dir symlink
+    await fs.ensureSymlink(targetPath, linkPath, 'dir');
+  }
+}
+
+export async function removeSymlink(linkPath: string): Promise<void> {
+  if (await isSymlink(linkPath)) {
+    await fs.remove(linkPath);
+  }
+}
+
+export async function isSymlink(path: string): Promise<boolean> {
+  try {
+    const stats = await fs.lstat(path);
+    return stats.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}

package/src/index.ts

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { handleConfigSet, handleConfigGet, handleConfigList } from './commands/config';
+import { handleSourceAdd, handleSourceList, handleSourceRemove, handleSourceUpdate } from './commands/source';
+import { handleUse, handleList, handleRemove, handleStatus } from './commands/use';
+import { showHelp } from './commands/help';
+import { GLOBAL_CONFIG_DIR } from './utils/path';
+
+const program = new Command();
+
+program
+  .name('tools-cc')
+  .description('CLI tool for managing skills/commands/agents across multiple AI coding tools')
+  .version('0.0.1');
+
+// Source management (shortcut options)
+program
+  .option('-s, --source <command> [args...]', 'Source management (shortcut)')
+  .option('-c, --config <command> [args...]', 'Config management (shortcut)');
+
+// Source subcommands (full command version)
+const sourceCmd = program
+  .command('sources')
+  .description('Source management');
+
+sourceCmd
+  .command('add <name> <path-or-url>')
+  .description('Add a source')
+  .action(async (name: string, pathOrUrl: string) => {
+    await handleSourceAdd(name, pathOrUrl);
+  });
+
+sourceCmd
+  .command('list')
+  .alias('ls')
+  .description('List all sources')
+  .action(async () => {
+    await handleSourceList();
+  });
+
+sourceCmd
+  .command('remove <name>')
+  .alias('rm')
+  .description('Remove a source')
+  .action(async (name: string) => {
+    await handleSourceRemove(name);
+  });
+
+sourceCmd
+  .command('update [name]')
+  .alias('up')
+  .description('Update source(s)')
+  .action(async (name?: string) => {
+    await handleSourceUpdate(name);
+  });
+
+// Config subcommands (full command version)
+const configCmd = program
+  .command('config')
+  .description('Config management');
+
+configCmd
+  .command('set <key> <value>')
+  .description('Set a config value')
+  .action(async (key: string, value: string) => {
+    await handleConfigSet(key, value);
+  });
+
+configCmd
+  .command('get <key>')
+  .description('Get a config value')
+  .action(async (key: string) => {
+    await handleConfigGet(key);
+  });
+
+configCmd
+  .command('list')
+  .description('Show full configuration')
+  .action(async () => {
+    await handleConfigList();
+  });
+
+// Project commands
+program
+  .command('use [sources...]')
+  .description('Use sources in current project')
+  .option('-p, --projects <tools...>', 'Tools to link (iflow, claude, codebuddy, opencode)')
+  .action(async (sources: string[], options) => {
+    await handleUse(sources, options);
+  });
+
+program
+  .command('list')
+  .description('List sources in use')
+  .action(async () => {
+    await handleList();
+  });
+
+program
+  .command('rm <source>')
+  .description('Remove a source from project')
+  .action(async (source: string) => {
+    await handleRemove(source);
+  });
+
+program
+  .command('status')
+  .description('Show project status')
+  .action(async () => {
+    await handleStatus();
+  });
+
+// Help command
+program
+  .command('help')
+  .description('Show bilingual help information')
+  .action(() => {
+    showHelp();
+  });
+
+// Main action handler for -s and -c options
+program
+  .action(async (options) => {
+    // Handle -s/--source
+    if (options.source) {
+      const [cmd, ...args] = options.source;
+      switch (cmd) {
+        case 'add':
+          if (args.length < 2) {
+            console.log('Usage: tools-cc -s add <name> <path-or-url>');
+            return;
+          }
+          await handleSourceAdd(args[0], args[1]);
+          break;
+        case 'list':
+        case 'ls':
+          await handleSourceList();
+          break;
+        case 'remove':
+        case 'rm':
+          if (args.length < 1) {
+            console.log('Usage: tools-cc -s remove <name>');
+            return;
+          }
+          await handleSourceRemove(args[0]);
+          break;
+        case 'update':
+        case 'up':
+          await handleSourceUpdate(args[0]);
+          break;
+        default:
+          console.log(`Unknown source command: ${cmd}`);
+      }
+      return;
+    }
+    
+    // Handle -c/--config
+    if (options.config) {
+      const [cmd, ...args] = options.config;
+      switch (cmd) {
+        case 'set':
+          if (args.length < 2) {
+            console.log('Usage: tools-cc -c set <key> <value>');
+            return;
+          }
+          await handleConfigSet(args[0], args[1]);
+          break;
+        case 'get':
+          if (args.length < 1) {
+            console.log('Usage: tools-cc -c get <key>');
+            return;
+          }
+          await handleConfigGet(args[0]);
+          break;
+        default:
+          console.log(`Unknown config command: ${cmd}`);
+      }
+      return;
+    }
+    
+    // No options provided, show help
+    program.outputHelp();
+  });
+
+program.parseAsync();

package/src/types/config.ts

@@ -0,0 +1,27 @@
+export interface SourceConfig {
+  type: 'git' | 'local';
+  url?: string;
+  path?: string;
+}
+
+export interface GlobalConfig {
+  sourcesDir: string;
+  sources: Record<string, SourceConfig>;
+}
+
+export interface ProjectConfig {
+  sources: string[];
+  links: string[];
+}
+
+export interface Manifest {
+  name: string;
+  version: string;
+  skills?: string[];
+  commands?: string[];
+  agents?: string[];
+}
+
+export interface ToolConfig {
+  linkName: string;
+}

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './config';

package/src/utils/path.ts

@@ -0,0 +1,18 @@
+import os from 'os';
+import path from 'path';
+
+export const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.tools-cc');
+export const GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, 'config.json');
+
+export const DEFAULT_CONFIG = {
+  sourcesDir: path.join(GLOBAL_CONFIG_DIR, 'sources'),
+  sources: {}
+};
+
+export function getProjectConfigPath(projectDir: string): string {
+  return path.join(projectDir, 'tools-cc.json');
+}
+
+export function getToolsccDir(projectDir: string): string {
+  return path.join(projectDir, '.toolscc');
+}

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');
+  });
+});

package/tests/core/project.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import { initProject, useSource, unuseSource, listUsedSources } from '../../src/core/project';
+
+describe('Project Module', () => {
+  const testProjectDir = path.join(__dirname, '../fixtures/test-project');
+  const testSourceDir = path.join(__dirname, '../fixtures/test-source');
+
+  beforeEach(async () => {
+    await fs.ensureDir(testProjectDir);
+    await fs.ensureDir(path.join(testSourceDir, 'skills', 'test-skill'));
+  });
+
+  afterEach(async () => {
+    await fs.remove(testProjectDir);
+    await fs.remove(testSourceDir);
+  });
+
+  it('should initialize project with .toolscc directory', async () => {
+    await initProject(testProjectDir);
+    expect(await fs.pathExists(path.join(testProjectDir, '.toolscc'))).toBe(true);
+    expect(await fs.pathExists(path.join(testProjectDir, 'tools-cc.json'))).toBe(true);
+  });
+
+  it('should use source and copy components', async () => {
+    await initProject(testProjectDir);
+    await useSource('test-source', testSourceDir, testProjectDir);
+    
+    // skills should be flattened with prefix
+    expect(await fs.pathExists(path.join(testProjectDir, '.toolscc', 'skills', 'test-source-test-skill'))).toBe(true);
+  });
+
+  it('should unuse source and remove components', async () => {
+    await initProject(testProjectDir);
+    await useSource('test-source', testSourceDir, testProjectDir);
+    await unuseSource('test-source', testProjectDir);
+    
+    const config = await fs.readJson(path.join(testProjectDir, 'tools-cc.json'));
+    expect(config.sources).not.toContain('test-source');
+  });
+
+  it('should list used sources', async () => {
+    await initProject(testProjectDir);
+    await useSource('test-source', testSourceDir, testProjectDir);
+    
+    const sources = await listUsedSources(testProjectDir);
+    expect(sources).toContain('test-source');
+  });
+});