💾 Feat(BlockScript/Blueprint): 实现插件函数全链路解析与类型化执行

管线层(BS→BP):
- ExprUtils 新增 GetFullMethodName() 保留完整点分路径
- FormattedStatement 新增 FullFunctionName 属性
- ScriptFormatter 在 FormatInvocation 和 ExpandExpression 中传递完整函数名
- NodeBuilder 解析 PluginName/FunctionName 到 CallNode
- ExpandExpression 拆分嵌套调用时保留 FullFunctionName

执行层(BS Runtime):
- BlockScriptExecutor 新增 PluginCallRewriter (Roslyn AST级转换)
  将 A.B.C.Func(args) → PluginCall("A.B.C", "Func", args)
- BlockScriptExecutionGlobals 新增 PluginCall 统一入口
- RealPluginManager 新增 CallAuto() 自动分发策略:
  void → fire-and-forget, 非void → 反射调用 Call<T>()
- RealPluginManager 新增 GetFunctionReturnType() 查询插件函数返回类型
- ParseResult<object?> 增加非JSON纯文本容错
- CoreServiceCollectionExtensions/WorkflowScriptService 注入 PluginManager

导出层(BP→BS):
- CallNodeExportStrategy 已正确处理 PluginName 生成完整调用路径

Author: StardustSeemsInk

KitX Clients/KitX Core/KitX.Core/DI/CoreServiceCollectionExtensions.cs

@@ -188,6 +188,17 @@ public static IServiceCollection AddCoreServices(this IServiceCollection service
         services.AddSingleton<IBlockScriptExecutor, KitX.Core.Workflow.BlockScripting.BlockScriptExecutor>(provider =>
         {
             var service = new KitX.Core.Workflow.BlockScripting.BlockScriptExecutor();
+            // Wire up plugin manager if PluginsServer is available
+            try
+            {
+                var pluginManager = new KitX.Core.Workflow.RealPluginManager(
+                    KitX.Core.Device.PluginsServer.Instance);
+                service.SetPluginManager(pluginManager);
+            }
+            catch (Exception ex)
+            {
+                Log.Warning(ex, "Could not initialize BlockScriptExecutor with plugin manager");
+            }
             return service;
         });
 

KitX Clients/KitX Core/KitX.Core/Workflow/BlockScripting/BlockScriptExecutionGlobals.cs

@@ -1,7 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.Threading;
+using Kscript.CSharp.Parser.Core;
+using Kscript.CSharp.Parser.Models;
 using KitX.Core.Workflow;
+using Serilog;
 
 namespace KitX.Core.Workflow.BlockScripting;
 
@@ -13,6 +16,7 @@ public class BlockScriptExecutionGlobals
     private readonly BlockScopeManager _scopeManager;
     private readonly List<string> _output;
     private readonly Dictionary<string, object?> _variables = new();
+    private readonly IPluginManager? _pluginManager;
 
     /// <summary>
     /// NextBlock 内置变量 - 设置后执行器会跳转到指定块
@@ -29,6 +33,15 @@ public BlockScriptExecutionGlobals(BlockScopeManager scopeManager, List<string>
         _output = output;
     }
 
+    /// <summary>
+    /// Creates script globals with plugin manager support
+    /// </summary>
+    public BlockScriptExecutionGlobals(BlockScopeManager scopeManager, List<string> output,
+        IPluginManager? pluginManager) : this(scopeManager, output)
+    {
+        _pluginManager = pluginManager;
+    }
+
     /// <summary>
     /// Gets a variable value - called by CSharpScript when accessing unknown properties
     /// Returns dynamic to allow implicit conversion to target variable types
@@ -127,4 +140,40 @@ public void Pause(int milliseconds)
         NextBlock = $"{parentBlockName}_Loop";
         return NextBlock;
     }
+
+    /// <summary>
+    /// 调用插件函数。所有分发策略（类型化调用、fire-and-forget vs 同步等待）
+    /// 由 RealPluginManager.CallAuto() 内部自动完成，调用方无需关心。
+    /// </summary>
+    public object? PluginCall(string pluginName, string methodName, params object?[] args)
+    {
+        if (_pluginManager == null)
+        {
+            Log.Warning("[BlockScriptGlobals] PluginCall: no plugin manager available, " +
+                "cannot call {PluginName}.{MethodName}", pluginName, methodName);
+            return null;
+        }
+
+        var callInfo = new PluginCallInfo
+        {
+            PluginName = pluginName,
+            MethodName = methodName,
+            Parameters = args ?? Array.Empty<object?>()
+        };
+
+        try
+        {
+            if (_pluginManager is RealPluginManager realManager)
+                return realManager.CallAuto(callInfo);
+
+            // Fallback for other IPluginManager implementations
+            return _pluginManager.Call<object?>(callInfo);
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "[BlockScriptGlobals] PluginCall failed: {PluginName}.{MethodName}",
+                pluginName, methodName);
+            return null;
+        }
+    }
 }

KitX Clients/KitX Core/KitX.Core/Workflow/BlockScripting/BlockScriptExecutor.cs

@@ -5,6 +5,10 @@
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
+using Kscript.CSharp.Parser.Core;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.CSharp.Scripting;
 using Microsoft.CodeAnalysis.Scripting;
 using KitX.Core.Contract.Workflow;
@@ -24,6 +28,7 @@ public class BlockScriptExecutor : IBlockScriptExecutor
     private BlockScript? _currentScript;
     private List<string> _output = new();
     private BlockScriptExecutionGlobals? _globals;
+    private IPluginManager? _pluginManager;
 
     /// <summary>
     /// Creates a new block script executor
@@ -41,6 +46,22 @@ public BlockScriptExecutor(BlockScopeManager scopeManager)
         _scopeManager = scopeManager;
     }
 
+    /// <summary>
+    /// Creates a new block script executor with plugin manager support
+    /// </summary>
+    public BlockScriptExecutor(IPluginManager? pluginManager) : this()
+    {
+        _pluginManager = pluginManager;
+    }
+
+    /// <summary>
+    /// Sets the plugin manager for plugin function calls during execution.
+    /// </summary>
+    public void SetPluginManager(IPluginManager? pluginManager)
+    {
+        _pluginManager = pluginManager;
+    }
+
     /// <summary>
     /// Executes a block script
     /// </summary>
@@ -488,6 +509,9 @@ private async Task ExecuteExpressionAsync(
     {
         try
         {
+            // Pre-process: rewrite dotted plugin calls (e.g. "Plugin.Func()") to PluginCall(...)
+            expression = PreProcessPluginCalls(expression);
+
             // Build a complete statement for execution
             var code = WrapExpressionAsStatement(expression);
 
@@ -524,7 +548,7 @@ private async Task ExecuteExpressionAsync(
             else
             {
                 // First evaluation: create initial script state using RunAsync to get ScriptState
-                _globals = new BlockScriptExecutionGlobals(_scopeManager, _output);
+                _globals = new BlockScriptExecutionGlobals(_scopeManager, _output, _pluginManager);
                 var globals = _globals;
                 _scriptState = await CSharpScript.RunAsync(
                     fullCode,
@@ -560,6 +584,106 @@ private string WrapExpressionAsStatement(string expression)
         return expression + ";";
     }
 
+    /// <summary>
+    /// Preprocesses an expression to rewrite dotted plugin calls into PluginCall() invocations.
+    /// Uses Roslyn SyntaxRewriter for safe, AST-level transformation that correctly handles
+    /// nested parentheses, complex expressions, and all edge cases.
+    /// Transforms: TestPlugin.WPF.Core.HelloKitX(arg1, arg2)
+    /// Into: PluginCall("TestPlugin.WPF.Core", "HelloKitX", arg1, arg2)
+    /// Transforms: TestPlugin.WPF.Core.HelloKitX()
+    /// Into: PluginCall("TestPlugin.WPF.Core", "HelloKitX")
+    /// </summary>
+    private static string PreProcessPluginCalls(string expression)
+    {
+        try
+        {
+            var wrappedCode = "_ = " + expression + ";";
+            var syntaxTree = CSharpSyntaxTree.ParseText(wrappedCode);
+            var root = syntaxTree.GetCompilationUnitRoot();
+
+            var rewriter = new PluginCallRewriter();
+            var rewritten = rewriter.Visit(root);
+
+            // Extract the expression back from "_ = ...;"
+            if (rewritten is CompilationUnitSyntax cu
+                && cu.Members.FirstOrDefault() is GlobalStatementSyntax gs
+                && gs.Statement is ExpressionStatementSyntax ess
+                && ess.Expression is AssignmentExpressionSyntax aes)
+            {
+                var result = aes.Right.ToString();
+                if (result != expression)
+                {
+                    Log.Debug("[BlockScriptExecutor] PreProcessPluginCalls: '{Original}' → '{Result}'",
+                        expression, result);
+                }
+                return result;
+            }
+
+            Log.Warning("[BlockScriptExecutor] PreProcessPluginCalls: extraction failed for '{Expression}', " +
+                "rewritten type={Type}", expression, rewritten?.GetType().Name);
+            return expression;
+        }
+        catch (Exception ex)
+        {
+            Log.Warning(ex, "[BlockScriptExecutor] PreProcessPluginCalls: exception for '{Expression}'",
+                expression);
+            return expression;
+        }
+    }
+
+    /// <summary>
+    /// Roslyn SyntaxRewriter that transforms dotted member-access invocations
+    /// (e.g. TestPlugin.WPF.Core.HelloKitX()) into PluginCall("...", "...", args) calls.
+    /// Operates at the AST level, preserving all expression structure and handling nesting.
+    /// </summary>
+    private class PluginCallRewriter : CSharpSyntaxRewriter
+    {
+        public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
+        {
+            // First, recursively rewrite any nested invocations in arguments
+            node = (InvocationExpressionSyntax)base.VisitInvocationExpression(node)!;
+
+            // Only rewrite member-access invocations (e.g. A.B.C.Method())
+            if (node.Expression is not MemberAccessExpressionSyntax member)
+                return node;
+
+            // Only rewrite when the expression has dots (plugin namespace path)
+            var fullExpression = member.Expression.ToString();
+            if (!fullExpression.Contains('.'))
+                return node;
+
+            var pluginName = fullExpression;
+            var funcName = member.Name.Identifier.Text;
+
+            Log.Debug("[PluginCallRewriter] Rewriting: {Plugin}.{Method}() → PluginCall()",
+                pluginName, funcName);
+
+            // Build: PluginCall("pluginName", "funcName" [, existingArgs])
+            // 所有分发策略（类型化调用、f-a-f vs 同步等待）由 Manager 内部自动处理
+            var args = new List<ArgumentSyntax>
+            {
+                SyntaxFactory.Argument(
+                    SyntaxFactory.LiteralExpression(
+                        SyntaxKind.StringLiteralExpression,
+                        SyntaxFactory.Literal(pluginName))),
+                SyntaxFactory.Argument(
+                    SyntaxFactory.LiteralExpression(
+                        SyntaxKind.StringLiteralExpression,
+                        SyntaxFactory.Literal(funcName)))
+            };
+
+            // Append original arguments
+            args.AddRange(node.ArgumentList.Arguments);
+
+            var newArgsList = SyntaxFactory.SeparatedList(args);
+            var newInvocation = SyntaxFactory.InvocationExpression(
+                SyntaxFactory.IdentifierName("PluginCall"),
+                SyntaxFactory.ArgumentList(newArgsList));
+
+            return newInvocation;
+        }
+    }
+
     /// <summary>
     /// Builds helper function code from a list of helper functions
     /// </summary>
@@ -644,7 +768,7 @@ private async Task InitializeScriptSessionAsync(CancellationToken cancellationTo
         if (string.IsNullOrWhiteSpace(initCode))
         {
             // No initialization needed, just do a simple first evaluation to establish session
-            _globals = new BlockScriptExecutionGlobals(_scopeManager, _output);
+            _globals = new BlockScriptExecutionGlobals(_scopeManager, _output, _pluginManager);
             _scriptState = await CSharpScript.RunAsync(
                 "0",  // Simple expression to establish session
                 ScriptOptions.Default
@@ -659,7 +783,7 @@ private async Task InitializeScriptSessionAsync(CancellationToken cancellationTo
 
         try
         {
-            _globals = new BlockScriptExecutionGlobals(_scopeManager, _output);
+            _globals = new BlockScriptExecutionGlobals(_scopeManager, _output, _pluginManager);
             _scriptState = await CSharpScript.RunAsync(
                 initCode,
                 ScriptOptions.Default
@@ -672,7 +796,7 @@ private async Task InitializeScriptSessionAsync(CancellationToken cancellationTo
         {
             Log.Warning(ex, "[BlockScriptExecutor] Initialization script failed, will try without it");
             // Fall back to simple session establishment
-            _globals = new BlockScriptExecutionGlobals(_scopeManager, _output);
+            _globals = new BlockScriptExecutionGlobals(_scopeManager, _output, _pluginManager);
             _scriptState = await CSharpScript.RunAsync(
                 "0",
                 ScriptOptions.Default

KitX Clients/KitX Core/KitX.Core/Workflow/Blueprint/Pipeline/ExprUtils.cs

@@ -82,7 +82,7 @@ public static (ExpressionSyntax? rightExpr, string? assignedVar)? ParseStatement
         catch { return (null, null); }
     }
 
-    /// <summary>Extracts method name from an invocation expression.</summary>
+    /// <summary>Extracts the short method name from an invocation expression.</summary>
     public static string GetMethodName(InvocationExpressionSyntax invoke)
     {
         if (invoke.Expression is IdentifierNameSyntax id) return id.Identifier.Text;
@@ -91,6 +91,20 @@ public static string GetMethodName(InvocationExpressionSyntax invoke)
         return string.Empty;
     }
 
+    /// <summary>
+    /// Extracts the full dotted method path from an invocation expression.
+    /// For "TestPlugin.WPF.Core.HelloKitX()" returns "TestPlugin.WPF.Core.HelloKitX".
+    /// For simple calls like "Get(...)" returns just "Get".
+    /// </summary>
+    public static string GetFullMethodName(InvocationExpressionSyntax invoke)
+    {
+        if (invoke.Expression is IdentifierNameSyntax id) return id.Identifier.Text;
+        if (invoke.Expression is GenericNameSyntax generic) return generic.Identifier.Text;
+        if (invoke.Expression is MemberAccessExpressionSyntax member)
+            return member.Expression.ToString() + "." + member.Name.Identifier.Text;
+        return string.Empty;
+    }
+
     /// <summary>Checks if a token is a simple variable reference.</summary>
     public static bool IsVariableReference(string token)
     {

KitX Clients/KitX Core/KitX.Core/Workflow/Blueprint/Pipeline/FormattedBlockScript.cs

@@ -57,9 +57,16 @@ public class FormattedStatement
     // --- For function calls ---
     /// <summary>
     /// Function name (e.g. "HelperFuncCompare", "Get", "Set", "Print").
+    /// For plugin calls, this is the short name (e.g. "HelloKitX").
     /// </summary>
     public string? FunctionName { get; set; }
 
+    /// <summary>
+    /// Full dotted method path for plugin/external calls (e.g. "TestPlugin.WPF.Core.HelloKitX").
+    /// Null for built-in and helper functions.
+    /// </summary>
+    public string? FullFunctionName { get; set; }
+
     /// <summary>
     /// Raw argument strings after expansion (no nested calls).
     /// Each argument is either a literal, a PubVar name, a ConstBlock variable name, or Get("varName").

KitX Clients/KitX Core/KitX.Core/Workflow/Blueprint/Pipeline/NodeBuilder.cs

@@ -227,7 +227,19 @@ or FormattedStatementKind.LoopBodyEnd
             else
             {
                 var callNode = (CallNode)_registry.Create(BlueprintNodeType.Call);
-                callNode.FunctionName = stmt.FunctionName!;
+
+                // Parse plugin name from full dotted method name (e.g. "TestPlugin.WPF.Core.HelloKitX")
+                if (!string.IsNullOrEmpty(stmt.FullFunctionName) && stmt.FullFunctionName.Contains('.'))
+                {
+                    var lastDot = stmt.FullFunctionName.LastIndexOf('.');
+                    callNode.PluginName = stmt.FullFunctionName.Substring(0, lastDot);
+                    callNode.FunctionName = stmt.FullFunctionName.Substring(lastDot + 1);
+                }
+                else
+                {
+                    callNode.FunctionName = stmt.FunctionName!;
+                }
+
                 mainNode = callNode;
             }