@ai-setting/roy-agent-cli 1.0.0

package/src/commands/workflow/commands/update.ts

@@ -0,0 +1,130 @@
+/**
+ * @fileoverview Workflow Update Command
+ * 
+ * Update an existing workflow
+ */
+
+import { CommandModule } from 'yargs';
+import { EnvironmentService } from '../../../services/environment.service';
+import { OutputService } from '../../../services/output.service';
+import { renderWorkflowUpdated } from '../renderers';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import type { WorkflowService } from '@ai-setting/roy-agent-core/env/workflow/service';
+
+export interface WorkflowUpdateOptions {
+  name: string;
+  file?: string;
+  description?: string;
+  tags?: string[];
+  taskId?: number;
+  config?: string;
+}
+
+/**
+ * WorkflowUpdateCommand - Update an existing workflow
+ */
+export const WorkflowUpdateCommand: CommandModule<object, object> = {
+  command: 'update <name>',
+  describe: '更新已存在的 Workflow',
+
+  builder: (yargs) =>
+    yargs
+      .positional('name', {
+        describe: 'Workflow 名称',
+        type: 'string',
+        demandOption: true,
+      })
+      .option('file', {
+        alias: 'f',
+        describe: 'Workflow 定义文件 (YAML/JSON)',
+        type: 'string',
+      })
+      .option('description', {
+        alias: 'd',
+        describe: '更新描述',
+        type: 'string',
+      })
+      .option('tags', {
+        alias: 't',
+        describe: '更新标签（逗号分隔）',
+        type: 'string',
+      })
+      .option('task-id', {
+        alias: 'i',
+        describe: '更新关联任务 ID',
+        type: 'number',
+      })
+      .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;
+
+      // Check if workflow exists
+      const existing = service.getWorkflow(a.name);
+      if (!existing) {
+        output.error(`Workflow not found: ${a.name}`);
+        process.exit(1);
+      }
+
+      // Prepare updates
+      const updates: any = {};
+
+      if (a.description !== undefined) {
+        updates.description = a.description;
+      }
+
+      if (a.taskId !== undefined) {
+        updates.metadata = { ...existing.metadata, taskId: a.taskId };
+      }
+
+      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');
+        const { definition } = await workflowComponent.parseWorkflowFile(content, filePath);
+        updates.definition = definition;
+      }
+
+      // Parse tags if provided
+      const tags = a.tags ? a.tags.split(',').map((t: string) => t.trim()) : undefined;
+
+      // Update workflow
+      const workflow = await service.updateWorkflow(a.name, updates, { tags });
+
+      output.log(renderWorkflowUpdated(workflow));
+      output.log(chalk.green(`\n✅ Workflow '${a.name}' updated successfully`));
+    } catch (error) {
+      output.error(`Failed to update workflow: ${error}`);
+      process.exit(1);
+    } finally {
+      await envService.dispose();
+    }
+  },
+};

package/src/commands/workflow/commands/validate.ts

@@ -0,0 +1,139 @@
+/**
+ * @fileoverview Workflow validate command
+ */
+
+import { CommandModule } from 'yargs';
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { WorkflowValidator } from '../validators/workflow-validator';
+import type { RawWorkflowDefinition, ValidationError } from '../validators/types';
+
+export interface WorkflowValidateOptions {
+  input?: string;
+  yaml?: string;
+  json?: boolean;
+}
+
+/**
+ * Parse workflow from various input formats
+ */
+async function parseWorkflowInput(input?: string, yamlStr?: string): Promise<RawWorkflowDefinition> {
+  // Helper to parse YAML
+  const parseYaml = async (content: string): Promise<RawWorkflowDefinition> => {
+    const YAML = await import('yaml');
+    return YAML.parse(content) as RawWorkflowDefinition;
+  };
+  
+  // From file path
+  if (input && !yamlStr) {
+    try {
+      const content = readFileSync(input, 'utf-8');
+      return await parseYaml(content);
+    } catch (error: any) {
+      throw new Error(`Failed to read file "${input}": ${error.message}`);
+    }
+  }
+  
+  // From --yaml flag
+  if (yamlStr) {
+    try {
+      return await parseYaml(yamlStr);
+    } catch (error: any) {
+      throw new Error(`Failed to parse YAML: ${error.message}`);
+    }
+  }
+  
+  // From workflow ID (requires database lookup)
+  if (input && !input.includes(':') && !input.includes('-')) {
+    // TODO: Load from database if needed
+    throw new Error('Workflow ID lookup not implemented yet. Please use file path or --yaml flag.');
+  }
+  
+  throw new Error('Please provide workflow input: file path, --yaml string, or workflow ID');
+}
+
+/**
+ * Render validation result
+ */
+function renderResult(result: ReturnType<WorkflowValidator['validate']>, options: WorkflowValidateOptions): void {
+  // JSON output
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  
+  // Text output
+  if (result.valid) {
+    console.log(chalk.green('\n✅ Workflow validation PASSED\n'));
+    console.log(chalk.bold(`Workflow: ${result.workflowName}`));
+    console.log(`Nodes: ${result.nodeCount}`);
+    
+    // List valid nodes
+    console.log('\nValid nodes:');
+    // Since we don't track valid nodes separately, we just show the count
+    console.log(chalk.green('  ✓ All nodes passed validation'));
+  } else {
+    console.log(chalk.red(`\n❌ Workflow validation FAILED (${result.errors.length} errors found)\n`));
+    
+    result.errors.forEach((error: ValidationError, index: number) => {
+      console.log(chalk.red(`[Error ${index + 1}/${result.errors.length}]${error.nodeId ? ` Node "${error.nodeId}"` : ''}`));
+      console.log(`  ${chalk.bold('Type:')} ${error.type}`);
+      console.log(`  ${chalk.bold('Description:')} ${error.description}`);
+      console.log(`  ${chalk.bold('Expected:')} ${error.expected}`);
+      console.log(`  ${chalk.bold('Actual:')} ${error.actual}`);
+      console.log(`  ${chalk.green('Fix:')} ${error.fix}`);
+      console.log();
+    });
+  }
+}
+
+/**
+ * WorkflowValidateCommand - Validate workflow YAML
+ */
+export const WorkflowValidateCommand: CommandModule<object, WorkflowValidateOptions> = {
+  command: 'validate [input]',
+  describe: 'Validate workflow YAML syntax and node configurations',
+  
+  builder: (yargs) =>
+    yargs
+      .positional('input', {
+        describe: 'Workflow file path or workflow ID',
+        type: 'string',
+      })
+      .option('yaml', {
+        describe: 'YAML content string (alternative to positional input)',
+        type: 'string',
+        alias: 'y',
+      })
+      .option('json', {
+        describe: 'Output in JSON format',
+        type: 'boolean',
+        alias: 'j',
+      }),
+  
+  async handler(args) {
+    const options = args as WorkflowValidateOptions;
+    
+    try {
+      // Parse input
+      const workflow = await parseWorkflowInput(options.input, options.yaml);
+      if (!workflow) {
+        console.error(chalk.red('Failed to parse workflow input'));
+        process.exit(1);
+      }
+      
+      // Validate
+      const validator = new WorkflowValidator();
+      const result = validator.validate(workflow);
+      
+      // Render result
+      renderResult(result, options);
+      
+      // Exit with appropriate code
+      process.exit(result.valid ? 0 : 1);
+    } catch (error: any) {
+      console.error(chalk.red(`\nError: ${error.message}`));
+      process.exit(1);
+    }
+  },
+};

package/src/commands/workflow/commands/workflow-cli.test.ts

@@ -0,0 +1,196 @@
+/**
+ * @fileoverview Workflow CLI Tests
+ * 
+ * Tests workflow CLI commands with taskId and search functionality.
+ */
+
+import { describe, it, expect } from 'bun:test';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { setTimeout as sleep } from 'timers/promises';
+
+// Get the project root
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '../../../../../..');
+const royBin = path.join(projectRoot, 'packages/cli/src/bin/roy.ts');
+
+// Helper function to run CLI command with proper timeout using Bun subprocess
+async function runCliCommand(args: string[], timeoutMs: number = 10000): Promise<{ stdout: string; stderr: string }> {
+  const cmd = `bun run ${royBin} ${args.join(' ')}`;
+  
+  // Create subprocess promise
+  const runProcess = async () => {
+    const proc = Bun.spawn({
+      cmd: ['bun', 'run', royBin, ...args],
+      cwd: projectRoot,
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+    
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    
+    const code = await proc.exited;
+    if (code !== 0 && code !== null) {
+      throw new Error(`Command exited with code ${code}: ${cmd}\nStderr: ${stderr}`);
+    }
+    
+    return { stdout, stderr };
+  };
+  
+  // Use Promise.race for timeout
+  return Promise.race([
+    runProcess(),
+    sleep(timeoutMs).then(() => {
+      throw new Error(`Command timed out after ${timeoutMs}ms: ${cmd}`);
+    }),
+  ]);
+}
+
+describe('Workflow CLI Commands', () => {
+  describe('workflow list --help', () => {
+    it('should show --task-id option', async () => {
+      const result = await runCliCommand(['workflow', 'list', '--help']);
+      
+      expect(result.stdout).toContain('--task-id');
+      expect(result.stdout).toContain('按关联任务 ID 筛选');
+    });
+
+    it('should show --search option', async () => {
+      const result = await runCliCommand(['workflow', 'list', '--help']);
+      
+      expect(result.stdout).toContain('--search');
+      expect(result.stdout).toContain('搜索 description 和 tags');
+    });
+  });
+
+  describe('workflow add --help', () => {
+    it('should show --task-id option', async () => {
+      const result = await runCliCommand(['workflow', 'add', '--help']);
+      
+      expect(result.stdout).toContain('--task-id');
+      expect(result.stdout).toContain('关联任务 ID');
+    });
+  });
+
+  describe('workflow update --help', () => {
+    it('should show --task-id option', async () => {
+      const result = await runCliCommand(['workflow', 'update', '--help']);
+      
+      expect(result.stdout).toContain('--task-id');
+      expect(result.stdout).toContain('更新关联任务 ID');
+    });
+  });
+});
+
+describe("workflow run CLI", () => {
+  describe("run --help", () => {
+    it("should show --session-id option for resume", async () => {
+      const result = await runCliCommand(['workflow', 'run', '--help']);
+      
+      expect(result.stdout).toContain('--session-id');
+      expect(result.stdout).toContain('-s');
+      expect(result.stdout).toContain('恢复运行');
+    });
+
+    it("should show --file option for file-based workflows", async () => {
+      const result = await runCliCommand(['workflow', 'run', '--help']);
+      
+      expect(result.stdout).toContain('--file');
+      expect(result.stdout).toContain('-f');
+      expect(result.stdout).toContain('文件路径');
+    });
+
+    it("should show --name option for custom registration", async () => {
+      const result = await runCliCommand(['workflow', 'run', '--help']);
+      
+      expect(result.stdout).toContain('--name');
+      expect(result.stdout).toContain('-n');
+      expect(result.stdout).toContain('注册');
+    });
+
+    it("should show --register-only option", async () => {
+      const result = await runCliCommand(['workflow', 'run', '--help']);
+      
+      expect(result.stdout).toContain('--register-only');
+      expect(result.stdout).toContain('-r');
+      expect(result.stdout).toContain('只注册不运行');
+    });
+
+    it("should show positional argument identifier", async () => {
+      const result = await runCliCommand(['workflow', 'run', '--help']);
+      
+      expect(result.stdout).toContain('<identifier>');
+      expect(result.stdout).toContain('Workflow 名称或定义文件路径');
+    });
+  });
+
+  // Note: Integration tests for actual run/resume functionality are skipped
+  // because they require:
+  // 1. A valid workflow to be registered in the system
+  // 2. Environment setup with proper configuration
+  // 3. Long execution time for workflow runs
+  // 
+  // These should be covered by E2E tests or integration tests with proper mocks.
+  
+  describe.skip("run with actual workflow", () => {
+    it("should create new session and run", async () => {
+      // TODO: This requires a registered workflow and proper environment
+      // Would test: roy workflow run <workflowName>
+      // Expected: creates session, runs workflow, returns result
+    });
+    
+    it("should validate session exists on resume", async () => {
+      // TODO: This requires a paused workflow session
+      // Would test: roy workflow run -s <sessionId> --input "response"
+      // Expected: validates session type is 'workflow', resumes execution
+    });
+  });
+});
+
+describe("workflow stop CLI", () => {
+  describe("stop --help", () => {
+    it("should show positional argument runId", async () => {
+      const result = await runCliCommand(['workflow', 'stop', '--help']);
+      
+      expect(result.stdout).toContain('<runId>');
+      expect(result.stdout).toContain('Run ID');
+    });
+
+    it("should show --config option", async () => {
+      const result = await runCliCommand(['workflow', 'stop', '--help']);
+      
+      expect(result.stdout).toContain('--config');
+      expect(result.stdout).toContain('配置文件路径');
+    });
+  });
+
+  // Note: Testing actual stop functionality requires a running/paused workflow session.
+  // This should be covered by E2E tests with proper setup.
+  
+  describe.skip("stop with actual run", () => {
+    it("should call engine.stop for running session", async () => {
+      // TODO: This requires a running workflow session
+      // Would test: roy workflow stop <runId>
+      // Expected: calls service.stopRun(runId), confirms stop
+    });
+    
+    it("should call engine.stop for paused session", async () => {
+      // TODO: This requires a paused workflow session
+      // Would test: roy workflow stop <sessionId>
+      // Expected: calls service.stopRun(sessionId), confirms stop
+    });
+
+    it("should error when session not found", async () => {
+      // TODO: This requires mocking the service to return null for getSession
+      // Expected: exits with error "Run not found"
+    });
+    
+    it("should error when session not in stoppable state", async () => {
+      // TODO: This requires a completed/failed session
+      // Expected: exits with error "Cannot stop run in status: completed"
+    });
+  });
+});

package/src/commands/workflow/index.ts

@@ -0,0 +1,65 @@
+/**
+ * @fileoverview Workflow Command - Main entry point
+ * 
+ * Workflow DAG management and execution CLI commands
+ * 
+ * Note: Resume functionality is unified into `workflow run -s <sessionId>`.
+ * Use `workflow run -s <sessionId> --input "response"` to resume a paused workflow.
+ */
+
+import { CommandModule } from 'yargs';
+import { WorkflowListCommand } from './commands/list';
+import { WorkflowAddCommand } from './commands/add';
+import { WorkflowGetCommand } from './commands/get';
+import { WorkflowUpdateCommand } from './commands/update';
+import { WorkflowRemoveCommand } from './commands/remove';
+import { WorkflowRunCommand } from './commands/run';
+import { WorkflowStopCommand } from './commands/stop';
+import { WorkflowStatusCommand } from './commands/status';
+import { WorkflowNodesCommand } from './commands/nodes';
+import { WorkflowValidateCommand } from './commands/validate';
+
+export interface WorkflowOptions {
+  command?: string;
+}
+
+/**
+ * WorkflowCommand - Workflow DAG management
+ */
+export const WorkflowCommand: CommandModule<object, WorkflowOptions> = {
+  command: 'workflow',
+  describe: 'Workflow DAG management and execution - create, run, and monitor workflows',
+
+  builder: (yargs) =>
+    yargs
+      .command(WorkflowListCommand)
+      .command(WorkflowAddCommand)
+      .command(WorkflowNodesCommand)
+      .command(WorkflowValidateCommand)
+      .command(WorkflowGetCommand)
+      .command(WorkflowUpdateCommand)
+      .command(WorkflowRemoveCommand)
+      .command(WorkflowRunCommand)
+      .command(WorkflowStopCommand)
+      .command(WorkflowStatusCommand)
+      .demandCommand(1, '请指定子命令：list、add、validate、nodes、get、update、remove、run、stop、status\n\nResume: 使用 `workflow run -s <sessionId>` 恢复暂停的工作流')
+      .help(),
+
+  handler() {
+    // Default to help (handled by yargs demandCommand)
+  },
+};
+
+// Export subcommands
+export {
+  WorkflowListCommand,
+  WorkflowAddCommand,
+  WorkflowGetCommand,
+  WorkflowUpdateCommand,
+  WorkflowRemoveCommand,
+  WorkflowRunCommand,
+  WorkflowStopCommand,
+  WorkflowStatusCommand,
+  WorkflowNodesCommand,
+  WorkflowValidateCommand,
+};