claude_swarm 0.1.15 → 0.1.17

data/examples/multi-directory.yml

@@ -0,0 +1,26 @@
+version: 1
+swarm:
+  name: "Multi-Directory Example"
+  main: fullstack_dev
+  instances:
+    fullstack_dev:
+      description: "Full-stack developer with access to multiple project directories"
+      directory: [./frontend, ./backend, ./shared, ./docs]
+      model: opus
+      connections: [frontend_specialist, backend_specialist]
+      allowed_tools: [Read, Edit, Write, Bash, WebSearch]
+      prompt: "You are a full-stack developer with access to frontend, backend, shared code, and documentation directories"
+      
+    frontend_specialist:
+      description: "Frontend developer focused on React components"
+      directory: ./frontend
+      model: sonnet
+      allowed_tools: [Read, Edit, Write, Bash]
+      prompt: "You specialize in React and frontend development"
+      
+    backend_specialist:
+      description: "Backend developer focused on API development"
+      directory: ./backend
+      model: sonnet
+      allowed_tools: [Read, Edit, Write, Bash]
+      prompt: "You specialize in backend API development"

data/lib/claude_swarm/claude_code_executor.rb

@@ -12,8 +12,9 @@ module ClaudeSwarm
 
     def initialize(working_directory: Dir.pwd, model: nil, mcp_config: nil, vibe: false,
                    instance_name: nil, instance_id: nil, calling_instance: nil, calling_instance_id: nil,
-                   claude_session_id: nil)
+                   claude_session_id: nil, additional_directories: [])
       @working_directory = working_directory
+      @additional_directories = additional_directories
       @model = model
       @mcp_config = mcp_config
       @vibe = vibe
@@ -259,6 +260,12 @@ module ClaudeSwarm
 
       cmd_array << "--verbose"
 
+      # Add additional directories with --add-dir
+      cmd_array << "--add-dir" if @additional_directories.any?
+      @additional_directories.each do |additional_dir|
+        cmd_array << additional_dir
+      end
+
       # Add MCP config if specified
       cmd_array += ["--mcp-config", @mcp_config] if @mcp_config
 
@@ -278,10 +285,18 @@ module ClaudeSwarm
       if @vibe
         cmd_array << "--dangerously-skip-permissions"
       else
+        # Build allowed tools list including MCP connections
+        allowed_tools = options[:allowed_tools] ? Array(options[:allowed_tools]).dup : []
+
+        # Add mcp__instance_name for each connection if we have instance info
+        options[:connections]&.each do |connection_name|
+          allowed_tools << "mcp__#{connection_name}"
+        end
+
         # Add allowed tools if any
-        if options[:allowed_tools]
-          tools = Array(options[:allowed_tools]).join(",")
-          cmd_array += ["--allowedTools", tools]
+        if allowed_tools.any?
+          tools_str = allowed_tools.join(",")
+          cmd_array += ["--allowedTools", tools_str]
         end
 
         # Add disallowed tools if any
@@ -289,9 +304,6 @@ module ClaudeSwarm
           disallowed_tools = Array(options[:disallowed_tools]).join(",")
           cmd_array += ["--disallowedTools", disallowed_tools]
         end
-
-        # Add permission prompt tool if not in vibe mode
-        cmd_array += ["--permission-prompt-tool", "mcp__permissions__check_permission"]
       end
 
       cmd_array

data/lib/claude_swarm/claude_mcp_server.rb

@@ -28,7 +28,8 @@ module ClaudeSwarm
         instance_id: instance_config[:instance_id],
         calling_instance: calling_instance,
         calling_instance_id: calling_instance_id,
-        claude_session_id: instance_config[:claude_session_id]
+        claude_session_id: instance_config[:claude_session_id],
+        additional_directories: instance_config[:directories][1..] || []
       )
 
       # Set class variables so tools can access them

data/lib/claude_swarm/cli.rb

@@ -6,7 +6,6 @@ require_relative "configuration"
 require_relative "mcp_generator"
 require_relative "orchestrator"
 require_relative "claude_mcp_server"
-require_relative "permission_mcp_server"
 
 module ClaudeSwarm
   class CLI < Thor
@@ -72,16 +71,20 @@ 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,
                            desc: "System prompt for the instance"
     method_option :description, type: :string,
                                 desc: "Description of the instance's role"
-    method_option :tools, aliases: "-t", type: :array,
-                          desc: "Allowed tools for the instance"
+    method_option :allowed_tools, aliases: "-t", type: :array,
+                                  desc: "Allowed tools for the instance"
     method_option :disallowed_tools, type: :array,
                                      desc: "Disallowed tools for the instance"
+    method_option :connections, type: :array,
+                                desc: "Connections to other instances"
     method_option :mcp_config_path, type: :string,
                                     desc: "Path to MCP configuration file"
     method_option :debug, type: :boolean, default: false,
@@ -100,13 +103,15 @@ module ClaudeSwarm
       instance_config = {
         name: options[:name],
         directory: options[:directory],
+        directories: options[:directories] || [options[:directory]],
         model: options[:model],
         prompt: options[:prompt],
         description: options[:description],
-        tools: options[:tools] || [],
+        allowed_tools: options[:allowed_tools] || [],
         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]
       }
@@ -192,6 +197,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#{cleaned == 1 ? "" : "s"}", :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"
@@ -265,22 +346,6 @@ module ClaudeSwarm
       say "  claude-swarm --session-id <session-id>", :cyan
     end
 
-    desc "tools-mcp", "Start a permission management MCP server for tool access control"
-    method_option :allowed_tools, aliases: "-t", type: :string,
-                                  desc: "Comma-separated list of allowed tool patterns (supports wildcards)"
-    method_option :disallowed_tools, type: :string,
-                                     desc: "Comma-separated list of disallowed tool patterns (supports wildcards)"
-    method_option :debug, type: :boolean, default: false,
-                          desc: "Enable debug output"
-    def tools_mcp
-      server = PermissionMcpServer.new(allowed_tools: options[:allowed_tools], disallowed_tools: options[:disallowed_tools])
-      server.start
-    rescue StandardError => e
-      error "Error starting permission MCP server: #{e.message}"
-      error e.backtrace.join("\n") if options[:debug]
-      exit 1
-    end
-
     default_task :start
 
     private

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

@@ -86,9 +86,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
@@ -156,8 +160,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,6 +174,17 @@ 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

data/lib/claude_swarm/mcp_generator.rb

@@ -68,9 +68,6 @@ module ClaudeSwarm
         )
       end
 
-      # Add permission MCP server if not in vibe mode (global or instance-specific)
-      mcp_servers["permissions"] = build_permission_mcp_config(instance[:tools], instance[:disallowed_tools]) unless @vibe || instance[:vibe]
-
       config = {
         "instance_id" => @instance_ids[name],
         "instance_name" => name,
@@ -110,15 +107,20 @@ 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]
 
       args.push("--description", instance[:description]) if instance[:description]
 
-      args.push("--tools", instance[:tools].join(",")) if instance[:tools] && !instance[:tools].empty?
+      args.push("--allowed-tools", instance[:allowed_tools].join(",")) if instance[:allowed_tools] && !instance[:allowed_tools].empty?
 
       args.push("--disallowed-tools", instance[:disallowed_tools].join(",")) if instance[:disallowed_tools] && !instance[:disallowed_tools].empty?
 
+      args.push("--connections", instance[:connections].join(",")) if instance[:connections] && !instance[:connections].empty?
+
       args.push("--mcp-config-path", mcp_config_path(name))
 
       args.push("--calling-instance", calling_instance) if calling_instance
@@ -162,23 +164,5 @@ module ClaudeSwarm
         # Skip invalid state files
       end
     end
-
-    def build_permission_mcp_config(allowed_tools, disallowed_tools)
-      exe_path = "claude-swarm"
-
-      args = ["tools-mcp"]
-
-      # Add allowed tools if specified
-      args.push("--allowed-tools", allowed_tools.join(",")) if allowed_tools && !allowed_tools.empty?
-
-      # Add disallowed tools if specified
-      args.push("--disallowed-tools", disallowed_tools.join(",")) if disallowed_tools && !disallowed_tools.empty?
-
-      {
-        "type" => "stdio",
-        "command" => exe_path,
-        "args" => args
-      }
-    end
   end
 end