ruby_todo 0.4.1 → 1.0.1

data/lib/ruby_todo/ai_assistant/task_management.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module TaskStatusMapping
+    private
+
+    def status_map
+      @status_map ||= {
+        "in_progress" => "in_progress",
+        "in progress" => "in_progress",
+        "inprogress" => "in_progress",
+        "in porgress" => "in_progress", # Common misspelling
+        "in pogress" => "in_progress",  # Another misspelling
+        "in prog" => "in_progress",     # Abbreviation
+        "in-progress" => "in_progress", # With hyphen
+        "n prgrs" => "in_progress",     # Very abbreviated
+        "todo" => "todo",
+        "to do" => "todo",
+        "to-do" => "todo",
+        "done" => "done",
+        "complete" => "done",
+        "completed" => "done",
+        "finish" => "done",
+        "finished" => "done",
+        "archived" => "archived",
+        "arch" => "archived",           # Abbreviation
+        "pending" => "todo"
+      }.freeze
+    end
+
+    def find_status_in_map(potential_status, pattern_name)
+      status_map.each_key do |key|
+        if potential_status.include?(key)
+          say "Found status '#{key}' in #{pattern_name}, mapping to '#{status_map[key]}'" if options[:verbose]
+          return status_map[key]
+        end
+      end
+
+      # If we didn't find a match in the status map, log the attempted matches
+      if options[:verbose]
+        say "No direct status match found in status_map. Attempted matches:"
+        status_map.each_key do |key|
+          say "  - Checking '#{key}' against '#{potential_status}'"
+        end
+      end
+
+      nil
+    end
+
+    def find_status_in_prompt(prompt)
+      # Try exact matches first anywhere in the prompt
+      status_map.each_key do |key|
+        if prompt.include?(key)
+          say "Found status '#{key}' mapping to '#{status_map[key]}'" if options[:verbose]
+          return status_map[key]
+        end
+      end
+      nil
+    end
+  end
+
+  module TaskStatusExtraction
+    include TaskStatusMapping
+
+    def extract_target_status(prompt)
+      prompt = prompt.downcase.strip
+      say "\n=== Extracting Target Status ===" if options[:verbose]
+      say "Looking for status in: '#{prompt}'" if options[:verbose]
+
+      # Try each pattern matcher in sequence
+      status = extract_status_from_related_to_pattern(prompt) ||
+               extract_status_from_set_status_pattern(prompt) ||
+               extract_status_from_to_pattern(prompt) ||
+               extract_status_from_as_pattern(prompt) ||
+               extract_status_from_general_pattern(prompt)
+
+      say "No status found in the prompt" if options[:verbose] && status.nil?
+      status
+    end
+
+    private
+
+    def extract_status_from_related_to_pattern(prompt)
+      return unless prompt =~ /\b(?:related\s+to|about)\b.*\bto\s+([a-z_\s]+)\b/i
+
+      potential_status = Regexp.last_match(1).strip
+      say "Found potential status in 'related to' pattern: '#{potential_status}'" if options[:verbose]
+      say "Full match: #{Regexp.last_match(0)}" if options[:verbose]
+      say "Captured group: #{Regexp.last_match(1)}" if options[:verbose]
+
+      find_status_in_map(potential_status, "'related to' pattern")
+    end
+
+    def extract_status_from_set_status_pattern(prompt)
+      return unless prompt =~ /\bset\s+(?:the\s+)?status\s+of\s+(?:tasks|task).*\bto\s+([a-z_\s]+)\b/i
+
+      potential_status = Regexp.last_match(1).strip
+      say "Found potential status in 'set status of tasks' pattern: '#{potential_status}'" if options[:verbose]
+      say "Full match: #{Regexp.last_match(0)}" if options[:verbose]
+      say "Captured group: #{Regexp.last_match(1)}" if options[:verbose]
+
+      find_status_in_map(potential_status, "'set status of tasks' pattern")
+    end
+
+    def extract_status_from_to_pattern(prompt)
+      return unless prompt =~ /\b(?:to|into|as)\s+([a-z_\s]+)\b/i
+
+      potential_status = Regexp.last_match(1).strip
+      say "Found potential status indicator: '#{potential_status}'" if options[:verbose]
+      say "Full match: #{Regexp.last_match(0)}" if options[:verbose]
+      say "Captured group: #{Regexp.last_match(1)}" if options[:verbose]
+
+      status = find_status_in_map(potential_status, "status indicator")
+      return status if status
+
+      # If we have a potential status but no exact match, try fuzzy matching
+      if potential_status =~ /\bin\s*p|\bn\s*p/i
+        say "Found fuzzy match for 'in_progress' in potential status: '#{potential_status}'" if options[:verbose]
+        return "in_progress"
+      end
+
+      nil
+    end
+
+    def extract_status_from_as_pattern(prompt)
+      return unless prompt =~ /\bas\s+([a-z_\s]+)\b/i
+
+      potential_status = Regexp.last_match(1).strip
+      say "Found 'as X' pattern with potential status: '#{potential_status}'" if options[:verbose]
+
+      find_status_in_map(potential_status, "'as X' pattern")
+    end
+
+    def extract_status_from_general_pattern(prompt)
+      find_status_in_prompt(prompt) ||
+        find_status_from_fuzzy_match(prompt) ||
+        find_status_from_special_chars(prompt) ||
+        find_status_from_final_check(prompt)
+    end
+
+    def find_status_from_fuzzy_match(prompt)
+      # Advanced fuzzy matching for progress with typos
+      if prompt =~ /\bin\s*p[o|r][r|o]?g(?:r?e?s{1,2})\b/i
+        say "Found advanced fuzzy match for 'in_progress'" if options[:verbose]
+        return "in_progress"
+      end
+
+      # Even more flexible matching for progress
+      if prompt =~ /\bn\s*p[r|o]?g|\bin\s*p[r|o]?g|\bn\s*p|\bin\s*p/i
+        say "Found flexible fuzzy match for 'in_progress'" if options[:verbose]
+        return "in_progress"
+      end
+      nil
+    end
+
+    def find_status_from_special_chars(prompt)
+      return nil unless prompt.end_with?(" in", " to", "\"", "'", "\n")
+
+      clean_prompt = prompt.gsub(/["'\n]/, " ").strip
+      say "Cleaned prompt for status detection: '#{clean_prompt}'" if options[:verbose]
+
+      case clean_prompt
+      when /prog|porg|p[o|r]g/i
+        say "Inferring in_progress from context" if options[:verbose]
+        "in_progress"
+      when /\btodo\b|\bto do\b|pending/i
+        say "Inferring todo from context" if options[:verbose]
+        "todo"
+      when /\bdone\b|complete/i
+        say "Inferring done from context" if options[:verbose]
+        "done"
+      end
+    end
+
+    def find_status_from_final_check(prompt)
+      # Final attempt to match "in progress" pattern
+      if prompt =~ /\b(?:to|into|as)\s+(?:in\s+progress|in-progress|inprogress)\b/i
+        say "Found 'in progress' pattern in final check" if options[:verbose]
+        return "in_progress"
+      end
+      nil
+    end
+  end
+
+  module TaskMovementDetection
+    def should_handle_task_movement?(prompt)
+      prompt = prompt.downcase
+      say "\nChecking if should handle task movement for prompt: '#{prompt}'" if options[:verbose]
+
+      result = (prompt.include?("move") && !prompt.include?("task")) ||
+               (prompt.include?("move") && prompt.include?("task")) ||
+               (prompt.include?("change") && prompt.include?("status")) ||
+               (prompt.include?("change") && prompt.include?("to")) ||
+               (prompt.include?("set") && prompt.include?("status")) ||
+               (prompt =~ /\bset\s+(?:the\s+)?status\b/) ||
+               (prompt =~ /\bupdate\s+(?:the\s+)?(?:task|tasks).+\bto\s+\w+\b/) ||
+               (prompt =~ /\bmark\s+(?:all\s+)?(?:the\s+)?(?:task|tasks)?.+\b(?:as|to)\s+\w+\b/)
+
+      say "Should handle task movement: #{result}" if options[:verbose]
+      result
+    end
+  end
+
+  module TaskProcessing
+    def handle_matching_tasks(matching_tasks, context)
+      return unless matching_tasks && !matching_tasks.empty?
+
+      context[:matching_tasks] = matching_tasks
+      return unless options[:verbose]
+
+      say "Found #{matching_tasks.size} matching tasks:".blue
+      matching_tasks.each do |task|
+        say "  - Notebook: #{task[:notebook]}, ID: #{task[:task_id]}, " \
+            "Title: #{task[:title]}, Status: #{task[:status]}".blue
+      end
+    end
+
+    def process_search_term(search_term, prompt, context)
+      say "\nSearching for tasks matching: '#{search_term}'" if options[:verbose]
+      say "Current context: #{context.inspect}" if options[:verbose]
+
+      matching_tasks = pre_search_tasks(search_term, prompt)
+      say "Pre-search returned #{matching_tasks&.size || 0} tasks" if options[:verbose]
+
+      if matching_tasks&.any?
+        process_matching_tasks(matching_tasks, prompt, context, search_term)
+      else
+        say "\nNo tasks found matching: '#{search_term}'".yellow
+        say "Context at failure: #{context.inspect}" if options[:verbose]
+        context[:matching_tasks] = []
+      end
+    end
+
+    def process_matching_tasks(matching_tasks, prompt, context, search_term)
+      target_status = extract_target_status(prompt)
+      say "\nProcessing matching tasks with target status: '#{target_status}'" if options[:verbose]
+
+      if target_status
+        handle_matching_tasks(matching_tasks, context)
+        context[:target_status] = target_status
+        context[:search_term] = search_term
+        say "\nFound #{matching_tasks.size} tasks to move to #{target_status}" if options[:verbose]
+        say "Updated context: #{context.inspect}" if options[:verbose]
+      else
+        say "\nCould not determine target status from prompt".yellow
+        say "Current context: #{context.inspect}" if options[:verbose]
+      end
+    end
+  end
+
+  module TaskStatusUpdate
+    def move_tasks_to_status(tasks, status)
+      if tasks && !tasks.empty?
+        display_tasks_to_move(tasks)
+        move_tasks(tasks, status)
+      else
+        say "\nNo tasks to move".yellow
+      end
+    end
+
+    private
+
+    def display_tasks_to_move(tasks)
+      return unless options[:verbose]
+
+      say "\nMoving tasks:".blue
+      tasks.each do |task|
+        say "  - Task #{task[:task_id]} in notebook #{task[:notebook]}".blue
+      end
+    end
+
+    def move_tasks(tasks, status)
+      tasks.each do |task|
+        move_single_task(task, status)
+      end
+    end
+
+    def move_single_task(task, status)
+      say "\nMoving task #{task[:task_id]} in notebook #{task[:notebook]} to #{status}".blue if options[:verbose]
+
+      notebook = RubyTodo::Notebook.find_by(name: task[:notebook])
+      return say "Notebook '#{task[:notebook]}' not found".red unless notebook
+
+      task_record = notebook.tasks.find_by(id: task[:task_id])
+      return say "Task #{task[:task_id]} not found in notebook '#{task[:notebook]}'".red unless task_record
+
+      if task_record.update(status: status)
+        say "Task #{task[:task_id]} moved to #{status}".green
+      else
+        say "Error moving task #{task[:task_id]}: #{task_record.errors.full_messages.join(", ")}".red
+      end
+    end
+  end
+
+  module TaskManagement
+    include TaskSearch
+    include TaskStatusExtraction
+    include TaskMovementDetection
+    include TaskProcessing
+    include TaskStatusUpdate
+
+    def handle_task_request(prompt, context)
+      say "\nHandling task request for prompt: '#{prompt}'" if options[:verbose]
+
+      return unless should_handle_task_movement?(prompt)
+
+      say "Task movement request confirmed" if options[:verbose]
+
+      search_term = extract_search_term(prompt)
+      say "Extracted search term: '#{search_term}'" if options[:verbose]
+
+      # Extract target status early to ensure we have it
+      target_status = extract_target_status(prompt)
+      say "Early status extraction result: '#{target_status}'" if options[:verbose]
+
+      if search_term
+        process_search_term(search_term, prompt, context)
+
+        # If we have a target status but it wasn't set in context, set it now
+        if target_status && !context[:target_status]
+          say "Setting target status from early extraction: '#{target_status}'" if options[:verbose]
+          context[:target_status] = target_status
+        end
+      end
+    end
+  end
+end

data/lib/ruby_todo/ai_assistant/task_search.rb

@@ -0,0 +1,362 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module TaskSearchPatterns
+    private
+
+    def status_of_pattern
+      @status_of_pattern ||= build_status_pattern
+    end
+
+    def move_pattern
+      @move_pattern ||= build_move_pattern
+    end
+
+    def mark_pattern
+      @mark_pattern ||= /^mark\s+(?:all\s+)?(?:tasks?\s+)?(?:about\s+|related\s+to\s+|concerning\s+)?/i
+    end
+
+    def build_status_pattern
+      pattern_parts = []
+      pattern_parts << "^(?:the\\s+)?"
+      pattern_parts << "status\\s+of\\s+"
+      pattern_parts << "(?:the\\s+)?"
+      pattern_parts << "(?:tasks?\\s+)?"
+      pattern_parts << "(?:about\\s+|related\\s+to\\s+|concerning\\s+)?"
+      Regexp.new(pattern_parts.join, Regexp::IGNORECASE)
+    end
+
+    def build_move_pattern
+      pattern_parts = []
+      pattern_parts << "^(?:move|change|update|set)\\s+"
+      pattern_parts << "(?:the\\s+)?"
+      pattern_parts << "(?:status\\s+of\\s+)?"
+      pattern_parts << "(?:all\\s+)?"
+      pattern_parts << "(?:tasks?\\s+)?"
+      pattern_parts << "(?:about\\s+|related\\s+to\\s+|concerning\\s+)?"
+      Regexp.new(pattern_parts.join, Regexp::IGNORECASE)
+    end
+  end
+
+  module TaskSearchTermCleaner
+    private
+
+    def clean_search_term(search_term)
+      return "*" if search_term.nil? || search_term.strip.empty?
+
+      # Remove common task-related words and patterns
+      cleaned = remove_task_related_words(search_term)
+      cleaned = remove_status_related_words(cleaned)
+      cleaned = remove_action_words(cleaned)
+      cleaned = clean_special_patterns(cleaned)
+
+      cleaned.strip
+    end
+
+    def remove_task_related_words(term)
+      term.gsub(/\b(?:task|tasks|about|related to|concerning)\b/i, "")
+    end
+
+    def remove_status_related_words(term)
+      term.gsub(/\b(?:status|state)\b/i, "")
+    end
+
+    def remove_action_words(term)
+      term.gsub(/\b(?:move|change|update|set|mark)\b/i, "")
+    end
+
+    def clean_special_patterns(term)
+      # Handle "related to X" pattern
+      if term =~ /related\s+to\s+(.+)/i
+        term = Regexp.last_match(1)
+      end
+
+      # Clean up any remaining special characters and extra whitespace
+      term.gsub(/[^\w\s-]/, " ")
+          .gsub(/\s+/, " ")
+          .strip
+    end
+  end
+
+  module TaskSearchMatcher
+    private
+
+    def task_matches_any_term?(task, search_terms)
+      return true if search_terms == ["*"]
+
+      matching_terms = []
+      search_terms.each do |term|
+        next if term.nil? || term.strip.empty?
+
+        term = term.strip.downcase
+        matches = check_task_match(task, term)
+        matching_terms << term if matches
+      end
+
+      handle_compound_query_matches(task, search_terms, matching_terms)
+    end
+
+    def check_task_match(task, term)
+      matches = false
+      matches ||= task[:task_id].to_s == term
+      matches ||= task[:title].downcase.include?(term)
+      matches ||= task[:description]&.downcase&.include?(term)
+      matches ||= task[:tags]&.downcase&.include?(term)
+      matches ||= task[:status].downcase == term
+      matches ||= task[:notebook].downcase.include?(term)
+      matches
+    end
+
+    def handle_compound_query_matches(task, search_terms, matching_terms)
+      return true if matching_terms.any? && search_terms.size == 1
+
+      handle_or_query(task, search_terms, matching_terms) ||
+        handle_and_query(search_terms, matching_terms) ||
+        handle_related_to_query(task, search_terms) ||
+        matching_terms.size == search_terms.size
+    end
+
+    def handle_or_query(task, search_terms, _matching_terms)
+      return false unless or_query?
+
+      matching_terms_for_or = find_matching_terms_for_or(task, search_terms)
+      return false unless matching_terms_for_or.any?
+
+      log_or_query_match(matching_terms_for_or)
+      true
+    end
+
+    def or_query?
+      Thread.current[:original_prompt] &&
+        Thread.current[:original_prompt].downcase =~ /\bor\b/i
+    end
+
+    def find_matching_terms_for_or(task, search_terms)
+      matching_terms = []
+      search_terms.each do |term|
+        if check_task_match(task, term)
+          matching_terms << term
+        elsif options[:verbose]
+          say "    Term '#{term}' does not match in OR compound query"
+        end
+      end
+      matching_terms
+    end
+
+    def log_or_query_match(matching_terms)
+      return unless options[:verbose]
+
+      say "    Found match for OR condition with term(s): " \
+          "#{matching_terms.join(", ")}"
+    end
+
+    def handle_and_query(search_terms, matching_terms)
+      return false unless and_query?
+
+      matching_terms.size == search_terms.size
+    end
+
+    def and_query?
+      Thread.current[:original_prompt] &&
+        Thread.current[:original_prompt].downcase =~ /\band\b/i
+    end
+
+    def handle_related_to_query(task, _search_terms)
+      return false unless related_to_query?
+
+      related_terms = extract_related_terms
+      return false unless related_terms
+
+      matching_terms = find_matching_terms_for_related(task, related_terms)
+      return false unless matching_terms.any?
+
+      log_related_to_match(matching_terms)
+      true
+    end
+
+    def related_to_query?
+      Thread.current[:original_prompt] =~ /related\s+to\s+(.+)/i
+    end
+
+    def extract_related_terms
+      return unless Thread.current[:original_prompt] =~ /related\s+to\s+(.+)/i
+
+      Regexp.last_match(1).split(/\s+or\s+|\s+and\s+/).map(&:strip)
+    end
+
+    def find_matching_terms_for_related(task, related_terms)
+      matching_terms = []
+      related_terms.each do |term|
+        if check_task_match(task, term)
+          matching_terms << term
+        elsif options[:verbose]
+          say "    Term '#{term}' does not match in 'related to' query"
+        end
+      end
+      matching_terms
+    end
+
+    def log_related_to_match(matching_terms)
+      return unless options[:verbose]
+
+      say "    Found match for 'related to' with term(s): " \
+          "#{matching_terms.join(", ")}"
+    end
+  end
+
+  module TaskSearchCore
+    include TaskSearchPatterns
+    include TaskSearchTermCleaner
+    include TaskSearchMatcher
+
+    def pre_search_tasks(search_term, prompt = nil)
+      Thread.current[:original_prompt] = prompt if prompt
+
+      if search_term == "*"
+        say "\nSearching for all tasks" if options[:verbose]
+        return find_all_tasks
+      end
+
+      search_terms = extract_search_terms(search_term)
+      find_tasks_by_search_terms(search_terms)
+    end
+
+    private
+
+    def find_all_tasks
+      tasks = []
+      RubyTodo::Notebook.all.each do |notebook|
+        notebook.tasks.each do |task|
+          tasks << {
+            task_id: task.id,
+            title: task.title,
+            description: task.description,
+            status: task.status,
+            tags: task.tags,
+            notebook: notebook.name
+          }
+        end
+      end
+      tasks
+    end
+
+    def find_tasks_by_search_terms(search_terms)
+      matching_tasks = []
+
+      RubyTodo::Notebook.all.each do |notebook|
+        notebook.tasks.each do |task|
+          task_info = {
+            task_id: task.id,
+            title: task.title,
+            description: task.description,
+            status: task.status,
+            tags: task.tags,
+            notebook: notebook.name
+          }
+
+          if task_matches_any_term?(task_info, search_terms)
+            matching_tasks << task_info
+          end
+        end
+      end
+
+      matching_tasks
+    end
+
+    def extract_search_terms(search_term)
+      return [] if search_term.nil?
+
+      search_term = clean_search_term(search_term)
+
+      # Handle special cases
+      return ["*"] if search_term == "*" || search_term =~ /\ball\b|\bevery\b/i
+
+      # Extract terms from compound queries
+      terms = if search_term =~ /\band\b|\bor\b/i
+                search_term.split(/\s+and\s+|\s+or\s+/).map(&:strip)
+              else
+                [search_term]
+              end
+
+      terms.reject(&:empty?)
+    end
+  end
+
+  module TaskSearch
+    include TaskSearchCore
+
+    def extract_search_term(prompt)
+      prompt = prompt.downcase.strip
+      say "\nExtracting search term from prompt: '#{prompt}'" if options[:verbose]
+
+      # Handle special cases first
+      return "*" if prompt =~ /\b(?:all|every)\s+(?:tasks?|things?)\b/i
+      return "*" if prompt =~ /\bmove\s+(?:all|everything)\b/i
+
+      # Try to extract terms from different patterns
+      extracted_terms = extract_terms_from_patterns(prompt)
+
+      # If no pattern matched, try to extract terms from the remaining text
+      if extracted_terms.nil?
+        extracted_terms = clean_remaining_text(prompt)
+      end
+
+      clean_search_term(extracted_terms)
+    end
+
+    private
+
+    def extract_terms_from_patterns(prompt)
+      extract_related_to_terms(prompt) ||
+        extract_status_terms(prompt) ||
+        extract_move_terms(prompt) ||
+        extract_mark_terms(prompt)
+    end
+
+    def extract_related_to_terms(prompt)
+      return unless prompt =~ /related\s+to\s+(.+?)(?:\s+(?:to|into|as)\s+|$)/i
+
+      terms = Regexp.last_match(1)
+      say "Found 'related to' pattern with terms: '#{terms}'" if options[:verbose]
+      terms
+    end
+
+    def extract_status_terms(prompt)
+      return unless prompt =~ /#{status_of_pattern}(.+?)(?:\s+(?:to|into|as)\s+|$)/i
+
+      terms = Regexp.last_match(1)
+      say "Found status pattern with terms: '#{terms}'" if options[:verbose]
+      terms
+    end
+
+    def extract_move_terms(prompt)
+      # Handle task ID pattern first
+      if prompt =~ /\btask\s+(\d+)\s+in\s+([^"']+?)(?:\s+(?:to|into|as)\s+|$)/i
+        task_id = Regexp.last_match(1)
+        say "Found task ID pattern with ID: '#{task_id}'" if options[:verbose]
+        return task_id
+      end
+
+      # Handle other move patterns
+      return unless prompt =~ /#{move_pattern}(.+?)(?:\s+(?:to|into|as)\s+|$)/i
+
+      terms = Regexp.last_match(1)
+      say "Found move pattern with terms: '#{terms}'" if options[:verbose]
+      terms
+    end
+
+    def extract_mark_terms(prompt)
+      return unless prompt =~ /#{mark_pattern}(.+?)(?:\s+(?:to|into|as)\s+|$)/i
+
+      terms = Regexp.last_match(1)
+      say "Found mark pattern with terms: '#{terms}'" if options[:verbose]
+      terms
+    end
+
+    def clean_remaining_text(prompt)
+      prompt.gsub(/(?:move|change|update|set|mark)\s+(?:to|into|as)\s+\w+/, "")
+            .gsub(/\b(?:status|state)\b/i, "")
+            .strip
+    end
+  end
+end