feat(mcp): complete Phase 2B analysis tools migration and symbol tools fixes

- Complete migration of 5 analysis tools from tools_legacy.rs:
  * detect_patterns: comprehensive pattern detection with confidence scoring
  * analyze_transitive_dependencies: dependency chain analysis with cycle detection
  * trace_data_flow: bidirectional flow tracing with transformation detection
  * trace_inheritance: hierarchy visualization with MRO complexity assessment
  * analyze_decorators: usage pattern analysis with framework detection

- Fix symbol tools API compatibility issues:
  * Updated get_dependencies → find_dependencies with DependencyType parameter
  * Fixed SymbolReference.source → SymbolReference.source_node
  * Updated SymbolReference.kind → SymbolReference.edge_kind
  * Fixed Node constructor for proper 6-argument initialization

- Add comprehensive debug tools and utilities:
  * debug_tools.rs: tool testing and validation utilities
  * list_all_tools.rs: complete tool inventory with counts

- Remove dead code from tools_legacy.rs:
  * Removed migrated transitive dependency analysis methods
  * Cleaned up unused helper functions and cycle detection code
  * All 219 tests passing with clean modular architecture

- Migration: 20/20 tools complete (Repository: 2, Search: 3, Symbols: 4, Analysis: 6, Quality: 5)

Architecture: Systematic migration from 10K+ line monolithic tools_legacy.rs
to focused 300-500 line modules with clear responsibilities

Author: milliondreams

crates/codeprism-mcp/examples/debug_tools.rs

@@ -0,0 +1,68 @@
+//! Debug tool sources for migration analysis
+
+use codeprism_mcp::{tools::ToolManager, CodePrismMcpServer};
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let server = Arc::new(RwLock::new(CodePrismMcpServer::new()?));
+    let manager = ToolManager::new(server.clone());
+
+    // Get modular tools
+    let mut modular_tools = Vec::new();
+    modular_tools.extend(codeprism_mcp::tools::basic::repository::list_tools());
+    modular_tools.extend(codeprism_mcp::tools::basic::search::list_tools());
+    modular_tools.extend(codeprism_mcp::tools::basic::symbols::list_tools());
+    modular_tools.extend(codeprism_mcp::tools::analysis::complexity::list_tools());
+    modular_tools.extend(codeprism_mcp::tools::analysis::patterns::list_tools());
+    modular_tools.extend(codeprism_mcp::tools::analysis::dependencies::list_tools());
+    modular_tools.extend(codeprism_mcp::tools::analysis::flow::list_tools());
+    modular_tools.extend(codeprism_mcp::tools::analysis::inheritance::list_tools());
+    modular_tools.extend(codeprism_mcp::tools::analysis::decorators::list_tools());
+    modular_tools.extend(codeprism_mcp::tools::quality::list_tools());
+
+    // Get legacy tools
+    let legacy_manager = codeprism_mcp::tools_legacy::ToolManager::new(server);
+    let legacy_result = legacy_manager
+        .list_tools(codeprism_mcp::tools::ListToolsParams { cursor: None })
+        .await?;
+
+    println!("=== MODULAR TOOLS ({}) ===", modular_tools.len());
+    for (i, tool) in modular_tools.iter().enumerate() {
+        println!("{}. {} - {}", i + 1, tool.name, tool.description);
+    }
+
+    println!("\n=== LEGACY TOOLS ({}) ===", legacy_result.tools.len());
+    for (i, tool) in legacy_result.tools.iter().enumerate() {
+        println!("{}. {} - {}", i + 1, tool.name, tool.description);
+    }
+
+    // Check for duplicates
+    let modular_names: std::collections::HashSet<String> =
+        modular_tools.iter().map(|t| t.name.clone()).collect();
+    let legacy_names: std::collections::HashSet<String> =
+        legacy_result.tools.iter().map(|t| t.name.clone()).collect();
+
+    let duplicates: Vec<_> = modular_names.intersection(&legacy_names).collect();
+
+    println!("\n=== DUPLICATES ({}) ===", duplicates.len());
+    for dup in &duplicates {
+        println!("- {}", dup);
+    }
+
+    // Final combined list (how ToolManager does it)
+    let combined_result = manager
+        .list_tools(codeprism_mcp::tools::ListToolsParams { cursor: None })
+        .await?;
+
+    println!(
+        "\n=== FINAL COMBINED TOOLS ({}) ===",
+        combined_result.tools.len()
+    );
+    for (i, tool) in combined_result.tools.iter().enumerate() {
+        println!("{}. {} - {}", i + 1, tool.name, tool.description);
+    }
+
+    Ok(())
+}

crates/codeprism-mcp/examples/list_all_tools.rs

@@ -0,0 +1,24 @@
+//! List all available tools for migration analysis
+
+use codeprism_mcp::{tools::ToolManager, CodePrismMcpServer};
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let server = Arc::new(RwLock::new(CodePrismMcpServer::new()?));
+    let manager = ToolManager::new(server);
+
+    let tools_result = manager
+        .list_tools(codeprism_mcp::tools::ListToolsParams { cursor: None })
+        .await?;
+
+    println!("Total tools available: {}", tools_result.tools.len());
+    println!("\nAll available tools:");
+
+    for (i, tool) in tools_result.tools.iter().enumerate() {
+        println!("{}. {} - {}", i + 1, tool.name, tool.description);
+    }
+
+    Ok(())
+}

crates/codeprism-mcp/src/tools/analysis/flow.rs

@@ -246,90 +246,48 @@ async fn collect_transitive_deps(
 
 /// List data flow analysis tools
 pub fn list_tools() -> Vec<Tool> {
-    vec![
-        Tool {
-            name: "trace_data_flow".to_string(),
-            title: Some("Trace Data Flow".to_string()),
-            description: "Trace data flow through the codebase with variable and parameter tracking".to_string(),
-            input_schema: serde_json::json!({
-                "type": "object",
-                "properties": {
-                    "variable_or_parameter": {
-                        "type": "string",
-                        "description": "Variable or parameter to trace"
-                    },
-                    "direction": {
-                        "type": "string",
-                        "enum": ["forward", "backward", "both"],
-                        "default": "forward",
-                        "description": "Direction to trace data flow"
-                    },
-                    "include_transformations": {
-                        "type": "boolean",
-                        "default": true,
-                        "description": "Include data transformations in trace"
-                    },
-                    "max_depth": {
-                        "type": "integer",
-                        "default": 10,
-                        "description": "Maximum depth for flow traversal"
-                    },
-                    "follow_function_calls": {
-                        "type": "boolean",
-                        "default": true,
-                        "description": "Follow data flow through function calls"
-                    },
-                    "include_field_access": {
-                        "type": "boolean",
-                        "default": true,
-                        "description": "Include field access in data flow"
-                    }
+    vec![Tool {
+        name: "trace_data_flow".to_string(),
+        title: Some("Trace Data Flow".to_string()),
+        description: "Trace data flow through the codebase with variable and parameter tracking"
+            .to_string(),
+        input_schema: serde_json::json!({
+            "type": "object",
+            "properties": {
+                "variable_or_parameter": {
+                    "type": "string",
+                    "description": "Variable or parameter to trace"
                 },
-                "required": ["variable_or_parameter"]
-            }),
-        },
-        Tool {
-            name: "analyze_transitive_dependencies".to_string(),
-            title: Some("Analyze Transitive Dependencies".to_string()),
-            description: "Analyze complete dependency chains, detect cycles, and map transitive relationships".to_string(),
-            input_schema: serde_json::json!({
-                "type": "object",
-                "properties": {
-                    "target": {
-                        "type": "string",
-                        "description": "Symbol ID or file path to analyze"
-                    },
-                    "max_depth": {
-                        "type": "number",
-                        "description": "Maximum depth for transitive analysis",
-                        "default": 5,
-                        "minimum": 1,
-                        "maximum": 20
-                    },
-                    "detect_cycles": {
-                        "type": "boolean",
-                        "description": "Detect circular dependencies",
-                        "default": true
-                    },
-                    "include_external_dependencies": {
-                        "type": "boolean",
-                        "description": "Include external/third-party dependencies",
-                        "default": false
-                    },
-                    "dependency_types": {
-                        "type": "array",
-                        "items": {
-                            "type": "string",
-                            "enum": ["calls", "imports", "reads", "writes", "extends", "implements", "all"]
-                        },
-                        "description": "Types of dependencies to analyze",
-                        "default": ["all"]
-                    }
+                "direction": {
+                    "type": "string",
+                    "enum": ["forward", "backward", "both"],
+                    "default": "forward",
+                    "description": "Direction to trace data flow"
                 },
-                "required": ["target"]
-            }),
-        }
-    ]
+                "include_transformations": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Include data transformations in trace"
+                },
+                "max_depth": {
+                    "type": "integer",
+                    "default": 10,
+                    "description": "Maximum depth for flow traversal"
+                },
+                "follow_function_calls": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Follow data flow through function calls"
+                },
+                "include_field_access": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Include field access in data flow"
+                }
+            },
+            "required": ["variable_or_parameter"]
+        }),
+    }]
 }
 
 /// Call data flow analysis tool

crates/codeprism-mcp/src/tools/basic/symbols.rs

@@ -653,7 +653,6 @@ async fn find_references(
 }
 
 /// Helper functions extracted from legacy implementation
-
 /// Parse a node ID from a hex string
 fn parse_node_id(hex_str: &str) -> Result<codeprism_core::NodeId> {
     codeprism_core::NodeId::from_hex(hex_str)