@42ailab/42plugin 0.1.21 → 0.1.23

package/README.md

@@ -109,7 +109,7 @@ bun run build
 ```
 
 选项：
-- `-g, --global`：仅下载到缓存，不链接到当前项目
+- `-g, --global`：安装到全局目录 (~/.42plugin/global/)
 - `-k, --kit`：安装该插件所属的整个套包
 - `--optional`：安装套包时包含可选项
 - `--force`：强制重新下载
@@ -119,11 +119,19 @@ bun run build
 ### 管理
 
 ```bash
-42plugin list                        # 查看已安装
-42plugin list --type skill --json
-42plugin uninstall <full_name>       # 卸载
-42plugin uninstall <full_name> --purge
-42plugin version                     # 版本
+# 查看插件
+42plugin list                        # 当前项目已安装的插件
+42plugin list --global               # 全局安装的插件 (~/.claude/)
+42plugin list --all                  # 所有项目 + 全局的插件
+42plugin list --type skill --json    # 筛选类型，输出 JSON
+
+# 卸载插件
+42plugin uninstall <full_name>            # 从当前项目卸载
+42plugin uninstall <full_name> --global   # 从全局目录卸载
+42plugin uninstall <full_name> --purge    # 卸载并清除下载缓存
+
+# 版本
+42plugin version
 ```
 
 ### 发布（开发中）
@@ -140,12 +148,30 @@ bun run build
 
 ## 数据存储
 
-| 类型 | 路径 |
-|------|------|
-| 数据库 | `~/.42plugin/local.db`（Windows: `%APPDATA%/42plugin/local.db`） |
-| 缓存 | `~/.42plugin/cache` |
-| 登录凭证 | `~/.42plugin/secrets.json`（权限 600） |
-| 项目链接 | `.claude/`（项目目录下） |
+| 类型 | 路径 | 说明 |
+|------|------|------|
+| 数据库 | `~/.42plugin/local.db` | 本地 SQLite（Windows: `%APPDATA%/42plugin/`） |
+| 下载缓存 | `~/.42plugin/cache/` | 插件原始文件缓存 |
+| 登录凭证 | `~/.42plugin/secrets.json` | 权限 600 |
+| 全局安装 | `~/.claude/` | 对所有项目生效，Claude Code 可识别 |
+| 项目安装 | `./.claude/` | 仅对当前项目生效 |
+
+### 全局 vs 项目安装
+
+```
+~/.claude/                    # 全局目录，对所有项目生效
+├── skills/
+├── agents/
+└── ...
+
+/path/to/project/.claude/     # 项目目录，仅对该项目生效
+├── skills/
+├── agents/
+└── ...
+```
+
+- **全局安装** (`--global`)：插件安装到 `~/.claude/`，所有项目都能使用
+- **项目安装**（默认）：插件安装到当前项目的 `.claude/`，仅当前项目可用
 
 ## 本地数据库表（SQLite）
 

package/package.json

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

package/src/api.ts

@@ -601,6 +601,7 @@ class ApiClient {
         description: params.description,
         tags: params.tags,
         visibility: params.visibility,
+        doc_content: params.docContent,
       },
     });
 

package/src/cli.ts

@@ -14,6 +14,7 @@ import {
   checkCommand,
 } from './commands';
 import { setupAuthHook } from './auth-middleware';
+import { checkForUpdates, checkForUpdatesSync } from './update-checker';
 
 // 版本号处理：
 // - Homebrew（编译后）：构建时通过 --define __VERSION__ 注入
@@ -58,11 +59,22 @@ program.addCommand(setupCommand);
 program
   .command('version')
   .description('显示版本信息')
-  .action(() => {
+  .option('--check', '检查是否有新版本')
+  .action(async (options: { check?: boolean }) => {
     console.log(`42plugin v${VERSION}`);
+    if (options.check) {
+      console.log();
+      await checkForUpdatesSync(VERSION);
+    }
   });
 
 // 注册全局认证 Hook
 setupAuthHook(program);
 
+// 注册版本更新检查 Hook（命令执行后触发）
+program.hook('postAction', () => {
+  // 非阻塞检查，不影响命令执行
+  checkForUpdates(VERSION);
+});
+
 export { program };

package/src/commands/install.ts

@@ -8,7 +8,7 @@ import ora from 'ora';
 import path from 'path';
 import os from 'os';
 import { confirm } from '@inquirer/prompts';
-import { api, QuotaExceededError } from '../api';
+import { api, ApiError, QuotaExceededError } from '../api';
 import fs from 'fs/promises';
 import {
   getOrCreateProject,
@@ -17,19 +17,63 @@ import {
   resolveCachePath,
   checkInstallConflict,
   removeInstallation,
+  getSessionToken,
 } from '../db';
 import { config } from '../config';
 import { parseTarget, getInstallPath, formatBytes, getTypeIcon } from '../utils';
 import { TargetType, type PluginDownloadInfo } from '../types';
 
 export const installCommand = new Command('install')
-  .description('安装插件或套包')
-  .argument('<target>', '安装目标 (author/name 或 author/kit/slug)')
-  .option('-g, --global', '仅下载到缓存，不链接到项目')
+  .description('安装插件或套包\n\n示例:\n  42plugin install alice/smart-reviewer     安装插件\n  42plugin install alice/kit/dev-tools      安装套包\n  42plugin install like                     安装您的收藏')
+  .argument('<target>', '安装目标 (author/name, author/kit/slug, 或 like)')
+  .option('-g, --global', `安装到全局目录，对所有项目生效 (~/.claude/)`)
   .option('-f, --force', '强制重新下载')
   .option('--no-cache', '跳过缓存检查')
   .option('--optional', '安装套包时包含可选插件')
   .action(async (target, options) => {
+    // 保留名称检测和扩展（虚拟收藏 Kit）
+    const RESERVED_KIT_NAMES = ['like', 'liked', 'starred', 'favorites', 'favourite', 'favourites'];
+    const normalizedTarget = target.trim().toLowerCase();
+
+    // 检测是否为单段保留名称（简化格式）
+    if (!normalizedTarget.includes('/') && RESERVED_KIT_NAMES.includes(normalizedTarget)) {
+      // 需要登录才能使用收藏功能
+      const sessionToken = await getSessionToken();
+      if (!sessionToken) {
+        console.error(chalk.red('\n使用收藏功能需要先登录'));
+        console.log(chalk.gray('执行 42plugin auth 登录'));
+        process.exit(1);
+      }
+
+      // 验证登录状态并获取 username（token 已在全局 hook 中注入）
+      let username: string | null = null;
+      try {
+        const session = await api.getSession();
+        const emailPrefix = session.user.email?.split('@')[0]?.trim();
+        username = session.user.username || session.user.name || (emailPrefix || null);
+
+        if (!username || username.trim() === '') {
+          console.error(chalk.red('\n无法获取用户名，请设置用户名后重试'));
+          console.log(chalk.gray('访问 42plugin.com 设置用户名'));
+          process.exit(1);
+        }
+      } catch (error) {
+        if (error instanceof ApiError && error.statusCode === 401) {
+          console.error(chalk.red('\n登录已过期，请重新登录'));
+          console.log(chalk.gray('执行 42plugin auth 登录'));
+        } else {
+          console.error(chalk.red('\n验证登录状态失败'));
+          console.log(chalk.gray(`错误: ${(error as Error).message}`));
+          console.log(chalk.gray('请检查网络连接或稍后重试'));
+        }
+        process.exit(1);
+      }
+
+      // 扩展为完整格式
+      target = `${username}/kit/${normalizedTarget}`;
+      console.log(chalk.gray(`\n安装您的收藏: ${username}/${normalizedTarget}\n`));
+    }
+
     // token 已在全局 hook 中注入
     try {
       // 检测是否在 home 目录
@@ -38,18 +82,19 @@ export const installCommand = new Command('install')
       const isHomeDir = currentPath === homePath;
 
       if (isHomeDir && !options.global) {
+        console.log(chalk.yellow('\n⚠ 您当前在用户根目录'));
+        console.log(chalk.gray('  • 全局安装：插件对所有项目生效，存放在 ~/.claude/'));
+        console.log(chalk.gray('  • 项目安装：插件仅对当前项目生效，存放在 ./.claude/\n'));
+
         const answer = await confirm({
-          message: '您当前在根目录，是否将插件安装到全局用户目录？',
+          message: '是否安装到全局目录？',
           default: true,
         });
 
         if (answer) {
           options.global = true;
-          // 确保全局目录存在
-          await fs.mkdir(config.globalDir, { recursive: true });
-          console.log(chalk.gray('将安装到全局目录: ~/.42plugin/global/'));
         } else {
-          console.log(chalk.yellow('提示: 建议在具体项目目录下执行安装命令'));
+          console.log(chalk.yellow('提示: 请进入具体项目目录后再执行安装命令'));
           return;
         }
       }
@@ -163,8 +208,9 @@ async function installPlugin(
     );
 
     if (options.global) {
-      console.log(chalk.green('✓ 已安装到全局用户目录'));
-      console.log(chalk.gray(`  → ~/.42plugin/global/${downloadInfo.installPath}`));
+      console.log(chalk.green('✓ 已全局安装，对所有项目生效'));
+      console.log(chalk.gray(`  → ~/.claude/${downloadInfo.installPath}`));
+      console.log(chalk.gray('  提示: 使用 42plugin list --global 查看全局插件'));
     } else {
       console.log(chalk.green(`✓ 已安装到当前项目: ${path.basename(projectPath)}`));
       console.log(chalk.gray(`  → ${downloadInfo.installPath}`));
@@ -316,7 +362,8 @@ async function installKit(
     console.log();
     if (failed === 0) {
       if (options.global) {
-        console.log(chalk.green(`✓ 已安装 ${installed} 个插件到全局用户目录`));
+        console.log(chalk.green(`✓ 已全局安装 ${installed} 个插件，对所有项目生效`));
+        console.log(chalk.gray('  提示: 使用 42plugin list --global 查看全局插件'));
       } else {
         console.log(chalk.green(`✓ 已安装 ${installed} 个插件到当前项目`));
       }

package/src/commands/list.ts

@@ -4,56 +4,173 @@
 
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { getInstallations } from '../db';
+import { getInstallations, getAllInstallations } from '../db';
+import { config, isGlobalDir } from '../config';
 import { getTypeIcon, formatRelativeTime } from '../utils';
 import type { PluginType } from '../types';
 
 export const listCommand = new Command('list')
   .alias('ls')
-  .description('查看当前项目已安装的插件')
+  .description('查看已安装的插件')
+  .option('-g, --global', '显示全局安装的插件 (~/.claude/)')
+  .option('-a, --all', '显示所有项目的插件（包括全局）')
   .option('-t, --type <type>', '筛选类型 (skill, agent, command, hook, mcp)')
   .option('--json', '输出 JSON 格式')
   .action(async (options) => {
     try {
-      let installations = await getInstallations(process.cwd());
-
-      // 类型筛选
-      if (options.type) {
-        installations = installations.filter((i) => i.type === options.type);
+      if (options.all) {
+        await listAllProjects(options);
+      } else if (options.global) {
+        await listGlobalPlugins(options);
+      } else {
+        await listCurrentProject(options);
       }
+    } catch (error) {
+      console.error(chalk.red((error as Error).message));
+      process.exit(1);
+    }
+  });
 
-      if (options.json) {
-        console.log(JSON.stringify(installations, null, 2));
-        return;
-      }
+async function listCurrentProject(options: { type?: string; json?: boolean }): Promise<void> {
+  const projectPath = process.cwd();
+  let installations = await getInstallations(projectPath);
 
-      if (installations.length === 0) {
-        console.log(chalk.yellow('当前项目未安装任何插件'));
-        console.log(chalk.gray('执行 42plugin install <name> 安装插件'));
-        return;
-      }
+  // 类型筛选
+  if (options.type) {
+    installations = installations.filter((i) => i.type === options.type);
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(installations, null, 2));
+    return;
+  }
+
+  if (installations.length === 0) {
+    console.log(chalk.yellow('当前项目未安装任何插件'));
+    console.log(chalk.gray('执行 42plugin install <name> 安装插件'));
+    console.log(chalk.gray('执行 42plugin list --global 查看全局插件'));
+    return;
+  }
+
+  console.log(chalk.gray(`当前项目已安装 ${installations.length} 个插件:\n`));
+
+  for (const item of installations) {
+    const icon = getTypeIcon(item.type);
+    const time = formatRelativeTime(item.installedAt);
+
+    console.log(`${icon} ${chalk.cyan.bold(item.fullName)} ${chalk.gray(`v${item.version}`)}`);
+    console.log(chalk.gray(`  → ${item.linkPath}`));
+
+    // 解析所属套包：fullName 格式为 author/kit/plugin
+    const parts = item.fullName.split('/');
+    if (parts.length >= 3) {
+      const kitName = `${parts[0]}/${parts[1]}`;
+      console.log(chalk.gray(`  所属套包: ${kitName}`));
+    }
+
+    console.log(chalk.gray(`  安装于 ${time}`));
+    console.log();
+  }
+}
+
+/**
+ * 列出全局安装的插件
+ */
+async function listGlobalPlugins(options: { type?: string; json?: boolean }): Promise<void> {
+  let installations = await getInstallations(config.globalDir);
+
+  // 类型筛选
+  if (options.type) {
+    installations = installations.filter((i) => i.type === options.type);
+  }
 
-      console.log(chalk.gray(`已安装 ${installations.length} 个插件:\n`));
+  if (options.json) {
+    console.log(JSON.stringify(installations, null, 2));
+    return;
+  }
 
-      for (const item of installations) {
-        const icon = getTypeIcon(item.type);
-        const time = formatRelativeTime(item.installedAt);
+  if (installations.length === 0) {
+    console.log(chalk.yellow('未安装任何全局插件'));
+    console.log(chalk.gray('执行 42plugin install <name> --global 安装全局插件'));
+    return;
+  }
 
-        console.log(`${icon} ${chalk.cyan.bold(item.fullName)} ${chalk.gray(`v${item.version}`)}`);
-        console.log(chalk.gray(`  → ${item.linkPath}`));
+  console.log(chalk.cyan('📍 全局插件') + chalk.gray(' (~/.claude/) - 对所有项目生效\n'));
+  console.log(chalk.gray(`共 ${installations.length} 个插件:\n`));
 
-        // 解析所属套包：fullName 格式为 author/kit/plugin
-        const parts = item.fullName.split('/');
-        if (parts.length >= 3) {
-          const kitName = `${parts[0]}/${parts[1]}`;
-          console.log(chalk.gray(`  所属套包: ${kitName}`));
-        }
+  for (const item of installations) {
+    const icon = getTypeIcon(item.type);
+    const time = formatRelativeTime(item.installedAt);
 
-        console.log(chalk.gray(`  安装于 ${time}`));
-        console.log();
+    console.log(`${icon} ${chalk.cyan.bold(item.fullName)} ${chalk.gray(`v${item.version}`)}`);
+
+    // 解析所属套包：fullName 格式为 author/kit/plugin
+    const parts = item.fullName.split('/');
+    if (parts.length >= 3) {
+      const kitName = `${parts[0]}/${parts[1]}`;
+      console.log(chalk.gray(`  所属套包: ${kitName}`));
+    }
+
+    console.log(chalk.gray(`  安装于 ${time}`));
+    console.log();
+  }
+}
+
+async function listAllProjects(options: { type?: string; json?: boolean }): Promise<void> {
+  let installations = await getAllInstallations();
+
+  // 类型筛选
+  if (options.type) {
+    installations = installations.filter((i) => i.type === options.type);
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(installations, null, 2));
+    return;
+  }
+
+  if (installations.length === 0) {
+    console.log(chalk.yellow('未安装任何插件'));
+    return;
+  }
+
+  // 按项目分组，区分全局和项目
+  const globalPlugins: typeof installations = [];
+  const byProject = new Map<string, typeof installations>();
+
+  for (const item of installations) {
+    if (isGlobalDir(item.projectPath)) {
+      globalPlugins.push(item);
+    } else {
+      const key = item.projectPath;
+      if (!byProject.has(key)) {
+        byProject.set(key, []);
       }
-    } catch (error) {
-      console.error(chalk.red((error as Error).message));
-      process.exit(1);
+      byProject.get(key)!.push(item);
     }
-  });
+  }
+
+  const projectCount = byProject.size + (globalPlugins.length > 0 ? 1 : 0);
+  console.log(chalk.gray(`共 ${installations.length} 个插件，分布在 ${projectCount} 个位置:\n`));
+
+  // 先显示全局插件
+  if (globalPlugins.length > 0) {
+    console.log(chalk.cyan.bold(`🌐 全局`) + chalk.gray(' (~/.claude/) - 对所有项目生效'));
+    for (const item of globalPlugins) {
+      const icon = getTypeIcon(item.type);
+      console.log(`   ${icon} ${chalk.cyan(item.fullName)} ${chalk.gray(`v${item.version}`)}`);
+    }
+    console.log();
+  }
+
+  // 再显示各项目
+  for (const [projectPath, items] of byProject) {
+    console.log(chalk.bold(`📁 ${projectPath}`));
+
+    for (const item of items) {
+      const icon = getTypeIcon(item.type);
+      console.log(`   ${icon} ${chalk.cyan(item.fullName)} ${chalk.gray(`v${item.version}`)}`);
+    }
+    console.log();
+  }
+}

package/src/commands/publish.ts

@@ -4,10 +4,73 @@
 
 import { Command } from 'commander';
 import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs/promises';
+import { select } from '@inquirer/prompts';
 import { api } from '../api';
 import { Publisher } from '../services/publisher';
 import { ValidationError, UploadError, AuthRequiredError } from '../errors';
 import { getTypeIcon } from '../utils';
+import type { PluginType } from '../types';
+
+const VALID_TYPES: PluginType[] = ['skill', 'agent', 'command', 'hook', 'mcp'];
+
+const TYPE_DESCRIPTIONS: Record<PluginType, string> = {
+  skill: 'skill(技能) - 包含 SKILL.md 的目录，为 Claude 提供特定能力',
+  agent: 'agent(代理) - 单个 .md 文件，定义 AI 角色和行为',
+  command: 'command(命令) - 单个 .md 文件，定义可执行的斜杠命令',
+  hook: 'hook(钩子) - 包含 hooks.json 的目录，响应事件触发',
+  mcp: 'mcp(MCP 服务) - 包含 mcp.json 的目录，Model Context Protocol 服务',
+};
+
+/**
+ * 从路径和文件特征推断建议类型（用于设置默认选项）
+ */
+async function suggestType(pluginPath: string): Promise<PluginType> {
+  const absPath = path.resolve(pluginPath);
+  const normalizedPath = absPath.replace(/\\/g, '/').toLowerCase();
+
+  // 1. 从路径推断（Claude Code 目录约定）
+  if (normalizedPath.includes('/.claude/agents/') || normalizedPath.includes('.claude/agents/')) {
+    return 'agent';
+  }
+  if (normalizedPath.includes('/.claude/commands/') || normalizedPath.includes('.claude/commands/')) {
+    return 'command';
+  }
+  if (normalizedPath.includes('/.claude/skills/') || normalizedPath.includes('.claude/skills/')) {
+    return 'skill';
+  }
+  if (normalizedPath.includes('/.claude/hooks/') || normalizedPath.includes('.claude/hooks/')) {
+    return 'hook';
+  }
+  if (normalizedPath.includes('/.claude/mcp/') || normalizedPath.includes('.claude/mcp/')) {
+    return 'mcp';
+  }
+
+  // 2. 检查是否是目录，如果是则检查特征文件
+  try {
+    const stat = await fs.stat(absPath);
+    if (stat.isDirectory()) {
+      const files = await fs.readdir(absPath);
+      const lowerFiles = files.map((f) => f.toLowerCase());
+
+      if (lowerFiles.includes('mcp.json') || lowerFiles.includes('.mcp.json')) {
+        return 'mcp';
+      }
+      if (lowerFiles.includes('hooks.json') || lowerFiles.includes('hook.json')) {
+        return 'hook';
+      }
+      if (lowerFiles.includes('skill.md')) {
+        return 'skill';
+      }
+    }
+  } catch {
+    // 路径不存在，忽略
+  }
+
+  // 3. 默认返回 skill
+  return 'skill';
+}
 
 export const publishCommand = new Command('publish')
   .alias('pub')
@@ -17,8 +80,31 @@ export const publishCommand = new Command('publish')
   .option('-f, --force', '强制发布（即使内容未变化）')
   .option('--public', '公开发布（默认仅自己可见）')
   .option('-n, --name <name>', '覆盖插件名称')
+  .option('-t, --type <type>', '指定插件类型 (skill|agent|command|hook|mcp)')
   .action(async (pluginPath, options) => {
     try {
+      // 验证 --type 参数
+      let selectedType: PluginType | undefined = options.type;
+      if (selectedType && !VALID_TYPES.includes(selectedType)) {
+        console.error(chalk.red(`无效的类型: ${selectedType}`));
+        console.log(chalk.gray(`有效类型: ${VALID_TYPES.join(', ')}`));
+        process.exit(1);
+      }
+
+      // 如果没有指定类型，让用户交互式选择（智能默认）
+      if (!selectedType) {
+        const suggested = await suggestType(pluginPath);
+        selectedType = await select({
+          message: '请选择插件类型:',
+          choices: VALID_TYPES.map((t) => ({
+            name: TYPE_DESCRIPTIONS[t],
+            value: t,
+          })),
+          default: suggested,
+        });
+        console.log();
+      }
+
       // 认证检查已在全局 hook 中完成
       // 执行发布
       const publisher = new Publisher();
@@ -28,6 +114,7 @@ export const publishCommand = new Command('publish')
         force: options.force,
         visibility: options.public ? 'public' : 'self',
         name: options.name,
+        type: selectedType,
       });
 
       // 显示结果

package/src/commands/uninstall.ts

@@ -6,6 +6,7 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
 import { api } from '../api';
+import { config } from '../config';
 import { getInstallations, removeInstallation, removeLink, removeCache } from '../db';
 import { parseTarget } from '../utils';
 import { TargetType } from '../types';
@@ -14,18 +15,24 @@ export const uninstallCommand = new Command('uninstall')
   .alias('rm')
   .description('卸载插件或套包')
   .argument('<target>', '插件名 (author/name) 或套包名 (author/kit/slug)')
-  .option('--purge', '同时清除缓存')
+  .option('-g, --global', '从全局目录卸载 (~/.claude/)')
+  .option('--purge', '同时清除下载缓存')
   .action(async (target, options) => {
     try {
       const parsed = parseTarget(target);
-      const projectPath = process.cwd();
+      const projectPath = options.global ? config.globalDir : process.cwd();
+
+      // 显示操作范围提示
+      if (options.global) {
+        console.log(chalk.gray('从全局目录卸载 (~/.claude/)\n'));
+      }
 
       if (parsed.type === TargetType.Kit) {
         // 卸载套包：批量卸载所有来自该套包的插件
-        await uninstallKit(projectPath, parsed.fullName, options.purge);
+        await uninstallKit(projectPath, parsed.fullName, options.purge, options.global);
       } else {
         // 卸载单个插件
-        await uninstallPlugin(projectPath, parsed.fullName, options.purge);
+        await uninstallPlugin(projectPath, parsed.fullName, options.purge, options.global);
       }
     } catch (error) {
       console.error(chalk.red((error as Error).message));
@@ -39,7 +46,8 @@ export const uninstallCommand = new Command('uninstall')
 async function uninstallPlugin(
   projectPath: string,
   fullName: string,
-  purge: boolean
+  purge: boolean,
+  isGlobal: boolean
 ): Promise<void> {
   const spinner = ora(`卸载 ${fullName}...`).start();
 
@@ -49,6 +57,11 @@ async function uninstallPlugin(
 
   if (!installation) {
     spinner.fail(`未找到已安装的插件: ${fullName}`);
+    if (isGlobal) {
+      console.log(chalk.gray('提示: 该插件可能安装在某个项目目录下，请进入项目目录后重试'));
+    } else {
+      console.log(chalk.gray('提示: 使用 42plugin uninstall --global 从全局目录卸载'));
+    }
     process.exit(1);
   }
 
@@ -78,6 +91,11 @@ async function uninstallPlugin(
   } else {
     spinner.succeed(`已卸载 ${fullName}`);
   }
+
+  // 显示位置提示
+  if (isGlobal) {
+    console.log(chalk.gray('  已从全局目录移除'));
+  }
 }
 
 /**
@@ -86,7 +104,8 @@ async function uninstallPlugin(
 async function uninstallKit(
   projectPath: string,
   kitFullName: string,
-  purge: boolean
+  purge: boolean,
+  isGlobal: boolean
 ): Promise<void> {
   const spinner = ora(`查找套包 ${kitFullName} 的插件...`).start();
 
@@ -96,6 +115,11 @@ async function uninstallKit(
 
   if (kitInstallations.length === 0) {
     spinner.fail(`未找到来自套包 ${kitFullName} 的已安装插件`);
+    if (isGlobal) {
+      console.log(chalk.gray('提示: 该套包可能安装在某个项目目录下，请进入项目目录后重试'));
+    } else {
+      console.log(chalk.gray('提示: 使用 42plugin uninstall --global 从全局目录卸载'));
+    }
     process.exit(1);
   }
 
@@ -140,6 +164,9 @@ async function uninstallKit(
     if (purge) {
       console.log(chalk.gray('  缓存已清除'));
     }
+    if (isGlobal) {
+      console.log(chalk.gray('  已从全局目录移除'));
+    }
   } else {
     console.log(chalk.yellow(`⚠ 部分卸载完成`));
     console.log(chalk.gray(`  成功: ${successCount}, 失败: ${failCount}`));