@ai-setting/roy-agent-core 1.0.0

package/src/env/workflow/nodes/condition-node.ts

@@ -0,0 +1,200 @@
+/**
+ * @fileoverview ConditionNode - Workflow condition node
+ * 
+ * Evaluates a condition and decides whether to proceed or skip.
+ * 
+ * Input can contain template strings like {{nodeId.output.path}} that will be
+ * resolved from previousOutputs.
+ */
+
+import { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';
+
+/**
+ * ConditionNode evaluates a condition and returns the result.
+ * 
+ * The condition can be:
+ * - A boolean value
+ * - A template expression that evaluates to a boolean
+ * - A template reference to a previous node's output
+ * 
+ * Usage in workflow:
+ * ```yaml
+ * nodes:
+ *   - id: check-tests-pass
+ *     type: condition
+ *     config:
+ *       condition: "{{run-unit-tests.success}}"
+ *     depends_on:
+ *       - run-unit-tests
+ * ```
+ */
+export class ConditionNode implements Node {
+  readonly type = 'condition';
+  readonly id: string;
+  
+  constructor(
+    private definition: NodeDefinition,
+  ) {
+    this.id = definition.id;
+  }
+  
+  async execute(context: NodeExecutionContext): Promise<NodeExecutionResult> {
+    const startTime = Date.now();
+    
+    try {
+      // Get condition from config
+      const conditionConfig = this.definition.config?.condition;
+      
+      if (conditionConfig === undefined) {
+        // No condition specified, default to true (pass through)
+        return {
+          output: { success: true, condition: true },
+          error: undefined,
+          durationMs: Date.now() - startTime,
+        };
+      }
+      
+      // Resolve template references in the condition
+      const resolvedCondition = this.resolveCondition(conditionConfig, context);
+      
+      // Evaluate the condition
+      const result = this.evaluateCondition(resolvedCondition);
+      
+      return {
+        output: { success: result, condition: resolvedCondition },
+        error: undefined,
+        durationMs: Date.now() - startTime,
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime,
+      };
+    }
+  }
+  
+  /**
+   * Resolve condition value, handling template references.
+   */
+  private resolveCondition(
+    condition: unknown,
+    context: NodeExecutionContext
+  ): unknown {
+    if (typeof condition === 'string') {
+      // Check if this is a template reference
+      const templateMatch = condition.match(/^\{\{([^}]+)\}\}$/);
+      if (templateMatch) {
+        const path = templateMatch[1].trim();
+        return this.resolveTemplate(path, context);
+      }
+      // Check if it's a literal boolean or other literal
+      if (condition === 'true') return true;
+      if (condition === 'false') return false;
+      return condition;
+    }
+    return condition;
+  }
+  
+  /**
+   * Resolve a template path to get a value from previous outputs or workflow input.
+   */
+  private resolveTemplate(path: string, context: NodeExecutionContext): unknown {
+    const trimmed = path.trim();
+    
+    // Pattern 1: input.key
+    if (trimmed.startsWith('input.')) {
+      const key = trimmed.slice(6);
+      return (context.input as Record<string, unknown>)?.[key];
+    }
+    
+    // Pattern 2: nodes.nodeId or nodes.nodeId.path
+    if (trimmed.startsWith('nodes.')) {
+      const rest = trimmed.slice(6);
+      const segments = rest.split('.');
+      const nodeId = segments[0];
+      
+      // 尝试规范化匹配（hyphen <-> underscore）
+      let nodeOutput = context.previousOutputs.get(nodeId);
+      if (nodeOutput === undefined) {
+        const normalizedUnderscore = nodeId.replace(/-/g, '_');
+        const normalizedHyphen = nodeId.replace(/_/g, '-');
+        if (normalizedUnderscore !== nodeId) {
+          nodeOutput = context.previousOutputs.get(normalizedUnderscore);
+        }
+        if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+          nodeOutput = context.previousOutputs.get(normalizedHyphen);
+        }
+      }
+      if (nodeOutput === undefined) return undefined;
+      
+      // Navigate path
+      let value: unknown = nodeOutput;
+      for (const segment of segments.slice(1)) {
+        if (value && typeof value === 'object') {
+          value = (value as Record<string, unknown>)[segment];
+        } else {
+          return undefined;
+        }
+      }
+      return value;
+    }
+    
+    // Pattern 3: Bare nodeId or nodeId.path
+    const segments = trimmed.split('.');
+    const nodeId = segments[0];
+    
+    // 尝试规范化匹配（hyphen <-> underscore）
+    let nodeOutput = context.previousOutputs.get(nodeId);
+    if (nodeOutput === undefined) {
+      const normalizedUnderscore = nodeId.replace(/-/g, '_');
+      const normalizedHyphen = nodeId.replace(/_/g, '-');
+      if (normalizedUnderscore !== nodeId) {
+        nodeOutput = context.previousOutputs.get(normalizedUnderscore);
+      }
+      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+        nodeOutput = context.previousOutputs.get(normalizedHyphen);
+      }
+    }
+    if (nodeOutput === undefined) return undefined;
+    
+    // Navigate path
+    let value: unknown = nodeOutput;
+    for (const segment of segments.slice(1)) {
+      if (value && typeof value === 'object') {
+        value = (value as Record<string, unknown>)[segment];
+      } else {
+        return undefined;
+      }
+    }
+    return value;
+  }
+  
+  /**
+   * Evaluate a resolved condition value.
+   */
+  private evaluateCondition(value: unknown): boolean {
+    if (typeof value === 'boolean') {
+      return value;
+    }
+    if (typeof value === 'string') {
+      return value.toLowerCase() === 'true' || value === '1';
+    }
+    if (typeof value === 'number') {
+      return value !== 0;
+    }
+    if (value === null || value === undefined) {
+      return false;
+    }
+    // For objects, check if it has a 'success' property
+    if (typeof value === 'object') {
+      const obj = value as Record<string, unknown>;
+      if ('success' in obj) {
+        return Boolean(obj.success);
+      }
+      // Non-empty object is truthy
+      return Object.keys(obj).length > 0;
+    }
+    return Boolean(value);
+  }
+}

package/src/env/workflow/nodes/index.ts

@@ -0,0 +1,9 @@
+// Node implementations
+export { ToolNode } from './tool-node';
+export type { ToolRegistry, Tool } from './tool-node';
+
+export { SkillNode } from './skill-node';
+export type { SkillRegistry, Skill } from './skill-node';
+
+export { WorkflowNode } from './workflow-node';
+export type { WorkflowRunner, WorkflowRunResult } from './workflow-node';

package/src/env/workflow/nodes/merge-node.ts

@@ -0,0 +1,141 @@
+/**
+ * @fileoverview MergeNode - Workflow merge/join node
+ * 
+ * A merge node waits for all dependencies to complete and collects their outputs.
+ * 
+ * Input can contain template strings like {{nodeId.output.path}} that will be
+ * resolved from previousOutputs.
+ */
+
+import { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';
+
+/**
+ * MergeNode collects outputs from all dependent nodes and optionally merges them.
+ * 
+ * The merge strategy can be:
+ * - "collect": Collect all outputs into an array
+ * - "first": Return the first completed output
+ * - "last": Return the last completed output
+ * - "merge": Deep merge all outputs into a single object
+ * 
+ * Usage in workflow:
+ * ```yaml
+ * nodes:
+ *   - id: final
+ *     type: merge
+ *     config:
+ *       strategy: collect
+ *     depends_on:
+ *       - log-workflow-complete
+ * ```
+ */
+export class MergeNode implements Node {
+  readonly type = 'merge';
+  readonly id: string;
+  
+  constructor(
+    private definition: NodeDefinition,
+  ) {
+    this.id = definition.id;
+  }
+  
+  async execute(context: NodeExecutionContext): Promise<NodeExecutionResult> {
+    const startTime = Date.now();
+    
+    try {
+      // Get merge strategy from config (default: collect)
+      const strategy = (this.definition.config?.strategy as string) || 'collect';
+      
+      // Get dependency outputs
+      const deps = this.definition.depends_on || [];
+      const outputs: Record<string, unknown> = {};
+      
+      for (const depId of deps) {
+        // 尝试规范化匹配（hyphen <-> underscore）
+        let output = context.previousOutputs.get(depId);
+        if (output === undefined) {
+          const normalizedUnderscore = depId.replace(/-/g, '_');
+          const normalizedHyphen = depId.replace(/_/g, '-');
+          if (normalizedUnderscore !== depId) {
+            output = context.previousOutputs.get(normalizedUnderscore);
+          }
+          if (output === undefined && normalizedHyphen !== depId) {
+            output = context.previousOutputs.get(normalizedHyphen);
+          }
+        }
+        if (output !== undefined) {
+          outputs[depId] = output;
+        }
+      }
+      
+      // Apply merge strategy
+      let result: unknown;
+      
+      switch (strategy) {
+        case 'collect':
+          // Return all outputs as a map
+          result = outputs;
+          break;
+          
+        case 'first':
+          // Return the first output
+          const firstKey = Object.keys(outputs)[0];
+          result = firstKey ? outputs[firstKey] : undefined;
+          break;
+          
+        case 'last':
+          // Return the last output
+          const lastKey = Object.keys(outputs).pop();
+          result = lastKey ? outputs[lastKey] : undefined;
+          break;
+          
+        case 'merge':
+          // Deep merge all outputs
+          result = this.deepMerge(Object.values(outputs));
+          break;
+          
+        default:
+          result = outputs;
+      }
+      
+      return {
+        output: {
+          strategy,
+          results: result,
+          count: Object.keys(outputs).length,
+        },
+        error: undefined,
+        durationMs: Date.now() - startTime,
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime,
+      };
+    }
+  }
+  
+  /**
+   * Deep merge multiple objects into a single object.
+   */
+  private deepMerge(objects: unknown[]): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    
+    for (const obj of objects) {
+      if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+        for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+          if (result[key] && typeof result[key] === 'object' && !Array.isArray(result[key]) &&
+              value && typeof value === 'object' && !Array.isArray(value)) {
+            // Recursively merge nested objects
+            result[key] = this.deepMerge([result[key], value]);
+          } else {
+            result[key] = value;
+          }
+        }
+      }
+    }
+    
+    return result;
+  }
+}

package/src/env/workflow/nodes/skill-node.test.ts

@@ -0,0 +1,253 @@
+import { describe, it, expect, beforeEach, jest } from 'vitest';
+import { SkillNode, SkillRegistry, Skill } from './skill-node';
+import type { NodeDefinition, NodeExecutionContext } from '../types';
+import type { EventBus } from '../engine/event-bus';
+
+// Mock EventBus
+const mockEventBus = {
+  emit: jest.fn(),
+  on: jest.fn(),
+  off: jest.fn(),
+} as Partial<EventBus> as EventBus;
+
+// Mock SkillRegistry
+const mockRegistry = {
+  getSkill: jest.fn<(name: string) => Skill | undefined>(),
+  hasSkill: jest.fn<(name: string) => boolean>(),
+} as {
+  getSkill: ReturnType<typeof jest.fn>;
+  hasSkill: ReturnType<typeof jest.fn>;
+};
+
+// Mock Skill
+const mockSkill = {
+  name: 'test-skill',
+  invoke: jest.fn<(input: any, context: any) => Promise<any>>(),
+};
+
+describe('SkillNode', () => {
+  let skillNode: SkillNode;
+  let nodeDefinition: NodeDefinition;
+  let executionContext: NodeExecutionContext;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    nodeDefinition = {
+      id: 'node-1',
+      type: 'skill',
+      name: 'Test Skill Node',
+      config: {
+        skill: 'test-skill',
+        input: { message: 'hello' },
+      },
+    };
+
+    executionContext = {
+      runId: 'run-1',
+      workflowName: 'test-workflow',
+      nodeId: 'node-1',
+      input: {},
+      previousOutputs: new Map(),
+      config: nodeDefinition.config,
+      debug: false,
+      eventBus: mockEventBus,
+    };
+
+    mockRegistry.getSkill = jest.fn().mockReturnValue(mockSkill);
+    mockRegistry.hasSkill = jest.fn().mockReturnValue(true);
+    mockSkill.invoke = jest.fn().mockResolvedValue({ result: 'success' });
+  });
+
+  describe('constructor', () => {
+    it('should create a SkillNode with correct type', () => {
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      expect(skillNode.type).toBe('skill');
+      expect(skillNode.id).toBe('node-1');
+    });
+  });
+
+  describe('execute', () => {
+    it('should invoke skill successfully', async () => {
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      const result = await skillNode.execute(executionContext);
+      
+      expect(result.output).toEqual({ result: 'success' });
+      expect(result.error).toBeUndefined();
+      expect(result.durationMs).toBeGreaterThanOrEqual(0);
+      expect(mockRegistry.getSkill).toHaveBeenCalledWith('test-skill');
+      expect(mockSkill.invoke).toHaveBeenCalled();
+    });
+
+    it('should return error when skill not found', async () => {
+      mockRegistry.getSkill = jest.fn().mockReturnValue(undefined);
+      mockRegistry.hasSkill = jest.fn().mockReturnValue(false);
+      
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      const result = await skillNode.execute(executionContext);
+      
+      expect(result.output).toBeUndefined();
+      expect(result.error).toBeDefined();
+      expect(result.error.message).toContain('Skill not found: test-skill');
+    });
+
+    it('should pass input to skill', async () => {
+      const customInput = { param1: 'value1', param2: 123 };
+      nodeDefinition.config.input = customInput;
+      executionContext.config = nodeDefinition.config;
+      
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      await skillNode.execute(executionContext);
+      
+      expect(mockSkill.invoke).toHaveBeenCalledWith(customInput, expect.any(Object));
+    });
+
+    it('should handle skill invocation errors', async () => {
+      const error = new Error('Skill invocation failed');
+      mockSkill.invoke = jest.fn().mockRejectedValue(error);
+      
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      const result = await skillNode.execute(executionContext);
+      
+      expect(result.output).toBeUndefined();
+      expect(result.error).toBeDefined();
+      expect(result.error.message).toBe('Skill invocation failed');
+    });
+
+    it('should resolve template references from previous outputs', async () => {
+      // Set up previous outputs
+      executionContext.previousOutputs.set('node-0', {
+        output: { value: 'from-node-0' }
+      });
+      
+      // Input contains template reference
+      nodeDefinition.config.input = {
+        message: '{{node-0.output.value}}',
+      };
+      executionContext.config = nodeDefinition.config;
+      
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      const result = await skillNode.execute(executionContext);
+      
+      expect(result.output).toEqual({ result: 'success' });
+      expect(mockSkill.invoke).toHaveBeenCalledWith({
+        message: 'from-node-0',
+      }, expect.any(Object));
+    });
+
+    it('should resolve nested template references', async () => {
+      executionContext.previousOutputs.set('data-node', {
+        nested: {
+          deep: {
+            value: 'nested-value',
+          }
+        }
+      });
+      
+      nodeDefinition.config.input = {
+        message: '{{data-node.nested.deep.value}}',
+      };
+      executionContext.config = nodeDefinition.config;
+      
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      await skillNode.execute(executionContext);
+      
+      expect(mockSkill.invoke).toHaveBeenCalledWith({
+        message: 'nested-value',
+      }, expect.any(Object));
+    });
+
+    it('should handle unresolved template references gracefully', async () => {
+      // Template references non-existent node
+      nodeDefinition.config.input = {
+        message: '{{non-existent.output.value}}',
+      };
+      executionContext.config = nodeDefinition.config;
+      
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      const result = await skillNode.execute(executionContext);
+      
+      // Should still execute with unresolved template
+      expect(mockSkill.invoke).toHaveBeenCalledWith({
+        message: '{{non-existent.output.value}}',
+      }, expect.any(Object));
+    });
+
+    it('should record execution duration', async () => {
+      mockSkill.invoke = jest.fn().mockImplementation(async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return { result: 'success' };
+      });
+      
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      const result = await skillNode.execute(executionContext);
+      
+      expect(result.durationMs).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should use skill name from config.skill', async () => {
+      nodeDefinition.config.skill = 'custom-skill';
+      executionContext.config = nodeDefinition.config;
+      
+      const customSkill = {
+        name: 'custom-skill',
+        invoke: jest.fn().mockResolvedValue({ custom: true }),
+      };
+      mockRegistry.getSkill = jest.fn().mockReturnValue(customSkill);
+      
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      await skillNode.execute(executionContext);
+      
+      expect(mockRegistry.getSkill).toHaveBeenCalledWith('custom-skill');
+    });
+
+    it('should throw error when skill config is missing', async () => {
+      nodeDefinition.config = {};  // No skill specified
+      executionContext.config = nodeDefinition.config;
+      
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      const result = await skillNode.execute(executionContext);
+      
+      expect(result.error).toBeDefined();
+      expect(result.error.message).toContain('Skill name is required');
+    });
+
+    it('should pass context to skill invoke', async () => {
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      await skillNode.execute(executionContext);
+      
+      // Verify context is passed with relevant info
+      expect(mockSkill.invoke).toHaveBeenCalledWith(
+        { message: 'hello' },
+        expect.objectContaining({
+          runId: 'run-1',
+          workflowName: 'test-workflow',
+          nodeId: 'node-1',
+        })
+      );
+    });
+  });
+
+  describe('SkillRegistry interface', () => {
+    it('should check skill existence with hasSkill', async () => {
+      mockRegistry.hasSkill = jest.fn().mockReturnValue(true);
+      
+      skillNode = new SkillNode(nodeDefinition, mockRegistry);
+      
+      // This is tested implicitly - if hasSkill returns false, 
+      // getSkill should also return undefined
+      expect(mockRegistry.hasSkill('test-skill')).toBe(true);
+    });
+  });
+});