TOOL-519: Minor tweaks.

Author: the-nick-fischer

application/apps/indexer/mcp/src/client/conversation.rs

@@ -1,5 +1,4 @@
-// Simple conversation state implementation for managing chat messages within the client
-// Currently all
+// Simple model for storing the state of a chat conversation inside the MCP client
 
 use rmcp::{
     model::Content,
@@ -15,7 +14,7 @@ pub enum ChatMessage {
 #[derive(Debug)]
 pub enum ClientToLlm {
     SystemPrompt { content: String },
-    Prompt { content: String },
+    UserPrompt { content: String },
     ToolResult { content: Vec<Content> },
 }
 
@@ -39,6 +38,9 @@ pub struct Conversation {
 }
 
 impl Conversation {
+    /// Create a new conversation with an initial system prompt
+    /// # Arguments
+    /// * `system_prompt`: The system prompt to initialize the conversation with
     pub fn new(system_prompt: String) -> Self {
         Self {
             chat_messages: vec![ChatMessage::ClientToLlm(ClientToLlm::SystemPrompt {

application/apps/indexer/mcp/src/client/llm/mock.rs

@@ -1,5 +1,5 @@
 // A mock LLM client for testing purposes
-// It simulates LLM behaviour without making actual API calls / without a HTTP client
+// It simulates LLM behavior without making actual API calls / without a HTTP client
 // The logic for processing messages is as follows:
 // - User prompts received from the chipmunk core will cause the mock LLM to emit a ToolCall message:
 //    LlmToClient::ToolCall ("apply_search_filter") with the prompt content as filters
@@ -19,10 +19,9 @@ use crate::{
 };
 pub struct MockLlmClient;
 
-// Implement the LlmClient trait for the MockLlmClient
+// Abstraction of LLM clients using the LlmClient trait
 impl LlmClient for MockLlmClient {
     async fn process(&self, conversation: &Conversation) -> Result<LlmToClient, McpError> {
-        // Call the inherent implementation to avoid recursive trait call
         MockLlmClient::process(self, conversation).await
     }
 }
@@ -40,7 +39,7 @@ impl MockLlmClient {
                 ClientToLlm::SystemPrompt { .. } => Err(McpError::Generic {
                     message: "Mock LLM client received a system prompt; nothing to do".into(),
                 }),
-                ClientToLlm::Prompt { content } => {
+                ClientToLlm::UserPrompt { content } => {
                     // Simulate LLM reasoning duration
                     warn!("⏰ Mock LLM client waits 5s ...");
                     sleep(Duration::from_secs(5)).await;

application/apps/indexer/mcp/src/client/llm/mod.rs

@@ -1,4 +1,7 @@
-use crate::{client::conversation::{Conversation, LlmToClient}, types::McpError};
+use crate::{
+    client::conversation::{Conversation, LlmToClient},
+    types::McpError,
+};
 
 pub mod mock;
 
@@ -24,10 +27,7 @@ pub enum LlmConfig {
 // We suppress the warning for now as all LLM clients are internal to the MCP client module.
 #[allow(async_fn_in_trait)]
 pub trait LlmClient {
-    async fn process(
-        &self,
-        conversation: &Conversation,
-    ) -> Result<LlmToClient, McpError>;
+    async fn process(&self, conversation: &Conversation) -> Result<LlmToClient, McpError>;
 }
 
 // LLM wrapper struct for abstracting over different LLM clients
@@ -41,16 +41,13 @@ impl<C: LlmClient> Llm<C> {
         Self { client }
     }
 
-    pub async fn process(
-        &self,
-        conversation: &Conversation,
-    ) -> Result<LlmToClient, McpError> {
+    pub async fn process(&self, conversation: &Conversation) -> Result<LlmToClient, McpError> {
         self.client.process(conversation).await
     }
 }
 
 // Implementation of LLM creation from configuration for the mock client
-// TODO:[MCP] Maybe move this into the trait instead so that each LLM client can implement its own from_config function
+// TODO:[MCP] Can this be moved to the client modules? Via trait?
 impl Llm<mock::MockLlmClient> {
     pub fn from_config(config: LlmConfig) -> Self {
         match config {

application/apps/indexer/mcp/src/client/messages.rs

@@ -2,13 +2,16 @@
 #[derive(Debug)]
 pub enum McpClientToChipmunk {
     Response { response: String },
+    // TODO:[MCP] add other message types as needed. E.g.:
     // If the LLM wants to use a tool it should be approved by the user
-    // ToolApprovalRequets { tool_name, arguments }
+    // ToolApprovalRequest { tool_name, arguments }
 }
 
 /// Messages from chipmunk to the MCP client
 #[derive(Debug, Clone)]
 pub enum McpChipmunkToClient {
-    Prompt { prompt: String },
+    UserPrompt { prompt: String },
+    // TODO:[MCP] add other message types as needed. E.g.:
+    // SystemPrompt { prompt: String },
     // ToolApprovalResponse { bool }
 }

application/apps/indexer/mcp/src/client/mod.rs

@@ -131,10 +131,11 @@ impl MCPClient {
             select! {
                 Some(chipmunk_request) = chipmunk_request_rx.recv() => {
                     match chipmunk_request {
-                        McpChipmunkToClient::Prompt { prompt } => {
+                        McpChipmunkToClient::UserPrompt { prompt } => {
                             warn!("🟢 MCP Client received mock prompt: {}", prompt);
-                            conversation.add_chat_message(ChatMessage::ClientToLlm(ClientToLlm::Prompt { content: prompt.clone() }));
+                            conversation.add_chat_message(ChatMessage::ClientToLlm(ClientToLlm::UserPrompt { content: prompt.clone() }));
 
+                            // Interatively process converasation/messages with the LLM until we get a final response
                             loop {
                                 match llm.process(&conversation).await? {
                                     LlmToClient::ToolCall { tool_name, arguments } => {

application/apps/indexer/mcp/src/server/messages.rs

@@ -7,7 +7,7 @@ use crate::types::SearchFilter;
 /// Messages from the MCP server to chipmunk
 #[derive(Debug)]
 pub enum McpServerToChipmunk {
-    ApplyFilter {
+    ApplySearchFilter {
         filters: Vec<SearchFilter>,
         response_tx: oneshot::Sender<Result<(), McpError>>,
     },

application/apps/indexer/mcp/src/server/mod.rs

@@ -4,24 +4,21 @@ use rmcp::{
     ErrorData as RmcpError,
     handler::server::{ServerHandler, tool::ToolRouter, wrapper::Parameters},
     model::{CallToolResult, Content, ErrorCode, ServerCapabilities, ServerInfo},
-
     tool, tool_handler, tool_router,
     transport::streamable_http_server::{
         session::local::LocalSessionManager,
         tower::{StreamableHttpServerConfig, StreamableHttpService},
     },
 };
-use tokio::{
-    sync::{mpsc, oneshot},
-};
+use tokio::sync::{mpsc, oneshot};
 
 pub mod messages;
 
 pub const BIND_ADDRESS: &str = "127.0.0.1:8181";
 
 use messages::McpServerToChipmunk;
 
-use crate::types::{SearchFilters};
+use crate::types::SearchFilters;
 
 #[derive(Clone, Debug)]
 pub struct McpServer {
@@ -133,12 +130,9 @@ When the user provides natural language instructions, interpret them as follows:
             "🟢 MCP server received apply_search_filter tool call with params: {:?}",
             params
         );
-        warn!("⏰ MCP server wait 5s");
-        // Simulate LLM reasoning
-        // sleep(std::time::Duration::from_secs(5)).await;
         let (response_tx, response_rx) = oneshot::channel();
-        let task = McpServerToChipmunk::ApplyFilter {
-            filters: params.filters,
+        let task = McpServerToChipmunk::ApplySearchFilter {
+            filters: params.filters.clone(),
             response_tx,
         };
         let task_tx_clone = self.server_to_chipmunk_tx.clone();
@@ -156,9 +150,10 @@ When the user provides natural language instructions, interpret them as follows:
         // based on the response send back the JSON response to client
         match response_rx.await {
             Ok(task_response) => match task_response {
-                Ok(()) => Ok(CallToolResult::success(vec![Content::json(
-                    "🟢 MCP Server received ApplyFilter task response: success",
-                )?])),
+                Ok(()) => Ok(CallToolResult::success(vec![Content::json(format!(
+                    "Chipmunk finished task ApplySearchFilter sucessfully. Applied filter: {}",
+                    params
+                ))?])),
                 Err(err) => {
                     let err_msg = format!("Error while applying the search filter: {err}");
                     Ok(CallToolResult::error(vec![Content::json(err_msg)?]))

application/apps/indexer/mcp/src/types.rs

@@ -1,3 +1,5 @@
+use std::{ffi::os_str::Display, fmt};
+
 use rmcp::ServiceError;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -41,3 +43,19 @@ pub struct SearchFilter {
 pub struct SearchFilters {
     pub filters: Vec<SearchFilter>,
 }
+
+impl fmt::Display for SearchFilters {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let filters: Vec<String> = self
+            .filters
+            .iter()
+            .map(|filter| {
+                format!(
+                    "{{ value: {}, is_regex: {}, ignore_case: {}, is_word: {} }}",
+                    filter.value, filter.is_regex, filter.ignore_case, filter.is_word
+                )
+            })
+            .collect();
+        write!(f, "[{}]", filters.join(", "))
+    }
+}

application/apps/indexer/session/src/mcp_api/mod.rs

@@ -1,3 +1,9 @@
+// MCP API for handling communication between the Chipmunk application and the MCP client/server.
+// Contains functinality to:
+// - create and manage MCP API instances
+// - run the MCP event loop to process incoming messages
+// - methods to send messages to the MCP client and server
+
 use crate::operations::{Operation, OperationKind};
 use crate::state::SessionStateAPI;
 use crate::tracker::OperationTrackerAPI;
@@ -37,7 +43,7 @@ impl McpApi {
     /// TODO:[MCP] Send a prompt to the Chipmunk MCP client. The prompt would typically come from the UI.
     /// The arguments probably need to be tweaked to also include the session
     pub async fn send_prompt(&self, prompt: String) -> Result<(), stypes::NativeError> {
-        let message = McpChipmunkToClient::Prompt { prompt };
+        let message = McpChipmunkToClient::UserPrompt { prompt };
 
         self.chipmunk_to_client_tx
             .send(message.clone())
@@ -61,7 +67,7 @@ pub async fn run(
         select! {
             Some(server_request) = server_to_chipmunk_rx.recv() => {
                 match server_request {
-                    McpServerToChipmunk::ApplyFilter {filters, response_tx} => {
+                    McpServerToChipmunk::ApplySearchFilter {filters, response_tx} => {
 
                         error!(
                             "[Chipmunk] received filters: {:?}", filters