@yiyi_zhang/reactflow-ui 0.1.0

package/dist/sample-workflows/sample-execution.json

@@ -0,0 +1,327 @@
+{
+    "workflowId": "wf_1234567890",
+    "status": "COMPLETED",
+    "startTime": 1704546000000,
+    "endTime": 1704546060000,
+    "workflowDefinition": {
+        "name": "complex_workflow",
+        "description": "综合示例：包含多种任务类型和嵌套结构",
+        "version": 1,
+        "tasks": [
+            {
+                "name": "initialize",
+                "taskReferenceName": "init_ref",
+                "type": "SIMPLE",
+                "inputParameters": {
+                    "workflowId": "${workflow.workflowId}"
+                }
+            },
+            {
+                "name": "check_environment",
+                "taskReferenceName": "env_check_ref",
+                "type": "DECISION",
+                "inputParameters": {
+                    "environment": "${workflow.input.environment}"
+                },
+                "caseValueParam": "environment",
+                "decisionCases": {
+                    "production": [
+                        {
+                            "name": "prod_validation",
+                            "taskReferenceName": "prod_valid_ref",
+                            "type": "SIMPLE",
+                            "inputParameters": {
+                                "strict": true
+                            }
+                        },
+                        {
+                            "name": "prod_parallel_tasks",
+                            "taskReferenceName": "prod_fork_ref",
+                            "type": "FORK_JOIN",
+                            "forkTasks": [
+                                [
+                                    {
+                                        "name": "security_check",
+                                        "taskReferenceName": "security_ref",
+                                        "type": "HTTP",
+                                        "inputParameters": {
+                                            "uri": "https://api.example.com/security/check"
+                                        }
+                                    }
+                                ],
+                                [
+                                    {
+                                        "name": "compliance_check",
+                                        "taskReferenceName": "compliance_ref",
+                                        "type": "SIMPLE",
+                                        "inputParameters": {
+                                            "level": "strict"
+                                        }
+                                    }
+                                ]
+                            ]
+                        },
+                        {
+                            "name": "join_prod_checks",
+                            "taskReferenceName": "prod_join_ref",
+                            "type": "JOIN",
+                            "joinOn": [
+                                "security_ref",
+                                "compliance_ref"
+                            ]
+                        }
+                    ],
+                    "staging": [
+                        {
+                            "name": "staging_validation",
+                            "taskReferenceName": "staging_valid_ref",
+                            "type": "SIMPLE"
+                        }
+                    ]
+                },
+                "defaultCase": [
+                    {
+                        "name": "dev_validation",
+                        "taskReferenceName": "dev_valid_ref",
+                        "type": "SIMPLE"
+                    }
+                ]
+            },
+            {
+                "name": "process_data_loop",
+                "taskReferenceName": "loop_ref",
+                "type": "DO_WHILE",
+                "loopOver": [
+                    {
+                        "name": "process_item",
+                        "taskReferenceName": "process_item_ref",
+                        "type": "SIMPLE"
+                    },
+                    {
+                        "name": "transform_item",
+                        "taskReferenceName": "transform_item_ref",
+                        "type": "JSON_JQ_TRANSFORM"
+                    }
+                ]
+            },
+            {
+                "name": "invoke_sub_workflow",
+                "taskReferenceName": "sub_wf_ref",
+                "type": "SUB_WORKFLOW",
+                "subWorkflowParam": {
+                    "name": "data_aggregation_workflow",
+                    "version": 1
+                }
+            },
+            {
+                "name": "final_processing",
+                "taskReferenceName": "final_ref",
+                "type": "FORK_JOIN",
+                "forkTasks": [
+                    [
+                        {
+                            "name": "save_to_database",
+                            "taskReferenceName": "db_save_ref",
+                            "type": "SIMPLE"
+                        }
+                    ],
+                    [
+                        {
+                            "name": "publish_event",
+                            "taskReferenceName": "event_ref",
+                            "type": "EVENT"
+                        }
+                    ],
+                    [
+                        {
+                            "name": "send_notification",
+                            "taskReferenceName": "notify_ref",
+                            "type": "KAFKA_PUBLISH"
+                        }
+                    ]
+                ]
+            },
+            {
+                "name": "join_final_tasks",
+                "taskReferenceName": "final_join_ref",
+                "type": "JOIN",
+                "joinOn": [
+                    "db_save_ref",
+                    "event_ref",
+                    "notify_ref"
+                ]
+            },
+            {
+                "name": "cleanup",
+                "taskReferenceName": "cleanup_ref",
+                "type": "SIMPLE"
+            }
+        ],
+        "inputParameters": [
+            "environment",
+            "items"
+        ],
+        "outputParameters": {
+            "result": "${cleanup_ref.output}"
+        },
+        "schemaVersion": 2
+    },
+    "tasks": [
+        {
+            "taskId": "task_init",
+            "referenceTaskName": "init_ref",
+            "status": "COMPLETED",
+            "taskType": "SIMPLE",
+            "startTime": 1704546000000,
+            "endTime": 1704546002000,
+            "inputData": {
+                "workflowId": "wf_1234567890"
+            },
+            "outputData": {
+                "items": [
+                    "Task A"
+                ]
+            }
+        },
+        {
+            "taskId": "task_decision",
+            "referenceTaskName": "env_check_ref",
+            "status": "COMPLETED",
+            "taskType": "DECISION",
+            "startTime": 1704546003000,
+            "endTime": 1704546004000,
+            "inputData": {
+                "environment": "production"
+            },
+            "outputData": {
+                "case": "production"
+            }
+        },
+        {
+            "taskId": "task_prod_valid",
+            "referenceTaskName": "prod_valid_ref",
+            "status": "COMPLETED",
+            "taskType": "SIMPLE",
+            "startTime": 1704546005000,
+            "endTime": 1704546007000
+        },
+        {
+            "taskId": "task_prod_fork",
+            "referenceTaskName": "prod_fork_ref",
+            "status": "COMPLETED",
+            "taskType": "FORK",
+            "startTime": 1704546008000,
+            "endTime": 1704546008100
+        },
+        {
+            "taskId": "task_security",
+            "referenceTaskName": "security_ref",
+            "status": "COMPLETED",
+            "taskType": "HTTP",
+            "startTime": 1704546009000,
+            "endTime": 1704546012000
+        },
+        {
+            "taskId": "task_compliance",
+            "referenceTaskName": "compliance_ref",
+            "status": "COMPLETED",
+            "taskType": "SIMPLE",
+            "startTime": 1704546009000,
+            "endTime": 1704546011000
+        },
+        {
+            "taskId": "task_prod_join",
+            "referenceTaskName": "prod_join_ref",
+            "status": "COMPLETED",
+            "taskType": "JOIN",
+            "startTime": 1704546013000,
+            "endTime": 1704546013500
+        },
+        {
+            "taskId": "task_loop",
+            "referenceTaskName": "loop_ref",
+            "status": "COMPLETED",
+            "taskType": "DO_WHILE",
+            "startTime": 1704546014000,
+            "endTime": 1704546025000
+        },
+        {
+            "taskId": "task_process_item",
+            "referenceTaskName": "process_item_ref",
+            "status": "COMPLETED",
+            "taskType": "SIMPLE",
+            "startTime": 1704546015000,
+            "endTime": 1704546018000
+        },
+        {
+            "taskId": "task_transform",
+            "referenceTaskName": "transform_item_ref",
+            "status": "COMPLETED",
+            "taskType": "JSON_JQ_TRANSFORM",
+            "startTime": 1704546019000,
+            "endTime": 1704546020000
+        },
+        {
+            "taskId": "task_subwf",
+            "referenceTaskName": "sub_wf_ref",
+            "status": "COMPLETED",
+            "taskType": "SUB_WORKFLOW",
+            "startTime": 1704546026000,
+            "endTime": 1704546035000
+        },
+        {
+            "taskId": "task_final_fork",
+            "referenceTaskName": "final_ref",
+            "status": "COMPLETED",
+            "taskType": "FORK",
+            "startTime": 1704546036000,
+            "endTime": 1704546036100
+        },
+        {
+            "taskId": "task_db_save",
+            "referenceTaskName": "db_save_ref",
+            "status": "COMPLETED",
+            "taskType": "SIMPLE",
+            "startTime": 1704546037000,
+            "endTime": 1704546042000
+        },
+        {
+            "taskId": "task_event",
+            "referenceTaskName": "event_ref",
+            "status": "COMPLETED",
+            "taskType": "EVENT",
+            "startTime": 1704546037000,
+            "endTime": 1704546039000
+        },
+        {
+            "taskId": "task_notify",
+            "referenceTaskName": "notify_ref",
+            "status": "COMPLETED",
+            "taskType": "KAFKA_PUBLISH",
+            "startTime": 1704546037000,
+            "endTime": 1704546040000
+        },
+        {
+            "taskId": "task_final_join",
+            "referenceTaskName": "final_join_ref",
+            "status": "COMPLETED",
+            "taskType": "JOIN",
+            "startTime": 1704546043000,
+            "endTime": 1704546043500
+        },
+        {
+            "taskId": "task_cleanup",
+            "referenceTaskName": "cleanup_ref",
+            "status": "COMPLETED",
+            "taskType": "SIMPLE",
+            "startTime": 1704546044000,
+            "endTime": 1704546050000
+        }
+    ],
+    "input": {
+        "environment": "production"
+    },
+    "output": {
+        "status": "Finished"
+    }
+}

package/dist/sample-workflows/simple-workflow.json

@@ -0,0 +1,42 @@
+{
+  "name": "simple_sequential_workflow",
+  "description": "简单的顺序工作流示例",
+  "version": 1,
+  "tasks": [
+    {
+      "name": "fetch_user_data",
+      "taskReferenceName": "fetch_user_ref",
+      "type": "HTTP",
+      "inputParameters": {
+        "http_request": {
+          "uri": "https://api.example.com/users/${workflow.input.userId}",
+          "method": "GET"
+        }
+      }
+    },
+    {
+      "name": "transform_data",
+      "taskReferenceName": "transform_ref",
+      "type": "JSON_JQ_TRANSFORM",
+      "inputParameters": {
+        "data": "${fetch_user_ref.output.response.body}",
+        "queryExpression": ".user | {id, name, email}"
+      }
+    },
+    {
+      "name": "send_notification",
+      "taskReferenceName": "notify_ref",
+      "type": "SIMPLE",
+      "inputParameters": {
+        "userId": "${transform_ref.output.id}",
+        "message": "User data processed successfully"
+      }
+    }
+  ],
+  "inputParameters": ["userId"],
+  "outputParameters": {
+    "result": "${notify_ref.output}"
+  },
+  "schemaVersion": 2,
+  "ownerEmail": "team@example.com"
+}

package/dist/services/aiService.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AI Interaction Service (OpenAI Standard)
+ */
+export interface AIServiceConfig {
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+}
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+/**
+ * 非流式调用（兼容旧逻辑）
+ */
+export declare const callAICopilot: (messages: ChatMessage[], config?: Partial<AIServiceConfig>, signal?: AbortSignal) => Promise<any>;
+/**
+ * 流式调用 - 通过 onToken 回调逐 token 返回内容
+ */
+export declare const callAICopilotStream: (messages: ChatMessage[], config: Partial<AIServiceConfig> | undefined, onToken: (token: string) => void, onDone?: () => void, signal?: AbortSignal) => Promise<string>;
+/**
+ * System Prompt for Conductor Workflow Modeling
+ */
+export declare const CONDUCTOR_SYSTEM_PROMPT = "\nYou are an expert in Netflix Conductor Workflow modeling.\nYour goal is to help users design JSON-based workflows.\n\nCONSTRANTS:\n1. Always output valid Conductor JSON within blocks if suggesting changes.\n2. Use standard task types: SIMPLE, FORK_JOIN, SWITCH, DO_WHILE, SUB_WORKFLOW, EVENT, WAIT, TERMINATE.\n3. Every task must have a unique 'taskReferenceName'.\n4. For SWITCH/DECISION, ensure 'decisionCases' and 'defaultCase' are properly structured.\n5. For FORK_JOIN, ensure a corresponding JOIN task follows.\n\nProvide clear, enterprise-grade logic with proper error handling paths.\n";

package/dist/services/promptTemplates.d.ts

@@ -0,0 +1,6 @@
+import { WorkflowDef, TaskDef } from '../types/conductor';
+/**
+ * AI Prompt Template System
+ */
+export declare const generateWorkflowSuggestionPrompt: (userRequest: string, currentWorkflow: WorkflowDef | null) => string;
+export declare const generateParameterHintPrompt: (task: TaskDef, workflow: WorkflowDef | null) => string;

package/dist/store/workflowStore.d.ts

@@ -0,0 +1,30 @@
+import { WorkflowStore, LayoutDirection, EditorMode, ThemeMode, ThemeColor } from '../types/workflow';
+import { WorkflowDef, TaskDef } from '../types/conductor';
+declare const useWorkflowStore: import("zustand").UseBoundStore<Omit<Omit<import("zustand").StoreApi<WorkflowStore>, "setState" | "persist"> & {
+    setState(partial: WorkflowStore | Partial<WorkflowStore> | ((state: WorkflowStore) => WorkflowStore | Partial<WorkflowStore>), replace?: false | undefined): unknown;
+    setState(state: WorkflowStore | ((state: WorkflowStore) => WorkflowStore), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<WorkflowStore, any, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: WorkflowStore) => void) => () => void;
+        onFinishHydration: (fn: (state: WorkflowStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<WorkflowStore, any, unknown>>;
+    };
+}, "temporal"> & {
+    temporal: import("zustand").StoreApi<import("zundo").TemporalState<{
+        workflowDef: WorkflowDef | null;
+        layoutDirection: LayoutDirection;
+        nodes: import("../types/workflow").WorkflowNode[];
+        edges: import("reactflow").Edge[];
+        taskMap: Record<string, TaskDef>;
+        theme: ThemeMode;
+        themeColor: ThemeColor;
+        mode: EditorMode;
+        edgeType: string;
+        nodesLocked: boolean;
+        copiedTask: TaskDef | null;
+    }>>;
+}>;
+export default useWorkflowStore;

package/dist/types/conductor.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Conductor 任务类型枚举
+ */
+export type TaskType = 'SIMPLE' | 'DYNAMIC' | 'FORK_JOIN' | 'FORK_JOIN_DYNAMIC' | 'DECISION' | 'SWITCH' | 'JOIN' | 'DO_WHILE' | 'SUB_WORKFLOW' | 'EVENT' | 'WAIT' | 'HUMAN' | 'USER_DEFINED' | 'HTTP' | 'LAMBDA' | 'EXCLUSIVE_JOIN' | 'TERMINATE' | 'KAFKA_PUBLISH' | 'JSON_JQ_TRANSFORM' | 'SET_VARIABLE';
+/**
+ * Conductor 任务定义
+ */
+/**
+ * Conductor 任务定义
+ */
+export interface TaskDef {
+    /** 任务名称 (必须唯一) */
+    name: string;
+    /** 任务引用名称 (在工作流内必须唯一) */
+    taskReferenceName: string;
+    /** 任务类型 */
+    type: TaskType;
+    /** 任务描述 */
+    description?: string;
+    /**
+     * 输入参数映射
+     * 支持 JSONPath 表达式 (e.g. `${workflow.input.value}`)
+     */
+    inputParameters?: Record<string, any>;
+    /** Decision case key 参数名 */
+    caseValueParam?: string;
+    /** 分支定义映射 (caseValue -> Task List) */
+    decisionCases?: Record<string, TaskDef[]>;
+    /** 默认分支 */
+    defaultCase?: TaskDef[];
+    /** 并行分支列表 */
+    forkTasks?: TaskDef[][];
+    dynamicForkTasksParam?: string;
+    dynamicForkTasksInputParamName?: string;
+    joinOn?: string[];
+    loopCondition?: string;
+    loopOver?: TaskDef[];
+    subWorkflowParam?: {
+        name: string;
+        version?: number;
+    };
+    optional?: boolean;
+    asyncComplete?: boolean;
+    startDelay?: number;
+    httpRequest?: {
+        method?: string;
+        uri?: string;
+        headers?: Record<string, string>;
+        body?: any;
+    };
+    sink?: string;
+    caseExpression?: string;
+    retryCount?: number;
+    timeoutSeconds?: number;
+}
+/**
+ * Conductor 工作流定义
+ */
+/**
+ * Conductor 工作流定义
+ */
+export interface WorkflowDef {
+    /** 工作流名称 */
+    name: string;
+    /** 工作流描述 */
+    description?: string;
+    /** 版本号 */
+    version?: number;
+    /** 任务列表 (DAG 定义) */
+    tasks: TaskDef[];
+    /** 输入参数定义 (用于文档生成) */
+    inputParameters?: any[];
+    /** 输出参数映射 */
+    outputParameters?: Record<string, any>;
+    schemaVersion?: number;
+    restartable?: boolean;
+    workflowStatusListenerEnabled?: boolean;
+    ownerEmail?: string;
+    timeoutPolicy?: 'TIME_OUT_WF' | 'ALERT_ONLY';
+    timeoutSeconds?: number;
+    variables?: Record<string, any>;
+    /** 失败时触发的补偿工作流名称 */
+    failureWorkflow?: string;
+    /** 默认输入模板 */
+    inputTemplate?: Record<string, any>;
+    /** 状态事件发送目标 */
+    workflowStatusListenerSink?: string;
+    /** 并发限流配置 */
+    rateLimitConfig?: {
+        rateLimitKey?: string;
+        concurrentExecLimit?: number;
+    };
+    /** 输入 Schema 定义 */
+    inputSchema?: {
+        name?: string;
+        type?: string;
+    };
+    /** 输出 Schema 定义 */
+    outputSchema?: {
+        name?: string;
+        type?: string;
+    };
+    /** 是否强制 Schema 校验 */
+    enforceSchema?: boolean;
+}
+/**
+ * Conductor 任务实例 (运行时)
+ */
+export interface TaskInstance {
+    taskType: string;
+    status: 'IN_PROGRESS' | 'CANCELED' | 'FAILED' | 'FAILED_WITH_TERMINAL_ERROR' | 'COMPLETED' | 'COMPLETED_WITH_ERRORS' | 'SCHEDULED' | 'TIMED_OUT' | 'SKIPPED';
+    inputData?: Record<string, any>;
+    outputData?: Record<string, any>;
+    referenceTaskName: string;
+    retryCount?: number;
+    iteration?: number;
+    seq?: number;
+    correlationId?: string;
+    pollCount?: number;
+    taskDefName?: string;
+    scheduledTime?: number;
+    startTime?: number;
+    endTime?: number;
+    updateTime?: number;
+    startDelayInSeconds?: number;
+    retriedTaskId?: string;
+    retried?: boolean;
+    executed?: boolean;
+    callbackFromWorker?: boolean;
+    responseTimeoutSeconds?: number;
+    workflowInstanceId: string;
+    workflowType?: string;
+    taskId: string;
+    reasonForIncompletion?: string;
+    callbackAfterSeconds?: number;
+    workerId?: string;
+    externalInputPayloadStoragePath?: string;
+    externalOutputPayloadStoragePath?: string;
+}
+/**
+ * Conductor 工作流实例 (运行时)
+ */
+export interface WorkflowInstance {
+    status: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
+    endTime?: number;
+    workflowId: string;
+    parentWorkflowId?: string;
+    parentWorkflowTaskId?: string;
+    tasks: TaskInstance[];
+    input?: Record<string, any>;
+    output?: Record<string, any>;
+    correlationId?: string;
+    reRunFromWorkflowId?: string;
+    reasonForIncompletion?: string;
+    event?: string;
+    taskToDomain?: Record<string, string>;
+    failedReferenceTaskNames?: string[];
+    failedTaskNames?: string[];
+    workflowDefinition: WorkflowDef;
+    externalInputPayloadStoragePath?: string;
+    externalOutputPayloadStoragePath?: string;
+    priority?: number;
+    variables?: Record<string, any>;
+    lastRetriedTime?: number;
+    createTime: number;
+    updateTime?: number;
+    startTime?: number;
+    createdBy?: string;
+    updatedBy?: string;
+}