kodo-bot 0.1.0

data/lib/kodo/config.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Kodo
+  class Config
+    # Map of Kodo config key → RubyLLM config setter name
+    PROVIDER_KEY_MAP = {
+      "anthropic"  => "anthropic",
+      "openai"     => "openai",
+      "gemini"     => "gemini",
+      "deepseek"   => "deepseek",
+      "mistral"    => "mistral",
+      "openrouter" => "openrouter",
+      "perplexity" => "perplexity",
+      "xai"        => "xai"
+    }.freeze
+
+    DEFAULTS = {
+      "daemon" => {
+        "port" => 7377,
+        "heartbeat_interval" => 60
+      },
+      "llm" => {
+        "model" => "claude-sonnet-4-20250514",
+        "providers" => {
+          "anthropic" => { "api_key_env" => "ANTHROPIC_API_KEY" }
+        }
+      },
+      "channels" => {
+        "telegram" => {
+          "enabled" => false,
+          "bot_token_env" => "TELEGRAM_BOT_TOKEN"
+        }
+      },
+      "memory" => {
+        "encryption" => false,
+        "store" => "file"
+      },
+      "logging" => {
+        "level" => "info",
+        "audit" => true
+      }
+    }.freeze
+
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+    end
+
+    class << self
+      def load(path = nil)
+        path ||= config_path
+        user_config = File.exist?(path) ? YAML.safe_load_file(path) : {}
+        merged = deep_merge(DEFAULTS, user_config || {})
+        new(merged)
+      end
+
+      def config_path
+        File.join(Kodo.home_dir, "config.yml")
+      end
+
+      def ensure_home_dir!
+        dirs = [
+          Kodo.home_dir,
+          File.join(Kodo.home_dir, "memory", "conversations"),
+          File.join(Kodo.home_dir, "memory", "knowledge"),
+          File.join(Kodo.home_dir, "memory", "audit"),
+          File.join(Kodo.home_dir, "skills")
+        ]
+        dirs.each { |d| FileUtils.mkdir_p(d) }
+
+        unless File.exist?(config_path)
+          File.write(config_path, YAML.dump(DEFAULTS))
+        end
+      end
+
+      private
+
+      def deep_merge(base, override)
+        base.merge(override) do |_key, old_val, new_val|
+          if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+            deep_merge(old_val, new_val)
+          else
+            new_val
+          end
+        end
+      end
+    end
+
+    # --- Daemon ---
+    def port               = data.dig("daemon", "port")
+    def heartbeat_interval = data.dig("daemon", "heartbeat_interval")
+
+    # --- LLM ---
+    def llm_model = data.dig("llm", "model")
+
+    # Returns a hash of { "provider_name" => "actual_api_key" } for all configured providers
+    def llm_api_keys
+      providers = data.dig("llm", "providers") || {}
+      keys = {}
+
+      providers.each do |provider, settings|
+        env_var = settings["api_key_env"]
+        next unless env_var
+
+        key = ENV[env_var]
+        if key && !key.empty?
+          ruby_llm_name = PROVIDER_KEY_MAP[provider] || provider
+          keys[ruby_llm_name] = key
+        end
+      end
+
+      if keys.empty?
+        raise Error, "No LLM API keys found. Set at least one provider key (e.g. ANTHROPIC_API_KEY)"
+      end
+
+      keys
+    end
+
+    # Optional: Ollama base URL for local models
+    def ollama_api_base
+      data.dig("llm", "providers", "ollama", "api_base") || ENV["OLLAMA_API_BASE"]
+    end
+
+    # --- Logging ---
+    def log_level       = data.dig("logging", "level")&.to_sym || :info
+    def audit_enabled?  = data.dig("logging", "audit") != false
+
+    # --- Channels ---
+    def telegram_bot_token
+      env_var = data.dig("channels", "telegram", "bot_token_env")
+      ENV.fetch(env_var) { raise Error, "Missing environment variable: #{env_var}" }
+    end
+
+    def telegram_enabled?
+      data.dig("channels", "telegram", "enabled") == true
+    end
+  end
+end

data/lib/kodo/daemon.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Kodo
+  class Daemon
+    attr_reader :config, :channels, :router, :heartbeat
+
+    def initialize(config: nil, heartbeat_interval: nil)
+      @config = config || Kodo.config
+      @heartbeat_interval = heartbeat_interval || @config.heartbeat_interval
+
+      @memory = Memory::Store.new
+      @audit = Memory::Audit.new
+      @prompt_assembler = PromptAssembler.new
+      @router = Router.new(memory: @memory, audit: @audit, prompt_assembler: @prompt_assembler)
+      @channels = []
+    end
+
+    def start!
+      Kodo.logger.info("🥁 Kodo v#{VERSION} starting...")
+      Kodo.logger.info("   Home: #{Kodo.home_dir}")
+
+      Config.ensure_home_dir!
+      @prompt_assembler.ensure_default_files!
+      configure_llm!
+      connect_channels!
+
+      # Log which prompt files were found
+      %w[persona.md user.md pulse.md origin.md].each do |f|
+        path = File.join(Kodo.home_dir, f)
+        status = File.exist?(path) ? "✅" : "  "
+        Kodo.logger.info("   #{status} #{f}")
+      end
+
+      start_heartbeat!
+    end
+
+    def stop!
+      Kodo.logger.info("🥁 Kodo shutting down...")
+      @heartbeat&.stop!
+      @channels.each(&:disconnect!)
+      Kodo.logger.info("🥁 Goodbye.")
+    end
+
+    private
+
+    def configure_llm!
+      LLM.configure!(config)
+      Kodo.logger.info("   Model: #{config.llm_model}")
+    end
+
+    def connect_channels!
+      if config.telegram_enabled?
+        telegram = Channels::Telegram.new(bot_token: config.telegram_bot_token)
+        telegram.connect!
+        @channels << telegram
+      end
+
+      if @channels.empty?
+        Kodo.logger.warn("No channels configured! Enable at least one in ~/.kodo/config.yml")
+      end
+
+      Kodo.logger.info("Connected #{@channels.length} channel(s)")
+    end
+
+    def start_heartbeat!
+      @heartbeat = Heartbeat.new(
+        channels: @channels,
+        router: @router,
+        audit: @audit,
+        interval: @heartbeat_interval
+      )
+
+      trap("INT") { stop! }
+      trap("TERM") { stop! }
+
+      @heartbeat.start!
+    end
+  end
+end

data/lib/kodo/heartbeat.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Kodo
+  class Heartbeat
+    def initialize(channels:, router:, audit:, interval: 60)
+      @channels = channels
+      @router = router
+      @audit = audit
+      @interval = interval
+      @running = false
+      @beat_count = 0
+    end
+
+    def start!
+      @running = true
+      Kodo.logger.info("💓 Heartbeat started (interval: #{@interval}s)")
+      @audit.log(event: "heartbeat_start", detail: "interval:#{@interval}s")
+
+      loop do
+        break unless @running
+
+        beat!
+        sleep(@interval)
+      end
+    rescue Interrupt
+      stop!
+    end
+
+    def stop!
+      @running = false
+      Kodo.logger.info("💓 Heartbeat stopped after #{@beat_count} beats")
+      @audit.log(event: "heartbeat_stop", detail: "beats:#{@beat_count}")
+    end
+
+    def running? = @running
+
+    private
+
+    def beat!
+      @beat_count += 1
+      Kodo.logger.debug("💓 Beat ##{@beat_count}")
+
+      # Phase 1: Collect — poll all channels for new messages
+      incoming = collect_messages
+
+      # Phase 2: Route — send each message through the router and respond
+      incoming.each do |message, channel|
+        process_message(message, channel)
+      end
+
+      # Phase 3: Schedule — check cron-like pulses (future)
+      # TODO: scheduled tasks
+
+    rescue StandardError => e
+      Kodo.logger.error("Heartbeat error: #{e.message}")
+      Kodo.logger.debug(e.backtrace&.first(5)&.join("\n"))
+    end
+
+    def collect_messages
+      messages = []
+
+      @channels.each do |channel|
+        next unless channel.running?
+
+        channel_messages = channel.poll
+        channel_messages.each do |msg|
+          messages << [msg, channel]
+        end
+      end
+
+      if messages.any?
+        Kodo.logger.debug("Collected #{messages.length} message(s) from #{@channels.length} channel(s)")
+      end
+
+      messages
+    end
+
+    def process_message(message, channel)
+      Kodo.logger.info("Processing: [#{channel.channel_id}] #{message.content.slice(0, 60)}...")
+
+      response = @router.route(message, channel: channel)
+      channel.send_message(response)
+
+    rescue StandardError => e
+      Kodo.logger.error("Error processing message: #{e.message}")
+
+      # Try to send an error message back to the user
+      error_msg = Message.new(
+        channel_id: channel.channel_id,
+        sender: :agent,
+        content: "Sorry, I hit an error processing that. Check the logs for details.",
+        metadata: { chat_id: message.metadata[:chat_id] || message.metadata["chat_id"] }
+      )
+      channel.send_message(error_msg) rescue nil
+    end
+  end
+end

data/lib/kodo/llm.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "ruby_llm"
+
+module Kodo
+  module LLM
+    class << self
+      # Configure RubyLLM from Kodo's config
+      def configure!(config)
+        RubyLLM.configure do |c|
+          config.llm_api_keys.each do |provider, key|
+            setter = "#{provider}_api_key="
+            c.send(setter, key) if c.respond_to?(setter)
+          end
+
+          if (ollama_url = config.ollama_api_base)
+            c.ollama_api_base = ollama_url
+          end
+        end
+
+        Kodo.logger.info("LLM configured: #{config.llm_model}")
+      end
+
+      # Create a new chat instance with the configured model
+      def chat(model: nil)
+        RubyLLM.chat(model: model || Kodo.config.llm_model)
+      end
+    end
+  end
+end

data/lib/kodo/memory/audit.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Kodo
+  module Memory
+    class Audit
+      def initialize
+        @audit_dir = File.join(Kodo.home_dir, "memory", "audit")
+        FileUtils.mkdir_p(@audit_dir)
+      end
+
+      # Log an event to the audit trail
+      def log(event:, channel: nil, detail: nil)
+        entry = {
+          "timestamp" => Time.now.iso8601,
+          "event" => event,
+          "channel" => channel,
+          "detail" => detail
+        }.compact
+
+        append_to_daily_log(entry)
+        Kodo.logger.debug("Audit: #{event} #{detail&.slice(0, 80)}")
+      end
+
+      # Read today's audit log
+      def today
+        read_log(Date.today)
+      end
+
+      private
+
+      def append_to_daily_log(entry)
+        path = log_path(Date.today)
+        File.open(path, "a") do |f|
+          f.puts(JSON.generate(entry))
+        end
+      end
+
+      def log_path(date)
+        File.join(@audit_dir, "#{date.iso8601}.jsonl")
+      end
+
+      def read_log(date)
+        path = log_path(date)
+        return [] unless File.exist?(path)
+
+        File.readlines(path).map { |line| JSON.parse(line) }
+      rescue JSON::ParserError
+        []
+      end
+    end
+  end
+end

data/lib/kodo/memory/store.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Kodo
+  module Memory
+    class Store
+      MAX_CONTEXT_MESSAGES = 50  # Keep last N messages per conversation
+
+      def initialize
+        @conversations = {}  # chat_id => Array<Hash>
+        @conversations_dir = File.join(Kodo.home_dir, "memory", "conversations")
+        FileUtils.mkdir_p(@conversations_dir)
+      end
+
+      # Append a message to a conversation
+      def append(chat_id, role:, content:)
+        chat_id = chat_id.to_s
+        @conversations[chat_id] ||= load_conversation(chat_id)
+        @conversations[chat_id] << {
+          "role" => role,
+          "content" => content,
+          "timestamp" => Time.now.iso8601
+        }
+
+        # Trim to max context window
+        if @conversations[chat_id].length > MAX_CONTEXT_MESSAGES
+          @conversations[chat_id] = @conversations[chat_id].last(MAX_CONTEXT_MESSAGES)
+        end
+
+        save_conversation(chat_id)
+      end
+
+      # Get conversation history in LLM-ready format
+      # Returns Array of {role: "user"|"assistant", content: String}
+      def conversation(chat_id)
+        chat_id = chat_id.to_s
+        @conversations[chat_id] ||= load_conversation(chat_id)
+        @conversations[chat_id].map do |msg|
+          { role: msg["role"], content: msg["content"] }
+        end
+      end
+
+      # Clear a conversation
+      def clear(chat_id)
+        chat_id = chat_id.to_s
+        @conversations.delete(chat_id)
+        path = conversation_path(chat_id)
+        File.delete(path) if File.exist?(path)
+      end
+
+      private
+
+      def conversation_path(chat_id)
+        # Sanitize chat_id for filesystem safety
+        safe_id = chat_id.gsub(/[^a-zA-Z0-9_\-]/, "_")
+        File.join(@conversations_dir, "#{safe_id}.json")
+      end
+
+      def load_conversation(chat_id)
+        path = conversation_path(chat_id)
+        return [] unless File.exist?(path)
+
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError => e
+        Kodo.logger.warn("Corrupt conversation file #{path}: #{e.message}")
+        []
+      end
+
+      def save_conversation(chat_id)
+        path = conversation_path(chat_id)
+        File.write(path, JSON.pretty_generate(@conversations[chat_id]))
+      end
+    end
+  end
+end

data/lib/kodo/message.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Kodo
+  Message = Data.define(
+    :id,
+    :channel_id,
+    :sender,       # :user, :agent, :system
+    :content,
+    :timestamp,
+    :metadata      # Hash — channel-specific extras
+  ) do
+    def initialize(id: SecureRandom.uuid, channel_id:, sender:, content:, timestamp: Time.now, metadata: {})
+      super
+    end
+
+    def from_user? = sender == :user
+    def from_agent? = sender == :agent
+    def from_system? = sender == :system
+
+    # Convert to the format expected by LLM providers
+    def to_llm_message
+      role = from_user? ? "user" : "assistant"
+      { role: role, content: content }
+    end
+  end
+end