swarm_memory 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9cc16f06662bd282f8c296aeb6600f53dd80d14f27afad26b9da6f724916d20a
+  data.tar.gz: 6acf6425bdc544f125826ac5ba1f6b127f9c3d96e7ba067712cd15f165ac5af5
+SHA512:
+  metadata.gz: 91b645763ed45723d82080fb2321ca5e9c0d61310c3f3907843c9086980f5b27e0176315b2ac399f837191c5559b6e36563e2f71bb18adaf2a93a957f186a2e9
+  data.tar.gz: 9b019e85c71c3f7c9f1c1ac5358c53566b5c5934fb1e983087e9c6ebdd81c79b1e32c100d762161bda4aff2227c2be24bfa3d9f0784edc7cbd227a9a21d724af

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Paulo Arruda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/claude_swarm/base_executor.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  class BaseExecutor
+    attr_reader :session_id, :last_response, :working_directory, :logger, :session_path, :session_json_path, :instance_info
+
+    def initialize(working_directory: Dir.pwd, model: nil, mcp_config: nil, vibe: false,
+      instance_name: nil, instance_id: nil, calling_instance: nil, calling_instance_id: nil,
+      claude_session_id: nil, additional_directories: [], debug: false)
+      @working_directory = working_directory
+      @additional_directories = additional_directories
+      @model = model
+      @mcp_config = mcp_config
+      @vibe = vibe
+      @session_id = claude_session_id
+      @last_response = nil
+      @instance_name = instance_name
+      @instance_id = instance_id
+      @calling_instance = calling_instance
+      @calling_instance_id = calling_instance_id
+      @debug = debug
+
+      # Setup static info strings for logging
+      @instance_info = build_info(@instance_name, @instance_id)
+      @caller_info = build_info(@calling_instance, @calling_instance_id)
+      @caller_to_instance = "#{@caller_info} -> #{instance_info}:"
+      @instance_to_caller = "#{instance_info} -> #{@caller_info}:"
+
+      # Setup logging
+      setup_logging
+
+      # Setup static event templates
+      setup_event_templates
+    end
+
+    def execute(_prompt, _options = {})
+      raise NotImplementedError, "Subclasses must implement the execute method"
+    end
+
+    def reset_session
+      @session_id = nil
+      @last_response = nil
+    end
+
+    def has_session?
+      !@session_id.nil?
+    end
+
+    protected
+
+    def build_info(name, id)
+      return name unless id
+
+      "#{name} (#{id})"
+    end
+
+    def setup_logging
+      # Use session path from environment (required)
+      @session_path = SessionPath.from_env
+      SessionPath.ensure_directory(@session_path)
+
+      # Initialize session JSON path
+      @session_json_path = File.join(@session_path, "session.log.json")
+
+      # Create logger with session.log filename
+      log_filename = "session.log"
+      log_path = File.join(@session_path, log_filename)
+      log_level = @debug ? :debug : :info
+      @logger = Logger.new(log_path, level: log_level, progname: @instance_name)
+
+      logger.info { "Started #{self.class.name} for instance: #{instance_info}" }
+    end
+
+    def setup_event_templates
+      @log_request_event_template = {
+        type: "request",
+        from_instance: @calling_instance,
+        from_instance_id: @calling_instance_id,
+        to_instance: @instance_name,
+        to_instance_id: @instance_id,
+      }.freeze
+
+      @session_json_entry_template = {
+        instance: @instance_name,
+        instance_id: @instance_id,
+        calling_instance: @calling_instance,
+        calling_instance_id: @calling_instance_id,
+      }.freeze
+    end
+
+    def log_request(prompt)
+      logger.info { "#{@caller_to_instance} \n---\n#{prompt}\n---" }
+
+      # Merge dynamic data with static template
+      event = @log_request_event_template.merge(
+        prompt: prompt,
+        timestamp: Time.now.iso8601,
+      )
+
+      append_to_session_json(event)
+    end
+
+    def log_response(response)
+      logger.info do
+        "($#{response["total_cost"]} - #{response["duration_ms"]}ms) #{@instance_to_caller} \n---\n#{response["result"]}\n---"
+      end
+    end
+
+    def append_to_session_json(event)
+      # Use file locking to ensure thread-safe writes
+      File.open(@session_json_path, File::WRONLY | File::APPEND | File::CREAT) do |file|
+        file.flock(File::LOCK_EX)
+
+        # Merge dynamic data with static template
+        entry = @session_json_entry_template.merge(
+          timestamp: Time.now.iso8601,
+          event: event,
+        )
+
+        # Write as single line JSON (JSONL format)
+        file.puts(entry.to_json)
+
+        file.flock(File::LOCK_UN)
+      end
+    rescue StandardError => e
+      logger.error { "Failed to append to session JSON: #{e.message}" }
+      raise
+    end
+
+    class ExecutionError < StandardError; end
+    class ParseError < StandardError; end
+  end
+end

data/lib/claude_swarm/claude_code_executor.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  class ClaudeCodeExecutor < BaseExecutor
+    def execute(prompt, options = {})
+      # Log the request
+      log_request(prompt)
+
+      # Build SDK options
+      sdk_options = build_sdk_options(prompt, options)
+
+      # Variables to collect output
+      all_messages = []
+      result_response = nil
+
+      # Execute with streaming
+      begin
+        ClaudeSDK.query(prompt, options: sdk_options) do |message|
+          # Convert message to hash for logging
+          message_hash = message_to_hash(message)
+          all_messages << message_hash
+
+          # Log streaming event BEFORE we modify anything
+          log_streaming_event(message_hash)
+
+          # Process specific message types
+          case message
+          when ClaudeSDK::Messages::System
+            # Capture session_id from system init
+            if message.subtype == "init" && message.data.is_a?(Hash)
+              # For init messages, session_id is in the data hash
+              session_id = message.data[:session_id] || message.data["session_id"]
+
+              if session_id
+                @session_id = session_id
+                write_instance_state
+              end
+            end
+          when ClaudeSDK::Messages::Assistant
+            # Assistant messages only contain content blocks
+            # No need to track for result extraction - result comes from Result message
+          when ClaudeSDK::Messages::Result
+            # Validate that we have actual result content
+            if message.result.nil? || (message.result.is_a?(String) && message.result.strip.empty?)
+              raise ExecutionError, "Claude SDK returned an empty result. The agent completed execution but provided no response content."
+            end
+
+            # Build result response in expected format
+            result_response = {
+              "type" => "result",
+              "subtype" => message.subtype || "success",
+              "cost_usd" => message.total_cost_usd,
+              "is_error" => message.is_error || false,
+              "duration_ms" => message.duration_ms,
+              "result" => message.result, # Result text is directly in message.result
+              "total_cost" => message.total_cost_usd,
+              "session_id" => message.session_id,
+            }
+          end
+        end
+      rescue StandardError => e
+        logger.error { "Execution error for #{@instance_name}: #{e.class} - #{e.message}" }
+        logger.error { "Backtrace: #{e.backtrace.join("\n")}" }
+        raise ExecutionError, "Claude Code execution failed: #{e.message}"
+      end
+
+      # Ensure we got a result
+      raise ParseError, "No result found in SDK response" unless result_response
+
+      # Write session JSON log
+      all_messages.each do |msg|
+        append_to_session_json(msg)
+      end
+
+      result_response
+    rescue StandardError => e
+      logger.error { "Unexpected error for #{@instance_name}: #{e.class} - #{e.message}" }
+      logger.error { "Backtrace: #{e.backtrace.join("\n")}" }
+      raise
+    end
+
+    private
+
+    def write_instance_state
+      return unless @instance_id && @session_id
+
+      state_dir = File.join(@session_path, "state")
+      FileUtils.mkdir_p(state_dir)
+
+      state_file = File.join(state_dir, "#{@instance_id}.json")
+      state_data = {
+        instance_name: @instance_name,
+        instance_id: @instance_id,
+        claude_session_id: @session_id,
+        status: "active",
+        updated_at: Time.now.iso8601,
+      }
+
+      JsonHandler.write_file!(state_file, state_data)
+      logger.info { "Wrote instance state for #{@instance_name} (#{@instance_id}) with session ID: #{@session_id}" }
+    rescue StandardError => e
+      logger.error { "Failed to write instance state for #{@instance_name} (#{@instance_id}): #{e.message}" }
+    end
+
+    def log_streaming_event(event)
+      append_to_session_json(event)
+
+      return log_system_message(event) if event["type"] == "system"
+
+      # Add specific details based on event type
+      case event["type"]
+      when "assistant"
+        log_assistant_message(event["message"])
+      when "user"
+        log_user_message(event["message"]["content"])
+      when "result"
+        log_response(event)
+      end
+    end
+
+    def log_system_message(event)
+      logger.debug { "SYSTEM: #{JsonHandler.pretty_generate!(event)}" }
+    end
+
+    def log_assistant_message(msg)
+      # Assistant messages don't have stop_reason in SDK - they only have content
+      content = msg["content"]
+      logger.debug { "ASSISTANT: #{JsonHandler.pretty_generate!(content)}" } if content
+
+      # Log tool calls
+      tool_calls = content&.select { |c| c["type"] == "tool_use" } || []
+      tool_calls.each do |tool_call|
+        arguments = tool_call["input"].to_json
+        arguments = "#{arguments[0..300]} ...}" if arguments.length > 300
+
+        logger.info do
+          "Tool call from #{instance_info} -> Tool: #{tool_call["name"]}, ID: #{tool_call["id"]}, Arguments: #{arguments}"
+        end
+      end
+
+      # Log thinking text
+      text = content&.select { |c| c["type"] == "text" } || []
+      text.each do |t|
+        logger.info { "#{instance_info} is thinking:\n---\n#{t["text"]}\n---" }
+      end
+    end
+
+    def log_user_message(content)
+      logger.debug { "USER: #{JsonHandler.pretty_generate!(content)}" }
+    end
+
+    def build_sdk_options(prompt, options)
+      # Map CLI options to SDK options
+      sdk_options = ClaudeSDK::ClaudeCodeOptions.new
+
+      # Basic options
+      # Only set model if ANTHROPIC_MODEL env var is not set
+      sdk_options.model = @model if @model && !ENV["ANTHROPIC_MODEL"]
+      sdk_options.cwd = @working_directory
+      sdk_options.resume = @session_id if @session_id && !options[:new_session]
+
+      # Permission mode
+      if @vibe
+        sdk_options.permission_mode = ClaudeSDK::PermissionMode::BYPASS_PERMISSIONS
+      else
+        # Build allowed tools list including MCP connections
+        allowed_tools = options[:allowed_tools] ? Array(options[:allowed_tools]).dup : []
+
+        # Add mcp__instance_name for each connection if we have instance info
+        options[:connections]&.each do |connection_name|
+          allowed_tools << "mcp__#{connection_name}"
+        end
+
+        # Set allowed and disallowed tools
+        sdk_options.allowed_tools = allowed_tools if allowed_tools.any?
+        sdk_options.disallowed_tools = Array(options[:disallowed_tools]) if options[:disallowed_tools]
+      end
+
+      # System prompt
+      sdk_options.append_system_prompt = options[:system_prompt] if options[:system_prompt]
+
+      # MCP configuration
+      if @mcp_config
+        sdk_options.mcp_servers = parse_mcp_config(@mcp_config)
+      end
+
+      # Handle additional directories by adding them to MCP servers
+      if @additional_directories.any?
+        setup_additional_directories_mcp(sdk_options)
+      end
+
+      # Add settings file path if it exists
+      settings_file = File.join(@session_path, "#{@instance_name}_settings.json")
+      sdk_options.settings = settings_file if File.exist?(settings_file)
+
+      sdk_options
+    end
+
+    def parse_mcp_config(config_path)
+      # Parse MCP JSON config file and convert to SDK format
+      config = JsonHandler.parse_file!(config_path)
+      mcp_servers = {}
+
+      config["mcpServers"]&.each do |name, server_config|
+        server_type = server_config["type"] || "stdio"
+
+        mcp_servers[name] = case server_type
+        when "stdio"
+          ClaudeSDK::McpServerConfig::StdioServer.new(
+            command: server_config["command"],
+            args: server_config["args"] || [],
+            env: server_config["env"] || {},
+          )
+        when "sse"
+          ClaudeSDK::McpServerConfig::SSEServer.new(
+            url: server_config["url"],
+            headers: server_config["headers"] || {},
+          )
+        when "http"
+          ClaudeSDK::McpServerConfig::HttpServer.new(
+            url: server_config["url"],
+            headers: server_config["headers"] || {},
+          )
+        else
+          logger.warn { "Unsupported MCP server type: #{server_type} for server: #{name}" }
+          nil
+        end
+      end
+
+      mcp_servers.compact
+    rescue StandardError => e
+      logger.error { "Failed to parse MCP config: #{e.message}" }
+      {}
+    end
+
+    def setup_additional_directories_mcp(sdk_options)
+      # Workaround for --add-dir: add file system MCP servers for additional directories
+      sdk_options.mcp_servers ||= {}
+
+      @additional_directories.each do |dir|
+        # This is a placeholder - the SDK doesn't directly support file system servers
+        # You would need to implement a proper MCP server that provides file access
+        logger.warn { "Additional directories not fully supported: #{dir}" }
+      end
+    end
+
+    def message_to_hash(message)
+      # Convert SDK message objects to hash format matching CLI JSON output
+      case message
+      when ClaudeSDK::Messages::System
+        # System messages have subtype and data attributes
+        # The data hash contains the actual information from the CLI
+        hash = {
+          "type" => "system",
+          "subtype" => message.subtype,
+        }
+
+        # Include the data hash if it exists - this is where CLI puts info like session_id, tools, etc.
+        if message.data.is_a?(Hash)
+          # For "init" subtype, extract session_id and tools from data
+          if message.subtype == "init"
+            hash["session_id"] = message.data[:session_id] || message.data["session_id"]
+            hash["tools"] = message.data[:tools] || message.data["tools"]
+          end
+          # You can add other relevant data fields as needed
+        end
+
+        hash.compact
+      when ClaudeSDK::Messages::Assistant
+        # Assistant messages only have content attribute
+        {
+          "type" => "assistant",
+          "message" => {
+            "type" => "message",
+            "role" => "assistant",
+            "content" => content_blocks_to_hash(message.content),
+          },
+          "session_id" => @session_id,
+        }
+      when ClaudeSDK::Messages::User
+        # User messages only have content attribute (a string)
+        {
+          "type" => "user",
+          "message" => {
+            "type" => "message",
+            "role" => "user",
+            "content" => message.content,
+          },
+          "session_id" => @session_id,
+        }
+      when ClaudeSDK::Messages::Result
+        # Result messages have multiple attributes
+        {
+          "type" => "result",
+          "subtype" => message.subtype || "success",
+          "cost_usd" => message.total_cost_usd,
+          "is_error" => message.is_error || false,
+          "duration_ms" => message.duration_ms,
+          "duration_api_ms" => message.duration_api_ms,
+          "num_turns" => message.num_turns,
+          "result" => message.result, # Result text is in message.result, not from content
+          "total_cost" => message.total_cost_usd,
+          "total_cost_usd" => message.total_cost_usd,
+          "session_id" => message.session_id,
+          "usage" => message.usage,
+        }.compact
+      else
+        # Fallback for unknown message types
+        begin
+          message.to_h
+        rescue
+          { "type" => "unknown", "data" => message.to_s }
+        end
+      end
+    end
+
+    def content_blocks_to_hash(content)
+      return [] unless content
+
+      content.map do |block|
+        case block
+        when ClaudeSDK::ContentBlock::Text
+          { "type" => "text", "text" => block.text }
+        when ClaudeSDK::ContentBlock::ToolUse
+          {
+            "type" => "tool_use",
+            "id" => block.id,
+            "name" => block.name,
+            "input" => block.input,
+          }
+        when ClaudeSDK::ContentBlock::ToolResult
+          {
+            "type" => "tool_result",
+            "tool_use_id" => block.tool_use_id,
+            "content" => block.content,
+            "is_error" => block.is_error,
+          }
+        else
+          # Fallback
+          begin
+            block.to_h
+          rescue
+            { "type" => "unknown", "data" => block.to_s }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/claude_swarm/claude_mcp_server.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  class ClaudeMcpServer
+    # Class variables to share state with tool classes
+    class << self
+      attr_accessor :executor, :instance_config, :logger, :session_path, :calling_instance, :calling_instance_id
+    end
+
+    def initialize(instance_config, calling_instance:, calling_instance_id: nil, debug: false)
+      @instance_config = instance_config
+      @calling_instance = calling_instance
+      @calling_instance_id = calling_instance_id
+
+      # Create appropriate executor based on provider
+      common_params = {
+        working_directory: instance_config[:directory],
+        model: instance_config[:model],
+        mcp_config: instance_config[:mcp_config_path],
+        vibe: instance_config[:vibe],
+        instance_name: instance_config[:name],
+        instance_id: instance_config[:instance_id],
+        calling_instance: calling_instance,
+        calling_instance_id: calling_instance_id,
+        claude_session_id: instance_config[:claude_session_id],
+        additional_directories: instance_config[:directories][1..] || [],
+        debug: debug,
+      }
+
+      @executor = if instance_config[:provider] == "openai"
+        OpenAI::Executor.new(
+          **common_params,
+          # OpenAI-specific parameters
+          temperature: instance_config[:temperature],
+          api_version: instance_config[:api_version],
+          openai_token_env: instance_config[:openai_token_env],
+          base_url: instance_config[:base_url],
+          reasoning_effort: instance_config[:reasoning_effort],
+        )
+      else
+        # Default Claude behavior - always use SDK
+        ClaudeCodeExecutor.new(**common_params)
+      end
+
+      # Set class variables so tools can access them
+      self.class.executor = @executor
+      self.class.instance_config = @instance_config
+      self.class.logger = @executor.logger
+      self.class.session_path = @executor.session_path
+      self.class.calling_instance = @calling_instance
+      self.class.calling_instance_id = @calling_instance_id
+    end
+
+    def start
+      server = FastMcp::Server.new(
+        name: @instance_config[:name],
+        version: "1.0.0",
+      )
+
+      # Set dynamic description for TaskTool based on instance config
+      thinking_info = " Thinking budget levels: \"think\" < \"think hard\" < \"think harder\" < \"ultrathink\"."
+      if @instance_config[:description]
+        Tools::TaskTool.description("Execute a task using Agent #{@instance_config[:name]}. #{@instance_config[:description]} #{thinking_info}")
+      else
+        Tools::TaskTool.description("Execute a task using Agent #{@instance_config[:name]}. #{thinking_info}")
+      end
+
+      # Register tool classes (not instances)
+      server.register_tool(Tools::TaskTool)
+      server.register_tool(Tools::SessionInfoTool)
+      server.register_tool(Tools::ResetSessionTool)
+
+      # Start the stdio server
+      server.start
+    end
+  end
+end