pocketrb 0.1.0

data/lib/pocketrb/providers/ruby_llm_provider.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Providers
+    # Provider using the RubyLLM gem for multi-model support
+    # This is an alternative to direct API calls
+    class RubyLLMProvider < Base
+      def name
+        :ruby_llm
+      end
+
+      def default_model
+        "claude-sonnet-4-20250514"
+      end
+
+      def available_models
+        return [] unless ruby_llm_available?
+
+        RubyLLM.models.map(&:id)
+      end
+
+      def chat(messages:, tools: nil, model: nil, temperature: 0.7, max_tokens: 4096, thinking: false)
+        ensure_ruby_llm!
+
+        model ||= default_model
+        chat_instance = RubyLLM.chat(model: model)
+
+        # Add tools if provided
+        tools&.each do |tool|
+          chat_instance.with_tool(build_ruby_llm_tool(tool))
+        end
+
+        # Configure and send
+        messages.each { |msg| add_message_to_chat(chat_instance, msg) }
+
+        response = chat_instance.complete
+
+        parse_ruby_llm_response(response, model)
+      end
+
+      def chat_stream(messages:, tools: nil, model: nil, temperature: 0.7, max_tokens: 4096, &block)
+        ensure_ruby_llm!
+
+        model ||= default_model
+        chat_instance = RubyLLM.chat(model: model)
+
+        tools&.each do |tool|
+          chat_instance.with_tool(build_ruby_llm_tool(tool))
+        end
+
+        messages.each { |msg| add_message_to_chat(chat_instance, msg) }
+
+        accumulated = ""
+        response = chat_instance.stream do |chunk|
+          accumulated << chunk.content if chunk.content
+          block&.call(chunk.content)
+        end
+
+        parse_ruby_llm_response(response, model)
+      end
+
+      protected
+
+      def supported_features
+        %i[tools streaming]
+      end
+
+      def validate_config!
+        # RubyLLM handles API key validation internally
+      end
+
+      private
+
+      def ruby_llm_available?
+        defined?(RubyLLM)
+      end
+
+      def ensure_ruby_llm!
+        return if ruby_llm_available?
+
+        begin
+          require "ruby_llm"
+          configure_ruby_llm
+        rescue LoadError
+          raise ConfigurationError, "ruby_llm gem is not installed. Add it to your Gemfile."
+        end
+      end
+
+      def configure_ruby_llm
+        RubyLLM.configure do |c|
+          c.anthropic_api_key = api_key(:anthropic_api_key) if api_key(:anthropic_api_key)
+          c.openai_api_key = api_key(:openai_api_key) if api_key(:openai_api_key)
+        end
+      end
+
+      def build_ruby_llm_tool(tool)
+        tool[:function] || tool
+        # RubyLLM uses a different tool format - this would need adaptation
+        # based on actual RubyLLM API
+      end
+
+      def add_message_to_chat(chat, message)
+        case message.role
+        when Role::SYSTEM
+          chat.with_system_prompt(message.content)
+        when Role::USER
+          chat.ask(message.content, stream: false)
+        when Role::ASSISTANT
+          # RubyLLM manages assistant messages internally
+        when Role::TOOL
+          # Tool results handled differently in RubyLLM
+        end
+      end
+
+      def parse_ruby_llm_response(response, model)
+        tool_calls = (response.tool_calls || []).map do |tc|
+          ToolCall.new(
+            id: tc.id,
+            name: tc.name,
+            arguments: tc.arguments
+          )
+        end
+
+        LLMResponse.new(
+          content: response.content,
+          tool_calls: tool_calls,
+          usage: Usage.new(
+            input_tokens: response.input_tokens || 0,
+            output_tokens: response.output_tokens || 0
+          ),
+          model: model
+        )
+      end
+    end
+  end
+end

data/lib/pocketrb/providers/types.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Providers
+    # Response from an LLM provider
+    LLMResponse = Data.define(
+      :content,      # String|nil - text content of the response
+      :tool_calls,   # Array<ToolCall> - tool calls requested by the model
+      :usage,        # Usage - token usage statistics
+      :stop_reason,  # Symbol - :end_turn, :tool_use, :max_tokens, :stop_sequence
+      :model,        # String - model that generated the response
+      :thinking      # String|nil - extended thinking content (Claude)
+    ) do
+      def initialize(content:, tool_calls: [], usage: nil, stop_reason: :end_turn, model: nil, thinking: nil)
+        super
+      end
+
+      def has_tool_calls?
+        tool_calls && !tool_calls.empty?
+      end
+
+      def has_content?
+        content && !content.empty?
+      end
+
+      def has_thinking?
+        thinking && !thinking.empty?
+      end
+    end
+
+    # Tool call from the model
+    ToolCall = Data.define(
+      :id,           # String - unique identifier for this tool call
+      :name,         # String - name of the tool to execute
+      :arguments     # Hash - arguments to pass to the tool
+    ) do
+      def initialize(id:, name:, arguments:)
+        args = arguments.is_a?(String) ? JSON.parse(arguments) : arguments
+        super(id: id, name: name, arguments: args)
+      rescue JSON::ParserError
+        super(id: id, name: name, arguments: {})
+      end
+    end
+
+    # Token usage statistics
+    Usage = Data.define(
+      :input_tokens,   # Integer - tokens in the input
+      :output_tokens,  # Integer - tokens in the output
+      :cache_read,     # Integer|nil - tokens read from cache
+      :cache_write     # Integer|nil - tokens written to cache
+    ) do
+      def initialize(input_tokens: 0, output_tokens: 0, cache_read: nil, cache_write: nil)
+        super
+      end
+
+      def total_tokens
+        input_tokens + output_tokens
+      end
+    end
+
+    # Message role for conversation history
+    module Role
+      SYSTEM = "system"
+      USER = "user"
+      ASSISTANT = "assistant"
+      TOOL = "tool"
+    end
+
+    # Message in conversation history
+    Message = Data.define(
+      :role,         # String - Role::SYSTEM, USER, ASSISTANT, or TOOL
+      :content,      # String|Array - text content or content blocks
+      :name,         # String|nil - for tool role, the tool name
+      :tool_call_id, # String|nil - for tool role, the tool call this responds to
+      :tool_calls    # Array<ToolCall>|nil - for assistant role, tool calls made
+    ) do
+      def initialize(role:, content:, name: nil, tool_call_id: nil, tool_calls: nil)
+        super
+      end
+
+      def self.system(content)
+        new(role: Role::SYSTEM, content: content)
+      end
+
+      def self.user(content, media: nil)
+        if media && !media.empty?
+          # Build content blocks array with text and images
+          blocks = []
+          blocks << { type: "text", text: content } if content && !content.empty?
+
+          media.each do |m|
+            # Media will be formatted by the provider
+            blocks << { type: "media", media: m }
+          end
+
+          new(role: Role::USER, content: blocks)
+        else
+          new(role: Role::USER, content: content)
+        end
+      end
+
+      def self.assistant(content, tool_calls: nil)
+        new(role: Role::ASSISTANT, content: content, tool_calls: tool_calls)
+      end
+
+      def self.tool_result(tool_call_id:, name:, content:)
+        new(role: Role::TOOL, content: content, name: name, tool_call_id: tool_call_id)
+      end
+    end
+  end
+end

data/lib/pocketrb/session/manager.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Pocketrb
+  module Session
+    # Manages session persistence using JSONL files
+    class Manager
+      attr_reader :storage_dir
+
+      def initialize(storage_dir:)
+        @storage_dir = Pathname.new(storage_dir)
+        @sessions = {}
+        @mutex = Mutex.new
+
+        ensure_storage_dir!
+      end
+
+      # Get or create a session
+      # @param key [String] Session key
+      # @return [Session]
+      def get_or_create(key)
+        @mutex.synchronize do
+          @sessions[key] ||= load_or_create(key)
+        end
+      end
+
+      # Get an existing session
+      # @param key [String] Session key
+      # @return [Session|nil]
+      def get(key)
+        @mutex.synchronize do
+          @sessions[key] || load_session(key)
+        end
+      end
+
+      # Save a session
+      # @param session [Session]
+      def save(session)
+        @mutex.synchronize do
+          @sessions[session.key] = session
+          persist_session(session)
+        end
+      end
+
+      # Delete a session
+      # @param key [String] Session key
+      def delete(key)
+        @mutex.synchronize do
+          @sessions.delete(key)
+          delete_session_file(key)
+        end
+      end
+
+      # List all session keys
+      # @return [Array<String>]
+      def list_keys
+        @mutex.synchronize do
+          loaded = @sessions.keys
+          persisted = Dir.glob(@storage_dir.join("*.jsonl")).map do |f|
+            File.basename(f, ".jsonl")
+          end
+          (loaded + persisted).uniq
+        end
+      end
+
+      # Append a message to a session's JSONL file (real-time logging)
+      # @param key [String] Session key
+      # @param message [Message]
+      def append_message(key, message)
+        @mutex.synchronize do
+          file = session_file(key)
+          File.open(file, "a") do |f|
+            f.puts(message.to_h.to_json)
+          end
+        end
+      end
+
+      # Clear all sessions
+      def clear_all!
+        @mutex.synchronize do
+          @sessions.clear
+          Dir.glob(@storage_dir.join("*.jsonl")).each { |f| File.delete(f) }
+        end
+      end
+
+      private
+
+      def ensure_storage_dir!
+        FileUtils.mkdir_p(@storage_dir) unless @storage_dir.exist?
+      end
+
+      def session_file(key)
+        # Sanitize key for filename
+        safe_key = key.gsub(/[^a-zA-Z0-9_-]/, "_")
+        @storage_dir.join("#{safe_key}.jsonl")
+      end
+
+      def load_or_create(key)
+        load_session(key) || Session.new(key: key)
+      end
+
+      def load_session(key)
+        file = session_file(key)
+        return nil unless file.exist?
+
+        messages = []
+        File.foreach(file) do |line|
+          next if line.strip.empty?
+
+          data = JSON.parse(line.strip)
+          messages << Providers::Message.new(
+            role: data["role"],
+            content: data["content"],
+            name: data["name"],
+            tool_call_id: data["tool_call_id"],
+            tool_calls: parse_tool_calls(data["tool_calls"])
+          )
+        end
+
+        Session.new(key: key, messages: messages)
+      rescue JSON::ParserError => e
+        Pocketrb.logger.error("Failed to parse session #{key}: #{e.message}")
+        Session.new(key: key)
+      end
+
+      def parse_tool_calls(tool_calls)
+        return nil unless tool_calls
+
+        tool_calls.map do |tc|
+          Providers::ToolCall.new(
+            id: tc["id"],
+            name: tc["name"],
+            arguments: tc["arguments"]
+          )
+        end
+      end
+
+      def persist_session(session)
+        file = session_file(session.key)
+        File.open(file, "w") do |f|
+          session.messages.each do |msg|
+            f.puts(message_to_json(msg))
+          end
+        end
+      end
+
+      def message_to_json(message)
+        {
+          role: message.role,
+          content: sanitize_content(message.content),
+          name: message.name,
+          tool_call_id: message.tool_call_id,
+          tool_calls: message.tool_calls&.map do |tc|
+            { id: tc.id, name: tc.name, arguments: tc.arguments }
+          end
+        }.compact.to_json
+      end
+
+      # Sanitize content to ensure valid UTF-8 for JSON encoding
+      def sanitize_content(content)
+        return nil if content.nil?
+
+        if content.is_a?(String)
+          # Replace invalid UTF-8 bytes with replacement character
+          content.encode("UTF-8", invalid: :replace, undef: :replace, replace: "\uFFFD")
+        elsif content.is_a?(Array)
+          content.map { |block| sanitize_content_block(block) }
+        else
+          content
+        end
+      end
+
+      def sanitize_content_block(block)
+        return block unless block.is_a?(Hash)
+
+        block.transform_values do |v|
+          if v.is_a?(String)
+            v.encode("UTF-8", invalid: :replace, undef: :replace, replace: "\uFFFD")
+          else
+            v
+          end
+        end
+      end
+
+      def delete_session_file(key)
+        file = session_file(key)
+        File.delete(file) if file.exist?
+      end
+    end
+  end
+end

data/lib/pocketrb/session/session.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Session
+    # Represents a conversation session with history
+    class Session
+      attr_reader :key, :metadata, :created_at
+      attr_accessor :messages
+
+      def initialize(key:, messages: [], metadata: {})
+        @key = key
+        @messages = messages
+        @metadata = metadata
+        @created_at = Time.now
+        @mutex = Mutex.new
+      end
+
+      # Add a message to the session
+      # @param role [String] Message role
+      # @param content [String] Message content
+      # @param kwargs [Hash] Additional message attributes
+      def add_message(role:, content:, **kwargs)
+        @mutex.synchronize do
+          message = Providers::Message.new(
+            role: role,
+            content: content,
+            **kwargs
+          )
+          @messages << message
+          save_to_log(message)
+        end
+      end
+
+      # Add a user message (with optional media)
+      # @param content [String] Text content
+      # @param media [Array<Bus::Media>] Media attachments
+      def add_user_message(content, media: nil)
+        if media && !media.empty?
+          # Build content blocks with text and media references
+          # Note: We store media metadata, not the actual data
+          blocks = []
+          blocks << { type: "text", text: content } if content && !content.empty?
+
+          media.each do |m|
+            blocks << {
+              type: "media",
+              media: {
+                type: m.type,
+                path: m.path.to_s,
+                mime_type: m.mime_type,
+                filename: m.filename
+                # Don't store base64 data in session - too large
+              }
+            }
+          end
+
+          add_message(role: Providers::Role::USER, content: blocks)
+        else
+          add_message(role: Providers::Role::USER, content: content)
+        end
+      end
+
+      # Add an assistant message
+      def add_assistant_message(content, tool_calls: nil)
+        # Truncate large tool call arguments to prevent context bloat
+        sanitized_calls = sanitize_tool_calls(tool_calls) if tool_calls
+        add_message(role: Providers::Role::ASSISTANT, content: content, tool_calls: sanitized_calls)
+      end
+
+      # Add a tool result message
+      MAX_TOOL_RESULT_LENGTH = 2000
+
+      def add_tool_result(tool_call_id:, name:, content:)
+        # Truncate large tool results to prevent context bloat
+        truncated_content = if content.is_a?(String) && content.length > MAX_TOOL_RESULT_LENGTH
+                              "#{content[0...MAX_TOOL_RESULT_LENGTH]}... [truncated #{content.length - MAX_TOOL_RESULT_LENGTH} chars]"
+                            else
+                              content
+                            end
+
+        add_message(
+          role: Providers::Role::TOOL,
+          content: truncated_content,
+          name: name,
+          tool_call_id: tool_call_id
+        )
+      end
+
+      # Get message history (optionally limited)
+      # @param max_messages [Integer|nil] Maximum messages to return
+      # @return [Array<Message>]
+      def get_history(max_messages: nil)
+        @mutex.synchronize do
+          return @messages.dup if max_messages.nil?
+
+          @messages.last(max_messages)
+        end
+      end
+
+      # Clear all messages
+      def clear
+        @mutex.synchronize do
+          @messages.clear
+        end
+      end
+
+      # Get the last message
+      def last_message
+        @mutex.synchronize { @messages.last }
+      end
+
+      # Number of messages
+      def message_count
+        @mutex.synchronize { @messages.size }
+      end
+
+      # Check if session is empty
+      def empty?
+        @mutex.synchronize { @messages.empty? }
+      end
+
+      # Set metadata value
+      def set_meta(key, value)
+        @mutex.synchronize { @metadata[key] = value }
+      end
+
+      # Get metadata value
+      def get_meta(key)
+        @mutex.synchronize { @metadata[key] }
+      end
+
+      # Convert to hash for serialization
+      def to_h
+        @mutex.synchronize do
+          {
+            key: @key,
+            messages: @messages.map(&:to_h),
+            metadata: @metadata,
+            created_at: @created_at.iso8601
+          }
+        end
+      end
+
+      # Create from hash
+      def self.from_h(hash)
+        messages = (hash[:messages] || hash["messages"] || []).map do |m|
+          Providers::Message.new(
+            role: m[:role] || m["role"],
+            content: m[:content] || m["content"],
+            name: m[:name] || m["name"],
+            tool_call_id: m[:tool_call_id] || m["tool_call_id"],
+            tool_calls: m[:tool_calls] || m["tool_calls"]
+          )
+        end
+
+        session = new(
+          key: hash[:key] || hash["key"],
+          messages: messages,
+          metadata: hash[:metadata] || hash["metadata"] || {}
+        )
+        session.instance_variable_set(
+          :@created_at,
+          Time.parse(hash[:created_at] || hash["created_at"])
+        )
+        session
+      rescue StandardError => e
+        Pocketrb.logger.error("Failed to load session: #{e.message}")
+        new(key: hash[:key] || hash["key"])
+      end
+
+      private
+
+      # Truncate large arguments in tool calls to prevent context bloat
+      # Large content (scripts, files) shouldn't be stored in session history
+      MAX_ARG_LENGTH = 500
+
+      def sanitize_tool_calls(tool_calls)
+        return nil if tool_calls.nil?
+
+        tool_calls.map do |tc|
+          sanitized_args = tc.arguments.transform_values do |v|
+            if v.is_a?(String) && v.length > MAX_ARG_LENGTH
+              "#{v[0...MAX_ARG_LENGTH]}... [truncated #{v.length - MAX_ARG_LENGTH} chars]"
+            else
+              v
+            end
+          end
+
+          # Create new tool call with sanitized arguments
+          Providers::ToolCall.new(
+            id: tc.id,
+            name: tc.name,
+            arguments: sanitized_args
+          )
+        end
+      end
+
+      def save_to_log(message)
+        # Session manager handles persistence via JSONL
+        # This is a hook for real-time logging if needed
+      end
+    end
+  end
+end