openclacky 0.6.0 → 0.6.2

data/lib/clacky/tools/glob.rb

@@ -122,13 +122,13 @@ module Clacky
 
       def format_result(result)
         if result[:error]
-          "✗ #{result[:error]}"
+          "[Error] #{result[:error]}"
         else
           count = result[:returned] || 0
           total = result[:total_matches] || 0
           truncated = result[:truncated] ? " (truncated)" : ""
           
-          msg = "✓ Found #{count}/#{total} files#{truncated}"
+          msg = "[OK] Found #{count}/#{total} files#{truncated}"
           
           # Add skipped files info if present
           if result[:skipped_files]

data/lib/clacky/tools/grep.rb

@@ -212,11 +212,11 @@ module Clacky
 
       def format_result(result)
         if result[:error]
-          "✗ #{result[:error]}"
+          "[Error] #{result[:error]}"
         else
           matches = result[:total_matches] || 0
           files = result[:files_with_matches] || 0
-          msg = "✓ Found #{matches} matches in #{files} files"
+          msg = "[OK] Found #{matches} matches in #{files} files"
           
           # Add truncation info if present
           if result[:truncated] && result[:truncation_reason]

data/lib/clacky/tools/run_project.rb

@@ -74,22 +74,22 @@ module Clacky
 
       def format_result(result)
         if result[:error]
-          "✗ #{result[:error]}"
+          "[Error] #{result[:error]}"
         elsif result[:status]
           case result[:status]
           when 'started'
             cmd_preview = result[:command] ? result[:command][0..50] : ''
             output_preview = result[:output]&.lines&.first(2)&.join&.strip
-            msg = "✓ Started (PID: #{result[:pid]}, cmd: #{cmd_preview})"
+            msg = "[OK] Started (PID: #{result[:pid]}, cmd: #{cmd_preview})"
             msg += "\n  #{output_preview}" if output_preview && !output_preview.empty?
             msg
           when 'stopped'
-            "✓ Stopped"
+            "[OK] Stopped"
           when 'running'
             uptime = result[:uptime] ? "#{result[:uptime].round(1)}s" : "unknown"
-            "Running (#{uptime}, PID: #{result[:pid]})"
+            "[Running] #{uptime}, PID: #{result[:pid]}"
           when 'not_running'
-            "Not running"
+            "[Not Running]"
           else
             result[:status].to_s
           end

data/lib/clacky/tools/safe_shell.rb

@@ -62,7 +62,7 @@ module Clacky
           {
             command: command,
             stdout: "",
-            stderr: "🔒 Security Protection: #{e.message}",
+            stderr: "[Security Protection] #{e.message}",
             exit_code: 126,
             success: false,
             security_blocked: true
@@ -72,7 +72,10 @@ module Clacky
 
       private def extract_timeout_from_command(command)
         # Match patterns: "timeout 30 ...", "timeout 30s ...", etc.
+        # Also supports: "cd xxx && timeout 30 command", "export X=Y && timeout 30 command"
         # Supports: timeout N command, timeout Ns command, timeout -s SIGNAL N command
+        
+        # Try to match timeout at the beginning of command
         match = command.match(/^timeout\s+(?:-s\s+\w+\s+)?(\d+)s?\s+(.+)$/i)
         
         if match
@@ -81,7 +84,22 @@ module Clacky
           return [actual_command, timeout_value]
         end
         
-        # No timeout prefix found, return original command
+        # Try to match timeout after && or ;
+        # Pattern: "prefix && timeout 30 command" or "prefix; timeout 30 command"
+        match = command.match(/^(.+?)\s*(&&|;)\s*timeout\s+(?:-s\s+\w+\s+)?(\d+)s?\s+(.+)$/i)
+        
+        if match
+          prefix = match[1]          # e.g., "cd /tmp"
+          separator = match[2]        # && or ;
+          timeout_value = match[3].to_i
+          main_command = match[4]     # e.g., "bundle exec rspec"
+          
+          # Reconstruct command without timeout prefix
+          actual_command = "#{prefix} #{separator} #{main_command}"
+          return [actual_command, timeout_value]
+        end
+        
+        # No timeout found, return original command
         [command, nil]
       end
 
@@ -135,7 +153,7 @@ module Clacky
           result[:safe_command] = safe_command
 
           # Add security note to stdout
-          security_note = "🔒 Command was automatically made safe\n"
+          security_note = "[Safe] Command was automatically made safe\n"
           result[:stdout] = security_note + (result[:stdout] || "")
         end
 
@@ -160,18 +178,111 @@ module Clacky
         stderr = result[:stderr] || result['stderr'] || ""
 
         if result[:security_blocked]
-          "🔒 Blocked for security"
+          "[Blocked] Security protection"
         elsif result[:security_enhanced]
           lines = stdout.lines.size
-          "🔒✓ Safe execution#{lines > 0 ? " (#{lines} lines)" : ''}"
+          "[Safe] Completed#{lines > 0 ? " (#{lines} lines)" : ''}"
         elsif exit_code == 0
           lines = stdout.lines.size
-          "✓ Completed#{lines > 0 ? " (#{lines} lines)" : ''}"
+          "[OK] Completed#{lines > 0 ? " (#{lines} lines)" : ''}"
+        else
+          format_non_zero_exit(exit_code, stdout, stderr)
+        end
+      end
+
+      # Override format_result_for_llm to preserve security fields
+      def format_result_for_llm(result)
+        # If security blocked, return as-is (small and important)
+        return result if result[:security_blocked]
+        
+        # Call parent's format_result_for_llm to truncate output
+        compact = super(result)
+        
+        # Add security enhancement fields if present (they're small and important for LLM to understand)
+        if result[:security_enhanced]
+          compact[:security_enhanced] = true
+          compact[:original_command] = result[:original_command]
+          compact[:safe_command] = result[:safe_command]
+        end
+        
+        compact
+      end
+
+      private def format_non_zero_exit(exit_code, stdout, stderr)
+        stdout_lines = stdout.lines.size
+        has_output = stdout_lines > 0
+        has_error = !stderr.empty?
+        
+        if has_error
+          # Real error: show error summary
+          error_summary = extract_error_summary(stderr)
+          "[Exit #{exit_code}] #{error_summary}"
+        elsif has_output
+          # Command produced output but exited with non-zero code
+          # This is common in commands like "ls; exit 1" or grep with no matches
+          "[Exit #{exit_code}] #{stdout_lines} lines output"
         else
-          error_msg = stderr.lines.first&.strip || "Failed"
-          "✗ Exit #{exit_code}: #{error_msg[0..50]}"
+          # No output, no error message - just show exit code
+          "[Exit #{exit_code}] No output"
         end
       end
+
+      private def extract_error_summary(stderr)
+        return "No error message" if stderr.empty?
+        
+        # Try to extract the most meaningful error line
+        lines = stderr.lines.map(&:strip).reject(&:empty?)
+        
+        # Common error patterns with priority
+        patterns = [
+          # Ruby/Python exceptions with error type
+          { regex: /(\w+(?:Error|Exception)):\s*(.+)$/, format: ->(m) { "#{m[1]}: #{m[2]}" } },
+          # File not found patterns
+          { regex: /cannot load such file.*--\s*(.+)$/, format: ->(m) { "Cannot load file: #{m[1]}" } },
+          { regex: /No such file or directory.*[@\-]\s*(.+)$/, format: ->(m) { "File not found: #{m[1]}" } },
+          # Undefined method/variable
+          { regex: /undefined (?:local variable or )?method [`'](\w+)'/, format: ->(m) { "Undefined method: #{m[1]}" } },
+          # Syntax errors
+          { regex: /syntax error,?\s*(.+)$/i, format: ->(m) { "Syntax error: #{m[1]}" } }
+        ]
+        
+        # Try each pattern on each line
+        patterns.each do |pattern|
+          lines.each do |line|
+            match = line.match(pattern[:regex])
+            if match
+              result = pattern[:format].call(match)
+              return truncate_error(clean_path(result), 80)
+            end
+          end
+        end
+        
+        # Fallback: find the most informative line
+        informative_line = lines.find do |line|
+          !line.start_with?('from', 'Did you mean?', '#', 'Showing full backtrace') &&
+          line.length > 10 &&
+          (line.include?(':') || line.match?(/error|failed|cannot|invalid/i))
+        end
+        
+        if informative_line
+          return truncate_error(clean_path(informative_line), 80)
+        end
+        
+        # Last resort: use first meaningful line
+        first_line = lines.first || "Unknown error"
+        truncate_error(clean_path(first_line), 80)
+      end
+
+      private def clean_path(text)
+        # Remove long absolute paths, keep only filename
+        text.gsub(/\/(?:Users|home)\/[^\/]+\/[\w\/\.\-]+\/([^:\/\s]+)/, '')
+            .gsub(/\/[\w\/\.\-]{30,}\/([^:\/\s]+)/, '...')
+      end
+
+      private def truncate_error(text, max_length)
+        return text if text.length <= max_length
+        "#{text[0...max_length-3]}..."
+      end
     end
 
     class CommandSafetyReplacer
@@ -238,7 +349,12 @@ module Clacky
 
       def replace_chmod_command(command)
         # Parse chmod command to ensure it's safe
-        parts = Shellwords.split(command)
+        begin
+          parts = Shellwords.split(command)
+        rescue Shellwords::BadQuotedString => e
+          # If Shellwords.split fails, use simple split as fallback
+          parts = command.split(/\s+/)
+        end
 
         # Only allow chmod +x on files in project directory
         files = parts[2..-1] || []
@@ -247,8 +363,6 @@ module Clacky
         # Allow chmod +x as it's generally safe
         log_replacement("chmod", command, "chmod +x is allowed - file permissions will be modified")
         command
-      rescue Shellwords::BadQuotedString
-        raise SecurityError, "Invalid chmod command syntax: #{command}"
       end
 
       def replace_curl_pipe_command(command)
@@ -277,7 +391,14 @@ module Clacky
 
       def validate_and_allow(command)
         # Check basic file operation commands
-        parts = Shellwords.split(command)
+        begin
+          parts = Shellwords.split(command)
+        rescue Shellwords::BadQuotedString => e
+          # If Shellwords.split fails due to quote issues, try simple split as fallback
+          # This handles cases where paths don't actually need shell escaping
+          parts = command.split(/\s+/)
+        end
+        
         cmd = parts.first
         args = parts[1..-1]
 
@@ -291,8 +412,6 @@ module Clacky
         end
 
         command
-      rescue Shellwords::BadQuotedString
-        raise SecurityError, "Invalid command syntax: #{command}"
       end
 
       def validate_general_command(command)
@@ -326,11 +445,15 @@ module Clacky
       end
 
       def parse_rm_files(command)
-        parts = Shellwords.split(command)
+        begin
+          parts = Shellwords.split(command)
+        rescue Shellwords::BadQuotedString => e
+          # If Shellwords.split fails, use simple split as fallback
+          parts = command.split(/\s+/)
+        end
+        
         # Skip rm command itself and option parameters
         parts.drop(1).reject { |part| part.start_with?('-') }
-      rescue Shellwords::BadQuotedString
-        raise SecurityError, "Invalid command syntax: #{command}"
       end
 
       def validate_file_path(path)

data/lib/clacky/tools/shell.rb

@@ -284,12 +284,79 @@ module Clacky
 
         if exit_code == 0
           lines = stdout.lines.size
-          "✓ Completed#{lines > 0 ? " (#{lines} lines)" : ''}"
+          "[OK] Completed#{lines > 0 ? " (#{lines} lines)" : ''}"
         else
           error_msg = stderr.lines.first&.strip || "Failed"
-          "✗ Exit #{exit_code}: #{error_msg[0..50]}"
+          "[Exit #{exit_code}] #{error_msg[0..50]}"
         end
       end
+
+      # Format result for LLM consumption - limit output size to save tokens
+      # Maximum characters to include in LLM output
+      MAX_LLM_OUTPUT_CHARS = 2000
+      
+      def format_result_for_llm(result)
+        # Return error info as-is if command failed or timed out
+        return result if result[:error] || result[:state] == 'TIMEOUT' || result[:state] == 'WAITING_INPUT'
+        
+        stdout = result[:stdout] || ""
+        stderr = result[:stderr] || ""
+        exit_code = result[:exit_code] || 0
+        
+        # Build compact result with truncated output
+        compact = {
+          command: result[:command],
+          exit_code: exit_code,
+          success: result[:success]
+        }
+        
+        # Add elapsed time if available
+        compact[:elapsed] = result[:elapsed] if result[:elapsed]
+        
+        # Truncate stdout to save tokens
+        if stdout.empty?
+          compact[:stdout] = ""
+        else
+          stdout_lines = stdout.lines
+          stdout_line_count = stdout_lines.length
+          
+          if stdout.length <= MAX_LLM_OUTPUT_CHARS
+            compact[:stdout] = stdout
+          else
+            # Take first N lines that fit within the character limit
+            accumulated_chars = 0
+            lines_to_include = []
+            
+            stdout_lines.each do |line|
+              break if accumulated_chars + line.length > MAX_LLM_OUTPUT_CHARS
+              lines_to_include << line
+              accumulated_chars += line.length
+            end
+            
+            compact[:stdout] = lines_to_include.join
+            compact[:stdout] += "\n\n... [Output truncated for LLM: showing #{lines_to_include.length} of #{stdout_line_count} lines, #{accumulated_chars} of #{stdout.length} chars] ...\n"
+          end
+        end
+        
+        # Truncate stderr to save tokens (usually more important than stdout, so keep more)
+        if stderr.empty?
+          compact[:stderr] = ""
+        else
+          stderr_line_count = stderr.lines.length
+          
+          if stderr.length <= MAX_LLM_OUTPUT_CHARS
+            compact[:stderr] = stderr
+          else
+            compact[:stderr] = stderr[0...MAX_LLM_OUTPUT_CHARS]
+            compact[:stderr] += "\n\n... [Error output truncated for LLM: showing #{MAX_LLM_OUTPUT_CHARS} of #{stderr.length} chars, #{stderr_line_count} lines] ...\n"
+          end
+        end
+        
+        # Add output_truncated flag
+        compact[:output_truncated] = result[:output_truncated] if result[:output_truncated]
+        
+        compact
+      end
     end
   end
 end

data/lib/clacky/tools/todo_manager.rb

@@ -29,12 +29,17 @@ module Clacky
           id: {
             type: "integer",
             description: "The task ID (required for 'complete' and 'remove' actions)"
+          },
+          ids: {
+            type: "array",
+            items: { type: "integer" },
+            description: "Array of task IDs for batch removal (for 'remove' action). Example: [1, 3, 5]"
           }
         },
         required: ["action"]
       }
 
-      def execute(action:, task: nil, tasks: nil, id: nil, todos_storage: nil)
+      def execute(action:, task: nil, tasks: nil, id: nil, ids: nil, todos_storage: nil)
         # todos_storage is injected by Agent, stores todos in memory
         @todos = todos_storage || []
 
@@ -46,7 +51,12 @@ module Clacky
         when "complete"
           complete_todo(id)
         when "remove"
-          remove_todo(id)
+          # Support both single ID and batch IDs
+          if ids && ids.is_a?(Array)
+            remove_todos(ids)
+          else
+            remove_todo(id)
+          end
         when "clear"
           clear_todos
         else
@@ -65,7 +75,12 @@ module Clacky
         when 'list'
           "TodoManager(list)"
         when 'remove'
-          "TodoManager(remove ##{args[:id] || args['id']})"
+          ids = args[:ids] || args['ids']
+          if ids && ids.is_a?(Array) && !ids.empty?
+            "TodoManager(remove #{ids.size} tasks: #{ids.join(', ')})"
+          else
+            "TodoManager(remove ##{args[:id] || args['id']})"
+          end
         when 'clear'
           "TodoManager(clear all)"
         else
@@ -223,6 +238,38 @@ module Clacky
           cleared_count: count
         }
       end
+
+      def remove_todos(ids)
+        return { error: "Task IDs array is required" } if ids.nil? || ids.empty?
+
+        todos = load_todos
+        removed_todos = []
+        not_found_ids = []
+
+        ids.each do |id|
+          todo = todos.find { |t| t[:id] == id }
+          if todo
+            removed_todos << todo
+          else
+            not_found_ids << id
+          end
+        end
+
+        # Remove all found todos
+        todos.reject! { |t| ids.include?(t[:id]) }
+        save_todos(todos)
+
+        result = {
+          message: "#{removed_todos.size} task(s) removed",
+          removed: removed_todos,
+          remaining: todos.size
+        }
+
+        # Add warning about not found IDs
+        result[:not_found] = not_found_ids unless not_found_ids.empty?
+
+        result
+      end
     end
   end
 end

data/lib/clacky/tools/trash_manager.rb

@@ -363,7 +363,7 @@ module Clacky
         when 'help'
           "❓ Help displayed"
         else
-          success ? "✓ #{action} completed" : "✗ #{action} failed"
+          success ? "[OK] #{action} completed" : "[Error] #{action} failed"
         end
       end
     end

data/lib/clacky/tools/web_fetch.rb

@@ -149,11 +149,11 @@ module Clacky
 
       def format_result(result)
         if result[:error]
-          "✗ #{result[:error]}"
+          "[Error] #{result[:error]}"
         else
           title = result[:title] || 'Untitled'
           display_title = title.length > 40 ? "#{title[0..37]}..." : title
-          "✓ Fetched: #{display_title}"
+          "[OK] Fetched: #{display_title}"
         end
       end
     end

data/lib/clacky/tools/web_search.rb

@@ -139,10 +139,10 @@ module Clacky
 
       def format_result(result)
         if result[:error]
-          "✗ #{result[:error]}"
+          "[Error] #{result[:error]}"
         else
           count = result[:count] || 0
-          "✓ Found #{count} results"
+          "[OK] Found #{count} results"
         end
       end
     end

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

@@ -15,7 +15,7 @@ module Clacky
           "#{symbol} #{text}"
         end
 
-        # Render progress indicator
+        # Render progress indicator (stopped state, gray)
         # @param message [String] Progress message
         # @return [String] Progress indicator
         def render_progress(message)
@@ -24,6 +24,15 @@ module Clacky
           "#{symbol} #{text}"
         end
 
+        # Render working indicator (active state, yellow)
+        # @param message [String] Progress message
+        # @return [String] Working indicator
+        def render_working(message)
+          symbol = format_symbol(:working)
+          text = format_text(message, :working)
+          "#{symbol} #{text}"
+        end
+
         # Render success message
         # @param message [String] Success message
         # @return [String] Success message
@@ -65,22 +74,22 @@ module Clacky
           lines << @pastel.dim("─" * 60)
           lines << render_success("Task Complete")
           lines << ""
-          
+
           # Display each stat on a separate line
           lines << "  Iterations: #{iterations}"
           lines << "  Cost: $#{cost.round(4)}"
           lines << "  Duration: #{duration.round(1)}s" if duration
-          
+
           # Display cache information if available
           if cache_tokens && cache_tokens > 0
             lines << "  Cache Tokens: #{cache_tokens} tokens"
           end
-          
+
           if cache_requests && cache_requests > 0
             hit_rate = cache_hits > 0 ? ((cache_hits.to_f / cache_requests) * 100).round(1) : 0
             lines << "  Cache Requests: #{cache_requests} (#{cache_hits} hits, #{hit_rate}% hit rate)"
           end
-          
+
           lines.join("\n")
         end
       end