@42ailab/42plugin 0.1.18 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@42ailab/42plugin",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "活水插件",
   "type": "module",
   "main": "src/index.ts",

package/src/api.ts

@@ -261,18 +261,20 @@ class ApiClient {
   // ==========================================================================
 
   /**
-   * 搜索插件
+   * 搜索插件和套包
    * 使用 CLI 专用端点 /cli/v1/search
-   * 响应直接返回 camelCase，只返回插件不返回套包
+   * 响应直接返回 camelCase
    */
   async search(params: {
     q: string;
+    searchType?: 'plugin' | 'kit' | 'all';
     pluginType?: string;
     page?: number;
     perPage?: number;
   }): Promise<SearchResponse> {
     const searchParams = new URLSearchParams();
     searchParams.set('q', params.q);
+    if (params.searchType) searchParams.set('search_type', params.searchType);
     if (params.pluginType) searchParams.set('type', params.pluginType);
     if (params.page) searchParams.set('page', String(params.page));
     if (params.perPage) searchParams.set('per_page', String(params.perPage));
@@ -302,7 +304,7 @@ class ApiClient {
 
     // CLI 专用端点直接返回 camelCase 格式
     interface CliSearchResponse {
-      data: Array<{
+      plugins: Array<{
         fullName: string;
         name: string;
         title: string | null;
@@ -312,9 +314,19 @@ class ApiClient {
         downloads: number;
         description: string | null;
       }>;
+      kits: Array<{
+        fullName: string;
+        name: string;
+        author: string;
+        pluginCount: number;
+        downloads: number;
+        description: string | null;
+      }>;
       pagination: {
         page: number;
         perPage: number;
+        totalPlugins: number;
+        totalKits: number;
         total: number;
         totalPages: number;
       };
@@ -323,7 +335,7 @@ class ApiClient {
     const apiData = raw as CliSearchResponse;
 
     return {
-      data: apiData.data.map((p) => ({
+      plugins: apiData.plugins.map((p) => ({
         fullName: p.fullName,
         name: p.name,
         title: p.title,
@@ -336,9 +348,19 @@ class ApiClient {
         downloads: p.downloads,
         icon: null,
       })),
+      kits: apiData.kits.map((k) => ({
+        fullName: k.fullName,
+        name: k.name,
+        author: k.author,
+        pluginCount: k.pluginCount,
+        downloads: k.downloads,
+        description: k.description,
+      })),
       pagination: {
         page: apiData.pagination.page,
         perPage: apiData.pagination.perPage,
+        totalPlugins: apiData.pagination.totalPlugins,
+        totalKits: apiData.pagination.totalKits,
         total: apiData.pagination.total,
         totalPages: apiData.pagination.totalPages,
       },

package/src/cli.ts

@@ -9,7 +9,6 @@ import {
   searchCommand,
   listCommand,
   uninstallCommand,
-  completionCommand,
   setupCommand,
   publishCommand,
   checkCommand,
@@ -53,7 +52,6 @@ program.addCommand(listCommand);
 program.addCommand(uninstallCommand);
 program.addCommand(publishCommand);
 program.addCommand(checkCommand);
-program.addCommand(completionCommand);
 program.addCommand(setupCommand);
 
 // 版本命令

package/src/commands/index.ts

@@ -7,7 +7,6 @@ export { installCommand } from './install';
 export { searchCommand } from './search';
 export { listCommand } from './list';
 export { uninstallCommand } from './uninstall';
-export { completionCommand } from './completion';
 export { setupCommand } from './setup';
 export { publishCommand } from './publish';
 export { checkCommand } from './check';

package/src/commands/install.ts

@@ -192,43 +192,74 @@ async function installKit(
     }
 
     spinner.succeed(`${kitDownload.kit.name} - ${plugins.length} 个插件`);
+
+    // 超过 42 个插件时提示确认
+    if (plugins.length > 42) {
+      console.log();
+      console.log(chalk.yellow(`⚠ 该套包包含 ${plugins.length} 个插件，数量较多`));
+      const shouldContinue = await confirm({
+        message: '确定要继续安装吗？',
+        default: true,
+      });
+      if (!shouldContinue) {
+        console.log(chalk.gray('已取消安装'));
+        return;
+      }
+    }
+
     console.log();
 
     // 获取项目
     const projectPath = options.global ? config.globalDir : process.cwd();
     const project = await getOrCreateProject(projectPath);
 
-    // 安装每个插件
-    let installed = 0;
-    let failed = 0;
-
-    for (const item of plugins) {
-      const pluginSpinner = ora(`  ${item.plugin.fullName}...`).start();
-
-      try {
+    // 第一阶段：检查所有冲突（并行）
+    const conflictCheckSpinner = ora('检查安装冲突...').start();
+    const conflictResults = await Promise.all(
+      plugins.map(async (item) => {
         const downloadInfo = item.download;
         const linkPath = path.join(projectPath, downloadInfo.installPath);
-
-        // 检查是否有同名冲突
         const conflictPlugin = await checkInstallConflict(projectPath, linkPath, downloadInfo.fullName);
-        if (conflictPlugin) {
-          pluginSpinner.stop();
-          console.log(chalk.yellow(`  ⚠ 路径冲突: ${downloadInfo.installPath}`));
-          console.log(chalk.gray(`    已安装: ${conflictPlugin}`));
-
-          const shouldReplace = await confirm({
-            message: `是否替换 ${conflictPlugin}？`,
-            default: false,
-          });
-
-          if (!shouldReplace) {
-            console.log(chalk.gray('    已跳过'));
-            continue;
-          }
-          // 删除冲突的旧安装记录
-          await removeInstallation(projectPath, conflictPlugin);
-          pluginSpinner.start(`  ${item.plugin.fullName}...`);
+        return { item, linkPath, conflictPlugin };
+      })
+    );
+    conflictCheckSpinner.stop();
+
+    // 第二阶段：处理冲突（需要用户交互，只能串行）
+    const toInstall: typeof conflictResults = [];
+    for (const result of conflictResults) {
+      if (result.conflictPlugin) {
+        console.log(chalk.yellow(`⚠ 路径冲突: ${result.item.download.installPath}`));
+        console.log(chalk.gray(`  已安装: ${result.conflictPlugin}`));
+        console.log(chalk.gray(`  新插件: ${result.item.plugin.fullName}`));
+
+        const shouldReplace = await confirm({
+          message: `是否替换 ${result.conflictPlugin}？`,
+          default: false,
+        });
+
+        if (shouldReplace) {
+          await removeInstallation(projectPath, result.conflictPlugin);
+          toInstall.push(result);
+        } else {
+          console.log(chalk.gray('  已跳过'));
         }
+      } else {
+        toInstall.push(result);
+      }
+    }
+
+    if (toInstall.length === 0) {
+      console.log(chalk.yellow('没有需要安装的插件'));
+      return;
+    }
+
+    // 第三阶段：并行安装
+    const installSpinner = ora(`安装 ${toInstall.length} 个插件...`).start();
+
+    const results = await Promise.allSettled(
+      toInstall.map(async ({ item, linkPath }) => {
+        const downloadInfo = item.download;
 
         const { cachePath, fromCache } = await resolveCachePath(
           downloadInfo,
@@ -253,13 +284,30 @@ async function installKit(
           api.recordInstall(downloadInfo.fullName).catch(() => {});
         }
 
-        pluginSpinner.succeed(
-          `  ${getTypeIcon(downloadInfo.type)} ${downloadInfo.fullName}` +
+        return { downloadInfo, fromCache };
+      })
+    );
+
+    installSpinner.stop();
+
+    // 显示结果
+    let installed = 0;
+    let failed = 0;
+
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const item = toInstall[i].item;
+
+      if (result.status === 'fulfilled') {
+        const { downloadInfo, fromCache } = result.value;
+        console.log(
+          chalk.green('  ✓ ') +
+            `${getTypeIcon(downloadInfo.type)} ${downloadInfo.fullName}` +
             (fromCache ? chalk.gray(' (cached)') : '')
         );
         installed++;
-      } catch (error) {
-        pluginSpinner.fail(`  ${item.plugin.fullName}: ${(error as Error).message}`);
+      } else {
+        console.log(chalk.red(`  ✗ ${item.plugin.fullName}: ${result.reason?.message || '未知错误'}`));
         failed++;
       }
     }

package/src/commands/publish.ts

@@ -10,6 +10,7 @@ import { ValidationError, UploadError, AuthRequiredError } from '../errors';
 import { getTypeIcon } from '../utils';
 
 export const publishCommand = new Command('publish')
+  .alias('pub')
   .description('发布插件到 42plugin')
   .argument('[path]', '插件路径（文件或目录）', '.')
   .option('--dry-run', '仅验证，不实际发布')

package/src/commands/search.ts

@@ -1,5 +1,5 @@
 /**
- * search 命令 - 搜索插件
+ * search 命令 - 搜索插件和套包
  */
 
 import { Command } from 'commander';
@@ -8,11 +8,11 @@ import ora from 'ora';
 import { checkbox, confirm } from '@inquirer/prompts';
 import { api } from '../api';
 import { getTypeIcon, getTypeLabel } from '../utils';
-import type { SearchResult } from '../types';
+import type { SearchResult, KitSearchResult } from '../types';
 
 const DEFAULT_PAGE_SIZE = 7;
 
-function displayResults(items: SearchResult[], startIndex: number = 0): void {
+function displayPluginResults(items: SearchResult[]): void {
   for (const item of items) {
     const icon = getTypeIcon(item.type);
     const typeLabel = getTypeLabel(item.type);
@@ -35,10 +35,28 @@ function displayResults(items: SearchResult[], startIndex: number = 0): void {
   }
 }
 
+function displayKitResults(items: KitSearchResult[]): void {
+  for (const item of items) {
+    console.log(`📦 ${chalk.magenta.bold(item.fullName)} ${chalk.gray('[套包]')}`);
+
+    if (item.description) {
+      const desc = item.description.length > 80
+        ? item.description.slice(0, 80) + '...'
+        : item.description;
+      console.log(chalk.gray(`  ${desc}`));
+    }
+
+    console.log(chalk.gray(`  ${item.pluginCount} 个插件 · ${item.downloads} 下载`));
+    console.log();
+  }
+}
+
 export const searchCommand = new Command('search')
-  .description('搜索插件')
+  .description('搜索插件和套包')
   .argument('<keyword>', '搜索关键词')
-  .option('-t, --type <type>', '筛选类型 (skill, agent, command, hook, mcp)')
+  .option('-t, --type <type>', '筛选插件类型 (skill, agent, command, hook, mcp)')
+  .option('-k, --kit', '只搜索套包')
+  .option('-p, --plugin', '只搜索插件')
   .option('-l, --limit <n>', '每页数量', String(DEFAULT_PAGE_SIZE))
   .option('-a, --all', '显示所有结果')
   .option('--json', '输出 JSON 格式')
@@ -49,14 +67,19 @@ export const searchCommand = new Command('search')
 
     try {
       const pageSize = parseInt(options.limit) || DEFAULT_PAGE_SIZE;
-      let allResults: SearchResult[] = [];
+      let allPlugins: SearchResult[] = [];
+      let allKits: KitSearchResult[] = [];
       let currentPage = 1;
-      let totalResults = 0;
-      let displayedCount = 0;
+
+      // 确定搜索类型
+      let searchType: 'plugin' | 'kit' | 'all' = 'all';
+      if (options.kit) searchType = 'kit';
+      else if (options.plugin || options.type) searchType = 'plugin';
 
       // 首次搜索
       const result = await api.search({
         q: keyword,
+        searchType,
         pluginType: options.type,
         perPage: pageSize,
         page: currentPage,
@@ -69,25 +92,41 @@ export const searchCommand = new Command('search')
         return;
       }
 
-      if (result.data.length === 0) {
-        console.log(chalk.yellow('未找到匹配的插件'));
+      const totalPlugins = result.pagination.totalPlugins;
+      const totalKits = result.pagination.totalKits;
+      const total = result.pagination.total;
+
+      if (total === 0) {
+        console.log(chalk.yellow('未找到匹配的结果'));
         return;
       }
 
-      totalResults = result.pagination.total;
-      allResults = result.data;
+      // 显示统计
+      const stats: string[] = [];
+      if (totalPlugins > 0) stats.push(`${totalPlugins} 个插件`);
+      if (totalKits > 0) stats.push(`${totalKits} 个套包`);
+      console.log(chalk.gray(`找到 ${stats.join('，')}:\n`));
+
+      allPlugins = result.plugins;
+      allKits = result.kits;
+
+      // 先显示套包
+      if (allKits.length > 0) {
+        displayKitResults(allKits);
+      }
 
-      console.log(chalk.gray(`找到 ${totalResults} 个结果:\n`));
+      // 再显示插件
+      if (allPlugins.length > 0) {
+        displayPluginResults(allPlugins);
+      }
 
-      // 显示首批结果
-      displayResults(allResults);
-      displayedCount = allResults.length;
+      let displayedCount = allPlugins.length + allKits.length;
 
       // 如果有更多结果，根据模式决定是否继续
-      while (displayedCount < totalResults) {
+      while (displayedCount < total) {
         // 非 --all 模式下询问用户
         if (!options.all) {
-          const remaining = totalResults - displayedCount;
+          const remaining = total - displayedCount;
 
           const loadMore = await confirm({
             message: `还有 ${remaining} 个结果，是否继续查看？`,
@@ -104,6 +143,7 @@ export const searchCommand = new Command('search')
 
         const moreResult = await api.search({
           q: keyword,
+          searchType,
           pluginType: options.type,
           perPage: pageSize,
           page: currentPage,
@@ -111,7 +151,7 @@ export const searchCommand = new Command('search')
 
         moreSpinner.stop();
 
-        if (moreResult.data.length === 0) {
+        if (moreResult.plugins.length === 0 && moreResult.kits.length === 0) {
           break;
         }
 
@@ -119,21 +159,37 @@ export const searchCommand = new Command('search')
           console.log();
         }
 
-        displayResults(moreResult.data);
-        allResults = [...allResults, ...moreResult.data];
-        displayedCount += moreResult.data.length;
+        if (moreResult.kits.length > 0) {
+          displayKitResults(moreResult.kits);
+          allKits = [...allKits, ...moreResult.kits];
+        }
+
+        if (moreResult.plugins.length > 0) {
+          displayPluginResults(moreResult.plugins);
+          allPlugins = [...allPlugins, ...moreResult.plugins];
+        }
+
+        displayedCount += moreResult.plugins.length + moreResult.kits.length;
       }
 
       // 交互式选择安装
-      if (options.interactive && allResults.length > 0) {
+      if (options.interactive && (allPlugins.length > 0 || allKits.length > 0)) {
         console.log();
-        const choices = allResults.map((item) => ({
-          name: `${getTypeIcon(item.type)} ${item.fullName} - ${item.title || item.slogan || item.description?.slice(0, 30) || ''}`,
-          value: item.fullName,
-        }));
+
+        // 构建选项列表（套包在前，插件在后）
+        const choices = [
+          ...allKits.map((item) => ({
+            name: `📦 ${item.fullName} - ${item.description?.slice(0, 30) || `${item.pluginCount} 个插件`}`,
+            value: item.fullName,
+          })),
+          ...allPlugins.map((item) => ({
+            name: `${getTypeIcon(item.type)} ${item.fullName} - ${item.title || item.slogan || item.description?.slice(0, 30) || ''}`,
+            value: item.fullName,
+          })),
+        ];
 
         const selected = await checkbox({
-          message: '选择要安装的插件 (空格选择，回车确认):',
+          message: '选择要安装的插件/套包 (空格选择，回车确认):',
           choices,
         });
 

package/src/commands/uninstall.ts

@@ -1,5 +1,5 @@
 /**
- * uninstall 命令 - 卸载插件
+ * uninstall 命令 - 卸载插件或套包
  */
 
 import { Command } from 'commander';
@@ -8,55 +8,140 @@ import ora from 'ora';
 import { api } from '../api';
 import { getInstallations, removeInstallation, removeLink, removeCache } from '../db';
 import { parseTarget } from '../utils';
+import { TargetType } from '../types';
 
 export const uninstallCommand = new Command('uninstall')
   .alias('rm')
-  .description('卸载插件')
-  .argument('<target>', '插件名 (author/name)')
+  .description('卸载插件或套包')
+  .argument('<target>', '插件名 (author/name) 或套包名 (author/kit/slug)')
   .option('--purge', '同时清除缓存')
   .action(async (target, options) => {
-    // token 已在全局 hook 中注入
-    const spinner = ora(`卸载 ${target}...`).start();
-
     try {
       const parsed = parseTarget(target);
       const projectPath = process.cwd();
 
-      // 查找安装记录
-      const installations = await getInstallations(projectPath);
-      const installation = installations.find((i) => i.fullName === parsed.fullName);
-
-      if (!installation) {
-        spinner.fail(`未找到已安装的插件: ${target}`);
-        process.exit(1);
+      if (parsed.type === TargetType.Kit) {
+        // 卸载套包：批量卸载所有来自该套包的插件
+        await uninstallKit(projectPath, parsed.fullName, options.purge);
+      } else {
+        // 卸载单个插件
+        await uninstallPlugin(projectPath, parsed.fullName, options.purge);
       }
+    } catch (error) {
+      console.error(chalk.red((error as Error).message));
+      process.exit(1);
+    }
+  });
+
+/**
+ * 卸载单个插件
+ */
+async function uninstallPlugin(
+  projectPath: string,
+  fullName: string,
+  purge: boolean
+): Promise<void> {
+  const spinner = ora(`卸载 ${fullName}...`).start();
+
+  // 查找安装记录
+  const installations = await getInstallations(projectPath);
+  const installation = installations.find((i) => i.fullName === fullName);
+
+  if (!installation) {
+    spinner.fail(`未找到已安装的插件: ${fullName}`);
+    process.exit(1);
+  }
+
+  // 移除链接
+  await removeLink(installation.linkPath);
+
+  // 移除安装记录
+  await removeInstallation(projectPath, fullName);
+
+  // 同步卸载记录（静默）
+  if (api.isAuthenticated()) {
+    const parts = fullName.split('/');
+    const author = parts[0];
+    const name = parts.slice(1).join('/');
+    api.removeInstallRecord(author, name).catch(() => {});
+  }
+
+  // 清除缓存
+  if (purge) {
+    const removed = await removeCache(fullName, installation.version);
+    if (removed) {
+      spinner.succeed(`已卸载 ${fullName}（含缓存）`);
+    } else {
+      spinner.succeed(`已卸载 ${fullName}`);
+      console.log(chalk.gray('  缓存已不存在'));
+    }
+  } else {
+    spinner.succeed(`已卸载 ${fullName}`);
+  }
+}
+
+/**
+ * 卸载套包（批量卸载所有来自该套包的插件）
+ */
+async function uninstallKit(
+  projectPath: string,
+  kitFullName: string,
+  purge: boolean
+): Promise<void> {
+  const spinner = ora(`查找套包 ${kitFullName} 的插件...`).start();
+
+  // 查找所有来自该套包的安装记录
+  const installations = await getInstallations(projectPath);
+  const kitInstallations = installations.filter((i) => i.sourceKit === kitFullName);
+
+  if (kitInstallations.length === 0) {
+    spinner.fail(`未找到来自套包 ${kitFullName} 的已安装插件`);
+    process.exit(1);
+  }
+
+  spinner.text = `卸载 ${kitInstallations.length} 个插件...`;
 
+  // 批量卸载
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const installation of kitInstallations) {
+    try {
       // 移除链接
       await removeLink(installation.linkPath);
 
       // 移除安装记录
-      await removeInstallation(projectPath, parsed.fullName);
-
-      // 同步卸载记录（静默）
-      if (api.isAuthenticated()) {
-        api.removeInstallRecord(parsed.author, parsed.name).catch(() => {});
-      }
+      await removeInstallation(projectPath, installation.fullName);
 
       // 清除缓存
-      if (options.purge) {
-        const removed = await removeCache(parsed.fullName, installation.version);
-        if (removed) {
-          spinner.succeed(`已卸载 ${target}（含缓存）`);
-        } else {
-          spinner.succeed(`已卸载 ${target}`);
-          console.log(chalk.gray('  缓存已不存在'));
-        }
-      } else {
-        spinner.succeed(`已卸载 ${target}`);
+      if (purge) {
+        await removeCache(installation.fullName, installation.version);
       }
-    } catch (error) {
-      spinner.fail('卸载失败');
-      console.error(chalk.red((error as Error).message));
-      process.exit(1);
+
+      successCount++;
+    } catch {
+      failCount++;
     }
-  });
+  }
+
+  // 同步卸载记录（静默）
+  if (api.isAuthenticated()) {
+    const parts = kitFullName.split('/');
+    const author = parts[0];
+    const slug = parts[2];
+    api.removeInstallRecord(author, `kit/${slug}`).catch(() => {});
+  }
+
+  spinner.stop();
+
+  if (failCount === 0) {
+    console.log(chalk.green(`✓ 已卸载套包 ${kitFullName}`));
+    console.log(chalk.gray(`  共 ${successCount} 个插件`));
+    if (purge) {
+      console.log(chalk.gray('  缓存已清除'));
+    }
+  } else {
+    console.log(chalk.yellow(`⚠ 部分卸载完成`));
+    console.log(chalk.gray(`  成功: ${successCount}, 失败: ${failCount}`));
+  }
+}

package/src/db.ts

@@ -467,7 +467,8 @@ export async function downloadAndExtract(
   url: string,
   expectedChecksum: string,
   fullName: string,
-  version: string
+  version: string,
+  pluginType: string
 ): Promise<string> {
   const parts = fullName.split('/');
   const targetDir = path.join(config.cacheDir, ...parts, version);
@@ -550,7 +551,7 @@ export async function downloadAndExtract(
     await fs.unlink(tempFile).catch(() => {});
 
     // 返回最终路径（如果只有一个子目录则进入）
-    return resolveFinalPath(targetDir);
+    return resolveFinalPath(targetDir, pluginType);
   } catch (error) {
     await fs.rm(targetDir, { recursive: true, force: true }).catch(() => {});
     throw error;
@@ -559,8 +560,9 @@ export async function downloadAndExtract(
 
 /**
  * 修正旧缓存路径（如果是目录但应该是文件）
+ * @param pluginType 插件类型：skill 需要目录，agent/command 需要文件
  */
-async function correctCachePath(cachePath: string): Promise<string> {
+async function correctCachePath(cachePath: string, pluginType: string): Promise<string> {
   try {
     const stat = await fs.stat(cachePath);
     if (!stat.isDirectory()) {
@@ -577,11 +579,16 @@ async function correctCachePath(cachePath: string): Promise<string> {
     // 如果只有一个子目录（且没有其他文件），递归进入
     if (dirs.length === 1 && nonMetadataFiles.length === 0) {
       const subDir = path.join(cachePath, dirs[0].name);
-      return correctCachePath(subDir);
+      return correctCachePath(subDir, pluginType);
     }
 
-    // 如果只有一个主文件（排除 metadata.json），返回该文件路径
+    // Skill 类型：保持目录结构（包含 SKILL.md）
+    // Agent/Command 类型：返回 .md 文件路径
     if (nonMetadataFiles.length === 1 && dirs.length === 0) {
+      if (pluginType === 'skill') {
+        // Skill 需要目录，不返回文件
+        return cachePath;
+      }
       return path.join(cachePath, nonMetadataFiles[0].name);
     }
 
@@ -591,7 +598,11 @@ async function correctCachePath(cachePath: string): Promise<string> {
   }
 }
 
-async function resolveFinalPath(dir: string): Promise<string> {
+/**
+ * 解析最终路径
+ * @param pluginType 插件类型：skill 需要目录，agent/command 需要文件
+ */
+async function resolveFinalPath(dir: string, pluginType: string): Promise<string> {
   const entries = await fs.readdir(dir, { withFileTypes: true });
   const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith('.'));
   const files = entries.filter((e) => e.isFile() && !e.name.startsWith('.'));
@@ -603,13 +614,17 @@ async function resolveFinalPath(dir: string): Promise<string> {
     const subEntries = await fs.readdir(subDir);
     if (subEntries.length > 0) {
       // 递归查找，处理 agent/command 类型的 name/name.md 结构
-      return resolveFinalPath(subDir);
+      return resolveFinalPath(subDir, pluginType);
     }
   }
 
-  // 如果只有一个主文件（排除 metadata.json），返回该文件路径
-  // 这是单文件插件（如 agent/command）的情况
+  // Skill 类型：保持目录结构（包含 SKILL.md）
+  // Agent/Command 类型：返回 .md 文件路径
   if (nonMetadataFiles.length === 1 && dirs.length === 0) {
+    if (pluginType === 'skill') {
+      // Skill 需要目录，不返回文件
+      return dir;
+    }
     return path.join(dir, nonMetadataFiles[0].name);
   }
 
@@ -670,12 +685,14 @@ export async function createLink(
 }
 
 export async function removeLink(linkPath: string): Promise<void> {
+  // 去掉结尾斜杠，否则 lstat 会跟踪符号链接返回目标状态
+  const normalizedPath = linkPath.replace(/\/+$/, '');
   try {
-    const stat = await fs.lstat(linkPath);
+    const stat = await fs.lstat(normalizedPath);
     if (stat.isSymbolicLink()) {
-      await fs.unlink(linkPath);
+      await fs.unlink(normalizedPath);
     } else if (stat.isDirectory()) {
-      await fs.rm(linkPath, { recursive: true, force: true });
+      await fs.rm(normalizedPath, { recursive: true, force: true });
     }
   } catch {
     // 不存在，忽略
@@ -701,8 +718,8 @@ export async function resolveCachePath(
       // 验证缓存文件是否仍然存在
       try {
         await fs.access(cached.cachePath);
-        // 修正旧缓存的路径（可能是目录而应该是文件）
-        const correctedPath = await correctCachePath(cached.cachePath);
+        // 修正旧缓存的路径（根据类型：skill 需要目录，agent/command 需要文件）
+        const correctedPath = await correctCachePath(cached.cachePath, downloadInfo.type);
         // 如果路径被修正，更新缓存记录
         if (correctedPath !== cached.cachePath) {
           await setCache({
@@ -726,7 +743,8 @@ export async function resolveCachePath(
     downloadInfo.downloadUrl,
     downloadInfo.checksum,
     downloadInfo.fullName,
-    downloadInfo.version
+    downloadInfo.version,
+    downloadInfo.type
   );
 
   // 更新缓存记录

package/src/types.ts

@@ -95,11 +95,23 @@ export interface SearchResult {
   icon: string | null;
 }
 
+export interface KitSearchResult {
+  fullName: string;
+  name: string;
+  author: string;
+  pluginCount: number;
+  downloads: number;
+  description: string | null;
+}
+
 export interface SearchResponse {
-  data: SearchResult[];
+  plugins: SearchResult[];
+  kits: KitSearchResult[];
   pagination: {
     page: number;
     perPage: number;
+    totalPlugins: number;
+    totalKits: number;
     total: number;
     totalPages: number;
   };

package/src/commands/completion.ts

@@ -1,210 +0,0 @@
-/**
- * completion 命令 - 生成 shell 自动补全脚本
- */
-
-import { Command } from 'commander';
-import chalk from 'chalk';
-
-export const completionCommand = new Command('completion')
-  .description('生成 shell 自动补全脚本')
-  .argument('<shell>', 'shell 类型 (bash, zsh, fish)')
-  .action((shell: string) => {
-    switch (shell.toLowerCase()) {
-      case 'bash':
-        console.log(generateBashCompletion());
-        break;
-      case 'zsh':
-        console.log(generateZshCompletion());
-        break;
-      case 'fish':
-        console.log(generateFishCompletion());
-        break;
-      default:
-        console.error(chalk.red(`不支持的 shell: ${shell}`));
-        console.log(chalk.gray('支持的 shell: bash, zsh, fish'));
-        process.exit(1);
-    }
-  });
-
-function generateBashCompletion(): string {
-  return `# 42plugin bash completion
-# 添加到 ~/.bashrc:
-#   eval "$(42plugin completion bash)"
-# 或:
-#   42plugin completion bash >> ~/.bashrc
-#
-# 注意: 动态补全插件名需要安装 jq (可选)
-# 未安装 jq 时仍可使用命令和选项补全
-
-_42plugin_completions() {
-  local cur="\${COMP_WORDS[COMP_CWORD]}"
-  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
-
-  case "\${prev}" in
-    42plugin)
-      COMPREPLY=( $(compgen -W "auth search install list uninstall version completion" -- "\${cur}") )
-      return 0
-      ;;
-    install|uninstall)
-      # 动态补全插件名 (需要 jq)
-      if command -v jq &>/dev/null; then
-        if [[ "\${cur}" == */* ]]; then
-          local plugins=$(42plugin list --json 2>/dev/null | jq -r '.[].fullName' 2>/dev/null)
-          COMPREPLY=( $(compgen -W "\${plugins}" -- "\${cur}") )
-        else
-          local authors=$(42plugin list --json 2>/dev/null | jq -r '.[].fullName' 2>/dev/null | cut -d'/' -f1 | sort -u)
-          COMPREPLY=( $(compgen -W "\${authors}" -- "\${cur}") )
-        fi
-      fi
-      return 0
-      ;;
-    search)
-      # 类型补全
-      if [[ "\${cur}" == -* ]]; then
-        COMPREPLY=( $(compgen -W "-t --type -l --limit --json -i --interactive" -- "\${cur}") )
-      fi
-      return 0
-      ;;
-    -t|--type)
-      COMPREPLY=( $(compgen -W "skill agent command hook mcp" -- "\${cur}") )
-      return 0
-      ;;
-    auth)
-      COMPREPLY=( $(compgen -W "--status --logout" -- "\${cur}") )
-      return 0
-      ;;
-    list|ls)
-      if [[ "\${cur}" == -* ]]; then
-        COMPREPLY=( $(compgen -W "-t --type --json" -- "\${cur}") )
-      fi
-      return 0
-      ;;
-    completion)
-      COMPREPLY=( $(compgen -W "bash zsh fish" -- "\${cur}") )
-      return 0
-      ;;
-  esac
-}
-
-complete -F _42plugin_completions 42plugin
-`;
-}
-
-function generateZshCompletion(): string {
-  return `#compdef 42plugin
-# 42plugin zsh completion
-# 添加到 ~/.zshrc:
-#   eval "$(42plugin completion zsh)"
-# 或:
-#   42plugin completion zsh >> ~/.zshrc
-#
-# 注意: 动态补全插件名需要安装 jq (可选)
-
-_42plugin() {
-  local -a commands
-  commands=(
-    'auth:登录/登出/查看状态'
-    'search:搜索插件'
-    'install:安装插件或套包'
-    'list:查看已安装插件'
-    'uninstall:卸载插件'
-    'version:显示版本'
-    'completion:生成补全脚本'
-  )
-
-  _arguments -C \\
-    '1: :->command' \\
-    '*: :->args'
-
-  case $state in
-    command)
-      _describe 'command' commands
-      ;;
-    args)
-      case $words[2] in
-        install|uninstall)
-          # 插件名补全 (需要 jq)
-          if (( $+commands[jq] )); then
-            local plugins
-            plugins=(\${(f)"$(42plugin list --json 2>/dev/null | jq -r '.[].fullName' 2>/dev/null)"})
-            _describe 'plugin' plugins
-          fi
-          ;;
-        search)
-          _arguments \\
-            '-t[筛选类型]:type:(skill agent command hook mcp)' \\
-            '--type[筛选类型]:type:(skill agent command hook mcp)' \\
-            '-l[结果数量]:limit:' \\
-            '--limit[结果数量]:limit:' \\
-            '--json[JSON 输出]' \\
-            '-i[交互式安装]' \\
-            '--interactive[交互式安装]'
-          ;;
-        auth)
-          _arguments \\
-            '--status[查看登录状态]' \\
-            '--logout[登出]'
-          ;;
-        list)
-          _arguments \\
-            '-t[筛选类型]:type:(skill agent command hook mcp)' \\
-            '--type[筛选类型]:type:(skill agent command hook mcp)' \\
-            '--json[JSON 输出]'
-          ;;
-        completion)
-          _describe 'shell' '(bash zsh fish)'
-          ;;
-      esac
-      ;;
-  esac
-}
-
-_42plugin
-`;
-}
-
-function generateFishCompletion(): string {
-  return `# 42plugin fish completion
-# 添加到 ~/.config/fish/config.fish:
-#   42plugin completion fish | source
-# 或:
-#   42plugin completion fish > ~/.config/fish/completions/42plugin.fish
-
-complete -c 42plugin -f
-
-# Commands
-complete -c 42plugin -n '__fish_use_subcommand' -a auth -d '登录/登出/查看状态'
-complete -c 42plugin -n '__fish_use_subcommand' -a search -d '搜索插件'
-complete -c 42plugin -n '__fish_use_subcommand' -a install -d '安装插件或套包'
-complete -c 42plugin -n '__fish_use_subcommand' -a list -d '查看已安装插件'
-complete -c 42plugin -n '__fish_use_subcommand' -a uninstall -d '卸载插件'
-complete -c 42plugin -n '__fish_use_subcommand' -a version -d '显示版本'
-complete -c 42plugin -n '__fish_use_subcommand' -a completion -d '生成补全脚本'
-
-# auth options
-complete -c 42plugin -n '__fish_seen_subcommand_from auth' -l status -d '查看登录状态'
-complete -c 42plugin -n '__fish_seen_subcommand_from auth' -l logout -d '登出'
-
-# search options
-complete -c 42plugin -n '__fish_seen_subcommand_from search' -s t -l type -d '筛选类型' -a 'skill agent command hook mcp'
-complete -c 42plugin -n '__fish_seen_subcommand_from search' -s l -l limit -d '结果数量'
-complete -c 42plugin -n '__fish_seen_subcommand_from search' -l json -d 'JSON 输出'
-complete -c 42plugin -n '__fish_seen_subcommand_from search' -s i -l interactive -d '交互式安装'
-
-# list options
-complete -c 42plugin -n '__fish_seen_subcommand_from list' -s t -l type -d '筛选类型' -a 'skill agent command hook mcp'
-complete -c 42plugin -n '__fish_seen_subcommand_from list' -l json -d 'JSON 输出'
-
-# install options
-complete -c 42plugin -n '__fish_seen_subcommand_from install' -s g -l global -d '安装到全局目录'
-complete -c 42plugin -n '__fish_seen_subcommand_from install' -s f -l force -d '强制重新下载'
-complete -c 42plugin -n '__fish_seen_subcommand_from install' -l no-cache -d '跳过缓存检查'
-complete -c 42plugin -n '__fish_seen_subcommand_from install' -l optional -d '安装套包时包含可选插件'
-
-# uninstall options
-complete -c 42plugin -n '__fish_seen_subcommand_from uninstall' -l purge -d '同时清除缓存'
-
-# completion argument
-complete -c 42plugin -n '__fish_seen_subcommand_from completion' -a 'bash zsh fish' -d 'Shell 类型'
-`;
-}