openclacky 0.5.6 → 0.6.0

data/lib/clacky/tools/shell.rb

@@ -95,7 +95,7 @@ module Clacky
               if elapsed > soft_timeout && !soft_timeout_triggered
                 soft_timeout_triggered = true
 
-                # L1:
+                # L1: Check for interaction patterns
                 interaction = detect_interaction(stdout_buffer.string)
                 if interaction
                   Process.kill('TERM', wait_thr.pid) rescue nil
@@ -107,24 +107,6 @@ module Clacky
                     max_output_lines
                   )
                 end
-
-                # L2:
-                last_size = stdout_buffer.size
-                stdin.puts("\n") rescue nil
-                sleep 2
-
-                if stdout_buffer.size > last_size
-                  next
-                else
-                  Process.kill('TERM', wait_thr.pid) rescue nil
-                  return format_stuck_result(
-                    command,
-                    stdout_buffer.string,
-                    stderr_buffer.string,
-                    elapsed,
-                    max_output_lines
-                  )
-                end
               end
 
               break unless wait_thr.alive?
@@ -255,36 +237,6 @@ module Clacky
         MSG
       end
 
-      def format_stuck_result(command, stdout, stderr, elapsed, max_output_lines)
-        {
-          command: command,
-          stdout: truncate_output(stdout, max_output_lines),
-          stderr: truncate_output(stderr, max_output_lines),
-          exit_code: -3,
-          success: false,
-          state: 'STUCK',
-          elapsed: elapsed,
-          message: format_stuck_message(truncate_output(stdout, max_output_lines), elapsed),
-          output_truncated: output_truncated?(stdout, stderr, max_output_lines)
-        }
-      end
-
-      def format_stuck_message(output, elapsed)
-        <<~MSG
-          #{output}
-
-          #{'=' * 60}
-          [Terminal State: STUCK]
-          #{'=' * 60}
-
-          The terminal is not responding after #{elapsed.round(1)}s.
-
-          Suggested actions:
-          • Try interrupting with Ctrl+C
-          • Check if command is frozen
-        MSG
-      end
-
       def format_timeout_result(command, stdout, stderr, elapsed, type, timeout, max_output_lines)
         {
           command: command,

data/lib/clacky/tools/web_fetch.rb

@@ -40,8 +40,8 @@ module Clacky
           # Fetch the web page
           response = fetch_url(uri)
 
-          # Extract content
-          content = response.body
+          # Extract content and force UTF-8 encoding at the source
+          content = response.body.force_encoding('UTF-8').scrub('?')
           content_type = response["content-type"] || ""
 
           # Parse HTML if it's an HTML page

data/lib/clacky/tools/web_search.rb

@@ -48,14 +48,14 @@ module Clacky
         end
       end
 
-      def search_duckduckgo(query, max_results)
+      private def search_duckduckgo(query, max_results)
         # DuckDuckGo HTML search endpoint
         encoded_query = CGI.escape(query)
         url = URI("https://html.duckduckgo.com/html/?q=#{encoded_query}")
 
         # Make request with user agent
         request = Net::HTTP::Get.new(url)
-        request["User-Agent"] = "Mozilla/5.0 (compatible; Clacky/1.0)"
+        request["User-Agent"] = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
 
         response = Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: 10) do |http|
           http.request(request)
@@ -78,45 +78,57 @@ module Clacky
         ]
       end
 
-      def parse_duckduckgo_html(html, max_results)
+      private def parse_duckduckgo_html(html, max_results)
         results = []
 
-        # Simple regex-based parsing (not perfect but works for basic cases)
-        # Look for result blocks in DuckDuckGo HTML
-        html.scan(%r{<div class="result__body">.*?</div>}m).each do |block|
+        # Ensure HTML is UTF-8 encoded
+        html = html.force_encoding('UTF-8') unless html.encoding == Encoding::UTF_8
+
+        # Extract all result links and snippets
+        # Pattern: <a class="result__a" href="//duckduckgo.com/l/?uddg=ENCODED_URL...">TITLE</a>
+        links = html.scan(%r{<a[^>]*class="result__a"[^>]*href="//duckduckgo\.com/l/\?uddg=([^"&]+)[^"]*"[^>]*>(.*?)</a>}m)
+        
+        # Pattern: <a class="result__snippet">SNIPPET</a>
+        snippets = html.scan(%r{<a[^>]*class="result__snippet"[^>]*>(.*?)</a>}m)
+
+        # Combine links and snippets
+        links.each_with_index do |link_data, index|
           break if results.length >= max_results
 
-          # Extract title and URL
-          if block =~ %r{<a.*?href="//duckduckgo\.com/l/\?uddg=([^"&]+).*?".*?>(.*?)</a>}m
-            url = CGI.unescape($1)
-            title = $2.gsub(/<[^>]+>/, "").strip
-
-            # Extract snippet
-            snippet = ""
-            if block =~ %r{<a class="result__snippet".*?>(.*?)</a>}m
-              snippet = $1.gsub(/<[^>]+>/, "").strip
-            end
-
-            results << {
-              title: title,
-              url: url,
-              snippet: snippet
-            }
+          url = CGI.unescape(link_data[0]).force_encoding('UTF-8')
+          title = link_data[1].gsub(/<[^>]+>/, "").strip
+          title = CGI.unescapeHTML(title) if title.include?("&")
+
+          snippet = ""
+          if snippets[index]
+            snippet = snippets[index][0].gsub(/<[^>]+>/, "").strip
+            snippet = CGI.unescapeHTML(snippet) if snippet.include?("&")
           end
+
+          results << {
+            title: title,
+            url: url,
+            snippet: snippet
+          }
         end
 
         # If parsing failed, provide a fallback
         if results.empty?
           results << {
             title: "Web search results",
-            url: "https://duckduckgo.com/?q=#{CGI.escape(query)}",
-            snippet: "Could not parse search results. Visit the URL to see results."
+            url: "https://duckduckgo.com/",
+            snippet: "Could not parse search results. Please try again."
           }
         end
 
         results
-      rescue StandardError
-        []
+      rescue StandardError => e
+        # Return fallback on error
+        [{
+          title: "Web search error",
+          url: "https://duckduckgo.com/",
+          snippet: "Error parsing results: #{e.message}"
+        }]
       end
 
       def format_call(args)

data/lib/clacky/ui2/README.md

@@ -0,0 +1,214 @@
+# Clacky UI2 - MVC Terminal UI System
+
+A modern, MVC-based terminal UI system with split-screen layout, component-based rendering, and direct method calls for simplicity.
+
+## Features
+
+- **Split-Screen Layout**: Scrollable output area on top, fixed input area at bottom
+- **MVC Architecture**: Clean separation of concerns (Model-View-Controller)
+- **Direct Method Calls**: Agent directly calls UIController semantic methods
+- **Component-Based**: Reusable, composable UI components
+- **Scrollable Output**: Navigate through history with arrow keys
+- **Input History**: Navigate previous inputs with up/down arrows
+- **Responsive**: Handles terminal resize automatically
+- **Rich Formatting**: Colored output with Pastel integration
+
+## Architecture
+
+```
++---------------------------------------------+
+|           Business Layer (Agent)            |
+|   Agent directly calls @ui.show_xxx()       |
++-----------------------+---------------------+
+                        | Direct calls
+                        v
++---------------------------------------------+
+|        Controller Layer (UIController)      |
+|  - show_assistant_message()                 |
+|  - show_tool_call()                         |
+|  - show_tool_result()                       |
+|  - request_confirmation()                   |
++-----------------------+---------------------+
+                        | Render
+                        v
++---------------------------------------------+
+|          View Layer (ViewRenderer)          |
+|  - Components (Message, Tool, Status)       |
++---------------------------------------------+
+```
+
+## Quick Start
+
+### Agent Integration
+
+```ruby
+# Create UI controller
+ui_controller = Clacky::UI2::UIController.new(
+  working_dir: Dir.pwd,
+  mode: "confirm_safes",
+  model: "claude-3-5-sonnet"
+)
+
+# Create agent with UI injected
+agent = Clacky::Agent.new(client, config, ui: ui_controller)
+
+# Set up input handler
+ui_controller.on_input do |input, images|
+  result = agent.run(input, images: images)
+end
+
+# Start UI (blocks until exit)
+ui_controller.start
+```
+
+### UIController Semantic Methods
+
+The Agent calls these methods directly:
+
+```ruby
+# Show messages
+@ui.show_assistant_message("Hello!")
+@ui.show_user_message("Hi there", images: [])
+
+# Show tool operations
+@ui.show_tool_call("file_reader", { path: "test.rb" })
+@ui.show_tool_result("File contents...")
+@ui.show_tool_error("File not found")
+
+# Show status
+@ui.show_progress("Thinking...")
+@ui.clear_progress
+@ui.show_complete(iterations: 5, cost: 0.001)
+
+# Show info/warning/error
+@ui.show_info("Session saved")
+@ui.show_warning("Rate limited")
+@ui.show_error("Failed to connect")
+
+# Interactive confirmation
+result = @ui.request_confirmation("Allow file write?", default: true)
+# Returns: true/false for yes/no, String for feedback, nil for cancelled
+
+# Show diff
+@ui.show_diff(old_content, new_content, max_lines: 50)
+```
+
+## Components
+
+### ViewRenderer
+
+Unified interface for rendering all UI components.
+
+```ruby
+renderer = Clacky::UI2::ViewRenderer.new
+
+# Render messages
+renderer.render_user_message("Hello")
+renderer.render_assistant_message("Hi there")
+
+# Render tools
+renderer.render_tool_call(
+  tool_name: "file_reader",
+  formatted_call: "file_reader(path: 'test.rb')"
+)
+renderer.render_tool_result(result: "Success")
+
+# Render status
+renderer.render_status(
+  iteration: 5,
+  cost: 0.1234,
+  tasks_completed: 3,
+  tasks_total: 10
+)
+```
+
+### OutputArea
+
+Scrollable output buffer with automatic line wrapping.
+
+```ruby
+output = Clacky::UI2::Components::OutputArea.new(height: 20)
+
+output.append("Line 1")
+output.append("Line 2\nLine 3")
+
+output.scroll_up(5)
+output.scroll_down(2)
+output.scroll_to_top
+output.scroll_to_bottom
+
+output.at_bottom? # => true/false
+output.scroll_percentage # => 0.0 to 100.0
+```
+
+### InputArea
+
+Fixed input area with cursor support and history.
+
+```ruby
+input = Clacky::UI2::Components::InputArea.new(height: 2)
+
+input.insert_char("H")
+input.backspace
+input.cursor_left
+input.cursor_right
+
+value = input.submit # Returns and clears input
+input.history_prev   # Navigate history
+```
+
+### LayoutManager
+
+Manages screen layout and coordinates rendering.
+
+```ruby
+layout = Clacky::UI2::LayoutManager.new(
+  output_area: output,
+  input_area: input
+)
+
+layout.initialize_screen
+layout.append_output("Hello")
+layout.move_input_to_output
+layout.scroll_output_up(5)
+layout.cleanup_screen
+```
+
+## Keyboard Shortcuts
+
+- **Enter** - Submit input
+- **Ctrl+C** - Exit/Interrupt
+- **Ctrl+L** - Clear output
+- **Ctrl+U** - Clear input line
+- **Up/Down** - Scroll output (when input empty) or navigate history
+- **Left/Right** - Move cursor in input
+- **Home/End** - Jump to start/end of input
+- **Backspace** - Delete character before cursor
+- **Delete** - Delete character at cursor
+
+## Layout Structure
+
+```
++----------------------------------------+
+|         Output Area (Scrollable)       | <- Lines 0 to height-4
+|  [<<] Assistant: Hello...              |
+|  [=>] Tool: file_reader                |
+|  [<=] Result: ...                      |
+|  ...                                   |
++----------------------------------------+ <- Separator
+| [>>] Input: _                          | <- Input line
++----------------------------------------+ <- Session bar
+| Mode: confirm_safes | Tasks: 5 | $0.01 |
++----------------------------------------+
+```
+
+## Design Principles
+
+1. **Simplicity**: Agent directly calls UIController methods - no middleware
+2. **Dependency Injection**: Agent receives `ui:` parameter
+3. **Component-Based**: Reusable, testable UI components
+4. **Responsive**: Handles terminal resize and edge cases
+
+## License
+
+MIT

data/lib/clacky/ui2/components/base_component.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Clacky
+  module UI2
+    module Components
+      # BaseComponent provides common functionality for all UI components
+      class BaseComponent
+        def initialize
+          @pastel = Pastel.new
+        end
+
+        # Render component with given data
+        # @param data [Hash] Data to render
+        # @return [String] Rendered output
+        def render(data)
+          raise NotImplementedError, "Subclasses must implement render method"
+        end
+
+        # Class method to render without instantiating
+        # @param data [Hash] Data to render
+        # @return [String] Rendered output
+        def self.render(data)
+          new.render(data)
+        end
+
+        protected
+
+        # Get current theme from ThemeManager
+        # @return [Themes::BaseTheme] Current theme instance
+        def theme
+          UI2::ThemeManager.current_theme
+        end
+
+        # Format symbol with color from theme
+        # @param symbol_key [Symbol] Symbol key (e.g., :user, :assistant)
+        # @return [String] Colored symbol
+        def format_symbol(symbol_key)
+          theme.format_symbol(symbol_key)
+        end
+
+        # Format text with color from theme
+        # @param text [String] Text to format
+        # @param symbol_key [Symbol] Symbol key for color lookup
+        # @return [String] Colored text
+        def format_text(text, symbol_key)
+          theme.format_text(text, symbol_key)
+        end
+
+        # Truncate text to max length
+        # @param text [String] Text to truncate
+        # @param max_length [Integer] Maximum length
+        # @return [String] Truncated text
+        def truncate(text, max_length)
+          return "" if text.nil? || text.empty?
+
+          cleaned = text.strip.gsub(/\s+/, ' ')
+          
+          if cleaned.length > max_length
+            cleaned[0...max_length] + "..."
+          else
+            cleaned
+          end
+        end
+
+        # Wrap text to specified width
+        # @param text [String] Text to wrap
+        # @param width [Integer] Maximum width
+        # @return [Array<String>] Array of wrapped lines
+        def wrap_text(text, width)
+          return [] if text.nil? || text.empty?
+          
+          words = text.split(/\s+/)
+          lines = []
+          current_line = ""
+          
+          words.each do |word|
+            if current_line.empty?
+              current_line = word
+            elsif (current_line.length + word.length + 1) <= width
+              current_line += " #{word}"
+            else
+              lines << current_line
+              current_line = word
+            end
+          end
+          
+          lines << current_line unless current_line.empty?
+          lines
+        end
+
+        # Format timestamp
+        # @param time [Time] Time object
+        # @return [String] Formatted timestamp
+        def format_timestamp(time = Time.now)
+          time.strftime("%H:%M:%S")
+        end
+
+        # Create indented text
+        # @param text [String] Text to indent
+        # @param spaces [Integer] Number of spaces
+        # @return [String] Indented text
+        def indent(text, spaces = 2)
+          prefix = " " * spaces
+          text.split("\n").map { |line| "#{prefix}#{line}" }.join("\n")
+        end
+
+        # Format key-value pair
+        # @param key [String] Key name
+        # @param value [String] Value
+        # @return [String] Formatted key-value
+        def format_key_value(key, value)
+          "#{@pastel.cyan(key)}: #{@pastel.white(value)}"
+        end
+
+        # Create a separator line
+        # @param char [String] Character to use
+        # @param width [Integer] Width of separator
+        # @return [String] Separator line
+        def separator(char = "─", width = 80)
+          @pastel.dim(char * width)
+        end
+
+        # Format list item
+        # @param text [String] Item text
+        # @param bullet [String] Bullet character
+        # @return [String] Formatted list item
+        def format_list_item(text, bullet = "•")
+          "#{@pastel.dim(bullet)} #{@pastel.white(text)}"
+        end
+
+        # Format code block
+        # @param code [String] Code content
+        # @param language [String, nil] Language for syntax highlighting hint
+        # @return [String] Formatted code block
+        def format_code_block(code, language = nil)
+          header = language ? @pastel.dim("```#{language}") : @pastel.dim("```")
+          footer = @pastel.dim("```")
+          content = @pastel.cyan(code)
+          
+          "#{header}\n#{content}\n#{footer}"
+        end
+
+        # Format progress bar
+        # @param current [Integer] Current value
+        # @param total [Integer] Total value
+        # @param width [Integer] Bar width
+        # @return [String] Progress bar
+        def format_progress_bar(current, total, width = 20)
+          return "" if total == 0
+          
+          percentage = (current.to_f / total * 100).round(1)
+          filled = (current.to_f / total * width).round
+          empty = width - filled
+          
+          bar = @pastel.green("█" * filled) + @pastel.dim("░" * empty)
+          "#{bar} #{percentage}%"
+        end
+      end
+    end
+  end
+end

data/lib/clacky/ui2/components/common_component.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "base_component"
+
+module Clacky
+  module UI2
+    module Components
+      # CommonComponent renders common UI elements (progress, success, error, warning)
+      class CommonComponent < BaseComponent
+        # Render thinking indicator
+        # @return [String] Thinking indicator
+        def render_thinking
+          symbol = format_symbol(:thinking)
+          text = format_text("Thinking...", :thinking)
+          "#{symbol} #{text}"
+        end
+
+        # Render progress indicator
+        # @param message [String] Progress message
+        # @return [String] Progress indicator
+        def render_progress(message)
+          symbol = format_symbol(:thinking)
+          text = format_text(message, :thinking)
+          "#{symbol} #{text}"
+        end
+
+        # Render success message
+        # @param message [String] Success message
+        # @return [String] Success message
+        def render_success(message)
+          symbol = format_symbol(:success)
+          text = format_text(message, :success)
+          "#{symbol} #{text}"
+        end
+
+        # Render error message
+        # @param message [String] Error message
+        # @return [String] Error message
+        def render_error(message)
+          symbol = format_symbol(:error)
+          text = format_text(message, :error)
+          "#{symbol} #{text}"
+        end
+
+        # Render warning message
+        # @param message [String] Warning message
+        # @return [String] Warning message
+        def render_warning(message)
+          symbol = format_symbol(:warning)
+          text = format_text(message, :warning)
+          "#{symbol} #{text}"
+        end
+
+        # Render task completion summary
+        # @param iterations [Integer] Number of iterations
+        # @param cost [Float] Cost in USD
+        # @param duration [Float] Duration in seconds
+        # @param cache_tokens [Integer] Cache read tokens
+        # @param cache_requests [Integer] Total cache requests count
+        # @param cache_hits [Integer] Cache hit requests count
+        # @return [String] Formatted completion summary
+        def render_task_complete(iterations:, cost:, duration: nil, cache_tokens: nil, cache_requests: nil, cache_hits: nil)
+          lines = []
+          lines << ""
+          lines << @pastel.dim("─" * 60)
+          lines << render_success("Task Complete")
+          lines << ""
+          
+          # Display each stat on a separate line
+          lines << "  Iterations: #{iterations}"
+          lines << "  Cost: $#{cost.round(4)}"
+          lines << "  Duration: #{duration.round(1)}s" if duration
+          
+          # Display cache information if available
+          if cache_tokens && cache_tokens > 0
+            lines << "  Cache Tokens: #{cache_tokens} tokens"
+          end
+          
+          if cache_requests && cache_requests > 0
+            hit_rate = cache_hits > 0 ? ((cache_hits.to_f / cache_requests) * 100).round(1) : 0
+            lines << "  Cache Requests: #{cache_requests} (#{cache_hits} hits, #{hit_rate}% hit rate)"
+          end
+          
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end