ruby_todo 1.0.0 → 1.0.1

data/lib/ruby_todo/commands/ai_assistant.rb

@@ -5,46 +5,34 @@ require "json"
 require "openai"
 require "dotenv/load"
 
+require_relative "../ai_assistant/task_search"
+require_relative "../ai_assistant/task_management"
+require_relative "../ai_assistant/openai_integration"
+require_relative "../ai_assistant/configuration_management"
+require_relative "../ai_assistant/common_query_handler"
+
 module RubyTodo
   class AIAssistantCommand < Thor
-    desc "ask [PROMPT]", "Ask the AI assistant to perform tasks using natural language"
+    include TaskManagement
+    include OpenAIIntegration
+    include ConfigurationManagement
+    include CommonQueryHandler
+
+    desc "ai:ask [PROMPT]", "Ask the AI assistant to perform tasks using natural language"
     method_option :api_key, type: :string, desc: "OpenAI API key"
     method_option :verbose, type: :boolean, default: false, desc: "Show detailed response"
     def ask(*prompt_args)
       prompt = prompt_args.join(" ")
-      unless prompt && !prompt.empty?
-        say "Please provide a prompt for the AI assistant".red
-        return
-      end
+      validate_prompt(prompt)
+      say "\n=== Starting AI Assistant with prompt: '#{prompt}' ===" if options[:verbose]
 
-      # Get API key from options, env var, or config file
-      api_key = options[:api_key] || ENV["OPENAI_API_KEY"] || load_api_key_from_config
-      unless api_key
-        say "No API key found. Please provide an API key using --api-key or set OPENAI_API_KEY environment variable".red
-        return
-      end
-
-      # Set up context for the AI
-      context = build_context
+      # Direct handling for common queries
+      return if handle_common_query(prompt)
 
-      response = query_openai(prompt, context, api_key)
-
-      if response[:error]
-        say "Error: #{response[:error]}".red
-        return
-      end
-
-      # Parse the AI's response for potential actions
-      parse_and_execute_actions(response[:content])
-
-      # Print the AI's response if verbose mode
-      if options[:verbose]
-        say "\nAI Assistant Response:".blue
-        say response[:content]
-      end
+      process_ai_query(prompt)
     end
 
-    desc "configure", "Configure the AI assistant settings"
+    desc "ai:configure", "Configure the AI assistant settings"
     def configure
       prompt = TTY::Prompt.new
       api_key = prompt.mask("Enter your OpenAI API key:")
@@ -52,402 +40,410 @@ module RubyTodo
       say "Configuration saved successfully!".green
     end
 
+    def self.banner(command, _namespace = nil, _subcommand: false)
+      "#{basename} #{command.name}"
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
     private
 
-    def build_context
-      # Build a context object with information about the current state of the app
-      notebooks = Notebook.all.map do |notebook|
-        {
-          id: notebook.id,
-          name: notebook.name,
-          task_count: notebook.tasks.count,
-          todo_count: notebook.tasks.todo.count,
-          in_progress_count: notebook.tasks.in_progress.count,
-          done_count: notebook.tasks.done.count,
-          archived_count: notebook.tasks.archived.count
-        }
-      end
+    def process_ai_query(prompt)
+      api_key = fetch_api_key
+      say "\nAPI key loaded successfully" if options[:verbose]
 
-      {
-        notebooks: notebooks,
-        commands: {
-          notebook_commands: %w[create list],
-          task_commands: %w[add list show edit delete move search],
-          export_commands: %w[export import],
-          template_commands: %w[create list show use delete]
-        },
-        app_version: RubyTodo::VERSION
-      }
-    end
-
-    def query_openai(prompt, context, api_key)
-      client = OpenAI::Client.new(access_token: api_key)
-      system_message = build_system_message(context)
-      make_openai_request(client, system_message, prompt)
-    end
-
-    def build_system_message(context)
-      <<~SYSTEM
-        You are an AI assistant for Ruby Todo, a command-line task management application.
-
-        Application Information:
-        #{JSON.pretty_generate(context)}
-
-        Your job is to help the user manage their tasks through natural language.
-        You can create tasks, move tasks between statuses, and more.
-
-        IMPORTANT FORMATTING REQUIREMENTS:
-        - Due dates must be in "YYYY-MM-DD HH:MM" format (e.g., "2024-04-10 14:00")
-        - Valid priority values are ONLY: "high", "medium", or "low" (lowercase)
-        - Valid status values are ONLY: "todo", "in_progress", "done", "archived" (lowercase)
-        - If you're unsure about any values, omit them rather than guessing
-
-        When the user asks you to perform an action, generate a response in this JSON format:
-        {
-          "explanation": "Brief explanation of what you're doing",
-          "actions": [
-            {"type": "create_task", "notebook": "Work", "title": "Task title", "description": "Task description", "priority": "high", "tags": "tag1,tag2", "due_date": "2024-04-10 14:00"},
-            {"type": "move_task", "notebook": "Work", "task_id": 1, "status": "in_progress"},
-            {"type": "create_notebook", "name": "Personal"},
-            {"type": "generate_import_json", "notebook": "Work", "tasks": [{...task data...}]}
-          ]
-        }
-
-        Action types:
-        - create_task: Create a new task in a notebook (requires notebook, title; optional: description, priority, tags, due_date)
-        - move_task: Move a task to a different status (requires notebook, task_id, status)
-        - create_notebook: Create a new notebook (requires name)
-        - generate_import_json: Generate JSON for importing tasks (requires notebook, tasks array)
-        - list_tasks: List tasks in a notebook (requires notebook; optional: status, priority)
-        - search_tasks: Search for tasks (requires query; optional: notebook)
-
-        EXTREMELY IMPORTANT:
-        1. Always respond with raw JSON only
-        2. DO NOT use markdown code blocks (like ```json)
-        3. DO NOT include any explanatory text before or after the JSON
-        4. The response must be parseable as JSON
-
-        Always validate all fields according to the requirements before including them in your response.
-      SYSTEM
-    end
-
-    def make_openai_request(client, system_message, prompt)
-      response = client.chat(
-        parameters: {
-          model: "gpt-4o-mini",
-          messages: [
-            { role: "system", content: system_message },
-            { role: "user", content: prompt }
-          ],
-          max_tokens: 1024
-        }
-      )
-      { content: response.dig("choices", 0, "message", "content") }
-    rescue StandardError => e
-      { error: e.message }
-    end
-
-    def parse_and_execute_actions(response)
-      cleaned_response = response.gsub(/```(?:json)?\s*/, "").gsub(/```\s*$/, "")
-
-      data = JSON.parse(cleaned_response)
-
-      say data["explanation"].green if data["explanation"]
-
-      if data["actions"] && data["actions"].is_a?(Array)
-        data["actions"].each do |action|
-          execute_action(action)
-        end
-      else
-        say "No actions found in response".yellow
-      end
-    rescue JSON::ParserError => e
-      say "Couldn't parse AI response: #{e.message}".red
-      say "Response starts with: #{response[0..100]}..." if options[:verbose]
-      say "Full response: #{response}" if options[:verbose]
-    end
-
-    def execute_action(action)
-      case action["type"]
-      when "create_task"
-        create_task(action)
-      when "move_task"
-        move_task(action)
-      when "create_notebook"
-        create_notebook(action)
-      when "generate_import_json"
-        generate_import_json(action)
-      when "list_tasks"
-        list_tasks(action)
-      when "search_tasks"
-        search_tasks(action)
-      else
-        say "Unknown action type: #{action["type"]}".yellow
+      context = build_context
+      say "\nInitial context built" if options[:verbose]
+
+      # Process based on query type
+      process_query_by_type(prompt, context)
+
+      # Get AI response for commands and explanation
+      say "\n=== Querying OpenAI ===" if options[:verbose]
+      response = query_openai(prompt, context, api_key)
+      say "\nOpenAI Response received" if options[:verbose]
+
+      # Execute actions based on response
+      execute_actions(response, context)
+    end
+
+    def process_query_by_type(prompt, context)
+      if should_handle_task_movement?(prompt)
+        # Handle task movement and build context
+        say "\n=== Processing Task Movement Request ===" if options[:verbose]
+        handle_task_request(prompt, context)
+      elsif options[:verbose]
+        say "\n=== Processing Non-Movement Request ==="
       end
     end
 
-    def create_task(action)
-      unless action["notebook"] && action["title"]
-        say "Missing required fields for create_task".red
-        return
+    def execute_actions(response, context)
+      # If we have tasks to move, do it now
+      if context[:matching_tasks]&.any? && context[:target_status]
+        say "\n=== Moving Tasks ===" if options[:verbose]
+        move_tasks_to_status(context[:matching_tasks], context[:target_status])
       end
 
-      notebook = Notebook.find_by(name: action["notebook"])
-      unless notebook
-        say "Notebook '#{action["notebook"]}' not found".red
-        return
+      # Execute any additional commands from the AI
+      if response && response["commands"]
+        say "\n=== Executing Additional Commands ===" if options[:verbose]
+        execute_commands(response)
       end
 
-      due_date = parse_task_due_date(action["due_date"])
-      priority = validate_task_priority(action["priority"])
-
-      task = Task.create(
-        notebook: notebook,
-        title: action["title"],
-        description: action["description"],
-        due_date: due_date,
-        priority: priority,
-        tags: action["tags"],
-        status: "todo"
-      )
-
-      if task.valid?
-        say "Added task: #{action["title"]}".green
-      else
-        say "Error creating task: #{task.errors.full_messages.join(", ")}".red
+      # Display the explanation from the AI
+      if response && response["explanation"]
+        say "\n=== AI Explanation ===" if options[:verbose]
+        say "\n#{response["explanation"]}"
       end
     end
 
-    def parse_task_due_date(due_date_str)
-      return nil unless due_date_str
+    def validate_prompt(prompt)
+      return if prompt && !prompt.empty?
 
-      begin
-        Time.parse(due_date_str)
-      rescue ArgumentError
-        say "Invalid date format '#{due_date_str}'. Using no due date.".yellow
-        nil
-      end
+      say "Please provide a prompt for the AI assistant".red
+      raise ArgumentError, "Empty prompt"
     end
 
-    def validate_task_priority(priority_str)
-      return nil unless priority_str
+    def fetch_api_key
+      api_key = options[:api_key] || ENV["OPENAI_API_KEY"] || load_api_key_from_config
+      return api_key if api_key
 
-      if %w[high medium low].include?(priority_str.downcase)
-        priority_str.downcase
-      else
-        msg = "Invalid priority '#{priority_str}'. Valid values are 'high', 'medium', or 'low'."
-        say "#{msg} Using default.".yellow
-        nil
+      say "No API key found. Please provide an API key using --api-key or set OPENAI_API_KEY environment variable".red
+      raise ArgumentError, "No API key found"
+    end
+
+    def build_context
+      { matching_tasks: [] }
+    end
+
+    def execute_commands(response)
+      return unless response["commands"].is_a?(Array)
+
+      response["commands"].each do |command|
+        process_command(command)
       end
     end
 
-    def move_task(action)
-      unless action["notebook"] && action["task_id"] && action["status"]
-        say "Missing required fields for move_task".red
-        return
+    def process_command(command)
+      say "\nExecuting command: #{command}".blue if options[:verbose]
+
+      begin
+        # Skip if empty or nil
+        return if command.nil? || command.strip.empty?
+
+        # Ensure command starts with ruby_todo
+        return unless command.start_with?("ruby_todo")
+
+        # Process and execute the command
+        process_ruby_todo_command(command)
+      rescue StandardError => e
+        say "Error executing command: #{e.message}".red
+        say e.backtrace.join("\n").red if options[:verbose]
       end
+    end
+
+    def process_ruby_todo_command(command)
+      # Remove the ruby_todo prefix
+      cmd_without_prefix = command.sub(/^ruby_todo\s+/, "")
+      say "\nCommand without prefix: '#{cmd_without_prefix}'".blue if options[:verbose]
 
-      notebook = Notebook.find_by(name: action["notebook"])
-      unless notebook
-        say "Notebook '#{action["notebook"]}' not found".red
-        return
+      # Convert underscores to colons for all task commands
+      if cmd_without_prefix =~ /^task_\w+/
+        cmd_without_prefix = cmd_without_prefix.sub(/^task_(\w+)/, 'task:\1')
+        say "\nConverted underscores to colons: '#{cmd_without_prefix}'".blue if options[:verbose]
       end
 
-      task = notebook.tasks.find_by(id: action["task_id"])
-      unless task
-        say "Task with ID #{action["task_id"]} not found".red
-        return
+      # Convert underscores to colons for notebook commands
+      if cmd_without_prefix =~ /^notebook_\w+/
+        cmd_without_prefix = cmd_without_prefix.sub(/^notebook_(\w+)/, 'notebook:\1')
+        say "\nConverted underscores to colons: '#{cmd_without_prefix}'".blue if options[:verbose]
       end
 
-      valid_statuses = %w[todo in_progress done archived]
-      status = action["status"].downcase
-      unless valid_statuses.include?(status)
-        say "Invalid status '#{status}'. Valid values are: #{valid_statuses.join(", ")}".red
-        return
+      # Convert underscores to colons for template commands
+      if cmd_without_prefix =~ /^template_\w+/
+        cmd_without_prefix = cmd_without_prefix.sub(/^template_(\w+)/, 'template:\1')
+        say "\nConverted underscores to colons: '#{cmd_without_prefix}'".blue if options[:verbose]
       end
 
-      if task.update(status: status)
-        say "Moved task #{action["task_id"]} to #{status}".green
+      # Process different command types
+      if cmd_without_prefix.start_with?("task:list")
+        execute_task_list_command(cmd_without_prefix)
+      elsif cmd_without_prefix.start_with?("task:search")
+        execute_task_search_command(cmd_without_prefix)
+      elsif cmd_without_prefix.start_with?("task:move")
+        execute_task_move_command(cmd_without_prefix)
       else
-        say "Error moving task: #{task.errors.full_messages.join(", ")}".red
+        execute_other_command(cmd_without_prefix)
       end
     end
 
-    def create_notebook(action)
-      unless action["name"]
-        say "Missing required field 'name' for create_notebook".red
-        return
-      end
+    def execute_task_list_command(cmd_without_prefix)
+      parts = cmd_without_prefix.split(/\s+/)
+      say "\nSplit task:list command into parts: #{parts.inspect}".blue if options[:verbose]
 
-      notebook = Notebook.create(name: action["name"])
-      if notebook.valid?
-        say "Created notebook: #{action["name"]}".green
+      if parts.size >= 2
+        execute_task_list_with_notebook(parts)
+      elsif Notebook.default_notebook
+        execute_task_list_with_default_notebook(parts)
       else
-        say "Error creating notebook: #{notebook.errors.full_messages.join(", ")}".red
+        say "\nNo notebook specified for task:list command".yellow
       end
     end
 
-    def generate_import_json(action)
-      unless action["notebook"] && action["tasks"] && action["tasks"].is_a?(Array)
-        say "Missing required fields for generate_import_json".red
-        return
+    def execute_task_list_with_notebook(parts)
+      notebook_name = parts[1]
+      # Extract any options
+      options_args = []
+      parts[2..].each do |part|
+        options_args << part if part.start_with?("--")
       end
 
-      data = {
-        "name" => action["notebook"],
-        "created_at" => Time.now.iso8601,
-        "updated_at" => Time.now.iso8601,
-        "tasks" => action["tasks"].map do |task|
-          {
-            "title" => task["title"],
-            "description" => task["description"],
-            "status" => task["status"] || "todo",
-            "priority" => task["priority"],
-            "tags" => task["tags"],
-            "due_date" => task["due_date"]
-          }
-        end
-      }
-
-      filename = action["filename"] || "#{action["notebook"].downcase.gsub(/\s+/, "_")}_tasks.json"
-      File.write(filename, JSON.pretty_generate(data))
-      say "Generated import JSON file: #{filename}".green
+      # Execute the task list command with the notebook name and any options
+      cli_args = ["task:list", notebook_name] + options_args
+      say "\nRunning CLI with args: #{cli_args.inspect}".blue if options[:verbose]
+      RubyTodo::CLI.start(cli_args)
+    end
 
-      if @prompt.yes?("Do you want to import these tasks now?")
-        import_result = RubyTodo::CLI.new.import(filename)
-        say "Import complete: #{import_result}"
+    def execute_task_list_with_default_notebook(parts)
+      cli_args = ["task:list", Notebook.default_notebook.name]
+      if parts.size > 1 && parts[1].start_with?("--")
+        cli_args << parts[1]
       end
+      say "\nUsing default notebook for task:list with args: #{cli_args.inspect}".blue if options[:verbose]
+      RubyTodo::CLI.start(cli_args)
     end
 
-    def list_tasks(action)
-      unless action["notebook"]
-        say "Missing required field 'notebook' for list_tasks".red
-        return
-      end
+    def execute_task_search_command(cmd_without_prefix)
+      parts = cmd_without_prefix.split(/\s+/, 2) # Split into command and search term
 
-      notebook = Notebook.find_by(name: action["notebook"])
-      unless notebook
-        say "Notebook '#{action["notebook"]}' not found".red
-        return
+      if parts.size >= 2
+        # Pass the entire search term as a single argument, not individual words
+        cli_args = ["task:search", parts[1]]
+        say "\nRunning CLI with args: #{cli_args.inspect}".blue if options[:verbose]
+        RubyTodo::CLI.start(cli_args)
+      else
+        say "\nNo search term provided for task:search command".yellow
       end
+    end
 
-      tasks = notebook.tasks
-      tasks = tasks.where(status: action["status"]) if action["status"]
-      tasks = tasks.where(priority: action["priority"]) if action["priority"]
+    def execute_task_move_command(cmd_without_prefix)
+      parts = cmd_without_prefix.split(/\s+/)
 
-      if tasks.empty?
-        say "No tasks found".yellow
-        return
+      # Need at least task:move NOTEBOOK TASK_ID STATUS
+      if parts.size >= 4
+        notebook_name = parts[1]
+        task_id = parts[2]
+        status = parts[3]
+
+        cli_args = ["task:move", notebook_name, task_id, status]
+        say "\nRunning CLI with args: #{cli_args.inspect}".blue if options[:verbose]
+        RubyTodo::CLI.start(cli_args)
+      else
+        say "\nInvalid task:move command format. Need NOTEBOOK, TASK_ID, and STATUS".yellow
       end
+    end
 
-      display_tasks_table(tasks)
+    def execute_other_command(cmd_without_prefix)
+      # Process all other commands
+      cli_args = cmd_without_prefix.split(/\s+/)
+      say "\nRunning CLI with args: #{cli_args.inspect}".blue if options[:verbose]
+      RubyTodo::CLI.start(cli_args)
     end
 
-    def display_tasks_table(tasks)
-      rows = tasks.map do |t|
-        [
-          t.id,
-          t.title,
-          format_status(t.status),
-          t.priority || "None",
-          t.due_date ? t.due_date.strftime("%Y-%m-%d %H:%M") : "No due date",
-          t.tags || "None"
-        ]
-      end
+    def handle_common_query(prompt)
+      prompt_lower = prompt.downcase
+
+      # Check for different types of common queries
+      return handle_task_creation(prompt, prompt_lower) if task_creation_query?(prompt_lower)
+      return handle_priority_tasks(prompt_lower, "high") if high_priority_query?(prompt_lower)
+      return handle_priority_tasks(prompt_lower, "medium") if medium_priority_query?(prompt_lower)
+      return handle_statistics(prompt_lower) if statistics_query?(prompt_lower)
+      return handle_status_tasks(prompt_lower) if status_tasks_query?(prompt_lower)
+      return handle_notebook_listing(prompt_lower) if notebook_listing_query?(prompt_lower)
+
+      # Not a common query
+      false
+    end
+
+    def task_creation_query?(prompt_lower)
+      (prompt_lower.include?("create") || prompt_lower.include?("add")) &&
+        (prompt_lower.include?("task") || prompt_lower.include?("todo"))
+    end
 
-      table = TTY::Table.new(
-        header: ["ID", "Title", "Status", "Priority", "Due Date", "Tags"],
-        rows: rows
-      )
-      puts table.render(:ascii)
+    def high_priority_query?(prompt_lower)
+      prompt_lower.include?("high priority") ||
+        (prompt_lower.include?("priority") && prompt_lower.include?("high"))
     end
 
-    def search_tasks(action)
-      unless action["query"]
-        say "Missing required field 'query' for search_tasks".red
-        return
+    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? do |name|
+        prompt_lower.include?("#{name} tasks") || prompt_lower.include?("tasks in #{name}")
       end
+    end
 
-      notebooks = if action["notebook"]
-                    [Notebook.find_by(name: action["notebook"])].compact
-                  else
-                    Notebook.all
-                  end
+    def notebook_listing_query?(prompt_lower)
+      prompt_lower.include?("list notebooks") ||
+        prompt_lower.include?("show notebooks") ||
+        prompt_lower.include?("all notebooks")
+    end
+
+    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
 
-      if notebooks.empty?
-        say "No notebooks found".yellow
-        return
+      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
 
-      results = find_matching_tasks(notebooks, action["query"])
+    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"
+      ]
 
-      if results.empty?
-        say "No tasks matching '#{action["query"]}' found".yellow
-        return
+      phrases_to_remove.each do |phrase|
+        potential_title = potential_title.gsub(/#{phrase}/i, " ")
       end
 
-      display_search_results(results)
+      result = potential_title.strip
+      result.empty? ? nil : result
     end
 
-    def find_matching_tasks(notebooks, query)
-      results = []
-      notebooks.each do |notebook|
-        notebook.tasks.each do |task|
-          next unless task.title.downcase.include?(query.downcase) ||
-                      (task.description && task.description.downcase.include?(query.downcase)) ||
-                      (task.tags && task.tags.downcase.include?(query.downcase))
+    def determine_notebook_name(prompt_lower)
+      return nil unless Notebook.default_notebook
+
+      notebook_name = Notebook.default_notebook.name
 
-          results << [notebook.name, task.id, task.title, format_status(task.status)]
+      # 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
-      results
+
+      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 display_search_results(results)
-      table = TTY::Table.new(
-        header: %w[Notebook ID Title Status],
-        rows: results
-      )
-      puts table.render(:ascii)
+    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
 
-    def load_api_key_from_config
-      config_file = File.expand_path("~/.ruby_todo/ai_config.json")
-      return nil unless File.exist?(config_file)
+    def handle_priority_tasks(_prompt_lower, priority)
+      say "\n=== Detecting #{priority} priority task request ===" if options[:verbose]
 
-      config = JSON.parse(File.read(config_file))
-      config["api_key"]
+      return false unless Notebook.default_notebook
+
+      say "\nListing #{priority} priority tasks from default notebook" if options[:verbose]
+      RubyTodo::CLI.start(["task:list", Notebook.default_notebook.name, "--priority", priority])
+
+      # Create a simple explanation
+      say "\nListing all #{priority} priority tasks in the #{Notebook.default_notebook.name} notebook"
+      true
     end
 
-    def save_config(api, api_key)
-      config_dir = File.expand_path("~/.ruby_todo")
-      FileUtils.mkdir_p(config_dir)
+    def handle_statistics(prompt_lower)
+      say "\n=== Detecting statistics request ===" if options[:verbose]
+
+      notebook_name = determine_notebook_name(prompt_lower)
 
-      config_file = File.join(config_dir, "ai_config.json")
-      config = {
-        "api" => api,
-        "api_key" => api_key
-      }
+      if notebook_name
+        say "\nShowing statistics for notebook: #{notebook_name}" if options[:verbose]
+        RubyTodo::CLI.start(["stats", notebook_name])
+        say "\nDisplaying statistics for the #{notebook_name} notebook"
+      else
+        # Show global stats if no default notebook
+        say "\nShowing global statistics" if options[:verbose]
+        RubyTodo::CLI.start(["stats"])
+        say "\nDisplaying global statistics for all notebooks"
+      end
 
-      File.write(config_file, JSON.pretty_generate(config))
-      FileUtils.chmod(0o600, config_file) # Secure the file with private permissions
+      true
     end
 
-    def format_status(status)
-      case status
-      when "todo" then "Todo".yellow
-      when "in_progress" then "In Progress".blue
-      when "done" then "Done".green
-      when "archived" then "Archived".gray
-      else status
+    def handle_status_tasks(prompt_lower)
+      statuses = { "todo" => "todo", "in progress" => "in_progress", "done" => "done", "archived" => "archived" }
+
+      statuses.each do |name, value|
+        next unless prompt_lower.include?("#{name} tasks") || prompt_lower.include?("tasks in #{name}")
+
+        say "\n=== Detecting #{name} task listing request ===" if options[:verbose]
+
+        return false unless Notebook.default_notebook
+
+        say "\nListing #{name} tasks from default notebook" if options[:verbose]
+        RubyTodo::CLI.start(["task:list", Notebook.default_notebook.name, "--status", value])
+
+        # Create a simple explanation
+        say "\nListing all #{name} tasks in the #{Notebook.default_notebook.name} notebook"
+        return true
       end
+
+      false
     end
 
-    def parse_due_date(date_string)
-      Time.parse(date_string)
-    rescue ArgumentError
-      say "Invalid date format. Use YYYY-MM-DD HH:MM format.".red
-      nil
+    def handle_notebook_listing(_prompt_lower)
+      say "\n=== Detecting notebook listing request ===" if options[:verbose]
+      RubyTodo::CLI.start(["notebook:list"])
+
+      # Create a simple explanation
+      say "\nListing all available notebooks"
+      true
     end
   end
 end