openclacky 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf44c03777d71d011e78e17171352ea824da23fa3cc5bcb09c8ba985134ea28e
-  data.tar.gz: bafeeb81f93b770c2929c9a71a11fd8ed8f344251d284d10031023c41390f73b
+  metadata.gz: 9c052d03a1c67251ddb1310bd82b4d1bbee0129716f4e0f2ec664dfdf3b52ced
+  data.tar.gz: 1d04af0f03f0e03e5ef41a312b2074a8b53a57d2fc9b38f95e73fe3baed3ffd4
 SHA512:
-  metadata.gz: 8d4be2efc7721ec808722faa943d3fe99e4a074bebdaf710be79c8b55cfc1ef5f6757ddf33f5c37dc63ebe020bbd135f98b19d3be287121756d020b86fdd3e8f
-  data.tar.gz: cb451f53e1d1c589760c1bfccfd530faa9bfafa22d1b3e6aaca1a03813dd5bc524fb3c12037c3f0fd84cf18c8a76d71d6e6fc02421bd7e314cde8b0d783156b5
+  metadata.gz: 6a78384406082c30a41e3546b145230276532567664e2fcf2d6de579a7765966d9ce837629c24b1e35e27f5b9a60b7e1337d6f95981665f74cc99cdee52773ef
+  data.tar.gz: 6da58385006861fcb511c56febf1a0c81d5f30825354e3610201ea2b4c53a29f0d65fd41cf89447c9347c396de4dadb77f7139e4a69d19d0f5debcc986e5536f

data/CHANGELOG.md

@@ -7,6 +7,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.1] - 2026-01-29
+
+### Added
+- User tips for better guidance and feedback
+- Batch TODO operations for improved task management
+- Markdown output support for better formatted responses
+- Text style customization options
+
+### Improved
+- Tool execution with slow progress indicators for long-running operations
+- Progress UI refinements for better visual feedback
+- Session restore now shows recent messages for context
+- TODO area UI enhancements with auto-hide when all tasks completed
+- Work status bar styling improvements
+- Text wrapping when moving input to output area
+- Safe shell output improvements for better readability
+- Task info display optimization (only show essential information)
+- TODO list cleanup and organization
+
+### Fixed
+- Double paste bug causing duplicate input
+- Double error message display issue
+- TODO clear functionality
+- RSpec test hanging issues
+
+### Removed
+- Tool emoji from output for cleaner display
+
 ## [0.6.0] - 2026-01-28
 
 ### Added

data/lib/clacky/agent.rb

@@ -129,6 +129,33 @@ module Clacky
       end
     end
 
+    # Get recent user messages from conversation history
+    # @param limit [Integer] Number of recent user messages to retrieve (default: 5)
+    # @return [Array<String>] Array of recent user message contents
+    def get_recent_user_messages(limit: 5)
+      # Filter messages to only include real user messages (exclude system-injected ones)
+      user_messages = @messages.select do |m|
+        m[:role] == "user" && !m[:system_injected]
+      end
+      
+      # Extract text content from the last N user messages
+      user_messages.last(limit).map do |msg|
+        extract_text_from_content(msg[:content])
+      end
+    end
+
+    private def extract_text_from_content(content)
+      if content.is_a?(String)
+        content
+      elsif content.is_a?(Array)
+        # Extract text from content array (may contain text and images)
+        text_parts = content.select { |c| c.is_a?(Hash) && c[:type] == "text" }
+        text_parts.map { |c| c[:text] }.join("\n")
+      else
+        content.to_s
+      end
+    end
+
     def add_hook(event, &block)
       @hooks.add(event, &block)
     end
@@ -137,6 +164,16 @@ module Clacky
       @start_time = Time.now
       @task_cost_source = :estimated  # Reset for new task
       @previous_total_tokens = 0  # Reset token tracking for new task
+      @task_start_iterations = @iterations  # Track starting iterations for this task
+      @task_start_cost = @total_cost  # Track starting cost for this task
+      
+      # Track cache stats for current task
+      @task_cache_stats = {
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0,
+        total_requests: 0,
+        cache_hit_requests: 0
+      }
 
       # Add system prompt as the first message if this is the first run
       if @messages.empty?
@@ -193,16 +230,17 @@ module Clacky
           if action_result[:denied]
             # If user provided feedback, treat it as a user question/instruction
             if action_result[:feedback] && !action_result[:feedback].empty?
-              # Add user feedback as a new user message
+              # Add user feedback as a new user message with system_injected marker
               @messages << {
                 role: "user",
-                content: "STOP. The user has a question/feedback for you: #{action_result[:feedback]}\n\nPlease respond to the user's question/feedback before continuing with any actions."
+                content: "STOP. The user has a question/feedback for you: #{action_result[:feedback]}\n\nPlease respond to the user's question/feedback before continuing with any actions.",
+                system_injected: true  # Mark as system-injected message for filtering
               }
               # Continue loop to let agent respond to feedback
               next
             else
               # User just said "no" without feedback - stop and wait
-              @ui&.show_assistant_message("Tool execution was denied. Please provide further instructions.")
+              @ui&.show_assistant_message("Tool execution was denied. Please give more instructions...")
               break
             end
           end
@@ -221,8 +259,8 @@ module Clacky
         # Let CLI handle the interrupt message
         raise
       rescue StandardError => e
+        # Build error result for session data, but let CLI handle error display
         result = build_result(:error, error: e.message)
-        @ui&.show_error("Error: #{e.message}")
         raise
       end
     end
@@ -405,8 +443,8 @@ module Clacky
         end
       end
 
-      # Stop progress thread (but keep progress line visible)
-      @ui&.stop_progress_thread
+      # Clear progress indicator (change to gray and show final time)
+      @ui&.clear_progress
 
       track_cost(response[:usage], raw_api_usage: response[:raw_api_usage])
 
@@ -494,7 +532,13 @@ module Clacky
 
           confirmation = confirm_tool_use?(call)
           unless confirmation[:approved]
-            @ui&.show_warning("Tool #{call[:name]} denied")
+            # Show denial warning with user feedback if provided
+            denial_message = "Tool #{call[:name]} denied"
+            if confirmation[:feedback] && !confirmation[:feedback].empty?
+              denial_message += ": #{confirmation[:feedback]}"
+            end
+            @ui&.show_warning(denial_message)
+            
             denied = true
             user_feedback = confirmation[:feedback]
             feedback = user_feedback if user_feedback
@@ -526,8 +570,17 @@ module Clacky
             args[:todos_storage] = @todos
           end
 
+          # Show progress for potentially slow tools (no prefix newline)
+          if potentially_slow_tool?(call[:name], args)
+            progress_message = build_tool_progress_message(call[:name], args)
+            @ui&.show_progress(progress_message, prefix_newline: false)
+          end
+
           result = tool.execute(**args)
 
+          # Clear progress if shown
+          @ui&.clear_progress if potentially_slow_tool?(call[:name], args)
+
           # Hook: after_tool_use
           @hooks.trigger(:after_tool_use, call, result)
 
@@ -606,6 +659,53 @@ module Clacky
       false
     end
 
+    # Check if a tool is potentially slow and should show progress
+    private def potentially_slow_tool?(tool_name, args)
+      case tool_name.to_s.downcase
+      when 'shell', 'safe_shell'
+        # Check if the command is a slow command
+        command = args[:command] || args['command']
+        return false unless command
+        
+        # List of slow command patterns
+        slow_patterns = [
+          /bundle\s+(install|exec\s+rspec|exec\s+rake)/,
+          /npm\s+(install|run\s+test|run\s+build)/,
+          /yarn\s+(install|test|build)/,
+          /pnpm\s+install/,
+          /cargo\s+(build|test)/,
+          /go\s+(build|test)/,
+          /make\s+(test|build)/,
+          /pytest/,
+          /jest/
+        ]
+        
+        slow_patterns.any? { |pattern| command.match?(pattern) }
+      when 'web_fetch', 'web_search'
+        true  # Network operations can be slow
+      else
+        false  # Most file operations are fast
+      end
+    end
+
+    # Build progress message for tool execution
+    private def build_tool_progress_message(tool_name, args)
+      case tool_name.to_s.downcase
+      when 'shell', 'safe_shell'
+        command = args[:command] || args['command']
+        # Extract the main command for display
+        cmd_parts = command.to_s.split
+        main_cmd = cmd_parts.first(2).join(' ')
+        "Running #{main_cmd}"
+      when 'web_fetch'
+        "Fetching web page"
+      when 'web_search'
+        "Searching web"
+      else
+        "Executing #{tool_name}"
+      end
+    end
+
     def track_cost(usage, raw_api_usage: nil)
       # Priority 1: Use API-provided cost if available (OpenRouter, LiteLLM, etc.)
       iteration_cost = nil
@@ -637,7 +737,7 @@ module Clacky
       # Display token usage statistics for this iteration
       display_iteration_tokens(usage, iteration_cost)
 
-      # Track cache usage statistics
+      # Track cache usage statistics (global)
       @cache_stats[:total_requests] += 1
 
       if usage[:cache_creation_input_tokens]
@@ -655,6 +755,20 @@ module Clacky
         @cache_stats[:raw_api_usage_samples] << raw_api_usage
         @cache_stats[:raw_api_usage_samples] = @cache_stats[:raw_api_usage_samples].last(3)
       end
+      
+      # Track cache usage for current task
+      if @task_cache_stats
+        @task_cache_stats[:total_requests] += 1
+        
+        if usage[:cache_creation_input_tokens]
+          @task_cache_stats[:cache_creation_input_tokens] += usage[:cache_creation_input_tokens]
+        end
+        
+        if usage[:cache_read_input_tokens]
+          @task_cache_stats[:cache_read_input_tokens] += usage[:cache_read_input_tokens]
+          @task_cache_stats[:cache_hit_requests] += 1
+        end
+      end
     end
 
     # Display token usage for current iteration
@@ -867,9 +981,14 @@ module Clacky
         when true
           { approved: true, feedback: nil }
         when false, nil
+          # User denied - add visual marker based on tool type
+          tool_name_capitalized = call[:name].capitalize
+          @ui&.show_info("  ↳ #{tool_name_capitalized} cancelled", prefix_newline: false)
           { approved: false, feedback: nil }
         else
-          # String feedback
+          # String feedback - also add visual marker
+          tool_name_capitalized = call[:name].capitalize
+          @ui&.show_info("  ↳ #{tool_name_capitalized} cancelled", prefix_newline: false)
           { approved: false, feedback: result.to_s }
         end
       else
@@ -1079,14 +1198,20 @@ module Clacky
     end
 
     def build_result(status, error: nil)
+      # Calculate iterations for current task only
+      task_iterations = @iterations - (@task_start_iterations || 0)
+      
+      # Calculate cost for current task only
+      task_cost = @total_cost - (@task_start_cost || 0)
+      
       {
         status: status,
         session_id: @session_id,
-        iterations: @iterations,
+        iterations: task_iterations,  # Show only current task iterations
         duration_seconds: Time.now - @start_time,
-        total_cost_usd: @total_cost.round(4),
+        total_cost_usd: task_cost.round(4),  # Show only current task cost
         cost_source: @task_cost_source,  # Add cost source for this task
-        cache_stats: @cache_stats,
+        cache_stats: @task_cache_stats || @cache_stats,  # Use task cache stats if available
         messages: @messages,
         error: error
       }

data/lib/clacky/cli.rb

@@ -82,11 +82,14 @@ module Clacky
       # Handle session loading/continuation
       session_manager = Clacky::SessionManager.new
       agent = nil
+      is_session_load = false
 
       if options[:continue]
         agent = load_latest_session(client, agent_config, session_manager, working_dir)
+        is_session_load = !agent.nil?
       elsif options[:attach]
         agent = load_session_by_number(client, agent_config, session_manager, working_dir, options[:attach])
+        is_session_load = !agent.nil?
       end
 
       # Create new agent if no session loaded
@@ -98,7 +101,7 @@ module Clacky
       Dir.chdir(working_dir) if should_chdir
 
       begin
-        run_agent_with_ui2(agent, working_dir, agent_config, message, session_manager, client)
+        run_agent_with_ui2(agent, working_dir, agent_config, message, session_manager, client, is_session_load: is_session_load)
       rescue StandardError => e
         # Save session on error
         if session_manager
@@ -231,7 +234,7 @@ module Clacky
           return nil
         end
 
-        say "Loading latest session: #{session_data[:session_id][0..7]}", :green
+        # Don't print message here - will be shown by UI after banner
         Clacky::Agent.from_session(client, agent_config, session_data)
       end
 
@@ -276,7 +279,7 @@ module Clacky
           end
         end
 
-        say "Loading session: #{session_data[:session_id][0..7]}", :green
+        # Don't print message here - will be shown by UI after banner
         Clacky::Agent.from_session(client, agent_config, session_data)
       end
 
@@ -296,7 +299,7 @@ module Clacky
       end
 
       # 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)
+      def run_agent_with_ui2(agent, working_dir, agent_config, initial_message = nil, session_manager = nil, client = nil, is_session_load: false)
         # Create UI2 controller with configuration
         ui_controller = UI2::UIController.new(
           working_dir: working_dir,
@@ -359,6 +362,8 @@ module Clacky
             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)
+            # Clear todo area display
+            ui_controller.update_todos([])
             next
           when "/exit", "/quit"
             ui_controller.stop
@@ -400,7 +405,12 @@ module Clacky
         end
 
         # Initialize UI screen first
-        ui_controller.initialize_and_show_banner
+        if is_session_load
+          recent_user_messages = agent.get_recent_user_messages(limit: 5)
+          ui_controller.initialize_and_show_banner(recent_user_messages: recent_user_messages)
+        else
+          ui_controller.initialize_and_show_banner
+        end
 
         # If there's an initial message, process it
         if initial_message && !initial_message.strip.empty?

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,93 @@ 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
-          error_msg = stderr.lines.first&.strip || "Failed"
-          "✗ Exit #{exit_code}: #{error_msg[0..50]}"
+          format_non_zero_exit(exit_code, stdout, stderr)
         end
       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
+          # 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

data/lib/clacky/tools/shell.rb

@@ -284,10 +284,10 @@ 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
     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