ace-tmux 0.14.3 → 0.17.2

data/lib/ace/tmux/cli/commands/list.rb

@@ -7,76 +7,141 @@ module Ace
   module Tmux
     module CLI
       module Commands
-        # List available tmux presets
         class List < Ace::Support::Cli::Command
           include Ace::Support::Cli::Base
 
           desc <<~DESC.strip
-            List available tmux presets
+            List live tmux sessions, windows, or panes
 
-            SYNTAX:
-              ace-tmux list [TYPE]
+            Default behavior lists panes in the resolved current window.
 
-            EXAMPLES:
-
-              # List all presets
-              $ ace-tmux list
-
-              # List only session presets
-              $ ace-tmux list sessions
-
-              # List only window presets
-              $ ace-tmux list windows
+            Scope flags:
+              --all-panes  List panes across the resolved session
+              --windows    List windows in the resolved session
+              --sessions   List all tmux sessions
           DESC
 
           example [
-            "                           # List all presets",
-            "sessions                   # List session presets",
-            "windows                    # List window presets",
-            "panes                      # List pane presets"
+            "                              # List panes in the current window",
+            "--all-panes                   # List panes across the current session",
+            "--windows                     # List windows in the current session",
+            "--sessions                    # List tmux sessions",
+            "--session dev --window work   # List panes in an explicit window"
           ]
 
-          argument :type, required: false, desc: "Preset type: sessions, windows, or panes"
+          option :session, type: :string, aliases: %w[-s], desc: "Target session name"
+          option :window, type: :string, aliases: %w[-w], desc: "Target window name, index, or tmux window id (@2)"
+          option :all_panes, type: :boolean, desc: "List panes across the resolved session"
+          option :windows, type: :boolean, desc: "List windows in the resolved session"
+          option :sessions, type: :boolean, desc: "List all tmux sessions"
+
+          def call(**options)
+            validate_scope!(options)
+
+            control = Organisms::ControlSurface.new
+            scope = selected_scope(options)
+
+            case scope
+            when :sessions
+              print_sessions(control.list_sessions)
+            when :windows
+              print_windows(control.list_windows(session: options[:session]))
+            when :all_panes
+              print_panes(control.list_panes(session: options[:session], all_panes: true))
+            else
+              print_panes(control.list_panes(session: options[:session], window: options[:window]))
+            end
+          rescue Ace::Tmux::Error => e
+            raise Ace::Support::Cli::Error, e.message
+          end
+
+          private
+
+          def validate_scope!(options)
+            scopes = %i[all_panes windows sessions].select { |key| options[key] }
+            raise Ace::Support::Cli::Error, "Use only one of --all-panes, --windows, or --sessions" if scopes.length > 1
+
+            if options[:sessions] && (options[:session] || options[:window])
+              raise Ace::Support::Cli::Error, "--sessions does not accept --session or --window"
+            end
+
+            if options[:windows] && options[:window]
+              raise Ace::Support::Cli::Error, "--windows does not accept --window"
+            end
+
+            if options[:all_panes] && options[:window]
+              raise Ace::Support::Cli::Error, "--all-panes does not accept --window"
+            end
+          end
+
+          def selected_scope(options)
+            return :sessions if options[:sessions]
+            return :windows if options[:windows]
+            return :all_panes if options[:all_panes]
+
+            :panes
+          end
 
-          option :verbose, type: :boolean, aliases: %w[-v], desc: "Show verbose output"
-          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+          def print_sessions(rows)
+            return puts("No tmux sessions found.") if rows.empty?
 
-          def call(type: nil, **options)
-            preset_loader = Molecules::PresetLoader.new(
-              gem_root: Tmux.gem_root
+            table = build_table(
+              %w[SESSION ATTACHED WINDOWS],
+              rows.map { |row| [row[:session], row[:attached_clients].to_s, row[:window_count].to_s] }
             )
+            puts table
+          end
 
-            if type
-              validate_type!(type)
-              presets = preset_loader.list(type)
-              display_type(type, presets, verbose: options[:verbose])
-            else
-              all = preset_loader.list_all
-              all.each do |preset_type, presets|
-                display_type(preset_type, presets, verbose: options[:verbose])
+          def print_windows(rows)
+            return puts("No windows found.") if rows.empty?
+
+            table = build_table(
+              %w[A WINDOW SESSION:INDEX NAME PANES],
+              rows.map do |row|
+                [
+                  row[:active] ? "*" : " ",
+                  row[:id],
+                  "#{row[:session]}:#{row[:index]}",
+                  row[:name],
+                  row[:pane_count].to_s
+                ]
               end
-              puts "No presets found." if all.empty?
-            end
+            )
+            puts table
           end
 
-          private
+          def print_panes(rows)
+            return puts("No panes found.") if rows.empty?
+
+            table = build_table(
+              %w[A PANE TARGET CMD CWD],
+              rows.map do |row|
+                [
+                  row[:active] ? "*" : " ",
+                  row[:pane_id],
+                  row[:target],
+                  row[:command],
+                  row[:cwd]
+                ]
+              end
+            )
+            puts table
+          end
 
-          def validate_type!(type)
-            unless Molecules::PresetLoader::PRESET_TYPES.include?(type)
-              raise Ace::Support::Cli::Error.new(
-                "Unknown preset type: #{type}. Valid types: #{Molecules::PresetLoader::PRESET_TYPES.join(", ")}"
-              )
+          def build_table(headers, rows)
+            widths = headers.each_index.map do |index|
+              ([headers[index]] + rows.map { |row| row[index].to_s }).map(&:length).max
             end
+
+            lines = []
+            lines << render_row(headers, widths)
+            lines << render_row(widths.map { |width| "-" * width }, widths)
+            rows.each { |row| lines << render_row(row, widths) }
+            lines.join("\n")
           end
 
-          def display_type(type, presets, verbose: false)
-            puts "#{type}:"
-            if presets.empty?
-              puts "  (none)"
-            else
-              presets.each { |name| puts "  #{name}" }
-            end
-            puts
+          def render_row(values, widths)
+            values.each_with_index.map { |value, index| value.to_s.ljust(widths[index]) }.join("  ").rstrip
           end
         end
       end

data/lib/ace/tmux/cli/commands/list_presets.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+
+module Ace
+  module Tmux
+    module CLI
+      module Commands
+        class ListPresets < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc <<~DESC.strip
+            List available tmux presets
+
+            Run without a type to list all preset groups, or pass one of:
+              sessions
+              windows
+              panes
+          DESC
+
+          example [
+            "                     # List all preset groups",
+            "sessions             # List session presets",
+            "windows              # List window presets",
+            "panes                # List pane presets"
+          ]
+
+          argument :type, required: false, desc: "Preset type: sessions, windows, or panes"
+
+          def call(type: nil, **_options)
+            preset_loader = Molecules::PresetLoader.new(gem_root: Tmux.gem_root)
+
+            if type
+              validate_type!(type)
+              display_type(type, preset_loader.list(type))
+              return
+            end
+
+            all = preset_loader.list_all
+            all.each { |preset_type, presets| display_type(preset_type, presets) }
+            puts "No presets found." if all.empty?
+          end
+
+          private
+
+          def validate_type!(type)
+            return if Molecules::PresetLoader::PRESET_TYPES.include?(type)
+
+            raise Ace::Support::Cli::Error,
+                  "Unknown preset type: #{type}. Valid types: #{Molecules::PresetLoader::PRESET_TYPES.join(", ")}"
+          end
+
+          def display_type(type, presets)
+            puts "#{type}:"
+            if presets.empty?
+              puts "  (none)"
+            else
+              presets.each { |name| puts "  #{name}" }
+            end
+            puts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/tmux/cli/commands/send.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+
+module Ace
+  module Tmux
+    module CLI
+      module Commands
+        class Send < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          DEFAULT_CAPTURE_LINES = 40
+          DEFAULT_CAPTURE_WAIT = 2.0
+
+          desc <<~DESC.strip
+            Send submitted commands, raw text, or named keys to a tmux pane
+
+            Bare --wait defaults to the interactive agent condition.
+            Bare --capture prints a post-send pane tail using default line and wait values.
+          DESC
+
+          example [
+            "--pane %1 --cmd 'bundle exec rake test'",
+            "--pane %8 --cmd 'Reply with exactly: pong' --wait --capture 20",
+            "--pane %1 --msg 'echo ready' --key Enter",
+            "--pane %1 --cmd 'echo done' --wait output --pattern done --capture 20"
+          ]
+
+          option :session, type: :string, aliases: %w[-s], desc: "Target session name"
+          option :window, type: :string, aliases: %w[-w], desc: "Target window name, index, or tmux window id (@2)"
+          option :pane, type: :string, aliases: %w[-p], desc: "Target pane id (%8), full pane target (dev:work.1), or current-window pane shorthand (.1)"
+          option :cmd, type: :string, aliases: %w[-c], desc: "Command text to send and submit with Enter"
+          option :msg, type: :string, aliases: %w[-m], repeat: true, desc: "Literal text chunk to send without Enter"
+          option :key, type: :string, aliases: %w[-k], repeat: true, desc: "Named key to send (for example Enter, C-c)"
+          option :capture, type: :string, default: false, optional_value: true, desc: "Capture pane output after send as [lines[:wait]]; bare --capture defaults to 40 lines"
+          option :wait, type: :string, default: false, optional_value: true, desc: "Wait after send as [agent|output|window-exists|window-active|pane-exists|pane-exited]; bare --wait defaults to agent"
+          option :pattern, type: :string, desc: "Pattern to match when waiting for output"
+          option :timeout, type: :string, aliases: %w[-t], default: Organisms::ControlSurface::DEFAULT_TIMEOUT.to_s, desc: "Wait timeout in seconds when --wait is used"
+          option :interval, type: :string, aliases: %w[-i], default: Organisms::ControlSurface::DEFAULT_INTERVAL.to_s, desc: "Wait polling interval in seconds when --wait is used"
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+
+          def call(**options)
+            control = Organisms::ControlSurface.new
+            cmd = normalized_cmd(options)
+            messages = normalized_messages(options)
+            keys = normalized_keys(options)
+            wait_condition = normalized_wait_condition(options.fetch(:wait, false))
+
+            validate_payloads!(cmd: cmd, messages: messages, keys: keys)
+            validate_wait_condition!(wait_condition: wait_condition, pattern: options[:pattern]) if wait_condition
+
+            capture_spec = parse_capture_spec(
+              options.fetch(:capture, false),
+              default_wait: wait_condition ? 0.0 : DEFAULT_CAPTURE_WAIT
+            )
+            wait_lines = capture_spec ? capture_spec[:lines] : DEFAULT_CAPTURE_LINES
+            baseline_output = wait_baseline_for(control, options, wait_condition, lines: wait_lines)
+
+            control.send_sequence(**target_options(options), command: cmd, messages: messages, keys: keys)
+
+            if wait_condition
+              control.wait_for_condition(
+                **target_options(options),
+                condition: wait_condition,
+                pattern: options[:pattern],
+                timeout: Float(options.fetch(:timeout, Organisms::ControlSurface::DEFAULT_TIMEOUT.to_s)),
+                interval: Float(options.fetch(:interval, Organisms::ControlSurface::DEFAULT_INTERVAL.to_s)),
+                lines: wait_lines,
+                baseline_output: baseline_output,
+                require_change: wait_condition == "agent"
+              )
+            end
+
+            if capture_spec
+              sleep(capture_spec[:wait]) if capture_spec[:wait].positive?
+              output = control.capture_recent_output(**target_options(options), lines: capture_spec[:lines])
+              puts output
+            elsif !options[:quiet]
+              puts success_message(cmd: cmd, messages: messages, keys: keys, wait_condition: wait_condition)
+            end
+          rescue Ace::Tmux::Error => e
+            raise Ace::Support::Cli::Error, e.message
+          rescue ArgumentError
+            raise Ace::Support::Cli::Error, "--timeout and --interval must be numeric"
+          end
+
+          private
+
+          def target_options(options)
+            options.slice(:session, :window, :pane)
+          end
+
+          def normalized_cmd(options)
+            value = options[:cmd].to_s
+            return nil if value.strip.empty?
+
+            value
+          end
+
+          def normalized_messages(options)
+            Array(options[:msg]).map(&:to_s)
+          end
+
+          def normalized_keys(options)
+            Array(options[:key]).map(&:to_s).reject { |value| value.strip.empty? }
+          end
+
+          def validate_payloads!(cmd:, messages:, keys:)
+            raise Ace::Support::Cli::Error, "Provide at least one of --cmd, --msg, or --key" if cmd.nil? && messages.empty? && keys.empty?
+            raise Ace::Support::Cli::Error, "Use either --cmd or --msg, not both" if cmd && !messages.empty?
+          end
+
+          def parse_capture_spec(raw, default_wait: DEFAULT_CAPTURE_WAIT)
+            return nil if raw == false
+            return { lines: DEFAULT_CAPTURE_LINES, wait: default_wait } if raw.nil? || raw == true || raw.to_s.strip.empty?
+
+            value = raw.to_s.strip
+            parts = value.split(":", 2)
+
+            lines = Integer(parts[0])
+            wait = parts[1] ? Float(parts[1]) : default_wait
+            raise ArgumentError if lines <= 0 || wait.negative?
+
+            { lines: lines, wait: wait }
+          rescue ArgumentError
+            raise Ace::Support::Cli::Error, "Invalid --capture value '#{raw}'. Use [lines[:wait]] such as 40 or 40:2"
+          end
+
+          def normalized_wait_condition(raw)
+            return nil if raw == false
+            return "agent" if raw.nil? || raw == true || raw.to_s.strip.empty?
+
+            raw.to_s.strip
+          end
+
+          def validate_wait_condition!(wait_condition:, pattern:)
+            Molecules::WaitConditionValidator.validate!(condition: wait_condition, pattern: pattern)
+          rescue Ace::Tmux::ValidationError => e
+            raise Ace::Support::Cli::Error, e.message
+          end
+
+          def wait_baseline_for(control, options, wait_condition, lines:)
+            return nil unless %w[agent output].include?(wait_condition)
+
+            control.capture_recent_output(**target_options(options), lines: lines)
+          end
+
+          def success_message(cmd:, messages:, keys:, wait_condition:)
+            message =
+              if cmd
+                "Sent command"
+              elsif !messages.empty? && !keys.empty?
+                "Sent #{messages.length} message#{messages.length == 1 ? '' : 's'} and #{keys.length} key#{keys.length == 1 ? '' : 's'}"
+              elsif !messages.empty?
+                "Sent #{messages.length} message#{messages.length == 1 ? '' : 's'}"
+              else
+                "Sent #{keys.length} key#{keys.length == 1 ? '' : 's'}"
+              end
+
+            return message unless wait_condition
+
+            "#{message} and waited for #{wait_condition}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/tmux/cli/commands/wait.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "ace/support/cli"
+require "ace/core"
+
+module Ace
+  module Tmux
+    module CLI
+      module Commands
+        class Wait < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+
+          desc <<~DESC.strip
+            Wait for a bounded tmux condition
+
+            Use --lines to control the pane tail observed by output and agent waits.
+          DESC
+
+          example [
+            "--pane %1 --for output --pattern 'Task context:' --lines 80",
+            "--pane %8 --for agent",
+            "--session dev --for window-active --window work-fs",
+            "--pane %1 --for pane-exited"
+          ]
+
+          option :for, type: :string, aliases: %w[-f], desc: "Condition: agent|output|window-exists|window-active|pane-exists|pane-exited"
+          option :session, type: :string, aliases: %w[-s], desc: "Target session name"
+          option :window, type: :string, aliases: %w[-w], desc: "Target window name, index, or tmux window id (@2)"
+          option :pane, type: :string, aliases: %w[-p], desc: "Target pane id (%8), full pane target (dev:work.1), or current-window pane shorthand (.1)"
+          option :pattern, type: :string, desc: "Pattern to match when waiting for output"
+          option :lines, type: :integer, aliases: %w[-n], default: Organisms::ControlSurface::DEFAULT_LINES, desc: "Number of lines to observe for output and agent waits"
+          option :timeout, type: :string, aliases: %w[-t], default: "10.0", desc: "Timeout in seconds"
+          option :interval, type: :string, aliases: %w[-i], default: "0.2", desc: "Polling interval in seconds"
+          option :quiet, type: :boolean, aliases: %w[-q], desc: "Suppress non-essential output"
+
+          def call(**options)
+            Organisms::ControlSurface.new.wait_for_condition(
+              condition: options[:for],
+              session: options[:session],
+              window: options[:window],
+              pane: options[:pane],
+              pattern: options[:pattern],
+              lines: options[:lines],
+              timeout: Float(options[:timeout]),
+              interval: Float(options[:interval])
+            )
+            puts "Condition met: #{options[:for]}" unless options[:quiet]
+          rescue Ace::Tmux::Error => e
+            raise Ace::Support::Cli::Error, e.message
+          rescue ArgumentError
+            raise Ace::Support::Cli::Error, "--timeout and --interval must be numeric"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/tmux/cli/commands/window.rb

@@ -59,9 +59,8 @@ module Ace
               tmux: tmux_bin
             )
 
-            effective_name = options[:name] || (options[:root] ? File.basename(options[:root]) : preset)
-            puts "Adding window '#{effective_name}' (preset: #{preset})..." unless options[:quiet]
-            manager.add_window(preset, session: options[:session], root: options[:root], name: options[:name])
+            puts "Adding window from preset '#{preset}'..." unless options[:quiet]
+            effective_name = manager.add_window(preset, session: options[:session], root: options[:root], name: options[:name])
             puts "Window '#{effective_name}' added." unless options[:quiet]
           rescue Ace::Tmux::PresetNotFoundError => e
             raise Ace::Support::Cli::Error.new(e.message)

data/lib/ace/tmux/cli.rb

@@ -6,6 +6,12 @@ require_relative "../tmux"
 require_relative "cli/commands/start"
 require_relative "cli/commands/window"
 require_relative "cli/commands/list"
+require_relative "cli/commands/list_presets"
+require_relative "cli/commands/send"
+require_relative "cli/commands/capture"
+require_relative "cli/commands/wait"
+require_relative "cli/commands/attach"
+require_relative "cli/commands/detach"
 
 module Ace
   module Tmux
@@ -19,13 +25,26 @@ module Ace
       REGISTERED_COMMANDS = [
         ["start", "Start tmux session from preset"],
         ["window", "Add window to existing session"],
-        ["list", "List available presets"]
+        ["list", "List live tmux sessions, windows, or panes"],
+        ["--list-presets", "List available tmux presets"],
+        ["send", "Send submitted commands, raw text, or named keys to a pane"],
+        ["capture", "Capture recent output from a pane"],
+        ["wait", "Wait for a bounded tmux condition"],
+        ["attach", "Attach to a tmux session"],
+        ["detach", "Detach clients from a tmux session"]
       ].freeze
 
       HELP_EXAMPLES = [
         "ace-tmux start dev                    # Launch dev session preset",
         "ace-tmux window cc --root ~/project   # Add window to session",
-        "ace-tmux list                         # Available presets"
+        "ace-tmux --list-presets windows       # Available window presets",
+        "ace-tmux list                         # Panes in the current window",
+        "ace-tmux list --windows               # Windows in the current session",
+        "ace-tmux send --pane %1 --cmd 'bundle exec rake test'      # Send command",
+        "ace-tmux send --pane .1 --msg 'echo ready' --key Enter     # Current-window pane shortcut",
+        "ace-tmux wait --session dev --for window-active --window work-fs # Wait for window",
+        "ace-tmux capture --pane %1 --lines 40 # Capture pane output",
+        "ace-tmux detach --session dev         # Detach session clients"
       ].freeze
 
       # Start the CLI
@@ -40,6 +59,12 @@ module Ace
       register "start", CLI::Commands::Start.new
       register "window", CLI::Commands::Window.new
       register "list", CLI::Commands::List.new
+      register "--list-presets", CLI::Commands::ListPresets.new
+      register "send", CLI::Commands::Send.new
+      register "capture", CLI::Commands::Capture.new
+      register "wait", CLI::Commands::Wait.new
+      register "attach", CLI::Commands::Attach.new
+      register "detach", CLI::Commands::Detach.new
 
       # Register version command
       version_cmd = Ace::Support::Cli::VersionCommand.build(

data/lib/ace/tmux/models/runtime_target.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Ace
+  module Tmux
+    module Models
+      class RuntimeTarget
+        attr_reader :session, :window, :pane, :source
+
+        def initialize(session: nil, window: nil, pane: nil, source:, raw_window_target: nil)
+          @session = presence(session)
+          @window = presence(window)
+          @pane = presence(pane)
+          @source = source.to_s
+          @raw_window_target = presence(raw_window_target)
+        end
+
+        def session_target
+          session
+        end
+
+        def window_target
+          return @raw_window_target if @raw_window_target
+          return nil unless session && window
+
+          "#{session}:#{window}"
+        end
+
+        def pane_target
+          return pane if pane&.start_with?("%")
+          return pane if pane&.start_with?("@")
+          return pane if pane&.include?(":")
+          return nil unless pane && window_target
+
+          "#{window_target}.#{pane}"
+        end
+
+        private
+
+        def presence(value)
+          normalized = value.to_s.strip
+          normalized.empty? ? nil : normalized
+        end
+      end
+    end
+  end
+end