Sublayer

When defining a Sublayer::Generator, use the llm_output_adapter directive to instruct the LLM on the specific structure of the data it should return. This ensures the LLM output is parsed into a predictable format.

Available adapter types include:

• :named_strings: Returns a single object with specific named attributes.
• :list_of_named_strings: Returns an array of objects, where each object has named attributes.
• :list_of_strings: Returns an array of simple strings.
• :single_string: Returns a single string.
• :single_integer: Returns a single integer.
• :string_selection_from_list: Returns a single string that must be chosen from a provided list of options.

# Example: Generating a list of movie reviews with specific attributes
llm_output_adapter type: :list_of_named_strings,
  name: "review_summaries",
  description: "List of movie reviews",
  item_name: "review",
  attributes: [
    { name: "movie_title", description: "The title of the movie" },
    { name: "reviewer_name", description: "The name of the reviewer" },
    { name: "rating", description: "The rating given by the reviewer (out of 5 stars)" },
    { name: "brief_comment", description: "A brief summary of the movie" }
  ]

A Sublayer agent is a Ruby-based DSL designed to define a feedback loop for an AI agent. Agents run as daemons, triggered by specific events, and iteratively execute steps to reach a defined goal while checking their status along the way.

The DSL consists of four primary components:

1. trigger: Defines what starts the agent. Built-in triggers include trigger_on_files_changed. Custom triggers can be created by subclassing Sublayer::Triggers::Base, implementing an initialize method, and a setup(agent) method that calls activate(agent) when conditions are met.
2. goal: A block that returns a boolean indicating whether the agent's objective has been achieved.
3. check_status: A method used to examine the state of the world or update the goal condition to monitor progress.
4. step: The core execution method. This method encapsulates the logic used to work toward the goal, typically leveraging Sublayer::Actions (to interact with the outside world) and Sublayer::Generators (to make LLM calls and receive structured data).

Agents interact with the framework using:

• Sublayer::Actions: For side effects like saving files, making API calls, or retrieving data.
• Sublayer::Generators: For structured LLM interactions.

To create a custom Generator in Sublayer, inherit from Sublayer::Generators::Base. You must implement the prompt method to define the instructions sent to the LLM. You can also use the llm_output_adapter macro to define how the LLM's response should be structured and named in the output.

Note that the generate method can be overridden to call super or add custom logic, and the initialize method is used to capture input data required for the prompt.

module YourProjectName
  module Generators
    class ExampleGenerator < Sublayer::Generators::Base
      # Define how the LLM output is mapped
      llm_output_adapter type: :single_string,
        name: "generated_text",
        description: "A simple generated text"

      def initialize(input:)
        @input = input
      end

      def generate
        super
      end

      def prompt
        <<-"PROMPT"
          Generate a simple story based on this input: #{@input}
        PROMPT
      end
    end
  end
end

Use the sublayer_agent generator to create a new Sublayer agent based on a natural language description and specific logic requirements. The generator uses an LLM to produce a Ruby file containing a Sublayer agent implementation that follows the Sublayer DSL pattern.

To generate an agent, you must provide the following parameters:

• Description: A high-level description of what the agent does.
• Trigger: The condition that starts the agent (e.g., trigger_on_files_changed).
• Goal: The logic (returning a boolean) that defines when the agent has achieved its objective.
• Check Status: The method used to monitor progress toward the goal.
• Step: The method containing the core logic/actions the agent performs to move toward the goal.

# Note: This is a conceptual representation of the generator's required inputs.
# The actual CLI command would be invoked via the sublayer CLI.
sublayer generate sublayer_agent \
  --description "An agent that fixes linting errors" \
  --trigger "trigger_on_files_changed" \
  --goal "lambda { |agent| !agent.has_lint_errors? }" \
  --check_status "check_lint_status" \
  --step "run_autofix_step"