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

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

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

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

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

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

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Tools List Command
+ *
+ * 命令：roy tools 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("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 toolComponent = env.getComponent("tool");
+            if (!toolComponent) {
+                output.error("ToolComponent not available");
+                process.exit(1);
+            }
+            const tools = toolComponent.listTools();
+            if (args.json) {
+                output.json({
+                    tools: tools.map((t) => ({
+                        name: t.name,
+                        description: t.description,
+                        category: t.metadata?.category,
+                    })),
+                    count: tools.length,
+                });
+            }
+            else if (args.quiet) {
+                tools.forEach((t) => output.log(t.name));
+            }
+            else {
+                // 表格输出
+                const header = [
+                    chalk.bold("Name"),
+                    chalk.bold("Description"),
+                    chalk.bold("Category"),
+                ].join(" | ");
+                const rows = tools.map((t) => {
+                    const desc = t.description.length > 40
+                        ? t.description.slice(0, 37) + "..."
+                        : t.description;
+                    return [
+                        chalk.cyan(t.name),
+                        desc,
+                        t.metadata?.category ? chalk.gray(`[${t.metadata.category}]`) : "-",
+                    ].join(" | ");
+                });
+                output.log([
+                    `┌─ Tools ${"─".repeat(48)}┐`,
+                    `│${header}│`,
+                    "├" + "─".repeat(header.length + 2) + "┤",
+                    ...rows.map((r) => `│${r}│`),
+                    "└" + "─".repeat(header.length + 2) + "┘",
+                    "",
+                    chalk.gray(`Total: ${tools.length} tools`),
+                ].join("\n"));
+            }
+        }
+        catch (error) {
+            output.error(`Failed to list tools: ${error}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=list.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Tools Shared Module
+ *
+ * 导出共享的工具函数
+ */
+export * from "./schema-helper";
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/src/commands/tools/shared/index.js

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Tools Shared Module
+ *
+ * 导出共享的工具函数
+ */
+export * from "./schema-helper.js";
+//# sourceMappingURL=index.js.map

package/dist/cli/src/commands/tools/shared/schema-helper.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Schema Helper
+ *
+ * 提供 Zod schema 解析和工具函数，用于从 tool 的参数 schema
+ * 提取参数信息、验证必需参数、生成 yargs 选项等。
+ */
+/**
+ * 参数信息
+ */
+export interface ParameterInfo {
+    /** 参数名称 */
+    name: string;
+    /** 参数类型 */
+    type: string;
+    /** 参数描述 */
+    description: string;
+    /** 是否必需 */
+    required: boolean;
+    /** 默认值 */
+    default?: unknown;
+}
+/**
+ * 验证结果
+ */
+export interface ValidateResult {
+    /** 是否有效 */
+    valid: boolean;
+    /** 缺少的必需参数 */
+    missing: string[];
+}
+/**
+ * 从 Zod schema 提取参数信息
+ *
+ * @param schema - Zod schema
+ * @returns 参数信息数组
+ */
+export declare function extractParameters(schema: any): ParameterInfo[];
+/**
+ * 检查参数是否完整
+ *
+ * @param params - 参数信息数组
+ * @param args - 用户提供的参数
+ * @returns 验证结果
+ */
+export declare function validateRequiredParams(params: ParameterInfo[], args: Record<string, unknown>): ValidateResult;
+/**
+ * 格式化参数为 yargs 选项
+ *
+ * @param params - 参数信息数组
+ * @returns yargs 选项配置
+ */
+export declare function formatYargsOptions(params: ParameterInfo[]): Record<string, any>;
+//# sourceMappingURL=schema-helper.d.ts.map

package/dist/cli/src/commands/tools/shared/schema-helper.js

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview Schema Helper
+ *
+ * 提供 Zod schema 解析和工具函数，用于从 tool 的参数 schema
+ * 提取参数信息、验证必需参数、生成 yargs 选项等。
+ */
+import { zodToJsonSchema } from "zod-to-json-schema";
+/**
+ * 从 Zod schema 提取参数信息
+ *
+ * @param schema - Zod schema
+ * @returns 参数信息数组
+ */
+export function extractParameters(schema) {
+    const jsonSchema = zodToJsonSchema(schema);
+    const properties = (jsonSchema.properties || {});
+    const required = (jsonSchema.required || []);
+    return Object.entries(properties).map(([name, prop]) => ({
+        name,
+        type: prop.type || "any",
+        description: prop.description || "",
+        required: required.includes(name),
+        default: prop.default,
+    }));
+}
+/**
+ * 检查参数是否完整
+ *
+ * @param params - 参数信息数组
+ * @param args - 用户提供的参数
+ * @returns 验证结果
+ */
+export function validateRequiredParams(params, args) {
+    const missing = params
+        .filter((p) => p.required)
+        .filter((p) => args[p.name] === undefined)
+        .map((p) => p.name);
+    return {
+        valid: missing.length === 0,
+        missing,
+    };
+}
+/**
+ * 格式化参数为 yargs 选项
+ *
+ * @param params - 参数信息数组
+ * @returns yargs 选项配置
+ */
+export function formatYargsOptions(params) {
+    const options = {};
+    for (const param of params) {
+        // 映射类型到 yargs 类型
+        let yargsType;
+        if (param.type === "number" || param.type === "integer") {
+            yargsType = "number";
+        }
+        else if (param.type === "boolean") {
+            yargsType = "boolean";
+        }
+        else {
+            yargsType = "string";
+        }
+        options[param.name] = {
+            type: yargsType,
+            description: param.description || param.name,
+            demandOption: param.required,
+        };
+        if (param.default !== undefined) {
+            options[param.name].default = param.default;
+        }
+    }
+    return options;
+}
+//# sourceMappingURL=schema-helper.js.map

package/dist/cli/src/commands/workflow/commands/add.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Workflow Add Command
+ *
+ * Add a new workflow from file or natural language description
+ */
+import { CommandModule } from 'yargs';
+export interface WorkflowAddOptions {
+    name?: string;
+    file?: string;
+    desc?: string;
+    description?: string;
+    tags?: string[];
+    taskId?: number;
+    force?: boolean;
+    validate?: boolean;
+    config?: string;
+}
+/**
+ * WorkflowAddCommand - Add a new workflow
+ */
+export declare const WorkflowAddCommand: CommandModule<object, object>;
+//# sourceMappingURL=add.d.ts.map

package/dist/cli/src/commands/workflow/commands/add.js

@@ -0,0 +1,271 @@
+/**
+ * @fileoverview Workflow Add Command
+ *
+ * Add a new workflow from file or natural language description
+ */
+import { EnvironmentService } from "../../../services/environment.service.js";
+import { OutputService } from "../../../services/output.service.js";
+import { renderWorkflowAdded, renderNodesList } from "../renderers.js";
+import { WorkflowValidator } from "../validators/workflow-validator.js";
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { createWorkflowExtractorAgent } from '@ai-setting/roy-agent-core/env/task/plugins';
+/**
+ * Parse workflow file content (YAML or JSON)
+ * Uses WorkflowDefinitionSchema to ensure default values are applied
+ */
+async function parseWorkflowContent(content, filename) {
+    const isYaml = filename.endsWith('.yaml') || filename.endsWith('.yml');
+    const isJson = filename.endsWith('.json');
+    let definition;
+    if (isYaml) {
+        // Dynamic import for YAML parser
+        const yaml = await import('yaml');
+        const parsed = yaml.parse(content);
+        // Use WorkflowDefinitionSchema to apply defaults
+        const { WorkflowDefinitionSchema } = await import('@ai-setting/roy-agent-core/env/workflow/types');
+        definition = WorkflowDefinitionSchema.parse(parsed);
+    }
+    else if (isJson) {
+        const parsed = JSON.parse(content);
+        const { WorkflowDefinitionSchema } = await import('@ai-setting/roy-agent-core/env/workflow/types');
+        definition = WorkflowDefinitionSchema.parse(parsed);
+    }
+    else {
+        // Auto-detect: try JSON first, then YAML
+        try {
+            const parsed = JSON.parse(content);
+            const { WorkflowDefinitionSchema } = await import('@ai-setting/roy-agent-core/env/workflow/types');
+            definition = WorkflowDefinitionSchema.parse(parsed);
+        }
+        catch {
+            const yaml = await import('yaml');
+            const parsed = yaml.parse(content);
+            const { WorkflowDefinitionSchema } = await import('@ai-setting/roy-agent-core/env/workflow/types');
+            definition = WorkflowDefinitionSchema.parse(parsed);
+        }
+    }
+    return definition;
+}
+/**
+ * Parse YAML from agent output
+ */
+function parseYamlFromAgentOutput(output) {
+    // 提取 YAML 代码块
+    const yamlMatch = output.match(/```yaml\n?([\s\S]*?)\n?```/) ||
+        output.match(/```\n?([\s\S]*?)\n?```/) ||
+        output.match(/(\|[\s\S]*?)(?:\n\n|$)/);
+    const yamlContent = yamlMatch?.[1] || output;
+    try {
+        const YAML = require('yaml');
+        const parsed = YAML.parse(yamlContent);
+        // 验证必要字段
+        if (!parsed.name || !parsed.nodes || !Array.isArray(parsed.nodes)) {
+            return null;
+        }
+        // Use WorkflowDefinitionSchema to apply defaults
+        const { WorkflowDefinitionSchema } = require('@ai-setting/roy-agent-core/env/workflow/types');
+        const definition = WorkflowDefinitionSchema.parse(parsed);
+        return definition;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * WorkflowAddCommand - Add a new workflow
+ */
+export const WorkflowAddCommand = {
+    command: 'add',
+    describe: '添加新的 Workflow（支持文件或自然语言描述）',
+    builder: (yargs) => yargs
+        .option('name', {
+        alias: 'n',
+        describe: 'Workflow 名称',
+        type: 'string',
+    })
+        .option('file', {
+        alias: 'f',
+        describe: 'Workflow 定义文件 (YAML/JSON)',
+        type: 'string',
+    })
+        .option('desc', {
+        alias: 'd',
+        describe: '自然语言描述（将使用 AI 生成 Workflow）',
+        type: 'string',
+    })
+        .option('description', {
+        describe: 'Workflow 描述（仅用于 --file 模式）',
+        type: 'string',
+    })
+        .option('tags', {
+        alias: 't',
+        describe: '标签（逗号分隔）',
+        type: 'string',
+    })
+        .option('task-id', {
+        alias: 'i',
+        describe: '关联任务 ID',
+        type: 'number',
+    })
+        .option('force', {
+        describe: '覆盖已存在的 Workflow',
+        type: 'boolean',
+        default: false,
+    })
+        .option('validate', {
+        describe: '保存前验证 Workflow',
+        type: 'boolean',
+        default: true,
+    })
+        .option('config', {
+        describe: '配置文件路径',
+        type: 'string',
+    }),
+    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 workflowComponent = env.getComponent('workflow');
+            if (!workflowComponent) {
+                output.error('WorkflowComponent not available');
+                process.exit(1);
+            }
+            const service = workflowComponent.getService();
+            let definition;
+            let workflowName;
+            // Mode 1: File input
+            if (a.file) {
+                const filePath = path.resolve(a.file);
+                if (!fs.existsSync(filePath)) {
+                    output.error(`File not found: ${filePath}`);
+                    process.exit(1);
+                }
+                const content = fs.readFileSync(filePath, 'utf-8');
+                definition = await parseWorkflowContent(content, filePath);
+                workflowName = a.name || definition.name || path.basename(filePath);
+                // Validate if requested
+                if (a.validate) {
+                    output.log(chalk.blue('🔍 Validating workflow...'));
+                    const validator = new WorkflowValidator();
+                    const result = validator.validate(definition);
+                    if (!result.valid) {
+                        output.error(`\n❌ Workflow validation FAILED (${result.errors.length} errors found)`);
+                        result.errors.forEach((error, i) => {
+                            output.error(`[Error ${i + 1}/${result.errors.length}]${error.nodeId ? ` Node "${error.nodeId}"` : ''}`);
+                            output.error(`  Type: ${error.type}`);
+                            output.error(`  Description: ${error.description}`);
+                            output.error(`  Fix: ${error.fix}\n`);
+                        });
+                        process.exit(1);
+                    }
+                    output.log(chalk.green('✅ Workflow validation passed\n'));
+                }
+            }
+            // Mode 2: Natural language description
+            else if (a.desc) {
+                output.log(chalk.blue('🤖 Generating workflow from description...\n'));
+                // Get AgentComponent
+                const agentComponent = env.getComponent('agent');
+                if (!agentComponent) {
+                    output.error('AgentComponent not available');
+                    process.exit(1);
+                }
+                // Auto-register workflow-extractor agent if not already registered
+                if (!agentComponent.getAgent('workflow-extractor')) {
+                    output.log(chalk.gray('Auto-registering workflow-extractor agent...'));
+                    const extractorConfig = createWorkflowExtractorAgent();
+                    agentComponent.registerAgent(extractorConfig.name, extractorConfig);
+                    output.log(chalk.green('✅ workflow-extractor agent registered\n'));
+                }
+                // Build prompt for workflow-extractor
+                const prompt = `## 任务
+请根据以下描述，构建一个可复用的 Workflow。
+使用迭代式流程：生成 YAML → validate 验证 → 修正错误 → 重复直到通过验证。
+
+## Workflow 描述
+${a.desc}
+
+## 重要提醒
+1. 先用 \`roy workflow nodes\` 查看可用的节点类型
+2. 生成的 YAML 必须通过 \`roy workflow validate --yaml "<yaml>"\` 验证
+3. 验证通过后才输出最终 YAML`;
+                // Run workflow-extractor agent
+                output.log(chalk.gray('Running workflow-extractor agent...'));
+                const result = await agentComponent.run('workflow-extractor', prompt);
+                const agentOutput = result.finalText || '';
+                // Parse YAML from agent output
+                definition = parseYamlFromAgentOutput(agentOutput);
+                if (definition === null) {
+                    output.error('Failed to parse workflow from agent output');
+                    output.log(chalk.gray('\nAgent output:\n' + agentOutput.slice(0, 500)));
+                    process.exit(1);
+                }
+                workflowName = a.name || definition.name;
+                // Validate the generated workflow
+                if (a.validate) {
+                    output.log(chalk.blue('\n🔍 Validating generated workflow...'));
+                    const validator = new WorkflowValidator();
+                    const result = validator.validate(definition);
+                    if (!result.valid) {
+                        output.error(`\n❌ Generated workflow validation FAILED (${result.errors.length} errors found)`);
+                        result.errors.forEach((error, i) => {
+                            output.error(`[Error ${i + 1}/${result.errors.length}]${error.nodeId ? ` Node "${error.nodeId}"` : ''}`);
+                            output.error(`  Type: ${error.type}`);
+                            output.error(`  Description: ${error.description}`);
+                            output.error(`  Fix: ${error.fix}\n`);
+                        });
+                        output.log(chalk.yellow('请修正描述后重新尝试，或使用 --file 选项直接提供 YAML'));
+                        process.exit(1);
+                    }
+                    output.log(chalk.green('✅ Generated workflow validation passed\n'));
+                }
+                // Show generated YAML
+                const yaml = await import('yaml');
+                output.log(chalk.gray('--- Generated YAML ---'));
+                output.log(yaml.stringify(definition));
+                output.log(chalk.gray('------------------------\n'));
+            }
+            else {
+                output.error('Please provide --file or --desc option');
+                output.error('Usage: roy workflow add --file <path> | --desc "<description>"');
+                process.exit(1);
+            }
+            // Parse tags
+            const tags = a.tags ? a.tags.split(',').map((t) => t.trim()) : undefined;
+            // Create workflow
+            const workflow = await service.createWorkflow(definition, {
+                tags,
+                taskId: a.taskId,
+                force: a.force,
+            });
+            output.log(renderWorkflowAdded(workflow));
+            // Show nodes summary
+            output.log(chalk.bold('\n📊 Nodes Summary:'));
+            output.log(renderNodesList(definition.nodes));
+            output.log(chalk.green(`\n✅ Workflow '${workflowName}' added successfully`));
+        }
+        catch (error) {
+            if (error.message?.includes('already exists') && !a.force) {
+                output.error(`Workflow already exists. Use --force to overwrite.`);
+                output.error(`Error: ${error.message}`);
+            }
+            else {
+                output.error(`Failed to add workflow: ${error}`);
+            }
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=add.js.map

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

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview Workflow Get Command
+ *
+ * Get workflow or run details
+ */
+import { CommandModule } from 'yargs';
+export interface WorkflowGetOptions {
+    identifier: string;
+    runId?: boolean;
+    includeNodes?: boolean;
+    includeRuns?: boolean;
+    json?: boolean;
+    yaml?: boolean;
+    config?: string;
+}
+/**
+ * WorkflowGetCommand - Get workflow or run details
+ */
+export declare const WorkflowGetCommand: CommandModule<object, WorkflowGetOptions>;
+//# sourceMappingURL=get.d.ts.map