clacky 0.5.0

data/lib/clacky/tools/trash_manager.rb

@@ -0,0 +1,367 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require_relative "base"
+
+module Clacky
+  module Tools
+    class TrashManager < Base
+      self.tool_name = "trash_manager"
+      self.tool_description = "Manage deleted files in the AI trash - list, restore, or permanently delete files"
+      self.tool_category = "system"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["list", "restore", "status", "empty", "help"],
+            description: "Action to perform: 'list' (show deleted files), 'restore' (restore a file), 'status' (show trash summary), 'empty' (permanently delete old files), 'help' (show usage)"
+          },
+          file_path: {
+            type: "string",
+            description: "Original file path to restore (required for 'restore' action)"
+          },
+          days_old: {
+            type: "integer",
+            description: "For 'empty' action: permanently delete files older than this many days (default: 7)"
+          }
+        },
+        required: ["action"]
+      }
+
+      def execute(action:, file_path: nil, days_old: 7)
+        project_root = Dir.pwd
+        trash_dir = File.join(project_root, '.ai_trash')
+
+        unless Dir.exist?(trash_dir)
+          return {
+            action: action,
+            success: false,
+            message: "No trash directory found. No files have been safely deleted yet."
+          }
+        end
+
+        case action.downcase
+        when 'list'
+          list_deleted_files(trash_dir)
+        when 'restore'
+          return { action: action, success: false, message: "file_path is required for restore action" } unless file_path
+          restore_file(trash_dir, file_path, project_root)
+        when 'status'
+          show_trash_status(trash_dir)
+        when 'empty'
+          empty_trash(trash_dir, days_old)
+        when 'help'
+          show_help
+        else
+          { action: action, success: false, message: "Unknown action: #{action}" }
+        end
+      end
+
+      def list_deleted_files(trash_dir)
+        deleted_files = get_deleted_files(trash_dir)
+
+        if deleted_files.empty?
+          return {
+            action: 'list',
+            success: true,
+            count: 0,
+            message: "🗑️  Trash is empty"
+          }
+        end
+
+        file_list = deleted_files.map.with_index(1) do |file, index|
+          size_info = file[:file_size] ? " (#{format_bytes(file[:file_size])})" : ""
+          "#{index}. #{file[:original_path]}#{size_info}\n   Deleted: #{format_time(file[:deleted_at])}"
+        end
+
+        {
+          action: 'list',
+          success: true,
+          count: deleted_files.size,
+          files: deleted_files,
+          message: "🗑️  Deleted Files:\n\n#{file_list.join("\n\n")}\n\n💡 Use trash_manager with action='restore' and file_path='<path>' to restore a file"
+        }
+      end
+
+      def restore_file(trash_dir, file_path, project_root)
+        deleted_files = get_deleted_files(trash_dir)
+        expanded_path = File.expand_path(file_path, project_root)
+
+        target_file = deleted_files.find { |f| f[:original_path] == expanded_path }
+
+        unless target_file
+          similar_files = deleted_files.select { |f| File.basename(f[:original_path]) == File.basename(file_path) }
+
+          if similar_files.any?
+            suggestions = similar_files.map { |f| f[:original_path] }.join("\n  - ")
+            return {
+              action: 'restore',
+              success: false,
+              message: "File not found in trash: #{file_path}\n\nDid you mean one of these?\n  - #{suggestions}"
+            }
+          else
+            return {
+              action: 'restore',
+              success: false,
+              message: "File not found in trash: #{file_path}\n\nUse trash_manager with action='list' to see available files."
+            }
+          end
+        end
+
+        if File.exist?(expanded_path)
+          return {
+            action: 'restore',
+            success: false,
+            message: "Cannot restore: file already exists at #{file_path}"
+          }
+        end
+
+        begin
+          # Ensure target directory exists
+          FileUtils.mkdir_p(File.dirname(expanded_path))
+
+          # Restore file
+          FileUtils.mv(target_file[:trash_file], expanded_path)
+          File.delete("#{target_file[:trash_file]}.metadata.json")
+
+          {
+            action: 'restore',
+            success: true,
+            restored_file: expanded_path,
+            message: "✅ Successfully restored: #{file_path}"
+          }
+        rescue StandardError => e
+          {
+            action: 'restore',
+            success: false,
+            message: "❌ Failed to restore file: #{e.message}"
+          }
+        end
+      end
+
+      def show_trash_status(trash_dir)
+        deleted_files = get_deleted_files(trash_dir)
+        total_size = deleted_files.sum { |f| f[:file_size] || 0 }
+
+        if deleted_files.empty?
+          return {
+            action: 'status',
+            success: true,
+            count: 0,
+            total_size: 0,
+            message: "🗑️  Trash is empty"
+          }
+        end
+
+        # Group by file type
+        by_type = deleted_files.group_by { |f| f[:file_type] || 'no extension' }
+        type_summary = by_type.map do |ext, files|
+          size = files.sum { |f| f[:file_size] || 0 }
+          "  #{ext}: #{files.size} files (#{format_bytes(size)})"
+        end.join("\n")
+
+        recent_files = deleted_files.first(3).map do |file|
+          "  - #{File.basename(file[:original_path])} (#{format_time(file[:deleted_at])})"
+        end.join("\n")
+
+        message = []
+        message << "🗑️  Trash Status:"
+        message << "  Files: #{deleted_files.count}"
+        message << "  Total size: #{format_bytes(total_size)}"
+        message << "  Location: #{trash_dir}"
+        message << ""
+        message << "📊 By file type:"
+        message << type_summary
+        message << ""
+        message << "📅 Recently deleted:"
+        message << recent_files
+
+        {
+          action: 'status',
+          success: true,
+          count: deleted_files.size,
+          total_size: total_size,
+          by_type: by_type.transform_values(&:size),
+          message: message.join("\n")
+        }
+      end
+
+      def empty_trash(trash_dir, days_old)
+        deleted_files = get_deleted_files(trash_dir)
+        cutoff_time = Time.now - (days_old * 24 * 60 * 60)
+
+        old_files = deleted_files.select do |file|
+          Time.parse(file[:deleted_at]) < cutoff_time
+        end
+
+        if old_files.empty?
+          return {
+            action: 'empty',
+            success: true,
+            deleted_count: 0,
+            message: "🗑️  No files older than #{days_old} days found in trash"
+          }
+        end
+
+        deleted_count = 0
+        freed_size = 0
+
+        old_files.each do |file|
+          begin
+            File.delete(file[:trash_file]) if File.exist?(file[:trash_file])
+            File.delete("#{file[:trash_file]}.metadata.json") if File.exist?("#{file[:trash_file]}.metadata.json")
+            deleted_count += 1
+            freed_size += file[:file_size] || 0
+          rescue StandardError => e
+            # Continue processing other files, but log the error
+          end
+        end
+
+        {
+          action: 'empty',
+          success: true,
+          deleted_count: deleted_count,
+          freed_size: freed_size,
+          days_old: days_old,
+          message: "🗑️  Permanently deleted #{deleted_count} files older than #{days_old} days\n💾 Freed up #{format_bytes(freed_size)} of disk space"
+        }
+      end
+
+      def show_help
+        help_text = <<~HELP
+          🗑️ Trash Manager Help
+
+          The SafeShell tool automatically moves deleted files to a trash directory
+          instead of permanently deleting them. This tool helps you manage those files.
+
+          Available actions:
+
+          📋 list - Show all deleted files
+          Example: trash_manager(action="list")
+
+          ♻️  restore - Restore a deleted file to its original location
+          Example: trash_manager(action="restore", file_path="path/to/file.txt")
+
+          📊 status - Show trash summary with statistics
+          Example: trash_manager(action="status")
+
+          🗑️  empty - Permanently delete files older than N days (default: 7)
+          Example: trash_manager(action="empty", days_old=7)
+
+          ❓ help - Show this help message
+
+          💡 Tips:
+          - 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
+        HELP
+
+        {
+          action: 'help',
+          success: true,
+          message: help_text
+        }
+      end
+
+      def get_deleted_files(trash_dir)
+        deleted_files = []
+
+        Dir.glob(File.join(trash_dir, "*.metadata.json")).each do |metadata_file|
+          begin
+            metadata = JSON.parse(File.read(metadata_file))
+            trash_file = metadata_file.sub('.metadata.json', '')
+
+            # Only include existing trash files
+            if File.exist?(trash_file)
+              deleted_files << {
+                original_path: metadata['original_path'],
+                deleted_at: metadata['deleted_at'],
+                trash_file: trash_file,
+                file_size: metadata['file_size'],
+                file_type: metadata['file_type'],
+                file_mode: metadata['file_mode']
+              }
+            end
+          rescue StandardError
+            # Skip corrupted metadata files
+          end
+        end
+
+        deleted_files.sort_by { |f| f[:deleted_at] }.reverse
+      end
+
+      def format_bytes(bytes)
+        return "0 B" if bytes.zero?
+
+        units = %w[B KB MB GB]
+        unit_index = 0
+        size = bytes.to_f
+
+        while size >= 1024 && unit_index < units.length - 1
+          size /= 1024.0
+          unit_index += 1
+        end
+
+        if unit_index == 0
+          "#{size.to_i} #{units[unit_index]}"
+        else
+          "#{size.round(2)} #{units[unit_index]}"
+        end
+      end
+
+      def format_time(time_str)
+        time = Time.parse(time_str)
+        if time.to_date == Date.today
+          time.strftime("%H:%M")
+        elsif time.to_date == Date.today - 1
+          "yesterday #{time.strftime('%H:%M')}"
+        elsif time.year == Date.today.year
+          time.strftime("%m/%d %H:%M")
+        else
+          time.strftime("%Y/%m/%d")
+        end
+      rescue
+        time_str
+      end
+
+      def format_call(args)
+        action = args[:action] || args['action'] || 'unknown'
+        "TrashManager(#{action})"
+      end
+
+      def format_result(result)
+        action = result[:action] || 'unknown'
+        success = result[:success]
+
+        case action
+        when 'list'
+          count = result[:count] || 0
+          "📋 Listed #{count} deleted files"
+        when 'restore'
+          if success
+            "♻️ File restored successfully"
+          else
+            "❌ Restore failed"
+          end
+        when 'status'
+          count = result[:count] || 0
+          "📊 Trash: #{count} files"
+        when 'empty'
+          if success
+            deleted_count = result[:deleted_count] || 0
+            "🗑️ Emptied #{deleted_count} files"
+          else
+            "❌ Empty failed"
+          end
+        when 'help'
+          "❓ Help displayed"
+        else
+          success ? "✓ #{action} completed" : "✗ #{action} failed"
+        end
+      end
+    end
+  end
+end

data/lib/clacky/tools/web_fetch.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Clacky
+  module Tools
+    class WebFetch < Base
+      self.tool_name = "web_fetch"
+      self.tool_description = "Fetch and parse content from a web page. Returns the page content, title, and metadata."
+      self.tool_category = "web"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          url: {
+            type: "string",
+            description: "The URL to fetch (must be a valid HTTP/HTTPS URL)"
+          },
+          max_length: {
+            type: "integer",
+            description: "Maximum content length to return in characters (default: 50000)",
+            default: 50000
+          }
+        },
+        required: %w[url]
+      }
+
+      def execute(url:, max_length: 50000)
+        # Validate URL
+        begin
+          uri = URI.parse(url)
+          unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+            return { error: "URL must be HTTP or HTTPS" }
+          end
+        rescue URI::InvalidURIError => e
+          return { error: "Invalid URL: #{e.message}" }
+        end
+
+        begin
+          # Fetch the web page
+          response = fetch_url(uri)
+
+          # Extract content
+          content = response.body
+          content_type = response["content-type"] || ""
+
+          # Parse HTML if it's an HTML page
+          if content_type.include?("text/html")
+            result = parse_html(content, max_length)
+            result[:url] = url
+            result[:content_type] = content_type
+            result[:status_code] = response.code.to_i
+            result[:error] = nil
+            result
+          else
+            # For non-HTML content, return raw text
+            truncated_content = content[0, max_length]
+            {
+              url: url,
+              content_type: content_type,
+              status_code: response.code.to_i,
+              content: truncated_content,
+              truncated: content.length > max_length,
+              error: nil
+            }
+          end
+        rescue StandardError => e
+          { error: "Failed to fetch URL: #{e.message}" }
+        end
+      end
+
+      def fetch_url(uri)
+        # Follow redirects (max 5)
+        redirects = 0
+        max_redirects = 5
+
+        loop do
+          request = Net::HTTP::Get.new(uri)
+          request["User-Agent"] = "Mozilla/5.0 (compatible; Clacky/1.0)"
+
+          response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https", read_timeout: 15) do |http|
+            http.request(request)
+          end
+
+          case response
+          when Net::HTTPSuccess
+            return response
+          when Net::HTTPRedirection
+            redirects += 1
+            raise "Too many redirects" if redirects > max_redirects
+
+            location = response["location"]
+            uri = URI.parse(location)
+          else
+            raise "HTTP error: #{response.code} #{response.message}"
+          end
+        end
+      end
+
+      def parse_html(html, max_length)
+        # Extract title
+        title = ""
+        if html =~ %r{<title[^>]*>(.*?)</title>}mi
+          title = $1.strip.gsub(/\s+/, " ")
+        end
+
+        # Extract meta description
+        description = ""
+        if html =~ /<meta[^>]*name=["']description["'][^>]*content=["']([^"']*)["']/mi
+          description = $1.strip
+        elsif html =~ /<meta[^>]*content=["']([^"']*)["'][^>]*name=["']description["']/mi
+          description = $1.strip
+        end
+
+        # Remove script and style tags
+        text = html.gsub(%r{<script[^>]*>.*?</script>}mi, "")
+                   .gsub(%r{<style[^>]*>.*?</style>}mi, "")
+
+        # Remove HTML tags
+        text = text.gsub(/<[^>]+>/, " ")
+
+        # Clean up whitespace
+        text = text.gsub(/\s+/, " ").strip
+
+        # Truncate if needed
+        truncated = text.length > max_length
+        text = text[0, max_length] if truncated
+
+        {
+          title: title,
+          description: description,
+          content: text,
+          truncated: truncated
+        }
+      end
+
+      def format_call(args)
+        url = args[:url] || args['url'] || ''
+        # Extract domain from URL for display
+        begin
+          uri = URI.parse(url)
+          domain = uri.host || url
+          "web_fetch(#{domain})"
+        rescue
+          display_url = url.length > 40 ? "#{url[0..37]}..." : url
+          "web_fetch(\"#{display_url}\")"
+        end
+      end
+
+      def format_result(result)
+        if result[:error]
+          "✗ #{result[:error]}"
+        else
+          title = result[:title] || 'Untitled'
+          display_title = title.length > 40 ? "#{title[0..37]}..." : title
+          "✓ Fetched: #{display_title}"
+        end
+      end
+    end
+  end
+end

data/lib/clacky/tools/web_search.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require "cgi"
+
+module Clacky
+  module Tools
+    class WebSearch < Base
+      self.tool_name = "web_search"
+      self.tool_description = "Search the web for current information. Returns search results with titles, URLs, and snippets."
+      self.tool_category = "web"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query"
+          },
+          max_results: {
+            type: "integer",
+            description: "Maximum number of results to return (default: 10)",
+            default: 10
+          }
+        },
+        required: %w[query]
+      }
+
+      def execute(query:, max_results: 10)
+        # Validate query
+        if query.nil? || query.strip.empty?
+          return { error: "Query cannot be empty" }
+        end
+
+        begin
+          # Use DuckDuckGo HTML search (no API key needed)
+          results = search_duckduckgo(query, max_results)
+
+          {
+            query: query,
+            results: results,
+            count: results.length,
+            error: nil
+          }
+        rescue StandardError => e
+          { error: "Failed to perform web search: #{e.message}" }
+        end
+      end
+
+      def search_duckduckgo(query, max_results)
+        # DuckDuckGo HTML search endpoint
+        encoded_query = CGI.escape(query)
+        url = URI("https://html.duckduckgo.com/html/?q=#{encoded_query}")
+
+        # Make request with user agent
+        request = Net::HTTP::Get.new(url)
+        request["User-Agent"] = "Mozilla/5.0 (compatible; Clacky/1.0)"
+
+        response = Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: 10) do |http|
+          http.request(request)
+        end
+
+        unless response.is_a?(Net::HTTPSuccess)
+          return []
+        end
+
+        # Parse HTML results (simple extraction)
+        parse_duckduckgo_html(response.body, max_results)
+      rescue StandardError => e
+        # Fallback: return basic search URL
+        [
+          {
+            title: "Search results for: #{query}",
+            url: "https://duckduckgo.com/?q=#{CGI.escape(query)}",
+            snippet: "Click to view search results in browser. Error: #{e.message}"
+          }
+        ]
+      end
+
+      def parse_duckduckgo_html(html, max_results)
+        results = []
+
+        # Simple regex-based parsing (not perfect but works for basic cases)
+        # Look for result blocks in DuckDuckGo HTML
+        html.scan(%r{<div class="result__body">.*?</div>}m).each do |block|
+          break if results.length >= max_results
+
+          # Extract title and URL
+          if block =~ %r{<a.*?href="//duckduckgo\.com/l/\?uddg=([^"&]+).*?".*?>(.*?)</a>}m
+            url = CGI.unescape($1)
+            title = $2.gsub(/<[^>]+>/, "").strip
+
+            # Extract snippet
+            snippet = ""
+            if block =~ %r{<a class="result__snippet".*?>(.*?)</a>}m
+              snippet = $1.gsub(/<[^>]+>/, "").strip
+            end
+
+            results << {
+              title: title,
+              url: url,
+              snippet: snippet
+            }
+          end
+        end
+
+        # If parsing failed, provide a fallback
+        if results.empty?
+          results << {
+            title: "Web search results",
+            url: "https://duckduckgo.com/?q=#{CGI.escape(query)}",
+            snippet: "Could not parse search results. Visit the URL to see results."
+          }
+        end
+
+        results
+      rescue StandardError
+        []
+      end
+
+      def format_call(args)
+        query = args[:query] || args['query'] || ''
+        display_query = query.length > 40 ? "#{query[0..37]}..." : query
+        "web_search(\"#{display_query}\")"
+      end
+
+      def format_result(result)
+        if result[:error]
+          "✗ #{result[:error]}"
+        else
+          count = result[:count] || 0
+          "✓ Found #{count} results"
+        end
+      end
+    end
+  end
+end