claude_swarm 0.3.2 → 1.0.0

data/lib/claude_swarm/session_cost_calculator.rb

@@ -4,26 +4,118 @@ module ClaudeSwarm
   module SessionCostCalculator
     extend self
 
+    # Model pricing in dollars per million tokens
+    MODEL_PRICING = {
+      opus: {
+        input: 15.0,
+        output: 75.0,
+        cache_write: 18.75,
+        cache_read: 1.50,
+      },
+      sonnet: {
+        input: 3.0,
+        output: 15.0,
+        cache_write: 3.75,
+        cache_read: 0.30,
+      },
+      haiku: {
+        input: 0.80,
+        output: 4.0,
+        cache_write: 1.0,
+        cache_read: 0.08,
+      },
+    }.freeze
+
+    # Determine model type from model name
+    def model_type_from_name(model_name)
+      return unless model_name
+
+      model_name_lower = model_name.downcase
+      if model_name_lower.include?("opus")
+        :opus
+      elsif model_name_lower.include?("sonnet")
+        :sonnet
+      elsif model_name_lower.include?("haiku")
+        :haiku
+      end
+    end
+
+    # Calculate cost from token usage
+    def calculate_token_cost(usage, model_name)
+      model_type = model_type_from_name(model_name)
+      return 0.0 unless model_type && usage
+
+      pricing = MODEL_PRICING[model_type]
+      return 0.0 unless pricing
+
+      cost = 0.0
+
+      # Regular input tokens
+      if usage["input_tokens"]
+        cost += (usage["input_tokens"] / 1_000_000.0) * pricing[:input]
+      end
+
+      # Output tokens
+      if usage["output_tokens"]
+        cost += (usage["output_tokens"] / 1_000_000.0) * pricing[:output]
+      end
+
+      # Cache creation tokens (write)
+      if usage["cache_creation_input_tokens"]
+        cost += (usage["cache_creation_input_tokens"] / 1_000_000.0) * pricing[:cache_write]
+      end
+
+      # Cache read tokens
+      if usage["cache_read_input_tokens"]
+        cost += (usage["cache_read_input_tokens"] / 1_000_000.0) * pricing[:cache_read]
+      end
+
+      cost
+    end
+
     # Calculate total cost from session log file
     # Returns a hash with:
-    # - total_cost: Total cost in USD
+    # - total_cost: Total cost in USD (sum of cost_usd for instances, token costs for main)
     # - instances_with_cost: Set of instance names that have cost data
     def calculate_total_cost(session_log_path)
       return { total_cost: 0.0, instances_with_cost: Set.new } unless File.exist?(session_log_path)
 
-      total_cost = 0.0
+      # Track costs per instance - simple sum of cost_usd
+      instance_costs = {}
       instances_with_cost = Set.new
+      main_instance_cost = 0.0
 
       File.foreach(session_log_path) do |line|
-        data = JSON.parse(line)
-        if data.dig("event", "type") == "result" && (cost = data.dig("event", "total_cost_usd"))
-          total_cost += cost
-          instances_with_cost << data["instance"]
+        data = JsonHandler.parse(line)
+        next if data == line # Skip unparseable lines
+
+        instance_name = data["instance"]
+        instance_id = data["instance_id"]
+
+        # Handle main instance token-based costs
+        if instance_id == "main" && data.dig("event", "type") == "assistant"
+          usage = data.dig("event", "message", "usage")
+          model = data.dig("event", "message", "model")
+          if usage && model
+            token_cost = calculate_token_cost(usage, model)
+            main_instance_cost += token_cost
+            instances_with_cost << instance_name if token_cost > 0
+          end
+        # Handle other instances with cost_usd (non-cumulative)
+        elsif instance_id != "main" && data.dig("event", "type") == "result"
+          # Use cost_usd (non-cumulative) instead of total_cost_usd (cumulative)
+          if (cost = data.dig("event", "cost_usd"))
+            instances_with_cost << instance_name
+            instance_costs[instance_name] ||= 0.0
+            instance_costs[instance_name] += cost
+          end
         end
-      rescue JSON::ParserError
-        next
       end
 
+      # Calculate total: sum of all instance costs + main instance token costs
+      other_instances_cost = instance_costs.values.sum
+      total_cost = other_instances_cost + main_instance_cost
+
       {
         total_cost: total_cost,
         instances_with_cost: instances_with_cost,
@@ -39,11 +131,15 @@ module ClaudeSwarm
     # Returns a hash of instances with their cost data and relationships
     def parse_instance_hierarchy(session_log_path)
       instances = {}
+      # Track main instance token costs
+      main_instance_costs = {}
 
       return instances unless File.exist?(session_log_path)
 
       File.foreach(session_log_path) do |line|
-        data = JSON.parse(line)
+        data = JsonHandler.parse(line)
+        next if data == line # Skip unparseable lines
+
         instance_name = data["instance"]
         instance_id = data["instance_id"]
         calling_instance = data["calling_instance"]
@@ -75,16 +171,36 @@ module ClaudeSwarm
           instances[calling_instance][:calls_to] << instance_name
         end
 
-        # Track costs and calls
-        if data.dig("event", "type") == "result"
+        # Handle main instance token-based costs
+        if instance_id == "main" && data.dig("event", "type") == "assistant"
+          usage = data.dig("event", "message", "usage")
+          model = data.dig("event", "message", "model")
+          if usage && model
+            token_cost = calculate_token_cost(usage, model)
+            if token_cost > 0
+              main_instance_costs[instance_name] ||= 0.0
+              main_instance_costs[instance_name] += token_cost
+              instances[instance_name][:has_cost_data] = true
+              instances[instance_name][:calls] += 1
+            end
+          end
+        # Track costs and calls for non-main instances using cost_usd
+        elsif data.dig("event", "type") == "result" && instance_id != "main"
           instances[instance_name][:calls] += 1
-          if (cost = data.dig("event", "total_cost_usd"))
+          # Use cost_usd (non-cumulative) instead of total_cost_usd
+          if (cost = data.dig("event", "cost_usd"))
             instances[instance_name][:cost] += cost
             instances[instance_name][:has_cost_data] = true
           end
         end
-      rescue JSON::ParserError
-        next
+      end
+
+      # Set main instance costs (replace, don't add)
+      main_instance_costs.each do |name, cost|
+        if instances[name]
+          # For main instances, use ONLY token costs, not cumulative costs
+          instances[name][:cost] = cost
+        end
       end
 
       instances

data/lib/claude_swarm/session_path.rb

@@ -2,13 +2,7 @@
 
 module ClaudeSwarm
   module SessionPath
-    SESSIONS_DIR = "sessions"
-
     class << self
-      def swarm_home
-        ENV["CLAUDE_SWARM_HOME"] || File.expand_path("~/.claude-swarm")
-      end
-
       # Convert a directory path to a safe folder name using + as separator
       def project_folder_name(working_dir = Dir.pwd)
         # Don't expand path if it's already expanded (avoids double expansion on Windows)
@@ -27,7 +21,7 @@ module ClaudeSwarm
       # Generate a full session path for a given directory and session ID
       def generate(working_dir: Dir.pwd, session_id: SecureRandom.uuid)
         project_name = project_folder_name(working_dir)
-        File.join(swarm_home, SESSIONS_DIR, project_name, session_id)
+        ClaudeSwarm.joined_sessions_dir(project_name, session_id)
       end
 
       # Ensure the session directory exists
@@ -35,7 +29,7 @@ module ClaudeSwarm
         FileUtils.mkdir_p(session_path)
 
         # Add .gitignore to swarm home if it doesn't exist
-        gitignore_path = File.join(swarm_home, ".gitignore")
+        gitignore_path = ClaudeSwarm.joined_home_dir(".gitignore")
         File.write(gitignore_path, "*\n") unless File.exist?(gitignore_path)
       end
 

data/lib/claude_swarm/settings_generator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  class SettingsGenerator
+    def initialize(configuration)
+      @config = configuration
+    end
+
+    def generate_all
+      ensure_session_directory
+
+      @config.instances.each do |name, instance|
+        generate_settings(name, instance)
+      end
+    end
+
+    def settings_path(instance_name)
+      File.join(session_path, "#{instance_name}_settings.json")
+    end
+
+    private
+
+    def session_path
+      @session_path ||= SessionPath.from_env
+    end
+
+    def ensure_session_directory
+      # Session directory is already created by orchestrator
+      # Just ensure it exists
+      SessionPath.ensure_directory(session_path)
+    end
+
+    def generate_settings(name, instance)
+      settings = {}
+
+      # Add hooks if configured
+      if instance[:hooks] && !instance[:hooks].empty?
+        settings["hooks"] = instance[:hooks]
+      end
+
+      # Add SessionStart hook for main instance to capture transcript path
+      if name == @config.main_instance
+        session_start_hook = build_session_start_hook
+
+        # Initialize hooks if not present
+        settings["hooks"] ||= {}
+        settings["hooks"]["SessionStart"] ||= []
+
+        # Add our hook to the SessionStart hooks
+        settings["hooks"]["SessionStart"] << session_start_hook
+      end
+
+      # Only write settings file if there are settings to write
+      return if settings.empty?
+
+      # Write settings file
+      JsonHandler.write_file!(settings_path(name), settings)
+    end
+
+    def build_session_start_hook
+      hook_script_path = File.expand_path("hooks/session_start_hook.rb", __dir__)
+      # Pass session path as an argument since ENV may not be inherited
+      session_path_arg = session_path
+
+      {
+        "matcher" => "startup",
+        "hooks" => [
+          {
+            "type" => "command",
+            "command" => "ruby #{hook_script_path} '#{session_path_arg}'",
+            "timeout" => 5,
+          },
+        ],
+      }
+    end
+  end
+end

data/lib/claude_swarm/system_utils.rb

@@ -7,8 +7,12 @@ module ClaudeSwarm
       unless success
         exit_status = $CHILD_STATUS&.exitstatus || 1
         command_str = args.size == 1 ? args.first : args.join(" ")
-        warn("❌ Command failed with exit status: #{exit_status}")
-        raise Error, "Command failed with exit status #{exit_status}: #{command_str}"
+        if exit_status == 143 # timeout command exit status = 128 + 15 (SIGTERM)
+          warn("⏱️ Command timeout: #{command_str}")
+        else
+          warn("❌ Command failed with exit status: #{exit_status}")
+          raise Error, "Command failed with exit status #{exit_status}: #{command_str}"
+        end
       end
       success
     end

data/lib/claude_swarm/templates/generation_prompt.md.erb

@@ -1,4 +1,4 @@
-You are a Claude Swarm configuration generator assistant. Your role is to help the user create a well-structured claude-swarm.yml file through an interactive conversation.
+You are a Claude Swarm configuration generator assistant. Your role is to help the user create a well-structured swarm YAML file through an interactive conversation.
 
 ## Claude Swarm Overview
 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).
@@ -10,6 +10,7 @@ Key capabilities:
 - Run instances in different directories or Git worktrees
 - Support for custom system prompts per instance
 - Choose appropriate models (opus for complex tasks, sonnet for simpler ones)
+- Support for OpenAI instances
 
 ## Your Task
 1. Start by asking about the user's project structure and development needs
@@ -43,7 +44,7 @@ swarm:
     instance_name:
       description: "Clear description of role and responsibilities"
       directory: ./path/to/directory
-      model: sonnet  # or opus for complex tasks
+      model: opus
       allowed_tools: [Read, Edit, Write, Bash]
       connections: [other_instance_names]  # Optional
       prompt: |
@@ -57,7 +58,7 @@ swarm:
 - Write clear descriptions explaining each instance's responsibilities
 - Choose opus model for complex architectural or algorithmic tasks and routine development.
 - Choose sonnet model for simpler tasks
-- Set up logical connections (e.g., lead → team members, architect → implementers), but avoid circular dependencies.
+- Set up logical connections (e.g., lead → team members, architect → implementers), but do not create circular dependencies.
 - Always add this to the end of every prompt: `For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.`
 - Select tools based on each instance's actual needs:
   - Read: For code review and analysis roles
@@ -72,7 +73,6 @@ swarm:
 
 ## Interactive Questions to Ask
 - What type of project are you working on?
-- What's your project's directory structure?
 - What are the main technologies/frameworks you're using?
 - What development tasks do you need help with?
 - Do you need specialized roles (testing, DevOps, documentation)?
@@ -226,5 +226,5 @@ The more precisely you explain what you want, the better Claude's response will
 
 </prompt_best_practices>
 
-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
+
+IMPORTANT: Do not generate swarms with circular dependencies. For example, instance A connections to instance B, and instance B connections to instance A.

data/lib/claude_swarm/tools/task_tool.rb

@@ -43,8 +43,20 @@ module ClaudeSwarm
 
         response = executor.execute(final_prompt, options)
 
+        # Validate the response has a result
+        unless response.is_a?(Hash) && response.key?("result")
+          raise "Invalid response from executor: missing 'result' field. Response structure: #{response.keys.join(", ")}"
+        end
+
+        result = response["result"]
+
+        # Validate the result is not empty
+        if result.nil? || (result.is_a?(String) && result.strip.empty?)
+          raise "Agent #{instance_config[:name]} returned an empty response. The task was executed but no content was provided."
+        end
+
         # Return just the result text as expected by MCP
-        response["result"]
+        result
       end
     end
   end

data/lib/claude_swarm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClaudeSwarm
-  VERSION = "0.3.2"
+  VERSION = "1.0.0"
 end

data/lib/claude_swarm/worktree_manager.rb

@@ -158,7 +158,7 @@ module ClaudeSwarm
       # Remove session-specific worktree directory if it exists and is empty
       return unless @session_id
 
-      session_worktree_dir = File.join(File.expand_path("~/.claude-swarm/worktrees"), @session_id)
+      session_worktree_dir = ClaudeSwarm.joined_worktrees_dir(@session_id)
       return unless File.exist?(session_worktree_dir)
 
       # Try to remove the directory tree
@@ -214,7 +214,7 @@ module ClaudeSwarm
       unique_repo_name = "#{repo_name}-#{path_hash}"
 
       # Build external path: ~/.claude-swarm/worktrees/[session_id]/[repo_name-hash]/[worktree_name]
-      base_dir = File.expand_path("~/.claude-swarm/worktrees")
+      base_dir = ClaudeSwarm.joined_worktrees_dir
 
       # Validate base directory is accessible
       begin

data/lib/claude_swarm.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # Standard library dependencies
+require "bundler"
 require "digest"
 require "English"
 require "erb"
@@ -20,9 +21,9 @@ require "tmpdir"
 require "yaml"
 
 # External dependencies
+require "claude_sdk"
 require "fast_mcp_annotations"
 require "mcp_client"
-require "openai"
 require "thor"
 
 # Zeitwerk setup
@@ -40,7 +41,27 @@ module ClaudeSwarm
 
   class << self
     def root_dir
-      ENV.fetch("CLAUDE_SWARM_ROOT_DIR", Dir.pwd)
+      ENV.fetch("CLAUDE_SWARM_ROOT_DIR") { Dir.pwd }
+    end
+
+    def home_dir
+      ENV.fetch("CLAUDE_SWARM_HOME") { File.expand_path("~/.claude-swarm") }
+    end
+
+    def joined_home_dir(*strings)
+      File.join(home_dir, *strings)
+    end
+
+    def joined_run_dir(*strings)
+      joined_home_dir("run", *strings)
+    end
+
+    def joined_sessions_dir(*strings)
+      joined_home_dir("sessions", *strings)
+    end
+
+    def joined_worktrees_dir(*strings)
+      joined_home_dir("worktrees", *strings)
     end
   end
 end

data/team.yml

@@ -8,10 +8,20 @@ swarm:
       directory: .
       model: opus
       vibe: true
-      connections: [github_expert, fast_mcp_expert, ruby_mcp_client_expert, openai_api_expert]
+      connections: [github_expert, fast_mcp_expert, ruby_mcp_client_expert, openai_api_expert, claude_code_sdk_expert]
       prompt: |
         You are the lead developer of Claude Swarm, a Ruby gem that orchestrates multiple Claude Code instances as a collaborative AI development team. The gem enables running AI agents with specialized roles, tools, and directory contexts, communicating via MCP (Model Context Protocol) in a tree-like hierarchy.
-        Use the github_expert to help you with git and github related tasks.
+        
+        IMPORTANT: Use your specialized team members for their areas of expertise. Each team member has deep knowledge in their domain:
+
+        Team Member Usage Guide:
+        - **github_expert**: Use for all Git and GitHub operations including creating issues, PRs, managing releases, checking CI/CD workflows, and repository management
+        - **fast_mcp_expert**: Use for MCP server development, tool creation, resource management, and any FastMCP-related architecture decisions
+        - **ruby_mcp_client_expert**: Use for MCP client integration, multi-transport connectivity, authentication flows, and ruby-mcp-client library guidance
+        - **openai_api_expert**: Use for OpenAI API integration, ruby-openai gem usage, model configuration, and OpenAI provider support in Claude Swarm
+        - **claude_code_sdk_expert**: Use for Claude Code SDK integration, programmatic Claude Code usage, client configuration, and SDK development patterns
+
+        Always delegate specialized tasks to the appropriate team member rather than handling everything yourself. This ensures the highest quality solutions and leverages each expert's deep domain knowledge.
 
         Your responsibilities include:
         - Developing new features and improvements for the Claude Swarm gem
@@ -254,4 +264,66 @@ swarm:
         - Set up CI to run code_quality checks
         - Document Raix integration in wiki/docs
         
-        For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
+        For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
+
+    claude_code_sdk_expert:
+      description: "Expert in Claude Code SDK for Ruby, specializing in client integration and API usage patterns"
+      directory: ~/src/github.com/parruda/claude-code-sdk-ruby
+      model: opus
+      vibe: true
+      prompt: |
+        You are an expert in the Claude Code SDK for Ruby, specializing in client integration, API usage patterns, and SDK development best practices.
+
+        Your expertise covers:
+        - Claude Code SDK architecture and client configuration
+        - API authentication and session management
+        - Request/response handling and error management
+        - Code generation and analysis capabilities
+        - SDK integration patterns and best practices
+        - Tool usage and permission management
+        - Streaming responses and real-time interactions
+        - Multi-modal capabilities (text, code, images)
+        - Rate limiting and cost optimization
+        - Testing and debugging SDK integrations
+
+        Key responsibilities:
+        - Analyze Claude Code SDK codebase for implementation patterns
+        - Provide guidance on proper SDK usage and integration
+        - Design robust client configurations and authentication flows
+        - Implement efficient request handling and error recovery
+        - Optimize SDK performance and resource usage
+        - Create comprehensive examples and documentation
+        - Troubleshoot integration issues and API errors
+        - Ensure proper handling of streaming and async operations
+
+        Technical focus areas:
+        - Client initialization and configuration options
+        - Authentication flows and token management
+        - Request builders and parameter validation
+        - Response parsing and error handling
+        - Streaming implementations and chunk processing
+        - Tool integration and permission management
+        - Session management and state persistence
+        - Performance optimization and caching strategies
+        - Testing patterns and mock configurations
+
+        When providing guidance:
+        - Reference specific SDK methods and classes
+        - Include practical code examples and usage patterns
+        - Explain both SDK abstractions and underlying API details
+        - Highlight important configuration options and their implications
+        - Warn about common pitfalls and API limitations
+        - Suggest performance optimizations and cost-saving strategies
+        - Provide context on when to use different SDK features
+        - Demonstrate proper error handling and retry strategies
+
+        Integration with Claude Swarm development:
+        - Understand how Claude Code SDK can enhance swarm capabilities
+        - Provide insights on programmatic Claude Code integration
+        - Design patterns for automated swarm management
+        - Optimize SDK usage within swarm orchestration
+        - Ensure compatibility with swarm session management
+
+        For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
+
+        Help developers integrate Claude Code SDK effectively with confidence, best practices, and optimal performance.