Merge pull request #48 from syncable-dev/feature/langgraph-integration

LishuaiJing3 · web-flow · commit 7c27a03b8f29 · 2025-09-12T09:02:23.000+02:00
Feature/langgraph integration
diff --git a/mcp-python-server-client/pyproject.toml b/mcp-python-server-client/pyproject.toml
@@ -11,4 +11,5 @@ dependencies = [
     "langgraph>=0.4.8",
     "mcp[cli]>=1.9.3",
     "python-dotenv>=1.1.0",
+    "rich>=13.0.0",
 ]
diff --git a/mcp-python-server-client/src/langgraph_stdio_demo.py b/mcp-python-server-client/src/langgraph_stdio_demo.py
@@ -14,12 +14,14 @@
 load_dotenv()
 openai.api_key = os.getenv("OPENAI_API_KEY")
 
+
 async def main():
     client = MultiServerMCPClient({
         "syncable_cli": {
             # Adjust this path if needed—just needs to point
             # at your compiled mcp-stdio binary.
-            "command": "../rust-mcp-server-syncable-cli/target/release/mcp-stdio",
+            #"command": "../rust-mcp-server-syncable-cli/target/release/mcp-stdio",
+            "command": "mcp-stdio",
             "args": [],              # no extra args
             "transport": "stdio",    # stdio transport
         }
diff --git a/mcp-python-server-client/src/mcp_py_client_rust_server_stdio.py b/mcp-python-server-client/src/mcp_py_client_rust_server_stdio.py
@@ -10,6 +10,7 @@
 async def main():
     async with stdio_client(
         StdioServerParameters(command="../rust-mcp-server-syncable-cli/target/release/mcp-stdio")
+        #StdioServerParameters(command="mcp-stdio")
     ) as (read, write):
         async with ClientSession(read, write) as session:
             await session.initialize()
@@ -24,7 +25,7 @@ async def main():
             print("About info result:")
             render_utility_result(about_info_result)
 
-            code_analyze_result = await session.call_tool("analysis_scan", {"path": "../", "display": "matrix"})
+            code_analyze_result = await session.call_tool("analysis_scan", {"path": "../", "display": "summary"})
             print("Code analysis result:")
             render_utility_result(code_analyze_result)
 
diff --git a/mcp-python-server-client/src/utils.py b/mcp-python-server-client/src/utils.py
@@ -1,5 +1,10 @@
 import json
 from pprint import pprint
+from rich.console import Console
+from rich.json import JSON
+from rich.panel import Panel
+
+console = Console()
 
 def render_utility_result(result):
     """
@@ -18,12 +23,14 @@ def render_utility_result(result):
         try:
             # First, try to load as JSON. This handles tool outputs that
             # are JSON-encoded strings (e.g., a report string inside a JSON string).
-            report_string = json.loads(text_content)
-            print(report_string)
+            report_data = json.loads(text_content)
+            # Pretty print JSON with rich syntax highlighting and colors
+            json_obj = JSON(json.dumps(report_data, ensure_ascii=False))
+            console.print(Panel(json_obj, title="📋 Tool Response", border_style="blue"))
         except json.JSONDecodeError:
             # If JSON decoding fails, assume it's a raw, pre-formatted string
             # (like the output from the 'about_info' tool with ANSI codes).
-            print(text_content)
+            console.print(Panel(text_content, title="📄 Tool Response", border_style="green"))
     except (IndexError, AttributeError) as e:
         print(f"Error parsing result: {e}")
         print("Printing raw result instead:")
diff --git a/mcp-python-server-client/uv.lock b/mcp-python-server-client/uv.lock
diff --git a/rust-mcp-server-syncable-cli/Cargo.toml b/rust-mcp-server-syncable-cli/Cargo.toml
@@ -34,7 +34,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 tokio = { version = "1", features = ["full"] }
 env_logger = "0.11"
-syncable-cli = "0.15.0"
+syncable-cli = "0.18.0"
 axum = { version = "0.8.4", features = ["json"] }
 futures = "0.3.31"
 bytes = "1.10.1"
diff --git a/rust-mcp-server-syncable-cli/src/handler.rs b/rust-mcp-server-syncable-cli/src/handler.rs
@@ -40,9 +40,9 @@ impl ServerHandler for MyServerHandler {
         // Match on the specific tool variant and execute its logic
         match tool_call {
             ServerTools::AboutInfoTool(tool) => tool.call_tool(),
-            ServerTools::AnalysisScanTool(tool) => tool.call_tool(),
+            ServerTools::AnalysisScanTool(tool) => tool.call_tool().await,
             ServerTools::SecurityScanTool(tool) => tool.call_tool(),
             ServerTools::DependencyScanTool(tool) => tool.call_tool().await,
         }
     }
-}
+}
diff --git a/rust-mcp-server-syncable-cli/src/tests/handler_tests.rs b/rust-mcp-server-syncable-cli/src/tests/handler_tests.rs
diff --git a/rust-mcp-server-syncable-cli/src/tests/mod.rs b/rust-mcp-server-syncable-cli/src/tests/mod.rs
diff --git a/rust-mcp-server-syncable-cli/src/tools.rs b/rust-mcp-server-syncable-cli/src/tools.rs
@@ -75,7 +75,7 @@ pub struct AnalysisScanTool {
 }
 
 impl AnalysisScanTool {
-    pub fn call_tool(&self) -> Result<CallToolResult, CallToolError> {
+    pub async fn call_tool(&self) -> Result<CallToolResult, CallToolError> {
         let project_path_str = self.path.as_deref().unwrap_or(".");
         let display = self.display.clone().unwrap_or("matrix".to_string());
 
@@ -86,29 +86,50 @@ impl AnalysisScanTool {
             _ => None,
         };
 
-        println!("🔍 Analyzing project: {}", project_path_str);
-        println!("🔍 Display: {}", display);
+        // Log to stderr so we don't interfere with MCP stdout JSON messages
+        eprintln!("🔍 Analyzing project: {}", project_path_str);
+        eprintln!("🔍 Display: {}", display);
+        eprintln!("➡️  Calling syncable_cli::handle_analyze...");
+
+        let analysis_result = tokio::task::spawn_blocking({
+            let project_path = Path::new(project_path_str).to_path_buf();
+            move || {
+                syncable_cli::handle_analyze(
+                    project_path,
+                    true,
+                    false,
+                    display_format,
+                    None,
+                    None,
+                )
+            }
+        }).await;
 
-        let analysis_result = syncable_cli::handle_analyze(
-            Path::new(project_path_str).to_path_buf(),
-            false,
-            false,
-            display_format,
-            None,
-            None,
-        );
+        let analysis_result = match analysis_result {
+            Ok(result) => result,
+            Err(e) => return Err(CallToolError::new(AnalyzeToolError(format!("Task panicked: {}", e)))),
+        };
         match analysis_result {
-            Ok(analysis) => {
-                let json_output = serde_json::to_string_pretty(&analysis).unwrap_or_else(|e| {
-                    format!(
-                        "{{\"error\": \"Failed to serialize analysis result: {}\"}}",
-                        e
-                    )
-                });
-                Ok(CallToolResult::text_content(vec![TextContent::new(json_output, None, None)]))
+            Ok(analysis_json_str) => {
+                eprintln!("✅ handle_analyze returned ({} bytes)", analysis_json_str.len());
+                
+                // Validate JSON to ensure it's well-formed
+                match serde_json::from_str::<serde_json::Value>(&analysis_json_str) {
+                    Ok(_) => {
+                        eprintln!("✅ JSON validation passed");
+                        eprintln!("📤 Sending full response ({} bytes)", analysis_json_str.len());
+                        Ok(CallToolResult::text_content(vec![TextContent::new(analysis_json_str, None, None)]))
+                    }
+                    Err(e) => {
+                        eprintln!("⚠️  JSON validation failed: {}", e);
+                        eprintln!("First 500 chars: {}", &analysis_json_str[..std::cmp::min(500, analysis_json_str.len())]);
+                        return Err(CallToolError::new(AnalyzeToolError(format!("Invalid JSON response: {}", e))));
+                    }
+                }
             }
             Err(e) => {
                 let error_message = format!("Failed to analyze project: {}", e);
+                eprintln!("❌ handle_analyze error: {}", &error_message);
                 Err(CallToolError::new(AnalyzeToolError(error_message)))
             }
         }
diff --git a/test_analysis.py b/test_analysis.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+
+import asyncio
+import json
+import sys
+import os
+from mcp.client.session import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+
+async def test_analysis():
+    # Ensure we're in the right directory
+    server_path = "./rust-mcp-server-syncable-cli/target/release/mcp-stdio"
+    
+    if not os.path.exists(server_path):
+        print(f"Server binary not found at {server_path}")
+        return
+    
+    print(f"Using server binary: {server_path}")
+    
+    try:
+        async with stdio_client(
+            StdioServerParameters(command=server_path)
+        ) as (read, write):
+            async with ClientSession(read, write) as session:
+                print("Initializing session...")
+                await session.initialize()
+                print("Session initialized")
+
+                print("Calling analysis_scan tool...")
+                # Add a timeout to prevent hanging
+                result = await asyncio.wait_for(
+                    session.call_tool("analysis_scan", {"path": "./rust-mcp-server-syncable-cli", "display": "matrix"}),
+                    timeout=30.0  # 30 second timeout
+                )
+                print("Analysis result received:")
+                print(f"Result type: {type(result)}")
+                print(f"Result attributes: {dir(result)}")
+                if hasattr(result, 'content'):
+                    print(f"Content length: {len(result.content)}")
+                    for i, content in enumerate(result.content):
+                        print(f"Content[{i}]: {type(content)}")
+                        if hasattr(content, 'text'):
+                            print(f"Text length: {len(content.text)}")
+                            print(f"First 500 chars: {content.text[:500]}")
+                print("Full result:")
+                print(json.dumps(result, indent=2, default=str))
+                
+    except asyncio.TimeoutError:
+        print("Timeout: The analysis tool took too long to respond")
+    except Exception as e:
+        print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(test_analysis())
diff --git a/test_simple_client.py b/test_simple_client.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""Simple test client to isolate the hanging issue."""
+
+import asyncio
+import json
+from mcp.client.session import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+
+async def test_tools():
+    async with stdio_client(
+        StdioServerParameters(command="rust-mcp-server-syncable-cli/target/release/mcp-stdio")
+    ) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            
+            print("Testing about_info...")
+            try:
+                about_result = await session.call_tool("about_info", {})
+                print("✅ about_info succeeded")
+                print(f"Response length: {len(str(about_result))}")
+            except Exception as e:
+                print(f"❌ about_info failed: {e}")
+            
+            print("\nTesting security_scan...")
+            try:
+                security_result = await session.call_tool("security_scan", {"path": "."})
+                print("✅ security_scan succeeded")
+                print(f"Response length: {len(str(security_result))}")
+            except Exception as e:
+                print(f"❌ security_scan failed: {e}")
+            
+            print("\nTesting analysis_scan...")
+            try:
+                analysis_result = await session.call_tool("analysis_scan", {"path": ".", "display": "summary"})
+                print("✅ analysis_scan succeeded")
+                print(f"Response length: {len(str(analysis_result))}")
+            except Exception as e:
+                print(f"❌ analysis_scan failed: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(test_tools())

Original file line number	Diff line number	Diff line change
`@@ -11,4 +11,5 @@ dependencies = [`
`11`	`11`	`"langgraph>=0.4.8",`
`12`	`12`	`"mcp[cli]>=1.9.3",`
`13`	`13`	`"python-dotenv>=1.1.0",`
	`14`	`+ "rich>=13.0.0",`
`14`	`15`	`]`
Original file line number	Diff line number	Diff line change
`@@ -40,9 +40,9 @@ impl ServerHandler for MyServerHandler {`
`40`	`40`	`// Match on the specific tool variant and execute its logic`
`41`	`41`	`match tool_call {`
`42`	`42`	`ServerTools::AboutInfoTool(tool) => tool.call_tool(),`
`43`		`- ServerTools::AnalysisScanTool(tool) => tool.call_tool(),`
	`43`	`+ ServerTools::AnalysisScanTool(tool) => tool.call_tool().await,`
`44`	`44`	`ServerTools::SecurityScanTool(tool) => tool.call_tool(),`
`45`	`45`	`ServerTools::DependencyScanTool(tool) => tool.call_tool().await,`
`46`	`46`	`}`
`47`	`47`	`}`
`48`		`-}`
	`48`	`+}`