@42ailab/42plugin 0.1.20 → 0.1.22

package/package.json

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

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/db.ts

@@ -8,13 +8,18 @@
 import { Database } from 'bun:sqlite';
 import fs from 'fs/promises';
 import path from 'path';
+import os from 'os';
 import crypto from 'crypto';
 import * as tar from 'tar';
 import cliProgress from 'cli-progress';
+import { spawn } from 'child_process';
 import { config } from './config';
 import { formatBytes } from './utils';
 import type { LocalProject, LocalCache, LocalInstallation, PluginType, PluginDownloadInfo } from './types';
 
+// Windows 平台检测
+const isWindows = process.platform === 'win32';
+
 // 文件大小超过 1MB 时显示下载进度条
 const PROGRESS_THRESHOLD = 1024 * 1024; // 1MB
 
@@ -386,8 +391,8 @@ export async function checkInstallConflict(
 ): Promise<string | null> {
   const client = await getDb();
   const absPath = path.resolve(projectPath);
-  // 规范化路径：去掉尾部斜杠以便比较
-  const normalizedLinkPath = path.resolve(linkPath).replace(/\/+$/, '');
+  // 规范化路径：去掉尾部斜杠以便比较（兼容 Unix 和 Windows）
+  const normalizedLinkPath = path.resolve(linkPath).replace(/[\/\\]+$/, '');
 
   // 查询该项目下所有安装记录，在应用层比较路径
   const rows = client.prepare(`
@@ -397,7 +402,7 @@ export async function checkInstallConflict(
   `).all(absPath, newFullName) as { full_name: string; link_path: string }[];
 
   for (const row of rows) {
-    const existingPath = row.link_path.replace(/\/+$/, '');
+    const existingPath = row.link_path.replace(/[\/\\]+$/, '');
     if (existingPath === normalizedLinkPath) {
       return row.full_name;
     }
@@ -659,12 +664,62 @@ export async function getDirectorySize(pathOrDir: string): Promise<number> {
   return totalSize;
 }
 
+/**
+ * 递归复制目录或文件
+ */
+async function copyRecursive(src: string, dest: string): Promise<void> {
+  const stat = await fs.stat(src);
+  if (stat.isDirectory()) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        await copyRecursive(srcPath, destPath);
+      } else {
+        await fs.copyFile(srcPath, destPath);
+      }
+    }
+  } else {
+    await fs.copyFile(src, dest);
+  }
+}
+
+/**
+ * Windows 上使用 mklink /J 创建 Junction（目录链接）
+ * Junction 不需要管理员权限
+ */
+async function createJunction(sourcePath: string, targetPath: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    // mklink /J 创建目录 junction
+    const cmd = spawn('cmd', ['/c', 'mklink', '/J', targetPath, sourcePath], {
+      windowsHide: true,
+    });
+
+    let stderr = '';
+    cmd.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    cmd.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`创建 Junction 失败: ${stderr}`));
+      }
+    });
+
+    cmd.on('error', reject);
+  });
+}
+
 export async function createLink(
   sourcePath: string,
   targetPath: string
 ): Promise<void> {
-  // 移除目标路径末尾的斜杠
-  const normalizedTarget = targetPath.replace(/\/+$/, '');
+  // 移除目标路径末尾的斜杠（兼容 Unix 和 Windows）
+  const normalizedTarget = targetPath.replace(/[\/\\]+$/, '');
   const targetDir = path.dirname(normalizedTarget);
   await fs.mkdir(targetDir, { recursive: true });
 
@@ -678,15 +733,50 @@ export async function createLink(
     // 不存在，继续
   }
 
-  // 检测源是文件还是目录，创建对应类型的符号链接
+  // 检测源是文件还是目录
   const sourceStat = await fs.stat(sourcePath);
-  const linkType = sourceStat.isDirectory() ? 'dir' : 'file';
-  await fs.symlink(sourcePath, normalizedTarget, linkType);
+  const isDirectory = sourceStat.isDirectory();
+
+  // 尝试创建符号链接
+  try {
+    const linkType = isDirectory ? 'dir' : 'file';
+    await fs.symlink(sourcePath, normalizedTarget, linkType);
+    return;
+  } catch (error) {
+    // 如果不是 Windows，直接抛出错误
+    if (!isWindows) {
+      throw error;
+    }
+
+    // Windows 上符号链接失败（EPERM），尝试回退方案
+    const isEperm = (error as NodeJS.ErrnoException).code === 'EPERM';
+    if (!isEperm) {
+      throw error;
+    }
+
+    // 回退方案 1: 对于目录，尝试使用 Junction
+    if (isDirectory) {
+      try {
+        await createJunction(sourcePath, normalizedTarget);
+        return;
+      } catch {
+        // Junction 也失败，继续尝试复制
+      }
+    }
+
+    // 回退方案 2: 直接复制文件/目录
+    // 这是最后的保底方案，虽然会占用更多磁盘空间
+    console.warn(
+      `[Windows] 符号链接创建失败，回退到文件复制模式\n` +
+      `  提示: 启用 Windows 开发者模式可使用符号链接，节省磁盘空间`
+    );
+    await copyRecursive(sourcePath, normalizedTarget);
+  }
 }
 
 export async function removeLink(linkPath: string): Promise<void> {
-  // 去掉结尾斜杠，否则 lstat 会跟踪符号链接返回目标状态
-  const normalizedPath = linkPath.replace(/\/+$/, '');
+  // 去掉结尾斜杠，否则 lstat 会跟踪符号链接返回目标状态（兼容 Unix 和 Windows）
+  const normalizedPath = linkPath.replace(/[\/\\]+$/, '');
   try {
     const stat = await fs.lstat(normalizedPath);
     if (stat.isSymbolicLink()) {

package/src/services/publisher.ts

@@ -49,7 +49,7 @@ export class Publisher {
     try {
       // Phase 1: 完整验证
       spinner.text = '验证插件...';
-      const validation = await this.validator.validateFull(options.path, options.name);
+      const validation = await this.validator.validateFull(options.path, options.name, options.type);
 
       // 显示验证结果
       spinner.stop();

package/src/types.ts

@@ -289,6 +289,7 @@ export interface PublishOptions {
   force?: boolean;
   visibility?: 'self' | 'public';
   name?: string;
+  type?: PluginType;  // 用户指定的类型，覆盖自动推断
 }
 
 export interface PluginMetadata {

package/src/validators/plugin-validator.ts

@@ -42,8 +42,15 @@ const VALID_TYPES: PluginType[] = ['skill', 'agent', 'command', 'hook', 'mcp'];
 export class PluginValidator {
   /**
    * 完整验证（返回详细结果）
+   * @param pluginPath 插件路径
+   * @param overrideName 覆盖名称
+   * @param overrideType 覆盖类型（用户通过 -t 参数指定）
    */
-  async validateFull(pluginPath: string, overrideName?: string): Promise<ValidationResult> {
+  async validateFull(
+    pluginPath: string,
+    overrideName?: string,
+    overrideType?: PluginType
+  ): Promise<ValidationResult> {
     const result: ValidationResult = {
       valid: true,
       metadata: {
@@ -72,9 +79,9 @@ export class PluginValidator {
     // Phase 2: 提取元信息并进行类型检测
     try {
       if (stat.isFile()) {
-        result.metadata = await this.extractFileMetadata(absPath, overrideName);
+        result.metadata = await this.extractFileMetadata(absPath, overrideName, overrideType);
       } else if (stat.isDirectory()) {
-        result.metadata = await this.extractDirectoryMetadata(absPath, overrideName);
+        result.metadata = await this.extractDirectoryMetadata(absPath, overrideName, overrideType);
       } else {
         result.errors.push({
           code: 'E000',
@@ -130,7 +137,8 @@ export class PluginValidator {
    */
   private async extractFileMetadata(
     filePath: string,
-    overrideName?: string
+    overrideName?: string,
+    overrideType?: PluginType
   ): Promise<PluginMetadata> {
     const ext = path.extname(filePath).toLowerCase();
     const basename = path.basename(filePath, ext);
@@ -146,8 +154,9 @@ export class PluginValidator {
     const parsed = matter(content);
     const data = parsed.data as Record<string, unknown>;
 
-    // 推断类型
-    const type = this.inferTypeFromContent(content, data);
+    // 类型由用户通过 -t 参数或交互选择指定，必须提供
+    // 仅在未指定时使用 frontmatter 作为后备（向后兼容 validate 方法）
+    let type: PluginType = overrideType || (data.type as PluginType) || 'skill';
 
     return {
       name: overrideName || (data.name as string) || basename,
@@ -164,35 +173,23 @@ export class PluginValidator {
    */
   private async extractDirectoryMetadata(
     dirPath: string,
-    overrideName?: string
+    overrideName?: string,
+    overrideType?: PluginType
   ): Promise<PluginMetadata> {
     const entries = await fs.readdir(dirPath, { withFileTypes: true });
     const files = entries.filter((e) => e.isFile()).map((e) => e.name);
-    const lowerFiles = files.map((f) => f.toLowerCase());
     const basename = path.basename(dirPath);
 
-    // 检测插件类型（基于特征文件）
-    let type: PluginType = 'skill';
-    let frontmatterData: Record<string, unknown> = {};
-
-    // MCP: 有 mcp.json 或 .mcp.json
-    if (lowerFiles.some((f) => f === 'mcp.json' || f === '.mcp.json')) {
-      type = 'mcp';
-    }
-    // Hook: 有 hooks.json 或 hook.json
-    else if (lowerFiles.some((f) => f === 'hooks.json' || f === 'hook.json')) {
-      type = 'hook';
-    }
-    // Skill: 有 SKILL.md 或 skill.md
-    else if (lowerFiles.some((f) => f === 'skill.md')) {
-      type = 'skill';
-    }
+    // 类型由用户通过 -t 参数或交互选择指定，必须提供
+    // 仅在未指定时使用 'skill' 作为后备（向后兼容 validate 方法）
+    const type: PluginType = overrideType || 'skill';
 
     // 尝试读取主文件获取元信息
     const mainFiles = ['SKILL.md', 'skill.md', 'README.md', 'readme.md'];
     let description: string | undefined;
     let title: string | undefined;
     let tags: string[] | undefined;
+    let frontmatterData: Record<string, unknown> = {};
 
     for (const file of mainFiles) {
       if (files.includes(file)) {
@@ -204,9 +201,6 @@ export class PluginValidator {
           if (frontmatterData.title) title = frontmatterData.title as string;
           if (frontmatterData.description) description = frontmatterData.description as string;
           if (frontmatterData.tags) tags = frontmatterData.tags as string[];
-          if (frontmatterData.type && VALID_TYPES.includes(frontmatterData.type as PluginType)) {
-            type = frontmatterData.type as PluginType;
-          }
 
           // 如果没有 frontmatter 描述，取第一段文字
           if (!description && parsed.content) {
@@ -233,30 +227,6 @@ export class PluginValidator {
     };
   }
 
-  /**
-   * 从内容推断插件类型
-   */
-  private inferTypeFromContent(content: string, data: Record<string, unknown>): PluginType {
-    // 优先使用 frontmatter 中的 type
-    if (data.type && VALID_TYPES.includes(data.type as PluginType)) {
-      return data.type as PluginType;
-    }
-
-    // 从内容推断
-    const lowerContent = content.toLowerCase();
-
-    if (lowerContent.includes('you are') || lowerContent.includes('你是')) {
-      return 'agent';
-    }
-
-    if (lowerContent.includes('mcp') || lowerContent.includes('model context protocol')) {
-      return 'mcp';
-    }
-
-    // 默认为 skill
-    return 'skill';
-  }
-
   // ==========================================================================
   // Schema 验证
   // ==========================================================================