ops-toolkit 1.1.0 → 1.2.1

package/src/cli/app.ts

@@ -0,0 +1,188 @@
+#!/usr/bin/env bun
+
+import { Config } from '@/utils/config';
+import { setupErrorHandlers } from '@/utils/error-handlers';
+import { Logger } from '@/utils/logger';
+import chalk from 'chalk';
+import { program } from 'commander';
+import figlet from 'figlet';
+import { CommandDiscovery } from './command-discovery';
+import { CommandRegistry, type CommandDefinition } from './command-registry';
+
+/**
+ * CLI应用程序主入口
+ * 统一处理CLI启动、命令注册和错误处理
+ */
+export class CLIApp {
+  private version: string;
+  private commandRegistry: CommandRegistry;
+
+  constructor(version: string = '1.2.0') {
+    this.version = version;
+    this.commandRegistry = new CommandRegistry(program);
+  }
+
+  /**
+   * 初始化CLI应用
+   */
+  public async initialize(): Promise<void> {
+    this.setupProgram();
+    await this.registerCommands();
+    setupErrorHandlers();
+  }
+
+  /**
+   * 初始化程序配置
+   */
+  private setupProgram(): void {
+    program.name('ops').description('全面的DevOps CLI工具包').version(this.version);
+
+    // 全局选项
+    program
+      .option('-d, --debug', '启用调试模式', false)
+      .option('-v, --verbose', '启用详细日志', false);
+  }
+
+  /**
+   * 注册所有命令
+   */
+  private async registerCommands(): Promise<void> {
+    // 注册基础命令
+    const commands = this.getAllCommands();
+    this.commandRegistry.registerMultiple(commands);
+
+    // 发现并注册命令目录中的命令
+    const discovery = new CommandDiscovery(this.commandRegistry);
+    await discovery.discoverAndRegister();
+  }
+
+  /**
+   * 获取所有命令定义
+   */
+  private getAllCommands(): CommandDefinition[] {
+    return [
+      {
+        name: 'ui',
+        description: '启动交互式终端界面',
+        action: async () => {
+          await this.handleUICommand();
+        },
+      },
+      {
+        name: 'monitor',
+        description: '系统监控',
+        action: async () => {
+          await this.handleMonitorCommand();
+        },
+      },
+      {
+        name: 'logs',
+        description: '日志管理',
+        action: async () => {
+          await this.handleLogsCommand();
+        },
+      },
+      {
+        name: 'deploy',
+        description: '部署工具',
+        action: async () => {
+          await this.handleDeployCommand();
+        },
+      },
+      {
+        name: 'system',
+        description: '系统管理',
+        action: async () => {
+          await this.handleSystemCommand();
+        },
+      },
+    ];
+  }
+
+  /**
+   * 显示欢迎信息
+   */
+  private showWelcome(): void {
+    const welcomeText = figlet.textSync('ops-toolkit', {
+      font: 'Standard',
+      horizontalLayout: 'default',
+      verticalLayout: 'default',
+    });
+
+    console.log(chalk.cyan(welcomeText));
+  }
+
+  /**
+   * 处理UI命令
+   */
+  private async handleUICommand(): Promise<void> {
+    this.showWelcome();
+    console.log(chalk.green('🚀 ops-toolkit CLI正在运行!'));
+    console.log(chalk.blue('📋 可用命令:'));
+    console.log(chalk.white('  ops monitor    - 系统监控'));
+    console.log(chalk.white('  ops logs       - 日志管理'));
+    console.log(chalk.white('  ops deploy     - 部署工具'));
+    console.log(chalk.white('  ops system     - 系统管理'));
+    console.log(chalk.gray('\n🔧 UI功能即将推出...'));
+  }
+
+  /**
+   * 处理监控命令
+   */
+  private async handleMonitorCommand(): Promise<void> {
+    console.log(chalk.blue('📊 系统监控'));
+    console.log(chalk.yellow('⚠️  监控功能即将推出...'));
+  }
+
+  /**
+   * 处理日志命令
+   */
+  private async handleLogsCommand(): Promise<void> {
+    console.log(chalk.blue('📋 日志管理'));
+    console.log(chalk.yellow('⚠️  日志管理功能即将推出...'));
+  }
+
+  /**
+   * 处理部署命令
+   */
+  private async handleDeployCommand(): Promise<void> {
+    console.log(chalk.blue('🚀 部署工具'));
+    console.log(chalk.yellow('⚠️  部署功能即将推出...'));
+  }
+
+  /**
+   * 处理系统命令
+   */
+  private async handleSystemCommand(): Promise<void> {
+    console.log(chalk.blue('⚙️  系统管理'));
+    console.log(chalk.yellow('⚠️  系统管理功能即将推出...'));
+  }
+
+  /**
+   * 启动CLI应用程序
+   */
+  public async start(): Promise<void> {
+    try {
+      program.parse();
+    } catch (error) {
+      Logger.error('CLI启动失败');
+      if (error instanceof Error) {
+        Logger.error('错误详情', error);
+      }
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * 创建并启动CLI应用程序
+ */
+export async function createCLI(): Promise<void> {
+  await Config.initialize();
+  const config = Config.get();
+  const version = config?.version || '1.2.0';
+
+  const app = new CLIApp(version);
+  await app.initialize();
+  await app.start();
+}

package/src/cli/command-discovery.ts

@@ -0,0 +1,212 @@
+import { readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { CommandRegistry, type CommandDefinition } from './command-registry';
+import { Logger } from '@/utils/logger';
+
+/**
+ * 命令发现器
+ * 自动发现并加载命令模块
+ */
+export class CommandDiscovery {
+  private commandRegistry: CommandRegistry;
+  private commandsDir: string;
+
+  constructor(
+    commandRegistry: CommandRegistry,
+    commandsDir: string = join(__dirname, '../commands')
+  ) {
+    this.commandRegistry = commandRegistry;
+    this.commandsDir = commandsDir;
+  }
+
+  /**
+   * 发现并注册所有命令
+   */
+  public async discoverAndRegister(): Promise<void> {
+    try {
+      const commandModules = await this.discoverCommandModules();
+
+      for (const modulePath of commandModules) {
+        try {
+          const commandModule = await import(modulePath);
+          await this.registerCommandFromModule(commandModule, modulePath);
+        } catch (error) {
+          Logger.error(`加载命令模块失败: ${modulePath}`, error);
+        }
+      }
+    } catch (error) {
+      Logger.error('命令发现过程失败', error);
+    }
+  }
+
+  /**
+   * 发现命令模块
+   */
+  private async discoverCommandModules(): Promise<string[]> {
+    const modules: string[] = [];
+
+    if (!this.directoryExists(this.commandsDir)) {
+      Logger.warning(`命令目录不存在: ${this.commandsDir}`);
+      return modules;
+    }
+
+    const entries = readdirSync(this.commandsDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(this.commandsDir, entry.name);
+
+      if (entry.isDirectory()) {
+        // 查找目录中的 index.ts 或 index.js 文件
+        const indexFile = this.findIndexFile(fullPath);
+        if (indexFile) {
+          modules.push(indexFile);
+        }
+      } else if (this.isCommandFile(entry.name)) {
+        // 直接的命令文件
+        modules.push(fullPath);
+      }
+    }
+
+    return modules;
+  }
+
+  /**
+   * 查找目录中的索引文件
+   */
+  private findIndexFile(dirPath: string): string | null {
+    const possibleFiles = ['index.ts', 'index.js'];
+
+    for (const file of possibleFiles) {
+      const filePath = join(dirPath, file);
+      if (this.fileExists(filePath)) {
+        return filePath;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 检查是否为命令文件
+   */
+  private isCommandFile(filename: string): boolean {
+    return (
+      /\.(ts|js)$/.test(filename) &&
+      !filename.startsWith('.') &&
+      !filename.includes('.test.') &&
+      !filename.includes('.spec.')
+    );
+  }
+
+  /**
+   * 从模块注册命令
+   */
+  private async registerCommandFromModule(
+    commandModule: unknown,
+    modulePath: string
+  ): Promise<void> {
+    try {
+      const moduleObj = commandModule as Record<string, unknown>;
+      // 支持多种导出方式
+      let commandDef: CommandDefinition | undefined;
+
+      if (moduleObj.default && typeof moduleObj.default === 'object') {
+        // 默认导出对象
+        commandDef = moduleObj.default as CommandDefinition;
+      } else if (moduleObj.Command && typeof moduleObj.Command === 'object') {
+        // 命名导出 Command
+        commandDef = moduleObj.Command as CommandDefinition;
+      } else if (typeof commandModule === 'function') {
+        // 函数导出，转换为命令定义
+        commandDef = this.createCommandFromFunction(
+          commandModule as (...args: unknown[]) => void,
+          modulePath
+        );
+      }
+
+      if (commandDef && this.validateCommandDefinition(commandDef)) {
+        this.commandRegistry.register(commandDef);
+        Logger.info(`已注册命令: ${commandDef.name}`);
+      } else {
+        Logger.warning(`跳过无效的命令模块: ${modulePath}`);
+      }
+    } catch (error) {
+      Logger.error(`注册命令失败: ${modulePath}`, error);
+    }
+  }
+
+  /**
+   * 从函数创建命令定义
+   */
+  private createCommandFromFunction(
+    commandFn: (...args: unknown[]) => void,
+    modulePath: string
+  ): CommandDefinition | undefined {
+    const commandName = this.extractCommandNameFromPath(modulePath);
+
+    if (!commandName) {
+      return undefined;
+    }
+
+    return {
+      name: commandName,
+      description: `${commandName} 命令`,
+      action: async () => {
+        await commandFn();
+      },
+    };
+  }
+
+  /**
+   * 从文件路径提取命令名称
+   */
+  private extractCommandNameFromPath(modulePath: string): string | null {
+    const parts = modulePath.split('/');
+    const lastPart = parts[parts.length - 1];
+
+    if (!lastPart) {
+      return null;
+    }
+
+    if (lastPart === 'index.ts' || lastPart === 'index.js') {
+      // 从父目录名称提取
+      const parentDir = parts[parts.length - 2];
+      return parentDir || null;
+    }
+
+    // 从文件名提取
+    const nameWithoutExt = lastPart.replace(/\.(ts|js)$/, '');
+    return nameWithoutExt || null;
+  }
+
+  /**
+   * 验证命令定义
+   */
+  private validateCommandDefinition(commandDef: CommandDefinition): boolean {
+    return !!(commandDef.name && commandDef.description && typeof commandDef.action === 'function');
+  }
+
+  /**
+   * 检查目录是否存在
+   */
+  private directoryExists(path: string): boolean {
+    try {
+      const stats = statSync(path);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 检查文件是否存在
+   */
+  private fileExists(path: string): boolean {
+    try {
+      const stats = statSync(path);
+      return stats.isFile();
+    } catch {
+      return false;
+    }
+  }
+}

package/src/cli/command-registry.ts

@@ -0,0 +1,136 @@
+import { Command } from 'commander';
+import type { CommandOptions } from '@/types/commands';
+
+/**
+ * 命令接口定义
+ */
+export interface CommandDefinition {
+  name: string;
+  description: string;
+  alias?: string;
+  options?: CommandOption[];
+  subcommands?: CommandDefinition[];
+  action: (options: CommandOptions) => Promise<void> | void;
+}
+
+/**
+ * 命令选项定义
+ */
+export interface CommandOption {
+  flags: string;
+  description: string;
+  defaultValue?: string | boolean | string[];
+}
+
+/**
+ * 命令注册器
+ */
+export class CommandRegistry {
+  private commands: Map<string, CommandDefinition> = new Map();
+  private program: Command;
+
+  constructor(program: Command) {
+    this.program = program;
+  }
+
+  /**
+   * 注册单个命令
+   */
+  public register(commandDef: CommandDefinition): void {
+    this.commands.set(commandDef.name, commandDef);
+    this.setupCommand(commandDef);
+  }
+
+  /**
+   * 批量注册命令
+   */
+  public registerMultiple(commandDefs: CommandDefinition[]): void {
+    commandDefs.forEach(commandDef => this.register(commandDef));
+  }
+
+  /**
+   * 设置命令到Commander程序
+   */
+  private setupCommand(commandDef: CommandDefinition): void {
+    const cmd = this.program.command(commandDef.name).description(commandDef.description);
+
+    // 设置别名
+    if (commandDef.alias) {
+      cmd.alias(commandDef.alias);
+    }
+
+    // 设置选项
+    if (commandDef.options) {
+      commandDef.options.forEach(option => {
+        cmd.option(option.flags, option.description, option.defaultValue);
+      });
+    }
+
+    // 设置子命令
+    if (commandDef.subcommands) {
+      commandDef.subcommands.forEach(subcommandDef => {
+        this.setupSubcommand(cmd, subcommandDef);
+      });
+    }
+
+    // 设置动作
+    cmd.action(async options => {
+      try {
+        await commandDef.action(options);
+      } catch (error) {
+        console.error(`命令 "${commandDef.name}" 执行失败:`, error);
+        process.exit(1);
+      }
+    });
+  }
+
+  /**
+   * 设置子命令
+   */
+  private setupSubcommand(parentCmd: Command, subcommandDef: CommandDefinition): void {
+    const subcmd = parentCmd.command(subcommandDef.name).description(subcommandDef.description);
+
+    // 设置别名
+    if (subcommandDef.alias) {
+      subcmd.alias(subcommandDef.alias);
+    }
+
+    // 设置选项
+    if (subcommandDef.options) {
+      subcommandDef.options.forEach(option => {
+        subcmd.option(option.flags, option.description, option.defaultValue);
+      });
+    }
+
+    // 设置动作
+    subcmd.action(async options => {
+      try {
+        await subcommandDef.action(options);
+      } catch (error) {
+        console.error(`子命令 "${subcommandDef.name}" 执行失败:`, error);
+        process.exit(1);
+      }
+    });
+  }
+
+  /**
+   * 获取所有注册的命令
+   */
+  public getCommands(): CommandDefinition[] {
+    return Array.from(this.commands.values());
+  }
+
+  /**
+   * 根据名称获取命令
+   */
+  public getCommand(name: string): CommandDefinition | undefined {
+    return this.commands.get(name);
+  }
+
+  /**
+   * 检查命令是否存在
+   */
+  public hasCommand(name: string): boolean {
+    return this.commands.has(name);
+  }
+}