changes

Author: callicles

apps/framework-cli/src/mcp/server.rs

@@ -108,7 +108,7 @@ impl ServerHandler for MooseMcpHandler {
                 self.redis_client.clone(),
             )
             .await),
-            "diagnose_infrastructure" => Ok(infra_issues::handle_call(
+            "get_issues" => Ok(infra_issues::handle_call(
                 param.arguments.as_ref(),
                 self.redis_client.clone(),
                 &self.clickhouse_config,
@@ -271,7 +271,7 @@ mod tests {
             "get_infra_map",
             "query_olap",
             "get_stream_sample",
-            "diagnose_infrastructure",
+            "get_issues",
         ];
 
         let logs_tool = logs::tool_definition();

apps/framework-cli/src/mcp/tools/infra_issues/mod.rs

@@ -137,15 +137,15 @@ pub fn tool_definition() -> Tool {
     });
 
     Tool {
-        name: "diagnose_infrastructure".into(),
+        name: "get_issues".into(),
         description: Some(
-            "Proactively diagnose infrastructure issues by intelligently checking relevant diagnostic sources based on infrastructure type. For ClickHouse, automatically checks: stuck mutations, S3Queue ingestion errors (for S3Queue tables), replication health (for replicated tables), data parts issues, background merge problems, system errors, and stopped operations. Returns structured, actionable information about errors and warnings with suggested remediation steps.".into()
+            "Proactively scan for infrastructure health issues (stuck mutations, replication errors, S3Queue failures, merge problems). Auto-checks relevant diagnostics based on infrastructure type. Use when investigating errors or performance issues. Returns actionable problems with remediation suggestions.".into()
         ),
         input_schema: Arc::new(schema.as_object().unwrap().clone()),
         annotations: None,
         icons: None,
         output_schema: None,
-        title: Some("Diagnose Infrastructure Issues".into()),
+        title: Some("Get Infrastructure Issues".into()),
     }
 }
 

apps/framework-cli/src/mcp/tools/infra_map.rs

@@ -25,39 +25,61 @@ pub enum InfraMapError {
     ToonSerialization(#[from] super::toon_serializer::ToonSerializationError),
 }
 
+/// Fuzzy match using case-insensitive substring matching
+fn fuzzy_match(query: &str, text: &str) -> bool {
+    let query_lower = query.to_lowercase();
+    let text_lower = text.to_lowercase();
+    text_lower.contains(&query_lower)
+}
+
 /// Returns the tool definition for the MCP server
 pub fn tool_definition() -> Tool {
     let schema = json!({
         "type": "object",
-        "properties": {}
+        "properties": {
+            "search": {
+                "type": "string",
+                "description": "Focus on specific components (fuzzy, case-insensitive). Examples: 'user' → UserEvents, user_table, INGRESS_User; 'bar' → Bar topic, BarAggregated table. Omit for complete map."
+            }
+        }
     });
 
     Tool {
         name: "get_infra_map".into(),
         description: Some(
-            "Retrieve the complete Moose infrastructure map showing all components and their connections. Returns tables, topics, API endpoints, sync processes, functions, SQL resources, workflows, and their relationships in a compact TOON table format.".into()
+            "🔍 START HERE: Get complete project topology showing all components (tables, topics, APIs, functions, workflows) with source file locations and data flow connections. Essential first step to understand project structure, locate files, and verify code changes are reflected. Use 'search' to focus on specific components (e.g., search='User' shows UserEvents topic, user tables, and all related connections).".into()
         ),
         input_schema: Arc::new(schema.as_object().unwrap().clone()),
         annotations: None,
         icons: None,
         output_schema: None,
-        title: Some("Get Moose Infrastructure Map".into()),
+        title: Some("Get Infrastructure Map".into()),
     }
 }
 
 /// Handle the tool call with the given arguments
 pub async fn handle_call(
-    _arguments: Option<&Map<String, Value>>,
+    arguments: Option<&Map<String, Value>>,
     redis_client: Arc<RedisClient>,
 ) -> CallToolResult {
-    match execute_get_infra_map(redis_client).await {
+    // Parse optional search parameter
+    let search = arguments
+        .and_then(|args| args.get("search"))
+        .and_then(|v| v.as_str())
+        .filter(|s| !s.is_empty())
+        .map(|s| s.to_string());
+
+    match execute_get_infra_map(redis_client, search).await {
         Ok(content) => create_success_result(content),
         Err(e) => create_error_result(format!("Error retrieving infrastructure map: {}", e)),
     }
 }
 
 /// Main function to retrieve infrastructure map
-async fn execute_get_infra_map(redis_client: Arc<RedisClient>) -> Result<String, InfraMapError> {
+async fn execute_get_infra_map(
+    redis_client: Arc<RedisClient>,
+    search: Option<String>,
+) -> Result<String, InfraMapError> {
     // Load infrastructure map from Redis
     let infra_map_opt = InfrastructureMap::load_from_redis(&redis_client).await?;
 
@@ -72,11 +94,14 @@ async fn execute_get_infra_map(redis_client: Arc<RedisClient>) -> Result<String,
     };
 
     // Format and return the infrastructure map
-    format_infrastructure_map(&infra_map)
+    format_infrastructure_map(&infra_map, &search)
 }
 
 /// Format infrastructure map with component lineage information
-fn format_infrastructure_map(infra_map: &InfrastructureMap) -> Result<String, InfraMapError> {
+fn format_infrastructure_map(
+    infra_map: &InfrastructureMap,
+    search: &Option<String>,
+) -> Result<String, InfraMapError> {
     let mut output = String::from("# Moose Infrastructure Map\n\n");
     output.push_str("This view shows infrastructure components and their connections.\n");
     output.push_str(
@@ -86,11 +111,95 @@ fn format_infrastructure_map(infra_map: &InfrastructureMap) -> Result<String, In
     // Build compressed map
     let compressed_map = build_compressed_map(infra_map);
 
+    // Apply search filter if provided
+    let filtered_map = if let Some(query) = search {
+        let mut filtered = compressed_map.clone();
+
+        // Filter components: keep if query matches id OR name
+        filtered.components.retain(|component| {
+            fuzzy_match(query, &component.id) || fuzzy_match(query, &component.name)
+        });
+
+        // Build set of matching component IDs for connection filtering
+        let component_ids: std::collections::HashSet<_> =
+            filtered.components.iter().map(|c| c.id.as_str()).collect();
+
+        // Filter connections: keep if source OR destination is in filtered components
+        filtered.connections.retain(|conn| {
+            component_ids.contains(conn.from.as_str()) || component_ids.contains(conn.to.as_str())
+        });
+
+        // Recalculate stats
+        filtered.stats.total_components = filtered.components.len() as u32;
+        filtered.stats.total_connections = filtered.connections.len() as u32;
+        filtered.stats.by_type.clear();
+        for component in &filtered.components {
+            *filtered
+                .stats
+                .by_type
+                .entry(component.component_type)
+                .or_insert(0) += 1;
+        }
+
+        filtered
+    } else {
+        compressed_map
+    };
+
     // Serialize to TOON
-    let compressed_json = serde_json::to_value(&compressed_map)?;
+    let compressed_json = serde_json::to_value(&filtered_map)?;
     output.push_str("```toon\n");
     output.push_str(&serialize_to_toon_compressed(&compressed_json)?);
     output.push_str("\n```\n");
 
+    // Add search info if filtered
+    if search.is_some() {
+        output.push_str(&format!(
+            "\n**Search:** '{}' | **Matched:** {} component(s), {} connection(s)\n",
+            search.as_ref().unwrap(),
+            filtered_map.stats.total_components,
+            filtered_map.stats.total_connections
+        ));
+    }
+
     Ok(output)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fuzzy_match() {
+        // Basic substring matching
+        assert!(fuzzy_match("user", "user_table"));
+        assert!(fuzzy_match("user", "UserEvents"));
+        assert!(fuzzy_match("table", "user_table"));
+
+        // Case insensitive
+        assert!(fuzzy_match("USER", "user_table"));
+        assert!(fuzzy_match("User", "UserEvents"));
+        assert!(fuzzy_match("user", "INGRESS_User"));
+
+        // Partial matches
+        assert!(fuzzy_match("eve", "UserEvents"));
+        assert!(fuzzy_match("gres", "INGRESS_User"));
+
+        // No match
+        assert!(!fuzzy_match("order", "user_table"));
+        assert!(!fuzzy_match("xyz", "UserEvents"));
+    }
+
+    #[test]
+    fn test_fuzzy_match_empty_query() {
+        // Empty query matches everything (substring logic)
+        assert!(fuzzy_match("", "user_table"));
+        assert!(fuzzy_match("", ""));
+    }
+
+    #[test]
+    fn test_fuzzy_match_exact() {
+        assert!(fuzzy_match("user_table", "user_table"));
+        assert!(fuzzy_match("Bar", "Bar"));
+    }
+}

apps/framework-cli/src/mcp/tools/logs.rs

@@ -172,13 +172,13 @@ pub fn tool_definition() -> Tool {
     Tool {
         name: "get_logs".into(),
         description: Some(
-            "Retrieve and filter Moose dev server logs. Access recent log entries from the current dev server session, filter by log level (ERROR, WARN, INFO, DEBUG, TRACE), and search with regex patterns (e.g., 'error|warn', '(?i)connection', 'user_\\d+').".into()
+            "Debug issues by checking dev server logs. Filter by level (ERROR/WARN/INFO/DEBUG/TRACE) or search with regex. Use when troubleshooting errors, connection issues, or unexpected behavior.".into()
         ),
         input_schema: Arc::new(schema.as_object().unwrap().clone()),
         annotations: None,
         icons: None,
         output_schema: None,
-        title: Some("Get Moose Dev Server Logs".into()),
+        title: Some("Get Dev Server Logs".into()),
     }
 }
 

apps/framework-cli/src/mcp/tools/query_olap.rs

@@ -291,7 +291,7 @@ pub fn tool_definition() -> Tool {
     Tool {
         name: "query_olap".into(),
         description: Some(
-            "Execute read-only SQL queries against the ClickHouse OLAP database. Queries automatically use the configured database as the default context, so you can query tables without fully-qualifying them. Use this tool to explore data, check table schemas, and analyze stored information. Supports SELECT queries, system table queries (e.g., system.tables, system.columns), and metadata commands (SHOW, DESCRIBE, EXPLAIN).".into()
+            "Query ClickHouse to explore data, verify ingestion, check schemas. Use SELECT to analyze stored data, SHOW/DESCRIBE for table info, system.tables/system.columns for metadata. Read-only, safe for production. Tables auto-scoped to project database.".into()
         ),
         input_schema: Arc::new(schema.as_object().unwrap().clone()),
         annotations: None,

apps/framework-cli/src/mcp/tools/sample_stream.rs

@@ -93,13 +93,13 @@ pub fn tool_definition() -> Tool {
     Tool {
         name: "get_stream_sample".into(),
         description: Some(
-            "Retrieve sample messages from a Redpanda/Kafka streaming topic. Get the last N messages from any topic/stream for debugging and exploration. Returns messages as JSON arrays with message payloads.".into()
+            "Sample recent messages from streaming topics to verify data flow, debug transformations, or inspect payloads. Get last N messages from any topic. Use after get_infra_map to see available topics.".into()
         ),
         input_schema: Arc::new(schema.as_object().unwrap().clone()),
         annotations: None,
         icons: None,
         output_schema: None,
-        title: Some("Get Stream Sample".into()),
+        title: Some("Sample Stream Messages".into()),
     }
 }