# Define the records your agent will interact with.
# Normally you'd only have one record.
#
# A versioned store saves a full db backup per-transaction
# so that you can recover from any step of the process.
# Just trying to save tokens...
class MyStore < VersionedStore::Base
  include AgentC::Store

  record(:summary) do

    # the migration schema is defined in line
    schema do |t|
      # we'll input this data
      t.string(:language)

      # claude will generate this data
      t.string(:input_path)
      t.text(:summary_text)
      t.text(:summary_path)
    end

    # this is the body of your ActiveRecord class
    # add methods here as needed
  end
end

# A "pipeline" processes a single record
class MyPipeline < AgentC::Pipeline
  # The prompts for these steps will
  # live in our prompts.yml file
  agent_step(:analyze_code)
  agent_step(:write_summary_to_file)

  step(:finalize) do
    repo.commit_all("claude: analyzed code")
  end

  # if this pipeline fails, we want to
  # leave the repo in a clean state
  # for the next pipeline.
  on_failure do
    repo.reset_hard_all
  end
end

batch = Batch.new(
  record_type: :summary, # the class name you want to work on
  pipeline: Pipeline, # the Pipeline class you made

  # A batch has a "project" and a "run". These are ways
  # to track Claude usage. Your Batch will have a
  # "project". Each time you call batch.new you get
  # a new "run".
  project: "TemplateProject",

  # We'll set some spending limits. Once these are
  # reached, the Batch will abort.
  max_spend_project: 100.0,
  max_spend_run: 20.0,

  store: {
    class: Store, # the Store class you made
    config: {
      logger: Logger.new("/dev/null"), # a logger for the store
      dir: "/where/you/want/your/store/saved"
    }
  },

  # Where Claude will work
  workspace: {
    dir: "/where/claude/will/be/working",
    env: {
      # available to your tools
      # only used by run_rails_test currently
      SOME_ENV_VAR: "1"
    }
  }

  # If you prefer, you can have the Batch manage
  # some git worktrees for you. It will parallelize
  # your tasks across your worktrees for MAXIMUM
  # TOKEN BURN.
  #
  # Worktrees will be created for you if you are
  # starting a new Batch. If you are continuing an
  # existing Batch (after an error, for example),
  # the worktrees will be left in their current
  # state.
  #
  # You must pass *either* a workspace or a repo
  repo: {
    dir: "/path/to/your/repo",

    # an existing git revision or branch name
    initial_revision: "main",

     # optional: limit Claude to a subdir from your repo
    working_subdir: "./",

    # Where to put your worktrees
    worktrees_root_dir: "/tmp/example-worktrees",

    # Each worktree gets a branch, they'll be suffixed
    # with a counter
    worktree_branch_prefix: "summary-examples",

    # Currently, this defines how many worktrees to
    # create. It's obnoxious I know, but hey, it works.
    worktree_envs: [{}, {}],
  }

  # The claude configuration:
  session: {
    # all chats with claude are saved to a sqlite db.
    # this is separate than your Store's db because
    # why throw anything away. Can be useful for
    # debugging why Claude did what it did
    agent_db_path: "/path/to/your/claude/db.sqlite",
    logger: Logger.new("/dev/null"), # probably use the same logger for everything...
    i18n_path: "/path/to/your/prompts.yml",

    # as you debug your pipeline, you'll probably run it
    # many times. We tag all Claude chat records with a
    # project so you can track costs.
    project: "SomeProject",

    # only available for Bedrock...
    ruby_llm: {
      bedrock_api_key: ENV.fetch("AWS_ACCESS_KEY_ID"),
      bedrock_secret_key: ENV.fetch("AWS_SECRET_ACCESS_KEY"),
      bedrock_session_token: ENV.fetch("AWS_SESSION_TOKEN"),
      bedrock_region: ENV.fetch("AWS_REGION", "us-west-2"),
      default_model: ENV.fetch("LLM_MODEL", "us.anthropic.claude-sonnet-4-5-20250929-v1:0")
    }
  },
)

# WHEW that's a lot of config,

# Now we add some records for processing.
# The batches "store" is just a bunch of
# ActiveRecord classes, but you reference
# them by the name you gave them in the
# store.
#
# We'll add some summary records.
# This seeded data represents the input
# into your pipelines.
#
# Because your batch can be stopped and
# restarted, we need our data creation
# to be idemptotent.
record_1 = (
  batch
    .store
    .summary
    .find_or_create_by!(language: "english")
)
record_2 = (
  batch
    .store
    .summary
    .find_or_create_by!(language: "spanish")
)

# Add the records to be processed.
# add_task is idempotent
batch.add_task(record_1)
batch.add_task(record_2)

batch.call

# See the details of what happened
puts batch.report
# =>
# Summary report:
# Succeeded: 2
# Pending: 0
# Failed: 0
# Run cost: $2.34
# Project total cost: $10.40
# ---
# task: 1 - wrote summary to /tmp/example-worktrees/summary-examples-0/CHAT_TEST_SUMMARY.md
# task: 2 - wrote summary to /tmp/example-worktrees/summary-examples-1/RESUMEN_BASE.md

# Get a more detailed breakdown
cost = batch.cost

# Explore the records created
tasks = batch.store.task.all
summaries = batch.store.summary.all

# see how many versions
puts batch.store.versions.count

# peruse your store:
batch.store.versions[12].summary.count

# restore a prior version
batch.store.version[12].restore

# re-run the batch
batch.call