swarm_cli 2.1.13 → 3.0.0.alpha2

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

@@ -1,170 +0,0 @@
-# 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

@@ -1,62 +0,0 @@
-# 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

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

data/lib/swarm_cli.rb

@@ -1,46 +0,0 @@
-# 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.tag = File.basename(__FILE__, ".rb")
-loader.push_dir("#{__dir__}/swarm_cli", namespace: SwarmCLI)
-loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
-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