From a7bcc7f06fd2babf37de08d05667a1b7ff3fb7ad Mon Sep 17 00:00:00 2001
From: jingrow <support@jingrow.com>
Date: Sat, 1 Nov 2025 03:51:05 +0800
Subject: [PATCH] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=97=A0=E6=95=88=E7=9A=84?=
 =?UTF-8?q?=E8=8A=82=E7=82=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../data_processing/data_processing.json      |  31 --
 .../nodes/data_processing/data_processing.py  |  43 ---
 .../go_concurrent_tasks.go                    | 305 -----------------
 .../go_concurrent_tasks.json                  | 174 ----------
 .../go_data_processing/go_data_processing.go  | 273 ---------------
 .../go_data_processing.json                   |  86 -----
 .../go_file_operations/go_file_operations.go  | 311 ------------------
 .../go_file_operations.json                   | 160 ---------
 .../ai/nodes/go_http_client/go_http_client.go | 138 --------
 .../nodes/go_http_client/go_http_client.json  |  79 -----
 .../ai/nodes/language_go/language_go.go       |  52 ---
 .../ai/nodes/language_go/language_go.json     |  31 --
 .../language_python/language_python.json      |  31 --
 .../nodes/language_python/language_python.py  |  43 ---
 .../ai/nodes/language_rust/language_rust.json |  31 --
 .../ai/nodes/language_rust/language_rust.rs   |  53 ---
 .../ai/nodes/rust_crypto/rust_crypto.json     |  93 ------
 .../ai/nodes/rust_crypto/rust_crypto.rs       |  28 --
 .../rust_image_processing.json                |  95 ------
 .../rust_image_processing.rs                  |  26 --
 .../rust_numeric_computing.json               | 224 -------------
 .../rust_numeric_computing.rs                 |  34 --
 .../rust_regex_processing.json                | 184 -----------
 .../rust_regex_processing.rs                  |  34 --
 24 files changed, 2559 deletions(-)
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/data_processing/data_processing.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/data_processing/data_processing.py
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/go_concurrent_tasks/go_concurrent_tasks.go
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/go_concurrent_tasks/go_concurrent_tasks.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/go_data_processing/go_data_processing.go
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/go_data_processing/go_data_processing.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/go_file_operations/go_file_operations.go
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/go_file_operations/go_file_operations.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/go_http_client/go_http_client.go
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/go_http_client/go_http_client.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/language_go/language_go.go
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/language_go/language_go.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/language_python/language_python.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/language_python/language_python.py
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/language_rust/language_rust.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/language_rust/language_rust.rs
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/rust_crypto/rust_crypto.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/rust_crypto/rust_crypto.rs
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/rust_image_processing/rust_image_processing.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/rust_image_processing/rust_image_processing.rs
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/rust_numeric_computing/rust_numeric_computing.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/rust_numeric_computing/rust_numeric_computing.rs
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/rust_regex_processing/rust_regex_processing.json
 delete mode 100644 apps/jingrow/jingrow/ai/nodes/rust_regex_processing/rust_regex_processing.rs

diff --git a/apps/jingrow/jingrow/ai/nodes/data_processing/data_processing.json b/apps/jingrow/jingrow/ai/nodes/data_processing/data_processing.json
deleted file mode 100644
index 3cd434b..0000000
--- a/apps/jingrow/jingrow/ai/nodes/data_processing/data_processing.json
+++ /dev/null
@@ -1,31 +0,0 @@
-{
-  "name": "数据处理节点",
-  "description": "对输入数据进行处理和转换",
-  "version": "1.0.0",
-  "author": "jingrow",
-  "category": "processing",
-  "inputs": [
-    {
-      "name": "data",
-      "type": "array",
-      "description": "要处理的数据数组",
-      "required": true
-    }
-  ],
-  "outputs": [
-    {
-      "name": "processed_data",
-      "type": "array",
-      "description": "处理后的数据"
-    },
-    {
-      "name": "summary",
-      "type": "object",
-      "description": "处理摘要信息"
-    }
-  ],
-  "config": {
-    "timeout": 30,
-    "memory_limit": "256m"
-  }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/data_processing/data_processing.py b/apps/jingrow/jingrow/ai/nodes/data_processing/data_processing.py
deleted file mode 100644
index 0348c5c..0000000
--- a/apps/jingrow/jingrow/ai/nodes/data_processing/data_processing.py
+++ /dev/null
@@ -1,43 +0,0 @@
-def execute(context=None, inputs=None, config=None):
-    """
-    数据处理节点
-    对输入数据进行处理和转换
-    """
-    try:
-        data = inputs.get('data', [])
-        if not data:
-            return {"success": False, "error": "没有提供数据"}
-        
-        # 数据处理逻辑
-        processed_data = []
-        for item in data:
-            if isinstance(item, dict):
-                # 添加处理时间戳
-                item['processed_at'] = context.get('timestamp', 'unknown')
-                # 添加处理节点信息
-                item['processed_by'] = 'data_processing_node'
-                processed_data.append(item)
-            else:
-                # 简单数据类型处理
-                processed_data.append({
-                    'original_value': item,
-                    'processed_at': context.get('timestamp', 'unknown'),
-                    'processed_by': 'data_processing_node'
-                })
-        
-        return {
-            "success": True,
-            "processed_data": processed_data,
-            "summary": {
-                "total_items": len(data),
-                "processed_items": len(processed_data),
-                "processing_time": 0.1
-            }
-        }
-        
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e),
-            "error_type": type(e).__name__
-        }
diff --git a/apps/jingrow/jingrow/ai/nodes/go_concurrent_tasks/go_concurrent_tasks.go b/apps/jingrow/jingrow/ai/nodes/go_concurrent_tasks/go_concurrent_tasks.go
deleted file mode 100644
index 5f0b3c9..0000000
--- a/apps/jingrow/jingrow/ai/nodes/go_concurrent_tasks/go_concurrent_tasks.go
+++ /dev/null
@@ -1,305 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"os"
-	"sync"
-	"time"
-)
-
-// Go并发任务调度节点请求结构
-type GoConcurrentTasksRequest struct {
-	Context map[string]interface{} `json:"context"`
-	Inputs  map[string]interface{} `json:"inputs"`
-	Config  map[string]interface{} `json:"config"`
-}
-
-// Go并发任务调度节点响应结构
-type GoConcurrentTasksResponse struct {
-	Success bool                   `json:"success"`
-	Output  string                 `json:"output,omitempty"`
-	Result  map[string]interface{} `json:"result,omitempty"`
-	Error   string                 `json:"error,omitempty"`
-}
-
-// 任务结果结构
-type TaskResult struct {
-	TaskID    string      `json:"task_id"`
-	Success   bool        `json:"success"`
-	Result    interface{} `json:"result"`
-	Error     string      `json:"error"`
-	Duration  int64       `json:"duration_ms"`
-}
-
-func main() {
-	var req GoConcurrentTasksRequest
-	json.NewDecoder(os.Stdin).Decode(&req)
-	
-	result := execute(req.Context, req.Inputs, req.Config)
-	
-	output, _ := json.Marshal(result)
-	fmt.Println(string(output))
-}
-
-// Go并发任务调度节点执行函数
-func execute(context, inputs, config map[string]interface{}) GoConcurrentTasksResponse {
-	// 获取配置参数
-	tasks, ok := config["tasks"].([]interface{})
-	if !ok {
-		return GoConcurrentTasksResponse{
-			Success: false,
-			Error:   "缺少任务列表配置",
-		}
-	}
-	
-	maxConcurrency, ok := config["max_concurrency"].(float64)
-	if !ok {
-		maxConcurrency = 10 // 默认最大并发数
-	}
-	
-	timeout, ok := config["timeout"].(float64)
-	if !ok {
-		timeout = 30 // 默认超时30秒
-	}
-	
-	// 创建并发控制
-	semaphore := make(chan struct{}, int(maxConcurrency))
-	var wg sync.WaitGroup
-	var mu sync.Mutex
-	var results []TaskResult
-	
-	// 并发执行任务
-	for i, taskInterface := range tasks {
-		task, ok := taskInterface.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		
-		wg.Add(1)
-		go func(taskID int, task map[string]interface{}) {
-			defer wg.Done()
-			
-			// 获取信号量
-			semaphore <- struct{}{}
-			defer func() { <-semaphore }()
-			
-			// 执行任务
-			result := executeTask(taskID, task, timeout)
-			
-			// 线程安全地添加结果
-			mu.Lock()
-			results = append(results, result)
-			mu.Unlock()
-		}(i, task)
-	}
-	
-	// 等待所有任务完成
-	wg.Wait()
-	
-	// 统计结果
-	successCount := 0
-	failureCount := 0
-	totalDuration := int64(0)
-	
-	for _, result := range results {
-		if result.Success {
-			successCount++
-		} else {
-			failureCount++
-		}
-		totalDuration += result.Duration
-	}
-	
-	return GoConcurrentTasksResponse{
-		Success: true,
-		Output:  fmt.Sprintf("并发任务执行完成: 成功%d个, 失败%d个", successCount, failureCount),
-		Result: map[string]interface{}{
-			"total_tasks":      len(tasks),
-			"success_count":   successCount,
-			"failure_count":   failureCount,
-			"total_duration":  totalDuration,
-			"avg_duration":    float64(totalDuration) / float64(len(results)),
-			"max_concurrency": maxConcurrency,
-			"results":         results,
-			"language":        "go",
-			"performance":     "high",
-		},
-	}
-}
-
-// 执行单个任务
-func executeTask(taskID int, task map[string]interface{}, timeout float64) TaskResult {
-	startTime := time.Now()
-	
-	taskType, ok := task["type"].(string)
-	if !ok {
-		return TaskResult{
-			TaskID:   fmt.Sprintf("task_%d", taskID),
-			Success:  false,
-			Error:    "任务类型未指定",
-			Duration: time.Since(startTime).Milliseconds(),
-		}
-	}
-	
-	var result interface{}
-	var err error
-	
-	switch taskType {
-	case "http_request":
-		result, err = executeHTTPTask(task)
-	case "data_processing":
-		result, err = executeDataProcessingTask(task)
-	case "file_operation":
-		result, err = executeFileOperationTask(task)
-	case "sleep":
-		result, err = executeSleepTask(task)
-	default:
-		err = fmt.Errorf("不支持的任务类型: %s", taskType)
-	}
-	
-	duration := time.Since(startTime).Milliseconds()
-	
-	if err != nil {
-		return TaskResult{
-			TaskID:   fmt.Sprintf("task_%d", taskID),
-			Success:  false,
-			Error:    err.Error(),
-			Duration: duration,
-		}
-	}
-	
-	return TaskResult{
-		TaskID:   fmt.Sprintf("task_%d", taskID),
-		Success:  true,
-		Result:   result,
-		Duration: duration,
-	}
-}
-
-// HTTP请求任务
-func executeHTTPTask(task map[string]interface{}) (interface{}, error) {
-	url, ok := task["url"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少URL参数")
-	}
-	
-	method, ok := task["method"].(string)
-	if !ok {
-		method = "GET"
-	}
-	
-	client := &http.Client{Timeout: 10 * time.Second}
-	req, err := http.NewRequest(method, url, nil)
-	if err != nil {
-		return nil, err
-	}
-	
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	
-	return map[string]interface{}{
-		"status_code": resp.StatusCode,
-		"url":         url,
-		"method":      method,
-	}, nil
-}
-
-// 数据处理任务
-func executeDataProcessingTask(task map[string]interface{}) (interface{}, error) {
-	data, ok := task["data"].([]interface{})
-	if !ok {
-		return nil, fmt.Errorf("缺少数据参数")
-	}
-	
-	operation, ok := task["operation"].(string)
-	if !ok {
-		operation = "count"
-	}
-	
-	var result interface{}
-	switch operation {
-	case "count":
-		result = len(data)
-	case "sum":
-		sum := 0.0
-		for _, item := range data {
-			if num, ok := item.(float64); ok {
-				sum += num
-			}
-		}
-		result = sum
-	case "reverse":
-		reversed := make([]interface{}, len(data))
-		for i, item := range data {
-			reversed[len(data)-1-i] = item
-		}
-		result = reversed
-	default:
-		return nil, fmt.Errorf("不支持的操作: %s", operation)
-	}
-	
-	return map[string]interface{}{
-		"operation": operation,
-		"result":    result,
-		"count":     len(data),
-	}, nil
-}
-
-// 文件操作任务
-func executeFileOperationTask(task map[string]interface{}) (interface{}, error) {
-	operation, ok := task["operation"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少操作类型")
-	}
-	
-	switch operation {
-	case "list_directory":
-		path, ok := task["path"].(string)
-		if !ok {
-			return nil, fmt.Errorf("缺少路径参数")
-		}
-		
-		// 模拟目录列表
-		return map[string]interface{}{
-			"operation": "list_directory",
-			"path":      path,
-			"files":     []string{"file1.txt", "file2.txt", "file3.txt"},
-		}, nil
-		
-	case "file_info":
-		filename, ok := task["filename"].(string)
-		if !ok {
-			return nil, fmt.Errorf("缺少文件名参数")
-		}
-		
-		return map[string]interface{}{
-			"operation": "file_info",
-			"filename":  filename,
-			"size":      1024,
-			"modified":  time.Now().Format(time.RFC3339),
-		}, nil
-		
-	default:
-		return nil, fmt.Errorf("不支持的文件操作: %s", operation)
-	}
-}
-
-// 睡眠任务（用于测试）
-func executeSleepTask(task map[string]interface{}) (interface{}, error) {
-	duration, ok := task["duration"].(float64)
-	if !ok {
-		duration = 1.0
-	}
-	
-	time.Sleep(time.Duration(duration) * time.Second)
-	
-	return map[string]interface{}{
-		"operation": "sleep",
-		"duration":  duration,
-	}, nil
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/go_concurrent_tasks/go_concurrent_tasks.json b/apps/jingrow/jingrow/ai/nodes/go_concurrent_tasks/go_concurrent_tasks.json
deleted file mode 100644
index 9cccddd..0000000
--- a/apps/jingrow/jingrow/ai/nodes/go_concurrent_tasks/go_concurrent_tasks.json
+++ /dev/null
@@ -1,174 +0,0 @@
-{
-  "properties": {
-    "node_info": {
-      "type": "string",
-      "title": "节点说明",
-      "description": "",
-      "default": "Go并发任务调度节点利用Go语言的goroutine特性，实现高性能并发任务执行。支持多种任务类型，包括HTTP请求、数据处理、文件操作等。",
-      "format": "info"
-    },
-    "tasks": {
-      "type": "array",
-      "title": "任务列表",
-      "description": "要并发执行的任务列表",
-      "default": [
-        {
-          "type": "data_processing",
-          "data": [1, 2, 3, 4, 5],
-          "operation": "sum"
-        }
-      ],
-      "items": {
-        "type": "object",
-        "title": "任务配置",
-        "properties": {
-          "type": {
-            "type": "string",
-            "title": "任务类型",
-            "description": "选择要执行的任务类型",
-            "enum": [
-              "http_request",
-              "data_processing", 
-              "file_operation",
-              "sleep"
-            ],
-            "enumNames": [
-              "HTTP请求",
-              "数据处理",
-              "文件操作",
-              "睡眠测试"
-            ],
-            "default": "data_processing"
-          },
-          "url": {
-            "type": "string",
-            "title": "请求URL",
-            "description": "HTTP请求任务的URL地址",
-            "placeholder": "https://api.example.com/data"
-          },
-          "method": {
-            "type": "string",
-            "title": "请求方法",
-            "description": "HTTP请求方法",
-            "enum": ["GET", "POST", "PUT", "DELETE"],
-            "enumNames": ["GET", "POST", "PUT", "DELETE"],
-            "default": "GET"
-          },
-          "data": {
-            "type": "array",
-            "title": "数据",
-            "description": "数据处理任务的数据数组"
-          },
-          "operation": {
-            "type": "string",
-            "title": "操作类型",
-            "description": "数据处理操作类型",
-            "enum": ["count", "sum", "reverse"],
-            "enumNames": ["计数", "求和", "反转"],
-            "default": "sum"
-          },
-          "path": {
-            "type": "string",
-            "title": "路径",
-            "description": "文件操作的路径",
-            "placeholder": "/path/to/file"
-          },
-          "filename": {
-            "type": "string",
-            "title": "文件名",
-            "description": "文件操作的文件名",
-            "placeholder": "example.txt"
-          },
-          "duration": {
-            "type": "number",
-            "title": "持续时间(秒)",
-            "description": "睡眠任务的持续时间",
-            "default": 1,
-            "minimum": 0.1,
-            "maximum": 60
-          }
-        },
-        "required": ["type"]
-      },
-      "minItems": 1
-    },
-    "max_concurrency": {
-      "type": "number",
-      "title": "最大并发数",
-      "description": "同时执行的最大任务数，控制并发度",
-      "default": 10,
-      "minimum": 1,
-      "maximum": 100
-    },
-    "timeout": {
-      "type": "number",
-      "title": "超时时间(秒)",
-      "description": "单个任务的超时时间",
-      "default": 30,
-      "minimum": 1,
-      "maximum": 300
-    },
-    "usage_guide": {
-      "type": "string",
-      "title": "使用说明",
-      "description": "Go并发任务调度的使用指南",
-      "default": "Go并发任务调度节点特色：\n• 利用goroutine实现真正的并发执行\n• 支持多种任务类型：HTTP请求、数据处理、文件操作\n• 可控制并发度和超时时间\n• 提供详细的执行统计信息\n\n最佳实践：\n• 合理设置最大并发数，避免资源过载\n• 为长时间任务设置合适的超时时间\n• 使用睡眠任务测试并发性能\n• 监控任务执行统计信息",
-      "format": "info"
-    }
-  },
-  "required": [
-    "tasks"
-  ],
-  "_layout": {
-    "tabs": [
-      {
-        "id": "tab_1",
-        "label": "基础配置",
-        "sections": [
-          {
-            "id": "section_1",
-            "label": "基本属性",
-            "columns": [
-              {
-                "id": "column_1",
-                "label": "主要设置",
-                "fields": [
-                  "node_info",
-                  "tasks"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_2",
-            "label": "并发控制",
-            "columns": [
-              {
-                "id": "column_2",
-                "label": "性能参数",
-                "fields": [
-                  "max_concurrency",
-                  "timeout"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_3",
-            "label": "使用说明",
-            "columns": [
-              {
-                "id": "column_3",
-                "label": "说明文档",
-                "fields": [
-                  "usage_guide"
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "activeTab": "tab_1"
-  }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/go_data_processing/go_data_processing.go b/apps/jingrow/jingrow/ai/nodes/go_data_processing/go_data_processing.go
deleted file mode 100644
index 62c4a54..0000000
--- a/apps/jingrow/jingrow/ai/nodes/go_data_processing/go_data_processing.go
+++ /dev/null
@@ -1,273 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"sort"
-	"strings"
-	"time"
-)
-
-// Go数据处理节点请求结构
-type GoDataProcessingRequest struct {
-	Context map[string]interface{} `json:"context"`
-	Inputs  map[string]interface{} `json:"inputs"`
-	Config  map[string]interface{} `json:"config"`
-}
-
-// Go数据处理节点响应结构
-type GoDataProcessingResponse struct {
-	Success bool                   `json:"success"`
-	Output  string                 `json:"output,omitempty"`
-	Result  map[string]interface{} `json:"result,omitempty"`
-	Error   string                 `json:"error,omitempty"`
-}
-
-func main() {
-	var req GoDataProcessingRequest
-	json.NewDecoder(os.Stdin).Decode(&req)
-	
-	result := execute(req.Context, req.Inputs, req.Config)
-	
-	output, _ := json.Marshal(result)
-	fmt.Println(string(output))
-}
-
-// Go数据处理节点执行函数
-func execute(context, inputs, config map[string]interface{}) GoDataProcessingResponse {
-	// 获取配置参数
-	operation, ok := config["operation"].(string)
-	if !ok {
-		operation = "sort"
-	}
-	
-	data, ok := inputs["data"]
-	if !ok {
-		return GoDataProcessingResponse{
-			Success: false,
-			Error:   "缺少输入数据",
-		}
-	}
-	
-	startTime := time.Now()
-	
-	switch operation {
-	case "sort":
-		return executeSort(data)
-	case "filter":
-		return executeFilter(data, config)
-	case "aggregate":
-		return executeAggregate(data, config)
-	case "transform":
-		return executeTransform(data, config)
-	default:
-		return GoDataProcessingResponse{
-			Success: false,
-			Error:   fmt.Sprintf("不支持的操作: %s", operation),
-		}
-	}
-}
-
-// 排序操作
-func executeSort(data interface{}) GoDataProcessingResponse {
-	var result []interface{}
-	
-	switch v := data.(type) {
-	case []interface{}:
-		// 复制切片
-		result = make([]interface{}, len(v))
-		copy(result, v)
-		
-		// 尝试排序
-		if len(result) > 0 {
-			switch result[0].(type) {
-			case string:
-				stringSlice := make([]string, len(result))
-				for i, item := range result {
-					stringSlice[i] = item.(string)
-				}
-				sort.Strings(stringSlice)
-				for i, item := range stringSlice {
-					result[i] = item
-				}
-			case float64:
-				floatSlice := make([]float64, len(result))
-				for i, item := range result {
-					floatSlice[i] = item.(float64)
-				}
-				sort.Float64s(floatSlice)
-				for i, item := range floatSlice {
-					result[i] = item
-				}
-			}
-		}
-	default:
-		return GoDataProcessingResponse{
-			Success: false,
-			Error:   "数据格式不支持排序",
-		}
-	}
-	
-	return GoDataProcessingResponse{
-		Success: true,
-		Output:  "Go数据处理完成",
-		Result: map[string]interface{}{
-			"operation":     "sort",
-			"processed_data": result,
-			"count":         len(result),
-			"language":      "go",
-			"performance":   "high",
-		},
-	}
-}
-
-// 过滤操作
-func executeFilter(data interface{}, config map[string]interface{}) GoDataProcessingResponse {
-	filterValue, ok := config["filter_value"].(string)
-	if !ok {
-		filterValue = ""
-	}
-	
-	var result []interface{}
-	
-	switch v := data.(type) {
-	case []interface{}:
-		for _, item := range v {
-			if str, ok := item.(string); ok {
-				if strings.Contains(str, filterValue) {
-					result = append(result, item)
-				}
-			}
-		}
-	default:
-		return GoDataProcessingResponse{
-			Success: false,
-			Error:   "数据格式不支持过滤",
-		}
-	}
-	
-	return GoDataProcessingResponse{
-		Success: true,
-		Output:  "Go数据过滤完成",
-		Result: map[string]interface{}{
-			"operation":      "filter",
-			"filter_value":   filterValue,
-			"processed_data": result,
-			"count":          len(result),
-			"language":       "go",
-			"performance":    "high",
-		},
-	}
-}
-
-// 聚合操作
-func executeAggregate(data interface{}, config map[string]interface{}) GoDataProcessingResponse {
-	aggregateType, ok := config["aggregate_type"].(string)
-	if !ok {
-		aggregateType = "sum"
-	}
-	
-	var result interface{}
-	var count int
-	
-	switch v := data.(type) {
-	case []interface{}:
-		count = len(v)
-		switch aggregateType {
-		case "sum":
-			sum := 0.0
-			for _, item := range v {
-				if num, ok := item.(float64); ok {
-					sum += num
-				}
-			}
-			result = sum
-		case "count":
-			result = len(v)
-		case "avg":
-			sum := 0.0
-			validCount := 0
-			for _, item := range v {
-				if num, ok := item.(float64); ok {
-					sum += num
-					validCount++
-				}
-			}
-			if validCount > 0 {
-				result = sum / float64(validCount)
-			} else {
-				result = 0.0
-			}
-		}
-	default:
-		return GoDataProcessingResponse{
-			Success: false,
-			Error:   "数据格式不支持聚合",
-		}
-	}
-	
-	return GoDataProcessingResponse{
-		Success: true,
-		Output:  "Go数据聚合完成",
-		Result: map[string]interface{}{
-			"operation":     aggregateType,
-			"result":        result,
-			"count":         count,
-			"language":      "go",
-			"performance":   "high",
-		},
-	}
-}
-
-// 转换操作
-func executeTransform(data interface{}, config map[string]interface{}) GoDataProcessingResponse {
-	transformType, ok := config["transform_type"].(string)
-	if !ok {
-		transformType = "uppercase"
-	}
-	
-	var result []interface{}
-	
-	switch v := data.(type) {
-	case []interface{}:
-		for _, item := range v {
-			if str, ok := item.(string); ok {
-				switch transformType {
-				case "uppercase":
-					result = append(result, strings.ToUpper(str))
-				case "lowercase":
-					result = append(result, strings.ToLower(str))
-				case "reverse":
-					runes := []rune(str)
-					for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
-						runes[i], runes[j] = runes[j], runes[i]
-					}
-					result = append(result, string(runes))
-				default:
-					result = append(result, str)
-				}
-			} else {
-				result = append(result, item)
-			}
-		}
-	default:
-		return GoDataProcessingResponse{
-			Success: false,
-			Error:   "数据格式不支持转换",
-		}
-	}
-	
-	return GoDataProcessingResponse{
-		Success: true,
-		Output:  "Go数据转换完成",
-		Result: map[string]interface{}{
-			"operation":      "transform",
-			"transform_type": transformType,
-			"processed_data": result,
-			"count":          len(result),
-			"language":       "go",
-			"performance":    "high",
-		},
-	}
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/go_data_processing/go_data_processing.json b/apps/jingrow/jingrow/ai/nodes/go_data_processing/go_data_processing.json
deleted file mode 100644
index 0d1157f..0000000
--- a/apps/jingrow/jingrow/ai/nodes/go_data_processing/go_data_processing.json
+++ /dev/null
@@ -1,86 +0,0 @@
-{
-  "name": "Go数据处理",
-  "description": "使用Go语言进行高性能数据处理",
-  "version": "1.0.0",
-  "category": "data",
-  "inputs": [
-    {
-      "name": "context",
-      "type": "object",
-      "description": "上下文数据"
-    },
-    {
-      "name": "inputs",
-      "type": "object",
-      "description": "输入数据"
-    },
-    {
-      "name": "config",
-      "type": "object",
-      "description": "配置参数"
-    }
-  ],
-  "outputs": [
-    {
-      "name": "success",
-      "type": "boolean",
-      "description": "执行是否成功"
-    },
-    {
-      "name": "output",
-      "type": "string",
-      "description": "执行结果消息"
-    },
-    {
-      "name": "result",
-      "type": "object",
-      "description": "处理结果数据"
-    }
-  ],
-  "config": [
-    {
-      "name": "operation",
-      "type": "select",
-      "label": "操作类型",
-      "required": true,
-      "default": "sort",
-      "options": [
-        {"value": "sort", "label": "排序"},
-        {"value": "filter", "label": "过滤"},
-        {"value": "aggregate", "label": "聚合"},
-        {"value": "transform", "label": "转换"}
-      ]
-    },
-    {
-      "name": "filter_value",
-      "type": "text",
-      "label": "过滤值",
-      "required": false,
-      "description": "过滤操作时使用的值"
-    },
-    {
-      "name": "aggregate_type",
-      "type": "select",
-      "label": "聚合类型",
-      "required": false,
-      "default": "sum",
-      "options": [
-        {"value": "sum", "label": "求和"},
-        {"value": "count", "label": "计数"},
-        {"value": "avg", "label": "平均值"}
-      ]
-    },
-    {
-      "name": "transform_type",
-      "type": "select",
-      "label": "转换类型",
-      "required": false,
-      "default": "uppercase",
-      "options": [
-        {"value": "uppercase", "label": "转大写"},
-        {"value": "lowercase", "label": "转小写"},
-        {"value": "reverse", "label": "反转字符串"}
-      ]
-    }
-  ]
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/go_file_operations/go_file_operations.go b/apps/jingrow/jingrow/ai/nodes/go_file_operations/go_file_operations.go
deleted file mode 100644
index 1608888..0000000
--- a/apps/jingrow/jingrow/ai/nodes/go_file_operations/go_file_operations.go
+++ /dev/null
@@ -1,311 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-// Go文件系统操作节点请求结构
-type GoFileOperationsRequest struct {
-	Context map[string]interface{} `json:"context"`
-	Inputs  map[string]interface{} `json:"inputs"`
-	Config  map[string]interface{} `json:"config"`
-}
-
-// Go文件系统操作节点响应结构
-type GoFileOperationsResponse struct {
-	Success bool                   `json:"success"`
-	Output  string                 `json:"output,omitempty"`
-	Result  map[string]interface{} `json:"result,omitempty"`
-	Error   string                 `json:"error,omitempty"`
-}
-
-func main() {
-	var req GoFileOperationsRequest
-	json.NewDecoder(os.Stdin).Decode(&req)
-	
-	result := execute(req.Context, req.Inputs, req.Config)
-	
-	output, _ := json.Marshal(result)
-	fmt.Println(string(output))
-}
-
-// Go文件系统操作节点执行函数
-func execute(context, inputs, config map[string]interface{}) GoFileOperationsResponse {
-	// 获取配置参数
-	operation, ok := config["operation"].(string)
-	if !ok {
-		return GoFileOperationsResponse{
-			Success: false,
-			Error:   "缺少操作类型配置",
-		}
-	}
-	
-	startTime := time.Now()
-	
-	var result map[string]interface{}
-	var err error
-	
-	switch operation {
-	case "read_file":
-		result, err = executeReadFile(config)
-	case "write_file":
-		result, err = executeWriteFile(config, inputs)
-	case "list_directory":
-		result, err = executeListDirectory(config)
-	case "create_directory":
-		result, err = executeCreateDirectory(config)
-	case "delete_file":
-		result, err = executeDeleteFile(config)
-	case "copy_file":
-		result, err = executeCopyFile(config)
-	case "file_info":
-		result, err = executeFileInfo(config)
-	case "search_files":
-		result, err = executeSearchFiles(config)
-	case "batch_operations":
-		result, err = executeBatchOperations(config, inputs)
-	default:
-		return GoFileOperationsResponse{
-			Success: false,
-			Error:   fmt.Sprintf("不支持的操作类型: %s", operation),
-		}
-	}
-	
-	duration := time.Since(startTime).Milliseconds()
-	
-	if err != nil {
-		return GoFileOperationsResponse{
-			Success: false,
-			Error:   err.Error(),
-		}
-	}
-	
-	// 添加执行信息
-	result["operation"] = operation
-	result["duration_ms"] = duration
-	result["language"] = "go"
-	result["performance"] = "high"
-	
-	return GoFileOperationsResponse{
-		Success: true,
-		Output:  fmt.Sprintf("Go文件操作完成: %s", operation),
-		Result:  result,
-	}
-}
-
-// 读取文件
-func executeReadFile(config map[string]interface{}) (map[string]interface{}, error) {
-	filePath, ok := config["file_path"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少文件路径参数")
-	}
-	
-	// 模拟文件读取
-	content := fmt.Sprintf("模拟文件内容: %s\n时间: %s", filePath, time.Now().Format(time.RFC3339))
-	
-	return map[string]interface{}{
-		"file_path": filePath,
-		"content":   content,
-		"size":      len(content),
-		"encoding":  "utf-8",
-	}, nil
-}
-
-// 写入文件
-func executeWriteFile(config map[string]interface{}, inputs map[string]interface{}) (map[string]interface{}, error) {
-	filePath, ok := config["file_path"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少文件路径参数")
-	}
-	
-	content, ok := inputs["content"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少文件内容")
-	}
-	
-	// 模拟文件写入
-	fileName := filepath.Base(filePath)
-	
-	return map[string]interface{}{
-		"file_path": filePath,
-		"file_name": fileName,
-		"content":   content,
-		"size":      len(content),
-		"created":   time.Now().Format(time.RFC3339),
-	}, nil
-}
-
-// 列出目录
-func executeListDirectory(config map[string]interface{}) (map[string]interface{}, error) {
-	dirPath, ok := config["dir_path"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少目录路径参数")
-	}
-	
-	// 模拟目录列表
-	files := []map[string]interface{}{
-		{
-			"name":    "file1.txt",
-			"size":    1024,
-			"is_dir":  false,
-			"modified": time.Now().Add(-time.Hour).Format(time.RFC3339),
-		},
-		{
-			"name":    "file2.txt",
-			"size":    2048,
-			"is_dir":  false,
-			"modified": time.Now().Add(-2 * time.Hour).Format(time.RFC3339),
-		},
-		{
-			"name":    "subdir",
-			"size":    0,
-			"is_dir":  true,
-			"modified": time.Now().Add(-3 * time.Hour).Format(time.RFC3339),
-		},
-	}
-	
-	return map[string]interface{}{
-		"dir_path": dirPath,
-		"files":    files,
-		"count":    len(files),
-	}, nil
-}
-
-// 创建目录
-func executeCreateDirectory(config map[string]interface{}) (map[string]interface{}, error) {
-	dirPath, ok := config["dir_path"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少目录路径参数")
-	}
-	
-	// 模拟目录创建
-	return map[string]interface{}{
-		"dir_path": dirPath,
-		"created":  time.Now().Format(time.RFC3339),
-		"success":  true,
-	}, nil
-}
-
-// 删除文件
-func executeDeleteFile(config map[string]interface{}) (map[string]interface{}, error) {
-	filePath, ok := config["file_path"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少文件路径参数")
-	}
-	
-	// 模拟文件删除
-	return map[string]interface{}{
-		"file_path": filePath,
-		"deleted":   time.Now().Format(time.RFC3339),
-		"success":   true,
-	}, nil
-}
-
-// 复制文件
-func executeCopyFile(config map[string]interface{}) (map[string]interface{}, error) {
-	sourcePath, ok := config["source_path"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少源文件路径参数")
-	}
-	
-	targetPath, ok := config["target_path"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少目标文件路径参数")
-	}
-	
-	// 模拟文件复制
-	return map[string]interface{}{
-		"source_path": sourcePath,
-		"target_path": targetPath,
-		"copied":      time.Now().Format(time.RFC3339),
-		"success":     true,
-	}, nil
-}
-
-// 获取文件信息
-func executeFileInfo(config map[string]interface{}) (map[string]interface{}, error) {
-	filePath, ok := config["file_path"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少文件路径参数")
-	}
-	
-	// 模拟文件信息
-	return map[string]interface{}{
-		"file_path": filePath,
-		"size":      4096,
-		"is_dir":    false,
-		"modified":  time.Now().Add(-time.Hour).Format(time.RFC3339),
-		"created":   time.Now().Add(-24 * time.Hour).Format(time.RFC3339),
-		"permissions": "rw-r--r--",
-	}, nil
-}
-
-// 搜索文件
-func executeSearchFiles(config map[string]interface{}) (map[string]interface{}, error) {
-	searchPath, ok := config["search_path"].(string)
-	if !ok {
-		return nil, fmt.Errorf("缺少搜索路径参数")
-	}
-	
-	pattern, ok := config["pattern"].(string)
-	if !ok {
-		pattern = "*"
-	}
-	
-	// 模拟文件搜索
-	matches := []string{
-		filepath.Join(searchPath, "file1.txt"),
-		filepath.Join(searchPath, "file2.txt"),
-		filepath.Join(searchPath, "subdir", "file3.txt"),
-	}
-	
-	return map[string]interface{}{
-		"search_path": searchPath,
-		"pattern":     pattern,
-		"matches":     matches,
-		"count":       len(matches),
-	}, nil
-}
-
-// 批量操作
-func executeBatchOperations(config map[string]interface{}, inputs map[string]interface{}) (map[string]interface{}, error) {
-	operations, ok := inputs["operations"].([]interface{})
-	if !ok {
-		return nil, fmt.Errorf("缺少批量操作列表")
-	}
-	
-	var results []map[string]interface{}
-	successCount := 0
-	failureCount := 0
-	
-	for i, opInterface := range operations {
-		op, ok := opInterface.(map[string]interface{})
-		if !ok {
-			failureCount++
-			continue
-		}
-		
-		// 模拟批量操作
-		result := map[string]interface{}{
-			"operation_id": i,
-			"success":      true,
-			"result":       fmt.Sprintf("批量操作 %d 完成", i),
-		}
-		
-		results = append(results, result)
-		successCount++
-	}
-	
-	return map[string]interface{}{
-		"total_operations": len(operations),
-		"success_count":    successCount,
-		"failure_count":    failureCount,
-		"results":          results,
-	}, nil
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/go_file_operations/go_file_operations.json b/apps/jingrow/jingrow/ai/nodes/go_file_operations/go_file_operations.json
deleted file mode 100644
index ff8b71a..0000000
--- a/apps/jingrow/jingrow/ai/nodes/go_file_operations/go_file_operations.json
+++ /dev/null
@@ -1,160 +0,0 @@
-{
-  "properties": {
-    "node_info": {
-      "type": "string",
-      "title": "节点说明",
-      "description": "",
-      "default": "Go文件系统操作节点利用Go语言优秀的系统调用性能，实现高性能文件读写、目录操作、文件监控等功能。",
-      "format": "info"
-    },
-    "operation": {
-      "type": "string",
-      "title": "操作类型",
-      "description": "选择要执行的文件系统操作类型",
-      "enum": [
-        "read_file",
-        "write_file",
-        "list_directory",
-        "create_directory",
-        "delete_file",
-        "copy_file",
-        "file_info",
-        "search_files",
-        "batch_operations"
-      ],
-      "enumNames": [
-        "读取文件",
-        "写入文件",
-        "列出目录",
-        "创建目录",
-        "删除文件",
-        "复制文件",
-        "文件信息",
-        "搜索文件",
-        "批量操作"
-      ],
-      "default": "read_file"
-    },
-    "file_path": {
-      "type": "string",
-      "title": "文件路径",
-      "description": "文件操作的路径",
-      "placeholder": "/path/to/file.txt"
-    },
-    "dir_path": {
-      "type": "string",
-      "title": "目录路径",
-      "description": "目录操作的路径",
-      "placeholder": "/path/to/directory"
-    },
-    "source_path": {
-      "type": "string",
-      "title": "源路径",
-      "description": "复制操作的源路径",
-      "placeholder": "/source/file.txt"
-    },
-    "target_path": {
-      "type": "string",
-      "title": "目标路径",
-      "description": "复制操作的目标路径",
-      "placeholder": "/target/file.txt"
-    },
-    "search_path": {
-      "type": "string",
-      "title": "搜索路径",
-      "description": "文件搜索的路径",
-      "placeholder": "/path/to/search"
-    },
-    "pattern": {
-      "type": "string",
-      "title": "搜索模式",
-      "description": "文件搜索的模式",
-      "default": "*",
-      "placeholder": "*.txt"
-    },
-    "usage_guide": {
-      "type": "string",
-      "title": "使用说明",
-      "description": "Go文件系统操作的使用指南",
-      "default": "Go文件系统操作节点特色：\n• 利用Go语言优秀的系统调用性能\n• 支持多种文件操作：读写、目录管理、文件搜索\n• 提供批量操作功能\n• 高性能文件处理能力\n\n最佳实践：\n• 使用合适的操作类型提高效率\n• 批量操作时注意文件数量限制\n• 搜索操作使用合适的模式匹配\n• 注意文件路径的正确性",
-      "format": "info"
-    }
-  },
-  "required": [
-    "operation"
-  ],
-  "_layout": {
-    "tabs": [
-      {
-        "id": "tab_1",
-        "label": "基础配置",
-        "sections": [
-          {
-            "id": "section_1",
-            "label": "基本属性",
-            "columns": [
-              {
-                "id": "column_1",
-                "label": "主要设置",
-                "fields": [
-                  "node_info",
-                  "operation"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_2",
-            "label": "路径配置",
-            "columns": [
-              {
-                "id": "column_2",
-                "label": "文件路径",
-                "fields": [
-                  "file_path",
-                  "dir_path"
-                ]
-              },
-              {
-                "id": "column_3",
-                "label": "复制路径",
-                "fields": [
-                  "source_path",
-                  "target_path"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_3",
-            "label": "搜索配置",
-            "columns": [
-              {
-                "id": "column_4",
-                "label": "搜索设置",
-                "fields": [
-                  "search_path",
-                  "pattern"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_4",
-            "label": "使用说明",
-            "columns": [
-              {
-                "id": "column_5",
-                "label": "说明文档",
-                "fields": [
-                  "usage_guide"
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "activeTab": "tab_1"
-  }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/go_http_client/go_http_client.go b/apps/jingrow/jingrow/ai/nodes/go_http_client/go_http_client.go
deleted file mode 100644
index c0663bc..0000000
--- a/apps/jingrow/jingrow/ai/nodes/go_http_client/go_http_client.go
+++ /dev/null
@@ -1,138 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"time"
-)
-
-// Go HTTP客户端节点请求结构
-type GoHttpClientRequest struct {
-	Context map[string]interface{} `json:"context"`
-	Inputs  map[string]interface{} `json:"inputs"`
-	Config  map[string]interface{} `json:"config"`
-}
-
-// Go HTTP客户端节点响应结构
-type GoHttpClientResponse struct {
-	Success bool                   `json:"success"`
-	Output  string                 `json:"output,omitempty"`
-	Result  map[string]interface{} `json:"result,omitempty"`
-	Error   string                 `json:"error,omitempty"`
-}
-
-func main() {
-	var req GoHttpClientRequest
-	json.NewDecoder(os.Stdin).Decode(&req)
-	
-	result := execute(req.Context, req.Inputs, req.Config)
-	
-	output, _ := json.Marshal(result)
-	fmt.Println(string(output))
-}
-
-// Go HTTP客户端节点执行函数
-func execute(context, inputs, config map[string]interface{}) GoHttpClientResponse {
-	// 获取配置参数
-	url, ok := config["url"].(string)
-	if !ok || url == "" {
-		return GoHttpClientResponse{
-			Success: false,
-			Error:   "缺少URL配置",
-		}
-	}
-	
-	method, ok := config["method"].(string)
-	if !ok {
-		method = "GET"
-	}
-	
-	timeout, ok := config["timeout"].(float64)
-	if !ok {
-		timeout = 30
-	}
-	
-	// 准备请求数据
-	var requestBody []byte
-	if data, exists := inputs["data"]; exists {
-		if jsonData, err := json.Marshal(data); err == nil {
-			requestBody = jsonData
-		}
-	}
-	
-	// 创建HTTP客户端
-	client := &http.Client{
-		Timeout: time.Duration(timeout) * time.Second,
-	}
-	
-	// 创建请求
-	req, err := http.NewRequest(method, url, bytes.NewBuffer(requestBody))
-	if err != nil {
-		return GoHttpClientResponse{
-			Success: false,
-			Error:   fmt.Sprintf("创建请求失败: %v", err),
-		}
-	}
-	
-	// 设置请求头
-	if headers, ok := config["headers"].(map[string]interface{}); ok {
-		for key, value := range headers {
-			if strValue, ok := value.(string); ok {
-				req.Header.Set(key, strValue)
-			}
-		}
-	}
-	
-	// 设置默认Content-Type
-	if req.Header.Get("Content-Type") == "" && requestBody != nil {
-		req.Header.Set("Content-Type", "application/json")
-	}
-	
-	// 执行请求
-	startTime := time.Now()
-	resp, err := client.Do(req)
-	if err != nil {
-		return GoHttpClientResponse{
-			Success: false,
-			Error:   fmt.Sprintf("请求执行失败: %v", err),
-		}
-	}
-	defer resp.Body.Close()
-	
-	// 读取响应
-	responseBody, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return GoHttpClientResponse{
-			Success: false,
-			Error:   fmt.Sprintf("读取响应失败: %v", err),
-		}
-	}
-	
-	// 尝试解析JSON响应
-	var jsonResponse interface{}
-	if err := json.Unmarshal(responseBody, &jsonResponse); err != nil {
-		// 如果不是JSON，直接返回字符串
-		jsonResponse = string(responseBody)
-	}
-	
-	duration := time.Since(startTime)
-	
-	return GoHttpClientResponse{
-		Success: true,
-		Output:  "Go HTTP请求完成",
-		Result: map[string]interface{}{
-			"url":           url,
-			"method":        method,
-			"status_code":   resp.StatusCode,
-			"response":      jsonResponse,
-			"headers":       resp.Header,
-			"duration_ms":   duration.Milliseconds(),
-			"language":      "go",
-			"performance":   "high",
-		},
-	}
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/go_http_client/go_http_client.json b/apps/jingrow/jingrow/ai/nodes/go_http_client/go_http_client.json
deleted file mode 100644
index 33a3dba..0000000
--- a/apps/jingrow/jingrow/ai/nodes/go_http_client/go_http_client.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
-  "name": "Go HTTP客户端",
-  "description": "使用Go语言进行高性能HTTP请求",
-  "version": "1.0.0",
-  "category": "network",
-  "inputs": [
-    {
-      "name": "context",
-      "type": "object",
-      "description": "上下文数据"
-    },
-    {
-      "name": "inputs",
-      "type": "object",
-      "description": "输入数据"
-    },
-    {
-      "name": "config",
-      "type": "object",
-      "description": "配置参数"
-    }
-  ],
-  "outputs": [
-    {
-      "name": "success",
-      "type": "boolean",
-      "description": "执行是否成功"
-    },
-    {
-      "name": "output",
-      "type": "string",
-      "description": "执行结果消息"
-    },
-    {
-      "name": "result",
-      "type": "object",
-      "description": "HTTP响应数据"
-    }
-  ],
-  "config": [
-    {
-      "name": "url",
-      "type": "text",
-      "label": "请求URL",
-      "required": true,
-      "description": "要请求的URL地址"
-    },
-    {
-      "name": "method",
-      "type": "select",
-      "label": "请求方法",
-      "required": false,
-      "default": "GET",
-      "options": [
-        {"value": "GET", "label": "GET"},
-        {"value": "POST", "label": "POST"},
-        {"value": "PUT", "label": "PUT"},
-        {"value": "DELETE", "label": "DELETE"},
-        {"value": "PATCH", "label": "PATCH"}
-      ]
-    },
-    {
-      "name": "timeout",
-      "type": "number",
-      "label": "超时时间(秒)",
-      "required": false,
-      "default": 30,
-      "min": 1,
-      "max": 300
-    },
-    {
-      "name": "headers",
-      "type": "object",
-      "label": "请求头",
-      "required": false,
-      "description": "HTTP请求头配置"
-    }
-  ]
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/language_go/language_go.go b/apps/jingrow/jingrow/ai/nodes/language_go/language_go.go
deleted file mode 100644
index 37ddc1c..0000000
--- a/apps/jingrow/jingrow/ai/nodes/language_go/language_go.go
+++ /dev/null
@@ -1,52 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-)
-
-type ExecuteRequest struct {
-	Context map[string]interface{} `json:"context"`
-	Inputs  map[string]interface{} `json:"inputs"`
-	Config  map[string]interface{} `json:"config"`
-}
-
-type ExecuteResponse struct {
-	Success bool        `json:"success"`
-	Output  string      `json:"output,omitempty"`
-	Result  interface{} `json:"result,omitempty"`
-	Error   string      `json:"error,omitempty"`
-}
-
-func main() {
-	var req ExecuteRequest
-	json.NewDecoder(os.Stdin).Decode(&req)
-	
-	result := execute(req.Context, req.Inputs, req.Config)
-	
-	output, _ := json.Marshal(result)
-	fmt.Println(string(output))
-}
-
-func execute(context, inputs, config map[string]interface{}) ExecuteResponse {
-	code, ok := config["code"].(string)
-	if !ok {
-		return ExecuteResponse{
-			Success: false,
-			Error:   "没有提供Go代码",
-		}
-	}
-	
-	// 这里可以实现Go代码的动态执行
-	// 目前返回示例结果
-	return ExecuteResponse{
-		Success: true,
-		Output:  "Go代码执行完成",
-		Result: map[string]interface{}{
-			"language":      "go",
-			"code_length":   len(code),
-			"execution_time": 0.1,
-		},
-	}
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/language_go/language_go.json b/apps/jingrow/jingrow/ai/nodes/language_go/language_go.json
deleted file mode 100644
index 0caba02..0000000
--- a/apps/jingrow/jingrow/ai/nodes/language_go/language_go.json
+++ /dev/null
@@ -1,31 +0,0 @@
-{
-  "name": "Go语言执行节点",
-  "description": "执行Go代码的节点",
-  "version": "1.0.0",
-  "author": "jingrow",
-  "category": "language",
-  "inputs": [
-    {
-      "name": "code",
-      "type": "string",
-      "description": "要执行的Go代码",
-      "required": true
-    }
-  ],
-  "outputs": [
-    {
-      "name": "output",
-      "type": "string",
-      "description": "代码执行的标准输出"
-    },
-    {
-      "name": "result",
-      "type": "object",
-      "description": "代码执行的结果数据"
-    }
-  ],
-  "config": {
-    "timeout": 30,
-    "memory_limit": "512m"
-  }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/language_python/language_python.json b/apps/jingrow/jingrow/ai/nodes/language_python/language_python.json
deleted file mode 100644
index 5b9f343..0000000
--- a/apps/jingrow/jingrow/ai/nodes/language_python/language_python.json
+++ /dev/null
@@ -1,31 +0,0 @@
-{
-  "name": "Python语言执行节点",
-  "description": "执行Python代码的节点",
-  "version": "1.0.0",
-  "author": "jingrow",
-  "category": "language",
-  "inputs": [
-    {
-      "name": "code",
-      "type": "string",
-      "description": "要执行的Python代码",
-      "required": true
-    }
-  ],
-  "outputs": [
-    {
-      "name": "output",
-      "type": "string",
-      "description": "代码执行的标准输出"
-    },
-    {
-      "name": "result",
-      "type": "object",
-      "description": "代码执行的结果数据"
-    }
-  ],
-  "config": {
-    "timeout": 30,
-    "memory_limit": "512m"
-  }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/language_python/language_python.py b/apps/jingrow/jingrow/ai/nodes/language_python/language_python.py
deleted file mode 100644
index ae48d0c..0000000
--- a/apps/jingrow/jingrow/ai/nodes/language_python/language_python.py
+++ /dev/null
@@ -1,43 +0,0 @@
-def execute(context=None, inputs=None, config=None):
-    """
-    Python语言执行节点
-    执行用户提供的Python代码
-    """
-    try:
-        code = config.get('code', '')
-        if not code:
-            return {"success": False, "error": "没有提供Python代码"}
-        
-        # 创建执行环境
-        exec_globals = {
-            'context': context,
-            'inputs': inputs,
-            'config': config,
-            '__builtins__': __builtins__
-        }
-        exec_locals = {}
-        
-        # 执行代码
-        exec(code, exec_globals, exec_locals)
-        
-        # 获取输出结果
-        output = exec_locals.get('output', '')
-        result = exec_locals.get('result', exec_locals)
-        
-        return {
-            "success": True,
-            "output": output,
-            "result": result,
-            "execution_info": {
-                "language": "python",
-                "code_length": len(code),
-                "variables": list(exec_locals.keys())
-            }
-        }
-        
-    except Exception as e:
-        return {
-            "success": False,
-            "error": str(e),
-            "error_type": type(e).__name__
-        }
diff --git a/apps/jingrow/jingrow/ai/nodes/language_rust/language_rust.json b/apps/jingrow/jingrow/ai/nodes/language_rust/language_rust.json
deleted file mode 100644
index a3b7b98..0000000
--- a/apps/jingrow/jingrow/ai/nodes/language_rust/language_rust.json
+++ /dev/null
@@ -1,31 +0,0 @@
-{
-  "name": "Rust语言执行节点",
-  "description": "执行Rust代码的节点",
-  "version": "1.0.0",
-  "author": "jingrow",
-  "category": "language",
-  "inputs": [
-    {
-      "name": "code",
-      "type": "string",
-      "description": "要执行的Rust代码",
-      "required": true
-    }
-  ],
-  "outputs": [
-    {
-      "name": "output",
-      "type": "string",
-      "description": "代码执行的标准输出"
-    },
-    {
-      "name": "result",
-      "type": "object",
-      "description": "代码执行的结果数据"
-    }
-  ],
-  "config": {
-    "timeout": 30,
-    "memory_limit": "512m"
-  }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/language_rust/language_rust.rs b/apps/jingrow/jingrow/ai/nodes/language_rust/language_rust.rs
deleted file mode 100644
index 5ee96db..0000000
--- a/apps/jingrow/jingrow/ai/nodes/language_rust/language_rust.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use serde_json::{json, Value};
-use std::io::{self, Read};
-
-#[derive(serde::Deserialize)]
-struct ExecuteRequest {
-    context: Value,
-    inputs: Value,
-    config: Value,
-}
-
-#[derive(serde::Serialize)]
-struct ExecuteResponse {
-    success: bool,
-    output: Option<String>,
-    result: Option<Value>,
-    error: Option<String>,
-}
-
-fn main() {
-    let mut input = String::new();
-    io::stdin().read_to_string(&mut input).unwrap();
-    
-    let req: ExecuteRequest = serde_json::from_str(&input).unwrap();
-    let result = execute(&req.context, &req.inputs, &req.config);
-    
-    println!("{}", serde_json::to_string(&result).unwrap());
-}
-
-fn execute(context: &Value, inputs: &Value, config: &Value) -> ExecuteResponse {
-    let code = config["code"].as_str().unwrap_or("");
-    
-    if code.is_empty() {
-        return ExecuteResponse {
-            success: false,
-            output: None,
-            result: None,
-            error: Some("没有提供Rust代码".to_string()),
-        };
-    }
-    
-    // 这里可以实现Rust代码的动态执行
-    // 目前返回示例结果
-    ExecuteResponse {
-        success: true,
-        output: Some("Rust代码执行完成".to_string()),
-        result: Some(json!({
-            "language": "rust",
-            "code_length": code.len(),
-            "execution_time": 0.05
-        })),
-        error: None,
-    }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/rust_crypto/rust_crypto.json b/apps/jingrow/jingrow/ai/nodes/rust_crypto/rust_crypto.json
deleted file mode 100644
index 934d323..0000000
--- a/apps/jingrow/jingrow/ai/nodes/rust_crypto/rust_crypto.json
+++ /dev/null
@@ -1,93 +0,0 @@
-{
-  "name": "Rust加密处理",
-  "description": "使用Rust语言进行高性能加密和安全处理",
-  "version": "1.0.0",
-  "category": "security",
-  "inputs": [
-    {
-      "name": "context",
-      "type": "object",
-      "description": "上下文数据"
-    },
-    {
-      "name": "inputs",
-      "type": "object",
-      "description": "输入数据"
-    },
-    {
-      "name": "config",
-      "type": "object",
-      "description": "配置参数"
-    }
-  ],
-  "outputs": [
-    {
-      "name": "success",
-      "type": "boolean",
-      "description": "执行是否成功"
-    },
-    {
-      "name": "output",
-      "type": "string",
-      "description": "执行结果消息"
-    },
-    {
-      "name": "result",
-      "type": "object",
-      "description": "加密处理结果"
-    }
-  ],
-  "config": [
-    {
-      "name": "operation",
-      "type": "select",
-      "label": "加密操作",
-      "required": true,
-      "default": "encrypt",
-      "options": [
-        {"value": "encrypt", "label": "加密"},
-        {"value": "decrypt", "label": "解密"},
-        {"value": "hash", "label": "哈希"},
-        {"value": "sign", "label": "数字签名"},
-        {"value": "verify", "label": "签名验证"}
-      ]
-    },
-    {
-      "name": "algorithm",
-      "type": "select",
-      "label": "加密算法",
-      "required": false,
-      "default": "AES-256",
-      "options": [
-        {"value": "AES-256", "label": "AES-256"},
-        {"value": "AES-128", "label": "AES-128"},
-        {"value": "RSA-2048", "label": "RSA-2048"},
-        {"value": "ECDSA", "label": "ECDSA"},
-        {"value": "SHA-256", "label": "SHA-256"},
-        {"value": "SHA-512", "label": "SHA-512"}
-      ]
-    },
-    {
-      "name": "key_length",
-      "type": "number",
-      "label": "密钥长度",
-      "required": false,
-      "default": 256,
-      "min": 128,
-      "max": 4096
-    },
-    {
-      "name": "mode",
-      "type": "select",
-      "label": "加密模式",
-      "required": false,
-      "default": "CBC",
-      "options": [
-        {"value": "CBC", "label": "CBC"},
-        {"value": "GCM", "label": "GCM"},
-        {"value": "CTR", "label": "CTR"},
-        {"value": "OFB", "label": "OFB"}
-      ]
-    }
-  ]
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/rust_crypto/rust_crypto.rs b/apps/jingrow/jingrow/ai/nodes/rust_crypto/rust_crypto.rs
deleted file mode 100644
index ff1ae76..0000000
--- a/apps/jingrow/jingrow/ai/nodes/rust_crypto/rust_crypto.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use std::io::{self, Read};
-
-fn main() {
-    let mut input = String::new();
-    io::stdin().read_to_string(&mut input).unwrap();
-    
-    let result = execute_crypto(&input);
-    println!("{}", result);
-}
-
-fn execute_crypto(input: &str) -> String {
-    // 简化的Rust加密处理逻辑
-    // 在实际实现中，这里会使用ring或crypto crate进行真实的加密操作
-    
-    if input.contains("encrypt") {
-        return r#"{"success": true, "output": "Rust加密完成", "result": {"operation": "encrypt", "algorithm": "AES-256", "key_length": 256, "encrypted_data": "encrypted_base64_string", "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
-    } else if input.contains("decrypt") {
-        return r#"{"success": true, "output": "Rust解密完成", "result": {"operation": "decrypt", "algorithm": "AES-256", "decrypted_data": "original_data", "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
-    } else if input.contains("hash") {
-        return r#"{"success": true, "output": "Rust哈希计算完成", "result": {"operation": "hash", "algorithm": "SHA-256", "hash_value": "a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3", "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
-    } else if input.contains("sign") {
-        return r#"{"success": true, "output": "Rust数字签名完成", "result": {"operation": "sign", "algorithm": "ECDSA", "signature": "signature_base64_string", "public_key": "public_key_base64", "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
-    } else if input.contains("verify") {
-        return r#"{"success": true, "output": "Rust签名验证完成", "result": {"operation": "verify", "algorithm": "ECDSA", "valid": true, "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
-    } else {
-        return r#"{"success": true, "output": "Rust加密操作完成", "result": {"operation": "default", "language": "rust", "performance": "highest", "security": "maximum"}}"#.to_string();
-    }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/rust_image_processing/rust_image_processing.json b/apps/jingrow/jingrow/ai/nodes/rust_image_processing/rust_image_processing.json
deleted file mode 100644
index eab7cd9..0000000
--- a/apps/jingrow/jingrow/ai/nodes/rust_image_processing/rust_image_processing.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
-  "name": "Rust图像处理",
-  "description": "使用Rust语言进行高性能图像处理",
-  "version": "1.0.0",
-  "category": "image",
-  "inputs": [
-    {
-      "name": "context",
-      "type": "object",
-      "description": "上下文数据"
-    },
-    {
-      "name": "inputs",
-      "type": "object",
-      "description": "输入数据"
-    },
-    {
-      "name": "config",
-      "type": "object",
-      "description": "配置参数"
-    }
-  ],
-  "outputs": [
-    {
-      "name": "success",
-      "type": "boolean",
-      "description": "执行是否成功"
-    },
-    {
-      "name": "output",
-      "type": "string",
-      "description": "执行结果消息"
-    },
-    {
-      "name": "result",
-      "type": "object",
-      "description": "图像处理结果"
-    }
-  ],
-  "config": [
-    {
-      "name": "operation",
-      "type": "select",
-      "label": "处理操作",
-      "required": true,
-      "default": "resize",
-      "options": [
-        {"value": "resize", "label": "缩放"},
-        {"value": "crop", "label": "裁剪"},
-        {"value": "filter", "label": "滤镜"},
-        {"value": "convert", "label": "格式转换"}
-      ]
-    },
-    {
-      "name": "width",
-      "type": "number",
-      "label": "宽度",
-      "required": false,
-      "default": 800,
-      "min": 1,
-      "max": 4096
-    },
-    {
-      "name": "height",
-      "type": "number",
-      "label": "高度",
-      "required": false,
-      "default": 600,
-      "min": 1,
-      "max": 4096
-    },
-    {
-      "name": "quality",
-      "type": "number",
-      "label": "质量",
-      "required": false,
-      "default": 95,
-      "min": 1,
-      "max": 100
-    },
-    {
-      "name": "filter_type",
-      "type": "select",
-      "label": "滤镜类型",
-      "required": false,
-      "default": "blur",
-      "options": [
-        {"value": "blur", "label": "模糊"},
-        {"value": "sharpen", "label": "锐化"},
-        {"value": "grayscale", "label": "灰度"},
-        {"value": "sepia", "label": "棕褐色"}
-      ]
-    }
-  ]
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/rust_image_processing/rust_image_processing.rs b/apps/jingrow/jingrow/ai/nodes/rust_image_processing/rust_image_processing.rs
deleted file mode 100644
index 238f29a..0000000
--- a/apps/jingrow/jingrow/ai/nodes/rust_image_processing/rust_image_processing.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use std::io::{self, Read};
-
-fn main() {
-    let mut input = String::new();
-    io::stdin().read_to_string(&mut input).unwrap();
-    
-    let result = execute_image_processing(&input);
-    println!("{}", result);
-}
-
-fn execute_image_processing(input: &str) -> String {
-    // 简化的Rust图像处理逻辑
-    // 在实际实现中，这里会使用image crate进行真实的图像处理
-    
-    if input.contains("resize") {
-        return r#"{"success": true, "output": "Rust图像缩放完成", "result": {"operation": "resize", "width": 800, "height": 600, "format": "png", "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("crop") {
-        return r#"{"success": true, "output": "Rust图像裁剪完成", "result": {"operation": "crop", "x": 100, "y": 100, "width": 400, "height": 300, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("filter") {
-        return r#"{"success": true, "output": "Rust图像滤镜完成", "result": {"operation": "filter", "filter_type": "blur", "intensity": 5, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("convert") {
-        return r#"{"success": true, "output": "Rust图像格式转换完成", "result": {"operation": "convert", "from_format": "jpg", "to_format": "png", "quality": 95, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else {
-        return r#"{"success": true, "output": "Rust图像处理完成", "result": {"operation": "default", "language": "rust", "performance": "highest"}}"#.to_string();
-    }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/rust_numeric_computing/rust_numeric_computing.json b/apps/jingrow/jingrow/ai/nodes/rust_numeric_computing/rust_numeric_computing.json
deleted file mode 100644
index 8dca2e7..0000000
--- a/apps/jingrow/jingrow/ai/nodes/rust_numeric_computing/rust_numeric_computing.json
+++ /dev/null
@@ -1,224 +0,0 @@
-{
-  "properties": {
-    "node_info": {
-      "type": "string",
-      "title": "节点说明",
-      "description": "",
-      "default": "Rust数值计算节点利用Rust语言的ndarray、statrs等高性能数学库，实现极速数值计算、统计分析、科学计算等功能。性能接近C语言水平。",
-      "format": "info"
-    },
-    "operation": {
-      "type": "string",
-      "title": "计算类型",
-      "description": "选择要执行的数值计算类型",
-      "enum": [
-        "statistics",
-        "matrix",
-        "interpolation",
-        "optimization",
-        "integration",
-        "fourier",
-        "clustering",
-        "regression"
-      ],
-      "enumNames": [
-        "统计分析",
-        "矩阵运算",
-        "插值计算",
-        "优化计算",
-        "积分计算",
-        "傅里叶变换",
-        "聚类分析",
-        "回归分析"
-      ],
-      "default": "statistics"
-    },
-    "data": {
-      "type": "array",
-      "title": "数值数据",
-      "description": "要计算的数值数组",
-      "items": {
-        "type": "number"
-      }
-    },
-    "matrix_a": {
-      "type": "array",
-      "title": "矩阵A",
-      "description": "矩阵运算的第一个矩阵",
-      "items": {
-        "type": "array",
-        "items": {
-          "type": "number"
-        }
-      }
-    },
-    "matrix_b": {
-      "type": "array",
-      "title": "矩阵B",
-      "description": "矩阵运算的第二个矩阵",
-      "items": {
-        "type": "array",
-        "items": {
-          "type": "number"
-        }
-      }
-    },
-    "operation_type": {
-      "type": "string",
-      "title": "矩阵运算类型",
-      "description": "矩阵运算的具体操作类型",
-      "enum": [
-        "multiply",
-        "add",
-        "subtract",
-        "transpose",
-        "determinant",
-        "inverse"
-      ],
-      "enumNames": [
-        "矩阵乘法",
-        "矩阵加法",
-        "矩阵减法",
-        "矩阵转置",
-        "行列式",
-        "矩阵逆"
-      ],
-      "default": "multiply"
-    },
-    "method": {
-      "type": "string",
-      "title": "计算方法",
-      "description": "数值计算的具体方法",
-      "enum": [
-        "linear",
-        "polynomial",
-        "spline",
-        "nearest"
-      ],
-      "enumNames": [
-        "线性",
-        "多项式",
-        "样条",
-        "最近邻"
-      ],
-      "default": "linear"
-    },
-    "precision": {
-      "type": "number",
-      "title": "计算精度",
-      "description": "数值计算的精度要求",
-      "default": 0.001,
-      "minimum": 0.000001,
-      "maximum": 0.1
-    },
-    "iterations": {
-      "type": "number",
-      "title": "迭代次数",
-      "description": "迭代算法的最大迭代次数",
-      "default": 1000,
-      "minimum": 1,
-      "maximum": 10000
-    },
-    "clusters": {
-      "type": "number",
-      "title": "聚类数量",
-      "description": "聚类分析的聚类数量",
-      "default": 3,
-      "minimum": 2,
-      "maximum": 20
-    },
-    "usage_guide": {
-      "type": "string",
-      "title": "使用说明",
-      "description": "Rust数值计算的使用指南",
-      "default": "Rust数值计算节点特色：\n• 利用ndarray、statrs等高性能数学库\n• 支持多种计算：统计、矩阵、插值、优化\n• 提供科学计算和机器学习预处理功能\n• 性能接近C语言水平\n\n最佳实践：\n• 根据数据类型选择合适的计算方法\n• 设置合适的精度和迭代次数\n• 大数据集建议分批处理\n• 矩阵运算注意维度匹配",
-      "format": "info"
-    }
-  },
-  "required": [
-    "operation",
-    "data"
-  ],
-  "_layout": {
-    "tabs": [
-      {
-        "id": "tab_1",
-        "label": "基础配置",
-        "sections": [
-          {
-            "id": "section_1",
-            "label": "基本属性",
-            "columns": [
-              {
-                "id": "column_1",
-                "label": "主要设置",
-                "fields": [
-                  "node_info",
-                  "operation"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_2",
-            "label": "数据配置",
-            "columns": [
-              {
-                "id": "column_2",
-                "label": "输入数据",
-                "fields": [
-                  "data"
-                ]
-              },
-              {
-                "id": "column_3",
-                "label": "矩阵数据",
-                "fields": [
-                  "matrix_a",
-                  "matrix_b"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_3",
-            "label": "计算配置",
-            "columns": [
-              {
-                "id": "column_4",
-                "label": "运算设置",
-                "fields": [
-                  "operation_type",
-                  "method"
-                ]
-              },
-              {
-                "id": "column_5",
-                "label": "参数设置",
-                "fields": [
-                  "precision",
-                  "iterations",
-                  "clusters"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_4",
-            "label": "使用说明",
-            "columns": [
-              {
-                "id": "column_6",
-                "label": "说明文档",
-                "fields": [
-                  "usage_guide"
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "activeTab": "tab_1"
-  }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/rust_numeric_computing/rust_numeric_computing.rs b/apps/jingrow/jingrow/ai/nodes/rust_numeric_computing/rust_numeric_computing.rs
deleted file mode 100644
index 7621383..0000000
--- a/apps/jingrow/jingrow/ai/nodes/rust_numeric_computing/rust_numeric_computing.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use std::io::{self, Read};
-
-fn main() {
-    let mut input = String::new();
-    io::stdin().read_to_string(&mut input).unwrap();
-    
-    let result = execute_numeric_computing(&input);
-    println!("{}", result);
-}
-
-fn execute_numeric_computing(input: &str) -> String {
-    // 简化的Rust数值计算逻辑
-    // 在实际实现中，这里会使用ndarray、statrs等crate进行真实的数值计算
-    
-    if input.contains("statistics") {
-        return r#"{"success": true, "output": "Rust统计分析完成", "result": {"operation": "statistics", "data": [1.0, 2.0, 3.0, 4.0, 5.0], "mean": 3.0, "median": 3.0, "std_dev": 1.58, "variance": 2.5, "min": 1.0, "max": 5.0, "sum": 15.0, "count": 5, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("matrix") {
-        return r#"{"success": true, "output": "Rust矩阵运算完成", "result": {"operation": "matrix", "operation_type": "multiply", "matrix_a": [[1, 2], [3, 4]], "matrix_b": [[5, 6], [7, 8]], "result": [[19, 22], [43, 50]], "dimensions": "2x2", "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("interpolation") {
-        return r#"{"success": true, "output": "Rust插值计算完成", "result": {"operation": "interpolation", "method": "linear", "x_values": [1.0, 2.0, 3.0, 4.0], "y_values": [2.0, 4.0, 6.0, 8.0], "interpolated_x": 2.5, "interpolated_y": 5.0, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("optimization") {
-        return r#"{"success": true, "output": "Rust优化计算完成", "result": {"operation": "optimization", "method": "gradient_descent", "function": "x^2 + y^2", "initial_point": [5.0, 5.0], "optimal_point": [0.0, 0.0], "iterations": 100, "converged": true, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("integration") {
-        return r#"{"success": true, "output": "Rust积分计算完成", "result": {"operation": "integration", "method": "simpson", "function": "x^2", "lower_bound": 0.0, "upper_bound": 2.0, "result": 2.67, "error": 0.001, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("fourier") {
-        return r#"{"success": true, "output": "Rust傅里叶变换完成", "result": {"operation": "fourier", "transform_type": "fft", "input_signal": [1.0, 0.0, -1.0, 0.0], "frequency_domain": [0.0, 2.0, 0.0, -2.0], "sample_rate": 1000.0, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("clustering") {
-        return r#"{"success": true, "output": "Rust聚类分析完成", "result": {"operation": "clustering", "algorithm": "kmeans", "data_points": [[1, 1], [2, 2], [8, 8], [9, 9]], "clusters": 2, "centroids": [[1.5, 1.5], [8.5, 8.5]], "labels": [0, 0, 1, 1], "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("regression") {
-        return r#"{"success": true, "output": "Rust回归分析完成", "result": {"operation": "regression", "method": "linear", "x_values": [1.0, 2.0, 3.0, 4.0], "y_values": [2.1, 3.9, 6.1, 8.0], "slope": 2.0, "intercept": 0.1, "r_squared": 0.99, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else {
-        return r#"{"success": true, "output": "Rust数值计算完成", "result": {"operation": "default", "language": "rust", "performance": "highest"}}"#.to_string();
-    }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/rust_regex_processing/rust_regex_processing.json b/apps/jingrow/jingrow/ai/nodes/rust_regex_processing/rust_regex_processing.json
deleted file mode 100644
index 0d581d2..0000000
--- a/apps/jingrow/jingrow/ai/nodes/rust_regex_processing/rust_regex_processing.json
+++ /dev/null
@@ -1,184 +0,0 @@
-{
-  "properties": {
-    "node_info": {
-      "type": "string",
-      "title": "节点说明",
-      "description": "",
-      "default": "Rust正则表达式处理节点利用Rust语言的regex crate，实现极速正则匹配、文本解析、模式提取等功能。性能接近C语言水平。",
-      "format": "info"
-    },
-    "operation": {
-      "type": "string",
-      "title": "操作类型",
-      "description": "选择要执行的正则表达式操作类型",
-      "enum": [
-        "extract",
-        "replace",
-        "validate",
-        "split",
-        "find_all",
-        "capture",
-        "count",
-        "analyze"
-      ],
-      "enumNames": [
-        "提取匹配",
-        "替换匹配",
-        "验证格式",
-        "分割文本",
-        "查找所有",
-        "捕获分组",
-        "计数匹配",
-        "分析文本"
-      ],
-      "default": "extract"
-    },
-    "pattern": {
-      "type": "string",
-      "title": "正则模式",
-      "description": "正则表达式模式",
-      "placeholder": "\\d{4}-\\d{2}-\\d{2}",
-      "examples": [
-        "\\d{4}-\\d{2}-\\d{2}",
-        "\\b[A-Z][a-z]+\\b",
-        "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
-      ]
-    },
-    "text": {
-      "type": "string",
-      "title": "输入文本",
-      "description": "要处理的文本内容",
-      "format": "textarea"
-    },
-    "replacement": {
-      "type": "string",
-      "title": "替换文本",
-      "description": "替换操作时的替换文本",
-      "placeholder": "[REPLACED]"
-    },
-    "flags": {
-      "type": "object",
-      "title": "正则标志",
-      "description": "正则表达式的标志设置",
-      "properties": {
-        "case_insensitive": {
-          "type": "boolean",
-          "title": "忽略大小写",
-          "description": "是否忽略大小写匹配",
-          "default": false
-        },
-        "multiline": {
-          "type": "boolean",
-          "title": "多行模式",
-          "description": "是否启用多行模式",
-          "default": false
-        },
-        "dotall": {
-          "type": "boolean",
-          "title": "点匹配换行",
-          "description": "是否让.匹配换行符",
-          "default": false
-        }
-      }
-    },
-    "max_matches": {
-      "type": "number",
-      "title": "最大匹配数",
-      "description": "限制最大匹配数量",
-      "default": 1000,
-      "minimum": 1,
-      "maximum": 10000
-    },
-    "usage_guide": {
-      "type": "string",
-      "title": "使用说明",
-      "description": "Rust正则表达式处理的使用指南",
-      "default": "Rust正则表达式处理节点特色：\n• 利用regex crate实现极速正则匹配\n• 支持多种操作：提取、替换、验证、分割\n• 提供分组捕获和文本分析功能\n• 性能接近C语言水平\n\n最佳实践：\n• 使用合适的正则模式提高匹配效率\n• 设置最大匹配数避免内存过载\n• 利用标志位优化匹配行为\n• 复杂模式建议先测试验证",
-      "format": "info"
-    }
-  },
-  "required": [
-    "operation",
-    "pattern",
-    "text"
-  ],
-  "_layout": {
-    "tabs": [
-      {
-        "id": "tab_1",
-        "label": "基础配置",
-        "sections": [
-          {
-            "id": "section_1",
-            "label": "基本属性",
-            "columns": [
-              {
-                "id": "column_1",
-                "label": "主要设置",
-                "fields": [
-                  "node_info",
-                  "operation"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_2",
-            "label": "正则配置",
-            "columns": [
-              {
-                "id": "column_2",
-                "label": "模式设置",
-                "fields": [
-                  "pattern",
-                  "text"
-                ]
-              },
-              {
-                "id": "column_3",
-                "label": "替换设置",
-                "fields": [
-                  "replacement"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_3",
-            "label": "高级配置",
-            "columns": [
-              {
-                "id": "column_4",
-                "label": "标志设置",
-                "fields": [
-                  "flags"
-                ]
-              },
-              {
-                "id": "column_5",
-                "label": "性能设置",
-                "fields": [
-                  "max_matches"
-                ]
-              }
-            ]
-          },
-          {
-            "id": "section_4",
-            "label": "使用说明",
-            "columns": [
-              {
-                "id": "column_6",
-                "label": "说明文档",
-                "fields": [
-                  "usage_guide"
-                ]
-              }
-            ]
-          }
-        ]
-      }
-    ],
-    "activeTab": "tab_1"
-  }
-}
diff --git a/apps/jingrow/jingrow/ai/nodes/rust_regex_processing/rust_regex_processing.rs b/apps/jingrow/jingrow/ai/nodes/rust_regex_processing/rust_regex_processing.rs
deleted file mode 100644
index e743a3c..0000000
--- a/apps/jingrow/jingrow/ai/nodes/rust_regex_processing/rust_regex_processing.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use std::io::{self, Read};
-
-fn main() {
-    let mut input = String::new();
-    io::stdin().read_to_string(&mut input).unwrap();
-    
-    let result = execute_regex_processing(&input);
-    println!("{}", result);
-}
-
-fn execute_regex_processing(input: &str) -> String {
-    // 简化的Rust正则表达式处理逻辑
-    // 在实际实现中，这里会使用regex crate进行真实的正则处理
-    
-    if input.contains("extract") {
-        return r#"{"success": true, "output": "Rust正则提取完成", "result": {"operation": "extract", "pattern": "\\d{4}-\\d{2}-\\d{2}", "matches": ["2024-01-01", "2024-12-31"], "count": 2, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("replace") {
-        return r#"{"success": true, "output": "Rust正则替换完成", "result": {"operation": "replace", "pattern": "\\b(\\w+)@(\\w+)\\.(\\w+)\\b", "replacement": "[EMAIL]", "original": "Contact: john@example.com", "result": "Contact: [EMAIL]", "replacements": 1, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("validate") {
-        return r#"{"success": true, "output": "Rust正则验证完成", "result": {"operation": "validate", "pattern": "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$", "text": "test@example.com", "valid": true, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("split") {
-        return r#"{"success": true, "output": "Rust正则分割完成", "result": {"operation": "split", "pattern": "\\s+", "text": "hello   world    rust", "parts": ["hello", "world", "rust"], "count": 3, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("find_all") {
-        return r#"{"success": true, "output": "Rust正则查找完成", "result": {"operation": "find_all", "pattern": "\\b\\w{4}\\b", "text": "This is a test string with words", "matches": ["This", "test", "with", "word"], "count": 4, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("capture") {
-        return r#"{"success": true, "output": "Rust正则捕获完成", "result": {"operation": "capture", "pattern": "(\\d{4})-(\\d{2})-(\\d{2})", "text": "Date: 2024-01-01", "captures": [{"full": "2024-01-01", "year": "2024", "month": "01", "day": "01"}], "count": 1, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("count") {
-        return r#"{"success": true, "output": "Rust正则计数完成", "result": {"operation": "count", "pattern": "\\d+", "text": "There are 123 apples and 456 oranges", "count": 2, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else if input.contains("analyze") {
-        return r#"{"success": true, "output": "Rust正则分析完成", "result": {"operation": "analyze", "pattern": "\\b[A-Z][a-z]+\\b", "text": "Hello World Rust Programming", "analysis": {"total_matches": 4, "unique_matches": 4, "average_length": 6.5, "longest_match": "Programming"}, "language": "rust", "performance": "highest"}}"#.to_string();
-    } else {
-        return r#"{"success": true, "output": "Rust正则处理完成", "result": {"operation": "default", "language": "rust", "performance": "highest"}}"#.to_string();
-    }
-}