claude_swarm 0.3.9 → 0.3.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55711fd9483c68d996c0a0e448c4d31135d7423269d1ed691bb3590db5487627
-  data.tar.gz: a84c0b4e1165057cbbe22bcd4d6c02c8fcdaedb5abb2f18e150b667ee0083385
+  metadata.gz: 8e0bade0292291825648214e0a1a420241ec1d6ffff018831d131d5c0f532e45
+  data.tar.gz: 74d62b916f1dbde6b725e8990924839c6ace2b6de75cb812f43305d044def7b7
 SHA512:
-  metadata.gz: cc2808da58a6cb2b2ac545cfbe4803382602d4339017337d3af84b92274baab241952186f7de4e72adfbd413d0fcb448b955fb4cb7ebb5ebc014b90895988247
-  data.tar.gz: 2d58c3795f4ea80da550c6241ad7639ffa5d25fa868eb9af18bf58382961f8cad4fb930616c133197858193fb2f9627aead812bfd60a3565631ef38398351b16
+  metadata.gz: 0f7f0b3dad9bb034a5b1cf07417df7b3cef6dc7fa88d02d4c9617db354ff0f52d7a368f678f0d2502343fdb03112cf8672f68f2dce3a77a46d769f4cc8f0afa6
+  data.tar.gz: d2c81f31e2534e4f92f519ea1b218236d68ed2e08adbd3bfdb2d0569de1a5f80a2f5b2452e3c47b75e6e4441fb70575ca1fbf381d169c0b9ee2aca4b2072c7d6

data/.claude/commands/release.md

@@ -0,0 +1,27 @@
+---
+description: Bump version, update changelog, and prepare for release
+allowed-tools: [Read, Edit, Bash]
+---
+
+Prepare a new release for Claude Swarm by:
+
+1. Read the current version from @lib/claude_swarm/version.rb
+2. Determine the new version number: $ARGUMENTS (should be in format like 0.3.11 or use patch/minor/major)
+3. Update the version in @lib/claude_swarm/version.rb 
+4. Update @CHANGELOG.md:
+   - Change "## [Unreleased]" to "## [new_version]"
+   - Add a new "## [Unreleased]" section at the top for future changes
+5. Run these commands:
+   - `git add .`
+   - `bundle install` 
+   - `git add .`
+   - `git commit -m "Release version X.X.X"`
+   - `git push`
+
+Make sure all tests pass before releasing. The version argument should be either:
+- A specific version number (e.g., 0.3.11)
+- "patch" for incrementing the patch version (0.3.10 -> 0.3.11)
+- "minor" for incrementing the minor version (0.3.10 -> 0.4.0)
+- "major" for incrementing the major version (0.3.10 -> 1.0.0)
+
+If no argument is provided, default to "patch".

data/CHANGELOG.md

@@ -1,3 +1,50 @@
+## [Unreleased]
+
+## [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
+- **Token-based cost calculation for main instance**: Main instance costs in interactive mode are now calculated from token usage using Claude model pricing
+  - Opus: $15/MTok input, $75/MTok output, $18.75/MTok cache write, $1.50/MTok cache read
+  - Sonnet: $3/MTok input, $15/MTok output, $3.75/MTok cache write, $0.30/MTok cache read  
+  - Haiku: $0.80/MTok input, $4/MTok output, $1/MTok cache write, $0.08/MTok cache read
+  - Automatically extracts usage data from assistant messages in session logs
+
+### Changed
+- **Simplified cost calculation**: Switched from cumulative `total_cost_usd` to per-request `cost_usd` for non-main instances
+  - Removed complex session reset detection logic
+  - Now uses simple summation of individual request costs
+  - More accurate and maintainable cost tracking
+- **Improved ps command cost display**: 
+  - Only shows cost warning when sessions are missing main instance data
+  - Adds asterisk (*) indicator to costs that exclude main instance
+  - Displays accurate total costs including main instance when available
+
+### Fixed
+- **Main instance log format consistency**: Fixed transcript logs in interactive mode to match standard instance log format
+  - Converted transcript wrapper to request/assistant event structure
+  - Properly extracts text content from nested message arrays
+  - Ensures uniform log parsing across all instances
+
 ## [0.3.9]
 
 ### Added

data/README.md

@@ -824,8 +824,8 @@ swarm:
 claude-swarm
 
 # Specify a different configuration file
-claude-swarm my-swarm.yml
-claude-swarm team-config.yml
+claude-swarm start my-swarm.yml
+claude-swarm start team-config.yml
 
 # Run with --dangerously-skip-permissions for all instances
 claude-swarm --vibe

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
 
@@ -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)

data/lib/claude_swarm/commands/ps.rb

@@ -34,6 +34,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 +53,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 +120,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 +135,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,

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)
       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
@@ -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/orchestrator.rb

@@ -73,6 +73,20 @@ module ClaudeSwarm
       # Track start time
       @start_time = Time.now
 
+      begin
+        start_internal
+      rescue StandardError => e
+        # Ensure cleanup happens even on unexpected errors
+        cleanup_processes
+        cleanup_run_symlink
+        cleanup_worktrees
+        raise e
+      end
+    end
+
+    private
+
+    def start_internal
       if @restore_session_path
         non_interactive_output do
           puts "🔄 Restoring Claude Swarm: #{@config.swarm_name}"
@@ -115,16 +129,24 @@ module ClaudeSwarm
 
         # Setup worktrees if needed
         if @worktree_manager
-          non_interactive_output { print("🌳 Setting up Git worktrees...") }
+          begin
+            non_interactive_output { print("🌳 Setting up Git worktrees...") }
 
-          # Get all instances for worktree setup
-          # Note: instances.values already includes the main instance
-          all_instances = @config.instances.values
+            # Get all instances for worktree setup
+            # Note: instances.values already includes the main instance
+            all_instances = @config.instances.values
 
-          @worktree_manager.setup_worktrees(all_instances)
+            @worktree_manager.setup_worktrees(all_instances)
 
-          non_interactive_output do
-            puts "✓ Worktrees created with branch: #{@worktree_manager.worktree_name}"
+            non_interactive_output do
+              puts "✓ Worktrees created with branch: #{@worktree_manager.worktree_name}"
+            end
+          rescue StandardError => e
+            non_interactive_output { print("❌ Failed to setup worktrees: #{e.message}") }
+            cleanup_processes
+            cleanup_run_symlink
+            cleanup_worktrees
+            raise
           end
         end
 
@@ -200,6 +222,20 @@ module ClaudeSwarm
           non_interactive_output do
             puts "✓ Before commands completed successfully"
           end
+
+          # Validate directories after before commands have run
+          begin
+            @config.validate_directories
+            non_interactive_output do
+              puts "✓ All directories validated successfully"
+            end
+          rescue ClaudeSwarm::Error => e
+            non_interactive_output { print("❌ Directory validation failed: #{e.message}") }
+            cleanup_processes
+            cleanup_run_symlink
+            cleanup_worktrees
+            exit(1)
+          end
         end
 
         # Execute main Claude instance with unbundled environment to avoid bundler conflicts
@@ -249,8 +285,6 @@ module ClaudeSwarm
       cleanup_worktrees
     end
 
-    private
-
     def non_interactive_output
       return if @non_interactive_prompt
 
@@ -573,9 +607,6 @@ module ClaudeSwarm
           pretty_json = JSON.pretty_generate(json_data)
           logger.info { pretty_json }
         rescue JSON::ParserError
-          # Warn about non-JSON output since we expect stream-json format
-          warn("⚠️  Warning: Non-JSON output detected in stream-json mode: #{line.chomp}")
-          # Log the line as-is
           logger.info { line.chomp }
         end
 
@@ -614,12 +645,14 @@ module ClaudeSwarm
                 # Convert to session.log.json format
                 session_entry = convert_transcript_to_session_format(transcript_entry)
 
-                # Write with file locking (same pattern as BaseExecutor)
-                session_json_path = File.join(@session_path, "session.log.json")
-                File.open(session_json_path, File::WRONLY | File::APPEND | File::CREAT) do |log_file|
-                  log_file.flock(File::LOCK_EX)
-                  log_file.puts(session_entry.to_json)
-                  log_file.flock(File::LOCK_UN)
+                # Only write if we got a valid conversion (skips summary and other non-relevant entries)
+                if session_entry
+                  # Write with file locking (same pattern as BaseExecutor)
+                  session_json_path = File.join(@session_path, "session.log.json")
+                  File.open(session_json_path, File::WRONLY | File::APPEND | File::CREAT) do |log_file|
+                    log_file.flock(File::LOCK_EX)
+                    log_file.puts(session_entry.to_json)
+                  end
                 end
               rescue JSON::ParserError
                 # Silently skip unparseable lines
@@ -638,16 +671,92 @@ module ClaudeSwarm
     end
 
     def convert_transcript_to_session_format(transcript_entry)
-      {
-        instance: @config.main_instance,
-        instance_id: "main",
-        timestamp: transcript_entry["timestamp"] || Time.now.iso8601,
-        event: {
-          type: "transcript",
-          source: "main_instance",
-          data: transcript_entry,
-        },
-      }
+      # Skip if no type
+      return unless transcript_entry["type"]
+
+      instance_name = @config.main_instance
+      instance_id = "main"
+      timestamp = transcript_entry["timestamp"] || Time.now.iso8601
+
+      case transcript_entry["type"]
+      when "user"
+        # User message - format as request from user to main instance
+        message = transcript_entry["message"]
+
+        # Extract prompt text - message might be a string or an object
+        prompt_text = if message.is_a?(String)
+          message
+        elsif message.is_a?(Hash)
+          content = message["content"]
+          if content.is_a?(String)
+            content
+          elsif content.is_a?(Array)
+            # For tool results or complex content, extract text
+            extract_text_from_array(content)
+          else
+            ""
+          end
+        else
+          ""
+        end
+
+        {
+          instance: instance_name,
+          instance_id: instance_id,
+          timestamp: timestamp,
+          event: {
+            type: "request",
+            from_instance: "user",
+            from_instance_id: "user",
+            to_instance: instance_name,
+            to_instance_id: instance_id,
+            prompt: prompt_text,
+            timestamp: timestamp,
+          },
+        }
+      when "assistant"
+        # Assistant message - format as assistant response
+        message = transcript_entry["message"]
+
+        # Build a clean message structure without transcript-specific fields
+        clean_message = {
+          "type" => "message",
+          "role" => "assistant",
+        }
+
+        # Handle different message formats
+        if message.is_a?(String)
+          # Simple string message
+          clean_message["content"] = [{ "type" => "text", "text" => message }]
+        elsif message.is_a?(Hash)
+          # Only include the fields that other instances include
+          clean_message["content"] = message["content"] if message["content"]
+          clean_message["model"] = message["model"] if message["model"]
+          clean_message["usage"] = message["usage"] if message["usage"]
+        end
+
+        {
+          instance: instance_name,
+          instance_id: instance_id,
+          timestamp: timestamp,
+          event: {
+            type: "assistant",
+            message: clean_message,
+            session_id: transcript_entry["sessionId"],
+          },
+        }
+      end
+      # For other types (like summary), return nil to skip them
+    end
+
+    def extract_text_from_array(content)
+      content.map do |item|
+        if item.is_a?(Hash)
+          item["text"] || item["content"] || ""
+        else
+          item.to_s
+        end
+      end.join("\n")
     end
 
     def cleanup_transcript_thread

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"]
+        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,6 +131,8 @@ 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)
 
@@ -75,10 +169,24 @@ 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
@@ -87,6 +195,14 @@ module ClaudeSwarm
         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
     end
   end

data/lib/claude_swarm/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: claude_swarm
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.3.11
 platform: ruby
 authors:
 - Paulo Arruda
@@ -140,6 +140,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/commands/release.md"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".ruby-version"