feat(autoagents): implement stateful tools with GraphToolExecutor integration

Replaces stubbed tool implementations with real executor calls.

Changes:
- graph_tools.rs: Add executor field to all 6 tools, implement actual execution
  - GetTransitiveDependencies, GetReverseDependencies, TraceCallChain
  - DetectCycles, CalculateCoupling, GetHubNodes
  - All tools now call self.executor.execute_sync() with proper args
- codegraph_agent.rs: Remove #[agent] macro and CodeGraphAgent struct
  - Keep only CodeGraphAgentOutput with #[AgentOutput] derive
  - Tools can't be auto-instantiated, require manual construction
- agent_builder.rs: Manual tool construction in build() method
  - Create Vec<Box<dyn ToolT>> with all 6 tools
  - Pass Arc<GraphToolExecutorAdapter> to each tool constructor
  - Use ReActAgent::with_tools(tools) instead of macro
- mod.rs: Remove CodeGraphAgent from re-exports

This completes Task 16's stubbed implementations, making all AutoAgents
tools functional with real SurrealDB graph queries.

Author: jruokola

crates/codegraph-mcp/src/autoagents/agent_builder.rs

@@ -174,16 +174,18 @@ impl ChatResponse for CodeGraphChatResponse {
 // Agent Builder
 // ============================================================================
 
-use crate::autoagents::codegraph_agent::CodeGraphAgent;
+use crate::autoagents::codegraph_agent::CodeGraphAgentOutput;
 use crate::autoagents::tier_plugin::TierAwarePromptPlugin;
 use crate::autoagents::tools::tool_executor_adapter::GraphToolFactory;
+use crate::autoagents::tools::graph_tools::*;
 use crate::{AnalysisType, GraphToolExecutor};
 use crate::context_aware_limits::ContextTier;
 
 use autoagents::core::agent::AgentBuilder;
 use autoagents::core::agent::prebuilt::executor::ReActAgent;
 use autoagents::core::agent::memory::SlidingWindowMemory;
 use autoagents::core::error::Error as AutoAgentsError;
+use autoagents::core::tool::ToolT;
 
 /// Builder for CodeGraph AutoAgents workflows
 pub struct CodeGraphAgentBuilder {
@@ -219,8 +221,21 @@ impl CodeGraphAgentBuilder {
         let memory_size = tier_plugin.get_max_iterations() * 2;
         let memory = Box::new(SlidingWindowMemory::new(memory_size));
 
-        // Build ReAct agent with our tools
-        let react_agent = ReActAgent::new(CodeGraphAgent::default());
+        // Get executor adapter for tool construction
+        let executor_adapter = self.tool_factory.adapter();
+
+        // Manually construct all 6 tools with the executor
+        let tools: Vec<Box<dyn ToolT>> = vec![
+            Box::new(GetTransitiveDependencies::new(executor_adapter.clone())),
+            Box::new(GetReverseDependencies::new(executor_adapter.clone())),
+            Box::new(TraceCallChain::new(executor_adapter.clone())),
+            Box::new(DetectCycles::new(executor_adapter.clone())),
+            Box::new(CalculateCoupling::new(executor_adapter.clone())),
+            Box::new(GetHubNodes::new(executor_adapter.clone())),
+        ];
+
+        // Build ReAct agent with manually constructed tools
+        let react_agent = ReActAgent::with_tools(tools);
 
         // Build full agent with configuration
         let agent = AgentBuilder::new(react_agent)

crates/codegraph-mcp/src/autoagents/codegraph_agent.rs

@@ -1,43 +1,23 @@
 // ABOUTME: CodeGraph agent definition for AutoAgents ReAct workflow
-// ABOUTME: Defines tools, output format, and behavior for graph analysis
+// ABOUTME: Defines output format and behavior for graph analysis (tools registered manually)
 
 use autoagents::core::agent::prebuilt::executor::ReActAgentOutput;
-use autoagents_derive::{agent, AgentHooks, AgentOutput};
+use autoagents_derive::AgentOutput;
 use serde::{Deserialize, Serialize};
 
-use crate::autoagents::tools::graph_tools::*;
-
 /// CodeGraph agent output format
 #[derive(Debug, Serialize, Deserialize, AgentOutput)]
 pub struct CodeGraphAgentOutput {
     #[output(description = "Final answer to the query")]
-    answer: String,
+    pub answer: String,
 
     #[output(description = "Key findings from graph analysis")]
-    findings: String,
+    pub findings: String,
 
     #[output(description = "Number of analysis steps performed")]
-    steps_taken: String,
+    pub steps_taken: String,
 }
 
-/// CodeGraph agent for code analysis via graph traversal
-#[agent(
-    name = "codegraph_agent",
-    description = "You are a code analysis agent with access to graph database tools. \
-                   Analyze code dependencies, call chains, and architectural patterns.",
-    tools = [
-        GetTransitiveDependencies,
-        GetReverseDependencies,
-        TraceCallChain,
-        DetectCycles,
-        CalculateCoupling,
-        GetHubNodes
-    ],
-    output = CodeGraphAgentOutput,
-)]
-#[derive(Default, Clone, AgentHooks)]
-pub struct CodeGraphAgent {}
-
 impl From<ReActAgentOutput> for CodeGraphAgentOutput {
     fn from(output: ReActAgentOutput) -> Self {
         let resp = output.response;

crates/codegraph-mcp/src/autoagents/mod.rs

@@ -20,6 +20,6 @@ pub use tier_plugin::TierAwarePromptPlugin;
 #[cfg(feature = "autoagents-experimental")]
 pub use agent_builder::{CodeGraphChatAdapter, CodeGraphAgentBuilder, AgentHandle};
 #[cfg(feature = "autoagents-experimental")]
-pub use codegraph_agent::{CodeGraphAgent, CodeGraphAgentOutput};
+pub use codegraph_agent::CodeGraphAgentOutput;
 #[cfg(feature = "autoagents-experimental")]
 pub use executor::{CodeGraphExecutor, CodeGraphExecutorBuilder, ExecutorError};

crates/codegraph-mcp/src/autoagents/tools/graph_tools.rs

@@ -1,5 +1,5 @@
 // ABOUTME: AutoAgents tool definitions for SurrealDB graph analysis
-// ABOUTME: Type-safe wrappers using AutoAgents derive macros
+// ABOUTME: Type-safe wrappers using AutoAgents derive macros with stateful executor access
 
 use autoagents::core::tool::{ToolCallError, ToolInputT, ToolRuntime, ToolT};
 use autoagents_derive::{tool, ToolInput};
@@ -36,22 +36,32 @@ fn default_depth() -> i32 {
                    Follows dependency edges recursively to find all nodes this node depends on.",
     input = GetTransitiveDependenciesArgs,
 )]
-pub struct GetTransitiveDependencies {}
+pub struct GetTransitiveDependencies {
+    executor: Arc<GraphToolExecutorAdapter>,
+}
+
+impl GetTransitiveDependencies {
+    pub fn new(executor: Arc<GraphToolExecutorAdapter>) -> Self {
+        Self { executor }
+    }
+}
 
 #[async_trait::async_trait]
 impl ToolRuntime for GetTransitiveDependencies {
     async fn execute(&self, args: serde_json::Value) -> Result<serde_json::Value, ToolCallError> {
         let typed_args: GetTransitiveDependenciesArgs = serde_json::from_value(args)?;
 
-        // TODO: Need executor instance - for now return placeholder
-        Ok(serde_json::json!({
-            "status": "not_implemented",
-            "params": {
+        // Call the actual executor
+        let result = self.executor.execute_sync(
+            "get_transitive_dependencies",
+            serde_json::json!({
                 "node_id": typed_args.node_id,
                 "edge_type": typed_args.edge_type,
-                "depth": typed_args.depth,
-            }
-        }))
+                "depth": typed_args.depth
+            })
+        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+
+        Ok(result)
     }
 }
 
@@ -74,13 +84,31 @@ pub struct GetReverseDependenciesArgs {
     description = "Get all nodes that depend on the specified node. Useful for impact analysis.",
     input = GetReverseDependenciesArgs,
 )]
-pub struct GetReverseDependencies {}
+pub struct GetReverseDependencies {
+    executor: Arc<GraphToolExecutorAdapter>,
+}
+
+impl GetReverseDependencies {
+    pub fn new(executor: Arc<GraphToolExecutorAdapter>) -> Self {
+        Self { executor }
+    }
+}
 
 #[async_trait::async_trait]
 impl ToolRuntime for GetReverseDependencies {
     async fn execute(&self, args: serde_json::Value) -> Result<serde_json::Value, ToolCallError> {
-        let _typed_args: GetReverseDependenciesArgs = serde_json::from_value(args)?;
-        Ok(serde_json::json!({"status": "not_implemented"}))
+        let typed_args: GetReverseDependenciesArgs = serde_json::from_value(args)?;
+
+        let result = self.executor.execute_sync(
+            "get_reverse_dependencies",
+            serde_json::json!({
+                "node_id": typed_args.node_id,
+                "edge_type": typed_args.edge_type,
+                "depth": typed_args.depth
+            })
+        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+
+        Ok(result)
     }
 }
 
@@ -104,13 +132,30 @@ fn default_call_chain_depth() -> i32 {
     description = "Trace the execution flow from a starting function through all called functions.",
     input = TraceCallChainArgs,
 )]
-pub struct TraceCallChain {}
+pub struct TraceCallChain {
+    executor: Arc<GraphToolExecutorAdapter>,
+}
+
+impl TraceCallChain {
+    pub fn new(executor: Arc<GraphToolExecutorAdapter>) -> Self {
+        Self { executor }
+    }
+}
 
 #[async_trait::async_trait]
 impl ToolRuntime for TraceCallChain {
     async fn execute(&self, args: serde_json::Value) -> Result<serde_json::Value, ToolCallError> {
-        let _typed_args: TraceCallChainArgs = serde_json::from_value(args)?;
-        Ok(serde_json::json!({"status": "not_implemented"}))
+        let typed_args: TraceCallChainArgs = serde_json::from_value(args)?;
+
+        let result = self.executor.execute_sync(
+            "trace_call_chain",
+            serde_json::json!({
+                "start_node_id": typed_args.start_node_id,
+                "max_depth": typed_args.max_depth
+            })
+        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+
+        Ok(result)
     }
 }
 
@@ -135,13 +180,30 @@ fn default_max_cycle_length() -> i32 {
     description = "Detect circular dependencies and cycles in the codebase graph.",
     input = DetectCyclesArgs,
 )]
-pub struct DetectCycles {}
+pub struct DetectCycles {
+    executor: Arc<GraphToolExecutorAdapter>,
+}
+
+impl DetectCycles {
+    pub fn new(executor: Arc<GraphToolExecutorAdapter>) -> Self {
+        Self { executor }
+    }
+}
 
 #[async_trait::async_trait]
 impl ToolRuntime for DetectCycles {
     async fn execute(&self, args: serde_json::Value) -> Result<serde_json::Value, ToolCallError> {
-        let _typed_args: DetectCyclesArgs = serde_json::from_value(args)?;
-        Ok(serde_json::json!({"status": "not_implemented"}))
+        let typed_args: DetectCyclesArgs = serde_json::from_value(args)?;
+
+        let result = self.executor.execute_sync(
+            "detect_cycles",
+            serde_json::json!({
+                "edge_type": typed_args.edge_type,
+                "max_cycle_length": typed_args.max_cycle_length
+            })
+        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+
+        Ok(result)
     }
 }
 
@@ -161,13 +223,30 @@ pub struct CalculateCouplingArgs {
     description = "Calculate afferent/efferent coupling and instability metrics for a node.",
     input = CalculateCouplingArgs,
 )]
-pub struct CalculateCoupling {}
+pub struct CalculateCoupling {
+    executor: Arc<GraphToolExecutorAdapter>,
+}
+
+impl CalculateCoupling {
+    pub fn new(executor: Arc<GraphToolExecutorAdapter>) -> Self {
+        Self { executor }
+    }
+}
 
 #[async_trait::async_trait]
 impl ToolRuntime for CalculateCoupling {
     async fn execute(&self, args: serde_json::Value) -> Result<serde_json::Value, ToolCallError> {
-        let _typed_args: CalculateCouplingArgs = serde_json::from_value(args)?;
-        Ok(serde_json::json!({"status": "not_implemented"}))
+        let typed_args: CalculateCouplingArgs = serde_json::from_value(args)?;
+
+        let result = self.executor.execute_sync(
+            "calculate_coupling",
+            serde_json::json!({
+                "node_id": typed_args.node_id,
+                "edge_type": typed_args.edge_type
+            })
+        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+
+        Ok(result)
     }
 }
 
@@ -199,13 +278,31 @@ fn default_limit() -> i32 {
     description = "Find highly connected hub nodes in the dependency graph.",
     input = GetHubNodesArgs,
 )]
-pub struct GetHubNodes {}
+pub struct GetHubNodes {
+    executor: Arc<GraphToolExecutorAdapter>,
+}
+
+impl GetHubNodes {
+    pub fn new(executor: Arc<GraphToolExecutorAdapter>) -> Self {
+        Self { executor }
+    }
+}
 
 #[async_trait::async_trait]
 impl ToolRuntime for GetHubNodes {
     async fn execute(&self, args: serde_json::Value) -> Result<serde_json::Value, ToolCallError> {
-        let _typed_args: GetHubNodesArgs = serde_json::from_value(args)?;
-        Ok(serde_json::json!({"status": "not_implemented"}))
+        let typed_args: GetHubNodesArgs = serde_json::from_value(args)?;
+
+        let result = self.executor.execute_sync(
+            "get_hub_nodes",
+            serde_json::json!({
+                "edge_type": typed_args.edge_type,
+                "min_connections": typed_args.min_connections,
+                "limit": typed_args.limit
+            })
+        ).map_err(|e| ToolCallError::ExecutionFailed(e))?;
+
+        Ok(result)
     }
 }