claude_swarm 0.1.20 → 0.2.1

data/lib/claude_swarm/commands/ps.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "yaml"
-require "json"
-require "time"
-
 module ClaudeSwarm
   module Commands
     class Ps
@@ -80,7 +76,7 @@ module ClaudeSwarm
 
         # Load config for swarm name and main directory
         config_file = File.join(session_dir, "config.yml")
-        return nil unless File.exist?(config_file)
+        return unless File.exist?(config_file)
 
         config = YAML.load_file(config_file)
         swarm_name = config.dig("swarm", "name") || "Unknown"
@@ -94,10 +90,10 @@ module ClaudeSwarm
         # Get all directories - handle both string and array formats
         dir_config = config.dig("swarm", "instances", main_instance, "directory")
         directories = if dir_config.is_a?(Array)
-                        dir_config
-                      else
-                        [dir_config || "."]
-                      end
+          dir_config
+        else
+          [dir_config || "."]
+        end
 
         # Expand paths relative to the base directory
         expanded_directories = directories.map do |dir|
@@ -110,10 +106,11 @@ module ClaudeSwarm
         directories_str = expanded_directories.join(", ")
 
         # Calculate total cost from JSON log
-        total_cost = calculate_total_cost(session_dir)
+        log_file = File.join(session_dir, "session.log.json")
+        total_cost = SessionCostCalculator.calculate_simple_total(log_file)
 
-        # Get uptime from directory creation time
-        start_time = File.stat(session_dir).ctime
+        # Get uptime from session metadata or fallback to directory creation time
+        start_time = get_start_time(session_dir)
         uptime = format_duration(Time.now - start_time)
 
         {
@@ -122,24 +119,25 @@ module ClaudeSwarm
           cost: total_cost,
           uptime: uptime,
           directory: directories_str,
-          start_time: start_time
+          start_time: start_time,
         }
       rescue StandardError
         nil
       end
 
-      def calculate_total_cost(session_dir)
-        log_file = File.join(session_dir, "session.log.json")
-        return 0.0 unless File.exist?(log_file)
-
-        total = 0.0
-        File.foreach(log_file) do |line|
-          data = JSON.parse(line)
-          total += data["event"]["total_cost_usd"] if data.dig("event", "type") == "result" && data.dig("event", "total_cost_usd")
-        rescue JSON::ParserError
-          next
+      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"]
         end
-        total
+
+        # Fallback to directory creation time
+        File.stat(session_dir).ctime
+      rescue StandardError
+        # If anything fails, use directory creation time
+        File.stat(session_dir).ctime
       end
 
       def format_duration(seconds)

data/lib/claude_swarm/commands/show.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "yaml"
-require "json"
-
 module ClaudeSwarm
   module Commands
     class Show
@@ -10,7 +7,7 @@ module ClaudeSwarm
         session_path = find_session_path(session_id)
         unless session_path
           puts "Session not found: #{session_id}"
-          exit 1
+          exit(1)
         end
 
         # Load config to get main instance name
@@ -18,19 +15,26 @@ module ClaudeSwarm
         main_instance_name = config.dig("swarm", "main")
 
         # Parse all events to build instance data
-        instances = parse_instance_hierarchy(session_path, main_instance_name)
+        log_file = File.join(session_path, "session.log.json")
+        instances = SessionCostCalculator.parse_instance_hierarchy(log_file)
 
         # Calculate total cost (excluding main if not available)
         total_cost = instances.values.sum { |i| i[:cost] }
         cost_display = if instances[main_instance_name] && instances[main_instance_name][:has_cost_data]
-                         format("$%.4f", total_cost)
-                       else
-                         "#{format("$%.4f", total_cost)} (excluding main instance)"
-                       end
+          format("$%.4f", total_cost)
+        else
+          "#{format("$%.4f", total_cost)} (excluding main instance)"
+        end
 
         # Display session info
         puts "Session: #{session_id}"
+        puts "Session Path: #{session_path}"
         puts "Swarm: #{config.dig("swarm", "name")}"
+
+        # Display runtime if available
+        runtime_info = get_runtime_info(session_path)
+        puts "Runtime: #{runtime_info}" if runtime_info
+
         puts "Total Cost: #{cost_display}"
 
         # Try to read start directory
@@ -71,58 +75,36 @@ module ClaudeSwarm
         end
       end
 
-      def parse_instance_hierarchy(session_path, _main_instance_name)
-        log_file = File.join(session_path, "session.log.json")
-        instances = {}
-
-        return instances unless File.exist?(log_file)
-
-        File.foreach(log_file) do |line|
-          data = JSON.parse(line)
-          instance_name = data["instance"]
-          instance_id = data["instance_id"]
-          calling_instance = data["calling_instance"]
-
-          # Initialize instance data
-          instances[instance_name] ||= {
-            name: instance_name,
-            id: instance_id,
-            cost: 0.0,
-            calls: 0,
-            called_by: Set.new,
-            calls_to: Set.new,
-            has_cost_data: false
-          }
-
-          # Track relationships
-          if calling_instance && calling_instance != instance_name
-            instances[instance_name][:called_by] << calling_instance
-
-            instances[calling_instance] ||= {
-              name: calling_instance,
-              id: data["calling_instance_id"],
-              cost: 0.0,
-              calls: 0,
-              called_by: Set.new,
-              calls_to: Set.new,
-              has_cost_data: false
-            }
-            instances[calling_instance][:calls_to] << instance_name
-          end
-
-          # Track costs and calls
-          if data.dig("event", "type") == "result"
-            instances[instance_name][:calls] += 1
-            if (cost = data.dig("event", "total_cost_usd"))
-              instances[instance_name][:cost] += cost
-              instances[instance_name][:has_cost_data] = true
-            end
-          end
-        rescue JSON::ParserError
-          next
+      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))
+
+        if metadata["duration_seconds"]
+          # Session has completed
+          format_duration(metadata["duration_seconds"])
+        elsif metadata["start_time"]
+          # Session is still running or was interrupted
+          start_time = Time.parse(metadata["start_time"])
+          duration = (Time.now - start_time).to_i
+          "#{format_duration(duration)} (active)"
         end
+      rescue StandardError
+        nil
+      end
 
-        instances
+      def format_duration(seconds)
+        hours = seconds / 3600
+        minutes = (seconds % 3600) / 60
+        secs = seconds % 60
+
+        parts = []
+        parts << "#{hours}h" if hours.positive?
+        parts << "#{minutes}m" if minutes.positive?
+        parts << "#{secs}s"
+
+        parts.join(" ")
       end
 
       def display_instance_tree(instance, all_instances, level, main_instance_name)
@@ -137,10 +119,10 @@ module ClaudeSwarm
 
         # Display cost - show n/a for main instance without cost data
         cost_display = if instance[:name] == main_instance_name && !instance[:has_cost_data]
-                         "n/a (interactive)"
-                       else
-                         format("$%.4f", instance[:cost])
-                       end
+          "n/a (interactive)"
+        else
+          format("$%.4f", instance[:cost])
+        end
 
         puts "#{indent}   Cost: #{cost_display} | Calls: #{instance[:calls]}"
 

data/lib/claude_swarm/configuration.rb

@@ -1,16 +1,25 @@
 # frozen_string_literal: true
 
-require "yaml"
-require "pathname"
-
 module ClaudeSwarm
   class Configuration
+    # Frozen constants for validation
+    VALID_PROVIDERS = ["claude", "openai"].freeze
+    OPENAI_SPECIFIC_FIELDS = ["temperature", "api_version", "openai_token_env", "base_url", "reasoning_effort"].freeze
+    VALID_API_VERSIONS = ["chat_completion", "responses"].freeze
+    VALID_REASONING_EFFORTS = ["low", "medium", "high"].freeze
+
+    # Regex patterns
+    ENV_VAR_PATTERN = /\$\{([^}]+)\}/
+    ENV_VAR_WITH_DEFAULT_PATTERN = /\$\{([^:}]+)(:=([^}]*))?\}/
+    O_SERIES_MODEL_PATTERN = /^o\d+(\s+(Preview|preview))?(-pro|-mini|-deep-research|-mini-deep-research)?$/
+
     attr_reader :config, :config_path, :swarm, :swarm_name, :main_instance, :instances
 
-    def initialize(config_path, base_dir: nil)
+    def initialize(config_path, base_dir: nil, options: {})
       @config_path = Pathname.new(config_path).expand_path
       @config_dir = @config_path.dirname
       @base_dir = base_dir || @config_dir
+      @options = options
       load_and_validate
     end
 
@@ -30,10 +39,15 @@ module ClaudeSwarm
       @swarm["before"] || []
     end
 
+    def after_commands
+      @swarm["after"] || []
+    end
+
     private
 
     def load_and_validate
       @config = YAML.load_file(@config_path)
+      interpolate_env_vars!(@config)
       validate_version
       validate_swarm
       parse_swarm
@@ -44,6 +58,35 @@ module ClaudeSwarm
       raise Error, "Invalid YAML syntax: #{e.message}"
     end
 
+    def interpolate_env_vars!(obj)
+      case obj
+      when String
+        interpolate_env_string(obj)
+      when Hash
+        obj.transform_values! { |v| interpolate_env_vars!(v) }
+      when Array
+        obj.map! { |v| interpolate_env_vars!(v) }
+      else
+        obj
+      end
+    end
+
+    def interpolate_env_string(str)
+      str.gsub(ENV_VAR_WITH_DEFAULT_PATTERN) do |_match|
+        env_var = Regexp.last_match(1)
+        has_default = Regexp.last_match(2)
+        default_value = Regexp.last_match(3)
+
+        if ENV.key?(env_var)
+          ENV[env_var]
+        elsif has_default
+          default_value || ""
+        else
+          raise Error, "Environment variable '#{env_var}' is not set"
+        end
+      end
+    end
+
     def validate_version
       version = @config["version"]
       raise Error, "Missing 'version' field in configuration" unless version
@@ -72,8 +115,11 @@ module ClaudeSwarm
       @swarm["instances"].each do |name, config|
         @instances[name] = parse_instance(name, config)
       end
+      validate_main_instance_provider
       validate_connections
       detect_circular_dependencies
+      validate_openai_env_vars
+      validate_openai_responses_api_compatibility
     end
 
     def parse_instance(name, config)
@@ -82,6 +128,52 @@ module ClaudeSwarm
       # Validate required fields
       raise Error, "Instance '#{name}' missing required 'description' field" unless config["description"]
 
+      # Parse provider (optional, defaults to claude)
+      provider = config["provider"]
+      model = config["model"]
+
+      # Validate provider value if specified
+      if provider && !VALID_PROVIDERS.include?(provider)
+        raise Error, "Instance '#{name}' has invalid provider '#{provider}'. Must be 'claude' or 'openai'"
+      end
+
+      # Validate reasoning_effort for OpenAI provider
+      if config["reasoning_effort"]
+        # Ensure it's only used with OpenAI provider
+        if provider != "openai"
+          raise Error, "Instance '#{name}' has reasoning_effort but provider is not 'openai'"
+        end
+
+        # Validate the value
+        unless VALID_REASONING_EFFORTS.include?(config["reasoning_effort"])
+          raise Error, "Instance '#{name}' has invalid reasoning_effort '#{config["reasoning_effort"]}'. Must be 'low', 'medium', or 'high'"
+        end
+
+        # Validate it's only used with o-series models
+        # Support patterns like: o1, o1-mini, o1-pro, o1 Preview, o3-deep-research, o4-mini-deep-research, etc.
+        unless model&.match?(O_SERIES_MODEL_PATTERN)
+          raise Error, "Instance '#{name}' has reasoning_effort but model '#{model}' is not an o-series model (o1, o1 Preview, o1-mini, o1-pro, o3, o3-mini, o3-pro, o3-deep-research, o4-mini, o4-mini-deep-research, etc.)"
+        end
+      end
+
+      # Validate temperature is not used with o-series models when provider is openai
+      if provider == "openai" && config["temperature"] && model&.match?(O_SERIES_MODEL_PATTERN)
+        raise Error, "Instance '#{name}' has temperature parameter but model '#{model}' is an o-series model. O-series models use deterministic reasoning and don't accept temperature settings"
+      end
+
+      # Validate OpenAI-specific fields only when provider is not "openai"
+      if provider != "openai"
+        invalid_fields = OPENAI_SPECIFIC_FIELDS & config.keys
+        unless invalid_fields.empty?
+          raise Error, "Instance '#{name}' has OpenAI-specific fields #{invalid_fields.join(", ")} but provider is not 'openai'"
+        end
+      end
+
+      # Validate api_version if specified
+      if config["api_version"] && !VALID_API_VERSIONS.include?(config["api_version"])
+        raise Error, "Instance '#{name}' has invalid api_version '#{config["api_version"]}'. Must be 'chat_completion' or 'responses'"
+      end
+
       # Validate tool fields are arrays if present
       validate_tool_field(name, config, "tools")
       validate_tool_field(name, config, "allowed_tools")
@@ -93,7 +185,7 @@ module ClaudeSwarm
       # Parse directory field - support both string and array
       directories = parse_directories(config["directory"])
 
-      {
+      instance_config = {
         name: name,
         directory: directories.first, # Keep single directory for backward compatibility
         directories: directories, # New field with all directories
@@ -105,9 +197,26 @@ module ClaudeSwarm
         mcps: parse_mcps(config["mcps"] || []),
         prompt: config["prompt"],
         description: config["description"],
-        vibe: config["vibe"] || false,
-        worktree: parse_worktree_value(config["worktree"])
+        vibe: config["vibe"],
+        worktree: parse_worktree_value(config["worktree"]),
+        provider: provider, # nil means Claude (default)
       }
+
+      # Add OpenAI-specific fields only when provider is "openai"
+      if provider == "openai"
+        instance_config[:temperature] = config["temperature"] if config["temperature"]
+        instance_config[:api_version] = config["api_version"] || "chat_completion"
+        instance_config[:openai_token_env] = config["openai_token_env"] || "OPENAI_API_KEY"
+        instance_config[:base_url] = config["base_url"]
+        instance_config[:reasoning_effort] = config["reasoning_effort"] if config["reasoning_effort"]
+        # Default vibe to true for OpenAI instances if not specified
+        instance_config[:vibe] = true if config["vibe"].nil?
+      elsif config["vibe"].nil?
+        # Default vibe to false for Claude instances if not specified
+        instance_config[:vibe] = false
+      end
+
+      instance_config
     end
 
     def parse_mcps(mcps)
@@ -195,11 +304,55 @@ module ClaudeSwarm
     end
 
     def parse_worktree_value(value)
-      return nil if value.nil? # Omitted means follow CLI behavior
+      return if value.nil? # Omitted means follow CLI behavior
       return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
       return value.to_s if value.is_a?(String) && !value.empty?
 
       raise Error, "Invalid worktree value: #{value.inspect}. Must be true, false, or a non-empty string"
     end
+
+    def validate_openai_env_vars
+      @instances.each_value do |instance|
+        next unless instance[:provider] == "openai"
+
+        env_var = instance[:openai_token_env]
+        unless ENV.key?(env_var) && !ENV[env_var].to_s.strip.empty?
+          raise Error, "Environment variable '#{env_var}' is not set. OpenAI provider instances require an API key."
+        end
+      end
+    end
+
+    def validate_main_instance_provider
+      # Only validate in interactive mode (when no prompt is provided)
+      return if @options[:prompt]
+
+      main_config = @instances[@main_instance]
+      if main_config[:provider]
+        raise Error, "Main instance '#{@main_instance}' cannot have a provider setting in interactive mode"
+      end
+    end
+
+    def validate_openai_responses_api_compatibility
+      # Check if any instance uses OpenAI provider with responses API
+      responses_api_instances = @instances.select do |_name, instance|
+        instance[:provider] == "openai" && instance[:api_version] == "responses"
+      end
+
+      return if responses_api_instances.empty?
+
+      # Check ruby-openai version
+      begin
+        require "openai/version"
+        openai_version = Gem::Version.new(::OpenAI::VERSION)
+        required_version = Gem::Version.new("8.0.0")
+
+        if openai_version < required_version
+          instance_names = responses_api_instances.keys.join(", ")
+          raise Error, "Instances #{instance_names} use OpenAI provider with api_version 'responses', which requires ruby-openai >= 8.0. Current version is #{openai_version}. Please update your Gemfile or run: gem install ruby-openai -v '>= 8.0'"
+        end
+      rescue LoadError
+        # ruby-openai is not installed, which is fine - it will be caught later when trying to use it
+      end
+    end
   end
 end

data/lib/claude_swarm/mcp_generator.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-require "fileutils"
-require "shellwords"
-require "securerandom"
-
 module ClaudeSwarm
   class McpGenerator
     def initialize(configuration, vibe: false, restore_session_path: nil)
@@ -62,15 +57,20 @@ module ClaudeSwarm
       instance[:connections].each do |connection_name|
         connected_instance = @config.instances[connection_name]
         mcp_servers[connection_name] = build_instance_mcp_config(
-          connection_name, connected_instance,
-          calling_instance: name, calling_instance_id: @instance_ids[name]
+          connection_name,
+          connected_instance,
+          calling_instance: name,
+          calling_instance_id: @instance_ids[name],
         )
       end
 
+      # Add Claude tools MCP server for OpenAI instances
+      mcp_servers["claude_tools"] = build_claude_tools_mcp_config if instance[:provider] == "openai"
+
       config = {
         "instance_id" => @instance_ids[name],
         "instance_name" => name,
-        "mcpServers" => mcp_servers
+        "mcpServers" => mcp_servers,
       }
 
       File.write(mcp_config_path(name), JSON.pretty_generate(config))
@@ -82,18 +82,26 @@ module ClaudeSwarm
         {
           "type" => "stdio",
           "command" => mcp["command"],
-          "args" => mcp["args"] || []
+          "args" => mcp["args"] || [],
         }.tap do |config|
           config["env"] = mcp["env"] if mcp["env"]
         end
       when "sse"
         {
           "type" => "sse",
-          "url" => mcp["url"]
+          "url" => mcp["url"],
         }
       end
     end
 
+    def build_claude_tools_mcp_config
+      {
+        "type" => "stdio",
+        "command" => "claude",
+        "args" => ["mcp", "serve"],
+      }
+    end
+
     def build_instance_mcp_config(name, instance, calling_instance:, calling_instance_id:)
       # Get the path to the claude-swarm executable
       exe_path = "claude-swarm"
@@ -101,9 +109,12 @@ module ClaudeSwarm
       # Build command-line arguments for Thor
       args = [
         "mcp-serve",
-        "--name", name,
-        "--directory", instance[:directory],
-        "--model", instance[:model]
+        "--name",
+        name,
+        "--directory",
+        instance[:directory],
+        "--model",
+        instance[:model],
       ]
 
       # Add directories array if we have multiple directories
@@ -130,6 +141,20 @@ module ClaudeSwarm
 
       args.push("--vibe") if @vibe || instance[:vibe]
 
+      # Add provider-specific parameters
+      if instance[:provider]
+        args.push("--provider", instance[:provider])
+
+        # Add OpenAI-specific parameters
+        if instance[:provider] == "openai"
+          args.push("--reasoning-effort", instance[:reasoning_effort]) if instance[:reasoning_effort]
+          args.push("--temperature", instance[:temperature].to_s) if instance[:temperature]
+          args.push("--api-version", instance[:api_version]) if instance[:api_version]
+          args.push("--openai-token-env", instance[:openai_token_env]) if instance[:openai_token_env]
+          args.push("--base-url", instance[:base_url]) if instance[:base_url]
+        end
+      end
+
       # Add claude session ID if restoring
       if @restore_states[name.to_s]
         claude_session_id = @restore_states[name.to_s]["claude_session_id"]
@@ -139,7 +164,7 @@ module ClaudeSwarm
       {
         "type" => "stdio",
         "command" => exe_path,
-        "args" => args
+        "args" => args,
       }
     end