@ai-setting/roy-agent-cli 1.0.0

package/src/commands/workflow/renderers.ts

@@ -0,0 +1,358 @@
+/**
+ * @fileoverview Workflow CLI Renderers
+ * 
+ * Output formatters for workflow CLI commands
+ */
+
+import chalk from 'chalk';
+import type { Workflow, WorkflowRun } from '@ai-setting/roy-agent-core/env/workflow/types';
+
+/**
+ * 计算字符串的视觉宽度（中文字符占2格）
+ */
+function visualWidth(str: string): number {
+  let width = 0;
+  for (const char of str) {
+    if (char.charCodeAt(0) > 255) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+
+/**
+ * 按视觉宽度截断字符串
+ */
+function truncateVisual(str: string, maxWidth: number): string {
+  if (!str) return '-';
+  let result = '';
+  let width = 0;
+  for (const char of str) {
+    const charWidth = char.charCodeAt(0) > 255 ? 2 : 1;
+    if (width + charWidth > maxWidth) break;
+    result += char;
+    width += charWidth;
+  }
+  return result || '-';
+}
+
+/**
+ * 格式化时间
+ */
+function formatDate(date: Date | string | undefined): string {
+  if (!date) return '-';
+  const d = typeof date === 'string' ? new Date(date) : date;
+  return d.toLocaleString('zh-CN');
+}
+
+/**
+ * 格式化时长
+ */
+function formatDuration(ms: number | undefined): string {
+  if (ms === undefined || ms === null) return '-';
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  if (ms < 3600000) return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+  return `${Math.floor(ms / 3600000)}h ${Math.floor((ms % 3600000) / 60000)}m`;
+}
+
+/**
+ * 获取状态颜色
+ */
+function statusColor(status: string): typeof chalk.green {
+  switch (status) {
+    case 'completed':
+      return chalk.green;
+    case 'running':
+    case 'idle':
+      return chalk.blue;
+    case 'paused':
+      return chalk.yellow;
+    case 'failed':
+      return chalk.red;
+    case 'stopped':
+      return chalk.gray;
+    default:
+      return chalk.white;
+  }
+}
+
+/**
+ * 渲染 Workflow 列表
+ */
+export function renderWorkflowList(workflows: Workflow[], options?: { json?: boolean }): string {
+  if (options?.json) {
+    return JSON.stringify({
+      workflows: workflows.map(w => ({
+        id: w.id,
+        name: w.name,
+        version: w.version,
+        description: w.description,
+        tags: w.tags,
+        createdAt: w.createdAt.toISOString(),
+        updatedAt: w.updatedAt.toISOString(),
+      })),
+      total: workflows.length,
+    }, null, 2);
+  }
+
+  if (workflows.length === 0) {
+    return chalk.yellow('No workflows found');
+  }
+
+  const NAME_WIDTH = 30;
+  const VERSION_WIDTH = 10;
+  const TAGS_WIDTH = 20;
+  const UPDATED_WIDTH = 20;
+  const GAP = '  ';
+
+  const headerLine = [
+    chalk.bold('NAME'.padEnd(NAME_WIDTH)),
+    chalk.bold('VER'.padEnd(VERSION_WIDTH)),
+    chalk.bold('TAGS'.padEnd(TAGS_WIDTH)),
+    chalk.bold('UPDATED'),
+  ].join(GAP);
+
+  const sepLine = '─'.repeat(NAME_WIDTH + VERSION_WIDTH + TAGS_WIDTH + UPDATED_WIDTH + GAP.length * 3);
+
+  const rows = workflows.map(w => {
+    const name = truncateVisual(w.name, NAME_WIDTH).padEnd(NAME_WIDTH);
+    const version = w.version.padEnd(VERSION_WIDTH);
+    const tags = truncateVisual(w.tags.join(', '), TAGS_WIDTH).padEnd(TAGS_WIDTH);
+    const updated = formatDate(w.updatedAt);
+    return `${name}${GAP}${version}${GAP}${tags}${GAP}${updated}`;
+  });
+
+  return [headerLine, sepLine, ...rows].join('\n');
+}
+
+/**
+ * 渲染 Workflow 详情
+ */
+export function renderWorkflowDetail(workflow: Workflow, options?: { includeRuns?: WorkflowRun[] }): string {
+  const lines: string[] = [];
+
+  lines.push(chalk.bold('\n📋 Workflow Details\n'));
+  lines.push(`  ${chalk.cyan('ID:')}          ${workflow.id}`);
+  lines.push(`  ${chalk.cyan('Name:')}        ${workflow.name}`);
+  lines.push(`  ${chalk.cyan('Version:')}     ${workflow.version}`);
+  lines.push(`  ${chalk.cyan('Description:')} ${workflow.description || '-'}`);
+  lines.push(`  ${chalk.cyan('Tags:')}        ${workflow.tags.join(', ') || '-'}`);
+  lines.push(`  ${chalk.cyan('Created:')}     ${formatDate(workflow.createdAt)}`);
+  lines.push(`  ${chalk.cyan('Updated:')}     ${formatDate(workflow.updatedAt)}`);
+
+  // Nodes summary
+  const nodeCount = workflow.definition.nodes.length;
+  lines.push(chalk.bold('\n📊 Nodes Summary\n'));
+  lines.push(`  Total: ${nodeCount} nodes`);
+
+  // Group nodes by type
+  const nodesByType: Record<string, number> = {};
+  for (const node of workflow.definition.nodes) {
+    nodesByType[node.type] = (nodesByType[node.type] || 0) + 1;
+  }
+  for (const [type, count] of Object.entries(nodesByType)) {
+    lines.push(`    - ${type}: ${count}`);
+  }
+
+  // Config summary
+  if (workflow.definition.config) {
+    lines.push(chalk.bold('\n⚙️  Configuration\n'));
+    if (workflow.definition.config.parallel_limit !== undefined) {
+      lines.push(`  parallel_limit: ${workflow.definition.config.parallel_limit}`);
+    }
+    if (workflow.definition.config.timeout !== undefined) {
+      lines.push(`  timeout: ${workflow.definition.config.timeout}ms`);
+    }
+    if (workflow.definition.config.debug !== undefined) {
+      lines.push(`  debug: ${workflow.definition.config.debug}`);
+    }
+  }
+
+  // Runs summary (if included)
+  if (options?.includeRuns && options.includeRuns.length > 0) {
+    lines.push(chalk.bold('\n📜 Recent Runs\n'));
+    lines.push(renderRunsList(options.includeRuns.slice(0, 5)));
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * 渲染 Runs 列表
+ */
+export function renderRunsList(runs: WorkflowRun[], options?: { json?: boolean }): string {
+  if (options?.json) {
+    return JSON.stringify({
+      runs: runs.map(r => ({
+        id: r.id,
+        workflowId: r.workflowId,
+        status: r.status,
+        startedAt: r.startedAt?.toISOString(),
+        completedAt: r.completedAt?.toISOString(),
+        durationMs: r.durationMs,
+        error: r.error,
+      })),
+      total: runs.length,
+    }, null, 2);
+  }
+
+  if (runs.length === 0) {
+    return chalk.yellow('No runs found');
+  }
+
+  const ID_WIDTH = 20;
+  const STATUS_WIDTH = 12;
+  const DURATION_WIDTH = 12;
+  const UPDATED_WIDTH = 20;
+  const GAP = '  ';
+
+  const headerLine = [
+    chalk.bold('RUN ID'.padEnd(ID_WIDTH)),
+    chalk.bold('STATUS'.padEnd(STATUS_WIDTH)),
+    chalk.bold('DURATION'.padEnd(DURATION_WIDTH)),
+    chalk.bold('STARTED'),
+  ].join(GAP);
+
+  const sepLine = '─'.repeat(ID_WIDTH + STATUS_WIDTH + DURATION_WIDTH + UPDATED_WIDTH + GAP.length * 3);
+
+  const rows = runs.map(r => {
+    const id = truncateVisual(r.id, ID_WIDTH).padEnd(ID_WIDTH);
+    const status = statusColor(r.status)(r.status.padEnd(STATUS_WIDTH));
+    const duration = formatDuration(r.durationMs).padEnd(DURATION_WIDTH);
+    const started = formatDate(r.startedAt);
+    return `${id}${GAP}${status}${GAP}${duration}${GAP}${started}`;
+  });
+
+  return [headerLine, sepLine, ...rows].join('\n');
+}
+
+/**
+ * 渲染 Run 详情
+ */
+export function renderRunDetail(run: WorkflowRun): string {
+  const lines: string[] = [];
+
+  lines.push(chalk.bold('\n🏃 Run Details\n'));
+  lines.push(`  ${chalk.cyan('Run ID:')}     ${run.id}`);
+  lines.push(`  ${chalk.cyan('Workflow:')}  ${run.workflowId}`);
+  lines.push(`  ${chalk.cyan('Status:')}    ${statusColor(run.status)(run.status)}`);
+  lines.push(`  ${chalk.cyan('Started:')}   ${formatDate(run.startedAt)}`);
+  
+  if (run.pausedAt) {
+    lines.push(`  ${chalk.cyan('Paused:')}    ${formatDate(run.pausedAt)}`);
+  }
+  if (run.resumedAt) {
+    lines.push(`  ${chalk.cyan('Resumed:')}   ${formatDate(run.resumedAt)}`);
+  }
+  if (run.stoppedAt) {
+    lines.push(`  ${chalk.cyan('Stopped:')}   ${formatDate(run.stoppedAt)}`);
+  }
+  if (run.completedAt) {
+    lines.push(`  ${chalk.cyan('Completed:')} ${formatDate(run.completedAt)}`);
+  }
+  
+  lines.push(`  ${chalk.cyan('Duration:')}  ${formatDuration(run.durationMs)}`);
+
+  if (run.error) {
+    lines.push(chalk.bold('\n❌ Error\n'));
+    lines.push(`  ${chalk.red(run.error)}`);
+  }
+
+  if (run.output) {
+    lines.push(chalk.bold('\n📤 Output\n'));
+    lines.push('  ' + JSON.stringify(run.output, null, 2).split('\n').join('\n  '));
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * 渲染工作流已添加成功
+ */
+export function renderWorkflowAdded(workflow: Workflow): string {
+  return chalk.green(`\n✅ Workflow '${workflow.name}' added successfully\n`) +
+    `   ID: ${workflow.id}\n` +
+    `   Version: ${workflow.version}\n`;
+}
+
+/**
+ * 渲染工作流已更新成功
+ */
+export function renderWorkflowUpdated(workflow: Workflow): string {
+  return chalk.green(`\n✅ Workflow '${workflow.name}' updated successfully\n`) +
+    `   ID: ${workflow.id}\n`;
+}
+
+/**
+ * 渲染工作流已删除成功
+ */
+export function renderWorkflowDeleted(name: string): string {
+  return chalk.green(`\n✅ Workflow '${name}' deleted successfully\n`);
+}
+
+/**
+ * 渲染工作流运行结果
+ */
+export function renderRunResult(result: { runId: string; status: string; output?: any; error?: string; durationMs?: number }): string {
+  const lines: string[] = [];
+
+  if (result.status === 'completed') {
+    lines.push(chalk.green('\n✅ Workflow completed successfully'));
+  } else if (result.status === 'failed') {
+    lines.push(chalk.red('\n❌ Workflow failed'));
+  } else if (result.status === 'stopped') {
+    lines.push(chalk.yellow('\n⚠️  Workflow stopped'));
+  } else {
+    lines.push(chalk.blue(`\n🔄 Workflow ${result.status}`));
+  }
+
+  lines.push(`   Run ID: ${result.runId}`);
+  
+  if (result.durationMs) {
+    lines.push(`   Duration: ${formatDuration(result.durationMs)}`);
+  }
+
+  if (result.error) {
+    lines.push(chalk.red(`\n   Error: ${result.error}`));
+  }
+
+  if (result.output) {
+    lines.push(chalk.bold('\n📤 Output:'));
+    lines.push(JSON.stringify(result.output, null, 2));
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * 渲染节点列表
+ */
+export function renderNodesList(nodes: Array<{ id?: string; type?: string; name?: string; depends_on?: string[] }>): string {
+  const ID_WIDTH = 25;
+  const TYPE_WIDTH = 12;
+  const NAME_WIDTH = 20;
+  const DEPS_WIDTH = 20;
+  const GAP = '  ';
+
+  const headerLine = [
+    chalk.bold('NODE ID'.padEnd(ID_WIDTH)),
+    chalk.bold('TYPE'.padEnd(TYPE_WIDTH)),
+    chalk.bold('NAME'.padEnd(NAME_WIDTH)),
+    chalk.bold('DEPENDS ON'),
+  ].join(GAP);
+
+  const sepLine = '─'.repeat(ID_WIDTH + TYPE_WIDTH + NAME_WIDTH + DEPS_WIDTH + GAP.length * 3);
+
+  const rows = nodes.map(n => {
+    const id = truncateVisual(n.id || '-', ID_WIDTH).padEnd(ID_WIDTH);
+    const type = (n.type || '-').padEnd(TYPE_WIDTH);
+    const name = truncateVisual(n.name || '-', NAME_WIDTH).padEnd(NAME_WIDTH);
+    const deps = n.depends_on?.join(', ') || '-';
+    return `${id}${GAP}${type}${GAP}${name}${GAP}${deps}`;
+  });
+
+  return [headerLine, sepLine, ...rows].join('\n');
+}

package/src/commands/workflow/validators/index.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Workflow validators exports
+ */
+
+export * from './types';
+export * from './node-validator';
+export * from './workflow-validator';
+export * from './node-validator-factory';

package/src/commands/workflow/validators/node-validator-factory.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Node validator factory
+ */
+
+import type { NodeValidator } from './node-validator';
+import { ToolNodeValidator } from './nodes/tool-node-validator';
+import { SkillNodeValidator } from './nodes/skill-node-validator';
+import { AgentNodeValidator } from './nodes/agent-node-validator';
+import { WorkflowNodeValidator } from './nodes/workflow-node-validator';
+import { ConditionNodeValidator } from './nodes/condition-node-validator';
+import { MergeNodeValidator } from './nodes/merge-node-validator';
+import { DecoratorNodeValidator } from './nodes/decorator-node-validator';
+
+/**
+ * Registry of node validators
+ */
+const validators: Map<string, NodeValidator> = new Map();
+
+// Register built-in validators
+validators.set('tool', new ToolNodeValidator());
+validators.set('skill', new SkillNodeValidator());
+validators.set('agent', new AgentNodeValidator());
+validators.set('workflow', new WorkflowNodeValidator());
+validators.set('condition', new ConditionNodeValidator());
+validators.set('merge', new MergeNodeValidator());
+validators.set('decorator', new DecoratorNodeValidator());
+
+/**
+ * Get validator for a node type
+ */
+export function getNodeValidator(type: string): NodeValidator | null {
+  return validators.get(type) || null;
+}
+
+/**
+ * Get all supported node types
+ */
+export function getSupportedNodeTypes(): string[] {
+  return Array.from(validators.keys());
+}

package/src/commands/workflow/validators/node-validator.ts

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview Node validator base class and interface
+ */
+
+import { ValidationErrorType, type ValidationError, type RawNodeDefinition } from './types';
+
+/**
+ * Base interface for node validators
+ */
+export interface NodeValidator {
+  /** Node type this validator handles */
+  readonly nodeType: string;
+  
+  /**
+   * Validate a node of this type
+   * @param node Raw node definition from YAML
+   * @returns List of validation errors (empty if valid)
+   */
+  validate(node: RawNodeDefinition): ValidationError[];
+}
+
+/**
+ * Base class for node validators with common utilities
+ */
+export abstract class BaseNodeValidator implements NodeValidator {
+  abstract readonly nodeType: string;
+  
+  /**
+   * Get required field names for this node type
+   */
+  protected abstract getRequiredFields(): string[];
+  
+  validate(node: RawNodeDefinition): ValidationError[] {
+    const errors: ValidationError[] = [];
+    
+    // Check node ID
+    if (!node.id || typeof node.id !== 'string' || !node.id.trim()) {
+      errors.push({
+        type: ValidationErrorType.MISSING_REQUIRED_FIELD,
+        description: 'Node ID is missing or empty',
+        expected: 'id must be a non-empty string',
+        actual: String(node.id),
+        fix: 'Add an "id" field to the node, e.g., id: "node-1"',
+        nodeId: undefined,
+      });
+    }
+    
+    // Check required fields
+    for (const field of this.getRequiredFields()) {
+      const value = node.config?.[field];
+      if (value === undefined || value === null || value === '') {
+        errors.push({
+          type: ValidationErrorType.MISSING_REQUIRED_FIELD,
+          description: `Required field "${field}" is missing`,
+          expected: `${field} must be a non-empty value`,
+          actual: String(value),
+          fix: `Add "${field}: <value>" to node config`,
+          nodeId: node.id,
+        });
+      }
+    }
+    
+    // Add type-specific validation
+    errors.push(...this.validateTypeSpecific(node));
+    
+    return errors;
+  }
+  
+  /**
+   * Override in subclasses for type-specific validation
+   */
+  protected validateTypeSpecific(_node: RawNodeDefinition): ValidationError[] {
+    return [];
+  }
+  
+  /**
+   * Helper: Check field type
+   */
+  protected checkFieldType(
+    node: RawNodeDefinition,
+    field: string,
+    expectedType: string,
+    expectedFormat?: string
+  ): ValidationError | null {
+    const value = node.config?.[field];
+    if (value === undefined || value === null) return null;
+    
+    let isValid = false;
+    switch (expectedType) {
+      case 'string':
+        isValid = typeof value === 'string';
+        break;
+      case 'number':
+        isValid = typeof value === 'number' && value > 0;
+        break;
+      case 'boolean':
+        isValid = typeof value === 'boolean';
+        break;
+      case 'object':
+        isValid = typeof value === 'object' && value !== null && !Array.isArray(value);
+        break;
+      case 'array':
+        isValid = Array.isArray(value);
+        break;
+      case 'string|boolean':
+        isValid = typeof value === 'string' || typeof value === 'boolean';
+        break;
+    }
+    
+    if (!isValid) {
+      return {
+        type: ValidationErrorType.INVALID_FIELD_TYPE,
+        description: `Field "${field}" has invalid type`,
+        expected: expectedFormat || `${expectedType}`,
+        actual: typeof value === 'object' ? JSON.stringify(value) : String(value),
+        fix: expectedFormat?.includes('non-empty') && typeof value === 'string' && !value.trim()
+          ? `Remove quotes or whitespace from ${field} value`
+          : `Check ${field} type: expected ${expectedFormat || expectedType}`,
+        nodeId: node.id,
+      };
+    }
+    
+    return null;
+  }
+}

package/src/commands/workflow/validators/nodes/agent-node-validator.ts

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Agent node validator
+ */
+
+import { BaseNodeValidator } from '../node-validator';
+import { ValidationErrorType } from '../types';
+import type { RawNodeDefinition, ValidationError } from '../types';
+
+export class AgentNodeValidator extends BaseNodeValidator {
+  readonly nodeType = 'agent';
+  
+  protected getRequiredFields(): string[] {
+    return ['agent_type', 'prompt'];
+  }
+  
+  protected validateTypeSpecific(node: RawNodeDefinition): ValidationError[] {
+    const errors: ValidationError[] = [];
+    
+    const agentType = node.config?.agent_type;
+    if (agentType !== undefined && typeof agentType !== 'string') {
+      errors.push({
+        type: ValidationErrorType.INVALID_FIELD_TYPE,
+        description: 'Field "agent_type" has invalid type',
+        expected: 'agent_type must be a string (e.g., "general", "research")',
+        actual: `typeof agent_type is "${typeof agentType}"`,
+        fix: `Change agent_type value to a string: agent_type: "${String(agentType)}"`,
+        nodeId: node.id,
+      });
+    }
+    
+    const prompt = node.config?.prompt;
+    if (prompt !== undefined && typeof prompt !== 'string') {
+      errors.push({
+        type: ValidationErrorType.INVALID_FIELD_TYPE,
+        description: 'Field "prompt" has invalid type',
+        expected: 'prompt must be a string',
+        actual: `typeof prompt is "${typeof prompt}"`,
+        fix: `Change prompt value to a string`,
+        nodeId: node.id,
+      });
+    }
+    
+    // Check options if present
+    const options = node.config?.options;
+    if (options !== undefined && (typeof options !== 'object' || options === null || Array.isArray(options))) {
+      errors.push({
+        type: ValidationErrorType.INVALID_FIELD_TYPE,
+        description: 'Field "options" has invalid type',
+        expected: 'options must be an object',
+        actual: Array.isArray(options) ? 'array' : typeof options,
+        fix: 'Change options to an object: options: { timeout: 60000 }',
+        nodeId: node.id,
+      });
+    }
+    
+    return errors;
+  }
+}

package/src/commands/workflow/validators/nodes/condition-node-validator.ts

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview Condition node validator
+ */
+
+import { BaseNodeValidator } from '../node-validator';
+import { ValidationErrorType } from '../types';
+import type { RawNodeDefinition, ValidationError } from '../types';
+
+export class ConditionNodeValidator extends BaseNodeValidator {
+  readonly nodeType = 'condition';
+  
+  protected getRequiredFields(): string[] {
+    // No required fields for condition node
+    return [];
+  }
+  
+  protected validateTypeSpecific(node: RawNodeDefinition): ValidationError[] {
+    const errors: ValidationError[] = [];
+    
+    const condition = node.config?.condition;
+    if (condition !== undefined && typeof condition !== 'string' && typeof condition !== 'boolean') {
+      errors.push({
+        type: ValidationErrorType.INVALID_FIELD_TYPE,
+        description: 'Field "condition" has invalid type',
+        expected: 'condition must be a string or boolean',
+        actual: typeof condition,
+        fix: 'Change condition to a string (template) or boolean value',
+        nodeId: node.id,
+      });
+    }
+    
+    return errors;
+  }
+}

package/src/commands/workflow/validators/nodes/decorator-node-validator.ts

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview Decorator node validator
+ */
+
+import { BaseNodeValidator } from '../node-validator';
+import { ValidationErrorType } from '../types';
+import type { RawNodeDefinition, ValidationError } from '../types';
+
+export class DecoratorNodeValidator extends BaseNodeValidator {
+  readonly nodeType = 'decorator';
+  
+  protected getRequiredFields(): string[] {
+    return ['_methodName', '_instance'];
+  }
+  
+  protected validateTypeSpecific(node: RawNodeDefinition): ValidationError[] {
+    const errors: ValidationError[] = [];
+    
+    const methodName = node.config?._methodName;
+    if (methodName !== undefined && typeof methodName !== 'string') {
+      errors.push({
+        type: ValidationErrorType.INVALID_FIELD_TYPE,
+        description: 'Field "_methodName" has invalid type',
+        expected: '_methodName must be a string',
+        actual: typeof methodName,
+        fix: `Change _methodName value to a string: _methodName: "${String(methodName)}"`,
+        nodeId: node.id,
+      });
+    }
+    
+    const instance = node.config?._instance;
+    if (instance !== undefined && typeof instance !== 'string') {
+      errors.push({
+        type: ValidationErrorType.INVALID_FIELD_TYPE,
+        description: 'Field "_instance" has invalid type',
+        expected: '_instance must be a string (template reference)',
+        actual: typeof instance,
+        fix: 'Change _instance to a template string: _instance: "{{input.instance}}"',
+        nodeId: node.id,
+      });
+    }
+    
+    return errors;
+  }
+}