crimson-code 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3df897eea195e49b088f6fd2bb7d498290cc191da69a55a30545475736876eaf
+  data.tar.gz: a7fa71c191c8782939f15cb257229d5600e75592140dc76767e43a5c636f4754
+SHA512:
+  metadata.gz: 4714cb918e14e15109c89729c1afac71e57f7013c9077fde01a5b82964afca1c4b83a1183eeb94eb62ccc1ab9103a9606ddcd1b1c026f725d5c68cb46dcdf313
+  data.tar.gz: fbe43ebfd0431bdff2c281d98b41ff106c05e3033b05bb348fdfc43793748cd62e133df6f74fe377418f27bfd5645fb8b81fb01f6c604ea28eb972ad91c68064

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 cmoiadib
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,150 @@
+# Crimson
+
+[![CI](https://github.com/nankhor/crimson/actions/workflows/ci.yml/badge.svg)](https://github.com/nankhor/crimson/actions/workflows/ci.yml)
+[![Gem Version](https://img.shields.io/gem/v/crimson-code)](https://rubygems.org/gems/crimson-code)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
+[![Ruby](https://img.shields.io/badge/ruby-3.3%2B-red)](https://www.ruby-lang.org)
+
+A minimal Ruby-based coding agent that gets things done.
+
+## Quick Start
+
+```bash
+# Install
+gem install crimson-code
+
+# Configure your API key
+crimson setup
+
+# Start coding
+crimson "refactor this module to use dependency injection"
+```
+
+## Features
+
+- **Multi-provider support** — OpenAI, Anthropic, OpenRouter, Mistral, xAI, and any OpenAI-compatible endpoint
+- **Official SDKs** — Uses the official OpenAI and Anthropic Ruby gems
+- **Built-in tools** — Read, write, edit, list files, run commands, search code, and glob
+- **Streaming output** — Real-time response with styled markdown rendering (headers, bold, italic, code, lists, links, blockquotes)
+- **Colored tool display** — `→Read`, `→Write`, `→Edit`, `$ command`, `✱Search`, `✱Glob`, `→List` with per-tool colors
+- **Thinking indicator** — Spinner while thinking, with `+ Thought: X.Xs` timing on first token
+- **Run stats** — Token usage, cost, and elapsed time shown at end of every run
+- **Skills system** — Customize agent behavior with markdown files
+- **Session management** — Save, load, fork, and name conversation sessions per directory
+- **Conversation compaction** — Automatic and manual compaction to stay within context limits
+- **Cost tracking** — Real-time token usage and cost tracking per run
+- **Interactive REPL** — Conversational coding assistant with tab-completion and slash commands
+
+## Requirements
+
+- Ruby 3.3+
+
+## Installation
+
+### Via RubyGems
+
+```bash
+gem install crimson-code
+```
+
+### From source
+
+```bash
+git clone https://github.com/nankhor/crimson.git
+cd crimson
+bundle install
+bundle exec exe/crimson setup
+```
+
+## Configuration
+
+```bash
+crimson setup
+```
+
+This walks you through selecting a provider, entering your API key, and picking a model.
+
+Configuration is stored in `~/.crimson/config.json` (600 permissions).
+
+You can also set the API key via environment variables:
+
+| Variable | Description |
+|----------|-------------|
+| `OPENAI_API_KEY` | OpenAI API key |
+| `ANTHROPIC_API_KEY` | Anthropic API key |
+| `MISTRAL_API_KEY` | Mistral API key |
+| `XAI_API_KEY` | xAI API key |
+
+## Usage
+
+### Interactive REPL
+
+Start a conversational session:
+
+```bash
+crimson
+```
+
+Type your task and the agent will use its tools to read, write, and edit files in your project.
+
+### One-shot mode
+
+Pass a task directly as an argument:
+
+```bash
+crimson "add error handling to the database module"
+```
+
+The agent completes the task and exits, showing the full conversation and cost summary.
+
+### Example session
+
+```
+$ crimson
+Crimson v0.1.0
+Type /help for commands, /exit to quit
+
+> add a health check endpoint to the Sinatra app
+→Read config.ru ...
+→Read app.rb ...
+✱Search app.rb for "get" ...
+→Write app.rb ...
+Done. Added GET /health endpoint returning JSON status.
+Tokens: 1,234 ↑ | Cost: $0.0123 | Time: 12.3s
+```
+
+### Slash commands
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show available commands |
+| `/clear` | Clear conversation history |
+| `/model` | Switch model (interactive selector) |
+| `/thinking` | Set thinking level (off/low/medium/high) |
+| `/tools` | List available tools |
+| `/save` | Save conversation to file |
+| `/load` | Load conversation from file |
+| `/usage` | Show token usage and cost |
+| `/sessions` | List sessions for current directory |
+| `/name` | Set session name |
+| `/session` | Show session info |
+| `/fork` | Fork current session into new branch |
+| `/tree` | Show conversation tree |
+| `/compact` | Compact conversation history |
+| `/exit` | Exit crimson |
+
+## Skills
+
+Add `.md` files to `~/.crimson/skills/` to customize agent behavior. These are loaded into the system prompt automatically. Built-in skills are in the `skills/` directory for reference.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) and [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md).
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md).
+
+## License
+
+MIT

data/exe/crimson

@@ -0,0 +1,207 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "date"
+require "crimson"
+
+module Crimson
+  module CLI
+    def self.run(args)
+      flags = %w[--continue -c --resume --session --no-session --help -h]
+      has_flags = args.any? { |a| flags.include?(a) || a == "setup" }
+
+      if has_flags
+        command = args.first
+        case command
+        when "setup"
+          Crimson::Setup.run
+          return
+        when "--help", "-h"
+          print_help
+          return
+        end
+        start_repl
+        return
+      end
+
+      command = args.first
+
+      case command
+      when "help"
+        print_help
+      when nil
+        start_repl
+      when /^\//
+        start_repl
+      else
+        run_one_shot(args.join(" "))
+      end
+    end
+
+    def self.start_repl
+      unless Crimson.configured?
+        puts "Welcome to Crimson! Running initial setup..."
+        puts
+        Crimson::Setup.first_run
+      end
+
+      trust_manager = Crimson::TrustManager.new
+      unless trust_manager.trusted?(Dir.pwd)
+        return unless trust_manager.prompt_trust(Dir.pwd)
+      end
+
+      client = Crimson::Client.create(Crimson.config)
+      registry = Crimson::ToolRegistry.new
+      Crimson::Tools::ALL.each { |tool| registry.register(tool) }
+
+      system_prompt = nil
+      agent = Crimson::Agent.new(
+        client: client,
+        tool_registry: registry,
+        system_prompt: nil
+      )
+
+      agent.define_system_prompt = -> {
+        system_prompt ||= build_system_prompt(registry)
+      }
+
+      handle_session_flags(agent)
+
+      agent.enable_compaction!(client: client, model: Crimson.config&.model)
+
+      Crimson::Repl.new(agent).start
+    end
+
+    def self.handle_session_flags(agent)
+      args = ARGV.dup
+      session_manager = Crimson::SessionManager.new
+      pastel = Pastel.new
+
+      if args.include?("--no-session")
+        return
+      elsif args.include?("--continue") || args.include?("-c")
+        latest = session_manager.latest(cwd: Dir.pwd)
+        if latest
+          agent.resume_session(latest.id, cwd: Dir.pwd, session_manager: session_manager)
+          puts pastel.dim("Resumed session: #{latest.id[0..7]} (#{latest.preview})")
+        else
+          agent.start_session(cwd: Dir.pwd, session_manager: session_manager)
+        end
+      elsif args.include?("--resume")
+        sessions = session_manager.list(cwd: Dir.pwd)
+        if sessions.empty?
+          puts pastel.dim("No sessions found. Starting new session.")
+          agent.start_session(cwd: Dir.pwd, session_manager: session_manager)
+        else
+          prompt = TTY::Prompt.new
+          choices = sessions.map { |s| { name: "#{s.preview || "(no preview)"} (#{s.last_timestamp})", value: s.id } }
+          selected = prompt.select("Resume session:", choices)
+          agent.resume_session(selected, cwd: Dir.pwd, session_manager: session_manager)
+        end
+      elsif idx = args.index("--session")
+        session_id = args[idx + 1]
+        if session_id
+          begin
+            agent.resume_session(session_id, cwd: Dir.pwd, session_manager: session_manager)
+          rescue => e
+            puts pastel.red("Failed to resume session: #{e.message}")
+            exit 1
+          end
+        else
+          puts pastel.red("--session requires a session ID")
+          exit 1
+        end
+      else
+        agent.start_session(cwd: Dir.pwd, session_manager: session_manager)
+      end
+    end
+
+    def self.run_one_shot(task)
+      unless Crimson.configured?
+        puts "Welcome to Crimson! Running initial setup..."
+        puts
+        Crimson::Setup.first_run
+      end
+
+      trust_manager = Crimson::TrustManager.new
+      unless trust_manager.trusted?(Dir.pwd)
+        return unless trust_manager.prompt_trust(Dir.pwd)
+      end
+
+      client = Crimson::Client.create(Crimson.config)
+      registry = Crimson::ToolRegistry.new
+      Crimson::Tools::ALL.each { |tool| registry.register(tool) }
+
+      system_prompt = build_system_prompt(registry)
+
+      agent = Crimson::Agent.new(
+        client: client,
+        tool_registry: registry,
+        system_prompt: system_prompt
+      )
+
+      Crimson::OutputHandler.new.attach(agent)
+      agent.prompt(task)
+    end
+
+    def self.build_system_prompt(registry)
+      default_skill = read_default_skill
+
+      parts = [default_skill.strip]
+
+      context = Crimson::ProjectContext.detect
+      parts << "## Project Context\n\n#{context}" if context
+
+      context_files = Crimson::ProjectContext.load_context_files
+      formatted = Crimson::ProjectContext.format_context_files(context_files)
+      parts << formatted unless formatted.empty?
+
+      parts << "Current date: #{Date.today}"
+      parts << "Current working directory: #{Dir.pwd}"
+
+      parts.join("\n\n")
+    end
+
+    def self.read_default_skill
+      gem_skill = File.join(Crimson::SKILLS_DIR, "coding.md")
+      raw = if File.exist?(gem_skill)
+        File.read(gem_skill)
+      else
+        gem_root = File.expand_path("../..", __FILE__)
+        bundled = File.join(gem_root, "skills", "coding.md")
+        File.read(bundled)
+      end
+
+      strip_front_matter(raw)
+    end
+
+    def self.strip_front_matter(content)
+      return content unless content.start_with?("---")
+      parts = content.split("---", 3)
+      parts.length >= 3 ? parts[2].strip : content
+    end
+
+    def self.print_help
+      puts <<~HELP
+        Usage: crimson [command] [options] [task]
+
+        Commands:
+          setup              Configure your provider and API key
+          help               Show this help message
+
+        Session Options:
+          -c, --continue     Resume latest session
+          --resume           Browse sessions to resume
+          --session ID       Resume specific session
+          --no-session       Don't save session
+
+        Running without a command starts the interactive REPL.
+        Passing a task string runs it in one-shot mode:
+
+          crimson "fix the failing test in spec/foo_spec.rb"
+      HELP
+    end
+  end
+end
+
+Crimson::CLI.run(ARGV)

data/lib/crimson/agent/event_emitter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Crimson
+  class Agent
+    # Pub/sub event emitter for agent lifecycle events.
+    class EventEmitter
+      def initialize
+        @listeners = Hash.new { |h, k| h[k] = [] }
+      end
+
+      # Register a handler for an event type.
+      # @param event_type [Symbol]
+      # @yield handler block
+      # @return [Proc] the handler
+      def on(event_type, &handler)
+        @listeners[event_type] << handler
+        handler
+      end
+
+      # Remove a previously registered handler.
+      # @param event_type [Symbol]
+      # @param handler [Proc]
+      # @return [void]
+      def off(event_type, handler)
+        @listeners[event_type].delete(handler)
+      end
+
+      # Emit an event with keyword payload.
+      # @param event_type [Symbol]
+      # @param payload [Hash] forwarded as keyword arguments
+      # @return [void]
+      def emit(event_type, **payload)
+        @listeners[event_type].each do |handler|
+          handler.call(event_type, **payload)
+        end
+      end
+
+      # Remove all listeners.
+      # @return [void]
+      def clear
+        @listeners.clear
+      end
+
+      # Count listeners, optionally filtered by event type.
+      # @param event_type [Symbol, nil]
+      # @return [Integer]
+      def listener_count(event_type = nil)
+        if event_type
+          @listeners[event_type].size
+        else
+          @listeners.values.sum(&:size)
+        end
+      end
+    end
+  end
+end

data/lib/crimson/agent/events.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Crimson
+  class Agent
+    # Event type constants for the agent pub/sub system.
+    module Events
+      # Emitted when the agent begins processing a user request.
+      AGENT_START = :agent_start
+      # Emitted at the start of each agent turn.
+      TURN_START = :turn_start
+      # Emitted when a new message is created.
+      MESSAGE_START = :message_start
+      # Emitted with streaming text deltas during message generation.
+      MESSAGE_UPDATE = :message_update
+      # Emitted when a message is fully received.
+      MESSAGE_END = :message_end
+      # Emitted when a tool begins executing.
+      TOOL_EXECUTION_START = :tool_execution_start
+      # Emitted with partial results during tool execution (e.g. command output).
+      TOOL_EXECUTION_UPDATE = :tool_execution_update
+      # Emitted when a tool finishes execution.
+      TOOL_EXECUTION_END = :tool_execution_end
+      # Emitted at the end of each agent turn.
+      TURN_END = :turn_end
+      # Emitted when the agent finishes processing.
+      AGENT_END = :agent_end
+
+      # All known event types.
+      ALL = [
+        AGENT_START,
+        TURN_START,
+        MESSAGE_START,
+        MESSAGE_UPDATE,
+        MESSAGE_END,
+        TOOL_EXECUTION_START,
+        TOOL_EXECUTION_UPDATE,
+        TOOL_EXECUTION_END,
+        TURN_END,
+        AGENT_END
+      ].freeze
+    end
+  end
+end

data/lib/crimson/agent/steering.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module Crimson
+  class Agent
+    # Thread-safe queue for steering messages and follow-ups injected into agent turns.
+    class SteeringManager
+      def initialize
+        @steering_mutex = Mutex.new
+        @steering_queue = []
+        @follow_up_queue = []
+      end
+
+      # Enqueue a steering message.
+      # @param message [Message::User]
+      # @return [void]
+      def steer(message)
+        @steering_mutex.synchronize { @steering_queue << message }
+      end
+
+      # Enqueue a follow-up message.
+      # @param message [Message::User]
+      # @return [void]
+      def follow_up(message)
+        @steering_mutex.synchronize { @follow_up_queue << message }
+      end
+
+      # @return [Boolean] whether steering messages are queued
+      def has_steering?
+        @steering_mutex.synchronize { !@steering_queue.empty? }
+      end
+
+      # @return [Boolean] whether follow-up messages are queued
+      def has_follow_up?
+        @steering_mutex.synchronize { !@follow_up_queue.empty? }
+      end
+
+      # Dequeue a single steering message.
+      # @return [Message::User, nil]
+      def pop_steering
+        @steering_mutex.synchronize { @steering_queue.shift }
+      end
+
+      # Dequeue a single follow-up message.
+      # @return [Message::User, nil]
+      def pop_follow_up
+        @steering_mutex.synchronize { @follow_up_queue.shift }
+      end
+
+      # Dequeue all steering messages.
+      # @return [Array<Message::User>]
+      def pop_all_steering
+        @steering_mutex.synchronize do
+          msgs = @steering_queue.dup
+          @steering_queue.clear
+          msgs
+        end
+      end
+
+      # Dequeue all follow-up messages.
+      # @return [Array<Message::User>]
+      def pop_all_follow_up
+        @steering_mutex.synchronize do
+          msgs = @follow_up_queue.dup
+          @follow_up_queue.clear
+          msgs
+        end
+      end
+
+      # Clear all queued messages.
+      # @return [void]
+      def clear_all
+        @steering_mutex.synchronize do
+          @steering_queue.clear
+          @follow_up_queue.clear
+        end
+      end
+
+      # @return [Integer] number of queued steering messages
+      def steering_count
+        @steering_mutex.synchronize { @steering_queue.size }
+      end
+
+      # @return [Integer] number of queued follow-up messages
+      def follow_up_count
+        @steering_mutex.synchronize { @follow_up_queue.size }
+      end
+    end
+  end
+end

data/lib/crimson/agent/tool_executor.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module Crimson
+  class Agent
+    # Executes tool calls with parallel/sequential modes, hooks, and abort support.
+    class ToolExecutor
+      # @param tool_registry [ToolRegistry]
+      # @param events [EventEmitter]
+      # @param before_hook [Proc, nil]
+      # @param after_hook [Proc, nil]
+      # @param abort_signal [AbortSignal, nil]
+      def initialize(tool_registry, events, before_hook: nil, after_hook: nil, abort_signal: nil)
+        @tool_registry = tool_registry
+        @events = events
+        @before_hook = before_hook
+        @after_hook = after_hook
+        @abort_signal = abort_signal
+      end
+
+      # Execute a list of tool calls.
+      # Tools marked as sequential run one at a time; others run in parallel.
+      # @param tool_calls [Array<Message::ToolCall>]
+      # @param history [Array<Message::Base>]
+      # @return [Array<Hash>] results with keys :tool_call, :result, :is_error
+      def execute(tool_calls, history)
+        sequential = tool_calls.any? { |tc| tool_sequential?(tc) }
+
+        if sequential
+          execute_sequential(tool_calls, history)
+        else
+          execute_parallel(tool_calls, history)
+        end
+      end
+
+      private
+
+      # @api private
+      def execute_parallel(tool_calls, history)
+        results = {}
+        mutex = Mutex.new
+
+        threads = tool_calls.map do |tc|
+          Thread.new do
+            result = execute_single(tc, history)
+            mutex.synchronize { results[tc.id] = result }
+          end
+        end
+
+        threads.each(&:join)
+
+        tool_calls.map { |tc| results[tc.id] }
+      end
+
+      # @api private
+      def execute_sequential(tool_calls, history)
+        tool_calls.map { |tc| execute_single(tc, history) }
+      end
+
+      # @api private
+      def execute_single(tc, history)
+        args_display = tc.arguments.is_a?(Hash) ? tc.arguments : tc.arguments.to_s
+        @events.emit(Events::TOOL_EXECUTION_START,
+          tool_call_id: tc.id, tool_name: tc.name, args: args_display)
+
+        if @before_hook
+          hook_result = @before_hook.call(tool_call: tc, args: tc.arguments, history: history)
+          if hook_result.is_a?(Hash) && hook_result[:block]
+            result = "Blocked: #{hook_result[:reason]}"
+            @events.emit(Events::TOOL_EXECUTION_END,
+              tool_call_id: tc.id, result: result, is_error: true)
+            return { tool_call: tc, result: result, is_error: true }
+          end
+        end
+
+        if tc.name == "run_command"
+          tool = @tool_registry.lookup("run_command")
+          if tool
+            tool.on_update = -> (cmd, elapsed, bytes) {
+              @events.emit(Events::TOOL_EXECUTION_UPDATE,
+                tool_call_id: tc.id, tool_name: tc.name,
+                partial_result: "running (#{elapsed.round(1)}s, #{bytes} bytes)")
+            }
+          end
+        end
+
+        result = @tool_registry.execute(tc.name, tc.arguments, abort_signal: @abort_signal)
+        is_error = result.is_a?(String) && result.start_with?("Error")
+
+        if @after_hook
+          hook_result = @after_hook.call(
+            tool_call: tc, result: result, is_error: is_error, history: history
+          )
+          if hook_result.is_a?(Hash)
+            result = hook_result[:result] if hook_result.key?(:result)
+          end
+        end
+
+        @events.emit(Events::TOOL_EXECUTION_END,
+          tool_call_id: tc.id, result: result, is_error: is_error)
+
+        { tool_call: tc, result: result, is_error: is_error }
+      end
+
+      # @api private
+      def tool_sequential?(tc)
+        tool = @tool_registry.lookup(tc.name)
+        return false unless tool
+        tool.const_defined?(:EXECUTION_MODE) && tool::EXECUTION_MODE == :sequential
+      end
+    end
+  end
+end