Merge branch 'main' into persistant-conv-invariant

Author: dingfeli

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

@@ -1,4 +1,11 @@
-use clap::Parser;
+use std::collections::HashMap;
+
+use clap::{
+    Args,
+    Parser,
+    Subcommand,
+    ValueEnum,
+};
 
 #[derive(Debug, Clone, PartialEq, Eq, Default, Parser)]
 pub struct Chat {
@@ -10,6 +17,9 @@ pub struct Chat {
     /// prompt requests permissions to use a tool, unless --trust-all-tools is also used.
     #[arg(long)]
     pub no_interactive: bool,
+    /// Start a new conversation and overwrites any previous conversation from this directory.
+    #[arg(long)]
+    pub new: bool,
     /// The first question to ask
     pub input: Option<String>,
     /// Context profile to use
@@ -23,3 +33,127 @@ pub struct Chat {
     #[arg(long, value_delimiter = ',', value_name = "TOOL_NAMES")]
     pub trust_tools: Option<Vec<String>>,
 }
+
+#[derive(Debug, Clone, PartialEq, Eq, Subcommand)]
+pub enum Mcp {
+    /// Add or replace a configured server
+    Add(McpAdd),
+    /// Remove a server from the MCP configuration
+    #[command(alias = "rm")]
+    Remove(McpRemove),
+    /// List configured servers
+    List(McpList),
+    /// Import a server configuration from another file
+    Import(McpImport),
+    /// Get the status of a configured server
+    Status {
+        #[arg(long)]
+        name: String,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Args)]
+pub struct McpAdd {
+    /// Name for the server
+    #[arg(long)]
+    pub name: String,
+    /// The command used to launch the server
+    #[arg(long)]
+    pub command: String,
+    /// Where to add the server to. For profile scope, the name of the profile must specified with
+    /// --profile.
+    #[arg(long, value_enum)]
+    pub scope: Option<Scope>,
+    /// Name of the profile to add the server config to. Not compatible with workspace scope or
+    /// global scope.
+    #[arg(long)]
+    pub profile: Option<String>,
+    /// Environment variables to use when launching the server
+    #[arg(long, value_parser = parse_env_vars)]
+    pub env: Vec<HashMap<String, String>>,
+    /// Server launch timeout, in milliseconds
+    #[arg(long)]
+    pub timeout: Option<u64>,
+    /// Overwrite an existing server with the same name
+    #[arg(long, default_value_t = false)]
+    pub force: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Args)]
+pub struct McpRemove {
+    #[arg(long)]
+    pub name: String,
+    #[arg(long, value_enum)]
+    pub scope: Option<Scope>,
+    #[arg(long)]
+    pub profile: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Args)]
+pub struct McpList {
+    #[arg(value_enum)]
+    pub scope: Option<Scope>,
+    #[arg(long)]
+    pub profile: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Args)]
+pub struct McpImport {
+    #[arg(long)]
+    pub file: String,
+    #[arg(value_enum)]
+    pub scope: Option<Scope>,
+    #[arg(long)]
+    pub profile: Option<String>,
+    /// Overwrite an existing server with the same name
+    #[arg(long, default_value_t = false)]
+    pub force: bool,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, ValueEnum)]
+pub enum Scope {
+    Workspace,
+    Profile,
+    Global,
+}
+
+impl std::fmt::Display for Scope {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Scope::Workspace => write!(f, "workspace"),
+            Scope::Profile => write!(f, "profile"),
+            Scope::Global => write!(f, "global"),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct EnvVarParseError(String);
+
+impl std::fmt::Display for EnvVarParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Failed to parse environment variables: {}", self.0)
+    }
+}
+
+impl std::error::Error for EnvVarParseError {}
+
+fn parse_env_vars(arg: &str) -> Result<HashMap<String, String>, EnvVarParseError> {
+    let mut vars = HashMap::new();
+
+    for pair in arg.split(",") {
+        match pair.split_once('=') {
+            Some((key, value)) => {
+                vars.insert(key.trim().to_string(), value.trim().to_string());
+            },
+            None => {
+                return Err(EnvVarParseError(format!(
+                    "Invalid environment variable '{}'. Expected 'name=value'",
+                    pair
+                )));
+            },
+        }
+    }
+
+    Ok(vars)
+}

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

@@ -59,6 +59,7 @@ pub struct ContextManager {
     /// Context configuration for the current profile.
     pub profile_config: ContextConfig,
 
+    #[serde(skip)]
     pub hook_executor: HookExecutor,
 }
 
@@ -128,6 +129,13 @@ impl ContextManager {
         Ok(())
     }
 
+    /// Reloads the global and profile config from disk.
+    pub async fn reload_config(&mut self) -> Result<()> {
+        self.global_config = load_global_config(&self.ctx).await?;
+        self.profile_config = load_profile_config(&self.ctx, &self.current_profile).await?;
+        Ok(())
+    }
+
     /// Add paths to the context configuration.
     ///
     /// # Arguments

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

@@ -157,6 +157,37 @@ impl ConversationState {
         }
     }
 
+    /// Reloads necessary fields after being deserialized. This should be called after
+    /// deserialization.
+    pub async fn reload_serialized_state(&mut self, ctx: Arc<Context>, updates: Option<SharedWriter>) {
+        self.updates = updates;
+
+        // Try to reload ContextManager, but do not return an error if we fail.
+        // TODO: Currently the failure modes around ContextManager is unclear, and we don't return
+        // errors in most cases. Thus, we try to preserve the same behavior here and simply have
+        // self.context_manager equal to None if any errors are encountered. This needs to be
+        // refactored.
+        let mut failed = false;
+        if let Some(context_manager) = self.context_manager.as_mut() {
+            match context_manager.reload_config().await {
+                Ok(_) => (),
+                Err(err) => {
+                    error!(?err, "failed to reload context config");
+                    match ContextManager::new(ctx, None).await {
+                        Ok(v) => *context_manager = v,
+                        Err(err) => {
+                            failed = true;
+                            error!(?err, "failed to construct context manager");
+                        },
+                    }
+                },
+            }
+        }
+        if failed {
+            self.context_manager.take();
+        }
+    }
+
     pub fn latest_summary(&self) -> Option<&str> {
         self.latest_summary.as_deref()
     }

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

@@ -119,15 +119,14 @@ pub enum HookTrigger {
     PerPrompt,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone)]
 pub struct CachedHook {
     output: String,
-    #[serde(skip)]
     expiry: Option<Instant>,
 }
 
 /// Maps a hook name to a [`CachedHook`]
-#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default)]
 pub struct HookExecutor {
     pub global_cache: HashMap<String, CachedHook>,
     pub profile_cache: HashMap<String, CachedHook>,