swarm_memory 2.1.4 → 2.1.6

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.4"
-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

data/lib/swarm_sdk/agent/RETRY_LOGIC.md

@@ -1,127 +0,0 @@
-# LLM Call Retry Logic
-
-## Feature
-
-SwarmSDK automatically retries failed LLM API calls to handle transient failures.
-
-## Configuration
-
-**Defaults:**
-- Max retries: 10
-- Delay: 10 seconds (fixed, no exponential backoff)
-- Retries ALL StandardError exceptions
-
-## Implementation
-
-**Location:** `lib/swarm_sdk/agent/chat.rb:768-801`
-
-```ruby
-def call_llm_with_retry(max_retries: 10, delay: 10, &block)
-  attempts = 0
-  loop do
-    attempts += 1
-    begin
-      return yield
-    rescue StandardError => e
-      raise if attempts >= max_retries
-
-      RubyLLM.logger.warn("SwarmSDK: LLM call failed (attempt #{attempts}/#{max_retries})")
-      sleep(delay)
-    end
-  end
-end
-```
-
-## Error Types Handled
-
-- `Faraday::ConnectionFailed` - Network connection issues
-- `Faraday::TimeoutError` - Request timeouts
-- `RubyLLM::APIError` - API errors (500s, etc.)
-- `RubyLLM::RateLimitError` - Rate limit errors
-- `RubyLLM::BadRequestError` - Usually not transient, but retries anyway
-- Any other `StandardError` - Catches proxy issues, DNS failures, etc.
-
-## Usage
-
-**Automatic - No Configuration Needed:**
-
-```ruby
-swarm = SwarmSDK.build do
-  agent :my_agent do
-    model "gpt-4"
-    base_url "http://proxy.example.com/v1"  # Can fail
-  end
-end
-
-# Automatically retries on failure
-response = swarm.execute("Do something")
-```
-
-## Logging
-
-**On Retry:**
-```
-WARN: SwarmSDK: LLM call failed (attempt 1/10): Faraday::ConnectionFailed: Connection failed
-WARN: SwarmSDK: Retrying in 10 seconds...
-```
-
-**On Max Retries:**
-```
-ERROR: SwarmSDK: LLM call failed after 10 attempts: Faraday::ConnectionFailed: Connection failed
-```
-
-## Testing
-
-Retry logic has been verified through:
-- ✅ All 728 SwarmSDK tests passing
-- ✅ Manual testing with failing proxies
-- ✅ Evaluation harnesses (assistant/retrieval modes)
-
-**Note:** Direct unit tests would require reflection (`instance_variable_set`) which violates security policy. The retry logic is tested implicitly through integration tests and real usage.
-
-## Behavior
-
-**Scenario 1: Transient failure**
-```
-Attempt 1: ConnectionFailed
-  → Wait 10s
-Attempt 2: ConnectionFailed
-  → Wait 10s
-Attempt 3: Success
-  → Returns response
-```
-
-**Scenario 2: Persistent failure**
-```
-Attempt 1-10: All fail
-  → Raises original error after attempt 10
-```
-
-**Scenario 3: Immediate success**
-```
-Attempt 1: Success
-  → Returns response (no retry needed)
-```
-
-## Why No Exponential Backoff
-
-**Design Decision:** Fixed 10-second delay
-
-**Rationale:**
-- Simpler implementation
-- Predictable retry duration (max 100 seconds)
-- Transient proxy/network issues typically resolve within seconds
-- Rate limit errors are caught by provider-specific handling
-- User explicitly requested fixed delays
-
-**Total max time:** 10 retries × 10 seconds = 100 seconds maximum
-
-## Future Enhancements (If Needed)
-
-- [ ] Configurable retry count per agent
-- [ ] Configurable delay per agent
-- [ ] Selective retry based on error type
-- [ ] Exponential backoff option
-- [ ] Circuit breaker pattern
-
-**Current State:** Production-ready with sensible defaults for proxy/network resilience.