claude_swarm 0.3.2 → 1.0.0

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
@@ -230,6 +233,7 @@ module ClaudeSwarm
           instance_config,
           calling_instance: options[:calling_instance],
           calling_instance_id: options[:calling_instance_id],
+          debug: options[:debug],
         )
         server.start
       rescue StandardError => e
@@ -330,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
 
@@ -402,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
@@ -433,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
@@ -507,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)
@@ -558,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
@@ -588,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|
@@ -600,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
@@ -629,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|
@@ -692,7 +694,12 @@ module ClaudeSwarm
     def build_generation_prompt(readme_content, output_file)
       template_path = File.expand_path("templates/generation_prompt.md.erb", __dir__)
       template = File.read(template_path)
-      ERB.new(template, trim_mode: "-").result(binding)
+      <<~PROMPT
+        #{ERB.new(template, trim_mode: "-").result(binding)}
+
+        Start the conversation by greeting the user and asking: 'What kind of project would you like to create a Claude Swarm for?'
+        Say: 'I am ready to start'
+      PROMPT
     end
   end
 end

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
@@ -34,6 +33,9 @@ module ClaudeSwarm
           return
         end
 
+        # Check if any session is missing main instance costs
+        any_missing_main = sessions.any? { |s| !s[:main_has_cost] }
+
         # Column widths
         col_session = 15
         col_swarm = 25
@@ -50,13 +52,23 @@ module ClaudeSwarm
         }  #{
           "UPTIME".ljust(col_uptime)
         }  DIRECTORY"
-        puts "\n⚠️  \e[3mTotal cost does not include the cost of the main instance\e[0m\n\n"
+
+        # Only show warning if any session is missing main instance costs
+        if any_missing_main
+          puts "\n⚠️  \e[3mTotal cost does not include the cost of the main instance for some sessions\e[0m\n\n"
+        else
+          puts
+        end
+
         puts header
         puts "-" * header.length
 
         # Display sessions sorted by start time (newest first)
         sessions.sort_by { |s| s[:start_time] }.reverse.each do |session|
           cost_str = format("$%.4f", session[:cost])
+          # Add asterisk if this session is missing main instance cost
+          cost_str += "*" unless session[:main_has_cost]
+
           puts "#{
             session[:id].ljust(col_session)
           }  #{
@@ -107,7 +119,12 @@ module ClaudeSwarm
 
         # Calculate total cost from JSON log
         log_file = File.join(session_dir, "session.log.json")
-        total_cost = SessionCostCalculator.calculate_simple_total(log_file)
+        cost_result = SessionCostCalculator.calculate_total_cost(log_file)
+        total_cost = cost_result[:total_cost]
+
+        # Check if main instance has cost data
+        instances_with_cost = cost_result[:instances_with_cost]
+        main_has_cost = main_instance && instances_with_cost.include?(main_instance)
 
         # Get uptime from session metadata or fallback to directory creation time
         start_time = get_start_time(session_dir)
@@ -117,6 +134,7 @@ module ClaudeSwarm
           id: session_id,
           name: swarm_name,
           cost: total_cost,
+          main_has_cost: main_has_cost,
           uptime: uptime,
           directory: directories_str,
           start_time: start_time,
@@ -128,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
@@ -160,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
@@ -200,6 +215,7 @@ module ClaudeSwarm
         vibe: config["vibe"],
         worktree: parse_worktree_value(config["worktree"]),
         provider: provider, # nil means Claude (default)
+        hooks: config["hooks"], # Pass hooks configuration as-is
       }
 
       # Add OpenAI-specific fields only when provider is "openai"
@@ -232,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"]}'"
@@ -272,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/hooks/session_start_hook.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This hook is called when Claude Code starts a session
+# It saves the transcript path for the main instance so the orchestrator can tail it
+
+require "json"
+require "fileutils"
+
+# Read input from stdin
+begin
+  stdin_data = $stdin.read
+  input = JSON.parse(stdin_data)
+rescue => e
+  # Return error response
+  puts JSON.generate({
+    "success" => false,
+    "error" => "Failed to read/parse input: #{e.message}",
+  })
+  exit(1)
+end
+
+# Get session path from command-line argument or environment
+session_path = ARGV[0] || ENV["CLAUDE_SWARM_SESSION_PATH"]
+
+if session_path && input["transcript_path"]
+  # Write the transcript path to a known location
+  path_file = File.join(session_path, "main_instance_transcript.path")
+  File.write(path_file, input["transcript_path"])
+
+  # Return success
+  puts JSON.generate({
+    "success" => true,
+  })
+else
+  # Return error if missing required data
+  puts JSON.generate({
+    "success" => false,
+    "error" => "Missing session path or transcript path",
+  })
+  exit(1)
+end

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,11 +86,13 @@ 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"]
+        end
       end
     end
 
@@ -218,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

@@ -5,11 +5,11 @@ module ClaudeSwarm
     class ChatCompletion
       MAX_TURNS_WITH_TOOLS = 100_000 # virtually infinite
 
-      def initialize(openai_client:, mcp_client:, available_tools:, logger:, instance_name:, model:, temperature: nil, reasoning_effort: nil)
+      def initialize(openai_client:, mcp_client:, available_tools:, executor:, instance_name:, model:, temperature: nil, reasoning_effort: nil)
         @openai_client = openai_client
         @mcp_client = mcp_client
         @available_tools = available_tools
-        @executor = logger # This is actually the executor, not a logger
+        @executor = executor
         @instance_name = instance_name
         @model = model
         @temperature = temperature
@@ -57,7 +57,7 @@ module ClaudeSwarm
       def process_chat_completion(messages, depth = 0)
         # Prevent infinite recursion
         if depth > MAX_TURNS_WITH_TOOLS
-          @executor.error("Maximum recursion depth reached in tool execution")
+          @executor.logger.error { "Maximum recursion depth reached in tool execution" }
           return "Error: Maximum tool call depth exceeded"
         end
 
@@ -83,7 +83,7 @@ module ClaudeSwarm
         parameters[:tools] = @mcp_client.to_openai_tools if @available_tools&.any? && @mcp_client
 
         # Log the request parameters
-        @executor.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({
@@ -97,16 +97,16 @@ module ClaudeSwarm
         begin
           response = @openai_client.chat(parameters: parameters)
         rescue StandardError => e
-          @executor.error("Chat API error: #{e.class} - #{e.message}")
-          @executor.error("Request parameters: #{JSON.pretty_generate(parameters)}")
+          @executor.logger.error { "Chat API error: #{e.class} - #{e.message}" }
+          @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)
             begin
               error_body = e.response[:body]
-              @executor.error("Error response body: #{error_body}")
+              @executor.logger.error { "Error response body: #{error_body}" }
             rescue StandardError => parse_error
-              @executor.error("Could not parse error response: #{parse_error.message}")
+              @executor.logger.error { "Could not parse error response: #{parse_error.message}" }
             end
           end
 
@@ -127,7 +127,7 @@ module ClaudeSwarm
         end
 
         # Log the response
-        @executor.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({
@@ -141,7 +141,7 @@ module ClaudeSwarm
         message = response.dig("choices", 0, "message")
 
         if message.nil?
-          @executor.error("No message in response: #{response.inspect}")
+          @executor.logger.error { "No message in response: #{response.inspect}" }
           return "Error: No response from OpenAI"
         end
 
@@ -169,7 +169,7 @@ module ClaudeSwarm
 
       def execute_and_append_tool_results(tool_calls, messages)
         # Log tool calls
-        @executor.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,16 +186,16 @@ 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.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)
 
               # Log result
-              @executor.info("Tool result for #{tool_name}: #{result}")
+              @executor.logger.info { "Tool result for #{tool_name}: #{result}" }
 
               # Append to session JSON
               append_to_session_json({
@@ -214,8 +214,8 @@ module ClaudeSwarm
                 content: result.to_s,
               }
             rescue StandardError => e
-              @executor.error("Tool execution failed for #{tool_name}: #{e.message}")
-              @executor.error(e.backtrace.join("\n"))
+              @executor.logger.error { "Tool execution failed for #{tool_name}: #{e.message}" }
+              @executor.logger.error { e.backtrace.join("\n") }
 
               # Append error to session JSON
               append_to_session_json({