claude_swarm 0.1.20 → 0.2.1

data/lib/claude_swarm/process_tracker.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "fileutils"
-
 module ClaudeSwarm
   class ProcessTracker
     PIDS_DIR = "pids"
@@ -39,7 +37,7 @@ module ClaudeSwarm
           puts "✓ Terminated MCP server: #{name} (PID: #{pid})"
 
           # Give it a moment to terminate gracefully
-          sleep 0.1
+          sleep(0.1)
 
           # Force kill if still running
           begin
@@ -62,11 +60,13 @@ module ClaudeSwarm
       FileUtils.rm_rf(@pids_dir)
     end
 
-    def self.cleanup_session(session_path)
-      return unless Dir.exist?(File.join(session_path, PIDS_DIR))
+    class << self
+      def cleanup_session(session_path)
+        return unless Dir.exist?(File.join(session_path, PIDS_DIR))
 
-      tracker = new(session_path)
-      tracker.cleanup_all
+        tracker = new(session_path)
+        tracker.cleanup_all
+      end
     end
 
     private

data/lib/claude_swarm/session_cost_calculator.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  module SessionCostCalculator
+    extend self
+
+    # Calculate total cost from session log file
+    # Returns a hash with:
+    # - total_cost: Total cost in USD
+    # - 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
+      instances_with_cost = Set.new
+
+      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"]
+        end
+      rescue JSON::ParserError
+        next
+      end
+
+      {
+        total_cost: total_cost,
+        instances_with_cost: instances_with_cost,
+      }
+    end
+
+    # Calculate simple total cost (for backward compatibility)
+    def calculate_simple_total(session_log_path)
+      calculate_total_cost(session_log_path)[:total_cost]
+    end
+
+    # Parse instance hierarchy with costs from session log
+    # Returns a hash of instances with their cost data and relationships
+    def parse_instance_hierarchy(session_log_path)
+      instances = {}
+
+      return instances unless File.exist?(session_log_path)
+
+      File.foreach(session_log_path) 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
+      end
+
+      instances
+    end
+  end
+end

data/lib/claude_swarm/session_path.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "fileutils"
-
 module ClaudeSwarm
   module SessionPath
     SESSIONS_DIR = "sessions"
@@ -26,10 +24,10 @@ module ClaudeSwarm
         path.gsub(%r{[/\\]}, "+")
       end
 
-      # Generate a full session path for a given directory and timestamp
-      def generate(working_dir: Dir.pwd, timestamp: Time.now.strftime("%Y%m%d_%H%M%S"))
+      # 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, timestamp)
+        File.join(swarm_home, SESSIONS_DIR, project_name, session_id)
       end
 
       # Ensure the session directory exists

data/lib/claude_swarm/system_utils.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "English"
-
 module ClaudeSwarm
   module SystemUtils
     def system!(*args)
@@ -9,7 +7,7 @@ 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}"
+        warn("❌ Command failed with exit status: #{exit_status}")
         raise Error, "Command failed with exit status #{exit_status}: #{command_str}"
       end
       success

data/lib/claude_swarm/tools/reset_session_tool.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  module Tools
+    class ResetSessionTool < FastMcp::Tool
+      tool_name "reset_session"
+      description "Reset the Claude session for this agent, starting fresh on the next task"
+
+      arguments do
+        # No arguments needed
+      end
+
+      def call
+        executor = ClaudeMcpServer.executor
+        executor.reset_session
+
+        {
+          success: true,
+          message: "Session has been reset",
+        }
+      end
+    end
+  end
+end

data/lib/claude_swarm/tools/session_info_tool.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  module Tools
+    class SessionInfoTool < FastMcp::Tool
+      tool_name "session_info"
+      description "Get information about the current Claude session for this agent"
+
+      arguments do
+        # No arguments needed
+      end
+
+      def call
+        executor = ClaudeMcpServer.executor
+
+        {
+          has_session: executor.has_session?,
+          session_id: executor.session_id,
+          working_directory: executor.working_directory,
+        }
+      end
+    end
+  end
+end

data/lib/claude_swarm/tools/task_tool.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  module Tools
+    class TaskTool < FastMcp::Tool
+      tool_name "task"
+      description "Execute a task using Claude Code. There is no description parameter."
+      annotations(read_only_hint: true, open_world_hint: false, destructive_hint: false)
+
+      arguments do
+        required(:prompt).filled(:string).description("The task or question for the agent")
+        optional(:new_session).filled(:bool).description("Start a new session (default: false)")
+        optional(:system_prompt).filled(:string).description("Override the system prompt for this request")
+        optional(:description).filled(:string).description("A description for the request")
+      end
+
+      def call(prompt:, new_session: false, system_prompt: nil, description: nil)
+        executor = ClaudeMcpServer.executor
+        instance_config = ClaudeMcpServer.instance_config
+
+        options = {
+          new_session: new_session,
+          system_prompt: system_prompt || instance_config[:prompt],
+          description: description,
+        }
+
+        # Add allowed tools from instance config
+        options[:allowed_tools] = instance_config[:allowed_tools] if instance_config[:allowed_tools]&.any?
+
+        # Add disallowed tools from instance config
+        options[:disallowed_tools] = instance_config[:disallowed_tools] if instance_config[:disallowed_tools]&.any?
+
+        # Add connections from instance config
+        options[:connections] = instance_config[:connections] if instance_config[:connections]&.any?
+
+        response = executor.execute(prompt, options)
+
+        # Return just the result text as expected by MCP
+        response["result"]
+      end
+    end
+  end
+end

data/lib/claude_swarm/version.rb

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

data/lib/claude_swarm/worktree_manager.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-require "open3"
-require "fileutils"
-require "json"
-require "pathname"
-require "securerandom"
-require "digest"
-
 module ClaudeSwarm
   class WorktreeManager
     include SystemUtils
@@ -17,12 +10,14 @@ module ClaudeSwarm
       @session_id = session_id
       # Generate a name based on session ID if no option given, empty string, or default "worktree" from Thor
       @shared_worktree_name = if cli_worktree_option.nil? || cli_worktree_option.empty? || cli_worktree_option == "worktree"
-                                generate_worktree_name
-                              else
-                                cli_worktree_option
-                              end
+        generate_worktree_name
+      else
+        cli_worktree_option
+      end
       @created_worktrees = {} # Maps "repo_root:worktree_name" to worktree_path
       @instance_worktree_configs = {} # Stores per-instance worktree settings
+      @instance_directories = {} # Stores original resolved directories for each instance
+      @instance_worktree_paths = {} # Stores worktree paths for each instance
     end
 
     def setup_worktrees(instances)
@@ -47,12 +42,23 @@ module ClaudeSwarm
           puts "Debug [WorktreeManager]: Worktree config: #{worktree_config.inspect}"
         end
 
-        next if worktree_config[:skip]
+        # Store original directories (resolved)
+        original_dirs = instance[:directories] || [instance[:directory]]
+        resolved_dirs = original_dirs.map { |dir| dir ? File.expand_path(dir) : nil }.compact
+        @instance_directories[instance[:name]] = resolved_dirs
+
+        if worktree_config[:skip]
+          # No worktree, paths remain the same
+          @instance_worktree_paths[instance[:name]] = resolved_dirs
+          next
+        end
 
         worktree_name = worktree_config[:name]
-        original_dirs = instance[:directories] || [instance[:directory]]
         mapped_dirs = original_dirs.map { |dir| map_to_worktree_path(dir, worktree_name) }
 
+        # Store the worktree paths
+        @instance_worktree_paths[instance[:name]] = mapped_dirs
+
         if ENV["CLAUDE_SWARM_DEBUG"]
           puts "Debug [WorktreeManager]: Original dirs: #{original_dirs.inspect}"
           puts "Debug [WorktreeManager]: Mapped dirs: #{mapped_dirs.inspect}"
@@ -101,10 +107,10 @@ module ClaudeSwarm
 
       # Return the equivalent path in the worktree
       result = if relative_path == "."
-                 worktree_path
-               else
-                 File.join(worktree_path, relative_path)
-               end
+        worktree_path
+      else
+        File.join(worktree_path, relative_path)
+      end
 
       puts "Debug [map_to_worktree_path]: Result: #{result}" if ENV["CLAUDE_SWARM_DEBUG"]
 
@@ -173,11 +179,22 @@ module ClaudeSwarm
     end
 
     def session_metadata
+      # Build instance details with resolved paths and worktree mappings
+      instance_details = {}
+
+      @instance_worktree_configs.each do |instance_name, worktree_config|
+        instance_details[instance_name] = {
+          worktree_config: worktree_config,
+          directories: @instance_directories[instance_name] || {},
+          worktree_paths: @instance_worktree_paths[instance_name] || {},
+        }
+      end
+
       {
         enabled: true,
         shared_name: @shared_worktree_name,
         created_paths: @created_worktrees.dup,
-        instance_configs: @instance_worktree_configs.dup
+        instance_configs: instance_details,
       }
     end
 
@@ -419,17 +436,17 @@ module ClaudeSwarm
     def find_original_repo_for_worktree(worktree_path)
       # Get the git directory for this worktree
       _, git_dir_status = Open3.capture2e("git", "-C", worktree_path, "rev-parse", "--git-dir")
-      return nil unless git_dir_status.success?
+      return unless git_dir_status.success?
 
       # Read the gitdir file to find the main repository
       # Worktree .git files contain: gitdir: /path/to/main/repo/.git/worktrees/worktree-name
       if File.file?(File.join(worktree_path, ".git"))
         gitdir_content = File.read(File.join(worktree_path, ".git")).strip
         if gitdir_content =~ /^gitdir: (.+)$/
-          git_path = $1
+          git_path = ::Regexp.last_match(1)
           # Extract the main repo path from the worktree git path
           # Format: /path/to/repo/.git/worktrees/worktree-name
-          return $1 if git_path =~ %r{^(.+)/\.git/worktrees/[^/]+$}
+          return ::Regexp.last_match(1) if git_path =~ %r{^(.+)/\.git/worktrees/[^/]+$}
         end
       end
 
@@ -438,7 +455,7 @@ module ClaudeSwarm
 
     def find_base_branch(repo_path)
       # Try to find the base branch - check for main, master, or the default branch
-      %w[main master].each do |branch|
+      ["main", "master"].each do |branch|
         _, status = Open3.capture2e("git", "-C", repo_path, "rev-parse", "--verify", "refs/heads/#{branch}")
         return branch if status.success?
       end

data/lib/claude_swarm.rb

@@ -1,24 +1,37 @@
 # frozen_string_literal: true
 
-# External dependencies
-require "time"
-require "thor"
-require "yaml"
-require "json"
-require "fileutils"
+# Standard library dependencies
+require "digest"
+require "English"
 require "erb"
-require "tmpdir"
+require "fileutils"
+require "io/console"
+require "json"
+require "logger"
 require "open3"
-require "timeout"
+require "pathname"
 require "pty"
-require "io/console"
+require "securerandom"
+require "set"
+require "shellwords"
+require "time"
+require "timeout"
+require "tmpdir"
+require "yaml"
+
+# External dependencies
+require "fast_mcp_annotations"
+require "mcp_client"
+require "openai"
+require "thor"
 
 # Zeitwerk setup
 require "zeitwerk"
 loader = Zeitwerk::Loader.for_gem
 loader.ignore("#{__dir__}/claude_swarm/templates")
 loader.inflector.inflect(
-  "cli" => "CLI"
+  "cli" => "CLI",
+  "openai" => "OpenAI",
 )
 loader.setup