openclacky 0.5.6 → 0.6.0

data/lib/clacky/agent_config.rb

@@ -5,19 +5,13 @@ module Clacky
     PERMISSION_MODES = [:auto_approve, :confirm_safes, :confirm_edits, :plan_only].freeze
     EDITING_TOOLS = %w[write edit].freeze
 
-    attr_accessor :model, :max_iterations, :max_cost_usd, :timeout_seconds,
-                  :permission_mode, :allowed_tools, :disallowed_tools,
+    attr_accessor :model, :permission_mode,
                   :max_tokens, :verbose, :enable_compression, :keep_recent_messages,
                   :enable_prompt_caching
 
     def initialize(options = {})
       @model = options[:model] || "gpt-3.5-turbo"
-      @max_iterations = options[:max_iterations] || 200
-      @max_cost_usd = options[:max_cost_usd] || 5.0
-      @timeout_seconds = options[:timeout_seconds] # nil means no timeout
       @permission_mode = validate_permission_mode(options[:permission_mode])
-      @allowed_tools = options[:allowed_tools]
-      @disallowed_tools = options[:disallowed_tools] || []
       @max_tokens = options[:max_tokens] || 8192
       @verbose = options[:verbose] || false
       @enable_compression = options[:enable_compression].nil? ? true : options[:enable_compression]

data/lib/clacky/cli.rb

@@ -2,11 +2,7 @@
 
 require "thor"
 require "tty-prompt"
-require "tty-spinner"
-require_relative "ui/banner"
-require_relative "ui/enhanced_prompt"
-require_relative "ui/statusbar"
-require_relative "ui/formatter"
+require_relative "ui2"
 
 module Clacky
   class CLI < Thor
@@ -42,26 +38,22 @@ module Clacky
         -a, --attach N  - Attach to session by number (e.g., -a 2) or session ID prefix (e.g., -a b6682a87)
 
       Examples:
-        $ clacky agent
-        $ clacky agent "Create a README file"
         $ clacky agent --mode=auto_approve --path /path/to/project
-        $ clacky agent --tools file_reader glob grep
-        $ clacky agent -c
-        $ clacky agent -l
-        $ clacky agent -a 2
-        $ clacky agent -a b6682a87
     LONGDESC
     option :mode, type: :string, default: "confirm_safes",
            desc: "Permission mode: auto_approve, confirm_safes, confirm_edits, plan_only"
-    option :tools, type: :array, default: ["all"], desc: "Allowed tools"
-    option :max_iterations, type: :numeric, desc: "Maximum iterations (default: 50)"
-    option :max_cost, type: :numeric, desc: "Maximum cost in USD (default: 5.0)"
-    option :verbose, type: :boolean, default: false, desc: "Show detailed output"
+    option :verbose, type: :boolean, aliases: "-v", default: false, desc: "Show detailed output"
     option :path, type: :string, desc: "Project directory path (defaults to current directory)"
     option :continue, type: :boolean, aliases: "-c", desc: "Continue most recent session"
     option :list, type: :boolean, aliases: "-l", desc: "List recent sessions"
     option :attach, type: :string, aliases: "-a", desc: "Attach to session by number or keyword"
+    option :help, type: :boolean, aliases: "-h", desc: "Show this help message"
     def agent(message = nil)
+      # Handle help option
+      if options[:help]
+        invoke :help, ["agent"]
+        return
+      end
       config = Clacky::Config.load
 
       unless config.api_key
@@ -106,8 +98,7 @@ module Clacky
       Dir.chdir(working_dir) if should_chdir
 
       begin
-        # Always run in interactive mode
-        run_agent_interactive(agent, working_dir, agent_config, message, session_manager, client)
+        run_agent_with_ui2(agent, working_dir, agent_config, message, session_manager, client)
       rescue StandardError => e
         # Save session on error
         if session_manager
@@ -136,9 +127,9 @@ module Clacky
     desc "price", "Show pricing information for AI models"
     def price
       say "\n💰 Model Pricing Information\n\n", :green
-      
+
       say "Clacky supports three pricing modes when calculating API costs:\n\n", :white
-      
+
       say "  1. ", :cyan
       say "API-provided cost", :bold
       say " (", :white
@@ -146,7 +137,7 @@ module Clacky
       say ")", :white
       say "\n     The most accurate - uses actual cost data from the API response", :white
       say "\n     Supported by: OpenRouter, LiteLLM, and other compatible proxies\n\n"
-      
+
       say "  2. ", :cyan
       say "Model-specific pricing", :bold
       say " (", :white
@@ -154,7 +145,7 @@ module Clacky
       say ")", :white
       say "\n     Uses official pricing from model providers (Claude models)", :white
       say "\n     Includes tiered pricing and prompt caching discounts\n\n"
-      
+
       say "  3. ", :cyan
       say "Default fallback pricing", :bold
       say " (", :white
@@ -162,9 +153,9 @@ module Clacky
       say ")", :white
       say "\n     Conservative estimates for unknown models", :white
       say "\n     Input: $0.50/MTok, Output: $1.50/MTok\n\n"
-      
+
       say "Priority order: API cost > Model pricing > Default pricing\n\n", :yellow
-      
+
       say "Supported models with official pricing:\n", :green
       say "  • claude-opus-4.5\n", :cyan
       say "  • claude-sonnet-4.5\n", :cyan
@@ -172,7 +163,7 @@ module Clacky
       say "  • claude-3-5-sonnet-20241022\n", :cyan
       say "  • claude-3-5-sonnet-20240620\n", :cyan
       say "  • claude-3-5-haiku-20241022\n\n", :cyan
-      
+
       say "For detailed pricing information, visit:\n", :white
       say "https://www.anthropic.com/pricing\n\n", :blue
     end
@@ -182,123 +173,10 @@ module Clacky
         AgentConfig.new(
           model: options[:model] || config.model,
           permission_mode: options[:mode].to_sym,
-          allowed_tools: options[:tools],
-          max_iterations: options[:max_iterations],
-          max_cost_usd: options[:max_cost],
           verbose: options[:verbose]
         )
       end
 
-      def prompt_for_input
-        prompt = TTY::Prompt.new
-        prompt.ask("What would you like the agent to do?", required: true)
-      end
-
-      def display_agent_event(event)
-        formatter = ui_formatter
-
-        case event[:type]
-        when :thinking
-          formatter.thinking
-        when :assistant_message
-          # Display assistant's thinking/explanation before tool calls
-          formatter.assistant_message(event[:data][:content])
-        when :tool_call
-          display_tool_call(event[:data])
-        when :observation
-          display_tool_result(event[:data])
-          # Auto-display TODO status if exists
-          display_todo_status_if_exists
-        when :answer
-          formatter.assistant_message(event[:data][:content])
-        when :tool_denied
-          formatter.tool_denied(event[:data][:name])
-        when :tool_planned
-          formatter.tool_planned(event[:data][:name])
-        when :tool_error
-          formatter.tool_error(event[:data][:error].message)
-        when :on_iteration
-          formatter.iteration(event[:data][:iteration]) if options[:verbose]
-        end
-      end
-
-      def display_tool_call(data)
-        tool_name = data[:name]
-        args_json = data[:arguments]
-
-        # Get tool instance to use its format_call method
-        tool = get_tool_instance(tool_name)
-        if tool
-          begin
-            args = JSON.parse(args_json, symbolize_names: true)
-            formatted = tool.format_call(args)
-            ui_formatter.tool_call(formatted)
-          rescue JSON::ParserError, StandardError => e
-            say "⚠️  Warning: Failed to format tool call: #{e.message}", :yellow
-            ui_formatter.tool_call("#{tool_name}(...)")
-          end
-        else
-          say "⚠️  Warning: Tool instance not found for '#{tool_name}'", :yellow
-          ui_formatter.tool_call("#{tool_name}(...)")
-        end
-
-        # Show verbose details if requested
-        if options[:verbose]
-          say "   Arguments: #{args_json[0..200]}", :white
-        end
-      end
-
-      def display_tool_result(data)
-        tool_name = data[:tool]
-        result = data[:result]
-
-        # Get tool instance to use its format_result method
-        tool = get_tool_instance(tool_name)
-        if tool
-          begin
-            summary = tool.format_result(result)
-            ui_formatter.tool_result(summary)
-          rescue StandardError => e
-            ui_formatter.tool_result("Done")
-          end
-        else
-          # Fallback for unknown tools
-          result_str = result.to_s
-          summary = result_str.length > 100 ? "#{result_str[0..100]}..." : result_str
-          ui_formatter.tool_result(summary)
-        end
-
-        # Show verbose details if requested
-        if options[:verbose] && result.is_a?(Hash)
-          say "     #{result.inspect[0..200]}", :white
-        end
-      end
-
-      def get_tool_instance(tool_name)
-        # Use metaprogramming to find tool class by name
-        # Convert tool_name to class name (e.g., "file_reader" -> "FileReader")
-        class_name = tool_name.split('_').map(&:capitalize).join
-
-        # Try to find the class in Clacky::Tools namespace
-        if Clacky::Tools.const_defined?(class_name)
-          tool_class = Clacky::Tools.const_get(class_name)
-          tool_class.new
-        else
-          nil
-        end
-      rescue NameError
-        nil
-      end
-
-      def display_todo_status_if_exists
-        return unless @current_agent
-
-        todos = @current_agent.todos
-        return if todos.empty?
-
-        ui_formatter.todo_status(todos)
-      end
-
       def validate_working_directory(path)
         working_dir = path || Dir.pwd
 
@@ -320,218 +198,6 @@ module Clacky
         working_dir
       end
 
-      def run_in_directory(directory)
-        original_dir = Dir.pwd
-
-        begin
-          Dir.chdir(directory)
-          yield
-        ensure
-          Dir.chdir(original_dir)
-        end
-      end
-
-      def run_agent_interactive(agent, working_dir, agent_config, initial_message = nil, session_manager = nil, client = nil)
-        # Store agent as instance variable for access in display methods
-        @current_agent = agent
-
-        # Initialize UI components
-        banner = ui_banner
-        prompt = ui_prompt
-        statusbar = ui_statusbar
-
-        # Show startup banner for new session
-        if agent.total_tasks == 0
-          banner.display_startup
-        end
-
-        # Show session info if continuing
-        if agent.total_tasks > 0
-          banner.display_session_continue(
-            session_id: agent.session_id[0..7],
-            created_at: Time.parse(agent.created_at).strftime('%Y-%m-%d %H:%M'),
-            tasks: agent.total_tasks,
-            cost: agent.total_cost.round(4)
-          )
-
-          # Show recent conversation history
-          display_recent_messages(agent.messages, limit: 5)
-        else
-          # Show welcome info for new session
-          banner.display_agent_welcome(
-            working_dir: working_dir,
-            mode: agent_config.permission_mode,
-            max_iterations: agent_config.max_iterations,
-            max_cost: agent_config.max_cost_usd
-          )
-        end
-
-        total_tasks = agent.total_tasks
-        total_cost = agent.total_cost
-
-        # Process initial message if provided
-        current_message = initial_message
-        current_images = []
-
-        loop do
-          # Get message from user if not provided
-          unless current_message && !current_message.strip.empty?
-            # Only show newline separator if we've completed tasks
-            # (but not right after /clear since we just showed a message)
-            say "\n" if total_tasks > 0
-
-            # Show status bar before input
-            statusbar.display(
-              working_dir: working_dir,
-              mode: agent_config.permission_mode.to_s,
-              model: agent_config.model,
-              tasks: total_tasks,
-              cost: total_cost
-            )
-
-            # Use enhanced prompt with "❯" prefix
-            result = prompt.read_input(prefix: "❯") do |display_lines|
-              # Shift+Tab pressed - toggle mode and update status bar
-              if agent_config.permission_mode == :confirm_safes
-                agent_config.permission_mode = :auto_approve
-              else
-                agent_config.permission_mode = :confirm_safes
-              end
-
-              # Update status bar (it's above the input box)
-              # display_lines includes the final newline, so we need display_lines moves to reach status bar
-              print "\e[#{display_lines}A"  # Move up to status bar line
-              print "\r\e[2K"  # Clear the status bar line
-
-              # Redisplay status bar with new mode (puts adds newline, cursor moves to next line)
-              statusbar.display(
-                working_dir: working_dir,
-                mode: agent_config.permission_mode.to_s,
-                model: agent_config.model,
-                tasks: total_tasks,
-                cost: total_cost
-              )
-
-              # Move back down to original position (display_lines - 1 because puts moved us down 1)
-              print "\e[#{display_lines - 1}B"
-            end
-            
-            # EnhancedPrompt returns:
-            # - { text: String, images: Array } for normal input
-            # - { command: Symbol } for commands
-            # - nil on EOF
-            if result.nil?
-              current_message = nil
-              current_images = []
-              break
-            elsif result[:command]
-              # Handle commands
-              case result[:command]
-              when :clear
-                # Clear session by creating a new agent
-                agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir)
-                @current_agent = agent
-                total_tasks = 0
-                total_cost = 0.0
-                ui_formatter.info("Session cleared. Starting fresh.")
-                current_message = nil
-                current_images = []
-                next
-              when :exit
-                current_message = nil
-                current_images = []
-                break
-              end
-            else
-              # Normal input with text and optional images
-              current_message = result[:text]
-              current_images = result[:images] || []
-            end
-
-            break if current_message.nil? || %w[exit quit].include?(current_message&.downcase&.strip)
-            next if current_message.strip.empty? && current_images.empty?
-
-            # Display user's message after input
-            ui_formatter.user_message(current_message)
-
-            # Display image info if images were pasted (without extra newline)
-            if current_images.any?
-              current_images.each_with_index do |img_path, idx|
-                filename = File.basename(img_path)
-                say "  📎 Image #{idx + 1}: #{filename}", :cyan
-              end
-              puts  # Add newline after all images
-            else
-              puts  # Add newline after user message if no images
-            end
-          end
-
-          total_tasks += 1
-
-          begin
-            result = agent.run(current_message, images: current_images) do |event|
-              display_agent_event(event)
-            end
-
-            total_cost += result[:total_cost_usd]
-
-            # Save session after each task with success status
-            if session_manager
-              session_manager.save(agent.to_session_data(status: :success))
-            end
-
-            # Show brief task completion
-            banner.display_task_complete(
-              iterations: result[:iterations],
-              cost: result[:total_cost_usd].round(4),
-              total_tasks: total_tasks,
-              total_cost: total_cost.round(4),
-              cost_source: result[:cost_source],
-              cache_stats: result[:cache_stats]
-            )
-          rescue Clacky::AgentInterrupted
-            # Save session on interruption
-            if session_manager
-              session_manager.save(agent.to_session_data(status: :interrupted))
-              ui_formatter.warning("Task interrupted by user (Ctrl+C)")
-              say "You can start a new task or type 'exit' to quit.\n", :yellow
-            end
-          rescue StandardError => e
-            # Save session on error
-            if session_manager
-              session_manager.save(agent.to_session_data(status: :error, error_message: e.message))
-            end
-
-            # Report the error
-            banner.display_error(e.message, details: options[:verbose] ? e.backtrace.first(3).join("\n") : nil)
-
-            # Show session saved message
-            if session_manager&.last_saved_path
-              ui_formatter.info("Session saved: #{session_manager.last_saved_path}")
-            end
-
-            # Guide user to recover
-            ui_formatter.info("To recover and retry, run: clacky agent -c")
-            say "\nOr you can continue with a new task or type 'exit' to quit.", :yellow
-          end
-
-          # Clear current_message and current_images to prompt for next input
-          current_message = nil
-          current_images = []
-        end
-
-        # Save final session state only if there were actual tasks
-        # Don't save empty sessions where user just started and exited
-        if session_manager && total_tasks > 0
-          session_manager.save(agent.to_session_data)
-        end
-
-        banner.display_goodbye(
-          total_tasks: total_tasks,
-          total_cost: total_cost.round(4)
-        )
-      end
-
       def list_sessions
         session_manager = Clacky::SessionManager.new
         working_dir = validate_working_directory(options[:path])
@@ -614,70 +280,163 @@ module Clacky
         Clacky::Agent.from_session(client, agent_config, session_data)
       end
 
-      def display_recent_messages(messages, limit: 5)
-        # Filter out user and assistant messages (exclude system and tool messages)
-        conversation_messages = messages.select { |m| m[:role] == "user" || m[:role] == "assistant" }
+      # Handle agent error/interrupt with cleanup
+      def handle_agent_exception(ui_controller, agent, session_manager, exception)
+        ui_controller.stop_progress_thread
+        ui_controller.set_idle_status
 
-        # Get the last N messages
-        recent = conversation_messages.last(limit * 2) # *2 to get user+assistant pairs
+        if exception.is_a?(Clacky::AgentInterrupted)
+          session_manager&.save(agent.to_session_data(status: :interrupted))
+          ui_controller.show_warning("Task interrupted by user")
+        else
+          error_message = "#{exception.message}\n#{exception.backtrace&.first(3)&.join("\n")}"
+          session_manager&.save(agent.to_session_data(status: :error, error_message: error_message))
+          ui_controller.show_error("Error: #{exception.message}")
+        end
+      end
 
-        if recent.empty?
-          return
+      # Run agent with UI2 split-screen interface
+      def run_agent_with_ui2(agent, working_dir, agent_config, initial_message = nil, session_manager = nil, client = nil)
+        # Create UI2 controller with configuration
+        ui_controller = UI2::UIController.new(
+          working_dir: working_dir,
+          mode: agent_config.permission_mode.to_s,
+          model: agent_config.model
+        )
+
+        # Inject UI into agent
+        agent.instance_variable_set(:@ui, ui_controller)
+
+        # Track agent thread state
+        agent_thread = nil
+
+        # Set up mode toggle handler
+        ui_controller.on_mode_toggle do |new_mode|
+          agent_config.permission_mode = new_mode.to_sym
         end
 
-        formatter = ui_formatter
-        formatter.separator("─")
-        say pastel.dim("Recent conversation history:"), :yellow
-        formatter.separator("─")
-
-        recent.each do |msg|
-          case msg[:role]
-          when "user"
-            content = truncate_message(msg[:content], 150)
-            say "  #{pastel.blue('[>>]')} You: #{content}"
-          when "assistant"
-            content = truncate_message(msg[:content], 200)
-            say "  #{pastel.green('[<<]')} Assistant: #{content}"
+        # Set up interrupt handler
+        ui_controller.on_interrupt do |input_was_empty:|
+          if (not agent_thread&.alive?) && input_was_empty
+            # Save final session state before exit
+            if session_manager && agent.total_tasks > 0
+              session_data = agent.to_session_data(status: :exited)
+              session_manager.save(session_data)
+
+              # Show session saved message in output area (before stopping UI)
+              session_id = session_data[:session_id][0..7]
+              ui_controller.append_output("")
+              ui_controller.append_output("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+              ui_controller.append_output("")
+              ui_controller.append_output("Session saved: #{session_id}")
+              ui_controller.append_output("Tasks completed: #{agent.total_tasks}")
+              ui_controller.append_output("Total cost: $#{agent.total_cost.round(4)}")
+              ui_controller.append_output("")
+              ui_controller.append_output("To continue this session, run:")
+              ui_controller.append_output("  clacky -a #{session_id}")
+              ui_controller.append_output("")
+            end
+
+            # Stop UI and exit
+            ui_controller.stop
+            exit(0)
+          end
+
+          if agent_thread&.alive?
+            agent_thread.raise(Clacky::AgentInterrupted, "User interrupted")
           end
+          ui_controller.input_area.clear
+          ui_controller.input_area.set_tips("Press Ctrl+C again to exit.", type: :info)
         end
 
-        formatter.separator("─")
-        say ""
-      end
+        # Set up input handler
+        ui_controller.on_input do |input, images|
+          # Handle commands
+          case input.downcase.strip
+          when "/clear"
+            # Clear session by creating a new agent
+            agent = Clacky::Agent.new(client, agent_config, working_dir: working_dir, ui: ui_controller)
+            ui_controller.show_info("Session cleared. Starting fresh.")
+            # Update session bar with reset values
+            ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+            next
+          when "/exit", "/quit"
+            ui_controller.stop
+            exit(0)
+          when "/help"
+            ui_controller.show_help
+            next
+          end
+
+          # If agent is already running, interrupt it first
+          if agent_thread&.alive?
+            agent_thread.raise(Clacky::AgentInterrupted, "New input received")
+            agent_thread.join(2) # Wait up to 2 seconds for graceful shutdown
+          end
 
-      def truncate_message(content, max_length)
-        return "" if content.nil? || content.empty?
+          # Run agent in background thread
+          agent_thread = Thread.new do
+            begin
+              # Set status to working when agent starts
+              ui_controller.set_working_status
 
-        # Remove excessive whitespace
-        cleaned = content.strip.gsub(/\s+/, ' ')
+              # Run agent (Agent will call @ui methods directly)
+              # Agent internally tracks total_tasks and total_cost
+              result = agent.run(input, images: images)
 
-        if cleaned.length > max_length
-          cleaned[0...max_length] + "..."
-        else
-          cleaned
+              # Save session after each task
+              if session_manager
+                session_manager.save(agent.to_session_data(status: :success))
+              end
+
+              # Update session bar with agent's cumulative stats
+              ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+            rescue Clacky::AgentInterrupted, StandardError => e
+              handle_agent_exception(ui_controller, agent, session_manager, e)
+            ensure
+              agent_thread = nil
+            end
+          end
         end
-      end
 
-      # UI component accessors
-      def ui_banner
-        @ui_banner ||= UI::Banner.new
-      end
+        # Initialize UI screen first
+        ui_controller.initialize_and_show_banner
 
-      def ui_prompt
-        @ui_prompt ||= UI::EnhancedPrompt.new
-      end
+        # If there's an initial message, process it
+        if initial_message && !initial_message.strip.empty?
+          ui_controller.show_user_message(initial_message)
 
-      def ui_statusbar
-        @ui_statusbar ||= UI::StatusBar.new
-      end
+          begin
+            # Set status to working when agent starts
+            ui_controller.set_working_status
 
-      def ui_formatter
-        @ui_formatter ||= UI::Formatter.new
-      end
+            result = agent.run(initial_message, images: [])
+
+            if session_manager
+              session_manager.save(agent.to_session_data(status: :success))
+            end
 
-      def pastel
-        @pastel ||= Pastel.new
+            # Update session bar with agent's cumulative stats
+            ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+          rescue Clacky::AgentInterrupted, StandardError => e
+            handle_agent_exception(ui_controller, agent, session_manager, e)
+          end
+        end
+
+        # Start input loop (blocks until exit)
+        ui_controller.start_input_loop
+
+        # Save final session state
+        if session_manager && agent.total_tasks > 0
+          session_manager.save(agent.to_session_data)
+        end
+
+        # Show goodbye message
+        say "\n👋 Goodbye! Session stats:", :green
+        say "   Tasks completed: #{agent.total_tasks}", :cyan
+        say "   Total cost: $#{agent.total_cost.round(4)}", :cyan
       end
+
     end
   end