claude_swarm 0.1.0

data/lib/claude_swarm/claude_code_executor.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module ClaudeSwarm
+  class ClaudeCodeExecutor
+    attr_reader :session_id, :last_response, :working_directory
+
+    def initialize(working_directory: Dir.pwd, model: nil, mcp_config: nil, vibe: false)
+      @working_directory = working_directory
+      @model = model
+      @mcp_config = mcp_config
+      @vibe = vibe
+      @session_id = nil
+      @last_response = nil
+    end
+
+    def execute(prompt, options = {})
+      cmd_array = build_command_array(prompt, options)
+
+      stdout, stderr, status = Open3.capture3(*cmd_array, chdir: @working_directory)
+
+      raise ExecutionError, "Claude Code execution failed: #{stderr}" unless status.success?
+
+      begin
+        response = JSON.parse(stdout)
+        @last_response = response
+
+        # Extract and store session ID from the response
+        @session_id = response["session_id"]
+
+        response
+      rescue JSON::ParserError => e
+        raise ParseError, "Failed to parse JSON response: #{e.message}\nOutput: #{stdout}"
+      end
+    end
+
+    def execute_text(prompt, options = {})
+      response = execute(prompt, options)
+      response["result"] || ""
+    end
+
+    def reset_session
+      @session_id = nil
+      @last_response = nil
+    end
+
+    def has_session?
+      !@session_id.nil?
+    end
+
+    private
+
+    def build_command_array(prompt, options)
+      cmd_array = ["claude"]
+
+      # Add model if specified
+      cmd_array += ["--model", @model]
+
+      # Add MCP config if specified
+      cmd_array += ["--mcp-config", @mcp_config] if @mcp_config
+
+      # Resume session if we have a session ID
+      cmd_array += ["--resume", @session_id] if @session_id && !options[:new_session]
+
+      # Always use JSON output format for structured responses
+      cmd_array += ["--output-format", "json"]
+
+      # Add non-interactive mode
+      cmd_array << "--print"
+
+      # Add any custom system prompt
+      cmd_array += ["--system-prompt", options[:system_prompt]] if options[:system_prompt]
+
+      # Add any allowed tools or vibe flag
+      if @vibe
+        cmd_array << "--dangerously-skip-permissions"
+      elsif options[:allowed_tools]
+        tools = Array(options[:allowed_tools]).join(",")
+        cmd_array += ["--allowedTools", tools]
+      end
+
+      # Add the prompt as the last argument (no escaping needed with array syntax)
+      cmd_array << prompt
+
+      cmd_array
+    end
+
+    class ExecutionError < StandardError; end
+    class ParseError < StandardError; end
+  end
+end

data/lib/claude_swarm/claude_mcp_server.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "fast_mcp"
+require "json"
+require "fileutils"
+require "logger"
+require_relative "claude_code_executor"
+
+module ClaudeSwarm
+  class ClaudeMcpServer
+    SWARM_DIR = ".claude-swarm"
+    LOGS_DIR = "logs"
+
+    # Class variables to share state with tool classes
+    class << self
+      attr_accessor :executor, :instance_config, :logger, :session_timestamp
+    end
+
+    def initialize(instance_config)
+      @instance_config = instance_config
+      @executor = ClaudeCodeExecutor.new(
+        working_directory: instance_config[:directory],
+        model: instance_config[:model],
+        mcp_config: instance_config[:mcp_config_path],
+        vibe: instance_config[:vibe]
+      )
+
+      # Setup logging
+      setup_logging
+
+      # Set class variables so tools can access them
+      self.class.executor = @executor
+      self.class.instance_config = @instance_config
+      self.class.logger = @logger
+    end
+
+    private
+
+    def setup_logging
+      # Use environment variable for session timestamp if available (set by orchestrator)
+      # Otherwise create a new timestamp
+      self.class.session_timestamp ||= ENV["CLAUDE_SWARM_SESSION_TIMESTAMP"] || Time.now.strftime("%Y%m%d_%H%M%S")
+
+      # Ensure the logs directory exists
+      logs_dir = File.join(Dir.pwd, SWARM_DIR, LOGS_DIR)
+      FileUtils.mkdir_p(logs_dir)
+
+      # Create logger with timestamped filename
+      log_filename = "session_#{self.class.session_timestamp}.log"
+      log_path = File.join(logs_dir, log_filename)
+      @logger = Logger.new(log_path)
+      @logger.level = Logger::INFO
+
+      # Custom formatter for better readability
+      @logger.formatter = proc do |severity, datetime, _progname, msg|
+        "[#{datetime.strftime("%Y-%m-%d %H:%M:%S.%L")}] [#{severity}] #{msg}\n"
+      end
+
+      @logger.info("Started MCP server for instance: #{@instance_config[:name]}")
+    end
+
+    public
+
+    def start
+      server = FastMcp::Server.new(
+        name: @instance_config[:name],
+        version: "1.0.0"
+      )
+
+      # Register tool classes (not instances)
+      server.register_tool(TaskTool)
+      server.register_tool(SessionInfoTool)
+      server.register_tool(ResetSessionTool)
+
+      # Start the stdio server
+      server.start
+    end
+
+    class TaskTool < FastMcp::Tool
+      tool_name "task"
+      description "Execute a task using Claude Code"
+
+      arguments do
+        required(:prompt).filled(:string).description("The task or question for Claude")
+        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")
+      end
+
+      def call(prompt:, new_session: false, system_prompt: nil)
+        executor = ClaudeMcpServer.executor
+        instance_config = ClaudeMcpServer.instance_config
+        logger = ClaudeMcpServer.logger
+
+        options = {
+          new_session: new_session,
+          system_prompt: system_prompt || instance_config[:prompt]
+        }
+
+        # Add allowed tools from instance config
+        options[:allowed_tools] = instance_config[:tools] if instance_config[:tools]&.any?
+
+        begin
+          # Log the request
+          log_entry = {
+            timestamp: Time.now.utc.iso8601,
+            instance_name: instance_config[:name],
+            model: instance_config[:model],
+            working_directory: instance_config[:directory],
+            session_id: executor.session_id,
+            request: {
+              prompt: prompt,
+              new_session: new_session,
+              system_prompt: options[:system_prompt],
+              allowed_tools: options[:allowed_tools]
+            }
+          }
+
+          logger.info("REQUEST: #{JSON.pretty_generate(log_entry)}")
+
+          response = executor.execute(prompt, options)
+
+          # Log the response
+          response_entry = log_entry.merge(
+            session_id: executor.session_id, # Update with new session ID if changed
+            response: {
+              result: response["result"],
+              cost_usd: response["cost_usd"],
+              duration_ms: response["duration_ms"],
+              is_error: response["is_error"],
+              total_cost: response["total_cost"]
+            }
+          )
+
+          logger.info("RESPONSE: #{JSON.pretty_generate(response_entry)}")
+
+          # Return just the result text as expected by MCP
+          response["result"]
+        rescue ClaudeCodeExecutor::ExecutionError => e
+          logger.error("Execution error for #{instance_config[:name]}: #{e.message}")
+          raise StandardError, "Execution failed: #{e.message}"
+        rescue ClaudeCodeExecutor::ParseError => e
+          logger.error("Parse error for #{instance_config[:name]}: #{e.message}")
+          raise StandardError, "Parse error: #{e.message}"
+        rescue StandardError => e
+          logger.error("Unexpected error for #{instance_config[:name]}: #{e.class} - #{e.message}")
+          logger.error("Backtrace: #{e.backtrace.join("\n")}")
+          raise StandardError, "Unexpected error: #{e.message}"
+        end
+      end
+    end
+
+    class SessionInfoTool < FastMcp::Tool
+      tool_name "session_info"
+      description "Get information about the current Claude session"
+
+      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
+
+    class ResetSessionTool < FastMcp::Tool
+      tool_name "reset_session"
+      description "Reset the Claude session, 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/cli.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "configuration"
+require_relative "mcp_generator"
+require_relative "orchestrator"
+require_relative "claude_mcp_server"
+
+module ClaudeSwarm
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "start [CONFIG_FILE]", "Start a Claude Swarm from configuration file"
+    method_option :config, aliases: "-c", type: :string, default: "claude-swarm.yml",
+                           desc: "Path to configuration file"
+    method_option :vibe, type: :boolean, default: false,
+                         desc: "Run with --dangerously-skip-permissions for all instances"
+    def start(config_file = nil)
+      config_path = config_file || options[:config]
+      unless File.exist?(config_path)
+        error "Configuration file not found: #{config_path}"
+        exit 1
+      end
+
+      say "Starting Claude Swarm from #{config_path}..."
+      begin
+        config = Configuration.new(config_path)
+        generator = McpGenerator.new(config, vibe: options[:vibe])
+        orchestrator = Orchestrator.new(config, generator, vibe: options[:vibe])
+        orchestrator.start
+      rescue Error => e
+        error e.message
+        exit 1
+      rescue StandardError => e
+        error "Unexpected error: #{e.message}"
+        error e.backtrace.join("\n") if options[:verbose]
+        exit 1
+      end
+    end
+
+    desc "mcp-serve", "Start an MCP server for a Claude instance"
+    method_option :name, aliases: "-n", type: :string, required: true,
+                         desc: "Instance name"
+    method_option :directory, aliases: "-d", type: :string, required: true,
+                              desc: "Working 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 :tools, aliases: "-t", type: :array,
+                          desc: "Allowed tools for the instance"
+    method_option :mcp_config_path, type: :string,
+                                    desc: "Path to MCP configuration file"
+    method_option :debug, type: :boolean, default: false,
+                          desc: "Enable debug output"
+    method_option :vibe, type: :boolean, default: false,
+                         desc: "Run with --dangerously-skip-permissions"
+    def mcp_serve
+      instance_config = {
+        name: options[:name],
+        directory: options[:directory],
+        model: options[:model],
+        prompt: options[:prompt],
+        tools: options[:tools] || [],
+        mcp_config_path: options[:mcp_config_path],
+        vibe: options[:vibe]
+      }
+
+      begin
+        server = ClaudeMcpServer.new(instance_config)
+        server.start
+      rescue StandardError => e
+        error "Error starting MCP server: #{e.message}"
+        error e.backtrace.join("\n") if options[:debug]
+        exit 1
+      end
+    end
+
+    desc "version", "Show Claude Swarm version"
+    def version
+      say "Claude Swarm #{VERSION}"
+    end
+
+    default_task :start
+
+    private
+
+    def error(message)
+      say message, :red
+    end
+  end
+end

data/lib/claude_swarm/configuration.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "pathname"
+
+module ClaudeSwarm
+  class Configuration
+    attr_reader :config, :swarm_name, :main_instance, :instances
+
+    def initialize(config_path)
+      @config_path = Pathname.new(config_path).expand_path
+      @config_dir = @config_path.dirname
+      load_and_validate
+    end
+
+    def main_instance_config
+      instances[main_instance]
+    end
+
+    def instance_names
+      instances.keys
+    end
+
+    def connections_for(instance_name)
+      instances[instance_name][:connections] || []
+    end
+
+    private
+
+    def load_and_validate
+      @config = YAML.load_file(@config_path)
+      validate_version
+      validate_swarm
+      parse_swarm
+      validate_directories
+    rescue Errno::ENOENT
+      raise Error, "Configuration file not found: #{@config_path}"
+    rescue Psych::SyntaxError => e
+      raise Error, "Invalid YAML syntax: #{e.message}"
+    end
+
+    def validate_version
+      version = @config["version"]
+      raise Error, "Missing 'version' field in configuration" unless version
+      raise Error, "Unsupported version: #{version}. Only version 1 is supported" unless version == 1
+    end
+
+    def validate_swarm
+      raise Error, "Missing 'swarm' field in configuration" unless @config["swarm"]
+
+      swarm = @config["swarm"]
+      raise Error, "Missing 'name' field in swarm configuration" unless swarm["name"]
+      raise Error, "Missing 'instances' field in swarm configuration" unless swarm["instances"]
+      raise Error, "Missing 'main' field in swarm configuration" unless swarm["main"]
+
+      raise Error, "No instances defined" if swarm["instances"].empty?
+
+      main = swarm["main"]
+      raise Error, "Main instance '#{main}' not found in instances" unless swarm["instances"].key?(main)
+    end
+
+    def parse_swarm
+      swarm = @config["swarm"]
+      @swarm_name = swarm["name"]
+      @main_instance = swarm["main"]
+      @instances = {}
+      swarm["instances"].each do |name, config|
+        @instances[name] = parse_instance(name, config)
+      end
+      validate_connections
+    end
+
+    def parse_instance(name, config)
+      config ||= {}
+      {
+        name: name,
+        role: config["role"] || name.to_s.tr("_", " ").capitalize,
+        directory: expand_path(config["directory"] || "."),
+        model: config["model"] || "sonnet",
+        connections: Array(config["connections"]),
+        tools: Array(config["tools"]),
+        mcps: parse_mcps(config["mcps"] || []),
+        prompt: config["prompt"]
+      }
+    end
+
+    def parse_mcps(mcps)
+      mcps.map do |mcp|
+        validate_mcp(mcp)
+        mcp
+      end
+    end
+
+    def validate_mcp(mcp)
+      raise Error, "MCP configuration missing 'name'" unless mcp["name"]
+
+      case mcp["type"]
+      when "stdio"
+        raise Error, "MCP '#{mcp["name"]}' missing 'command'" unless mcp["command"]
+      when "sse"
+        raise Error, "MCP '#{mcp["name"]}' missing 'url'" unless mcp["url"]
+      else
+        raise Error, "Unknown MCP type '#{mcp["type"]}' for '#{mcp["name"]}'"
+      end
+    end
+
+    def validate_connections
+      @instances.each do |name, instance|
+        instance[:connections].each do |connection|
+          raise Error, "Instance '#{name}' has connection to unknown instance '#{connection}'" unless @instances.key?(connection)
+        end
+      end
+    end
+
+    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)
+      end
+    end
+
+    def expand_path(path)
+      Pathname.new(path).expand_path(@config_dir).to_s
+    end
+  end
+end

data/lib/claude_swarm/mcp_generator.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "shellwords"
+
+module ClaudeSwarm
+  class McpGenerator
+    SWARM_DIR = ".claude-swarm"
+
+    def initialize(configuration, vibe: false)
+      @config = configuration
+      @vibe = vibe
+    end
+
+    def generate_all
+      ensure_swarm_directory
+
+      @config.instances.each do |name, instance|
+        generate_mcp_config(name, instance)
+      end
+    end
+
+    def mcp_config_path(instance_name)
+      File.join(Dir.pwd, SWARM_DIR, "#{instance_name}.mcp.json")
+    end
+
+    private
+
+    def swarm_dir
+      File.join(Dir.pwd, SWARM_DIR)
+    end
+
+    def ensure_swarm_directory
+      FileUtils.mkdir_p(swarm_dir)
+
+      # Create logs directory as well
+      logs_dir = File.join(swarm_dir, "logs")
+      FileUtils.mkdir_p(logs_dir)
+
+      gitignore_path = File.join(swarm_dir, ".gitignore")
+      File.write(gitignore_path, "*\n") unless File.exist?(gitignore_path)
+    end
+
+    def generate_mcp_config(name, instance)
+      mcp_servers = {}
+
+      # Add configured MCP servers
+      instance[:mcps].each do |mcp|
+        mcp_servers[mcp["name"]] = build_mcp_server_config(mcp)
+      end
+
+      # Add connection MCPs for other instances
+      instance[:connections].each do |connection_name|
+        connected_instance = @config.instances[connection_name]
+        mcp_servers[connection_name] = build_instance_mcp_config(connection_name, connected_instance)
+      end
+
+      config = {
+        "mcpServers" => mcp_servers
+      }
+
+      File.write(mcp_config_path(name), JSON.pretty_generate(config))
+    end
+
+    def build_mcp_server_config(mcp)
+      case mcp["type"]
+      when "stdio"
+        {
+          "type" => "stdio",
+          "command" => mcp["command"],
+          "args" => mcp["args"] || []
+        }.tap do |config|
+          config["env"] = mcp["env"] if mcp["env"]
+        end
+      when "sse"
+        {
+          "type" => "sse",
+          "url" => mcp["url"]
+        }
+      end
+    end
+
+    def build_instance_mcp_config(name, instance)
+      # Get the path to the claude-swarm executable
+      exe_path = "claude-swarm"
+
+      # Build command-line arguments for Thor
+      args = [
+        "mcp-serve",
+        "--name", name,
+        "--directory", instance[:directory],
+        "--model", instance[:model]
+      ]
+
+      # Add optional arguments
+      args.push("--prompt", instance[:prompt]) if instance[:prompt]
+
+      args.push("--tools", instance[:tools].join(",")) if instance[:tools] && !instance[:tools].empty?
+
+      args.push("--mcp-config-path", mcp_config_path(name))
+
+      args.push("--vibe") if @vibe
+
+      {
+        "type" => "stdio",
+        "command" => exe_path,
+        "args" => args
+      }
+    end
+  end
+end

data/lib/claude_swarm/orchestrator.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module ClaudeSwarm
+  class Orchestrator
+    def initialize(configuration, mcp_generator, vibe: false)
+      @config = configuration
+      @generator = mcp_generator
+      @vibe = vibe
+    end
+
+    def start
+      puts "🐝 Starting Claude Swarm: #{@config.swarm_name}"
+      puts "😎 Vibe mode ON" if @vibe
+      puts
+
+      # Set session timestamp for all instances to share the same log file
+      session_timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+      ENV["CLAUDE_SWARM_SESSION_TIMESTAMP"] = session_timestamp
+      puts "📝 Session logs will be saved to: .claude-swarm/logs/session_#{session_timestamp}.log"
+      puts
+
+      # Generate all MCP configuration files
+      @generator.generate_all
+      puts "✓ Generated MCP configurations in .claude-swarm/"
+      puts
+
+      # Launch the main instance
+      main_instance = @config.main_instance_config
+      puts "🚀 Launching main instance: #{@config.main_instance} (#{main_instance[:role]})"
+      puts "   Model: #{main_instance[:model]}"
+      puts "   Directory: #{main_instance[:directory]}"
+      puts "   Tools: #{main_instance[:tools].join(", ")}" if main_instance[:tools].any?
+      puts "   Connections: #{main_instance[:connections].join(", ")}" if main_instance[:connections].any?
+      puts
+
+      command = build_main_command(main_instance)
+      if ENV["DEBUG"]
+        puts "Running: #{command}"
+        puts
+      end
+
+      # Execute the main instance - this will cascade to other instances via MCP
+      exec(command)
+    end
+
+    private
+
+    def build_main_command(instance)
+      parts = []
+      parts << "cd #{Shellwords.escape(instance[:directory])} &&"
+      parts << "claude"
+      parts << "--model #{instance[:model]}"
+
+      if @vibe
+        parts << "--dangerously-skip-permissions"
+      elsif instance[:tools].any?
+        tools_str = instance[:tools].join(",")
+        parts << "--allowedTools '#{tools_str}'"
+      end
+
+      parts << "--append-system-prompt #{Shellwords.escape(instance[:prompt])}" if instance[:prompt]
+
+      mcp_config_path = @generator.mcp_config_path(@config.main_instance)
+      parts << "--mcp-config #{mcp_config_path}"
+
+      parts.join(" ")
+    end
+  end
+end

data/lib/claude_swarm/version.rb

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

data/lib/claude_swarm.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "claude_swarm/version"
+require_relative "claude_swarm/cli"
+require_relative "claude_swarm/claude_code_executor"
+require_relative "claude_swarm/claude_mcp_server"
+
+module ClaudeSwarm
+  class Error < StandardError; end
+end