crimson-code 0.1.0

data/lib/crimson/cost_tracker.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Crimson
+  # Model pricing in USD per million tokens.
+  # @!parse
+  #   MODEL_PRICING = Hash[String, Hash]
+  MODEL_PRICING = {
+    "gpt-4o" => { input: 2.50, output: 10.00 },
+    "gpt-4o-mini" => { input: 0.15, output: 0.60 },
+    "gpt-4-turbo" => { input: 10.00, output: 30.00 },
+    "gpt-3.5-turbo" => { input: 0.50, output: 1.50 },
+    "claude-sonnet-4-20250514" => { input: 3.00, output: 15.00 },
+    "claude-3-5-sonnet-20241022" => { input: 3.00, output: 15.00 },
+    "claude-3-5-haiku-20241022" => { input: 0.80, output: 4.00 },
+    "claude-3-opus-20240229" => { input: 15.00, output: 75.00 },
+    "claude-3-haiku-20240307" => { input: 0.25, output: 1.25 }
+  }
+
+  # Per-model cost tracking for API usage.
+  class CostTracker
+    # @return [Float] accumulated cost in USD
+    attr_reader :total_cost
+
+    def initialize
+      @total_cost = 0.0
+      @cost_breakdown = []
+    end
+
+    # Record usage for a single turn.
+    # @param model [String] model name
+    # @param usage [Hash, nil] token usage with prompt_tokens/completion_tokens
+    # @return [Hash] input/output/total cost for this turn
+    def track(model, usage)
+      pricing = MODEL_PRICING[model]
+      return { input: 0, output: 0, total: 0 } unless pricing && usage
+
+      prompt_tokens = usage[:prompt_tokens] || usage["prompt_tokens"] || usage[:prompt] || 0
+      completion_tokens = usage[:completion_tokens] || usage["completion_tokens"] || usage[:completion] || 0
+
+      input_cost = (pricing[:input] / 1_000_000.0) * prompt_tokens
+      output_cost = (pricing[:output] / 1_000_000.0) * completion_tokens
+      turn_cost = input_cost + output_cost
+
+      @total_cost += turn_cost
+      @cost_breakdown << { input: input_cost, output: output_cost, total: turn_cost }
+
+      { input: input_cost, output: output_cost, total: turn_cost }
+    end
+
+    # @return [Array<Hash>] per-turn cost breakdown
+    def breakdown
+      @cost_breakdown.dup
+    end
+
+    # Reset all tracked costs.
+    # @return [void]
+    def reset
+      @total_cost = 0.0
+      @cost_breakdown = []
+    end
+  end
+end

data/lib/crimson/formatter.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Crimson
+  # ANSI-markdown formatter for rendering Markdown-formatted text with terminal colors.
+  module Formatter
+    @pastel = Pastel.new(enabled: true)
+    @in_code_block = false
+
+    class << self
+      # Reset the code block tracking state.
+      # @return [void]
+      def reset
+        @in_code_block = false
+      end
+
+      # Format a single line of Markdown text with ANSI styling.
+      # @param line [String, nil]
+      # @return [String] styled output
+      def format_line(line)
+        return "" if line.nil?
+
+        if @in_code_block
+          if line.start_with?("```")
+            @in_code_block = false
+            @pastel.dim("```")
+          else
+            line
+          end
+        elsif line.start_with?("```")
+          @in_code_block = true
+          lang = line.sub(/^```\s*/, "").strip
+          lang.empty? ? @pastel.dim("```") : @pastel.dim("``` #{lang}")
+        else
+          style_inline(line)
+        end
+      end
+
+      # @return [Boolean] whether currently inside a code block
+      def in_code_block?
+        @in_code_block
+      end
+
+      private
+
+      # Apply inline Markdown styling (headers, bold, code, links, etc.).
+      # @api private
+      def style_inline(line)
+        result = line.dup
+
+        header_re = Regexp.new('^\#{1,6}\s+(.+)$')
+        if (m = result.match(header_re))
+          return @pastel.bold.yellow(m[1])
+        end
+
+        result = result.gsub(/^(\s{0,3})([-*+])\s/) do
+          "#{$1}#{@pastel.cyan($2)} "
+        end
+
+        result = result.gsub(/^(\s{0,3})(\d+\.)\s/) do
+          "#{$1}#{@pastel.cyan($2)} "
+        end
+
+        result = result.gsub(/^>\s?(.*)$/) do
+          @pastel.dim("│ ") + @pastel.dim($1)
+        end
+
+        if result.strip =~ /^-{3,}$|^_{3,}$|^\*{3,}$/
+          result = @pastel.dim("─" * 40)
+        end
+
+        result = result.gsub(/\[([^\]]+)\]\(([^)]+)\)/) do
+          @pastel.underline($1) + @pastel.dim(" (#{$2})")
+        end
+
+        result = result.gsub(/`([^`]+)`/) do
+          @pastel.cyan($1)
+        end
+
+        result = result.gsub(/\*\*([^*]+)\*\*/) do
+          @pastel.bold($1)
+        end
+
+        result = result.gsub(/(?<!\*)\*([^*]+)\*(?!\*)/) do
+          @pastel.italic($1)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/crimson/message.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Crimson
+  # Namespace for message types used in conversation history.
+  module Message
+    # Base class for all message types.
+    # @abstract
+    class Base
+      # @return [String] the role name (e.g. "system", "user", "assistant", "tool")
+      attr_reader :role
+
+      # @param role [String]
+      def initialize(role)
+        @role = role
+      end
+    end
+
+    # A system-level message carrying instructions or context.
+    class System < Base
+      # @return [String] the system message content
+      attr_reader :content
+
+      # @param content [String]
+      def initialize(content)
+        super("system")
+        @content = content
+      end
+
+      # @return [Hash] OpenAI-compatible representation
+      def to_openai_h
+        { role: "system", content: @content }
+      end
+
+      # @return [Hash] Anthropic-compatible representation
+      def to_anthropic_h
+        { type: "text", text: @content }
+      end
+    end
+
+    # A user message.
+    class User < Base
+      # @return [String] the user message content
+      attr_reader :content
+
+      # @param content [String]
+      def initialize(content)
+        super("user")
+        @content = content
+      end
+
+      # @return [Hash] OpenAI-compatible representation
+      def to_openai_h
+        { role: "user", content: @content }
+      end
+
+      # @return [Hash] Anthropic-compatible representation
+      def to_anthropic_h
+        { role: "user", content: @content }
+      end
+    end
+
+    # An assistant (model) response, optionally containing tool calls.
+    class Assistant < Base
+      # @return [String, nil] the text content
+      # @return [Array<ToolCall>] any tool calls requested
+      attr_reader :content, :tool_calls
+
+      # @param content [String, nil]
+      # @param tool_calls [Array<ToolCall>]
+      def initialize(content: nil, tool_calls: [])
+        super("assistant")
+        @content = content
+        @tool_calls = tool_calls
+      end
+
+      # @return [Boolean] whether this message contains tool calls
+      def tool_call?
+        !@tool_calls.nil? && !@tool_calls.empty?
+      end
+
+      # @return [Hash] OpenAI-compatible representation
+      def to_openai_h
+        h = { role: "assistant" }
+        h[:content] = @content if @content
+        h[:tool_calls] = @tool_calls.map(&:to_openai_h) if tool_call?
+        h
+      end
+
+      # @return [Hash] Anthropic-compatible representation
+      def to_anthropic_h
+        content_blocks = []
+        content_blocks << { type: "text", text: @content } if @content && !@content.empty?
+        @tool_calls.each do |tc|
+          content_blocks << {
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: tc.arguments
+          }
+        end
+        { role: "assistant", content: content_blocks }
+      end
+    end
+
+    # Represents a tool/function call requested by the model.
+    class ToolCall
+      # @return [String] unique identifier for this tool call
+      # @return [String] name of the tool
+      # @return [Hash] arguments passed to the tool
+      attr_reader :id, :name, :arguments
+
+      # @param id [String]
+      # @param name [String]
+      # @param arguments [Hash]
+      def initialize(id:, name:, arguments: {})
+        @id = id
+        @name = name
+        @arguments = arguments
+      end
+
+      # @return [Hash] OpenAI-compatible tool call representation
+      def to_openai_h
+        {
+          id: @id,
+          type: "function",
+          function: {
+            name: @name,
+            arguments: JSON.generate(@arguments)
+          }
+        }
+      end
+    end
+
+    # The result of executing a tool call, sent back to the model.
+    class ToolResult < Base
+      # @return [String] the ID of the tool call this result belongs to
+      # @return [String] the tool name
+      # @return [String] the result content
+      attr_reader :tool_call_id, :name, :content
+
+      # @param tool_call_id [String]
+      # @param name [String]
+      # @param content [String]
+      def initialize(tool_call_id:, name:, content:)
+        super("tool")
+        @tool_call_id = tool_call_id
+        @name = name
+        @content = content
+      end
+
+      # @return [Hash] OpenAI-compatible representation
+      def to_openai_h
+        {
+          role: "tool",
+          tool_call_id: @tool_call_id,
+          content: @content
+        }
+      end
+
+      # @return [Hash] Anthropic-compatible representation
+      def to_anthropic_h
+        {
+          role: "user",
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: @tool_call_id,
+              content: @content
+            }
+          ]
+        }
+      end
+    end
+  end
+end

data/lib/crimson/output_handler.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require "set"
+require "pastel"
+
+module Crimson
+  # Streaming output handler with spinner, tool call logging, and usage statistics.
+  # Subscribes to agent events to provide real-time terminal feedback.
+  class OutputHandler
+    # Interval in seconds between render flushes.
+    RENDER_INTERVAL = 0.05
+    # Spinner animation frame characters.
+    SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"].freeze
+
+    # Visual styles for known tools (prefix color and label).
+    TOOL_STYLES = {
+      "read_file"      => { prefix: "→Read",   color: :blue   },
+      "write_file"     => { prefix: "→Write",  color: :green  },
+      "edit_file"      => { prefix: "→Edit",   color: :yellow },
+      "run_command"    => { prefix: "$",        color: :bright_white },
+      "search_files"   => { prefix: "✱Search", color: :cyan   },
+      "glob"           => { prefix: "✱Glob",   color: :cyan   },
+      "list_directory" => { prefix: "→List",   color: :cyan   }
+    }.freeze
+
+    # Extractors to pull display-relevant arguments from tool call argument hashes.
+    TOOL_ARG_EXTRACTORS = {
+      "read_file"      => ->(a) { a["path"] || a[:path] },
+      "write_file"     => ->(a) { a["path"] || a[:path] },
+      "edit_file"      => ->(a) { a["path"] || a[:path] },
+      "run_command"    => ->(a) { a["command"] || a[:command] },
+      "search_files"   => ->(a) { a["pattern"] || a[:pattern] },
+      "list_directory" => ->(a) { a["path"] || a[:path] },
+      "glob"           => ->(a) { a["pattern"] || a[:pattern] }
+    }.freeze
+
+    def initialize
+      @pastel = Pastel.new
+      @spinner_active = false
+      @first_token = false
+      @render_buffer = String.new
+      @render_thread = nil
+      @render_mutex = Mutex.new
+      @spinner_thread = nil
+      @seen_tool_calls = Set.new
+      @thinking_start = nil
+      @run_start = nil
+    end
+
+    # Subscribe to events on the given agent for output rendering.
+    # @param agent [Agent]
+    # @return [void]
+    def attach(agent)
+      agent.on(Agent::Events::AGENT_START) do
+        @first_token = false
+        Formatter.reset
+        @thinking_start = Time.now
+        @run_start = Time.now
+        start_spinner
+      end
+
+      agent.on(Agent::Events::MESSAGE_UPDATE) do |_event, delta:, **|
+        unless @first_token
+          stop_spinner
+          @first_token = true
+          if @thinking_start
+            elapsed = format("%.1fs", Time.now - @thinking_start)
+            puts @pastel.dim("+ Thought: #{elapsed}")
+            @thinking_start = nil
+          end
+        end
+        @render_mutex.synchronize { @render_buffer << delta }
+        start_render_thread unless @render_thread&.alive?
+      end
+
+      agent.on(Agent::Events::TOOL_EXECUTION_START) do |_event, tool_name:, args:, tool_call_id:, **|
+        next if @seen_tool_calls.include?(tool_call_id)
+        @seen_tool_calls << tool_call_id
+        stop_spinner
+        $stdout.write("\r\e[2K")
+        $stdout.flush
+        log_tool_call(tool_name, args)
+      end
+
+      agent.on(Agent::Events::TOOL_EXECUTION_END) do |_event, result:, is_error:, tool_call_id:, **|
+        next if tool_call_id && @seen_tool_calls.include?("#{tool_call_id}_end")
+        @seen_tool_calls << "#{tool_call_id}_end" if tool_call_id
+        next unless is_error
+        truncated = truncate(result.to_s, 120)
+        puts @pastel.red("  ✗ #{truncated}")
+      end
+
+      agent.on(Agent::Events::TOOL_EXECUTION_UPDATE) do |_event, tool_name:, partial_result:, **|
+        next unless tool_name == "run_command"
+        flush_render_buffer
+        $stdout.write("\r\e[2K #{@pastel.dim(partial_result)}")
+        $stdout.flush
+      end
+
+      agent.on(Agent::Events::TURN_START) do |_event, active_skills: []|
+        conditional = active_skills.reject { |s| s == "coding" }
+        unless conditional.empty?
+          stop_spinner
+          puts @pastel.dim("+ #{conditional.join(", ")}")
+        end
+        unless @first_token
+          @thinking_start = Time.now
+          start_spinner
+        end
+      end
+
+      agent.on(Agent::Events::AGENT_END) do
+        stop_spinner
+        flush_render_buffer(final: true)
+        @seen_tool_calls.clear
+        elapsed = @run_start ? format_elapsed(Time.now - @run_start) : ""
+        usage = agent.token_usage
+        parts = []
+        if usage[:total] > 0
+          cost = agent.cost_tracker.total_cost
+          cost_str = cost > 0 ? " ($#{format("%.4f", cost)})" : ""
+          parts << "tokens: #{usage[:prompt]}↑ #{usage[:completion]}↓ = #{usage[:total]}#{cost_str}"
+        end
+        parts << "time: #{elapsed}" unless elapsed.empty?
+        puts @pastel.dim("\n  #{parts.join("  ·  ")}") unless parts.empty?
+      end
+    end
+
+    private
+
+    # @api private
+    def log_tool_call(tool_name, args)
+      style = TOOL_STYLES[tool_name]
+      if style
+        detail = extract_tool_arg(tool_name, args) || ""
+        puts @pastel.decorate("#{style[:prefix]} ", style[:color]) + detail
+      else
+        detail = extract_tool_arg(tool_name, args)
+        puts @pastel.dim("→ #{tool_name}") + (detail ? " #{detail}" : "")
+      end
+    end
+
+    # @api private
+    def format_elapsed(seconds)
+      if seconds < 60
+        format("%.1fs", seconds)
+      else
+        mins = (seconds / 60).to_i
+        secs = format("%.0f", seconds - mins * 60)
+        "#{mins}m #{secs}s"
+      end
+    end
+
+    # @api private
+    def start_spinner
+      return if @spinner_active
+      @spinner_active = true
+      @spinner_thread = Thread.new do
+        i = 0
+        while @spinner_active
+          $stdout.write("\r  \e[36m#{SPINNER_FRAMES[i % SPINNER_FRAMES.length]}\e[0m Thinking...")
+          $stdout.flush
+          i += 1
+          sleep 0.08
+        end
+        $stdout.write("\r\e[2K")
+        $stdout.flush
+      end
+    end
+
+    # @api private
+    def stop_spinner
+      return unless @spinner_active
+      @spinner_active = false
+      @spinner_thread&.join(2)
+      @spinner_thread = nil
+      $stdout.write("\r\e[2K")
+      $stdout.flush
+    end
+
+    # @api private
+    def start_render_thread
+      @render_thread = Thread.new do
+        loop do
+          sleep RENDER_INTERVAL
+          break if flush_render_buffer == :empty
+        end
+      end
+    end
+
+    # @api private
+    def flush_render_buffer(final: false)
+      data = nil
+      @render_mutex.synchronize do
+        data = @render_buffer.dup
+        @render_buffer.clear
+      end
+      return :empty if data.nil? || data.empty?
+
+      output = String.new
+      lines = if final
+                data.split("\n", -1)
+              else
+                last_newline = data.rindex("\n")
+                if last_newline.nil?
+                  @render_mutex.synchronize { @render_buffer.prepend(data) }
+                  return :empty
+                end
+
+                complete = data[0..last_newline]
+                remainder = data[(last_newline + 1)..]
+                @render_mutex.synchronize { @render_buffer.prepend(remainder) } if remainder
+                complete.split("\n", -1)
+              end
+
+      lines.each do |line|
+        next if line.nil?
+        next if line.strip.empty?
+        if !output.empty? && header?(line)
+          output << "\n"
+        end
+        styled = Formatter.format_line(line)
+        output << styled << "\n"
+      end
+
+      $stdout.write(output)
+      $stdout.flush
+      nil
+    end
+
+    # @api private
+    def extract_tool_arg(tool_name, args)
+      return nil unless args.is_a?(Hash)
+      extractor = TOOL_ARG_EXTRACTORS[tool_name]
+      extractor ? extractor.call(args) : nil
+    rescue
+      nil
+    end
+
+    # @api private
+    def header?(line)
+      line.match?(Regexp.new('^\#{1,6}\s'))
+    end
+
+    # @api private
+    def truncate(text, max_len)
+      return "" if text.nil?
+      cleaned = text.gsub("\n", "\\n")
+      cleaned.length > max_len ? "#{cleaned[0...max_len]}..." : cleaned
+    end
+  end
+end