ruby_claude 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ce8e2c7378bd0ed7559c37995d1886fb37367b8e53e29f77a2bc65ffc10344d
-  data.tar.gz: a1e7bf9563ed416687cb0b8bac091850b3123b623ecf91fd25bbe31c240be9cc
+  metadata.gz: 0a4d20f9115801eff338db4cab7ac026b9cdfeb013ede2da9bb2e32dbd8d0c13
+  data.tar.gz: 7dd1564b9e3421f00520946263e926e5f007ed4da7cc8d666e9e8ef23c12ede4
 SHA512:
-  metadata.gz: d158e722113e3b3ee48313f3fbb2cf0a9df9d7980b263045a1a89f5ff1c7786e396d4bc8d1195aef7edf256c720b18e5d0c1936253673b0a605c6e790f42b62d
-  data.tar.gz: ebac20bcc17499f0b5007c62dba352699d52bb779285b160401daa7a1a08399f67f0df0efcf37bfecbbd0146b99361024f9707b84da17a94b445deb24e409470
+  metadata.gz: 2b49597cdd634ab90688ad07de32fa50cde70326118499f1d464c46936040984a61e4b79865fba1db602f3070031102668847870a8a48139ad1c3803c2df086e
+  data.tar.gz: 5fd8032c248da309d1f7d0215793dccae106c328c71856d153e855edb82f9d54abfe310494cf9f9a1671f8cb44f2213e11e3d1ef4761524b4d242540d126fef4

data/README.md

@@ -1,172 +1,3 @@
-# Ruby Claude
+# ruby_claude
 
-A tiny, zero-dependency Ruby SDK for Claude that shells out to the **Claude Code
-CLI** (`claude -p`) and authenticates with your **Claude Pro/Max subscription**
-instead of an API key.
-
-> **Unofficial** community gem — not affiliated with Anthropic. It uses the
-> supported `claude -p` headless mode within your subscription's rate limits; no
-> OAuth-token handling and no direct API calls.
-
-## Subscription, not API key
-
-`claude -p` uses whatever the CLI is logged in with — if that's a subscription,
-calls draw on it with no API billing. Ruby Claude **strips `ANTHROPIC_API_KEY`
-from the child environment by default** so the CLI can't silently fall back to
-API billing; set `use_subscription = false` to opt back in.
-
-## Prerequisites
-
-`claude` must be installed and logged in (this gem drives it, it doesn't replace it):
-
-```bash
-npm install -g @anthropic-ai/claude-code
-claude        # run /login once and choose the subscription option
-```
-
-## Install
-
-```ruby
-gem "ruby_claude"   # in your Gemfile
-```
-
-…or `gem install ruby_claude`. Requires Ruby 3.2+; zero runtime dependencies.
-
-## Quickstart
-
-```ruby
-require "ruby_claude"
-
-puts RubyClaude.query("Summarize lib/foo.rb in two sentences")
-```
-
-## Usage
-
-```ruby
-# A configured client
-client = RubyClaude::Client.new(model: "claude-sonnet-4-6",
-                                allowed_tools: ["Read", "Grep"], timeout: 180)
-
-res = client.query("What does this project do?")
-res.text         # final text (Response#to_s returns it too, so `puts res` works)
-res.session_id   # String
-res.cost_usd     # Float (often 0.0 on a subscription)
-res.usage        # Hash   — also: res.num_turns, res.duration_ms, res.error?, res.raw
-
-# Streaming — yields typed events, returns the final Response
-client.stream("Write a haiku about Ruby") do |event|
-  print event.text if event.type == :assistant
-end
-
-# Multi-turn session — resumes the underlying session_id automatically
-chat = client.session
-chat.query("My favorite number is 7.")
-puts chat.query("What's my favorite number?")   # => "...7..."
-
-# Global defaults for RubyClaude.query and new clients
-RubyClaude.configure { |c| c.model = "claude-sonnet-4-6"; c.timeout = 300 }
-```
-
-A streaming `Event#type` is `:system`, `:assistant`, `:user`, or `:result`. Use
-`#query` (alias `#ask`) — there is intentionally no `#send`.
-
-## Configuration
-
-`Client.new(**opts)` overrides per instance; `RubyClaude.configure` sets globals.
-
-| Option | Default | Maps to |
-|--------|---------|---------|
-| `binary` | `"claude"` | executable name/path |
-| `model` | `nil` | `--model` |
-| `cwd` | `Dir.pwd` | subprocess working directory |
-| `timeout` | `300` | seconds before the child is killed |
-| `use_subscription` | `true` | strip `ANTHROPIC_API_KEY` from the child env |
-| `append_system_prompt` | `nil` | `--append-system-prompt` |
-| `allowed_tools` / `disallowed_tools` | `nil` | `--allowedTools` / `--disallowedTools` |
-| `add_dirs` | `[]` | `--add-dir` |
-| `permission_mode` | `nil` | `--permission-mode` |
-| `max_turns` | `nil` | `--max-turns` |
-
-## Errors
-
-All subclass `RubyClaude::Error`: `BinaryNotFoundError` (no `claude` on PATH),
-`AuthenticationError` (not logged in), `TimeoutError`, `ExecutionError` (non-zero
-exit or an `is_error` result; carries `#status`/`#stderr`), and `ParseError`.
-
-## How it works
-
-`Command` builds the argv + child env (pure, no I/O); `Runner` spawns `claude`
-via `Open3` (array form — no shell; prompt on stdin), enforces the timeout, and
-parses output; `Client` builds `Response`/`Event`; `Session` resumes via
-`--resume`. The runner is stateless per call, so a `Client` is safe to share
-across threads.
-
-## Development
-
-```bash
-bundle exec rake        # tests + lint (hermetic — never spawns the real claude)
-bin/console             # IRB with the gem loaded
-```
-
-Contributing or tracking upstream SDK changes? See
-[`doc/DEVELOPMENT.md`](doc/DEVELOPMENT.md).
-
-## Building and publishing the gem
-
-The version lives in [`lib/ruby_claude/version.rb`](lib/ruby_claude/version.rb).
-Before a release, bump it following [SemVer](https://semver.org).
-
-### Build locally
-
-```bash
-gem build ruby_claude.gemspec             # => ruby_claude-<version>.gem
-gem install ./ruby_claude-<version>.gem   # try the built gem locally
-```
-
-`spec.files` is derived from `git ls-files`, so only **tracked** files are
-packaged — commit (or at least stage) your changes before building, or the gem
-will be missing files. Bundler's gem tasks do the same and drop the artifact in
-`pkg/`:
-
-```bash
-rake build      # build into pkg/
-rake install    # build and install locally
-```
-
-### Publish to RubyGems
-
-1. Create a [RubyGems.org](https://rubygems.org) account and sign in once
-   (credentials are stored in `~/.gem/credentials`):
-
-   ```bash
-   gem signin
-   ```
-
-2. Make sure the tree is green and committed:
-
-   ```bash
-   rake            # tests + lint
-   git status      # nothing uncommitted
-   ```
-
-3. Build and push:
-
-   ```bash
-   gem build ruby_claude.gemspec
-   gem push ruby_claude-<version>.gem
-   ```
-
-Alternatively, do it all in one step with Bundler's release task, which builds
-the gem, creates and pushes a `v<version>` git tag, and pushes to RubyGems
-(requires a clean, committed tree):
-
-```bash
-rake release
-```
-
-> The gemspec sets `rubygems_mfa_required`, so enable MFA on your RubyGems
-> account; pushes and yanks will then prompt for a one-time code.
-
-## License
-
-BSD-3-Clause. See [LICENSE](LICENSE).
+This gem is no longer maintained. Version 1.0.0 intentionally contains no functionality.

data/lib/ruby_claude.rb

@@ -1,70 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "ruby_claude/version"
-require_relative "ruby_claude/errors"
-require_relative "ruby_claude/configuration"
-require_relative "ruby_claude/response"
-require_relative "ruby_claude/event"
-require_relative "ruby_claude/command"
-require_relative "ruby_claude/runner"
-require_relative "ruby_claude/session"
-require_relative "ruby_claude/client"
-
-# Ruby Claude — a subscription-authenticated Ruby SDK that talks to Claude by
-# shelling out to the Claude Code CLI (+claude -p+) in headless mode.
-#
-# It is an unofficial, community wrapper around a supported headless feature.
-# By default it strips +ANTHROPIC_API_KEY+ from the child environment so calls
-# draw on the logged-in Pro/Max subscription rather than API billing.
-#
-# @example One-shot
-#   puts RubyClaude.query("Summarize lib/foo.rb in two sentences")
-#
-# @example A configured client
-#   client = RubyClaude::Client.new(model: "claude-sonnet-4-6", timeout: 180)
-#   client.query("What does this project do?").text
+# This release intentionally contains no functionality.
 module RubyClaude
-  class << self
-    # The global configuration used by {RubyClaude.query} and as the default
-    # for new {Client} instances.
-    #
-    # @return [Configuration]
-    def configuration
-      @configuration ||= Configuration.new
-    end
-
-    # Configure the global defaults.
-    #
-    # @yieldparam config [Configuration]
-    # @return [Configuration]
-    def configure
-      yield configuration if block_given?
-      @default_client = nil # rebuild with the new configuration on next use
-      configuration
-    end
-
-    # Reset all global state. Mainly useful in tests.
-    #
-    # @return [void]
-    def reset_configuration!
-      @configuration = Configuration.new
-      @default_client = nil
-    end
-
-    # One-shot convenience that delegates to a memoized default {Client}.
-    #
-    # @param prompt [String]
-    # @param options [Hash] forwarded to {Client#query} (e.g. +resume:+)
-    # @return [Response]
-    def query(prompt, **options)
-      default_client.query(prompt, **options)
-    end
-
-    # The memoized default {Client}, rebuilt whenever {configure} is called.
-    #
-    # @return [Client]
-    def default_client
-      @default_client ||= Client.new
-    end
-  end
+  VERSION = "1.0.0"
 end

metadata

@@ -1,78 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ruby_claude
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Kaíque Kandy Koga
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.60'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.60'
-- !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.6'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-description: |
-  Ruby Claude is a small, dependency-light, idiomatic Ruby wrapper around the
-  Claude Code CLI in headless mode (claude -p). It lets Ruby programs talk to
-  Claude using a Claude Pro/Max subscription for authentication instead of an
-  Anthropic API key: by default it strips ANTHROPIC_API_KEY from the child
-  process environment so the CLI falls back to the logged-in subscription
-  credentials. Unofficial; uses a supported headless feature within the
-  subscription's rate limits.
+dependencies: []
+description: ruby_claude is discontinued. Version 1.0.0 is an empty placeholder release.
 email:
 - kaiquekandykoga@gmail.com
 executables: []
@@ -82,22 +19,12 @@ files:
 - LICENSE
 - README.md
 - lib/ruby_claude.rb
-- lib/ruby_claude/client.rb
-- lib/ruby_claude/command.rb
-- lib/ruby_claude/configuration.rb
-- lib/ruby_claude/errors.rb
-- lib/ruby_claude/event.rb
-- lib/ruby_claude/response.rb
-- lib/ruby_claude/runner.rb
-- lib/ruby_claude/session.rb
-- lib/ruby_claude/version.rb
-- ruby_claude.gemspec
-homepage: https://github.com/kaiquekandykoga/ruby_claude
+homepage: https://rubygems.org/gems/ruby_claude
 licenses:
 - BSD-3-Clause
 metadata:
-  source_code_uri: https://github.com/kaiquekandykoga/ruby_claude
   rubygems_mfa_required: 'true'
+post_install_message: ruby_claude is discontinued; this release contains no functionality.
 rdoc_options: []
 require_paths:
 - lib
@@ -112,7 +39,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.18
 specification_version: 4
-summary: Subscription-authenticated Ruby SDK for Claude via the Claude Code CLI.
+summary: Discontinued. This release intentionally contains no functionality.
 test_files: []

data/lib/ruby_claude/client.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module RubyClaude
-  # Composes a {Command} and a {Runner} to execute queries and build
-  # {Response} and {Event} objects.
-  #
-  # A client holds an immutable {Configuration} and a stateless runner, builds
-  # fresh argv/env per call, and never mutates shared state — so one instance
-  # is safe to reuse and to call concurrently from many threads.
-  class Client
-    # Heuristic patterns in stderr/result text that indicate an auth problem.
-    # Deliberately specific: bare "authentication" / "api key" / "credit
-    # balance" match too much benign text and would misclassify ordinary
-    # execution and billing failures as authentication errors.
-    AUTH_PATTERNS = Regexp.union(
-      /invalid api key/i,
-      /authentication[ _](?:failed|error|required)/i,
-      /unauthorized/i,
-      /not logged ?in/i,
-      %r{/login}i,
-      /oauth/i,
-      /log ?in to claude/i
-    ).freeze
-
-    # @return [Configuration] the effective configuration for this client
-    attr_reader :config
-
-    # @param runner [#run, #stream] subprocess runner (injectable for tests)
-    # @param overrides [Hash] per-instance {Configuration} overrides
-    # @raise [ArgumentError] on an unknown configuration option
-    def initialize(runner: Runner.new, **overrides)
-      @config = RubyClaude.configuration.merge(overrides)
-      @runner = runner
-    end
-
-    # Run a one-shot query and return its {Response}.
-    #
-    # @param prompt [String]
-    # @param resume [String, nil] a session id to resume
-    # @return [Response]
-    # @raise [AuthenticationError, ExecutionError, ParseError, TimeoutError,
-    #   BinaryNotFoundError]
-    def query(prompt, resume: nil)
-      argv, env = Command.new(@config).build(stream: false, resume: resume)
-      result = @runner.run(**run_args(argv, env, prompt))
-      interpret(result)
-    end
-    alias ask query
-
-    # Stream a query, yielding {Event}s as they arrive.
-    #
-    # @param prompt [String]
-    # @param resume [String, nil] a session id to resume
-    # @yieldparam event [Event]
-    # @return [Response] the final result, built from the +result+ event
-    # @raise [AuthenticationError, ExecutionError, TimeoutError,
-    #   BinaryNotFoundError]
-    def stream(prompt, resume: nil)
-      argv, env = Command.new(@config).build(stream: true, resume: resume)
-      final = nil
-      result = @runner.stream(**run_args(argv, env, prompt)) do |line|
-        data = try_parse(line)
-        next unless data
-
-        final = data if data["type"] == "result"
-        yield Event.from_hash(data) if block_given?
-      end
-      check_stream_result!(final, result)
-      Response.from_result(final)
-    end
-
-    # Start a multi-turn {Session} backed by this client.
-    #
-    # @param id [String, nil] an existing session id to resume
-    # @return [Session]
-    def session(id: nil)
-      Session.new(self, id: id)
-    end
-
-    private
-
-    def run_args(argv, env, prompt)
-      { argv: argv, env: env, cwd: @config.cwd, timeout: @config.timeout, stdin: prompt.to_s }
-    end
-
-    # Turn a one-shot {RunResult} into a {Response} or raise a typed error.
-    def interpret(result)
-      data = try_parse(result.stdout)
-      if data.is_a?(Hash) && data["type"] == "result"
-        raise_result_error!(data, result) if data["is_error"]
-        return Response.from_result(data)
-      end
-
-      raise failure_for(result) if failed?(result)
-
-      raise ParseError, "could not parse claude output as JSON: #{truncate(result.stdout)}"
-    end
-
-    def check_stream_result!(final, result)
-      raise_result_error!(final, result) if final && final["is_error"]
-      raise failure_for(result) if final.nil? && failed?(result)
-    end
-
-    def failed?(result)
-      status = result.exit_status
-      status.nil? || !status.zero?
-    end
-
-    def raise_result_error!(data, result)
-      detail = data["result"] || data["errors"]&.join("; ") || "subtype=#{data["subtype"]}"
-      raise AuthenticationError, auth_message(detail) if auth?(detail, result&.stderr)
-
-      raise ExecutionError.new(
-        "claude returned an error result: #{detail}",
-        status: result&.exit_status,
-        stderr: result&.stderr
-      )
-    end
-
-    def failure_for(result)
-      stderr = result.stderr.to_s
-      return AuthenticationError.new(auth_message(stderr.strip)) if auth?(stderr, result.stdout)
-
-      status = result.exit_status
-      ExecutionError.new(
-        "claude exited with status #{status || "signal"}: #{truncate(stderr)}",
-        status: status,
-        stderr: stderr
-      )
-    end
-
-    def auth?(*sources)
-      sources.compact.any? { |source| AUTH_PATTERNS.match?(source.to_s) }
-    end
-
-    def auth_message(detail)
-      base = "Claude authentication failed. Run `claude` and use `/login` to sign in with " \
-             "your Claude subscription (or set use_subscription = false to use ANTHROPIC_API_KEY)."
-      detail.nil? || detail.empty? ? base : "#{base}\n#{detail}"
-    end
-
-    def try_parse(string)
-      return nil if string.nil? || string.strip.empty?
-
-      JSON.parse(string)
-    rescue JSON::ParserError
-      nil
-    end
-
-    def truncate(string, max = 500)
-      stripped = string.to_s.strip
-      stripped.length > max ? "#{stripped[0, max]}..." : stripped
-    end
-  end
-end

data/lib/ruby_claude/command.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module RubyClaude
-  # Pure translation of a {Configuration} plus per-call options into the argv
-  # array and child-environment overrides for the +claude+ CLI.
-  #
-  # Performs no I/O, which makes flag mapping trivial to unit-test. The prompt
-  # is intentionally *never* part of argv — it is written to the child's stdin
-  # by the {Runner} to avoid +ARG_MAX+ limits and shell-escaping concerns.
-  class Command
-    # @param config [Configuration]
-    def initialize(config)
-      @config = config
-    end
-
-    # Build the argv array and child-environment overrides.
-    #
-    # @param stream [Boolean] use stream-json output (also adds +--verbose+,
-    #   which the CLI requires for stream-json in print mode)
-    # @param resume [String, nil] a session id to resume via +--resume+
-    # @return [Array(Array<String>, Hash)] +[argv, env]+
-    def build(stream:, resume: nil)
-      argv = [@config.binary, "-p", "--output-format", stream ? "stream-json" : "json"]
-      argv << "--verbose" if stream
-      add_flag(argv, "--model", @config.model)
-      add_flag(argv, "--append-system-prompt", @config.append_system_prompt)
-      add_list(argv, "--allowedTools", @config.allowed_tools)
-      add_list(argv, "--disallowedTools", @config.disallowed_tools)
-      add_list(argv, "--add-dir", @config.add_dirs)
-      add_flag(argv, "--permission-mode", @config.permission_mode)
-      add_flag(argv, "--max-turns", @config.max_turns&.to_s)
-      add_flag(argv, "--resume", resume)
-      [argv, child_env]
-    end
-
-    # Environment overrides for the child process. In subscription mode,
-    # +ANTHROPIC_API_KEY+ is mapped to +nil+, which tells +Open3+/+spawn+ to
-    # remove it from the inherited environment so the CLI falls back to the
-    # logged-in subscription credentials.
-    #
-    # @return [Hash{String => String, nil}]
-    def child_env
-      return {} unless @config.use_subscription
-
-      { "ANTHROPIC_API_KEY" => nil }
-    end
-
-    private
-
-    # Append +flag value+ when +value+ is present.
-    def add_flag(argv, flag, value)
-      return if value.nil?
-
-      string = value.to_s
-      return if string.empty?
-
-      argv.push(flag, string)
-    end
-
-    # Append +flag item item ...+ (each list item as its own argv token, which
-    # matches the CLI's space-separated variadic options and preserves spaces
-    # inside permission-rule patterns such as +Bash(git log *)+).
-    def add_list(argv, flag, value)
-      items = Array(value).map(&:to_s).reject(&:empty?)
-      return if items.empty?
-
-      argv.push(flag, *items)
-    end
-  end
-end

data/lib/ruby_claude/configuration.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module RubyClaude
-  # Holds every tunable option with sane defaults.
-  #
-  # Used as the global default (via {RubyClaude.configure}) and as the basis
-  # for per-{Client} overrides through {#merge}. A configuration is only ever
-  # read while a query runs, never mutated, which keeps {Client} thread-safe.
-  class Configuration
-    # @return [String] executable name or path of the CLI
-    attr_accessor :binary
-
-    # @return [String, nil] model for +--model+ (nil uses the CLI default)
-    attr_accessor :model
-
-    # @return [String, nil] working directory for the subprocess
-    attr_accessor :cwd
-
-    # @return [Integer] seconds before the child process is killed
-    attr_accessor :timeout
-
-    # @return [Boolean] when true, strip +ANTHROPIC_API_KEY+ from the child env
-    attr_accessor :use_subscription
-
-    # @return [String, nil] text for +--append-system-prompt+
-    attr_accessor :append_system_prompt
-
-    # @return [Array<String>, String, nil] tools for +--allowedTools+
-    attr_accessor :allowed_tools
-
-    # @return [Array<String>, String, nil] tools for +--disallowedTools+
-    attr_accessor :disallowed_tools
-
-    # @return [Array<String>] directories for repeated +--add-dir+
-    attr_accessor :add_dirs
-
-    # @return [String, nil] mode for +--permission-mode+
-    attr_accessor :permission_mode
-
-    # @return [Integer, nil] limit for +--max-turns+
-    attr_accessor :max_turns
-
-    def initialize
-      @binary = "claude"
-      @model = nil
-      @cwd = Dir.pwd
-      @timeout = 300
-      @use_subscription = true
-      @append_system_prompt = nil
-      @allowed_tools = nil
-      @disallowed_tools = nil
-      @add_dirs = []
-      @permission_mode = nil
-      @max_turns = nil
-    end
-
-    # Return a copy with the given overrides applied. The receiver is left
-    # untouched, so the global configuration is never mutated by a {Client}.
-    #
-    # @param overrides [Hash{Symbol => Object}]
-    # @return [Configuration]
-    # @raise [ArgumentError] when an option is not recognized
-    def merge(overrides)
-      dup.tap do |copy|
-        overrides.each do |key, value|
-          setter = "#{key}="
-          raise ArgumentError, "unknown configuration option: #{key}" unless copy.respond_to?(setter)
-
-          copy.public_send(setter, value)
-        end
-      end
-    end
-
-    # @return [Hash{Symbol => Object}] a plain-hash view of the configuration
-    def to_h
-      {
-        binary: binary, model: model, cwd: cwd, timeout: timeout,
-        use_subscription: use_subscription, append_system_prompt: append_system_prompt,
-        allowed_tools: allowed_tools, disallowed_tools: disallowed_tools,
-        add_dirs: add_dirs, permission_mode: permission_mode, max_turns: max_turns
-      }
-    end
-
-    private
-
-    # Deep-copy the mutable array options so a {Client} can never mutate the
-    # array held by the global configuration.
-    def initialize_copy(source)
-      super
-      @add_dirs = source.add_dirs.dup if source.add_dirs.is_a?(Array)
-      @allowed_tools = source.allowed_tools.dup if source.allowed_tools.is_a?(Array)
-      @disallowed_tools = source.disallowed_tools.dup if source.disallowed_tools.is_a?(Array)
-    end
-  end
-end

data/lib/ruby_claude/errors.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module RubyClaude
-  # Base class for every error raised by Ruby Claude.
-  class Error < StandardError; end
-
-  # Raised when the +claude+ binary cannot be found on PATH or executed.
-  #
-  # The message explains how to install Claude Code and reminds the user that
-  # they must run +claude+ and +/login+ at least once.
-  class BinaryNotFoundError < Error; end
-
-  # Raised when the CLI output or exit status indicates the user is not
-  # logged in or that authentication otherwise failed.
-  class AuthenticationError < Error; end
-
-  # Raised when the child process exceeds the configured timeout and the gem
-  # kills it.
-  class TimeoutError < Error; end
-
-  # Raised on a non-zero exit status, or on a result payload that reports
-  # +is_error: true+. Carries the exit status and captured stderr.
-  class ExecutionError < Error
-    # @return [Integer, nil] the child process exit status, when known
-    attr_reader :status
-
-    # @return [String, nil] captured standard error output, when available
-    attr_reader :stderr
-
-    # @param message [String, nil]
-    # @param status [Integer, nil]
-    # @param stderr [String, nil]
-    def initialize(message = nil, status: nil, stderr: nil)
-      @status = status
-      @stderr = stderr
-      super(message)
-    end
-  end
-
-  # Raised when the CLI output cannot be parsed as the expected JSON.
-  class ParseError < Error; end
-end

data/lib/ruby_claude/event.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module RubyClaude
-  # Immutable streaming event parsed from one line of +--output-format
-  # stream-json+ output. The {#type} mirrors the CLI's +type+ field as a
-  # Symbol (+:system+, +:assistant+, +:user+, +:result+, ...).
-  #
-  # @!attribute [r] type
-  #   @return [Symbol] the event type
-  # @!attribute [r] text
-  #   @return [String, nil] text extracted from assistant/user/result payloads
-  # @!attribute [r] session_id
-  #   @return [String, nil] the session id, when present
-  # @!attribute [r] cost_usd
-  #   @return [Float, nil] total cost, present on the result event
-  # @!attribute [r] duration_ms
-  #   @return [Integer, nil] duration, present on the result event
-  # @!attribute [r] raw
-  #   @return [Hash] the full parsed line
-  Event = Data.define(:type, :text, :session_id, :cost_usd, :duration_ms, :raw) do
-    # Build an Event from one parsed NDJSON line.
-    #
-    # @param data [Hash, nil] the parsed line
-    # @return [Event]
-    def self.from_hash(data)
-      data ||= {}
-      new(
-        type: (data["type"] || "unknown").to_sym,
-        text: extract_text(data),
-        session_id: data["session_id"],
-        cost_usd: data["total_cost_usd"],
-        duration_ms: data["duration_ms"],
-        raw: data
-      )
-    end
-
-    # Pull human-readable text out of a parsed line, if any.
-    #
-    # @param data [Hash]
-    # @return [String, nil]
-    def self.extract_text(data)
-      case data["type"]
-      when "assistant", "user"
-        message = data["message"] || data
-        text_from_content(message["content"])
-      when "result"
-        data["result"]
-      end
-    end
-
-    # Join the text from a content array (or pass a bare string through).
-    #
-    # @param content [String, Array, nil]
-    # @return [String, nil]
-    def self.text_from_content(content)
-      return content if content.is_a?(String)
-      return nil unless content.is_a?(Array)
-
-      texts = content
-              .select { |block| block.is_a?(Hash) && block["type"] == "text" }
-              .filter_map { |block| block["text"] }
-      texts.empty? ? nil : texts.join
-    end
-
-    # @return [Boolean] whether this is the final result event
-    def result? = type == :result
-
-    # @return [Boolean] whether this is an assistant message event
-    def assistant? = type == :assistant
-
-    # @return [Boolean] whether this is a system event
-    def system? = type == :system
-
-    # @return [Boolean] whether this is a user message event
-    def user? = type == :user
-  end
-end

data/lib/ruby_claude/response.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RubyClaude
-  # Immutable value object describing the final result of a query.
-  #
-  # Built from the CLI's +--output-format json+ result object (or from the
-  # final +result+ line of a stream). Missing keys map to sensible defaults
-  # rather than raising.
-  #
-  # @!attribute [r] text
-  #   @return [String] the assistant's final text result
-  # @!attribute [r] session_id
-  #   @return [String, nil] the session id of this conversation
-  # @!attribute [r] cost_usd
-  #   @return [Float] total cost in USD (often +0.0+ on a subscription)
-  # @!attribute [r] usage
-  #   @return [Hash] token usage counts, when present
-  # @!attribute [r] num_turns
-  #   @return [Integer] number of agentic turns
-  # @!attribute [r] duration_ms
-  #   @return [Integer] wall-clock duration in milliseconds
-  # @!attribute [r] error
-  #   @return [Boolean] whether the CLI reported an error
-  # @!attribute [r] raw
-  #   @return [Hash] the full parsed result object
-  Response = Data.define(:text, :session_id, :cost_usd, :usage,
-                         :num_turns, :duration_ms, :error, :raw) do
-    # Build a Response from a parsed CLI result hash.
-    #
-    # @param data [Hash, nil] the parsed result object
-    # @return [Response]
-    def self.from_result(data)
-      data ||= {}
-      new(
-        text: data["result"] || "",
-        session_id: data["session_id"],
-        cost_usd: (data["total_cost_usd"] || data["cost_usd"] || 0.0).to_f,
-        usage: data["usage"] || {},
-        num_turns: (data["num_turns"] || 0).to_i,
-        duration_ms: (data["duration_ms"] || 0).to_i,
-        error: data.fetch("is_error", false) ? true : false,
-        raw: data
-      )
-    end
-
-    # @return [Boolean] whether the result represents an error
-    def error? = !!error
-
-    # @return [Boolean] whether the result was successful
-    def success? = !error?
-
-    # Returns the assistant text, so +puts response+ prints the answer.
-    #
-    # @return [String]
-    def to_s = text
-  end
-end

data/lib/ruby_claude/runner.rb

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-
-module RubyClaude
-  # The captured result of a completed subprocess run.
-  #
-  # @!attribute [r] stdout
-  #   @return [String, nil] captured stdout (nil when streaming)
-  # @!attribute [r] stderr
-  #   @return [String] captured stderr
-  # @!attribute [r] exit_status
-  #   @return [Integer, nil] exit code, or nil if the process was signalled
-  RunResult = Data.define(:stdout, :stderr, :exit_status)
-
-  # Owns every subprocess concern: spawning +claude+ via +Open3+, writing the
-  # prompt to stdin, enforcing the timeout by killing the child, capturing
-  # output, and translating spawn failures into {BinaryNotFoundError}.
-  #
-  # The runner is stateless, so a single instance is safe to share across
-  # threads. The {Client} accepts an injected runner so tests never spawn.
-  class Runner
-    # Seconds to wait after +SIGTERM+ before escalating to +SIGKILL+.
-    KILL_GRACE = 2
-
-    # Run the command to completion and capture its output.
-    #
-    # @param argv [Array<String>] the command and its arguments
-    # @param env [Hash] environment overrides (nil values unset a variable)
-    # @param cwd [String, nil] working directory
-    # @param timeout [Numeric] seconds before the child is killed
-    # @param stdin [String, nil] data to write to the child's stdin
-    # @return [RunResult]
-    # @raise [TimeoutError] if the child exceeds +timeout+
-    # @raise [BinaryNotFoundError] if the binary cannot be executed
-    def run(argv:, env:, cwd:, timeout:, stdin: nil)
-      spawn(argv, env, cwd) do |stdin_io, stdout_io, stderr_io, wait_thr|
-        out_reader = Thread.new { stdout_io.read }
-        err_reader = Thread.new { stderr_io.read }
-        write_stdin(stdin_io, stdin)
-
-        if wait_thr.join(timeout).nil?
-          terminate(wait_thr)
-          out_reader.kill
-          err_reader.kill
-          raise TimeoutError, "claude did not finish within #{timeout}s; the process was killed"
-        end
-
-        RunResult.new(
-          stdout: out_reader.value,
-          stderr: err_reader.value,
-          exit_status: wait_thr.value.exitstatus
-        )
-      end
-    end
-
-    # Run the command and yield each non-empty stdout line as it arrives.
-    #
-    # @param (see #run)
-    # @yieldparam line [String] one chomped, non-empty stdout line
-    # @return [RunResult] with +stdout+ nil (it was streamed, not captured)
-    # @raise [TimeoutError] if the child exceeds +timeout+
-    # @raise [BinaryNotFoundError] if the binary cannot be executed
-    def stream(argv:, env:, cwd:, timeout:, stdin: nil)
-      spawn(argv, env, cwd) do |stdin_io, stdout_io, stderr_io, wait_thr|
-        err_reader = Thread.new { stderr_io.read }
-        # Write stdin on its own thread so a prompt larger than the OS pipe
-        # buffer can't deadlock against stdout we haven't started reading yet.
-        writer = Thread.new { write_stdin(stdin_io, stdin) }
-        timed_out = false
-        watchdog = Thread.new do
-          sleep(timeout)
-          timed_out = true
-          terminate(wait_thr)
-        end
-
-        begin
-          stdout_io.each_line do |line|
-            chomped = line.chomp
-            yield chomped unless chomped.empty?
-          end
-        ensure
-          watchdog.kill
-          writer.join
-        end
-
-        raise TimeoutError, "claude streaming exceeded #{timeout}s; the process was killed" if timed_out
-
-        RunResult.new(stdout: nil, stderr: err_reader.value, exit_status: wait_thr.value.exitstatus)
-      end
-    end
-
-    private
-
-    def spawn(argv, env, cwd, &block)
-      validate_cwd!(cwd)
-      options = {}
-      options[:chdir] = cwd if cwd
-      Open3.popen3(env || {}, *argv, **options, &block)
-    rescue Errno::ENOENT
-      raise BinaryNotFoundError, binary_not_found_message(argv.first)
-    end
-
-    def validate_cwd!(cwd)
-      return if cwd.nil? || File.directory?(cwd)
-
-      raise Error, "working directory does not exist: #{cwd}"
-    end
-
-    def write_stdin(stdin_io, data)
-      stdin_io.write(data) if data
-    rescue Errno::EPIPE
-      # The child exited before reading stdin; the failure surfaces via status.
-    ensure
-      stdin_io.close unless stdin_io.closed?
-    end
-
-    # Send +SIGTERM+, wait up to {KILL_GRACE} for the child to exit, then
-    # escalate to +SIGKILL+ if it ignored the polite signal.
-    #
-    # This runs synchronously while holding +wait_thr+: the child's PID can't
-    # be reaped (and therefore can't be recycled by the OS) until we let go,
-    # so the +SIGKILL+ can never land on an unrelated, reused PID.
-    def terminate(wait_thr)
-      Process.kill("TERM", wait_thr.pid)
-      return if wait_thr.join(KILL_GRACE)
-
-      Process.kill("KILL", wait_thr.pid)
-    rescue Errno::ESRCH
-      # The process already exited.
-    end
-
-    def binary_not_found_message(binary)
-      "could not run #{binary.inspect}: is Claude Code installed and on your PATH?\n" \
-        "Install it with `npm install -g @anthropic-ai/claude-code`, then run `claude` " \
-        "and `/login` once to sign in with your Claude subscription."
-    end
-  end
-end

data/lib/ruby_claude/session.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RubyClaude
-  # A multi-turn conversation.
-  #
-  # The first {#query} captures the +session_id+ from the reply; subsequent
-  # queries transparently pass +--resume <id>+ so the conversation continues.
-  class Session
-    # @return [String, nil] the session id being resumed (nil until the first
-    #   reply, unless one was supplied to {Client#session})
-    attr_reader :id
-
-    # @param client [Client] the client used to run each turn
-    # @param id [String, nil] an existing session id to resume from the start
-    def initialize(client, id: nil)
-      @client = client
-      @id = id
-      @mutex = Mutex.new
-    end
-
-    # Ask a question within this conversation, resuming the captured session.
-    #
-    # @param prompt [String]
-    # @return [Response]
-    def query(prompt)
-      @mutex.synchronize do
-        response = @client.query(prompt, resume: @id)
-        @id = response.session_id || @id
-        response
-      end
-    end
-    alias ask query
-  end
-end

data/lib/ruby_claude/version.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module RubyClaude
-  # The released version of the gem, following Semantic Versioning.
-  VERSION = "0.0.1"
-end

data/ruby_claude.gemspec

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/ruby_claude/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "ruby_claude"
-  spec.version = RubyClaude::VERSION
-  spec.authors = ["Kaíque Kandy Koga"]
-  spec.email = ["kaiquekandykoga@gmail.com"]
-
-  spec.summary = "Subscription-authenticated Ruby SDK for Claude via the Claude Code CLI."
-  spec.description = <<~DESC
-    Ruby Claude is a small, dependency-light, idiomatic Ruby wrapper around the
-    Claude Code CLI in headless mode (claude -p). It lets Ruby programs talk to
-    Claude using a Claude Pro/Max subscription for authentication instead of an
-    Anthropic API key: by default it strips ANTHROPIC_API_KEY from the child
-    process environment so the CLI falls back to the logged-in subscription
-    credentials. Unofficial; uses a supported headless feature within the
-    subscription's rate limits.
-  DESC
-  spec.homepage = "https://github.com/kaiquekandykoga/ruby_claude"
-  spec.license = "BSD-3-Clause"
-  spec.required_ruby_version = ">= 3.2"
-
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["rubygems_mfa_required"] = "true"
-
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").select do |path|
-      path.start_with?("lib/") ||
-        %w[README.md LICENSE ruby_claude.gemspec].include?(path)
-    end
-  end
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rubocop", "~> 1.60"
-  spec.add_development_dependency "test-unit", "~> 3.6"
-  spec.add_development_dependency "yard", "~> 0.9"
-end