Slash command + persistence in progress commit

Author: kiran-garre

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

@@ -12,6 +12,7 @@ pub mod prompts;
 pub mod subscribe;
 pub mod tools;
 pub mod usage;
+pub mod todos;
 
 use clap::Parser;
 use clear::ClearArgs;
@@ -26,6 +27,7 @@ use persist::PersistSubcommand;
 use profile::ProfileSubcommand;
 use prompts::PromptsArgs;
 use tools::ToolsArgs;
+use todos::TodoSubcommand;
 
 use crate::cli::chat::cli::subscribe::SubscribeArgs;
 use crate::cli::chat::cli::usage::UsageArgs;
@@ -82,6 +84,8 @@ pub enum SlashCommand {
     Persist(PersistSubcommand),
     // #[command(flatten)]
     // Root(RootSubcommand),
+    #[command(subcommand)]
+    Todos(TodoSubcommand),
 }
 
 impl SlashCommand {
@@ -120,6 +124,8 @@ impl SlashCommand {
             //         skip_printing_tools: true,
             //     })
             // },
+
+            Self::Todos(subcommand) => subcommand.execute(os, session).await,
         }
     }
 }

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

@@ -0,0 +1,44 @@
+use clap::Args;
+use crate::os::Os;
+use crossterm::{
+    cursor,
+    execute,
+    queue,
+    style,
+};
+
+use crate::cli::chat::{
+    ChatError,
+    ChatSession,
+    ChatState,
+};
+
+const TODO_INTERNAL_PROMPT: &str = "This is the internal prompt that will be 
+sent to create the todo list";
+
+#[derive(Debug, Clone, PartialEq, Eq, Default, Args)]
+pub struct TodoArgs {
+    // Task/prompt to generate TODO list for
+    task_prompt: String,
+}
+
+impl TodoArgs {
+    pub async fn execute(self, os: &Os, session: &mut ChatSession) -> Result<ChatState, ChatError> {
+        execute!(
+            session.stderr,
+            style::Print("Dummy? Who you callin' a dummy?\n")
+        )?;
+        Ok(ChatState::PromptUser { skip_printing_tools: true })
+    }
+
+    // pub async fn create_todo_request(os: &Os) {
+
+    // }
+}
+/*
+async fn generate_todo(os: &Os, prompt: &str) {
+    // Create todo request using string above
+    // This will be a conversation state method
+}
+
+*/

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

@@ -0,0 +1,134 @@
+#![allow(warnings)]
+
+use clap::Subcommand;
+use std::{io, path::PathBuf};
+use crate::{cli::chat::tools::todo::TodoState, os::Os};
+use crossterm::{
+    execute,
+    style::{self, Stylize},
+};
+
+use crate::cli::chat::{
+    ChatError,
+    ChatSession,
+    ChatState,
+};
+
+use eyre::{
+    Result,
+    bail,
+};
+
+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
+    Show,
+    ClearFinished,
+    Select,
+}
+
+pub struct TodoDisplayEntry {
+    pub num_completed: usize,
+    pub num_tasks: usize,
+    pub description: String,
+    pub path: PathBuf,
+}
+
+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> {
+        
+        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) => {
+                        for e in entries {
+                            execute!(
+                                session.stderr,
+                                style::Print(e),
+                                style::Print("\n"),
+                            );
+                        }
+                    }
+                    Err(e) => { 
+                        execute!(
+                            session.stderr,
+                            style::Print("Could not show to-do lists"),
+                        ); 
+                    }
+                }
+            },
+            Self::ClearFinished => {
+                ();
+            },
+            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;
+                    }
+                    Err(e) => println!("{:?}", e),
+                };
+            },
+        };
+        Ok(ChatState::PromptUser { skip_printing_tools: true })
+    }
+
+    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?;
+
+        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 {
+                num_completed: temp_struct.completed.iter().filter(|b| **b).count(),
+                num_tasks: temp_struct.completed.len(),
+                description: temp_struct.task_description,
+                path: entry.path(),
+            });
+        }
+        Ok(out)
+    }
+
+}

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

@@ -4,6 +4,7 @@ use std::collections::{
     VecDeque,
 };
 use std::io::Write;
+use std::path::PathBuf;
 use std::sync::atomic::Ordering;
 
 use crossterm::style::Color;
@@ -21,6 +22,10 @@ use tracing::{
     warn,
 };
 
+use eyre::{
+    Result, 
+};
+
 use super::consts::{
     DUMMY_TOOL_NAME,
     MAX_CHARS,
@@ -73,6 +78,8 @@ use crate::cli::chat::cli::hooks::{
 use crate::mcp_client::Prompt;
 use crate::os::Os;
 
+use super::tools::todo::TodoState;
+
 const CONTEXT_ENTRY_START_HEADER: &str = "--- CONTEXT ENTRY BEGIN ---\n";
 const CONTEXT_ENTRY_END_HEADER: &str = "--- CONTEXT ENTRY END ---\n\n";
 
@@ -105,6 +112,9 @@ pub struct ConversationState {
     /// Model explicitly selected by the user in this conversation state via `/model`.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub model: Option<String>,
+
+    // Current todo list
+    pub todo_state: Option<TodoState>,
 }
 
 impl ConversationState {
@@ -157,6 +167,7 @@ impl ConversationState {
             context_message_length: None,
             latest_summary: None,
             model: current_model_id,
+            todo_state: Some(TodoState::default()),
         }
     }
 
@@ -835,6 +846,41 @@ impl ConversationState {
             },
         }
     }
+
+    pub async fn create_todo_request(&self, os: &Os, path: PathBuf) -> Result<FigConversationState> {
+        let contents = self.can_resume_todo(os, &path).await?;
+        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.
+            TODO LIST CONTENTS: {}
+            FILE PATH: {}",
+            contents,
+            path.display()
+        ); 
+        
+        let request_message = UserInputMessage {
+            content: request,
+            user_input_message_context: None,
+            user_intent: None,
+            images: None,
+            model_id: self.model.clone(),
+        };
+
+        Ok(FigConversationState {
+            conversation_id: Some(self.conversation_id.clone()),
+            user_input_message: request_message,
+            history: None,
+        }) 
+    }
+
+    // For now, just check that file path is valid and deserializable
+    // QUESTION: How do you pass errors cleanly in the todo_request functions?
+    pub async fn can_resume_todo(&self, os: &Os, path: &PathBuf) -> Result<String> {
+        let contents = os.fs.read_to_string(path).await?;
+        let _ = serde_json::from_str::<TodoState>(&contents)?;
+        Ok(contents)
+    }
 }
 
 /// Represents a conversation state that can be converted into a [FigConversationState] (the type

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

@@ -55,6 +55,8 @@ use eyre::{
     bail,
     eyre,
 };
+use std::path::PathBuf;
+
 use input_source::InputSource;
 use message::{
     AssistantMessage,
@@ -970,6 +972,64 @@ impl ChatSession {
         Ok(())
     }
 
+    async fn resume_todo(
+        &mut self,
+        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.set_next_user_message(state.user_input_message.content).await;
+            },
+            Err(_) => {
+                execute!(
+                    self.stderr,
+                    style::Print("TODO could not be resumed\n"),
+                )?;
+                return Ok(ChatState::PromptUser {
+                    skip_printing_tools: true,
+                });
+            },
+        };
+
+        // Use the normal sendable conversation state which includes tool definitions
+        let conv_state = self
+            .conversation
+            .as_sendable_conversation_state(os, &mut self.stderr, false)
+            .await?;
+ 
+        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)
+
+
+        // Ok(ChatState::PromptUser {
+        //     skip_printing_tools: true,
+        // })
+
+        
+    }
+
     /// Compacts the conversation history, replacing the history with a summary generated by the
     /// model.
     ///

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

@@ -977,7 +977,7 @@ impl ToolManager {
             "report_issue" => Tool::GhIssue(serde_json::from_value::<GhIssue>(value.args).map_err(map_err)?),
             "thinking" => Tool::Thinking(serde_json::from_value::<Thinking>(value.args).map_err(map_err)?),
             "knowledge" => Tool::Knowledge(serde_json::from_value::<Knowledge>(value.args).map_err(map_err)?),
-            "todoooooo" => Tool::Todo(serde_json::from_value::<TodoInput>(value.args).map_err(map_err)?),
+            "todo_list" => Tool::Todo(serde_json::from_value::<TodoInput>(value.args).map_err(map_err)?),
             // Note that this name is namespaced with server_name{DELIMITER}tool_name
             name => {
                 // Note: tn_map also has tools that underwent no transformation. In otherwords, if