feat(chat): support shell aliases in command execution

Author: GoodluckH

codebase-summary.md

@@ -57,7 +57,7 @@ The chat implementation includes a robust tool system that allows Amazon Q to in
 1. **Available Tools**:
    - `fs_read`: Reads files or lists directories (similar to `cat` or `ls`)
    - `fs_write`: Creates or modifies files with various operations (create, append, replace)
-   - `execute_bash`: Executes shell commands in the user's environment
+   - `execute_shell_commands`: Executes shell commands in the user's environment
    - `use_aws`: Makes AWS CLI API calls with specified services and operations
 
 2. **Tool Execution Flow**:
@@ -68,7 +68,7 @@ The chat implementation includes a robust tool system that allows Amazon Q to in
    - The conversation continues with the tool results incorporated
 
 3. **Security Considerations**:
-   - Tools that modify the system (like `fs_write` and `execute_bash`) require user confirmation
+   - Tools that modify the system (like `fs_write` and `execute_shell_commands`) require user confirmation
    - The `/acceptall` command can toggle automatic acceptance for the session
    - Tool responses are limited to prevent excessive output (30KB limit)
 

crates/q_cli/src/cli/chat/parser.rs

@@ -332,7 +332,7 @@ mod tests {
     async fn test_parse() {
         let _ = tracing_subscriber::fmt::try_init();
         let tool_use_id = "TEST_ID".to_string();
-        let tool_name = "execute_bash".to_string();
+        let tool_name = "execute_shell_commands".to_string();
         let tool_args = serde_json::json!({
             "command": "echo hello"
         })

…q_cli/src/cli/chat/tools/execute_bash.rs …cli/chat/tools/execute_shell_commands.rscrates/q_cli/src/cli/chat/tools/execute_bash.rs renamed to crates/q_cli/src/cli/chat/tools/execute_shell_commands.rs crates/q_cli/src/cli/chat/tools/execute_bash.rs renamed to crates/q_cli/src/cli/chat/tools/execute_shell_commands.rs

@@ -1,4 +1,5 @@
 use std::collections::VecDeque;
+use std::fs;
 use std::io::Write;
 use std::process::Stdio;
 
@@ -27,11 +28,11 @@ use crate::cli::chat::truncate_safe;
 const READONLY_COMMANDS: &[&str] = &["ls", "cat", "echo", "pwd", "which", "head", "tail", "find", "grep"];
 
 #[derive(Debug, Clone, Deserialize)]
-pub struct ExecuteBash {
+pub struct ExecuteShellCommands {
     pub command: String,
 }
 
-impl ExecuteBash {
+impl ExecuteShellCommands {
     pub fn requires_acceptance(&self) -> bool {
         let Some(args) = shlex::split(&self.command) else {
             return true;
@@ -90,15 +91,63 @@ impl ExecuteBash {
     }
 
     pub async fn invoke(&self, mut updates: impl Write) -> Result<InvokeOutput> {
+        // Detect the user's default shell
+        let shell = std::env::var("$0").unwrap_or_else(|_| "bash".to_string());
+
+        let home = std::env::var("HOME").unwrap_or_else(|_| "~".to_string());
+        let shell_init_file = match shell.as_str() {
+            s if s.contains("zsh") => Some(format!("{}/{}", home, ".zshrc")),
+            s if s.contains("bash") => Some(format!("{}/{}", home, ".bashrc")),
+            _ => None,
+        };
+
+        // // Extract aliases from the shell config file
+        let aliases = if let Some(config_path) = &shell_init_file {
+            match fs::read_to_string(config_path) {
+                Ok(content) => {
+                    // Extract aliases based on shell type
+                    let pattern = match shell.as_str() {
+                        s if s.contains("zsh") | s.contains("bash") => r#"^\s*alias\s+([^=]+)=['"]?([^'"]+)['"]?$"#,
+                        // TODO: support Fish and other shells
+                        _ => r"^\s*alias\s+.+$", // fallback, won't convert to function
+                    };
+
+                    let re = regex::Regex::new(pattern).unwrap_or_else(|_| regex::Regex::new(r"").unwrap());
+                    let mut alias_commands = String::new();
+
+                    for line in content.lines() {
+                        if let Some(caps) = re.captures(line) {
+                            if caps.len() >= 3 {
+                                let name = caps[1].trim();
+                                let raw_cmd = caps[2].trim();
+                                alias_commands.push_str(&format!(
+                                    "{name}() {{ {cmd} \"$@\"; }}\n",
+                                    name = name,
+                                    cmd = raw_cmd
+                                ));
+                            }
+                        }
+                    }
+
+                    alias_commands
+                },
+                Err(_) => String::new(),
+            }
+        } else {
+            String::new()
+        };
+
+        let command_with_aliases = format!("{}\n{}", aliases, self.command);
+
         // We need to maintain a handle on stderr and stdout, but pipe it to the terminal as well
-        let mut child = tokio::process::Command::new("bash")
+        let mut child = tokio::process::Command::new(&shell)
             .arg("-c")
-            .arg(&self.command)
+            .arg(&command_with_aliases)
             .stdin(Stdio::inherit())
             .stdout(Stdio::piped())
             .stderr(Stdio::piped())
             .spawn()
-            .wrap_err_with(|| format!("Unable to spawn command '{}'", &self.command))?;
+            .wrap_err_with(|| format!("Unable to spawn command '{}' in shell '{}'", &self.command, &shell))?;
 
         let stdout = child.stdout.take().unwrap();
         let stdout = tokio::io::BufReader::new(stdout);
@@ -206,14 +255,14 @@ mod tests {
 
     #[ignore = "todo: fix failing on musl for some reason"]
     #[tokio::test]
-    async fn test_execute_bash_tool() {
+    async fn test_execute_shell_commands_tool() {
         let mut stdout = std::io::stdout();
 
         // Verifying stdout
         let v = serde_json::json!({
             "command": "echo Hello, world!",
         });
-        let out = serde_json::from_value::<ExecuteBash>(v)
+        let out = serde_json::from_value::<ExecuteShellCommands>(v)
             .unwrap()
             .invoke(&mut stdout)
             .await
@@ -231,7 +280,7 @@ mod tests {
         let v = serde_json::json!({
             "command": "echo Hello, world! 1>&2",
         });
-        let out = serde_json::from_value::<ExecuteBash>(v)
+        let out = serde_json::from_value::<ExecuteShellCommands>(v)
             .unwrap()
             .invoke(&mut stdout)
             .await
@@ -250,7 +299,7 @@ mod tests {
             "command": "exit 1",
             "interactive": false
         });
-        let out = serde_json::from_value::<ExecuteBash>(v)
+        let out = serde_json::from_value::<ExecuteShellCommands>(v)
             .unwrap()
             .invoke(&mut stdout)
             .await
@@ -304,7 +353,7 @@ mod tests {
             ("find important-dir/ -name '*.txt'", false),
         ];
         for (cmd, expected) in cmds {
-            let tool = serde_json::from_value::<ExecuteBash>(serde_json::json!({
+            let tool = serde_json::from_value::<ExecuteShellCommands>(serde_json::json!({
                 "command": cmd,
             }))
             .unwrap();

crates/q_cli/src/cli/chat/tools/mod.rs

@@ -1,4 +1,4 @@
-pub mod execute_bash;
+pub mod execute_shell_commands;
 pub mod fs_read;
 pub mod fs_write;
 pub mod gh_issue;
@@ -15,7 +15,7 @@ use aws_smithy_types::{
     Document,
     Number as SmithyNumber,
 };
-use execute_bash::ExecuteBash;
+use execute_shell_commands::ExecuteShellCommands;
 use eyre::Result;
 use fig_api_client::model::{
     ToolResult,
@@ -38,7 +38,7 @@ pub const MAX_TOOL_RESPONSE_SIZE: usize = 800000;
 pub enum Tool {
     FsRead(FsRead),
     FsWrite(FsWrite),
-    ExecuteBash(ExecuteBash),
+    ExecuteShellCommands(ExecuteShellCommands),
     UseAws(UseAws),
     GhIssue(GhIssue),
 }
@@ -49,7 +49,7 @@ impl Tool {
         match self {
             Tool::FsRead(_) => "Read from filesystem",
             Tool::FsWrite(_) => "Write to filesystem",
-            Tool::ExecuteBash(_) => "Execute shell command",
+            Tool::ExecuteShellCommands(_) => "Execute shell command",
             Tool::UseAws(_) => "Use AWS CLI",
             Tool::GhIssue(_) => "Prepare GitHub issue",
         }
@@ -60,7 +60,9 @@ impl Tool {
         match self {
             Tool::FsRead(_) => "Reading from filesystem",
             Tool::FsWrite(_) => "Writing to filesystem",
-            Tool::ExecuteBash(execute_bash) => return format!("Executing `{}`", execute_bash.command),
+            Tool::ExecuteShellCommands(execute_shell_commands) => {
+                return format!("Executing `{}`", execute_shell_commands.command);
+            },
             Tool::UseAws(_) => "Using AWS CLI",
             Tool::GhIssue(_) => "Preparing GitHub issue",
         }
@@ -72,7 +74,7 @@ impl Tool {
         match self {
             Tool::FsRead(_) => false,
             Tool::FsWrite(_) => true,
-            Tool::ExecuteBash(execute_bash) => execute_bash.requires_acceptance(),
+            Tool::ExecuteShellCommands(execute_shell_commands) => execute_shell_commands.requires_acceptance(),
             Tool::UseAws(use_aws) => use_aws.requires_acceptance(),
             Tool::GhIssue(_) => false,
         }
@@ -83,7 +85,7 @@ impl Tool {
         match self {
             Tool::FsRead(fs_read) => fs_read.invoke(context, updates).await,
             Tool::FsWrite(fs_write) => fs_write.invoke(context, updates).await,
-            Tool::ExecuteBash(execute_bash) => execute_bash.invoke(updates).await,
+            Tool::ExecuteShellCommands(execute_shell_commands) => execute_shell_commands.invoke(updates).await,
             Tool::UseAws(use_aws) => use_aws.invoke(context, updates).await,
             Tool::GhIssue(gh_issue) => gh_issue.invoke(updates).await,
         }
@@ -94,7 +96,7 @@ impl Tool {
         match self {
             Tool::FsRead(fs_read) => fs_read.queue_description(ctx, updates).await,
             Tool::FsWrite(fs_write) => fs_write.queue_description(ctx, updates),
-            Tool::ExecuteBash(execute_bash) => execute_bash.queue_description(updates),
+            Tool::ExecuteShellCommands(execute_shell_commands) => execute_shell_commands.queue_description(updates),
             Tool::UseAws(use_aws) => use_aws.queue_description(updates),
             Tool::GhIssue(gh_issue) => gh_issue.queue_description(updates),
         }
@@ -105,7 +107,7 @@ impl Tool {
         match self {
             Tool::FsRead(fs_read) => fs_read.validate(ctx).await,
             Tool::FsWrite(fs_write) => fs_write.validate(ctx).await,
-            Tool::ExecuteBash(execute_bash) => execute_bash.validate(ctx).await,
+            Tool::ExecuteShellCommands(execute_shell_commands) => execute_shell_commands.validate(ctx).await,
             Tool::UseAws(use_aws) => use_aws.validate(ctx).await,
             Tool::GhIssue(gh_issue) => gh_issue.validate(ctx).await,
         }
@@ -127,7 +129,9 @@ impl TryFrom<ToolUse> for Tool {
         Ok(match value.name.as_str() {
             "fs_read" => Self::FsRead(serde_json::from_value::<FsRead>(value.args).map_err(map_err)?),
             "fs_write" => Self::FsWrite(serde_json::from_value::<FsWrite>(value.args).map_err(map_err)?),
-            "execute_bash" => Self::ExecuteBash(serde_json::from_value::<ExecuteBash>(value.args).map_err(map_err)?),
+            "execute_shell_commands" => {
+                Self::ExecuteShellCommands(serde_json::from_value::<ExecuteShellCommands>(value.args).map_err(map_err)?)
+            },
             "use_aws" => Self::UseAws(serde_json::from_value::<UseAws>(value.args).map_err(map_err)?),
             "report_issue" => Self::GhIssue(serde_json::from_value::<GhIssue>(value.args).map_err(map_err)?),
             unknown => {

crates/q_cli/src/cli/chat/tools/tool_index.json

@@ -1,13 +1,13 @@
 {
-  "execute_bash": {
-    "name": "execute_bash",
-    "description": "Execute the specified bash command.",
+  "execute_shell_commands": {
+    "name": "execute_shell_commands",
+    "description": "Execute the specified shell command.",
     "input_schema": {
       "type": "object",
       "properties": {
         "command": {
           "type": "string",
-          "description": "Bash command to execute"
+          "description": "Shell command to execute"
         }
       },
       "required": [