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

package/dist/core/src/env/workflow/nodes/merge-node.d.ts

@@ -1,41 +0,0 @@
-/**
- * @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 declare class MergeNode implements Node {
-    private definition;
-    readonly type = "merge";
-    readonly id: string;
-    constructor(definition: NodeDefinition);
-    execute(context: NodeExecutionContext): Promise<NodeExecutionResult>;
-    /**
-     * Deep merge multiple objects into a single object.
-     */
-    private deepMerge;
-}
-//# sourceMappingURL=merge-node.d.ts.map

package/dist/core/src/env/workflow/nodes/merge-node.js

@@ -1,126 +0,0 @@
-/**
- * @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.
- */
-/**
- * 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 {
-    definition;
-    type = 'merge';
-    id;
-    constructor(definition) {
-        this.definition = definition;
-        this.id = definition.id;
-    }
-    async execute(context) {
-        const startTime = Date.now();
-        try {
-            // Get merge strategy from config (default: collect)
-            const strategy = this.definition.config?.strategy || 'collect';
-            // Get dependency outputs
-            const deps = this.definition.depends_on || [];
-            const outputs = {};
-            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;
-            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.
-     */
-    deepMerge(objects) {
-        const result = {};
-        for (const obj of objects) {
-            if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
-                for (const [key, value] of Object.entries(obj)) {
-                    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;
-    }
-}
-//# sourceMappingURL=merge-node.js.map

package/dist/core/src/env/workflow/nodes/skill-node.d.ts

@@ -1,118 +0,0 @@
-import { Node, NodeDefinition, NodeExecutionContext, NodeExecutionResult } from '../types';
-/**
- * Skill Registry interface for looking up skills
- */
-export interface SkillRegistry {
-    getSkill(name: string): Skill | undefined;
-    hasSkill(name: string): boolean;
-}
-/**
- * Skill interface for invocation
- */
-export interface Skill {
-    name: string;
-    invoke(input: any, context: any): Promise<any>;
-}
-/**
- * SkillNode invokes a registered Skill with the provided input.
- *
- * Input can contain template strings like {{nodeId.output.path}} that will be
- * resolved from previousOutputs.
- */
-export declare class SkillNode implements Node {
-    private definition;
-    private skillRegistry;
-    readonly type = "skill";
-    readonly id: string;
-    constructor(definition: NodeDefinition, skillRegistry: SkillRegistry);
-    execute(context: NodeExecutionContext): Promise<NodeExecutionResult>;
-    /**
-     * Resolve template references in input values.
-     * Templates can be in the format:
-     * - {{input.key}} - from workflow input
-     * - {{nodeId}} - entire previous node output
-     * - {{nodeId.path}} - nested path within previous node output
-     * - {{nodes.nodeId}} - entire previous node output (alias)
-     * - {{nodes.nodeId.path}} - nested path within previous node output
-     *
-     * Key behavior for template strings:
-     * - If the string is a pure template reference (e.g., "{{nodes.fetch}}"),
-     *   the resolved value is returned as-is (preserving objects/arrays)
-     * - If the string contains text + templates (e.g., "Hello {{name}}"),
-     *   returns a string with interpolated values
-     *
-     * @param input - The input object that may contain template strings
-     * @param previousOutputs - Map of previous node outputs
-     * @param workflowInput - The workflow input parameters
-     * @returns The input with template references resolved
-     */
-    private resolveTemplateReferences;
-    /**
-     * Check if a string is a pure template reference (starts with {{ and ends with }})
-     * @param str - String to check
-     * @returns The template content if pure, null otherwise
-     */
-    private extractPureTemplate;
-    /**
-     * Resolve a pure template reference and return the value as-is.
-     * @param templateContent - Content between {{ and }}
-     * @param previousOutputs - Map of previous node outputs
-     * @param workflowInput - The workflow input parameters
-     * @returns The resolved value (may be object, array, or primitive),
-     *          or the original template string if unresolved
-     */
-    private resolvePureTemplate;
-    /**
-     * Resolve template references in a single string (for mixed text + templates).
-     * Supports formats:
-     * - {{input.key}} - from workflow input
-     * - {{nodeId}} - entire previous node output
-     * - {{nodeId.path}} - nested path within previous node output
-     * - {{nodes.nodeId}} - entire previous node output (alias)
-     * - {{nodes.nodeId.path}} - nested path within previous node output
-     *
-     * Note: Returns string because the input contains text around the template.
-     * For pure template references, use resolvePureTemplate instead.
-     */
-    private resolveStringTemplate;
-    /**
-     * Resolve a value from previous outputs.
-     * @param nodeId - The node ID to look up
-     * @param path - Optional dot-notation path within the node output
-     * @param previousOutputs - Map of previous node outputs
-     */
-    private resolvePath;
-    /**
-     * Extract the actual output value from wrapper formats.
-     *
-     * Handles:
-     * - AgentNode format: { result, metadata } -> returns result
-     * - DecoratorNode format: { success, output, ... } -> returns output
-     * - Other formats: returns value as-is
-     *
-     * @param value - The value to extract from
-     * @returns The extracted value
-     */
-    private extractFromWrapper;
-    /**
-     * Get nested value from an object using dot-notation path.
-     *
-     * Special handling: If the object has an 'input' key and we're looking for a path that doesn't
-     * exist at the top level, check inside the 'input' key.
-     * This allows {{input.city}} to work when workflowInput is wrapped as {input: {city: "..."}}
-     */
-    private getNestedValue;
-    /**
-     * Convert a value to string for template replacement.
-     * - If value is undefined, return the original template
-     * - If value is a string, return it directly
-     * - If value is null, return 'null'
-     * - If value is an object or array, serialize to JSON
-     *
-     * @param value - The value to stringify
-     * @param originalTemplate - The original template string (returned if value is undefined)
-     * @returns String representation of the value
-     */
-    private stringifyValue;
-}
-//# sourceMappingURL=skill-node.d.ts.map

package/dist/core/src/env/workflow/nodes/skill-node.js

@@ -1,322 +0,0 @@
-/**
- * SkillNode invokes a registered Skill with the provided input.
- *
- * Input can contain template strings like {{nodeId.output.path}} that will be
- * resolved from previousOutputs.
- */
-export class SkillNode {
-    definition;
-    skillRegistry;
-    type = 'skill';
-    id;
-    constructor(definition, skillRegistry) {
-        this.definition = definition;
-        this.skillRegistry = skillRegistry;
-        this.id = definition.id;
-    }
-    async execute(context) {
-        const startTime = Date.now();
-        try {
-            // 1. Get skill name from definition.config.skill
-            const skillName = this.definition.config?.skill;
-            if (!skillName) {
-                throw new Error('Skill name is required. Please specify config.skill in the node definition.');
-            }
-            // 2. Look up skill from registry
-            const skill = this.skillRegistry.getSkill(skillName);
-            if (!skill) {
-                throw new Error(`Skill not found: ${skillName}`);
-            }
-            // 3. Prepare input (may reference previous outputs and workflow input)
-            const input = this.definition.config?.input ?? {};
-            const resolvedInput = this.resolveTemplateReferences(input, context.previousOutputs, context.input);
-            // 4. Prepare context for skill invocation
-            const skillContext = {
-                runId: context.runId,
-                workflowName: context.workflowName,
-                nodeId: context.nodeId,
-                debug: context.debug,
-            };
-            // 5. Invoke skill
-            const output = await skill.invoke(resolvedInput, skillContext);
-            // 6. Return result
-            return {
-                output,
-                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 template references in input values.
-     * Templates can be in the format:
-     * - {{input.key}} - from workflow input
-     * - {{nodeId}} - entire previous node output
-     * - {{nodeId.path}} - nested path within previous node output
-     * - {{nodes.nodeId}} - entire previous node output (alias)
-     * - {{nodes.nodeId.path}} - nested path within previous node output
-     *
-     * Key behavior for template strings:
-     * - If the string is a pure template reference (e.g., "{{nodes.fetch}}"),
-     *   the resolved value is returned as-is (preserving objects/arrays)
-     * - If the string contains text + templates (e.g., "Hello {{name}}"),
-     *   returns a string with interpolated values
-     *
-     * @param input - The input object that may contain template strings
-     * @param previousOutputs - Map of previous node outputs
-     * @param workflowInput - The workflow input parameters
-     * @returns The input with template references resolved
-     */
-    resolveTemplateReferences(input, previousOutputs, workflowInput) {
-        if (typeof input === 'string') {
-            // Check if this is a pure template reference (no surrounding text)
-            const pureTemplate = this.extractPureTemplate(input);
-            if (pureTemplate) {
-                // Pure template reference - resolve and return value as-is (preserve objects/arrays)
-                return this.resolvePureTemplate(pureTemplate, previousOutputs, workflowInput);
-            }
-            // Mixed text + templates - return resolved string
-            return this.resolveStringTemplate(input, previousOutputs, workflowInput);
-        }
-        if (Array.isArray(input)) {
-            return input.map(item => this.resolveTemplateReferences(item, previousOutputs, workflowInput));
-        }
-        if (input !== null && typeof input === 'object') {
-            const resolved = {};
-            for (const [key, value] of Object.entries(input)) {
-                resolved[key] = this.resolveTemplateReferences(value, previousOutputs, workflowInput);
-            }
-            return resolved;
-        }
-        // Return primitive values as-is
-        return input;
-    }
-    /**
-     * Check if a string is a pure template reference (starts with {{ and ends with }})
-     * @param str - String to check
-     * @returns The template content if pure, null otherwise
-     */
-    extractPureTemplate(str) {
-        const trimmed = str.trim();
-        if (trimmed.startsWith('{{') && trimmed.endsWith('}}') && trimmed.length > 4) {
-            // Extract content between {{ and }}
-            const content = trimmed.slice(2, -2).trim();
-            // Check there's no other text (except the template patterns themselves)
-            if (!content.includes('{{') && !content.includes('}}')) {
-                return content;
-            }
-        }
-        return null;
-    }
-    /**
-     * Resolve a pure template reference and return the value as-is.
-     * @param templateContent - Content between {{ and }}
-     * @param previousOutputs - Map of previous node outputs
-     * @param workflowInput - The workflow input parameters
-     * @returns The resolved value (may be object, array, or primitive),
-     *          or the original template string if unresolved
-     */
-    resolvePureTemplate(templateContent, previousOutputs, workflowInput) {
-        const trimmed = templateContent.trim();
-        const originalTemplate = `{{${templateContent}}}`;
-        // Pattern 1: {{input.key}} or {{input.key.nested}}
-        if (trimmed.startsWith('input.')) {
-            const value = this.getNestedValue(workflowInput, trimmed.slice(6));
-            return value !== undefined ? value : originalTemplate;
-        }
-        // Pattern 2: {{nodes.nodeId}} or {{nodes.nodeId.output}}
-        if (trimmed.startsWith('nodes.')) {
-            const path = trimmed.slice(6);
-            const segments = path.split('.');
-            const nodeId = segments[0];
-            const restPath = segments.slice(1).join('.') || undefined;
-            const value = this.resolvePath(nodeId, restPath, previousOutputs);
-            return value !== undefined ? value : originalTemplate;
-        }
-        // Pattern 3: Bare nodeId (backward compatibility)
-        if (trimmed !== 'input' && trimmed !== 'nodes') {
-            const segments = trimmed.split('.');
-            const nodeId = segments[0];
-            const restPath = segments.slice(1).join('.') || undefined;
-            const value = this.resolvePath(nodeId, restPath, previousOutputs);
-            return value !== undefined ? value : originalTemplate;
-        }
-        return originalTemplate;
-    }
-    /**
-     * Resolve template references in a single string (for mixed text + templates).
-     * Supports formats:
-     * - {{input.key}} - from workflow input
-     * - {{nodeId}} - entire previous node output
-     * - {{nodeId.path}} - nested path within previous node output
-     * - {{nodes.nodeId}} - entire previous node output (alias)
-     * - {{nodes.nodeId.path}} - nested path within previous node output
-     *
-     * Note: Returns string because the input contains text around the template.
-     * For pure template references, use resolvePureTemplate instead.
-     */
-    resolveStringTemplate(template, previousOutputs, workflowInput) {
-        let resolved = template;
-        // Pattern 1: {{input.key}} or {{input.key.path}}
-        resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
-            const value = this.getNestedValue(workflowInput, path.trim());
-            return this.stringifyValue(value, match);
-        });
-        // Pattern 2: {{nodeId}} or {{nodeId.path}} (bare nodeId without prefix)
-        resolved = resolved.replace(/\{\{([^:.{}][^}]*?)\}\}/g, (match, path) => {
-            // Skip if it starts with 'nodes.' or 'input.'
-            if (path.trim().startsWith('nodes.') || path.trim().startsWith('input.')) {
-                return match;
-            }
-            // Split into nodeId and optional path
-            const segments = path.trim().split('.');
-            const nodeId = segments[0];
-            const restPath = segments.slice(1).join('.') || undefined;
-            const value = this.resolvePath(nodeId, restPath, previousOutputs);
-            return this.stringifyValue(value, match);
-        });
-        // Pattern 3: {{nodes.nodeId}} or {{nodes.nodeId.path}}
-        resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
-            const segments = path.trim().split('.');
-            const nodeId = segments[0];
-            const restPath = segments.slice(1).join('.') || undefined;
-            const value = this.resolvePath(nodeId, restPath, previousOutputs);
-            return this.stringifyValue(value, match);
-        });
-        return resolved;
-    }
-    /**
-     * Resolve a value from previous outputs.
-     * @param nodeId - The node ID to look up
-     * @param path - Optional dot-notation path within the node output
-     * @param previousOutputs - Map of previous node outputs
-     */
-    resolvePath(nodeId, path, previousOutputs) {
-        // Try exact match first, then try normalized versions (hyphen <-> underscore)
-        let nodeOutput = previousOutputs.get(nodeId);
-        if (nodeOutput === undefined) {
-            // Try normalized versions for flexibility
-            const normalizedUnderscore = nodeId.replace(/-/g, '_');
-            const normalizedHyphen = nodeId.replace(/_/g, '-');
-            if (normalizedUnderscore !== nodeId) {
-                nodeOutput = previousOutputs.get(normalizedUnderscore);
-            }
-            if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-                nodeOutput = previousOutputs.get(normalizedHyphen);
-            }
-        }
-        if (nodeOutput === undefined) {
-            return undefined;
-        }
-        // Extract from wrapper formats (DecoratorNode: {success, output} and AgentNode: {result, metadata})
-        let value = this.extractFromWrapper(nodeOutput);
-        // If no path specified, return the extracted value
-        if (!path) {
-            return value;
-        }
-        // Navigate the path within the node's output
-        // Skip first segment if it's a wrapper property since extractFromWrapper already extracted it
-        // (e.g., template {{node-0.output.value}} -> path="output.value" -> skip "output")
-        let segments = path.split('.');
-        if (segments.length > 1 &&
-            (segments[0] === 'output' || segments[0] === 'result' || segments[0] === 'metadata')) {
-            segments = segments.slice(1);
-        }
-        let current = value;
-        for (const segment of segments) {
-            if (current === null || current === undefined) {
-                return undefined;
-            }
-            current = current[segment];
-        }
-        return current;
-    }
-    /**
-     * Extract the actual output value from wrapper formats.
-     *
-     * Handles:
-     * - AgentNode format: { result, metadata } -> returns result
-     * - DecoratorNode format: { success, output, ... } -> returns output
-     * - Other formats: returns value as-is
-     *
-     * @param value - The value to extract from
-     * @returns The extracted value
-     */
-    extractFromWrapper(value) {
-        if (value === null || value === undefined) {
-            return value;
-        }
-        if (typeof value !== 'object') {
-            return value;
-        }
-        // Check for AgentNode wrapper: { result, metadata }
-        // This is the signature of AgentNode output
-        if ('result' in value && 'metadata' in value) {
-            return value.result;
-        }
-        // Check for DecoratorNode wrapper: { success, output, ... }
-        // This has 'output' but NOT 'result' (that's AgentNode's signature)
-        if ('output' in value) {
-            return value.output;
-        }
-        return value;
-    }
-    /**
-     * Get nested value from an object using dot-notation path.
-     *
-     * Special handling: If the object has an 'input' key and we're looking for a path that doesn't
-     * exist at the top level, check inside the 'input' key.
-     * This allows {{input.city}} to work when workflowInput is wrapped as {input: {city: "..."}}
-     */
-    getNestedValue(obj, path) {
-        if (!obj) {
-            return undefined;
-        }
-        // Special case: If obj has an 'input' key, we might be accessing a key inside it
-        // This happens when createExecutionContext wraps globalInput as {input: globalInput}
-        if ('input' in obj && path in obj['input']) {
-            // Path exists inside 'input', so look there
-            return obj['input'][path];
-        }
-        // Normal case: path.split('.').reduce(...) with obj as initial value
-        // This allows {{input.city}} to work when path = "city" and obj = {input: {city: "..."}}
-        return path.split('.').reduce((current, key) => {
-            if (current && typeof current === 'object') {
-                return current[key];
-            }
-            return undefined;
-        }, obj);
-    }
-    /**
-     * Convert a value to string for template replacement.
-     * - If value is undefined, return the original template
-     * - If value is a string, return it directly
-     * - If value is null, return 'null'
-     * - If value is an object or array, serialize to JSON
-     *
-     * @param value - The value to stringify
-     * @param originalTemplate - The original template string (returned if value is undefined)
-     * @returns String representation of the value
-     */
-    stringifyValue(value, originalTemplate) {
-        if (value === undefined) {
-            return originalTemplate;
-        }
-        if (value === null) {
-            return 'null';
-        }
-        if (typeof value === 'string') {
-            return value;
-        }
-        // For objects and arrays, serialize to JSON
-        return JSON.stringify(value);
-    }
-}
-//# sourceMappingURL=skill-node.js.map

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

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