swarm_memory 2.1.4 → 2.1.6

data/lib/claude_swarm/commands/ps.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-
-module ClaudeSwarm
-  module Commands
-    class Ps
-      def execute
-        run_dir = ClaudeSwarm.joined_run_dir
-        unless Dir.exist?(run_dir)
-          puts "No active sessions"
-          return
-        end
-
-        # Read all symlinks in run directory and process them
-        sessions = Dir.glob("#{run_dir}/*").filter_map do |symlink|
-          process_symlink(symlink)
-        end
-
-        if sessions.empty?
-          puts "No active sessions"
-          return
-        end
-
-        # Check if any session is missing main instance costs
-        any_missing_main = sessions.any? { |s| !s[:main_has_cost] }
-
-        # 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"
-
-        # Only show warning if any session is missing main instance costs
-        if any_missing_main
-          puts "\n⚠️  \e[3mTotal cost does not include the cost of the main instance for some sessions\e[0m\n\n"
-        else
-          puts
-        end
-
-        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])
-          # Add asterisk if this session is missing main instance cost
-          cost_str += "*" unless session[:main_has_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 process_symlink(symlink)
-        session_dir = File.readlink(symlink)
-        session_id = File.basename(session_dir)
-        # Skip if target doesn't exist (stale symlink)
-        return unless Dir.exist?(session_dir)
-
-        parse_session_info(session_id, session_dir)
-      rescue Errno::EINVAL
-        # Not a symlink, skip it
-        nil
-      rescue StandardError => e
-        # Try to get session_id if we have session_dir
-        warn("⚠️  Skipping session #{session_id}: #{e.message}")
-        nil
-      end
-
-      def parse_session_info(session_id, session_dir)
-        # Load config for swarm name and main directory
-        config_file = File.join(session_dir, "config.yml")
-        return unless File.exist?(config_file)
-
-        config = YamlLoader.load_config_file(config_file)
-        swarm_name = config.dig("swarm", "name") || "Unknown"
-        main_instance = config.dig("swarm", "main")
-
-        # Get base directory from session metadata or root_directory file
-        root_dir_file = File.join(session_dir, "root_directory")
-        base_dir = File.exist?(root_dir_file) ? File.read(root_dir_file).strip : Dir.pwd
-
-        # 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
-
-        # Expand paths relative to the base directory
-        expanded_directories = directories.map do |dir|
-          File.expand_path(dir, base_dir)
-        end
-
-        # Check for worktree information in session metadata
-        expanded_directories = apply_worktree_paths(expanded_directories, session_dir)
-
-        directories_str = expanded_directories.join(", ")
-
-        # Calculate total cost from JSON log
-        log_file = File.join(session_dir, "session.log.json")
-        cost_result = SessionCostCalculator.calculate_total_cost(log_file)
-        total_cost = cost_result[:total_cost]
-
-        # Check if main instance has cost data
-        instances_with_cost = cost_result[:instances_with_cost]
-        main_has_cost = main_instance && instances_with_cost.include?(main_instance)
-
-        # Get uptime from session metadata or fallback to directory creation time
-        start_time = get_start_time(session_dir)
-        uptime = format_duration(Time.now - start_time)
-
-        {
-          id: session_id,
-          name: swarm_name,
-          cost: total_cost,
-          main_has_cost: main_has_cost,
-          uptime: uptime,
-          directory: directories_str,
-          start_time: start_time,
-        }
-      end
-
-      def get_start_time(session_dir)
-        # Try to get from session metadata first
-        metadata_file = File.join(session_dir, "session_metadata.json")
-        metadata = JsonHandler.parse_file(metadata_file)
-
-        if metadata && metadata["start_time"]
-          return Time.parse(metadata["start_time"])
-        end
-
-        # Fallback to directory creation time
-        File.stat(session_dir).ctime
-      rescue StandardError
-        # If anything fails, use directory creation time
-        File.stat(session_dir).ctime
-      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
-
-      def apply_worktree_paths(directories, session_dir)
-        session_metadata_file = File.join(session_dir, "session_metadata.json")
-        return directories unless File.exist?(session_metadata_file)
-
-        metadata = JsonHandler.parse_file!(session_metadata_file)
-        worktree_info = metadata["worktree"]
-        return directories unless worktree_info && worktree_info["enabled"]
-
-        # Get the created worktree paths
-        created_paths = worktree_info["created_paths"] || {}
-
-        # For each directory, find the appropriate worktree path
-        directories.map do |dir|
-          # Find if this directory has a worktree created
-          repo_root = find_git_root(dir)
-          next dir unless repo_root
-
-          # Look for a worktree with this repo root
-          worktree_key = created_paths.keys.find { |key| key.start_with?("#{repo_root}:") }
-          worktree_key ? created_paths[worktree_key] : dir
-        end
-      end
-
-      def worktree_path_for(dir, worktree_name)
-        git_root = find_git_root(dir)
-        git_root ? File.join(git_root, ".worktrees", worktree_name) : dir
-      end
-
-      def find_git_root(dir)
-        current = File.expand_path(dir)
-        while current != "/"
-          return current if File.exist?(File.join(current, ".git"))
-
-          current = File.dirname(current)
-        end
-        nil
-      end
-    end
-  end
-end

data/lib/claude_swarm/commands/show.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-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 = YamlLoader.load_config_file(File.join(session_path, "config.yml"))
-        main_instance_name = config.dig("swarm", "main")
-
-        # Parse all events to build instance data
-        log_file = File.join(session_path, "session.log.json")
-        instances = SessionCostCalculator.parse_instance_hierarchy(log_file)
-
-        # 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 "Session Path: #{session_path}"
-        puts "Swarm: #{config.dig("swarm", "name")}"
-
-        # Display runtime if available
-        runtime_info = get_runtime_info(session_path)
-        puts "Runtime: #{runtime_info}" if runtime_info
-
-        puts "Total Cost: #{cost_display}"
-
-        # Try to read root directory
-        root_dir_file = File.join(session_path, "root_directory")
-        puts "Root Directory: #{File.read(root_dir_file).strip}" if File.exist?(root_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 = ClaudeSwarm.joined_run_dir(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(ClaudeSwarm.joined_sessions_dir("*", "*")).find do |path|
-          File.basename(path) == session_id
-        end
-      end
-
-      def get_runtime_info(session_path)
-        metadata_file = File.join(session_path, "session_metadata.json")
-        metadata = JsonHandler.parse_file(metadata_file)
-        return unless metadata
-
-        if metadata["duration_seconds"]
-          # Session has completed
-          format_duration(metadata["duration_seconds"])
-        elsif metadata["start_time"]
-          # Session is still running or was interrupted
-          start_time = Time.parse(metadata["start_time"])
-          duration = (Time.now - start_time).to_i
-          "#{format_duration(duration)} (active)"
-        end
-      rescue StandardError
-        nil
-      end
-
-      def format_duration(seconds)
-        hours = seconds / 3600
-        minutes = (seconds % 3600) / 60
-        secs = seconds % 60
-
-        parts = []
-        parts << "#{hours}h" if hours.positive?
-        parts << "#{minutes}m" if minutes.positive?
-        parts << "#{secs}s"
-
-        parts.join(" ")
-      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