first round changes for agent generate for workshopping (#2690)

* adding in agent contribution metric

* chore: fix lints

* agent generate where user is prompted to include or exclude entire MCP servers

* rebasing changes to newest api for conversation.rs

* making changes according to Brandon's feedback

* clippy

* suppress warning messages

* making changes after code review

* felix feedback changes

---------

Co-authored-by: Xian Wu <[email protected]>
Co-authored-by: Brandon Kiser <[email protected]>

Author: 3 people

crates/chat-cli/src/cli/agent/mod.rs

@@ -208,17 +208,21 @@ impl Agent {
     /// This function mutates the agent to a state that is usable for runtime.
     /// Practically this means to convert some of the fields value to their usable counterpart.
     /// For example, converting the mcp array to actual mcp config and populate the agent file path.
-    fn thaw(&mut self, path: &Path, legacy_mcp_config: Option<&McpServerConfig>) -> Result<(), AgentConfigError> {
+    fn thaw(
+        &mut self,
+        path: &Path,
+        legacy_mcp_config: Option<&McpServerConfig>,
+        output: &mut impl Write,
+    ) -> Result<(), AgentConfigError> {
         let Self { mcp_servers, .. } = self;
 
         self.path = Some(path.to_path_buf());
 
-        let mut stderr = std::io::stderr();
         if let (true, Some(legacy_mcp_config)) = (self.use_legacy_mcp_json, legacy_mcp_config) {
             for (name, legacy_server) in &legacy_mcp_config.mcp_servers {
                 if mcp_servers.mcp_servers.contains_key(name) {
                     let _ = queue!(
-                        stderr,
+                        output,
                         style::SetForegroundColor(Color::Yellow),
                         style::Print("WARNING: "),
                         style::ResetColor,
@@ -238,7 +242,7 @@ impl Agent {
             }
         }
 
-        stderr.flush()?;
+        output.flush()?;
 
         Ok(())
     }
@@ -299,8 +303,8 @@ impl Agent {
                 } else {
                     None
                 };
-
-                agent.thaw(&config_path, legacy_mcp_config.as_ref())?;
+                let mut stderr = std::io::stderr();
+                agent.thaw(&config_path, legacy_mcp_config.as_ref(), &mut stderr)?;
                 Ok((agent, config_path))
             },
             _ => bail!("Agent {agent_name} does not exist"),
@@ -312,6 +316,7 @@ impl Agent {
         agent_path: impl AsRef<Path>,
         legacy_mcp_config: &mut Option<McpServerConfig>,
         mcp_enabled: bool,
+        output: &mut impl Write,
     ) -> Result<Agent, AgentConfigError> {
         let content = os.fs.read(&agent_path).await?;
         let mut agent = serde_json::from_slice::<Agent>(&content).map_err(|e| AgentConfigError::InvalidJson {
@@ -326,11 +331,11 @@ impl Agent {
                     legacy_mcp_config.replace(config);
                 }
             }
-            agent.thaw(agent_path.as_ref(), legacy_mcp_config.as_ref())?;
+            agent.thaw(agent_path.as_ref(), legacy_mcp_config.as_ref(), output)?;
         } else {
             agent.clear_mcp_configs();
             // Thaw the agent with empty MCP config to finalize normalization.
-            agent.thaw(agent_path.as_ref(), None)?;
+            agent.thaw(agent_path.as_ref(), None, output)?;
         }
         Ok(agent)
     }
@@ -495,7 +500,7 @@ impl Agents {
             };
 
             let mut agents = Vec::<Agent>::new();
-            let results = load_agents_from_entries(files, os, &mut global_mcp_config, mcp_enabled).await;
+            let results = load_agents_from_entries(files, os, &mut global_mcp_config, mcp_enabled, output).await;
             for result in results {
                 match result {
                     Ok(agent) => agents.push(agent),
@@ -533,7 +538,7 @@ impl Agents {
             };
 
             let mut agents = Vec::<Agent>::new();
-            let results = load_agents_from_entries(files, os, &mut global_mcp_config, mcp_enabled).await;
+            let results = load_agents_from_entries(files, os, &mut global_mcp_config, mcp_enabled, output).await;
             for result in results {
                 match result {
                     Ok(agent) => agents.push(agent),
@@ -834,6 +839,7 @@ async fn load_agents_from_entries(
     os: &Os,
     global_mcp_config: &mut Option<McpServerConfig>,
     mcp_enabled: bool,
+    output: &mut impl Write,
 ) -> Vec<Result<Agent, AgentConfigError>> {
     let mut res = Vec::<Result<Agent, AgentConfigError>>::new();
 
@@ -844,7 +850,7 @@ async fn load_agents_from_entries(
             .and_then(OsStr::to_str)
             .is_some_and(|s| s == "json")
         {
-            res.push(Agent::load(os, file_path, global_mcp_config, mcp_enabled).await);
+            res.push(Agent::load(os, file_path, global_mcp_config, mcp_enabled, output).await);
         }
     }
 

crates/chat-cli/src/cli/agent/root_command_args.rs

@@ -140,7 +140,7 @@ impl AgentArgs {
             },
             Some(AgentSubcommands::Validate { path }) => {
                 let mut global_mcp_config = None::<McpServerConfig>;
-                let agent = Agent::load(os, path.as_str(), &mut global_mcp_config, mcp_enabled).await;
+                let agent = Agent::load(os, path.as_str(), &mut global_mcp_config, mcp_enabled, &mut stderr).await;
 
                 'validate: {
                     match agent {

crates/chat-cli/src/cli/chat/cli/editor.rs

@@ -83,7 +83,7 @@ impl EditorArgs {
 }
 
 /// Opens the user's preferred editor to compose a prompt
-fn open_editor(initial_text: Option<String>) -> Result<String, ChatError> {
+pub fn open_editor(initial_text: Option<String>) -> Result<String, ChatError> {
     // Create a temporary file with a unique name
     let temp_dir = std::env::temp_dir();
     let file_name = format!("q_prompt_{}.md", Uuid::new_v4());

crates/chat-cli/src/cli/chat/cli/profile.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::collections::HashMap;
 use std::io::Write;
 
 use clap::Subcommand;
@@ -11,7 +12,11 @@ use crossterm::{
     execute,
     queue,
 };
-use dialoguer::Select;
+use dialoguer::{
+    MultiSelect,
+    Select,
+};
+use eyre::Result;
 use syntect::easy::HighlightLines;
 use syntect::highlighting::{
     Style,
@@ -26,8 +31,10 @@ use syntect::util::{
 use crate::cli::agent::{
     Agent,
     Agents,
+    McpServerConfig,
     create_agent,
 };
+use crate::cli::chat::conversation::McpServerInfo;
 use crate::cli::chat::{
     ChatError,
     ChatSession,
@@ -36,6 +43,10 @@ use crate::cli::chat::{
 use crate::database::settings::Setting;
 use crate::os::Os;
 use crate::util::directories::chat_global_agent_path;
+use crate::util::{
+    NullWriter,
+    directories,
+};
 
 #[deny(missing_docs)]
 #[derive(Debug, PartialEq, Subcommand)]
@@ -65,6 +76,8 @@ pub enum AgentSubcommand {
         #[arg(long, short)]
         from: Option<String>,
     },
+    /// Generate an agent configuration using AI
+    Generate {},
     /// Delete the specified agent
     #[command(hide = true)]
     Delete { name: String },
@@ -83,6 +96,22 @@ pub enum AgentSubcommand {
     Swap { name: Option<String> },
 }
 
+fn prompt_mcp_server_selection(servers: &[McpServerInfo]) -> eyre::Result<Vec<&McpServerInfo>> {
+    let items: Vec<String> = servers
+        .iter()
+        .map(|server| format!("{} ({})", server.name, server.config.command))
+        .collect();
+
+    let selections = MultiSelect::new()
+        .with_prompt("Select MCP servers (use Space to toggle, Enter to confirm)")
+        .items(&items)
+        .interact()?;
+
+    let selected_servers: Vec<&McpServerInfo> = selections.iter().filter_map(|&i| servers.get(i)).collect();
+
+    Ok(selected_servers)
+}
+
 impl AgentSubcommand {
     pub async fn execute(self, os: &mut Os, session: &mut ChatSession) -> Result<ChatState, ChatError> {
         let agents = &session.conversation.agents;
@@ -146,8 +175,14 @@ impl AgentSubcommand {
                     return Err(ChatError::Custom("Editor process did not exit with success".into()));
                 }
 
-                let new_agent =
-                    Agent::load(os, &path_with_file_name, &mut None, session.conversation.mcp_enabled).await;
+                let new_agent = Agent::load(
+                    os,
+                    &path_with_file_name,
+                    &mut None,
+                    session.conversation.mcp_enabled,
+                    &mut session.stderr,
+                )
+                .await;
                 match new_agent {
                     Ok(agent) => {
                         session.conversation.agents.agents.insert(agent.name.clone(), agent);
@@ -184,6 +219,75 @@ impl AgentSubcommand {
                     style::SetForegroundColor(Color::Reset)
                 )?;
             },
+
+            Self::Generate {} => {
+                let agent_name = match session.read_user_input("Enter agent name: ", false) {
+                    Some(input) => input.trim().to_string(),
+                    None => {
+                        return Ok(ChatState::PromptUser {
+                            skip_printing_tools: true,
+                        });
+                    },
+                };
+
+                let agent_description = match session.read_user_input("Enter agent description: ", false) {
+                    Some(input) => input.trim().to_string(),
+                    None => {
+                        return Ok(ChatState::PromptUser {
+                            skip_printing_tools: true,
+                        });
+                    },
+                };
+
+                let scope_options = vec!["Local (current workspace)", "Global (all workspaces)"];
+                let scope_selection = Select::new()
+                    .with_prompt("Agent scope")
+                    .items(&scope_options)
+                    .default(0)
+                    .interact()
+                    .map_err(|e| ChatError::Custom(format!("Failed to get scope selection: {}", e).into()))?;
+
+                let is_global = scope_selection == 1;
+
+                let mcp_servers = get_enabled_mcp_servers(os)
+                    .await
+                    .map_err(|e| ChatError::Custom(e.to_string().into()))?;
+
+                let selected_servers = if mcp_servers.is_empty() {
+                    Vec::new()
+                } else {
+                    prompt_mcp_server_selection(&mcp_servers).map_err(|e| ChatError::Custom(e.to_string().into()))?
+                };
+
+                let mcp_servers_json = if !selected_servers.is_empty() {
+                    let servers: std::collections::HashMap<String, serde_json::Value> = selected_servers
+                        .iter()
+                        .map(|server| {
+                            (
+                                server.name.clone(),
+                                serde_json::to_value(&server.config).unwrap_or_default(),
+                            )
+                        })
+                        .collect();
+                    serde_json::to_string(&servers).unwrap_or_default()
+                } else {
+                    "{}".to_string()
+                };
+                use schemars::schema_for;
+                let schema = schema_for!(Agent);
+                let schema_string = serde_json::to_string_pretty(&schema)
+                    .map_err(|e| ChatError::Custom(format!("Failed to serialize agent schema: {e}").into()))?;
+                return session
+                    .generate_agent_config(
+                        os,
+                        &agent_name,
+                        &agent_description,
+                        &mcp_servers_json,
+                        &schema_string,
+                        is_global,
+                    )
+                    .await;
+            },
             Self::Set { .. } | Self::Delete { .. } => {
                 // As part of the agent implementation, we are disabling the ability to
                 // switch / create profile after a session has started.
@@ -285,6 +389,7 @@ impl AgentSubcommand {
         match self {
             Self::List => "list",
             Self::Create { .. } => "create",
+            Self::Generate { .. } => "generate",
             Self::Delete { .. } => "delete",
             Self::Set { .. } => "set",
             Self::Schema => "schema",
@@ -311,3 +416,63 @@ fn highlight_json(output: &mut impl Write, json_str: &str) -> eyre::Result<()> {
 
     Ok(execute!(output, style::ResetColor)?)
 }
+
+/// Searches all configuration sources for MCP servers and returns a deduplicated list.
+/// Priority order: Agent configs > Workspace legacy > Global legacy
+pub async fn get_all_available_mcp_servers(os: &mut Os) -> Result<Vec<McpServerInfo>> {
+    let mut servers = HashMap::<String, McpServerInfo>::new();
+
+    // 1. Load from agent configurations (highest priority)
+    let mut null_writer = NullWriter;
+    let (agents, _) = Agents::load(os, None, true, &mut null_writer, true).await;
+
+    for (_, agent) in agents.agents {
+        for (server_name, server_config) in agent.mcp_servers.mcp_servers {
+            if !servers.values().any(|s| s.config.command == server_config.command) {
+                servers.insert(server_name.clone(), McpServerInfo {
+                    name: server_name,
+                    config: server_config,
+                });
+            }
+        }
+    }
+
+    // 2. Load from workspace legacy config (medium priority)
+    if let Ok(workspace_path) = directories::chat_legacy_workspace_mcp_config(os) {
+        if let Ok(workspace_config) = McpServerConfig::load_from_file(os, workspace_path).await {
+            for (server_name, server_config) in workspace_config.mcp_servers {
+                if !servers.values().any(|s| s.config.command == server_config.command) {
+                    servers.insert(server_name.clone(), McpServerInfo {
+                        name: server_name,
+                        config: server_config,
+                    });
+                }
+            }
+        }
+    }
+
+    // 3. Load from global legacy config (lowest priority)
+    if let Ok(global_path) = directories::chat_legacy_global_mcp_config(os) {
+        if let Ok(global_config) = McpServerConfig::load_from_file(os, global_path).await {
+            for (server_name, server_config) in global_config.mcp_servers {
+                if !servers.values().any(|s| s.config.command == server_config.command) {
+                    servers.insert(server_name.clone(), McpServerInfo {
+                        name: server_name,
+                        config: server_config,
+                    });
+                }
+            }
+        }
+    }
+
+    Ok(servers.into_values().collect())
+}
+
+/// Get only enabled MCP servers (excludes disabled ones)
+pub async fn get_enabled_mcp_servers(os: &mut Os) -> Result<Vec<McpServerInfo>> {
+    let all_servers = get_all_available_mcp_servers(os).await?;
+    Ok(all_servers
+        .into_iter()
+        .filter(|server| !server.config.disabled)
+        .collect())
+}