feat(tools): add gh_issue (#974)

Addresses #873

Add the gh_issue tool that allows Q to open pre-filled issue templates with additional information. Similar to q issue, when asked to report an issue, a browser will open to the template (or URL if the browser cannot be opened).

Features:

- Triggers when asked to create or report an issue, or to open a feature request.
- Adds additional chat information automatically.
- Q could fill in expected/actual behavior, steps to reproduce, title.
- Includes any request IDs that resulted in an error.
- Includes chat context (from /context show --expand). This also includes their sizes.
- Includes the last 5 user-assistant requests from the chat transcript. This also includes any tool uses or errors that were displayed.

Author: hayemaxi

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

@@ -59,6 +59,11 @@ pub struct ConversationState {
     /// calling [Self::as_sendable_conversation_state].
     pub next_message: Option<UserInputMessage>,
     history: VecDeque<ChatMessage>,
+    /// Similar to history in that stores user and assistant responses, except that it is not used
+    /// in message requests. Instead, the responses are expected to be in human-readable format,
+    /// e.g user messages prefixed with '> '. Should also be used to store errors posted in the
+    /// chat.
+    pub transcript: VecDeque<String>,
     tools: Vec<Tool>,
     /// Context manager for handling sticky context files
     pub context_manager: Option<ContextManager>,
@@ -92,6 +97,7 @@ impl ConversationState {
             conversation_id,
             next_message: None,
             history: VecDeque::new(),
+            transcript: VecDeque::with_capacity(MAX_CONVERSATION_STATE_HISTORY_LEN),
             tools: tool_config
                 .into_values()
                 .map(|v| {
@@ -151,6 +157,9 @@ impl ConversationState {
             None
         };
 
+        // Record message before adding context.
+        self.append_user_transcript(&input);
+
         // Combine context files with user input if available
         let content = if let Some(context) = context_files {
             format!("{}\n{}", context, input)
@@ -183,6 +192,8 @@ impl ConversationState {
         if let Some(next_message) = self.next_message.as_ref() {
             warn!(?next_message, "next_message should not exist");
         }
+
+        self.append_assistant_transcript(&message);
         self.history.push_back(ChatMessage::AssistantResponseMessage(message));
     }
 
@@ -460,6 +471,24 @@ impl ConversationState {
     pub fn context_message_length(&self) -> Option<usize> {
         self.context_message_length
     }
+
+    pub fn append_user_transcript(&mut self, message: &str) {
+        self.append_transcript(format!("> {}", message.replace("\n", "> \n")));
+    }
+
+    pub fn append_assistant_transcript(&mut self, message: &AssistantResponseMessage) {
+        let tool_uses = message.tool_uses.as_deref().map_or("none".to_string(), |tools| {
+            tools.iter().map(|tool| tool.name.clone()).collect::<Vec<_>>().join(",")
+        });
+        self.append_transcript(format!("{}\n[Tool uses: {tool_uses}]", message.content.clone()));
+    }
+
+    pub fn append_transcript(&mut self, message: String) {
+        if self.transcript.len() >= MAX_CONVERSATION_STATE_HISTORY_LEN {
+            self.transcript.pop_front();
+        }
+        self.transcript.push_back(message);
+    }
 }
 
 impl From<InvokeOutput> for ToolResultContentBlock {

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

@@ -50,11 +50,11 @@ use fig_settings::Settings;
 use fig_util::CLI_BINARY_NAME;
 use input_source::InputSource;
 use parser::{
-    RecvError,
     RecvErrorKind,
     ResponseParser,
     ToolUse,
 };
+use regex::Regex;
 use serde_json::Map;
 use spinners::{
     Spinner,
@@ -65,6 +65,7 @@ use tokio::signal::unix::{
     SignalKind,
     signal,
 };
+use tools::gh_issue::GhIssueContext;
 use tools::{
     Tool,
     ToolSpec,
@@ -260,6 +261,8 @@ pub struct ChatContext<W: Write> {
     /// State used to keep track of tool use relation
     tool_use_status: ToolUseStatus,
     accept_all: bool,
+    /// Any failed requests that could be useful for error report/debugging
+    failed_request_ids: Vec<String>,
 }
 
 impl<W: Write> ChatContext<W> {
@@ -291,6 +294,7 @@ impl<W: Write> ChatContext<W> {
             tool_use_telemetry_events: HashMap::new(),
             tool_use_status: ToolUseStatus::Idle,
             accept_all,
+            failed_request_ids: Vec::new(),
         })
     }
 }
@@ -388,6 +392,9 @@ where
             });
         }
 
+        // Remove non-ASCII and ANSI characters.
+        let re = Regex::new(r"((\x9B|\x1B\[)[0-?]*[ -\/]*[@-~])|([^\x00-\x7F]+)").unwrap();
+
         loop {
             debug_assert!(next_state.is_some());
             let chat_state = next_state.take().unwrap_or_default();
@@ -428,28 +435,37 @@ where
             match result {
                 Ok(state) => next_state = Some(state),
                 Err(e) => {
-                    fn print_error<W: Write>(
-                        output: &mut W,
-                        prepend_msg: &str,
-                        report: Option<eyre::Report>,
-                    ) -> Result<(), std::io::Error> {
+                    let mut print_error = |output: &mut W,
+                                           prepend_msg: &str,
+                                           report: Option<eyre::Report>|
+                     -> Result<(), std::io::Error> {
                         queue!(
                             output,
                             style::SetAttribute(Attribute::Bold),
                             style::SetForegroundColor(Color::Red),
                         )?;
 
                         match report {
-                            Some(report) => queue!(output, style::Print(format!("{}: {:?}\n", prepend_msg, report)),)?,
-                            None => queue!(output, style::Print(prepend_msg), style::Print("\n"))?,
+                            Some(report) => {
+                                let text = re
+                                    .replace_all(&format!("{}: {:?}\n", prepend_msg, report), "")
+                                    .into_owned();
+
+                                queue!(output, style::Print(&text),)?;
+                                self.conversation_state.append_transcript(text);
+                            },
+                            None => {
+                                queue!(output, style::Print(prepend_msg), style::Print("\n"))?;
+                                self.conversation_state.append_transcript(prepend_msg.to_string());
+                            },
                         }
 
                         execute!(
                             output,
                             style::SetAttribute(Attribute::Reset),
                             style::SetForegroundColor(Color::Reset),
                         )
-                    }
+                    };
 
                     error!(?e, "An error occurred processing the current state");
                     if self.interactive && self.spinner.is_some() {
@@ -987,7 +1003,13 @@ where
                 style::Print(format!("{}\n", "▔".repeat(terminal_width))),
                 style::SetForegroundColor(Color::Reset),
             )?;
-            let invoke_result = tool.1.invoke(&self.ctx, &mut self.output).await;
+            let invoke_result = tool
+                .1
+                .invoke(&self.ctx, &mut self.output, GhIssueContext {
+                    conversation_state: &self.conversation_state,
+                    failed_request_ids: &self.failed_request_ids,
+                })
+                .await;
 
             if self.interactive && self.spinner.is_some() {
                 queue!(
@@ -1105,78 +1127,81 @@ where
                         },
                     }
                 },
-                Err(RecvError {
-                    request_id,
-                    source: RecvErrorKind::StreamTimeout { source, duration },
-                }) => {
-                    error!(
-                        request_id,
-                        ?source,
-                        "Encountered a stream timeout after waiting for {}s",
-                        duration.as_secs()
-                    );
-                    if self.interactive {
-                        execute!(self.output, cursor::Hide)?;
-                        self.spinner = Some(Spinner::new(Spinners::Dots, "Dividing up the work...".to_string()));
-                    }
-                    // For stream timeouts, we'll tell the model to try and split its response into
-                    // smaller chunks.
-                    self.conversation_state
-                        .push_assistant_message(AssistantResponseMessage {
-                            message_id: None,
-                            content: "Response timed out - message took too long to generate".to_string(),
-                            tool_uses: None,
-                        });
-                    self.conversation_state
-                        .append_new_user_message(
-                            "You took too long to respond - try to split up the work into smaller steps.".to_string(),
-                        )
-                        .await;
-                    self.send_tool_use_telemetry().await;
-                    return Ok(ChatState::HandleResponseStream(
-                        self.client
-                            .send_message(self.conversation_state.as_sendable_conversation_state().await)
-                            .await?,
-                    ));
-                },
-                Err(RecvError {
-                    request_id,
-                    source:
+                Err(recv_error) => {
+                    if let Some(request_id) = &recv_error.request_id {
+                        self.failed_request_ids.push(request_id.clone());
+                    };
+
+                    match recv_error.source {
+                        RecvErrorKind::StreamTimeout { source, duration } => {
+                            error!(
+                                recv_error.request_id,
+                                ?source,
+                                "Encountered a stream timeout after waiting for {}s",
+                                duration.as_secs()
+                            );
+                            if self.interactive {
+                                execute!(self.output, cursor::Hide)?;
+                                self.spinner =
+                                    Some(Spinner::new(Spinners::Dots, "Dividing up the work...".to_string()));
+                            }
+                            // For stream timeouts, we'll tell the model to try and split its response into
+                            // smaller chunks.
+                            self.conversation_state
+                                .push_assistant_message(AssistantResponseMessage {
+                                    message_id: None,
+                                    content: "Response timed out - message took too long to generate".to_string(),
+                                    tool_uses: None,
+                                });
+                            self.conversation_state
+                                .append_new_user_message(
+                                    "You took too long to respond - try to split up the work into smaller steps."
+                                        .to_string(),
+                                )
+                                .await;
+                            self.send_tool_use_telemetry().await;
+                            return Ok(ChatState::HandleResponseStream(
+                                self.client
+                                    .send_message(self.conversation_state.as_sendable_conversation_state().await)
+                                    .await?,
+                            ));
+                        },
                         RecvErrorKind::UnexpectedToolUseEos {
                             tool_use_id,
                             name,
                             message,
+                        } => {
+                            error!(
+                                recv_error.request_id,
+                                tool_use_id, name, "The response stream ended before the entire tool use was received"
+                            );
+                            if self.interactive {
+                                execute!(self.output, cursor::Hide)?;
+                                self.spinner = Some(Spinner::new(
+                                    Spinners::Dots,
+                                    "The generated tool use was too large, trying to divide up the work...".to_string(),
+                                ));
+                            }
+
+                            self.conversation_state.push_assistant_message(*message);
+                            let tool_results = vec![ToolResult {
+                                    tool_use_id,
+                                    content: vec![ToolResultContentBlock::Text(
+                                        "The generated tool was too large, try again but this time split up the work between multiple tool uses".to_string(),
+                                    )],
+                                    status: ToolResultStatus::Error,
+                                }];
+                            self.conversation_state.add_tool_results(tool_results);
+                            self.send_tool_use_telemetry().await;
+                            return Ok(ChatState::HandleResponseStream(
+                                self.client
+                                    .send_message(self.conversation_state.as_sendable_conversation_state().await)
+                                    .await?,
+                            ));
                         },
-                }) => {
-                    error!(
-                        request_id,
-                        tool_use_id, name, "The response stream ended before the entire tool use was received"
-                    );
-                    if self.interactive {
-                        execute!(self.output, cursor::Hide)?;
-                        self.spinner = Some(Spinner::new(
-                            Spinners::Dots,
-                            "The generated tool use was too large, trying to divide up the work...".to_string(),
-                        ));
+                        _ => return Err(recv_error.into()),
                     }
-
-                    self.conversation_state.push_assistant_message(*message);
-                    let tool_results = vec![ToolResult {
-                            tool_use_id,
-                            content: vec![ToolResultContentBlock::Text(
-                                "The generated tool was too large, try again but this time split up the work between multiple tool uses".to_string(),
-                            )],
-                            status: ToolResultStatus::Error,
-                        }];
-                    self.conversation_state.add_tool_results(tool_results);
-                    self.send_tool_use_telemetry().await;
-                    return Ok(ChatState::HandleResponseStream(
-                        self.client
-                            .send_message(self.conversation_state.as_sendable_conversation_state().await)
-                            .await?,
-                    ));
                 },
-                Err(err) => return Err(err.into()),
             }
 
             // Fix for the markdown parser copied over from q chat: