feat: add to-do list functionality to QCLI (#2533)

Author: kiran-garre

build-config/buildspec-linux.yml

@@ -44,4 +44,3 @@ artifacts:
     # Signatures
     - ./*.asc
     - ./*.sig
-

build-config/buildspec-macos.yml

@@ -38,4 +38,3 @@ artifacts:
     - ./*.zip
     # Hashes
     - ./*.sha256
-

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

@@ -810,6 +810,7 @@ impl Agents {
             "use_aws" => "trust read-only commands".dark_grey(),
             "report_issue" => "trusted".dark_green().bold(),
             "thinking" => "trusted (prerelease)".dark_green().bold(),
+            "todo_list" => "trusted".dark_green().bold(),
             _ if self.trust_all_tools => "trusted".dark_grey().bold(),
             _ => "not trusted".dark_grey(),
         };

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

@@ -11,6 +11,7 @@ pub mod profile;
 pub mod prompts;
 pub mod subscribe;
 pub mod tangent;
+pub mod todos;
 pub mod tools;
 pub mod usage;
 
@@ -27,6 +28,7 @@ use persist::PersistSubcommand;
 use profile::AgentSubcommand;
 use prompts::PromptsArgs;
 use tangent::TangentArgs;
+use todos::TodoSubcommand;
 use tools::ToolsArgs;
 
 use crate::cli::chat::cli::subscribe::SubscribeArgs;
@@ -89,6 +91,9 @@ pub enum SlashCommand {
     Persist(PersistSubcommand),
     // #[command(flatten)]
     // Root(RootSubcommand),
+    /// View, manage, and resume to-do lists
+    #[command(subcommand)]
+    Todos(TodoSubcommand),
 }
 
 impl SlashCommand {
@@ -151,6 +156,7 @@ impl SlashCommand {
             //         skip_printing_tools: true,
             //     })
             // },
+            Self::Todos(subcommand) => subcommand.execute(os, session).await,
         }
     }
 
@@ -177,6 +183,7 @@ impl SlashCommand {
                 PersistSubcommand::Save { .. } => "save",
                 PersistSubcommand::Load { .. } => "load",
             },
+            Self::Todos(_) => "todos",
         }
     }
 

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

@@ -0,0 +1,205 @@
+use clap::Subcommand;
+use crossterm::execute;
+use crossterm::style::{
+    self,
+    Stylize,
+};
+use dialoguer::FuzzySelect;
+use eyre::Result;
+
+use crate::cli::chat::tools::todo::{
+    TodoListState,
+    delete_todo,
+    get_all_todos,
+};
+use crate::cli::chat::{
+    ChatError,
+    ChatSession,
+    ChatState,
+};
+use crate::os::Os;
+
+/// Defines subcommands that allow users to view and manage todo lists
+#[derive(Debug, PartialEq, Subcommand)]
+pub enum TodoSubcommand {
+    /// Delete all completed to-do lists
+    ClearFinished,
+
+    /// Resume a selected to-do list
+    Resume,
+
+    /// View a to-do list
+    View,
+
+    /// Delete a to-do list
+    Delete {
+        #[arg(long, short)]
+        all: bool,
+    },
+}
+
+/// Used for displaying completed and in-progress todo lists
+pub struct TodoDisplayEntry {
+    pub num_completed: usize,
+    pub num_tasks: usize,
+    pub description: String,
+    pub id: String,
+}
+
+impl std::fmt::Display for TodoDisplayEntry {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.num_completed == self.num_tasks {
+            write!(f, "{} {}", "✓".green().bold(), self.description.clone(),)
+        } else {
+            write!(
+                f,
+                "{} {} ({}/{})",
+                "✗".red().bold(),
+                self.description.clone(),
+                self.num_completed,
+                self.num_tasks
+            )
+        }
+    }
+}
+
+impl TodoSubcommand {
+    pub async fn execute(self, os: &mut Os, session: &mut ChatSession) -> Result<ChatState, ChatError> {
+        TodoListState::init_dir(os)
+            .await
+            .map_err(|e| ChatError::Custom(format!("Could not create todos directory: {e}").into()))?;
+        match self {
+            Self::ClearFinished => {
+                let (todos, errors) = match get_all_todos(os).await {
+                    Ok(res) => res,
+                    Err(e) => return Err(ChatError::Custom(format!("Could not get to-do lists: {e}").into())),
+                };
+                let mut cleared_one = false;
+
+                for todo_status in todos.iter() {
+                    if todo_status.tasks.iter().all(|b| b.completed) {
+                        match delete_todo(os, &todo_status.id).await {
+                            Ok(_) => cleared_one = true,
+                            Err(e) => {
+                                return Err(ChatError::Custom(format!("Could not delete to-do list: {e}").into()));
+                            },
+                        };
+                    }
+                }
+                if cleared_one {
+                    execute!(
+                        session.stderr,
+                        style::Print("✔ Cleared finished to-do lists!\n".green())
+                    )?;
+                } else {
+                    execute!(session.stderr, style::Print("No finished to-do lists to clear!\n"))?;
+                }
+                if !errors.is_empty() {
+                    execute!(
+                        session.stderr,
+                        style::Print(format!("* Failed to get {} todo list(s)\n", errors.len()).dark_grey())
+                    )?;
+                }
+            },
+            Self::Resume => match Self::get_descriptions_and_statuses(os).await {
+                Ok(entries) => {
+                    if entries.is_empty() {
+                        execute!(session.stderr, style::Print("No to-do lists to resume!\n"),)?;
+                    } else if let Some(index) = fuzzy_select_todos(&entries, "Select a to-do list to resume:") {
+                        if index < entries.len() {
+                            execute!(
+                                session.stderr,
+                                style::Print(format!(
+                                    "{} {}",
+                                    "⟳ Resuming:".magenta(),
+                                    entries[index].description.clone()
+                                ))
+                            )?;
+                            return session.resume_todo_request(os, &entries[index].id).await;
+                        }
+                    }
+                },
+                Err(e) => return Err(ChatError::Custom(format!("Could not show to-do lists: {e}").into())),
+            },
+            Self::View => match Self::get_descriptions_and_statuses(os).await {
+                Ok(entries) => {
+                    if entries.is_empty() {
+                        execute!(session.stderr, style::Print("No to-do lists to view!\n"))?;
+                    } else if let Some(index) = fuzzy_select_todos(&entries, "Select a to-do list to view:") {
+                        if index < entries.len() {
+                            let list = TodoListState::load(os, &entries[index].id).await.map_err(|e| {
+                                ChatError::Custom(format!("Could not load current to-do list: {e}").into())
+                            })?;
+                            execute!(
+                                session.stderr,
+                                style::Print(format!(
+                                    "{} {}\n\n",
+                                    "Viewing:".magenta(),
+                                    entries[index].description.clone()
+                                ))
+                            )?;
+                            if list.display_list(&mut session.stderr).is_err() {
+                                return Err(ChatError::Custom("Could not display the selected to-do list".into()));
+                            }
+                            execute!(session.stderr, style::Print("\n"),)?;
+                        }
+                    }
+                },
+                Err(e) => return Err(ChatError::Custom(format!("Could not show to-do lists: {e}").into())),
+            },
+            Self::Delete { all } => match Self::get_descriptions_and_statuses(os).await {
+                Ok(entries) => {
+                    if entries.is_empty() {
+                        execute!(session.stderr, style::Print("No to-do lists to delete!\n"))?;
+                    } else if all {
+                        for entry in entries {
+                            delete_todo(os, &entry.id)
+                                .await
+                                .map_err(|_e| ChatError::Custom("Could not delete all to-do lists".into()))?;
+                        }
+                        execute!(session.stderr, style::Print("✔ Deleted all to-do lists!\n".green()),)?;
+                    } else if let Some(index) = fuzzy_select_todos(&entries, "Select a to-do list to delete:") {
+                        if index < entries.len() {
+                            delete_todo(os, &entries[index].id).await.map_err(|e| {
+                                ChatError::Custom(format!("Could not delete the selected to-do list: {e}").into())
+                            })?;
+                            execute!(
+                                session.stderr,
+                                style::Print("✔ Deleted to-do list: ".green()),
+                                style::Print(format!("{}\n", entries[index].description.clone().dark_grey()))
+                            )?;
+                        }
+                    }
+                },
+                Err(e) => return Err(ChatError::Custom(format!("Could not show to-do lists: {e}").into())),
+            },
+        }
+        Ok(ChatState::PromptUser {
+            skip_printing_tools: true,
+        })
+    }
+
+    /// Convert all to-do list state entries to displayable entries
+    async fn get_descriptions_and_statuses(os: &Os) -> Result<Vec<TodoDisplayEntry>> {
+        let mut out = Vec::new();
+        let (todos, _) = get_all_todos(os).await?;
+        for todo in todos.iter() {
+            out.push(TodoDisplayEntry {
+                num_completed: todo.tasks.iter().filter(|t| t.completed).count(),
+                num_tasks: todo.tasks.len(),
+                description: todo.description.clone(),
+                id: todo.id.clone(),
+            });
+        }
+        Ok(out)
+    }
+}
+
+fn fuzzy_select_todos(entries: &[TodoDisplayEntry], prompt_str: &str) -> Option<usize> {
+    FuzzySelect::new()
+        .with_prompt(prompt_str)
+        .items(entries)
+        .report(false)
+        .interact_opt()
+        .unwrap_or(None)
+}

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

@@ -12,6 +12,7 @@ use crossterm::{
     execute,
     style,
 };
+use eyre::Result;
 use serde::{
     Deserialize,
     Serialize,
@@ -555,12 +556,15 @@ impl ConversationState {
                             2) Bullet points for all significant tools executed and their results\n\
                             3) Bullet points for any code or technical information shared\n\
                             4) A section of key insights gained\n\n\
+                            5) REQUIRED: the ID of the currently loaded todo list, if any\n\n\
                             FORMAT THE SUMMARY IN THIRD PERSON, NOT AS A DIRECT RESPONSE. Example format:\n\n\
                             ## CONVERSATION SUMMARY\n\
                             * Topic 1: Key information\n\
                             * Topic 2: Key information\n\n\
                             ## TOOLS EXECUTED\n\
                             * Tool X: Result Y\n\n\
+                            ## TODO ID\n\
+                            * <id>\n\n\
                             Remember this is a DOCUMENT not a chat response. The custom instruction above modifies what to prioritize.\n\
                             FILTER OUT CHAT CONVENTIONS (greetings, offers to help, etc).",
                     custom_prompt.as_ref()
@@ -575,12 +579,15 @@ impl ConversationState {
                         2) Bullet points for all significant tools executed and their results\n\
                         3) Bullet points for any code or technical information shared\n\
                         4) A section of key insights gained\n\n\
+                        5) REQUIRED: the ID of the currently loaded todo list, if any\n\n\
                         FORMAT THE SUMMARY IN THIRD PERSON, NOT AS A DIRECT RESPONSE. Example format:\n\n\
                         ## CONVERSATION SUMMARY\n\
                         * Topic 1: Key information\n\
                         * Topic 2: Key information\n\n\
                         ## TOOLS EXECUTED\n\
                         * Tool X: Result Y\n\n\
+                        ## TODO ID\n\
+                        * <id>\n\n\
                         Remember this is a DOCUMENT not a chat response.\n\
                         FILTER OUT CHAT CONVENTIONS (greetings, offers to help, etc).".to_string()
             },

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

@@ -136,13 +136,15 @@ use crate::api_client::{
 };
 use crate::auth::AuthError;
 use crate::auth::builder_id::is_idc_user;
+use crate::cli::TodoListState;
 use crate::cli::agent::Agents;
 use crate::cli::chat::cli::SlashCommand;
 use crate::cli::chat::cli::model::find_model;
 use crate::cli::chat::cli::prompts::{
     GetPromptError,
     PromptsSubcommand,
 };
+use crate::cli::chat::message::UserMessage;
 use crate::cli::chat::util::sanitize_unicode_tags;
 use crate::database::settings::Setting;
 use crate::mcp_client::Prompt;
@@ -2859,6 +2861,43 @@ impl ChatSession {
             tracing::warn!("Failed to send slash command telemetry: {}", e);
         }
     }
+
+    /// Prompts Q to resume a to-do list with the given id by calling the load
+    /// command of the todo_list tool
+    pub async fn resume_todo_request(&mut self, os: &mut Os, id: &str) -> Result<ChatState, ChatError> {
+        // Have to unpack each value separately since Reports can't be converted to
+        // ChatError
+        let todo_list = match TodoListState::load(os, id).await {
+            Ok(todo) => todo,
+            Err(e) => {
+                return Err(ChatError::Custom(format!("Error getting todo list: {e}").into()));
+            },
+        };
+        let contents = match serde_json::to_string(&todo_list) {
+            Ok(s) => s,
+            Err(e) => return Err(ChatError::Custom(format!("Error deserializing todo list: {e}").into())),
+        };
+        let request_content = format!(
+            "[SYSTEM NOTE: This is an automated request, not from the user]\n
+            Read the TODO list contents below and understand the task description, completed tasks, and provided context.\n 
+            Call the `load` command of the todo_list tool with the given ID as an argument to display the TODO list to the user and officially resume execution of the TODO list tasks.\n
+            You do not need to display the tasks to the user yourself. You can begin completing the tasks after calling the `load` command.\n
+            TODO LIST CONTENTS: {}\n
+            ID: {}\n",
+            contents,
+            id
+        );
+
+        let summary_message = UserMessage::new_prompt(request_content.clone(), None);
+
+        ChatSession::reset_user_turn(self);
+
+        Ok(ChatState::HandleInput {
+            input: summary_message
+                .into_user_input_message(self.conversation.model.clone(), &self.conversation.tools)
+                .content,
+        })
+    }
 }
 
 /// Replaces amzn_codewhisperer_client::types::SubscriptionStatus with a more descriptive type.
@@ -2919,7 +2958,7 @@ async fn get_subscription_status_with_spinner(
     .await;
 }
 
-async fn with_spinner<T, E, F, Fut>(output: &mut impl std::io::Write, spinner_text: &str, f: F) -> Result<T, E>
+pub async fn with_spinner<T, E, F, Fut>(output: &mut impl std::io::Write, spinner_text: &str, f: F) -> Result<T, E>
 where
     F: FnOnce() -> Fut,
     Fut: std::future::Future<Output = Result<T, E>>,

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

@@ -88,6 +88,11 @@ pub const COMMANDS: &[&str] = &[
     "/save",
     "/load",
     "/subscribe",
+    "/todos",
+    "/todos resume",
+    "/todos clear-finished",
+    "/todos view",
+    "/todos delete",
 ];
 
 pub type PromptQuerySender = tokio::sync::broadcast::Sender<PromptQuery>;