claude_swarm 1.0.0 → 1.0.2

data/lib/swarm_cli/ui/state/depth_tracker.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module State
+      # Tracks agent depth for hierarchical indentation display
+      class DepthTracker
+        def initialize
+          @depths = {}
+          @seen_agents = []
+        end
+
+        # Get indentation depth for agent
+        def get(agent_name)
+          @depths[agent_name] ||= calculate_depth(agent_name)
+        end
+
+        # Get indent string for agent
+        def indent(agent_name, char: "  ")
+          char * get(agent_name)
+        end
+
+        # Reset tracker (for testing)
+        def reset
+          @depths.clear
+          @seen_agents.clear
+        end
+
+        private
+
+        def calculate_depth(agent_name)
+          @seen_agents << agent_name unless @seen_agents.include?(agent_name)
+
+          # First agent is depth 0, all others are depth 1
+          @seen_agents.size == 1 ? 0 : 1
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/ui/state/spinner_manager.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module State
+      # Manages active spinners with elapsed time display
+      class SpinnerManager
+        def initialize
+          @active_spinners = {}
+          @time_updaters = {}
+        end
+
+        # Start a spinner with elapsed time tracking
+        #
+        # @param key [Symbol, String] Unique key for this spinner
+        # @param message [String] Spinner message
+        # @param format [Symbol] Spinner format (:dots, :pulse, etc.)
+        # @return [TTY::Spinner] The spinner instance
+        def start(key, message, format: :dots)
+          # Stop any existing spinner with this key
+          stop(key) if @active_spinners[key]
+
+          # Create spinner with elapsed time token
+          spinner = TTY::Spinner.new(
+            "[:spinner] #{message} (:elapsed)",
+            format: format,
+            hide_cursor: true,
+          )
+
+          spinner.auto_spin
+
+          # Spawn thread to update elapsed time every 1 second
+          # This is 10x slower than spinner animation (100ms), preventing flicker
+          @time_updaters[key] = Thread.new do
+            loop do
+              elapsed = spinner.duration
+              break unless elapsed
+
+              formatted_time = format_duration(elapsed)
+              spinner.update(elapsed: formatted_time)
+              sleep(1.0) # 1s refresh rate - smooth without flicker
+            rescue StandardError
+              break
+            end
+          end
+
+          @active_spinners[key] = spinner
+          spinner
+        end
+
+        # Stop spinner with success
+        #
+        # @param key [Symbol, String] Spinner key
+        # @param message [String] Success message
+        def success(key, message = "completed")
+          spinner = @active_spinners[key]
+          return unless spinner
+
+          # Kill time updater
+          kill_updater(key)
+
+          # Show final time
+          final_time = format_duration(spinner.duration || 0)
+          spinner.success("#{message} (#{final_time})")
+
+          cleanup(key)
+        end
+
+        # Stop spinner with error
+        #
+        # @param key [Symbol, String] Spinner key
+        # @param message [String] Error message
+        def error(key, message = "failed")
+          spinner = @active_spinners[key]
+          return unless spinner
+
+          # Kill time updater
+          kill_updater(key)
+
+          # Show final time
+          final_time = format_duration(spinner.duration || 0)
+          spinner.error("#{message} (#{final_time})")
+
+          cleanup(key)
+        end
+
+        # Stop spinner without success/error (just stop)
+        #
+        # @param key [Symbol, String] Spinner key
+        def stop(key)
+          spinner = @active_spinners[key]
+          return unless spinner
+
+          kill_updater(key)
+          spinner.stop
+          cleanup(key)
+        end
+
+        # Stop all active spinners
+        def stop_all
+          @active_spinners.keys.each { |key| stop(key) }
+        end
+
+        # Check if a spinner is active
+        #
+        # @param key [Symbol, String] Spinner key
+        # @return [Boolean]
+        def active?(key)
+          @active_spinners.key?(key)
+        end
+
+        # Pause all active spinners (for interactive debugging)
+        #
+        # This temporarily stops spinner animation while preserving state,
+        # allowing interactive sessions like binding.irb to run cleanly.
+        #
+        # @return [void]
+        def pause_all
+          @active_spinners.each_value do |spinner|
+            spinner.stop if spinner.spinning?
+          end
+
+          # Keep time updaters running (they'll safely handle stopped spinners)
+        end
+
+        # Resume all paused spinners
+        #
+        # Restarts spinner animation for all spinners that were paused.
+        #
+        # @return [void]
+        def resume_all
+          @active_spinners.each_value do |spinner|
+            spinner.auto_spin unless spinner.spinning?
+          end
+        end
+
+        private
+
+        def kill_updater(key)
+          updater = @time_updaters[key]
+          return unless updater
+
+          updater.kill if updater.alive?
+          @time_updaters.delete(key)
+        end
+
+        def cleanup(key)
+          @active_spinners.delete(key)
+          @time_updaters.delete(key)
+        end
+
+        def format_duration(seconds)
+          if seconds < 1
+            "#{(seconds * 1000).round}ms"
+          elsif seconds < 60
+            "#{seconds.round}s"
+          elsif seconds < 3600
+            minutes = (seconds / 60).floor
+            secs = (seconds % 60).round
+            "#{minutes}m #{secs}s"
+          else
+            hours = (seconds / 3600).floor
+            minutes = ((seconds % 3600) / 60).floor
+            "#{hours}h #{minutes}m"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/ui/state/usage_tracker.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module State
+      # Tracks cumulative usage statistics during swarm execution
+      class UsageTracker
+        attr_reader :total_cost, :total_tokens, :llm_requests, :tool_calls
+
+        def initialize
+          @total_cost = 0.0
+          @total_tokens = 0
+          @llm_requests = 0
+          @tool_calls = 0
+          @agents_seen = Set.new
+          @recent_tool_calls = {} # tool_call_id => tool_name for matching
+        end
+
+        # Track an LLM API call
+        def track_llm_request(usage_data)
+          @llm_requests += 1
+
+          if usage_data
+            @total_cost += usage_data[:total_cost] || 0.0
+            @total_tokens += usage_data[:total_tokens] || 0
+          end
+        end
+
+        # Track a tool call
+        def track_tool_call(tool_call_id: nil, tool_name: nil)
+          @tool_calls += 1
+          @recent_tool_calls[tool_call_id] = tool_name if tool_call_id && tool_name
+        end
+
+        # Track agent usage
+        def track_agent(agent_name)
+          @agents_seen.add(agent_name)
+        end
+
+        # Get list of agents seen
+        def agents
+          @agents_seen.to_a
+        end
+
+        # Get tool name from call ID
+        def tool_name_for(tool_call_id)
+          @recent_tool_calls[tool_call_id]
+        end
+
+        # Reset all counters (for testing)
+        def reset
+          @total_cost = 0.0
+          @total_tokens = 0
+          @llm_requests = 0
+          @tool_calls = 0
+          @agents_seen.clear
+          @recent_tool_calls.clear
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/version.rb

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

data/lib/swarm_cli.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "pathname"
+require "yaml"
+
+require "reline"
+require "pastel"
+require "tty-box"
+require "tty-screen"
+require "tty/link"
+require "tty/markdown"
+require "tty/option"
+require "tty/spinner"
+require "tty/spinner/multi"
+require "tty/tree"
+
+require "swarm_sdk"
+
+require_relative "swarm_cli/version"
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.new
+loader.push_dir("#{__dir__}/swarm_cli", namespace: SwarmCLI)
+loader.inflector.inflect(
+  "cli" => "CLI",
+  "ui" => "UI",
+  "interactive_repl" => "InteractiveREPL",
+)
+loader.setup
+
+module SwarmCLI
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class ExecutionError < Error; end
+end
+
+# Try to load swarm_memory gem if available (for CLI command extensions)
+begin
+  require "swarm_memory"
+rescue LoadError
+  # swarm_memory not installed - that's fine, memory commands won't be available
+end

data/lib/swarm_memory/adapters/base.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module SwarmMemory
+  module Adapters
+    # Abstract base adapter interface for memory storage backends
+    #
+    # Subclasses must implement all public methods to provide
+    # different storage backends (filesystem, Redis, SQLite, etc.)
+    class Base
+      # Maximum size per entry (1MB)
+      MAX_ENTRY_SIZE = 1_000_000
+
+      # Maximum total storage size (100MB)
+      MAX_TOTAL_SIZE = 100_000_000
+
+      # Write content to storage
+      #
+      # @param file_path [String] Path to store content
+      # @param content [String] Content to store
+      # @param title [String] Brief title describing the content
+      # @param embedding [Array<Float>, nil] Optional embedding vector
+      # @param metadata [Hash, nil] Optional metadata
+      # @raise [ArgumentError] If size limits are exceeded
+      # @return [Core::Entry] The created entry
+      def write(file_path:, content:, title:, embedding: nil, metadata: nil)
+        raise NotImplementedError, "Subclass must implement #write"
+      end
+
+      # Read content from storage
+      #
+      # @param file_path [String] Path to read from
+      # @raise [ArgumentError] If path not found
+      # @return [String] Content at the path
+      def read(file_path:)
+        raise NotImplementedError, "Subclass must implement #read"
+      end
+
+      # Read full entry with metadata
+      #
+      # @param file_path [String] Path to read from
+      # @raise [ArgumentError] If path not found
+      # @return [Core::Entry] Full entry object
+      def read_entry(file_path:)
+        raise NotImplementedError, "Subclass must implement #read_entry"
+      end
+
+      # Delete a specific entry
+      #
+      # @param file_path [String] Path to delete
+      # @raise [ArgumentError] If path not found
+      # @return [void]
+      def delete(file_path:)
+        raise NotImplementedError, "Subclass must implement #delete"
+      end
+
+      # List entries, optionally filtered by prefix
+      #
+      # @param prefix [String, nil] Filter by path prefix
+      # @return [Array<Hash>] Array of entry metadata (path, title, size, updated_at)
+      def list(prefix: nil)
+        raise NotImplementedError, "Subclass must implement #list"
+      end
+
+      # Search entries by glob pattern
+      #
+      # @param pattern [String] Glob pattern (e.g., "**/*.txt", "parallel/*/task_*")
+      # @return [Array<Hash>] Array of matching entry metadata, sorted by most recent first
+      def glob(pattern:)
+        raise NotImplementedError, "Subclass must implement #glob"
+      end
+
+      # Search entry content by pattern
+      #
+      # @param pattern [String] Regular expression pattern to search for
+      # @param case_insensitive [Boolean] Whether to perform case-insensitive search
+      # @param output_mode [String] Output mode: "files_with_matches" (default), "content", or "count"
+      # @param path [String, nil] Optional path prefix filter (e.g., "concept/", "fact/api-design")
+      # @return [Array<Hash>, String] Results based on output_mode
+      def grep(pattern:, case_insensitive: false, output_mode: "files_with_matches", path: nil)
+        raise NotImplementedError, "Subclass must implement #grep"
+      end
+
+      # Clear all entries
+      #
+      # @return [void]
+      def clear
+        raise NotImplementedError, "Subclass must implement #clear"
+      end
+
+      # Get current total size
+      #
+      # @return [Integer] Total size in bytes
+      def total_size
+        raise NotImplementedError, "Subclass must implement #total_size"
+      end
+
+      # Get number of entries
+      #
+      # @return [Integer] Number of entries
+      def size
+        raise NotImplementedError, "Subclass must implement #size"
+      end
+
+      protected
+
+      # Format bytes to human-readable size
+      #
+      # @param bytes [Integer] Number of bytes
+      # @return [String] Formatted size (e.g., "1.5MB", "500.0KB")
+      def format_bytes(bytes)
+        if bytes >= 1_000_000
+          "#{(bytes.to_f / 1_000_000).round(1)}MB"
+        elsif bytes >= 1_000
+          "#{(bytes.to_f / 1_000).round(1)}KB"
+        else
+          "#{bytes}B"
+        end
+      end
+
+      # Convert glob pattern to regex
+      #
+      # @param pattern [String] Glob pattern
+      # @return [Regexp] Regular expression
+      def glob_to_regex(pattern)
+        # Escape special regex characters except glob wildcards
+        escaped = Regexp.escape(pattern)
+
+        # Convert glob wildcards to regex
+        # ** matches any number of directories (including zero)
+        escaped = escaped.gsub('\*\*', ".*")
+        # * matches anything except directory separator
+        escaped = escaped.gsub('\*', "[^/]*")
+        # ? matches single character except directory separator
+        escaped = escaped.gsub('\?', "[^/]")
+
+        # Anchor to start and end
+        Regexp.new("\\A#{escaped}\\z")
+      end
+    end
+  end
+end