openclacky 0.5.1 → 0.5.3

data/lib/clacky/cli.rb

@@ -3,7 +3,10 @@
 require "thor"
 require "tty-prompt"
 require "tty-spinner"
-require "readline"
+require_relative "ui/banner"
+require_relative "ui/prompt"
+require_relative "ui/statusbar"
+require_relative "ui/formatter"
 
 module Clacky
   class CLI < Thor
@@ -140,7 +143,7 @@ module Clacky
         # Report the error
         say "\n❌ Error: #{e.message}", :red
         say e.backtrace.first(5).join("\n"), :red if options[:verbose]
-        
+
         # Show session saved message
         if session_manager&.last_saved_path
           say "\n📂 Session saved: #{session_manager.last_saved_path}", :yellow
@@ -149,7 +152,7 @@ module Clacky
         # Guide user to recover
         say "\n💡 To recover and retry, run:", :yellow
         say "   clacky agent -c", :cyan
-        
+
         exit 1
       ensure
         Dir.chdir(original_dir)
@@ -214,12 +217,14 @@ module Clacky
       end
 
       def display_agent_event(event)
+        formatter = ui_formatter
+
         case event[:type]
         when :thinking
-          print "💭 "
+          formatter.thinking
         when :assistant_message
           # Display assistant's thinking/explanation before tool calls
-          say "\n💬 #{event[:data][:content]}", :white if event[:data][:content] && !event[:data][:content].empty?
+          formatter.assistant_message(event[:data][:content])
         when :tool_call
           display_tool_call(event[:data])
         when :observation
@@ -227,15 +232,15 @@ module Clacky
           # Auto-display TODO status if exists
           display_todo_status_if_exists
         when :answer
-          say "\n⏺ #{event[:data][:content]}", :white if event[:data][:content] && !event[:data][:content].empty?
+          formatter.assistant_message(event[:data][:content])
         when :tool_denied
-          say "\n⏺ Tool denied: #{event[:data][:name]}\n\n", :yellow
+          formatter.tool_denied(event[:data][:name])
         when :tool_planned
-          say "\n⏺ Planned: #{event[:data][:name]}", :blue
+          formatter.tool_planned(event[:data][:name])
         when :tool_error
-          say "\n⏺ Error: #{event[:data][:error].message}", :red
+          formatter.tool_error(event[:data][:error].message)
         when :on_iteration
-          say "\n--- Iteration #{event[:data][:iteration]} ---", :yellow if options[:verbose]
+          formatter.iteration(event[:data][:iteration]) if options[:verbose]
         end
       end
 
@@ -249,14 +254,14 @@ module Clacky
           begin
             args = JSON.parse(args_json, symbolize_names: true)
             formatted = tool.format_call(args)
-            say "\n⏺ #{formatted}", :cyan
+            ui_formatter.tool_call(formatted)
           rescue JSON::ParserError, StandardError => e
             say "⚠️  Warning: Failed to format tool call: #{e.message}", :yellow
-            say "\n⏺ #{tool_name}(...)", :cyan
+            ui_formatter.tool_call("#{tool_name}(...)")
           end
         else
           say "⚠️  Warning: Tool instance not found for '#{tool_name}'", :yellow
-          say "\n⏺ #{tool_name}(...)", :cyan
+          ui_formatter.tool_call("#{tool_name}(...)")
         end
 
         # Show verbose details if requested
@@ -274,15 +279,15 @@ module Clacky
         if tool
           begin
             summary = tool.format_result(result)
-            say "  ⎿ #{summary}", :white
+            ui_formatter.tool_result(summary)
           rescue StandardError => e
-            say "  ⎿ Done", :white
+            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
-          say "  ⎿ #{summary}", :white
+          ui_formatter.tool_result(summary)
         end
 
         # Show verbose details if requested
@@ -313,42 +318,7 @@ module Clacky
         todos = @current_agent.todos
         return if todos.empty?
 
-        # Count statuses
-        completed = todos.count { |t| t[:status] == "completed" }
-        total = todos.size
-
-        # Build progress bar
-        progress_bar = todos.map { |t| t[:status] == "completed" ? "✓" : "○" }.join
-
-        # Check if all completed
-        if completed == total
-          say "\n📋 Tasks [#{completed}/#{total}]: #{progress_bar} 🎉 All completed!", :green
-          return
-        end
-
-        # Find current and next tasks
-        current_task = todos.find { |t| t[:status] == "pending" }
-        next_task_index = todos.index(current_task)
-        next_task = next_task_index && todos[next_task_index + 1]
-
-        say "\n📋 Tasks [#{completed}/#{total}]: #{progress_bar}", :yellow
-        if current_task
-          say "   → Next: ##{current_task[:id]} - #{current_task[:task]}", :white
-        end
-        if next_task && next_task[:status] == "pending"
-          say "   ⇢ After that: ##{next_task[:id]} - #{next_task[:task]}", :white
-        end
-      end
-
-      def display_agent_result(result)
-        say "\n" + ("=" * 60), :cyan
-        say "Agent Session Complete", :green
-        say "=" * 60, :cyan
-        say "Status: #{result[:status]}", :green
-        say "Iterations: #{result[:iterations]}", :yellow
-        say "Duration: #{result[:duration_seconds].round(2)}s", :yellow
-        say "Total Cost: $#{result[:total_cost_usd]}", :yellow
-        say "=" * 60, :cyan
+        ui_formatter.todo_status(todos)
       end
 
       def validate_working_directory(path)
@@ -387,26 +357,37 @@ module Clacky
         # 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
-          say "Continuing session: #{agent.session_id[0..7]}", :cyan
-          say "Created: #{Time.parse(agent.created_at).strftime('%Y-%m-%d %H:%M')}", :cyan
-          say "Tasks completed: #{agent.total_tasks}", :cyan
-          say "Total cost: $#{agent.total_cost.round(4)}", :cyan
-          say ""
+          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
 
-        say "🤖 Starting interactive agent mode...", :green
-        say "Working directory: #{working_dir}", :cyan
-        say "Mode: #{agent_config.permission_mode}", :yellow
-        say "Max iterations: #{agent_config.max_iterations} per task", :yellow
-        say "Max cost: $#{agent_config.max_cost_usd} per task", :yellow
-        say "\nType 'exit' or 'quit' to end the session.\n", :yellow
-
-        prompt = TTY::Prompt.new
         total_tasks = agent.total_tasks
         total_cost = agent.total_cost
 
@@ -418,15 +399,26 @@ module Clacky
           unless current_message && !current_message.strip.empty?
             say "\n" if total_tasks > 0
 
-            # Use Readline for better Unicode/CJK support
-            current_message = Readline.readline("You: ", true)
+            # 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 "You:" prefix
+            current_message = prompt.read_input(prefix: "You:")
 
             break if current_message.nil? || %w[exit quit].include?(current_message&.downcase&.strip)
             next if current_message.strip.empty?
+
+            # Display user's message after input
+            ui_formatter.user_message(current_message)
           end
 
           total_tasks += 1
-          say "\n"
 
           begin
             result = agent.run(current_message) do |event|
@@ -441,17 +433,18 @@ module Clacky
             end
 
             # Show brief task completion
-            say "\n" + ("-" * 60), :cyan
-            say "✓ Task completed", :green
-            say "  Iterations: #{result[:iterations]}", :white
-            say "  Cost: $#{result[:total_cost_usd].round(4)}", :white
-            say "  Session total: #{total_tasks} tasks, $#{total_cost.round(4)}", :yellow
-            say "-" * 60, :cyan
+            banner.display_task_complete(
+              iterations: result[:iterations],
+              cost: result[:total_cost_usd].round(4),
+              total_tasks: total_tasks,
+              total_cost: total_cost.round(4),
+              cache_stats: result[:cache_stats]
+            )
           rescue Clacky::AgentInterrupted
             # Save session on interruption
             if session_manager
               session_manager.save(agent.to_session_data(status: :interrupted))
-              say "\n\n⚠️  Task interrupted by user (Ctrl+C)", :yellow
+              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
@@ -461,17 +454,15 @@ module Clacky
             end
 
             # Report the error
-            say "\n❌ Error: #{e.message}", :red
-            say e.backtrace.first(3).join("\n"), :white if options[:verbose]
-            
+            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
-              say "\n📂 Session saved: #{session_manager.last_saved_path}", :yellow
+              ui_formatter.info("Session saved: #{session_manager.last_saved_path}")
             end
 
             # Guide user to recover
-            say "\n💡 To recover and retry, run:", :yellow
-            say "   clacky agent -c", :cyan
+            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
 
@@ -484,9 +475,10 @@ module Clacky
           session_manager.save(agent.to_session_data)
         end
 
-        say "\n👋 Agent session ended", :green
-        say "Total tasks completed: #{total_tasks}", :cyan
-        say "Total cost: $#{total_cost.round(4)}", :cyan
+        banner.display_goodbye(
+          total_tasks: total_tasks,
+          total_cost: total_cost.round(4)
+        )
       end
 
       def list_sessions
@@ -582,21 +574,23 @@ module Clacky
           return
         end
 
-        say "📜 Recent conversation history:\n", :yellow
-        say "-" * 60, :white
+        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 "\n👤 You: #{content}", :cyan
+            say "  #{pastel.blue('[>>]')} You: #{content}"
           when "assistant"
             content = truncate_message(msg[:content], 200)
-            say "🤖 Assistant: #{content}", :green
+            say "  #{pastel.green('[<<]')} Assistant: #{content}"
           end
         end
 
-        say "\n" + ("-" * 60), :white
+        formatter.separator("─")
         say ""
       end
 
@@ -612,6 +606,27 @@ module Clacky
           cleaned
         end
       end
+
+      # UI component accessors
+      def ui_banner
+        @ui_banner ||= UI::Banner.new
+      end
+
+      def ui_prompt
+        @ui_prompt ||= UI::Prompt.new
+      end
+
+      def ui_statusbar
+        @ui_statusbar ||= UI::StatusBar.new
+      end
+
+      def ui_formatter
+        @ui_formatter ||= UI::Formatter.new
+      end
+
+      def pastel
+        @pastel ||= Pastel.new
+      end
     end
 
     private
@@ -641,12 +656,23 @@ module Clacky
         base_url: config.base_url
       )
 
+      # Use TTY::Prompt for input
+      tty_prompt = TTY::Prompt.new(interrupt: :exit)
+
       loop do
-        # Use Readline for better Unicode/CJK support
-        message = Readline.readline("You: ", true)
+        # Use TTY::Prompt for better input handling
+        begin
+          message = tty_prompt.ask("You:", required: false) do |q|
+            q.modify :strip
+          end
+        rescue TTY::Reader::InputInterrupt
+          # Handle Ctrl+C
+          puts
+          break
+        end
 
-        break if message.nil? || %w[exit quit].include?(message.downcase.strip)
-        next if message.strip.empty?
+        break if message.nil? || %w[exit quit].include?(message&.downcase&.strip)
+        next if message.nil? || message.strip.empty?
 
         spinner = TTY::Spinner.new("[:spinner] Claude is thinking...", format: :dots)
         spinner.auto_spin

data/lib/clacky/client.rb

@@ -43,7 +43,9 @@ module Clacky
     end
 
     # Send messages with function calling (tools) support
-    def send_messages_with_tools(messages, model:, tools:, max_tokens:, verbose: false)
+    # Options:
+    #   - enable_caching: Enable prompt caching for system prompt and tools (default: false)
+    def send_messages_with_tools(messages, model:, tools:, max_tokens:, verbose: false, enable_caching: false)
       body = {
         model: model,
         max_tokens: max_tokens,
@@ -51,7 +53,18 @@ module Clacky
       }
 
       # Add tools if provided
-      body[:tools] = tools if tools&.any?
+      # For Claude API with caching: mark the last tool definition with cache_control
+      if tools&.any?
+        if enable_caching && supports_prompt_caching?(model)
+          # Deep clone tools to avoid modifying original
+          cached_tools = tools.map { |tool| deep_clone(tool) }
+          # Mark the last tool for caching (Claude caches from cache breakpoint to end)
+          cached_tools.last[:cache_control] = { type: "ephemeral" }
+          body[:tools] = cached_tools
+        else
+          body[:tools] = tools
+        end
+      end
 
       # Debug output
       if verbose || ENV["CLACKY_DEBUG"]
@@ -77,6 +90,31 @@ module Clacky
 
     private
 
+    # Check if the model supports prompt caching
+    # Currently only Claude 3.5 Sonnet and newer Claude models support this
+    def supports_prompt_caching?(model)
+      model_str = model.to_s.downcase
+      # Claude 3.5 Sonnet (20241022 and newer) supports prompt caching
+      # Also Claude 3.7 Sonnet and Opus models when they're released
+      model_str.include?("claude-3.5-sonnet") ||
+        model_str.include?("claude-3-7") ||
+        model_str.include?("claude-4")
+    end
+
+    # Deep clone a hash/array structure (for tool definitions)
+    def deep_clone(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) { |(k, v), h| h[k] = deep_clone(v) }
+      when Array
+        obj.map { |item| deep_clone(item) }
+      when String, Symbol, Integer, Float, TrueClass, FalseClass, NilClass
+        obj
+      else
+        obj.dup rescue obj
+      end
+    end
+
     def connection
       @connection ||= Faraday.new(url: @base_url) do |conn|
         conn.headers["Content-Type"] = "application/json"
@@ -117,15 +155,26 @@ module Clacky
           puts "  content length: #{message["content"]&.length || 0}"
         end
 
+        # Parse usage with cache information
+        usage_data = {
+          prompt_tokens: usage["prompt_tokens"],
+          completion_tokens: usage["completion_tokens"],
+          total_tokens: usage["total_tokens"]
+        }
+        
+        # Add cache metrics if present (Claude API with prompt caching)
+        if usage["cache_creation_input_tokens"]
+          usage_data[:cache_creation_input_tokens] = usage["cache_creation_input_tokens"]
+        end
+        if usage["cache_read_input_tokens"]
+          usage_data[:cache_read_input_tokens] = usage["cache_read_input_tokens"]
+        end
+        
         {
           content: message["content"],
           tool_calls: parse_tool_calls(message["tool_calls"]),
           finish_reason: data["choices"].first["finish_reason"],
-          usage: {
-            prompt_tokens: usage["prompt_tokens"],
-            completion_tokens: usage["completion_tokens"],
-            total_tokens: usage["total_tokens"]
-          }
+          usage: usage_data
         }
       when 401
         raise Error, "Invalid API key"

data/lib/clacky/hook_manager.rb

@@ -8,7 +8,8 @@ module Clacky
       :on_tool_error,
       :on_start,
       :on_complete,
-      :on_iteration
+      :on_iteration,
+      :session_rollback
     ].freeze
 
     def initialize

data/lib/clacky/progress_indicator.rb

@@ -14,7 +14,9 @@ module Clacky
     def start
       @start_time = Time.now
       @running = true
-      print_status("#{@thinking_verb}… (ctrl+c to interrupt) ")
+      # Save cursor position after the [..] symbol
+      print "\e[s"  # Save cursor position
+      print_thinking_status("#{@thinking_verb}… (ctrl+c to interrupt)")
 
       # Start background thread to update elapsed time
       @update_thread = Thread.new do
@@ -29,24 +31,25 @@ module Clacky
       return unless @start_time
 
       elapsed = (Time.now - @start_time).to_i
-      print_status("#{@thinking_verb}… (ctrl+c to interrupt · #{elapsed}s) ")
+      print_thinking_status("#{@thinking_verb}… (ctrl+c to interrupt · #{elapsed}s)")
     end
 
     def finish
       @running = false
       @update_thread&.join
-      clear_line
+      # Restore cursor and clear to end of line
+      print "\e[u"     # Restore cursor position
+      print "\e[K"     # Clear to end of line
+      puts ""          # Add newline after finishing
     end
 
     private
 
-    def print_status(text)
-      print "\r\033[K#{text}" # \r moves to start of line, \033[K clears to end of line
-      $stdout.flush
-    end
-
-    def clear_line
-      print "\r\033[K" # Clear the entire line
+    def print_thinking_status(text)
+      print "\e[u"     # Restore cursor position (to after [..] symbol)
+      print "\e[K"     # Clear to end of line from cursor
+      print text
+      print " "
       $stdout.flush
     end
   end

data/lib/clacky/tools/safe_shell.rb

@@ -147,6 +147,12 @@ module Clacky
         trash_directory = Clacky::TrashDirectory.new(@project_root)
         @trash_dir = trash_directory.trash_dir
         @backup_dir = trash_directory.backup_dir
+        
+        # Setup safety log directory under ~/.clacky/safety_logs/
+        @project_hash = trash_directory.generate_project_hash(@project_root)
+        @safety_log_dir = File.join(Dir.home, ".clacky", "safety_logs", @project_hash)
+        FileUtils.mkdir_p(@safety_log_dir) unless Dir.exist?(@safety_log_dir)
+        @safety_log_file = File.join(@safety_log_dir, "safety.log")
       end
 
       def make_command_safe(command)
@@ -384,8 +390,7 @@ module Clacky
       end
 
       def write_log(log_entry)
-        log_file = File.join(@project_root, '.ai_safety.log')
-        File.open(log_file, 'a') do |f|
+        File.open(@safety_log_file, 'a') do |f|
           f.puts JSON.generate(log_entry)
         end
       rescue StandardError

data/lib/clacky/tools/trash_manager.rb

@@ -260,7 +260,7 @@ module Clacky
           - Use 'list' to see what files are in trash
           - Use 'restore' to get back accidentally deleted files
           - Use 'empty' periodically to free up disk space
-          - All deletions by SafeShell are logged in .ai_safety.log
+          - All deletions by SafeShell are logged in ~/.clacky/safety_logs/
         HELP
 
         {