ruby-claw 0.1.2 → 0.2.0

data/lib/claw/tui/chat_panel.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "glamour"
+
+module Claw
+  module TUI
+    # Left panel: chat history + input box.
+    # Uses Bubbles::Viewport for scrollable content and Glamour for markdown rendering.
+    module ChatPanel
+      def self.render(model, width, height)
+        # Reserve 3 lines for input box
+        chat_height = height - 3
+
+        # Render chat messages
+        content = render_messages(model.chat_history, width - 4)
+
+        # Set up viewport
+        viewport = model.chat_viewport
+        viewport.width = width - 4
+        viewport.height = chat_height
+        viewport.content = content
+        viewport.goto_bottom unless model.scrolled_up?
+
+        # Input box
+        input_line = render_input(model, width - 4)
+
+        # Compose with border
+        chat_view = viewport.view
+        panel = "#{chat_view}\n#{input_line}"
+
+        Styles::PANEL_BORDER.width(width).height(height).render(panel)
+      end
+
+      def self.render_messages(messages, width)
+        # Fold consecutive tool calls
+        messages = Folding.fold_tool_calls(messages)
+
+        lines = []
+        messages.each do |msg|
+          case msg[:role]
+          when :user
+            lines << Styles::USER_STYLE.render("you> #{msg[:content]}")
+          when :agent
+            rendered = begin
+              Glamour.render(msg[:content].to_s)
+            rescue
+              msg[:content].to_s
+            end
+            folded = Folding.fold_text(rendered.rstrip)
+            lines << Styles::AGENT_STYLE.render("claw> ") + folded[:display]
+          when :tool_call
+            lines << Styles::TOOL_STYLE.render("  #{msg[:icon] || "⚡"} #{msg[:detail]}")
+          when :tool_result
+            lines << Styles::RESULT_STYLE.render("  ↩ #{truncate(msg[:result].to_s, width - 6)}")
+          when :ruby
+            highlighted = InputHandler.highlight(msg[:content].to_s)
+            lines << Styles::RUBY_STYLE.render("=> #{highlighted}")
+          when :error
+            lines << Styles::ERROR_STYLE.render("error: #{msg[:content]}")
+          when :system
+            lines << Styles::TOOL_STYLE.render("  #{msg[:content]}")
+          end
+        end
+        lines.join("\n")
+      end
+
+      def self.render_input(model, width)
+        prompt = model.mode == :plan ? "plan> " : "claw> "
+        cursor = model.input_focused? ? "█" : ""
+        text = "#{prompt}#{model.input_text}#{cursor}"
+        Lipgloss::Style.new.foreground(Styles::CYAN).width(width).render(text)
+      end
+
+      def self.truncate(str, max)
+        str.length > max ? "#{str[0, max - 3]}..." : str
+      end
+
+      private_class_method :render_messages, :render_input, :truncate
+    end
+  end
+end

data/lib/claw/tui/command_bar.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Claw
+  module TUI
+    # Bottom bar: slash command hints + keyboard shortcuts.
+    module CommandBar
+      HINTS = %w[/snapshot /rollback /diff /history /status /evolve /plan /role].freeze
+
+      def self.render(model, width)
+        left = HINTS.join("  ")
+        right = "ctrl+c quit"
+        left_w, _ = Lipgloss.size(left)
+        right_w, _ = Lipgloss.size(right)
+        spacing = width - left_w - right_w - 2
+        spacing = 1 if spacing < 1
+
+        text = "#{left}#{" " * spacing}#{right}"
+        Styles::COMMAND_BAR.width(width).render(text)
+      end
+    end
+  end
+end

data/lib/claw/tui/file_card.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Claw
+  module TUI
+    # Detect @filename references in user input and render file cards.
+    module FileCard
+      # Pattern to match @filename references (supports glob patterns).
+      FILE_REF_PATTERN = /@([\w.*\/\-]+(?:\.\w+)?)/
+
+      # Extract file references from input text.
+      #
+      # @param input [String] user input
+      # @return [Array<String>] list of file reference patterns
+      def self.extract_refs(input)
+        input.scan(FILE_REF_PATTERN).flatten
+      end
+
+      # Resolve a file reference to actual file paths.
+      # Supports glob patterns like @*.rb.
+      #
+      # @param ref [String] file reference (e.g., "user.rb" or "*.rb")
+      # @return [Array<String>] resolved file paths
+      def self.resolve(ref)
+        if ref.include?("*")
+          Dir.glob(ref)
+        elsif File.exist?(ref)
+          [ref]
+        else
+          []
+        end
+      end
+
+      # Render a compact file card for display.
+      #
+      # @param path [String] file path
+      # @return [String] rendered card
+      def self.render_card(path)
+        return "  (file not found: #{path})" unless File.exist?(path)
+
+        stat = File.stat(path)
+        ext = File.extname(path).delete(".")
+        lines = File.readlines(path).size rescue 0
+        size = format_size(stat.size)
+        lang = language_for(ext)
+
+        card = Lipgloss::Style.new
+          .border(:rounded)
+          .border_foreground(Styles::DIM_GRAY)
+          .padding(0, 1)
+          .render("#{path} | #{lines} lines | #{lang} | #{size}")
+
+        card
+      end
+
+      # Read file content for injection into LLM context.
+      #
+      # @param path [String] file path
+      # @return [String] file content (truncated if large)
+      def self.read_for_context(path)
+        return "" unless File.exist?(path)
+
+        content = File.read(path, 50_001) || ""
+        if content.length > 50_000
+          content = content[0, 50_000] + "\n... (truncated)"
+        end
+        "# File: #{path}\n```\n#{content}\n```"
+      end
+
+      # --- Helpers ---
+
+      def self.format_size(bytes)
+        return "#{bytes}B" if bytes < 1024
+        return "#{(bytes / 1024.0).round(1)}KB" if bytes < 1024 * 1024
+        "#{(bytes / (1024.0 * 1024)).round(1)}MB"
+      end
+
+      def self.language_for(ext)
+        { "rb" => "Ruby", "py" => "Python", "js" => "JavaScript", "ts" => "TypeScript",
+          "rs" => "Rust", "go" => "Go", "java" => "Java", "c" => "C", "cpp" => "C++",
+          "md" => "Markdown", "json" => "JSON", "yml" => "YAML", "yaml" => "YAML",
+          "sh" => "Shell", "sql" => "SQL", "html" => "HTML", "css" => "CSS"
+        }.fetch(ext, ext.upcase)
+      end
+
+      private_class_method :format_size, :language_for
+    end
+  end
+end

data/lib/claw/tui/folding.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Claw
+  module TUI
+    # Content folding for Claude Code-style UX:
+    # - Large text blocks collapsed
+    # - Consecutive same-type tool calls collapsed
+    # - Colored diff rendering
+    module Folding
+      # Fold text that exceeds a line threshold.
+      #
+      # @param text [String] the text to potentially fold
+      # @param threshold [Integer] max lines before folding (default 10)
+      # @return [Hash] { folded: bool, display: String, full: String }
+      def self.fold_text(text, threshold: 10)
+        lines = text.lines
+        if lines.size <= threshold
+          { folded: false, display: text, full: text }
+        else
+          preview = lines[0, 3].join
+          summary = "[+#{lines.size - 3} more lines · Ctrl+E to expand]"
+          display = "#{preview}#{Styles::TOOL_STYLE.render(summary)}"
+          { folded: true, display: display, full: text }
+        end
+      end
+
+      # Fold consecutive same-type tool calls into a summary.
+      #
+      # @param calls [Array<Hash>] tool call messages ({ role: :tool_call, ... })
+      # @return [Array<Hash>] folded messages (may be shorter)
+      def self.fold_tool_calls(calls)
+        return calls if calls.size <= 2
+
+        groups = calls.chunk { |c| c[:detail]&.split("(")&.first || c[:detail] }
+        groups.flat_map do |tool_name, group|
+          if group.size > 2
+            targets = group.map { |c| c[:detail].to_s.split("(").last&.tr(")", "") || "" }
+            summary = "#{group.size}x #{tool_name} (#{targets.first(3).join(', ')}#{targets.size > 3 ? ', ...' : ''})"
+            [{ role: :tool_call, icon: "⚡", detail: summary,
+               folded: true, children: group }]
+          else
+            group
+          end
+        end
+      end
+
+      # Render a diff hash with colors (green for additions, red for removals).
+      #
+      # @param diff_text [String] unified diff text
+      # @return [String] colored diff
+      def self.render_diff(diff_text)
+        diff_text.lines.map do |line|
+          case line[0]
+          when "+"
+            Lipgloss::Style.new.foreground("#32CD32").render(line.rstrip)
+          when "-"
+            Lipgloss::Style.new.foreground("#FF4444").render(line.rstrip)
+          when "~"
+            Lipgloss::Style.new.foreground("#FFD700").render(line.rstrip)
+          else
+            line.rstrip
+          end
+        end.join("\n")
+      end
+
+      # Render a resource diff hash from Runtime#diff.
+      #
+      # @param diffs [Hash] { resource_name => diff_string }
+      # @return [String] colored output
+      def self.render_resource_diff(diffs)
+        sections = diffs.map do |name, diff_text|
+          header = Lipgloss::Style.new.bold(true).render("#{name}:")
+          colored = render_diff(diff_text)
+          "#{header}\n#{colored}"
+        end
+        sections.join("\n\n")
+      end
+    end
+  end
+end

data/lib/claw/tui/input_handler.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Claw
+  module TUI
+    # Enhanced input handling: syntax highlighting, tab completion, auto-indent.
+    module InputHandler
+      # Syntax highlight Ruby code using basic token patterns.
+      # Returns ANSI-colored string.
+      def self.highlight(code)
+        code
+          .gsub(/\b(def|end|class|module|if|else|elsif|unless|do|while|until|for|begin|rescue|ensure|return|yield|raise|require|require_relative|include|extend|attr_\w+)\b/) { "\e[35m#{$&}\e[0m" }
+          .gsub(/\b(true|false|nil|self)\b/) { "\e[36m#{$&}\e[0m" }
+          .gsub(/(#.*)$/) { "\e[2m#{$1}\e[0m" }
+          .gsub(/(:[\w!?]+)/) { "\e[33m#{$1}\e[0m" }
+          .gsub(/"([^"]*)"/) { "\e[32m\"#{$1}\"\e[0m" }
+          .gsub(/'([^']*)'/) { "\e[32m'#{$1}'\e[0m" }
+          .gsub(/\b(\d+\.?\d*)\b/) { "\e[34m#{$1}\e[0m" }
+      end
+
+      # Generate tab completion candidates from binding, memory, and commands.
+      #
+      # @param prefix [String] current input prefix
+      # @param binding [Binding] caller's binding
+      # @param memory [Claw::Memory, nil] memory for fact keywords
+      # @return [Array<String>] completion candidates
+      def self.completions(prefix, binding:, memory: nil)
+        candidates = []
+
+        # Local variables
+        candidates.concat(binding.local_variables.map(&:to_s))
+
+        # Receiver methods (filtered)
+        receiver = binding.eval("self")
+        candidates.concat(
+          receiver.methods.map(&:to_s).reject { |m| m.start_with?("_") || m.include?("!") && m.length < 3 }
+        )
+
+        # Slash commands
+        candidates.concat(Claw::Commands::COMMANDS.map { |c| "/#{c}" })
+        candidates.concat(%w[/plan /role /ls /cd /source /doc /find /whereami /shell /memory /forget])
+
+        # Memory keywords
+        if memory
+          memory.long_term.each do |m|
+            words = m[:content].to_s.split(/\s+/).select { |w| w.length > 3 }
+            candidates.concat(words)
+          end
+        end
+
+        candidates.uniq.select { |c| c.start_with?(prefix) }.sort
+      end
+
+      # Check if code has unclosed blocks (for multi-line continuation).
+      def self.incomplete?(code)
+        RubyVM::InstructionSequence.compile(code)
+        false
+      rescue SyntaxError => e
+        e.message.include?("unexpected end-of-input") ||
+          e.message.include?("unterminated")
+      end
+
+      # Calculate auto-indent level based on code structure.
+      #
+      # @param code [String] current multi-line buffer
+      # @return [Integer] number of spaces to indent
+      def self.indent_level(code)
+        opens = code.scan(/\b(def|class|module|if|unless|while|until|for|do|begin|case)\b/).size
+        closes = code.scan(/\bend\b/).size
+        [(opens - closes) * 2, 0].max
+      end
+    end
+  end
+end

data/lib/claw/tui/layout.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Claw
+  module TUI
+    # Composes the 4-zone TUI layout: top status bar, left chat, right status, bottom commands.
+    module Layout
+      CHAT_RATIO = 0.65
+
+      def self.render(model, width, height)
+        # Top status bar: 1 line
+        top = StatusBar.render(model, width)
+        _, top_h = Lipgloss.size(top)
+
+        # Bottom command bar: 1 line
+        bottom = CommandBar.render(model, width)
+        _, bottom_h = Lipgloss.size(bottom)
+
+        # Middle area
+        middle_h = height - top_h - bottom_h
+        middle_h = 6 if middle_h < 6
+
+        left_w = (width * CHAT_RATIO).to_i
+        right_w = width - left_w
+
+        left = ChatPanel.render(model, left_w, middle_h)
+        right = StatusPanel.render(model, right_w, middle_h)
+
+        middle = Lipgloss.join_horizontal(Lipgloss::TOP, left, right)
+
+        Lipgloss.join_vertical(Lipgloss::LEFT, top, middle, bottom)
+      end
+    end
+  end
+end

data/lib/claw/tui/messages.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Claw
+  module TUI
+    # MVU message types sent between components and the model.
+
+    # Agent emitted a text chunk (streaming).
+    AgentTextMsg = Struct.new(:text, keyword_init: true)
+
+    # Agent started a tool call.
+    ToolCallMsg = Struct.new(:name, :input, keyword_init: true)
+
+    # Agent finished a tool call.
+    ToolResultMsg = Struct.new(:name, :result, keyword_init: true)
+
+    # Agent execution completed.
+    ExecutionDoneMsg = Struct.new(:result, :trace, keyword_init: true)
+
+    # Agent execution failed.
+    ExecutionErrorMsg = Struct.new(:error, keyword_init: true)
+
+    # Runtime state changed (idle/thinking/executing_tool/failed).
+    StateChangeMsg = Struct.new(:old_state, :new_state, :step, keyword_init: true)
+
+    # Tick for spinner/progress animations.
+    TickMsg = Struct.new(:time, keyword_init: true)
+
+    # Command result from a slash command.
+    CommandResultMsg = Struct.new(:result, :cmd, keyword_init: true)
+  end
+end