dannykeane 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d38a8a66ba6a406a36dcec88f9bff39e15160d8283a2bf0267009cda1b72a092
+  data.tar.gz: 391c52c002b41a24c4689a10c25ccadd205c2e2ea5d85705d822ae9048e3479b
+SHA512:
+  metadata.gz: 66417a2fd69f75b1163fe59ee54e914e119971941256ec6f356c080efbe2c7eb29601b8baa2d8b43fd356a3dc103b2841674c290e69a8fbeb4e5461d1566ea90
+  data.tar.gz: 6f4b2d2f99b5e451a7519f40709990f296996ea151678d6b9bcb57d62c0c83634a79d44f5f28a50a7174506d8cb6cb7757b49562925cbfea77845bee840dd759

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Danny Keane
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# dannykeane
+
+Official Ruby SDK and CLI for the [dannykeane.com](https://dannykeane.com) public API: Danny Keane's work history, GitHub contribution calendar, live visitor stats, and the Habbo room NPC chat.
+
+Zero dependencies, standard library only. Ruby 2.6+.
+
+```sh
+gem install dannykeane
+```
+
+## Usage
+
+```ruby
+require "dannykeane"
+
+dk = DannyKeane::Client.new
+dk.iter_work { |role| puts "#{role["company"]} #{role["years"]}" }
+```
+
+Every endpoint is public, so there is no API key. Pass `base_url:` to point at a local or preview deploy.
+
+| Method | API operation | Endpoint |
+| --- | --- | --- |
+| `list_work(limit: nil, cursor: nil)` | `listWork` | `GET /api/v1/work` |
+| `iter_work(limit: nil)` | `listWork`, every page | `GET /api/v1/work` |
+| `get_stats` | `getStats` | `GET /api/v1/stats` |
+| `get_github_contributions` | `getGithubContributions` | `GET /api/v1/github-contributions` |
+| `npc_chat(message, npc_id, context: nil)` | `npcChat` | `POST /api/v1/npc-chat` |
+| `npc_chat_health` | `npcChatHealth` | `GET /api/v1/npc-chat` |
+| `run_batch(requests)` | `runBatch` | `POST /api/v1/batch` |
+
+Results are the API's own JSON, parsed into Hashes with string keys. The full contract is the OpenAPI document at https://dannykeane.com/openapi.json.
+
+### Pagination
+
+`list_work` returns one page: `{"data" => [...], "next_cursor" => "..."}`, with `next_cursor` set to `nil` on the last page. `iter_work` follows the cursors for you; without a block it returns an Enumerator that fetches each page only when iteration reaches it.
+
+### Errors
+
+Every non-2xx response raises `DannyKeane::ApiError`, parsed from the API's ErrorResponse body:
+
+```ruby
+begin
+  DannyKeane::Client.new.list_work(limit: 50)
+rescue DannyKeane::ApiError => error
+  puts error.status, error.code, error.message, error.hint
+  # 400 invalid_parameter limit must be an integer from 1 to 20 ...
+end
+```
+
+`error.body` holds the full parsed body. Network failures (DNS, refused connection, TLS, timeout) raise `DannyKeane::ConnectionError`, with the original exception on `cause`. Both inherit from `DannyKeane::Error`.
+
+### Rate limits
+
+On a 429 the client waits out `Retry-After` and retries, up to `max_retries:` (default 2). A `Retry-After` longer than `max_retry_delay:` (default 60 seconds) raises immediately instead, with the wait on `error.retry_after`. Set `max_retries: 0` to handle every 429 yourself.
+
+## CLI
+
+The gem installs a `dannykeane` command:
+
+```sh
+dannykeane work --limit 5
+```
+
+| Command | Operation |
+| --- | --- |
+| `dannykeane work [--limit N] [--cursor TOKEN] [--all]` | `listWork`; `--all` walks every page and prints one array |
+| `dannykeane stats` | `getStats` |
+| `dannykeane github-contributions` | `getGithubContributions` |
+| `dannykeane npc-chat [--npc-id ID] <message>` | `npcChat` |
+| `dannykeane npc-chat-health` | `npcChatHealth` |
+| `dannykeane batch <operationId>...` | `runBatch` |
+
+The API's JSON goes to stdout, indented when stdout is a terminal (`--pretty` forces it). Failures go to stderr as one line of ErrorResponse JSON, with stdout empty. `--base-url` or `DANNYKEANE_BASE_URL` points it at another deploy.
+
+Exit codes: `0` success, `1` the API returned an error, `2` usage error, `3` the API could not be reached.
+
+The npm package [`dannykeane`](https://www.npmjs.com/package/dannykeane) and the PyPI package [`dannykeane`](https://pypi.org/project/dannykeane/) ship the same client and CLI for TypeScript and Python.
+
+## Links
+
+- Developer docs: https://dannykeane.com/developers
+- OpenAPI spec: https://dannykeane.com/openapi.json
+- Contact: me@dannykeane.co.uk
+
+## License
+
+MIT

data/exe/dannykeane

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "dannykeane/cli"
+
+exit DannyKeane::CLI.new.run(ARGV)

data/lib/dannykeane/cli.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require "json"
+require "optparse"
+
+require_relative "../dannykeane"
+
+module DannyKeane
+  # +dannykeane+ -- the official CLI for the dannykeane.com public API.
+  #
+  # A thin layer over DannyKeane::Client: one command per API operation, the
+  # API's own JSON on stdout, and any failure on stderr as one line of
+  # ErrorResponse-shaped JSON. The npm and PyPI packages ship the same command
+  # surface.
+  #
+  # Exit codes: 0 success, 1 the API returned an error, 2 usage error,
+  # 3 the API could not be reached.
+  class CLI
+    EXIT_OK = 0
+    EXIT_API_ERROR = 1
+    EXIT_USAGE = 2
+    EXIT_UNREACHABLE = 3
+
+    class UsageError < StandardError
+      attr_reader :command
+
+      def initialize(message, command = nil)
+        super(message)
+        @command = command
+      end
+    end
+
+    Command = Struct.new(:summary, :usage, :examples, :flags, :accepts, :takes_args, :run, keyword_init: true)
+
+    COMMANDS = {
+      "work" => Command.new(
+        summary: "List roles from the /work tables, one page or all of them",
+        usage: "dannykeane work [--limit <n>] [--cursor <token>] [--all]",
+        examples: ["dannykeane work --limit 5", "dannykeane work --all"],
+        flags: [
+          "    --limit <n>       page size, 1-20 (API default 10)",
+          "    --cursor <token>  next_cursor from the previous page",
+          "    --all             follow next_cursor to the end; prints one array of every role"
+        ],
+        accepts: [:limit, :cursor, :all],
+        takes_args: false,
+        run: lambda do |client, args|
+          next client.list_work(limit: args[:limit], cursor: args[:cursor]) unless args[:all]
+
+          client.iter_work(limit: args[:limit]).to_a
+        end
+      ),
+      "stats" => Command.new(
+        summary: "Live visitor count on dannykeane.com",
+        usage: "dannykeane stats",
+        examples: ["dannykeane stats"],
+        flags: [],
+        accepts: [],
+        takes_args: false,
+        run: ->(client, _args) { client.get_stats }
+      ),
+      "github-contributions" => Command.new(
+        summary: "GitHub contribution calendar: 52 weeks plus aggregate stats",
+        usage: "dannykeane github-contributions",
+        examples: ["dannykeane github-contributions | jq .totalContributions"],
+        flags: [],
+        accepts: [],
+        takes_args: false,
+        run: ->(client, _args) { client.get_github_contributions }
+      ),
+      "npc-chat" => Command.new(
+        summary: "Say something to Frank, the NPC in the /habbo room",
+        usage: "dannykeane npc-chat [--npc-id <id>] <message>",
+        examples: ['dannykeane npc-chat "hey frank, got any coffee?"'],
+        flags: ['    --npc-id <id>     the NPC to address (default "frank")'],
+        accepts: [:npc_id],
+        takes_args: true,
+        run: lambda do |client, args|
+          message = args[:positionals].join(" ")
+          raise UsageError.new("npc-chat needs a message", "npc-chat") if message.empty?
+
+          client.npc_chat(message, args[:npc_id])
+        end
+      ),
+      "npc-chat-health" => Command.new(
+        summary: "Liveness probe for the NPC chat service",
+        usage: "dannykeane npc-chat-health",
+        examples: ["dannykeane npc-chat-health"],
+        flags: [],
+        accepts: [],
+        takes_args: false,
+        run: ->(client, _args) { client.npc_chat_health }
+      ),
+      "batch" => Command.new(
+        summary: "Run several read operations in one request, by operationId",
+        usage: "dannykeane batch <operationId>...",
+        examples: ["dannykeane batch getStats npcChatHealth"],
+        flags: [
+          "    operationIds: #{BATCH_OPERATION_IDS.join(", ")} (up to 10).",
+          "    Each result carries its own status; one failed item doesn't fail the batch."
+        ],
+        accepts: [],
+        takes_args: true,
+        run: lambda do |client, args|
+          if args[:positionals].empty?
+            raise UsageError.new("batch needs at least one operationId", "batch")
+          end
+
+          client.run_batch(args[:positionals])
+        end
+      )
+    }.freeze
+
+    COMMAND_FLAGS = { limit: "limit", cursor: "cursor", all: "all", npc_id: "npc-id" }.freeze
+
+    GLOBAL_FLAGS = [
+      "    --base-url <url>  API origin (env DANNYKEANE_BASE_URL, default #{DEFAULT_BASE_URL})",
+      "    --pretty          indent JSON output (the default when stdout is a terminal)",
+      "-h, --help            show help",
+      "-V, --version         print the version"
+    ].freeze
+
+    EXIT_CODES = [
+      "  0  success",
+      "  1  the API returned an error (its ErrorResponse JSON is on stderr)",
+      "  2  usage error",
+      "  3  the API could not be reached"
+    ].freeze
+
+    def initialize(stdout: $stdout, stderr: $stderr, env: ENV)
+      @stdout = stdout
+      @stderr = stderr
+      @env = env
+    end
+
+    # Runs one invocation and returns its exit code.
+    def run(argv)
+      begin
+        values, positionals = parse(argv)
+      rescue OptionParser::ParseError => error
+        return usage(UsageError.new(error.message, argv.find { |arg| COMMANDS.key?(arg) }))
+      end
+      name = positionals.shift
+
+      if values[:version]
+        @stdout.puts("dannykeane #{VERSION}")
+        return EXIT_OK
+      end
+      if name.nil?
+        @stdout.puts(root_help)
+        return EXIT_OK
+      end
+      command = COMMANDS[name]
+      return usage(UsageError.new("unknown command \"#{name}\"")) if command.nil?
+
+      if values[:help]
+        @stdout.puts(command_help(name))
+        return EXIT_OK
+      end
+
+      args = validate(name, command, values, positionals)
+      base_url = [values[:base_url], @env["DANNYKEANE_BASE_URL"]].find { |url| url && !url.empty? } ||
+                 DEFAULT_BASE_URL
+      execute(command, Client.new(base_url: base_url), args, base_url, values[:pretty])
+    rescue UsageError => error
+      usage(error)
+    end
+
+    private
+
+    def parse(argv)
+      values = {}
+      parser = OptionParser.new do |opts|
+        opts.on("-h", "--help") { values[:help] = true }
+        opts.on("-V", "--version") { values[:version] = true }
+        opts.on("--pretty") { values[:pretty] = true }
+        opts.on("--base-url URL") { |url| values[:base_url] = url }
+        opts.on("--limit N") { |limit| values[:limit] = limit }
+        opts.on("--cursor TOKEN") { |cursor| values[:cursor] = cursor }
+        opts.on("--all") { values[:all] = true }
+        opts.on("--npc-id ID") { |npc_id| values[:npc_id] = npc_id }
+      end
+      positionals = parser.parse(argv)
+      [values, positionals]
+    end
+
+    def validate(name, command, values, positionals)
+      stray = COMMAND_FLAGS.keys.find { |flag| values.key?(flag) && !command.accepts.include?(flag) }
+      raise UsageError.new("#{name} does not take --#{COMMAND_FLAGS[stray]}", name) if stray
+      if !command.takes_args && !positionals.empty?
+        raise UsageError.new("#{name} takes no arguments, got \"#{positionals.first}\"", name)
+      end
+      if values[:all] && values.key?(:cursor)
+        raise UsageError.new("--all starts from the first page; drop --cursor", name)
+      end
+
+      {
+        positionals: positionals,
+        limit: parse_limit(values[:limit], name),
+        cursor: values[:cursor],
+        all: values[:all] || false,
+        npc_id: values[:npc_id] || "frank"
+      }
+    end
+
+    def parse_limit(value, name)
+      return nil if value.nil?
+
+      Integer(value, 10)
+    rescue ArgumentError
+      raise UsageError.new("--limit must be an integer, got \"#{value}\"", name)
+    end
+
+    def execute(command, client, args, base_url, pretty)
+      result = command.run.call(client, args)
+      pretty ||= @stdout.respond_to?(:tty?) && @stdout.tty?
+      @stdout.puts(pretty ? JSON.pretty_generate(result) : JSON.generate(result))
+      EXIT_OK
+    rescue ApiError => error
+      body = error.body.is_a?(Hash) ? error.body : { "code" => nil, "error" => error.message, "status" => error.status }
+      write_error(body)
+      EXIT_API_ERROR
+    rescue ConnectionError => error
+      write_error(
+        "code" => "connection_failed",
+        "error" => "Could not reach #{base_url}: #{error.message}",
+        "hint" => "Check your network connection, or --base-url / DANNYKEANE_BASE_URL."
+      )
+      EXIT_UNREACHABLE
+    end
+
+    def usage(error)
+      help = error.command ? "dannykeane #{error.command} --help" : "dannykeane --help"
+      write_error("code" => "usage_error", "error" => error.message, "hint" => "Run '#{help}'.")
+      EXIT_USAGE
+    end
+
+    def write_error(body)
+      @stderr.puts(JSON.generate(body))
+    end
+
+    def root_help
+      width = COMMANDS.keys.map(&:length).max + 2
+      [
+        "Query the dannykeane.com public API. JSON on stdout, errors on stderr.",
+        "",
+        "USAGE",
+        "  dannykeane <command> [flags]",
+        "",
+        "EXAMPLES",
+        "  $ dannykeane work --limit 5",
+        "  $ dannykeane work --all | jq '.[].company'",
+        "  $ dannykeane stats",
+        "",
+        "COMMANDS",
+        *COMMANDS.map { |name, command| "  #{name.ljust(width)}#{command.summary}" },
+        "",
+        "GLOBAL FLAGS",
+        *GLOBAL_FLAGS.map { |line| "  #{line}" },
+        "",
+        "EXIT CODES",
+        *EXIT_CODES,
+        "",
+        "Run 'dannykeane <command> --help' for a command's flags.",
+        "Docs: https://dannykeane.com/developers"
+      ].join("\n")
+    end
+
+    def command_help(name)
+      command = COMMANDS[name]
+      flags = command.flags.empty? ? [] : ["FLAGS", *command.flags.map { |line| "  #{line}" }, ""]
+      [
+        command.summary,
+        "",
+        "USAGE",
+        "  #{command.usage}",
+        "",
+        "EXAMPLES",
+        *command.examples.map { |example| "  $ #{example}" },
+        "",
+        *flags,
+        "GLOBAL FLAGS",
+        *GLOBAL_FLAGS.map { |line| "  #{line}" },
+        "",
+        "EXIT CODES",
+        *EXIT_CODES,
+        "",
+        "Docs: https://dannykeane.com/developers"
+      ].join("\n")
+    end
+  end
+end

data/lib/dannykeane/client.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "time"
+require "uri"
+
+require_relative "errors"
+require_relative "version"
+
+module DannyKeane
+  DEFAULT_BASE_URL = "https://dannykeane.com"
+
+  # The argument-free read operations run_batch accepts.
+  BATCH_OPERATION_IDS = ["getStats", "getGithubContributions", "npcChatHealth"].freeze
+
+  # Client for the dannykeane.com public API.
+  #
+  # A thin, zero-dependency wrapper over Net::HTTP, written by hand against the
+  # OpenAPI 3.1 document at https://dannykeane.com/openapi.json. The site's
+  # test suite (app/lib/sdkCoverage.test.ts) fails when the spec gains an
+  # operation this client doesn't cover, so the two can't drift apart silently.
+  #
+  # No authentication: every endpoint is public. Results are the API's own
+  # JSON, parsed into Hashes and Arrays with string keys.
+  class Client
+    # Exceptions Net::HTTP raises when the server can't be reached or talked to.
+    NETWORK_ERRORS = [
+      SocketError, SystemCallError, IOError, Timeout::Error,
+      OpenSSL::SSL::SSLError, Net::ProtocolError, Net::HTTPBadResponse
+    ].freeze
+
+    attr_reader :base_url, :max_retries, :max_retry_delay, :timeout, :user_agent
+
+    # base_url::        Defaults to https://dannykeane.com. Override for a local
+    #                   or preview deploy.
+    # max_retries::     Retries after a 429, honoring Retry-After. 0 disables.
+    # max_retry_delay:: Longest Retry-After, in seconds, the client will wait
+    #                   out. Longer waits raise instead.
+    # timeout::         Per-attempt open and read timeout in seconds.
+    # user_agent::      Appended to the SDK's own User-Agent.
+    def initialize(base_url: nil, max_retries: 2, max_retry_delay: 60.0, timeout: 30.0, user_agent: nil)
+      @base_url = (base_url || DEFAULT_BASE_URL).sub(%r{/+\z}, "")
+      @max_retries = max_retries
+      @max_retry_delay = max_retry_delay
+      @timeout = timeout
+      @user_agent = ["dannykeane-ruby/#{VERSION}", user_agent].compact.reject(&:empty?).join(" ")
+    end
+
+    # Active users on the site right now (GA4, cached 60s).
+    def get_stats
+      request("GET", "/api/v1/stats")
+    end
+
+    # Danny Keane's GitHub contribution calendar: 52 weeks plus aggregate stats.
+    def get_github_contributions
+      request("GET", "/api/v1/github-contributions")
+    end
+
+    # Liveness probe for the NPC chat service.
+    def npc_chat_health
+      request("GET", "/api/v1/npc-chat")
+    end
+
+    # Send a message (up to 500 characters) to a Habbo room NPC, e.g. "frank".
+    def npc_chat(message, npc_id, context: nil)
+      body = { "message" => message, "npcId" => npc_id }
+      body["context"] = context.to_h unless context.nil?
+      request("POST", "/api/v1/npc-chat", body: body)
+    end
+
+    # Run up to 10 argument-free read operations in one request.
+    #
+    # Each request is an operationId ("getStats") or a Hash with
+    # "operationId" and an optional "id" (string or symbol keys).
+    def run_batch(requests)
+      items = requests.map do |item|
+        if item.is_a?(String) || item.is_a?(Symbol)
+          { "operationId" => item.to_s }
+        else
+          item.to_h.each_with_object({}) { |(key, value), out| out[key.to_s] = value }
+        end
+      end
+      request("POST", "/api/v1/batch", body: { "requests" => items })
+    end
+
+    # One page of roles. Follow "next_cursor", or use iter_work.
+    def list_work(limit: nil, cursor: nil)
+      request("GET", "/api/v1/work", query: { "limit" => limit, "cursor" => cursor })
+    end
+
+    # Every role, fetching pages of +limit+ as the iteration needs them.
+    # Returns an Enumerator when called without a block.
+    def iter_work(limit: nil)
+      return enum_for(:iter_work, limit: limit) unless block_given?
+
+      cursor = nil
+      loop do
+        page = list_work(limit: limit, cursor: cursor)
+        page["data"].each { |role| yield role }
+        cursor = page["next_cursor"]
+        break if cursor.nil?
+      end
+      nil
+    end
+
+    private
+
+    def request(method, path, query: nil, body: nil)
+      params = (query || {}).reject { |_key, value| value.nil? }
+      uri = URI(base_url + path + (params.empty? ? "" : "?" + URI.encode_www_form(params)))
+      headers = { "Accept" => "application/json", "User-Agent" => user_agent }
+      data = nil
+      unless body.nil?
+        headers["Content-Type"] = "application/json"
+        data = JSON.generate(body)
+      end
+
+      attempt = 0
+      loop do
+        status, retry_after_header, payload = send_request(method, uri, headers, data)
+        return payload if status >= 200 && status < 300
+
+        retry_after = DannyKeane.parse_retry_after(retry_after_header, Time.now.to_f)
+        wait = retry_after.nil? ? 2**attempt : retry_after
+        if status == 429 && attempt < max_retries && wait <= max_retry_delay
+          sleep(wait)
+          attempt += 1
+          next
+        end
+        raise ApiError.new(status, payload, retry_after)
+      end
+    end
+
+    def send_request(method, uri, headers, data)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      request = (method == "POST" ? Net::HTTP::Post : Net::HTTP::Get).new(uri, headers)
+      request.body = data unless data.nil?
+      response = http.start { |connection| connection.request(request) }
+      [response.code.to_i, response["Retry-After"], DannyKeane.parse_body(response.body)]
+    rescue *NETWORK_ERRORS => error
+      raise ConnectionError, "#{error.message} (#{error.class})"
+    end
+  end
+
+  # The response body as JSON, or the raw text when it isn't; nil when empty.
+  def self.parse_body(raw)
+    return nil if raw.nil? || raw.empty?
+
+    text = raw.dup.force_encoding(Encoding::UTF_8).scrub
+    begin
+      JSON.parse(text)
+    rescue JSON::ParserError
+      text
+    end
+  end
+
+  # Retry-After as seconds: delta-seconds or an HTTP-date (RFC 9110 section 10.2.3).
+  def self.parse_retry_after(value, now)
+    return nil if value.nil?
+
+    value = value.strip
+    return value.to_f if value.match?(/\A\d+\z/)
+
+    begin
+      at = Time.httpdate(value).to_f
+    rescue ArgumentError
+      return nil
+    end
+    [0.0, (at - now).ceil.to_f].max
+  end
+end

data/lib/dannykeane/errors.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DannyKeane
+  # The machine-readable +code+ of every ErrorResponse the API documents.
+  ERROR_CODES = [
+    "invalid_body",
+    "unknown_event",
+    "missing_message",
+    "empty_message",
+    "message_too_long",
+    "missing_parameters",
+    "invalid_parameter",
+    "rate_limited",
+    "not_configured",
+    "upstream_error",
+    "method_not_allowed",
+    "not_found",
+    "internal_error"
+  ].freeze
+
+  # Base class for everything this SDK raises.
+  class Error < StandardError; end
+
+  # A non-2xx response.
+  #
+  # +code+, +message+ and +hint+ come from the API's ErrorResponse body;
+  # +code+ is nil when the body wasn't one (a proxy's HTML error page, say).
+  # A server newer than this SDK may send a code not in ERROR_CODES.
+  class ApiError < Error
+    attr_reader :status, :code, :hint
+    # Seconds to wait before retrying, from Retry-After, when the response sent one.
+    attr_reader :retry_after
+    # The parsed JSON body, or the raw text when it wasn't JSON.
+    attr_reader :body
+
+    def initialize(status, body, retry_after = nil)
+      parsed = ApiError.error_response?(body) ? body : nil
+      @status = status
+      @code = parsed ? parsed["code"] : nil
+      @hint = parsed ? parsed["hint"] : nil
+      @retry_after = retry_after
+      @body = body
+      super(parsed ? parsed["error"] : "HTTP #{status}")
+    end
+
+    def self.error_response?(body)
+      body.is_a?(Hash) && body["code"].is_a?(String) && body["error"].is_a?(String)
+    end
+  end
+
+  # The API could not be reached: DNS, refused connection, TLS, or timeout.
+  # The underlying exception is on +cause+.
+  class ConnectionError < Error; end
+end

data/lib/dannykeane/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DannyKeane
+  VERSION = "0.1.0"
+end

data/lib/dannykeane.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Official Ruby SDK and CLI for the dannykeane.com public API.
+#
+#   require "dannykeane"
+#   dk = DannyKeane::Client.new
+#   dk.iter_work { |role| puts "#{role["company"]} #{role["years"]}" }
+#
+# Docs: https://dannykeane.com/developers
+module DannyKeane; end
+
+require_relative "dannykeane/version"
+require_relative "dannykeane/errors"
+require_relative "dannykeane/client"

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: dannykeane
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Danny Keane
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2026-10-01 00:00:00.000000000 Z
+dependencies: []
+description: 'Official Ruby SDK and CLI for the dannykeane.com public API: work history,
+  GitHub contributions, live stats, and the Habbo NPC chat. Zero dependencies.'
+email:
+- me@dannykeane.co.uk
+executables:
+- dannykeane
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/dannykeane
+- lib/dannykeane.rb
+- lib/dannykeane/cli.rb
+- lib/dannykeane/client.rb
+- lib/dannykeane/errors.rb
+- lib/dannykeane/version.rb
+homepage: https://dannykeane.com/developers
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://dannykeane.com/developers
+  documentation_uri: https://dannykeane.com/developers/sdk
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Official Ruby SDK and CLI for the dannykeane.com public API.
+test_files: []