skill4agent 1.0.0

package/src/commands/add.ts

@@ -0,0 +1,311 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import inquirer from 'inquirer';
+import os from 'os';
+import path from 'path';
+import { extractZip } from '../utils';
+import { UNIVERSAL_AGENTS, OTHER_AGENTS, UNIVERSAL_PATH, getAgentDisplayPath } from '../tools';
+import { downloadSkill, getSkillInfo, SkillInfo } from '../api';
+
+function getAgentName(id: string): string {
+  const agent = [...UNIVERSAL_AGENTS, ...OTHER_AGENTS].find(a => a.id === id);
+  return agent?.name || id;
+}
+
+async function promptTypeSelection(skillInfo: SkillInfo): Promise<'original' | 'translated'> {
+  const isOriginalEnglish = skillInfo.originalLanguage === 'en';
+  const originalName = isOriginalEnglish ? 'English' : 'Chinese';
+  const translatedName = isOriginalEnglish ? 'Chinese' : 'English';
+
+  if (!skillInfo.hasTranslation) {
+    console.log(chalk.yellow(`\nℹ️  This skill does not have a ${translatedName} translation yet.`));
+    console.log(chalk.gray(`   Installing ${originalName} version...\n`));
+    return 'original';
+  }
+
+  const { type } = await inquirer.prompt({
+    type: 'list',
+    name: 'type',
+    message: `Select version for "${skillInfo.name}"`,
+    choices: [
+      {
+        name: `${originalName} (Original)`,
+        value: 'original',
+      },
+      {
+        name: `${translatedName} (Translation)`,
+        value: 'translated',
+      },
+    ],
+    default: 'original',
+  });
+
+  return type;
+}
+
+async function promptScopeSelection(): Promise<'project' | 'global'> {
+  const { scope } = await inquirer.prompt({
+    type: 'list',
+    name: 'scope',
+    message: 'Installation scope',
+    choices: [
+      {
+        name: 'Project (Install in current directory (committed with your project))',
+        value: 'project',
+      },
+      {
+        name: 'Global (Install in home directory (available across all projects))',
+        value: 'global',
+      },
+    ],
+    default: 'project',
+  });
+
+  return scope;
+}
+
+async function promptAgentSelection(isGlobal: boolean): Promise<string[]> {
+  const universalNames = UNIVERSAL_AGENTS.map(a => a.name).join(', ');
+  const universalDisplayPath = getAgentDisplayPath(UNIVERSAL_AGENTS[0].id, isGlobal);
+
+  const otherAgentChoices = OTHER_AGENTS.map(agent => ({
+    name: `${agent.name} (${getAgentDisplayPath(agent.id, isGlobal)})`,
+    value: agent.id,
+  }));
+
+  console.log(chalk.green(`✓ Universal (${universalDisplayPath}): ${universalNames} is always included`));
+
+  const { selectedOtherAgents } = await inquirer.prompt({
+    type: 'checkbox',
+    name: 'selectedOtherAgents',
+    message: 'Select additional agents:',
+    pageSize: 12,
+    loop: false,
+    choices: otherAgentChoices,
+  });
+
+  const selectedNames = (selectedOtherAgents as string[]).map(id =>
+    OTHER_AGENTS.find(a => a.id === id)?.name || id
+  );
+  const displayNames = selectedNames.length > 0
+    ? ['Universal', ...selectedNames].join(', ')
+    : 'Universal';
+  console.log(chalk.green(`✓ Selected: ${displayNames}\n`));
+
+  const universalAgentIds = UNIVERSAL_AGENTS.map(a => a.id);
+  return [...universalAgentIds, ...(selectedOtherAgents as string[])];
+}
+
+async function promptMethodSelection(): Promise<'symlink' | 'copy'> {
+  const { method } = await inquirer.prompt({
+    type: 'list',
+    name: 'method',
+    message: 'Installation method',
+    choices: [
+      {
+        name: 'Symlink (Recommended) (Single source of truth, easy updates)',
+        value: 'symlink',
+      },
+      {
+        name: 'Copy to all agents (Independent copies for each agent)',
+        value: 'copy',
+      },
+    ],
+    default: 'symlink',
+  });
+
+  return method;
+}
+
+function displaySummary(
+  skillName: string,
+  source: string,
+  typeDisplay: string,
+  scope: string,
+  agents: string[],
+  method: string
+): void {
+  const universalAgentIds = UNIVERSAL_AGENTS.map(a => a.id);
+  const hasUniversal = agents.some(id => universalAgentIds.includes(id));
+  const otherAgents = agents.filter(id => !universalAgentIds.includes(id));
+  const otherAgentNames = otherAgents.map(id => getAgentName(id));
+
+  const agentDisplay = hasUniversal
+    ? ['Universal', ...otherAgentNames].join(', ')
+    : otherAgentNames.join(', ');
+  const agentCount = (hasUniversal ? 1 : 0) + otherAgentNames.length;
+
+  console.log(chalk.blue('\n📊 Installation Summary'));
+  console.log(chalk.gray('─'.repeat(50)));
+  console.log(`Skill: ${chalk.white(skillName)}`);
+  console.log(`Source: ${source}`);
+  console.log(`Type: ${typeDisplay}`);
+  console.log(`Scope: ${scope === 'global' ? 'Global' : 'Project'}`);
+  console.log(`Agents (${agentCount}): ${agentDisplay}`);
+  console.log(`Method: ${method === 'symlink' ? 'Symlink (Recommended)' : 'Copy'}`);
+  console.log(chalk.gray('─'.repeat(50)));
+}
+
+async function promptConfirmation(): Promise<boolean> {
+  const { confirm } = await inquirer.prompt({
+    type: 'confirm',
+    name: 'confirm',
+    message: 'Proceed with installation?',
+    default: true,
+  });
+
+  return confirm;
+}
+
+export async function add(topSource: string, skillName: string): Promise<void> {
+  console.log(chalk.blue(`\n📦 Installing skill: ${skillName}`));
+  console.log(chalk.gray(`   Source: ${topSource}\n`));
+
+  let result: { skill: SkillInfo | null; sourceExists: boolean };
+  try {
+    result = await getSkillInfo(topSource, skillName);
+  } catch (error: any) {
+    console.log(chalk.red(`\n❌  Skill "${skillName}" not found in source "${topSource}".`));
+    console.log(chalk.gray(`   Please check the source repository and skill name.\n`));
+    return;
+  }
+
+  if (!result.skill) {
+    console.log(chalk.red(`\n❌  Skill "${skillName}" not found in source "${topSource}".`));
+    console.log(chalk.gray(`   Please check the source repository and skill name.\n`));
+    return;
+  }
+
+  const skillInfo = result.skill;
+
+  console.log(chalk.blue(`\n📦 Skill: ${chalk.white(skillInfo.name)}`));
+  console.log(chalk.gray(`   Category: ${skillInfo.category?.nameEn || 'N/A'} | Installs: ${skillInfo.installs}`));
+
+  if (skillInfo.tags) {
+    console.log(chalk.gray(`   Tags: ${skillInfo.tags}`));
+  }
+
+  if (!skillInfo.hasScript) {
+    console.log(chalk.gray(`   📜 Scripts: No scripts`));
+  } else {
+    const statusText = skillInfo.scriptCheckResult === 'safe' ? '✅ Check passed' : '⚠️ Needs attention';
+    console.log(chalk.gray(`   📜 Scripts: ${skillInfo.scriptCount} script(s) - ${statusText}`));
+  }
+
+  console.log(chalk.gray(`   ${skillInfo.hasTranslation ? '✅' : '❌'} Translation available\n`));
+
+  const type = await promptTypeSelection(skillInfo);
+
+  const isOriginalEnglish = skillInfo.originalLanguage === 'en';
+  const typeDisplay = type === 'original'
+    ? (isOriginalEnglish ? 'English' : 'Chinese')
+    : (isOriginalEnglish ? 'Chinese' : 'English');
+  console.log(chalk.gray(`   Type: ${typeDisplay}\n`));
+
+  const scope = await promptScopeSelection();
+  const isGlobal = scope === 'global';
+
+  const selectedAgentIds = await promptAgentSelection(isGlobal);
+  if (selectedAgentIds.length === 0) {
+    console.log(chalk.yellow('\n⚠️  No agents selected. Installation cancelled.'));
+    return;
+  }
+
+  const installMethod = await promptMethodSelection();
+
+  displaySummary(skillName, topSource, typeDisplay, scope, selectedAgentIds, installMethod);
+
+  const confirmed = await promptConfirmation();
+  if (!confirmed) {
+    console.log(chalk.yellow('\n⚠️  Installation cancelled.'));
+    return;
+  }
+
+  const basePath = isGlobal ? os.homedir() : process.cwd();
+
+  let tempZip: string;
+  try {
+    tempZip = await downloadSkill(topSource, skillName, type);
+  } catch (error: any) {
+    if (error.response?.status === 404) {
+      console.log(chalk.red(`\n❌  Failed to download skill "${skillName}".`));
+      console.log(chalk.gray(`   The skill may not exist or the download link is invalid.\n`));
+      return;
+    }
+    console.log(chalk.red(`\n❌  Download failed: ${error.message}`));
+    return;
+  }
+
+  if (installMethod === 'symlink') {
+    const universalFullPath = path.join(basePath, UNIVERSAL_PATH);
+    fs.ensureDirSync(universalFullPath);
+    const skillDir = path.join(universalFullPath, skillName);
+
+    if (fs.existsSync(skillDir)) {
+      console.log(chalk.yellow(`\n⚠️  Skill "${skillName}" already exists. Overwriting...`));
+      fs.removeSync(skillDir);
+    }
+
+    await extractZip(tempZip, universalFullPath);
+    fs.removeSync(tempZip);
+
+    console.log(chalk.green(`✅ Installed to: ${skillDir}`));
+
+    const otherAgentIds = selectedAgentIds.filter(id => !UNIVERSAL_AGENTS.some(a => a.id === id));
+
+    for (const agentId of otherAgentIds) {
+      const agent = OTHER_AGENTS.find(a => a.id === agentId);
+      if (!agent) continue;
+      const effectivePath = isGlobal && agent.globalPath ? agent.globalPath : agent.path;
+      const agentPath = path.join(basePath, effectivePath);
+      fs.ensureDirSync(agentPath);
+      const destDir = path.join(agentPath, skillName);
+      if (fs.existsSync(destDir)) {
+        fs.removeSync(destDir);
+      }
+
+      if (isGlobal) {
+        fs.symlinkSync(skillDir, destDir);
+      } else {
+        const relativePath = path.relative(agentPath, skillDir);
+        fs.symlinkSync(relativePath, destDir);
+      }
+
+      console.log(chalk.green(`✅ Linked to: ${destDir}`));
+    }
+  } else {
+    const universalFullPath = path.join(basePath, UNIVERSAL_PATH);
+    fs.ensureDirSync(universalFullPath);
+
+    if (fs.existsSync(path.join(universalFullPath, skillName))) {
+      fs.removeSync(path.join(universalFullPath, skillName));
+    }
+
+    await extractZip(tempZip, universalFullPath);
+    fs.removeSync(tempZip);
+
+    console.log(chalk.green(`✅ Copied to: ${universalFullPath}`));
+
+    let copiedCount = 0;
+    const otherAgentIds = selectedAgentIds.filter(id => !UNIVERSAL_AGENTS.some(a => a.id === id));
+
+    for (const agentId of otherAgentIds) {
+      const agent = OTHER_AGENTS.find(a => a.id === agentId);
+      if (!agent) continue;
+      const effectivePath = isGlobal && agent.globalPath ? agent.globalPath : agent.path;
+      const agentPath = path.join(basePath, effectivePath);
+      fs.ensureDirSync(agentPath);
+      const destDir = path.join(agentPath, skillName);
+
+      if (fs.existsSync(destDir)) {
+        fs.removeSync(destDir);
+      }
+
+      fs.copySync(path.join(universalFullPath, skillName), destDir);
+      console.log(chalk.green(`✅ Copied to: ${destDir}`));
+      copiedCount++;
+    }
+  }
+
+  console.log(chalk.green('\n🎉 Installation completed!\n'));
+}

package/src/commands/install.ts

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { extractZip } from '../utils';
+import { UNIVERSAL_PATH, getAgentDisplayPath } from '../tools';
+import { downloadSkill, getSkillInfo } from '../api';
+
+interface InstallOptions {
+  topSource: string;
+  skillName: string;
+  type: 'original' | 'translated';
+  global: boolean;
+  dirs: string[];
+  method: 'symlink' | 'copy';
+}
+
+function getAgentNameFromPath(dirPath: string): string {
+  const name = path.basename(dirPath);
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+function getAgentDisplayName(dirPath: string): string {
+  const dirname = path.basename(path.dirname(dirPath));
+  if (dirname === '.agents') return 'Universal';
+  return dirname.charAt(0).toUpperCase() + dirname.slice(1);
+}
+
+function displaySummary(options: InstallOptions, skillInfo: any, typeDisplay: string, allDirs: string[]): void {
+  const dirNames = allDirs.map(d => getAgentDisplayName(d));
+  const dirCount = allDirs.length;
+
+  console.log(chalk.blue('\n📊 Installation Summary'));
+  console.log(chalk.gray('─'.repeat(50)));
+  console.log(`Skill: ${chalk.white(skillInfo.name)}`);
+  console.log(`Source: ${options.topSource}`);
+  console.log(`Type: ${typeDisplay}`);
+  console.log(`Scope: ${options.global ? 'Global' : 'Project'}`);
+  console.log(`Dirs (${dirCount}): ${dirNames.join(', ')}`);
+  console.log(`Method: ${options.method === 'symlink' ? 'Symlink (Recommended)' : 'Copy'}`);
+  console.log(chalk.gray('─'.repeat(50)));
+}
+
+export async function install(options: InstallOptions): Promise<void> {
+  const { topSource, skillName, type, global, dirs, method } = options;
+
+  console.log(chalk.blue(`\n📦 Installing skill: ${skillName}`));
+  console.log(chalk.gray(`   Source: ${topSource}\n`));
+
+  let result: { skill: any; sourceExists: boolean };
+  try {
+    result = await getSkillInfo(topSource, skillName);
+  } catch (error: any) {
+    console.log(chalk.red(`\n❌  Skill "${skillName}" not found in source "${topSource}".`));
+    console.log(chalk.gray(`   Please check the source repository and skill name.\n`));
+    return;
+  }
+
+  if (!result.skill) {
+    console.log(chalk.red(`\n❌  Skill "${skillName}" not found in source "${topSource}".`));
+    console.log(chalk.gray(`   Please check the source repository and skill name.\n`));
+    return;
+  }
+
+  const skillInfo = result.skill;
+
+  console.log(chalk.blue(`\n📦 Skill: ${chalk.white(skillInfo.name)}`));
+  console.log(chalk.gray(`   Category: ${skillInfo.category?.nameEn || 'N/A'} | Installs: ${skillInfo.installs}`));
+
+  if (skillInfo.tags) {
+    console.log(chalk.gray(`   Tags: ${skillInfo.tags}`));
+  }
+
+  if (!skillInfo.hasScript) {
+    console.log(chalk.gray(`   📜 Scripts: No scripts`));
+  } else {
+    const statusText = skillInfo.scriptCheckResult === 'safe' ? '✅ Check passed' : '⚠️ Needs attention';
+    console.log(chalk.gray(`   📜 Scripts: ${skillInfo.scriptCount} script(s) - ${statusText}`));
+  }
+
+  console.log(chalk.gray(`   ${skillInfo.hasTranslation ? '✅' : '❌'} Translation available\n`));
+
+  let finalType = type;
+  const isOriginalEnglish = skillInfo.originalLanguage === 'en';
+
+  if (type === 'translated' && !skillInfo.hasTranslation) {
+    console.log(chalk.yellow(`⚠️  Translation not available. Using original (${isOriginalEnglish ? 'English' : 'Chinese'}) version.\n`));
+    finalType = 'original';
+  }
+
+  const typeDisplay = finalType === 'original'
+    ? (isOriginalEnglish ? 'English' : 'Chinese')
+    : (isOriginalEnglish ? 'Chinese' : 'English');
+  console.log(chalk.gray(`   Type: ${typeDisplay}\n`));
+
+  const isGlobal = global;
+  const basePath = isGlobal ? os.homedir() : process.cwd();
+
+  const allDirs = [UNIVERSAL_PATH, ...dirs.map((d: string) => d.endsWith('/skills') ? d : `${d}/skills`)];
+  const dirNames = allDirs.map(d => getAgentDisplayName(d));
+  console.log(chalk.green(`✓ Directories: ${dirNames.join(', ')}`));
+
+  if (allDirs.length === 0) {
+    console.log(chalk.yellow('\n⚠️  No directories selected. Installation cancelled.'));
+    return;
+  }
+
+  displaySummary({ topSource, skillName, type: finalType, global, dirs, method }, skillInfo, typeDisplay, allDirs);
+
+  let tempZip: string;
+  try {
+    tempZip = await downloadSkill(topSource, skillName, finalType);
+  } catch (error: any) {
+    if (error.response?.status === 404) {
+      console.log(chalk.red(`\n❌  Failed to download skill "${skillName}".`));
+      console.log(chalk.gray(`   The skill may not exist or the download link is invalid.\n`));
+      return;
+    }
+    console.log(chalk.red(`\n❌  Download failed: ${error.message}`));
+    return;
+  }
+
+  if (method === 'symlink') {
+    const universalFullPath = path.join(basePath, UNIVERSAL_PATH);
+    fs.ensureDirSync(universalFullPath);
+    const skillDir = path.join(universalFullPath, skillName);
+
+    if (fs.existsSync(skillDir)) {
+      console.log(chalk.yellow(`\n⚠️  Skill "${skillName}" already exists. Overwriting...`));
+      fs.removeSync(skillDir);
+    }
+
+    await extractZip(tempZip, universalFullPath);
+    fs.removeSync(tempZip);
+
+    console.log(chalk.green(`✅ Installed to: ${skillDir}`));
+
+    for (const dir of dirs) {
+      const fullDir = dir.endsWith('/skills') ? dir : `${dir}/skills`;
+      const dirPath = path.join(basePath, fullDir);
+      fs.ensureDirSync(dirPath);
+      const destDir = path.join(dirPath, skillName);
+      if (fs.existsSync(destDir)) {
+        fs.removeSync(destDir);
+      }
+
+      if (isGlobal) {
+        fs.symlinkSync(skillDir, destDir);
+      } else {
+        const relativePath = path.relative(dirPath, skillDir);
+        fs.symlinkSync(relativePath, destDir);
+      }
+
+      console.log(chalk.green(`✅ Linked to: ${destDir}`));
+    }
+  } else {
+    const universalFullPath = path.join(basePath, UNIVERSAL_PATH);
+    const skillDir = path.join(universalFullPath, skillName);
+    fs.ensureDirSync(universalFullPath);
+
+    if (fs.existsSync(skillDir)) {
+      fs.removeSync(skillDir);
+    }
+
+    await extractZip(tempZip, universalFullPath);
+    fs.removeSync(tempZip);
+
+    console.log(chalk.green(`✅ Copied to: ${skillDir}`));
+
+    for (const dir of dirs) {
+      const fullDir = dir.endsWith('/skills') ? dir : `${dir}/skills`;
+      const dirPath = path.join(basePath, fullDir);
+      fs.ensureDirSync(dirPath);
+      const destDir = path.join(dirPath, skillName);
+
+      if (fs.existsSync(destDir)) {
+        fs.removeSync(destDir);
+      }
+
+      fs.copySync(skillDir, destDir);
+      console.log(chalk.green(`✅ Copied to: ${destDir}`));
+    }
+  }
+
+  console.log(chalk.green('\n🎉 Installation completed!\n'));
+}

package/src/commands/list.ts

@@ -0,0 +1,15 @@
+export async function list(): Promise<void> {
+  console.log('list command');
+}
+
+export async function search(query: string): Promise<void> {
+  console.log('search command', query);
+}
+
+export async function update(skillName?: string): Promise<void> {
+  console.log('update command', skillName);
+}
+
+export async function uninstall(skillName: string): Promise<void> {
+  console.log('uninstall command', skillName);
+}

package/src/main.ts

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { install } from './commands/install';
+import { add } from './commands/add';
+import { list, search, update, uninstall } from './commands/list';
+
+const program = new Command();
+
+program
+  .name('skill4agent')
+  .description('CLI tool for installing and managing agent skills')
+  .version('1.0.0');
+
+program
+  .command('add <top_source> <skill_name>')
+  .description('Interactive installation with guided prompts')
+  .action(async (topSource: string, skillName: string) => {
+    await add(topSource, skillName);
+  });
+
+program
+  .command('install <top_source> <skill_name>')
+  .description('Non-interactive installation with command-line options')
+  .option('--type <type>', 'Package type: original or translated', 'original')
+  .option('--global', 'Install to global storage')
+  .option('--dirs <dirs>', 'Additional directories (comma-separated): .trae,.cursor,.qwen')
+  .option('--method <method>', 'Installation method: symlink or copy', 'symlink')
+  .action(async (topSource: string, skillName: string, options: any) => {
+    if (options.type && !['original', 'translated'].includes(options.type)) {
+      console.log(chalk.red('\n❌ Invalid --type value. Must be "original" or "translated".\n'));
+      process.exit(1);
+    }
+
+    if (options.method && !['symlink', 'copy'].includes(options.method)) {
+      console.log(chalk.red('\n❌ Invalid --method value. Must be "symlink" or "copy".\n'));
+      process.exit(1);
+    }
+
+    const dirsArray = options.dirs
+      ? options.dirs.split(',').map((a: string) => a.trim()).filter((a: string) => a.length > 0)
+      : [];
+
+    await install({
+      topSource,
+      skillName,
+      type: options.type || 'original',
+      global: !!options.global,
+      dirs: dirsArray,
+      method: options.method || 'symlink',
+    });
+  });
+
+program
+  .command('list')
+  .description('List installed skills')
+  .action(list);
+
+program
+  .command('search <query>')
+  .description('Search for skills')
+  .action(search);
+
+program
+  .command('update [skill_name]')
+  .description('Update installed skills')
+  .action(update);
+
+program
+  .command('uninstall <skill_name>')
+  .description('Uninstall a skill')
+  .action(uninstall);
+
+program.parse();
+
+process.on('unhandledRejection', (reason: any) => {
+  console.error(chalk.red('Error:'), reason);
+  process.exit(1);
+});