crimson-code 0.1.0

data/lib/crimson/client/anthropic_adapter.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'anthropic'
+require_relative 'base'
+
+module Crimson
+  module Client
+    # Anthropic SDK client adapter supporting streaming, thinking mode, and tool use.
+    class AnthropicAdapter < Base
+      # @param config [Config]
+      def initialize(config)
+        super
+        @client = Anthropic::Client.new(api_key: config.api_key)
+      end
+
+      # @param messages [Array<Message::Base>]
+      # @param tools [Array<Hash>]
+      # @yield [text_chunk, tool_event] streaming callback
+      # @return [Array(Message::Assistant, Hash, nil)]
+      def chat(messages:, tools: [], &stream_callback)
+        system_msg, chat_msgs = split_messages(messages)
+
+        params = {
+          model: @config.model,
+          max_tokens: @config.max_tokens
+        }
+        params[:system] = system_msg if system_msg
+        params[:messages] = chat_msgs
+        params[:tools] = tools unless tools.empty?
+
+        if @config.thinking_level && @config.thinking_level != "off"
+          budget = thinking_budget(@config.thinking_level)
+          params[:thinking] = { type: "enabled", budget_tokens: budget }
+          params[:max_tokens] = [params[:max_tokens], budget * 2].max
+        end
+
+        if block_given?
+          stream_chat(params, &stream_callback)
+        else
+          non_stream_chat(params)
+        end
+      end
+
+      private
+
+      # @api private
+      def split_messages(messages)
+        system_parts = []
+        chat_msgs = []
+
+        messages.each do |msg|
+          case msg
+          when Message::System
+            system_parts << msg.content
+          when Message::ToolResult
+            anthropic_h = msg.to_anthropic_h
+            last_msg = chat_msgs.last
+            if last_msg && last_msg[:role] == "user" && last_msg[:content].is_a?(Array)
+              last_msg[:content].concat(anthropic_h[:content])
+            else
+              chat_msgs << anthropic_h
+            end
+          else
+            chat_msgs << msg.to_anthropic_h
+          end
+        end
+
+        system_text = system_parts.join("\n\n")
+        system_text = nil if system_text.empty?
+
+        [system_text, chat_msgs]
+      end
+
+      # @api private
+      def thinking_budget(level)
+        case level
+        when "low" then 2_048
+        when "medium" then 10_000
+        when "high" then 32_000
+        else 10_000
+        end
+      end
+
+      # @api private
+      def stream_chat(params, &callback)
+        collected_content = String.new
+        collected_tool_calls = {}
+        current_tool_use = nil
+        collected_usage = nil
+
+        stream = @client.messages.stream(
+          model: params[:model],
+          max_tokens: params[:max_tokens],
+          system: params[:system],
+          messages: params[:messages],
+          tools: params[:tools]
+        )
+
+        stream.each do |event|
+          case event.type
+          when "message_delta"
+            if event.respond_to?(:usage)
+              u = event.usage
+              collected_usage = {
+                prompt_tokens: u&.input_tokens || 0,
+                completion_tokens: u&.output_tokens || 0,
+                total_tokens: (u&.input_tokens || 0) + (u&.output_tokens || 0)
+              }
+            end
+          when "content_block_delta"
+            delta = event.delta
+            next unless delta
+
+            delta_type = delta[:type] || delta["type"]
+            if delta_type == "text_delta"
+              text = delta[:text] || delta["text"] || ""
+              collected_content << text
+              callback.call(text, nil)
+            elsif delta_type == "input_json_delta"
+              partial = delta[:partial_json] || delta["partial_json"] || ""
+              current_tool_use[:arguments] << partial if current_tool_use
+            end
+          when "content_block_start"
+            content_block = event.content_block
+            next unless content_block
+
+            cb_type = content_block[:type] || content_block["type"]
+            if cb_type == "tool_use"
+              current_tool_use = {
+                id: content_block[:id] || content_block["id"],
+                name: content_block[:name] || content_block["name"],
+                arguments: String.new
+              }
+            end
+          when "content_block_stop"
+            if current_tool_use
+              callback.call(nil, current_tool_use)
+              collected_tool_calls[current_tool_use[:id]] = current_tool_use
+              current_tool_use = nil
+            end
+          end
+        end
+
+        [build_assistant_message(collected_content, collected_tool_calls.values), collected_usage]
+      rescue => e
+        [Message::Assistant.new(content: "Error communicating with Anthropic: #{e.message}"), nil]
+      end
+
+      # @api private
+      def non_stream_chat(params)
+        response = @client.messages.create(
+          model: params[:model],
+          max_tokens: params[:max_tokens],
+          system: params[:system],
+          messages: params[:messages],
+          tools: params[:tools]
+        )
+
+        content = String.new
+        tool_calls = []
+
+        Array(response.content).each do |block|
+          block_type = block[:type] || block["type"]
+          if block_type == "text"
+            content << (block[:text] || block["text"] || "")
+          elsif block_type == "tool_use"
+            tool_calls << Message::ToolCall.new(
+              id: block[:id] || block["id"],
+              name: block[:name] || block["name"],
+              arguments: block[:input] || block["input"] || {}
+            )
+          end
+        end
+
+        usage = response.usage
+        usage_h = usage ? {
+          prompt_tokens: usage.input_tokens || 0,
+          completion_tokens: usage.output_tokens || 0,
+          total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
+        } : nil
+
+        [Message::Assistant.new(content: content.empty? ? nil : content.to_s, tool_calls: tool_calls), usage_h]
+      rescue => e
+        [Message::Assistant.new(content: "Error communicating with Anthropic: #{e.message}"), nil]
+      end
+
+      # @api private
+      def build_assistant_message(content, tool_calls)
+        tc = tool_calls.map do |raw|
+          args = begin
+            JSON.parse(raw[:arguments], symbolize_names: false)
+          rescue JSON::ParserError
+            {}
+          end
+          Message::ToolCall.new(id: raw[:id], name: raw[:name], arguments: args)
+        end
+
+        Message::Assistant.new(
+          content: content.empty? ? nil : content.to_s,
+          tool_calls: tc
+        )
+      end
+    end
+  end
+end

data/lib/crimson/client/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Crimson
+  module Client
+    # Abstract base class for LLM API client adapters.
+    # @abstract Subclasses must implement {#chat}.
+    class Base
+      # @param config [Config]
+      def initialize(config)
+        @config = config
+      end
+
+      # Send a chat request and return the assistant response.
+      # @param messages [Array<Message::Base>] conversation messages
+      # @param tools [Array<Hash>] tool definitions
+      # @yield [text_chunk, tool_event] optional streaming callback
+      # @yieldparam text_chunk [String, nil] incremental text delta
+      # @yieldparam tool_event [Hash, nil] partial tool call data
+      # @return [Array(Message::Assistant, Hash, nil)] response message and usage data
+      def chat(messages:, tools: [], &stream_callback)
+        raise NotImplementedError, "#{self.class}#chat must be implemented"
+      end
+    end
+  end
+end

data/lib/crimson/client/factory.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module Crimson
+module Client
+  # Factory method to create the correct client adapter based on provider configuration.
+  # @param config [Config]
+  # @return [Client::Base]
+  # @raise [Error] if the provider SDK is unsupported
+  def self.create(config)
+    provider = config.provider.to_sym
+    sdk = PROVIDERS[provider][:sdk]
+
+    case sdk
+    when :openai
+      require_relative 'openai_adapter'
+      OpenAIAdapter.new(config)
+    when :anthropic
+      require_relative 'anthropic_adapter'
+      AnthropicAdapter.new(config)
+    else
+      raise Error, "Unsupported provider: #{config.provider}"
+    end
+  end
+end
+end

data/lib/crimson/client/openai_adapter.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'openai'
+require_relative 'base'
+
+module Crimson
+  module Client
+    # OpenAI SDK client adapter supporting streaming and non-streaming chat.
+    class OpenAIAdapter < Base
+      # @param config [Config]
+      def initialize(config)
+        super
+        @client = build_client
+      end
+
+      # @param messages [Array<Message::Base>]
+      # @param tools [Array<Hash>]
+      # @yield [text_chunk, tool_event] streaming callback
+      # @return [Array(Message::Assistant, Hash, nil)]
+      def chat(messages:, tools: [], &stream_callback)
+        params = {
+          messages: messages.map(&:to_openai_h),
+          model: @config.model
+        }
+        params[:tools] = tools unless tools.empty?
+
+        if block_given?
+          stream_chat(params, &stream_callback)
+        else
+          non_stream_chat(params)
+        end
+      end
+
+      private
+
+      # @api private
+      def build_client
+        opts = { api_key: @config.api_key }
+
+        base_url = @config.base_url || PROVIDERS[@config.provider.to_sym][:base_url]
+        opts[:base_url] = base_url if base_url
+
+        OpenAI::Client.new(**opts)
+      end
+
+      # @api private
+      def stream_chat(params, &callback)
+        collected_content = String.new
+        collected_tool_calls = {}
+        usage = nil
+
+        stream = @client.chat.completions.stream(
+          messages: params[:messages],
+          model: params[:model],
+          tools: params[:tools] || []
+        )
+
+        stream.each do |event|
+          case event
+          when OpenAI::Helpers::Streaming::ChatContentDeltaEvent
+            text = event.delta
+            if text && !text.empty?
+              collected_content << text
+              callback.call(text, nil)
+            end
+
+          when OpenAI::Helpers::Streaming::ChatFunctionToolCallArgumentsDeltaEvent
+            idx = event.index
+            collected_tool_calls[idx] ||= {
+              id: nil,
+              name: event.name || "",
+              arguments: String.new,
+              _emitted: false
+            }
+            collected_tool_calls[idx][:name] = event.name if event.name
+            collected_tool_calls[idx][:arguments] << event.arguments_delta if event.arguments_delta
+
+            if event.name && !collected_tool_calls[idx][:_emitted]
+              collected_tool_calls[idx][:_emitted] = true
+              callback.call(nil, collected_tool_calls[idx])
+            end
+
+          when OpenAI::Helpers::Streaming::ChatFunctionToolCallArgumentsDoneEvent
+            idx = event.index
+            collected_tool_calls[idx] ||= {
+              id: nil,
+              name: event.name || "",
+              arguments: String.new
+            }
+            collected_tool_calls[idx][:name] = event.name if event.name
+            collected_tool_calls[idx][:arguments] = event.arguments if event.arguments
+
+          when OpenAI::Helpers::Streaming::ResponseCompletedEvent
+            final = event.response
+            if final.respond_to?(:usage) && final.usage
+              usage = {
+                prompt_tokens: final.usage.prompt_tokens || 0,
+                completion_tokens: final.usage.completion_tokens || 0,
+                total_tokens: final.usage.total_tokens || 0
+              }
+            end
+
+          when OpenAI::Helpers::Streaming::ChatChunkEvent
+            chunk = event.chunk
+            if chunk.respond_to?(:usage) && chunk.usage
+              usage = {
+                prompt_tokens: chunk.usage.prompt_tokens || 0,
+                completion_tokens: chunk.usage.completion_tokens || 0,
+                total_tokens: chunk.usage.total_tokens || 0
+              }
+            end
+          end
+        end
+
+        collected_tool_calls.each do |_idx, tc|
+          next if tc[:_emitted]
+          callback.call(nil, tc)
+        end
+
+        [build_assistant_message(collected_content, collected_tool_calls.values), usage]
+      rescue => e
+        [Message::Assistant.new(content: "Error communicating with #{provider_name}: #{e.message}"), nil]
+      end
+
+      # @api private
+      def non_stream_chat(params)
+        response = @client.chat.completions.create(
+          messages: params[:messages],
+          model: params[:model],
+          tools: params[:tools] || []
+        )
+
+        choice = response.choices&.first
+        return [Message::Assistant.new(content: ""), nil] unless choice
+
+        msg = choice.message
+        tool_calls = parse_tool_calls(msg.tool_calls) if msg.tool_calls
+
+        usage = response.usage
+        usage_h = usage ? {
+          prompt_tokens: usage.prompt_tokens || 0,
+          completion_tokens: usage.completion_tokens || 0,
+          total_tokens: usage.total_tokens || 0
+        } : nil
+
+        [Message::Assistant.new(content: msg.content, tool_calls: tool_calls || []), usage_h]
+      rescue => e
+        [Message::Assistant.new(content: "Error communicating with #{provider_name}: #{e.message}"), nil]
+      end
+
+      # @api private
+      def parse_tool_calls(raw_tool_calls)
+        raw_tool_calls.map do |tc|
+          args = begin
+            JSON.parse(tc.function.arguments, symbolize_names: false)
+          rescue JSON::ParserError
+            {}
+          end
+
+          Message::ToolCall.new(id: tc.id, name: tc.function.name, arguments: args)
+        end
+      end
+
+      # @api private
+      def build_assistant_message(content, tool_calls)
+        tc = tool_calls.map do |raw|
+          args = begin
+            JSON.parse(raw[:arguments], symbolize_names: false)
+          rescue JSON::ParserError
+            {}
+          end
+          Message::ToolCall.new(id: raw[:id] || SecureRandom.uuid, name: raw[:name], arguments: args)
+        end
+
+        Message::Assistant.new(
+          content: content.empty? ? nil : content.to_s,
+          tool_calls: tc
+        )
+      end
+
+      # @api private
+      def provider_name
+        PROVIDERS[@config.provider.to_sym][:name]
+      end
+    end
+  end
+end

data/lib/crimson/compactor.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Crimson
+  # Compacts conversation history by summarizing older messages when context limits are approached.
+  class Compactor
+    # Default max context tokens before compaction is triggered.
+    DEFAULT_MAX_CONTEXT_TOKENS = 100_000
+    # Number of most recent messages to preserve verbatim during compaction.
+    KEEP_RECENT_MESSAGES = 4
+
+    # @param client [Client::Base] the API client used for summarization
+    # @param max_context_tokens [Integer] threshold for triggering compaction
+    # @param model [String, nil] model name for token counting
+    # @param provider [String, nil] provider name
+    def initialize(client:, max_context_tokens: DEFAULT_MAX_CONTEXT_TOKENS, model: nil, provider: nil)
+      @client = client
+      @max_context_tokens = max_context_tokens
+      @token_counter = TokenCounter.new(model: model, provider: provider)
+    end
+
+    # Check whether the history exceeds 80% of the max context token budget.
+    # @param history [Array<Message::Base>]
+    # @return [Boolean]
+    def needs_compaction?(history)
+      estimated_tokens(history) > @max_context_tokens * 0.8
+    end
+
+    # Compact history by summarizing older entries and keeping recent ones verbatim.
+    # @param history [Array<Message::Base>]
+    # @param system_prompt [String]
+    # @return [Array<Message::Base>] compacted history
+    def compact(history, system_prompt:)
+      return history if history.length <= KEEP_RECENT_MESSAGES + 1
+
+      older = history[0...-KEEP_RECENT_MESSAGES]
+      recent = history[-KEEP_RECENT_MESSAGES..]
+
+      file_ops = extract_file_operations(history)
+      summary = summarize(older, system_prompt, file_ops)
+
+      compacted = []
+      compacted << Message::User.new("[Previous conversation summary]\n#{summary}")
+      compacted << Message::Assistant.new(content: "Understood. I have the context from the previous conversation.")
+      compacted.concat(recent)
+      compacted
+    end
+
+    private
+
+    # @api private
+    def extract_file_operations(history)
+      ops = { read: [], modified: [] }
+      pending_tool_calls = {}
+
+      history.each do |msg|
+        if msg.is_a?(Message::Assistant) && msg.tool_calls
+          msg.tool_calls.each do |tc|
+            pending_tool_calls[tc.id] = tc
+          end
+        elsif msg.is_a?(Message::ToolResult)
+          tc = pending_tool_calls[msg.tool_call_id]
+          if tc
+            path = tc.arguments.is_a?(Hash) ? (tc.arguments["path"] || tc.arguments[:path]) : nil
+            case tc.name
+            when "read_file"
+              ops[:read] << path if path
+            when "write_file", "edit_file"
+              ops[:modified] << path if path
+            end
+          end
+        end
+      end
+
+      ops[:read] = ops[:read].compact.uniq
+      ops[:modified] = ops[:modified].compact.uniq
+      ops
+    end
+
+    # @api private
+    def summarize(messages, system_prompt, file_ops = { read: [], modified: [] })
+      files_section = ""
+      if file_ops[:read].any? || file_ops[:modified].any?
+        files_section = "\n\nFiles involved in this conversation:\n"
+        files_section += "  Read: #{file_ops[:read].join(', ')}\n" if file_ops[:read].any?
+        files_section += "  Modified: #{file_ops[:modified].join(', ')}\n" if file_ops[:modified].any?
+      end
+
+      summary_prompt = "Summarize the following conversation between a user and an AI coding assistant. " \
+        "Preserve all important details: file paths discussed, code changes made, errors encountered, " \
+        "decisions reached, and any unresolved issues. Be concise but complete.\n\n" \
+        "Conversation:\n#{format_messages(messages)}#{files_section}"
+
+      msgs = [
+        Message::System.new("You are a helpful assistant that summarizes conversations concisely."),
+        Message::User.new(summary_prompt)
+      ]
+
+      response, _usage = @client.chat(messages: msgs, tools: [])
+      response&.content || "Summary unavailable"
+    end
+
+    # @api private
+    def format_messages(messages)
+      messages.map do |msg|
+        case msg
+        when Message::User
+          "User: #{msg.content}"
+        when Message::Assistant
+          tool_str = msg.tool_calls.any? ? " [called: #{msg.tool_calls.map(&:name).join(", ")}]" : ""
+          "Assistant: #{msg.content}#{tool_str}"
+        when Message::ToolResult
+          "Tool (#{msg.name}): #{truncate(msg.content.to_s, 200)}"
+        else
+          nil
+        end
+      end.compact.join("\n")
+    end
+
+    # @api private
+    def estimated_tokens(history)
+      @token_counter.count_messages(history)
+    end
+
+    # @api private
+    def truncate(text, max)
+      text.length > max ? "#{text[0...max]}..." : text
+    end
+  end
+end

data/lib/crimson/config.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Crimson
+  # Configuration model with JSON file persistence.
+  # Stores provider, model, API key, and other connection settings.
+  class Config
+    # @return [String, nil] provider name
+    # @return [String, nil] model identifier
+    # @return [String, nil] API key
+    # @return [String, nil] custom base URL
+    # @return [Integer] max tokens for responses
+    # @return [String, nil] thinking level (off/low/medium/high)
+    attr_reader :provider, :model, :api_key, :base_url, :max_tokens, :thinking_level
+
+    # Valid thinking level values.
+    VALID_THINKING_LEVELS = %w[off low medium high].freeze
+
+    # @param provider [String, nil]
+    # @param model [String, nil]
+    # @param api_key [String, nil]
+    # @param base_url [String, nil]
+    # @param max_tokens [Integer]
+    # @param thinking_level [String, nil]
+    def initialize(provider: nil, model: nil, api_key: nil, base_url: nil, max_tokens: 8192, thinking_level: nil)
+      @provider = provider
+      @model = model
+      @api_key = api_key
+      @base_url = base_url
+      @max_tokens = max_tokens
+      @thinking_level = validate_thinking_level(thinking_level)
+    end
+
+    # Load configuration from the JSON config file.
+    # @return [Config]
+    def self.load
+      return new unless File.exist?(Crimson::CONFIG_FILE)
+
+      data = JSON.parse(File.read(Crimson::CONFIG_FILE))
+      new(
+        provider: data["provider"],
+        model: data["model"],
+        api_key: data["api_key"],
+        base_url: data["base_url"],
+        max_tokens: data["max_tokens"] || 1000,
+        thinking_level: data["thinking_level"]
+      )
+    rescue JSON::ParserError => e
+      raise Error, "Invalid config file: #{e.message}"
+    end
+
+    # Persist configuration to the JSON config file with restricted permissions.
+    # @return [void]
+    def save
+      FileUtils.mkdir_p(File.dirname(Crimson::CONFIG_FILE))
+
+      data = {
+        provider: @provider,
+        model: @model,
+        api_key: @api_key,
+        base_url: @base_url,
+        max_tokens: @max_tokens,
+        thinking_level: @thinking_level
+      }
+
+      File.write(Crimson::CONFIG_FILE, JSON.pretty_generate(data))
+      File.chmod(0o600, Crimson::CONFIG_FILE)
+    end
+
+    # @return [Boolean] whether required fields are present
+    def valid?
+      return false if @provider.nil? || @provider.empty?
+      return false if @model.nil? || @model.empty?
+      return false if @api_key.nil? || @api_key.empty?
+      return false if @provider == "custom" && (@base_url.nil? || @base_url.empty?)
+      true
+    end
+
+    # @param level [String, nil]
+    def thinking_level=(level)
+      @thinking_level = validate_thinking_level(level)
+    end
+
+    private
+
+    # @param level [String, nil]
+    # @return [String, nil]
+    def validate_thinking_level(level)
+      return nil if level.nil?
+      level = level.to_s.downcase
+      VALID_THINKING_LEVELS.include?(level) ? level : nil
+    end
+  end
+end