clacky 0.5.0

data/lib/clacky/client.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Clacky
+  class Client
+    MAX_RETRIES = 10
+    RETRY_DELAY = 5 # seconds
+
+    def initialize(api_key, base_url:)
+      @api_key = api_key
+      @base_url = base_url
+    end
+
+    def send_message(content, model:, max_tokens:)
+      response = connection.post("chat/completions") do |req|
+        req.body = {
+          model: model,
+          max_tokens: max_tokens,
+          messages: [
+            {
+              role: "user",
+              content: content
+            }
+          ]
+        }.to_json
+      end
+
+      handle_response(response)
+    end
+
+    def send_messages(messages, model:, max_tokens:)
+      response = connection.post("chat/completions") do |req|
+        req.body = {
+          model: model,
+          max_tokens: max_tokens,
+          messages: messages
+        }.to_json
+      end
+
+      handle_response(response)
+    end
+
+    # Send messages with function calling (tools) support
+    def send_messages_with_tools(messages, model:, tools:, max_tokens:, verbose: false)
+      body = {
+        model: model,
+        max_tokens: max_tokens,
+        messages: messages
+      }
+
+      # Add tools if provided
+      body[:tools] = tools if tools&.any?
+
+      # Debug output
+      if verbose || ENV["CLACKY_DEBUG"]
+        puts "\n[DEBUG] Current directory: #{Dir.pwd}"
+        puts "[DEBUG] Request to API:"
+
+        # Create a simplified version of the body for display
+        display_body = body.dup
+        if display_body[:tools]&.any?
+          tool_names = display_body[:tools].map { |t| t.dig(:function, :name) }.compact
+          display_body[:tools] = "use tools: #{tool_names.join(', ')}"
+        end
+
+        puts JSON.pretty_generate(display_body)
+      end
+
+      response = connection.post("chat/completions") do |req|
+        req.body = body.to_json
+      end
+
+      handle_tool_response(response)
+    end
+
+    private
+
+    def connection
+      @connection ||= Faraday.new(url: @base_url) do |conn|
+        conn.headers["Content-Type"] = "application/json"
+        conn.headers["Authorization"] = "Bearer #{@api_key}"
+        conn.options.timeout = 120  # Read timeout in seconds
+        conn.options.open_timeout = 10  # Connection timeout in seconds
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200
+        data = JSON.parse(response.body)
+        data["choices"].first["message"]["content"]
+      when 401
+        raise Error, "Invalid API key"
+      when 429
+        raise Error, "Rate limit exceeded"
+      when 500..599
+        raise Error, "Server error: #{response.status}"
+      else
+        raise Error, "Unexpected error: #{response.status} - #{response.body}"
+      end
+    end
+
+    def handle_tool_response(response)
+      case response.status
+      when 200
+        data = JSON.parse(response.body)
+        message = data["choices"].first["message"]
+        usage = data["usage"]
+
+        # Debug: show raw API response content
+        if ENV["CLACKY_DEBUG"]
+          puts "\n[DEBUG] Raw API response content:"
+          puts "  content: #{message["content"].inspect}"
+          puts "  content length: #{message["content"]&.length || 0}"
+        end
+
+        {
+          content: message["content"],
+          tool_calls: parse_tool_calls(message["tool_calls"]),
+          finish_reason: data["choices"].first["finish_reason"],
+          usage: {
+            prompt_tokens: usage["prompt_tokens"],
+            completion_tokens: usage["completion_tokens"],
+            total_tokens: usage["total_tokens"]
+          }
+        }
+      when 401
+        raise Error, "Invalid API key"
+      when 429
+        raise Error, "Rate limit exceeded"
+      when 500..599
+        error_body = begin
+          JSON.parse(response.body)
+        rescue JSON::ParserError
+          response.body
+        end
+        raise Error, "Server error: #{response.status}\nResponse: #{error_body.inspect}"
+      else
+        raise Error, "Unexpected error: #{response.status} - #{response.body}"
+      end
+    end
+
+    def parse_tool_calls(tool_calls)
+      return nil if tool_calls.nil? || tool_calls.empty?
+
+      tool_calls.map do |call|
+        {
+          id: call["id"],
+          type: call["type"],
+          name: call["function"]["name"],
+          arguments: call["function"]["arguments"]
+        }
+      end
+    end
+  end
+end

data/lib/clacky/config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Clacky
+  class Config
+    CONFIG_DIR = File.join(Dir.home, ".clacky")
+    CONFIG_FILE = File.join(CONFIG_DIR, "config.yml")
+
+    attr_accessor :api_key, :model, :base_url
+
+    def initialize(data = {})
+      @api_key = data["api_key"]
+      @model = data["model"] || "gpt-3.5-turbo"
+      @base_url = data["base_url"] || "https://api.openai.com"
+    end
+
+    def self.load(config_file = CONFIG_FILE)
+      if File.exist?(config_file)
+        data = YAML.load_file(config_file) || {}
+        new(data)
+      else
+        new
+      end
+    end
+
+    def save(config_file = CONFIG_FILE)
+      config_dir = File.dirname(config_file)
+      FileUtils.mkdir_p(config_dir)
+      File.write(config_file, to_yaml)
+      FileUtils.chmod(0o600, config_file)
+    end
+
+    def to_yaml
+      YAML.dump({
+        "api_key" => @api_key,
+        "model" => @model,
+        "base_url" => @base_url
+      })
+    end
+  end
+end

data/lib/clacky/conversation.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Conversation
+    attr_reader :messages
+
+    def initialize(api_key, model:, base_url:, max_tokens:)
+      @client = Client.new(api_key, base_url: base_url)
+      @model = model
+      @max_tokens = max_tokens
+      @messages = []
+    end
+
+    def send_message(content)
+      # Add user message to history
+      @messages << {
+        role: "user",
+        content: content
+      }
+
+      # Get response from Claude
+      response_text = @client.send_messages(@messages, model: @model, max_tokens: @max_tokens)
+
+      # Add assistant response to history
+      @messages << {
+        role: "assistant",
+        content: response_text
+      }
+
+      response_text
+    end
+
+    def clear
+      @messages = []
+    end
+
+    def history
+      @messages.dup
+    end
+  end
+end

data/lib/clacky/hook_manager.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Clacky
+  class HookManager
+    HOOK_EVENTS = [
+      :before_tool_use,
+      :after_tool_use,
+      :on_tool_error,
+      :on_start,
+      :on_complete,
+      :on_iteration
+    ].freeze
+
+    def initialize
+      @hooks = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def add(event, &block)
+      validate_event!(event)
+      @hooks[event] << block
+    end
+
+    def trigger(event, *args)
+      validate_event!(event)
+      result = { action: :allow }
+
+      @hooks[event].each do |hook|
+        begin
+          hook_result = hook.call(*args)
+          result.merge!(hook_result) if hook_result.is_a?(Hash)
+        rescue StandardError => e
+          # Log error but don't fail
+          warn "Hook error in #{event}: #{e.message}"
+        end
+      end
+
+      result
+    end
+
+    def has_hooks?(event)
+      @hooks[event].any?
+    end
+
+    def clear(event = nil)
+      if event
+        validate_event!(event)
+        @hooks[event].clear
+      else
+        @hooks.clear
+      end
+    end
+
+    private
+
+    def validate_event!(event)
+      return if HOOK_EVENTS.include?(event)
+
+      raise ArgumentError, "Invalid hook event: #{event}. Must be one of #{HOOK_EVENTS.join(', ')}"
+    end
+  end
+end

data/lib/clacky/progress_indicator.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Clacky
+  class ProgressIndicator
+    def initialize(verbose: false, message: nil)
+      @verbose = verbose
+      @start_time = nil
+      @custom_message = message
+      @thinking_verb = message || THINKING_VERBS.sample
+      @running = false
+      @update_thread = nil
+    end
+
+    def start
+      @start_time = Time.now
+      @running = true
+      print_status("#{@thinking_verb}… (ctrl+c to interrupt)")
+
+      # Start background thread to update elapsed time
+      @update_thread = Thread.new do
+        while @running
+          sleep 1
+          update if @running
+        end
+      end
+    end
+
+    def update
+      return unless @start_time
+
+      elapsed = (Time.now - @start_time).to_i
+      print_status("#{@thinking_verb}… (ctrl+c to interrupt · #{elapsed}s)")
+    end
+
+    def finish
+      @running = false
+      @update_thread&.join
+      clear_line
+    end
+
+    private
+
+    def print_status(text)
+      print "\r\033[K#{text}" # \r moves to start of line, \033[K clears to end of line
+      $stdout.flush
+    end
+
+    def clear_line
+      print "\r\033[K" # Clear the entire line
+      $stdout.flush
+    end
+  end
+end

data/lib/clacky/session_manager.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Clacky
+  class SessionManager
+    SESSIONS_DIR = File.join(Dir.home, ".clacky", "sessions")
+
+    def initialize
+      ensure_sessions_dir
+    end
+
+    # Save a session
+    def save(session_data)
+      filename = generate_filename(session_data[:session_id], session_data[:created_at])
+      filepath = File.join(SESSIONS_DIR, filename)
+
+      File.write(filepath, JSON.pretty_generate(session_data))
+      FileUtils.chmod(0o600, filepath)
+
+      @last_saved_path = filepath
+      filepath
+    end
+
+    # Get the path of the last saved session
+    def last_saved_path
+      @last_saved_path
+    end
+
+    # Load a specific session by ID
+    def load(session_id)
+      sessions = all_sessions
+      session = sessions.find { |s| s[:session_id].start_with?(session_id) }
+      session
+    end
+
+    # Get the most recent session for a specific working directory
+    def latest_for_directory(working_dir)
+      sessions = all_sessions
+      sessions
+        .select { |s| s[:working_dir] == working_dir }
+        .max_by { |s| Time.parse(s[:updated_at]) }
+    end
+
+    # List recent sessions, prioritizing those from current directory
+    def list(current_dir: nil, limit: 5)
+      sessions = all_sessions.sort_by { |s| Time.parse(s[:updated_at]) }.reverse
+
+      if current_dir
+        current_sessions = sessions.select { |s| s[:working_dir] == current_dir }
+        other_sessions = sessions.reject { |s| s[:working_dir] == current_dir }
+        (current_sessions + other_sessions).first(limit)
+      else
+        sessions.first(limit)
+      end
+    end
+
+    # Delete old sessions (older than days)
+    def cleanup(days: 30)
+      cutoff_time = Time.now - (days * 24 * 60 * 60)
+      deleted_count = 0
+
+      Dir.glob(File.join(SESSIONS_DIR, "*.json")).each do |filepath|
+        session = load_session_file(filepath)
+        next unless session
+
+        updated_at = Time.parse(session[:updated_at])
+        if updated_at < cutoff_time
+          File.delete(filepath)
+          deleted_count += 1
+        end
+      end
+
+      deleted_count
+    end
+
+    # Keep only the most recent N sessions, delete older ones
+    def cleanup_by_count(keep:)
+      sessions = all_sessions.sort_by { |s| Time.parse(s[:updated_at]) }.reverse
+
+      return 0 if sessions.size <= keep
+
+      sessions_to_delete = sessions[keep..]
+      deleted_count = 0
+
+      sessions_to_delete.each do |session|
+        filename = generate_filename(session[:session_id], session[:created_at])
+        filepath = File.join(SESSIONS_DIR, filename)
+
+        if File.exist?(filepath)
+          File.delete(filepath)
+          deleted_count += 1
+        end
+      end
+
+      deleted_count
+    end
+
+    private
+
+    def ensure_sessions_dir
+      FileUtils.mkdir_p(SESSIONS_DIR) unless Dir.exist?(SESSIONS_DIR)
+    end
+
+    def generate_filename(session_id, created_at)
+      date = Time.parse(created_at).strftime("%Y-%m-%d")
+      short_id = session_id[0..7]
+      "#{date}_#{short_id}.json"
+    end
+
+    def all_sessions
+      Dir.glob(File.join(SESSIONS_DIR, "*.json")).map do |filepath|
+        load_session_file(filepath)
+      end.compact
+    end
+
+    def load_session_file(filepath)
+      JSON.parse(File.read(filepath), symbolize_names: true)
+    rescue JSON::ParserError, Errno::ENOENT
+      nil
+    end
+  end
+end

data/lib/clacky/thinking_verbs.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Clacky
+  THINKING_VERBS = [
+    "Cogitating",
+    "Pondering",
+    "Ruminating",
+    "Deliberating",
+    "Contemplating",
+    "Flibbertigibbeting",
+    "Percolating",
+    "Noodling",
+    "Brewing",
+    "Marinating",
+    "Stewing",
+    "Mulling",
+    "Processing",
+    "Computing",
+    "Calculating",
+    "Analyzing",
+    "Synthesizing",
+    "Ideating",
+    "Brainstorming",
+    "Reasoning"
+  ].freeze
+end

data/lib/clacky/tool_registry.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Clacky
+  class ToolRegistry
+    def initialize
+      @tools = {}
+    end
+
+    def register(tool)
+      @tools[tool.name] = tool
+    end
+
+    def get(name)
+      # Handle shell alias to safe_shell for backward compatibility
+      name = 'safe_shell' if name == 'shell' && @tools.key?('safe_shell') && !@tools.key?('shell')
+      
+      @tools[name] || raise(Error, "Tool not found: #{name}")
+    end
+
+    def all
+      @tools.values
+    end
+
+    def all_definitions
+      @tools.values.map(&:to_function_definition)
+    end
+
+    def allowed_definitions(allowed_tools = nil)
+      return all_definitions if allowed_tools.nil? || allowed_tools.include?("all")
+
+      @tools.select { |name, _| allowed_tools.include?(name) }
+             .values
+             .map(&:to_function_definition)
+    end
+
+    def tool_names
+      @tools.keys
+    end
+
+    def by_category(category)
+      @tools.values.select { |tool| tool.category == category }
+    end
+  end
+end

data/lib/clacky/tools/base.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Tools
+    class Base
+      class << self
+        attr_accessor :tool_name, :tool_description, :tool_parameters, :tool_category
+      end
+
+      def name
+        self.class.tool_name
+      end
+
+      def description
+        self.class.tool_description
+      end
+
+      def parameters
+        self.class.tool_parameters
+      end
+
+      def category
+        self.class.tool_category || "general"
+      end
+
+      # Execute the tool - must be implemented by subclasses
+      def execute(**_args)
+        raise NotImplementedError, "#{self.class.name} must implement #execute"
+      end
+
+      # Format tool call for display - can be overridden by subclasses
+      # @param args [Hash] The arguments passed to the tool
+      # @return [String] Formatted call description (e.g., "Read(file.rb)")
+      def format_call(args)
+        "#{name}(...)"
+      end
+
+      # Format tool result for display - can be overridden by subclasses
+      # @param result [Object] The result returned by execute
+      # @return [String] Formatted result summary (e.g., "Read 150 lines")
+      def format_result(result)
+        if result.is_a?(Hash) && result[:message]
+          result[:message]
+        elsif result.is_a?(String)
+          result.length > 100 ? "#{result[0..100]}..." : result
+        else
+          "Done"
+        end
+      end
+
+      # Convert to OpenAI function calling format
+      def to_function_definition
+        {
+          type: "function",
+          function: {
+            name: name,
+            description: description,
+            parameters: parameters
+          }
+        }
+      end
+    end
+  end
+end