octo-agent 0.11.2

data/lib/octo/ui2/view_renderer.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require_relative "components/message_component"
+require_relative "components/tool_component"
+require_relative "components/common_component"
+require_relative "markdown_renderer"
+
+module Octo
+  module UI2
+    # ViewRenderer coordinates all UI components and provides a unified rendering interface
+    class ViewRenderer
+      def initialize
+        @message_component = Components::MessageComponent.new
+        @tool_component = Components::ToolComponent.new
+        @common_component = Components::CommonComponent.new
+      end
+
+      # Render a user message
+      # @param content [String] Message content
+      # @param timestamp [Time, nil] Optional timestamp
+      # @param files [Array<Hash>] Optional file hashes { name:, mime_type:, ... }
+      # @return [String] Rendered message
+      def render_user_message(content, timestamp: nil, files: [])
+        @message_component.render(
+          role: "user",
+          content: content,
+          timestamp: timestamp,
+          files: files
+        )
+      end
+
+      # Render an assistant message
+      # @param content [String] Message content
+      # @param timestamp [Time, nil] Optional timestamp
+      # @return [String] Rendered message
+      def render_assistant_message(content, timestamp: nil)
+        # Render markdown if content contains markdown syntax
+        rendered_content = if MarkdownRenderer.markdown?(content)
+          MarkdownRenderer.render(content)
+        else
+          content
+        end
+
+        @message_component.render(
+          role: "assistant",
+          content: rendered_content,
+          timestamp: timestamp
+        )
+      end
+
+      # Render a system message
+      # @param content [String] Message content
+      # @param timestamp [Time, nil] Optional timestamp
+      # @param prefix_newline [Boolean] Whether to add newline before message
+      # @return [String] Rendered message
+      def render_system_message(content, timestamp: nil, prefix_newline: true)
+        @message_component.render(
+          role: "system",
+          content: content,
+          timestamp: timestamp,
+          prefix_newline: prefix_newline
+        )
+      end
+
+      # Render a tool call
+      # @param tool_name [String] Tool name
+      # @param formatted_call [String] Formatted call description
+      # @return [String] Rendered tool call
+      def render_tool_call(tool_name:, formatted_call:)
+        @tool_component.render(
+          type: :call,
+          tool_name: tool_name,
+          formatted_call: formatted_call
+        )
+      end
+
+      # Render a tool result
+      # @param result [String] Tool result
+      # @return [String] Rendered tool result
+      def render_tool_result(result:)
+        @tool_component.render(
+          type: :result,
+          result: result
+        )
+      end
+
+      # Render a tool error
+      # @param error [String] Error message
+      # @return [String] Rendered tool error
+      def render_tool_error(error:)
+        @tool_component.render(
+          type: :error,
+          error: error
+        )
+      end
+
+      # Render a tool denied message
+      # @param tool_name [String] Tool name
+      # @return [String] Rendered tool denied
+      def render_tool_denied(tool_name:)
+        @tool_component.render(
+          type: :denied,
+          tool_name: tool_name
+        )
+      end
+
+      # Render a tool planned message
+      # @param tool_name [String] Tool name
+      # @return [String] Rendered tool planned
+      def render_tool_planned(tool_name:)
+        @tool_component.render(
+          type: :planned,
+          tool_name: tool_name
+        )
+      end
+
+      # Render thinking indicator
+      # @return [String] Thinking indicator
+      def render_thinking
+        @common_component.render_thinking
+      end
+
+      # Render progress message (stopped state, gray)
+      # @param message [String] Progress message
+      # @return [String] Progress indicator
+      def render_progress(message)
+        @common_component.render_progress(message)
+      end
+
+      # Render working message (active state, yellow)
+      # @param message [String] Progress message
+      # @return [String] Working indicator
+      def render_working(message)
+        @common_component.render_working(message)
+      end
+
+      # Render success message
+      # @param message [String] Success message
+      # @return [String] Success message
+      def render_success(message)
+        @common_component.render_success(message)
+      end
+
+      # Render error message
+      # @param message [String] Error message
+      # @return [String] Error message
+      def render_error(message)
+        @common_component.render_error(message)
+      end
+
+      # Render warning message
+      # @param message [String] Warning message
+      # @return [String] Warning message
+      def render_warning(message)
+        @common_component.render_warning(message)
+      end
+
+      # Render task completion summary
+      # @param iterations [Integer] Number of iterations
+      # @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:, duration: nil, cache_tokens: nil, cache_requests: nil, cache_hits: nil)
+        @common_component.render_task_complete(
+          iterations: iterations,
+          duration: duration,
+          cache_tokens: cache_tokens,
+          cache_requests: cache_requests,
+          cache_hits: cache_hits
+        )
+      end
+
+    end
+  end
+end

data/lib/octo/ui2.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# UI2 - MVC-based terminal UI system for Octo
+# Provides split-screen interface with scrollable output and fixed input
+
+require_relative "ui2/thinking_verbs"
+require_relative "ui2/progress_indicator"
+require_relative "ui2/terminal_detector"
+require_relative "ui2/theme_manager"
+require_relative "ui2/screen_buffer"
+require_relative "ui2/layout_manager"
+require_relative "ui2/view_renderer"
+require_relative "ui2/ui_controller"
+
+require_relative "ui2/components/base_component"
+require_relative "ui2/components/input_area"
+require_relative "ui2/components/message_component"
+require_relative "ui2/components/tool_component"
+require_relative "ui2/components/common_component"
+require_relative "ui2/components/welcome_banner"
+require_relative "ui2/components/modal_component"
+
+module Octo
+  module UI2
+    # Version of the UI2 system
+    VERSION = "1.0.0"
+
+    # Quick start: Create a UI controller and run
+    # @param config [Hash] Optional configuration (working_dir, mode, model)
+    # @example
+    #   controller = Octo::UI2::UIController.new
+    #   controller.on_input { |input| puts "Got: #{input}" }
+    #   controller.start
+    def self.start(config = {}, &block)
+      controller = UIController.new(config)
+      controller.on_input(&block) if block_given?
+      controller.start
+    end
+  end
+end

data/lib/octo/ui_interface.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Octo
+  # UIInterface defines the standard interface between Agent/CLI and UI implementations.
+  # All UI controllers (UIController, JsonUIController) must implement these methods.
+  module UIInterface
+    # === Output display ===
+    # @param content [String] text portion of the assistant reply (file:// links stripped)
+    # @param files   [Array<Hash>] extracted file refs: [{ name:, path:, inline: }]
+    def show_assistant_message(content, files:); end
+    def show_tool_call(name, args); end
+    def show_tool_result(result, ui_payload: nil); end
+    def show_tool_stdout(lines); end
+    def show_tool_error(error); end
+    def show_tool_args(formatted_args); end
+    def show_file_write_preview(path, is_new_file:); end
+    def show_file_edit_preview(path); end
+    def show_file_error(error_message); end
+    def show_shell_preview(command); end
+    def show_diff(old_content, new_content, max_lines: 50); end
+    def show_token_usage(token_data); end
+    def show_complete(iterations:, duration: nil, cache_stats: nil, awaiting_user_feedback: false); end
+    def append_output(content); end
+
+    # === Status messages ===
+    def show_info(message, prefix_newline: true); end
+    def show_warning(message); end
+    def show_error(message); end
+    def show_success(message); end
+    def log(message, level: :info); end
+
+    # === Progress ===
+    # Unified progress indicator with type-based display customization.
+    # progress_type: "thinking" | "retrying" | "idle_compress" | custom
+    # phase: "active" | "done"
+    # metadata: extensible hash (e.g., {attempt: 3, total: 10} for retries)
+    def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {}); end
+
+    # Update the live "thinking" progress with streamed token counts.
+    # This is *purely decorative*: it must NEVER start a new progress
+    # indicator. If no thinking progress is currently active (e.g. during
+    # idle compression, where only a quiet "Compressing..." progress is
+    # live), the call is a no-op. UI2 overrides this; other UIs delegate
+    # to show_progress.
+    def stream_thinking_progress(input_tokens:, output_tokens:)
+      show_progress(
+        progress_type: "thinking",
+        phase: "active",
+        metadata: { input_tokens: input_tokens, output_tokens: output_tokens }
+      )
+    end
+
+    # === Progress (v2: owned handles) ===
+    #
+    # Start a new progress indicator and return an owned handle. The caller
+    # is responsible for finishing it — use +with_progress+ (below) whenever
+    # possible to get ensure-based auto-close.
+    #
+    # @param message [String, nil] Initial progress message (nil picks a random thinking verb).
+    # @param style [Symbol] :primary (foreground, yellow, bumps sessionbar)
+    #   or :quiet (background, gray, no sessionbar change).
+    # @param quiet_on_fast_finish [Boolean] When true, a finish under
+    #   FAST_FINISH_THRESHOLD_SECONDS removes the progress line entirely
+    #   (preferred for per-tool wrappers so fast tools don't leave a
+    #   permanent "Executing foo… (0s)" log line). The default
+    #   implementation ignores this flag — it only affects the native
+    #   UI2::UIController + ProgressHandle path.
+    # @return [#update, #finish, #cancel] a ProgressHandle-like object.
+    #
+    # Default implementation degrades gracefully to the old show_progress API
+    # so UI implementations that haven't migrated still behave correctly.
+    def start_progress(message: nil, style: :primary, quiet_on_fast_finish: false)
+      _ = quiet_on_fast_finish # default impl doesn't honor fast-collapse
+      progress_type = style == :primary ? "thinking" : "idle_compress"
+      show_progress(message, progress_type: progress_type, phase: "active")
+      LegacyProgressHandleAdapter.new(self, progress_type: progress_type)
+    end
+
+    # Run the given block with a progress indicator active. The handle is
+    # always finished in an +ensure+ block — exceptions (including
+    # AgentInterrupted) cannot leave the ticker or entry orphaned.
+    #
+    # @yieldparam handle the progress handle
+    def with_progress(message: nil, style: :primary, quiet_on_fast_finish: false)
+      handle = start_progress(
+        message: message,
+        style: style,
+        quiet_on_fast_finish: quiet_on_fast_finish
+      )
+      begin
+        yield handle
+      ensure
+        handle.finish
+      end
+    end
+
+    # Minimal adapter that lets UIs without a native ProgressHandle still
+    # participate in the new +with_progress+ API by delegating to the old
+    # +show_progress(phase: ...)+ contract. UI2::UIController overrides
+    # +start_progress+ directly with a native ProgressHandle, so this
+    # adapter is only used by plain/json/web/channel UIs.
+    class LegacyProgressHandleAdapter
+      def initialize(ui, progress_type:)
+        @ui = ui
+        @progress_type = progress_type
+        @closed = false
+      end
+
+      def update(message: nil, metadata: nil)
+        return if @closed
+        @ui.show_progress(message, progress_type: @progress_type, phase: "active", metadata: metadata || {})
+      end
+
+      def finish(final_message: nil)
+        return if @closed
+        @closed = true
+        @ui.show_progress(final_message, progress_type: @progress_type, phase: "done")
+      end
+      alias_method :cancel, :finish
+    end
+
+    # === State updates ===
+    def update_sessionbar(tasks: nil, status: nil, latency: nil); end
+    def update_todos(todos); end
+
+    def update_background_tasks(running: 0, tasks: []); end
+    def show_background_task_notice(command: nil, handle_id: nil, status: "success"); end
+
+    def set_working_status; end
+    def set_idle_status; end
+
+    # Broadcast the count of user messages currently sitting in @inbox waiting
+    # for the next iteration-boundary drain. Web renders a small "{{n}} messages
+    # waiting" hint above the input. Emitted by Agent on two occasions:
+    #   - enqueue_user_message returned :running (msg will wait behind an in-flight run)
+    #   - drain_inbox_into_history! consumed items (count typically drops to 0)
+    # CLI / JSON / channel UIs no-op by default.
+    #
+    # @param pending [Integer] number of user_msg items still queued
+    def update_user_message_queue_status(pending: 0); end
+
+    # === Blocking interaction ===
+    def request_confirmation(message, default: true); end
+
+    # === Input control (CLI layer) ===
+    def clear_input; end
+    def set_input_tips(message, type: :info); end
+    def show_next_message_suggestion(text); end
+    def hide_next_message_suggestion; end
+
+    # === Lifecycle ===
+    def stop; end
+  end
+end

data/lib/octo/utils/arguments_parser.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Octo
+  module Utils
+    class ArgumentsParser
+      # Parse and validate tool call arguments with JSON repair capability
+      def self.parse_and_validate(call, tool_registry)
+        # 1. Try standard parsing
+        begin
+          args = JSON.parse(call[:arguments], symbolize_names: true)
+          
+          # Check if any key contains XML tags (< or >) indicating contamination
+          # Even though JSON.parse succeeded, the keys might be malformed
+          has_xml_contamination = args.keys.any? { |k| k.to_s.include?('<') || k.to_s.include?('>') }
+          
+          if has_xml_contamination
+            # Force repair even though JSON.parse succeeded
+            raise JSON::ParserError.new("Keys contain XML contamination")
+          end
+          
+          return validate_required_params(call, args, tool_registry)
+        rescue JSON::ParserError => e
+          # Continue to repair
+        end
+
+        # 2. Try simple repair
+        repaired = repair_json(call[:arguments])
+
+        begin
+          args = JSON.parse(repaired, symbolize_names: true)
+          return validate_required_params(call, args, tool_registry)
+        rescue JSON::ParserError, MissingRequiredParamsError => e
+          # 3. Repair failed or missing params, return helpful error
+          raise_helpful_error(call, tool_registry, e)
+        end
+      end
+
+
+      # Simple JSON repair: complete brackets and quotes, and remove XML contamination
+      def self.repair_json(json_str)
+
+        result = json_str.strip
+        # Step 0: Convert literal \n (backslash+n) to real newlines
+        result = result.gsub(/\\n/, "\n")
+        # Step 0.5: Unescape quotes in JSON keys and values (\" -> ")
+        # This handles cases like {"end_line\":550 or name=\"path\"
+        result = result.gsub(/\\"/, '"')
+        # Step 1: Remove XML-style parameter tags that Claude might mix in
+        # Pattern 1: </parameter> closing tags - remove completely
+        result = result.gsub(/<\/parameter>/, '')
+
+        # Pattern 2: <parameter name="key"> or <parameter name="key": opening tags -> convert to JSON key
+        # Example: \n<parameter name="end_line"> 330 -> , "end_line": 330
+        # Also handles: \n<parameter name="end_line": 330 -> , "end_line": 330
+        # result = result.gsub(/<parameter\s+name="([^"\\]+)":\s*/) { |match| ", \"#{$1}\": " }
+        # result = result.gsub(/<parameter\s+name="([^"\\]+)">/) { |match| ", \"#{$1}\":" }
+        result = result.gsub(/<parameter\s+name=\\?"([^"\\]+)\\?"[>:]?\s*/) { |match| ", \"#{$1}\": " }
+
+        # Pattern 3: Remove any remaining XML-like tags
+        result = result.gsub(/<[^>]+>/, '')
+
+        # Step 2: Clean up newlines with commas
+        # Example: 315\n, "end_line" -> 315, "end_line"
+        result = result.gsub(/\n\s*,/, ',')
+        result = result.gsub(/\n,/, ',')
+        result = result.gsub(/,\s*\n/, ',')
+
+        # Step 3: Clean up formatting issues
+        # Remove multiple consecutive commas
+        result = result.gsub(/,+/, ',')
+        # Remove trailing commas before closing braces/brackets
+        result = result.gsub(/,\s*}/, '}')
+        result = result.gsub(/,\s*\]/, ']')
+        # Remove leading commas after opening braces/brackets
+        result = result.gsub(/\{\s*,/, '{')
+        result = result.gsub(/\[\s*,/, '[')
+
+        # Step 4: Complete unclosed strings
+        result += '"' if result.count('"').odd?
+
+        # Step 5: Complete unclosed braces
+        depth = 0
+        result.each_char { |c| depth += 1 if c == '{'; depth -= 1 if c == '}' }
+        result += '}' * depth if depth > 0
+
+        result
+      end
+
+      # Validate required parameters and filter unknown parameters
+      def self.validate_required_params(call, args, tool_registry)
+        tool = tool_registry.get(call[:name])
+        required = tool.parameters&.dig(:required) || []
+        properties = tool.parameters&.dig(:properties) || {}
+
+        missing = required.reject { |param|
+          args.key?(param.to_sym) || args.key?(param.to_s)
+        }
+
+        if missing.any?
+          raise MissingRequiredParamsError.new(call[:name], missing, args.keys)
+        end
+
+        # Filter out unknown parameters to prevent errors when LLM sends extra arguments
+        known_params = properties.keys.map(&:to_sym) + properties.keys.map(&:to_s)
+        filtered_args = args.select { |key, _| known_params.include?(key) }
+
+        filtered_args
+      end
+
+      # Generate error message with tool definition
+      def self.raise_helpful_error(call, tool_registry, original_error)
+        tool = tool_registry.get(call[:name])
+        error_msg = build_error_message(call, tool, original_error)
+        raise BadArgumentsError, error_msg
+      end
+
+      def self.build_error_message(call, tool, original_error)
+        # Extract tool information
+        required_params = tool.parameters&.dig(:required) || []
+
+        # Try to parse provided parameters from incomplete JSON
+        provided_params = extract_provided_params(call[:arguments])
+
+        # Build clear error message
+        msg = []
+        msg << "Failed to parse arguments for tool '#{call[:name]}'."
+        msg << ""
+        msg << "Error: #{original_error.message}"
+        msg << ""
+
+        if provided_params.any?
+          msg << "Provided parameters: #{provided_params.join(', ')}"
+        else
+          msg << "No valid parameters could be extracted."
+        end
+
+        msg << "Required parameters: #{required_params.join(', ')}"
+        msg << ""
+        msg << "Tool definition:"
+        msg << format_tool_definition(tool)
+        msg << ""
+        msg << "Suggestions:"
+        msg << "- If the parameter value is too large (e.g., large file content), consider breaking it into smaller operations"
+        msg << "- Ensure all required parameters are provided"
+        msg << "- Simplify complex parameter values"
+
+        msg.join("\n")
+      end
+
+      # Extract parameter names from incomplete JSON
+      def self.extract_provided_params(json_str)
+        # Simple extraction: find all "key": patterns
+        json_str.scan(/"(\w+)"\s*:/).flatten.uniq
+      end
+
+      # Format tool definition (concise version)
+      def self.format_tool_definition(tool)
+        lines = []
+        lines << "  Name: #{tool.name}"
+        lines << "  Description: #{tool.description}"
+
+        if tool.parameters[:properties]
+          lines << "  Parameters:"
+          tool.parameters[:properties].each do |param, spec|
+            required_mark = tool.parameters[:required]&.include?(param.to_s) ? " (required)" : ""
+            lines << "    - #{param}#{required_mark}: #{spec[:description]}"
+          end
+        end
+
+        lines.join("\n")
+      end
+    end
+
+    # Raised when tool call arguments are malformed or missing required params.
+    class BadArgumentsError < StandardError; end
+
+    # Custom exception for missing required parameters
+    class MissingRequiredParamsError < BadArgumentsError
+      attr_reader :tool_name, :missing_params, :provided_params
+
+      def initialize(tool_name, missing_params, provided_params)
+        @tool_name = tool_name
+        @missing_params = missing_params
+        @provided_params = provided_params
+        super("Missing required parameters: #{missing_params.join(', ')}")
+      end
+    end
+  end
+end