pocketrb 0.1.0

data/lib/pocketrb/agent/compaction.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Agent
+    # Context compaction to summarize long conversations and save tokens
+    class Compaction
+      # Default thresholds (balanced for context retention)
+      DEFAULT_MESSAGE_THRESHOLD = 40      # Compact when exceeding this many messages
+      DEFAULT_TOKEN_THRESHOLD = 50_000    # Compact when exceeding this many estimated tokens
+      DEFAULT_KEEP_RECENT = 15            # Keep this many recent messages uncompacted
+      CHARS_PER_TOKEN = 4                 # Rough estimate for token counting
+
+      COMPACTION_PROMPT = <<~PROMPT
+        Summarize this conversation history concisely. Include:
+        - Key decisions made
+        - Important information learned
+        - Current task/goal if any
+        - Any pending items or context needed for continuation
+
+        Keep the summary under 500 words. Focus on information the assistant needs to continue effectively.
+      PROMPT
+
+      attr_reader :provider, :model
+      attr_accessor :message_threshold, :token_threshold, :keep_recent
+
+      def initialize(provider:, model: nil, message_threshold: nil, token_threshold: nil, keep_recent: nil)
+        @provider = provider
+        @model = model || provider.default_model
+        @message_threshold = message_threshold || DEFAULT_MESSAGE_THRESHOLD
+        @token_threshold = token_threshold || DEFAULT_TOKEN_THRESHOLD
+        @keep_recent = keep_recent || DEFAULT_KEEP_RECENT
+      end
+
+      # Check if compaction is needed for messages
+      # @param messages [Array<Message>] Conversation messages
+      # @return [Boolean]
+      def needs_compaction?(messages)
+        return false if messages.size <= @keep_recent
+
+        messages.size > @message_threshold || estimate_tokens(messages) > @token_threshold
+      end
+
+      # Compact messages by summarizing older ones
+      # @param messages [Array<Message>] Conversation messages (excluding system)
+      # @return [Array<Message>] Compacted messages
+      def compact(messages)
+        return messages unless needs_compaction?(messages)
+
+        # Split messages: older ones to summarize, recent ones to keep
+        split_point = [messages.size - @keep_recent, 0].max
+        to_summarize = messages[0...split_point]
+        to_keep = messages[split_point..]
+
+        return messages if to_summarize.empty?
+
+        Pocketrb.logger.info("Compacting #{to_summarize.size} messages into summary")
+
+        # Generate summary
+        summary = generate_summary(to_summarize)
+
+        # Build compacted message list
+        compacted = []
+        compacted << build_summary_message(summary)
+        compacted.concat(to_keep)
+
+        compacted
+      end
+
+      # Compact a session's messages in place
+      # @param session [Session::Session] Session to compact
+      # @return [Boolean] Whether compaction occurred
+      def compact_session!(session)
+        messages = session.messages.dup
+        return false unless needs_compaction?(messages)
+
+        # Filter out system messages for compaction
+        user_assistant_messages = messages.reject { |m| m.role == Providers::Role::SYSTEM }
+        return false if user_assistant_messages.size <= @keep_recent
+
+        compacted = compact(user_assistant_messages)
+
+        # Update session
+        session.messages.clear
+        compacted.each { |m| session.messages << m }
+
+        Pocketrb.logger.info("Session compacted: #{messages.size} -> #{compacted.size} messages")
+        true
+      end
+
+      # Estimate token count for messages
+      # @param messages [Array<Message>] Messages to count
+      # @return [Integer] Estimated tokens
+      def estimate_tokens(messages)
+        total_chars = messages.sum do |msg|
+          content = msg.content
+          if content.is_a?(Array)
+            # Content blocks (text + media references)
+            content.sum do |block|
+              if block.is_a?(Hash) && block[:type] == "text"
+                block[:text].to_s.length
+              elsif block.is_a?(String)
+                block.length
+              else
+                50 # Estimate for non-text blocks
+              end
+            end
+          else
+            content.to_s.length
+          end
+        end
+
+        (total_chars / CHARS_PER_TOKEN).to_i
+      end
+
+      private
+
+      def generate_summary(messages)
+        # Format messages for summarization
+        formatted = format_for_summary(messages)
+
+        summary_request = [
+          Providers::Message.system(COMPACTION_PROMPT),
+          Providers::Message.user("Conversation history to summarize:\n\n#{formatted}")
+        ]
+
+        response = @provider.chat(
+          messages: summary_request,
+          model: @model,
+          max_tokens: 1000
+        )
+
+        response.content || "Previous conversation summary unavailable."
+      rescue StandardError => e
+        Pocketrb.logger.error("Compaction summary failed: #{e.message}")
+        # Fallback: create basic summary
+        basic_summary(messages)
+      end
+
+      def format_for_summary(messages)
+        messages.map do |msg|
+          role = msg.role.capitalize
+          content = extract_text_content(msg.content)
+          "#{role}: #{content[0..500]}#{"..." if content.length > 500}"
+        end.join("\n\n")
+      end
+
+      def extract_text_content(content)
+        if content.is_a?(Array)
+          content.filter_map do |block|
+            if block.is_a?(Hash) && block[:type] == "text"
+              block[:text]
+            elsif block.is_a?(String)
+              block
+            end
+          end.join("\n")
+        else
+          content.to_s
+        end
+      end
+
+      def build_summary_message(summary)
+        Providers::Message.user(
+          "[Previous conversation summary]\n#{summary}\n[End of summary - continuing conversation]"
+        )
+      end
+
+      def basic_summary(messages)
+        # Create a very basic summary without LLM
+        user_count = messages.count { |m| m.role == Providers::Role::USER }
+        assistant_count = messages.count { |m| m.role == Providers::Role::ASSISTANT }
+        tool_count = messages.count { |m| m.role == Providers::Role::TOOL }
+
+        parts = ["Previous conversation: #{user_count} user messages, #{assistant_count} assistant responses"]
+        parts << "#{tool_count} tool calls" if tool_count.positive?
+
+        # Extract last few user queries for context
+        recent_queries = messages.select { |m| m.role == Providers::Role::USER }
+                                 .last(3)
+                                 .map { |m| "- #{extract_text_content(m.content)[0..100]}" }
+
+        parts << "Recent topics:\n#{recent_queries.join("\n")}" unless recent_queries.empty?
+
+        parts.join("\n\n")
+      end
+    end
+  end
+end

data/lib/pocketrb/agent/context.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Agent
+    # Builds context for LLM requests
+    class Context
+      TOOL_GUIDELINES = <<~PROMPT
+        ## Tool Usage Guidelines
+
+        You have access to tools for interacting with files, executing commands, and searching the web.
+
+        - Use tools when they would help accomplish the user's request
+        - Be concise and direct in your responses
+        - When executing commands, explain what you're doing
+        - If a task requires multiple steps, plan them out first
+        - Report errors clearly and suggest fixes when possible
+        - Use the memory tool to store important information for future reference
+        - Search memory when the user asks about something you may have learned before
+      PROMPT
+
+      DEFAULT_IDENTITY = <<~PROMPT
+        You are Pocketrb, an AI assistant with access to tools for interacting with files, executing commands, and searching the web.
+      PROMPT
+
+      attr_reader :system_prompt, :workspace, :skills_summary
+
+      def initialize(workspace: nil, system_prompt: nil, skills_summary: nil)
+        @workspace = workspace
+        @skills_summary = skills_summary
+        @system_prompt = system_prompt || build_base_prompt
+      end
+
+      private
+
+      def build_base_prompt
+        parts = []
+
+        # Load identity from file or use default
+        identity = load_workspace_file("IDENTITY.md")
+        parts << (identity || DEFAULT_IDENTITY)
+
+        # Add tool guidelines
+        parts << TOOL_GUIDELINES
+
+        # Load static memory/knowledge if exists
+        memory = load_workspace_file("MEMORY.md")
+        parts << "## Background Knowledge\n\n#{memory}" if memory
+
+        parts.join("\n\n")
+      end
+
+      def load_workspace_file(filename)
+        return nil unless @workspace
+
+        path = @workspace.join(filename)
+        return nil unless path.exist?
+
+        content = File.read(path).strip
+        content.empty? ? nil : content
+      rescue StandardError => e
+        Pocketrb.logger.debug("Failed to load #{filename}: #{e.message}")
+        nil
+      end
+
+      public
+
+      # Build the complete message array for an LLM request
+      # @param history [Array<Message>] Conversation history
+      # @param current [String] Current user message
+      # @param media [Array<Bus::Media>] Media attachments
+      # @param memory_context [String|nil] Memory context from Memory system
+      # @return [Array<Message>]
+      def build_messages(history:, current:, media: nil, memory_context: nil)
+        messages = []
+
+        # Add system message with memory context
+        messages << build_system_message(memory_context)
+
+        # Add conversation history (strip media to prevent context bloat)
+        messages.concat(strip_media_from_history(history))
+
+        # Add current user message with media (only current message gets images)
+        messages << Providers::Message.user(current, media: media)
+
+        messages
+      end
+
+      # Build messages for continuing after tool execution
+      # @param history [Array<Message>] Full history including tool results
+      # @return [Array<Message>]
+      def build_continuation(history:, memory_context: nil)
+        messages = []
+        messages << build_system_message(memory_context)
+        messages.concat(history)
+        messages
+      end
+
+      # Update system prompt
+      def update_system_prompt(prompt)
+        @system_prompt = prompt
+      end
+
+      # Add to system prompt
+      def append_to_system_prompt(content)
+        @system_prompt = "#{@system_prompt}\n\n#{content}"
+      end
+
+      # Update skills summary
+      def update_skills_summary(summary)
+        @skills_summary = summary
+      end
+
+      private
+
+      # Strip media from history messages to prevent context bloat
+      # Only the current message should include images
+      def strip_media_from_history(history)
+        history.map do |msg|
+          content = msg.content
+
+          # If content is an array with media blocks, convert to text-only
+          if content.is_a?(Array)
+            text_parts = content.filter_map do |block|
+              if block.is_a?(Hash)
+                case block[:type]
+                when "text"
+                  block[:text]
+                when "media"
+                  media = block[:media]
+                  filename = media.is_a?(Hash) ? media[:filename] : media&.filename
+                  "[Previous image: #{filename || "attachment"}]"
+                end
+              elsif block.is_a?(String)
+                block
+              end
+            end
+
+            # Create new message with text-only content
+            Providers::Message.new(
+              role: msg.role,
+              content: text_parts.join("\n"),
+              name: msg.name,
+              tool_call_id: msg.tool_call_id,
+              tool_calls: msg.tool_calls
+            )
+          else
+            msg
+          end
+        end
+      end
+
+      def build_system_message(memory_context = nil)
+        parts = [@system_prompt]
+
+        # Add workspace info
+        parts << "Working directory: #{@workspace}" if @workspace
+
+        # Add skills summary
+        parts << "Available skills:\n#{@skills_summary}" if @skills_summary && !@skills_summary.empty?
+
+        # Add memory context if provided
+        parts << "Relevant context from memory:\n#{memory_context}" if memory_context && !memory_context.empty?
+
+        # Add timestamp
+        parts << "Current time: #{Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")}"
+
+        Providers::Message.system(parts.join("\n\n"))
+      end
+    end
+  end
+end

data/lib/pocketrb/agent/loop.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require "async"
+
+module Pocketrb
+  # Agent module provides the core agentic loop and context management
+  module Agent
+    # Core agent processing loop
+    class Loop
+      attr_reader :bus, :provider, :tools, :sessions, :context, :model, :max_iterations, :workspace, :memory_dir,
+                  :memory, :compaction
+
+      def initialize(
+        bus:,
+        provider:,
+        workspace:,
+        memory_dir: nil,
+        model: nil,
+        max_iterations: 50,
+        system_prompt: nil,
+        mcp_endpoint: nil,
+        enable_compaction: true,
+        compaction_threshold: nil
+      )
+        @bus = bus
+        @provider = provider
+        @workspace = Pathname.new(workspace)
+        @memory_dir = Pathname.new(memory_dir || workspace)
+        @model = model || provider.default_model
+        @max_iterations = max_iterations
+
+        @sessions = Session::Manager.new(storage_dir: @memory_dir.join(".pocketrb", "sessions"))
+
+        # Initialize simple memory system
+        @memory = Memory.new(workspace: @memory_dir)
+
+        @context = Context.new(
+          workspace: @memory_dir,
+          system_prompt: system_prompt
+        )
+
+        @tools = Tools::Registry.new(workspace: @workspace, memory_dir: @memory_dir, bus: @bus)
+        @tools.register_defaults!
+
+        # Pass memory instance to tools
+        @tools.update_context(memory: @memory)
+
+        # Load always-on skills into context
+        @skills_loader = Skills::Loader.new(workspace: @memory_dir)
+        load_always_skills!
+
+        # Initialize context compaction
+        @compaction = if enable_compaction
+                        Compaction.new(
+                          provider: @provider,
+                          model: @model,
+                          message_threshold: compaction_threshold
+                        )
+                      end
+
+        @running = false
+      end
+
+      # Start the agent loop (async)
+      def run
+        @running = true
+        Pocketrb.logger.info("Agent loop starting with model: #{@model}")
+
+        Async do
+          while @running
+            begin
+              msg = @bus.consume_inbound
+              response = process_message(msg)
+              @bus.publish_outbound(response) if response
+            rescue StandardError => e
+              Pocketrb.logger.error("Error processing message: #{e.message}")
+              Pocketrb.logger.error(e.backtrace.first(5).join("\n"))
+            end
+          end
+        end
+      end
+
+      # Stop the agent loop
+      def stop
+        @running = false
+        Pocketrb.logger.info("Agent loop stopping")
+      end
+
+      # Process a single message (synchronous, for direct use)
+      # @param msg [Bus::InboundMessage]
+      # @return [Bus::OutboundMessage|nil]
+      def process_message(msg)
+        # Update tools context with current channel info for message/send_file tools
+        @tools.update_context(
+          default_channel: msg.channel,
+          default_chat_id: msg.chat_id
+        )
+
+        session = @sessions.get_or_create(msg.session_key)
+        session.add_user_message(msg.content, media: msg.media)
+
+        publish_state_change(msg.session_key, :idle, :processing)
+
+        # Compact session history if needed (before building messages)
+        if @compaction&.needs_compaction?(session.messages)
+          @compaction.compact_session!(session)
+          @sessions.save(session)
+        end
+
+        # Get relevant memory context for this message
+        memory_context = @memory.relevant_context(msg.content, max_facts: 10)
+
+        # Build initial messages (with media support)
+        messages = @context.build_messages(
+          history: session.get_history(max_messages: 50),
+          current: msg.content,
+          media: msg.media,
+          memory_context: memory_context
+        )
+
+        # Drop the last message since we already added it to history
+        messages = messages[0..-2] + [session.last_message]
+
+        iteration = 0
+        final_response = nil
+
+        while iteration < @max_iterations
+          iteration += 1
+          Pocketrb.logger.debug("Iteration #{iteration}/#{@max_iterations}")
+
+          response = @provider.chat(
+            messages: messages,
+            tools: @tools.definitions,
+            model: @model
+          )
+
+          if response.has_tool_calls?
+            messages = execute_tool_calls(session, messages, response)
+          else
+            final_response = response
+            break
+          end
+        end
+
+        if final_response.nil?
+          Pocketrb.logger.warn("Max iterations reached without completion")
+          final_response = Providers::LLMResponse.new(
+            content: "I apologize, but I've reached the maximum number of iterations. Please try breaking down your request into smaller steps."
+          )
+        end
+
+        # Save assistant response to session
+        session.add_assistant_message(final_response.content, tool_calls: final_response.tool_calls)
+        @sessions.save(session)
+
+        publish_state_change(msg.session_key, :processing, :idle)
+
+        # Build outbound message
+        Bus::OutboundMessage.new(
+          channel: msg.channel,
+          chat_id: msg.chat_id,
+          content: final_response.content || "",
+          reply_to: msg.metadata[:message_id]
+        )
+      end
+
+      # Register an additional tool
+      def register_tool(tool)
+        @tools.register(tool)
+      end
+
+      # Update the system prompt
+      def update_system_prompt(prompt)
+        @context.update_system_prompt(prompt)
+      end
+
+      private
+
+      def execute_tool_calls(session, messages, response)
+        # Add assistant message with tool calls
+        assistant_msg = Providers::Message.assistant(
+          response.content || "",
+          tool_calls: response.tool_calls
+        )
+        messages << assistant_msg
+        session.add_assistant_message(response.content, tool_calls: response.tool_calls)
+
+        # Execute each tool call
+        response.tool_calls.each do |tool_call|
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          begin
+            result = @tools.execute(tool_call.name, tool_call.arguments)
+            duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).to_i
+
+            publish_tool_event(tool_call, result, nil, duration_ms)
+
+            # Add tool result to messages
+            tool_msg = Providers::Message.tool_result(
+              tool_call_id: tool_call.id,
+              name: tool_call.name,
+              content: result
+            )
+            messages << tool_msg
+            session.add_tool_result(
+              tool_call_id: tool_call.id,
+              name: tool_call.name,
+              content: result
+            )
+          rescue ToolError => e
+            duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).to_i
+            error_msg = "Tool error: #{e.message}"
+
+            publish_tool_event(tool_call, nil, e.message, duration_ms)
+
+            tool_msg = Providers::Message.tool_result(
+              tool_call_id: tool_call.id,
+              name: tool_call.name,
+              content: error_msg
+            )
+            messages << tool_msg
+            session.add_tool_result(
+              tool_call_id: tool_call.id,
+              name: tool_call.name,
+              content: error_msg
+            )
+          end
+        end
+
+        @sessions.save(session)
+        messages
+      end
+
+      def publish_tool_event(tool_call, result, error, duration_ms)
+        event = Bus::ToolExecution.new(
+          tool_call_id: tool_call.id,
+          name: tool_call.name,
+          arguments: tool_call.arguments,
+          result: result,
+          error: error,
+          duration_ms: duration_ms
+        )
+        @bus.publish_tool_event(event)
+      end
+
+      def publish_state_change(session_key, from, to, reason = nil)
+        event = Bus::StateChange.new(
+          session_key: session_key,
+          from_state: from,
+          to_state: to,
+          reason: reason
+        )
+        @bus.publish_state_event(event)
+      end
+
+      # Load skills marked as always: true into the system prompt
+      def load_always_skills!
+        always_skills = @skills_loader.get_always_skills
+        return if always_skills.empty?
+
+        skill_content = always_skills.map(&:to_prompt).join("\n\n")
+        @context.append_to_system_prompt(skill_content)
+
+        Pocketrb.logger.debug("Loaded #{always_skills.size} always-on skills: #{always_skills.map(&:name).join(", ")}")
+      end
+
+      # Load skills triggered by a message (for context-aware skill loading)
+      def load_triggered_skills(text)
+        triggered = @skills_loader.get_triggered_skills(text)
+        return "" if triggered.empty?
+
+        triggered.map(&:to_prompt).join("\n\n")
+      end
+    end
+  end
+end

data/lib/pocketrb/agent/spawn_tool.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Agent
+    # Tool for spawning subagents
+    class SpawnTool < Tools::Base
+      def name
+        "spawn"
+      end
+
+      def description
+        "Spawn a subagent to work on a specific task in the background. Useful for delegating independent work or parallel processing."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            task: {
+              type: "string",
+              description: "The task for the subagent to complete"
+            },
+            skills: {
+              type: "array",
+              items: { type: "string" },
+              description: "Skills to load for this subagent"
+            },
+            wait: {
+              type: "boolean",
+              description: "Wait for the subagent to complete before returning (default: false)"
+            },
+            timeout: {
+              type: "integer",
+              description: "Timeout in seconds if waiting (default: 300)"
+            }
+          },
+          required: ["task"]
+        }
+      end
+
+      def available?
+        @context[:subagent_manager] != nil
+      end
+
+      def execute(task:, skills: [], wait: false, timeout: 300)
+        manager = @context[:subagent_manager]
+        return error("Subagent spawning not available") unless manager
+
+        origin_channel = @context[:current_channel] || :cli
+        origin_chat_id = @context[:current_chat_id] || "main"
+
+        agent_id = manager.spawn(
+          task: task,
+          skills: skills,
+          origin_channel: origin_channel,
+          origin_chat_id: origin_chat_id
+        )
+
+        if wait
+          result = manager.wait_for(agent_id, timeout: timeout)
+          if result
+            success("Subagent #{agent_id} completed:\n\n#{result}")
+          else
+            error("Subagent #{agent_id} did not complete within timeout")
+          end
+        else
+          success("Spawned subagent #{agent_id} for task: #{task[0..100]}...\nResults will be announced when complete.")
+        end
+      end
+    end
+  end
+end