jules-ruby 0.0.67

data/lib/jules-ruby/client.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'async'
+require 'async/http/internet'
+require 'json'
+require 'uri'
+
+module JulesRuby
+  class Client
+    attr_reader :configuration
+
+    DEFAULT_HEADERS = {
+      'Content-Type' => 'application/json',
+      'Accept' => 'application/json'
+    }.freeze
+
+    def initialize(api_key: nil, base_url: nil, timeout: nil)
+      @configuration = JulesRuby.configuration&.dup || Configuration.new
+
+      @configuration.api_key = api_key if api_key
+      @configuration.base_url = base_url if base_url
+      @configuration.timeout = timeout if timeout
+
+      validate_configuration!
+    end
+
+    # Resource accessors
+    def sources
+      @sources ||= Resources::Sources.new(self)
+    end
+
+    def sessions
+      @sessions ||= Resources::Sessions.new(self)
+    end
+
+    def activities
+      @activities ||= Resources::Activities.new(self)
+    end
+
+    # HTTP methods
+    def get(path, params: {})
+      request(:get, path, params: params)
+    end
+
+    def post(path, body: {})
+      request(:post, path, body: body)
+    end
+
+    def delete(path)
+      request(:delete, path)
+    end
+
+    private
+
+    def validate_configuration!
+      return if configuration.valid?
+
+      raise ConfigurationError,
+            'API key is required. Set JULES_API_KEY environment variable or pass api_key to Client.new'
+    end
+
+    def request(method, path, params: {}, body: nil)
+      url = build_url(path, params)
+
+      Async do
+        internet = Async::HTTP::Internet.new
+
+        begin
+          headers = build_headers
+
+          response = case method
+                     when :get
+                       internet.get(url, headers)
+                     when :post
+                       internet.post(url, headers, body ? JSON.generate(body) : nil)
+                     when :delete
+                       internet.delete(url, headers)
+                     else
+                       raise ArgumentError, "Unsupported HTTP method: #{method}"
+                     end
+
+          handle_response(response)
+        ensure
+          internet.close
+        end
+      end.wait
+    end
+
+    def build_url(path, params)
+      # Ensure base_url ends without slash and path starts with slash
+      base = configuration.base_url.chomp('/')
+      path = "/#{path}" unless path.start_with?('/')
+
+      uri = URI.parse("#{base}#{path}")
+      uri.query = URI.encode_www_form(params.compact) unless params.empty?
+      uri.to_s
+    end
+
+    def build_headers
+      # Optimization: Reuse DEFAULT_HEADERS hash to avoid multiple array allocations per request
+      headers = DEFAULT_HEADERS.dup
+      headers['X-Goog-Api-Key'] = configuration.api_key
+      headers
+    end
+
+    def handle_response(response)
+      body = response.read
+      status = response.status
+
+      case status
+      when 200..299
+        body.nil? || body.empty? ? {} : JSON.parse(body)
+      when 400
+        raise BadRequestError.new('Bad request', status_code: status, response: body)
+      when 401
+        raise AuthenticationError.new('Invalid API key', status_code: status, response: body)
+      when 403
+        raise ForbiddenError.new('Access forbidden', status_code: status, response: body)
+      when 404
+        raise NotFoundError.new('Resource not found', status_code: status, response: body)
+      when 429
+        raise RateLimitError.new('Rate limit exceeded', status_code: status, response: body)
+      when 500..599
+        raise ServerError.new('Server error', status_code: status, response: body)
+      else
+        raise Error.new("Unexpected response: #{status}", status_code: status, response: body)
+      end
+    end
+  end
+end

data/lib/jules-ruby/configuration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  class Configuration
+    attr_accessor :api_key, :base_url, :timeout
+
+    DEFAULT_BASE_URL = 'https://jules.googleapis.com/v1alpha'
+    DEFAULT_TIMEOUT = 30
+
+    def initialize
+      @api_key = ENV.fetch('JULES_API_KEY', nil)
+      @base_url = DEFAULT_BASE_URL
+      @timeout = DEFAULT_TIMEOUT
+    end
+
+    def valid?
+      !api_key.nil? && !api_key.empty?
+    end
+  end
+end

data/lib/jules-ruby/errors.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  # Base error class
+  class Error < StandardError
+    attr_reader :response, :status_code
+
+    def initialize(message = nil, response: nil, status_code: nil)
+      @response = response
+      @status_code = status_code
+      super(message)
+    end
+  end
+
+  # 400 Bad Request
+  class BadRequestError < Error; end
+
+  # 401 Unauthorized
+  class AuthenticationError < Error; end
+
+  # 403 Forbidden
+  class ForbiddenError < Error; end
+
+  # 404 Not Found
+  class NotFoundError < Error; end
+
+  # 429 Too Many Requests
+  class RateLimitError < Error; end
+
+  # 5xx Server Errors
+  class ServerError < Error; end
+
+  # Configuration error
+  class ConfigurationError < Error; end
+end

data/lib/jules-ruby/models/activity.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  module Models
+    class Activity
+      ORIGINATORS = %w[user agent system].freeze
+
+      attr_reader :name, :id, :description, :create_time, :originator, :artifacts,
+                  :agent_messaged, :user_messaged, :plan_generated, :plan_approved,
+                  :progress_updated, :session_completed, :session_failed
+
+      def initialize(data)
+        @name = data['name']
+        @id = data['id']
+        @description = data['description']
+        @create_time = data['createTime']
+        @originator = data['originator']
+        @artifacts = (data['artifacts'] || []).map { |a| Artifact.new(a) }
+
+        # Activity type (union field)
+        @agent_messaged = data['agentMessaged']
+        @user_messaged = data['userMessaged']
+        @plan_generated = parse_plan_generated(data['planGenerated'])
+        @plan_approved = data['planApproved']
+        @progress_updated = data['progressUpdated']
+        @session_completed = data['sessionCompleted']
+        @session_failed = data['sessionFailed']
+      end
+
+      def type
+        if agent_messaged
+          :agent_messaged
+        elsif user_messaged
+          :user_messaged
+        elsif plan_generated
+          :plan_generated
+        elsif plan_approved
+          :plan_approved
+        elsif progress_updated
+          :progress_updated
+        elsif session_completed
+          :session_completed
+        elsif session_failed
+          :session_failed
+        else
+          :unknown
+        end
+      end
+
+      # Type check helpers
+      def agent_message?
+        !agent_messaged.nil?
+      end
+
+      def user_message?
+        !user_messaged.nil?
+      end
+
+      def plan_generated?
+        !plan_generated.nil?
+      end
+
+      def plan_approved?
+        !plan_approved.nil?
+      end
+
+      def progress_update?
+        !progress_updated.nil?
+      end
+
+      def session_completed?
+        !session_completed.nil?
+      end
+
+      def session_failed?
+        !session_failed.nil?
+      end
+
+      def from_agent?
+        originator == 'agent'
+      end
+
+      def from_user?
+        originator == 'user'
+      end
+
+      def from_system?
+        originator == 'system'
+      end
+
+      # Content helpers
+      def message
+        agent_messaged&.dig('agentMessage') || user_messaged&.dig('userMessage')
+      end
+
+      def plan
+        plan_generated
+      end
+
+      def approved_plan_id
+        plan_approved&.dig('planId')
+      end
+
+      def progress_title
+        progress_updated&.dig('title')
+      end
+
+      def progress_description
+        progress_updated&.dig('description')
+      end
+
+      def failure_reason
+        session_failed&.dig('reason')
+      end
+
+      def to_h
+        {
+          name: name,
+          id: id,
+          description: description,
+          create_time: create_time,
+          originator: originator,
+          type: type,
+          artifacts: artifacts.map(&:to_h)
+        }
+      end
+
+      private
+
+      def parse_plan_generated(data)
+        return nil unless data
+
+        data['plan'] ? Plan.new(data['plan']) : nil
+      end
+    end
+  end
+end

data/lib/jules-ruby/models/artifact.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  module Models
+    class Artifact
+      attr_reader :change_set, :media, :bash_output
+
+      def initialize(data)
+        @change_set = data['changeSet']
+        @media = data['media']
+        @bash_output = data['bashOutput']
+      end
+
+      def type
+        if change_set
+          :change_set
+        elsif media
+          :media
+        elsif bash_output
+          :bash_output
+        else
+          :unknown
+        end
+      end
+
+      # ChangeSet helpers
+      def source
+        change_set&.dig('source')
+      end
+
+      def git_patch
+        change_set&.dig('gitPatch')
+      end
+
+      def unidiff_patch
+        git_patch&.dig('unidiffPatch')
+      end
+
+      def base_commit_id
+        git_patch&.dig('baseCommitId')
+      end
+
+      def suggested_commit_message
+        git_patch&.dig('suggestedCommitMessage')
+      end
+
+      # Media helpers
+      def media_data
+        media&.dig('data')
+      end
+
+      def media_mime_type
+        media&.dig('mimeType')
+      end
+
+      # BashOutput helpers
+      def bash_command
+        bash_output&.dig('command')
+      end
+
+      def bash_output_text
+        bash_output&.dig('output')
+      end
+
+      def bash_exit_code
+        bash_output&.dig('exitCode')
+      end
+
+      def to_h
+        {
+          change_set: change_set,
+          media: media,
+          bash_output: bash_output
+        }
+      end
+    end
+  end
+end

data/lib/jules-ruby/models/github_branch.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  module Models
+    class GitHubBranch
+      attr_reader :display_name
+
+      def initialize(data)
+        @display_name = data['displayName']
+      end
+
+      def to_h
+        { display_name: display_name }
+      end
+    end
+  end
+end

data/lib/jules-ruby/models/github_repo.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  module Models
+    class GitHubRepo
+      attr_reader :owner, :repo, :is_private, :default_branch, :branches
+
+      def initialize(data)
+        @owner = data['owner']
+        @repo = data['repo']
+        @is_private = data['isPrivate']
+        @default_branch = data['defaultBranch'] ? GitHubBranch.new(data['defaultBranch']) : nil
+        @branches = (data['branches'] || []).map { |b| GitHubBranch.new(b) }
+      end
+
+      def to_h
+        {
+          owner: owner,
+          repo: repo,
+          is_private: is_private,
+          default_branch: default_branch&.to_h,
+          branches: branches.map(&:to_h)
+        }
+      end
+
+      def full_name
+        "#{owner}/#{repo}"
+      end
+    end
+  end
+end

data/lib/jules-ruby/models/plan.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  module Models
+    class Plan
+      attr_reader :id, :steps, :create_time
+
+      def initialize(data)
+        @id = data['id']
+        @steps = (data['steps'] || []).map { |s| PlanStep.new(s) }
+        @create_time = data['createTime']
+      end
+
+      def to_h
+        {
+          id: id,
+          steps: steps.map(&:to_h),
+          create_time: create_time
+        }
+      end
+    end
+  end
+end

data/lib/jules-ruby/models/plan_step.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  module Models
+    class PlanStep
+      attr_reader :id, :title, :description, :index
+
+      def initialize(data)
+        @id = data['id']
+        @title = data['title']
+        @description = data['description']
+        @index = data['index']
+      end
+
+      def to_h
+        {
+          id: id,
+          title: title,
+          description: description,
+          index: index
+        }
+      end
+    end
+  end
+end

data/lib/jules-ruby/models/pull_request.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  module Models
+    class PullRequest
+      attr_reader :url, :title, :description
+
+      def initialize(data)
+        @url = data['url']
+        @title = data['title']
+        @description = data['description']
+      end
+
+      def to_h
+        {
+          url: url,
+          title: title,
+          description: description
+        }
+      end
+    end
+  end
+end

data/lib/jules-ruby/models/session.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  module Models
+    class Session
+      # Session states
+      STATES = %w[
+        STATE_UNSPECIFIED
+        QUEUED
+        PLANNING
+        AWAITING_PLAN_APPROVAL
+        AWAITING_USER_FEEDBACK
+        IN_PROGRESS
+        PAUSED
+        FAILED
+        COMPLETED
+      ].freeze
+
+      # Automation modes
+      AUTOMATION_MODES = %w[
+        AUTOMATION_MODE_UNSPECIFIED
+        AUTO_CREATE_PR
+      ].freeze
+
+      attr_reader :name, :id, :prompt, :title, :source_context, :state,
+                  :url, :outputs, :create_time, :update_time,
+                  :require_plan_approval, :automation_mode
+
+      def initialize(data)
+        @name = data['name']
+        @id = data['id']
+        @prompt = data['prompt']
+        @title = data['title']
+        @source_context = data['sourceContext'] ? SourceContext.new(data['sourceContext']) : nil
+        @state = data['state']
+        @url = data['url']
+        @create_time = data['createTime']
+        @update_time = data['updateTime']
+        @require_plan_approval = data['requirePlanApproval']
+        @automation_mode = data['automationMode']
+        @outputs = parse_outputs(data['outputs'])
+      end
+
+      def to_h
+        {
+          name: name,
+          id: id,
+          prompt: prompt,
+          title: title,
+          source_context: source_context&.to_h,
+          state: state,
+          url: url,
+          outputs: outputs.map(&:to_h),
+          create_time: create_time,
+          update_time: update_time
+        }
+      end
+
+      # State check helpers
+      def queued?
+        state == 'QUEUED'
+      end
+
+      def planning?
+        state == 'PLANNING'
+      end
+
+      def awaiting_plan_approval?
+        state == 'AWAITING_PLAN_APPROVAL'
+      end
+
+      def awaiting_user_feedback?
+        state == 'AWAITING_USER_FEEDBACK'
+      end
+
+      def in_progress?
+        state == 'IN_PROGRESS'
+      end
+
+      def paused?
+        state == 'PAUSED'
+      end
+
+      def failed?
+        state == 'FAILED'
+      end
+
+      def completed?
+        state == 'COMPLETED'
+      end
+
+      def active?
+        %w[QUEUED PLANNING AWAITING_PLAN_APPROVAL AWAITING_USER_FEEDBACK IN_PROGRESS].include?(state)
+      end
+
+      private
+
+      def parse_outputs(outputs_data)
+        return [] unless outputs_data
+
+        outputs_data.map do |output|
+          if output['pullRequest']
+            PullRequest.new(output['pullRequest'])
+          else
+            output
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jules-ruby/models/source.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  module Models
+    class Source
+      attr_reader :name, :id, :github_repo
+
+      def initialize(data)
+        @name = data['name']
+        @id = data['id']
+        @github_repo = data['githubRepo'] ? GitHubRepo.new(data['githubRepo']) : nil
+      end
+
+      def to_h
+        {
+          name: name,
+          id: id,
+          github_repo: github_repo&.to_h
+        }
+      end
+    end
+  end
+end

data/lib/jules-ruby/models/source_context.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module JulesRuby
+  module Models
+    class SourceContext
+      attr_reader :source, :github_repo_context
+
+      def initialize(data)
+        @source = data['source']
+        @github_repo_context = data['githubRepoContext']
+      end
+
+      def starting_branch
+        github_repo_context&.dig('startingBranch')
+      end
+
+      def to_h
+        {
+          source: source,
+          github_repo_context: github_repo_context
+        }
+      end
+
+      # Build a SourceContext hash for API requests
+      def self.build(source:, starting_branch:)
+        {
+          'source' => source,
+          'githubRepoContext' => {
+            'startingBranch' => starting_branch
+          }
+        }
+      end
+    end
+  end
+end