claude_swarm 0.3.10 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a44d1b33e538b1efaeca7eb223f09bd617fcb4ba2288d7844773ae5908a10248
-  data.tar.gz: 28312f81eada550b05bbf568807be51c5077366c08d168b928a35a4d356148da
+  metadata.gz: be01b40a18b703189532df1e653c15e406c0b798b220c20fe1f014a35331e213
+  data.tar.gz: a4eddd8c10cb1974e9693c27cb9d6660117bd781a4ed16ef52dc1408b4c414d2
 SHA512:
-  metadata.gz: 2d8ba31f8a64f91060b980ee90bea57c736e4541410eeb36c4c78bdc602f7c3335ea82a388c0b61847a04c90210fb432c2d525df4f4bfa85cbe3725a0034b260
-  data.tar.gz: 15180a4a4df3f9ccc55da9dd40769435c1ba650a575b476c10d7c0b16d650bb1f65524b8d44a10d731e9aed3dcda886b0bb63fd2b64e5665c5ba1cc22633182b
+  metadata.gz: c8207b22b7d3514e910d9f4c72ba7c99e5f5b2f5034e532fa8708ae5d9e9219047153d54ac148c688114cc3f9bd167a4e7a16ceed9439512fe9f1c60c77f8d63
+  data.tar.gz: 53cfc85b8898b8906372e5518913de7c373e98ca2a7de1202f343f1d93f9efc566ed21acee1529f8bc9945e3e60f0cde335040dd49a9d582f723ea739c790c4e

data/CHANGELOG.md

@@ -1,3 +1,66 @@
+## [Unreleased]
+
+## [1.0.0]
+
+### Added
+- **HTTP MCP server configuration support**: Added support for HTTP-type MCP servers alongside existing stdio and SSE types
+  - HTTP servers can be configured with a `url` field
+  - Properly preserves server type (http/sse) in generated configurations
+  - Full compatibility with Claude Code's HTTP MCP server implementation
+
+### Changed
+- **Updated dependency from fast-mcp-annotations to fast-mcp gem**: Migrated to the consolidated fast-mcp gem (~> 1.6)
+  - Consolidates MCP functionality into a single, more maintainable gem
+  - Maintains all existing functionality with improved performance
+- **Updated claude-code-sdk-ruby dependency**: Minimum version requirement increased to 0.1.6
+  - Includes latest SDK improvements and bug fixes
+  - Better error handling and stability
+- **Swarm generation improvements**: Generator now avoids creating swarms with circular dependencies
+  - Prevents generation of invalid configurations
+  - Improves reliability of generated swarm templates
+
+### Fixed
+- **Empty response validation**: Added validation to prevent empty or nil responses from being passed to MCP callers
+  - ClaudeCodeExecutor now validates that Claude SDK returns non-empty result content
+  - TaskTool validates response structure and content before returning to MCP caller
+  - Clear error messages indicate when agent completes execution but provides no response
+  - Prevents silent failures when Claude SDK returns empty results
+- **Before commands directory handling**: Fixed error when before commands need to create the main instance directory
+  - Smart directory detection: if the main instance directory exists, commands run inside it (for `npm install`, etc.)
+  - If the directory doesn't exist, commands run in the parent directory (allowing `mkdir` commands to create it)
+  - Works correctly with both regular directories and Git worktrees
+  - After commands follow the same logic for consistency
+  - Fixes "No such file or directory @ dir_chdir" errors when before commands create directories
+
+### Internal
+- **Centralized JSON handling**: Added JsonHandler class for consistent JSON parsing and generation
+  - Improved error handling for malformed JSON files
+  - Standardized JSON output formatting across all modules
+- **Centralized CLAUDE_SWARM_HOME handling**: Refactored environment variable management for cleaner code
+- **Enhanced test coverage**: Added comprehensive configuration tests and enabled branch coverage in SimpleCov
+  - Extensive validation of edge cases including circular dependencies
+  - Better coverage metrics with branch coverage enabled
+
+## [0.3.11]
+
+### Added
+- **Deferred directory validation for before commands**: Directories are now validated after `before` commands run, allowing them to create required directories
+  - Automatically skips initial directory validation when `before` commands are present in configuration
+  - Validates all directories after `before` commands complete successfully
+  - Enables dynamic directory creation workflows without pre-creating directory structures
+
+### Fixed
+- **--root-dir parameter path resolution**: Fixed relative config file paths to be resolved relative to the --root-dir value instead of current directory
+  - Config paths are now expanded using the root directory as the base path
+  - Allows running claude-swarm from any location with consistent path resolution
+  - Absolute paths continue to work as expected regardless of --root-dir setting
+
+### Improved
+- **Enhanced worktree cleanup on errors**: Improved error handling to ensure worktrees are always cleaned up properly
+  - Added comprehensive error handling with cleanup at all failure points
+  - Worktrees are now cleaned up when worktree setup fails, before commands fail, or directory validation fails
+  - Prevents orphaned worktrees that could clutter the system or cause issues with future runs
+
 ## [0.3.10]
 
 ### Added

data/CLAUDE.md

@@ -6,6 +6,8 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 Claude Swarm is a Ruby gem that orchestrates multiple Claude Code instances as a collaborative AI development team. It enables running AI agents with specialized roles, tools, and directory contexts, communicating via MCP (Model Context Protocol).
 
+SwarmCore is a complete reimagining of Claude Swarm that decouples from Claude Code and runs everything in a single process using RubyLLM for all LLM interactions. It is being developed in `lib/swarm_core`, and using the gemspec swarm-core.gemspec.
+
 ## Development Commands
 
 ### Testing

data/README.md

@@ -228,6 +228,53 @@ swarm:
     # Instance definitions...
 ```
 
+#### YAML Aliases
+
+Claude Swarm supports [YAML aliases](https://yaml.org/spec/1.2.2/#71-alias-nodes) to reduce duplication in your configuration. This is particularly useful for sharing common values like prompts, tool lists, or MCP configurations across multiple instances:
+
+```yaml
+version: 1
+swarm:
+  name: "Development Team"
+  main: lead
+  instances:
+    lead:
+      description: "Lead developer"
+      prompt: &shared_prompt "You are an expert developer following best practices"
+      allowed_tools: &standard_tools
+        - Read
+        - Edit
+        - Bash
+        - WebSearch
+      mcps: &common_mcps
+        - name: github
+          type: stdio
+          command: gh
+          args: ["mcp"]
+          
+    frontend:
+      description: "Frontend developer"
+      prompt: *shared_prompt  # Reuses the same prompt
+      allowed_tools: *standard_tools  # Reuses the same tool list
+      mcps: *common_mcps  # Reuses the same MCP servers
+      directory: ./frontend
+      
+    backend:
+      description: "Backend developer"
+      prompt: *shared_prompt  # Reuses the same prompt
+      allowed_tools: *standard_tools  # Reuses the same tool list
+      mcps: *common_mcps  # Reuses the same MCP servers
+      directory: ./backend
+```
+
+In this example:
+- `&shared_prompt` defines an anchor for the prompt string
+- `&standard_tools` defines an anchor for the tool array
+- `&common_mcps` defines an anchor for the MCP configuration
+- `*shared_prompt`, `*standard_tools`, and `*common_mcps` reference those anchors
+
+This helps maintain consistency across instances and makes configuration updates easier.
+
 #### Environment Variable Interpolation
 
 Claude Swarm supports environment variable interpolation in all configuration values using the `${ENV_VAR_NAME}` syntax:
@@ -395,6 +442,17 @@ mcps:
       X-Custom-Header: "value"
 ```
 
+#### http (HTTP-based MCP)
+```yaml
+mcps:
+  - name: http_service
+    type: http
+    url: "https://api.example.com/mcp-endpoint"
+    headers:  # Optional: custom headers for authentication
+      Authorization: "Bearer ${API_TOKEN}"
+      X-API-Key: "${API_KEY}"
+```
+
 ### Hooks Configuration
 
 Claude Swarm supports configuring [Claude Code hooks](https://docs.anthropic.com/en/docs/claude-code/hooks) for each instance. Hooks allow you to run custom scripts before/after tools, on prompt submission, and more. Each instance can have its own hooks configuration.

data/lib/claude_swarm/claude_code_executor.rb

@@ -40,6 +40,11 @@ module ClaudeSwarm
             # 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",
@@ -91,7 +96,7 @@ module ClaudeSwarm
         updated_at: Time.now.iso8601,
       }
 
-      File.write(state_file, JSON.pretty_generate(state_data))
+      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}" }
@@ -114,13 +119,13 @@ 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)
       # Assistant messages don't have stop_reason in SDK - they only have content
       content = msg["content"]
-      logger.debug { "ASSISTANT: #{JSON.pretty_generate(content)}" } if content
+      logger.debug { "ASSISTANT: #{JsonHandler.pretty_generate!(content)}" } if content
 
       # Log tool calls
       tool_calls = content&.select { |c| c["type"] == "tool_use" } || []
@@ -141,7 +146,7 @@ module ClaudeSwarm
     end
 
     def log_user_message(content)
-      logger.debug { "USER: #{JSON.pretty_generate(content)}" }
+      logger.debug { "USER: #{JsonHandler.pretty_generate!(content)}" }
     end
 
     def build_sdk_options(prompt, options)
@@ -193,7 +198,7 @@ module ClaudeSwarm
 
     def parse_mcp_config(config_path)
       # Parse MCP JSON config file and convert to SDK format
-      config = JSON.parse(File.read(config_path))
+      config = JsonHandler.parse_file!(config_path)
       mcp_servers = {}
 
       config["mcpServers"]&.each do |name, server_config|

data/lib/claude_swarm/cli.rb

@@ -42,16 +42,19 @@ module ClaudeSwarm
       type: :string,
       desc: "Root directory for resolving relative paths (defaults to current directory)"
     def start(config_file = nil)
+      # Set root directory early so it's available to all components
+      root_dir = options[:root_dir] || Dir.pwd
+      ENV["CLAUDE_SWARM_ROOT_DIR"] = File.expand_path(root_dir)
+
+      # Resolve config path relative to root directory
       config_path = config_file || "claude-swarm.yml"
+      config_path = File.expand_path(config_path, root_dir)
+
       unless File.exist?(config_path)
         error("Configuration file not found: #{config_path}")
         exit(1)
       end
 
-      # Set root directory early so it's available to all components
-      root_dir = options[:root_dir] || Dir.pwd
-      ENV["CLAUDE_SWARM_ROOT_DIR"] = File.expand_path(root_dir)
-
       say("Starting Claude Swarm from #{config_path}...") unless options[:prompt]
 
       # Validate stream_logs option
@@ -331,7 +334,7 @@ module ClaudeSwarm
         system!("command -v claude > /dev/null 2>&1")
       rescue Error
         error("Claude CLI is not installed or not in PATH")
-        say("To install Claude CLI, visit: https://docs.anthropic.com/en/docs/claude-code")
+        error("To install Claude CLI, visit: https://docs.anthropic.com/en/docs/claude-code")
         exit(1)
       end
 
@@ -403,12 +406,12 @@ module ClaudeSwarm
       desc: "Number of lines to show initially"
     def watch(session_id)
       # Find session path
-      run_symlink = File.join(File.expand_path("~/.claude-swarm/run"), session_id)
+      run_symlink = ClaudeSwarm.joined_run_dir(session_id)
       session_path = if File.symlink?(run_symlink)
         File.readlink(run_symlink)
       else
         # Search in sessions directory
-        Dir.glob(File.expand_path("~/.claude-swarm/sessions/*/*")).find do |path|
+        Dir.glob(ClaudeSwarm.joined_sessions_dir("*", "*")).find do |path|
           File.basename(path) == session_id
         end
       end
@@ -434,7 +437,7 @@ module ClaudeSwarm
       default: 10,
       desc: "Maximum number of sessions to display"
     def list_sessions
-      sessions_dir = File.expand_path("~/.claude-swarm/sessions")
+      sessions_dir = ClaudeSwarm.joined_sessions_dir
       unless Dir.exist?(sessions_dir)
         say("No sessions found", :yellow)
         return
@@ -508,7 +511,7 @@ module ClaudeSwarm
     private
 
     def error(message)
-      say(message, :red)
+      $stderr.puts(Thor::Shell::Color.new.set_color(message, :red))
     end
 
     def restore_session(session_id)
@@ -559,12 +562,10 @@ module ClaudeSwarm
         # Load session metadata if it exists to check for worktree info
         session_metadata_file = File.join(session_path, "session_metadata.json")
         worktree_name = nil
-        if File.exist?(session_metadata_file)
-          metadata = JSON.parse(File.read(session_metadata_file))
-          if metadata["worktree"] && metadata["worktree"]["enabled"]
-            worktree_name = metadata["worktree"]["name"]
-            say("Restoring with worktree: #{worktree_name}", :green) unless options[:prompt]
-          end
+        metadata = JsonHandler.parse_file(session_metadata_file)
+        if metadata && metadata["worktree"] && metadata["worktree"]["enabled"]
+          worktree_name = metadata["worktree"]["name"]
+          say("Restoring with worktree: #{worktree_name}", :green) unless options[:prompt]
         end
 
         # Create orchestrator with restoration mode
@@ -589,7 +590,7 @@ module ClaudeSwarm
     end
 
     def find_session_path(session_id)
-      sessions_dir = File.expand_path("~/.claude-swarm/sessions")
+      sessions_dir = ClaudeSwarm.joined_sessions_dir
 
       # Search for the session ID in all projects
       Dir.glob("#{sessions_dir}/*/#{session_id}").each do |path|
@@ -601,7 +602,7 @@ module ClaudeSwarm
     end
 
     def clean_stale_symlinks(days)
-      run_dir = File.expand_path("~/.claude-swarm/run")
+      run_dir = ClaudeSwarm.joined_run_dir
       return 0 unless Dir.exist?(run_dir)
 
       cleaned = 0
@@ -630,10 +631,10 @@ module ClaudeSwarm
     end
 
     def clean_orphaned_worktrees(days)
-      worktrees_dir = File.expand_path("~/.claude-swarm/worktrees")
+      worktrees_dir = ClaudeSwarm.joined_worktrees_dir
       return 0 unless Dir.exist?(worktrees_dir)
 
-      sessions_dir = File.expand_path("~/.claude-swarm/sessions")
+      sessions_dir = ClaudeSwarm.joined_sessions_dir
       cleaned = 0
 
       Dir.glob("#{worktrees_dir}/*").each do |session_worktree_dir|

data/lib/claude_swarm/commands/ps.rb

@@ -3,10 +3,9 @@
 module ClaudeSwarm
   module Commands
     class Ps
-      RUN_DIR = File.expand_path("~/.claude-swarm/run")
-
       def execute
-        unless Dir.exist?(RUN_DIR)
+        run_dir = ClaudeSwarm.joined_run_dir
+        unless Dir.exist?(run_dir)
           puts "No active sessions"
           return
         end
@@ -14,7 +13,7 @@ module ClaudeSwarm
         sessions = []
 
         # Read all symlinks in run directory
-        Dir.glob("#{RUN_DIR}/*").each do |symlink|
+        Dir.glob("#{run_dir}/*").each do |symlink|
           next unless File.symlink?(symlink)
 
           begin
@@ -147,9 +146,10 @@ module ClaudeSwarm
       def get_start_time(session_dir)
         # Try to get from session metadata first
         metadata_file = File.join(session_dir, "session_metadata.json")
-        if File.exist?(metadata_file)
-          metadata = JSON.parse(File.read(metadata_file))
-          return Time.parse(metadata["start_time"]) if metadata["start_time"]
+        metadata = JsonHandler.parse_file(metadata_file)
+
+        if metadata && metadata["start_time"]
+          return Time.parse(metadata["start_time"])
         end
 
         # Fallback to directory creation time
@@ -179,7 +179,7 @@ module ClaudeSwarm
         session_metadata_file = File.join(session_dir, "session_metadata.json")
         return directories unless File.exist?(session_metadata_file)
 
-        metadata = JSON.parse(File.read(session_metadata_file))
+        metadata = JsonHandler.parse_file!(session_metadata_file)
         worktree_info = metadata["worktree"]
         return directories unless worktree_info && worktree_info["enabled"]
 

data/lib/claude_swarm/commands/show.rb

@@ -63,23 +63,22 @@ module ClaudeSwarm
 
       def find_session_path(session_id)
         # First check the run directory
-        run_symlink = File.join(File.expand_path("~/.claude-swarm/run"), session_id)
+        run_symlink = ClaudeSwarm.joined_run_dir(session_id)
         if File.symlink?(run_symlink)
           target = File.readlink(run_symlink)
           return target if Dir.exist?(target)
         end
 
         # Fall back to searching all sessions
-        Dir.glob(File.expand_path("~/.claude-swarm/sessions/*/*")).find do |path|
+        Dir.glob(ClaudeSwarm.joined_sessions_dir("*", "*")).find do |path|
           File.basename(path) == session_id
         end
       end
 
       def get_runtime_info(session_path)
         metadata_file = File.join(session_path, "session_metadata.json")
-        return unless File.exist?(metadata_file)
-
-        metadata = JSON.parse(File.read(metadata_file))
+        metadata = JsonHandler.parse_file(metadata_file)
+        return unless metadata
 
         if metadata["duration_seconds"]
           # Session has completed

data/lib/claude_swarm/configuration.rb

@@ -43,15 +43,30 @@ module ClaudeSwarm
       @swarm["after"] || []
     end
 
+    def validate_directories
+      @instances.each do |name, instance|
+        # Validate all directories in the directories array
+        instance[:directories].each do |directory|
+          raise Error, "Directory '#{directory}' for instance '#{name}' does not exist" unless File.directory?(directory)
+        end
+      end
+    end
+
     private
 
+    def has_before_commands?
+      @swarm && @swarm["before"] && !@swarm["before"].empty?
+    end
+
     def load_and_validate
-      @config = YAML.load_file(@config_path)
+      @config = YAML.load_file(@config_path, aliases: true)
       interpolate_env_vars!(@config)
       validate_version
       validate_swarm
       parse_swarm
-      validate_directories
+      # Skip directory validation if before commands are present
+      # They might create the directories
+      validate_directories unless has_before_commands?
     rescue Errno::ENOENT
       raise Error, "Configuration file not found: #{@config_path}"
     rescue Psych::SyntaxError => e
@@ -233,7 +248,7 @@ module ClaudeSwarm
       case mcp["type"]
       when "stdio"
         raise Error, "MCP '#{mcp["name"]}' missing 'command'" unless mcp["command"]
-      when "sse"
+      when "sse", "http"
         raise Error, "MCP '#{mcp["name"]}' missing 'url'" unless mcp["url"]
       else
         raise Error, "Unknown MCP type '#{mcp["type"]}' for '#{mcp["name"]}'"
@@ -273,15 +288,6 @@ module ClaudeSwarm
       visited.add(instance_name)
     end
 
-    def validate_directories
-      @instances.each do |name, instance|
-        # Validate all directories in the directories array
-        instance[:directories].each do |directory|
-          raise Error, "Directory '#{directory}' for instance '#{name}' does not exist" unless File.directory?(directory)
-        end
-      end
-    end
-
     def validate_tool_field(instance_name, config, field_name)
       return unless config.key?(field_name)
 

data/lib/claude_swarm/json_handler.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  # Centralized JSON handling for the Claude Swarm codebase
+  class JsonHandler
+    class << self
+      # Parse JSON string into Ruby object
+      # @param json_string [String] The JSON string to parse
+      # @param raise_on_error [Boolean] Whether to raise exception on error (default: false)
+      # @return [Object] The parsed Ruby object, or original string if parsing fails and raise_on_error is false
+      # @raise [JSON::ParserError] If the JSON is invalid and raise_on_error is true
+      def parse(json_string, raise_on_error: false)
+        JSON.parse(json_string)
+      rescue JSON::ParserError => e
+        raise e if raise_on_error
+
+        json_string
+      end
+
+      # Parse JSON string with exception raising
+      # @param json_string [String] The JSON string to parse
+      # @return [Object] The parsed Ruby object
+      # @raise [JSON::ParserError] If the JSON is invalid
+      def parse!(json_string)
+        parse(json_string, raise_on_error: true)
+      end
+
+      # Parse JSON from a file with exception raising
+      # @param file_path [String] Path to the JSON file
+      # @return [Object] The parsed Ruby object
+      # @raise [Errno::ENOENT] If the file does not exist
+      # @raise [JSON::ParserError] If the file contains invalid JSON
+      def parse_file!(file_path)
+        content = File.read(file_path)
+        parse!(content)
+      end
+
+      # Parse JSON from a file, returning nil on error
+      # @param file_path [String] Path to the JSON file
+      # @return [Object, nil] The parsed Ruby object or nil if file doesn't exist or contains invalid JSON
+      def parse_file(file_path)
+        parse_file!(file_path)
+      rescue Errno::ENOENT, JSON::ParserError
+        nil
+      end
+
+      # Generate pretty-formatted JSON string
+      # @param object [Object] The Ruby object to convert to JSON
+      # @param raise_on_error [Boolean] Whether to raise exception on error (default: false)
+      # @return [String, nil] The pretty-formatted JSON string, or nil if generation fails and raise_on_error is false
+      # @raise [JSON::GeneratorError] If the object cannot be converted to JSON and raise_on_error is true
+      def pretty_generate(object, raise_on_error: false)
+        JSON.pretty_generate(object)
+      rescue JSON::GeneratorError, JSON::NestingError => e
+        raise e if raise_on_error
+
+        nil
+      end
+
+      # Generate pretty-formatted JSON string with exception raising
+      # @param object [Object] The Ruby object to convert to JSON
+      # @return [String] The pretty-formatted JSON string
+      # @raise [JSON::GeneratorError] If the object cannot be converted to JSON
+      def pretty_generate!(object)
+        pretty_generate(object, raise_on_error: true)
+      end
+
+      # Write Ruby object to a JSON file with pretty formatting
+      # @param file_path [String] Path to the JSON file
+      # @param object [Object] The Ruby object to write
+      # @return [Boolean] True if successful, false if generation or write fails
+      def write_file(file_path, object)
+        json_string = pretty_generate!(object)
+        File.write(file_path, json_string)
+        true
+      rescue JSON::GeneratorError, JSON::NestingError, SystemCallError
+        false
+      end
+
+      # Write Ruby object to a JSON file with exception raising
+      # @param file_path [String] Path to the JSON file
+      # @param object [Object] The Ruby object to write
+      # @raise [JSON::GeneratorError] If the object cannot be converted to JSON
+      # @raise [SystemCallError] If the file cannot be written
+      def write_file!(file_path, object)
+        json_string = pretty_generate!(object)
+        File.write(file_path, json_string)
+      end
+    end
+  end
+end

data/lib/claude_swarm/mcp_generator.rb

@@ -73,7 +73,7 @@ module ClaudeSwarm
         "mcpServers" => mcp_servers,
       }
 
-      File.write(mcp_config_path(name), JSON.pretty_generate(config))
+      JsonHandler.write_file!(mcp_config_path(name), config)
     end
 
     def build_mcp_server_config(mcp)
@@ -86,9 +86,9 @@ module ClaudeSwarm
         }.tap do |config|
           config["env"] = mcp["env"] if mcp["env"]
         end
-      when "sse"
+      when "sse", "http"
         {
-          "type" => "sse",
+          "type" => mcp["type"],
           "url" => mcp["url"],
         }.tap do |config|
           config["headers"] = mcp["headers"] if mcp["headers"]
@@ -220,7 +220,7 @@ module ClaudeSwarm
       return unless Dir.exist?(state_dir)
 
       Dir.glob(File.join(state_dir, "*.json")).each do |state_file|
-        data = JSON.parse(File.read(state_file))
+        data = JsonHandler.parse_file!(state_file)
         instance_name = data["instance_name"]
         instance_id = data["instance_id"]
 

data/lib/claude_swarm/openai/chat_completion.rb

@@ -83,7 +83,7 @@ module ClaudeSwarm
         parameters[:tools] = @mcp_client.to_openai_tools if @available_tools&.any? && @mcp_client
 
         # Log the request parameters
-        @executor.logger.info { "Chat API Request (depth=#{depth}): #{JSON.pretty_generate(parameters)}" }
+        @executor.logger.info { "Chat API Request (depth=#{depth}): #{JsonHandler.pretty_generate!(parameters)}" }
 
         # Append to session JSON
         append_to_session_json({
@@ -98,7 +98,7 @@ module ClaudeSwarm
           response = @openai_client.chat(parameters: parameters)
         rescue StandardError => e
           @executor.logger.error { "Chat API error: #{e.class} - #{e.message}" }
-          @executor.logger.error { "Request parameters: #{JSON.pretty_generate(parameters)}" }
+          @executor.logger.error { "Request parameters: #{JsonHandler.pretty_generate!(parameters)}" }
 
           # Try to extract and log the response body for better debugging
           if e.respond_to?(:response)
@@ -127,7 +127,7 @@ module ClaudeSwarm
         end
 
         # Log the response
-        @executor.logger.info { "Chat API Response (depth=#{depth}): #{JSON.pretty_generate(response)}" }
+        @executor.logger.info { "Chat API Response (depth=#{depth}): #{JsonHandler.pretty_generate!(response)}" }
 
         # Append to session JSON
         append_to_session_json({
@@ -169,7 +169,7 @@ module ClaudeSwarm
 
       def execute_and_append_tool_results(tool_calls, messages)
         # Log tool calls
-        @executor.logger.info { "Executing tool calls: #{JSON.pretty_generate(tool_calls)}" }
+        @executor.logger.info { "Executing tool calls: #{JsonHandler.pretty_generate!(tool_calls)}" }
 
         # Append to session JSON
         append_to_session_json({
@@ -186,10 +186,10 @@ module ClaudeSwarm
 
             begin
               # Parse arguments
-              tool_args = tool_args_str.is_a?(String) ? JSON.parse(tool_args_str) : tool_args_str
+              tool_args = tool_args_str.is_a?(String) ? JsonHandler.parse!(tool_args_str) : tool_args_str
 
               # Log tool execution
-              @executor.logger.info { "Executing tool: #{tool_name} with args: #{JSON.pretty_generate(tool_args)}" }
+              @executor.logger.info { "Executing tool: #{tool_name} with args: #{JsonHandler.pretty_generate!(tool_args)}" }
 
               # Execute tool via MCP
               result = @mcp_client.call_tool(tool_name, tool_args)

data/lib/claude_swarm/openai/executor.rb

@@ -122,7 +122,7 @@ module ClaudeSwarm
         return unless @mcp_config && File.exist?(@mcp_config)
 
         # Read MCP config to find MCP servers
-        mcp_data = JSON.parse(File.read(@mcp_config))
+        mcp_data = JsonHandler.parse_file!(@mcp_config)
 
         # Build MCP configurations from servers
         mcp_configs = build_mcp_configs(mcp_data["mcpServers"])