@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/core/src/env/workflow/engine/node-registry.test.js

@@ -0,0 +1,439 @@
+/**
+ * @fileoverview NodeRegistry Tests
+ *
+ * TDD tests for the NodeRegistry class that manages node creation
+ * from NodeDefinition instances.
+ */
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { NodeRegistry } from "./node-registry.js";
+import { ToolNode } from "../nodes/tool-node.js";
+import { SkillNode } from "../nodes/skill-node.js";
+import { AgentNode } from "../nodes/agent-node.js";
+import { WorkflowNode } from "../nodes/workflow-node.js";
+import { EventBus } from "./event-bus.js";
+// ============================================================================
+// Test Setup
+// ============================================================================
+/**
+ * Create a mock ToolRegistry for testing
+ */
+function createMockToolRegistry() {
+    return {
+        getTool: vi.fn(),
+        hasTool: vi.fn(),
+    };
+}
+/**
+ * Create a mock SkillRegistry for testing
+ */
+function createMockSkillRegistry() {
+    return {
+        getSkill: vi.fn(),
+        hasSkill: vi.fn(),
+    };
+}
+/**
+ * Create a mock AgentRunner for testing
+ */
+function createMockAgentRunner() {
+    return {
+        run: vi.fn(),
+    };
+}
+/**
+ * Create a mock WorkflowRunner for testing
+ */
+function createMockWorkflowRunner() {
+    return {
+        run: vi.fn(),
+        getRun: vi.fn(),
+    };
+}
+/**
+ * Create a NodeContext for testing
+ */
+function createNodeContext() {
+    const eventBus = new EventBus();
+    const context = {
+        sessionId: 'test-session',
+        nodeOutputs: {},
+        previousOutputs: new Map(),
+    };
+    return { context, eventBus };
+}
+/**
+ * Create a basic NodeDefinition for testing
+ */
+function createDefinition(overrides = {}) {
+    return {
+        id: 'test-node',
+        type: 'tool',
+        config: {},
+        ...overrides,
+    };
+}
+// ============================================================================
+// Test Suites
+// ============================================================================
+describe('NodeRegistry', () => {
+    let toolRegistry;
+    let skillRegistry;
+    let agentRunner;
+    let workflowRunner;
+    beforeEach(() => {
+        toolRegistry = createMockToolRegistry();
+        skillRegistry = createMockSkillRegistry();
+        agentRunner = createMockAgentRunner();
+        workflowRunner = createMockWorkflowRunner();
+    });
+    describe('constructor', () => {
+        it('should create a NodeRegistry with no arguments', () => {
+            const registry = new NodeRegistry();
+            expect(registry).toBeDefined();
+        });
+        it('should create a NodeRegistry with all registries using options object', () => {
+            const registry = new NodeRegistry({
+                toolRegistry,
+                skillRegistry,
+                agentRunner,
+                workflowRunner,
+            });
+            expect(registry).toBeDefined();
+        });
+        it('should support legacy positional arguments for backward compatibility', () => {
+            // Note: This tests that the options object format works
+            const registry = new NodeRegistry({
+                toolRegistry,
+                skillRegistry,
+                agentRunner,
+                workflowRunner,
+            });
+            expect(registry).toBeDefined();
+            expect(registry.has('tool')).toBe(true);
+            expect(registry.has('skill')).toBe(true);
+            expect(registry.has('agent')).toBe(true);
+            expect(registry.has('workflow')).toBe(true);
+        });
+    });
+    describe('built-in node types', () => {
+        it('should have tool type registered by default', () => {
+            const registry = new NodeRegistry({ toolRegistry });
+            expect(registry.has('tool')).toBe(true);
+        });
+        it('should have skill type registered by default', () => {
+            const registry = new NodeRegistry({ skillRegistry });
+            expect(registry.has('skill')).toBe(true);
+        });
+        it('should have agent type registered by default', () => {
+            const registry = new NodeRegistry({ agentRunner });
+            expect(registry.has('agent')).toBe(true);
+        });
+        it('should have workflow type registered by default', () => {
+            const registry = new NodeRegistry({ workflowRunner });
+            expect(registry.has('workflow')).toBe(true);
+        });
+    });
+    describe('has()', () => {
+        it('should return false for unknown types', () => {
+            const registry = new NodeRegistry();
+            expect(registry.has('unknown')).toBe(false);
+        });
+        it('should return true for built-in types', () => {
+            const registry = new NodeRegistry();
+            expect(registry.has('tool')).toBe(true);
+            expect(registry.has('skill')).toBe(true);
+            expect(registry.has('agent')).toBe(true);
+            expect(registry.has('workflow')).toBe(true);
+        });
+        it('should return true for registered custom types', () => {
+            const registry = new NodeRegistry();
+            registry.register('custom', () => {
+                return {};
+            });
+            expect(registry.has('custom')).toBe(true);
+        });
+    });
+    describe('list()', () => {
+        it('should list all registered types', () => {
+            const registry = new NodeRegistry();
+            const types = registry.list();
+            expect(types).toContain('tool');
+            expect(types).toContain('skill');
+            expect(types).toContain('agent');
+            expect(types).toContain('workflow');
+        });
+        it('should include custom registered types', () => {
+            const registry = new NodeRegistry();
+            registry.register('custom1', () => ({ type: 'custom1', id: 'x', execute: async () => ({ success: true }) }));
+            registry.register('custom2', () => ({ type: 'custom2', id: 'y', execute: async () => ({ success: true }) }));
+            const types = registry.list();
+            expect(types).toContain('custom1');
+            expect(types).toContain('custom2');
+        });
+    });
+    describe('register()', () => {
+        it('should register a custom node factory', () => {
+            const registry = new NodeRegistry();
+            const factory = vi.fn();
+            registry.register('custom', factory);
+            expect(registry.has('custom')).toBe(true);
+        });
+        it('should allow overriding existing types', () => {
+            const registry = new NodeRegistry();
+            const newFactory = vi.fn();
+            // This should not throw
+            registry.register('tool', newFactory);
+            expect(registry.has('tool')).toBe(true);
+        });
+    });
+    describe('createNode()', () => {
+        describe('tool node', () => {
+            it('should create a ToolNode instance', () => {
+                const registry = new NodeRegistry({ toolRegistry });
+                const definition = createDefinition({
+                    type: 'tool',
+                    config: { tool: 'test-tool' },
+                });
+                const node = registry.createNode(definition);
+                expect(node).toBeInstanceOf(ToolNode);
+                expect(node.type).toBe('tool');
+                expect(node.id).toBe('test-node');
+            });
+            it('should throw error when tool registry is not provided', () => {
+                const registry = new NodeRegistry();
+                const definition = createDefinition({
+                    type: 'tool',
+                    config: { tool: 'test-tool' },
+                });
+                expect(() => registry.createNode(definition)).toThrow('ToolRegistry is required');
+            });
+            it('should create ToolNode with proper tool registry', async () => {
+                const mockTool = {
+                    name: 'test-tool',
+                    execute: vi.fn().mockResolvedValue({ result: 'success' }),
+                };
+                toolRegistry.getTool.mockReturnValue(mockTool);
+                const registry = new NodeRegistry({ toolRegistry });
+                const definition = createDefinition({
+                    id: 'tool-1',
+                    type: 'tool',
+                    config: { tool: 'test-tool', input: {} },
+                });
+                const node = registry.createNode(definition);
+                const { context } = createNodeContext();
+                await node.execute(context);
+                expect(toolRegistry.getTool).toHaveBeenCalledWith('test-tool');
+            });
+        });
+        describe('skill node', () => {
+            it('should create a SkillNode instance', () => {
+                const registry = new NodeRegistry({ skillRegistry });
+                const definition = createDefinition({
+                    type: 'skill',
+                    config: { skill: 'test-skill' },
+                });
+                const node = registry.createNode(definition);
+                expect(node).toBeInstanceOf(SkillNode);
+                expect(node.type).toBe('skill');
+                expect(node.id).toBe('test-node');
+            });
+            it('should throw error when skill registry is not provided', () => {
+                const registry = new NodeRegistry();
+                const definition = createDefinition({
+                    type: 'skill',
+                    config: { skill: 'test-skill' },
+                });
+                expect(() => registry.createNode(definition)).toThrow('SkillRegistry is required');
+            });
+            it('should create SkillNode with proper skill registry', async () => {
+                const mockSkill = {
+                    name: 'test-skill',
+                    invoke: vi.fn().mockResolvedValue({ result: 'success' }),
+                };
+                skillRegistry.getSkill.mockReturnValue(mockSkill);
+                const registry = new NodeRegistry({ skillRegistry });
+                const definition = createDefinition({
+                    id: 'skill-1',
+                    type: 'skill',
+                    config: { skill: 'test-skill', input: {} },
+                });
+                const node = registry.createNode(definition);
+                const { context } = createNodeContext();
+                await node.execute(context);
+                expect(skillRegistry.getSkill).toHaveBeenCalledWith('test-skill');
+            });
+        });
+        describe('agent node', () => {
+            it('should create an AgentNode instance', () => {
+                const registry = new NodeRegistry({ agentRunner });
+                const definition = createDefinition({
+                    type: 'agent',
+                    config: { prompt: 'Do something' },
+                });
+                const node = registry.createNode(definition);
+                expect(node).toBeInstanceOf(AgentNode);
+                expect(node.type).toBe('agent');
+                expect(node.id).toBe('test-node');
+            });
+            it('should throw error when agent runner is not provided', () => {
+                const registry = new NodeRegistry();
+                const definition = createDefinition({
+                    type: 'agent',
+                    config: { prompt: 'Do something' },
+                });
+                expect(() => registry.createNode(definition)).toThrow('AgentRunner is required');
+            });
+            it('should create AgentNode with proper agent runner', async () => {
+                agentRunner.run.mockResolvedValue({
+                    output: 'agent response',
+                    metadata: { tokens: 100 },
+                });
+                const registry = new NodeRegistry({ agentRunner });
+                const definition = createDefinition({
+                    id: 'agent-1',
+                    type: 'agent',
+                    config: { prompt: 'Test prompt' },
+                });
+                const node = registry.createNode(definition);
+                const { context } = createNodeContext();
+                await node.execute(context);
+                expect(agentRunner.run).toHaveBeenCalled();
+            });
+        });
+        describe('workflow node', () => {
+            it('should create a WorkflowNode instance', () => {
+                const registry = new NodeRegistry({ workflowRunner });
+                const definition = createDefinition({
+                    type: 'workflow',
+                    config: { workflow_name: 'test-workflow' },
+                });
+                const node = registry.createNode(definition);
+                expect(node).toBeInstanceOf(WorkflowNode);
+                expect(node.type).toBe('workflow');
+                expect(node.id).toBe('test-node');
+            });
+            it('should throw error when workflow runner is not provided', () => {
+                const registry = new NodeRegistry();
+                const definition = createDefinition({
+                    type: 'workflow',
+                    config: { workflow_name: 'test-workflow' },
+                });
+                expect(() => registry.createNode(definition)).toThrow('WorkflowRunner is required');
+            });
+            it('should create WorkflowNode with proper workflow runner', async () => {
+                workflowRunner.run.mockResolvedValue({
+                    runId: 'run-123',
+                    status: 'completed',
+                    output: { result: 'success' },
+                });
+                const registry = new NodeRegistry({ workflowRunner });
+                const definition = createDefinition({
+                    id: 'workflow-1',
+                    type: 'workflow',
+                    config: { workflow_name: 'test-workflow' },
+                });
+                const node = registry.createNode(definition);
+                const { context } = createNodeContext();
+                await node.execute(context);
+                expect(workflowRunner.run).toHaveBeenCalledWith('test-workflow', {});
+            });
+        });
+        describe('custom registered node', () => {
+            it('should create a custom registered node', () => {
+                const registry = new NodeRegistry();
+                const customNode = {
+                    type: 'custom',
+                    id: 'custom-node',
+                    execute: async () => ({ success: true, output: 'custom' }),
+                };
+                registry.register('custom', () => customNode);
+                const definition = createDefinition({ type: 'custom' });
+                const node = registry.createNode(definition);
+                expect(node).toBe(customNode);
+                expect(node.type).toBe('custom');
+            });
+            it('should call factory function with definition and context', () => {
+                const registry = new NodeRegistry();
+                const factory = vi.fn().mockReturnValue({
+                    type: 'factory-test',
+                    id: 'factory-node',
+                    execute: async () => ({ success: true }),
+                });
+                registry.register('factory-test', factory);
+                const definition = createDefinition({ type: 'factory-test' });
+                registry.createNode(definition);
+                expect(factory).toHaveBeenCalled();
+            });
+        });
+        describe('unknown node type', () => {
+            it('should throw error for unknown node type', () => {
+                const registry = new NodeRegistry();
+                const definition = createDefinition({ type: 'unknown-type' });
+                expect(() => registry.createNode(definition)).toThrow('Unknown node type: unknown-type');
+            });
+            it('should include available types in error message', () => {
+                const registry = new NodeRegistry();
+                const definition = createDefinition({ type: 'nonexistent' });
+                expect(() => registry.createNode(definition)).toThrow('tool');
+                expect(() => registry.createNode(definition)).toThrow('skill');
+                expect(() => registry.createNode(definition)).toThrow('agent');
+                expect(() => registry.createNode(definition)).toThrow('workflow');
+            });
+        });
+    });
+    describe('integration scenarios', () => {
+        it('should create multiple different node types from same registry', () => {
+            const registry = new NodeRegistry({
+                toolRegistry,
+                skillRegistry,
+                agentRunner,
+                workflowRunner,
+            });
+            const toolDef = createDefinition({ id: 'n1', type: 'tool' });
+            const skillDef = createDefinition({ id: 'n2', type: 'skill' });
+            const agentDef = createDefinition({ id: 'n3', type: 'agent' });
+            const workflowDef = createDefinition({ id: 'n4', type: 'workflow' });
+            const toolNode = registry.createNode(toolDef);
+            const skillNode = registry.createNode(skillDef);
+            const agentNode = registry.createNode(agentDef);
+            const workflowNode = registry.createNode(workflowDef);
+            expect(toolNode).toBeInstanceOf(ToolNode);
+            expect(skillNode).toBeInstanceOf(SkillNode);
+            expect(agentNode).toBeInstanceOf(AgentNode);
+            expect(workflowNode).toBeInstanceOf(WorkflowNode);
+        });
+        it('should maintain separate node instances for same definition', () => {
+            const registry = new NodeRegistry({ toolRegistry });
+            const definition = createDefinition({ id: 'shared', type: 'tool' });
+            const node1 = registry.createNode(definition);
+            const node2 = registry.createNode(definition);
+            // Nodes should be separate instances (unless factory is stateless)
+            expect(node1).toBeInstanceOf(ToolNode);
+            expect(node2).toBeInstanceOf(ToolNode);
+        });
+    });
+    describe('AgentComponent integration', () => {
+        it('should create AgentRunner from AgentComponent when provided', () => {
+            // Mock AgentComponent
+            const mockAgentComponent = {
+                registerAgent: vi.fn(),
+                getAgent: vi.fn(),
+                listAgents: vi.fn().mockReturnValue([]),
+                run: vi.fn(),
+            };
+            const registry = new NodeRegistry({
+                agentComponent: mockAgentComponent,
+            });
+            // AgentNode should be createable now
+            expect(registry.has('agent')).toBe(true);
+            const definition = createDefinition({
+                id: 'test-agent',
+                type: 'agent',
+                config: { prompt: 'Test' },
+            });
+            const node = registry.createNode(definition);
+            expect(node).toBeInstanceOf(AgentNode);
+        });
+    });
+});
+//# sourceMappingURL=node-registry.test.js.map

package/dist/core/src/env/workflow/engine/resume-removed.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resume-removed.test.d.ts.map

package/dist/core/src/env/workflow/engine/resume-removed.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect } from 'vitest';
+import { WorkflowEngine } from "./engine.js";
+describe('resume() method', () => {
+    it('should have resume method for pausing recovery', () => {
+        // In the session-based design, resume() is used to recover from pauses
+        expect(typeof WorkflowEngine.prototype.resume).toBe('function');
+    });
+    it('should still have run method for unified run/resume', () => {
+        // The unified run() method handles both fresh start and resume
+        expect(typeof WorkflowEngine.prototype.run).toBe('function');
+    });
+    it('should still have stop method', () => {
+        expect(typeof WorkflowEngine.prototype.stop).toBe('function');
+    });
+    it('should still have pause method', () => {
+        expect(typeof WorkflowEngine.prototype.pause).toBe('function');
+    });
+});
+//# sourceMappingURL=resume-removed.test.js.map

package/dist/core/src/env/workflow/engine/scheduler.d.ts

@@ -0,0 +1,133 @@
+import { DAGManager } from './dag-manager';
+/**
+ * Scheduler Options
+ */
+export interface SchedulerOptions {
+    /** Maximum number of nodes that can run in parallel. null = unlimited */
+    parallelLimit: number | null;
+}
+/**
+ * Scheduler State
+ */
+export interface SchedulerState {
+    /** Nodes that have not been started yet */
+    pending: string[];
+    /** Nodes that are ready to execute (dependencies met, not started) */
+    ready: string[];
+    /** Nodes that are currently running */
+    running: string[];
+    /** Nodes that have completed successfully */
+    completed: string[];
+    /** Nodes that have failed */
+    failed: string[];
+    /** Nodes that were skipped (not executed) */
+    skipped: string[];
+}
+/**
+ * Scheduler
+ *
+ * Determines which nodes are ready to execute based on:
+ * - DAG dependencies
+ * - Parallel execution limit
+ * - Node completion status
+ *
+ * The scheduler tracks the state of all nodes and manages the execution queue.
+ */
+export declare class Scheduler {
+    private dagManager;
+    private options;
+    private pending;
+    private ready;
+    private running;
+    private completed;
+    private failed;
+    private skipped;
+    /**
+     * Create a new Scheduler
+     * @param dagManager - The DAG manager for the workflow
+     * @param options - Scheduler options
+     */
+    constructor(dagManager: DAGManager, options?: Partial<SchedulerOptions>);
+    /**
+     * Get nodes that are ready to execute
+     * Ready nodes are those whose dependencies are met and are not already running/completed/failed
+     * @param completedNodes - Set of completed node IDs (external tracking)
+     */
+    getReadyNodes(completedNodes: Set<string>): string[];
+    /**
+     * Get the number of currently running nodes
+     */
+    getRunningCount(): number;
+    /**
+     * Check if more nodes can be started based on the parallel limit
+     */
+    canStartMore(): boolean;
+    /**
+     * Mark a node as started
+     * @param nodeId - The node ID
+     */
+    markStarted(nodeId: string): void;
+    /**
+     * Check if a node is currently running
+     * @param nodeId - The node ID
+     */
+    isRunning(nodeId: string): boolean;
+    /**
+     * Check if a node has completed
+     * @param nodeId - The node ID
+     */
+    isCompleted(nodeId: string): boolean;
+    /**
+     * Check if a node has failed
+     * @param nodeId - The node ID
+     */
+    isFailed(nodeId: string): boolean;
+    /**
+     * Check if a node is in pending state
+     * @param nodeId - The node ID
+     */
+    isPending(nodeId: string): boolean;
+    /**
+     * Check if a node is ready to execute
+     * @param nodeId - The node ID
+     */
+    isReady(nodeId: string): boolean;
+    /**
+     * Mark a node as completed successfully
+     * @param nodeId - The node ID
+     */
+    markCompleted(nodeId: string): void;
+    /**
+     * Mark a node as failed
+     * @param nodeId - The node ID
+     */
+    markFailed(nodeId: string): void;
+    /**
+     * Mark a node as skipped (not executed)
+     * @param nodeId - The node ID
+     */
+    markSkipped(nodeId: string): void;
+    /**
+     * Reset the scheduler state
+     * Clears all running, completed, failed, and skipped nodes
+     */
+    reset(): void;
+    /**
+     * Get the current state of the scheduler
+     */
+    getState(): SchedulerState;
+    /**
+     * Update the ready set based on completed nodes
+     */
+    private updateReadyNodes;
+    /**
+     * Get the parallel limit
+     */
+    getParallelLimit(): number | null;
+    /**
+     * Update the parallel limit
+     * @param limit - New parallel limit (null for unlimited)
+     */
+    setParallelLimit(limit: number | null): void;
+}
+//# sourceMappingURL=scheduler.d.ts.map