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

package/dist/core/src/env/workflow/utils/execution-state.js

@@ -1,228 +0,0 @@
-/**
- * Execution State Builder
- *
- * Builds execution state from session messages and workflow definition.
- */
-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 { TracedAs } from "../../log-trace/decorator.js";
-/**
- * Builder for constructing ExecutionState from session data
- */
-export class ExecutionStateBuilder {
-    build(messages, definition) {
-        const state = {
-            completedNodes: new Set(),
-            inProgressNodes: new Set(),
-            pendingNodes: new Set(),
-            nodeOutputs: new Map(),
-            nodeInputs: new Map(),
-            variables: new Map(),
-            loopCounts: new Map(),
-        };
-        // Parse messages to build state
-        this.parseMessages(messages, state);
-        // Build DAG from definition to determine pending nodes
-        this.buildPendingNodes(definition, state);
-        return state;
-    }
-    /**
-     * Parse session messages to extract node states and outputs
-     */
-    parseMessages(messages, state) {
-        let lastCallNodeId = null;
-        let lastCallInput = null;
-        for (const msg of messages) {
-            const metadata = msg.metadata;
-            const msgType = metadata?.type;
-            switch (msgType) {
-                case 'workflow.node.call': {
-                    const nodeId = metadata?.workflowNodeId;
-                    if (nodeId) {
-                        lastCallNodeId = nodeId;
-                        lastCallInput = this.extractInput(msg);
-                        // Mark as in-progress (might be completed later)
-                        state.inProgressNodes.add(nodeId);
-                        state.nodeInputs.set(nodeId, lastCallInput);
-                    }
-                    break;
-                }
-                case 'workflow.node.result': {
-                    if (lastCallNodeId) {
-                        // Node completed successfully
-                        state.inProgressNodes.delete(lastCallNodeId);
-                        state.completedNodes.add(lastCallNodeId);
-                        // Extract output
-                        const output = this.extractOutput(msg);
-                        state.nodeOutputs.set(lastCallNodeId, output);
-                        // Extract variables from output
-                        this.extractVariables(output, state);
-                        lastCallNodeId = null;
-                        lastCallInput = null;
-                    }
-                    break;
-                }
-                case 'workflow.node.interrupt': {
-                    if (lastCallNodeId) {
-                        // Node interrupted - still in progress
-                        state.inProgressNodes.add(lastCallNodeId);
-                    }
-                    break;
-                }
-                case 'workflow.node.resume': {
-                    // User resumed after interrupt
-                    if (lastCallNodeId) {
-                        state.inProgressNodes.add(lastCallNodeId);
-                    }
-                    break;
-                }
-            }
-        }
-        // If there's still a lastCallNodeId in progress without result, keep it as in-progress
-        // This means the workflow was interrupted mid-execution
-    }
-    /**
-     * Build pending nodes from workflow definition
-     */
-    buildPendingNodes(definition, state) {
-        const nodeIds = new Set((definition.nodes || []).map(n => n.id));
-        const allNodeIds = Array.from(nodeIds);
-        // Determine entry nodes
-        const entryNodes = this.getEntryNodes(definition);
-        // For each entry node, traverse the DAG and mark nodes as pending
-        // if they are reachable from an in-progress node and not completed
-        for (const entryNode of entryNodes) {
-            if (!state.completedNodes.has(entryNode)) {
-                this.markPendingFromNode(entryNode, definition, state);
-            }
-        }
-        // Also check if any completed node has unexecuted children
-        for (const completedId of state.completedNodes) {
-            const children = this.getDirectChildren(completedId, definition);
-            for (const childId of children) {
-                if (!state.completedNodes.has(childId) && !state.inProgressNodes.has(childId)) {
-                    state.pendingNodes.add(childId);
-                }
-            }
-        }
-    }
-    /**
-     * Get entry nodes from workflow definition
-     */
-    getEntryNodes(definition) {
-        const entry = definition.entry;
-        if (!entry) {
-            return [];
-        }
-        if (Array.isArray(entry)) {
-            return entry;
-        }
-        return [entry];
-    }
-    /**
-     * Mark all nodes as pending starting from a given node
-     */
-    markPendingFromNode(startNodeId, definition, state) {
-        const visited = new Set();
-        const queue = [startNodeId];
-        while (queue.length > 0) {
-            const nodeId = queue.shift();
-            if (visited.has(nodeId)) {
-                continue;
-            }
-            visited.add(nodeId);
-            // Only add to pending if not completed
-            if (!state.completedNodes.has(nodeId)) {
-                state.pendingNodes.add(nodeId);
-            }
-            // Queue children
-            const children = this.getDirectChildren(nodeId, definition);
-            for (const childId of children) {
-                if (!visited.has(childId)) {
-                    queue.push(childId);
-                }
-            }
-        }
-    }
-    /**
-     * Get direct children of a node
-     */
-    getDirectChildren(nodeId, definition) {
-        // Note: In the actual definition, edges might use 'source' and 'target'
-        // but for now we need to check both possible formats
-        const edges = definition.edges || definition.connections || [];
-        return edges
-            .filter((edge) => edge.source === nodeId || edge.from === nodeId)
-            .map((edge) => edge.target || edge.to);
-    }
-    /**
-     * Extract input from a workflow.node.call message
-     */
-    extractInput(msg) {
-        try {
-            // Try parsing as JSON
-            return JSON.parse(msg.content);
-        }
-        catch {
-            return msg.content;
-        }
-    }
-    /**
-     * Extract output from a workflow.node.result message
-     */
-    extractOutput(msg) {
-        try {
-            // Try parsing as JSON
-            return JSON.parse(msg.content);
-        }
-        catch {
-            return msg.content;
-        }
-    }
-    /**
-     * Extract variables from node output and add to state
-     */
-    extractVariables(output, state) {
-        if (!output || typeof output !== 'object') {
-            return;
-        }
-        const outputObj = output;
-        // Add each top-level property as a potential variable
-        for (const [key, value] of Object.entries(outputObj)) {
-            // Skip internal properties
-            if (key.startsWith('_') || key.startsWith('$')) {
-                continue;
-            }
-            // Add to variables if not already set
-            if (!state.variables.has(key)) {
-                state.variables.set(key, value);
-            }
-        }
-    }
-}
-__decorate([
-    TracedAs("recovery.builder.build", { recordParams: true, recordResult: true, log: true }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Object)
-], ExecutionStateBuilder.prototype, "build", null);
-__decorate([
-    TracedAs("recovery.builder.parseMessages", { recordParams: true, recordResult: true, log: true }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", void 0)
-], ExecutionStateBuilder.prototype, "parseMessages", null);
-__decorate([
-    TracedAs("recovery.builder.buildPendingNodes", { recordParams: true, recordResult: true, log: true }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", void 0)
-], ExecutionStateBuilder.prototype, "buildPendingNodes", null);
-//# sourceMappingURL=execution-state.js.map

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

@@ -1,9 +0,0 @@
-/**
- * Workflow Utilities
- */
-export { TemplateResolver, resolveTemplates, resolveTemplateString } from './template-resolver';
-export type { TemplateResolverOptions, ResolvedValue } from './template-resolver';
-export { RecoveryValidator } from './recovery-validator';
-export { ExecutionStateBuilder } from './execution-state';
-export { ValidationError, ValidationResult, RecoveryPlan, ValidationErrorType, SuggestedAction, ExecutionState, } from './validation-rules';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,9 +0,0 @@
-/**
- * Workflow Utilities
- */
-export { TemplateResolver, resolveTemplates, resolveTemplateString } from "./template-resolver.js";
-// Recovery utilities
-export { RecoveryValidator } from "./recovery-validator.js";
-export { ExecutionStateBuilder } from "./execution-state.js";
-export { ValidationErrorType, SuggestedAction, } from "./validation-rules.js";
-//# sourceMappingURL=index.js.map

package/dist/core/src/env/workflow/utils/node-registry-helper.d.ts

@@ -1,37 +0,0 @@
-/**
- * NodeRegistry 集成辅助
- *
- * 提供函数来帮助将 decorator 节点类型注册到 NodeRegistry
- */
-import type { NodeRegistry } from '../engine/node-registry';
-/**
- * 将所有内置节点类型注册到 NodeRegistry
- *
- * @param registry - NodeRegistry 实例
- *
- * @example
- * ```typescript
- * import { registerDecoratorNodeType } from '@roy-agent/workflow-decorators';
- *
- * // 在 WorkflowComponent 初始化时调用
- * registerDecoratorNodeType(registry);
- * ```
- */
-export declare function registerDecoratorNodeType(registry: NodeRegistry): void;
-/**
- * 检查 WorkflowDefinition 是否包含 decorator 类型的节点
- */
-export declare function hasDecoratorNodes(nodes: Array<{
-    type: string;
-}>): boolean;
-/**
- * 从 WorkflowDefinition 中提取所有 decorator 类型的节点
- */
-export declare function getDecoratorNodes(nodes: Array<{
-    type: string;
-    id: string;
-}>): Array<{
-    type: string;
-    id: string;
-}>;
-//# sourceMappingURL=node-registry-helper.d.ts.map

package/dist/core/src/env/workflow/utils/node-registry-helper.js

@@ -1,48 +0,0 @@
-/**
- * NodeRegistry 集成辅助
- *
- * 提供函数来帮助将 decorator 节点类型注册到 NodeRegistry
- */
-import { DecoratorNode } from "../decorators/decorator-node.js";
-import { ConditionNode } from "../nodes/condition-node.js";
-import { MergeNode } from "../nodes/merge-node.js";
-/**
- * 将所有内置节点类型注册到 NodeRegistry
- *
- * @param registry - NodeRegistry 实例
- *
- * @example
- * ```typescript
- * import { registerDecoratorNodeType } from '@roy-agent/workflow-decorators';
- *
- * // 在 WorkflowComponent 初始化时调用
- * registerDecoratorNodeType(registry);
- * ```
- */
-export function registerDecoratorNodeType(registry) {
-    // 注册 decorator 节点类型
-    registry.register('decorator', (definition) => {
-        return new DecoratorNode(definition);
-    });
-    // 注册 condition 节点类型
-    registry.register('condition', (definition) => {
-        return new ConditionNode(definition);
-    });
-    // 注册 merge 节点类型
-    registry.register('merge', (definition) => {
-        return new MergeNode(definition);
-    });
-}
-/**
- * 检查 WorkflowDefinition 是否包含 decorator 类型的节点
- */
-export function hasDecoratorNodes(nodes) {
-    return nodes.some(node => node.type === 'decorator');
-}
-/**
- * 从 WorkflowDefinition 中提取所有 decorator 类型的节点
- */
-export function getDecoratorNodes(nodes) {
-    return nodes.filter(node => node.type === 'decorator');
-}
-//# sourceMappingURL=node-registry-helper.js.map

package/dist/core/src/env/workflow/utils/recovery-validator.d.ts

@@ -1,31 +0,0 @@
-/**
- * RecoveryValidator - 分层恢复验证框架
- *
- * 遵循保守策略，严格验证状态完整性
- */
-import { WorkflowDefinition } from '../types';
-import { SessionMessage } from '../../session/types';
-import { ValidationResult, RecoveryPlan } from './validation-rules';
-/**
- * RecoveryValidator - 分层恢复验证框架
- *
- * 遵循保守策略，严格验证状态完整性
- */
-export declare class RecoveryValidator {
-    private stateBuilder;
-    constructor();
-    validate(messages: SessionMessage[], definition: WorkflowDefinition): Promise<ValidationResult>;
-    generatePlan(messages: SessionMessage[], definition: WorkflowDefinition): Promise<RecoveryPlan>;
-    private validateStateIntegrity;
-    private validateParallelBranches;
-    private validateConditionBranches;
-    private validateLoopState;
-    private validateNestedWorkflows;
-    private extractVariableRefs;
-    private identifyParallelGroups;
-    private findMergeNodeForParallel;
-    private identifyLoops;
-    private determineResumePoint;
-    private generateSummary;
-}
-//# sourceMappingURL=recovery-validator.d.ts.map