jules-ruby

gem 'jules-ruby'

require 'jules-ruby'

JulesRuby.configure do |config|
  config.api_key = 'your_api_key_here'
  config.timeout = 60 # optional, default is 30 seconds
end

client = JulesRuby::Client.new(api_key: 'different_api_key')

require 'jules-ruby'

client = JulesRuby::Client.new

# List sources with pagination
result = client.sources.list(page_size: 10)
result[:sources].each do |source|
  puts "#{source.name}: #{source.github_repo.full_name}"
end

# Get all sources
sources = client.sources.all

# Create a new session
session = client.sessions.create(
  prompt: "Fix the login bug in the authentication module",
  source_context: {
    "source" => "sources/github/myorg/myrepo",
    "githubRepoContext" => { "startingBranch" => "main" }
  },
  title: "Fix Login Bug",
  automation_mode: "AUTO_CREATE_PR"  # optional: auto-create PR when done
)

puts "Session created: #{session.url}"
puts "State: #{session.state}"

# List sessions
result = client.sessions.list(page_size: 10)
result[:sessions].each { |s| puts "#{s.title}: #{s.state}" }

# Get a specific session
session = client.sessions.find("12345678")
# or
session = client.sessions.find("sessions/12345678")

# Check session state
if session.awaiting_plan_approval?
  client.sessions.approve_plan(session.name)
end

# Send a message to the agent
client.sessions.send_message(session.name, prompt: "Can you also add unit tests?")

# Delete a session
client.sessions.destroy(session.name)

# List activities for a session
result = client.activities.list(session.name, page_size: 30)

result[:activities].each do |activity|
  case activity.type
  when :plan_generated
    puts "Plan: #{activity.plan.steps.map(&:title).join(', ')}"
  when :progress_updated
    puts "Progress: #{activity.progress_title}"
  when :session_completed
    puts "Session completed!"
  when :session_failed
    puts "Failed: #{activity.failure_reason}"
  end
end

# Get all activities
activities = client.activities.all(session.name)

session.queued?                 # Waiting to start
session.planning?               # Creating a plan
session.awaiting_plan_approval? # Needs plan approval
session.awaiting_user_feedback? # Waiting for user input
session.in_progress?            # Working on the task
session.completed?              # Finished successfully
session.failed?                 # Failed
session.active?                 # Any non-terminal state

activity.agent_message?    # Agent posted a message
activity.user_message?     # User posted a message
activity.plan_generated?   # A plan was created
activity.plan_approved?    # A plan was approved
activity.progress_update?  # Progress update
activity.session_completed? # Session completed
activity.session_failed?   # Session failed

# Get content based on type
activity.message           # For agent/user messages
activity.plan              # For plan_generated (returns Plan object)
activity.progress_title    # For progress updates
activity.failure_reason    # For session_failed

activity.artifacts.each do |artifact|
  case artifact.type
  when :change_set
    puts "Changes to: #{artifact.source}"
    puts "Commit message: #{artifact.suggested_commit_message}"
  when :bash_output
    puts "Command: #{artifact.bash_command}"
    puts "Output: #{artifact.bash_output_text}"
    puts "Exit code: #{artifact.bash_exit_code}"
  when :media
    puts "Media type: #{artifact.media_mime_type}"
  end
end

begin
  client.sessions.find("nonexistent")
rescue JulesRuby::AuthenticationError => e
  puts "Invalid API key"
rescue JulesRuby::NotFoundError => e
  puts "Session not found"
rescue JulesRuby::RateLimitError => e
  puts "Rate limit exceeded, try again later"
rescue JulesRuby::ServerError => e
  puts "Server error: #{e.message}"
rescue JulesRuby::Error => e
  puts "API error: #{e.message} (status: #{e.status_code})"
end