@ai-setting/roy-agent-cli 1.0.0

package/src/commands/tasks/list.ts

@@ -0,0 +1,140 @@
+/**
+ * @fileoverview Tasks List Command
+ * 
+ * 命令：roy tasks list
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type {
+  TaskComponent,
+  Task,
+  ListTasksOptions,
+} from "@ai-setting/roy-agent-core";
+
+interface ListOptions {
+  status?: string;
+  priority?: string;
+  limit?: number;
+  offset?: number;
+  json?: boolean;
+  quiet?: boolean;
+  config?: string;
+}
+
+export const ListCommand: CommandModule<object, ListOptions> = {
+  command: "list",
+  aliases: ["ls"],
+  describe: "列出所有任务",
+  
+  builder: (yargs) =>
+    yargs
+      .option("status", {
+        alias: "s",
+        type: "string",
+        choices: ["todo", "active", "completed", "paused", "cancelled"],
+        description: "按状态筛选",
+      })
+      .option("priority", {
+        alias: "p",
+        type: "string",
+        choices: ["low", "medium", "high"],
+        description: "按优先级筛选",
+      })
+      .option("limit", { alias: "n", type: "number", default: 20, description: "返回数量" })
+      .option("offset", { type: "number", default: 0, description: "偏移量" })
+      .option("json", { alias: "j", type: "boolean", default: false, description: "JSON 输出" })
+      .option("quiet", { alias: "q", type: "boolean", default: false, description: "简洁输出" }),
+  
+  async handler(args) {
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: args.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const taskComponent = env.getComponent("task") as TaskComponent | undefined;
+
+      if (!taskComponent) {
+        output.error("TaskComponent not available");
+        process.exit(1);
+      }
+
+      const listOptions: ListTasksOptions = {
+        status: args.status as any,
+        priority: args.priority as any,
+        limit: args.limit,
+        offset: args.offset,
+      };
+      const tasks: Task[] = await taskComponent.listTasks(listOptions);
+
+      if (args.json) {
+        output.json({
+          tasks: tasks.map((t: Task) => ({
+            id: t.id,
+            title: t.title,
+            status: t.status,
+            priority: t.priority,
+            progress: t.progress,
+            current_status: t.current_status,
+            createdAt: t.createdAt,
+            updatedAt: t.updatedAt,
+          })),
+          count: tasks.length,
+        });
+      } else if (args.quiet) {
+        tasks.forEach((t: Task) => output.log(t.id.toString()));
+      } else {
+        // 表格输出
+        const header = [
+          chalk.bold("#"),
+          chalk.bold("Title"),
+          chalk.bold("Status"),
+          chalk.bold("Priority"),
+          chalk.bold("Progress"),
+        ].join(" │ ");
+
+        const rows = tasks.map((t: Task, i: number) => {
+          const statusColor = t.status === "completed" ? chalk.green :
+                            t.status === "active" ? chalk.blue :
+                            t.status === "paused" ? chalk.yellow :
+                            t.status === "cancelled" ? chalk.strikethrough :
+                            chalk.gray;
+          
+          const priorityColor = t.priority === "high" ? chalk.red :
+                              t.priority === "medium" ? chalk.yellow :
+                              chalk.gray;
+
+          return [
+            (args.offset! + i + 1).toString(),
+            t.title.length > 30 ? t.title.slice(0, 27) + "..." : t.title,
+            statusColor(t.status),
+            priorityColor(t.priority),
+            `${t.progress}%`,
+          ].join(" │ ");
+        });
+
+        output.log([
+          `┌─ Tasks ${"─".repeat(55)}┐`,
+          `│${header}│`,
+          "├" + "─".repeat(header.length + 2) + "┤",
+          ...rows.map(r => `│${r}│`),
+          "└" + "─".repeat(header.length + 2) + "┘",
+          "",
+          chalk.gray(`Total: ${tasks.length} tasks`),
+        ].join("\n"));
+      }
+    } catch (error) {
+      output.error(`Failed to list tasks: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/tasks/operations.ts

@@ -0,0 +1,120 @@
+/**
+ * @fileoverview Tasks Operations Command
+ * 
+ * 命令：roy tasks operations <task-id>
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type {
+  TaskComponent,
+  Task,
+  TaskOperation,
+  ActionType,
+  ListOperationsOptions,
+} from "@ai-setting/roy-agent-core";
+
+interface OperationsOptions {
+  taskId: number;
+  type?: string;
+  limit?: number;
+  offset?: number;
+  json?: boolean;
+  config?: string;
+}
+
+export const OperationsCommand: CommandModule<object, object> = {
+  command: "operations <task-id>",
+  aliases: ["ops", "log"],
+  describe: "查看任务操作记录",
+  
+  builder: (yargs) =>
+    yargs
+      .positional("task-id", {
+        type: "number",
+        describe: "任务 ID",
+        demandOption: true,
+      })
+      .option("type", {
+        alias: "t",
+        type: "string",
+        choices: ["create", "progress", "milestone", "problem", "solution", "decision", "review", "completed"],
+        description: "按类型筛选",
+      })
+      .option("limit", { alias: "n", type: "number", default: 20, description: "返回数量" })
+      .option("offset", { type: "number", default: 0, description: "偏移量" })
+      .option("json", { alias: "j", type: "boolean", default: false, description: "JSON 输出" }),
+  
+  async handler(args) {
+    const a = args as any;
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: a.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const taskComponent = env.getComponent("task") as TaskComponent | undefined;
+
+      if (!taskComponent) {
+        output.error("TaskComponent not available");
+        process.exit(1);
+      }
+
+      // Check if task exists
+      const task: Task | undefined = await taskComponent.getTask(a.taskId);
+      if (!task) {
+        output.error(`Task not found: ${a.taskId}`);
+        process.exit(1);
+      }
+
+      const listOptions: ListOperationsOptions = {
+        taskId: a.taskId,
+        actionType: a.type as ActionType,
+        limit: a.limit,
+        offset: a.offset,
+      };
+      const operations: TaskOperation[] = await taskComponent.listOperations(listOptions);
+
+      if (a.json) {
+        output.json({
+          task: { id: task.id, title: task.title },
+          operations,
+          count: operations.length,
+        });
+      } else {
+        output.log(chalk.bold(`\nOperations for Task #${task.id}: ${task.title}\n`));
+        
+        if (operations.length === 0) {
+          output.log(chalk.gray("No operations found."));
+        } else {
+          operations.forEach((op: TaskOperation, i: number) => {
+            const actionColor = op.actionType === "completed" ? chalk.green :
+                               op.actionType === "milestone" ? chalk.blue :
+                               op.actionType === "problem" ? chalk.red :
+                               chalk.gray;
+            
+            output.log(`${chalk.bold(a.offset! + i + 1)}. ` + actionColor(`[${op.actionType}]`) + ` ${op.actionTitle}`);
+            output.log(`   Session: ${chalk.cyan(op.sessionId)} | Time: ${op.timestamp}`);
+            if (op.actionDescription) {
+              output.log(`   ${op.actionDescription}`);
+            }
+            output.log("");
+          });
+        }
+        
+        output.log(chalk.gray(`Total: ${operations.length} operations`));
+      }
+    } catch (error) {
+      output.error(`Failed to list operations: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/tasks/update.ts

@@ -0,0 +1,122 @@
+/**
+ * @fileoverview Tasks Update Command
+ * 
+ * 命令：roy tasks update <task-id>
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type {
+  SessionComponent,
+  TaskComponent,
+  Task,
+  TaskStatus,
+  TaskPriority,
+  UpdateTaskOptions,
+} from "@ai-setting/roy-agent-core";
+
+interface UpdateOptions {
+  id: number;
+  title?: string;
+  description?: string;
+  status?: string;
+  priority?: string;
+  progress?: number;
+  current_status?: string;
+  json?: boolean;
+  config?: string;
+}
+
+export const UpdateCommand: CommandModule<object, UpdateOptions> = {
+  command: "update <id>",
+  aliases: ["set"],
+  describe: "更新任务",
+  
+  builder: (yargs) =>
+    yargs
+      .positional("id", {
+        type: "number",
+        describe: "任务 ID",
+        demandOption: true,
+      })
+      .option("title", { alias: "t", type: "string", description: "标题" })
+      .option("description", { alias: "d", type: "string", description: "描述" })
+      .option("status", { alias: "s", type: "string", choices: ["todo", "active", "completed", "paused", "cancelled"], description: "状态" })
+      .option("priority", { alias: "p", type: "string", choices: ["low", "medium", "high"], description: "优先级" })
+      .option("progress", { type: "number", min: 0, max: 100, description: "进度 (0-100)" })
+      .option("current_status", { alias: "c", type: "string", description: "当前状态描述" })
+      .option("json", { alias: "j", type: "boolean", default: false, description: "JSON 输出" }),
+  
+  async handler(args) {
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: args.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const sessionComponent = env.getComponent("session") as SessionComponent | undefined;
+      const taskComponent = env.getComponent("task") as TaskComponent | undefined;
+
+      if (!taskComponent) {
+        output.error("TaskComponent not available");
+        process.exit(1);
+      }
+
+      // Get current session ID
+      const currentSessionId = sessionComponent?.getActiveSessionId() || "cli";
+      
+      const updateOptions: UpdateTaskOptions = {
+        title: args.title,
+        description: args.description,
+        status: args.status as TaskStatus,
+        priority: args.priority as TaskPriority,
+        progress: args.progress,
+        current_status: args.current_status,
+      };
+      const task: Task | undefined = await taskComponent.updateTask(args.id, updateOptions);
+
+      if (!task) {
+        output.error(`Task not found: ${args.id}`);
+        process.exit(1);
+      }
+
+      // Create operation record for status/progress changes
+      if (args.status || args.progress !== undefined || args.current_status) {
+        await taskComponent.createOperation({
+          taskId: args.id,
+          sessionId: currentSessionId,
+          actionType: "progress",
+          actionTitle: args.current_status || `Updated: ${args.status || `${args.progress}%`}`,
+          actionDescription: JSON.stringify({
+            status: args.status,
+            progress: args.progress,
+          }),
+        });
+      }
+
+      if (args.json) {
+        output.json(task);
+      } else {
+        output.log(chalk.green(`\n✓ Task updated: #${task.id}`));
+        output.log(`  Title: ${task.title}`);
+        output.log(`  Status: ${task.status}`);
+        output.log(`  Priority: ${task.priority}`);
+        output.log(`  Progress: ${task.progress}%`);
+        if (task.current_status) {
+          output.log(`  Current Status: ${task.current_status}`);
+        }
+      }
+    } catch (error) {
+      output.error(`Failed to update task: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/tools/exec-tool.ts

@@ -0,0 +1,128 @@
+/**
+ * @fileoverview Tools Exec-Tool Command
+ * 
+ * 命令：roy tools exec-tool <name>
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import type { ToolComponent, Tool } from "@ai-setting/roy-agent-core";
+import {
+  extractParameters,
+  validateRequiredParams,
+} from "./shared/schema-helper";
+
+interface ExecToolOptions {
+  name: string;
+  config?: string;
+  // 动态参数将通过 yargs builder 动态添加
+  [key: string]: unknown;
+}
+
+export const ExecToolCommand: CommandModule<object, ExecToolOptions> = {
+  command: "exec-tool <name>",
+  describe: "执行指定工具",
+
+  builder: (yargs) => {
+    return yargs
+      .positional("name", {
+        type: "string",
+        demandOption: true,
+        description: "工具名称",
+      })
+      .strict(false); // 允许动态参数
+  },
+
+  async handler(args) {
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+    const toolName = args.name;
+
+    try {
+      await envService.create({ configPath: args.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const toolComponent = env.getComponent("tool") as ToolComponent | undefined;
+
+      if (!toolComponent) {
+        output.error("ToolComponent not available");
+        process.exit(1);
+      }
+
+      // 获取工具
+      const tool = toolComponent.getTool(toolName);
+
+      if (!tool) {
+        output.error(`Tool not found: ${toolName}`);
+        output.log("Use 'roy tools list' to see available tools.");
+        process.exit(1);
+      }
+
+      // 提取参数信息
+      const params = extractParameters(tool.parameters);
+
+      // 收集用户提供的参数（排除 name 和 config）
+      const userArgs: Record<string, unknown> = {};
+      for (const param of params) {
+        if (args[param.name] !== undefined) {
+          userArgs[param.name] = args[param.name];
+        }
+      }
+
+      // 验证必需参数
+      const validation = validateRequiredParams(params, userArgs);
+
+      if (!validation.valid) {
+        output.error(`Missing required arguments for '${toolName}':`);
+        for (const missing of validation.missing) {
+          const param = params.find((p) => p.name === missing);
+          output.log(`  - ${missing} (${param?.description || "required"})`);
+        }
+        output.log("");
+        output.log(`Usage: roy tools exec-tool ${toolName} [options]`);
+        for (const param of params) {
+          const req = param.required ? "required" : "optional";
+          const def =
+            param.default !== undefined
+              ? ` [default: ${JSON.stringify(param.default)}]`
+              : "";
+          output.log(`  --${param.name} <${param.type}> (${req})${def}`);
+        }
+        process.exit(1);
+      }
+
+      // 执行工具
+      const result = await toolComponent.execute({
+        name: toolName,
+        args: userArgs,
+        context: {
+          workdir: process.cwd(),
+        },
+      });
+
+      // 输出结果（JSON 格式）
+      output.json(result);
+
+      // 根据结果设置退出码
+      if (!result.success) {
+        process.exit(1);
+      }
+    } catch (error) {
+      output.json({
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: {
+          execution_time_ms: 0,
+        },
+      });
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/tools/get.ts

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview Tools Get Command
+ * 
+ * 命令：roy tools get <name>
+ */
+
+import { CommandModule } from "yargs";
+import { EnvironmentService } from "../../services/environment.service";
+import { OutputService } from "../../services/output.service";
+import chalk from "chalk";
+import type { ToolComponent, Tool } from "@ai-setting/roy-agent-core";
+import { extractParameters } from "./shared/schema-helper";
+
+interface GetOptions {
+  name: string;
+  json?: boolean;
+  config?: string;
+}
+
+export const GetCommand: CommandModule<object, GetOptions> = {
+  command: "get <name>",
+  describe: "获取指定工具的详细信息",
+
+  builder: (yargs) =>
+    yargs
+      .positional("name", {
+        type: "string",
+        demandOption: true,
+        description: "工具名称",
+      })
+      .option("json", {
+        alias: "j",
+        type: "boolean",
+        default: false,
+        description: "JSON 输出",
+      }),
+
+  async handler(args) {
+    const output = new OutputService();
+    const envService = new EnvironmentService(output);
+
+    try {
+      await envService.create({ configPath: args.config });
+      const env = envService.getEnvironment();
+      if (!env) {
+        output.error("Failed to create environment");
+        process.exit(1);
+      }
+      const toolComponent = env.getComponent("tool") as ToolComponent | undefined;
+
+      if (!toolComponent) {
+        output.error("ToolComponent not available");
+        process.exit(1);
+      }
+
+      const tool = toolComponent.getTool(args.name);
+
+      if (!tool) {
+        output.error(`Tool not found: ${args.name}`);
+        output.log("Use 'roy tools list' to see available tools.");
+        process.exit(1);
+      }
+
+      // 提取参数信息
+      const params = extractParameters(tool.parameters);
+
+      if (args.json) {
+        output.json({
+          name: tool.name,
+          description: tool.description,
+          category: tool.metadata?.category,
+          tags: tool.metadata?.tags,
+          parameters: params.map((p) => ({
+            name: p.name,
+            type: p.type,
+            description: p.description,
+            required: p.required,
+            default: p.default,
+          })),
+        });
+      } else {
+        // 格式化输出
+        output.log(chalk.bold.cyan(`Tool: ${tool.name}`));
+        output.log(chalk.gray("─".repeat(60)));
+        output.log(`Description: ${tool.description}`);
+        if (tool.metadata?.category) {
+          output.log(`Category: ${tool.metadata.category}`);
+        }
+        if (tool.metadata?.tags?.length) {
+          output.log(`Tags: ${tool.metadata.tags.join(", ")}`);
+        }
+        output.log("");
+        output.log(chalk.bold("Parameters:"));
+
+        for (const param of params) {
+          const required = param.required
+            ? chalk.red("(required)")
+            : chalk.gray("(optional)");
+          const defaultVal =
+            param.default !== undefined
+              ? ` [default: ${JSON.stringify(param.default)}]`
+              : "";
+          output.log(`  --${param.name} <${param.type}> ${required}`);
+          output.log(`      ${param.description}${defaultVal}`);
+        }
+      }
+    } catch (error) {
+      output.error(`Failed to get tool: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/tools/index.ts

@@ -0,0 +1,35 @@
+/**
+ * @fileoverview Tools Command Entry
+ * 
+ * 命令入口：roy tools [action]
+ */
+
+import { CommandModule } from "yargs";
+import { ListCommand } from "./list";
+import { GetCommand } from "./get";
+import { ExecToolCommand } from "./exec-tool";
+
+/**
+ * Tools Command
+ * 
+ * 工具管理命令，提供以下子命令：
+ * - list: 列出所有工具
+ * - get: 获取工具详情
+ * - exec-tool: 执行工具
+ */
+export const ToolsCommand: CommandModule = {
+  command: "tools",
+  describe: "工具管理 - 列出、获取、执行内置工具",
+
+  builder: (yargs) =>
+    yargs
+      .command(ListCommand)
+      .command(GetCommand)
+      .command(ExecToolCommand)
+      .demandCommand()
+      .help(),
+
+  handler: () => {
+    console.log("Use 'roy tools --help' for usage information");
+  },
+};