ruby_todo 1.0.1 → 1.0.4

data/lib/ruby_todo/commands/ai_commands.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module AICommands
+    def ai_ask(*prompt_args)
+      prompt = prompt_args.join(" ")
+      ai_command.ask(prompt, verbose: options[:verbose], api_key: options[:api_key])
+    end
+
+    def ai_configure
+      ai_command.configure
+    end
+
+    private
+
+    def ai_command
+      @ai_command ||= AIAssistantCommand.new
+    end
+  end
+end

data/lib/ruby_todo/commands/notebook_commands.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module NotebookCommands
+    def notebook_create(name)
+      Notebook.create(name: name)
+      puts "Created notebook: #{name}".green
+    end
+
+    def notebook_list
+      notebooks = Notebook.all
+      return say "No notebooks found".yellow if notebooks.empty?
+
+      table = TTY::Table.new(
+        header: ["ID", "Name", "Tasks", "Created At", "Default"],
+        rows: notebooks.map do |notebook|
+          [
+            notebook.id,
+            notebook.name,
+            notebook.tasks.count,
+            notebook.created_at,
+            notebook.is_default? ? "✓" : ""
+          ]
+        end
+      )
+      puts table.render(:ascii)
+    end
+
+    def notebook_set_default(name)
+      notebook = Notebook.find_by(name: name)
+      if notebook
+        notebook.make_default!
+        say "Successfully set '#{name}' as the default notebook".green
+      else
+        say "Notebook '#{name}' not found".red
+      end
+    end
+  end
+end

data/lib/ruby_todo/commands/template_commands.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module TemplateDisplay
+    def display_template_list(templates)
+      if templates.empty?
+        puts "No templates found. Create one with 'ruby_todo template create NAME'"
+        return
+      end
+
+      table = TTY::Table.new(
+        header: ["ID", "Name", "Title Pattern", "Notebook", "Priority", "Due Date Offset"],
+        rows: templates.map do |template|
+          [
+            template.id,
+            template.name,
+            template.title_pattern,
+            template.notebook&.name || "None",
+            template.priority || "None",
+            template.due_date_offset || "None"
+          ]
+        end
+      )
+
+      puts table.render(:unicode, padding: [0, 1])
+    end
+
+    def display_template_details(template)
+      puts "Template Details:"
+      puts "ID: #{template.id}"
+      puts "Name: #{template.name}"
+      puts "Notebook: #{template.notebook&.name || "None"}"
+      puts "Title Pattern: #{template.title_pattern}"
+      puts "Description Pattern: #{template.description_pattern || "None"}"
+      puts "Tags Pattern: #{template.tags_pattern || "None"}"
+      puts "Priority: #{template.priority || "None"}"
+      puts "Due Date Offset: #{template.due_date_offset || "None"}"
+      puts "Created At: #{template.created_at}"
+      puts "Updated At: #{template.updated_at}"
+    end
+  end
+
+  module TemplateCommands
+    include TemplateDisplay
+
+    def template_create(name)
+      notebook = nil
+      if options[:notebook]
+        notebook = RubyTodo::Notebook.find_by(name: options[:notebook])
+        unless notebook
+          puts "Notebook '#{options[:notebook]}' not found."
+          exit 1
+        end
+      end
+
+      template = RubyTodo::Template.new(
+        name: name,
+        notebook: notebook,
+        title_pattern: options[:title],
+        description_pattern: options[:description],
+        tags_pattern: options[:tags],
+        priority: options[:priority],
+        due_date_offset: options[:due]
+      )
+
+      if template.save
+        puts "Template '#{name}' created successfully."
+      else
+        puts "Error creating template: #{template.errors.full_messages.join(", ")}"
+        exit 1
+      end
+    end
+
+    def template_list
+      templates = RubyTodo::Template.all
+      display_template_list(templates)
+    end
+
+    def template_show(name)
+      template = RubyTodo::Template.find_by(name: name)
+
+      unless template
+        puts "Template '#{name}' not found."
+        exit 1
+      end
+
+      display_template_details(template)
+    end
+
+    def template_delete(name)
+      template = RubyTodo::Template.find_by(name: name)
+
+      unless template
+        puts "Template '#{name}' not found."
+        exit 1
+      end
+
+      if template.destroy
+        puts "Template '#{name}' deleted successfully."
+      else
+        puts "Error deleting template: #{template.errors.full_messages.join(", ")}"
+        exit 1
+      end
+    end
+
+    def template_use(name, notebook_name)
+      template = RubyTodo::Template.find_by(name: name)
+
+      unless template
+        puts "Template '#{name}' not found."
+        exit 1
+      end
+
+      notebook = RubyTodo::Notebook.find_by(name: notebook_name)
+
+      unless notebook
+        puts "Notebook '#{notebook_name}' not found."
+        exit 1
+      end
+
+      replacements = {}
+      if options[:replacements]
+        options[:replacements].split(",").each do |r|
+          key, value = r.split(":")
+          replacements[key] = value if key && value
+        end
+      end
+
+      task = template.create_task(notebook, replacements)
+
+      if task.persisted?
+        puts "Task created successfully with ID: #{task.id}"
+      else
+        puts "Error creating task: #{task.errors.full_messages.join(", ")}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/ruby_todo/concerns/import_export.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module CsvExport
+    private
+
+    def export_multiple_notebooks_to_csv(data, csv)
+      csv << ["Notebook", "Task ID", "Title", "Description", "Status", "Priority", "Tags", "Due Date",
+              "Created At", "Updated At"]
+
+      data["notebooks"].each do |notebook|
+        notebook_name = notebook["name"]
+        notebook["tasks"].each_with_index do |task, index|
+          csv << [
+            notebook_name,
+            index + 1,
+            task["title"],
+            task["description"],
+            task["status"],
+            task["priority"],
+            task["tags"],
+            task["due_date"],
+            task["created_at"],
+            task["updated_at"]
+          ]
+        end
+      end
+    end
+
+    def export_single_notebook_to_csv(data, csv)
+      csv << ["Task ID", "Title", "Description", "Status", "Priority", "Tags", "Due Date", "Created At",
+              "Updated At"]
+
+      data["tasks"].each_with_index do |task, index|
+        csv << [
+          index + 1,
+          task["title"],
+          task["description"],
+          task["status"],
+          task["priority"],
+          task["tags"],
+          task["due_date"],
+          task["created_at"],
+          task["updated_at"]
+        ]
+      end
+    end
+  end
+
+  module ImportExport
+    include CsvExport
+
+    def export_notebook(notebook)
+      {
+        "name" => notebook.name,
+        "created_at" => notebook.created_at,
+        "updated_at" => notebook.updated_at,
+        "tasks" => notebook.tasks.map { |task| task_to_hash(task) }
+      }
+    end
+
+    def export_all_notebooks(notebooks)
+      {
+        "notebooks" => notebooks.map { |notebook| export_notebook(notebook) }
+      }
+    end
+
+    def task_to_hash(task)
+      {
+        "title" => task.title,
+        "description" => task.description,
+        "status" => task.status,
+        "priority" => task.priority,
+        "tags" => task.tags,
+        "due_date" => task.due_date&.iso8601,
+        "created_at" => task.created_at&.iso8601,
+        "updated_at" => task.updated_at&.iso8601
+      }
+    end
+
+    def export_to_json(data, filename)
+      File.write(filename, JSON.pretty_generate(data))
+    end
+
+    def export_to_csv(data, filename)
+      CSV.open(filename, "wb") do |csv|
+        if data["notebooks"]
+          export_multiple_notebooks_to_csv(data, csv)
+        else
+          export_single_notebook_to_csv(data, csv)
+        end
+      end
+    end
+
+    def import_tasks(notebook, tasks_data)
+      count = 0
+
+      tasks_data.each do |task_data|
+        due_date = Time.parse(task_data["due_date"]) if task_data["due_date"]
+
+        task = Task.create(
+          notebook: notebook,
+          title: task_data["title"],
+          description: task_data["description"],
+          status: task_data["status"] || "todo",
+          priority: task_data["priority"],
+          tags: task_data["tags"],
+          due_date: due_date
+        )
+
+        count += 1 if task.persisted?
+      end
+
+      count
+    end
+
+    def import_all_notebooks(data)
+      results = { notebooks: 0, tasks: 0 }
+
+      data["notebooks"].each do |notebook_data|
+        notebook_name = notebook_data["name"]
+        notebook = Notebook.find_by(name: notebook_name)
+
+        unless notebook
+          notebook = Notebook.create(name: notebook_name)
+          results[:notebooks] += 1 if notebook.persisted?
+        end
+
+        if notebook.persisted?
+          tasks_count = import_tasks(notebook, notebook_data["tasks"])
+          results[:tasks] += tasks_count
+        end
+      end
+
+      results
+    end
+  end
+end

data/lib/ruby_todo/concerns/statistics.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module StatisticsDisplay
+    private
+
+    def display_priority_distribution(tasks)
+      return if tasks.empty?
+
+      total = tasks.count
+      high_count = tasks.where(priority: "high").count
+      medium_count = tasks.where(priority: "medium").count
+      low_count = tasks.where(priority: "low").count
+
+      puts "\nPriority Distribution:"
+      puts "High: #{high_count} (#{percentage(high_count, total)}%)"
+      puts "Medium: #{medium_count} (#{percentage(medium_count, total)}%)"
+      puts "Low: #{low_count} (#{percentage(low_count, total)}%)"
+    end
+
+    def display_tag_distribution(tasks)
+      return if tasks.empty?
+
+      puts "\nTop Tags:"
+      tag_counts = Hash.new(0)
+      tasks.each do |task|
+        task.tags.split(",").each { |tag| tag_counts[tag.strip] += 1 } if task.tags
+      end
+
+      tag_counts.sort_by { |_, count| -count }.first(5).each do |tag, count|
+        puts "#{tag}: #{count} tasks (#{percentage(count, tasks.count)}%)"
+      end
+    end
+
+    def display_overdue_tasks(tasks)
+      return if tasks.empty?
+
+      overdue_count = tasks.select(&:overdue?).count
+      due_soon_count = tasks.select(&:due_soon?).count
+      total = tasks.count
+
+      puts "\nDue Date Status:"
+      puts "Overdue: #{overdue_count} (#{percentage(overdue_count, total)}%)"
+      puts "Due Soon: #{due_soon_count} (#{percentage(due_soon_count, total)}%)"
+    end
+  end
+
+  module Statistics
+    include StatisticsDisplay
+
+    def display_notebook_stats(notebook)
+      total_tasks = notebook.tasks.count
+      return puts "No tasks found in notebook '#{notebook.name}'" if total_tasks.zero?
+
+      todo_count = notebook.tasks.where(status: "todo").count
+      in_progress_count = notebook.tasks.where(status: "in_progress").count
+      done_count = notebook.tasks.where(status: "done").count
+      archived_count = notebook.tasks.where(status: "archived").count
+
+      puts "\nStatistics for notebook '#{notebook.name}':"
+      puts "Total tasks: #{total_tasks}"
+      puts "Todo: #{todo_count} (#{percentage(todo_count, total_tasks)}%)"
+      puts "In Progress: #{in_progress_count} (#{percentage(in_progress_count, total_tasks)}%)"
+      puts "Done: #{done_count} (#{percentage(done_count, total_tasks)}%)"
+      puts "Archived: #{archived_count} (#{percentage(archived_count, total_tasks)}%)"
+
+      display_priority_distribution(notebook.tasks)
+      display_tag_distribution(notebook.tasks)
+      display_overdue_tasks(notebook.tasks)
+    end
+
+    def display_global_stats
+      total_tasks = Task.count
+      return puts "No tasks found in any notebook" if total_tasks.zero?
+
+      display_global_stats_summary
+    end
+
+    def display_top_notebooks
+      puts "\nNotebook Statistics:"
+      notebook_stats = collect_notebook_stats
+      display_notebook_stats_table(notebook_stats)
+    end
+
+    private
+
+    def percentage(count, total)
+      return 0 if total.zero?
+
+      ((count.to_f / total) * 100).round(1)
+    end
+
+    def display_global_stats_summary
+      total_tasks = Task.count
+      todo_count = Task.where(status: "todo").count
+      in_progress_count = Task.where(status: "in_progress").count
+      done_count = Task.where(status: "done").count
+      archived_count = Task.where(status: "archived").count
+
+      puts "\nGlobal Statistics:"
+      puts "Total tasks across all notebooks: #{total_tasks}"
+      puts "Todo: #{todo_count} (#{percentage(todo_count, total_tasks)}%)"
+      puts "In Progress: #{in_progress_count} (#{percentage(in_progress_count, total_tasks)}%)"
+      puts "Done: #{done_count} (#{percentage(done_count, total_tasks)}%)"
+      puts "Archived: #{archived_count} (#{percentage(archived_count, total_tasks)}%)"
+
+      display_priority_distribution(Task.all)
+      display_tag_distribution(Task.all)
+      display_overdue_tasks(Task.all)
+      display_top_notebooks
+    end
+
+    def collect_notebook_stats
+      notebook_data = Notebook.all.map do |notebook|
+        calculate_notebook_stats(notebook)
+      end
+      notebook_data.sort_by! { |data| -data[1] }
+    end
+
+    def calculate_notebook_stats(notebook)
+      task_count = notebook.tasks.count
+      todo_count = notebook.tasks.where(status: "todo").count
+      in_progress_count = notebook.tasks.where(status: "in_progress").count
+      done_count = notebook.tasks.where(status: "done").count
+      archived_count = notebook.tasks.where(status: "archived").count
+
+      [
+        notebook.name,
+        task_count,
+        todo_count,
+        in_progress_count,
+        done_count,
+        archived_count
+      ]
+    end
+
+    def display_notebook_stats_table(notebook_stats)
+      headers = ["Notebook", "Total", "Todo", "In Progress", "Done", "Archived"]
+      rows = create_table_rows(notebook_stats)
+      render_stats_table(headers, rows)
+    end
+
+    def create_table_rows(notebook_stats)
+      notebook_stats.map do |stats|
+        name, total, todo, in_progress, done, archived = stats
+        [
+          name,
+          total.to_s,
+          "#{todo} (#{percentage(todo, total)}%)",
+          "#{in_progress} (#{percentage(in_progress, total)}%)",
+          "#{done} (#{percentage(done, total)}%)",
+          "#{archived} (#{percentage(archived, total)}%)"
+        ]
+      end
+    end
+
+    def render_stats_table(headers, rows)
+      table = TTY::Table.new(header: headers, rows: rows)
+      puts table.render(:ascii, padding: [0, 1], width: TTY::Screen.width || 80)
+    rescue NoMethodError
+      # Fallback for non-TTY environments (like tests)
+      puts headers.join("\t")
+      rows.each { |row| puts row.join("\t") }
+    end
+  end
+end

data/lib/ruby_todo/concerns/task_filters.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module TaskFilters
+    def apply_filters(tasks)
+      tasks = apply_status_filter(tasks)
+      tasks = apply_priority_filter(tasks)
+      tasks = apply_tag_filter(tasks)
+      apply_due_date_filters(tasks)
+    end
+
+    private
+
+    def apply_status_filter(tasks)
+      return tasks unless options[:status]
+
+      tasks.where(status: options[:status])
+    end
+
+    def apply_priority_filter(tasks)
+      return tasks unless options[:priority]
+
+      tasks.where(priority: options[:priority])
+    end
+
+    def apply_tag_filter(tasks)
+      return tasks unless options[:tags]
+
+      tag_filters = options[:tags].split(",").map(&:strip)
+      tasks.select { |t| t.tags && tag_filters.any? { |tag| t.tags.include?(tag) } }
+    end
+
+    def apply_due_date_filters(tasks)
+      tasks = tasks.select(&:due_soon?) if options[:due_soon]
+      tasks = tasks.select(&:overdue?) if options[:overdue]
+      tasks
+    end
+  end
+end

data/lib/ruby_todo/formatters/display_formatter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RubyTodo
+  module DisplayFormatter
+    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
+      end
+    end
+
+    def format_priority(priority)
+      return nil unless priority
+
+      case priority.downcase
+      when "high" then "High".red
+      when "medium" then "Medium".yellow
+      when "low" then "Low".green
+      else priority
+      end
+    end
+
+    def format_due_date(due_date)
+      return "No due date" unless due_date
+
+      if due_date < Time.now && due_date > Time.now - 24 * 60 * 60
+        "Today #{due_date.strftime("%H:%M")}".red
+      elsif due_date < Time.now
+        "Overdue #{due_date.strftime("%Y-%m-%d %H:%M")}".red
+      elsif due_date < Time.now + 24 * 60 * 60
+        "Today #{due_date.strftime("%H:%M")}".yellow
+      else
+        due_date.strftime("%Y-%m-%d %H:%M")
+      end
+    end
+
+    def truncate_text(text, length = 30)
+      return nil unless text
+
+      text.length > length ? "#{text[0...length]}..." : text
+    end
+
+    def display_tasks(tasks)
+      if ENV["RUBY_TODO_TEST"]
+        display_tasks_simple_format(tasks)
+      else
+        display_tasks_table_format(tasks)
+      end
+    end
+
+    private
+
+    def display_tasks_simple_format(tasks)
+      tasks.each do |t|
+        puts "#{t.id}: #{t.title} (#{t.status})"
+      end
+    end
+
+    def display_tasks_table_format(tasks)
+      table = TTY::Table.new(
+        header: ["ID", "Title", "Status", "Priority", "Due Date", "Tags", "Description"],
+        rows: tasks.map do |t|
+          [
+            t.id,
+            t.title,
+            format_status(t.status),
+            format_priority(t.priority),
+            format_due_date(t.due_date),
+            truncate_text(t.tags, 15),
+            truncate_text(t.description, 30)
+          ]
+        end
+      )
+      puts table.render(:ascii)
+    end
+  end
+end

data/lib/ruby_todo/models/task.rb

@@ -13,7 +13,6 @@ module RubyTodo
     validate :due_date_cannot_be_in_past, if: :due_date?
     validate :tags_format, if: :tags?
 
-    before_save :archive_completed_tasks
     before_save :format_tags
 
     scope :todo, -> { where(status: "todo") }
@@ -50,12 +49,6 @@ module RubyTodo
 
     private
 
-    def archive_completed_tasks
-      return unless status_changed? && status == "done"
-
-      self.status = "archived"
-    end
-
     def due_date_cannot_be_in_past
       return unless due_date.present? && due_date < Time.current && new_record?
 

data/lib/ruby_todo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyTodo
-  VERSION = "1.0.1"
+  VERSION = "1.0.4"
 end

data/lib/ruby_todo.rb

@@ -5,6 +5,15 @@ require_relative "ruby_todo/database"
 require_relative "ruby_todo/models/notebook"
 require_relative "ruby_todo/models/task"
 require_relative "ruby_todo/models/template"
+require_relative "ruby_todo/formatters/display_formatter"
+require_relative "ruby_todo/concerns/statistics"
+require_relative "ruby_todo/concerns/task_filters"
+require_relative "ruby_todo/concerns/import_export"
+require_relative "ruby_todo/commands/notebook_commands"
+require_relative "ruby_todo/commands/template_commands"
+require_relative "ruby_todo/commands/ai_commands"
+require_relative "ruby_todo/commands/ai_assistant"
+require_relative "ruby_todo/ai_assistant/openai_integration"
 require_relative "ruby_todo/cli"
 
 module RubyTodo