rubyn-code 0.1.0

data/lib/rubyn_code/cli/stream_formatter.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "rouge"
+
+module RubynCode
+  module CLI
+    # Formats streamed text on-the-fly with markdown rendering.
+    # Buffers code blocks until they close, then syntax-highlights them.
+    # Applies inline formatting (bold, code, headers) as text arrives.
+    class StreamFormatter
+      def initialize(renderer = nil)
+        @pastel = Pastel.new
+        @rouge_formatter = Rouge::Formatters::Terminal256.new(theme: Rouge::Themes::Monokai.new)
+        @buffer = +""
+        @in_code_block = false
+        @code_lang = nil
+        @code_buffer = +""
+      end
+
+      # Feed a chunk of streamed text
+      def feed(text)
+        @buffer << text
+
+        # Process complete lines from the buffer
+        while (newline_idx = @buffer.index("\n"))
+          line = @buffer.slice!(0, newline_idx + 1)
+          process_line(line)
+        end
+
+        # Print any remaining partial line (no newline yet) if not in a code block
+        unless @in_code_block || @buffer.empty?
+          $stdout.print format_inline(@buffer)
+          $stdout.flush
+          @buffer = +""
+        end
+      end
+
+      # Flush any remaining buffered content
+      def flush
+        unless @buffer.empty?
+          if @in_code_block
+            @code_buffer << @buffer
+            render_code_block
+          else
+            $stdout.print format_inline(@buffer)
+          end
+          @buffer = +""
+        end
+
+        # Flush unclosed code block
+        render_code_block if @in_code_block && !@code_buffer.empty?
+        $stdout.flush
+      end
+
+      private
+
+      def process_line(line)
+        stripped = line.rstrip
+
+        # Code block toggle
+        if stripped.match?(/\A\s*```/)
+          if @in_code_block
+            # Closing fence — render the buffered code
+            render_code_block
+            @in_code_block = false
+            @code_lang = nil
+          else
+            # Opening fence
+            @in_code_block = true
+            @code_lang = stripped.match(/```(\w*)/)[1]
+            @code_lang = "ruby" if @code_lang.empty?
+            @code_buffer = +""
+            $stdout.puts @pastel.dim("  ┌─ #{@code_lang}")
+          end
+          return
+        end
+
+        if @in_code_block
+          @code_buffer << line
+          return
+        end
+
+        # Regular line — format and print
+        $stdout.print format_line(line)
+        $stdout.flush
+      end
+
+      def render_code_block
+        return if @code_buffer.empty?
+
+        lexer = Rouge::Lexer.find(@code_lang || "ruby") || Rouge::Lexers::PlainText.new
+        highlighted = @rouge_formatter.format(lexer.lex(@code_buffer))
+        border = @pastel.dim("  │ ")
+
+        highlighted.each_line do |l|
+          $stdout.print "#{border}#{l}"
+        end
+        $stdout.puts @pastel.dim("  └─")
+        $stdout.flush
+
+        @code_buffer = +""
+      rescue StandardError
+        # Fallback: print unformatted
+        @code_buffer.each_line { |l| $stdout.print "  #{l}" }
+        $stdout.puts
+        @code_buffer = +""
+      end
+
+      def format_line(line)
+        stripped = line.rstrip
+
+        # Headers
+        if stripped.match?(/\A\#{1,6}\s/)
+          level = stripped.match(/\A(\#{1,6})\s/)[1].length
+          text = stripped.sub(/\A\#{1,6}\s+/, "")
+          case level
+          when 1 then "#{@pastel.bold.underline(text)}\n"
+          when 2 then "\n#{@pastel.bold(text)}\n"
+          else "#{@pastel.bold(text)}\n"
+          end
+        # Bullet lists
+        elsif stripped.match?(/\A\s*[-*]\s/)
+          indent = stripped.match(/\A(\s*)/)[1]
+          content = stripped.sub(/\A\s*[-*]\s+/, "")
+          "#{indent}  #{@pastel.cyan("•")} #{format_inline(content)}\n"
+        # Numbered lists
+        elsif stripped.match?(/\A\s*\d+\.\s/)
+          indent = stripped.match(/\A(\s*)/)[1]
+          num = stripped.match(/(\d+)\./)[1]
+          content = stripped.sub(/\A\s*\d+\.\s+/, "")
+          "#{indent}  #{@pastel.cyan(num + ".")} #{format_inline(content)}\n"
+        # Horizontal rules
+        elsif stripped.match?(/\A-{3,}\z/)
+          "#{@pastel.dim("─" * 40)}\n"
+        else
+          "#{format_inline(line.chomp)}\n"
+        end
+      end
+
+      def format_inline(text)
+        text
+          .gsub(/\*\*(.+?)\*\*/) { @pastel.bold(Regexp.last_match(1)) }
+          .gsub(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/) { @pastel.italic(Regexp.last_match(1)) }
+          .gsub(/`([^`]+)`/) { @pastel.cyan(Regexp.last_match(1)) }
+      end
+    end
+  end
+end

data/lib/rubyn_code/config/defaults.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Config
+    module Defaults
+      HOME_DIR = File.expand_path("~/.rubyn-code")
+      CONFIG_FILE = File.join(HOME_DIR, "config.yml")
+      DB_FILE = File.join(HOME_DIR, "rubyn_code.db")
+      TOKENS_FILE = File.join(HOME_DIR, "tokens.yml")
+      SESSIONS_DIR = File.join(HOME_DIR, "sessions")
+      MEMORIES_DIR = File.join(HOME_DIR, "memories")
+
+      DEFAULT_MODEL = "claude-opus-4-6"
+      MAX_ITERATIONS = 200
+      MAX_SUB_AGENT_ITERATIONS = 30
+      MAX_OUTPUT_CHARS = 50_000
+      CONTEXT_THRESHOLD_TOKENS = 50_000
+      MICRO_COMPACT_KEEP_RECENT = 3
+
+      POLL_INTERVAL = 5
+      IDLE_TIMEOUT = 60
+
+      SESSION_BUDGET_USD = 5.00
+      DAILY_BUDGET_USD = 10.00
+
+      OAUTH_CLIENT_ID = "rubyn-code"
+      OAUTH_REDIRECT_URI = "http://localhost:19275/callback"
+      OAUTH_AUTHORIZE_URL = "https://claude.ai/oauth/authorize"
+      OAUTH_TOKEN_URL = "https://claude.ai/oauth/token"
+      OAUTH_SCOPES = "user:read model:read model:write"
+
+      DANGEROUS_PATTERNS = [
+        "rm -rf /", "sudo rm", "shutdown", "reboot",
+        "> /dev/", "mkfs", "dd if=", ":(){:|:&};:"
+      ].freeze
+
+      SCRUB_ENV_VARS = %w[
+        API_KEY SECRET TOKEN PASSWORD CREDENTIAL
+        PRIVATE_KEY ACCESS_KEY SESSION_KEY
+      ].freeze
+    end
+  end
+end

data/lib/rubyn_code/config/project_config.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require_relative "defaults"
+require_relative "settings"
+
+module RubynCode
+  module Config
+    class ProjectConfig
+      class LoadError < StandardError; end
+
+      PROJECT_DIR_NAME = ".rubyn-code"
+      CONFIG_FILENAME = "config.yml"
+
+      attr_reader :project_root, :config_path, :data
+
+      # @param project_root [String] the root directory of the project (defaults to pwd)
+      # @param global_settings [Settings, nil] global settings to fall back to
+      def initialize(project_root: Dir.pwd, global_settings: nil)
+        @project_root = File.expand_path(project_root)
+        @project_dir = File.join(@project_root, PROJECT_DIR_NAME)
+        @config_path = File.join(@project_dir, CONFIG_FILENAME)
+        @global_settings = global_settings || Settings.new
+        @data = {}
+        load!
+      end
+
+      def get(key, default = nil)
+        @data.fetch(key.to_s) { @global_settings.get(key, default) }
+      end
+
+      def set(key, value)
+        @data[key.to_s] = value
+      end
+
+      # Dynamically delegate configurable keys: project-level overrides global
+      Settings::CONFIGURABLE_KEYS.each do |key|
+        define_method(key) do
+          @data.fetch(key.to_s) { @global_settings.public_send(key) }
+        end
+
+        define_method(:"#{key}=") do |value|
+          @data[key.to_s] = value
+        end
+      end
+
+      def save!
+        ensure_project_directory!
+        File.write(@config_path, YAML.dump(@data))
+      rescue Errno::EACCES => e
+        raise LoadError, "Permission denied writing project config to #{@config_path}: #{e.message}"
+      rescue SystemCallError => e
+        raise LoadError, "Failed to save project config to #{@config_path}: #{e.message}"
+      end
+
+      def reload!
+        load!
+      end
+
+      def to_h
+        @global_settings.to_h.merge(@data)
+      end
+
+      def project_dir_exists?
+        File.directory?(@project_dir)
+      end
+
+      # Walks up the directory tree to find the nearest .rubyn-code/config.yml
+      # Returns nil if none is found before reaching the filesystem root.
+      def self.find_nearest(start_dir: Dir.pwd, global_settings: nil)
+        dir = File.expand_path(start_dir)
+
+        loop do
+          candidate = File.join(dir, PROJECT_DIR_NAME, CONFIG_FILENAME)
+          if File.exist?(candidate)
+            return new(project_root: dir, global_settings: global_settings)
+          end
+
+          parent = File.dirname(dir)
+          break if parent == dir # filesystem root reached
+
+          dir = parent
+        end
+
+        nil
+      end
+
+      private
+
+      def ensure_project_directory!
+        return if File.directory?(@project_dir)
+
+        FileUtils.mkdir_p(@project_dir)
+      rescue SystemCallError => e
+        raise LoadError, "Cannot create project config directory #{@project_dir}: #{e.message}"
+      end
+
+      def load!
+        return unless File.exist?(@config_path)
+
+        content = File.read(@config_path)
+        return if content.strip.empty?
+
+        parsed = YAML.safe_load(content, permitted_classes: [Symbol])
+
+        case parsed
+        in Hash => h
+          @data = h.transform_keys(&:to_s)
+        else
+          raise LoadError, "Expected a YAML mapping in #{@config_path}, got #{parsed.class}"
+        end
+      rescue Psych::SyntaxError => e
+        raise LoadError, "Malformed YAML in #{@config_path}: #{e.message}"
+      rescue Errno::EACCES => e
+        raise LoadError, "Permission denied reading #{@config_path}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/rubyn_code/config/settings.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require_relative "defaults"
+
+module RubynCode
+  module Config
+    class Settings
+      class LoadError < StandardError; end
+
+      CONFIGURABLE_KEYS = %i[
+        model max_iterations max_sub_agent_iterations max_output_chars
+        context_threshold_tokens micro_compact_keep_recent
+        poll_interval idle_timeout
+        session_budget_usd daily_budget_usd
+        oauth_client_id oauth_redirect_uri oauth_authorize_url
+        oauth_token_url oauth_scopes
+      ].freeze
+
+      DEFAULT_MAP = {
+        model: Defaults::DEFAULT_MODEL,
+        max_iterations: Defaults::MAX_ITERATIONS,
+        max_sub_agent_iterations: Defaults::MAX_SUB_AGENT_ITERATIONS,
+        max_output_chars: Defaults::MAX_OUTPUT_CHARS,
+        context_threshold_tokens: Defaults::CONTEXT_THRESHOLD_TOKENS,
+        micro_compact_keep_recent: Defaults::MICRO_COMPACT_KEEP_RECENT,
+        poll_interval: Defaults::POLL_INTERVAL,
+        idle_timeout: Defaults::IDLE_TIMEOUT,
+        session_budget_usd: Defaults::SESSION_BUDGET_USD,
+        daily_budget_usd: Defaults::DAILY_BUDGET_USD,
+        oauth_client_id: Defaults::OAUTH_CLIENT_ID,
+        oauth_redirect_uri: Defaults::OAUTH_REDIRECT_URI,
+        oauth_authorize_url: Defaults::OAUTH_AUTHORIZE_URL,
+        oauth_token_url: Defaults::OAUTH_TOKEN_URL,
+        oauth_scopes: Defaults::OAUTH_SCOPES
+      }.freeze
+
+      attr_reader :config_path, :data
+
+      def initialize(config_path: Defaults::CONFIG_FILE)
+        @config_path = config_path
+        @data = {}
+        ensure_home_directory!
+        load!
+      end
+
+      # Define accessor methods for each configurable key
+      CONFIGURABLE_KEYS.each do |key|
+        define_method(key) do
+          @data.fetch(key.to_s, DEFAULT_MAP[key])
+        end
+
+        define_method(:"#{key}=") do |value|
+          @data[key.to_s] = value
+        end
+      end
+
+      def get(key, default = nil)
+        sym = key.to_sym
+        @data.fetch(key.to_s) { DEFAULT_MAP.fetch(sym, default) }
+      end
+
+      def set(key, value)
+        @data[key.to_s] = value
+      end
+
+      def save!
+        ensure_home_directory!
+        File.write(@config_path, YAML.dump(@data))
+        File.chmod(0o600, @config_path)
+      rescue Errno::EACCES => e
+        raise LoadError, "Permission denied writing config to #{@config_path}: #{e.message}"
+      rescue SystemCallError => e
+        raise LoadError, "Failed to save config to #{@config_path}: #{e.message}"
+      end
+
+      def reload!
+        load!
+      end
+
+      def to_h
+        DEFAULT_MAP.transform_keys(&:to_s).merge(@data)
+      end
+
+      def home_dir = Defaults::HOME_DIR
+      def db_file = Defaults::DB_FILE
+      def tokens_file = Defaults::TOKENS_FILE
+      def sessions_dir = Defaults::SESSIONS_DIR
+      def memories_dir = Defaults::MEMORIES_DIR
+
+      def dangerous_patterns = Defaults::DANGEROUS_PATTERNS
+      def scrub_env_vars = Defaults::SCRUB_ENV_VARS
+
+      private
+
+      def ensure_home_directory!
+        dir = File.dirname(@config_path)
+        return if File.directory?(dir)
+
+        FileUtils.mkdir_p(dir, mode: 0o700)
+      rescue SystemCallError => e
+        raise LoadError, "Cannot create config directory #{dir}: #{e.message}"
+      end
+
+      def load!
+        return unless File.exist?(@config_path)
+
+        content = File.read(@config_path)
+        return if content.strip.empty?
+
+        parsed = YAML.safe_load(content, permitted_classes: [Symbol])
+
+        case parsed
+        in Hash => h
+          @data = h.transform_keys(&:to_s)
+        else
+          raise LoadError, "Expected a YAML mapping in #{@config_path}, got #{parsed.class}"
+        end
+      rescue Psych::SyntaxError => e
+        raise LoadError, "Malformed YAML in #{@config_path}: #{e.message}"
+      rescue Errno::EACCES => e
+        raise LoadError, "Permission denied reading #{@config_path}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/rubyn_code/context/auto_compact.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module RubynCode
+  module Context
+    # LLM-driven summarization triggered automatically when the context window
+    # grows too large. Serializes the conversation tail, asks the LLM to produce
+    # a continuity summary, and returns a fresh single-message conversation.
+    module AutoCompact
+      SUMMARY_INSTRUCTION = <<~PROMPT
+        You are a context compaction assistant. Summarize the following conversation transcript for continuity. Cover exactly three areas:
+
+        1) **What was accomplished** - completed tasks, files changed, problems solved
+        2) **Current state** - what the user/agent is working on right now, any pending actions
+        3) **Key decisions made** - architectural choices, user preferences, constraints established
+
+        Be concise but preserve all details needed to continue the work seamlessly. Use bullet points.
+      PROMPT
+
+      MAX_TRANSCRIPT_CHARS = 80_000
+
+      # Compacts the conversation by summarizing it through the LLM.
+      #
+      # @param messages [Array<Hash>] current conversation messages
+      # @param llm_client [#chat] an LLM client that responds to #chat
+      # @param transcript_dir [String, nil] directory to save full transcript before compaction
+      # @return [Array<Hash>] new messages array containing only the summary
+      def self.call(messages, llm_client:, transcript_dir: nil)
+        save_transcript(messages, transcript_dir) if transcript_dir
+
+        transcript_text = serialize_tail(messages, MAX_TRANSCRIPT_CHARS)
+        summary = request_summary(transcript_text, llm_client)
+
+        [{ role: "user", content: "[Context compacted]\n\n#{summary}" }]
+      end
+
+      # Persists the full conversation to a timestamped JSON file.
+      def self.save_transcript(messages, dir)
+        FileUtils.mkdir_p(dir)
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        path = File.join(dir, "transcript_#{timestamp}.json")
+        File.write(path, JSON.pretty_generate(messages))
+        path
+      end
+
+      # Takes the last +max_chars+ of the JSON-serialized messages.
+      def self.serialize_tail(messages, max_chars)
+        json = JSON.generate(messages)
+        return json if json.length <= max_chars
+
+        json[-max_chars..]
+      end
+
+      # Sends the transcript to the LLM for summarization.
+      def self.request_summary(transcript_text, llm_client)
+        summary_messages = [
+          {
+            role: "user",
+            content: "#{SUMMARY_INSTRUCTION}\n\n---\n\n#{transcript_text}"
+          }
+        ]
+
+        options = {}
+        options[:model] = "claude-sonnet-4-20250514" if llm_client.respond_to?(:chat)
+
+        response = llm_client.chat(messages: summary_messages, **options)
+
+        case response
+        when String then response
+        when Hash then response[:content] || response["content"] || response.to_s
+        else
+          response.respond_to?(:text) ? response.text : response.to_s
+        end
+      end
+
+      private_class_method :save_transcript, :serialize_tail, :request_summary
+    end
+  end
+end

data/lib/rubyn_code/context/compactor.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubynCode
+  module Context
+    # Facade that coordinates the three compaction strategies: micro (every turn),
+    # auto (when threshold is exceeded), and manual (user-triggered via /compact).
+    class Compactor
+      CHARS_PER_TOKEN = 4
+
+      # @param llm_client [#chat, nil] LLM client for summarization-based compaction
+      # @param threshold [Integer] estimated token count that triggers auto-compaction
+      # @param transcript_dir [String, nil] directory to persist transcripts before compaction
+      def initialize(llm_client:, threshold: 50_000, transcript_dir: nil)
+        @llm_client = llm_client
+        @threshold = threshold
+        @transcript_dir = transcript_dir
+      end
+
+      # Runs zero-cost micro-compaction on old tool results. Mutates messages
+      # in place and returns the count of compacted results.
+      #
+      # @param messages [Array<Hash>] conversation messages
+      # @return [Integer] number of tool results compacted
+      def micro_compact!(messages)
+        MicroCompact.call(messages)
+      end
+
+      # Runs LLM-driven auto-compaction, replacing the full conversation with a
+      # continuity summary. Returns a new messages array.
+      #
+      # @param messages [Array<Hash>] conversation messages
+      # @return [Array<Hash>] compacted messages (single summary message)
+      # @raise [RubynCode::Error] if no LLM client is configured
+      def auto_compact!(messages)
+        ensure_llm_client!
+
+        AutoCompact.call(
+          messages,
+          llm_client: @llm_client,
+          transcript_dir: @transcript_dir
+        )
+      end
+
+      # Runs LLM-driven manual compaction, optionally guided by a focus prompt.
+      # Returns a new messages array.
+      #
+      # @param messages [Array<Hash>] conversation messages
+      # @param focus [String, nil] optional user-supplied focus to guide summarization
+      # @return [Array<Hash>] compacted messages (single summary message)
+      # @raise [RubynCode::Error] if no LLM client is configured
+      def manual_compact!(messages, focus: nil)
+        ensure_llm_client!
+
+        ManualCompact.call(
+          messages,
+          llm_client: @llm_client,
+          transcript_dir: @transcript_dir,
+          focus: focus
+        )
+      end
+
+      # Checks whether the estimated token count for the messages exceeds the
+      # configured threshold.
+      #
+      # @param messages [Array<Hash>] conversation messages
+      # @return [Boolean]
+      def should_auto_compact?(messages)
+        estimated_tokens(messages) > @threshold
+      end
+
+      private
+
+      def estimated_tokens(messages)
+        json = JSON.generate(messages)
+        (json.length.to_f / CHARS_PER_TOKEN).ceil
+      rescue JSON::GeneratorError
+        0
+      end
+
+      def ensure_llm_client!
+        return if @llm_client
+
+        raise RubynCode::Error, "LLM client is required for summarization-based compaction"
+      end
+    end
+  end
+end

data/lib/rubyn_code/context/manager.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubynCode
+  module Context
+    # Orchestrates context management for a session. Tracks cumulative token
+    # usage from LLM responses and triggers compaction strategies when the
+    # estimated context size exceeds the configured threshold.
+    class Manager
+      CHARS_PER_TOKEN = 4
+
+      attr_reader :total_input_tokens, :total_output_tokens
+
+      # @param threshold [Integer] estimated token count that triggers auto-compaction
+      def initialize(threshold: 50_000)
+        @threshold = threshold
+        @total_input_tokens = 0
+        @total_output_tokens = 0
+      end
+
+      # Accumulates token counts from an LLM response usage object.
+      #
+      # @param usage [LLM::Usage, #input_tokens] usage data from an LLM response
+      def track_usage(usage)
+        @total_input_tokens += usage.input_tokens.to_i
+        @total_output_tokens += usage.output_tokens.to_i
+      end
+
+      # Rough estimate of token count for a set of messages based on their
+      # JSON-serialized character length (~4 chars per token).
+      #
+      # @param messages [Array<Hash>] conversation messages
+      # @return [Integer] estimated token count
+      def estimated_tokens(messages)
+        json = JSON.generate(messages)
+        (json.length.to_f / CHARS_PER_TOKEN).ceil
+      rescue JSON::GeneratorError
+        0
+      end
+
+      # Returns true if the estimated token count exceeds the threshold.
+      #
+      # @param messages [Array<Hash>] conversation messages
+      # @return [Boolean]
+      def needs_compaction?(messages)
+        estimated_tokens(messages) > @threshold
+      end
+
+      # Runs micro-compaction every turn and auto-compaction when the context
+      # exceeds the threshold. Expects a conversation object that responds to
+      # #messages and #messages= (or #replace_messages).
+      #
+      # @param conversation [#messages, #messages=] conversation wrapper
+      # @return [void]
+      def check_compaction!(conversation)
+        messages = conversation.messages
+
+        MicroCompact.call(messages)
+
+        return unless needs_compaction?(messages)
+
+        compactor = Compactor.new(
+          llm_client: conversation.respond_to?(:llm_client) ? conversation.llm_client : nil,
+          threshold: @threshold
+        )
+
+        new_messages = compactor.auto_compact!(messages)
+        apply_compacted_messages(conversation, new_messages)
+      end
+
+      # Resets cumulative token counters to zero.
+      #
+      # @return [void]
+      def reset!
+        @total_input_tokens = 0
+        @total_output_tokens = 0
+      end
+
+      private
+
+      def apply_compacted_messages(conversation, new_messages)
+        if conversation.respond_to?(:replace_messages)
+          conversation.replace_messages(new_messages)
+        elsif conversation.respond_to?(:messages=)
+          conversation.messages = new_messages
+        end
+      end
+    end
+  end
+end