claude_swarm 0.1.16 → 0.1.18

data/lib/claude_swarm/cli.rb

@@ -26,6 +26,9 @@ module ClaudeSwarm
                           desc: "Enable debug output"
     method_option :session_id, type: :string,
                                desc: "Resume a previous session by ID or path"
+    method_option :worktree, type: :string, aliases: "-w",
+                             desc: "Create instances in Git worktrees with the given name (auto-generated if true)",
+                             banner: "[NAME]"
     def start(config_file = nil)
       # Handle session restoration
       if options[:session_id]
@@ -54,7 +57,8 @@ module ClaudeSwarm
                                         vibe: options[:vibe],
                                         prompt: options[:prompt],
                                         stream_logs: options[:stream_logs],
-                                        debug: options[:debug])
+                                        debug: options[:debug],
+                                        worktree: options[:worktree])
         orchestrator.start
       rescue Error => e
         error e.message
@@ -71,6 +75,8 @@ module ClaudeSwarm
                          desc: "Instance name"
     method_option :directory, aliases: "-d", type: :string, required: true,
                               desc: "Working directory for the instance"
+    method_option :directories, type: :array,
+                                desc: "All directories (including main directory) for the instance"
     method_option :model, aliases: "-m", type: :string, required: true,
                           desc: "Claude model to use (e.g., opus, sonnet)"
     method_option :prompt, aliases: "-p", type: :string,
@@ -101,6 +107,7 @@ module ClaudeSwarm
       instance_config = {
         name: options[:name],
         directory: options[:directory],
+        directories: options[:directories] || [options[:directory]],
         model: options[:model],
         prompt: options[:prompt],
         description: options[:description],
@@ -108,7 +115,7 @@ module ClaudeSwarm
         disallowed_tools: options[:disallowed_tools] || [],
         connections: options[:connections] || [],
         mcp_config_path: options[:mcp_config_path],
-        vibe: options[:vibe],
+        vibe: options[:vibe] || false,
         instance_id: options[:instance_id],
         claude_session_id: options[:claude_session_id]
       }
@@ -144,6 +151,10 @@ module ClaudeSwarm
         swarm:
           name: "Swarm Name"
           main: lead_developer
+          # before:  # Optional: commands to run before launching swarm (executed in sequence)
+          #   - "echo 'Setting up environment...'"
+          #   - "npm install"
+          #   - "docker-compose up -d"
           instances:
             lead_developer:
               description: "Lead developer who coordinates the team and makes architectural decisions"
@@ -194,6 +205,82 @@ module ClaudeSwarm
       say "Claude Swarm #{VERSION}"
     end
 
+    desc "ps", "List running Claude Swarm sessions"
+    def ps
+      require_relative "commands/ps"
+      Commands::Ps.new.execute
+    end
+
+    desc "show SESSION_ID", "Show detailed session information"
+    def show(session_id)
+      require_relative "commands/show"
+      Commands::Show.new.execute(session_id)
+    end
+
+    desc "clean", "Remove stale session symlinks"
+    method_option :days, aliases: "-d", type: :numeric, default: 7,
+                         desc: "Remove sessions older than N days"
+    def clean
+      run_dir = File.expand_path("~/.claude-swarm/run")
+      unless Dir.exist?(run_dir)
+        say "No run directory found", :yellow
+        return
+      end
+
+      cleaned = 0
+      Dir.glob("#{run_dir}/*").each do |symlink|
+        next unless File.symlink?(symlink)
+
+        begin
+          # Remove if target doesn't exist (stale)
+          unless File.exist?(File.readlink(symlink))
+            File.unlink(symlink)
+            cleaned += 1
+            next
+          end
+
+          # Remove if older than specified days
+          if File.stat(symlink).mtime < Time.now - (options[:days] * 86_400)
+            File.unlink(symlink)
+            cleaned += 1
+          end
+        rescue StandardError
+          # Skip problematic symlinks
+        end
+      end
+
+      say "Cleaned #{cleaned} stale session#{"s" unless cleaned == 1}", :green
+    end
+
+    desc "watch SESSION_ID", "Watch session logs"
+    method_option :lines, aliases: "-n", type: :numeric, default: 100,
+                          desc: "Number of lines to show initially"
+    def watch(session_id)
+      # Find session path
+      run_symlink = File.join(File.expand_path("~/.claude-swarm/run"), session_id)
+      session_path = if File.symlink?(run_symlink)
+                       File.readlink(run_symlink)
+                     else
+                       # Search in sessions directory
+                       Dir.glob(File.expand_path("~/.claude-swarm/sessions/*/*")).find do |path|
+                         File.basename(path) == session_id
+                       end
+                     end
+
+      unless session_path && Dir.exist?(session_path)
+        error "Session not found: #{session_id}"
+        exit 1
+      end
+
+      log_file = File.join(session_path, "session.log")
+      unless File.exist?(log_file)
+        error "Log file not found for session: #{session_id}"
+        exit 1
+      end
+
+      exec("tail", "-f", "-n", options[:lines].to_s, log_file)
+    end
+
     desc "list-sessions", "List all available Claude Swarm sessions"
     method_option :limit, aliases: "-l", type: :numeric, default: 10,
                           desc: "Maximum number of sessions to display"
@@ -316,6 +403,17 @@ module ClaudeSwarm
 
         config = Configuration.new(config_file, base_dir: Dir.pwd)
 
+        # Load session metadata if it exists to check for worktree info
+        session_metadata_file = File.join(session_path, "session_metadata.json")
+        worktree_name = nil
+        if File.exist?(session_metadata_file)
+          metadata = JSON.parse(File.read(session_metadata_file))
+          if metadata["worktree"] && metadata["worktree"]["enabled"]
+            worktree_name = metadata["worktree"]["name"]
+            say "Restoring with worktree: #{worktree_name}", :green unless options[:prompt]
+          end
+        end
+
         # Create orchestrator with restoration mode
         generator = McpGenerator.new(config, vibe: options[:vibe], restore_session_path: session_path)
         orchestrator = Orchestrator.new(config, generator,
@@ -323,7 +421,8 @@ module ClaudeSwarm
                                         prompt: options[:prompt],
                                         stream_logs: options[:stream_logs],
                                         debug: options[:debug],
-                                        restore_session_path: session_path)
+                                        restore_session_path: session_path,
+                                        worktree: worktree_name)
         orchestrator.start
       rescue StandardError => e
         error "Failed to restore session: #{e.message}"

data/lib/claude_swarm/commands/ps.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "json"
+require "time"
+
+module ClaudeSwarm
+  module Commands
+    class Ps
+      RUN_DIR = File.expand_path("~/.claude-swarm/run")
+
+      def execute
+        unless Dir.exist?(RUN_DIR)
+          puts "No active sessions"
+          return
+        end
+
+        sessions = []
+
+        # Read all symlinks in run directory
+        Dir.glob("#{RUN_DIR}/*").each do |symlink|
+          next unless File.symlink?(symlink)
+
+          begin
+            session_dir = File.readlink(symlink)
+            # Skip if target doesn't exist (stale symlink)
+            next unless Dir.exist?(session_dir)
+
+            session_info = parse_session_info(session_dir)
+            sessions << session_info if session_info
+          rescue StandardError
+            # Skip problematic symlinks
+          end
+        end
+
+        if sessions.empty?
+          puts "No active sessions"
+          return
+        end
+
+        # Column widths
+        col_session = 15
+        col_swarm = 25
+        col_cost = 12
+        col_uptime = 10
+
+        # Display header with proper spacing
+        header = "#{
+          "SESSION_ID".ljust(col_session)
+        }  #{
+          "SWARM_NAME".ljust(col_swarm)
+        }  #{
+          "TOTAL_COST".ljust(col_cost)
+        }  #{
+          "UPTIME".ljust(col_uptime)
+        }  DIRECTORY"
+        puts "\n⚠️  \e[3mTotal cost does not include the cost of the main instance\e[0m\n\n"
+        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])
+          puts "#{
+            session[:id].ljust(col_session)
+          }  #{
+            truncate(session[:name], col_swarm).ljust(col_swarm)
+          }  #{
+            cost_str.ljust(col_cost)
+          }  #{
+            session[:uptime].ljust(col_uptime)
+          }  #{session[:directory]}"
+        end
+      end
+
+      private
+
+      def parse_session_info(session_dir)
+        session_id = File.basename(session_dir)
+
+        # Load config for swarm name and main directory
+        config_file = File.join(session_dir, "config.yml")
+        return nil unless File.exist?(config_file)
+
+        config = YAML.load_file(config_file)
+        swarm_name = config.dig("swarm", "name") || "Unknown"
+        main_instance = config.dig("swarm", "main")
+
+        # 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
+        directories_str = directories.join(", ")
+
+        # Calculate total cost from JSON log
+        total_cost = calculate_total_cost(session_dir)
+
+        # Get uptime from directory creation time
+        start_time = File.stat(session_dir).ctime
+        uptime = format_duration(Time.now - start_time)
+
+        {
+          id: session_id,
+          name: swarm_name,
+          cost: total_cost,
+          uptime: uptime,
+          directory: directories_str,
+          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
+        end
+        total
+      end
+
+      def format_duration(seconds)
+        if seconds < 60
+          "#{seconds.to_i}s"
+        elsif seconds < 3600
+          "#{(seconds / 60).to_i}m"
+        elsif seconds < 86_400
+          "#{(seconds / 3600).to_i}h"
+        else
+          "#{(seconds / 86_400).to_i}d"
+        end
+      end
+
+      def truncate(str, length)
+        str.length > length ? "#{str[0...length - 2]}.." : str
+      end
+    end
+  end
+end

data/lib/claude_swarm/commands/show.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "json"
+
+module ClaudeSwarm
+  module Commands
+    class Show
+      def execute(session_id)
+        session_path = find_session_path(session_id)
+        unless session_path
+          puts "Session not found: #{session_id}"
+          exit 1
+        end
+
+        # Load config to get main instance name
+        config = YAML.load_file(File.join(session_path, "config.yml"))
+        main_instance_name = config.dig("swarm", "main")
+
+        # Parse all events to build instance data
+        instances = parse_instance_hierarchy(session_path, main_instance_name)
+
+        # 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
+
+        # Display session info
+        puts "Session: #{session_id}"
+        puts "Swarm: #{config.dig("swarm", "name")}"
+        puts "Total Cost: #{cost_display}"
+
+        # Try to read start directory
+        start_dir_file = File.join(session_path, "start_directory")
+        puts "Start Directory: #{File.read(start_dir_file).strip}" if File.exist?(start_dir_file)
+
+        puts
+        puts "Instance Hierarchy:"
+        puts "-" * 50
+
+        # Find root instances
+        roots = instances.values.select { |i| i[:called_by].empty? }
+        roots.each do |instance|
+          display_instance_tree(instance, instances, 0, main_instance_name)
+        end
+
+        # Add note about interactive main instance
+        return if instances[main_instance_name]&.dig(:has_cost_data)
+
+        puts
+        puts "Note: Main instance (#{main_instance_name}) cost is not tracked in interactive mode."
+        puts "      View costs directly in the Claude interface."
+      end
+
+      private
+
+      def find_session_path(session_id)
+        # First check the run directory
+        run_symlink = File.join(File.expand_path("~/.claude-swarm/run"), session_id)
+        if File.symlink?(run_symlink)
+          target = File.readlink(run_symlink)
+          return target if Dir.exist?(target)
+        end
+
+        # Fall back to searching all sessions
+        Dir.glob(File.expand_path("~/.claude-swarm/sessions/*/*")).find do |path|
+          File.basename(path) == session_id
+        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
+        end
+
+        instances
+      end
+
+      def display_instance_tree(instance, all_instances, level, main_instance_name)
+        indent = "  " * level
+        prefix = level.zero? ? "├─" : "└─"
+
+        # Display instance name with special marker for main
+        instance_display = instance[:name]
+        instance_display += " [main]" if instance[:name] == main_instance_name
+
+        puts "#{indent}#{prefix} #{instance_display} (#{instance[:id]})"
+
+        # 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
+
+        puts "#{indent}   Cost: #{cost_display} | Calls: #{instance[:calls]}"
+
+        # Display children
+        children = instance[:calls_to].map { |name| all_instances[name] }.compact
+        children.each do |child|
+          # Don't recurse if we've already shown this instance (avoid cycles)
+          next if level.positive? && child[:called_by].size > 1
+
+          display_instance_tree(child, all_instances, level + 1, main_instance_name)
+        end
+      end
+    end
+  end
+end

data/lib/claude_swarm/configuration.rb

@@ -26,6 +26,10 @@ module ClaudeSwarm
       instances[instance_name][:connections] || []
     end
 
+    def before_commands
+      @swarm["before"] || []
+    end
+
     private
 
     def load_and_validate
@@ -86,9 +90,13 @@ module ClaudeSwarm
       # Support both 'tools' (deprecated) and 'allowed_tools' for backward compatibility
       allowed_tools = config["allowed_tools"] || config["tools"] || []
 
+      # Parse directory field - support both string and array
+      directories = parse_directories(config["directory"])
+
       {
         name: name,
-        directory: expand_path(config["directory"] || "."),
+        directory: directories.first, # Keep single directory for backward compatibility
+        directories: directories, # New field with all directories
         model: config["model"] || "sonnet",
         connections: Array(config["connections"]),
         tools: Array(allowed_tools), # Keep as 'tools' internally for compatibility
@@ -97,7 +105,8 @@ module ClaudeSwarm
         mcps: parse_mcps(config["mcps"] || []),
         prompt: config["prompt"],
         description: config["description"],
-        vibe: config["vibe"] || false
+        vibe: config["vibe"] || false,
+        worktree: parse_worktree_value(config["worktree"])
       }
     end
 
@@ -156,8 +165,10 @@ module ClaudeSwarm
 
     def validate_directories
       @instances.each do |name, instance|
-        directory = instance[:directory]
-        raise Error, "Directory '#{directory}' for instance '#{name}' does not exist" unless File.directory?(directory)
+        # 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
 
@@ -168,8 +179,27 @@ module ClaudeSwarm
       raise Error, "Instance '#{instance_name}' field '#{field_name}' must be an array, got #{field_value.class.name}" unless field_value.is_a?(Array)
     end
 
+    def parse_directories(directory_config)
+      # Default to current directory if not specified
+      directory_config ||= "."
+
+      # Convert to array and expand paths
+      directories = Array(directory_config).map { |dir| expand_path(dir) }
+
+      # Ensure at least one directory
+      directories.empty? ? [expand_path(".")] : directories
+    end
+
     def expand_path(path)
       Pathname.new(path).expand_path(@base_dir).to_s
     end
+
+    def parse_worktree_value(value)
+      return nil 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
   end
 end

data/lib/claude_swarm/mcp_generator.rb

@@ -107,6 +107,9 @@ module ClaudeSwarm
         "--model", instance[:model]
       ]
 
+      # Add directories array if we have multiple directories
+      args.push("--directories", *instance[:directories]) if instance[:directories] && instance[:directories].size > 1
+
       # Add optional arguments
       args.push("--prompt", instance[:prompt]) if instance[:prompt]