Method execute

crates/chat-cli/src/cli/agent/root_command_args.rs:82–320

(self, os: &mut Os)

impl AgentArgs {
    pub async fn execute(self, os: &mut Os) -> Result<ExitCode> {
        let mut stderr = std::io::stderr();
        let mcp_enabled = match os.client.is_mcp_enabled().await {
            Ok(enabled) => enabled,
            Err(err) => {
                tracing::warn!(?err, "Failed to check MCP configuration, defaulting to enabled");
                true
            },
        };
        match self.cmd {
            Some(AgentSubcommands::List) | None => {
                let agents = Agents::load(os, None, true, &mut stderr, mcp_enabled).await.0;
                let agent_with_path =
                    agents
                        .agents
                        .into_iter()
                        .fold(Vec::<(String, String)>::new(), |mut acc, (name, agent)| {
                            acc.push((
                                name,
                                agent
                                    .path
                                    .and_then(|p| p.parent().map(|p| p.to_string_lossy().to_string()))
                                    .unwrap_or("**No path found**".to_string()),
                            ));
                            acc
                        });
                let max_name_length = agent_with_path.iter().map(|(name, _)| name.len()).max().unwrap_or(0);
                let output_str = agent_with_path
                    .into_iter()
                    .map(|(name, path)| format!("{name:<width$}    {path}", width = max_name_length))
                    .collect::<Vec<_>>()
                    .join("\n");

                writeln!(stderr, "{}", output_str)?;
            },
            Some(AgentSubcommands::Create { name, directory, from }) => {
                let mut agents = Agents::load(os, None, true, &mut stderr, mcp_enabled).await.0;
                let path_with_file_name = create_agent(os, &mut agents, name.clone(), directory, from).await?;

                crate::util::editor::launch_editor(&path_with_file_name)?;

                let Ok(content) = os.fs.read(&path_with_file_name).await else {
                    bail!(
                        "Post write validation failed. Error opening {}. Aborting",
                        path_with_file_name.display()
                    );
                };
                if let Err(e) = serde_json::from_slice::<Agent>(&content) {
                    bail!(
                        "Post write validation failed for agent '{name}' at path: {}. Malformed config detected: {e}",
                        path_with_file_name.display()
                    );
                }

                writeln!(
                    stderr,
                    "\n📁 Created agent {} '{}'\n",
                    name,