claude_code_sdk 0.1.0

data/examples/debug_process.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "open3"
+require "json"
+require "timeout"
+
+puts "=== Debug Process Example ==="
+
+cli_path = `which claude`.chomp
+puts "CLI path: #{cli_path}"
+
+args = ["--print", "--output-format", "stream-json", "--verbose", "What is 2 + 2?"]
+puts "Command: #{cli_path} #{args.join(" ")}"
+
+ENV["ANTHROPIC_API_KEY"] =
+  "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"
+
+stdin, stdout, stderr, wait_thread = Open3.popen3(cli_path, *args)
+
+puts "\nProcess started, PID: #{wait_thread.pid}"
+
+# Read stdout in a thread
+stdout_thread = Thread.new do
+  puts "\nSTDOUT:"
+  stdout.each_line do |line|
+    puts "  > #{line}"
+  end
+end
+
+# Read stderr in a thread
+stderr_thread = Thread.new do
+  puts "\nSTDERR:"
+  stderr.each_line do |line|
+    puts "  ! #{line}"
+  end
+end
+
+# Wait for threads with timeout
+begin
+  Timeout.timeout(5) do
+    stdout_thread.join
+    stderr_thread.join
+  end
+rescue Timeout::Error
+  puts "\n[Timeout after 5 seconds]"
+end
+
+# Check process status
+if wait_thread.alive?
+  puts "\nProcess still alive, killing..."
+  Process.kill("TERM", wait_thread.pid)
+  wait_thread.join(1)
+end
+
+puts "\nExit status: #{wait_thread.value.exitstatus}"
+
+stdin.close
+stdout.close
+stderr.close

data/examples/debug_query.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add the lib directory to the load path for local development
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "claude_code_sdk"
+
+# Enable debug output
+puts "=== Debug Query Example ==="
+
+# Create a simple transport to see what's happening
+transport = ClaudeCodeSDK::Transport::SubprocessCLI.new(
+  prompt: "What is 2 + 2?",
+  options: ClaudeCodeSDK::Options.new
+)
+
+begin
+  puts "Connecting to CLI..."
+  transport.connect
+  puts "Connected!"
+
+  puts "\nReceiving messages..."
+  transport.receive_messages do |raw_message|
+    puts "Raw message: #{raw_message.inspect}"
+  end
+rescue StandardError => e
+  puts "Error: #{e.class} - #{e.message}"
+  puts e.backtrace.first(5).join("\n")
+ensure
+  puts "\nDisconnecting..."
+  transport.disconnect
+end
+
+puts "Done!"

data/examples/simple_query.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add the lib directory to the load path for local development
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "claude_code_sdk"
+
+# Simple query with block
+puts "=== Simple Query Example ==="
+ClaudeCodeSDK.query("What is 2 + 2?") do |message|
+  case message
+  when ClaudeCodeSDK::AssistantMessage
+    message.content.each do |block|
+      puts block.text if block.is_a?(ClaudeCodeSDK::Content::TextBlock)
+    end
+  when ClaudeCodeSDK::SystemMessage
+    puts "[System] #{message.title}: #{message.message}"
+  end
+end
+
+puts "\n=== Using ask method ==="
+response = ClaudeCodeSDK.ask("What is the capital of France?")
+puts response

data/examples/simple_test.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Test using backticks
+require "English"
+ENV["ANTHROPIC_API_KEY"] =
+  "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"
+
+command = 'claude --print --output-format json "What is 2 + 2?"'
+puts "Running: #{command}"
+
+output = `#{command}`
+puts "Exit status: #{$CHILD_STATUS.exitstatus}"
+puts "Output: #{output}"
+
+require "json"
+data = JSON.parse(output)
+puts "Result: #{data["result"]}"

data/examples/simple_tools.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add the lib directory to the load path for local development
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "claude_code_sdk"
+
+puts "=== Simple Tools Example ==="
+
+# Test without cwd to see if that's the issue
+options = ClaudeCodeSDK::Options.new(
+  allowed_tools: %w[read_file write_file list_files]
+)
+
+ClaudeCodeSDK.query("List the Ruby files in the current directory", options) do |message|
+  case message
+  when ClaudeCodeSDK::AssistantMessage
+    message.content.each do |block|
+      case block
+      when ClaudeCodeSDK::Content::TextBlock
+        puts block.text
+      when ClaudeCodeSDK::Content::ToolUseBlock
+        puts "[Tool Use] #{block.name}: #{block.input.inspect}"
+      end
+    end
+  when ClaudeCodeSDK::SystemMessage
+    puts "[System] #{message.title}"
+  when ClaudeCodeSDK::ResultMessage
+    puts "[Result] Status: #{message.status}"
+  end
+end

data/examples/simple_tools_fixed.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add the lib directory to the load path for local development
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "claude_code_sdk"
+
+puts "=== Simple Tools Example (Fixed) ==="
+
+# Create options without cwd to avoid CLI parsing issues
+options = ClaudeCodeSDK::Options.new(
+  allowed_tools: %w[read_file write_file list_files]
+  # NOTE: Removing cwd for now as it causes CLI parsing issues
+)
+
+ClaudeCodeSDK.query("Help me understand what Ruby files are in this project", options) do |message|
+  case message
+  when ClaudeCodeSDK::AssistantMessage
+    message.content.each do |block|
+      case block
+      when ClaudeCodeSDK::Content::TextBlock
+        puts block.text
+      when ClaudeCodeSDK::Content::ToolUseBlock
+        puts "[Tool Use] #{block.name}: #{block.input.inspect}"
+      end
+    end
+  when ClaudeCodeSDK::SystemMessage
+    puts "[System] #{message.title}"
+  when ClaudeCodeSDK::ResultMessage
+    puts "[Result] Status: #{message.status}"
+    puts "  Cost: $#{message.cost[:usd]}" if message.cost && message.cost[:usd]
+  end
+end

data/examples/streaming_responses.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add the lib directory to the load path for local development
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "claude_code_sdk"
+
+# Example showing real-time streaming of responses
+puts "=== Streaming Response Example ==="
+
+# Configure global defaults
+ClaudeCodeSDK.configure do |config|
+  config.default_system_prompt = "You are a Ruby programming expert"
+  config.default_cwd = Dir.pwd
+end
+
+# Track message types
+message_counts = Hash.new(0)
+
+ClaudeCodeSDK.query("Write a Ruby function to calculate fibonacci numbers") do |message|
+  message_counts[message.class.name] += 1
+
+  case message
+  when ClaudeCodeSDK::UserMessage
+    puts "\n[You] #{message.text}"
+  when ClaudeCodeSDK::AssistantMessage
+    print "\n[Claude] "
+    message.content.each do |block|
+      print block.text if block.is_a?(ClaudeCodeSDK::Content::TextBlock)
+    end
+  when ClaudeCodeSDK::SystemMessage
+    puts "\n[System] #{message.title}: #{message.message}"
+  when ClaudeCodeSDK::ResultMessage
+    puts "\n\n[Conversation Complete]"
+    puts "Status: #{message.status}"
+    puts "Messages received:"
+    message_counts.each { |type, count| puts "  #{type}: #{count}" }
+  end
+end

data/examples/test_sdk.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add the lib directory to the load path for local development
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "claude_code_sdk"
+
+puts "=== Testing Ruby SDK ==="
+puts "SDK Version: #{ClaudeCodeSDK::VERSION}"
+puts "Environment: #{ENV.fetch("CLAUDE_CODE_SDK", nil)}"
+
+# Test Options creation
+options = ClaudeCodeSDK::Options.new(
+  system_prompt: "Test prompt",
+  allowed_tools: %w[read_file write_file],
+  max_thinking_tokens: 5000,
+  cwd: "/tmp"
+)
+
+puts "\nOptions created successfully:"
+puts "  System prompt: #{options.system_prompt}"
+puts "  Allowed tools: #{options.allowed_tools.join(", ")}"
+puts "  Max thinking tokens: #{options.max_thinking_tokens}"
+puts "  CWD: #{options.cwd}"
+
+puts "\nCLI args: #{options.to_cli_args.join(" ")}"
+
+# Test message creation
+user_msg = ClaudeCodeSDK::UserMessage.new(id: "1", text: "Hello")
+puts "\nUser message created: #{user_msg.text}"
+
+assistant_msg = ClaudeCodeSDK::AssistantMessage.new(
+  id: "2",
+  content: [
+    ClaudeCodeSDK::Content::TextBlock.new(text: "Hi there!"),
+    ClaudeCodeSDK::Content::ToolUseBlock.new(id: "tool1", name: "read_file", input: { path: "test.txt" })
+  ]
+)
+puts "Assistant message created with #{assistant_msg.content.length} content blocks"
+
+# Test error creation
+error = ClaudeCodeSDK::CLINotFoundError.new("Test error", cli_path: "/usr/bin/claude")
+puts "\nError created: #{error.message}"
+
+puts "\n✅ Ruby SDK is working correctly!"

data/examples/with_tools.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Add the lib directory to the load path for local development
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "claude_code_sdk"
+
+# Query with tool permissions
+puts "=== Query with Tools Example ==="
+
+options = ClaudeCodeSDK::Options.new(
+  system_prompt: "You are a helpful coding assistant",
+  allowed_tools: %w[read_file write_file list_files],
+  max_thinking_tokens: 10_000,
+  cwd: Dir.pwd
+)
+
+ClaudeCodeSDK.query("List the files in the current directory", options) do |message|
+  case message
+  when ClaudeCodeSDK::AssistantMessage
+    message.content.each do |block|
+      case block
+      when ClaudeCodeSDK::Content::TextBlock
+        puts block.text
+      when ClaudeCodeSDK::Content::ToolUseBlock
+        puts "[Tool Use] #{block.name}: #{block.input}"
+      end
+    end
+  when ClaudeCodeSDK::SystemMessage
+    puts "[System] #{message.title}"
+  when ClaudeCodeSDK::ResultMessage
+    puts "[Result] Status: #{message.status}"
+    puts "  Cost: $#{message.cost[:usd]}" if message.cost
+  end
+end

data/lib/claude_code_sdk/configuration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module ClaudeCodeSDK
+  class Configuration
+    include Singleton
+
+    attr_accessor :default_system_prompt, :default_cwd,
+                  :default_permission_mode, :cli_path
+
+    def initialize
+      @default_system_prompt = nil
+      @default_cwd = nil
+      @default_permission_mode = PermissionMode::DEFAULT
+      @cli_path = nil
+    end
+
+    def to_options
+      Options.new(
+        system_prompt: default_system_prompt,
+        cwd: default_cwd,
+        permission_mode: default_permission_mode
+      )
+    end
+  end
+end

data/lib/claude_code_sdk/errors.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ClaudeCodeSDK
+  # Base error class for all SDK errors
+  class Error < StandardError; end
+
+  # Raised when unable to connect to Claude Code CLI
+  class CLIConnectionError < Error; end
+
+  # Raised when Claude Code CLI is not found
+  class CLINotFoundError < CLIConnectionError
+    attr_reader :cli_path
+
+    def initialize(message = "Claude Code not found", cli_path: nil)
+      @cli_path = cli_path
+      super(cli_path ? "#{message}: #{cli_path}" : message)
+    end
+  end
+
+  # Raised when the CLI process fails
+  class ProcessError < Error
+    attr_reader :exit_code, :stderr
+
+    def initialize(message, exit_code: nil, stderr: nil)
+      @exit_code = exit_code
+      @stderr = stderr
+
+      full_message = message
+      full_message += " (exit code: #{exit_code})" if exit_code
+      full_message += "\nError output: #{stderr}" if stderr && !stderr.empty?
+
+      super(full_message)
+    end
+  end
+
+  # Raised when JSON parsing fails
+  class CLIJSONDecodeError < Error
+    attr_reader :line
+
+    def initialize(message, line: nil)
+      @line = line
+      super(line ? "#{message}\nLine: #{line}" : message)
+    end
+  end
+end

data/lib/claude_code_sdk/internal/client.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module ClaudeCodeSDK
+  module Internal
+    class Client
+      def initialize
+        @transport = nil
+      end
+
+      def query(prompt:, options: nil, &block)
+        # Use SubprocessCLI for streaming JSON support
+        require_relative "../transport/subprocess_cli"
+        @transport = Transport::SubprocessCLI.new(prompt: prompt, options: options)
+
+        begin
+          @transport.connect
+
+          @transport.receive_messages do |raw_message|
+            message = parse_message(raw_message)
+            block.call(message) if message
+          end
+        ensure
+          @transport&.disconnect
+        end
+      end
+
+      private
+
+      def parse_message(raw)
+        case raw[:type]
+        when "user"
+          UserMessage.new(
+            id: raw[:id] || "user-#{Time.now.to_f}",
+            text: raw[:text] || raw[:prompt]
+          )
+        when "assistant"
+          # Handle the actual CLI format
+          if raw[:message]
+            msg = raw[:message]
+            # Extract thinking from content blocks
+            thinking_content = extract_thinking_from_content(msg[:content] || [])
+            # Parse remaining content blocks
+            content_blocks = parse_content_blocks(msg[:content] || [])
+            
+            AssistantMessage.new(
+              id: msg[:id],
+              content: content_blocks,
+              thinking: thinking_content
+            )
+          else
+            # Extract thinking from content blocks
+            thinking_content = extract_thinking_from_content(raw[:content] || [])
+            # Parse remaining content blocks
+            content_blocks = parse_content_blocks(raw[:content] || [])
+            
+            AssistantMessage.new(
+              id: raw[:id] || "assistant-#{Time.now.to_f}",
+              content: content_blocks,
+              thinking: thinking_content
+            )
+          end
+        when "system"
+          # System messages from CLI have different structure
+          SystemMessage.new(
+            id: raw[:id] || "system-#{Time.now.to_f}",
+            title: raw[:subtype] || "system",
+            message: raw.to_json
+          )
+        when "result"
+          ResultMessage.new(
+            id: raw[:id] || "result-#{Time.now.to_f}",
+            status: raw[:subtype] || raw[:status],
+            cost: raw[:total_cost_usd] ? { usd: raw[:total_cost_usd] } : raw[:cost],
+            usage: raw[:usage]
+          )
+        when "thinking"
+          # Handle thinking messages from the CLI
+          content = raw[:content] || raw[:text] || raw[:message] || ""
+          ::ClaudeCodeSDK::ThinkingMessage.new(
+            id: raw[:id] || "thinking-#{Time.now.to_f}",
+            content: content
+          )
+        else
+          # Unknown message type, skip
+          nil
+        end
+      end
+
+      def extract_thinking_from_content(content)
+        thinking_blocks = content.select { |block| block[:type] == "thinking" }
+        return nil if thinking_blocks.empty?
+        
+        # Combine all thinking blocks
+        thinking_blocks.map { |block| block[:thinking] }.join("\n")
+      end
+      
+      def parse_content_blocks(content)
+        content.map do |block|
+          case block[:type]
+          when "text"
+            Content::TextBlock.new(text: block[:text])
+          when "tool_use"
+            Content::ToolUseBlock.new(
+              id: block[:id],
+              name: block[:name],
+              input: block[:input]
+            )
+          when "tool_result"
+            Content::ToolResultBlock.new(
+              tool_use_id: block[:tool_use_id],
+              output: block[:output],
+              is_error: block[:is_error] || false
+            )
+          when "thinking"
+            # Skip thinking blocks as they're handled separately
+            nil
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/claude_code_sdk/messages.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ClaudeCodeSDK
+  # Base message class
+  class Message
+    attr_reader :id, :type
+
+    def initialize(id:, type:)
+      @id = id
+      @type = type
+    end
+  end
+
+  # User input message
+  class UserMessage < Message
+    attr_reader :text
+
+    def initialize(id:, text:)
+      super(id: id, type: "user")
+      @text = text
+    end
+  end
+
+  # Assistant response message
+  class AssistantMessage < Message
+    attr_reader :content, :thinking
+
+    def initialize(id:, content:, thinking: nil)
+      super(id: id, type: "assistant")
+      @content = content # Array of content blocks
+      @thinking = thinking # Optional thinking content
+    end
+  end
+
+  # System message
+  class SystemMessage < Message
+    attr_reader :title, :message
+
+    def initialize(id:, title:, message:)
+      super(id: id, type: "system")
+      @title = title
+      @message = message
+    end
+  end
+
+  # Final result message
+  class ResultMessage < Message
+    attr_reader :status, :cost, :usage
+
+    def initialize(id:, status:, cost: nil, usage: nil)
+      super(id: id, type: "result")
+      @status = status
+      @cost = cost
+      @usage = usage
+    end
+  end
+
+  # Thinking message (Claude's internal reasoning)
+  class ThinkingMessage < Message
+    attr_reader :content
+
+    def initialize(id:, content:)
+      super(id: id, type: "thinking")
+      @content = content
+    end
+  end
+
+  # Content blocks
+  module Content
+    class TextBlock
+      attr_reader :type, :text
+
+      def initialize(text:)
+        @type = "text"
+        @text = text
+      end
+    end
+
+    class ToolUseBlock
+      attr_reader :type, :id, :name, :input
+
+      def initialize(id:, name:, input:)
+        @type = "tool_use"
+        @id = id
+        @name = name
+        @input = input
+      end
+    end
+
+    class ToolResultBlock
+      attr_reader :type, :tool_use_id, :output, :is_error
+
+      def initialize(tool_use_id:, output:, is_error: false)
+        @type = "tool_result"
+        @tool_use_id = tool_use_id
+        @output = output
+        @is_error = is_error
+      end
+    end
+  end
+end

data/lib/claude_code_sdk/transport/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ClaudeCodeSDK
+  module Transport
+    # Abstract base class for transports
+    class Base
+      def connect
+        raise NotImplementedError
+      end
+
+      def disconnect
+        raise NotImplementedError
+      end
+
+      def connected?
+        raise NotImplementedError
+      end
+
+      def receive_messages(&block)
+        raise NotImplementedError
+      end
+    end
+  end
+end