@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/cli/src/commands/tasks/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview Tasks Command Entry
+ *
+ * 命令入口：roy tasks [action]
+ */
+import { CommandModule } from "yargs";
+/**
+ * Tasks Command
+ *
+ * 任务管理命令，提供以下子命令：
+ * - list: 列出所有任务
+ * - get: 获取任务详情
+ * - create: 创建任务
+ * - update: 更新任务
+ * - delete: 删除任务
+ * - complete: 完成任务
+ * - operations: 操作记录管理
+ */
+export declare const TasksCommand: CommandModule;
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/src/commands/tasks/index.js

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview Tasks Command Entry
+ *
+ * 命令入口：roy tasks [action]
+ */
+import { ListCommand } from "./list.js";
+import { GetCommand } from "./get.js";
+import { CreateCommand } from "./create.js";
+import { UpdateCommand } from "./update.js";
+import { DeleteCommand } from "./delete.js";
+import { CompleteCommand } from "./complete.js";
+import { OperationsCommand } from "./operations.js";
+/**
+ * Tasks Command
+ *
+ * 任务管理命令，提供以下子命令：
+ * - list: 列出所有任务
+ * - get: 获取任务详情
+ * - create: 创建任务
+ * - update: 更新任务
+ * - delete: 删除任务
+ * - complete: 完成任务
+ * - operations: 操作记录管理
+ */
+export const TasksCommand = {
+    command: "tasks",
+    describe: "任务管理 - 创建、追踪、管理任务",
+    builder: (yargs) => yargs
+        // 传递全局 plugin 选项到子命令
+        .option("plugin", {
+        alias: "p",
+        type: "string",
+        array: true,
+        description: "Enable plugin (e.g., --plugin task-tag)",
+        global: false, // 不再是 global，避免重复
+    })
+        .command(ListCommand)
+        .command(GetCommand)
+        .command(CreateCommand)
+        .command(UpdateCommand)
+        .command(DeleteCommand)
+        .command(CompleteCommand)
+        .command(OperationsCommand)
+        .demandCommand()
+        .help(),
+    handler: () => {
+        console.log("Use 'roy tasks --help' for usage information");
+    },
+};
+//# sourceMappingURL=index.js.map

package/dist/cli/src/commands/tasks/list.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Tasks List Command
+ *
+ * 命令：roy tasks list
+ */
+import { CommandModule } from "yargs";
+interface ListOptions {
+    status?: string;
+    priority?: string;
+    limit?: number;
+    offset?: number;
+    json?: boolean;
+    quiet?: boolean;
+    config?: string;
+}
+export declare const ListCommand: CommandModule<object, ListOptions>;
+export {};
+//# sourceMappingURL=list.d.ts.map

package/dist/cli/src/commands/tasks/list.js

@@ -0,0 +1,116 @@
+/**
+ * @fileoverview Tasks List Command
+ *
+ * 命令：roy tasks list
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const ListCommand = {
+    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");
+            if (!taskComponent) {
+                output.error("TaskComponent not available");
+                process.exit(1);
+            }
+            const listOptions = {
+                status: args.status,
+                priority: args.priority,
+                limit: args.limit,
+                offset: args.offset,
+            };
+            const tasks = await taskComponent.listTasks(listOptions);
+            if (args.json) {
+                output.json({
+                    tasks: tasks.map((t) => ({
+                        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) => 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, i) => {
+                    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();
+        }
+    },
+};
+//# sourceMappingURL=list.js.map

package/dist/cli/src/commands/tasks/operations.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Tasks Operations Command
+ *
+ * 命令：roy tasks operations <task-id>
+ */
+import { CommandModule } from "yargs";
+export declare const OperationsCommand: CommandModule<object, object>;
+//# sourceMappingURL=operations.d.ts.map

package/dist/cli/src/commands/tasks/operations.js

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Tasks Operations Command
+ *
+ * 命令：roy tasks operations <task-id>
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const OperationsCommand = {
+    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;
+        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");
+            if (!taskComponent) {
+                output.error("TaskComponent not available");
+                process.exit(1);
+            }
+            // Check if task exists
+            const task = await taskComponent.getTask(a.taskId);
+            if (!task) {
+                output.error(`Task not found: ${a.taskId}`);
+                process.exit(1);
+            }
+            const listOptions = {
+                taskId: a.taskId,
+                actionType: a.type,
+                limit: a.limit,
+                offset: a.offset,
+            };
+            const operations = 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, i) => {
+                        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();
+        }
+    },
+};
+//# sourceMappingURL=operations.js.map

package/dist/cli/src/commands/tasks/update.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview Tasks Update Command
+ *
+ * 命令：roy tasks update <task-id>
+ */
+import { CommandModule } from "yargs";
+interface UpdateOptions {
+    id: number;
+    title?: string;
+    description?: string;
+    status?: string;
+    priority?: string;
+    progress?: number;
+    current_status?: string;
+    json?: boolean;
+    config?: string;
+}
+export declare const UpdateCommand: CommandModule<object, UpdateOptions>;
+export {};
+//# sourceMappingURL=update.d.ts.map

package/dist/cli/src/commands/tasks/update.js

@@ -0,0 +1,93 @@
+/**
+ * @fileoverview Tasks Update Command
+ *
+ * 命令：roy tasks update <task-id>
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const UpdateCommand = {
+    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");
+            const taskComponent = env.getComponent("task");
+            if (!taskComponent) {
+                output.error("TaskComponent not available");
+                process.exit(1);
+            }
+            // Get current session ID
+            const currentSessionId = sessionComponent?.getActiveSessionId() || "cli";
+            const updateOptions = {
+                title: args.title,
+                description: args.description,
+                status: args.status,
+                priority: args.priority,
+                progress: args.progress,
+                current_status: args.current_status,
+            };
+            const task = 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();
+        }
+    },
+};
+//# sourceMappingURL=update.js.map

package/dist/cli/src/commands/tools/exec-tool.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Tools Exec-Tool Command
+ *
+ * 命令：roy tools exec-tool <name>
+ */
+import { CommandModule } from "yargs";
+interface ExecToolOptions {
+    name: string;
+    config?: string;
+    [key: string]: unknown;
+}
+export declare const ExecToolCommand: CommandModule<object, ExecToolOptions>;
+export {};
+//# sourceMappingURL=exec-tool.d.ts.map

package/dist/cli/src/commands/tools/exec-tool.js

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview Tools Exec-Tool Command
+ *
+ * 命令：roy tools exec-tool <name>
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import { extractParameters, validateRequiredParams, } from "./shared/schema-helper.js";
+export const ExecToolCommand = {
+    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");
+            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 = {};
+            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();
+        }
+    },
+};
+//# sourceMappingURL=exec-tool.js.map

package/dist/cli/src/commands/tools/get.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Tools Get Command
+ *
+ * 命令：roy tools get <name>
+ */
+import { CommandModule } from "yargs";
+interface GetOptions {
+    name: string;
+    json?: boolean;
+    config?: string;
+}
+export declare const GetCommand: CommandModule<object, GetOptions>;
+export {};
+//# sourceMappingURL=get.d.ts.map

package/dist/cli/src/commands/tools/get.js

@@ -0,0 +1,97 @@
+/**
+ * @fileoverview Tools Get Command
+ *
+ * 命令：roy tools get <name>
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+import { extractParameters } from "./shared/schema-helper.js";
+export const GetCommand = {
+    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");
+            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();
+        }
+    },
+};
+//# sourceMappingURL=get.js.map

package/dist/cli/src/commands/tools/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Tools Command Entry
+ *
+ * 命令入口：roy tools [action]
+ */
+import { CommandModule } from "yargs";
+/**
+ * Tools Command
+ *
+ * 工具管理命令，提供以下子命令：
+ * - list: 列出所有工具
+ * - get: 获取工具详情
+ * - exec-tool: 执行工具
+ */
+export declare const ToolsCommand: CommandModule;
+//# sourceMappingURL=index.d.ts.map