@ai-setting/roy-agent-cli 1.3.15 → 1.3.17

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

@@ -0,0 +1,85 @@
+/**
+ * @NodeAs 装饰器
+ *
+ * 用于将类方法声明为 Workflow 的 Node
+ */
+import 'reflect-metadata';
+import { NODE_METADATA_KEY } from "../metadata/keys.js";
+/**
+ * 将方法声明为 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 function NodeAs(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const methodName = String(propertyKey);
+        // 构建节点元数据
+        const nodeMetadata = {
+            nodeId: options.nodeId || methodName, // 默认使用方法名作为 nodeId
+            nodeType: options.nodeType || 'tool', // 默认类型为 tool
+            name: options.name,
+            // 标准化 dependsOn 为数组
+            dependsOn: normalizeDependsOn(options.dependsOn),
+            condition: options.condition,
+            retry: options.retry,
+            timeout: options.timeout,
+            config: options.config || {},
+            methodName,
+            method: descriptor.value, // 存储方法引用
+        };
+        // 获取已存在的节点元数据列表
+        const existingNodes = Reflect.getMetadata(NODE_METADATA_KEY, target) || [];
+        // 检查是否已存在同名节点（同一方法不能被多次装饰）
+        const existingIndex = existingNodes.findIndex(n => n.methodName === methodName);
+        if (existingIndex >= 0) {
+            // 更新已存在的节点元数据
+            existingNodes[existingIndex] = nodeMetadata;
+        }
+        else {
+            // 添加新节点元数据
+            existingNodes.push(nodeMetadata);
+        }
+        // 存储元数据
+        Reflect.defineMetadata(NODE_METADATA_KEY, existingNodes, target);
+        return descriptor;
+    };
+}
+/**
+ * 标准化 dependsOn 为数组
+ */
+function normalizeDependsOn(dependsOn) {
+    if (!dependsOn) {
+        return [];
+    }
+    return Array.isArray(dependsOn) ? dependsOn : [dependsOn];
+}
+/**
+ * 获取类上所有方法的 Node 元数据
+ */
+export function getNodeMetadatas(target) {
+    return Reflect.getMetadata(NODE_METADATA_KEY, target) || [];
+}
+//# sourceMappingURL=node-as.js.map

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

@@ -0,0 +1,31 @@
+/**
+ * @Workflow 装饰器
+ *
+ * 用于声明一个类为 Workflow 类
+ */
+import 'reflect-metadata';
+import type { WorkflowOptions, WorkflowMetadata } from '../types/decorators-types';
+/**
+ * 声明一个类为 Workflow 类
+ *
+ * @param options - Workflow 配置选项
+ *
+ * @example
+ * ```typescript
+ * @Workflow({
+ *   name: 'my-workflow',
+ *   version: '1.0',
+ *   entry: 'start'
+ * })
+ * class MyWorkflow {
+ *   @NodeAs({ nodeId: 'start' })
+ *   async start() { }
+ * }
+ * ```
+ */
+export declare function Workflow(options: WorkflowOptions): ClassDecorator;
+/**
+ * 获取类上的 Workflow 元数据
+ */
+export declare function getWorkflowMetadata(target: Function): WorkflowMetadata | undefined;
+//# sourceMappingURL=workflow.d.ts.map

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

@@ -0,0 +1,49 @@
+/**
+ * @Workflow 装饰器
+ *
+ * 用于声明一个类为 Workflow 类
+ */
+import 'reflect-metadata';
+import { WORKFLOW_METADATA_KEY } from "../metadata/keys.js";
+/**
+ * 声明一个类为 Workflow 类
+ *
+ * @param options - Workflow 配置选项
+ *
+ * @example
+ * ```typescript
+ * @Workflow({
+ *   name: 'my-workflow',
+ *   version: '1.0',
+ *   entry: 'start'
+ * })
+ * class MyWorkflow {
+ *   @NodeAs({ nodeId: 'start' })
+ *   async start() { }
+ * }
+ * ```
+ */
+export function Workflow(options) {
+    return function (target) {
+        // 构建元数据对象
+        const metadata = {
+            name: options.name,
+            version: options.version || '1.0',
+            description: options.description,
+            entry: options.entry,
+            config: options.config,
+            tags: options.tags || [],
+            author: options.author,
+        };
+        // 使用 Reflect.metadata 存储元数据
+        Reflect.defineMetadata(WORKFLOW_METADATA_KEY, metadata, target);
+        return target;
+    };
+}
+/**
+ * 获取类上的 Workflow 元数据
+ */
+export function getWorkflowMetadata(target) {
+    return Reflect.getMetadata(WORKFLOW_METADATA_KEY, target);
+}
+//# sourceMappingURL=workflow.js.map

package/dist/core/src/env/workflow/engine/dag-manager.d.ts

@@ -0,0 +1,129 @@
+import type { WorkflowDefinition, NodeDefinition, WorkflowDefinitionExtended } from '../types';
+/**
+ * DAG Analysis Result
+ */
+export interface DAGAnalysis {
+    /** 入口节点（无依赖） */
+    entryNodes: string[];
+    /** 出口节点（无下游） */
+    exitNodes: string[];
+    /** 按层级组织的节点，用于并行执行 */
+    levels: string[][];
+    /** 每个节点的依赖 */
+    dependencies: Map<string, string[]>;
+    /** 每个节点的下游 */
+    dependents: Map<string, string[]>;
+    /** 关键路径 */
+    criticalPath: string[];
+}
+/**
+ * DAG Manager
+ *
+ * Manages Directed Acyclic Graph (DAG) operations for workflow execution.
+ * Provides analysis, topological sorting, and validation of workflow structures.
+ */
+export declare class DAGManager {
+    private workflow;
+    private nodeMap;
+    private extendedDefinition;
+    private cachedAnalysis;
+    constructor(workflow: WorkflowDefinition);
+    /**
+     * Get extended workflow definition with computed properties
+     */
+    getExtendedDefinition(): WorkflowDefinitionExtended;
+    /**
+     * Analyze the DAG structure
+     */
+    analyze(): DAGAnalysis;
+    /**
+     * Build a map of node dependencies
+     */
+    private buildDependenciesMap;
+    /**
+     * Build a map of node dependents (reverse of dependencies)
+     */
+    private buildDependentsMap;
+    /**
+     * Find entry nodes (nodes with no dependencies)
+     */
+    private findEntryNodes;
+    /**
+     * Find exit nodes (nodes with no dependents)
+     */
+    private findExitNodes;
+    /**
+     * Compute levels for parallel execution
+     * Nodes at the same level can be executed in parallel
+     */
+    private computeLevels;
+    /**
+     * Find critical path (longest path through the DAG)
+     */
+    private findCriticalPath;
+    /**
+     * Get topological order using Kahn's algorithm
+     */
+    getTopologicalOrder(): string[];
+    /**
+     * Get nodes that are ready to execute (dependencies met and not completed)
+     */
+    getReadyNodes(completedNodes: Set<string>): string[];
+    /**
+     * Check if all dependencies for a node are completed
+     */
+    areDependenciesMet(nodeId: string, completedNodes: Set<string>): boolean;
+    /**
+     * Check if the workflow contains a cycle
+     */
+    isCyclic(): boolean;
+    /**
+     * Internal topological sort that detects cycles
+     */
+    private getTopologicalOrderInternal;
+    /**
+     * Validate the workflow
+     */
+    validate(): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Add a new node to the workflow dynamically
+     *
+     * @param node - The node definition to add
+     * @throws Error if a node with the same ID already exists
+     * @throws Error if the node depends on a non-existent node
+     * @throws Error if adding this node would create a cycle
+     */
+    addNode(node: NodeDefinition): void;
+    /**
+     * Remove a node from the workflow dynamically
+     *
+     * @param nodeId - The ID of the node to remove
+     * @throws Error if the node doesn't exist
+     * @throws Error if other nodes depend on this node
+     */
+    removeNode(nodeId: string): void;
+    /**
+     * Get direct dependents of a node (nodes that depend on this node)
+     */
+    getDependents(nodeId: string): string[];
+    /**
+     * Get the workflow definition (current state)
+     */
+    getDefinition(): WorkflowDefinition;
+    /**
+     * Get a node by ID
+     */
+    getNode(nodeId: string): NodeDefinition | undefined;
+    /**
+     * Get all node IDs
+     */
+    getNodeIds(): string[];
+    /**
+     * Get the number of nodes in the workflow
+     */
+    getNodeCount(): number;
+}
+//# sourceMappingURL=dag-manager.d.ts.map