feat: Add basic todo list tool

Current functionality:
- Supports interally creating a todo list and completing tasks
- Displays list to the user
- Can be somewhat reliably invoked by explicitly asking Q for a todo list
- Q sometimes automatically generates a todo list on some prompts

Future chagnes:
- Add context so todo lists can be used across sessions
- Allow Q to add and remove tasks

Author: kiran-garre

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

@@ -80,6 +80,7 @@ use crate::cli::chat::tools::fs_write::FsWrite;
 use crate::cli::chat::tools::gh_issue::GhIssue;
 use crate::cli::chat::tools::knowledge::Knowledge;
 use crate::cli::chat::tools::thinking::Thinking;
+use crate::cli::chat::tools::todo::TodoInput;
 use crate::cli::chat::tools::use_aws::UseAws;
 use crate::cli::chat::tools::{
     Tool,
@@ -976,6 +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)?),
             // 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

crates/chat-cli/src/cli/chat/tools/compiler/token.h

@@ -0,0 +1,63 @@
+#ifndef TOKEN_H
+#define TOKEN_H
+
+// Token types for SimpleLang
+typedef enum {
+    // Literals
+    TOKEN_NUMBER,
+    TOKEN_IDENTIFIER,
+    TOKEN_STRING,
+    
+    // Keywords
+    TOKEN_IF,
+    TOKEN_ELSE,
+    TOKEN_WHILE,
+    TOKEN_PRINT,
+    TOKEN_READ,
+    TOKEN_INT,
+    TOKEN_STRING_TYPE,
+    
+    // Operators
+    TOKEN_PLUS,
+    TOKEN_MINUS,
+    TOKEN_MULTIPLY,
+    TOKEN_DIVIDE,
+    TOKEN_ASSIGN,
+    TOKEN_EQUAL,
+    TOKEN_NOT_EQUAL,
+    TOKEN_LESS,
+    TOKEN_GREATER,
+    TOKEN_LESS_EQUAL,
+    TOKEN_GREATER_EQUAL,
+    
+    // Delimiters
+    TOKEN_SEMICOLON,
+    TOKEN_COMMA,
+    TOKEN_LEFT_PAREN,
+    TOKEN_RIGHT_PAREN,
+    TOKEN_LEFT_BRACE,
+    TOKEN_RIGHT_BRACE,
+    
+    // Special
+    TOKEN_NEWLINE,
+    TOKEN_EOF,
+    TOKEN_ERROR
+} TokenType;
+
+typedef struct {
+    TokenType type;
+    char* lexeme;
+    int line;
+    int column;
+    union {
+        int int_value;
+        char* string_value;
+    } value;
+} Token;
+
+// Function declarations
+Token* create_token(TokenType type, char* lexeme, int line, int column);
+void free_token(Token* token);
+const char* token_type_to_string(TokenType type);
+
+#endif

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

@@ -6,6 +6,7 @@ pub mod gh_issue;
 pub mod knowledge;
 pub mod thinking;
 pub mod use_aws;
+pub mod todo;
 
 use std::collections::{
     HashMap,
@@ -36,6 +37,7 @@ use serde::{
 };
 use thinking::Thinking;
 use use_aws::UseAws;
+use todo::TodoInput;
 
 use super::consts::MAX_TOOL_RESPONSE_SIZE;
 use super::util::images::RichImageBlocks;
@@ -53,6 +55,7 @@ pub enum Tool {
     GhIssue(GhIssue),
     Knowledge(Knowledge),
     Thinking(Thinking),
+    Todo(TodoInput),
 }
 
 impl Tool {
@@ -70,6 +73,7 @@ impl Tool {
             Tool::GhIssue(_) => "gh_issue",
             Tool::Knowledge(_) => "knowledge",
             Tool::Thinking(_) => "thinking (prerelease)",
+            Tool::Todo(_) => "todoooooo"
         }
         .to_owned()
     }
@@ -85,6 +89,7 @@ impl Tool {
             Tool::GhIssue(_) => false,
             Tool::Knowledge(_) => false,
             Tool::Thinking(_) => false,
+            Tool::Todo(_) => false,
         }
     }
 
@@ -99,6 +104,8 @@ impl Tool {
             Tool::GhIssue(gh_issue) => gh_issue.invoke(os, stdout).await,
             Tool::Knowledge(knowledge) => knowledge.invoke(os, stdout).await,
             Tool::Thinking(think) => think.invoke(stdout).await,
+            Tool::Todo(todo) => todo.clone().invoke(os, stdout).await,
+
         }
     }
 
@@ -113,6 +120,7 @@ impl Tool {
             Tool::GhIssue(gh_issue) => gh_issue.queue_description(output),
             Tool::Knowledge(knowledge) => knowledge.queue_description(os, output).await,
             Tool::Thinking(thinking) => thinking.queue_description(output),
+            Tool::Todo(todo) => todo.queue_description(os, output),
         }
     }
 
@@ -127,6 +135,7 @@ impl Tool {
             Tool::GhIssue(gh_issue) => gh_issue.validate(os).await,
             Tool::Knowledge(knowledge) => knowledge.validate(os).await,
             Tool::Thinking(think) => think.validate(os).await,
+            Tool::Todo(todo) => todo.validate(os).await,
         }
     }
 }
@@ -238,6 +247,7 @@ impl ToolPermissions {
             "report_issue" => "trusted".dark_green().bold(),
             "knowledge" => "trusted".dark_green().bold(),
             "thinking" => "trusted (prerelease)".dark_green().bold(),
+            "todoooooo" => "trusted".dark_green().bold(),
             _ if self.trust_all => "trusted".dark_grey().bold(),
             _ => "not trusted".dark_grey(),
         };

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

@@ -0,0 +1,148 @@
+use std::io::Write;
+use serde::{
+    Deserialize,
+    Serialize
+};
+
+use crossterm::{
+    queue,
+    style,
+};
+
+use eyre::{
+    Result,
+};
+
+use super::{
+    InvokeOutput,
+    MAX_TOOL_RESPONSE_SIZE,
+    OutputKind,
+};
+
+use crate::os::Os;
+
+const TODO_STATE_PATH: &str = "todo_state.json";
+/*
+Prompts that kinda work:
+
+Make a simple todo list for writing a hello world program in C
+Execute the steps for me and mark them off on the todo list after you complete each one (as you go).
+
+Design a multi-file compiler for a small language. In each file, include minimal skeleton code for implementing the compiler.
+ */
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(tag = "command")]
+
+pub enum TodoInput {
+
+    #[serde(rename = "create")]
+    Create { tasks: Vec<String> },
+
+    // #[serde(rename = "add")]
+    // Add { new_task: String },
+    
+    #[serde(rename = "complete")]
+    Complete { completed_indices: Vec<usize> },
+}
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct TodoState {
+    pub tasks: Vec<String>,
+    pub completed: Vec<bool>,
+}
+
+impl TodoState {
+    pub async fn load(os: &Os) -> Result<Self> {
+        if os.fs.exists(TODO_STATE_PATH) {
+            let json_str = os.fs.read_to_string(TODO_STATE_PATH).await?;
+            match serde_json::from_str::<Self>(&json_str) {
+                Ok(state_struct) => Ok(state_struct),
+                Err(_) => Ok(Self::default())
+            }
+        } else {
+            Ok(Self::default())
+        }
+    }
+
+    pub async fn save(&self, os: &Os) -> Result<()> {
+        if !os.fs.exists(TODO_STATE_PATH) {
+            os.fs.create_new(TODO_STATE_PATH).await?;
+        }
+        let json_str = serde_json::to_string(self)?;
+        os.fs.write(TODO_STATE_PATH, json_str).await?;
+        Ok(())
+    }
+
+    pub fn display_list(&self, output: &mut impl Write) -> Result<()> {
+        queue!(
+            output,
+            style::Print("TODO:\n"),
+        )?;
+        for (task, completed) in self.tasks.iter().zip(self.completed.iter()) {
+            TodoState::queue_next(output, task.clone(), *completed)?;
+        }
+        Ok(())
+    }
+
+    fn queue_next(output: &mut impl Write, task: String, completed: bool) -> Result<()> {
+        if completed {
+            queue!(
+                output, 
+                style::SetAttribute(style::Attribute::Italic),
+                style::SetForegroundColor(style::Color::Green),
+                style::Print("  ■ "),
+                style::SetForegroundColor(style::Color::DarkGrey),
+                // style::SetAttribute(style::Attribute::CrossedOut),
+                style::Print(format!("{}\n", task)),
+                // style::SetAttribute(style::Attribute::NotCrossedOut),
+                style::SetAttribute(style::Attribute::NoItalic),
+            )?;
+        } else {
+            queue!(
+                output, 
+                style::SetForegroundColor(style::Color::Reset),
+                style::Print(format!("  ☐ {}\n", task)),
+            )?;
+        }
+        Ok(())
+    }
+}
+
+
+impl TodoInput {
+    pub async fn invoke(&self, os: &Os, output: &mut impl Write) -> Result<InvokeOutput> {
+        let mut state = TodoState::load(os).await?;
+        match self {
+            TodoInput::Create { tasks } => {
+                state.tasks = tasks.clone();
+                state.completed = vec![false; state.tasks.len()];
+            },
+            TodoInput::Complete { completed_indices } => {
+                completed_indices.iter().for_each(|i| {
+                    if *i > state.completed.len() {
+                        return ();
+                    }
+                    state.completed[*i as usize] = true;
+                });
+            }
+        };
+        state.display_list(output)?;
+        output.flush()?;
+        state.save(os).await?;
+        Ok(Default::default())
+        // execute!(
+        //     output,
+        //     style::Print("Q requested to use the TODO tool!"),
+        // )?;
+        // panic!("panicked");
+    }
+
+    pub fn queue_description(&self, os: &Os, output: &mut impl Write) -> Result<()> {
+        Ok(())
+    }
+
+    pub async fn validate(&mut self, os: &Os) -> Result<()> {
+        Ok(())
+    }
+}

crates/chat-cli/src/cli/chat/tools/tool_index.json

@@ -232,5 +232,34 @@
         },
         "required": ["command"]
       }
+  },
+  "todo": {
+    "name": "todoooooo",
+    "description": "A tool for creating a TODO list and keeping track of tasks. This tool should be used any time the user gives you a task with multiple steps. A TODO list should be made BEFORE executing any steps. Steps should be marked off as you complete them. You should use this tool when appropriate, even if it is not explicitly requested by the user.",
+    "input_schema": {
+      "type": "object",
+      "properties": {
+        "command": {
+          "type": "string",
+          "enum": ["create, complete"],
+          "description": "The command to run. Allowed options are `add`, `complete`."
+        },
+        "tasks": {
+          "description": "Required paramter of `create` command containing the list of tasks to be added to the TODO list.",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "completed_indices": {
+          "description": "Required parameter of `complete` command containing the 0-INDEXED numbers of EVERY completed task.",
+          "type": "array",
+          "items": {
+            "type": "integer"
+          }
+        }
+      },
+      "required": ["command"]
+    }
   }
 }