@42ailab/42plugin 0.1.21 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@42ailab/42plugin",
-  "version": "0.1.21",
+  "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/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 验证
   // ==========================================================================