ruby_todo 0.4.1 → 1.0.1

data/implementation_steps.md

@@ -0,0 +1,130 @@
+# Implementation Guide: Adding AI Assistant to Ruby Todo
+
+This guide outlines the specific steps to add AI assistant functionality to the Ruby Todo gem, allowing users to interact with the application using natural language through Claude or OpenAI.
+
+## Step 1: Update the gemspec file
+
+Edit `ruby_todo.gemspec` to add the required dependencies:
+
+```ruby
+# Runtime dependencies
+spec.add_dependency "anthropic", "~> 0.1.0"  # For Claude API
+spec.add_dependency "ruby-openai", "~> 6.3.0" # For OpenAI API
+spec.add_dependency "dotenv", "~> 2.8"  # For API key management
+```
+
+## Step 2: Create the folder structure
+
+```bash
+mkdir -p lib/ruby_todo/commands
+```
+
+## Step 3: Create the AI Assistant command file
+
+Create a new file at `lib/ruby_todo/commands/ai_assistant.rb` with the implementation from the plan document.
+
+## Step 4: Update the CLI class
+
+Edit `lib/ruby_todo/cli.rb` to add the AI Assistant command:
+
+1. Add the require statement at the top:
+```ruby
+require_relative "commands/ai_assistant"
+```
+
+2. Register the subcommand inside the CLI class:
+```ruby
+# Register AI Assistant subcommand
+desc "ai SUBCOMMAND", "Use AI assistant"
+subcommand "ai", AIAssistantCommand
+```
+
+## Step 5: Create .env template
+
+Create a `.env.template` file in the project root:
+
+```
+# Claude API key (if using Claude)
+ANTHROPIC_API_KEY=your_claude_api_key_here
+
+# OpenAI API key (if using OpenAI)
+OPENAI_API_KEY=your_openai_api_key_here
+```
+
+Add `.env` to `.gitignore` to prevent accidental check-in of API keys.
+
+## Step 6: Update README
+
+Add the AI Assistant documentation to the README.md file:
+
+1. Add "AI Assistant" to the Features list at the top
+2. Add the full AI Assistant section after the Templates section
+
+## Step 7: Create tests
+
+Create tests for the AI Assistant functionality:
+
+1. Create a new file `test/ai_assistant_test.rb`
+2. Add unit tests for the AI Assistant command class
+3. Add integration tests for the CLI integration
+4. Add mock tests for API interactions
+
+## Step 8: Install and test
+
+1. Install the updated gem: `bundle exec rake install`
+2. Run `ruby_todo ai configure` to set up your API key
+3. Test with a simple prompt: `ruby_todo ai ask "Create a task in the Work notebook"`
+
+## Usage Examples
+
+Here are some examples of how to use the AI assistant:
+
+1. Configure the AI assistant:
+```bash
+ruby_todo ai configure
+```
+
+2. Create a task using natural language:
+```bash
+ruby_todo ai ask "Add a high priority task to update documentation in my Work notebook due next Friday"
+```
+
+3. Move tasks to a different status:
+```bash
+ruby_todo ai ask "Move all tasks related to documentation in my Work notebook to in_progress"
+```
+
+4. Generate a JSON import file:
+```bash
+ruby_todo ai ask "Create a JSON file with 5 tasks for my upcoming vacation planning"
+```
+
+5. Get task statistics:
+```bash
+ruby_todo ai ask "Give me a summary of my Work notebook"
+```
+
+6. Search for specific tasks:
+```bash
+ruby_todo ai ask "Find all high priority tasks that are overdue"
+```
+
+## Troubleshooting
+
+1. API key issues:
+   - Ensure your API key is correctly configured
+   - Try passing the API key directly: `ruby_todo ai ask "..." --api-key=your_key`
+
+2. JSON parsing errors:
+   - Enable verbose mode to see the raw response: `ruby_todo ai ask "..." --verbose`
+   - Check if the model is generating valid JSON
+
+3. Permission issues:
+   - Check file permissions on `~/.ruby_todo/ai_config.json`
+
+4. Missing dependencies:
+   - Run `bundle install` to ensure all gems are installed
+
+5. Command not found:
+   - Ensure the gem is properly installed: `gem list ruby_todo`
+   - Reinstall if necessary: `gem uninstall ruby_todo && bundle exec rake install` 

data/lib/ruby_todo/ai_assistant/common_query_handler.rb

@@ -0,0 +1,378 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module TaskStatistics
+    private
+
+    def handle_statistics_query(prompt)
+      say "\nHandling statistics query" if options[:verbose]
+
+      if prompt =~ /\b(?:show|display|get)\s+(?:me\s+)?(?:the\s+)?stats\b/i
+        display_task_statistics
+        return true
+      end
+
+      false
+    end
+
+    def display_task_statistics
+      notebooks = RubyTodo::Notebook.all
+      total_stats = { todo: 0, in_progress: 0, done: 0, archived: 0 }
+
+      notebooks.each do |notebook|
+        stats = notebook.task_statistics
+        total_stats.merge!(stats) { |_key, old_val, new_val| old_val + new_val }
+
+        display_notebook_statistics(notebook, stats)
+      end
+
+      display_total_statistics(total_stats)
+    end
+
+    def display_notebook_statistics(notebook, stats)
+      say "\nNotebook: #{notebook.name}".blue
+      say "  Todo: #{stats[:todo]}".yellow
+      say "  In Progress: #{stats[:in_progress]}".blue
+      say "  Done: #{stats[:done]}".green
+      say "  Archived: #{stats[:archived]}".gray
+    end
+
+    def display_total_statistics(stats)
+      say "\nTotal Statistics:".blue
+      say "  Todo: #{stats[:todo]}".yellow
+      say "  In Progress: #{stats[:in_progress]}".blue
+      say "  Done: #{stats[:done]}".green
+      say "  Archived: #{stats[:archived]}".gray
+    end
+  end
+
+  module TaskPriority
+    private
+
+    def handle_priority_query(prompt)
+      say "\nHandling priority query" if options[:verbose]
+
+      if prompt =~ /\b(?:show|display|get|list)\s+(?:me\s+)?(?:the\s+)?(?:high|medium|low)\s*-?\s*priority\b/i
+        display_priority_tasks(prompt)
+        return true
+      end
+
+      false
+    end
+
+    def display_priority_tasks(prompt)
+      priority = extract_priority_level(prompt)
+      tasks = find_priority_tasks(priority)
+
+      if tasks.any?
+        display_tasks_by_priority(tasks, priority)
+      else
+        say "No #{priority} priority tasks found.".yellow
+      end
+    end
+
+    def extract_priority_level(prompt)
+      if prompt =~ /\b(high|medium|low)\s*-?\s*priority\b/i
+        Regexp.last_match(1).downcase
+      else
+        "high" # Default to high priority
+      end
+    end
+
+    def find_priority_tasks(priority)
+      tasks = []
+      RubyTodo::Notebook.all.each do |notebook|
+        notebook.tasks.each do |task|
+          next unless task_matches_priority?(task, priority)
+
+          tasks << {
+            task_id: task.id,
+            title: task.title,
+            status: task.status,
+            notebook: notebook.name
+          }
+        end
+      end
+      tasks
+    end
+
+    def task_matches_priority?(task, priority)
+      return false unless task.tags
+
+      case priority
+      when "high"
+        task.tags.downcase.include?("high") || task.tags.downcase.include?("urgent")
+      when "medium"
+        task.tags.downcase.include?("medium") || task.tags.downcase.include?("normal")
+      when "low"
+        task.tags.downcase.include?("low")
+      else
+        false
+      end
+    end
+
+    def display_tasks_by_priority(tasks, priority)
+      say "\n#{priority.capitalize} Priority Tasks:".blue
+      tasks.each do |task|
+        status_color = case task[:status]
+                       when "todo" then :yellow
+                       when "in_progress" then :blue
+                       when "done" then :green
+                       else :white
+                       end
+
+        say "  [#{task[:notebook]}] Task #{task[:task_id]}: #{task[:title]}".send(status_color)
+      end
+    end
+  end
+
+  module TaskDeadlines
+    private
+
+    def handle_deadline_query(prompt)
+      say "\nHandling deadline query" if options[:verbose]
+      # rubocop:disable Layout/LineLength
+      deadline_pattern = /\b(?:show|display|get|list)\s+(?:me\s+)?(?:the\s+)?(?:upcoming|due|overdue)\s+(?:tasks|deadlines)\b/
+      # rubocop:enable Layout/LineLength
+      if prompt =~ /#{deadline_pattern}/i
+        display_deadline_tasks(prompt)
+        return true
+      end
+
+      false
+    end
+
+    def display_deadline_tasks(prompt)
+      deadline_type = extract_deadline_type(prompt)
+      tasks = find_deadline_tasks(deadline_type)
+
+      if tasks.any?
+        display_tasks_by_deadline(tasks, deadline_type)
+      else
+        say "No #{deadline_type} tasks found.".yellow
+      end
+    end
+
+    def extract_deadline_type(prompt)
+      if prompt =~ /\b(upcoming|due|overdue)\b/i
+        Regexp.last_match(1).downcase
+      else
+        "upcoming" # Default to upcoming
+      end
+    end
+
+    def find_deadline_tasks(deadline_type)
+      tasks = []
+      RubyTodo::Notebook.all.each do |notebook|
+        notebook.tasks.each do |task|
+          next unless task_matches_deadline?(task, deadline_type)
+
+          tasks << {
+            task_id: task.id,
+            title: task.title,
+            status: task.status,
+            notebook: notebook.name,
+            deadline: task.deadline
+          }
+        end
+      end
+      tasks
+    end
+
+    def task_matches_deadline?(task, deadline_type)
+      return false unless task.deadline
+
+      case deadline_type
+      when "upcoming"
+        task.deadline > Time.now && task.deadline <= Time.now + (7 * 24 * 60 * 60) # 7 days
+      when "due"
+        task.deadline <= Time.now + (24 * 60 * 60) # 1 day
+      when "overdue"
+        task.deadline < Time.now
+      else
+        false
+      end
+    end
+
+    def display_tasks_by_deadline(tasks, deadline_type)
+      say "\n#{deadline_type.capitalize} Tasks:".blue
+      tasks.each do |task|
+        deadline_str = task[:deadline].strftime("%Y-%m-%d %H:%M")
+        status_color = case task[:status]
+                       when "todo" then :yellow
+                       when "in_progress" then :blue
+                       when "done" then :green
+                       else :white
+                       end
+
+        say "  [#{task[:notebook]}] Task #{task[:task_id]}: " \
+            "#{task[:title]} (Due: #{deadline_str})".send(status_color)
+      end
+    end
+  end
+
+  module TaskCreation
+    private
+
+    def handle_task_creation(prompt, prompt_lower)
+      say "\n=== Detecting task creation request ===" if options[:verbose]
+
+      title = extract_task_title(prompt)
+      return false unless title
+
+      notebook_name = determine_notebook_name(prompt_lower)
+      return false unless notebook_name
+
+      priority = determine_priority(prompt_lower)
+
+      create_task(notebook_name, title, priority)
+      true
+    end
+
+    def extract_task_title(prompt)
+      # Try to extract title from quotes first
+      title_match = prompt.match(/'([^']+)'|"([^"]+)"/)
+
+      if title_match
+        title_match[1] || title_match[2]
+      else
+        # If no quoted title found, try extracting from the prompt
+        extract_title_from_text(prompt)
+      end
+    end
+
+    def extract_title_from_text(prompt)
+      potential_title = prompt
+      phrases_to_remove = [
+        "create a task", "create task", "add a task", "add task",
+        "called", "named", "with", "priority", "high", "medium", "low",
+        "in", "notebook"
+      ]
+
+      phrases_to_remove.each do |phrase|
+        potential_title = potential_title.gsub(/#{phrase}/i, " ")
+      end
+
+      result = potential_title.strip
+      result.empty? ? nil : result
+    end
+
+    def determine_notebook_name(prompt_lower)
+      return nil unless Notebook.default_notebook
+
+      notebook_name = Notebook.default_notebook.name
+
+      # Try to extract a specific notebook name from the prompt
+      Notebook.all.each do |notebook|
+        if prompt_lower.include?(notebook.name.downcase)
+          notebook_name = notebook.name
+          break
+        end
+      end
+
+      notebook_name
+    end
+
+    def determine_priority(prompt_lower)
+      if prompt_lower.include?("high priority") || prompt_lower.match(/priority.*high/)
+        "high"
+      elsif prompt_lower.include?("medium priority") || prompt_lower.match(/priority.*medium/)
+        "medium"
+      elsif prompt_lower.include?("low priority") || prompt_lower.match(/priority.*low/)
+        "low"
+      end
+    end
+
+    def create_task(notebook_name, title, priority)
+      say "\nCreating task in notebook: #{notebook_name}" if options[:verbose]
+      cli_args = ["task:add", notebook_name, title]
+
+      # Add priority if specified
+      cli_args.push("--priority", priority) if priority
+
+      RubyTodo::CLI.start(cli_args)
+
+      # Create a simple explanation
+      priority_text = priority ? " with #{priority} priority" : ""
+      say "\nCreated task '#{title}'#{priority_text} in the #{notebook_name} notebook"
+    end
+  end
+
+  module CommonQueryHandler
+    include TaskStatistics
+    include TaskPriority
+    include TaskDeadlines
+    include TaskCreation
+
+    def handle_common_query(prompt)
+      handle_statistics_query(prompt) ||
+        handle_priority_query(prompt) ||
+        handle_deadline_query(prompt)
+    end
+
+    private
+
+    def high_priority_query?(prompt_lower)
+      prompt_lower.include?("high priority") ||
+        (prompt_lower.include?("priority") && prompt_lower.include?("high"))
+    end
+
+    def medium_priority_query?(prompt_lower)
+      prompt_lower.include?("medium priority") ||
+        (prompt_lower.include?("priority") && prompt_lower.include?("medium"))
+    end
+
+    def statistics_query?(prompt_lower)
+      (prompt_lower.include?("statistics") || prompt_lower.include?("stats")) &&
+        (prompt_lower.include?("notebook") || prompt_lower.include?("tasks"))
+    end
+
+    def status_tasks_query?(prompt_lower)
+      statuses = { "todo" => "todo", "in progress" => "in_progress", "done" => "done", "archived" => "archived" }
+      statuses.keys.any? { |status| prompt_lower.include?(status) }
+    end
+
+    def notebook_listing_query?(prompt_lower)
+      prompt_lower.include?("list notebooks") ||
+        prompt_lower.include?("show notebooks") ||
+        prompt_lower.include?("display notebooks")
+    end
+
+    def handle_status_tasks(prompt_lower)
+      say "\n=== Detecting status tasks request ===" if options[:verbose]
+
+      statuses = { "todo" => "todo", "in progress" => "in_progress", "done" => "done", "archived" => "archived" }
+      status = nil
+
+      statuses.each do |name, value|
+        if prompt_lower.include?(name)
+          status = value
+          break
+        end
+      end
+
+      return false unless status
+
+      tasks = find_tasks_by_status(status)
+      display_tasks_by_status(tasks, status)
+      true
+    end
+
+    def handle_notebook_listing(_prompt_lower)
+      say "\n=== Detecting notebook listing request ===" if options[:verbose]
+
+      notebooks = Notebook.all
+      if notebooks.empty?
+        say "No notebooks found.".yellow
+        return true
+      end
+
+      say "\nNotebooks:".blue
+      notebooks.each do |notebook|
+        say "  #{notebook.name}".green
+      end
+
+      true
+    end
+  end
+end

data/lib/ruby_todo/ai_assistant/configuration_management.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module ConfigurationManagement
+    def load_api_key_from_config
+      config = load_config
+      config["openai"]
+    end
+
+    def load_config
+      return {} unless File.exist?(config_file)
+
+      YAML.load_file(config_file) || {}
+    end
+
+    def save_config(key, value)
+      config = load_config
+      config[key] = value
+      FileUtils.mkdir_p(File.dirname(config_file))
+      File.write(config_file, config.to_yaml)
+    end
+
+    def config_file
+      File.join(Dir.home, ".config", "ruby_todo", "config.yml")
+    end
+  end
+end