claude_swarm 0.3.9 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55711fd9483c68d996c0a0e448c4d31135d7423269d1ed691bb3590db5487627
-  data.tar.gz: a84c0b4e1165057cbbe22bcd4d6c02c8fcdaedb5abb2f18e150b667ee0083385
+  metadata.gz: a44d1b33e538b1efaeca7eb223f09bd617fcb4ba2288d7844773ae5908a10248
+  data.tar.gz: 28312f81eada550b05bbf568807be51c5077366c08d168b928a35a4d356148da
 SHA512:
-  metadata.gz: cc2808da58a6cb2b2ac545cfbe4803382602d4339017337d3af84b92274baab241952186f7de4e72adfbd413d0fcb448b955fb4cb7ebb5ebc014b90895988247
-  data.tar.gz: 2d58c3795f4ea80da550c6241ad7639ffa5d25fa868eb9af18bf58382961f8cad4fb930616c133197858193fb2f9627aead812bfd60a3565631ef38398351b16
+  metadata.gz: 2d8ba31f8a64f91060b980ee90bea57c736e4541410eeb36c4c78bdc602f7c3335ea82a388c0b61847a04c90210fb432c2d525df4f4bfa85cbe3725a0034b260
+  data.tar.gz: 15180a4a4df3f9ccc55da9dd40769435c1ba650a575b476c10d7c0b16d650bb1f65524b8d44a10d731e9aed3dcda886b0bb63fd2b64e5665c5ba1cc22633182b

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,28 @@
+## [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/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/orchestrator.rb

@@ -573,9 +573,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 +611,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 +637,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.10"
 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.10
 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"