crimson-code 0.1.0

data/lib/crimson/token_counter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Crimson
+  # Token counter using tiktoken when available, with fallback estimation.
+  class TokenCounter
+    # @param model [String, nil] model name for encoder selection
+    # @param provider [String, Symbol, nil] provider name
+    def initialize(model: nil, provider: nil)
+      @model = model
+      @provider = provider ? provider.to_sym : nil
+      @encoder = nil
+      @encoder_loaded = false
+    end
+
+    # Count tokens in a text string.
+    # @param text [String, nil]
+    # @return [Integer]
+    def count(text)
+      return 0 if text.nil? || text.empty?
+      encoder = load_encoder
+      return estimate(text) unless encoder
+      encoder.encode(text).length
+    rescue => e
+      estimate(text)
+    end
+
+    # Count total tokens for an array of messages, including per-message overhead.
+    # @param messages [Array<Message::Base>]
+    # @return [Integer]
+    def count_messages(messages)
+      total = 0
+      messages.each do |msg|
+        total += 4
+        total += count(msg.content.to_s)
+        if msg.respond_to?(:tool_calls) && msg.tool_calls
+          msg.tool_calls.each do |tc|
+            total += count(tc.name.to_s)
+            total += count(tc.arguments.to_s)
+          end
+        end
+      end
+      total
+    end
+
+    private
+
+    # @api private
+    def load_encoder
+      return @encoder if @encoder_loaded
+      @encoder_loaded = true
+
+      require "tiktoken_ruby"
+
+      @encoder = if openai_sdk?
+        load_openai_encoder
+      else
+        nil
+      end
+    rescue LoadError
+      @encoder = nil
+    rescue => e
+      @encoder = nil
+    end
+
+    # @api private
+    def openai_sdk?
+      return true if @provider.nil? && @model&.match?(/gpt|o1|o3|davinci|curie|babbage|ada/)
+      return false unless @provider
+      PROVIDERS.dig(@provider, :sdk) == :openai
+    end
+
+    # @api private
+    def load_openai_encoder
+      enc = @model ? ::Tiktoken.encoding_for_model(@model) : nil
+      enc || ::Tiktoken.get_encoding("cl100k_base")
+    end
+
+    # Fallback token estimation based on character count.
+    # @api private
+    def estimate(text)
+      (text.length / 4.0).ceil
+    end
+  end
+end

data/lib/crimson/tool_registry.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Crimson
+  # Central registry for tool registration, execution, and schema generation.
+  class ToolRegistry
+    def initialize
+      @tools = {}
+      @openai_defs = nil
+      @anthropic_defs = nil
+    end
+
+    # Register a tool module by its TOOL_NAME constant.
+    # @param tool_module [Module] a tool module with TOOL_NAME, .call, and .definition
+    # @return [void]
+    def register(tool_module)
+      name = tool_module.const_get(:TOOL_NAME)
+      @tools[name] = tool_module
+      @openai_defs = nil
+      @anthropic_defs = nil
+    end
+
+    # Execute a tool by name with the given arguments.
+    # @param tool_name [String]
+    # @param arguments [Hash, String] argument hash or JSON string
+    # @param abort_signal [AbortSignal, nil]
+    # @return [String] tool result (or error message prefixed with "Error")
+    def execute(tool_name, arguments, abort_signal: nil)
+      tool = @tools[tool_name]
+      return "Error: Unknown tool '#{tool_name}'" unless tool
+
+      args = if arguments.is_a?(String)
+               JSON.parse(arguments, symbolize_names: true)
+             else
+               arguments.transform_keys(&:to_sym)
+             end
+
+      if tool.respond_to?(:prepare_arguments)
+        begin
+          prepared = tool.prepare_arguments(args.transform_keys(&:to_s))
+          args = prepared.transform_keys(&:to_sym)
+        rescue => e
+          return "Error preparing arguments for #{tool_name}: #{e.message}"
+        end
+      end
+
+      result = if tool.respond_to?(:call_with_signal) && abort_signal
+                 tool.call_with_signal(**args, signal: abort_signal)
+               else
+                 tool.call(**args)
+               end
+
+      result = apply_truncation(tool_name, result)
+
+      result
+    rescue JSON::ParserError
+      "Error: Invalid JSON arguments for #{tool_name}"
+    rescue ArgumentError => e
+      "Error: Wrong arguments for #{tool_name}: #{e.message}"
+    rescue => e
+      "Error executing #{tool_name}: #{e.message}"
+    end
+
+    # @return [Array<Hash>] OpenAI-compatible tool definitions
+    def openai_definitions
+      @openai_defs ||= @tools.values.map(&:definition)
+    end
+
+    # @return [Array<Hash>] Anthropic-compatible tool definitions
+    def anthropic_definitions
+      @anthropic_defs ||= @tools.values.map(&:anthropic_definition)
+    end
+
+    # Look up a tool module by name.
+    # @param tool_name [String]
+    # @return [Module, nil]
+    def lookup(tool_name)
+      @tools[tool_name]
+    end
+
+    # @return [Array<String>] all registered tool names
+    def tool_names
+      @tools.keys
+    end
+
+    # Load all skill markdown files from a directory.
+    # @param skills_dir [String] directory path
+    # @return [String] concatenated skill content
+    def load_skills(skills_dir)
+      return "" unless Dir.exist?(skills_dir)
+
+      Dir.glob(File.join(skills_dir, "*.md")).sort.filter_map do |file|
+        File.read(file).strip
+      end.join("\n\n")
+    end
+
+    private
+
+    # @api private
+    def apply_truncation(tool_name, result)
+      return result unless result.is_a?(String)
+      return result if result.start_with?("Error")
+      return result if result.bytesize <= Tools::Truncator::DEFAULT_MAX_BYTES
+
+      truncation = Tools::Truncator.truncate(result)
+      output = truncation.text
+      output += "\n\n(full output saved to #{truncation.full_output_path})" if truncation.full_output_path
+      output
+    end
+  end
+end

data/lib/crimson/tools/diff_util.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "diff/lcs"
+require "pastel"
+
+module Crimson
+  module Tools
+    # Diff utility using the diff/lcs library with ANSI-colored output.
+    module DiffUtil
+      # Produce a colored unified-format diff between two texts.
+      # @param old_text [String] original content
+      # @param new_text [String] new content
+      # @param path [String] file path for header display
+      # @return [String] ANSI-colored diff output
+      def self.format_diff(old_text, new_text, path)
+        pastel = Pastel.new
+        old_lines = old_text.lines.map(&:chomp)
+        new_lines = new_text.lines.map(&:chomp)
+
+        changes = Diff::LCS.sdiff(old_lines, new_lines)
+
+        output = []
+        output << pastel.dim("--- #{path}")
+        output << pastel.dim("+++ #{path}")
+
+        changes.each do |change|
+          case change.action
+          when "-"
+            output << pastel.red("- #{change.old_element}")
+          when "+"
+            output << pastel.green("+ #{change.new_element}")
+          when "!"
+            output << pastel.red("- #{change.old_element}")
+            output << pastel.green("+ #{change.new_element}")
+          when "="
+            output << pastel.dim("  #{change.old_element}")
+          end
+        end
+
+        output.join("\n")
+      end
+    end
+  end
+end

data/lib/crimson/tools/edit_file.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Crimson
+  module Tools
+    # Edit files by replacing strings, with single and multi-edit modes.
+    # Handles BOM, CRLF/LF line endings, and produces diffs.
+    module EditFile
+      TOOL_NAME = "edit_file"
+
+      # Tool parameter definitions.
+      PARAMS = {
+        path: { type: "string", description: "The path to the file to edit" },
+        old_string: { type: "string", description: "The exact string to find and replace (single edit mode)" },
+        new_string: { type: "string", description: "The string to replace it with (single edit mode)" },
+        replace_all: { type: "boolean", description: "Replace all occurrences (default: false)" },
+        edits: {
+          type: "array",
+          description: "Array of edits for multiple replacements in one call. Each edit has old_string, new_string, and optional replace_all.",
+          items: {
+            type: "object",
+            properties: {
+              old_string: { type: "string", description: "The exact string to find" },
+              new_string: { type: "string", description: "The replacement string" },
+              replace_all: { type: "boolean", description: "Replace all occurrences (default: false)" }
+            },
+            required: %w[old_string new_string]
+          }
+        }
+      }.freeze
+
+      MUTATION_QUEUE = FileMutationQueue.new
+
+      # @api private
+      def self.prepare_arguments(args)
+        if args["edits"].is_a?(Array)
+          args["edits"].each { |e| e["replace_all"] = !!e["replace_all"] if e.key?("replace_all") }
+        end
+        args["replace_all"] = !!args["replace_all"] if args.key?("replace_all")
+        args
+      end
+
+      # @return [Hash] OpenAI-compatible tool definition
+      def self.definition
+        Schema.build(name: TOOL_NAME, description: "Replace strings in a file. Supports single edit or multiple edits in one call.", parameters: PARAMS, required: ["path"])
+      end
+
+      # @return [Hash] Anthropic-compatible tool definition
+      def self.anthropic_definition
+        Schema.build_anthropic(name: TOOL_NAME, description: "Replace strings in a file. Supports single edit or multiple edits in one call.", parameters: PARAMS, required: ["path"])
+      end
+
+      # Execute the tool.
+      # @param path [String] file path
+      # @param old_string [String, nil] text to find
+      # @param new_string [String, nil] replacement text
+      # @param replace_all [Boolean] replace all occurrences
+      # @param edits [Array<Hash>, nil] multiple edits
+      # @return [String] result message with diff or error
+      def self.call(path:, old_string: nil, new_string: nil, replace_all: false, edits: nil)
+        return "Error: No path provided" if path.nil? || path.strip.empty?
+
+        expanded = File.expand_path(path)
+
+        MUTATION_QUEUE.with_file(expanded) do
+          return "Error: File not found: #{path}" unless File.exist?(expanded)
+          return "Error: Not a file: #{path}" unless File.file?(expanded)
+
+          content = File.binread(expanded)
+          has_bom = content.start_with?("\xEF\xBB\xBF")
+          content = content.byteslice(3..) if has_bom
+          content = content.force_encoding("UTF-8")
+
+          line_ending = detect_line_ending(content)
+          content = content.gsub("\r\n", "\n") if line_ending == :crlf
+
+          old_content = content.dup
+
+          if edits.is_a?(Array) && !edits.empty?
+            count = 0
+            edits.each do |e|
+              result = apply_edit(content, e["old_string"], e["new_string"], e["replace_all"])
+              return result[:error] if result[:error]
+              content = result[:content]
+              count += result[:count]
+            end
+          elsif old_string
+            return "Error: No old_string provided" if old_string.nil? || old_string.empty?
+
+            result = apply_edit(content, old_string, new_string, replace_all)
+            return result[:error] if result[:error]
+
+            content = result[:content]
+            count = result[:count]
+          else
+            return "Error: Provide either old_string/new_string or edits array"
+          end
+
+          content = content.gsub("\n", "\r\n") if line_ending == :crlf
+          content = "\xEF\xBB\xBF#{content}" if has_bom
+
+          File.binwrite(expanded, content)
+
+          clean_old = old_content
+          clean_new = has_bom ? content.byteslice(3..) : content
+          diff = DiffUtil.format_diff(clean_old, clean_new, path)
+          "Successfully edited #{path} (#{count} replacement#{'s' if count != 1})\n#{diff}"
+        end
+      rescue => e
+        "Error editing file: #{e.message}"
+      end
+
+      class << self
+        private
+
+        # @api private
+        def apply_edit(content, old_string, new_string, replace_all = false)
+          return { error: "Error: old_string not provided" } if old_string.nil? || old_string.empty?
+          return { error: "Error: new_string not provided" } if new_string.nil?
+
+          count = content.scan(Regexp.escape(old_string)).length
+
+          if count == 0
+            return { error: "Error: old_string not found in file. Make sure it matches exactly." }
+          end
+
+          if !replace_all && count > 1
+            return { error: "Error: old_string found #{count} times. It must be unique, or use replace_all: true." }
+          end
+
+          new_content = replace_all ? content.gsub(old_string, new_string) : content.sub(old_string, new_string)
+          { content: new_content, count: count }
+        end
+
+        # @api private
+        def detect_line_ending(content)
+          crlf_pos = content.index("\r\n")
+          lf_pos = content.index("\n")
+          return :lf if lf_pos.nil?
+          return :lf if crlf_pos.nil?
+          crlf_pos < lf_pos ? :crlf : :lf
+        end
+      end
+    end
+  end
+end

data/lib/crimson/tools/file_mutation_queue.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Crimson
+  module Tools
+    # Per-file mutex queue to serialize write/edit operations on the same path.
+    class FileMutationQueue
+      def initialize
+        @queues = {}
+        @global_mutex = Mutex.new
+      end
+
+      # Execute a block with exclusive access to the given file.
+      # @param path [String] file path
+      # @yield block to run under the file's mutex
+      # @return [Object] the block's result
+      def with_file(path)
+        normalized = File.expand_path(path)
+        queue = @global_mutex.synchronize do
+          @queues[normalized] ||= Mutex.new
+        end
+
+        queue.synchronize { yield }
+      ensure
+        @global_mutex.synchronize do
+          @queues.delete(normalized) if queue && !queue.locked?
+        end
+      end
+    end
+  end
+end

data/lib/crimson/tools/glob.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Crimson
+  module Tools
+    # Find files matching a glob pattern with configurable search root.
+    module Glob
+      TOOL_NAME = "glob"
+
+      # Tool parameter definitions.
+      PARAMS = {
+        pattern: { type: "string", description: "The glob pattern to match files against" },
+        path: { type: "string", description: "The directory to search in. Defaults to current directory." }
+      }.freeze
+
+      # @return [Hash] OpenAI-compatible tool definition
+      def self.definition
+        Schema.build(name: TOOL_NAME, description: "Find files matching a glob pattern (e.g. '**/*.rb', 'src/**/*.ts'). Returns sorted file paths.", parameters: PARAMS, required: ["pattern"])
+      end
+
+      # @return [Hash] Anthropic-compatible tool definition
+      def self.anthropic_definition
+        Schema.build_anthropic(name: TOOL_NAME, description: "Find files matching a glob pattern (e.g. '**/*.rb', 'src/**/*.ts'). Returns sorted file paths.", parameters: PARAMS, required: ["pattern"])
+      end
+
+      # Execute the tool.
+      # @param pattern [String] glob pattern
+      # @param path [String] search root (default ".")
+      # @return [String] sorted file paths or error
+      def self.call(pattern:, path: ".")
+        return "Error: No pattern provided" if pattern.nil? || pattern.strip.empty?
+
+        expanded = File.expand_path(path)
+        return "Error: Directory not found: #{path}" unless Dir.exist?(expanded)
+
+        files = Dir.glob(File.join(expanded, pattern)).sort
+
+        if files.empty?
+          "No files found matching pattern: #{pattern}"
+        elsif files.length > 200
+          "#{files.first(200).join("\n")}\n... (truncated, #{files.length - 200} more files)"
+        else
+          files.join("\n")
+        end
+      rescue => e
+        "Error searching files: #{e.message}"
+      end
+    end
+  end
+end

data/lib/crimson/tools/index.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "schema"
+require_relative "diff_util"
+require_relative "truncator"
+require_relative "file_mutation_queue"
+require_relative "read_file"
+require_relative "write_file"
+require_relative "edit_file"
+require_relative "list_directory"
+require_relative "run_command"
+require_relative "search_files"
+require_relative "glob"
+
+module Crimson
+  module Tools
+    # All built-in tool modules available for registration.
+    ALL = [ReadFile, WriteFile, EditFile, ListDirectory, RunCommand, SearchFiles, Glob].freeze
+  end
+end

data/lib/crimson/tools/list_directory.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Crimson
+  module Tools
+    # List files and directories at a given path, with trailing / for directories.
+    module ListDirectory
+      TOOL_NAME = "list_directory"
+
+      # Tool parameter definitions.
+      PARAMS = {
+        path: { type: "string", description: "The directory path to list. Defaults to current directory." }
+      }.freeze
+
+      # @return [Hash] OpenAI-compatible tool definition
+      def self.definition
+        Schema.build(name: TOOL_NAME, description: "List files and directories at the given path.", parameters: PARAMS, required: ["path"])
+      end
+
+      # @return [Hash] Anthropic-compatible tool definition
+      def self.anthropic_definition
+        Schema.build_anthropic(name: TOOL_NAME, description: "List files and directories at the given path.", parameters: PARAMS, required: ["path"])
+      end
+
+      # Execute the tool.
+      # @param path [String] directory path (defaults to ".")
+      # @return [String] sorted listing or error
+      def self.call(path: ".")
+        expanded = File.expand_path(path)
+        return "Error: Directory not found: #{path}" unless Dir.exist?(expanded)
+
+        entries = Dir.entries(expanded).sort - [".", ".."]
+
+        entries.map do |entry|
+          full_path = File.join(expanded, entry)
+          File.directory?(full_path) ? "#{entry}/" : entry
+        end.join("\n")
+      rescue => e
+        "Error listing directory: #{e.message}"
+      end
+    end
+  end
+end

data/lib/crimson/tools/read_file.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Crimson
+  module Tools
+    # Read file contents with optional offset/limit for large files.
+    # Detects image and binary files and returns metadata instead of content.
+    module ReadFile
+      TOOL_NAME = "read_file"
+
+      # Extensions treated as viewable images.
+      IMAGE_EXTENSIONS = %w[.png .jpg .jpeg .gif .webp .bmp .ico .svg .tiff .tif].freeze
+      # Extensions treated as binary (not readable as text).
+      BINARY_EXTENSIONS = %w[.zip .tar .gz .bz2 .xz .7z .rar .exe .dll .so .dylib .o .a .class .jar .wasm .pdf .doc .docx .xls .xlsx .ppt .pptx .woff .woff2 .ttf .eot .otf .mp3 .mp4 .avi .mov .mkv .flac .ogg .wav].freeze
+
+      # Tool parameter definitions.
+      PARAMS = {
+        path: { type: "string", description: "The path to the file to read" },
+        offset: { type: "integer", description: "Line number to start reading from (1-indexed). Defaults to 1." },
+        limit: { type: "integer", description: "Maximum number of lines to read. Defaults to all lines." }
+      }.freeze
+
+      # @api private
+      def self.prepare_arguments(args)
+        args["offset"] = args["offset"].to_i if args["offset"]
+        args["limit"] = args["limit"].to_i if args["limit"]
+        args
+      end
+
+      # @return [Hash] OpenAI-compatible tool definition
+      def self.definition
+        Schema.build(name: TOOL_NAME, description: "Read the contents of a file. Supports offset/limit for reading portions of large files.", parameters: PARAMS, required: ["path"])
+      end
+
+      # @return [Hash] Anthropic-compatible tool definition
+      def self.anthropic_definition
+        Schema.build_anthropic(name: TOOL_NAME, description: "Read the contents of a file. Supports offset/limit for reading portions of large files.", parameters: PARAMS, required: ["path"])
+      end
+
+      # Execute the tool.
+      # @param path [String] file path
+      # @param offset [Integer, nil] starting line (1-indexed)
+      # @param limit [Integer, nil] max lines to read
+      # @return [String] file content or error message
+      def self.call(path:, offset: nil, limit: nil)
+        return "Error: No path provided" if path.nil? || path.strip.empty?
+
+        expanded = File.expand_path(path)
+        return "Error: File not found: #{path}" unless File.exist?(expanded)
+        return "Error: Not a file: #{path}" unless File.file?(expanded)
+
+        ext = File.extname(expanded).downcase
+        return describe_image(expanded, ext) if IMAGE_EXTENSIONS.include?(ext)
+        return describe_binary(expanded, ext) if BINARY_EXTENSIONS.include?(ext)
+
+        content = File.read(expanded)
+        lines = content.lines
+
+        if offset || limit
+          start_line = [(offset || 1) - 1, 0].max
+          end_line = limit ? start_line + limit : lines.length
+          end_line = [end_line, lines.length].min
+          total = lines.length
+
+          selected = lines[start_line...end_line]
+          numbered = selected.each_with_index.map do |line, i|
+            "#{start_line + i + 1}: #{line}"
+          end
+
+          "(lines #{start_line + 1}-#{end_line} of #{total})\n#{numbered.join}"
+        else
+          content
+        end
+      rescue => e
+        "Error reading file: #{e.message}"
+      end
+
+      # @api private
+      def self.describe_image(path, ext)
+        size = File.size(path)
+        size_str = size > 1_048_576 ? "#{(size / 1_048_576.0).round(1)}MB" : "#{(size / 1024.0).round(1)}KB"
+        "Image file: #{File.basename(path)} (#{ext}, #{size_str}). Image reading not yet supported."
+      end
+
+      # @api private
+      def self.describe_binary(path, ext)
+        size = File.size(path)
+        size_str = size > 1_048_576 ? "#{(size / 1_048_576.0).round(1)}MB" : "#{(size / 1024.0).round(1)}KB"
+        "Binary file: #{File.basename(path)} (#{ext}, #{size_str}). Cannot display binary content."
+      end
+    end
+  end
+end