crimson-code 0.1.0

data/lib/crimson/project_context.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Crimson
+  # Auto-detects project language, framework, package manager, and testing tools.
+  # Also loads project context files (AGENTS.md, CLAUDE.md, etc.) from directory tree.
+  class ProjectContext
+    # File names considered as project instruction files.
+    CONTEXT_FILE_NAMES = %w[
+      AGENTS.md AGENTS.MD
+      CLAUDE.md CLAUDE.MD
+      GEMINI.md GEMINI.MD
+    ].freeze
+
+    # Detect project context (language, framework, package manager, git status).
+    # @param root_dir [String] project root directory
+    # @return [String] formatted context string
+    def self.detect(root_dir = Dir.pwd)
+      context = []
+      context << "Working directory: #{root_dir}"
+      context << "OS: #{RUBY_PLATFORM}"
+
+      lang = detect_language(root_dir)
+      context << "Language: #{lang}" if lang
+
+      framework = detect_framework(root_dir)
+      context << "Framework: #{framework}" if framework
+
+      pkg = detect_package_manager(root_dir)
+      context << "Package manager: #{pkg}" if pkg
+
+      testing = detect_testing(root_dir)
+      context << "Testing: #{testing}" if testing
+
+      git = detect_git(root_dir)
+      context << "Git: #{git}" if git
+
+      context.join("\n")
+    end
+
+    # Load project context files (AGENTS.md, CLAUDE.md, GEMINI.md) walking up to git root.
+    # @param root_dir [String] starting directory
+    # @return [Array<Hash>] array of { path:, content: } hashes
+    def self.load_context_files(root_dir = Dir.pwd)
+      files = []
+      seen_paths = Set.new
+      dir = File.expand_path(root_dir)
+
+      loop do
+        CONTEXT_FILE_NAMES.each do |name|
+          path = File.join(dir, name)
+          next unless File.exist?(path)
+          real = File.realpath(path) rescue File.expand_path(path)
+          next if seen_paths.include?(real)
+
+          seen_paths.add(real)
+          files << { path: path, content: File.read(path) }
+        end
+
+        break if git_root?(dir)
+        parent = File.dirname(dir)
+        break if parent == dir
+        dir = parent
+      end
+
+      global = File.join(Crimson::CONFIG_DIR, "AGENTS.md")
+      if File.exist?(global)
+        real = File.realpath(global) rescue File.expand_path(global)
+        unless seen_paths.include?(real)
+          files << { path: global, content: File.read(global) }
+        end
+      end
+
+      files
+    end
+
+    # Format context files into an XML-like string for the system prompt.
+    # @param files [Array<Hash>, nil] array of { path:, content: }
+    # @return [String]
+    def self.format_context_files(files)
+      return "" if files.nil? || files.empty?
+
+      parts = ["<project_context>", "", "Project-specific instructions and guidelines:", ""]
+      files.each do |f|
+        parts << "<project_instructions path=\"#{f[:path]}\">"
+        parts << f[:content]
+        parts << "</project_instructions>"
+        parts << ""
+      end
+      parts << "</project_context>"
+      parts.join("\n")
+    end
+
+    # @api private
+    def self.git_root?(dir)
+      Dir.exist?(File.join(dir, ".git"))
+    end
+
+    # @api private
+    def self.detect_language(root_dir)
+      indicators = {
+        "Ruby"     => ["Gemfile", "*.rb", "*.gemspec"],
+        "Python"   => ["requirements.txt", "pyproject.toml", "*.py", "Pipfile"],
+        "TypeScript" => ["tsconfig.json", "*.ts", "*.tsx"],
+        "JavaScript" => ["package.json", "*.js", "*.jsx"],
+        "Go"       => ["go.mod", "*.go"],
+        "Rust"     => ["Cargo.toml", "*.rs"],
+        "Java"     => ["pom.xml", "build.gradle", "*.java"],
+        "Elixir"   => ["mix.exs", "*.ex"],
+      }
+
+      indicators.each do |lang, patterns|
+        patterns.each do |pattern|
+          return lang if Dir.glob(File.join(root_dir, pattern)).any?
+        end
+      end
+
+      nil
+    end
+
+    # @api private
+    def self.detect_framework(root_dir)
+      return "Rails" if File.exist?(File.join(root_dir, "bin", "rails"))
+      return "Sinatra" if gem_in_gemfile?(root_dir, "sinatra")
+      return "Hanami" if gem_in_gemfile?(root_dir, "hanami")
+      return "Next.js" if file_has_dep?(root_dir, "package.json", "next")
+      return "React" if file_has_dep?(root_dir, "package.json", "react")
+      return "Vue" if file_has_dep?(root_dir, "package.json", "vue")
+      return "Express" if file_has_dep?(root_dir, "package.json", "express")
+      return "Django" if File.exist?(File.join(root_dir, "manage.py"))
+      return "Flask" if file_has_dep?(root_dir, "requirements.txt", "flask")
+      nil
+    end
+
+    # @api private
+    def self.detect_package_manager(root_dir)
+      return "bundler" if File.exist?(File.join(root_dir, "Gemfile"))
+      return "npm" if File.exist?(File.join(root_dir, "package-lock.json"))
+      return "yarn" if File.exist?(File.join(root_dir, "yarn.lock"))
+      return "pnpm" if File.exist?(File.join(root_dir, "pnpm-lock.yaml"))
+      return "pip" if File.exist?(File.join(root_dir, "requirements.txt"))
+      return "cargo" if File.exist?(File.join(root_dir, "Cargo.toml"))
+      return "go modules" if File.exist?(File.join(root_dir, "go.mod"))
+      nil
+    end
+
+    # @api private
+    def self.detect_testing(root_dir)
+      return "RSpec" if File.exist?(File.join(root_dir, ".rspec")) || gem_in_gemfile?(root_dir, "rspec")
+      return "Minitest" if Dir.glob(File.join(root_dir, "test/**/*_test.rb")).any?
+      return "Jest" if file_has_dep?(root_dir, "package.json", "jest")
+      return "pytest" if File.exist?(File.join(root_dir, "pytest.ini"))
+      return "Go testing" if Dir.glob(File.join(root_dir, "**/*_test.go")).any?
+      nil
+    end
+
+    # @api private
+    def self.detect_git(root_dir)
+      return nil unless Dir.exist?(File.join(root_dir, ".git"))
+
+      branch = `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+      return nil if branch.empty?
+
+      dirty = !`git status --porcelain 2>/dev/null`.strip.empty?
+      status = dirty ? "#{branch} (dirty)" : "#{branch} (clean)"
+      status
+    end
+
+    # @api private
+    def self.gem_in_gemfile?(root_dir, gem_name)
+      gemfile = File.join(root_dir, "Gemfile")
+      return false unless File.exist?(gemfile)
+      File.read(gemfile).include?(gem_name)
+    end
+
+    # @api private
+    def self.file_has_dep?(root_dir, filename, dep_name)
+      path = File.join(root_dir, filename)
+      return false unless File.exist?(path)
+      File.read(path).include?(dep_name)
+    end
+  end
+end

data/lib/crimson/providers.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Crimson
+  # @!parse
+  #   PROVIDERS = Hash[Symbol, Hash]
+  # Provider definitions including base URLs, SDK type, and auth header builders.
+  # Each entry maps a provider symbol to its configuration hash.
+  PROVIDERS = {
+    openai: {
+      name: "OpenAI",
+      base_url: "https://api.openai.com/v1",
+      sdk: :openai,
+      auth_headers: ->(key) { { "Authorization" => "Bearer #{key}" } }
+    },
+    anthropic: {
+      name: "Anthropic",
+      base_url: "https://api.anthropic.com/v1",
+      sdk: :anthropic,
+      auth_headers: ->(key) { { "x-api-key" => key, "anthropic-version" => "2023-06-01" } }
+    },
+    openrouter: {
+      name: "OpenRouter",
+      base_url: "https://openrouter.ai/api/v1",
+      sdk: :openai,
+      auth_headers: ->(key) { { "Authorization" => "Bearer #{key}" } }
+    },
+    mistral: {
+      name: "Mistral",
+      base_url: "https://api.mistral.ai/v1",
+      sdk: :openai,
+      auth_headers: ->(key) { { "Authorization" => "Bearer #{key}" } }
+    },
+    xai: {
+      name: "xAI (Grok)",
+      base_url: "https://api.x.ai/v1",
+      sdk: :openai,
+      auth_headers: ->(key) { { "Authorization" => "Bearer #{key}" } }
+    },
+    custom: {
+      name: "Custom (OpenAI-compatible)",
+      base_url: nil,
+      sdk: :openai,
+      auth_headers: ->(key) { { "Authorization" => "Bearer #{key}" } }
+    }
+  }
+
+  # Endpoint path suffix appended to provider base URLs to fetch available models.
+  MODELS_ENDPOINT = "/models"
+end

data/lib/crimson/repl.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require "reline"
+require "pastel"
+
+module Crimson
+  # Interactive REPL with readline support, slash commands, and session management.
+  class Repl
+    # @param agent [Agent]
+    def initialize(agent)
+      @agent = agent
+      @pastel = Pastel.new
+      @output_handler = OutputHandler.new
+      @output_handler.attach(agent)
+      setup_readline
+    end
+
+    # Start the REPL event loop.
+    # @return [void]
+    def start
+      puts @pastel.bold("Crimson v#{VERSION}")
+      puts @pastel.dim("Type /help for commands, /exit to quit")
+      puts
+
+      loop do
+        input = Reline.readline("> ", true)
+
+        break if input.nil?
+        input = input.strip
+        break if input == "/exit" || input == "/quit"
+        next if input.empty?
+
+        if input.start_with?("/")
+          handle_command(input)
+        else
+          @agent.prompt(input)
+        end
+      rescue => e
+        puts @pastel.red("Error: #{e.message}")
+      end
+
+      puts @pastel.dim("Goodbye!")
+    end
+
+    private
+
+    # @api private
+    def handle_command(input)
+      case input
+      when "/help"
+        puts @pastel.bold("Commands:")
+        puts "  /help       Show help message"
+        puts "  /clear      Clear conversation history"
+        puts "  /model      Switch model (interactive selector)"
+        puts "  /thinking   Set thinking level (off/low/medium/high)"
+        puts "  /tools      List available tools"
+        puts "  /save       Save conversation to file"
+        puts "  /load       Load conversation from file"
+        puts "  /usage      Show token usage and cost"
+        puts "  /sessions   List sessions for current directory"
+        puts "  /name       Set session name"
+        puts "  /session    Show session info"
+        puts "  /fork       Fork current session into new branch"
+        puts "  /tree       Show conversation tree"
+        puts "  /compact    Compact conversation history"
+        puts "  /exit       Exit crimson"
+      when "/clear"
+        @agent.reset
+        puts @pastel.dim("Conversation cleared.")
+      when "/model"
+        handle_model_switch
+      when "/thinking"
+        handle_thinking
+      when "/tools"
+        puts @pastel.bold("Available tools:")
+        @agent.tool_registry.tool_names.each do |name|
+          puts "  - #{name}"
+        end
+      when "/save"
+        puts @agent.save_history
+      when "/load"
+        puts @agent.load_history
+      when "/usage"
+        usage = @agent.token_usage
+        cost = @agent.cost_tracker.total_cost
+        puts @pastel.bold("Token usage:")
+        puts "  Prompt:     #{usage[:prompt]}"
+        puts "  Completion: #{usage[:completion]}"
+        puts "  Total:      #{usage[:total]}"
+        puts "  Cost:       $#{format('%.4f', cost)}" if cost > 0
+      when "/sessions"
+        handle_sessions
+      when "/name"
+        handle_name
+      when "/session"
+        handle_session_info
+      when "/fork"
+        handle_fork
+      when "/tree"
+        handle_tree
+      when "/compact"
+        if @agent.compactor
+          result = @agent.compact!
+          puts @pastel.dim(result)
+        else
+          puts @pastel.yellow("Compaction not enabled.")
+        end
+      else
+        if input.start_with?("/name ")
+          handle_name_set(input[6..].strip)
+        else
+          puts @pastel.yellow("Unknown command: #{input}. Type /help for commands.")
+        end
+      end
+    end
+
+    # @api private
+    def handle_sessions
+      return puts(@pastel.dim("No active session.")) unless @agent.session_id
+
+      manager = SessionManager.new
+      sessions = manager.list(cwd: Dir.pwd)
+      if sessions.empty?
+        puts @pastel.dim("No sessions found.")
+      else
+        puts @pastel.bold("Sessions:")
+        sessions.each do |s|
+          current = s.id == @agent.session_id ? " (current)" : ""
+          name_str = s.name ? "[#{s.name}] " : ""
+          preview = s.preview || "(no preview)"
+          puts "  #{@pastel.cyan(s.id[0..7])} #{name_str}#{preview} #{s.last_timestamp}#{current}"
+        end
+      end
+    end
+
+    # @api private
+    def handle_model_switch
+      config = @agent.config || Crimson.config
+      puts @pastel.dim("Current: #{PROVIDERS[config.provider.to_sym][:name]} / #{config.model}")
+      puts
+
+      begin
+        prompt = TTY::Prompt.new
+        models = fetch_available_models(config)
+        if models.empty?
+          puts @pastel.yellow("Could not fetch model list. Showing current model only.")
+          return
+        end
+
+        selected = prompt.select("Select model:", models.map { |m| { name: m, value: m } })
+        @agent.switch_model(selected)
+        @agent.config.save
+        puts @pastel.dim("Switched to: #{selected}")
+      rescue => e
+        puts @pastel.red("Error switching model: #{e.message}")
+      end
+    end
+
+    # @api private
+    def fetch_available_models(config)
+      require "net/http"
+      require "uri"
+      provider = PROVIDERS[config.provider.to_sym]
+      base_url = config.base_url || provider[:base_url]
+      url = URI("#{base_url}/models")
+
+      headers = provider[:auth_headers].call(config.api_key)
+      http = Net::HTTP.new(url.host, url.port)
+      http.use_ssl = url.scheme == "https"
+      http.open_timeout = 5
+      http.read_timeout = 10
+
+      request = Net::HTTP::Get.new(url.request_uri, headers)
+      response = http.request(request)
+
+      return [] unless response.is_a?(Net::HTTPSuccess)
+      data = JSON.parse(response.body)
+      (data["data"] || []).map { |m| m["id"] }.sort
+    rescue
+      []
+    end
+
+    # @api private
+    def handle_thinking
+      config = @agent.config || Crimson.config
+      current = config.thinking_level || "off"
+      puts @pastel.dim("Current thinking level: #{current}")
+      puts
+
+      begin
+        prompt = TTY::Prompt.new
+        level = prompt.select("Thinking level:", %w[off low medium high].map { |l| { name: l, value: l } })
+        config.thinking_level = level
+        config.save
+        @agent.config = config
+        puts @pastel.dim("Thinking level set to: #{level}")
+      rescue => e
+        puts @pastel.red("Error setting thinking level: #{e.message}")
+      end
+    end
+
+    # @api private
+    def handle_name
+      return puts(@pastel.yellow("No active session.")) unless @agent.session_id
+      puts @pastel.dim("Usage: /name <session name>")
+    end
+
+    # @api private
+    def handle_name_set(name)
+      return puts(@pastel.yellow("No active session.")) unless @agent.session_id
+      return puts(@pastel.yellow("Usage: /name <session name>")) if name.empty?
+
+      manager = SessionManager.new
+      manager.set_name(@agent.session_id, cwd: Dir.pwd, name: name)
+      puts @pastel.dim("Session name set to: #{name}")
+    end
+
+    # @api private
+    def handle_session_info
+      return puts(@pastel.dim("No active session.")) unless @agent.session_id
+
+      manager = SessionManager.new
+      header = manager.load_header(@agent.session_id, cwd: Dir.pwd)
+      entries = manager.load(@agent.session_id, cwd: Dir.pwd)
+
+      puts @pastel.bold("Session info:")
+      puts "  ID:       #{@agent.session_id}"
+      puts "  Name:     #{header&.dig('name') || '(unnamed)'}" if header
+      puts "  Created:  #{header&.dig('timestamp')}" if header
+      puts "  CWD:      #{@agent.session_cwd}"
+      puts "  Entries:  #{entries.length}"
+
+      usage = @agent.token_usage
+      puts "  Tokens:   #{usage[:total]} (#{usage[:prompt]} prompt + #{usage[:completion]} completion)"
+      cost = @agent.cost_tracker.total_cost
+      puts "  Cost:     $#{format('%.4f', cost)}" if cost > 0
+    end
+
+    # @api private
+    def handle_fork
+      return puts(@pastel.yellow("No active session to fork.")) unless @agent.session_id
+
+      manager = SessionManager.new
+      last_id = @agent.instance_variable_get(:@last_entry_id)
+      new_id = manager.fork(@agent.session_id, cwd: Dir.pwd, from_entry_id: last_id)
+      @agent.resume_session(new_id, cwd: Dir.pwd, session_manager: manager)
+      puts @pastel.dim("Forked to new session: #{new_id[0..7]}")
+    end
+
+    # @api private
+    def handle_tree
+      return puts(@pastel.dim("No active session.")) unless @agent.session_id
+
+      manager = SessionManager.new
+      entries = manager.load(@agent.session_id, cwd: Dir.pwd)
+      entries.each do |e|
+        case e.role
+        when "user"
+          preview = truncate(e.content.to_s, 60)
+          puts "  #{@pastel.cyan("⏺")} #{preview}"
+        when "assistant"
+          tool_str = e.tool_calls.any? ? " [#{e.tool_calls.map { |t| t["name"] }.join(", ")}]" : ""
+          preview = truncate(e.content.to_s, 60)
+          puts "  #{@pastel.dim("↳ #{preview}#{tool_str}")}"
+        when "tool_result"
+          preview = truncate(e.content.to_s, 40)
+          puts "  #{@pastel.dim("  → #{e.tool_name}: #{preview}")}"
+        end
+      end
+    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
+
+    # @api private
+    def setup_readline
+      Reline.completion_proc = method(:file_path_completion)
+    end
+
+    # @api private
+    def file_path_completion(input)
+      prefix = input.strip
+      return [] unless prefix.start_with?("@", "./", "~/", "/")
+
+      path_prefix = prefix.start_with?("@") ? prefix[1..] : prefix
+      expanded = File.expand_path(path_prefix)
+
+      if File.directory?(expanded)
+        Dir.entries(expanded)
+          .reject { |e| e.start_with?(".") }
+          .map { |e| prefix.end_with?("/") ? "#{prefix}#{e}" : "#{prefix}/#{e}" }
+      else
+        dir = File.dirname(expanded)
+        base = File.basename(expanded)
+        return [] unless Dir.exist?(dir)
+
+        Dir.entries(dir)
+          .reject { |e| e.start_with?(".") }
+          .select { |e| e.downcase.start_with?(base.downcase) }
+          .map { |e| prefix.include?("/") ? "#{File.dirname(prefix)}/#{e}" : e }
+      end
+    rescue => e
+      []
+    end
+  end
+end

data/lib/crimson/retry_handler.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Crimson
+  # Retry logic for API calls with exponential backoff and retry-After header support.
+  module RetryHandler
+    # Maximum number of retry attempts.
+    MAX_RETRIES = 3
+    # Base delay in seconds for exponential backoff.
+    BASE_DELAY = 1.0
+    # Maximum delay cap in seconds.
+    MAX_DELAY = 30.0
+
+    # Patterns in error messages that indicate a retry is appropriate.
+    RETRYABLE_MESSAGES = [
+      /rate.?limit/i,
+      /too many requests/i,
+      /429/,
+      /5\d{2}/,
+      /timeout/i,
+      /timed?\s*out/i,
+      /connection.*reset/i,
+      /connection.*refused/i,
+      /ECONNRESET/,
+      /ECONNREFUSED/,
+      /ETIMEDOUT/,
+      /ENOTFOUND/,
+      /network/i,
+      /overloaded/i,
+      /capacity/i,
+      /server error/i,
+      /service unavailable/i,
+      /bad gateway/i,
+      /gateway timeout/i,
+      /internal server error/i
+    ].freeze
+
+    # Execute a block with retry logic.
+    # @param max_retries [Integer] maximum retry attempts
+    # @param base_delay [Float] base delay in seconds
+    # @param max_delay [Float] maximum delay cap
+    # @yield block to execute and potentially retry
+    # @return [Object] the result of the block
+    # @raise [StandardError] if all retries are exhausted or error is non-retryable
+    def self.with_retry(max_retries: MAX_RETRIES, base_delay: BASE_DELAY, max_delay: MAX_DELAY)
+      attempts = 0
+      last_error = nil
+
+      loop do
+        attempts += 1
+        begin
+          return yield
+        rescue => e
+          last_error = e
+          raise e if attempts > max_retries
+          raise e unless retryable?(e)
+
+          delay = compute_delay(e, attempts, base_delay, max_delay)
+          sleep delay
+        end
+      end
+    end
+
+    # Check whether an error is retryable based on its message.
+    # @param error [StandardError]
+    # @return [Boolean]
+    def self.retryable?(error)
+      message = "#{error.class}: #{error.message}"
+      RETRYABLE_MESSAGES.any? { |pattern| message.match?(pattern) }
+    end
+
+    # Compute delay using exponential backoff, respecting Retry-After headers.
+    # @param error [StandardError]
+    # @param attempt [Integer] current attempt number
+    # @param base_delay [Float]
+    # @param max_delay [Float]
+    # @return [Float] delay in seconds
+    def self.compute_delay(error, attempt, base_delay, max_delay)
+      retry_after = extract_retry_after(error)
+      return [retry_after, max_delay].min if retry_after && retry_after > 0
+
+      delay = [base_delay * (2 ** (attempt - 1)), max_delay].min
+      delay + rand * 0.5
+    end
+
+    # Extract Retry-After header from an error response.
+    # @api private
+    def self.extract_retry_after(error)
+      return nil unless error.respond_to?(:response)
+
+      response = error.response
+      return nil unless response.is_a?(Hash)
+
+      headers = response[:headers] || response["headers"]
+      return nil unless headers.is_a?(Hash)
+
+      retry_after = headers["Retry-After"] || headers["retry-after"]
+      return nil unless retry_after
+
+      retry_after.to_f
+    rescue
+      nil
+    end
+  end
+end