ask-agent 0.1.0

data/lib/ask/agent/meta_agent.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "set"
+require "json"
+
+module Ask
+  module Agent
+    class MetaAgent
+      Result = Data.define(:issue, :file, :line, :confidence, :suggestion, :evidence, :meta_pr, :recommendation_id, :suggested_code)
+
+      def initialize(telemetry: nil, model: nil, **chat_options)
+        @telemetry = telemetry || Telemetry.new
+        @model = model || Ask::Agent.configuration.default_model
+        @chat_options = chat_options
+        @agent_source = nil
+      end
+
+      def analyze(error_threshold: 3, loop_threshold: 2, max_turns_threshold: 2)
+        load_source
+        telemetry_data = @telemetry.read
+        resolved_ids = resolved_recommendation_ids
+        recommendations = @telemetry.read_recommendations(status: "open")
+
+        unless has_data?(telemetry_data, error_threshold, loop_threshold, max_turns_threshold)
+          return []
+        end
+
+        results = call_llm_for_analysis(telemetry_data, recommendations, resolved_ids)
+        return [] if results.empty?
+
+        results.each do |r|
+          r[:recommendation_id] = @telemetry.track_recommendation(build_result(r))
+        end
+
+        results.map { |r| build_result(r) }
+      end
+
+      def generate_report(results = nil)
+        results ||= analyze
+        return "No improvement opportunities found." if results.empty?
+
+        lines = []
+        lines << "# Agent Self-Improvement Report"
+        lines << "*Generated: #{Time.now.utc.iso8601}*"
+        lines << ""
+
+        results.each_with_index do |result, i|
+          lines << "## #{i + 1}. #{result.issue}"
+          lines << ""
+          lines << "| | |"
+          lines << "|---|---|"
+          lines << "| **File** | `#{result.file}:#{result.line}` |"
+          lines << "| **Confidence** | #{result.confidence} |"
+          lines << "| **Recommendation ID** | `#{result.recommendation_id}` |"
+          lines << ""
+          if result.suggested_code
+            lines << "### Suggested Code"
+            lines << ""
+            lines << "```ruby"
+            lines << result.suggested_code
+            lines << "```"
+          end
+          lines << "---"
+        end
+
+        lines.join("\n")
+      end
+
+      def track_resolution(recommendation_id)
+        return false unless recommendation_id
+        @telemetry.track_resolution(recommendation_id)
+      end
+
+      def auto_resolve!
+        load_source
+        count = 0
+
+        @telemetry.read_recommendations(status: "open").each do |rec|
+          source = @agent_source[rec["file"]]
+          next unless source && rec["suggested_code"]
+          if source.include?(rec["suggested_code"].strip)
+            @telemetry.track_resolution(rec["recommendation_id"])
+            count += 1
+          end
+        end
+        count
+      end
+
+      private
+
+      def has_data?(telemetry_data, error_threshold, loop_threshold, max_turns_threshold)
+        telemetry_data["tool_error"]&.size.to_i >= error_threshold ||
+          telemetry_data["loop_detected"]&.size.to_i >= loop_threshold ||
+          telemetry_data["max_turns_exceeded"]&.size.to_i >= max_turns_threshold
+      end
+
+      def resolved_recommendation_ids
+        @telemetry.read_recommendations(status: "resolved").map { |r| r["recommendation_id"] }
+      end
+
+      def call_llm_for_analysis(telemetry_data, existing_recommendations, resolved_ids)
+        prompt = build_analysis_prompt(telemetry_data, existing_recommendations, resolved_ids)
+        chat = RubyLLM::Chat.new(model: @model, **@chat_options)
+        response = chat.ask(prompt)
+        parse_llm_response(response.content.to_s)
+      rescue => e
+        warn "[MetaAgent] LLM analysis failed: #{e.class}: #{e.message}"
+        []
+      end
+
+      def build_analysis_prompt(telemetry_data, existing_recommendations, resolved_ids)
+        parts = []
+        parts << "You are analyzing telemetry from the Agent runtime."
+        parts << "Detect patterns in errors and suggest specific code improvements."
+        parts << ""
+
+        tool_errors = telemetry_data["tool_error"] || []
+        loop_events = telemetry_data["loop_detected"] || []
+        max_turn_events = telemetry_data["max_turns_exceeded"] || []
+
+        parts << "=== Telemetry Summary ==="
+        parts << "Tool errors: #{tool_errors.size} total"
+        unless tool_errors.empty?
+          by_error = tool_errors.group_by { |e| [e.dig("details", "tool_name"), e.dig("details", "error_class")] }
+          by_error.each do |(tool_name, error_class), entries|
+            parts << "  - `#{tool_name}` raised `#{error_class}` (#{entries.size}x)"
+          end
+        end
+        parts << "Loop detections: #{loop_events.size} total"
+        parts << "Max turns exceeded: #{max_turn_events.size} total"
+        parts << ""
+        parts << "=== Instructions ==="
+        parts << 'Respond with a JSON array only: [{"issue": "...", "confidence": "high", "file": "...", "line": 0, "suggestion": "...", "suggested_code": ""}]'
+        parts << 'If no issues, respond with []'
+
+        parts.join("\n")
+      end
+
+      def parse_llm_response(text)
+        text = text.strip
+        text = text[/\[.*\]/m] || text
+        JSON.parse(text)
+      rescue JSON::ParserError
+        []
+      end
+
+      def build_result(r)
+        Result.new(
+          issue: r[:issue] || r["issue"],
+          file: r[:file] || r["file"],
+          line: (r[:line] || r["line"]).to_i,
+          confidence: r[:confidence] || r["confidence"],
+          suggestion: r[:suggestion] || r["suggestion"],
+          evidence: r[:evidence] || r["evidence"] || [],
+          meta_pr: r[:meta_pr] || r["meta_pr"],
+          recommendation_id: r[:recommendation_id] || r["recommendation_id"],
+          suggested_code: r[:suggested_code] || r["suggested_code"]
+        )
+      end
+
+      def load_source
+        return @agent_source if @agent_source
+        source = {}
+        Dir[File.expand_path("../**/*.rb", __dir__)].each do |file|
+          rel = file.sub("#{File.expand_path("../..", __dir__)}/", "")
+          source[rel] = File.read(file)
+        end
+        @agent_source = source
+      end
+    end
+  end
+end

data/lib/ask/agent/persistence/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Ask
+  module Agent
+    module Persistence
+      class Base
+        def save(session_id, data)
+          raise NotImplementedError
+        end
+
+        def load(session_id)
+          raise NotImplementedError
+        end
+
+        def delete(session_id)
+          raise NotImplementedError
+        end
+
+        def list
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/ask/agent/persistence/in_memory.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Ask
+  module Agent
+    module Persistence
+      class InMemory < Base
+        def initialize
+          @store = {}
+          @mutex = Mutex.new
+        end
+
+        def save(session_id, data)
+          @mutex.synchronize { @store[session_id] = data }
+        end
+
+        def load(session_id)
+          @mutex.synchronize { @store[session_id] }
+        end
+
+        def delete(session_id)
+          @mutex.synchronize { @store.delete(session_id) }
+        end
+
+        def list
+          @mutex.synchronize { @store.keys }
+        end
+      end
+    end
+  end
+end

data/lib/ask/agent/reflector.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Ask
+  module Agent
+    class Reflector
+      attr_reader :reflection_count
+
+      def initialize(model:, max_reflections: 1)
+        @model = model
+        @max_reflections = max_reflections
+        @reflection_count = 0
+      end
+
+      def reflect?(tool_calls_made)
+        return false if @reflection_count >= @max_reflections
+        tool_calls_made > 0
+      end
+
+      def evaluate(response:, event_emitter:)
+        return { decision: :deliver } unless response
+
+        event_emitter.emit(Events::ReflectionStart.new(reflection_number: @reflection_count + 1))
+
+        result = build_eval_chat.ask(reflection_prompt(response)) do |chunk|
+          if chunk.content.to_s.strip.length > 0
+            event_emitter.emit(Events::ReflectionDelta.new(content: chunk.content))
+          end
+        end
+
+        decision = parse_decision(result.content.to_s)
+
+        event_emitter.emit(Events::ReflectionEnd.new(
+          decision: decision[:decision],
+          feedback: decision[:feedback]
+        ))
+
+        @reflection_count += 1
+        decision
+      end
+
+      def reset!
+        @reflection_count = 0
+      end
+
+      private
+
+      def reflection_prompt(response)
+        <<~PROMPT.strip
+          Evaluate this assistant response. Is it accurate, complete, and helpful?
+          Reply with JSON only — no other text:
+          {"decision": "deliver"} or {"decision": "improve", "feedback": "<what to fix>"}
+
+          Response: #{response}
+        PROMPT
+      end
+
+      def parse_decision(text)
+        parsed = JSON.parse(text)
+        {
+          decision: parsed["decision"] == "improve" ? :improve : :deliver,
+          feedback: parsed["feedback"]
+        }
+      rescue JSON::ParserError
+        { decision: :deliver, feedback: nil }
+      end
+
+      def build_eval_chat
+        model_id = model_id_from(@model)
+        RubyLLM::Chat.new(model: model_id)
+      end
+
+      def model_id_from(model)
+        case model
+        when RubyLLM::Chat then model.model.respond_to?(:id) ? model.model.id : model.model.to_s
+        when String then model
+        else model.to_s
+        end
+      end
+    end
+  end
+end

data/lib/ask/agent/session.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module Ask
+  module Agent
+    class Session
+      attr_reader :id, :chat, :tools, :turn_count, :created_at, :messages
+      attr_reader :tool_calls_made
+
+      def reflection_count
+        @reflector&.reflection_count || 0
+      end
+
+      attr_reader :meta_agent_results
+
+      def initialize(model:, tools: [], max_turns: 25, max_tool_retries: 3,
+                     compactor: nil, hooks: {}, persistence: nil,
+                     id: nil, system_prompt: nil, parallel_tools: true,
+                     reflector: nil, telemetry: true, meta_agent: nil, **chat_options)
+        @id = id || SecureRandom.uuid
+        @max_turns = max_turns
+        @max_tool_retries = max_tool_retries
+        @parallel_tools = parallel_tools
+        @event_handlers = { all: [] }
+        @running = false
+        @deleted = false
+        @abort_requested = false
+        @turn_count = 0
+        @created_at = Time.now
+        @_no_tools_instructed = false
+
+        @telemetry = telemetry.is_a?(Telemetry) ? telemetry : Telemetry.new(enabled: !!telemetry)
+
+        @chat = build_chat(model, system_prompt, tools, **chat_options)
+        @tools = resolve_tools(tools)
+        register_tools_on_chat
+        @loop = Loop.new(max_turns: max_turns)
+        @tool_executor = ToolExecutor.new(max_retries: max_tool_retries, parallel: parallel_tools)
+        @compactor = compactor ? build_compactor(compactor) : nil
+        @hooks = Hooks.new(hooks)
+        @persistence = persistence
+
+        reflector_opts = reflector.is_a?(Hash) ? reflector : {}
+        @reflector = if reflector
+          Reflector.new(
+            model: @chat,
+            max_reflections: reflector_opts[:max_reflections] || 1
+          )
+        end
+
+        @meta_agent_config = meta_agent
+        @meta_agent_results = nil
+
+        @compactor&.chat = @chat
+      end
+
+      def run(message, tools: nil)
+        raise "Session deleted" if @deleted
+        raise "Session already running" if @running
+
+        @running = true
+        @abort_requested = false
+        @turn_count = 0
+        @loop.reset!
+
+        emit(Events::SessionStart.new)
+
+        active_tools = resolve_tools(tools || [])
+        active_tools = @tools if active_tools.empty?
+
+        if active_tools.empty? && !@_no_tools_instructed
+          @chat.add_message(role: :system, content: "You have no tools available. Do not claim you can look up information or use tools of any kind. Just respond based on your existing knowledge.")
+          @_no_tools_instructed = true
+        end
+
+        begin
+          @tool_executor.telemetry = @telemetry
+
+          response = @loop.run_turn(
+            chat: @chat,
+            message: message,
+            tools: active_tools,
+            tool_executor: @tool_executor,
+            compactor: @compactor,
+            hooks: @hooks,
+            event_emitter: self,
+            session_id: @id
+          )
+        rescue MaxTurnsExceeded => e
+          emit(Events::MaxTurnsExceeded.new(max_turns: @max_turns))
+          @telemetry.log(:max_turns_exceeded, session_id: @id, max_turns: @max_turns)
+          response = last_content
+        rescue LoopDetected => e
+          emit(Events::LoopDetected.new(tool_name: e.message, repeated_count: 3))
+          @telemetry.log(:loop_detected, session_id: @id, tool_name: e.message, repeated_count: 3)
+          response = last_content
+        rescue RubyLLM::ContextLengthExceededError
+          if @compactor && !@compactor.overflow_recovered?
+            @compactor.recover_from_overflow
+            retry
+          end
+          response = "I'm sorry, the conversation has grown too long. Please start a new session."
+        rescue StandardError => e
+          emit(Events::Error.new(error: e.message, recoverable: true))
+          raise
+        ensure
+          @running = false
+          persist! if @persistence
+        end
+
+        @tool_calls_made = @tool_executor.total_executions
+
+        if @reflector && @reflector.reflect?(@tool_calls_made) && !@abort_requested
+          eval_result = @reflector.evaluate(response: response, event_emitter: self)
+          @telemetry.log(:reflection_end, session_id: @id, decision: eval_result[:decision], feedback: eval_result[:feedback])
+
+          if eval_result[:decision] == :improve && !@abort_requested
+            @chat.add_message(
+              role: :system,
+              content: "Improve your last response: #{eval_result[:feedback]}"
+            )
+
+            response = @loop.run_turn(
+              chat: @chat,
+              message: "",
+              tools: active_tools,
+              tool_executor: @tool_executor,
+              compactor: @compactor,
+              hooks: @hooks,
+              event_emitter: self,
+              session_id: @id
+            )
+          end
+        end
+
+        if @meta_agent_config
+          @telemetry.increment_session_count!
+          try_auto_meta_agent
+        end
+
+        emit(Events::SessionEnd.new(result: response, turn_count: @turn_count, tool_calls_made: @tool_calls_made))
+        @messages = @chat.messages.dup
+
+        response
+      end
+
+      def on_event(&block)
+        @event_handlers[:all] << block
+        self
+      end
+
+      def on(type, &block)
+        @event_handlers[type] ||= []
+        @event_handlers[type] << block
+        self
+      end
+
+      def emit(event)
+        @event_handlers[:all].each { |h| h.call(event) }
+        handlers = @event_handlers[event.class]
+        handlers&.each { |h| h.call(event) }
+      end
+
+      def running? = @running
+      def deleted? = @deleted
+
+      def save
+        persist! if @persistence
+      end
+
+      def self.load(id, adapter:)
+        data = adapter.load(id)
+        return nil unless data
+
+        session = new(
+          id: data[:id],
+          model: data.dig(:metadata, :model),
+          tools: data.dig(:metadata, :tools)&.map(&:constantize) || [],
+          persistence: adapter
+        )
+
+        data[:messages].each do |msg|
+          session.chat.add_message(
+            role: msg[:role].to_sym,
+            content: msg[:content],
+            tool_call_id: msg[:tool_call_id]
+          )
+        end
+
+        session
+      end
+
+      def delete
+        @deleted = true
+        @persistence&.delete(@id)
+      end
+
+      def abort
+        @abort_requested = true
+      end
+
+      def abort_requested? = @abort_requested
+
+      def reset_messages!
+        @chat.reset_messages!
+        @messages = []
+      end
+
+      private
+
+      def register_tools_on_chat
+        return unless @tools.any?
+
+        def @chat.handle_tool_calls(response, &)
+          @on[:end_message]&.call(response) if @on[:end_message]
+          response
+        end
+      end
+
+      def build_chat(model, system_prompt, tools, **chat_options)
+        if model.respond_to?(:ask)
+          model
+        else
+          chat = RubyLLM::Chat.new(model: model, **chat_options)
+          chat.with_instructions(system_prompt) if system_prompt
+          chat
+        end
+      end
+
+      def resolve_tools(tools)
+        tools.map do |tool|
+          tool.is_a?(Class) ? tool.new : tool
+        end
+      end
+
+      def build_compactor(config)
+        compactor = Compactor.new(
+          threshold: config[:threshold] || 0.8,
+          strategy: config[:strategy] || :proactive
+        )
+        compactor.chat = @chat
+        compactor
+      end
+
+      def persist!
+        @persistence.save(@id, {
+          id: @id,
+          messages: @chat.messages.map { |m|
+            {
+              role: m.role,
+              content: m.content.to_s,
+              tool_call_id: m.tool_call_id,
+              created_at: Time.now.iso8601
+            }
+          },
+          metadata: {
+            model: @chat.model.respond_to?(:id) ? @chat.model.id : @chat.model,
+            tools: @tools.map { |t| t.class.name },
+            max_turns: @max_turns,
+            turn_count: @turn_count,
+            created_at: @created_at.iso8601,
+            updated_at: Time.now.iso8601
+          }
+        })
+      end
+
+      def try_auto_meta_agent
+        return unless @meta_agent_config
+        return unless @meta_agent_config[:auto]
+
+        interval = @meta_agent_config[:interval] || 10
+        count = @telemetry.session_count
+        return unless count >= interval
+
+        agent = MetaAgent.new(
+          telemetry: @telemetry,
+          model: model_id_from(@chat),
+          **@meta_agent_config[:chat_options].to_h
+        )
+
+        results = agent.analyze
+        @meta_agent_results = results
+        emit(Events::MetaAgentAnalysis.new(results: results, count: results.size))
+        @telemetry.reset_session_count!
+      end
+
+      def model_id_from(chat)
+        chat.model.respond_to?(:id) ? chat.model.id : chat.model.to_s
+      end
+
+      def last_content
+        @chat.messages.reverse_each.lazy
+          .select { |m| m.role == :assistant && m.content.to_s.strip.length > 0 }
+          .first&.content.to_s
+      end
+    end
+  end
+end