@ai-setting/roy-agent-cli 1.0.0

package/src/commands/tools/list.ts

@@ -0,0 +1,107 @@
+/**
+ * @fileoverview Tools List Command
+ * 
+ * 命令：roy tools list
+ */
+
+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";
+
+interface ListOptions {
+  json?: boolean;
+  quiet?: boolean;
+  config?: string;
+}
+
+export const ListCommand: CommandModule<object, ListOptions> = {
+  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") as ToolComponent | undefined;
+
+      if (!toolComponent) {
+        output.error("ToolComponent not available");
+        process.exit(1);
+      }
+
+      const tools = toolComponent.listTools();
+
+      if (args.json) {
+        output.json({
+          tools: tools.map((t: Tool) => ({
+            name: t.name,
+            description: t.description,
+            category: t.metadata?.category,
+          })),
+          count: tools.length,
+        });
+      } else if (args.quiet) {
+        tools.forEach((t: Tool) => output.log(t.name));
+      } else {
+        // 表格输出
+        const header = [
+          chalk.bold("Name"),
+          chalk.bold("Description"),
+          chalk.bold("Category"),
+        ].join(" | ");
+
+        const rows = tools.map((t: Tool) => {
+          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();
+    }
+  },
+};

package/src/commands/tools/shared/index.ts

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

package/src/commands/tools/shared/schema-helper.ts

@@ -0,0 +1,111 @@
+/**
+ * @fileoverview Schema Helper
+ * 
+ * 提供 Zod schema 解析和工具函数，用于从 tool 的参数 schema
+ * 提取参数信息、验证必需参数、生成 yargs 选项等。
+ */
+
+import { z, ZodType } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+/**
+ * 参数信息
+ */
+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 function extractParameters(schema: any): ParameterInfo[] {
+  const jsonSchema = zodToJsonSchema(schema) as Record<string, unknown>;
+  const properties = (jsonSchema.properties || {}) as Record<string, unknown>;
+  const required = ((jsonSchema.required as string[]) || []);
+
+  return Object.entries(properties).map(([name, prop]) => ({
+    name,
+    type: (prop as any).type || "any",
+    description: (prop as any).description || "",
+    required: required.includes(name),
+    default: (prop as any).default,
+  }));
+}
+
+/**
+ * 检查参数是否完整
+ * 
+ * @param params - 参数信息数组
+ * @param args - 用户提供的参数
+ * @returns 验证结果
+ */
+export function validateRequiredParams(
+  params: ParameterInfo[],
+  args: Record<string, unknown>
+): ValidateResult {
+  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: ParameterInfo[]): Record<string, any> {
+  const options: Record<string, any> = {};
+
+  for (const param of params) {
+    // 映射类型到 yargs 类型
+    let yargsType: "string" | "number" | "boolean";
+    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;
+}

package/src/commands/workflow/commands/add.ts

@@ -0,0 +1,315 @@
+/**
+ * @fileoverview Workflow Add Command
+ * 
+ * Add a new workflow from file or natural language description
+ */
+
+import { CommandModule } from 'yargs';
+import { EnvironmentService } from '../../../services/environment.service';
+import { OutputService } from '../../../services/output.service';
+import { renderWorkflowAdded, renderNodesList } from '../renderers';
+import { WorkflowValidator } from '../validators/workflow-validator';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import type { WorkflowService, WorkflowDefinition } from '@ai-setting/roy-agent-core/env/workflow/service';
+import type { AgentComponent } from '@ai-setting/roy-agent-core';
+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: string, filename: string): Promise<WorkflowDefinition> {
+  const isYaml = filename.endsWith('.yaml') || filename.endsWith('.yml');
+  const isJson = filename.endsWith('.json');
+  
+  let definition: WorkflowDefinition;
+  
+  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: string): WorkflowDefinition | null {
+  // 提取 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;
+  }
+}
+
+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 const WorkflowAddCommand: CommandModule<object, object> = {
+  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 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 workflowComponent = env.getComponent('workflow') as any;
+
+      if (!workflowComponent) {
+        output.error('WorkflowComponent not available');
+        process.exit(1);
+      }
+
+      const service = workflowComponent.getService() as WorkflowService;
+
+      let definition: WorkflowDefinition | null;
+      let workflowName: string;
+
+      // 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 as string || 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') as AgentComponent;
+        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 as string;
+        
+        // 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: string) => 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: any) {
+      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();
+    }
+  },
+};