octo-agent 0.11.2

data/lib/octo/ui2/terminal_detector.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Octo
+  module UI2
+    # TerminalDetector - Detect terminal background color before UI starts
+    class TerminalDetector
+      # Detect if terminal has dark background
+      # Uses multiple strategies to determine background color
+      # @return [Boolean] true if dark background, false if light background
+      def self.detect_dark_background
+        # Strategy 1: Check $COLORFGBG environment variable (fast, set by some terminals)
+        if ENV.key?('COLORFGBG')
+          # Format is like "15;0" where second number is background ANSI code
+          # 0-7 are dark, 8-15 are light
+          parts = ENV['COLORFGBG'].split(';')
+          if parts.size >= 2
+            bg_code = parts.last.to_i
+            if bg_code >= 0 && bg_code <= 15
+              return bg_code < 8
+            end
+          end
+        end
+        
+        # Strategy 2: Query terminal background using OSC 11 sequence
+        begin
+          rgb = query_terminal_background_color
+          if rgb
+            # Calculate luma (perceived brightness): 0.0 (black) to 1.0 (white)
+            # Formula: 0.299*R + 0.587*G + 0.114*B
+            luma = (0.299 * rgb[:r] + 0.587 * rgb[:g] + 0.114 * rgb[:b]) / 255.0
+            return luma < 0.5
+          end
+        rescue => e
+          # Silently fall through to default
+        end
+        
+        # Default: assume dark background (most common for terminals)
+        true
+      end
+
+      # Query terminal background color using OSC 11 sequence
+      # This should be called BEFORE UI starts to avoid interference
+      # @return [Hash, nil] RGB hash like {r: 26, g: 43, b: 60} or nil if failed
+      def self.query_terminal_background_color
+        require 'io/console'
+        
+        # Only works on TTY
+        return nil unless $stdin.tty?
+        return nil unless $stdout.tty?
+        
+        old_state = nil
+        begin
+          # Save current terminal state
+          old_state = $stdin.raw!
+          
+          # Clear any pending input first
+          while IO.select([$stdin], nil, nil, 0)
+            $stdin.read_nonblock(1000) rescue break
+          end
+          
+          # Send OSC 11 query: ESC ] 11 ; ? ST
+          # Use ST terminator (ESC \) instead of BEL for better compatibility
+          $stdout.print "\e]11;?\e\\\\"
+          $stdout.flush
+          
+          # Read response with timeout (terminal should respond quickly)
+          response = String.new  # Use String.new to create mutable string
+          timeout = 0.1  # 100ms timeout
+          start_time = Time.now
+          
+          while Time.now - start_time < timeout
+            if IO.select([$stdin], nil, nil, 0.01)
+              char = $stdin.read_nonblock(1) rescue nil
+              break unless char
+              response << char
+              
+              # Look for complete response pattern
+              # Response format: ESC ] 11 ; rgb:RRRR/GGGG/BBBB BEL or ST
+              if response.match?(/\e\]11;rgb:[0-9a-fA-F]+\/[0-9a-fA-F]+\/[0-9a-fA-F]+(\e\\|\a)/)
+                break
+              end
+              
+              # Safety: stop if response gets too long (probably garbage)
+              break if response.length > 100
+            end
+          end
+          
+          # Parse response: look for rgb:RRRR/GGGG/BBBB
+          # Example: ]11;rgb:1a2b/3c4d/5e6f or ]11;rgb:ffff/ffff/ffff
+          if response =~ /rgb:([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)/
+            r_hex, g_hex, b_hex = $1, $2, $3
+            # Take first 2 hex digits (terminals may return 4 or 2 hex digits per channel)
+            r = r_hex[0, 2].to_i(16)
+            g = g_hex[0, 2].to_i(16)
+            b = b_hex[0, 2].to_i(16)
+            return { r: r, g: g, b: b }
+          end
+          
+          nil
+        rescue => e
+          # If anything goes wrong, return nil to fall back to default
+          nil
+        ensure
+          # Make sure we restore terminal state even if error occurs
+          old_state.restore if old_state rescue nil
+          
+          # Clear any remaining input to prevent leakage
+          begin
+            while IO.select([$stdin], nil, nil, 0)
+              $stdin.read_nonblock(1000) rescue break
+            end
+          rescue
+            # Ignore cleanup errors
+          end
+        end
+      end
+    end
+  end
+end

data/lib/octo/ui2/theme_manager.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "themes/base_theme"
+require_relative "themes/hacker_theme"
+require_relative "themes/minimal_theme"
+
+module Octo
+  module UI2
+    # ThemeManager handles theme registration and switching
+    class ThemeManager
+      class << self
+        def instance
+          @instance ||= new
+        end
+
+        # Delegate methods to instance
+        def current_theme
+          instance.current_theme
+        end
+
+        def set_theme(name)
+          instance.set_theme(name)
+        end
+
+        def available_themes
+          instance.available_themes
+        end
+
+        def register_theme(name, theme_class)
+          instance.register_theme(name, theme_class)
+        end
+      end
+
+      def initialize
+        @themes = {}
+        @current_theme = nil
+        @is_dark_background = nil  # Store detected background mode
+        register_default_themes
+        set_theme(:hacker)
+      end
+
+      # Set the detected terminal background mode
+      # This should be called BEFORE UI starts (from CLI)
+      # @param is_dark [Boolean] true if dark background, false if light
+      def set_background_mode(is_dark)
+        @is_dark_background = is_dark
+        # Pass to current theme if already initialized
+        @current_theme&.set_background_mode(is_dark)
+      end
+
+      # Get the detected background mode
+      # @return [Boolean, nil] true if dark, false if light, nil if not detected
+      def dark_background?
+        @is_dark_background
+      end
+
+      def current_theme
+        @current_theme
+      end
+
+      def set_theme(name)
+        name = name.to_sym
+        raise ArgumentError, "Unknown theme: #{name}" unless @themes.key?(name)
+
+        @current_theme = @themes[name].new
+        # Pass background mode to new theme if already detected
+        @current_theme.set_background_mode(@is_dark_background) unless @is_dark_background.nil?
+      end
+
+      def available_themes
+        @themes.keys
+      end
+
+      def register_theme(name, theme_class)
+        @themes[name.to_sym] = theme_class
+      end
+
+
+      def register_default_themes
+        register_theme(:hacker, Themes::HackerTheme)
+        register_theme(:minimal, Themes::MinimalTheme)
+      end
+    end
+  end
+end

data/lib/octo/ui2/themes/base_theme.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Octo
+  module UI2
+    module Themes
+      # BaseTheme defines the abstract interface for all themes
+      # Subclasses MUST define SYMBOLS and COLORS constants
+      class BaseTheme
+        def initialize
+          @pastel = Pastel.new
+          @is_dark_background = nil  # Will be set by ThemeManager
+          validate_theme_definition!
+        end
+
+        # Set background mode (called by ThemeManager after detection)
+        # @param is_dark [Boolean] true if dark background, false if light
+        def set_background_mode(is_dark)
+          @is_dark_background = is_dark
+        end
+
+        # Get all symbols defined by this theme
+        # @return [Hash] Symbol definitions
+        def symbols
+          self.class::SYMBOLS
+        end
+
+        # Get all colors defined by this theme
+        # @return [Hash] Color definitions
+        def colors
+          self.class::COLORS
+        end
+
+        # Get symbol for a specific key
+        # @param key [Symbol] Symbol key
+        # @return [String] Symbol string
+        def symbol(key)
+          symbols[key] || "[??]"
+        end
+
+        # Get symbol color for a specific key
+        # @param key [Symbol] Color key
+        # @return [Symbol] Pastel color method name
+        def symbol_color(key)
+          colors.dig(key, 0) || :white
+        end
+
+        # Get text color for a specific key
+        # Automatically selects appropriate color based on terminal background
+        # Color format: [symbol_color, dark_bg_text_color, light_bg_text_color]
+        # @param key [Symbol] Color key
+        # @return [Symbol] Pastel color method name
+        def text_color(key)
+          color_def = colors[key]
+          return :white unless color_def
+          
+          # Use index 1 for dark background, index 2 for light background
+          dark_background? ? color_def[1] : color_def[2]
+        end
+
+        # Format symbol with its color
+        # @param key [Symbol] Symbol key (e.g., :user, :assistant)
+        # @return [String] Colored symbol
+        def format_symbol(key)
+          @pastel.public_send(symbol_color(key), symbol(key))
+        end
+
+        # Format text with color for given key
+        # @param text [String] Text to format
+        # @param key [Symbol] Color key (e.g., :user, :assistant)
+        # @return [String] Colored text
+        def format_text(text, key)
+          @pastel.public_send(text_color(key), text)
+        end
+
+        # Theme name for display (subclasses should override)
+        # @return [String] Theme name
+        def name
+          raise NotImplementedError, "Subclass must implement #name method"
+        end
+
+        # Check if terminal has dark background
+        # Uses pre-detected value from ThemeManager, or defaults to true
+        # @return [Boolean] true if dark background, false if light background
+        def dark_background?
+          # Use pre-detected value if available, otherwise default to dark
+          @is_dark_background.nil? ? true : @is_dark_background
+        end
+
+
+        # Validate that subclass has defined required constants
+        def validate_theme_definition!
+          unless self.class.const_defined?(:SYMBOLS)
+            raise NotImplementedError, "Theme #{self.class.name} must define SYMBOLS constant"
+          end
+
+          unless self.class.const_defined?(:COLORS)
+            raise NotImplementedError, "Theme #{self.class.name} must define COLORS constant"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/octo/ui2/themes/hacker_theme.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "base_theme"
+
+module Octo
+  module UI2
+    module Themes
+      # HackerTheme - Matrix/hacker-style with bracket symbols
+      class HackerTheme < BaseTheme
+        SYMBOLS = {
+          user: "[>>]",
+          assistant: "[<<]",
+          tool_call: "[=>]",
+          tool_result: "[<=]",
+          tool_denied: "[!!]",
+          tool_planned: "[??]",
+          tool_error: "[XX]",
+          thinking: "[..]",
+          working: "[..]",
+          success: "[OK]",
+          error: "[ER]",
+          warning: "[!!]",
+          info: "[--]",
+          task: "[##]",
+          progress: "[>>]",
+          file: "[F]",
+          command: "[C]",
+          cached: "[*]"
+        }.freeze
+
+        COLORS = {
+          # Format: [symbol_color, dark_bg_text, light_bg_text]
+          user: [:bright_black, :white, :black],           # User prompt and input
+          assistant: [:bright_green, :bright_black, :bright_black], # AI response - keep green hacker style
+          tool_call: [:bright_cyan, :cyan, :cyan],                # Tool execution
+          tool_result: [:bright_cyan, :bright_black, :bright_black], # Tool output
+          tool_denied: [:bright_yellow, :yellow, :yellow],        # Denied actions
+          tool_planned: [:bright_cyan, :cyan, :cyan],             # Planned actions
+          tool_error: [:bright_red, :red, :red],                  # Errors
+          thinking: [:bright_black, :bright_black, :bright_black], # Thinking status
+          working: [:bright_yellow, :yellow, :yellow],            # Working status
+          success: [:bright_green, :green, :green],               # Success messages
+          error: [:bright_red, :red, :red],                       # Error messages
+          warning: [:bright_yellow, :yellow, :yellow],            # Warnings
+          info: [:bright_black, :bright_black, :bright_black],    # Info messages
+          task: [:bright_yellow, :bright_black, :bright_black],   # Task items
+          progress: [:bright_cyan, :cyan, :cyan],                 # Progress indicators
+          file: [:cyan, :bright_black, :bright_black],            # File references
+          command: [:cyan, :bright_black, :bright_black],         # Command references
+          cached: [:cyan, :cyan, :cyan],                          # Cached indicators
+          # Status bar colors
+          statusbar_path: [:bright_black, :bright_black, :bright_black],        # Path
+          statusbar_secondary: [:bright_black, :bright_black, :bright_black]    # Model/tasks
+        }.freeze
+
+        def name
+          "hacker"
+        end
+      end
+    end
+  end
+end

data/lib/octo/ui2/themes/minimal_theme.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "base_theme"
+
+module Octo
+  module UI2
+    module Themes
+      # MinimalTheme - Clean, simple symbols
+      class MinimalTheme < BaseTheme
+        SYMBOLS = {
+          user: ">",
+          assistant: "<",
+          tool_call: "*",
+          tool_result: "-",
+          tool_denied: "!",
+          tool_planned: "?",
+          tool_error: "x",
+          thinking: ".",
+          working: ".",
+          success: "+",
+          error: "x",
+          warning: "!",
+          info: "-",
+          task: "#",
+          progress: ">"
+        }.freeze
+
+        COLORS = {
+          # Format: [symbol_color, dark_bg_text, light_bg_text]
+          user: [:bright_black, :bright_black, :black],           # User prompt and input
+          assistant: [:green, :bright_black, :bright_black],      # AI response
+          tool_call: [:cyan, :cyan, :cyan],                       # Tool execution
+          tool_result: [:cyan, :bright_black, :bright_black],     # Tool output
+          tool_denied: [:yellow, :yellow, :yellow],               # Denied actions
+          tool_planned: [:cyan, :cyan, :cyan],                    # Planned actions
+          tool_error: [:red, :red, :red],                         # Errors
+          thinking: [:bright_black, :bright_black, :bright_black], # Thinking status
+          working: [:bright_yellow, :yellow, :yellow],            # Working status
+          success: [:green, :green, :green],                      # Success messages
+          error: [:red, :red, :red],                              # Error messages
+          warning: [:yellow, :yellow, :yellow],                   # Warnings
+          info: [:bright_black, :bright_black, :bright_black],    # Info messages
+          task: [:yellow, :bright_black, :bright_black],          # Task items
+          progress: [:cyan, :cyan, :cyan],                        # Progress indicators
+          # Status bar colors
+          statusbar_path: [:bright_black, :bright_black, :bright_black],        # Path
+          statusbar_secondary: [:bright_black, :bright_black, :bright_black]    # Model/tasks
+        }.freeze
+
+        def name
+          "minimal"
+        end
+      end
+    end
+  end
+end

data/lib/octo/ui2/thinking_verbs.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Octo
+  THINKING_VERBS = [
+    "Cogitating",
+    "Pondering",
+    "Ruminating",
+    "Deliberating",
+    "Contemplating",
+    "Flibbertigibbeting",
+    "Percolating",
+    "Noodling",
+    "Brewing",
+    "Marinating",
+    "Stewing",
+    "Mulling",
+    "Processing",
+    "Computing",
+    "Calculating",
+    "Analyzing",
+    "Synthesizing",
+    "Ideating",
+    "Brainstorming",
+    "Reasoning"
+  ].freeze
+end