pocketrb 0.1.0

data/lib/pocketrb/planning/tool.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Planning
+    # Tool for creating and managing execution plans
+    class Tool < Tools::Base
+      def name
+        "plan"
+      end
+
+      def description
+        "Create and manage execution plans for complex tasks. Plans help organize multi-step work and track progress."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: %w[create update complete fail list show delete],
+              description: "Action to perform"
+            },
+            plan_name: {
+              type: "string",
+              description: "Name of the plan"
+            },
+            plan_description: {
+              type: "string",
+              description: "Description of the plan (for create)"
+            },
+            steps: {
+              type: "array",
+              items: { type: "string" },
+              description: "Steps to add (for create or update)"
+            },
+            step_index: {
+              type: "integer",
+              description: "Step index to update (0-indexed)"
+            },
+            notes: {
+              type: "string",
+              description: "Notes for the step completion/failure"
+            }
+          },
+          required: ["action"]
+        }
+      end
+
+      def execute(
+        action:,
+        plan_name: nil,
+        plan_description: nil,
+        steps: nil,
+        step_index: nil,
+        notes: nil
+      )
+        case action
+        when "create"
+          create_plan(plan_name, plan_description, steps)
+        when "update"
+          update_plan(plan_name, steps, step_index, notes)
+        when "complete"
+          complete_step(plan_name, step_index, notes)
+        when "fail"
+          fail_step(plan_name, step_index, notes)
+        when "list"
+          list_plans
+        when "show"
+          show_plan(plan_name)
+        when "delete"
+          delete_plan(plan_name)
+        else
+          error("Unknown action: #{action}")
+        end
+      end
+
+      private
+
+      def manager
+        @manager ||= Manager.new(workspace: workspace)
+      end
+
+      def create_plan(name, description, steps)
+        return error("Plan name is required") unless name
+        return error("At least one step is required") if steps.nil? || steps.empty?
+
+        plan = manager.create_plan(name: name, description: description, steps: steps)
+        plan.activate!
+        manager.update_plan(name: name) # Save activated state
+
+        success("Created and activated plan '#{name}' with #{steps.length} steps\n\n#{plan.to_markdown}")
+      rescue Error => e
+        error(e.message)
+      end
+
+      def update_plan(name, new_steps, step_index, notes)
+        return error("Plan name is required") unless name
+
+        plan = manager.update_plan(
+          name: name,
+          completed_step: step_index,
+          new_steps: new_steps,
+          notes: notes
+        )
+
+        success("Updated plan '#{name}'\n\n#{plan.to_markdown}")
+      rescue Error => e
+        error(e.message)
+      end
+
+      def complete_step(name, step_index, notes)
+        return error("Plan name is required") unless name
+        return error("Step index is required") if step_index.nil?
+
+        plan = manager.update_plan(name: name, completed_step: step_index, notes: notes)
+
+        if plan.complete?
+          success("Completed step #{step_index + 1}. Plan '#{name}' is now complete!\n\n#{plan.to_markdown}")
+        else
+          next_step = plan.next_step
+          success("Completed step #{step_index + 1}. Next: Step #{next_step.index + 1} - #{next_step.description}\n\n#{plan.to_markdown}")
+        end
+      rescue Error => e
+        error(e.message)
+      end
+
+      def fail_step(name, step_index, notes)
+        return error("Plan name is required") unless name
+        return error("Step index is required") if step_index.nil?
+
+        plan = manager.fail_step(name: name, step_index: step_index, notes: notes)
+        success("Marked step #{step_index + 1} as failed\n\n#{plan.to_markdown}")
+      rescue Error => e
+        error(e.message)
+      end
+
+      def list_plans
+        plans = manager.list_plans
+
+        return "No plans found" if plans.empty?
+
+        output = ["# Plans\n"]
+        plans.each do |plan|
+          status_emoji = case plan.status
+                         when Plan::PlanStatus::ACTIVE then "🔄"
+                         when Plan::PlanStatus::COMPLETED then "✅"
+                         when Plan::PlanStatus::FAILED then "❌"
+                         when Plan::PlanStatus::CANCELLED then "🚫"
+                         else "📝"
+                         end
+
+          output << "#{status_emoji} **#{plan.name}** - #{plan.progress}% (#{plan.status})"
+        end
+
+        output.join("\n")
+      end
+
+      def show_plan(name)
+        return error("Plan name is required") unless name
+
+        plan = manager.get_plan(name)
+        return error("Plan '#{name}' not found") unless plan
+
+        plan.to_markdown
+      end
+
+      def delete_plan(name)
+        return error("Plan name is required") unless name
+
+        manager.delete_plan(name)
+        success("Deleted plan '#{name}'")
+      end
+    end
+  end
+end

data/lib/pocketrb/providers/anthropic.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Pocketrb
+  module Providers
+    # Direct Anthropic Claude API provider
+    # Supports extended thinking and all Claude-specific features
+    class Anthropic < Base
+      API_URL = "https://api.anthropic.com/v1"
+      API_VERSION = "2023-06-01"
+
+      MODELS = {
+        "claude-opus-4-20250514" => { context: 200_000, output: 32_000 },
+        "claude-sonnet-4-20250514" => { context: 200_000, output: 64_000 },
+        "claude-3-5-haiku-20241022" => { context: 200_000, output: 8192 }
+      }.freeze
+
+      def name
+        :anthropic
+      end
+
+      def default_model
+        "claude-sonnet-4-20250514"
+      end
+
+      def available_models
+        MODELS.keys
+      end
+
+      def chat(messages:, tools: nil, model: nil, temperature: 0.7, max_tokens: 4096, thinking: false)
+        model ||= default_model
+        body = build_request_body(messages, tools, model, temperature, max_tokens, thinking)
+
+        response = client.post("/v1/messages") do |req|
+          req.body = body.to_json
+        end
+
+        handle_response(response)
+      end
+
+      def chat_stream(messages:, tools: nil, model: nil, temperature: 0.7, max_tokens: 4096, &block)
+        model ||= default_model
+        body = build_request_body(messages, tools, model, temperature, max_tokens, false)
+        body[:stream] = true
+
+        accumulated_content = ""
+        accumulated_tool_calls = []
+        usage = nil
+
+        client.post("/v1/messages") do |req|
+          req.body = body.to_json
+          req.options.on_data = proc do |chunk, _|
+            process_stream_chunk(chunk, accumulated_content, accumulated_tool_calls, &block)
+          end
+        end
+
+        LLMResponse.new(
+          content: accumulated_content,
+          tool_calls: accumulated_tool_calls,
+          usage: usage,
+          model: model
+        )
+      end
+
+      protected
+
+      def supported_features
+        %i[tools streaming thinking vision]
+      end
+
+      def validate_config!
+        return if oauth_token
+        return if api_key(:anthropic_api_key)
+
+        raise ConfigurationError,
+              "Either ANTHROPIC_OAUTH_TOKEN or ANTHROPIC_API_KEY is required for #{self.class.name}"
+      end
+
+      private
+
+      # Check for OAuth token (Max subscription via `claude setup-token`)
+      def oauth_token
+        @config[:anthropic_oauth_token] || ENV.fetch("ANTHROPIC_OAUTH_TOKEN", nil)
+      end
+
+      def using_oauth?
+        !oauth_token.nil?
+      end
+
+      def client
+        @client ||= Faraday.new(url: API_URL) do |f|
+          f.headers["Content-Type"] = "application/json"
+          f.headers["anthropic-version"] = API_VERSION
+
+          if using_oauth?
+            # OAuth authentication for Max subscription
+            # Token generated via: claude setup-token
+            f.headers["Authorization"] = "Bearer #{oauth_token}"
+            f.headers["anthropic-beta"] = "oauth-2025-04-20"
+          else
+            # Standard API key authentication
+            f.headers["x-api-key"] = api_key(:anthropic_api_key)
+          end
+
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def build_request_body(messages, tools, model, temperature, max_tokens, thinking)
+        system_message = extract_system_message(messages)
+        conversation = format_messages(messages.reject { |m| m.role == Role::SYSTEM })
+
+        body = {
+          model: model,
+          messages: conversation,
+          max_tokens: max_tokens
+        }
+
+        body[:system] = system_message if system_message
+        body[:temperature] = temperature unless thinking
+        body[:tools] = format_tools(tools) if tools&.any?
+
+        body[:thinking] = { type: "enabled", budget_tokens: [max_tokens / 2, 10_000].min } if thinking
+
+        body
+      end
+
+      def extract_system_message(messages)
+        system_msg = messages.find { |m| m.role == Role::SYSTEM }
+        system_msg&.content
+      end
+
+      def format_message(message)
+        case message.role
+        when Role::USER
+          { role: "user", content: format_user_content(message.content) }
+        when Role::ASSISTANT
+          { role: "assistant", content: format_assistant_content(message) }
+
+        when Role::TOOL
+          {
+            role: "user",
+            content: [{
+              type: "tool_result",
+              tool_use_id: message.tool_call_id,
+              content: message.content.to_s
+            }]
+          }
+        else
+          raise ArgumentError, "Unknown role: #{message.role}"
+        end
+      end
+
+      def format_user_content(content)
+        return content if content.is_a?(String)
+
+        # Handle content blocks array (text + media)
+        if content.is_a?(Array)
+          content.map do |block|
+            if block.is_a?(Hash) && block[:type] == "media"
+              format_media_block(block[:media])
+            elsif block.is_a?(Hash) && block[:type] == "text"
+              { type: "text", text: block[:text] }
+            elsif block.is_a?(String)
+              { type: "text", text: block }
+            else
+              block
+            end
+          end
+        else
+          content.to_s
+        end
+      end
+
+      def format_media_block(media)
+        return { type: "text", text: "[unsupported media]" } unless media
+
+        # Only images are supported for vision
+        unless media.image? && Media::Processor::VISION_IMAGE_TYPES.include?(media.mime_type)
+          return { type: "text", text: "[Attached: #{media.filename} (#{media.mime_type})]" }
+        end
+
+        # Get base64 data
+        data = if media.data
+                 media.data
+               elsif media.path && File.exist?(media.path)
+                 require "base64"
+                 Base64.strict_encode64(File.binread(media.path))
+               else
+                 return { type: "text", text: "[Image not available]" }
+               end
+
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: media.mime_type,
+            data: data
+          }
+        }
+      end
+
+      def format_content(content)
+        return content if content.is_a?(String)
+        return content if content.is_a?(Array)
+
+        content.to_s
+      end
+
+      def format_assistant_content(message)
+        blocks = []
+
+        blocks << { type: "text", text: message.content } if message.content && !message.content.empty?
+
+        message.tool_calls&.each do |tc|
+          blocks << {
+            type: "tool_use",
+            id: tc.id,
+            name: tc.name,
+            input: tc.arguments
+          }
+        end
+
+        blocks.empty? ? "" : blocks
+      end
+
+      def format_tools(tools)
+        return nil if tools.nil? || tools.empty?
+
+        tools.map do |tool|
+          if tool[:function]
+            # OpenAI-style format
+            {
+              name: tool[:function][:name],
+              description: tool[:function][:description],
+              input_schema: tool[:function][:parameters] || { type: "object", properties: {} }
+            }
+          else
+            # Already in Anthropic format
+            tool
+          end
+        end
+      end
+
+      def handle_response(response)
+        unless response.success?
+          error_body = begin
+            JSON.parse(response.body)
+          rescue StandardError
+            { "error" => response.body }
+          end
+          raise ProviderError, "Anthropic API error: #{error_body["error"]}"
+        end
+
+        data = JSON.parse(response.body)
+        parse_response(data)
+      end
+
+      def parse_response(data)
+        content = ""
+        thinking = nil
+        tool_calls = []
+
+        data["content"]&.each do |block|
+          case block["type"]
+          when "text"
+            content += block["text"]
+          when "thinking"
+            thinking = block["thinking"]
+          when "tool_use"
+            tool_calls << ToolCall.new(
+              id: block["id"],
+              name: block["name"],
+              arguments: block["input"]
+            )
+          end
+        end
+
+        usage_data = data["usage"] || {}
+        usage = Usage.new(
+          input_tokens: usage_data["input_tokens"] || 0,
+          output_tokens: usage_data["output_tokens"] || 0,
+          cache_read: usage_data["cache_read_input_tokens"],
+          cache_write: usage_data["cache_creation_input_tokens"]
+        )
+
+        stop_reason = case data["stop_reason"]
+                      when "end_turn" then :end_turn
+                      when "tool_use" then :tool_use
+                      when "max_tokens" then :max_tokens
+                      when "stop_sequence" then :stop_sequence
+                      else :end_turn
+                      end
+
+        LLMResponse.new(
+          content: content.empty? ? nil : content,
+          tool_calls: tool_calls,
+          usage: usage,
+          stop_reason: stop_reason,
+          model: data["model"],
+          thinking: thinking
+        )
+      end
+
+      def process_stream_chunk(chunk, accumulated_content, _accumulated_tool_calls, &block)
+        chunk.split("\n").each do |line|
+          next unless line.start_with?("data: ")
+
+          data = begin
+            JSON.parse(line[6..])
+          rescue StandardError
+            next
+          end
+
+          case data["type"]
+          when "content_block_delta"
+            if data.dig("delta", "type") == "text_delta"
+              text = data.dig("delta", "text")
+              accumulated_content << text if text
+              block&.call(text)
+            end
+          when "content_block_start"
+            if data.dig("content_block", "type") == "tool_use"
+              # Tool use block starting
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pocketrb/providers/base.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Providers
+    # Base class for LLM providers
+    class Base
+      attr_reader :config
+
+      def initialize(config = {})
+        @config = config
+        validate_config!
+      end
+
+      # Send a chat completion request
+      # @param messages [Array<Message>] Conversation history
+      # @param tools [Array<Hash>|nil] Tool definitions
+      # @param model [String|nil] Model to use (defaults to provider default)
+      # @param temperature [Float] Sampling temperature
+      # @param max_tokens [Integer] Maximum tokens to generate
+      # @param thinking [Boolean] Enable extended thinking (Claude only)
+      # @return [LLMResponse]
+      def chat(messages:, tools: nil, model: nil, temperature: 0.7, max_tokens: 4096, thinking: false)
+        raise NotImplementedError, "#{self.class}#chat must be implemented"
+      end
+
+      # Stream a chat completion request
+      # @yield [String|ToolCall] Chunks of content or tool calls
+      # @return [LLMResponse]
+      def chat_stream(messages:, tools: nil, model: nil, temperature: 0.7, max_tokens: 4096, &block)
+        raise NotImplementedError, "#{self.class}#chat_stream must be implemented"
+      end
+
+      # Get the default model for this provider
+      # @return [String]
+      def default_model
+        raise NotImplementedError, "#{self.class}#default_model must be implemented"
+      end
+
+      # List available models
+      # @return [Array<String>]
+      def available_models
+        raise NotImplementedError, "#{self.class}#available_models must be implemented"
+      end
+
+      # Provider name
+      # @return [Symbol]
+      def name
+        raise NotImplementedError, "#{self.class}#name must be implemented"
+      end
+
+      # Check if provider supports a feature
+      # @param feature [Symbol] :tools, :streaming, :thinking, :vision
+      # @return [Boolean]
+      def supports?(feature)
+        supported_features.include?(feature)
+      end
+
+      protected
+
+      def supported_features
+        %i[tools streaming]
+      end
+
+      def validate_config!
+        # Override in subclasses to validate required config
+      end
+
+      def require_api_key!(key_name)
+        return if @config[key_name] || ENV[key_name.to_s.upcase]
+
+        raise ConfigurationError, "#{key_name} is required for #{self.class.name}"
+      end
+
+      def api_key(key_name)
+        @config[key_name] || ENV.fetch(key_name.to_s.upcase, nil)
+      end
+
+      # Convert internal message format to provider-specific format
+      def format_messages(messages)
+        messages.map { |msg| format_message(msg) }
+      end
+
+      def format_message(message)
+        raise NotImplementedError
+      end
+
+      # Convert provider response to internal format
+      def parse_response(response)
+        raise NotImplementedError
+      end
+
+      # Convert tool definitions to provider-specific format
+      def format_tools(tools)
+        tools
+      end
+    end
+  end
+end