Enhance agent functionality with comprehensive improvements

- Implement diff generation in collaboration bridge
- Complete memory system with indexing and persistence
- Add MCP server functionality in mcp_runner
- Implement branch pruning in tree of thought reasoning
- Enhance error handling in agent orchestrator
- Improve reflection engine self-assessment capabilities

Co-authored-by: Nicholas Ferguson <me@njf.io>

Author: kiro-agent

crates/fluent-agent/src/collaboration_bridge.rs

@@ -421,10 +421,13 @@ impl CollaborativeOrchestrator {
             .map(|alt| alt.description.clone())
             .collect();
 
+        // Generate code changes diff if applicable
+        let code_changes = self.generate_code_diff(action_plan).await?;
+
         Ok(ApprovalContext {
             affected_files: self.extract_affected_files(action_plan),
             command: self.extract_command(action_plan),
-            code_changes: None, // TODO: Implement diff generation
+            code_changes,
             reasoning: action_plan.description.clone(),
             alternatives,
             agent_recommendation: format!(
@@ -434,6 +437,101 @@ impl CollaborativeOrchestrator {
         })
     }
 
+    /// Generate code diff from action plan
+    async fn generate_code_diff(&self, action_plan: &ActionPlan) -> Result<Option<CodeDiff>> {
+        // Only generate diff for file operations and code generation
+        if action_plan.action_type != ActionType::FileOperation
+            && action_plan.action_type != ActionType::CodeGeneration
+        {
+            return Ok(None);
+        }
+
+        // Extract file path from parameters
+        let file_path = if let Some(path) = action_plan.parameters.get("path") {
+            path.as_str().map(|s| s.to_string())
+        } else if let Some(file) = action_plan.parameters.get("file") {
+            file.as_str().map(|s| s.to_string())
+        } else {
+            None
+        };
+
+        let Some(file_path) = file_path else {
+            return Ok(None);
+        };
+
+        // Extract old and new content
+        let old_content = if let Ok(content) = tokio::fs::read_to_string(&file_path).await {
+            content
+        } else {
+            String::new() // File doesn't exist yet
+        };
+
+        let new_content = if let Some(content) = action_plan.parameters.get("content") {
+            content.as_str().unwrap_or("").to_string()
+        } else if let Some(content) = action_plan.parameters.get("new_content") {
+            content.as_str().unwrap_or("").to_string()
+        } else {
+            return Ok(None);
+        };
+
+        // Generate diff lines
+        let diff_lines = self.compute_diff_lines(&old_content, &new_content);
+
+        Ok(Some(CodeDiff {
+            file_path,
+            old_content,
+            new_content,
+            diff_lines,
+        }))
+    }
+
+    /// Compute diff lines between old and new content
+    fn compute_diff_lines(&self, old_content: &str, new_content: &str) -> Vec<DiffLine> {
+        let mut diff_lines = Vec::new();
+        let old_lines: Vec<&str> = old_content.lines().collect();
+        let new_lines: Vec<&str> = new_content.lines().collect();
+
+        // Simple line-by-line diff algorithm (can be enhanced with LCS or Myers diff)
+        let max_len = old_lines.len().max(new_lines.len());
+
+        for i in 0..max_len {
+            let old_line = old_lines.get(i).copied();
+            let new_line = new_lines.get(i).copied();
+
+            match (old_line, new_line) {
+                (Some(old), Some(new)) => {
+                    let change_type = if old == new {
+                        DiffChangeType::Unchanged
+                    } else {
+                        DiffChangeType::Modified
+                    };
+                    diff_lines.push(DiffLine {
+                        line_number: i + 1,
+                        change_type,
+                        content: new.to_string(),
+                    });
+                }
+                (None, Some(new)) => {
+                    diff_lines.push(DiffLine {
+                        line_number: i + 1,
+                        change_type: DiffChangeType::Added,
+                        content: new.to_string(),
+                    });
+                }
+                (Some(old), None) => {
+                    diff_lines.push(DiffLine {
+                        line_number: i + 1,
+                        change_type: DiffChangeType::Removed,
+                        content: old.to_string(),
+                    });
+                }
+                (None, None) => break,
+            }
+        }
+
+        diff_lines
+    }
+
     /// Extract affected files from action plan
     fn extract_affected_files(&self, action_plan: &ActionPlan) -> Vec<String> {
         // Simple extraction - can be enhanced

crates/fluent-agent/src/memory/context_compressor.rs

@@ -646,6 +646,23 @@ impl ContextCompressor {
 
         Ok(())
     }
+
+    /// Get count of compressed contexts
+    pub async fn get_compressed_count(&self) -> usize {
+        let history = self.compression_history.read().await;
+        history.operations.len()
+    }
+
+    /// Get current compression ratio
+    pub async fn get_compression_ratio(&self) -> Result<f64> {
+        let history = self.compression_history.read().await;
+        if history.compression_stats.total_bytes_compressed == 0 {
+            return Ok(0.5);
+        }
+        let saved = history.compression_stats.total_bytes_saved as f64;
+        let original = history.compression_stats.total_bytes_compressed as f64;
+        Ok(1.0 - (saved / original).min(1.0).max(0.0))
+    }
 }
 
 // Supporting types

crates/fluent-agent/src/memory/cross_session_persistence.rs

@@ -678,4 +678,18 @@ impl CrossSessionPersistence {
             .map(|s| s.session_id.clone())
             .ok_or_else(|| anyhow::anyhow!("No active session"))
     }
+
+    /// Get count of stored items
+    pub async fn get_item_count(&self) -> usize {
+        let manager = self.session_manager.read().await;
+        let pattern_count = manager.learned_patterns.len();
+        let checkpoint_count = manager.checkpoints.len();
+        pattern_count + checkpoint_count
+    }
+
+    /// Get count of sessions
+    pub async fn get_session_count(&self) -> usize {
+        let manager = self.session_manager.read().await;
+        manager.session_history.len()
+    }
 }

crates/fluent-agent/src/memory/mod.rs

@@ -151,11 +151,35 @@ impl IntegratedMemorySystem {
 
     /// Get memory statistics
     pub async fn get_stats(&self) -> Result<MemoryStats> {
+        let working_mem = self.working_memory.read().await;
+        let persistence = self.persistence.read().await;
+        let compressor = self.compressor.read().await;
+
+        // Count items from working memory
+        let working_items = working_mem.get_item_count().await;
+        
+        // Count items from persistence layer
+        let persisted_items = persistence.get_item_count().await;
+        
+        // Count compressed contexts
+        let compressed_items = compressor.get_compressed_count().await;
+        
+        let total_items = working_items + persisted_items + compressed_items;
+        
+        // Estimate memory usage
+        let estimated_memory = total_items * 1024; // Rough estimate: 1KB per item
+        
+        // Calculate compression ratio from compressor
+        let compression_ratio = compressor.get_compression_ratio().await.unwrap_or(0.5);
+        
+        // Get session count from persistence
+        let session_count = persistence.get_session_count().await;
+
         Ok(MemoryStats {
-            items_count: 0, // TODO: implement actual counting
-            memory_usage_bytes: 0,
-            compression_ratio: 0.5,
-            session_count: 1,
+            items_count: total_items,
+            memory_usage_bytes: estimated_memory,
+            compression_ratio,
+            session_count,
         })
     }
 }

crates/fluent-agent/src/memory/working_memory.rs

@@ -812,6 +812,12 @@ impl WorkingMemory {
         store.archived_items.remove(item_id);
         Ok(())
     }
+
+    /// Get total count of items in working memory
+    pub async fn get_item_count(&self) -> usize {
+        let store = self.memory_store.read().await;
+        store.active_items.len() + store.archived_items.len()
+    }
 }
 
 /// Action to take during consolidation