legion-tty 0.2.0

data/lib/legion/tty/background/scanner.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'fileutils'
+
+module Legion
+  module TTY
+    module Background
+      # rubocop:disable Metrics/ClassLength
+      class Scanner
+        MAX_DEPTH = 3
+
+        SERVICES = {
+          rabbitmq: 5672,
+          redis: 6379,
+          memcached: 11_211,
+          vault: 8200,
+          postgres: 5432
+        }.freeze
+
+        CONFIG_FILES = %w[.env Gemfile package.json Dockerfile].freeze
+
+        LANGUAGE_MAP = {
+          '.rb' => 'Ruby',
+          '.py' => 'Python',
+          '.js' => 'JavaScript',
+          '.ts' => 'TypeScript',
+          '.go' => 'Go',
+          '.java' => 'Java',
+          '.rs' => 'Rust',
+          '.tf' => 'Terraform',
+          '.sh' => 'Shell'
+        }.freeze
+
+        def initialize(base_dirs: nil, logger: nil)
+          @base_dirs = base_dirs || [File.expand_path('~')]
+          @log = logger
+        end
+
+        def scan_services
+          SERVICES.each_with_object({}) do |(name, port), result|
+            result[name] = { name: name.to_s, port: port, running: port_open?('127.0.0.1', port) }
+          end
+        end
+
+        def scan_git_repos
+          @base_dirs.flat_map { |base| collect_repos(base) }
+        end
+
+        def scan_shell_history
+          lines = read_history_lines
+          tally_commands(lines).sort_by { |_, v| -v }.first(20).to_h
+        end
+
+        def scan_config_files
+          @base_dirs.flat_map do |base|
+            CONFIG_FILES.map { |name| File.join(base, name) }.select { |p| File.exist?(p) }
+          end
+        end
+
+        def scan_all
+          { services: scan_services, repos: scan_git_repos, tools: scan_shell_history,
+            configs: scan_config_files }
+        end
+
+        def run_async(queue)
+          Thread.new do
+            @log&.log('scanner', "starting scan of #{@base_dirs.join(', ')}")
+            t0 = Time.now
+            data = scan_all
+            elapsed = ((Time.now - t0) * 1000).round
+            @log&.log('scanner', "scan complete in #{elapsed}ms")
+            queue.push({ type: :scan_complete, data: data })
+          rescue StandardError => e
+            @log&.log('scanner', "ERROR: #{e.class}: #{e.message}")
+            queue.push({ type: :scan_error, error: e.message })
+          end
+        end
+
+        private
+
+        def port_open?(host, port)
+          ::Socket.tcp(host, port, connect_timeout: 1) { true }
+        rescue StandardError
+          false
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def collect_repos(base, depth = 0)
+          return [] unless File.directory?(base)
+          return [build_repo_entry(base)] if File.directory?(File.join(base, '.git'))
+          return [] if depth >= MAX_DEPTH
+
+          Dir.children(base).each_with_object([]) do |child, acc|
+            next if child.start_with?('.')
+
+            child_path = File.join(base, child)
+            acc.concat(collect_repos(child_path, depth + 1)) if File.directory?(child_path)
+          rescue StandardError
+            next
+          end
+        rescue StandardError
+          []
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def build_repo_entry(path)
+          { path: path, name: File.basename(path), remote: git_remote(path),
+            branch: git_branch(path), language: detect_language(path) }
+        end
+
+        def git_remote(path)
+          out = `git -C #{path.shellescape} remote get-url origin 2>/dev/null`.strip
+          out.empty? ? nil : out
+        rescue StandardError
+          nil
+        end
+
+        def git_branch(path)
+          out = `git -C #{path.shellescape} rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+          out.empty? ? nil : out
+        rescue StandardError
+          nil
+        end
+
+        def detect_language(path)
+          ext_counts = Hash.new(0)
+          Dir.glob(File.join(path, '**', '*')).each do |f|
+            ext = File.extname(f)
+            ext_counts[ext] += 1 if File.file?(f) && !ext.empty?
+          end
+          LANGUAGE_MAP[ext_counts.max_by { |_, v| v }&.first]
+        end
+
+        def read_history_lines
+          %w[~/.zsh_history ~/.bash_history].flat_map do |path|
+            full = File.expand_path(path)
+            next [] unless File.exist?(full)
+
+            File.readlines(full, encoding: 'utf-8', chomp: true).last(500)
+          rescue StandardError
+            []
+          end
+        end
+
+        def tally_commands(lines)
+          lines.each_with_object(Hash.new(0)) do |line, counts|
+            cmd = extract_command(line)
+            counts[cmd] += 1 if cmd && !cmd.empty?
+          end
+        end
+
+        def extract_command(line)
+          line.sub(/^: \d+:\d+;/, '').split.first
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/legion/tty/boot_logger.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Legion
+  module TTY
+    class BootLogger
+      LOG_DIR = File.expand_path('~/.legionio/logs')
+      LOG_FILE = File.join(LOG_DIR, 'tty-boot.log')
+
+      def initialize(path: LOG_FILE)
+        @path = path
+        FileUtils.mkdir_p(File.dirname(@path))
+        File.write(@path, '')
+        log('boot', 'legion-tty boot logger started')
+      end
+
+      def log(source, message)
+        ts = Time.now.strftime('%H:%M:%S.%L')
+        line = "[#{ts}] [#{source}] #{message}\n"
+        File.open(@path, 'a') { |f| f.write(line) }
+      end
+
+      def log_hash(source, label, hash)
+        log(source, "#{label}:")
+        hash.each do |k, v|
+          log(source, "  #{k}: #{v.inspect}")
+        end
+      end
+
+      attr_reader :path
+    end
+  end
+end

data/lib/legion/tty/components/digital_rain.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative '../theme'
+
+module Legion
+  module TTY
+    module Components
+      # rubocop:disable Metrics/ClassLength
+      class DigitalRain
+        # rubocop:disable Naming/VariableNumber
+        FADE_SHADES = %i[
+          purple_12 purple_11 purple_10 purple_9 purple_8
+          purple_7 purple_6 purple_5 purple_4 purple_3
+          purple_2 purple_1
+        ].freeze
+
+        HEAD_COLOR = :purple_17
+        # rubocop:enable Naming/VariableNumber
+
+        FALLBACK_NAMES = %w[
+          hippocampus amygdala prefrontal-cortex cerebellum thalamus hypothalamus
+          brainstem synapse apollo tasker scheduler node health telemetry
+          conditioner transformer memory dream cortex glia neuron dendrite axon receptor
+        ].freeze
+
+        attr_reader :columns, :width, :height
+
+        def initialize(width:, height:, extensions: nil, density: 0.7)
+          @width = width
+          @height = height
+          @density = density
+          @extensions = extensions || self.class.extension_names
+          @max_frames = 200
+          @frame = 0
+          @columns = build_columns
+        end
+
+        def self.extension_names
+          gems = Gem::Specification.select { |s| s.name.start_with?('lex-') }
+                                   .map { |s| s.name.sub(/^lex-/, '') }
+          gems.empty? ? FALLBACK_NAMES : gems
+        rescue StandardError
+          FALLBACK_NAMES
+        end
+
+        def tick
+          @frame += 1
+          @columns.each do |col|
+            col[:y] += col[:speed]
+            reset_column(col) if col[:y] - col[:length] > @height
+          end
+        end
+
+        def render_frame
+          grid = Array.new(@height) { Array.new(@width) { { char: ' ', color: nil } } }
+          paint_columns(grid)
+          render_grid(grid)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def run(duration_seconds: 7, fps: 18, output: $stdout)
+          require 'tty-cursor'
+          cursor = ::TTY::Cursor
+          frame_delay = 1.0 / fps
+          output.print cursor.hide
+          output.print cursor.save
+          (duration_seconds * fps).times do
+            output.print cursor.restore
+            render_frame.each { |line| output.puts line }
+            tick
+            sleep frame_delay
+          end
+        ensure
+          output.print cursor.show
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def done?
+          @frame >= @max_frames
+        end
+
+        private
+
+        def paint_columns(grid)
+          @columns.each do |col|
+            pos = col[:x]
+            next if pos >= @width
+
+            head_y = col[:y].floor
+            col[:chars].each_with_index do |ch, idx|
+              row = head_y - idx
+              next if row.negative? || row >= @height
+
+              color = pick_color(idx)
+              grid[row][pos] = { char: ch, color: color }
+            end
+          end
+        end
+
+        def render_grid(grid)
+          grid.map do |row|
+            row.map { |cell| cell[:color] ? Theme.c(cell[:color], cell[:char]) : cell[:char] }.join
+          end
+        end
+
+        def pick_color(idx)
+          return HEAD_COLOR if idx.zero?
+
+          idx < FADE_SHADES.size ? FADE_SHADES[idx] : FADE_SHADES.last
+        end
+
+        def build_columns
+          count = [(@width * @density).ceil, 1].max
+          (0...@width).to_a.sample(count).map { |pos| new_column(pos) }
+        end
+
+        def new_column(pos)
+          { x: pos, y: rand(-@height..0).to_f, speed: rand(0.3..1.0), length: rand(4..14), chars: build_chars }
+        end
+
+        def reset_column(col)
+          col[:y] = rand(-@height..-1).to_f
+          col[:speed] = rand(0.3..1.0)
+          col[:length] = rand(4..14)
+          col[:chars] = build_chars
+        end
+
+        def build_chars
+          source = @extensions.sample || 'legion'
+          chars = source.chars.reject { |chr| chr == '-' }
+          chars = ('a'..'z').to_a if chars.empty?
+          Array.new(14) { chars.sample }
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/legion/tty/components/input_bar.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../theme'
+
+module Legion
+  module TTY
+    module Components
+      class InputBar
+        def initialize(name: 'User', reader: nil)
+          @name = name
+          @reader = reader || build_default_reader
+          @thinking = false
+        end
+
+        def prompt_string
+          "#{Theme.c(:accent, @name)} #{Theme.c(:primary, '>')} "
+        end
+
+        def read_line
+          @reader.read_line(prompt_string)
+        end
+
+        def show_thinking
+          @thinking = true
+        end
+
+        def clear_thinking
+          @thinking = false
+        end
+
+        def thinking?
+          @thinking
+        end
+
+        private
+
+        def build_default_reader
+          require 'tty-reader'
+          ::TTY::Reader.new
+        rescue LoadError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/components/markdown_view.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'tty-markdown'
+
+module Legion
+  module TTY
+    module Components
+      module MarkdownView
+        def self.render(text, width: 80)
+          ::TTY::Markdown.parse(text, width: width)
+        rescue StandardError => e
+          "#{text}\n(markdown render error: #{e.message})"
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/components/message_stream.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative '../theme'
+
+module Legion
+  module TTY
+    module Components
+      class MessageStream
+        attr_reader :messages, :scroll_offset
+
+        def initialize
+          @messages = []
+          @scroll_offset = 0
+        end
+
+        def add_message(role:, content:)
+          @messages << { role: role, content: content, tool_panels: [] }
+        end
+
+        def append_streaming(text)
+          return if @messages.empty?
+
+          @messages.last[:content] = @messages.last[:content] + text
+        end
+
+        def add_tool_panel(panel)
+          return if @messages.empty?
+
+          @messages.last[:tool_panels] << panel
+        end
+
+        def scroll_up(lines = 1)
+          @scroll_offset += lines
+        end
+
+        def scroll_down(lines = 1)
+          @scroll_offset = [@scroll_offset - lines, 0].max
+        end
+
+        def render(width:, height:)
+          all_lines = build_all_lines(width)
+          total = all_lines.size
+          start_idx = [total - height - @scroll_offset, 0].max
+          start_idx = [start_idx, total].min
+          all_lines[start_idx, height] || []
+        end
+
+        private
+
+        def build_all_lines(width)
+          @messages.flat_map { |msg| render_message(msg, width) }
+        end
+
+        def render_message(msg, width)
+          role_lines(msg) + panel_lines(msg, width)
+        end
+
+        def role_lines(msg)
+          case msg[:role]
+          when :user then user_lines(msg)
+          when :assistant then assistant_lines(msg)
+          when :system then system_lines(msg)
+          else []
+          end
+        end
+
+        def user_lines(msg)
+          prefix = Theme.c(:accent, 'You')
+          ['', "#{prefix}: #{msg[:content]}"]
+        end
+
+        def assistant_lines(msg)
+          ['', *msg[:content].split("\n")]
+        end
+
+        def system_lines(msg)
+          msg[:content].split("\n").map { |l| "  #{Theme.c(:muted, l)}" }
+        end
+
+        def panel_lines(msg, width)
+          msg[:tool_panels].flat_map { |panel| panel.render(width: width).split("\n") }
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/components/status_bar.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative '../theme'
+
+module Legion
+  module TTY
+    module Components
+      class StatusBar
+        def initialize
+          @state = { model: nil, tokens: 0, cost: 0.0, session: 'default' }
+        end
+
+        def update(**fields)
+          @state.merge!(fields)
+        end
+
+        def render(width:)
+          segments = build_segments
+          separator = Theme.c(:muted, ' | ')
+          line = segments.join(separator)
+          plain_length = strip_ansi(line).length
+          if plain_length < width
+            line + (' ' * (width - plain_length))
+          else
+            truncate_to_width(line, width)
+          end
+        end
+
+        private
+
+        def build_segments
+          [
+            model_segment,
+            tokens_segment,
+            cost_segment,
+            session_segment
+          ].compact
+        end
+
+        def model_segment
+          Theme.c(:accent, @state[:model]) if @state[:model]
+        end
+
+        def tokens_segment
+          Theme.c(:secondary, "#{format_number(@state[:tokens])} tokens") if @state[:tokens].to_i.positive?
+        end
+
+        def cost_segment
+          Theme.c(:success, format('$%.3f', @state[:cost])) if @state[:cost].to_f.positive?
+        end
+
+        def session_segment
+          Theme.c(:muted, @state[:session]) if @state[:session]
+        end
+
+        def format_number(num)
+          num.to_s.chars.reverse.each_slice(3).map(&:join).join(',').reverse
+        end
+
+        def strip_ansi(str)
+          str.gsub(/\e\[[0-9;]*m/, '')
+        end
+
+        def truncate_to_width(str, width)
+          plain = strip_ansi(str)
+          return str if plain.length <= width
+
+          result = +''
+          visible = 0
+          idx = 0
+          while idx < str.length && visible < width
+            if str[idx] == "\e"
+              jdx = str.index('m', idx)
+              if jdx
+                result << str[idx..jdx]
+                idx = jdx + 1
+                next
+              end
+            end
+            result << str[idx]
+            visible += 1
+            idx += 1
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/components/token_tracker.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Components
+      class TokenTracker
+        PRICING = {
+          'claude' => { input: 0.003, output: 0.015 },
+          'openai' => { input: 0.005, output: 0.015 },
+          'gemini' => { input: 0.001, output: 0.002 },
+          'azure' => { input: 0.005, output: 0.015 },
+          'local' => { input: 0.0, output: 0.0 }
+        }.freeze
+
+        attr_reader :total_input_tokens, :total_output_tokens, :total_cost
+
+        def initialize(provider: 'claude')
+          @provider = provider
+          @total_input_tokens = 0
+          @total_output_tokens = 0
+          @total_cost = 0.0
+        end
+
+        def track(input_tokens:, output_tokens:)
+          @total_input_tokens += input_tokens.to_i
+          @total_output_tokens += output_tokens.to_i
+          rates = PRICING[@provider] || PRICING['claude']
+          @total_cost += (input_tokens.to_i * rates[:input] / 1000.0) + (output_tokens.to_i * rates[:output] / 1000.0)
+        end
+
+        def summary
+          input = format_number(@total_input_tokens)
+          output = format_number(@total_output_tokens)
+          cost = format('%.4f', @total_cost)
+          "Tokens: #{input} in / #{output} out | Cost: $#{cost}"
+        end
+
+        private
+
+        def format_number(num)
+          num.to_s.chars.reverse.each_slice(3).map(&:join).join(',').reverse
+        end
+      end
+    end
+  end
+end