kodo-bot 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4c50c7a3b926a9094c06ddd7615226ddfd187f0c385e0435b34a066e7618cc0
-  data.tar.gz: d4a4535bab02df618af02330b3a0bdf8521ece8c022e96f019da0bff65ea20c4
+  metadata.gz: 28db2b743e15b691e4c20712a38e822add6c2e559edf75780a9a82887695dfee
+  data.tar.gz: ddc6dc895a4b102506c2a68f5d497053dba8c6bf34ea09150ba47d25e3c8eab8
 SHA512:
-  metadata.gz: 7f7a3f02b91efd833009737cf3858d91dfa0dad9018dc38cd704fa91d7a064cc4d8960928de41d16a4e31be64a721deeed3c44bd71c6a643a8ff282bed1d4923
-  data.tar.gz: 1bdcdddfe5afa5960fbf6ec77e766e4e3b0c2f326ca29df9d2e9a0078c90173f42e18835b1879101a32ac979ff2f9867158787859d92759e0a00e3fdc3facf1d
+  metadata.gz: f475e0f066e08ae275093769a245a1a8e2d88147a8a0aa76985968365fd84cb12d530cfdee3c5afb69ca177f56d24437a725fe9ce4b451a3b61778c183d2745f
+  data.tar.gz: 703e9236a4338a9441e28aadb0d00ce2ab43e9f689fa79ff7fea63578e852c4682bd3ac4384706ae4f01d3acc376a1638791032def2f6d185b5cb2d2e4d53410

data/bin/kodo

@@ -6,25 +6,27 @@ require_relative "../lib/kodo"
 module Kodo
   class CLI
     COMMANDS = {
-      "start"    => "Start the Kodo daemon",
-      "chat"     => "Chat with Kodo directly in the terminal",
-      "memories" => "List what Kodo remembers about you",
-      "status"   => "Show daemon status",
-      "version"  => "Show version",
-      "init"     => "Create default config and prompt files in ~/.kodo/",
-      "help"     => "Show this help"
+      "start"     => "Start the Kodo daemon",
+      "chat"      => "Chat with Kodo directly in the terminal",
+      "memories"  => "List what Kodo remembers about you",
+      "reminders" => "List active reminders",
+      "status"    => "Show daemon status",
+      "version"   => "Show version",
+      "init"      => "Create default config and prompt files in ~/.kodo/",
+      "help"      => "Show this help"
     }.freeze
 
     def run(args = ARGV)
       command = args.first || "help"
 
       case command
-      when "start"    then start(args)
-      when "chat"     then chat
-      when "memories" then memories
-      when "init"     then init
-      when "version"  then puts "kodo v#{VERSION}"
-      when "status"   then status
+      when "start"     then start(args)
+      when "chat"      then chat
+      when "memories"  then memories
+      when "reminders" then reminders
+      when "init"      then init
+      when "version"   then puts "kodo v#{VERSION}"
+      when "status"    then status
       else help
       end
     end
@@ -61,7 +63,14 @@ module Kodo
       memory = Memory::Store.new(passphrase: passphrase)
       audit = Memory::Audit.new
       knowledge = Memory::Knowledge.new(passphrase: passphrase)
-      router = Router.new(memory: memory, audit: audit, prompt_assembler: assembler, knowledge: knowledge)
+      reminder_store = Memory::Reminders.new(passphrase: passphrase)
+      router = Router.new(
+        memory: memory,
+        audit: audit,
+        prompt_assembler: assembler,
+        knowledge: knowledge,
+        reminders: reminder_store
+      )
       console = Channels::Console.new
       console.connect!
 
@@ -77,7 +86,7 @@ module Kodo
           metadata: { chat_id: "console" }
         )
 
-        response = router.route(message, channel: console)
+        response = with_spinner { router.route(message, channel: console) }
         console.send_message(response)
       end
     rescue Interrupt
@@ -113,6 +122,27 @@ module Kodo
       end
     end
 
+    def reminders
+      Config.ensure_home_dir!
+      passphrase = Kodo.config.memory_encryption? ? Kodo.config.memory_passphrase : nil
+      reminder_store = Memory::Reminders.new(passphrase: passphrase)
+
+      active = reminder_store.all_active.sort_by { |r| r["due_at"] }
+      if active.empty?
+        puts "No active reminders."
+        return
+      end
+
+      puts "Active reminders (#{active.length}):"
+      puts ""
+
+      active.each do |r|
+        puts "  - #{r['content']}"
+        puts "    due: #{r['due_at']}  id: #{r['id']}"
+      end
+      puts ""
+    end
+
     def init
       Config.ensure_home_dir!
       PromptAssembler.new.ensure_default_files!
@@ -170,6 +200,25 @@ module Kodo
       puts "   Telegram: #{ENV["TELEGRAM_BOT_TOKEN"] ? "✅ set" : "❌ TELEGRAM_BOT_TOKEN missing"}"
     end
 
+    def with_spinner
+      frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+      done = false
+      spinner = Thread.new do
+        i = 0
+        while !done
+          print "\r\e[36m#{frames[i % frames.length]} thinking...\e[0m"
+          i += 1
+          sleep 0.1
+        end
+        print "\r\e[K"
+      end
+
+      result = yield
+      done = true
+      spinner.join
+      result
+    end
+
     def help
       puts "🥁 Kodo v#{VERSION} — your personal AI agent"
       puts ""

data/lib/kodo/config.rb

@@ -69,6 +69,7 @@ module Kodo
           Kodo.home_dir,
           File.join(Kodo.home_dir, "memory", "conversations"),
           File.join(Kodo.home_dir, "memory", "knowledge"),
+          File.join(Kodo.home_dir, "memory", "reminders"),
           File.join(Kodo.home_dir, "memory", "audit"),
           File.join(Kodo.home_dir, "skills")
         ]

data/lib/kodo/daemon.rb

@@ -12,12 +12,14 @@ module Kodo
       @memory = Memory::Store.new(passphrase: passphrase)
       @audit = Memory::Audit.new
       @knowledge = Memory::Knowledge.new(passphrase: passphrase)
+      @reminders = Memory::Reminders.new(passphrase: passphrase)
       @prompt_assembler = PromptAssembler.new
       @router = Router.new(
         memory: @memory,
         audit: @audit,
         prompt_assembler: @prompt_assembler,
-        knowledge: @knowledge
+        knowledge: @knowledge,
+        reminders: @reminders
       )
       @channels = []
     end
@@ -43,6 +45,7 @@ module Kodo
       end
 
       Kodo.logger.info("   Knowledge facts: #{@knowledge.count}")
+      Kodo.logger.info("   Active reminders: #{@reminders.active_count}")
 
       start_heartbeat!
     end
@@ -90,6 +93,7 @@ module Kodo
         channels: @channels,
         router: @router,
         audit: @audit,
+        reminders: @reminders,
         interval: @heartbeat_interval
       )
 

data/lib/kodo/heartbeat.rb

@@ -2,10 +2,11 @@
 
 module Kodo
   class Heartbeat
-    def initialize(channels:, router:, audit:, interval: 60)
+    def initialize(channels:, router:, audit:, reminders: nil, interval: 60)
       @channels = channels
       @router = router
       @audit = audit
+      @reminders = reminders
       @interval = interval
       @running = false
       @beat_count = 0
@@ -48,8 +49,8 @@ module Kodo
         process_message(message, channel)
       end
 
-      # Phase 3: Schedule — check cron-like pulses (future)
-      # TODO: scheduled tasks
+      # Phase 3: Reminders — deliver any due reminders
+      deliver_due_reminders!
 
     rescue StandardError => e
       Kodo.logger.error("Heartbeat error: #{e.message}")
@@ -75,6 +76,39 @@ module Kodo
       messages
     end
 
+    def deliver_due_reminders!
+      return unless @reminders
+
+      @reminders.due_reminders.each do |reminder|
+        channel = find_channel(reminder["channel_id"])
+        next unless channel
+
+        message = Message.new(
+          channel_id: reminder["channel_id"],
+          sender: :agent,
+          content: "Reminder: #{reminder['content']}",
+          metadata: { chat_id: reminder["chat_id"] }
+        )
+
+        channel.send_message(message)
+        @reminders.fire!(reminder["id"])
+
+        @audit.log(
+          event: "reminder_fired",
+          channel: reminder["channel_id"],
+          detail: "id:#{reminder['id']} content:#{reminder['content']&.slice(0, 60)}"
+        )
+
+        Kodo.logger.info("Fired reminder: #{reminder['content']&.slice(0, 60)}")
+      rescue StandardError => e
+        Kodo.logger.error("Error firing reminder #{reminder['id']}: #{e.message}")
+      end
+    end
+
+    def find_channel(channel_id)
+      @channels.find { |c| c.channel_id == channel_id && c.running? }
+    end
+
     def process_message(message, channel)
       Kodo.logger.info("Processing: [#{channel.channel_id}] #{message.content.slice(0, 60)}...")
 

data/lib/kodo/llm.rb

@@ -18,6 +18,9 @@ module Kodo
           end
         end
 
+        # Refresh model registry so newly released models are recognized
+        RubyLLM.models.refresh!
+
         Kodo.logger.info("LLM configured: #{config.llm_model}")
       end
 

data/lib/kodo/memory/reminders.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "fileutils"
+
+module Kodo
+  module Memory
+    class Reminders
+      MAX_ACTIVE = 50
+      MAX_CONTENT_LENGTH = 500
+
+      def initialize(passphrase: nil)
+        @reminders_dir = File.join(Kodo.home_dir, "memory", "reminders")
+        @passphrase = passphrase
+        FileUtils.mkdir_p(@reminders_dir)
+        @reminders = load_reminders
+      end
+
+      def add(content:, due_at:, channel_id: nil, chat_id: nil)
+        if active_count >= MAX_ACTIVE
+          raise Kodo::Error, "Too many active reminders (max #{MAX_ACTIVE}). Dismiss some first."
+        end
+
+        now = Time.now.iso8601
+        reminder = {
+          "id" => SecureRandom.uuid,
+          "content" => content,
+          "due_at" => due_at.is_a?(Time) ? due_at.iso8601 : due_at,
+          "channel_id" => channel_id,
+          "chat_id" => chat_id,
+          "status" => "active",
+          "created_at" => now
+        }
+
+        @reminders << reminder
+        save_reminders
+        reminder
+      end
+
+      def dismiss(id)
+        reminder = @reminders.find { |r| r["id"] == id && r["status"] == "active" }
+        return nil unless reminder
+
+        reminder["status"] = "dismissed"
+        save_reminders
+        reminder
+      end
+
+      def fire!(id)
+        reminder = @reminders.find { |r| r["id"] == id && r["status"] == "active" }
+        return nil unless reminder
+
+        reminder["status"] = "fired"
+        save_reminders
+        reminder
+      end
+
+      def due_reminders
+        now = Time.now
+        all_active.select { |r| Time.parse(r["due_at"]) <= now }
+      end
+
+      def all_active
+        @reminders.select { |r| r["status"] == "active" }
+      end
+
+      def active_count
+        all_active.length
+      end
+
+      private
+
+      def reminders_path
+        File.join(@reminders_dir, "reminders.jsonl")
+      end
+
+      def load_reminders
+        path = reminders_path
+        return [] unless File.exist?(path)
+
+        raw = File.binread(path)
+
+        if Encryption.encrypted?(raw)
+          raise Kodo::Error, "Encrypted reminders file but no passphrase provided" unless @passphrase
+          raw = Encryption.decrypt(raw, key: @passphrase)
+        end
+
+        raw.each_line.filter_map do |line|
+          line = line.strip
+          next if line.empty?
+          JSON.parse(line)
+        end
+      rescue JSON::ParserError => e
+        Kodo.logger.warn("Corrupt reminders file #{path}: #{e.message}")
+        []
+      end
+
+      def save_reminders
+        path = reminders_path
+        jsonl = @reminders.map { |r| JSON.generate(r) }.join("\n") + "\n"
+
+        if @passphrase
+          File.binwrite(path, Encryption.encrypt(jsonl, key: @passphrase))
+        else
+          File.write(path, jsonl)
+        end
+      end
+    end
+  end
+end

data/lib/kodo/router.rb

@@ -2,11 +2,12 @@
 
 module Kodo
   class Router
-    def initialize(memory:, audit:, prompt_assembler: nil, knowledge: nil)
+    def initialize(memory:, audit:, prompt_assembler: nil, knowledge: nil, reminders: nil)
       @memory = memory
       @audit = audit
       @prompt_assembler = prompt_assembler || PromptAssembler.new
       @knowledge = knowledge
+      @reminders = reminders
       @tools = build_tools
     end
 
@@ -14,6 +15,9 @@ module Kodo
     def route(message, channel:)
       chat_id = message.metadata[:chat_id] || message.metadata["chat_id"]
 
+      # Set channel context on SetReminder so it knows where to deliver
+      set_reminder_context(channel.channel_id, chat_id)
+
       # Store the user's message
       @memory.append(chat_id, role: "user", content: message.content)
 
@@ -37,7 +41,7 @@ module Kodo
       chat = LLM.chat
       chat.with_instructions(system_prompt)
 
-      # Register tools if knowledge store is available
+      # Register tools with the LLM chat
       if @tools.any?
         reset_tool_rate_limits!
         chat.with_tools(*@tools)
@@ -75,12 +79,27 @@ module Kodo
     private
 
     def build_tools
-      return [] unless @knowledge
+      tools = []
+
+      # Always available
+      tools << Tools::GetCurrentTime.new(audit: @audit)
+
+      # Knowledge tools (require knowledge store)
+      if @knowledge
+        tools << Tools::RememberFact.new(knowledge: @knowledge, audit: @audit)
+        tools << Tools::ForgetFact.new(knowledge: @knowledge, audit: @audit)
+        tools << Tools::RecallFacts.new(knowledge: @knowledge, audit: @audit)
+        tools << Tools::UpdateFact.new(knowledge: @knowledge, audit: @audit)
+      end
+
+      # Reminder tools (require reminders store)
+      if @reminders
+        tools << Tools::SetReminder.new(reminders: @reminders, audit: @audit)
+        tools << Tools::ListReminders.new(reminders: @reminders, audit: @audit)
+        tools << Tools::DismissReminder.new(reminders: @reminders, audit: @audit)
+      end
 
-      [
-        Tools::RememberFact.new(knowledge: @knowledge, audit: @audit),
-        Tools::ForgetFact.new(knowledge: @knowledge, audit: @audit)
-      ]
+      tools
     end
 
     def reset_tool_rate_limits!
@@ -88,5 +107,14 @@ module Kodo
         tool.reset_turn_count! if tool.respond_to?(:reset_turn_count!)
       end
     end
+
+    def set_reminder_context(channel_id, chat_id)
+      @tools.each do |tool|
+        if tool.is_a?(Tools::SetReminder)
+          tool.channel_id = channel_id
+          tool.chat_id = chat_id
+        end
+      end
+    end
   end
 end

data/lib/kodo/tools/dismiss_reminder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Kodo
+  module Tools
+    class DismissReminder < RubyLLM::Tool
+      description "Dismiss (cancel) an active reminder by its ID."
+
+      param :id, desc: "The UUID of the reminder to dismiss"
+
+      def initialize(reminders:, audit:)
+        super()
+        @reminders = reminders
+        @audit = audit
+      end
+
+      def execute(id:)
+        reminder = @reminders.dismiss(id)
+
+        if reminder
+          @audit.log(
+            event: "reminder_dismissed",
+            detail: "id:#{id} content:#{reminder['content']&.slice(0, 60)}"
+          )
+          "Dismissed reminder: #{reminder['content']}"
+        else
+          "No active reminder found with id: #{id}"
+        end
+      end
+
+      def name
+        "dismiss_reminder"
+      end
+    end
+  end
+end

data/lib/kodo/tools/get_current_time.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Kodo
+  module Tools
+    class GetCurrentTime < RubyLLM::Tool
+      description "Get the current date and time. Use this when you need to know what time it is, " \
+                  "what day of the week it is, or make time-relative decisions."
+
+      def initialize(audit:)
+        super()
+        @audit = audit
+      end
+
+      def execute
+        now = Time.now
+        day_name = now.strftime("%A")
+        date_str = now.strftime("%Y-%m-%d")
+        time_str = now.strftime("%H:%M:%S %Z")
+        period = time_period(now.hour)
+
+        @audit.log(event: "tool_get_current_time", detail: "#{date_str} #{time_str}")
+
+        "#{day_name}, #{date_str} #{time_str} (#{period})"
+      end
+
+      def name
+        "get_current_time"
+      end
+
+      private
+
+      def time_period(hour)
+        case hour
+        when 5..11 then "morning"
+        when 12..16 then "afternoon"
+        when 17..20 then "evening"
+        else "night"
+        end
+      end
+    end
+  end
+end

data/lib/kodo/tools/list_reminders.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Kodo
+  module Tools
+    class ListReminders < RubyLLM::Tool
+      description "List all active reminders, sorted by due time."
+
+      def initialize(reminders:, audit:)
+        super()
+        @reminders = reminders
+        @audit = audit
+      end
+
+      def execute
+        active = @reminders.all_active.sort_by { |r| r["due_at"] }
+
+        @audit.log(event: "tool_list_reminders", detail: "count:#{active.length}")
+
+        if active.empty?
+          "No active reminders."
+        else
+          lines = active.map do |r|
+            "- [#{r['due_at']}] #{r['content']} (id: #{r['id']})"
+          end
+          "#{active.length} active reminder(s):\n#{lines.join("\n")}"
+        end
+      end
+
+      def name
+        "list_reminders"
+      end
+    end
+  end
+end

data/lib/kodo/tools/recall_facts.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Kodo
+  module Tools
+    class RecallFacts < RubyLLM::Tool
+      description "Search your knowledge store for facts about the user. " \
+                  "Use this when you need to look up specific information, especially " \
+                  "if the knowledge was truncated in your system prompt."
+
+      param :query, desc: "Keyword to search for in fact content (case-insensitive)", required: false
+      param :category, desc: "Filter by category: preference, fact, instruction, or context", required: false
+
+      def initialize(knowledge:, audit:)
+        super()
+        @knowledge = knowledge
+        @audit = audit
+      end
+
+      def execute(query: nil, category: nil)
+        if category && !Memory::Knowledge::VALID_CATEGORIES.include?(category)
+          return "Invalid category '#{category}'. Use: #{Memory::Knowledge::VALID_CATEGORIES.join(', ')}"
+        end
+
+        results = @knowledge.recall(query: query, category: category)
+
+        @audit.log(
+          event: "tool_recall_facts",
+          detail: "query:#{query || '*'} cat:#{category || '*'} results:#{results.length}"
+        )
+
+        if results.empty?
+          "No facts found#{" matching '#{query}'" if query}#{" in category '#{category}'" if category}."
+        else
+          lines = results.map { |f| "- [#{f['category']}] #{f['content']} (id: #{f['id']})" }
+          "Found #{results.length} fact(s):\n#{lines.join("\n")}"
+        end
+      end
+
+      def name
+        "recall_facts"
+      end
+    end
+  end
+end

data/lib/kodo/tools/set_reminder.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+require "time"
+
+module Kodo
+  module Tools
+    class SetReminder < RubyLLM::Tool
+      MAX_PER_TURN = 3
+      MAX_CONTENT_LENGTH = 500
+
+      description "Set a reminder for a future time. The reminder will be delivered proactively " \
+                  "when the time arrives, even if the user hasn't sent a message."
+
+      param :content, desc: "What to remind the user about (max 500 chars)"
+      param :due_at, desc: "When to deliver the reminder, in ISO 8601 format (e.g. 2025-01-15T14:30:00-05:00)"
+
+      attr_writer :channel_id, :chat_id
+
+      def initialize(reminders:, audit:)
+        super()
+        @reminders = reminders
+        @audit = audit
+        @turn_count = 0
+        @channel_id = nil
+        @chat_id = nil
+      end
+
+      def reset_turn_count!
+        @turn_count = 0
+      end
+
+      def execute(content:, due_at:)
+        if content.length > MAX_CONTENT_LENGTH
+          return "Content too long (#{content.length} chars). Maximum is #{MAX_CONTENT_LENGTH}."
+        end
+
+        if Memory::Redactor.sensitive?(content)
+          return "Cannot store sensitive data in reminders."
+        end
+
+        @turn_count += 1
+        if @turn_count > MAX_PER_TURN
+          return "Rate limit reached (max #{MAX_PER_TURN} reminders per message). Try again next message."
+        end
+
+        parsed_time = parse_time(due_at)
+        return parsed_time if parsed_time.is_a?(String) # error message
+
+        if parsed_time <= Time.now
+          return "Cannot set a reminder in the past. Please provide a future time."
+        end
+
+        reminder = @reminders.add(
+          content: content,
+          due_at: parsed_time,
+          channel_id: @channel_id,
+          chat_id: @chat_id
+        )
+
+        @audit.log(
+          event: "reminder_set",
+          detail: "id:#{reminder['id']} due:#{reminder['due_at']} content:#{content.slice(0, 60)}"
+        )
+
+        "Reminder set for #{reminder['due_at']}: #{content} (id: #{reminder['id']})"
+      rescue Kodo::Error => e
+        e.message
+      end
+
+      def name
+        "set_reminder"
+      end
+
+      private
+
+      def parse_time(due_at)
+        Time.parse(due_at)
+      rescue ArgumentError, TypeError
+        "Invalid time format '#{due_at}'. Use ISO 8601 (e.g. 2025-01-15T14:30:00-05:00)."
+      end
+    end
+  end
+end

data/lib/kodo/tools/update_fact.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Kodo
+  module Tools
+    class UpdateFact < RubyLLM::Tool
+      MAX_PER_TURN = 5
+      MAX_CONTENT_LENGTH = 500
+
+      description "Update an existing fact with new content. Use this instead of forget+remember " \
+                  "when a fact needs correction or updating."
+
+      param :id, desc: "The UUID of the fact to update"
+      param :content, desc: "The new content for the fact (max 500 chars)"
+
+      def initialize(knowledge:, audit:)
+        super()
+        @knowledge = knowledge
+        @audit = audit
+        @turn_count = 0
+      end
+
+      def reset_turn_count!
+        @turn_count = 0
+      end
+
+      def execute(id:, content:)
+        if content.length > MAX_CONTENT_LENGTH
+          return "Content too long (#{content.length} chars). Maximum is #{MAX_CONTENT_LENGTH}."
+        end
+
+        if Memory::Redactor.sensitive?(content)
+          return "Cannot store sensitive data (passwords, API keys, SSNs, credit card numbers)."
+        end
+
+        @turn_count += 1
+        if @turn_count > MAX_PER_TURN
+          return "Rate limit reached (max #{MAX_PER_TURN} updates per message). Try again next message."
+        end
+
+        old_fact = @knowledge.all_active.find { |f| f["id"] == id }
+        unless old_fact
+          return "No active fact found with id: #{id}"
+        end
+
+        @knowledge.forget(id)
+        new_fact = @knowledge.remember(
+          category: old_fact["category"],
+          content: content,
+          source: old_fact["source"]
+        )
+
+        @audit.log(
+          event: "knowledge_updated",
+          detail: "old:#{id} new:#{new_fact['id']} cat:#{old_fact['category']}"
+        )
+
+        "Updated fact: #{content} (new id: #{new_fact['id']}, replaces: #{id})"
+      rescue Kodo::Error => e
+        e.message
+      end
+
+      def name
+        "update_fact"
+      end
+    end
+  end
+end

data/lib/kodo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kodo
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kodo-bot
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Freedom Dumlao
@@ -61,12 +61,19 @@ files:
 - lib/kodo/memory/encryption.rb
 - lib/kodo/memory/knowledge.rb
 - lib/kodo/memory/redactor.rb
+- lib/kodo/memory/reminders.rb
 - lib/kodo/memory/store.rb
 - lib/kodo/message.rb
 - lib/kodo/prompt_assembler.rb
 - lib/kodo/router.rb
+- lib/kodo/tools/dismiss_reminder.rb
 - lib/kodo/tools/forget_fact.rb
+- lib/kodo/tools/get_current_time.rb
+- lib/kodo/tools/list_reminders.rb
+- lib/kodo/tools/recall_facts.rb
 - lib/kodo/tools/remember_fact.rb
+- lib/kodo/tools/set_reminder.rb
+- lib/kodo/tools/update_fact.rb
 - lib/kodo/version.rb
 homepage: https://kodo.bot
 licenses: