crimson-code 0.1.0

data/lib/crimson/session_entry.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "json"
+
+module Crimson
+  # Data model for a single entry in a session log.
+  # Can represent user messages, assistant responses, and tool results.
+  class SessionEntry
+    # @return [String] unique entry ID
+    # @return [String, nil] parent entry ID for threading
+    # @return [String] role (user/assistant/tool_result/system)
+    # @return [String, nil] message content
+    # @return [Array<Hash>] tool call data
+    # @return [String, nil] tool call ID for results
+    # @return [String, nil] tool name for results
+    # @return [Hash] token usage metadata
+    # @return [String] ISO 8601 timestamp
+    # @return [Array<String>] files read by this entry
+    # @return [Array<String>] files modified by this entry
+    attr_accessor :id, :parent_id, :role, :content,
+                  :tool_calls, :tool_call_id, :tool_name,
+                  :token_usage, :timestamp,
+                  :read_files, :modified_files
+
+    # @param attrs [Hash] entry attributes
+    def initialize(attrs = {})
+      @id = attrs[:id] || SecureRandom.uuid
+      @parent_id = attrs[:parent_id]
+      @role = attrs[:role]
+      @content = attrs[:content]
+      @tool_calls = attrs[:tool_calls] || []
+      @tool_call_id = attrs[:tool_call_id]
+      @tool_name = attrs[:tool_name]
+      @token_usage = attrs[:token_usage] || {}
+      @timestamp = attrs[:timestamp] || Time.now.utc.iso8601
+      @read_files = attrs[:read_files] || []
+      @modified_files = attrs[:modified_files] || []
+    end
+
+    # Convert to a hash suitable for JSON serialization.
+    # @return [Hash]
+    def to_h
+      h = {
+        id: @id,
+        parentId: @parent_id,
+        role: @role,
+        content: @content,
+        toolCalls: @tool_calls,
+        timestamp: @timestamp
+      }
+      h[:toolCallId] = @tool_call_id if @tool_call_id
+      h[:toolName] = @tool_name if @tool_name
+      h[:tokenUsage] = @token_usage unless @token_usage.empty?
+      h[:readFiles] = @read_files unless @read_files.empty?
+      h[:modifiedFiles] = @modified_files unless @modified_files.empty?
+      h
+    end
+
+    # @return [String] JSON representation
+    def to_json(*_args)
+      JSON.generate(to_h)
+    end
+
+    # Deserialize from a hash (with string or symbol keys).
+    # @param hash [Hash]
+    # @return [SessionEntry]
+    def self.from_h(hash)
+      new(
+        id: hash[:id] || hash["id"],
+        parent_id: hash[:parentId] || hash["parentId"],
+        role: hash[:role] || hash["role"],
+        content: hash[:content] || hash["content"],
+        tool_calls: hash[:toolCalls] || hash["toolCalls"] || [],
+        tool_call_id: hash[:toolCallId] || hash["toolCallId"],
+        tool_name: hash[:toolName] || hash["toolName"],
+        token_usage: hash[:tokenUsage] || hash["tokenUsage"] || {},
+        timestamp: hash[:timestamp] || hash["timestamp"],
+        read_files: hash[:readFiles] || hash["readFiles"] || [],
+        modified_files: hash[:modifiedFiles] || hash["modifiedFiles"] || []
+      )
+    end
+
+    # Build a session entry from a message object.
+    # @param message [Message::Base]
+    # @param parent_id [String, nil]
+    # @param read_files [Array<String>]
+    # @param modified_files [Array<String>]
+    # @return [SessionEntry]
+    def self.from_message(message, parent_id:, read_files: [], modified_files: [])
+      case message
+      when Message::User
+        new(role: "user", content: message.content, parent_id: parent_id)
+      when Message::Assistant
+        tc_data = message.tool_calls.map do |tc|
+          { "id" => tc.id, "name" => tc.name, "arguments" => tc.arguments }
+        end
+        new(
+          role: "assistant",
+          content: message.content,
+          parent_id: parent_id,
+          tool_calls: tc_data
+        )
+      when Message::ToolResult
+        new(
+          role: "tool_result",
+          content: message.content,
+          parent_id: parent_id,
+          tool_call_id: message.tool_call_id,
+          tool_name: message.name,
+          read_files: read_files,
+          modified_files: modified_files
+        )
+      else
+        new(role: "system", content: message&.content.to_s, parent_id: parent_id)
+      end
+    end
+
+    # Convert back to a Message object.
+    # @return [Message::Base, nil]
+    def to_message
+      case @role
+      when "user"
+        Message::User.new(@content)
+      when "assistant"
+        tcs = (@tool_calls || []).map do |tc|
+          Message::ToolCall.new(
+            id: tc["id"],
+            name: tc["name"],
+            arguments: tc["arguments"]
+          )
+        end
+        Message::Assistant.new(content: @content, tool_calls: tcs)
+      when "tool_result"
+        Message::ToolResult.new(
+          tool_call_id: @tool_call_id,
+          name: @tool_name,
+          content: @content
+        )
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/crimson/session_manager.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "json"
+require "fileutils"
+require "digest"
+
+module Crimson
+  # Metadata for a session listing.
+  SessionMeta = Struct.new(:id, :entry_count, :last_timestamp, :preview, :name, :mtime, keyword_init: true)
+
+  # JSONL-based session persistence manager.
+  # Sessions are stored as per-directory JSONL files with a header entry.
+  class SessionManager
+    # Current session file format version.
+    CURRENT_SESSION_VERSION = 1
+
+    # @param sessions_dir [String, nil] base directory for session storage
+    def initialize(sessions_dir: nil)
+      @sessions_dir = sessions_dir || File.join(Crimson::CONFIG_DIR, "sessions")
+    end
+
+    # Create a new session and return its ID.
+    # @param cwd [String] working directory for the session
+    # @param parent_session [String, nil] optional parent session ID
+    # @return [String] session ID
+    def create(cwd:, parent_session: nil)
+      id = SecureRandom.uuid
+      FileUtils.mkdir_p(session_dir(cwd: cwd))
+      header = {
+        type: "session_header",
+        version: CURRENT_SESSION_VERSION,
+        id: id,
+        timestamp: Time.now.utc.iso8601,
+        cwd: cwd,
+        parentSession: parent_session
+      }
+      File.write(session_file(id, cwd: cwd), JSON.generate(header) + "\n")
+      id
+    end
+
+    # Load all entries for a session.
+    # @param session_id [String]
+    # @param cwd [String] working directory
+    # @return [Array<SessionEntry>]
+    def load(session_id, cwd:)
+      file = session_file(session_id, cwd: cwd)
+      return [] unless File.exist?(file)
+
+      entries = []
+      File.foreach(file) do |line|
+        line = line.strip
+        next if line.empty?
+        begin
+          parsed = JSON.parse(line)
+          next if parsed["type"] == "session_header"
+          entries << SessionEntry.from_h(parsed)
+        rescue JSON::ParserError
+          next
+        end
+      end
+      entries
+    end
+
+    # Load only the header entry of a session.
+    # @param session_id [String]
+    # @param cwd [String] working directory
+    # @return [Hash, nil]
+    def load_header(session_id, cwd:)
+      file = session_file(session_id, cwd: cwd)
+      return nil unless File.exist?(file)
+
+      File.foreach(file) do |line|
+        line = line.strip
+        next if line.empty?
+        begin
+          parsed = JSON.parse(line)
+          return parsed if parsed["type"] == "session_header"
+        rescue JSON::ParserError
+          next
+        end
+      end
+      nil
+    end
+
+    # Append an entry to a session.
+    # @param session_id [String]
+    # @param cwd [String] working directory
+    # @param entry [SessionEntry]
+    # @return [void]
+    def append(session_id, cwd:, entry:)
+      file = session_file(session_id, cwd: cwd)
+      FileUtils.mkdir_p(File.dirname(file))
+      File.open(file, "a") { |f| f.puts(entry.to_json) }
+    end
+
+    # List all sessions for a given directory, sorted by mtime (newest first).
+    # @param cwd [String] working directory
+    # @return [Array<SessionMeta>]
+    def list(cwd:)
+      dir = session_dir(cwd: cwd)
+      return [] unless Dir.exist?(dir)
+
+      Dir.glob(File.join(dir, "*.jsonl")).filter_map do |file|
+        id = File.basename(file, ".jsonl")
+        entries = []
+        last_user_content = nil
+        session_name = nil
+
+        File.foreach(file) do |line|
+          line = line.strip
+          next if line.empty?
+          begin
+            parsed = JSON.parse(line)
+            if parsed["type"] == "session_header"
+              session_name = parsed["name"]
+              next
+            end
+            entry = SessionEntry.from_h(parsed)
+            entries << entry
+            last_user_content = entry.content if entry.role == "user"
+          rescue JSON::ParserError
+            next
+          end
+        end
+
+        next if entries.empty?
+
+        SessionMeta.new(
+          id: id,
+          entry_count: entries.length,
+          last_timestamp: entries.last.timestamp,
+          preview: last_user_content && last_user_content.length > 80 ? last_user_content[0, 77] + "..." : last_user_content,
+          name: session_name,
+          mtime: File.mtime(file)
+        )
+      end.sort_by { |s| s.mtime }.reverse
+    end
+
+    # Set the human-readable name for a session.
+    # @param session_id [String]
+    # @param cwd [String] working directory
+    # @param name [String]
+    # @return [void]
+    def set_name(session_id, cwd:, name:)
+      file = session_file(session_id, cwd: cwd)
+      return unless File.exist?(file)
+
+      lines = File.readlines(file)
+      lines.each_with_index do |line, idx|
+        stripped = line.strip
+        next if stripped.empty?
+        begin
+          parsed = JSON.parse(stripped)
+          if parsed["type"] == "session_header"
+            parsed["name"] = name
+            lines[idx] = JSON.generate(parsed) + "\n"
+            File.write(file, lines.join)
+            return
+          end
+        rescue JSON::ParserError
+          next
+        end
+      end
+    end
+
+    # Get the most recent session for a directory.
+    # @param cwd [String] working directory
+    # @return [SessionMeta, nil]
+    def latest(cwd:)
+      sessions = list(cwd: cwd)
+      sessions.first
+    end
+
+    # Fork a session at a specific entry, creating a new branching session.
+    # @param session_id [String]
+    # @param cwd [String] working directory
+    # @param from_entry_id [String] entry ID to fork at
+    # @return [String] new session ID
+    # @raise [RuntimeError] if entry is not found
+    def fork(session_id, cwd:, from_entry_id:)
+      entries = load(session_id, cwd: cwd)
+      fork_point = entries.index { |e| e.id == from_entry_id }
+      raise "Entry #{from_entry_id} not found in session #{session_id}" unless fork_point
+
+      prefix = entries[0..fork_point]
+      new_id = SecureRandom.uuid
+      prefix.each { |e| append(new_id, cwd: cwd, entry: e) }
+      new_id
+    end
+
+    # Delete a session file.
+    # @param session_id [String]
+    # @param cwd [String] working directory
+    # @return [void]
+    def delete(session_id, cwd:)
+      file = session_file(session_id, cwd: cwd)
+      File.delete(file) if File.exist?(file)
+    end
+
+    # @api private
+    def session_file(session_id, cwd:)
+      File.join(session_dir(cwd: cwd), "#{session_id}.jsonl")
+    end
+
+    # Compute a short directory hash for session folder naming.
+    # @api private
+    def dir_hash(cwd:)
+      Digest::SHA256.hexdigest(cwd)[0, 12]
+    end
+
+    private
+
+    # @api private
+    def session_dir(cwd:)
+      File.join(@sessions_dir, dir_hash(cwd: cwd))
+    end
+  end
+end

data/lib/crimson/setup.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require 'tty-spinner'
+require 'net/http'
+require 'uri'
+require 'json'
+require 'fileutils'
+require_relative 'providers'
+
+module Crimson
+  # First-run setup wizard that guides users through provider selection and configuration.
+  class Setup
+    # Run the full first-time setup including copying default skills.
+    # @return [void]
+    def self.first_run
+      copy_default_skills
+      run
+    end
+
+    # Run the interactive configuration wizard.
+    # @return [void]
+    def self.run
+      prompt = TTY::Prompt.new
+      puts "Crimson Setup"
+      puts "============="
+      puts
+
+      provider = select_provider(prompt)
+      api_key = ask_for_api_key(prompt, provider)
+      base_url = ask_for_base_url(prompt) if provider == :custom
+      models = fetch_models(provider, api_key, base_url)
+
+      if models.empty?
+        puts "No models found for the provided API key."
+        return
+      end
+
+      model = select_model(prompt, models)
+      save_config(provider, api_key, base_url, model)
+
+      puts
+      puts "Configuration saved to #{Crimson::CONFIG_FILE}"
+    end
+
+    private
+
+    # @api private
+    def self.select_provider(prompt)
+      prompt.select("Select a provider:",
+        PROVIDERS.map { |key, data| { name: data[:name], value: key } }
+      )
+    end
+
+    # @api private
+    def self.ask_for_api_key(prompt, provider)
+      prompt.mask("Enter your #{PROVIDERS[provider][:name]} API key:")
+    end
+
+    # @api private
+    def self.ask_for_base_url(prompt)
+      prompt.ask("Enter the base URL for the provider:")
+    end
+
+    # @api private
+    def self.select_model(prompt, models)
+      prompt.select("Select a model:", models)
+    end
+
+    # @api private
+    def self.fetch_models(provider, api_key, base_url = nil)
+      spinner = TTY::Spinner.new("[:spinner] Fetching models...", format: :dots)
+      spinner.auto_spin
+
+      url_str = base_url || PROVIDERS[provider][:base_url]
+      url_str += MODELS_ENDPOINT
+      uri = URI(url_str)
+
+      headers = PROVIDERS[provider][:auth_headers].call(api_key)
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = 10
+      http.read_timeout = 30
+
+      request = Net::HTTP::Get.new(uri.request_uri, headers)
+
+      begin
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          spinner.error("Failed!")
+          return []
+        end
+
+        data = JSON.parse(response.body)
+        models = data["data"].map { |model| model["id"] }
+
+        spinner.success("Done!")
+        models
+      rescue => e
+        spinner.error("Error: #{e.message}")
+        []
+      end
+    end
+
+    # @api private
+    def self.save_config(provider, api_key, base_url, model)
+      config = Crimson::Config.new(
+        provider: provider.to_s,
+        model: model,
+        api_key: api_key,
+        base_url: base_url,
+        max_tokens: 1000
+      )
+      config.save
+    end
+
+    # @api private
+    def self.copy_default_skills
+      FileUtils.mkdir_p(Crimson::SKILLS_DIR)
+
+      gem_root = File.expand_path("../..", __dir__)
+      bundled_skills_dir = File.join(gem_root, "skills")
+
+      return unless Dir.exist?(bundled_skills_dir)
+
+      Dir.glob(File.join(bundled_skills_dir, "*.md")).each do |file|
+        dest = File.join(Crimson::SKILLS_DIR, File.basename(file))
+        FileUtils.cp(file, dest) unless File.exist?(dest)
+      end
+    end
+  end
+end

data/lib/crimson/skill_router.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Crimson
+  # Routes user intents to skills based on trigger keyword matching.
+  # Supports auto-inject skills triggered by tool usage and domain-based priority sorting.
+  class SkillRouter
+    # Directory where bundled skills are stored in the repository.
+    REPO_SKILLS_DIR = File.expand_path("../../skills", __dir__)
+
+    # Skill domain descriptor.
+    Domain = Struct.new(:name, :priority, keyword_init: true)
+
+    # Built-in skill domains with their priority levels.
+    DOMAINS = {
+      engineering: Domain.new(name: "engineering", priority: 10),
+      analysis:    Domain.new(name: "analysis",    priority: 5),
+      communication: Domain.new(name: "communication", priority: 5),
+      safety:      Domain.new(name: "safety",      priority: 20),
+    }.freeze
+
+    MAX_CONDITIONAL_SKILLS = 2
+
+    # @param skills_dirs [Array<String>, nil] directories to search for skill markdown files
+    def initialize(skills_dirs: nil)
+      @skills_dirs = skills_dirs || [REPO_SKILLS_DIR]
+      @manifests = {}
+      @skill_paths = {}
+      load_manifests
+    end
+
+    # Resolve which skills are relevant to a user message.
+    # @param user_message [String] the user's input
+    # @param tools_invoked [Array<String>] tools used in the current turn
+    # @return [Array<String>] list of active skill names (always includes "coding")
+    def resolve(user_message, tools_invoked: [])
+      lower = user_message.to_s.downcase.strip
+      matched = []
+
+      @manifests.each do |name, manifest|
+        next if manifest[:auto_inject]
+        next unless triggers_match?(lower, manifest[:triggers])
+        matched << { name: name, priority: manifest[:domain_priority], domain: manifest[:domain] }
+      end
+
+      matched.sort_by! { |s| -s[:priority] }
+
+      result = ["coding"]
+      seen_domains = Set.new
+
+      matched.each do |skill|
+        break if result.length >= MAX_CONDITIONAL_SKILLS + 1
+        next if seen_domains.include?(skill[:domain])
+        result << skill[:name].to_s
+        seen_domains << skill[:domain]
+      end
+
+      @manifests.each do |name, manifest|
+        next unless manifest[:auto_inject]
+        next unless (tools_invoked & manifest[:auto_inject_tools]).any?
+        result << name.to_s unless result.include?(name.to_s)
+      end
+
+      result
+    end
+
+    # Load a skill's content (with front matter stripped).
+    # @param name [String] skill name
+    # @return [String, nil] skill content or nil if not found
+    def load_skill(name)
+      path = @skill_paths[name.to_sym]
+      return nil unless path && File.exist?(path)
+      content = File.read(path)
+      strip_front_matter(content)
+    end
+
+    # @return [Array<String>] all discovered skill names
+    def skill_names
+      @manifests.keys.map(&:to_s)
+    end
+
+    private
+
+    # @api private
+    def load_manifests
+      @skills_dirs.each do |dir|
+        next unless Dir.exist?(dir)
+        Dir.glob(File.join(dir, "*.md")).each do |path|
+          name = File.basename(path, ".md").to_sym
+          next if @manifests.key?(name)
+          content = File.read(path)
+          manifest = parse_front_matter(content, name)
+          if manifest
+            @manifests[name] = manifest
+            @skill_paths[name] = path
+          end
+        end
+      end
+    rescue Errno::ENOENT
+      nil
+    end
+
+    # @api private
+    def parse_front_matter(content, name)
+      return default_manifest(name) unless content.start_with?("---")
+
+      parts = content.split("---", 3)
+      return default_manifest(name) if parts.length < 3
+
+      yaml_block = parts[1]
+      manifest = default_manifest(name)
+
+      yaml_block.each_line do |line|
+        line = line.strip
+        case line
+        when /^domain:\s*(\S+)/
+          domain_name = $1.to_sym
+          manifest[:domain] = domain_name
+          manifest[:domain_priority] = DOMAINS[domain_name]&.priority || 0
+        when /^triggers:\s*\[(.+)\]/
+          manifest[:triggers] = $1.split(",").map { |t| t.strip.downcase }
+        when /^priority:\s*(\d+)/
+          manifest[:priority] = $1.to_i
+        when /^auto_inject:\s*true/
+          manifest[:auto_inject] = true
+          manifest[:auto_inject_tools] = %w[write_file edit_file]
+        when /^auto_inject_tools:\s*\[(.+)\]/
+          manifest[:auto_inject_tools] = $1.split(",").map { |t| t.strip }
+        end
+      end
+
+      manifest[:triggers]&.map!(&:downcase)
+      manifest
+    end
+
+    # @api private
+    def default_manifest(name)
+      {
+        domain: :base,
+        domain_priority: 0,
+        triggers: [],
+        priority: 0,
+        auto_inject: false,
+        auto_inject_tools: [],
+      }
+    end
+
+    # @api private
+    def triggers_match?(message, triggers)
+      triggers&.any? do |t|
+        if t.include?(" ")
+          message.include?(t)
+        else
+          message.match?(/\b#{Regexp.escape(t)}\b/)
+        end
+      end
+    end
+
+    # @api private
+    def strip_front_matter(content)
+      return content unless content.start_with?("---")
+      parts = content.split("---", 3)
+      parts.length >= 3 ? parts[2].strip : content
+    end
+  end
+end