crimson-code 0.1.0

data/lib/crimson/tools/run_command.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Crimson
+  module Tools
+    # Execute shell commands with timeout, streaming output, and abort support.
+    module RunCommand
+      TOOL_NAME = "run_command"
+      # This tool must run sequentially (not parallel).
+      EXECUTION_MODE = :sequential
+
+      # Tool parameter definitions.
+      PARAMS = {
+        command: { type: "string", description: "The shell command to execute" },
+        timeout: { type: "integer", description: "Timeout in seconds (default: 30)" }
+      }.freeze
+
+      @update_callback = nil
+      @callback_mutex = Mutex.new
+
+      class << self
+        # Register a callback for streaming execution updates.
+        # @param callback [Proc, nil]
+        def on_update=(callback)
+          @callback_mutex.synchronize { @update_callback = callback }
+        end
+
+        # @return [Proc, nil] current update callback
+        def on_update
+          @callback_mutex.synchronize { @update_callback }
+        end
+      end
+
+      # @return [Hash] OpenAI-compatible tool definition
+      def self.definition
+        Schema.build(name: TOOL_NAME, description: "Execute a shell command and return stdout and stderr.", parameters: PARAMS, required: ["command"])
+      end
+
+      # @return [Hash] Anthropic-compatible tool definition
+      def self.anthropic_definition
+        Schema.build_anthropic(name: TOOL_NAME, description: "Execute a shell command and return stdout and stderr.", parameters: PARAMS, required: ["command"])
+      end
+
+      # Execute a command without abort signal support.
+      # @param command [String] shell command
+      # @param timeout [Integer] timeout in seconds
+      # @return [String] command output or error
+      def self.call(command:, timeout: 30)
+        call_with_signal(command: command, timeout: timeout, signal: nil)
+      end
+
+      # Execute a command with abort signal support.
+      # @param command [String] shell command
+      # @param timeout [Integer] timeout in seconds
+      # @param signal [AbortSignal, nil]
+      # @return [String] command output or error
+      def self.call_with_signal(command:, timeout: 30, signal: nil)
+        return "Error: No command provided" if command.nil? || command.strip.empty?
+
+        stdout = String.new
+        stderr = String.new
+        status = nil
+        start_time = Time.now
+
+        begin
+          Timeout.timeout(timeout) do
+            Open3.popen3(command) do |stdin, out, err, wait_thr|
+              stdin.close
+
+              abort_thread = if signal
+                Thread.new do
+                  sleep 0.1 until signal.aborted? || !wait_thr.status
+                  if signal.aborted? && wait_thr.pid
+                    begin
+                      Process.kill("TERM", wait_thr.pid)
+                    rescue Errno::ESRCH, Errno::EPERM
+                    end
+                  end
+                end
+              end
+
+              readers = [out, err]
+              while readers.any?
+                ready = IO.select(readers, nil, nil, 0.1)
+                next unless ready
+
+                ready[0].each do |io|
+                  chunk = io.read_nonblock(4096, exception: false)
+                  if chunk == :wait_readable || chunk.nil?
+                    readers.delete(io) if io.eof?
+                    next
+                  end
+                  if io == out
+                    stdout << chunk
+                  else
+                    stderr << chunk
+                  end
+                  elapsed = Time.now - start_time
+                  cb = on_update
+                  cb&.call(command, elapsed, stdout.length + stderr.length)
+                end
+              end
+
+              status = wait_thr.value
+              abort_thread&.kill
+            end
+          end
+
+          output = String.new
+          output << stdout if !stdout.empty?
+          output << stderr if !stderr.empty?
+
+          output = strip_ansi_codes(output)
+          output = String.new("(no output)") if output.strip.empty?
+          if status.success?
+            # No exit code line needed for success
+          elsif status.exitstatus
+            output << "\n(exit code: #{status.exitstatus})"
+          else
+            output << "\n(process killed)"
+          end
+          output
+        rescue Timeout::Error
+          "Error: Command timed out after #{timeout} seconds"
+        rescue => e
+          "Error executing command: #{e.message}"
+        end
+      end
+
+      # @api private
+      def self.strip_ansi_codes(text)
+        text.gsub(/\e\[[0-9;]*[a-zA-Z]/, '')
+      end
+    end
+  end
+end

data/lib/crimson/tools/schema.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Crimson
+  module Tools
+    # Helper for building OpenAI and Anthropic tool definition schemas.
+    module Schema
+      # Build an OpenAI-compatible tool definition.
+      # @param name [String]
+      # @param description [String]
+      # @param parameters [Hash] JSON Schema properties
+      # @param required [Array<String>]
+      # @return [Hash]
+      def self.build(name:, description:, parameters:, required:)
+        {
+          type: "function",
+          function: {
+            name: name,
+            description: description,
+            parameters: {
+              type: "object",
+              properties: parameters,
+              required: required
+            }
+          }
+        }
+      end
+
+      # Build an Anthropic-compatible tool definition.
+      # @param name [String]
+      # @param description [String]
+      # @param parameters [Hash] JSON Schema properties
+      # @param required [Array<String>]
+      # @return [Hash]
+      def self.build_anthropic(name:, description:, parameters:, required:)
+        {
+          name: name,
+          description: description,
+          input_schema: {
+            type: "object",
+            properties: parameters,
+            required: required
+          }
+        }
+      end
+
+      # Build both OpenAI and Anthropic definitions at once.
+      # @param name [String]
+      # @param description [String]
+      # @param parameters [Hash]
+      # @param required [Array<String>]
+      # @return [Hash] with keys :openai and :anthropic
+      def self.definitions_for(name:, description:, parameters:, required:)
+        {
+          openai: build(name: name, description: description, parameters: parameters, required: required),
+          anthropic: build_anthropic(name: name, description: description, parameters: parameters, required: required)
+        }
+      end
+    end
+  end
+end

data/lib/crimson/tools/search_files.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Crimson
+  module Tools
+    # Search files for regex patterns using ripgrep (preferred) or grep fallback.
+    module SearchFiles
+      TOOL_NAME = "search_files"
+
+      # Tool parameter definitions.
+      PARAMS = {
+        pattern: { type: "string", description: "The regex pattern to search for" },
+        path: { type: "string", description: "The directory to search in. Defaults to current directory." },
+        file_pattern: { type: "string", description: "Glob pattern to filter files (e.g. '*.rb'). Defaults to all files." },
+        context_lines: { type: "integer", description: "Number of context lines to show around each match (default: 0)" }
+      }.freeze
+
+      # Whether ripgrep is available on this system.
+      RG_AVAILABLE = system("which rg > /dev/null 2>&1")
+
+      # @api private
+      def self.prepare_arguments(args)
+        args["context_lines"] = args["context_lines"].to_i if args["context_lines"]
+        args
+      end
+
+      # @return [Hash] OpenAI-compatible tool definition
+      def self.definition
+        Schema.build(name: TOOL_NAME, description: "Search for a regex pattern in files. Returns matching file paths, line numbers, and context.", parameters: PARAMS, required: ["pattern"])
+      end
+
+      # @return [Hash] Anthropic-compatible tool definition
+      def self.anthropic_definition
+        Schema.build_anthropic(name: TOOL_NAME, description: "Search for a regex pattern in files. Returns matching file paths, line numbers, and context.", parameters: PARAMS, required: ["pattern"])
+      end
+
+      # Execute the tool.
+      # @param pattern [String] regex pattern
+      # @param path [String] directory to search (default ".")
+      # @param file_pattern [String, nil] glob to filter files
+      # @param context_lines [Integer] lines of context around matches
+      # @return [String] search results or error
+      def self.call(pattern:, path: ".", file_pattern: nil, context_lines: 0)
+        return "Error: No pattern provided" if pattern.nil? || pattern.strip.empty?
+
+        expanded = File.expand_path(path)
+        context = [context_lines, 5].min
+
+        if RG_AVAILABLE
+          search_with_rg(pattern, expanded, file_pattern, context)
+        else
+          search_with_grep(pattern, expanded, file_pattern, context)
+        end
+      rescue => e
+        "Error searching files: #{e.message}"
+      end
+
+      class << self
+        private
+
+        # @api private
+        def search_with_rg(pattern, path, file_pattern, context)
+          cmd = ["rg", "--no-heading", "--line-number", "--color=never"]
+          cmd << "-C" << context.to_s if context > 0
+          cmd += ["--glob", "!{.git,node_modules,vendor,.bundle,tmp,log}"]
+          cmd += ["--glob", file_pattern] if file_pattern
+          cmd << "--max-count" << "500"
+          cmd << pattern << path
+
+          stdout, stderr, status = Open3.capture3(*cmd)
+
+          return "No matches found." if status.exitstatus == 1
+          return "Error: #{stderr}" unless status.success? || status.exitstatus == 2
+
+          truncate_output(stdout)
+        end
+
+        # @api private
+        def search_with_grep(pattern, path, file_pattern, context)
+          cmd = ["grep", "-rn", "--color=never", "-E"]
+          cmd << "-C" << context.to_s if context > 0
+          cmd += ["--exclude-dir=.git", "--exclude-dir=node_modules", "--exclude-dir=vendor"]
+          cmd += ["--exclude-dir=.bundle", "--exclude-dir=tmp", "--exclude-dir=log"]
+          cmd += ["--include=#{file_pattern}"] if file_pattern
+          cmd << "-m" << "500" if context == 0
+          cmd << pattern << path
+
+          stdout, _stderr, status = Open3.capture3(*cmd)
+
+          return "No matches found." if status.exitstatus == 1
+          truncate_output(stdout)
+        end
+
+        # @api private
+        def truncate_output(output)
+          lines = output.lines
+          if lines.length > 200
+            "#{lines.first(200).join}\n... (truncated, #{lines.length - 200} more lines)"
+          else
+            output
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crimson/tools/truncator.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+module Crimson
+  module Tools
+    # Truncates large text output by line count, line length, and byte size.
+    # Saves full output to a temp file when truncation occurs.
+    module Truncator
+      # Default maximum output size in bytes.
+      DEFAULT_MAX_BYTES = 100_000
+      # Default maximum number of lines.
+      DEFAULT_MAX_LINES = 2000
+      # Default maximum length per line.
+      DEFAULT_MAX_LINE_LENGTH = 2000
+
+      # Truncation result struct.
+      # @!attribute [r] text
+      #   @return [String] truncated text
+      # @!attribute [r] was_truncated
+      #   @return [Boolean]
+      # @!attribute [r] full_output_path
+      #   @return [String, nil] path to full output temp file
+      # @!attribute [r] original_size
+      #   @return [Integer] original byte size
+      Result = Struct.new(:text, :was_truncated, :full_output_path, :original_size, keyword_init: true)
+
+      # Truncate text by line length, line count, and byte size limits.
+      # @param text [String, nil]
+      # @param max_bytes [Integer]
+      # @param max_lines [Integer]
+      # @param max_line_length [Integer]
+      # @return [Result]
+      def self.truncate(text, max_bytes: DEFAULT_MAX_BYTES, max_lines: DEFAULT_MAX_LINES, max_line_length: DEFAULT_MAX_LINE_LENGTH)
+        return Result.new(text: text, was_truncated: false, full_output_path: nil, original_size: 0) if text.nil? || text.empty?
+
+        original_size = text.bytesize
+        truncated = false
+        full_output_path = nil
+
+        lines = text.lines
+        if lines.any? { |l| l.chomp.length > max_line_length }
+          lines = lines.map do |line|
+            if line.chomp.length > max_line_length
+              line.chomp[0...max_line_length] + "... (line truncated)\n"
+            else
+              line
+            end
+          end
+          truncated = true
+        end
+
+        if lines.length > max_lines
+          kept = lines.first(max_lines)
+          remaining = lines.length - max_lines
+          kept << "\n... (#{remaining} more lines, output truncated)\n"
+          lines = kept
+          truncated = true
+        end
+
+        result = lines.join
+
+        if result.bytesize > max_bytes
+          byte_limit = max_bytes - 100
+          result = result.byteslice(0, byte_limit) + "\n... (output truncated by size)\n"
+          truncated = true
+        end
+
+        if truncated && original_size > max_bytes
+          full_output_path = save_full_output(text)
+        end
+
+        Result.new(
+          text: result,
+          was_truncated: truncated,
+          full_output_path: full_output_path,
+          original_size: original_size
+        )
+      end
+
+      # Save full text to a temp file and return its path.
+      # @api private
+      def self.save_full_output(text)
+        file = Tempfile.new(["crimson-output-", ".log"])
+        file.binmode
+        file.write(text)
+        file.close
+        file.path
+      rescue => e
+        nil
+      end
+    end
+  end
+end

data/lib/crimson/tools/write_file.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Crimson
+  module Tools
+    # Write content to a file, creating parent directories and showing a diff.
+    module WriteFile
+      TOOL_NAME = "write_file"
+
+      # Tool parameter definitions.
+      PARAMS = {
+        path: { type: "string", description: "The path to the file to write" },
+        content: { type: "string", description: "The content to write" }
+      }.freeze
+
+      MUTATION_QUEUE = FileMutationQueue.new
+
+      # @return [Hash] OpenAI-compatible tool definition
+      def self.definition
+        Schema.build(name: TOOL_NAME, description: "Write content to a file. Creates the file and parent directories if needed.", parameters: PARAMS, required: %w[path content])
+      end
+
+      # @return [Hash] Anthropic-compatible tool definition
+      def self.anthropic_definition
+        Schema.build_anthropic(name: TOOL_NAME, description: "Write content to a file. Creates the file and parent directories if needed.", parameters: PARAMS, required: %w[path content])
+      end
+
+      # Execute the tool.
+      # @param path [String] file path
+      # @param content [String] content to write
+      # @return [String] result message with diff or error
+      def self.call(path:, content:)
+        return "Error: No path provided" if path.nil? || path.strip.empty?
+
+        expanded = File.expand_path(path)
+
+        MUTATION_QUEUE.with_file(expanded) do
+          dir = File.dirname(expanded)
+          old_content = File.exist?(expanded) ? File.read(expanded) : nil
+
+          FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+          File.write(expanded, content)
+
+          diff = DiffUtil.format_diff(old_content || "", content, path)
+          "Successfully wrote to #{path}\n#{diff}"
+        end
+      rescue => e
+        "Error writing file: #{e.message}"
+      end
+    end
+  end
+end

data/lib/crimson/trust_manager.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Crimson
+  # Manages directory trust state for loading project context files.
+  # Persists trust decisions to a JSON file and prompts users for untrusted directories.
+  class TrustManager
+    # File names considered as project context files.
+    CONTEXT_FILE_NAMES = %w[
+      AGENTS.md AGENTS.MD
+      CLAUDE.md CLAUDE.MD
+      GEMINI.md GEMINI.MD
+    ].freeze
+
+    # @param trust_file [String, nil] path to the trust JSON file
+    def initialize(trust_file: nil)
+      @trust_file = trust_file || File.join(Crimson::CONFIG_DIR, "trust.json")
+      @trust_data = load_trust_data
+    end
+
+    # Check whether a directory (or an ancestor) is trusted.
+    # @param cwd [String] directory path
+    # @return [Boolean]
+    def trusted?(cwd)
+      entry = find_nearest_trust(File.expand_path(cwd))
+      entry == true
+    end
+
+    # Prompt the user to trust a directory that has context files.
+    # @param cwd [String] directory path
+    # @return [Boolean] whether the directory is now trusted
+    def prompt_trust(cwd)
+      expanded = File.expand_path(cwd)
+      return true unless has_context_files?(expanded)
+      return true if trusted?(expanded)
+
+      prompt = TTY::Prompt.new
+      puts
+      choice = prompt.select("Trust this project?\n#{expanded}\n\nThis allows loading AGENTS.md and project settings.", [
+        { name: "Trust", value: :trust },
+        { name: "Trust parent folder (#{File.dirname(expanded)})", value: :trust_parent },
+        { name: "Trust (this session only)", value: :session_only },
+        { name: "Don't trust", value: :deny }
+      ])
+
+      case choice
+      when :trust
+        save_trust(expanded, true)
+        true
+      when :trust_parent
+        save_trust(File.dirname(expanded), true)
+        save_trust(expanded, nil)
+        true
+      when :session_only
+        true
+      when :deny
+        save_trust(expanded, false)
+        false
+      end
+    end
+
+    # Check whether a directory contains any project context files.
+    # @param dir [String] directory path
+    # @return [Boolean]
+    def has_context_files?(dir)
+      CONTEXT_FILE_NAMES.any? { |name| File.exist?(File.join(dir, name)) }
+    end
+
+    private
+
+    # @api private
+    def load_trust_data
+      return {} unless File.exist?(@trust_file)
+      JSON.parse(File.read(@trust_file))
+    rescue JSON::ParserError
+      {}
+    end
+
+    # @api private
+    def save_trust(path, decision)
+      @trust_data[File.expand_path(path)] = decision
+      FileUtils.mkdir_p(File.dirname(@trust_file))
+      File.write(@trust_file, JSON.pretty_generate(@trust_data))
+    end
+
+    # Walk up the directory tree looking for a trust decision.
+    # @api private
+    def find_nearest_trust(dir)
+      loop do
+        value = @trust_data[dir]
+        return value if value == true || value == false
+
+        parent = File.dirname(dir)
+        break if parent == dir
+        dir = parent
+      end
+      nil
+    end
+  end
+end

data/lib/crimson/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Crimson
+  # Current version of the Crimson gem.
+  VERSION = "0.1.0"
+end

data/lib/crimson.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "crimson/version"
+require_relative "crimson/config"
+require_relative "crimson/providers"
+require_relative "crimson/message"
+require_relative "crimson/tools/index"
+require_relative "crimson/tool_registry"
+require_relative "crimson/skill_router"
+require_relative "crimson/formatter"
+require_relative "crimson/client/base"
+require_relative "crimson/client/factory"
+require_relative "crimson/agent/event_emitter"
+require_relative "crimson/agent/events"
+require_relative "crimson/agent/steering"
+require_relative "crimson/agent/tool_executor"
+require_relative "crimson/agent"
+require_relative "crimson/output_handler"
+require_relative "crimson/repl"
+require_relative "crimson/setup"
+require_relative "crimson/project_context"
+require_relative "crimson/session_entry"
+require_relative "crimson/session_manager"
+require_relative "crimson/cost_tracker"
+require_relative "crimson/compactor"
+require_relative "crimson/retry_handler"
+require_relative "crimson/token_counter"
+require_relative "crimson/trust_manager"
+
+module Crimson
+  # Base error class for Crimson-specific errors.
+  class Error < StandardError; end
+
+  # Directory for Crimson configuration files.
+  CONFIG_DIR = File.join(Dir.home, ".crimson")
+  # Path to the JSON configuration file.
+  CONFIG_FILE = File.join(CONFIG_DIR, "config.json")
+  # Directory for user skill markdown files.
+  SKILLS_DIR = File.join(CONFIG_DIR, "skills")
+
+  # @return [Config] the global configuration (loaded once, cached)
+  def self.config
+    @config ||= Crimson::Config.load
+  end
+
+  # @return [String] path to the config directory
+  def self.config_dir
+    CONFIG_DIR
+  end
+
+  # @return [Boolean] whether the config file exists
+  def self.configured?
+    File.exist?(CONFIG_FILE)
+  end
+end

data/skills/coding.md

@@ -0,0 +1,49 @@
+---
+domain: base
+triggers: []
+priority: 0
+auto_inject: false
+---
+
+You are Crimson, a minimal coding agent. You help users with software engineering tasks.
+
+## Core Principles
+
+- Be concise and direct. Avoid unnecessary explanations.
+- Only read files when the user explicitly asks you to or when you need to edit them.
+- Do not explore the codebase unless asked.
+- When making changes, prefer editing existing files over creating new ones.
+- Always verify your changes work by suggesting the user run tests or lint commands.
+
+## Available Tools
+
+You have access to the following tools:
+
+- `read_file` - Read the contents of a file
+- `write_file` - Write content to a file (creates or overwrites)
+- `edit_file` - Edit a file with targeted string replacement
+- `list_directory` - List files and directories
+- `run_command` - Execute a shell command
+- `search_files` - Search for patterns in files using grep
+- `glob` - Find files by pattern
+
+## Workflow
+
+1. Answer simple questions directly without reading files.
+2. Only read files when you need to edit them or when the user asks.
+3. Make targeted, minimal changes.
+4. Verify changes by running relevant commands (tests, linters, etc.).
+
+## Code Style
+
+- Match the existing code style in the file you are editing.
+- Use the same indentation, naming conventions, and import patterns.
+- Do not introduce new dependencies unless the user asks.
+- Prefer standard library over external gems/packages when possible.
+
+## Guidelines
+
+- Never commit changes unless explicitly asked.
+- Never expose or log secrets, API keys, or tokens.
+- Work within the current working directory unless specified otherwise.
+- If you are unsure about something, ask the user for clarification.