Plugin Creator

/**
 * 插件模板生成脚本
 * 快速创建标准 Claude Code 插件目录结构
 */

import * as fs from 'fs';
import * as path from 'path';

interface PluginOptions {
  name: string;
  version?: string;
  description?: string;
  author?: string;
  includeSkills?: boolean;
  includeAgents?: boolean;
  includeCommands?: boolean;
  includeHooks?: boolean;
  includeMcp?: boolean;
  includeLsp?: boolean;
  includeSettings?: boolean;
}

/**
 * 创建插件目录结构
 */
export function createPlugin(outputPath: string, options: PluginOptions): void {
  const pluginDir = path.join(outputPath, options.name);

  // 检查目录是否已存在
  if (fs.existsSync(pluginDir)) {
    throw new Error(`目录已存在: ${pluginDir}`);
  }

  // 创建主目录
  fs.mkdirSync(pluginDir, { recursive: true });

  // 1. 创建 plugin.json
  const pluginJsonDir = path.join(pluginDir, '.claude-plugin');
  fs.mkdirSync(pluginJsonDir, { recursive: true });

  const pluginJson = {
    name: options.name,
    version: options.version || '1.0.0',
    description: options.description || `${options.name} 插件`,
    author: options.author || '',
  };

  fs.writeFileSync(
    path.join(pluginJsonDir, 'plugin.json'),
    JSON.stringify(pluginJson, null, 2)
  );

  // 2. 创建 skills 目录
  if (options.includeSkills) {
    const skillsDir = path.join(pluginDir, 'skills', 'example-skill');
    fs.mkdirSync(skillsDir, { recursive: true });

    const skillMd = `---
name: example-skill
description: 示例技能描述。说明何时使用此技能的触发条件和使用场景。
---

# Example Skill

技能的具体指令和使用说明。

## 使用方法

1. 步骤一
2. 步骤二
3. 步骤三

## 示例

\`\`\`typescript
// 示例代码
console.log('Hello from ${options.name}!');
\`\`\`
`;

    fs.writeFileSync(path.join(skillsDir, 'SKILL.md'), skillMd);
  }

  // 3. 创建 agents 目录
  if (options.includeAgents) {
    const agentsDir = path.join(pluginDir, 'agents');
    fs.mkdirSync(agentsDir, { recursive: true });

    const agentMd = `---
name: example-agent
description: 示例代理描述
tools: Read, Write, Edit, Grep, Glob
model: inherit
---

# Example Agent

你是一个专业的示例代理。

## 职责

- 职责一
- 职责二
- 职责三

## 工作流程

1. 分析任务
2. 执行操作
3. 验证结果
`;

    fs.writeFileSync(path.join(agentsDir, 'example-agent.md'), agentMd);
  }

  // 4. 创建 commands 目录
  if (options.includeCommands) {
    const commandsDir = path.join(pluginDir, 'commands');
    fs.mkdirSync(commandsDir, { recursive: true });

    const commandMd = `# Example Command

这是一个示例命令。

## 使用方法

\`\`\`
/${options.name}:example
\`\`\`

## 功能说明

执行示例命令时，Claude 会按照以下步骤操作：

1. 步骤一
2. 步骤二
3. 步骤三
`;

    fs.writeFileSync(path.join(commandsDir, 'example.md'), commandMd);
  }

  // 5. 创建 hooks 目录
  if (options.includeHooks) {
    const hooksDir = path.join(pluginDir, 'hooks');
    fs.mkdirSync(hooksDir, { recursive: true });

    const hooksJson = {
      hooks: {
        PreToolUse: [
          {
            matcher: 'Bash',
            hooks: ['echo "即将执行命令"'],
          },
        ],
        PostToolUse: [
          {
            matcher: 'Write',
            hooks: ['echo "文件已写入"'],
          },
        ],
      },
    };

    fs.writeFileSync(
      path.join(hooksDir, 'hooks.json'),
      JSON.stringify(hooksJson, null, 2)
    );
  }

  // 6. 创建 .mcp.json
  if (options.includeMcp) {
    const mcpJson = {
      mcpServers: {
        'example-server': {
          command: 'node',
          args: ['./server.js'],
          env: {
            API_KEY: 'your-api-key',
          },
        },
      },
    };

    fs.writeFileSync(
      path.join(pluginDir, '.mcp.json'),
      JSON.stringify(mcpJson, null, 2)
    );
  }

  // 7. 创建 .lsp.json
  if (options.includeLsp) {
    const lspJson = {
      typescript: {
        command: 'typescript-language-server',
        args: ['--stdio'],
        extensionToLanguage: {
          '.ts': 'typescript',
          '.tsx': 'typescriptreact',
        },
      },
    };

    fs.writeFileSync(
      path.join(pluginDir, '.lsp.json'),
      JSON.stringify(lspJson, null, 2)
    );
  }

  // 8. 创建 settings.json
  if (options.includeSettings) {
    const settingsJson = {
      // 默认设置
    };

    fs.writeFileSync(
      path.join(pluginDir, 'settings.json'),
      JSON.stringify(settingsJson, null, 2)
    );
  }

  // 9. 创建 README.md
  const readme = `# ${options.name}

${options.description || `${options.name} 插件`}

## 安装

\`\`\`bash
claude /plugin install <plugin-path>
\`\`\`

## 组件

${options.includeSkills ? `### Skills\n- \`example-skill\`: 示例技能描述\n\n` : ''}${options.includeAgents ? `### Agents\n- \`example-agent\`: 示例代理描述\n\n` : ''}${options.includeCommands ? `### Commands\n- \`/${options.name}:example\`: 示例命令\n\n` : ''}${options.includeHooks ? `### Hooks\n- PreToolUse: Bash 命令执行前\n- PostToolUse: Write 文件写入后\n\n` : ''}${options.includeMcp ? `### MCP\n- \`example-server\`: 示例 MCP 服务器\n\n` : ''}
## 使用示例

\`\`\`
/${options.name}:example
\`\`\`

## 配置

参见各配置文件了解详细配置选项。

## 版本历史

- \`1.0.0\` - 初始版本
`;

  fs.writeFileSync(path.join(pluginDir, 'README.md'), readme);

  console.log(`✅ 插件已创建: ${pluginDir}`);
  console.log('\n目录结构:');
  printTree(pluginDir, '', true);
}

/**
 * 打印目录树
 */
function printTree(dir: string, prefix: string, isLast: boolean): void {
  const name = path.basename(dir);
  const stats = fs.statSync(dir);

  if (stats.isDirectory()) {
    console.log(`${prefix}${isLast ? '└── ' : '├── '}${name}/`);

    const children = fs.readdirSync(dir);
    const newPrefix = prefix + (isLast ? '    ' : '│   ');

    children.forEach((child, index) => {
      const childPath = path.join(dir, child);
      const childIsLast = index === children.length - 1;
      printTree(childPath, newPrefix, childIsLast);
    });
  } else {
    console.log(`${prefix}${isLast ? '└── ' : '├── '}${name}`);
  }
}

// CLI 入口
if (require.main === module) {
  const args = process.argv.slice(2);

  if (args.length < 2) {
    console.log('用法: npx ts-node create_plugin.ts <output-path> <plugin-name> [options]');
    console.log('');
    console.log('选项:');
    console.log('  --description <desc>  插件描述');
    console.log('  --author <name>       作者名称');
    console.log('  --with-skills         包含示例技能');
    console.log('  --with-agents         包含示例代理');
    console.log('  --with-commands       包含示例命令');
    console.log('  --with-hooks          包含示例钩子');
    console.log('  --with-mcp            包含 MCP 配置');
    console.log('  --with-lsp            包含 LSP 配置');
    console.log('  --with-settings       包含设置文件');
    console.log('  --full                包含所有组件');
    console.log('');
    console.log('示例:');
    console.log('  npx ts-node create_plugin.ts ./plugins my-plugin --full');
    console.log('  npx ts-node create_plugin.ts ./plugins my-plugin --with-skills --with-commands');
    process.exit(1);
  }

  const outputPath = args[0];
  const pluginName = args[1];

  const options: PluginOptions = {
    name: pluginName,
  };

  for (let i = 2; i < args.length; i++) {
    switch (args[i]) {
      case '--description':
        options.description = args[++i];
        break;
      case '--author':
        options.author = args[++i];
        break;
      case '--with-skills':
        options.includeSkills = true;
        break;
      case '--with-agents':
        options.includeAgents = true;
        break;
      case '--with-commands':
        options.includeCommands = true;
        break;
      case '--with-hooks':
        options.includeHooks = true;
        break;
      case '--with-mcp':
        options.includeMcp = true;
        break;
      case '--with-lsp':
        options.includeLsp = true;
        break;
      case '--with-settings':
        options.includeSettings = true;
        break;
      case '--full':
        options.includeSkills = true;
        options.includeAgents = true;
        options.includeCommands = true;
        options.includeHooks = true;
        options.includeMcp = true;
        options.includeLsp = true;
        options.includeSettings = true;
        break;
    }
  }

  try {
    createPlugin(outputPath, options);
  } catch (error) {
    console.error(`❌ 错误: ${(error as Error).message}`);
    process.exit(1);
  }
}

/**
 * 插件验证脚本
 * 用于检查 Claude Code 插件结构的完整性
 */

import * as fs from 'fs';
import * as path from 'path';

interface ValidationResult {
  valid: boolean;
  errors: string[];
  warnings: string[];
  components: {
    skills: string[];
    agents: string[];
    commands: string[];
    hooks: boolean;
    mcp: boolean;
    lsp: boolean;
    settings: boolean;
  };
}

/**
 * 验证插件目录结构
 */
export function validatePlugin(pluginPath: string): ValidationResult {
  const result: ValidationResult = {
    valid: true,
    errors: [],
    warnings: [],
    components: {
      skills: [],
      agents: [],
      commands: [],
      hooks: false,
      mcp: false,
      lsp: false,
      settings: false,
    },
  };

  // 检查目录是否存在
  if (!fs.existsSync(pluginPath)) {
    result.valid = false;
    result.errors.push(`插件目录不存在: ${pluginPath}`);
    return result;
  }

  // 1. 检查 plugin.json
  const pluginJsonPath = path.join(pluginPath, '.claude-plugin', 'plugin.json');
  if (fs.existsSync(pluginJsonPath)) {
    try {
      const content = fs.readFileSync(pluginJsonPath, 'utf-8');
      const pluginJson = JSON.parse(content);

      if (!pluginJson.name) {
        result.errors.push('plugin.json 缺少 name 字段');
        result.valid = false;
      }
      if (!pluginJson.version) {
        result.warnings.push('plugin.json 建议包含 version 字段');
      }
      if (!pluginJson.description) {
        result.warnings.push('plugin.json 建议包含 description 字段');
      }
    } catch (e) {
      result.errors.push(`plugin.json 解析失败: ${(e as Error).message}`);
      result.valid = false;
    }
  } else {
    result.warnings.push('未找到 .claude-plugin/plugin.json（可选但推荐）');
  }

  // 2. 检查 skills
  const skillsPath = path.join(pluginPath, 'skills');
  if (fs.existsSync(skillsPath)) {
    const skillDirs = fs.readdirSync(skillsPath, { withFileTypes: true })
      .filter(dirent => dirent.isDirectory())
      .map(dirent => dirent.name);

    for (const skillName of skillDirs) {
      const skillMdPath = path.join(skillsPath, skillName, 'SKILL.md');
      if (fs.existsSync(skillMdPath)) {
        const content = fs.readFileSync(skillMdPath, 'utf-8');
        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);

        if (!frontmatterMatch) {
          result.errors.push(`skills/${skillName}/SKILL.md 缺少 frontmatter`);
          result.valid = false;
        } else {
          const frontmatter = frontmatterMatch[1];
          if (!frontmatter.includes('name:')) {
            result.errors.push(`skills/${skillName}/SKILL.md frontmatter 缺少 name 字段`);
            result.valid = false;
          }
          if (!frontmatter.includes('description:')) {
            result.errors.push(`skills/${skillName}/SKILL.md frontmatter 缺少 description 字段`);
            result.valid = false;
          }
        }
        result.components.skills.push(skillName);
      } else {
        result.warnings.push(`skills/${skillName} 目录缺少 SKILL.md 文件`);
      }
    }
  }

  // 3. 检查 agents
  const agentsPath = path.join(pluginPath, 'agents');
  if (fs.existsSync(agentsPath)) {
    const agentFiles = fs.readdirSync(agentsPath)
      .filter(file => file.endsWith('.md'));

    for (const agentFile of agentFiles) {
      const agentPath = path.join(agentsPath, agentFile);
      const content = fs.readFileSync(agentPath, 'utf-8');
      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);

      if (!frontmatterMatch) {
        result.errors.push(`agents/${agentFile} 缺少 frontmatter`);
        result.valid = false;
      } else {
        const frontmatter = frontmatterMatch[1];
        if (!frontmatter.includes('name:')) {
          result.errors.push(`agents/${agentFile} frontmatter 缺少 name 字段`);
          result.valid = false;
        }
        if (!frontmatter.includes('description:')) {
          result.errors.push(`agents/${agentFile} frontmatter 缺少 description 字段`);
          result.valid = false;
        }
      }
      result.components.agents.push(agentFile.replace('.md', ''));
    }
  }

  // 4. 检查 commands
  const commandsPath = path.join(pluginPath, 'commands');
  if (fs.existsSync(commandsPath)) {
    const commandFiles = fs.readdirSync(commandsPath)
      .filter(file => file.endsWith('.md'));

    for (const commandFile of commandFiles) {
      result.components.commands.push(commandFile.replace('.md', ''));
    }
  }

  // 5. 检查 hooks
  const hooksPath = path.join(pluginPath, 'hooks', 'hooks.json');
  if (fs.existsSync(hooksPath)) {
    try {
      const content = fs.readFileSync(hooksPath, 'utf-8');
      const hooksJson = JSON.parse(content);

      if (!hooksJson.hooks) {
        result.warnings.push('hooks/hooks.json 建议包含 hooks 字段');
      }
      result.components.hooks = true;
    } catch (e) {
      result.errors.push(`hooks/hooks.json 解析失败: ${(e as Error).message}`);
      result.valid = false;
    }
  }

  // 6. 检查 MCP 配置
  const mcpPath = path.join(pluginPath, '.mcp.json');
  if (fs.existsSync(mcpPath)) {
    try {
      const content = fs.readFileSync(mcpPath, 'utf-8');
      const mcpJson = JSON.parse(content);

      if (!mcpJson.mcpServers || Object.keys(mcpJson.mcpServers).length === 0) {
        result.warnings.push('.mcp.json 建议包含 mcpServers 配置');
      }
      result.components.mcp = true;
    } catch (e) {
      result.errors.push(`.mcp.json 解析失败: ${(e as Error).message}`);
      result.valid = false;
    }
  }

  // 7. 检查 LSP 配置
  const lspPath = path.join(pluginPath, '.lsp.json');
  if (fs.existsSync(lspPath)) {
    try {
      fs.readFileSync(lspPath, 'utf-8');
      JSON.parse(fs.readFileSync(lspPath, 'utf-8'));
      result.components.lsp = true;
    } catch (e) {
      result.errors.push(`.lsp.json 解析失败: ${(e as Error).message}`);
      result.valid = false;
    }
  }

  // 8. 检查 settings
  const settingsPath = path.join(pluginPath, 'settings.json');
  if (fs.existsSync(settingsPath)) {
    try {
      fs.readFileSync(settingsPath, 'utf-8');
      JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
      result.components.settings = true;
    } catch (e) {
      result.errors.push(`settings.json 解析失败: ${(e as Error).message}`);
      result.valid = false;
    }
  }

  // 9. 检查 README
  const readmePath = path.join(pluginPath, 'README.md');
  if (!fs.existsSync(readmePath)) {
    result.warnings.push('建议添加 README.md 文档');
  }

  return result;
}

/**
 * 打印验证结果
 */
export function printValidationResult(result: ValidationResult): void {
  console.log('\n=== 插件验证结果 ===\n');

  if (result.valid) {
    console.log('✅ 插件结构有效\n');
  } else {
    console.log('❌ 插件结构存在问题\n');
  }

  if (result.errors.length > 0) {
    console.log('错误:');
    result.errors.forEach(err => console.log(`  ❌ ${err}`));
    console.log('');
  }

  if (result.warnings.length > 0) {
    console.log('警告:');
    result.warnings.forEach(warn => console.log(`  ⚠️  ${warn}`));
    console.log('');
  }

  console.log('组件统计:');
  console.log(`  📦 Skills: ${result.components.skills.length > 0 ? result.components.skills.join(', ') : '无'}`);
  console.log(`  🤖 Agents: ${result.components.agents.length > 0 ? result.components.agents.join(', ') : '无'}`);
  console.log(`  ⚡ Commands: ${result.components.commands.length > 0 ? result.components.commands.join(', ') : '无'}`);
  console.log(`  🪝 Hooks: ${result.components.hooks ? '已配置' : '未配置'}`);
  console.log(`  🔌 MCP: ${result.components.mcp ? '已配置' : '未配置'}`);
  console.log(`  📝 LSP: ${result.components.lsp ? '已配置' : '未配置'}`);
  console.log(`  ⚙️  Settings: ${result.components.settings ? '已配置' : '未配置'}`);
}

// CLI 入口
if (require.main === module) {
  const pluginPath = process.argv[2];

  if (!pluginPath) {
    console.error('用法: npx ts-node validate_plugin.ts <plugin-path>');
    process.exit(1);
  }

  const result = validatePlugin(pluginPath);
  printValidationResult(result);

  process.exit(result.valid ? 0 : 1);
}