debug-agent 0.2.6

data/lib/debug_agent/context_compressor.rb

@@ -0,0 +1,159 @@
+require 'json'
+
+module DebugAgent
+  CompressionResult = Struct.new(:original_tokens, :compressed_tokens, :removed_rounds, :strategy, keyword_init: true)
+
+  class ContextCompressor
+    def initialize(llm, model, temperature, max_context_tokens, recent_rounds_to_keep = 3)
+      @llm = llm
+      @model = model
+      @temperature = temperature
+      @max_context_tokens = max_context_tokens
+      @recent_rounds_to_keep = recent_rounds_to_keep
+    end
+
+    # Trigger compression when token usage exceeds 75% of context window
+    def needs_compression?(current_tokens)
+      current_tokens > (@max_context_tokens * 0.75).to_i
+    end
+
+    def compress(session)
+      original_tokens = session.current_context_tokens
+      return nil unless needs_compression?(original_tokens)
+
+      rounds = identify_rounds(session.messages)
+
+      keep_count = [@recent_rounds_to_keep, rounds.size - 1].min
+      return nil if keep_count < 1
+
+      summarize_count = rounds.size - keep_count
+
+      to_summarize = rounds.first(summarize_count).flatten
+      to_keep = rounds.drop(summarize_count).flatten
+
+      begin
+        summary = summarize_with_llm(to_summarize)
+      rescue StandardError => e
+        summary = fallback_truncate(to_summarize)
+      end
+
+      compressed = [
+        { 'role' => 'system', 'content' => "[Previous conversation summary — #{summarize_count} rounds compressed]\n\n#{summary}" }
+      ] + to_keep
+
+      compressed_tokens = estimate_tokens(compressed)
+      session.replace_messages(compressed)
+
+      CompressionResult.new(
+        original_tokens: original_tokens,
+        compressed_tokens: compressed_tokens,
+        removed_rounds: summarize_count,
+        strategy: "LLM summarized #{summarize_count} rounds"
+      )
+    end
+
+    private
+
+    def summarize_with_llm(old_messages)
+      conversation_text = ''
+      old_messages.each do |msg|
+        case msg['role']
+        when 'user'
+          conversation_text << "[User] #{msg['content']}\n\n"
+        when 'assistant'
+          conversation_text << "[Assistant] #{msg['content']}\n\n" if msg['content']
+          (msg['tool_calls'] || []).each do |tc|
+            fn = tc['function'] || {}
+            conversation_text << "[Tool Call] #{fn['name']}(#{fn['arguments']})\n\n"
+          end
+        when 'tool'
+          content = msg['content'].to_s
+          content = content[0..2000] + '...[truncated]' if content.length > 2000
+          conversation_text << "[Tool Result] #{content}\n\n"
+        end
+      end
+
+      prompt = <<~PROMPT
+        You are a conversation summarizer for a Ruby debugging assistant.
+        Summarize the KEY diagnostic findings from the conversation below concisely.
+
+        Focus on preserving:
+        - Problems investigated and their root causes (if found)
+        - Key tool results: actual numbers, statuses, error messages, configuration values
+        - Recommendations or fixes already suggested
+        - Any unresolved issues or follow-up actions pending
+
+        Rules:
+        - Be concise but preserve ALL important data points
+        - Use bullet points
+        - Do NOT include full JSON dumps
+        - Keep it under 600 words
+      PROMPT
+
+      response = @llm.chat(
+        [
+          { 'role' => 'system', 'content' => prompt },
+          { 'role' => 'user', 'content' => "Conversation to summarize:\n\n#{conversation_text}" }
+        ],
+        nil
+      )
+      response.dig('choices', 0, 'message', 'content') || '(summary unavailable)'
+    end
+
+    def fallback_truncate(messages)
+      sb = +"Previous conversation summary (fallback):\n\n"
+      messages.each do |msg|
+        if msg['role'] == 'user' && msg['content']
+          q = msg['content'].length > 100 ? msg['content'][0..99] + '...' : msg['content']
+          sb << "- User asked: #{q}\n"
+        end
+        if msg['role'] == 'assistant' && msg['tool_calls']
+          msg['tool_calls'].each { |tc| sb << "- Called tool: #{tc.dig('function', 'name')}\n" }
+        end
+      end
+      sb
+    end
+
+    def identify_rounds(messages)
+      rounds = []
+      current = []
+      has_assistant = false
+
+      messages.each do |msg|
+        case msg['role']
+        when 'user'
+          if current.any?
+            rounds << current
+            current = []
+            has_assistant = false
+          end
+          current << msg
+        when 'assistant'
+          if has_assistant
+            rounds << current
+            current = []
+            has_assistant = false
+          end
+          current << msg
+          has_assistant = true
+        else
+          current << msg
+        end
+      end
+      rounds << current if current.any?
+      rounds
+    end
+
+    def estimate_tokens(messages)
+      chars = 0
+      messages.each do |msg|
+        chars += (msg['content'] || '').length
+        (msg['tool_calls'] || []).each do |tc|
+          fn = tc['function'] || {}
+          chars += (fn['name'] || '').length + (fn['arguments'] || '').length
+        end
+      end
+      chars / 4
+    end
+  end
+end

data/lib/debug_agent/engine.rb

@@ -0,0 +1,162 @@
+require 'json'
+
+module DebugAgent
+  # StreamHandler implementation used internally by the engine
+  class EngineStreamHandler < StreamHandler
+    attr_reader :tool_calls, :usage, :had_error, :content
+
+    def initialize(callback)
+      @callback = callback
+      @tool_calls = []
+      @usage = nil
+      @had_error = false
+      @content = +''
+    end
+
+    def on_content(chunk)
+      @content << chunk
+      @callback.on_content(chunk)
+    end
+
+    def on_complete(tool_calls, finish_reason, usage)
+      @tool_calls = tool_calls
+      @usage = usage
+    end
+
+    def on_error(error)
+      @had_error = true
+      @callback.on_error("LLM API error: #{error.message}")
+    end
+  end
+
+  class DebugEngine
+    attr_reader :tools, :system_prompt
+
+    def initialize(config = nil)
+      @config = config || Config.from_env
+      @llm = LLMClient.new(@config.llm)
+      @tools = REGISTRY
+
+      @prompt_builder = SystemPromptBuilder.new(@tools)
+      @system_prompt = @prompt_builder.build
+
+      @context_compressor = ContextCompressor.new(
+        @llm, @config.llm.model, @config.llm.temperature, @config.llm.context_window_tokens
+      )
+
+      @sessions = {}
+      @mutex = Mutex.new
+    end
+
+    def chat(message, session_id = 'default', callback = nil)
+      callback ||= ChatCallback.new
+
+      session = get_or_create_session(session_id)
+      session.add_message({ 'role' => 'user', 'content' => message })
+
+      run_tool_loop(session, callback)
+    end
+
+    def clear_session(session_id = 'default')
+      @mutex.synchronize do
+        session = @sessions[session_id]
+        session&.clear
+      end
+    end
+
+    private
+
+    def get_or_create_session(session_id)
+      @mutex.synchronize do
+        @sessions[session_id] ||= ChatSession.new(session_id)
+      end
+    end
+
+    def run_tool_loop(session, cb)
+      max_rounds = @config.llm.max_tool_rounds
+
+      max_rounds.times do |round_num|
+        # Context compression
+        if round_num > 0 && @context_compressor.needs_compression?(session.current_context_tokens)
+          result = @context_compressor.compress(session)
+          if result
+            cb.on_content("\n\n> [Context auto-compressed: #{result.original_tokens} -> ~#{result.compressed_tokens} tokens (#{result.strategy})]\n\n")
+            cb.on_context_compressed(result.original_tokens, result.compressed_tokens, result.removed_rounds)
+          end
+        end
+
+        messages = [{ 'role' => 'system', 'content' => @system_prompt }] + session.messages
+        tool_schemas = @tools.all_schemas
+
+        handler = EngineStreamHandler.new(cb)
+        @llm.chat_stream_raw(messages, tool_schemas, 'auto', handler)
+
+        return if handler.had_error
+
+        session.record_token_usage(handler.usage) if handler.usage
+
+        if handler.tool_calls.empty?
+          # After tool calls, if LLM returns empty content, prompt it to summarize
+          if handler.content.strip.empty? && round_num > 0
+            session.add_message({ 'role' => 'assistant', 'content' => '' })
+            session.add_message({
+              'role' => 'user',
+              'content' => 'You called tools but did not provide any analysis. ' \
+                'Please summarize the key findings from the tool results above and ' \
+                'provide actionable recommendations.'
+            })
+            next
+          end
+
+          # Final answer
+          session.add_message({ 'role' => 'assistant', 'content' => handler.content })
+          cb.on_complete
+          return
+        end
+
+        # Execute tool calls
+        session.add_message({
+          'role' => 'assistant',
+          'content' => handler.content,
+          'tool_calls' => handler.tool_calls
+        })
+
+        handler.tool_calls.each do |tc|
+          tool_name = tc['function']['name']
+          args = {}
+          begin
+            args = JSON.parse(tc['function']['arguments'] || '{}')
+          rescue JSON::ParserError
+          end
+
+          cb.on_tool_start(tool_name, tc['function']['arguments'])
+
+          result = @tools.execute(tool_name, args)
+          result_str = JSON.generate(result)
+          result_str = result_str[0..12_000] if result_str.length > 12_000
+
+          cb.on_tool_result(tool_name, result_str)
+          session.add_message({
+            'role' => 'tool',
+            'tool_call_id' => tc['id'],
+            'content' => result_str
+          })
+        end
+      end
+
+      # Max rounds — force final summary
+      final_messages = [{ 'role' => 'system', 'content' => @system_prompt }] + session.messages
+      final_messages << {
+        'role' => 'system',
+        'content' => 'You have reached the maximum number of tool-calling rounds. ' \
+          'Based on all the diagnostic data you have gathered so far, ' \
+          'provide a comprehensive analysis and actionable recommendations NOW. ' \
+          'Do not attempt to call more tools.'
+      }
+
+      handler = EngineStreamHandler.new(cb)
+      @llm.chat_stream_raw(final_messages, [], 'none', handler)
+      cb.on_complete
+    end
+  end
+end

data/lib/debug_agent/inspectors/gc.rb

@@ -0,0 +1,90 @@
+require 'objspace'
+
+module DebugAgent
+  register_tool('get_gc_stats',
+                'Get detailed GC statistics: count, heap pages, slots, total allocated objects') do
+    stats = GC.stat
+    {
+      count: stats[:count],
+      major_gc_count: stats[:major_gc_count],
+      minor_gc_count: stats[:minor_gc_count],
+      total_allocated_objects: stats[:total_allocated_objects],
+      total_freed_objects: stats[:total_freed_objects],
+      heap_allocation_pages: stats[:heap_length],
+      heap_eden_pages: stats[:heap_eden_pages],
+      heap_tomb_pages: stats[:heap_tomb_pages],
+      total_slots: stats[:heap_length] * 512,
+      live_slots: stats[:heap_live_slots],
+      free_slots: stats[:heap_free_slots],
+      old_objects: stats[:old_objects],
+      old_objects_limit: stats[:old_objects_limit],
+      malloc_increase_bytes: stats[:malloc_increase_bytes],
+      malloc_increase_bytes_limit: stats[:malloc_increase_bytes_limit]
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_gc_profiler',
+                'Get GC::Profiler data if profiling is enabled (GC timing details)') do
+    if defined?(GC::Profiler)
+      raw_data = GC::Profiler.raw_data
+      total_time = GC::Profiler.total_time
+      if raw_data && !raw_data.empty?
+        {
+          enabled: true,
+          total_gc_time_seconds: total_time.round(6),
+          gc_count: raw_data.size,
+          entries: raw_data.map do |entry|
+            {
+              gc_time: entry[:GC_TIME]&.round(6),
+              gc_invoke_time: entry[:GC_INVOKE_TIME]&.round(6),
+              heap_use_pages: entry[:HEAP_USE_PAGES],
+              heap_live_objects: entry[:HEAP_LIVE_OBJECTS],
+              heap_free_objects: entry[:HEAP_FREE_OBJECTS],
+              heap_total_objects: entry[:HEAP_TOTAL_OBJECTS],
+              gc_mark_time: entry[:GC_MARK_TIME]&.round(6),
+              gc_sweep_time: entry[:GC_SWEEP_TIME]&.round(6)
+            }
+          end
+        }
+      else
+        {
+          enabled: true,
+          message: 'GC::Profiler is available but has no data. Call GC::Profiler.enable to start collecting.',
+          total_gc_time_seconds: 0
+        }
+      end
+    else
+      { enabled: false, message: 'GC::Profiler is not available on this Ruby implementation' }
+    end
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('force_gc',
+                'Trigger a full garbage collection (GC.start with full_mark) and show before/after comparison') do
+    before_stats = GC.stat
+    before_objects = ObjectSpace.count_objects.values.sum
+
+    GC.start(full_mark: true)
+    GC.start(full_mark: true)  # Second call to compact and finalize
+
+    after_stats = GC.stat
+    after_objects = ObjectSpace.count_objects.values.sum
+
+    {
+      triggered: true,
+      objects_before: before_objects,
+      objects_after: after_objects,
+      freed_objects: before_objects - after_objects,
+      gc_count_before: before_stats[:count],
+      gc_count_after: after_stats[:count],
+      live_slots_before: before_stats[:heap_live_slots],
+      live_slots_after: after_stats[:heap_live_slots],
+      freed_slots: before_stats[:heap_live_slots] - after_stats[:heap_live_slots]
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/http_tracker.rb

@@ -0,0 +1,70 @@
+require 'time'
+require 'thread'
+
+module DebugAgent
+  MAX_REQUESTS = 500
+  @request_buffer = []
+  @buffer_lock = Mutex.new
+
+  module HttpRequestTracker
+    def self.record(method, path, status, duration_ms, client = '')
+      DebugAgent.instance_variable_get(:@buffer_lock).synchronize do
+        buffer = DebugAgent.instance_variable_get(:@request_buffer)
+        buffer << {
+          timestamp: Time.now.iso8601,
+          method: method,
+          path: path,
+          status: status,
+          duration_ms: duration_ms.round(2),
+          client: client
+        }
+        buffer.shift if buffer.size > MAX_REQUESTS
+      end
+    end
+
+    def self.all
+      DebugAgent.instance_variable_get(:@buffer_lock).synchronize do
+        DebugAgent.instance_variable_get(:@request_buffer).dup
+      end
+    end
+  end
+
+  register_tool('get_recent_requests', 'Get recent HTTP requests from ring buffer') do |limit: 50|
+    reqs = HttpRequestTracker.all
+    reqs = reqs.last(limit) if limit
+    {
+      total: HttpRequestTracker.all.size,
+      requests: reqs.reverse
+    }
+  end
+
+  register_tool('get_error_requests', 'Get error requests (4xx/5xx)') do
+    reqs = HttpRequestTracker.all.select { |r| r[:status] >= 400 }
+    {
+      count: reqs.size,
+      requests: reqs.sort_by { |r| -r[:duration_ms] }
+    }
+  end
+
+  register_tool('get_request_stats', 'Get HTTP request stats: P50/P95/P99 latency, error rate') do
+    reqs = HttpRequestTracker.all
+    next({ message: 'No requests recorded yet' }) if reqs.empty?
+
+    durations = reqs.map { |r| r[:duration_ms] }.sort
+    n = durations.size
+    errors = reqs.count { |r| r[:status] >= 400 }
+
+    {
+      total_requests: n,
+      error_count: errors,
+      error_rate: format('%.1f%%', errors.to_f / n * 100),
+      latency_ms: {
+        min: durations[0].round(2),
+        p50: durations[(n * 0.5).to_i].round(2),
+        p95: durations[(n * 0.95).to_i].round(2),
+        p99: durations[(n * 0.99).to_i].round(2),
+        max: durations[-1].round(2)
+      }
+    }
+  end
+end

data/lib/debug_agent/inspectors/object_space.rb

@@ -0,0 +1,74 @@
+require 'objspace'
+
+module DebugAgent
+  register_tool('get_object_space_stats',
+                'Get ObjectSpace.count_objects summary by type (T_STRING, T_ARRAY, etc.)') do
+    counts = ObjectSpace.count_objects
+    total = counts[:TOTAL] || counts.values.sum
+
+    {
+      total_objects: total,
+      free_slots: counts[:FREE] || 0,
+      by_type: counts.reject { |k, _| k == :TOTAL || k == :FREE }
+                     .sort_by { |_, v| -v }
+                     .map { |type, count| { type: type.to_s, count: count } }
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_memory_size',
+                'Get total memory size of all live objects (ObjectSpace.memsize_of_all)') do
+    total_bytes = ObjectSpace.memsize_of_all
+
+    # Also get per-type breakdown
+    type_sizes = {}
+    ObjectSpace.count_objects.each do |type, count|
+      next if type == :TOTAL || type == :FREE || count == 0
+      begin
+        size = case type
+               when :T_STRING then ObjectSpace.memsize_of_all(String)
+               when :T_ARRAY then ObjectSpace.memsize_of_all(Array)
+               when :T_HASH then ObjectSpace.memsize_of_all(Hash)
+               when :T_OBJECT then ObjectSpace.memsize_of_all(Object)
+               else 0
+               end
+        type_sizes[type.to_s] = size if size > 0
+      rescue
+      end
+    end
+
+    {
+      total_bytes: total_bytes,
+      total_mb: (total_bytes / 1024.0 / 1024.0).round(2),
+      total_kb: (total_bytes / 1024.0).round(2),
+      top_type_sizes: type_sizes.sort_by { |_, v| -v }.first(10).to_h
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_object_count_by_class',
+                'Get top N classes by instance count using ObjectSpace.each_object') do |top_n: 20|
+    counts = Hash.new(0)
+
+    ObjectSpace.each_object do |obj|
+      begin
+        klass = obj.class
+        name = klass.name || klass.to_s
+        counts[name] += 1
+      rescue
+      end
+    end
+
+    top = counts.sort_by { |_, v| -v }.first(top_n)
+
+    {
+      total_classes: counts.size,
+      total_instances: counts.values.sum,
+      top_classes: top.map { |name, count| { class: name, count: count } }
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/inspectors/process_info.rb

@@ -0,0 +1,61 @@
+require 'etc'
+
+module DebugAgent
+  register_tool('get_process_info',
+                'Get process info: PID, PPID, platform, Ruby version, uptime') do
+    rss = `ps -o rss= -p #{Process.pid}`.to_i
+    start_time = DebugAgent::PROCESS_START_TIME
+    uptime_seconds = Time.now - start_time
+
+    {
+      pid: Process.pid,
+      ppid: Process.ppid,
+      uid: Process.uid,
+      gid: Process.gid,
+      user: Etc.getpwuid(Process.uid)&.name,
+      platform: RUBY_PLATFORM,
+      ruby_version: RUBY_VERSION,
+      ruby_engine: RUBY_ENGINE,
+      ruby_patchlevel: defined?(RUBY_PATCHLEVEL) ? RUBY_PATCHLEVEL : nil,
+      ruby_revision: defined?(RUBY_REVISION) ? RUBY_REVISION.to_s : nil,
+      process_name: $0,
+      rss_mb: (rss / 1024.0).round(2),
+      uptime_seconds: uptime_seconds.round(0),
+      uptime_human: format_uptime(uptime_seconds),
+      hostname: Socket.gethostname,
+      cpu_count: Etc.nprocessors
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_cpu_time',
+                'Get CPU time: user, system, and total (Process.times)') do
+    times = Process.times
+    {
+      user_cpu_seconds: times.utime.round(4),
+      system_cpu_seconds: times.stime.round(4),
+      total_cpu_seconds: (times.utime + times.stime).round(4),
+      child_user_cpu_seconds: times.cutime.round(4),
+      child_system_cpu_seconds: times.cstime.round(4),
+      child_total_cpu_seconds: (times.cutime + times.cstime).round(4)
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  # Helper method for formatting uptime
+  def self.format_uptime(seconds)
+    days = (seconds / 86400).to_i
+    hours = ((seconds % 86400) / 3600).to_i
+    minutes = ((seconds % 3600) / 60).to_i
+    secs = (seconds % 60).to_i
+
+    parts = []
+    parts << "#{days}d" if days > 0
+    parts << "#{hours}h" if hours > 0 || days > 0
+    parts << "#{minutes}m" if minutes > 0 || hours > 0 || days > 0
+    parts << "#{secs}s"
+    parts.join(' ')
+  end
+end