Feat: Add accept all flag and command to chat, and change verbage around consent

Author: chaynabors

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

@@ -5,6 +5,7 @@ pub enum Command {
     Execute { command: String },
     Clear,
     Help,
+    AcceptAll,
     Quit,
 }
 
@@ -16,6 +17,7 @@ impl Command {
             return Ok(match command.to_lowercase().as_str() {
                 "clear" => Self::Clear,
                 "help" => Self::Help,
+                "acceptall" => Self::AcceptAll,
                 "q" | "exit" | "quit" => Self::Quit,
                 _ => return Err(format!("Unknown command: {}", input)),
             });

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

@@ -105,9 +105,12 @@ const HELP_TEXT: &str = color_print::cstr! {"
 
 <em>!{command}</em>    <black!>Quickly execute a command in your current session</black!>
 
+<black!>Use the following dangerous command at your own discretion.</black!>
+<em>/acceptall</em>    <black!>Disables acceptance prompting for the session.</black!>
+
 "};
 
-pub async fn chat(input: Option<String>) -> Result<ExitCode> {
+pub async fn chat(input: Option<String>, accept_all: bool) -> Result<ExitCode> {
     if !fig_util::system_info::in_cloudshell() && !fig_auth::is_logged_in().await {
         bail!(
             "You are not logged in, please log in with {}",
@@ -136,9 +139,16 @@ pub async fn chat(input: Option<String>) -> Result<ExitCode> {
         _ => StreamingClient::new().await?,
     };
 
-    let mut chat = ChatContext::new(ctx, output, input, InputSource::new()?, interactive, client, || {
-        terminal::window_size().map(|s| s.columns.into()).ok()
-    })?;
+    let mut chat = ChatContext::new(
+        ctx,
+        output,
+        input,
+        InputSource::new()?,
+        interactive,
+        client,
+        || terminal::window_size().map(|s| s.columns.into()).ok(),
+        accept_all,
+    )?;
 
     let result = chat.try_chat().await.map(|_| ExitCode::SUCCESS);
     drop(chat); // Explicit drop for clarity
@@ -191,9 +201,11 @@ pub struct ChatContext<W: Write> {
     tool_use_telemetry_events: HashMap<String, ToolUseEventBuilder>,
     /// State used to keep track of tool use relation
     tool_use_status: ToolUseStatus,
+    accept_all: bool,
 }
 
 impl<W: Write> ChatContext<W> {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         ctx: Arc<Context>,
         output: W,
@@ -202,6 +214,7 @@ impl<W: Write> ChatContext<W> {
         interactive: bool,
         client: StreamingClient,
         terminal_width_provider: fn() -> Option<usize>,
+        accept_all: bool,
     ) -> Result<Self> {
         Ok(Self {
             ctx,
@@ -215,6 +228,7 @@ impl<W: Write> ChatContext<W> {
             conversation_state: ConversationState::new(load_tools()?),
             tool_use_telemetry_events: HashMap::new(),
             tool_use_status: ToolUseStatus::Idle,
+            accept_all,
         })
     }
 }
@@ -429,7 +443,7 @@ where
                 style::Print("y"),
                 style::SetForegroundColor(Color::DarkGrey),
                 style::Print(format!(
-                    " to run {}, otherwise continue without.\n\n",
+                    " to run {}, otherwise continue chatting.\n\n",
                     match tool_uses.len() == 1 {
                         true => "this tool",
                         false => "these tools",
@@ -499,7 +513,7 @@ where
                 execute!(
                     self.output,
                     style::SetForegroundColor(Color::Green),
-                    style::Print("\nConversation history cleared\n\n"),
+                    style::Print("\nConversation history cleared.\n\n"),
                     style::SetForegroundColor(Color::Reset)
                 )?;
 
@@ -509,6 +523,21 @@ where
                 execute!(self.output, style::Print(HELP_TEXT))?;
                 ChatState::PromptUser { tool_uses: None }
             },
+            Command::AcceptAll => {
+                self.accept_all = !self.accept_all;
+
+                execute!(
+                    self.output,
+                    style::SetForegroundColor(Color::Green),
+                    style::Print(format!("\n{} acceptance prompting.\n\n", match self.accept_all {
+                        true => "Disabled",
+                        false => "Enabled",
+                    })),
+                    style::SetForegroundColor(Color::Reset)
+                )?;
+
+                ChatState::PromptUser { tool_uses: None }
+            },
             Command::Quit => ChatState::Exit,
         })
     }
@@ -851,20 +880,16 @@ where
             return Ok(ChatState::HandleResponseStream(response));
         }
 
-        let skip_consent = self
-            .ctx
-            .env()
-            .get("Q_CHAT_SKIP_TOOL_CONSENT")
-            .is_ok_and(|s| !s.is_empty() && !queued_tools.is_empty())
-            || queued_tools.iter().all(|tool| !tool.1.requires_consent(&self.ctx));
+        let skip_acceptance = self.accept_all || queued_tools.iter().all(|tool| !tool.1.requires_acceptance(&self.ctx));
 
-        if skip_consent {
-            self.print_tool_descriptions(&queued_tools)?;
-            Ok(ChatState::ExecuteTools(queued_tools))
-        } else {
-            Ok(ChatState::PromptUser {
+        match skip_acceptance {
+            true => {
+                self.print_tool_descriptions(&queued_tools)?;
+                Ok(ChatState::ExecuteTools(queued_tools))
+            },
+            false => Ok(ChatState::PromptUser {
                 tool_uses: Some(queued_tools),
-            })
+            }),
         }
     }
 
@@ -1080,6 +1105,7 @@ mod tests {
             true,
             test_client,
             || Some(80),
+            false,
         )
         .unwrap()
         .try_chat()

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

@@ -32,7 +32,7 @@ pub struct ExecuteBash {
 }
 
 impl ExecuteBash {
-    pub fn requires_consent(&self) -> bool {
+    pub fn requires_acceptance(&self) -> bool {
         let Some(args) = shlex::split(&self.command) else {
             return true;
         };
@@ -228,7 +228,7 @@ mod tests {
     }
 
     #[test]
-    fn test_requires_consent_for_readonly_commands() {
+    fn test_requires_acceptance_for_readonly_commands() {
         let cmds = &[
             // Safe commands
             ("ls ~", false),
@@ -259,9 +259,9 @@ mod tests {
             }))
             .unwrap();
             assert_eq!(
-                tool.requires_consent(),
+                tool.requires_acceptance(),
                 *expected,
-                "expected command: `{}` to have requires_consent: `{}`",
+                "expected command: `{}` to have requires_acceptance: `{}`",
                 cmd,
                 expected
             );

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

@@ -80,13 +80,13 @@ impl Tool {
         .to_owned()
     }
 
-    /// Whether or not the tool should prompt the user for consent before [Self::invoke] is called.
-    pub fn requires_consent(&self, _ctx: &Context) -> bool {
+    /// Whether or not the tool should prompt the user to accept before [Self::invoke] is called.
+    pub fn requires_acceptance(&self, _ctx: &Context) -> bool {
         match self {
             Tool::FsRead(_) => false,
             Tool::FsWrite(_) => true,
-            Tool::ExecuteBash(execute_bash) => execute_bash.requires_consent(),
-            Tool::UseAws(use_aws) => use_aws.requires_consent(),
+            Tool::ExecuteBash(execute_bash) => execute_bash.requires_acceptance(),
+            Tool::UseAws(use_aws) => use_aws.requires_acceptance(),
         }
     }
 

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

@@ -39,7 +39,7 @@ pub struct UseAws {
 }
 
 impl UseAws {
-    pub fn requires_consent(&self) -> bool {
+    pub fn requires_acceptance(&self) -> bool {
         !READONLY_OPS.iter().any(|op| self.operation_name.starts_with(op))
     }
 
@@ -160,31 +160,31 @@ mod tests {
     }
 
     #[test]
-    fn test_requires_consent() {
+    fn test_requires_acceptance() {
         let cmd = use_aws! {{
             "service_name": "ecs",
             "operation_name": "list-task-definitions",
             "region": "us-west-2",
             "profile_name": "default",
             "label": ""
         }};
-        assert!(!cmd.requires_consent());
+        assert!(!cmd.requires_acceptance());
         let cmd = use_aws! {{
             "service_name": "lambda",
             "operation_name": "list-functions",
             "region": "us-west-2",
             "profile_name": "default",
             "label": ""
         }};
-        assert!(!cmd.requires_consent());
+        assert!(!cmd.requires_acceptance());
         let cmd = use_aws! {{
             "service_name": "s3",
             "operation_name": "put-object",
             "region": "us-west-2",
             "profile_name": "default",
             "label": ""
         }};
-        assert!(cmd.requires_consent());
+        assert!(cmd.requires_acceptance());
     }
 
     #[test]

crates/q_cli/src/cli/mod.rs

@@ -182,6 +182,10 @@ pub enum CliRootCommands {
     /// AI assistant in your terminal
     #[command(alias("q"))]
     Chat {
+        /// Enabling this flag allows the model to execute all commands without first accepting
+        /// them.
+        #[arg(short, long)]
+        accept_all: bool,
         /// The first question to ask
         input: Option<String>,
     },
@@ -328,7 +332,7 @@ impl Cli {
                 CliRootCommands::Telemetry(subcommand) => subcommand.execute().await,
                 CliRootCommands::Version => Self::print_version(),
                 CliRootCommands::Dashboard => launch_dashboard(false).await,
-                CliRootCommands::Chat { input } => chat::chat(input).await,
+                CliRootCommands::Chat { accept_all, input } => chat::chat(input, accept_all).await,
                 CliRootCommands::Inline(subcommand) => subcommand.execute(&cli_context).await,
             },
             // Root command
@@ -447,7 +451,10 @@ mod test {
         });
 
         assert_eq!(Cli::parse_from([CLI_BINARY_NAME, "chat", "-vv"]), Cli {
-            subcommand: Some(CliRootCommands::Chat { input: None },),
+            subcommand: Some(CliRootCommands::Chat {
+                accept_all: false,
+                input: None
+            },),
             verbose: 2,
             help_all: false,
         });