claude_swarm 0.3.2 → 1.0.0

data/lib/claude_swarm/claude_code_executor.rb

@@ -1,102 +1,84 @@
 # frozen_string_literal: true
 
 module ClaudeSwarm
-  class ClaudeCodeExecutor
-    attr_reader :session_id, :last_response, :working_directory, :logger, :session_path
-
-    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: [])
-      @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
-
-      # Setup logging
-      setup_logging
-    end
-
+  class ClaudeCodeExecutor < BaseExecutor
     def execute(prompt, options = {})
       # Log the request
       log_request(prompt)
 
-      cmd_array = build_command_array(prompt, options)
+      # Build SDK options
+      sdk_options = build_sdk_options(prompt, options)
 
       # Variables to collect output
-      stderr_output = []
+      all_messages = []
       result_response = nil
 
-      # Execute command with unbundled environment to avoid bundler conflicts
-      # This ensures claude runs in a clean environment without inheriting
-      # Claude Swarm's BUNDLE_* environment variables
-      Bundler.with_unbundled_env do
-        # Execute command with streaming
-        Open3.popen3(*cmd_array, chdir: @working_directory) do |stdin, stdout, stderr, wait_thread|
-          stdin.close
-
-          # Read stderr in a separate thread
-          stderr_thread = Thread.new do
-            stderr.each_line { |line| stderr_output << line }
-          end
+      # 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
 
-          # Process stdout line by line
-          stdout.each_line do |line|
-            json_data = JSON.parse(line.strip)
-
-            # Log each JSON event
-            log_streaming_event(json_data)
+          # 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 json_data["type"] == "system" && json_data["subtype"] == "init"
-              @session_id = json_data["session_id"]
-              write_instance_state
+            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
 
-            # Capture the final result
-            result_response = json_data if json_data["type"] == "result"
-          rescue JSON::ParserError => e
-            @logger.warn("Failed to parse JSON line: #{line.strip} - #{e.message}")
-          end
-
-          # Wait for stderr thread to finish
-          stderr_thread.join
-
-          # Check exit status
-          exit_status = wait_thread.value
-          unless exit_status.success?
-            error_msg = stderr_output.join
-            @logger.error("Execution error for #{@instance_name}: #{error_msg}")
-            raise ExecutionError, "Claude Code execution failed: #{error_msg}"
+            # 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 stream output" unless result_response
+      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")}")
+      logger.error { "Unexpected error for #{@instance_name}: #{e.class} - #{e.message}" }
+      logger.error { "Backtrace: #{e.backtrace.join("\n")}" }
       raise
     end
 
-    def reset_session
-      @session_id = nil
-      @last_response = nil
-    end
-
-    def has_session?
-      !@session_id.nil?
-    end
-
     private
 
     def write_instance_state
@@ -114,64 +96,10 @@ module ClaudeSwarm
         updated_at: Time.now.iso8601,
       }
 
-      File.write(state_file, JSON.pretty_generate(state_data))
-      @logger.info("Wrote instance state for #{@instance_name} (#{@instance_id}) with session ID: #{@session_id}")
+      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 setup_logging
-      # Use session path from environment (required)
-      @session_path = SessionPath.from_env
-      SessionPath.ensure_directory(@session_path)
-
-      # Create logger with session.log filename
-      log_filename = "session.log"
-      log_path = File.join(@session_path, log_filename)
-      @logger = Logger.new(log_path)
-      @logger.level = Logger::INFO
-
-      # Custom formatter for better readability
-      @logger.formatter = proc do |severity, datetime, _progname, msg|
-        "[#{datetime.strftime("%Y-%m-%d %H:%M:%S.%L")}] [#{severity}] #{msg}\n"
-      end
-
-      return unless @instance_name
-
-      instance_info = @instance_name
-      instance_info += " (#{@instance_id})" if @instance_id
-      @logger.info("Started Claude Code executor for instance: #{instance_info}")
-    end
-
-    def log_request(prompt)
-      caller_info = @calling_instance
-      caller_info += " (#{@calling_instance_id})" if @calling_instance_id
-      instance_info = @instance_name
-      instance_info += " (#{@instance_id})" if @instance_id
-      @logger.info("#{caller_info} -> #{instance_info}: \n---\n#{prompt}\n---")
-
-      # Build event hash for JSON logging
-      event = {
-        type: "request",
-        from_instance: @calling_instance,
-        from_instance_id: @calling_instance_id,
-        to_instance: @instance_name,
-        to_instance_id: @instance_id,
-        prompt: prompt,
-        timestamp: Time.now.iso8601,
-      }
-
-      append_to_session_json(event)
-    end
-
-    def log_response(response)
-      caller_info = @calling_instance
-      caller_info += " (#{@calling_instance_id})" if @calling_instance_id
-      instance_info = @instance_name
-      instance_info += " (#{@instance_id})" if @instance_id
-      @logger.info(
-        "($#{response["total_cost"]} - #{response["duration_ms"]}ms) #{instance_info} -> #{caller_info}: \n---\n#{response["result"]}\n---",
-      )
+      logger.error { "Failed to write instance state for #{@instance_name} (#{@instance_id}): #{e.message}" }
     end
 
     def log_streaming_event(event)
@@ -191,124 +119,231 @@ module ClaudeSwarm
     end
 
     def log_system_message(event)
-      @logger.debug("SYSTEM: #{JSON.pretty_generate(event)}")
+      logger.debug { "SYSTEM: #{JsonHandler.pretty_generate!(event)}" }
     end
 
     def log_assistant_message(msg)
-      return if msg["stop_reason"] == "end_turn" # that means it is not a thought but the final answer
-
+      # Assistant messages don't have stop_reason in SDK - they only have content
       content = msg["content"]
-      @logger.debug("ASSISTANT: #{JSON.pretty_generate(content)}")
-      tool_calls = content.select { |c| c["type"] == "tool_use" }
+      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
 
-        instance_info = @instance_name
-        instance_info += " (#{@instance_id})" if @instance_id
-        @logger.info(
-          "Tool call from #{instance_info} -> Tool: #{tool_call["name"]}, ID: #{tool_call["id"]}, Arguments: #{arguments}",
-        )
+        logger.info do
+          "Tool call from #{instance_info} -> Tool: #{tool_call["name"]}, ID: #{tool_call["id"]}, Arguments: #{arguments}"
+        end
       end
 
-      text = content.select { |c| c["type"] == "text" }
+      # Log thinking text
+      text = content&.select { |c| c["type"] == "text" } || []
       text.each do |t|
-        instance_info = @instance_name
-        instance_info += " (#{@instance_id})" if @instance_id
-        @logger.info("#{instance_info} is thinking:\n---\n#{t["text"]}\n---")
+        logger.info { "#{instance_info} is thinking:\n---\n#{t["text"]}\n---" }
       end
     end
 
     def log_user_message(content)
-      @logger.debug("USER: #{JSON.pretty_generate(content)}")
+      logger.debug { "USER: #{JsonHandler.pretty_generate!(content)}" }
     end
 
-    def append_to_session_json(event)
-      json_filename = "session.log.json"
-      json_path = File.join(@session_path, json_filename)
-
-      # Use file locking to ensure thread-safe writes
-      File.open(json_path, File::WRONLY | File::APPEND | File::CREAT) do |file|
-        file.flock(File::LOCK_EX)
-
-        # Create entry with metadata
-        entry = {
-          instance: @instance_name,
-          instance_id: @instance_id,
-          calling_instance: @calling_instance,
-          calling_instance_id: @calling_instance_id,
-          timestamp: Time.now.iso8601,
-          event: event,
-        }
+    def build_sdk_options(prompt, options)
+      # Map CLI options to SDK options
+      sdk_options = ClaudeSDK::ClaudeCodeOptions.new
 
-        # Write as single line JSON (JSONL format)
-        file.puts(entry.to_json)
+      # 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]
 
-        file.flock(File::LOCK_UN)
-      end
-    rescue StandardError => e
-      @logger.error("Failed to append to session JSON: #{e.message}")
-      raise
-    end
+      # 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 : []
 
-    def build_command_array(prompt, options)
-      cmd_array = ["claude"]
+        # Add mcp__instance_name for each connection if we have instance info
+        options[:connections]&.each do |connection_name|
+          allowed_tools << "mcp__#{connection_name}"
+        end
 
-      # Add model if specified
-      cmd_array += ["--model", @model]
+        # 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
 
-      cmd_array << "--verbose"
+      # System prompt
+      sdk_options.append_system_prompt = options[:system_prompt] if options[:system_prompt]
 
-      # Add additional directories with --add-dir
-      cmd_array << "--add-dir" if @additional_directories.any?
-      @additional_directories.each do |additional_dir|
-        cmd_array << additional_dir
+      # MCP configuration
+      if @mcp_config
+        sdk_options.mcp_servers = parse_mcp_config(@mcp_config)
       end
 
-      # Add MCP config if specified
-      cmd_array += ["--mcp-config", @mcp_config] if @mcp_config
+      # Handle additional directories by adding them to MCP servers
+      if @additional_directories.any?
+        setup_additional_directories_mcp(sdk_options)
+      end
 
-      # Resume session if we have a session ID
-      cmd_array += ["--resume", @session_id] if @session_id && !options[:new_session]
+      # 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)
 
-      # Always use JSON output format for structured responses
-      cmd_array += ["--output-format", "stream-json"]
+      sdk_options
+    end
 
-      # Add non-interactive mode with prompt
-      cmd_array += ["--print", "-p", prompt]
+    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
 
-      # Add any custom system prompt
-      cmd_array += ["--append-system-prompt", options[:system_prompt]] if options[:system_prompt]
+      mcp_servers.compact
+    rescue StandardError => e
+      logger.error { "Failed to parse MCP config: #{e.message}" }
+      {}
+    end
 
-      # Add any allowed tools or vibe flag
-      if @vibe
-        cmd_array << "--dangerously-skip-permissions"
-      else
-        # Build allowed tools list including MCP connections
-        allowed_tools = options[:allowed_tools] ? Array(options[:allowed_tools]).dup : []
+    def setup_additional_directories_mcp(sdk_options)
+      # Workaround for --add-dir: add file system MCP servers for additional directories
+      sdk_options.mcp_servers ||= {}
 
-        # Add mcp__instance_name for each connection if we have instance info
-        options[:connections]&.each do |connection_name|
-          allowed_tools << "mcp__#{connection_name}"
-        end
+      @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,
+        }
 
-        # Add allowed tools if any
-        if allowed_tools.any?
-          tools_str = allowed_tools.join(",")
-          cmd_array += ["--allowedTools", tools_str]
+        # 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
 
-        # Add disallowed tools if any
-        if options[:disallowed_tools]
-          disallowed_tools = Array(options[:disallowed_tools]).join(",")
-          cmd_array += ["--disallowedTools", disallowed_tools]
+        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
-
-      cmd_array
     end
 
-    class ExecutionError < StandardError; end
-    class ParseError < StandardError; 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

@@ -7,7 +7,7 @@ module ClaudeSwarm
       attr_accessor :executor, :instance_config, :logger, :session_path, :calling_instance, :calling_instance_id
     end
 
-    def initialize(instance_config, calling_instance:, calling_instance_id: nil)
+    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
@@ -24,6 +24,7 @@ module ClaudeSwarm
         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"
@@ -37,7 +38,7 @@ module ClaudeSwarm
           reasoning_effort: instance_config[:reasoning_effort],
         )
       else
-        # Default Claude behavior (existing code)
+        # Default Claude behavior - always use SDK
         ClaudeCodeExecutor.new(**common_params)
       end