devin_api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c8ff85d6a59c3442dcf00776af4e5b8e80903f2ccdcad81f79db2a89d91cb9f
+  data.tar.gz: 3f14dc6752122758ae1a95915db964bc1812ce58d07afe26a02b45df1ef13457
+SHA512:
+  metadata.gz: c99ddb448b733f01522c47664ecb8dc223792c7728a999cb87536aca2612893a7c989c21b8d89684f30e82df7210529940aed52cffb4b7de7b3a45b226b1dba9
+  data.tar.gz: 239eb0b9069025d187350c853d3c9ebd0bc65606dad01c32b1732fa312279d0e11a605066e823047d3f845accc2d5526ea604bb849f23d79ac4bde912f14ce89

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.0] - 2025-05-18
+
+* Initial version of the Devin API client

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Masato Sugiyama
+
+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,136 @@
+# Devin API Client
+[![Test](https://github.com/smasato/devin_api_client_rb/actions/workflows/rspec.yml/badge.svg)](https://github.com/smasato/devin_api_client_rb/actions/workflows/rspec.yml?query=branch%3Amain)
+
+This Ruby gem is a client for the Devin API.
+
+This gem is not officially supported by Cognition AI, Inc.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'devin_api'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install devin_api
+```
+
+## Usage
+
+### Endpoint-based API
+
+```ruby
+require 'devin_api'
+
+client = DevinApi::Client.new do |config|
+  config.url = 'https://api.devin.ai'
+  config.access_token = 'your_access_token'
+end
+
+# Sessions
+sessions = client.list_sessions(limit: 10)
+puts "Sessions: #{sessions}"
+
+new_session = client.create_session(prompt: 'Build a simple web app')
+session_id = new_session['id']
+puts "Created session: #{session_id}"
+
+session_details = client.get_session(session_id)
+puts "Session details: #{session_details}"
+
+message_response = client.send_message(session_id, message: 'How do I start?')
+puts "Message response: #{message_response}"
+
+# Upload files to a session
+file = File.open('path/to/file.txt')
+upload_response = client.upload_file(file)
+puts "Upload response: #{upload_response}"
+
+# Update session tags
+tags_response = client.update_session_tags(session_id, tags: ['web', 'app'])
+puts "Tags update response: #{tags_response}"
+
+# Secrets
+secrets = client.list_secrets
+puts "Secrets: #{secrets}"
+
+# Knowledge
+knowledge_items = client.list_knowledge
+puts "Knowledge items: #{knowledge_items}"
+
+new_knowledge = client.create_knowledge(
+  name: 'API Documentation',
+  body: 'This is the API documentation for our service.',
+  trigger_description: 'When API documentation is needed'
+)
+knowledge_id = new_knowledge['id']
+puts "Created knowledge: #{knowledge_id}"
+
+# Enterprise (for enterprise customers)
+audit_logs = client.list_audit_logs(start_time: '2023-01-01T00:00:00Z')
+puts "Audit logs: #{audit_logs}"
+
+consumption = client.get_enterprise_consumption(period: 'current_month')
+puts "Consumption: #{consumption}"
+```
+
+### Resource-based API
+
+```ruby
+require 'devin_api'
+
+client = DevinApi::Client.new do |config|
+  config.url = 'https://api.devin.ai'
+  config.access_token = 'your_access_token'
+end
+
+# Resource-based usage
+# Get a collection of sessions
+sessions = client.sessions
+sessions.each do |session|
+  puts "Session ID: #{session.id}, Prompt: #{session[:prompt]}"
+end
+
+# Create a new session
+new_session = client.sessions.create(prompt: 'Build a simple web app')
+puts "Created session: #{new_session.session_id}"
+
+# Get a specific session
+session = client.session('session_id')
+
+# Send a message to the session
+response = session.send_message('How do I start?')
+
+# Upload files to the session
+files = [File.open('path/to/file.txt')]
+upload_response = session.upload_files(files)
+
+# Update session tags
+session.update_tags(['web', 'app'])
+
+# Pagination
+next_page = sessions.next_page
+if next_page
+  next_page.each do |session|
+    puts "Next page session: #{session.id}"
+  end
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/smasato/devin_api_client_rb.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/devin_api/client.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'json'
+
+require 'devin_api/version'
+require 'devin_api/configuration'
+require 'devin_api/endpoints'
+require 'devin_api/collection'
+require 'devin_api/resources/session'
+require 'devin_api/resources/secret'
+require 'devin_api/resources/knowledge'
+require 'devin_api/resources/enterprise'
+require 'devin_api/resources/attachment'
+
+module DevinApi
+  # The top-level class that handles configuration and connection to the Devin API.
+  class Client
+    include DevinApi::Endpoints
+    # @return [Configuration] Config instance
+    attr_reader :config
+
+    # Creates a new {Client} instance and yields {#config}.
+    #
+    # Requires a block to be given.
+    def initialize
+      raise ArgumentError, 'block not given' unless block_given?
+
+      @config = DevinApi::Configuration.new
+      yield config
+
+      check_url
+      set_access_token
+    end
+
+    # Creates a connection if there is none, otherwise returns the existing connection.
+    #
+    # @return [Faraday::Connection] Faraday connection for the client
+    def connection
+      @connection ||= build_connection
+    end
+
+    # Executes a GET request
+    # @param [String] path The path to request
+    # @param [Hash] params Query parameters
+    # @return [Hash] Response body
+    def get(path, params = {})
+      response = connection.get(path, params)
+      parse_response(response)
+    end
+
+    # Executes a POST request
+    # @param [String] path The path to request
+    # @param [Hash] params Body parameters
+    # @return [Hash] Response body
+    def post(path, params = {})
+      response = connection.post(path) do |req|
+        req.body = params.to_json
+      end
+      parse_response(response)
+    end
+
+    # Executes a PUT request
+    # @param [String] path The path to request
+    # @param [Hash] params Body parameters
+    # @return [Hash] Response body
+    def put(path, params = {})
+      response = connection.put(path) do |req|
+        req.body = params.to_json
+      end
+      parse_response(response)
+    end
+
+    # Executes a DELETE request
+    # @param [String] path The path to request
+    # @param [Hash] params Query parameters
+    # @return [Hash] Response body
+    def delete(path, params = {})
+      response = connection.delete(path, params)
+      parse_response(response)
+    end
+
+    protected
+
+    # Called by {#connection} to build a connection.
+    #
+    # Uses middleware according to configuration options.
+    def build_connection
+      Faraday.new(url: config.url) do |conn|
+        # Response middlewares
+        conn.use DevinApi::Middleware::Response::RaiseError
+        conn.response :json, content_type: /\bjson$/
+
+        # Request middlewares
+        conn.request :json
+        conn.request :multipart
+
+        # Authentication
+        conn.headers['Authorization'] = "Bearer #{config.access_token}"
+        conn.headers['User-Agent'] = "DevinApi Ruby Client/#{DevinApi::VERSION}"
+
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    private
+
+    def parse_response(response)
+      return nil if response.status == 204
+      return {} if response.body.nil? || response.body.empty?
+
+      if response.body.is_a?(String) && response.body.start_with?('{', '[')
+        begin
+          JSON.parse(response.body)
+        rescue JSON::ParserError
+          response.body
+        end
+      else
+        response.body
+      end
+    end
+
+    def check_url
+      raise ArgumentError, 'url must be provided' unless config.url
+
+      return if config.url.start_with?('https://')
+
+      raise ArgumentError, 'devin_api is ssl only; url must begin with https://'
+    end
+
+    def set_access_token
+      return if config.access_token
+
+      raise ArgumentError, 'access_token must be provided'
+    end
+
+    def method_missing(method, *args, &)
+      method_name = method.to_s
+
+      if resource_exists?(method_name.singularize)
+        resource_class = resource_class_for(method_name.singularize)
+
+        # Special case for 'knowledge' which is both singular and plural
+        return Collection.new(self, resource_class, args.first || {}) if method_name == 'knowledge'
+
+        if method_name.singularize == method_name
+          id = args.first
+          resource_class.new(self, get("#{resource_class.resource_path}/#{id}"))
+        else
+          Collection.new(self, resource_class, args.first || {})
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      resource_exists?(method.to_s.singularize) || super
+    end
+
+    def resource_class_for(resource_name)
+      class_name = resource_name.capitalize
+      DevinApi::Resources.const_get(class_name) if DevinApi::Resources.const_defined?(class_name)
+    end
+
+    def resource_exists?(resource_name)
+      class_name = resource_name.capitalize
+      DevinApi::Resources.const_defined?(class_name)
+    end
+  end
+end

data/lib/devin_api/collection.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module DevinApi
+  # Collection class for handling resource lists and pagination
+  class Collection
+    include Enumerable
+
+    attr_reader :resource_class, :client, :options, :resources
+
+    def initialize(client, resource_class, options = {})
+      @client = client
+      @resource_class = resource_class
+      @options = options
+
+      # Process array options
+      @options.each do |key, value|
+        @options[key] = value.join(',') if value.is_a?(Array)
+      end
+    end
+
+    def each(&)
+      fetch if @resources.nil?
+      @resources.each(&)
+    end
+
+    def fetch
+      response = client.get(path, @options)
+      resource_key = "#{resource_class.resource_name.downcase}s"
+
+      @resources = if response[resource_key]
+                     response[resource_key].map do |attrs|
+                       resource_class.new(client, attrs)
+                     end
+                   else
+                     []
+                   end
+
+      @next_cursor = response['pagination'] && response['pagination']['next_cursor']
+      @resources
+    end
+
+    def find(options = {})
+      if options[:id]
+        response = client.get("#{path}/#{options[:id]}")
+        resource_class.new(client, response)
+      else
+        self
+      end
+    end
+
+    def next_page
+      return nil unless @next_cursor
+
+      new_options = @options.dup
+      new_options[:cursor] = @next_cursor
+      self.class.new(@client, @resource_class, new_options)
+    end
+
+    def path
+      resource_class.resource_path
+    end
+
+    def create(attributes = {})
+      response = client.post(path, attributes)
+      resource_class.new(client, response)
+    end
+  end
+end

data/lib/devin_api/configuration.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DevinApi
+  # Configuration class for the Devin API client
+  class Configuration
+    # @return [String] The base URL of the Devin API
+    attr_accessor :url
+
+    # @return [String] The access token for authentication
+    attr_accessor :access_token
+
+    # @return [Logger] The logger to use
+    attr_accessor :logger
+
+    # @return [Hash] Additional options to pass to Faraday
+    attr_accessor :options
+
+    def initialize
+      @options = {}
+    end
+  end
+end

data/lib/devin_api/core_ext/inflection.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'inflection'
+
+module DevinApi
+  module CoreExt
+    # String extensions for inflection
+    module StringExtensions
+      def singularize
+        Inflection.singular(self)
+      end
+    end
+  end
+end
+
+String.include DevinApi::CoreExt::StringExtensions

data/lib/devin_api/endpoints/attachment.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DevinApi
+  module Endpoints
+    # Attachment endpoints for the Devin API
+    module Attachment
+      # Upload a file for Devin to work with during sessions
+      # @see https://docs.devin.ai/api-reference/attachments/upload-files-for-devin-to-work-with
+      #
+      # @param [File] file File object to upload
+      # @return [Hash] Response body
+      def upload_file(file)
+        payload = Faraday::UploadIO.new(
+          file.path,
+          file.content_type || 'application/octet-stream',
+          File.basename(file.path)
+        )
+
+        connection.post('/v1/attachments', payload).body
+      end
+    end
+  end
+end

data/lib/devin_api/endpoints/enterprise.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DevinApi
+  module Endpoints
+    # Enterprise endpoints for the Devin API
+    module Enterprise
+      # Get enterprise collection
+      #
+      # @param [Hash] options Query parameters
+      # @return [DevinApi::Collection] Collection of enterprise resources
+      def enterprise(options = {})
+        Collection.new(self, DevinApi::Resources::Enterprise, options)
+      end
+
+      # List all audit logs
+      # @see https://docs.devin.ai/api-reference/audit-logs/list-audit-logs
+      #
+      # @param [Hash] params Query parameters
+      # @option params [Integer] :limit Maximum number of logs to return (default: 100, min: 1)
+      # @option params [String] :before Filter logs before a specific timestamp
+      # @option params [String] :after Filter logs after a specific timestamp
+      # @return [Hash] Response body with audit logs
+      def list_audit_logs(params = {})
+        get('/v1/enterprise/audit-logs', params)
+      end
+
+      # Get enterprise consumption data
+      # @see https://docs.devin.ai/api-reference/enterprise/get-enterprise-consumption-data
+      #
+      # @param [Hash] params Query parameters
+      # @option params [String] :period Period for consumption data (e.g., 'current_month', 'previous_month')
+      # @option params [String] :start_date Start date for custom period (ISO 8601 format)
+      # @option params [String] :end_date End date for custom period (ISO 8601 format)
+      # @return [Hash] Response body with consumption data
+      def get_enterprise_consumption(params = {})
+        get('/v1/enterprise/consumption', params)
+      end
+    end
+  end
+end

data/lib/devin_api/endpoints/knowledge.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DevinApi
+  module Endpoints
+    # Knowledge endpoints for the Devin API
+    module Knowledge
+      # List knowledge
+      # @see https://docs.devin.ai/api-reference/knowledge/list-knowledge
+      #
+      # @param [Hash] params Query parameters
+      # @option params [Integer] :limit Maximum number of knowledge items to return (default: 100, max: 1000)
+      # @option params [Integer] :offset Number of knowledge items to skip for pagination (default: 0)
+      # @return [Hash] Response body with knowledge and folders
+      def list_knowledge(params = {})
+        get('/v1/knowledge', params)
+      end
+
+      # Create knowledge
+      # @see https://docs.devin.ai/api-reference/knowledge/create-knowledge
+      #
+      # @param [Hash] params Body parameters
+      # @option params [String] :body Content of the knowledge (required)
+      # @option params [String] :name Name of the knowledge (required)
+      # @option params [String] :trigger_description Description of when this knowledge should be used (required)
+      # @option params [String] :parent_folder_id ID of the folder that this knowledge is located in
+      # @return [Hash] Response body with the created knowledge
+      def create_knowledge(params = {})
+        post('/v1/knowledge', params)
+      end
+
+      # Update knowledge
+      # @see https://docs.devin.ai/api-reference/knowledge/update-knowledge
+      #
+      # @param [String] knowledge_id The ID of the knowledge to update
+      # @param [Hash] params Body parameters
+      # @option params [String] :body Content of the knowledge
+      # @option params [String] :name Name of the knowledge
+      # @option params [String] :trigger_description Description of when this knowledge should be used
+      # @option params [String] :parent_folder_id ID of the folder that this knowledge is located in
+      # @return [Hash] Response body with the updated knowledge
+      def update_knowledge(knowledge_id, params = {})
+        put("/v1/knowledge/#{knowledge_id}", params)
+      end
+
+      # Delete knowledge
+      # @see https://docs.devin.ai/api-reference/knowledge/delete-knowledge
+      #
+      # @param [String] knowledge_id The ID of the knowledge to delete
+      # @return [nil] Returns nil on success (204 No Content)
+      def delete_knowledge(knowledge_id)
+        delete("/v1/knowledge/#{knowledge_id}")
+      end
+    end
+  end
+end

data/lib/devin_api/endpoints/secrets.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DevinApi
+  module Endpoints
+    # Secrets endpoints for the Devin API
+    module Secrets
+      # List all secrets metadata
+      # @see https://docs.devin.ai/api-reference/sessions/list-secrets
+      #
+      # @param [Hash] params Query parameters
+      # @option params [Integer] :limit Maximum number of secrets to return (default: 100, max: 1000)
+      # @option params [Integer] :offset Number of secrets to skip for pagination (default: 0)
+      # @return [Hash] Response body with secrets metadata (does not return secret values)
+      def list_secrets(params = {})
+        get('/v1/secrets', params)
+      end
+
+      # Delete a secret
+      # @see https://docs.devin.ai/api-reference/sessions/delete-secret
+      #
+      # @param [String] secret_id The ID of the secret to delete
+      # @return [nil] Returns nil on success (204 No Content)
+      def delete_secret(secret_id)
+        delete("/v1/secrets/#{secret_id}")
+      end
+    end
+  end
+end

data/lib/devin_api/endpoints/session.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DevinApi
+  module Endpoints
+    # Session endpoint for the Devin API
+    module Session
+      # Retrieve details about an existing session
+      # @see https://docs.devin.ai/api-reference/sessions/retrieve-details-about-an-existing-session
+      #
+      # @param [String] session_id The ID of the session
+      # @return [Hash] Response body
+      def get_session(session_id)
+        get("/v1/session/#{session_id}")
+      end
+
+      # Send a message to an existing session
+      # @see https://docs.devin.ai/api-reference/sessions/send-a-message-to-an-existing-devin-session
+      #
+      # @param [String] session_id The ID of the session
+      # @param [Hash] params Body parameters
+      # @option params [String] :message The message to send (required)
+      # @return [Hash] Response body
+      def send_message(session_id, params = {})
+        post("/v1/session/#{session_id}/messages", params)
+      end
+
+      # Update session tags
+      # @see https://docs.devin.ai/api-reference/sessions/update-session-tags
+      #
+      # @param [String] session_id The ID of the session
+      # @param [Hash] params Body parameters
+      # @option params [Array<String>] :tags Tags to associate with the session (required)
+      # @return [Hash] Response body
+      def update_session_tags(session_id, params = {})
+        put("/v1/session/#{session_id}/tags", params)
+      end
+    end
+  end
+end

data/lib/devin_api/endpoints/sessions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DevinApi
+  module Endpoints
+    # Sessions endpoints for the Devin API
+    module Sessions
+      # List all sessions
+      # @see https://docs.devin.ai/api-reference/sessions/list-sessions
+      #
+      # @param [Hash] params Query parameters
+      # @option params [Integer] :limit Maximum number of sessions to return (default: 100, max: 1000)
+      # @option params [Integer] :offset Number of sessions to skip for pagination (default: 0)
+      # @option params [Array<String>] :tags Filter sessions by tags
+      # @return [Hash] Response body
+      def list_sessions(params = {})
+        get('/v1/sessions', params)
+      end
+
+      # Create a new session
+      # @see https://docs.devin.ai/api-reference/sessions/create-a-new-devin-session
+      #
+      # @param [Hash] params Body parameters
+      # @option params [String] :prompt The task description for Devin (required)
+      # @option params [String, nil] :snapshot_id ID of a machine snapshot to use
+      # @option params [Boolean, nil] :unlisted Whether the session should be unlisted
+      # @option params [Boolean, nil] :idempotent Enable idempotent session creation
+      # @option params [Integer, nil] :max_acu_limit Maximum ACU limit for the session
+      # @option params [Array<String>, nil] :secret_ids Array of secret IDs to use. If nil, use all secrets. If empty array, use no secrets.
+      # @option params [Array<String>, nil] :knowledge_ids Array of knowledge IDs to use. If nil, use all knowledge. If empty array, use no knowledge.
+      # @option params [Array<String>, nil] :tags Array of tags to add to the session.
+      # @option params [String, nil] :title Custom title for the session. If nil, a title will be generated automatically.
+      # @return [Hash] Response body
+      def create_session(params = {})
+        post('/v1/sessions', params)
+      end
+    end
+  end
+end

data/lib/devin_api/endpoints.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'devin_api/endpoints/sessions'
+require 'devin_api/endpoints/session'
+require 'devin_api/endpoints/secrets'
+require 'devin_api/endpoints/knowledge'
+require 'devin_api/endpoints/enterprise'
+require 'devin_api/endpoints/attachment'
+
+module DevinApi
+  # Endpoints module for the Devin API
+  module Endpoints
+    # Include all endpoint modules
+    def self.included(base)
+      base.include(Sessions)
+      base.include(Session)
+      base.include(Secrets)
+      base.include(Knowledge)
+      base.include(Enterprise)
+      base.include(Attachment)
+    end
+  end
+end

data/lib/devin_api/error.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DevinApi
+  module Error
+    # Base class for all errors
+    class Error < StandardError
+      attr_reader :response
+
+      def initialize(response = nil)
+        @response = response
+        super(build_message)
+      end
+
+      private
+
+      def build_message
+        return response if response.is_a?(String)
+        return nil unless response
+
+        message = "Status: #{response[:status]}"
+
+        message += " - #{response[:body]['error']}" if response[:body].is_a?(Hash) && response[:body]['error']
+
+        message
+      end
+    end
+
+    class ClientError < Error; end
+    class ServerError < Error; end
+    class BadRequest < ClientError; end
+    class Unauthorized < ClientError; end
+    class Forbidden < ClientError; end
+    class NotFound < ClientError; end
+    class RateLimited < ClientError; end
+  end
+end

data/lib/devin_api/middleware/response/raise_error.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DevinApi
+  module Middleware
+    module Response
+      # Middleware for raising errors based on HTTP status
+      class RaiseError < Faraday::Middleware
+        def call(env)
+          @app.call(env).on_complete do |response|
+            handle_error_response(response)
+          end
+        rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e
+          raise DevinApi::Error::ClientError, "Connection error: #{e.message}"
+        end
+
+        private
+
+        def handle_error_response(response)
+          status = response[:status]
+          case status
+          when 400 then raise DevinApi::Error::BadRequest, response
+          when 401 then raise DevinApi::Error::Unauthorized, response
+          when 403 then raise DevinApi::Error::Forbidden, response
+          when 404 then raise DevinApi::Error::NotFound, response
+          when 429 then raise DevinApi::Error::RateLimited, response
+          when 400..499 then raise DevinApi::Error::ClientError, response
+          when 500..599 then raise DevinApi::Error::ServerError, response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/devin_api/resources/attachment.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'devin_api/resources/base'
+
+module DevinApi
+  module Resources
+    # Attachment resource for the Devin API
+    class Attachment < Base
+      def path
+        '/v1/attachments'
+      end
+
+      def upload_file(file)
+        payload = Faraday::UploadIO.new(
+          file.path,
+          file.content_type || 'application/octet-stream',
+          File.basename(file.path)
+        )
+
+        client.connection.post(path, payload).body
+      end
+    end
+  end
+end

data/lib/devin_api/resources/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module DevinApi
+  module Resources
+    # Base class for all API resources
+    class Base
+      attr_reader :client, :attributes
+
+      def initialize(client, attributes = {})
+        @client = client
+        @attributes = attributes
+      end
+
+      def [](key)
+        @attributes[key.to_s] || @attributes[key.to_sym]
+      end
+
+      def []=(key, value)
+        @attributes[key.to_sym] = value
+      end
+
+      def id
+        self[:id]
+      end
+
+      def path
+        "#{self.class.resource_path}/#{id}"
+      end
+
+      def to_hash
+        @attributes.dup
+      end
+
+      def method_missing(method, *_args)
+        if @attributes.key?(method.to_s)
+          @attributes[method.to_s]
+        elsif @attributes.key?(method.to_sym)
+          @attributes[method.to_sym]
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @attributes.key?(method.to_s) || @attributes.key?(method.to_sym) || super
+      end
+
+      class << self
+        def resource_name
+          @resource_name ||= name.split('::').last.downcase
+        end
+
+        def resource_path
+          "/v1/#{resource_name.gsub('_', '-')}s"
+        end
+
+        def create(client, attributes = {})
+          response = client.post(resource_path, attributes)
+          new(client, response)
+        end
+      end
+    end
+  end
+end

data/lib/devin_api/resources/enterprise.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'devin_api/resources/base'
+
+module DevinApi
+  module Resources
+    # Enterprise resource for the Devin API
+    class Enterprise < Base
+      def path
+        '/v1/enterprise'
+      end
+
+      def audit_logs(params = {})
+        client.get("#{path}/audit-logs", params)
+      end
+
+      def consumption(params = {})
+        client.get("#{path}/consumption", params)
+      end
+    end
+  end
+end

data/lib/devin_api/resources/knowledge.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'devin_api/resources/base'
+
+module DevinApi
+  module Resources
+    # Knowledge resource for the Devin API
+    class Knowledge < Base
+      def path
+        "/v1/knowledge/#{id}"
+      end
+
+      def update(attributes = {})
+        client.put(path, attributes)
+      end
+
+      def delete
+        client.delete(path)
+      end
+    end
+  end
+end

data/lib/devin_api/resources/secret.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'devin_api/resources/base'
+
+module DevinApi
+  module Resources
+    # Secret resource for the Devin API
+    class Secret < Base
+      def path
+        "/v1/secrets/#{id}"
+      end
+
+      def delete
+        client.delete(path)
+      end
+    end
+  end
+end

data/lib/devin_api/resources/session.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'devin_api/resources/base'
+
+module DevinApi
+  module Resources
+    # Session resource for the Devin API
+    class Session < Base
+      def path
+        "/v1/session/#{session_id}"
+      end
+
+      def send_message(message)
+        client.post("#{path}/messages", { message: message })
+      end
+
+      def update_tags(tags)
+        client.put("#{path}/tags", { tags: tags })
+      end
+    end
+  end
+end

data/lib/devin_api/version.rb

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

data/lib/devin_api.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module DevinApi; end
+
+require 'faraday'
+require 'faraday/multipart'
+require 'inflection'
+
+require 'devin_api/version'
+require 'devin_api/core_ext/inflection'
+require 'devin_api/error'
+require 'devin_api/middleware/response/raise_error'
+require 'devin_api/client'
+require 'devin_api/endpoints'

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: devin_api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Masato Sugiyama
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: inflection
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Unofficial Ruby client library for the Devin API
+email:
+- public@smasato.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/devin_api.rb
+- lib/devin_api/client.rb
+- lib/devin_api/collection.rb
+- lib/devin_api/configuration.rb
+- lib/devin_api/core_ext/inflection.rb
+- lib/devin_api/endpoints.rb
+- lib/devin_api/endpoints/attachment.rb
+- lib/devin_api/endpoints/enterprise.rb
+- lib/devin_api/endpoints/knowledge.rb
+- lib/devin_api/endpoints/secrets.rb
+- lib/devin_api/endpoints/session.rb
+- lib/devin_api/endpoints/sessions.rb
+- lib/devin_api/error.rb
+- lib/devin_api/middleware/response/raise_error.rb
+- lib/devin_api/resources/attachment.rb
+- lib/devin_api/resources/base.rb
+- lib/devin_api/resources/enterprise.rb
+- lib/devin_api/resources/knowledge.rb
+- lib/devin_api/resources/secret.rb
+- lib/devin_api/resources/session.rb
+- lib/devin_api/version.rb
+homepage: https://github.com/smasato/devin_api_client_rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/smasato/devin_api_client_rb
+  source_code_uri: https://github.com/smasato/devin_api_client_rb
+  changelog_uri: https://github.com/smasato/devin_api_client_rb/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Unofficial Ruby client for the Devin API
+test_files: []