openclacky 0.5.1 → 0.5.2

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,24 @@ 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
       $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
 
         {

data/lib/clacky/ui/banner.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Clacky
+  module UI
+    # ASCII art banner and startup screen with Matrix/hacker aesthetic
+    class Banner
+      LOGO = <<~'LOGO'
+         ██████╗ ██████╗ ███████╗███╗   ██╗ ██████╗██╗      █████╗  ██████╗██╗  ██╗██╗   ██╗
+        ██╔═══██╗██╔══██╗██╔════╝████╗  ██║██╔════╝██║     ██╔══██╗██╔════╝██║ ██╔╝╚██╗ ██╔╝
+        ██║   ██║██████╔╝█████╗  ██╔██╗ ██║██║     ██║     ███████║██║     █████╔╝  ╚████╔╝ 
+        ██║   ██║██╔═══╝ ██╔══╝  ██║╚██╗██║██║     ██║     ██╔══██║██║     ██╔═██╗   ╚██╔╝  
+        ╚██████╔╝██║     ███████╗██║ ╚████║╚██████╗███████╗██║  ██║╚██████╗██║  ██╗   ██║   
+         ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═══╝ ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝   ╚═╝   
+      LOGO
+
+      TAGLINE = "[>] AI Coding Assistant & Technical Co-founder"
+
+      TIPS = [
+        "[*] Ask questions, edit files, or run commands",
+        "[*] Be specific for the best results",
+        "[*] Create .clackyrules to customize interactions",
+        "[*] Type /help for more commands"
+      ]
+
+      def initialize
+        @pastel = Pastel.new
+      end
+
+      # Display full startup banner
+      def display_startup
+        puts
+        puts @pastel.bright_green(LOGO)
+        puts
+        puts @pastel.bright_cyan(TAGLINE)
+        puts
+        display_tips
+        puts
+      end
+
+      # Display welcome message for agent mode
+      def display_agent_welcome(working_dir:, mode:, max_iterations:, max_cost:)
+        puts
+        puts separator("=")
+        puts @pastel.bright_green("[+] AGENT MODE INITIALIZED")
+        puts separator("=")
+        puts
+        puts info_line("Working Directory", working_dir)
+        puts info_line("Permission Mode", mode)
+        puts info_line("Max Iterations", max_iterations)
+        puts info_line("Max Cost", "$#{max_cost}")
+        puts
+        puts @pastel.dim("[!] Type 'exit' or 'quit' to terminate session")
+        puts separator("-")
+        puts
+      end
+
+      # Display session continuation info
+      def display_session_continue(session_id:, created_at:, tasks:, cost:)
+        puts
+        puts separator("=")
+        puts @pastel.bright_yellow("[~] RESUMING SESSION")
+        puts separator("=")
+        puts
+        puts info_line("Session ID", session_id)
+        puts info_line("Started", created_at)
+        puts info_line("Tasks Completed", tasks)
+        puts info_line("Total Cost", "$#{cost}")
+        puts separator("-")
+        puts
+      end
+
+      # Display task completion summary
+      def display_task_complete(iterations:, cost:, total_tasks:, total_cost:, cache_stats: {})
+        puts
+        puts separator("-")
+        puts @pastel.bright_green("[✓] TASK COMPLETED")
+        puts info_line("Iterations", iterations)
+        puts info_line("Cost", "$#{cost}")
+        puts info_line("Session Total", "#{total_tasks} tasks, $#{total_cost}")
+        
+        # Display cache statistics if available
+        if cache_stats[:total_requests] && cache_stats[:total_requests] > 0
+          puts
+          puts @pastel.cyan("    [Prompt Caching]")
+          puts info_line("  Cache Writes", "#{cache_stats[:cache_creation_input_tokens]} tokens")
+          puts info_line("  Cache Reads", "#{cache_stats[:cache_read_input_tokens]} tokens")
+          
+          hit_rate = (cache_stats[:cache_hit_requests].to_f / cache_stats[:total_requests] * 100).round(1)
+          puts info_line("  Cache Hit Rate", "#{hit_rate}% (#{cache_stats[:cache_hit_requests]}/#{cache_stats[:total_requests]} requests)")
+        end
+        
+        puts separator("-")
+        puts
+      end
+
+      # Display error message
+      def display_error(message, details: nil)
+        puts
+        puts separator("-")
+        puts @pastel.bright_red("[✗] ERROR")
+        puts @pastel.red("    #{message}")
+        if details
+          puts @pastel.dim("    #{details}")
+        end
+        puts separator("-")
+        puts
+      end
+
+      # Display session end
+      def display_goodbye(total_tasks:, total_cost:)
+        puts
+        puts separator("=")
+        puts @pastel.bright_cyan("[#] SESSION TERMINATED")
+        puts separator("=")
+        puts
+        puts info_line("Total Tasks", total_tasks)
+        puts info_line("Total Cost", "$#{total_cost}")
+        puts
+        puts @pastel.dim("[*] All session data has been saved")
+        puts
+      end
+
+      private
+
+      def display_tips
+        TIPS.each do |tip|
+          puts @pastel.dim(tip)
+        end
+      end
+
+      def info_line(label, value)
+        label_text = @pastel.cyan("[#{label}]")
+        value_text = @pastel.white(value)
+        "    #{label_text} #{value_text}"
+      end
+
+      def separator(char = "-")
+        @pastel.dim(char * 80)
+      end
+    end
+  end
+end

data/lib/clacky/ui/formatter.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Clacky
+  module UI
+    # Matrix/hacker-style output formatter
+    class Formatter
+      # Hacker-style symbols (no emoji)
+      SYMBOLS = {
+        user: "[>>]",
+        assistant: "[<<]",
+        tool_call: "[=>]",
+        tool_result: "[<=]",
+        tool_denied: "[!!]",
+        tool_planned: "[??]",
+        tool_error: "[XX]",
+        thinking: "[..]",
+        success: "[OK]",
+        error: "[ER]",
+        warning: "[!!]",
+        info: "[--]",
+        task: "[##]",
+        progress: "[>>]"
+      }.freeze
+
+      def initialize
+        @pastel = Pastel.new
+      end
+
+      # Format user message
+      def user_message(content)
+        symbol = @pastel.bright_blue(SYMBOLS[:user])
+        text = @pastel.blue(content)
+        puts "\n#{symbol} #{text}"
+      end
+
+      # Format assistant message
+      def assistant_message(content)
+        return if content.nil? || content.empty?
+        
+        symbol = @pastel.bright_green(SYMBOLS[:assistant])
+        text = @pastel.white(content)
+        puts "\n#{symbol} #{text}"
+      end
+
+      # Format tool call
+      def tool_call(formatted_call)
+        symbol = @pastel.bright_cyan(SYMBOLS[:tool_call])
+        text = @pastel.cyan(formatted_call)
+        puts "\n#{symbol} #{text}"
+      end
+
+      # Format tool result
+      def tool_result(summary)
+        symbol = @pastel.cyan(SYMBOLS[:tool_result])
+        text = @pastel.white(summary)
+        puts "#{symbol} #{text}"
+      end
+
+      # Format tool denied
+      def tool_denied(tool_name)
+        symbol = @pastel.bright_yellow(SYMBOLS[:tool_denied])
+        text = @pastel.yellow("Tool denied: #{tool_name}")
+        puts "\n#{symbol} #{text}"
+      end
+
+      # Format tool planned
+      def tool_planned(tool_name)
+        symbol = @pastel.bright_blue(SYMBOLS[:tool_planned])
+        text = @pastel.blue("Planned: #{tool_name}")
+        puts "\n#{symbol} #{text}"
+      end
+
+      # Format tool error
+      def tool_error(error_message)
+        symbol = @pastel.bright_red(SYMBOLS[:tool_error])
+        text = @pastel.red("Error: #{error_message}")
+        puts "\n#{symbol} #{text}"
+      end
+
+      # Format thinking indicator
+      def thinking
+        symbol = @pastel.dim(SYMBOLS[:thinking])
+        # Output symbol on the same line, progress indicator will follow
+        print "\n#{symbol} "
+      end
+
+      # Format success message
+      def success(message)
+        symbol = @pastel.bright_green(SYMBOLS[:success])
+        text = @pastel.green(message)
+        puts "#{symbol} #{text}"
+      end
+
+      # Format error message
+      def error(message)
+        symbol = @pastel.bright_red(SYMBOLS[:error])
+        text = @pastel.red(message)
+        puts "#{symbol} #{text}"
+      end
+
+      # Format warning message
+      def warning(message)
+        symbol = @pastel.bright_yellow(SYMBOLS[:warning])
+        text = @pastel.yellow(message)
+        puts "#{symbol} #{text}"
+      end
+
+      # Format info message
+      def info(message)
+        symbol = @pastel.bright_white(SYMBOLS[:info])
+        text = @pastel.white(message)
+        puts "#{symbol} #{text}"
+      end
+
+      # Format TODO status with progress bar
+      def todo_status(todos)
+        return if todos.empty?
+
+        completed = todos.count { |t| t[:status] == "completed" }
+        total = todos.size
+
+        # Build progress bar with hacker style
+        progress_bar = todos.map { |t| 
+          t[:status] == "completed" ? @pastel.green("█") : @pastel.dim("░")
+        }.join
+
+        # Check if all completed
+        if completed == total
+          symbol = @pastel.bright_green(SYMBOLS[:success])
+          puts "\n#{symbol} Tasks [#{completed}/#{total}]: #{progress_bar} #{@pastel.bright_green('COMPLETE')}"
+          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]
+
+        symbol = @pastel.bright_yellow(SYMBOLS[:task])
+        puts "\n#{symbol} Tasks [#{completed}/#{total}]: #{progress_bar}"
+        
+        if current_task
+          puts "    #{@pastel.cyan('→')} Next: ##{current_task[:id]} - #{current_task[:task]}"
+        end
+        
+        if next_task && next_task[:status] == "pending"
+          puts "    #{@pastel.dim('⇢')} After: ##{next_task[:id]} - #{next_task[:task]}"
+        end
+      end
+
+      # Format iteration indicator
+      def iteration(number)
+        symbol = @pastel.dim(SYMBOLS[:progress])
+        text = @pastel.dim("Iteration #{number}")
+        puts "\n#{symbol} #{text}"
+      end
+
+      # Format separator
+      def separator(char = "─", width: 80)
+        puts @pastel.dim(char * width)
+      end
+
+      # Format section header
+      def section_header(title)
+        puts
+        separator("═")
+        puts @pastel.bright_white(title.center(80))
+        separator("═")
+        puts
+      end
+
+      # Format confirmation prompt for tool use
+      def tool_confirmation_prompt(formatted_call)
+        symbol = @pastel.bright_yellow("[??]")
+        puts "\n#{symbol} #{@pastel.yellow(formatted_call)}"
+      end
+
+      # Format conversation history message
+      def history_message(role, content, index, total)
+        case role
+        when "user"
+          symbol = @pastel.blue(SYMBOLS[:user])
+          text = @pastel.white(truncate(content, 150))
+          puts "#{symbol} You: #{text}"
+        when "assistant"
+          symbol = @pastel.green(SYMBOLS[:assistant])
+          text = @pastel.white(truncate(content, 200))
+          puts "#{symbol} Assistant: #{text}"
+        end
+      end
+
+      private
+
+      def truncate(content, max_length)
+        return "" if content.nil? || content.empty?
+
+        cleaned = content.strip.gsub(/\s+/, ' ')
+        
+        if cleaned.length > max_length
+          cleaned[0...max_length] + "..."
+        else
+          cleaned
+        end
+      end
+    end
+  end
+end

data/lib/clacky/ui/prompt.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "readline"
+require "pastel"
+require "tty-screen"
+
+module Clacky
+  module UI
+    # Enhanced input prompt with box drawing and status info
+    class Prompt
+      def initialize
+        @pastel = Pastel.new
+      end
+
+      # Read user input with enhanced prompt box
+      # @param prefix [String] Prompt prefix (default: "You:")
+      # @param placeholder [String] Placeholder text (not shown when using Readline)
+      # @return [String, nil] User input or nil on EOF
+      def read_input(prefix: "You:", placeholder: nil)
+        width = [TTY::Screen.width - 5, 70].min
+
+        # Display complete box frame first
+        puts @pastel.dim("╭" + "─" * width + "╮")
+
+        # Empty input line with borders (width - 2 for left/right padding)
+        padding = " " * (width - 2)
+        puts @pastel.dim("│ #{padding} │")
+
+        # Bottom border
+        puts @pastel.dim("╰" + "─" * width + "╯")
+
+        # Move cursor back up to input line (2 lines up)
+        print "\e[2A"  # Move up 2 lines
+        print "\r"     # Move to beginning of line
+        print "\e[2C"  # Move right 2 chars to after "│ "
+
+        # Read input with Readline
+        prompt_text = @pastel.bright_blue("#{prefix} ")
+        input = read_with_readline(prompt_text)
+
+        # After input, clear the input box completely
+        # Move cursor up 2 lines to the top of the box
+        print "\e[2A"
+        print "\r"
+        
+        # Clear all 3 lines of the box
+        3.times do
+          print "\e[2K"  # Clear entire line
+          print "\e[1B"  # Move down 1 line
+          print "\r"     # Move to beginning of line
+        end
+        
+        # Move cursor back up to where the box started
+        print "\e[3A"
+        print "\r"
+        
+        input
+      end
+
+      private
+
+      def read_with_readline(prompt)
+        Readline.readline(prompt, true)
+      rescue Interrupt
+        puts
+        nil
+      end
+    end
+  end
+end

data/lib/clacky/ui/statusbar.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "tty-screen"
+
+module Clacky
+  module UI
+    # Status bar showing session information
+    class StatusBar
+      def initialize
+        @pastel = Pastel.new
+      end
+
+      # Display session status bar
+      # @param working_dir [String] Current working directory
+      # @param mode [String] Permission mode
+      # @param model [String] AI model name
+      # @param tasks [Integer] Number of completed tasks (optional)
+      # @param cost [Float] Total cost (optional)
+      def display(working_dir:, mode:, model:, tasks: nil, cost: nil)
+        parts = []
+        
+        # Working directory (shortened if too long)
+        dir_display = shorten_path(working_dir)
+        parts << @pastel.bright_cyan(dir_display)
+        
+        # Permission mode
+        mode_color = mode_color_for(mode)
+        parts << @pastel.public_send(mode_color, mode)
+        
+        # Model
+        parts << @pastel.bright_white(model)
+        
+        # Optional: tasks and cost
+        if tasks
+          parts << @pastel.yellow("#{tasks} tasks")
+        end
+        
+        if cost
+          parts << @pastel.yellow("$#{cost.round(4)}")
+        end
+        
+        # Join with separator
+        separator = @pastel.dim(" │ ")
+        status_line = " " + parts.join(separator)
+        
+        puts status_line
+        puts @pastel.dim("─" * [TTY::Screen.width, 80].min)
+      end
+
+      # Display minimal status for non-interactive mode
+      def display_minimal(working_dir:, mode:)
+        dir_display = shorten_path(working_dir)
+        puts " #{@pastel.bright_cyan(dir_display)} #{@pastel.dim('│')} #{@pastel.yellow(mode)}"
+        puts @pastel.dim("─" * [TTY::Screen.width, 80].min)
+      end
+
+      private
+
+      def shorten_path(path)
+        return path if path.length <= 40
+        
+        # Replace home directory with ~
+        home = ENV['HOME']
+        if home && path.start_with?(home)
+          path = path.sub(home, '~')
+        end
+        
+        # If still too long, show last parts
+        if path.length > 40
+          parts = path.split('/')
+          if parts.length > 3
+            ".../" + parts[-3..-1].join('/')
+          else
+            path[0..40] + "..."
+          end
+        else
+          path
+        end
+      end
+
+      def mode_color_for(mode)
+        case mode.to_s
+        when /auto_approve/
+          :bright_red
+        when /confirm_safes/
+          :bright_yellow
+        when /confirm_edits/
+          :bright_green
+        when /plan_only/
+          :bright_blue
+        else
+          :white
+        end
+      end
+    end
+  end
+end

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end

data/lib/clacky.rb

@@ -30,6 +30,12 @@ require_relative "clacky/tools/safe_shell"
 require_relative "clacky/tools/trash_manager"
 require_relative "clacky/agent"
 
+# UI components
+require_relative "clacky/ui/banner"
+require_relative "clacky/ui/prompt"
+require_relative "clacky/ui/statusbar"
+require_relative "clacky/ui/formatter"
+
 require_relative "clacky/cli"
 
 module Clacky

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openclacky
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - windy
@@ -79,6 +79,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: tty-screen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 description: OpenClacky is a Ruby CLI tool for interacting with AI models via OpenAI-compatible
   APIs. It provides chat functionality and autonomous AI agent capabilities with tool
   use.
@@ -128,6 +156,10 @@ files:
 - lib/clacky/tools/web_search.rb
 - lib/clacky/tools/write.rb
 - lib/clacky/trash_directory.rb
+- lib/clacky/ui/banner.rb
+- lib/clacky/ui/formatter.rb
+- lib/clacky/ui/prompt.rb
+- lib/clacky/ui/statusbar.rb
 - lib/clacky/utils/arguments_parser.rb
 - lib/clacky/utils/limit_stack.rb
 - lib/clacky/utils/path_helper.rb