feat: Add basic persistence functionality to todo_list

Updates:
- Users can select past to-do lists to complete
- Q will load the selected to-do list and finish the remaining tasks

Future changes
- Improve consistency of todo_list tool
- Add more checks for argument validity
- Add more detailed context to todo_lists for cross-session usage

Author: kiran-garre

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

@@ -19,18 +19,15 @@ use eyre::{
     bail,
 };
 
+use crate::cli::chat::tools::todo::{
+    build_path,
+    TODO_STATE_FOLDER_PATH,
+};
+
 use dialoguer::{
     FuzzySelect
 };
 
-const TODO_INTERNAL_PROMPT: &str = "This is the internal prompt that will be 
-sent to create the todo list";
-
-// ########### REMOVE BEFORE PUSHING ##############
-const TODO_STATE_FOLDER_PATH: &str = "/Users/kiranbug/.aws/amazonq/todos"; // temporary path where we store state files
-// ########### --------------------- ##############
-
-
 #[derive(Debug, PartialEq, Subcommand)]
 pub enum TodoSubcommand {
     // Task/prompt to generate TODO list for
@@ -66,16 +63,16 @@ impl std::fmt::Display for TodoDisplayEntry {
 
 impl TodoSubcommand {
     pub async fn execute(self, os: &mut Os, session: &mut ChatSession) -> Result<ChatState, ChatError> {
-        
-        execute!(
-            session.stderr,
-            style::Print("Dummy? Who you callin' a dummy?\n")
-        )?;
-
         match self {
             Self::Show => {
                 match self.get_descriptions_and_statuses(os).await {
                     Ok(entries) => {
+                        if entries.len() == 0 {
+                            execute!(
+                                session.stderr,
+                                style::Print("No to-do lists to show"),
+                            );
+                        }
                         for e in entries {
                             execute!(
                                 session.stderr,
@@ -98,11 +95,30 @@ impl TodoSubcommand {
             Self::Select => {
                 match self.get_descriptions_and_statuses(os).await {
                     Ok(entries) => {
-                        let selection_index = FuzzySelect::new()
-                            .items(&entries)
-                            .interact()
-                            .unwrap(); // FIX THIS
-                        return session.resume_todo(os, entries[selection_index].path.clone()).await;
+                        if entries.len() == 0 {
+                            execute!(
+                                session.stderr,
+                                style::Print("No to-do lists to show"),
+                            );
+                        } else {
+                            let selection = FuzzySelect::new()
+                                .with_prompt("Select task:")
+                                .items(&entries)
+                                .report(false)
+                                .interact_opt()
+                                .unwrap_or(None); // FIX: workaround for ^C during selection
+
+                            if let Some(index) = selection {
+                                if index < entries.len() {
+                                    execute!(
+                                        session.stderr,
+                                        style::Print("⟳ Resuming: ".magenta()),
+                                        style::Print(format!("{}\n", entries[index].description.clone())),
+                                    );
+                                    return session.resume_todo(os, entries[index].path.clone()).await;
+                                }
+                            }
+                        }
                     }
                     Err(e) => println!("{:?}", e),
                 };
@@ -113,22 +129,63 @@ impl TodoSubcommand {
 
     async fn get_descriptions_and_statuses(self, os: &Os) -> Result<Vec<TodoDisplayEntry>> {
         let mut out = Vec::new();
-        let mut entries = os.fs.read_dir(TODO_STATE_FOLDER_PATH).await?;
+        let mut entries = os.fs.read_dir(
+            build_path(os, TODO_STATE_FOLDER_PATH, "")?
+        ).await?;
 
         while let Some(entry) = entries.next_entry().await? {
             let contents = os.fs.read_to_string(entry.path()).await?;
             let temp_struct = match serde_json::from_str::<TodoState>(&contents) {
                 Ok(state) => state,
                 Err(_) => continue,
             };
-            out.push(TodoDisplayEntry {
+            out.push( TodoDisplayEntry {
                 num_completed: temp_struct.completed.iter().filter(|b| **b).count(),
                 num_tasks: temp_struct.completed.len(),
-                description: temp_struct.task_description,
+                description: prewrap(&temp_struct.task_description),
                 path: entry.path(),
             });
         }
         Ok(out)
     }
 
+}
+
+
+const MAX_LINE_LENGTH: usize = 80;
+
+// FIX: Hacky workaround for cleanly wrapping lines
+/// Insert newlines every n characters, not within a word and not at the end.
+/// 
+/// Generated by Q
+fn prewrap(text: &str) -> String {
+    if text.is_empty() || MAX_LINE_LENGTH == 0 {
+        return text.to_string();
+    }
+    
+    let mut result = String::new();
+    let mut current_line_length = 0;
+    let words: Vec<&str> = text.split_whitespace().collect();
+    
+    for (i, word) in words.iter().enumerate() {
+        let word_length = word.len();
+        
+        // If adding this word would exceed the line length and we're not at the start of a line
+        if current_line_length > 0 && current_line_length + 1 + word_length > MAX_LINE_LENGTH {
+            result.push('\n');
+            result.push_str(&" ".repeat("> ".len()));
+            current_line_length = 0;
+        }
+        
+        // Add space before word if not at start of line
+        if current_line_length > 0 {
+            result.push(' ');
+            current_line_length += 1;
+        }
+        
+        result.push_str(word);
+        current_line_length += word_length;
+    }
+    
+    result
 }

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

@@ -852,7 +852,8 @@ impl ConversationState {
         let request = format!(
             "[SYSTEM NOTE: This is an automated request, not from the user] 
             Read the TODO list contents below and understand the task description, completed tasks, and provided context. 
-            Call the Load command of the todo_list tool with the given file path as an argument to display the TODO list to the user and officially resume execution of the TODO list tasks.
+            Call the `load` command of the todo_list tool with the given file path as an argument to display the TODO list to the user and officially resume execution of the TODO list tasks.
+            You do not need to display the tasks to the user yourself. You can begin completing the tasks after calling the `load` command.
             TODO LIST CONTENTS: {}
             FILE PATH: {}",
             contents,

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

@@ -977,13 +977,15 @@ impl ChatSession {
         os: &mut Os,
         path: PathBuf,
     ) -> Result<ChatState, ChatError> {
+        
         let request_state = self
             .conversation
             .create_todo_request(os, path)
             .await;
 
         match request_state {
             Ok(state) => {
+                self.conversation.reset_next_user_message();
                 self.conversation.set_next_user_message(state.user_input_message.content).await;
             },
             Err(_) => {
@@ -1006,23 +1008,22 @@ impl ChatSession {
         let response = os.client.send_message(conv_state).await?;
 
         let mut result =  self.handle_response(os, response).await?;
-        match result {
-            ChatState::ExecuteTools => {
-                result = self.tool_use_execute(os).await?;
-            },
-            ChatState::ValidateTools(tool_uses) => {
-                result = self.validate_tools(os, tool_uses).await?;
-            },
-            ChatState::HandleResponseStream(response) => {
-                result = self.handle_response(os, response).await?;
-            },
-            other => {
-                return Ok(other);
-            },
-        }
-        Ok(result)
-
-
+        loop {
+            match result {
+                ChatState::ExecuteTools => {
+                    result = self.tool_use_execute(os).await?;
+                },
+                ChatState::ValidateTools(tool_uses) => {
+                    result = self.validate_tools(os, tool_uses).await?;
+                },
+                ChatState::HandleResponseStream(response) => {
+                    result = self.handle_response(os, response).await?;
+                },
+                other => {
+                    return Ok(other);
+                },
+            }
+        };
         // Ok(ChatState::PromptUser {
         //     skip_printing_tools: true,
         // })