@ai-setting/roy-agent-cli 1.3.18 → 1.3.22

package/dist/core/src/env/workflow/decorators/decorator-node.d.ts

@@ -1,77 +0,0 @@
-/**
- * DecoratorNode - 执行装饰器类方法的节点
- *
- * 实现 Node 接口，用于执行使用 @Workflow/@NodeAs 装饰的类方法
- */
-import type { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';
-/**
- * DecoratorNode 节点配置
- */
-export interface DecoratorNodeConfig extends NodeDefinition {
-    config: {
-        /** 方法名称 */
-        _methodName: string;
-        /** 类实例 */
-        _instance: any;
-        /** 用户自定义配置 */
-        [key: string]: unknown;
-    };
-}
-/**
- * DecoratorNode - 执行装饰器类方法的节点
- *
- * 用于执行使用 @Workflow/@NodeAs 装饰器定义的类方法
- *
- * @example
- * ```typescript
- * const definition: DecoratorNodeConfig = {
- *   id: 'myNode',
- *   type: 'decorator',
- *   config: {
- *     _methodName: 'myMethod',
- *     _instance: myWorkflowInstance,
- *   }
- * };
- *
- * const node = new DecoratorNode(definition);
- * const result = await node.execute(context);
- * ```
- */
-export declare class DecoratorNode implements Node {
-    readonly type = "decorator";
-    readonly id: string;
-    private readonly methodName;
-    private readonly instance;
-    private readonly dependsOn;
-    private readonly timeout?;
-    private readonly retryConfig?;
-    constructor(definition: NodeDefinition);
-    /**
-     * 执行装饰器方法
-     */
-    execute(context: NodeExecutionContext): Promise<NodeExecutionResult>;
-    /**
-     * 准备输入参数
-     *
-     * 根据依赖的节点 ID，从 nodeOutputs 中提取对应的输出
-     * 返回格式: { [depNodeId]: depOutput }
-     */
-    private prepareInput;
-    /**
-     * 带重试的执行
-     */
-    private executeWithRetry;
-    /**
-     * 带超时的执行
-     */
-    private executeWithTimeout;
-    /**
-     * 计算退避延迟
-     */
-    private calculateBackoff;
-    /**
-     * 睡眠
-     */
-    private sleep;
-}
-//# sourceMappingURL=decorator-node.d.ts.map

package/dist/core/src/env/workflow/decorators/decorator-node.js

@@ -1,176 +0,0 @@
-/**
- * DecoratorNode - 执行装饰器类方法的节点
- *
- * 实现 Node 接口，用于执行使用 @Workflow/@NodeAs 装饰的类方法
- */
-/**
- * DecoratorNode - 执行装饰器类方法的节点
- *
- * 用于执行使用 @Workflow/@NodeAs 装饰器定义的类方法
- *
- * @example
- * ```typescript
- * const definition: DecoratorNodeConfig = {
- *   id: 'myNode',
- *   type: 'decorator',
- *   config: {
- *     _methodName: 'myMethod',
- *     _instance: myWorkflowInstance,
- *   }
- * };
- *
- * const node = new DecoratorNode(definition);
- * const result = await node.execute(context);
- * ```
- */
-export class DecoratorNode {
-    type = 'decorator';
-    id;
-    methodName;
-    instance;
-    dependsOn;
-    timeout;
-    retryConfig;
-    constructor(definition) {
-        const config = definition.config;
-        this.id = definition.id;
-        this.methodName = config._methodName;
-        this.instance = config._instance;
-        this.dependsOn = definition.depends_on || [];
-        this.timeout = definition.timeout;
-        this.retryConfig = definition.retry;
-    }
-    /**
-     * 执行装饰器方法
-     */
-    async execute(context) {
-        const startTime = Date.now();
-        // 获取方法
-        const method = this.instance[this.methodName];
-        if (typeof method !== 'function') {
-            return {
-                success: false,
-                error: `Method '${this.methodName}' is not a function`,
-                duration: Date.now() - startTime,
-            };
-        }
-        // 准备输入参数
-        const input = this.prepareInput(context);
-        // 执行（带重试和超时）
-        const result = await this.executeWithRetry(input, context.abort);
-        return {
-            success: !result.error,
-            output: result.output,
-            error: result.error,
-            duration: Date.now() - startTime,
-            metadata: {
-                methodName: this.methodName,
-            },
-        };
-    }
-    /**
-     * 准备输入参数
-     *
-     * 根据依赖的节点 ID，从 nodeOutputs 中提取对应的输出
-     * 返回格式: { [depNodeId]: depOutput }
-     */
-    prepareInput(context) {
-        // nodeOutputs 可以是 Map 或普通对象
-        const nodeOutputs = context.nodeOutputs;
-        // 如果没有依赖节点，直接使用全局 input
-        if (this.dependsOn.length === 0) {
-            return context.input || {};
-        }
-        // 根据依赖节点 ID 提取输出，构建输入对象
-        const input = {};
-        for (const depId of this.dependsOn) {
-            // 支持 Map 和普通对象
-            const depOutput = nodeOutputs instanceof Map
-                ? nodeOutputs.get(depId)
-                : nodeOutputs?.[depId];
-            if (depOutput && typeof depOutput === 'object') {
-                // 如果是完整的 NodeExecutionResult，提取 output 字段
-                if ('output' in depOutput) {
-                    input[depId] = depOutput.output;
-                }
-                else {
-                    // 已经是裸对象
-                    input[depId] = depOutput;
-                }
-            }
-        }
-        return input;
-    }
-    /**
-     * 带重试的执行
-     */
-    async executeWithRetry(input, abort) {
-        const maxAttempts = this.retryConfig?.max_attempts ?? 1;
-        const backoff = this.retryConfig?.backoff ?? 'exponential';
-        const initialDelay = this.retryConfig?.initial_delay ?? 1000;
-        let lastError;
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-            // 检查中断信号
-            if (abort?.aborted) {
-                return { error: 'Execution aborted' };
-            }
-            try {
-                // 执行方法
-                const output = await this.executeWithTimeout(input, abort);
-                return { output };
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                // 如果不是最后一次尝试，等待后重试
-                if (attempt < maxAttempts) {
-                    const delay = this.calculateBackoff(backoff, initialDelay, attempt - 1);
-                    await this.sleep(delay, abort);
-                }
-            }
-        }
-        return { error: lastError?.message || 'Unknown error' };
-    }
-    /**
-     * 带超时的执行
-     */
-    async executeWithTimeout(input, abort) {
-        if (!this.timeout) {
-            // 无超时限制
-            return this.instance[this.methodName](input);
-        }
-        // 创建超时 Promise
-        const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => {
-                reject(new Error(`Execution timeout after ${this.timeout}ms`));
-            }, this.timeout);
-        });
-        // 竞速执行
-        return Promise.race([
-            this.instance[this.methodName](input),
-            timeoutPromise,
-        ]);
-    }
-    /**
-     * 计算退避延迟
-     */
-    calculateBackoff(backoff, initialDelay, attempt) {
-        if (backoff === 'exponential') {
-            return initialDelay * Math.pow(2, attempt);
-        }
-        return initialDelay;
-    }
-    /**
-     * 睡眠
-     */
-    sleep(ms, abort) {
-        return new Promise((resolve) => {
-            const timeout = setTimeout(resolve, ms);
-            // 如果被中断，清除定时器
-            abort?.addEventListener('abort', () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-        });
-    }
-}
-//# sourceMappingURL=decorator-node.js.map

package/dist/core/src/env/workflow/decorators/decorator.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * @fileoverview Workflow Decorator Integration Tests
- */
-import 'reflect-metadata';
-//# sourceMappingURL=decorator.test.d.ts.map

package/dist/core/src/env/workflow/decorators/decorator.test.js

@@ -1,212 +0,0 @@
-/**
- * @fileoverview Workflow Decorator Integration Tests
- */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { describe, test, expect } from 'bun:test';
-import 'reflect-metadata';
-import { Workflow, NodeAs, WorkflowEdges } from "./index.js";
-import { WorkflowConverter } from "../extractor/workflow-converter.js";
-import { createWorkflowFromClass } from "../utils/create-workflow.js";
-import { getWorkflowMetadata, getNodeMetadatas, getEdgeMetadatas } from "./index.js";
-describe('Workflow Decorators', () => {
-    // ============ Test Workflow Class ============
-    let TestWorkflow = class TestWorkflow {
-        async step1(input) {
-            return { result: `Step1: ${input.message}` };
-        }
-        async step2(input) {
-            return { result: `Step2: ${input.step1.result}` };
-        }
-        async step3(input) {
-            return { result: `Step3: ${input.step1.result}` };
-        }
-        async step4(input) {
-            return {
-                result: `Step4: ${input.step2.result} & ${input.step3.result}`
-            };
-        }
-    };
-    __decorate([
-        NodeAs({ nodeId: 'step1', nodeType: 'tool' }),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Object]),
-        __metadata("design:returntype", Promise)
-    ], TestWorkflow.prototype, "step1", null);
-    __decorate([
-        NodeAs({ nodeId: 'step2', dependsOn: 'step1' }),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Object]),
-        __metadata("design:returntype", Promise)
-    ], TestWorkflow.prototype, "step2", null);
-    __decorate([
-        NodeAs({ nodeId: 'step3', dependsOn: 'step1' }),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Object]),
-        __metadata("design:returntype", Promise)
-    ], TestWorkflow.prototype, "step3", null);
-    __decorate([
-        NodeAs({ nodeId: 'step4', dependsOn: ['step2', 'step3'] }),
-        __metadata("design:type", Function),
-        __metadata("design:paramtypes", [Object]),
-        __metadata("design:returntype", Promise)
-    ], TestWorkflow.prototype, "step4", null);
-    TestWorkflow = __decorate([
-        Workflow({
-            name: 'test-workflow',
-            version: '1.0',
-            description: 'Test workflow for decorator functionality',
-            entry: 'step1',
-            config: { parallel_limit: 3 }
-        }),
-        WorkflowEdges([
-            { from: 'step2', to: 'step3' },
-            { from: 'step3', to: 'step4' }
-        ])
-    ], TestWorkflow);
-    // ============ Tests ============
-    test('should extract workflow metadata', () => {
-        const metadata = getWorkflowMetadata(TestWorkflow);
-        expect(metadata).toBeDefined();
-        expect(metadata?.name).toBe('test-workflow');
-        expect(metadata?.version).toBe('1.0');
-        expect(metadata?.description).toBe('Test workflow for decorator functionality');
-        expect(metadata?.entry).toBe('step1');
-    });
-    test('should extract node metadatas', () => {
-        const nodes = getNodeMetadatas(TestWorkflow.prototype);
-        expect(nodes).toHaveLength(4);
-        // Check step1
-        const step1 = nodes.find(n => n.nodeId === 'step1');
-        expect(step1).toBeDefined();
-        expect(step1?.nodeType).toBe('tool');
-        expect(step1?.dependsOn).toEqual([]);
-        expect(step1?.methodName).toBe('step1');
-        // Check step2 (depends on step1)
-        const step2 = nodes.find(n => n.nodeId === 'step2');
-        expect(step2).toBeDefined();
-        expect(step2?.dependsOn).toEqual(['step1']);
-        // Check step4 (depends on step2 and step3)
-        const step4 = nodes.find(n => n.nodeId === 'step4');
-        expect(step4).toBeDefined();
-        expect(step4?.dependsOn).toEqual(['step2', 'step3']);
-    });
-    test('should extract edge metadatas', () => {
-        const edges = getEdgeMetadatas(TestWorkflow);
-        expect(edges).toHaveLength(2);
-        expect(edges).toContainEqual({ from: 'step2', to: 'step3' });
-        expect(edges).toContainEqual({ from: 'step3', to: 'step4' });
-    });
-    test('should validate workflow class', () => {
-        const result = WorkflowConverter.validateWorkflowClass(TestWorkflow);
-        expect(result.valid).toBe(true);
-        expect(result.errors).toHaveLength(0);
-    });
-    test('should convert to WorkflowDefinition', () => {
-        const workflow = createWorkflowFromClass(TestWorkflow);
-        expect(workflow.name).toBe('test-workflow');
-        expect(workflow.version).toBe('1.0');
-        expect(workflow.nodes).toHaveLength(4);
-        // Check nodes
-        const step1Node = workflow.nodes.find(n => n.id === 'step1');
-        expect(step1Node).toBeDefined();
-        expect(step1Node?.type).toBe('tool');
-        expect(step1Node?.depends_on).toEqual([]);
-        const step4Node = workflow.nodes.find(n => n.id === 'step4');
-        expect(step4Node).toBeDefined();
-        expect(step4Node?.depends_on).toContain('step2');
-        expect(step4Node?.depends_on).toContain('step3');
-    });
-    test('should validate missing entry node', () => {
-        let BrokenWorkflow = class BrokenWorkflow {
-            async step1() { return {}; }
-        };
-        __decorate([
-            NodeAs({ nodeId: 'step1' }),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", []),
-            __metadata("design:returntype", Promise)
-        ], BrokenWorkflow.prototype, "step1", null);
-        BrokenWorkflow = __decorate([
-            Workflow({ name: 'broken-workflow', entry: 'nonexistent' })
-        ], BrokenWorkflow);
-        const result = WorkflowConverter.validateWorkflowClass(BrokenWorkflow);
-        expect(result.valid).toBe(false);
-        expect(result.errors.some(e => e.includes("Entry node 'nonexistent' not found"))).toBe(true);
-    });
-    test('should validate missing dependency', () => {
-        let BrokenWorkflow2 = class BrokenWorkflow2 {
-            async step1() { return {}; }
-        };
-        __decorate([
-            NodeAs({ nodeId: 'step1', dependsOn: 'nonexistent' }),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", []),
-            __metadata("design:returntype", Promise)
-        ], BrokenWorkflow2.prototype, "step1", null);
-        BrokenWorkflow2 = __decorate([
-            Workflow({ name: 'broken-workflow-2' })
-        ], BrokenWorkflow2);
-        const result = WorkflowConverter.validateWorkflowClass(BrokenWorkflow2);
-        expect(result.valid).toBe(false);
-        expect(result.errors.some(e => e.includes("depends on non-existent node"))).toBe(true);
-    });
-    test('should validate cycle detection', () => {
-        let CyclicWorkflow = class CyclicWorkflow {
-            async a() { return {}; }
-            async b() { return {}; }
-            async c() { return {}; }
-        };
-        __decorate([
-            NodeAs({ nodeId: 'a', dependsOn: 'c' }),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", []),
-            __metadata("design:returntype", Promise)
-        ], CyclicWorkflow.prototype, "a", null);
-        __decorate([
-            NodeAs({ nodeId: 'b', dependsOn: 'a' }),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", []),
-            __metadata("design:returntype", Promise)
-        ], CyclicWorkflow.prototype, "b", null);
-        __decorate([
-            NodeAs({ nodeId: 'c', dependsOn: 'b' }),
-            __metadata("design:type", Function),
-            __metadata("design:paramtypes", []),
-            __metadata("design:returntype", Promise)
-        ], CyclicWorkflow.prototype, "c", null);
-        CyclicWorkflow = __decorate([
-            Workflow({ name: 'cyclic-workflow' })
-        ], CyclicWorkflow);
-        const result = WorkflowConverter.validateWorkflowClass(CyclicWorkflow);
-        expect(result.valid).toBe(false);
-        expect(result.errors.some(e => e.includes('cycle'))).toBe(true);
-    });
-    test('should execute decorator node method', async () => {
-        const workflow = createWorkflowFromClass(TestWorkflow);
-        const step1Node = workflow.nodes.find(n => n.id === 'step1');
-        const result = await WorkflowConverter.executeNode(step1Node, { input: { message: 'hello' }, previousOutputs: new Map() });
-        expect(result.output).toEqual({ result: 'Step1: hello' });
-        expect(result.error).toBeUndefined();
-    });
-    test('should handle node execution with dependencies', async () => {
-        const workflow = createWorkflowFromClass(TestWorkflow);
-        const step4Node = workflow.nodes.find(n => n.id === 'step4');
-        const previousOutputs = new Map([
-            ['step2', { result: 'Step2: data2' }],
-            ['step3', { result: 'Step3: data3' }]
-        ]);
-        const result = await WorkflowConverter.executeNode(step4Node, { input: {}, previousOutputs });
-        expect(result.output).toEqual({
-            result: 'Step4: Step2: data2 & Step3: data3'
-        });
-    });
-});
-//# sourceMappingURL=decorator.test.js.map

package/dist/core/src/env/workflow/decorators/edge.d.ts

@@ -1,43 +0,0 @@
-/**
- * @Edge 和 @WorkflowEdges 装饰器
- *
- * 用于显式声明节点之间的边关系
- */
-import 'reflect-metadata';
-import type { EdgeMetadata, EdgeOptions } from '../types/decorators-types';
-/**
- * 声明一条边 (from -> to)
- *
- * 这是一个方法装饰器，用于在方法上声明边关系
- *
- * @param from - 起始节点 ID
- * @param to - 目标节点 ID
- *
- * @example
- * ```typescript
- * @Edge('nodeA', 'nodeB')
- * static __edge_nodeA_to_nodeB__ = null;
- * ```
- */
-export declare function Edge(from: string, to: string): MethodDecorator;
-/**
- * 类级别装饰器，声明多条边
- *
- * @param edges - 边数组
- *
- * @example
- * ```typescript
- * @WorkflowEdges([
- *   { from: 'A', to: 'B' },
- *   { from: 'B', to: 'C' }
- * ])
- * @Workflow({ name: 'test' })
- * class TestWorkflow { }
- * ```
- */
-export declare function WorkflowEdges(edges: EdgeOptions[]): ClassDecorator;
-/**
- * 获取类上的所有边元数据
- */
-export declare function getEdgeMetadatas(target: Function): EdgeMetadata[];
-//# sourceMappingURL=edge.d.ts.map

package/dist/core/src/env/workflow/decorators/edge.js

@@ -1,68 +0,0 @@
-/**
- * @Edge 和 @WorkflowEdges 装饰器
- *
- * 用于显式声明节点之间的边关系
- */
-import 'reflect-metadata';
-import { EDGE_METADATA_KEY } from "../metadata/keys.js";
-/**
- * 声明一条边 (from -> to)
- *
- * 这是一个方法装饰器，用于在方法上声明边关系
- *
- * @param from - 起始节点 ID
- * @param to - 目标节点 ID
- *
- * @example
- * ```typescript
- * @Edge('nodeA', 'nodeB')
- * static __edge_nodeA_to_nodeB__ = null;
- * ```
- */
-export function Edge(from, to) {
-    return function (target, propertyKey, descriptor) {
-        const edge = { from, to };
-        // 获取已存在的边元数据列表
-        const existingEdges = Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
-        // 添加新边
-        existingEdges.push(edge);
-        // 存储元数据
-        Reflect.defineMetadata(EDGE_METADATA_KEY, existingEdges, target);
-        return descriptor;
-    };
-}
-/**
- * 类级别装饰器，声明多条边
- *
- * @param edges - 边数组
- *
- * @example
- * ```typescript
- * @WorkflowEdges([
- *   { from: 'A', to: 'B' },
- *   { from: 'B', to: 'C' }
- * ])
- * @Workflow({ name: 'test' })
- * class TestWorkflow { }
- * ```
- */
-export function WorkflowEdges(edges) {
-    return function (target) {
-        // 将 EdgeOptions[] 转换为 EdgeMetadata[]
-        const edgeMetadatas = edges.map(edge => ({
-            from: edge.from,
-            to: edge.to,
-            condition: edge.condition,
-        }));
-        // 存储元数据
-        Reflect.defineMetadata(EDGE_METADATA_KEY, edgeMetadatas, target);
-        return target;
-    };
-}
-/**
- * 获取类上的所有边元数据
- */
-export function getEdgeMetadatas(target) {
-    return Reflect.getMetadata(EDGE_METADATA_KEY, target) || [];
-}
-//# sourceMappingURL=edge.js.map

package/dist/core/src/env/workflow/decorators/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * @fileoverview Workflow Decorators Index
- *
- * 导出所有装饰器相关的 API
- */
-export { Workflow, getWorkflowMetadata } from './workflow';
-export { NodeAs, getNodeMetadatas } from './node-as';
-export { Edge, WorkflowEdges, getEdgeMetadatas } from './edge';
-export { DecoratorNode } from './decorator-node';
-export type { DecoratorNodeConfig } from './decorator-node';
-export { WorkflowConverter } from '../extractor/workflow-converter';
-export { createWorkflowFromClass } from '../utils/create-workflow';
-export type { WorkflowOptions, NodeAsOptions, EdgeOptions, WorkflowMetadata, NodeMetadata, EdgeMetadata, ValidationResult, ConvertedWorkflowDefinition, ConvertedNodeDefinition, } from '../types/decorators-types';
-//# sourceMappingURL=index.d.ts.map

package/dist/core/src/env/workflow/decorators/index.js

@@ -1,15 +0,0 @@
-/**
- * @fileoverview Workflow Decorators Index
- *
- * 导出所有装饰器相关的 API
- */
-// Decorators
-export { Workflow, getWorkflowMetadata } from "./workflow.js";
-export { NodeAs, getNodeMetadatas } from "./node-as.js";
-export { Edge, WorkflowEdges, getEdgeMetadatas } from "./edge.js";
-// Node
-export { DecoratorNode } from "./decorator-node.js";
-// Converter (需要单独导入，避免循环依赖)
-export { WorkflowConverter } from "../extractor/workflow-converter.js";
-export { createWorkflowFromClass } from "../utils/create-workflow.js";
-//# sourceMappingURL=index.js.map

package/dist/core/src/env/workflow/decorators/node-as.d.ts

@@ -1,41 +0,0 @@
-/**
- * @NodeAs 装饰器
- *
- * 用于将类方法声明为 Workflow 的 Node
- */
-import 'reflect-metadata';
-import type { NodeAsOptions, NodeMetadata } from '../types/decorators-types';
-/**
- * 将方法声明为 Workflow 的 Node
- *
- * @param options - Node 配置选项
- *
- * @example
- * ```typescript
- * @Workflow({ name: 'my-workflow', entry: 'fetch' })
- * class MyWorkflow {
- *   @NodeAs({
- *     nodeId: 'fetch',
- *     nodeType: 'tool',
- *     config: { tool: 'web_search' }
- *   })
- *   async fetch(input: { query: string }) {
- *     return { data: [] };
- *   }
- *
- *   @NodeAs({
- *     nodeId: 'process',
- *     dependsOn: 'fetch'
- *   })
- *   async process(input: { data: any }) {
- *     return { result: {} };
- *   }
- * }
- * ```
- */
-export declare function NodeAs(options?: NodeAsOptions): MethodDecorator;
-/**
- * 获取类上所有方法的 Node 元数据
- */
-export declare function getNodeMetadatas(target: Object): NodeMetadata[];
-//# sourceMappingURL=node-as.d.ts.map