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

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

@@ -0,0 +1,387 @@
+import { z } from 'zod';
+export declare const DependsOnSchema: z.ZodArray<z.ZodString, "many">;
+export type DependsOn = z.infer<typeof DependsOnSchema>;
+export declare const RetryConfigSchema: z.ZodObject<{
+    max_attempts: z.ZodDefault<z.ZodNumber>;
+    backoff: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+    initial_delay: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    max_attempts?: number;
+    backoff?: "fixed" | "exponential";
+    initial_delay?: number;
+}, {
+    max_attempts?: number;
+    backoff?: "fixed" | "exponential";
+    initial_delay?: number;
+}>;
+export type RetryConfig = z.infer<typeof RetryConfigSchema>;
+export declare const NodeDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    config: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    depends_on: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    condition: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodDefault<z.ZodNumber>;
+        backoff: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+        initial_delay: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        max_attempts?: number;
+        backoff?: "fixed" | "exponential";
+        initial_delay?: number;
+    }, {
+        max_attempts?: number;
+        backoff?: "fixed" | "exponential";
+        initial_delay?: number;
+    }>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    retry?: {
+        max_attempts?: number;
+        backoff?: "fixed" | "exponential";
+        initial_delay?: number;
+    };
+    config?: Record<string, unknown>;
+    name?: string;
+    type?: string;
+    timeout?: number;
+    depends_on?: string[];
+    condition?: string;
+}, {
+    id?: string;
+    retry?: {
+        max_attempts?: number;
+        backoff?: "fixed" | "exponential";
+        initial_delay?: number;
+    };
+    config?: Record<string, unknown>;
+    name?: string;
+    type?: string;
+    timeout?: number;
+    depends_on?: string[];
+    condition?: string;
+}>;
+export type NodeDefinition = z.infer<typeof NodeDefinitionSchema>;
+/**
+ * Node interface - base interface for all workflow nodes
+ */
+export interface Node {
+    /** Node type identifier */
+    readonly type: string;
+    /** Node unique identifier */
+    readonly id: string;
+    /** Execute the node with the given context */
+    execute(context: NodeExecutionContext): Promise<NodeExecutionResult>;
+}
+import type { NodeExecutionContext, NodeExecutionResult } from './run';
+export declare const WorkflowConfigSchema: z.ZodObject<{
+    parallel_limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    retry: z.ZodOptional<z.ZodObject<{
+        max_attempts: z.ZodDefault<z.ZodNumber>;
+        backoff: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+        initial_delay: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        max_attempts?: number;
+        backoff?: "fixed" | "exponential";
+        initial_delay?: number;
+    }, {
+        max_attempts?: number;
+        backoff?: "fixed" | "exponential";
+        initial_delay?: number;
+    }>>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    retry?: {
+        max_attempts?: number;
+        backoff?: "fixed" | "exponential";
+        initial_delay?: number;
+    };
+    debug?: boolean;
+    timeout?: number;
+    parallel_limit?: number;
+}, {
+    retry?: {
+        max_attempts?: number;
+        backoff?: "fixed" | "exponential";
+        initial_delay?: number;
+    };
+    debug?: boolean;
+    timeout?: number;
+    parallel_limit?: number;
+}>;
+export type WorkflowConfig = z.infer<typeof WorkflowConfigSchema>;
+export declare const OutputDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    source: z.ZodString;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    source?: string;
+    path?: string;
+}, {
+    name?: string;
+    source?: string;
+    path?: string;
+}>;
+export type OutputDefinition = z.infer<typeof OutputDefinitionSchema>;
+export declare const WorkflowMetadataSchema: z.ZodObject<{
+    author: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    created_at: z.ZodOptional<z.ZodString>;
+    updated_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    tags?: string[];
+    created_at?: string;
+    updated_at?: string;
+    taskId?: number;
+    author?: string;
+}, {
+    tags?: string[];
+    created_at?: string;
+    updated_at?: string;
+    taskId?: number;
+    author?: string;
+}>;
+export type WorkflowMetadata = z.infer<typeof WorkflowMetadataSchema>;
+export declare const WorkflowDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    config: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        parallel_limit: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            max_attempts: z.ZodDefault<z.ZodNumber>;
+            backoff: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+            initial_delay: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        }, {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        }>>;
+        debug: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        retry?: {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        };
+        debug?: boolean;
+        timeout?: number;
+        parallel_limit?: number;
+    }, {
+        retry?: {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        };
+        debug?: boolean;
+        timeout?: number;
+        parallel_limit?: number;
+    }>>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        config: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        depends_on: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        condition: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            max_attempts: z.ZodDefault<z.ZodNumber>;
+            backoff: z.ZodDefault<z.ZodEnum<["fixed", "exponential"]>>;
+            initial_delay: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        }, {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        }>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        retry?: {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        };
+        config?: Record<string, unknown>;
+        name?: string;
+        type?: string;
+        timeout?: number;
+        depends_on?: string[];
+        condition?: string;
+    }, {
+        id?: string;
+        retry?: {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        };
+        config?: Record<string, unknown>;
+        name?: string;
+        type?: string;
+        timeout?: number;
+        depends_on?: string[];
+        condition?: string;
+    }>, "many">;
+    entry: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    outputs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        source: z.ZodString;
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name?: string;
+        source?: string;
+        path?: string;
+    }, {
+        name?: string;
+        source?: string;
+        path?: string;
+    }>, "many">>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        author: z.ZodOptional<z.ZodString>;
+        taskId: z.ZodOptional<z.ZodNumber>;
+        tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        tags?: string[];
+        created_at?: string;
+        updated_at?: string;
+        taskId?: number;
+        author?: string;
+    }, {
+        tags?: string[];
+        created_at?: string;
+        updated_at?: string;
+        taskId?: number;
+        author?: string;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    config?: {
+        retry?: {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        };
+        debug?: boolean;
+        timeout?: number;
+        parallel_limit?: number;
+    };
+    name?: string;
+    version?: string;
+    description?: string;
+    entry?: string | string[];
+    metadata?: {
+        tags?: string[];
+        created_at?: string;
+        updated_at?: string;
+        taskId?: number;
+        author?: string;
+    };
+    nodes?: {
+        id?: string;
+        retry?: {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        };
+        config?: Record<string, unknown>;
+        name?: string;
+        type?: string;
+        timeout?: number;
+        depends_on?: string[];
+        condition?: string;
+    }[];
+    outputs?: {
+        name?: string;
+        source?: string;
+        path?: string;
+    }[];
+}, {
+    config?: {
+        retry?: {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        };
+        debug?: boolean;
+        timeout?: number;
+        parallel_limit?: number;
+    };
+    name?: string;
+    version?: string;
+    description?: string;
+    entry?: string | string[];
+    metadata?: {
+        tags?: string[];
+        created_at?: string;
+        updated_at?: string;
+        taskId?: number;
+        author?: string;
+    };
+    nodes?: {
+        id?: string;
+        retry?: {
+            max_attempts?: number;
+            backoff?: "fixed" | "exponential";
+            initial_delay?: number;
+        };
+        config?: Record<string, unknown>;
+        name?: string;
+        type?: string;
+        timeout?: number;
+        depends_on?: string[];
+        condition?: string;
+    }[];
+    outputs?: {
+        name?: string;
+        source?: string;
+        path?: string;
+    }[];
+}>;
+export type WorkflowDefinition = z.infer<typeof WorkflowDefinitionSchema>;
+export interface WorkflowDefinitionExtended extends WorkflowDefinition {
+    computedEntry: string[];
+    nodeMap: Map<string, NodeDefinition>;
+    topologicalOrder: string[];
+}
+export interface Workflow {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    definition: WorkflowDefinition;
+    config: WorkflowConfig;
+    metadata: WorkflowMetadata;
+    tags: string[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ParsedWorkflow {
+    format: 'yaml' | 'json';
+    definition: WorkflowDefinition;
+}
+/**
+ * 解析 Workflow 文件
+ * @param content 文件内容
+ * @param filename 文件名，用于自动检测格式
+ */
+export declare function parseWorkflowFile(content: string, filename: string): Promise<ParsedWorkflow>;
+/**
+ * Synchronous version of parseWorkflowFile
+ * Uses JSON parsing only for auto-detection
+ */
+export declare function parseWorkflowFileSync(content: string, filename: string): ParsedWorkflow;
+//# sourceMappingURL=workflow.d.ts.map

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

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+// ==================== Schema 定义 ====================
+// 节点依赖配置
+export const DependsOnSchema = z.array(z.string());
+// 重试配置
+export const RetryConfigSchema = z.object({
+    max_attempts: z.number().min(1).default(1),
+    backoff: z.enum(['fixed', 'exponential']).default('exponential'),
+    initial_delay: z.number().min(0).default(1000),
+});
+// 节点定义 Schema
+export const NodeDefinitionSchema = z.object({
+    id: z.string().min(1, 'Node ID is required'),
+    type: z.string().min(1, 'Node type is required'),
+    name: z.string().optional(),
+    config: z.record(z.string(), z.unknown()).optional().default({}),
+    depends_on: z.array(z.string()).optional(),
+    condition: z.string().optional(),
+    retry: RetryConfigSchema.optional(),
+    timeout: z.number().optional(),
+});
+// Workflow 配置
+export const WorkflowConfigSchema = z.object({
+    parallel_limit: z.number().nullable().optional(),
+    timeout: z.number().nullable().optional(),
+    retry: RetryConfigSchema.optional(),
+    debug: z.boolean().optional(),
+});
+// 输出定义
+export const OutputDefinitionSchema = z.object({
+    name: z.string(),
+    source: z.string(),
+    path: z.string(),
+});
+// Workflow 元数据
+export const WorkflowMetadataSchema = z.object({
+    author: z.string().optional(),
+    taskId: z.number().optional(), // 新增：关联的任务 ID
+    tags: z.array(z.string()).optional().default([]),
+    created_at: z.string().optional(),
+    updated_at: z.string().optional(),
+});
+// ==================== Workflow 定义 ====================
+export const WorkflowDefinitionSchema = z.object({
+    name: z.string().min(1, 'Workflow name is required'),
+    version: z.string().default('1.0'),
+    description: z.string().optional(),
+    config: WorkflowConfigSchema.optional().default({}),
+    nodes: z.array(NodeDefinitionSchema).min(1, 'At least one node is required'),
+    entry: z.union([z.string(), z.array(z.string())]).default('__default_entry__'),
+    outputs: z.array(OutputDefinitionSchema).optional().default([]),
+    metadata: WorkflowMetadataSchema.optional().default({}),
+});
+// YAML parser placeholder - will be implemented with yaml package
+let yamlParser = null;
+async function getYamlParser() {
+    if (!yamlParser) {
+        yamlParser = await import('yaml');
+    }
+    return yamlParser;
+}
+/**
+ * 解析 Workflow 文件
+ * @param content 文件内容
+ * @param filename 文件名，用于自动检测格式
+ */
+export async function parseWorkflowFile(content, filename) {
+    const isYaml = filename.endsWith('.yaml') || filename.endsWith('.yml');
+    const isJson = filename.endsWith('.json');
+    let definition;
+    if (isYaml) {
+        const yaml = await getYamlParser();
+        definition = WorkflowDefinitionSchema.parse(yaml.parse(content));
+    }
+    else if (isJson) {
+        definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+    }
+    else {
+        // 尝试自动检测
+        try {
+            definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+        }
+        catch {
+            const yaml = await getYamlParser();
+            definition = WorkflowDefinitionSchema.parse(yaml.parse(content));
+        }
+    }
+    return {
+        format: isYaml ? 'yaml' : 'json',
+        definition
+    };
+}
+/**
+ * Synchronous version of parseWorkflowFile
+ * Uses JSON parsing only for auto-detection
+ */
+export function parseWorkflowFileSync(content, filename) {
+    const isYaml = filename.endsWith('.yaml') || filename.endsWith('.yml');
+    const isJson = filename.endsWith('.json');
+    let definition;
+    if (isJson) {
+        definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+    }
+    else if (isYaml) {
+        // For sync YAML parsing, we need the yaml package synchronously
+        // This will throw if yaml is not imported, but that's acceptable
+        // for production use where async parsing is preferred
+        throw new Error('Synchronous YAML parsing not supported. Use parseWorkflowFile() instead.');
+    }
+    else {
+        // 尝试自动检测 JSON
+        try {
+            definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
+        }
+        catch {
+            throw new Error('Cannot auto-detect format. Please use .yaml, .yml, or .json extension.');
+        }
+    }
+    return {
+        format: isJson ? 'json' : 'yaml',
+        definition
+    };
+}
+//# sourceMappingURL=workflow.js.map

package/dist/core/src/env/workflow/types/workflow.test.d.ts

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