debug-agent 0.2.6

data/lib/debug_agent/inspectors/routes.rb

@@ -0,0 +1,114 @@
+require 'json'
+
+module DebugAgent
+  register_tool('get_routes',
+                'Discover Sinatra/Rack routes from the running application') do
+    routes = []
+    app = DebugAgent.app
+
+    if app.nil?
+      return {
+        total: 0,
+        routes: [],
+        message: 'No application registered with DebugAgent. ' \
+          'Ensure the middleware is properly installed.'
+      }
+    end
+
+    app_class = app.is_a?(Class) ? app : app.class
+
+    # Try Sinatra routes
+    if app_class.respond_to?(:routes)
+      app_class.routes.each do |method, route_list|
+        route_list.each do |route|
+          pattern = route[0]
+          pattern_str = case pattern
+                        when Regexp then pattern.source
+                        else pattern.to_s
+                        end
+          routes << {
+            method: method.to_s.upcase,
+            pattern: pattern_str,
+            file: route[1],
+            line: route[2]
+          }
+        end
+      end
+    end
+
+    # Fallback: check Sinatra::Base if nothing found
+    if routes.empty? && defined?(Sinatra) && defined?(Sinatra::Base)
+      Sinatra::Base.routes.each do |method, route_list|
+        route_list.each do |route|
+          pattern = route[0]
+          pattern_str = case pattern
+                        when Regexp then pattern.source
+                        else pattern.to_s
+                        end
+          routes << {
+            method: method.to_s.upcase,
+            pattern: pattern_str,
+            file: route[1],
+            line: route[2]
+          }
+        end
+      end
+    end
+
+    {
+      total: routes.size,
+      routes: routes
+    }
+  rescue => e
+    { error: e.message, total: 0, routes: [] }
+  end
+
+  register_tool('get_middleware_stack',
+                'List Rack middleware stack from the running application') do
+    stack = []
+    app = DebugAgent.app
+
+    if app.nil?
+      return {
+        total: 0,
+        middleware: [],
+        message: 'No application registered with DebugAgent.'
+      }
+    end
+
+    app_class = app.is_a?(Class) ? app : app.class
+
+    # Try Sinatra/Rack middleware stack
+    if app_class.respond_to?(:middleware)
+      app_class.middleware.each_with_index do |mw, i|
+        klass = mw[0]
+        args = mw[1..-1]
+        stack << {
+          index: i,
+          name: klass.respond_to?(:name) ? klass.name : klass.to_s,
+          arguments: args.map { |a| a.is_a?(String) ? a : a.inspect }
+        }
+      end
+    end
+
+    # Also try Sinatra::Base
+    if stack.empty? && defined?(Sinatra) && defined?(Sinatra::Base)
+      Sinatra::Base.middleware.each_with_index do |mw, i|
+        klass = mw[0]
+        args = mw[1..-1]
+        stack << {
+          index: i,
+          name: klass.respond_to?(:name) ? klass.name : klass.to_s,
+          arguments: args.map { |a| a.is_a?(String) ? a : a.inspect }
+        }
+      end
+    end
+
+    {
+      total: stack.size,
+      middleware: stack
+    }
+  rescue => e
+    { error: e.message, total: 0, middleware: [] }
+  end
+end

data/lib/debug_agent/inspectors/runtime.rb

@@ -0,0 +1,81 @@
+require 'objspace'
+require 'thread'
+
+module DebugAgent
+  register_tool('get_gc_stats', 'Get GC statistics: count, time, live 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],
+      live_objects: ObjectSpace.count_objects[:T_OBJECT] || 0,
+      heap_pages: stats[:heap_length],
+      total_freed_objects: stats[:total_freed_objects]
+    }
+  end
+
+  register_tool('get_memory_summary', 'Get process memory usage: RSS, object counts') do
+    rss = `ps -o rss= -p #{Process.pid}`.to_i / 1024.0
+    counts = ObjectSpace.count_objects
+    top_types = counts.sort_by { |_, v| -v }.first(15).to_h
+    {
+      rss_mb: rss.round(2),
+      total_objects: counts.values.sum,
+      top_object_types: top_types,
+      live_strings: counts[:T_STRING] || 0,
+      live_arrays: counts[:T_ARRAY] || 0,
+      live_hashes: counts[:T_HASH] || 0
+    }
+  end
+
+  register_tool('trigger_gc', 'Trigger GC and show before/after comparison') do
+    before = ObjectSpace.count_objects.values.sum
+    GC.start
+    after = ObjectSpace.count_objects.values.sum
+    {
+      objects_before: before,
+      objects_after: after,
+      freed: before - after,
+      gc_count: GC.stat[:count]
+    }
+  end
+
+  register_tool('get_thread_summary', 'Get thread count and list') do
+    threads = Thread.list
+    {
+      total_threads: threads.size,
+      threads: threads.map do |t|
+        { name: t.to_s, alive: t.alive?, status: t.status }
+      end
+    }
+  end
+
+  register_tool('get_runtime_info', 'Get Ruby runtime info: version, platform, PID') do
+    {
+      ruby_version: RUBY_VERSION,
+      ruby_engine: RUBY_ENGINE,
+      platform: RUBY_PLATFORM,
+      pid: Process.pid,
+      process_name: $0,
+      load_path_count: $LOAD_PATH.size
+    }
+  rescue
+    {
+      ruby_version: RUBY_VERSION,
+      ruby_engine: RUBY_ENGINE,
+      platform: RUBY_PLATFORM,
+      pid: Process.pid
+    }
+  end
+
+  register_tool('get_object_allocations',
+                'Get top memory allocation sites using ObjectSpace tracing') do
+    # Snapshot current allocation statistics
+    stats = ObjectSpace.count_objects
+    {
+      total_objects: stats.values.sum,
+      by_type: stats.sort_by { |_, v| -v }.first(20).map { |k, v| { type: k, count: v } }
+    }
+  end
+end

data/lib/debug_agent/inspectors/system.rb

@@ -0,0 +1,61 @@
+require 'etc'
+
+module DebugAgent
+  register_tool('get_system_info', 'Get system info: hostname, CPU, memory, load') do
+    {
+      hostname: Socket.gethostname,
+      os: RUBY_PLATFORM,
+      cpu_count: Etc.nprocessors,
+      ruby_version: RUBY_VERSION,
+      process_count: `ps aux | wc -l`.strip.to_i
+    }
+  end
+
+  register_tool('get_disk_usage', 'Get disk usage for current directory') do
+    stat = Sys::Filesystem.stat(Dir.pwd) rescue nil
+    if stat
+      {
+        total_gb: (stat.block_size * stat.blocks / 1024**3).round(2),
+        free_gb: (stat.block_size * stat.blocks_available / 1024**3).round(2),
+        used_pct: ((1 - stat.blocks_available.to_f / stat.blocks) * 100).round(1)
+      }
+    else
+      # Fallback: use df
+      output = `df -k .`.split("\n").last.split
+      total = output[1].to_i / 1024 / 1024.0
+      free = output[3].to_i / 1024 / 1024.0
+      {
+        total_gb: total.round(2),
+        free_gb: free.round(2),
+        used_pct: output[4]
+      }
+    end
+  end
+
+  register_tool('get_environment_variables', 'List environment variables (masked secrets)') do |prefix: ''|
+    secret_patterns = %w[KEY SECRET PASSWORD TOKEN CREDENTIAL]
+    result = {}
+    ENV.each do |k, v|
+      next if !prefix.empty? && !k.upcase.start_with?(prefix.upcase)
+
+      if secret_patterns.any? { |s| k.upcase.include?(s) }
+        result[k] = '***masked***'
+      else
+        result[k] = v
+      end
+    end
+    { variables: result, count: result.size }
+  end
+
+  register_tool('get_process_info', 'Get process info: PID, CPU time, user') do
+    rss = `ps -o rss= -p #{Process.pid}`.to_i
+    {
+      pid: Process.pid,
+      ppid: Process.ppid,
+      rss_mb: (rss / 1024.0).round(2),
+      uid: Process.uid,
+      gid: Process.gid,
+      user: Etc.getpwuid(Process.uid).name
+    }
+  end
+end

data/lib/debug_agent/inspectors/threads.rb

@@ -0,0 +1,67 @@
+module DebugAgent
+  register_tool('get_thread_list',
+                'List all threads with status and backtrace summary') do
+    threads = Thread.list
+    {
+      total_threads: threads.size,
+      threads: threads.map do |t|
+        backtrace = begin
+          t.backtrace || []
+        rescue => e
+          ["<unable to get backtrace: #{e.message}>"]
+        end
+
+        {
+          object_id: t.object_id,
+          to_s: t.to_s,
+          status: t.status.nil? ? 'terminated' : t.status.to_s,
+          alive: t.alive?,
+          priority: t.priority,
+          name: (t.name if t.respond_to?(:name)),
+          backtrace_summary: backtrace.first(5),
+          backtrace_length: backtrace.size
+        }
+      end
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_thread_count',
+                'Get current thread count') do
+    threads = Thread.list
+    alive = threads.count(&:alive?)
+    sleeping = threads.count { |t| t.status == 'sleep' }
+    runnable = threads.count { |t| t.status == 'run' }
+
+    {
+      total: threads.size,
+      alive: alive,
+      sleeping: sleeping,
+      runnable: runnable,
+      main_thread: Thread.main.object_id
+    }
+  rescue => e
+    { error: e.message }
+  end
+
+  register_tool('get_main_thread_info',
+                'Get main thread info: priority, status, name') do
+    main = Thread.main
+    backtrace = main.backtrace || []
+
+    {
+      object_id: main.object_id,
+      status: main.status.to_s,
+      alive: main.alive?,
+      priority: main.priority,
+      name: main.respond_to?(:name) ? main.name : nil,
+      backtrace_length: backtrace.size,
+      backtrace_top: backtrace.first(10),
+      thread_group: main.group.to_s,
+      ruby_thread_id: (main.respond_to?(:native_thread_id) ? main.native_thread_id : nil)
+    }
+  rescue => e
+    { error: e.message }
+  end
+end

data/lib/debug_agent/llm_client.rb

@@ -0,0 +1,221 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'timeout'
+
+module DebugAgent
+  # Stream callback interface (engine implements this)
+  class StreamHandler
+    def on_content(chunk); end
+    def on_complete(tool_calls, finish_reason, usage); end
+    def on_error(error); end
+  end
+
+  # Chat callback interface (engine -> UI)
+  class ChatCallback
+    def on_content(chunk); end
+    def on_tool_start(tool_name, args); end
+    def on_tool_result(tool_name, result); end
+    def on_complete; end
+    def on_error(message); end
+    def on_context_compressed(original, compressed, removed_rounds); end
+  end
+
+  class LLMClient
+    def initialize(config)
+      @cfg = config
+    end
+
+    # ==================== Non-Streaming ====================
+
+    def chat(messages, tools = nil)
+      body = {
+        'model' => @cfg.model,
+        'messages' => messages,
+        'temperature' => 0,
+        'max_tokens' => 1024
+      }
+      body['tools'] = tools if tools
+
+      post_with_retry('/chat/completions', body)
+    end
+
+    # ==================== Streaming ====================
+
+    def chat_stream_raw(messages, tools, tool_choice, handler)
+      body = {
+        'model' => @cfg.model,
+        'messages' => messages,
+        'temperature' => @cfg.temperature,
+        'max_tokens' => @cfg.max_tokens,
+        'stream' => true,
+        'stream_options' => { 'include_usage' => true }
+      }
+      body['tools'] = tools if tools && tools.any?
+      body['tool_choice'] = tool_choice if tool_choice
+
+      max_retries = @cfg.max_retries
+      last_error = nil
+
+      (0..max_retries).each do |attempt|
+        begin
+          stream_request('/chat/completions', body, handler)
+          return
+        rescue RetriableError => e
+          last_error = e
+          if attempt < max_retries
+            delay = calculate_delay(attempt)
+            sleep(delay / 1000.0)
+            next
+          end
+          handler.on_error(e)
+          return
+        rescue StandardError => e
+          handler.on_error(e)
+          return
+        end
+      end
+
+      handler.on_error(StandardError.new("Exhausted retries: #{last_error&.message}"))
+    end
+
+    # ==================== Stream Processing ====================
+
+    def stream_request(path, body, handler)
+      uri = URI(@cfg.base_url + path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.read_timeout = @cfg.timeout_seconds
+
+      request = Net::HTTP::Post.new(uri.path)
+      request['Authorization'] = "Bearer #{@cfg.api_key}"
+      request['Content-Type'] = 'application/json'
+      request.body = JSON.generate(body)
+
+      response = http.request(request)
+
+      if response.code.to_i >= 400
+        raise RetriableError.new(response.code.to_i, "HTTP #{response.code}: #{response.body}")
+      end
+
+      tool_call_map = {}
+      finish_reason = nil
+      usage = nil
+
+      response.read_body do |chunk|
+        chunk.split("\n").each do |line|
+          next unless line.start_with?('data: ')
+
+          data_str = line[6..]
+          next if data_str.strip == '[DONE]'
+
+          begin
+            parsed = JSON.parse(data_str)
+          rescue JSON::ParserError
+            next
+          end
+
+          if parsed['usage'] && parsed['usage']['prompt_tokens']
+            usage = parsed['usage']
+          end
+
+          choices = parsed['choices'] || []
+          next if choices.empty?
+
+          choice = choices[0]
+          delta = choice['delta'] || {}
+
+          if delta['content'] && !delta['content'].empty?
+            handler.on_content(delta['content'])
+          end
+
+          if delta['tool_calls']
+            delta['tool_calls'].each do |tc|
+              idx = tc['index'] || 0
+              tool_call_map[idx] ||= { 'id' => '', 'type' => 'function', 'function' => { 'name' => '', 'arguments' => '' } }
+              entry = tool_call_map[idx]
+              entry['id'] = tc['id'] if tc['id']
+              entry['type'] = tc['type'] if tc['type']
+              fn = tc['function'] || {}
+              entry['function']['name'] += fn['name'] if fn['name']
+              entry['function']['arguments'] += fn['arguments'] if fn['arguments']
+            end
+          end
+
+          finish_reason = choice['finish_reason'] if choice['finish_reason']
+        end
+      end
+
+      tool_calls = tool_call_map.keys.sort.map { |k| tool_call_map[k] }.select { |tc| tc['function']['name'] && !tc['function']['name'].empty? }
+
+      handler.on_complete(tool_calls, finish_reason, usage)
+    end
+
+    # ==================== Non-Streaming POST with retry ====================
+
+    def post_with_retry(path, body)
+      max_retries = @cfg.max_retries
+      last_error = nil
+
+      (0..max_retries).each do |attempt|
+        begin
+          return post(path, body)
+        rescue RetriableError => e
+          last_error = e
+          if attempt < max_retries
+            delay = calculate_delay(attempt)
+            sleep(delay / 1000.0)
+            next
+          end
+          raise
+        rescue StandardError => e
+          raise
+        end
+      end
+
+      raise last_error
+    end
+
+    def post(path, body)
+      uri = URI(@cfg.base_url + path)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.read_timeout = @cfg.timeout_seconds
+
+      request = Net::HTTP::Post.new(uri.path)
+      request['Authorization'] = "Bearer #{@cfg.api_key}"
+      request['Content-Type'] = 'application/json'
+      request.body = JSON.generate(body)
+
+      response = http.request(request)
+
+      if response.code.to_i >= 400
+        raise RetriableError.new(response.code.to_i, "HTTP #{response.code}: #{response.body}")
+      end
+
+      JSON.parse(response.body)
+    end
+
+    # ==================== Helpers ====================
+
+    def calculate_delay(attempt)
+      base = @cfg.retry_base_delay_ms * (2 ** attempt)
+      jitter = rand(base / 2 + 1)
+      delay = base + jitter
+      [delay, @cfg.retry_max_delay_ms].min
+    end
+  end
+
+  class RetriableError < StandardError
+    attr_reader :status_code
+
+    def initialize(status_code, message)
+      super(message)
+      @status_code = status_code
+    end
+
+    def retriable?
+      [429, 500, 502, 503, 504].include?(@status_code)
+    end
+  end
+end

data/lib/debug_agent/middleware.rb

@@ -0,0 +1,127 @@
+require 'json'
+require_relative 'chat_page'
+
+module DebugAgent
+  # SSE callback that bridges engine to SSE response lines
+  class SseCallback < ChatCallback
+    def initialize
+      @events = []
+    end
+
+    def events
+      @events
+    end
+
+    def on_content(chunk)
+      @events << ['content', JSON.generate(chunk)]
+    end
+
+    def on_tool_start(tool_name, args)
+      @events << ['tool_start', tool_name]
+    end
+
+    def on_tool_result(tool_name, result)
+      @events << ['tool_result', "#{tool_name}: #{result}"]
+    end
+
+    def on_complete
+      @events << ['done', '']
+    end
+
+    def on_error(message)
+      @events << ['error', message]
+    end
+
+    def on_context_compressed(original, compressed, removed_rounds)
+      info = JSON.generate({ originalTokens: original, compressedTokens: compressed, removedRounds: removed_rounds })
+      @events << ['context_compressed', info]
+    end
+  end
+
+  # Rack-compatible middleware class (use with Sinatra: `use DebugAgent::RackMiddleware`)
+  class RackMiddleware
+    def initialize(app, config = nil)
+      @app = app
+      @config = config || Config.from_env
+      @engine = DebugEngine.new(@config)
+      DebugAgent.app = app
+    end
+
+    def call(env)
+      MiddlewareCore.call(env, @app, @engine, @config)
+    end
+  end
+
+  module Middleware
+    # Create a lambda-based middleware (for non-Sinatra Rack apps)
+    def self.new(app = nil, config = nil)
+      config_obj = config || Config.from_env
+      engine = DebugEngine.new(config_obj)
+      DebugAgent.app = app
+
+      lambda do |env|
+        MiddlewareCore.call(env, app, engine, config_obj)
+      end
+    end
+  end
+
+  # Shared routing logic used by both RackMiddleware class and Middleware lambda
+  module MiddlewareCore
+    def self.call(env, app, engine, config)
+      path = env['PATH_INFO']
+      method = env['REQUEST_METHOD']
+      base = config.base_path
+
+      # Chat UI
+      if path == base || path == "#{base}/"
+        if method == 'GET'
+          html = ChatPage.render(base)
+          return [200, { 'Content-Type' => 'text/html; charset=utf-8' }, [html]]
+        end
+      end
+
+      # SSE streaming chat
+      if path == "#{base}/api/chat" && method == 'POST'
+        body = JSON.parse(env['rack.input'].read)
+        message = body['message'] || ''
+        session_id = body['sessionId'] || "session-#{Time.now.to_i}"
+
+        cb = SseCallback.new
+        engine.chat(message, session_id, cb)
+
+        stream = cb.events.map { |event_type, data| "event: #{event_type}\ndata: #{data}\n\n" }.join
+
+        return [200, {
+          'Content-Type' => 'text/event-stream',
+          'Cache-Control' => 'no-cache',
+          'Connection' => 'keep-alive'
+        }, [stream]]
+      end
+
+      # Clear conversation
+      if path == "#{base}/api/clear" && method == 'POST'
+        body = JSON.parse(env['rack.input'].read)
+        session_id = body['sessionId'] || ''
+        engine.clear_session(session_id) if session_id && !session_id.empty?
+        return [200, { 'Content-Type' => 'application/json' }, [JSON.generate({ status: 'cleared' })]]
+      end
+
+      # Health check
+      if path == "#{base}/api/health" && method == 'GET'
+        return [200, { 'Content-Type' => 'application/json' }, [JSON.generate({ status: 'ok', agent: 'ruby-debug-agent' })]]
+      end
+
+      # List tools
+      if path == "#{base}/api/tools" && method == 'GET'
+        return [200, { 'Content-Type' => 'application/json' }, [JSON.generate({ tools: engine.tools.all_schemas })]]
+      end
+
+      # Pass through to the wrapped app
+      if app
+        app.call(env)
+      else
+        [404, { 'Content-Type' => 'text/plain' }, ['Not Found']]
+      end
+    end
+  end
+end