@ai-setting/roy-agent-cli 1.0.0

package/src/commands/workflow/commands/get.ts

@@ -0,0 +1,193 @@
+/**
+ * @fileoverview Workflow Get Command
+ * 
+ * Get workflow or run details
+ */
+
+import { CommandModule } from 'yargs';
+import { EnvironmentService } from '../../../services/environment.service';
+import { OutputService } from '../../../services/output.service';
+import { renderWorkflowDetail, renderRunDetail, renderNodesList } from '../renderers';
+import chalk from 'chalk';
+import type { WorkflowService, SessionInfo } from '@ai-setting/roy-agent-core/env/workflow/service';
+import type { WorkflowRun } from '@ai-setting/roy-agent-core/env/workflow/types';
+
+export interface WorkflowGetOptions {
+  identifier: string;
+  runId?: boolean;
+  includeNodes?: boolean;
+  includeRuns?: boolean;
+  json?: boolean;
+  yaml?: boolean;
+  config?: string;
+}
+
+/**
+ * WorkflowGetCommand - Get workflow or run details
+ */
+export const WorkflowGetCommand: CommandModule<object, WorkflowGetOptions> = {
+  command: 'get <identifier>',
+  describe: '获取 Workflow 或 Run 详情',
+
+  builder: (yargs) =>
+    yargs
+      .positional('identifier', {
+        describe: 'Workflow 名称或 Run ID',
+        type: 'string',
+        demandOption: true,
+      })
+      .option('run-id', {
+        describe: '将 identifier 作为 Run ID 处理',
+        type: 'boolean',
+        default: false,
+      })
+      .option('include-nodes', {
+        describe: '显示节点详情',
+        type: 'boolean',
+        default: false,
+      })
+      .option('include-runs', {
+        describe: '包含运行历史',
+        type: 'boolean',
+        default: false,
+      })
+      .option('json', {
+        alias: 'j',
+        describe: 'JSON 格式输出',
+        type: 'boolean',
+        default: false,
+      })
+      .option('yaml', {
+        alias: 'y',
+        describe: 'YAML 格式输出',
+        type: 'boolean',
+        default: false,
+      })
+      .option('config', {
+        describe: '配置文件路径',
+        type: 'string',
+      }),
+
+  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 workflowComponent = env.getComponent('workflow') as any;
+
+      if (!workflowComponent) {
+        output.error('WorkflowComponent not available');
+        process.exit(1);
+      }
+
+      const service = workflowComponent.getService() as WorkflowService;
+
+      // Determine if this is a run ID
+      const isRunId = args.runId || args.identifier.startsWith('run_');
+
+      if (isRunId) {
+        // Get run details (using getSession since runs are now sessions)
+        const session: SessionInfo | null = await service.getSession(args.identifier);
+        if (!session) {
+          output.error(`Run not found: ${args.identifier}`);
+          process.exit(1);
+        }
+
+        const metadata = session.metadata;
+        if (args.json) {
+          output.json({
+            run: {
+              id: session.id,
+              workflowId: metadata.workflowId,
+              status: metadata.status,
+              input: metadata.input,
+              startedAt: session.createdAt?.toISOString(),
+            },
+          });
+        } else {
+          const run: WorkflowRun = {
+            id: session.id,
+            workflowId: (metadata as any).workflowId || '',
+            workflowName: metadata.workflowName,
+            status: metadata.status,
+            input: (metadata as any).input,
+            startedAt: session.createdAt,
+            debugMode: false,
+          };
+          output.log(renderRunDetail(run));
+        }
+      } else {
+        // Get workflow details
+        const workflow = service.getWorkflow(args.identifier);
+        if (!workflow) {
+          output.error(`Workflow not found: ${args.identifier}`);
+          process.exit(1);
+        }
+
+        // Get runs if requested (using listSessions since runs are now sessions)
+        let sessionRuns: SessionInfo[] = [];
+        if (args.includeRuns) {
+          sessionRuns = await service.listSessions({ limit: 5 });
+          // Filter runs for this workflow
+          sessionRuns = sessionRuns.filter(r => 
+            (r.metadata as any).workflowId === workflow.id || 
+            (r.metadata as any).workflowName === workflow.name
+          );
+        }
+
+        // Convert SessionInfo[] to WorkflowRun[] for renderer
+        const runs: WorkflowRun[] = sessionRuns.map(r => {
+          const m = r.metadata as any;
+          return {
+            id: r.id,
+            workflowId: m.workflowId || '',
+            workflowName: m.workflowName || workflow.name,
+            status: m.status,
+            startedAt: r.createdAt,
+            debugMode: false,
+          };
+        });
+
+        if (args.json) {
+          output.json({
+            workflow: {
+              id: workflow.id,
+              name: workflow.name,
+              version: workflow.version,
+              description: workflow.description,
+              definition: workflow.definition,
+              tags: workflow.tags,
+              createdAt: workflow.createdAt.toISOString(),
+              updatedAt: workflow.updatedAt.toISOString(),
+            },
+            runs: runs.map(r => ({
+              id: r.id,
+              status: r.status,
+              startedAt: r.startedAt?.toISOString(),
+              workflowId: r.workflowId,
+            })),
+          });
+        } else {
+          output.log(renderWorkflowDetail(workflow, { includeRuns: runs }));
+
+          // Show nodes if requested
+          if (args.includeNodes) {
+            output.log(chalk.bold('\n📋 All Nodes:'));
+            output.log(renderNodesList(workflow.definition.nodes));
+          }
+        }
+      }
+    } catch (error) {
+      output.error(`Failed to get workflow: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/workflow/commands/list.ts

@@ -0,0 +1,137 @@
+/**
+ * @fileoverview Workflow List Command
+ * 
+ * List all registered workflows
+ */
+
+import { CommandModule } from 'yargs';
+import { EnvironmentService } from '../../../services/environment.service';
+import { OutputService } from '../../../services/output.service';
+import { renderWorkflowList } from '../renderers';
+import chalk from 'chalk';
+import type { WorkflowService } from '@ai-setting/roy-agent-core/env/workflow/service';
+
+export interface WorkflowListOptions {
+  tag?: string;
+  taskId?: number;
+  search?: string;
+  limit?: number;
+  offset?: number;
+  json?: boolean;
+  yaml?: boolean;
+  config?: string;
+}
+
+/**
+ * WorkflowListCommand - List workflows
+ */
+export const WorkflowListCommand: CommandModule<object, WorkflowListOptions> = {
+  command: 'list',
+  describe: '列出所有已注册的 Workflow',
+
+  builder: (yargs) =>
+    yargs
+      .option('tag', {
+        alias: 't',
+        describe: '按标签筛选',
+        type: 'string',
+      })
+      .option('task-id', {
+        alias: 'i',
+        describe: '按关联任务 ID 筛选',
+        type: 'number',
+      })
+      .option('search', {
+        alias: 's',
+        describe: '搜索 description 和 tags（支持 AND/OR/NOT 语法）',
+        type: 'string',
+      })
+      .option('limit', {
+        alias: 'l',
+        describe: '返回数量限制',
+        type: 'number',
+        default: 50,
+      })
+      .option('offset', {
+        alias: 'o',
+        describe: '分页偏移',
+        type: 'number',
+        default: 0,
+      })
+      .option('json', {
+        alias: 'j',
+        describe: 'JSON 格式输出',
+        type: 'boolean',
+        default: false,
+      })
+      .option('yaml', {
+        alias: 'y',
+        describe: 'YAML 格式输出',
+        type: 'boolean',
+        default: false,
+      })
+      .option('config', {
+        describe: '配置文件路径',
+        type: 'string',
+      }),
+
+  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 workflowComponent = env.getComponent('workflow');
+
+      if (!workflowComponent) {
+        output.error('WorkflowComponent not available');
+        process.exit(1);
+      }
+
+      // 获取 WorkflowService
+      const service = (workflowComponent as any).workflowService as WorkflowService;
+      
+      if (!service) {
+        output.error('WorkflowService not initialized. Please run "roy workflow init" first.');
+        process.exit(1);
+      }
+      const workflows = service.listWorkflows({
+        tag: args.tag,
+        taskId: args.taskId,
+        search: args.search,
+        limit: args.limit,
+        offset: args.offset,
+      });
+
+      if (args.json) {
+        output.json({
+          workflows: workflows.map(w => ({
+            id: w.id,
+            name: w.name,
+            version: w.version,
+            description: w.description,
+            tags: w.tags,
+            taskId: w.metadata.taskId,
+            createdAt: w.createdAt.toISOString(),
+            updatedAt: w.updatedAt.toISOString(),
+          })),
+          total: workflows.length,
+        });
+      } else {
+        output.log(renderWorkflowList(workflows));
+        output.log(chalk.green(`\n✅ 共 ${workflows.length} 个 Workflow`));
+      }
+    } catch (error) {
+      output.error(`Failed to list workflows: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};