openclacky 0.7.0 → 0.7.2

data/lib/clacky/tools/list_tasks.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Tools
+    # Tool for listing task history (Time Machine feature)
+    class ListTasks < Base
+      self.tool_name = "list_tasks"
+      self.tool_description = "List recent tasks in the task history with summaries. " \
+        "Shows current task, past tasks, and future tasks (after undo). " \
+        "Use when user wants to see task history or choose which task to undo/redo to."
+      self.tool_category = "time_machine"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          limit: {
+            type: "integer",
+            description: "Maximum number of recent tasks to show (default: 10)",
+            default: 10
+          }
+        }
+      }
+
+      def execute(agent:, limit: 10, **_args)
+        history = agent.get_task_history(limit: limit)
+        
+        if history.empty?
+          return "No task history available."
+        end
+
+        lines = ["Task History:"]
+        history.each do |task|
+          indicator = case task[:status]
+          when :current then "→"
+          when :past then " "
+          when :future then "↯"
+          end
+          
+          branch_indicator = task[:has_branches] ? " ⎇" : ""
+          lines << "#{indicator}#{branch_indicator} Task #{task[:task_id]}: #{task[:summary]}"
+        end
+
+        lines.join("\n")
+      end
+
+      def format_call(limit: 10, **_args)
+        "Listing task history (limit: #{limit})..."
+      end
+
+      def format_result(result)
+        result
+      end
+    end
+  end
+end

data/lib/clacky/tools/redo_task.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Tools
+    # Tool for redoing a task after undo (Time Machine feature)
+    class RedoTask < Base
+      self.tool_name = "redo_task"
+      self.tool_description = "Redo to a specific task after undo. Restores files to that task's state. " \
+        "Use when user wants to go forward to a future task or switch to a different branch."
+      self.tool_category = "time_machine"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          task_id: {
+            type: "integer",
+            description: "The task ID to redo to (must be greater than current active task)"
+          }
+        },
+        required: ["task_id"]
+      }
+
+      def execute(agent:, task_id:, **_args)
+        result = agent.switch_to_task(task_id)
+        
+        if result[:success]
+          result[:message]
+        else
+          "Error: #{result[:message]}"
+        end
+      end
+
+      def format_call(task_id:, **_args)
+        "Redoing to task #{task_id}..."
+      end
+
+      def format_result(result)
+        result
+      end
+    end
+  end
+end

data/lib/clacky/tools/safe_shell.rb

@@ -4,7 +4,7 @@ require "shellwords"
 require "json"
 require "fileutils"
 require_relative "shell"
-require_relative "../trash_directory"
+require_relative "../utils/trash_directory"
 
 module Clacky
   module Tools

data/lib/clacky/tools/shell.rb

@@ -66,96 +66,108 @@ module Clacky
         stdout_buffer = StringIO.new
         stderr_buffer = StringIO.new
         soft_timeout_triggered = false
+        process_pid = nil
 
         begin
           Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+            process_pid = wait_thr.pid
             start_time = Time.now
 
             stdout.sync = true
             stderr.sync = true
 
-            loop do
-              elapsed = Time.now - start_time
-
-              if elapsed > hard_timeout
-                Process.kill('TERM', wait_thr.pid) rescue nil
-                sleep 0.5
-                Process.kill('KILL', wait_thr.pid) if wait_thr.alive? rescue nil
-
-                return format_timeout_result(
-                  command,
-                  stdout_buffer.string,
-                  stderr_buffer.string,
-                  elapsed,
-                  :hard_timeout,
-                  hard_timeout,
-                  max_output_lines
-                )
-              end
-
-              if elapsed > soft_timeout && !soft_timeout_triggered
-                soft_timeout_triggered = true
+            begin
+              loop do
+                elapsed = Time.now - start_time
 
-                # L1: Check for interaction patterns
-                interaction = detect_interaction(stdout_buffer.string)
-                if interaction
+                if elapsed > hard_timeout
                   Process.kill('TERM', wait_thr.pid) rescue nil
-                  return format_waiting_input_result(
+                  sleep 0.5
+                  Process.kill('KILL', wait_thr.pid) if wait_thr.alive? rescue nil
+
+                  return format_timeout_result(
                     command,
                     stdout_buffer.string,
                     stderr_buffer.string,
-                    interaction,
+                    elapsed,
+                    :hard_timeout,
+                    hard_timeout,
                     max_output_lines
                   )
                 end
-              end
 
-              break unless wait_thr.alive?
+                if elapsed > soft_timeout && !soft_timeout_triggered
+                  soft_timeout_triggered = true
+
+                  # L1: Check for interaction patterns
+                  interaction = detect_interaction(stdout_buffer.string)
+                  if interaction
+                    Process.kill('TERM', wait_thr.pid) rescue nil
+                    return format_waiting_input_result(
+                      command,
+                      stdout_buffer.string,
+                      stderr_buffer.string,
+                      interaction,
+                      max_output_lines
+                    )
+                  end
+                end
 
-              begin
-                ready = IO.select([stdout, stderr], nil, nil, 0.1)
-                if ready
-                  ready[0].each do |io|
-                    begin
-                      data = io.read_nonblock(4096)
-                      if io == stdout
-                        stdout_buffer.write(data)
-                      else
-                        stderr_buffer.write(data)
+                break unless wait_thr.alive?
+
+                begin
+                  ready = IO.select([stdout, stderr], nil, nil, 0.1)
+                  if ready
+                    ready[0].each do |io|
+                      begin
+                        data = io.read_nonblock(4096)
+                        if io == stdout
+                          stdout_buffer.write(data)
+                        else
+                          stderr_buffer.write(data)
+                        end
+                      rescue IO::WaitReadable, EOFError
                       end
-                    rescue IO::WaitReadable, EOFError
                     end
                   end
+                rescue StandardError => e
                 end
-              rescue StandardError => e
+
+                sleep 0.1
               end
 
-              sleep 0.1
-            end
+              begin
+                stdout_buffer.write(stdout.read)
+              rescue StandardError
+              end
+              begin
+                stderr_buffer.write(stderr.read)
+              rescue StandardError
+              end
 
-            begin
-              stdout_buffer.write(stdout.read)
-            rescue StandardError
-            end
-            begin
-              stderr_buffer.write(stderr.read)
-            rescue StandardError
+              stdout_output = stdout_buffer.string
+              stderr_output = stderr_buffer.string
+
+              {
+                command: command,
+                stdout: truncate_output(stdout_output, max_output_lines),
+                stderr: truncate_output(stderr_output, max_output_lines),
+                exit_code: wait_thr.value.exitstatus,
+                success: wait_thr.value.success?,
+                elapsed: Time.now - start_time,
+                output_truncated: output_truncated?(stdout_output, stderr_output, max_output_lines)
+              }
+            ensure
+              # Ensure child process is killed when block exits (for any reason: exception, return, etc.)
+              if wait_thr&.alive?
+                Process.kill('TERM', wait_thr.pid) rescue nil
+                sleep 0.1
+                Process.kill('KILL', wait_thr.pid) if wait_thr.alive? rescue nil
+              end
             end
-
-            stdout_output = stdout_buffer.string
-            stderr_output = stderr_buffer.string
-
-            {
-              command: command,
-              stdout: truncate_output(stdout_output, max_output_lines),
-              stderr: truncate_output(stderr_output, max_output_lines),
-              exit_code: wait_thr.value.exitstatus,
-              success: wait_thr.value.success?,
-              elapsed: Time.now - start_time,
-              output_truncated: output_truncated?(stdout_output, stderr_output, max_output_lines)
-            }
           end
         rescue StandardError => e
+          # Handle other errors
           stdout_output = stdout_buffer.string
           stderr_output = "Error executing command: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
 

data/lib/clacky/tools/trash_manager.rb

@@ -3,7 +3,7 @@
 require "json"
 require "fileutils"
 require_relative "base"
-require_relative "../trash_directory"
+require_relative "../utils/trash_directory"
 
 module Clacky
   module Tools

data/lib/clacky/tools/undo_task.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Tools
+    # Tool for undoing the last task (Time Machine feature)
+    class UndoTask < Base
+      self.tool_name = "undo_task"
+      self.tool_description = "Undo the last task and restore files to previous state. " \
+        "Use when user wants to go back to previous state or undo recent changes."
+      self.tool_category = "time_machine"
+      self.tool_parameters = {}
+
+      def execute(agent:, **_args)
+        result = agent.undo_last_task
+        
+        if result[:success]
+          result[:message]
+        else
+          "Error: #{result[:message]}"
+        end
+      end
+
+      def format_call(**_args)
+        "Undoing last task..."
+      end
+
+      def format_result(result)
+        result
+      end
+    end
+  end
+end

data/lib/clacky/tools/web_fetch.rb

@@ -211,7 +211,8 @@ module Clacky
           compact[:content] = result[:content]
           compact[:truncated] = true
           compact[:temp_file] = result[:temp_file]
-          compact[:message] = "[Content truncated - full content saved to temp file. Use file_reader to read it if needed.]"
+          compact[:message] = "[Content truncated - full content saved to: #{result[:temp_file]}. " \
+                              "Use grep to search keywords, or file_reader with start_line/end_line to read sections.]"
         else
           compact[:content] = result[:content]
           compact[:truncated] = result[:truncated] || false

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

@@ -14,6 +14,8 @@ module Clacky
         # System commands available by default
         SYSTEM_COMMANDS = [
           { command: "/clear", description: "Clear chat history and restart session" },
+          { command: "/config", description: "Open configuration (models, API keys, settings)" },
+          { command: "/undo", description: "Undo the last task and restore previous state" },
           { command: "/help", description: "Show help information" },
           { command: "/exit", description: "Exit the chat session" },
           { command: "/quit", description: "Quit the application" }
@@ -46,7 +48,8 @@ module Clacky
             {
               command: skill.slash_command,
               description: skill.description || "No description available",
-              type: :skill
+              type: :skill,
+              argument_hint: skill.argument_hint
             }
           end
 
@@ -104,6 +107,13 @@ module Clacky
           cmd ? cmd[:command] : nil
         end
 
+        # Get the argument hint for the currently selected command
+        # @return [String, nil] Argument hint string or nil if none
+        def selected_argument_hint
+          cmd = selected_command
+          cmd ? cmd[:argument_hint] : nil
+        end
+
         # Check if there are any suggestions to show
         # @return [Boolean]
         def has_suggestions?
@@ -189,8 +199,8 @@ module Clacky
             @filtered_commands = @commands.select do |cmd|
               # Remove leading / for comparison
               cmd_name = cmd[:command].sub(/^\//, "")
-              cmd_name.downcase.start_with?(filter_lower) ||
-                cmd[:description].downcase.include?(filter_lower)
+              # Only match command name, not description
+              cmd_name.downcase.start_with?(filter_lower)
             end
           end
         end

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

@@ -20,6 +20,7 @@ module Clacky
           @result_queue = nil
           @paste_counter = 0
           @paste_placeholders = {}
+          @continuation_prompt = "> "  # Continuation prompt for wrapped lines
         end
 
         # Activate inline input and wait for user input
@@ -92,6 +93,8 @@ module Clacky
             { action: :update }
           when :shift_tab
             handle_shift_tab
+          when :ctrl_o
+            handle_toggle_expand
           when :ctrl_c
             handle_cancel
           when :escape
@@ -110,8 +113,10 @@ module Clacky
         # @return [String] Rendered line (may wrap to multiple lines)
         def render
           width = TTY::Screen.width
+          # Use effective content width (respecting MAX_CONTENT_WIDTH_RATIO)
+          content_width = effective_content_width(width)
           prompt_width = calculate_display_width(strip_ansi_codes(@prompt))
-          available_width = width - prompt_width
+          available_width = content_width - prompt_width
 
           # Get wrapped segments
           wrapped_segments = wrap_line(@line, available_width)
@@ -142,12 +147,23 @@ module Clacky
           cursor_column(@prompt)
         end
 
+        # Get cursor position for display (considering line wrapping and continuation prompt)
+        # @param width [Integer] Terminal width
+        # @return [Array<Integer>] Row and column position (0-indexed)
+        def cursor_position_for_display(width = TTY::Screen.width)
+          # Use effective content width (respecting MAX_CONTENT_WIDTH_RATIO)
+          content_width = effective_content_width(width)
+          cursor_position_with_wrap(@prompt, content_width, @continuation_prompt)
+        end
+
         # Get the number of lines this input will occupy when rendered
         # @param width [Integer] Terminal width
         # @return [Integer] Number of lines
         def line_count(width = TTY::Screen.width)
+          # Use effective content width (respecting MAX_CONTENT_WIDTH_RATIO)
+          content_width = effective_content_width(width)
           prompt_width = calculate_display_width(strip_ansi_codes(@prompt))
-          available_width = width - prompt_width
+          available_width = content_width - prompt_width
           return 1 if available_width <= 0
 
           segments = wrap_line(@line, available_width)
@@ -200,6 +216,11 @@ module Clacky
 
           { action: :toggle_mode }
         end
+
+        private def handle_toggle_expand
+          # Toggle expansion of diff display
+          { action: :toggle_expand }
+        end
       end
     end
   end

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

@@ -101,6 +101,8 @@ module Clacky
           height += @images.size
           
           # Calculate height considering wrapped lines
+          # Use effective content width (respecting MAX_CONTENT_WIDTH_RATIO)
+          content_width = effective_content_width(@width)
           @lines.each_with_index do |line, idx|
             prefix = if idx == 0
               prompt
@@ -108,7 +110,7 @@ module Clacky
               " " * prompt.length
             end
             prefix_width = calculate_display_width(strip_ansi_codes(prefix))
-            available_width = [@width - prefix_width, 20].max  # At least 20 chars
+            available_width = [content_width - prefix_width, 20].max  # At least 20 chars
             wrapped_segments = wrap_line(line, available_width)
             height += wrapped_segments.size
           end
@@ -169,7 +171,7 @@ module Clacky
               @command_suggestions.select_next
               return { action: nil }
             when :enter
-              # Accept selected command
+              # Accept selected command and submit immediately
               if @command_suggestions.has_suggestions?
                 selected = @command_suggestions.selected_command_text
                 if selected
@@ -178,7 +180,8 @@ module Clacky
                   @line_index = 0
                   @cursor_position = selected.length
                   @command_suggestions.hide
-                  return { action: nil }
+                  # Submit the command immediately
+                  return handle_enter
                 end
               end
               # Fall through to normal enter handling if no suggestion
@@ -186,20 +189,30 @@ module Clacky
               @command_suggestions.hide
               return { action: nil }
             when :tab
-              # Tab also accepts the suggestion
+              # Tab accepts the currently highlighted suggestion
               if @command_suggestions.has_suggestions?
                 selected = @command_suggestions.selected_command_text
                 if selected
-                  @lines = [selected]
+                  hint = @command_suggestions.selected_argument_hint
+                  completed = "#{selected} "
+                  @lines = [completed]
                   @line_index = 0
-                  @cursor_position = selected.length
+                  @cursor_position = completed.length
                   @command_suggestions.hide
+                  # Show argument hint as a tip if available
+                  set_tips("Usage: #{selected} #{hint}", type: :info) if hint && !hint.empty?
                   return { action: nil }
                 end
               end
             end
           end
 
+          # Tab with no visible suggestions: trigger slash-command completion
+          if key == :tab
+            trigger_tab_completion
+            return { action: nil }
+          end
+
           result = case key
           when Hash
             if key[:type] == :rapid_input
@@ -230,12 +243,16 @@ module Clacky
           when :ctrl_c then handle_ctrl_c
           when :ctrl_d then handle_ctrl_d
           when :ctrl_v then handle_paste
+          when :ctrl_o then { action: :toggle_expand }
           when :shift_tab then { action: :toggle_mode }
           when :escape 
             if @command_suggestions.visible
               @command_suggestions.hide
+              { action: nil }
+            else
+              # Trigger time machine when ESC is pressed and suggestions not visible
+              { action: :time_machine }
             end
-            { action: nil }
           else
             if key.is_a?(String) && key.length >= 1 && key.ord >= 32
               insert_char(key)
@@ -318,6 +335,8 @@ module Clacky
         def position_cursor(start_row)
           # Calculate which wrapped line the cursor is on
           cursor_row = start_row + 2 + @images.size  # session_bar + separator + images
+          # Use effective content width (respecting MAX_CONTENT_WIDTH_RATIO)
+          content_width = effective_content_width(@width)
           
           # Add rows for lines before current line
           @lines[0...@line_index].each_with_index do |line, idx|
@@ -327,7 +346,7 @@ module Clacky
               " " * prompt.length
             end
             prefix_width = calculate_display_width(strip_ansi_codes(prefix))
-            available_width = [@width - prefix_width, 20].max
+            available_width = [content_width - prefix_width, 20].max
             wrapped_segments = wrap_line(line, available_width)
             cursor_row += wrapped_segments.size
           end
@@ -340,7 +359,7 @@ module Clacky
             " " * prompt.length
           end
           prefix_width = calculate_display_width(strip_ansi_codes(prefix))
-          available_width = [@width - prefix_width, 20].max
+          available_width = [content_width - prefix_width, 20].max
           wrapped_segments = wrap_line(current, available_width)
           
           # Find cursor segment and position within segment
@@ -610,9 +629,9 @@ module Clacky
         # Shows suggestions when input starts with /
         private def update_command_suggestions
           return unless @command_suggestions
-          
+
           current = current_line.strip
-          
+
           # Check if we should show suggestions (input starts with /)
           if current.start_with?('/') && @line_index == 0
             # Extract the filter text (everything after /)
@@ -623,16 +642,37 @@ module Clacky
           end
         end
 
+        # Trigger tab completion: show all commands or filter by current slash input
+        # Called when Tab is pressed and no suggestions dropdown is visible
+        private def trigger_tab_completion
+          return unless @command_suggestions
+
+          current = current_line.strip
+
+          if current.empty?
+            # Empty input: type "/" and show all commands
+            insert_char("/")
+            @command_suggestions.show("")
+          elsif current.start_with?("/")
+            # Already typing a slash command: show/refresh filtered suggestions
+            filter_text = current[1..-1] || ""
+            @command_suggestions.show(filter_text)
+          end
+          # Tab on normal text has no effect
+        end
+
         # Render all input lines with auto-wrap support
         # @param start_row [Integer] Starting row position
         # @return [Integer] Next available row after rendering all lines
         def render_input_lines(start_row)
           current_row = start_row
+          # Use effective content width (respecting MAX_CONTENT_WIDTH_RATIO)
+          content_width = effective_content_width(@width)
           
           @lines.each_with_index do |line, line_idx|
             prefix = calculate_line_prefix(line_idx)
             prefix_width = calculate_display_width(strip_ansi_codes(prefix))
-            available_width = @width - prefix_width
+            available_width = content_width - prefix_width
             wrapped_segments = wrap_line(line, available_width)
 
             wrapped_segments.each_with_index do |segment_info, wrap_idx|
@@ -748,6 +788,11 @@ module Clacky
         def handle_enter
           text = current_value.strip
 
+          # Prepare display content and data BEFORE clearing
+          content_to_display = current_content
+          result_text = current_value
+          result_images = @images.dup
+
           # Handle commands (with or without slash)
           if text.start_with?('/')
             # Check if it's a command (single slash followed by English letters only)
@@ -755,10 +800,13 @@ module Clacky
             if text =~ /^\/([a-zA-Z-]+)$/
               case text
               when '/clear'
+                add_to_history(result_text) unless result_text.empty?
                 clear
-                return { action: :clear_output }
+                return { action: :clear_output, data: { text: result_text, images: result_images, display: content_to_display } }
               when '/help'
-                return { action: :help }
+                add_to_history(result_text) unless result_text.empty?
+                clear
+                return { action: :help, data: { text: result_text, images: result_images, display: content_to_display } }
               when '/exit', '/quit'
                 return { action: :exit }
               else
@@ -768,7 +816,9 @@ module Clacky
             end
             # If it's not a command pattern (e.g., /xxx/xxxx), treat as normal input
           elsif text == '?'
-            return { action: :help }
+            add_to_history(result_text) unless result_text.empty?
+            clear
+            return { action: :help, data: { text: result_text, images: result_images, display: content_to_display } }
           elsif text == 'exit' || text == 'quit'
             return { action: :exit }
           end
@@ -777,10 +827,6 @@ module Clacky
             return { action: nil }
           end
 
-          content_to_display = current_content
-          result_text = current_value
-          result_images = @images.dup
-
           add_to_history(result_text) unless result_text.empty?
           clear
 
@@ -1168,8 +1214,6 @@ module Clacky
             :magenta
           when /confirm_safes/
             :cyan
-          when /confirm_edits/
-            :green
           when /plan_only/
             :blue
           else