sorbet-baml 0.3.0 → 0.4.0

data/docs-site/src/type-mapping.md

@@ -1,236 +0,0 @@
----
-layout: doc
-title: "Type Mapping Reference"
-description: "Complete mapping between Sorbet types and BAML output. Learn how every Sorbet type converts to efficient BAML format."
----
-
-# Type Mapping Reference
-
-Complete mapping between Sorbet types and BAML output for autonomous LLM workflows. All listed types are **fully supported** with automatic field descriptions.
-
-## Basic Types
-
-| Sorbet Type | BAML Output | Example |
-|-------------|-------------|---------|
-| `String` | `string` | `name string` |
-| `Integer` | `int` | `age int` |
-| `Float` | `float` | `price float` |
-| `T::Boolean` | `bool` | `active bool` |
-| `NilClass` | `null` | `null` |
-| `Symbol` | `string` | `status string` |
-| `Date/DateTime/Time` | `string` | `created_at string` |
-
-## Optional Types (T.nilable)
-
-| Sorbet Type | BAML Output | Example |
-|-------------|-------------|---------|
-| `T.nilable(String)` | `string?` | `email string?` |
-| `T.nilable(Integer)` | `int?` | `age int?` |
-| `T.nilable(MyStruct)` | `MyStruct?` | `address Address?` |
-
-## Collection Types
-
-| Sorbet Type | BAML Output | Example |
-|-------------|-------------|---------|
-| `T::Array[String]` | `string[]` | `tags string[]` |
-| `T::Array[Integer]` | `int[]` | `scores int[]` |
-| `T::Array[MyStruct]` | `MyStruct[]` | `addresses Address[]` |
-
-## Hash/Map Types
-
-| Sorbet Type | BAML Output | Example |
-|-------------|-------------|---------|
-| `T::Hash[String, String]` | `map<string, string>` | `metadata map<string, string>` |
-| `T::Hash[String, Integer]` | `map<string, int>` | `counts map<string, int>` |
-| `T::Hash[Symbol, String]` | `map<string, string>` | `config map<string, string>` |
-
-## Union Types (T.any)
-
-| Sorbet Type | BAML Output | Example |
-|-------------|-------------|---------|
-| `T.any(String, Integer)` | `string \| int` | `value string \| int` |
-| `T.any(String, Integer, Float)` | `string \| int \| float` | `mixed string \| int \| float` |
-| `T.nilable(T.any(String, Integer))` | `(string \| int)?` | `optional (string \| int)?` |
-
-## Complex Collection Types
-
-| Sorbet Type | BAML Output | Example |
-|-------------|-------------|---------|
-| `T::Array[T.any(String, Integer)]` | `(string \| int)[]` | `mixed_array (string \| int)[]` |
-| `T::Hash[String, T.any(String, Integer)]` | `map<string, string \| int>` | `settings map<string, string \| int>` |
-| `T::Hash[String, T::Array[String]]` | `map<string, string[]>` | `labels map<string, string[]>` |
-
-## Structured Types
-
-### T::Struct to BAML Classes (Research Workflow Example)
-
-```ruby
-class ConfidenceLevel < T::Enum
-  enums do
-    # Low confidence, requires further verification
-    Low = new('low')
-    # High confidence, strongly supported by evidence
-    High = new('high')
-  end
-end
-
-class ResearchFindings < T::Struct
-  # Detailed research findings and analysis
-  const :findings, String
-  # Key actionable insights extracted
-  const :key_insights, T::Array[String]
-  # Assessment of evidence quality
-  const :evidence_quality, ConfidenceLevel
-  # Confidence score (1-10 scale)
-  const :confidence_score, Integer
-end
-```
-
-```ruby
-ResearchFindings.to_baml
-```
-
-**Generated BAML:**
-```baml
-enum ConfidenceLevel {
-  "low" @description("Low confidence, requires further verification")
-  "high" @description("High confidence, strongly supported by evidence")
-}
-
-class ResearchFindings {
-  findings string @description("Detailed research findings and analysis")
-  key_insights string[] @description("Key actionable insights extracted")
-  evidence_quality ConfidenceLevel @description("Assessment of evidence quality")
-  confidence_score int @description("Confidence score (1-10 scale)")
-}
-```
-
-### T::Enum to BAML Enums (Task Classification)
-
-```ruby
-class TaskType < T::Enum
-  enums do
-    # Literature review and information gathering
-    Research = new('research')
-    # Data analysis and statistical interpretation
-    Analysis = new('analysis')
-    # Combining multiple sources into coherent insights
-    Synthesis = new('synthesis')
-  end
-end
-
-class ResearchTask < T::Struct
-  # Clear description of the research objective
-  const :objective, String
-  # Type of research task to be performed
-  const :task_type, TaskType
-end
-```
-
-```ruby
-[TaskType, ResearchTask].map(&:to_baml).join("\n\n")
-```
-
-**Generated BAML:**
-```baml
-enum TaskType {
-  "research" @description("Literature review and information gathering")
-  "analysis" @description("Data analysis and statistical interpretation")
-  "synthesis" @description("Combining multiple sources into coherent insights")
-}
-
-class ResearchTask {
-  objective string @description("Clear description of the research objective")
-  task_type TaskType @description("Type of research task to be performed")
-}
-```
-
-### Complex Real-World Example (Autonomous Research Agent)
-
-```ruby
-class ComplexityLevel < T::Enum
-  enums do
-    # Basic analysis requiring straightforward research
-    Basic = new('basic')
-    # Advanced analysis requiring deep domain expertise
-    Advanced = new('advanced')
-  end
-end
-
-class TaskDecomposition < T::Struct
-  # The main research topic being investigated
-  const :research_topic, String
-  # Target complexity level for the decomposition
-  const :complexity_level, ComplexityLevel
-  # Autonomously generated list of research subtasks
-  const :subtasks, T::Array[String]
-  # Strategic priority rankings (1-5 scale) for each subtask
-  const :priority_order, T::Array[Integer]
-  # Task dependency relationships for optimal sequencing
-  const :dependencies, T::Array[String]
-  # Key-value metadata for agent coordination
-  const :agent_metadata, T::Hash[String, T.any(String, Integer)]
-end
-```
-
-```ruby
-[ComplexityLevel, TaskDecomposition].map(&:to_baml).join("\n\n")
-```
-
-**Generated BAML:**
-```baml
-enum ComplexityLevel {
-  "basic" @description("Basic analysis requiring straightforward research")
-  "advanced" @description("Advanced analysis requiring deep domain expertise")
-}
-
-class TaskDecomposition {
-  research_topic string @description("The main research topic being investigated")
-  complexity_level ComplexityLevel @description("Target complexity level for the decomposition")
-  subtasks string[] @description("Autonomously generated list of research subtasks")
-  priority_order int[] @description("Strategic priority rankings (1-5 scale) for each subtask")
-  dependencies string[] @description("Task dependency relationships for optimal sequencing")
-  agent_metadata map<string, string | int> @description("Key-value metadata for agent coordination")
-}
-```
-
-## Advanced Features
-
-### Dependency Management
-
-```ruby
-# Dependencies automatically included with smart defaults
-TaskDecomposition.to_baml
-# Outputs ComplexityLevel enum, then TaskDecomposition class in correct order
-```
-
-### Field Descriptions (Included by Default)
-
-```ruby
-# Smart defaults extract field descriptions from comments
-TaskDecomposition.to_baml
-# Outputs BAML with @description() annotations for LLM context
-```
-
-### Custom Formatting
-
-```ruby
-# Smart defaults include dependencies and descriptions automatically
-TaskDecomposition.to_baml(indent_size: 4)
-# Disable features if needed:
-TaskDecomposition.to_baml(include_descriptions: false)
-```
-
-## ✅ Completed Features
-
-- ✅ `T::Struct` → `class Name { ... }` with field descriptions
-- ✅ `T::Enum` → `enum Name { ... }` with value descriptions
-- ✅ Automatic dependency resolution and ordering
-- ✅ Smart defaults (descriptions and dependencies enabled)
-- ✅ Full type safety with Sorbet type checking
-
-## Future Enhancements (Optional)
-
-- `T.type_alias` → `type Name = ...`
-- Custom naming strategies (snake_case ↔ camelCase)
-- Self-referential type handling

data/docs-site/tailwind.config.js

@@ -1,85 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-module.exports = {
-  content: [
-    "./src/**/*.{html,md,liquid,erb}",
-    "./frontend/**/*.js",
-  ],
-  darkMode: 'media',
-  theme: {
-    extend: {
-      typography: {
-        DEFAULT: {
-          css: {
-            maxWidth: 'none',
-            color: 'inherit',
-            a: {
-              color: '#3b82f6',
-              textDecoration: 'underline',
-              fontWeight: '500',
-            },
-            '[class~="lead"]': {
-              color: 'inherit',
-            },
-            strong: {
-              color: 'inherit',
-            },
-            'ol > li::before': {
-              color: 'inherit',
-            },
-            'ul > li::before': {
-              backgroundColor: 'currentColor',
-            },
-            hr: {
-              borderColor: 'currentColor',
-              opacity: 0.3,
-            },
-            blockquote: {
-              color: 'inherit',
-              borderLeftColor: 'currentColor',
-              opacity: 0.8,
-            },
-            h1: {
-              color: 'inherit',
-            },
-            h2: {
-              color: 'inherit',
-            },
-            h3: {
-              color: 'inherit',
-            },
-            h4: {
-              color: 'inherit',
-            },
-            'figure figcaption': {
-              color: 'inherit',
-            },
-            code: {
-              color: 'inherit',
-              backgroundColor: 'rgba(156, 163, 175, 0.2)',
-              padding: '0.125rem 0.25rem',
-              borderRadius: '0.25rem',
-              fontWeight: '400',
-            },
-            'code::before': {
-              content: '""',
-            },
-            'code::after': {
-              content: '""',
-            },
-            pre: {
-              backgroundColor: '#1f2937',
-              color: '#f9fafb',
-            },
-            'pre code': {
-              backgroundColor: 'transparent',
-              color: 'inherit',
-            },
-          },
-        },
-      },
-    },
-  },
-  plugins: [
-    require('@tailwindcss/typography'),
-  ],
-}

data/sorbet/config

@@ -1,6 +0,0 @@
---dir
-.
---ignore=tmp/
---ignore=vendor/
---ignore=docs-site/
---ignore=docs-output/

data/sorbet/rbi/annotations/.gitattributes

@@ -1 +0,0 @@
-**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/rainbow.rbi

@@ -1,269 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This file was pulled from a central RBI files repository.
-# Please run `bin/tapioca annotations` to update it.
-
-module Rainbow
-  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
-  sig { returns(T::Boolean) }
-  attr_accessor :enabled
-
-  class Color
-    sig { returns(Symbol) }
-    attr_reader :ground
-
-    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
-    def self.build(ground, values); end
-
-    sig { params(hex: String).returns([Integer, Integer, Integer]) }
-    def self.parse_hex_color(hex); end
-
-    class Indexed < Rainbow::Color
-      sig { returns(Integer) }
-      attr_reader :num
-
-      sig { params(ground: Symbol, num: Integer).void }
-      def initialize(ground, num); end
-
-      sig { returns(T::Array[Integer]) }
-      def codes; end
-    end
-
-    class Named < Rainbow::Color::Indexed
-      NAMES = T.let(nil, T::Hash[Symbol, Integer])
-
-      sig { params(ground: Symbol, name: Symbol).void }
-      def initialize(ground, name); end
-
-      sig { returns(T::Array[Symbol]) }
-      def self.color_names; end
-
-      sig { returns(String) }
-      def self.valid_names; end
-    end
-
-    class RGB < Rainbow::Color::Indexed
-      sig { returns(Integer) }
-      attr_reader :r, :g, :b
-
-      sig { params(ground: Symbol, values: Integer).void }
-      def initialize(ground, *values); end
-
-      sig { returns(T::Array[Integer]) }
-      def codes; end
-
-      sig { params(value: Numeric).returns(Integer) }
-      def self.to_ansi_domain(value); end
-    end
-
-    class X11Named < Rainbow::Color::RGB
-      include Rainbow::X11ColorNames
-
-      sig { params(ground: Symbol, name: Symbol).void }
-      def initialize(ground, name); end
-
-      sig { returns(T::Array[Symbol]) }
-      def self.color_names; end
-
-      sig { returns(String) }
-      def self.valid_names; end
-    end
-  end
-
-  sig { returns(Wrapper) }
-  def self.global; end
-
-  sig { returns(T::Boolean) }
-  def self.enabled; end
-
-  sig { params(value: T::Boolean).returns(T::Boolean) }
-  def self.enabled=(value); end
-
-  sig { params(string: String).returns(String) }
-  def self.uncolor(string); end
-
-  class NullPresenter < String
-    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
-    def color(*values); end
-
-    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
-    def foreground(*values); end
-
-    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
-    def fg(*values); end
-
-    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
-    def background(*values); end
-
-    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
-    def bg(*values); end
-
-    sig { returns(NullPresenter) }
-    def reset; end
-
-    sig { returns(NullPresenter) }
-    def bright; end
-
-    sig { returns(NullPresenter) }
-    def faint; end
-
-    sig { returns(NullPresenter) }
-    def italic; end
-
-    sig { returns(NullPresenter) }
-    def underline; end
-
-    sig { returns(NullPresenter) }
-    def blink; end
-
-    sig { returns(NullPresenter) }
-    def inverse; end
-
-    sig { returns(NullPresenter) }
-    def hide; end
-
-    sig { returns(NullPresenter) }
-    def cross_out; end
-
-    sig { returns(NullPresenter) }
-    def black; end
-
-    sig { returns(NullPresenter) }
-    def red; end
-
-    sig { returns(NullPresenter) }
-    def green; end
-
-    sig { returns(NullPresenter) }
-    def yellow; end
-
-    sig { returns(NullPresenter) }
-    def blue; end
-
-    sig { returns(NullPresenter) }
-    def magenta; end
-
-    sig { returns(NullPresenter) }
-    def cyan; end
-
-    sig { returns(NullPresenter) }
-    def white; end
-
-    sig { returns(NullPresenter) }
-    def bold; end
-
-    sig { returns(NullPresenter) }
-    def dark; end
-
-    sig { returns(NullPresenter) }
-    def strike; end
-  end
-
-  class Presenter < String
-    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
-
-    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
-    def color(*values); end
-
-    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
-    def foreground(*values); end
-
-    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
-    def fg(*values); end
-
-    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
-    def background(*values); end
-
-    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
-    def bg(*values); end
-
-    sig { returns(Presenter) }
-    def reset; end
-
-    sig { returns(Presenter) }
-    def bright; end
-
-    sig { returns(Presenter) }
-    def faint; end
-
-    sig { returns(Presenter) }
-    def italic; end
-
-    sig { returns(Presenter) }
-    def underline; end
-
-    sig { returns(Presenter) }
-    def blink; end
-
-    sig { returns(Presenter) }
-    def inverse; end
-
-    sig { returns(Presenter) }
-    def hide; end
-
-    sig { returns(Presenter) }
-    def cross_out; end
-
-    sig { returns(Presenter) }
-    def black; end
-
-    sig { returns(Presenter) }
-    def red; end
-
-    sig { returns(Presenter) }
-    def green; end
-
-    sig { returns(Presenter) }
-    def yellow; end
-
-    sig { returns(Presenter) }
-    def blue; end
-
-    sig { returns(Presenter) }
-    def magenta; end
-
-    sig { returns(Presenter) }
-    def cyan; end
-
-    sig { returns(Presenter) }
-    def white; end
-
-    sig { returns(Presenter) }
-    def bold; end
-
-    sig { returns(Presenter) }
-    def dark; end
-
-    sig { returns(Presenter) }
-    def strike; end
-  end
-
-  class StringUtils
-    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
-    def self.wrap_with_sgr(string, codes); end
-
-    sig { params(string: String).returns(String) }
-    def self.uncolor(string); end
-  end
-
-  VERSION = T.let(nil, String)
-
-  class Wrapper
-    sig { returns(T::Boolean) }
-    attr_accessor :enabled
-
-    sig { params(enabled: T::Boolean).void }
-    def initialize(enabled = true); end
-
-    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
-    def wrap(string); end
-  end
-
-  module X11ColorNames
-    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
-  end
-end
-
-sig { params(string: String).returns(Rainbow::Presenter) }
-def Rainbow(string); end

data/sorbet/rbi/gems/.gitattributes

@@ -1 +0,0 @@
-**/*.rbi linguist-generated=true