aura-lang 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b5a53033716e3d07a59c7296c6328f45c7c30a9e39d501a7a5d6ff0593b7d33f
+  data.tar.gz: 1e4d6fa383dde613cb0d900fd5d8fedcacfcfa865bb357a58eb17a5dc18d852b
+SHA512:
+  metadata.gz: cede94d08727f5ff825ced664ad5ff14854919b9bb2b071f0d5099640da4faecedf70592a4c426f08bcf40e76f59839b9c7a315d95fb00bb4168724ef979867c
+  data.tar.gz: 7428d7086f65d52ab169e0ddff72004ef696e451d941105cabfb444fb119b3c0ac24dfece326dacb42ea1053490622cdff4f554a5ca90617ada6667161f007b4

data/CHANGELOG.md

@@ -0,0 +1,154 @@
+# Changelog
+
+All notable changes to Aura are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/), and the project aims to follow
+[Semantic Versioning](https://semver.org/).
+
+## [1.3.0]
+
+A correctness + feature release driven by a full-project audit.
+
+### Fixed
+- **Conv model without an explicit `input shape` no longer emits uncompilable
+  Ruby** (`Conv2d.new(, …)`); channels default to 1.
+- **`train`/`evaluate` on an LLM or text model is now a compile-time error**
+  (it previously generated `<model>_model.train` → NameError).
+- **Transfer models use the correct module `TorchVision::Models`** (was the
+  non-existent `Torchvision::Models`).
+- **Multiple `environment` blocks are rejected** (they redefined `AuraConfig`).
+- **Torch inference routes guard a missing input key** (`halt 400`) and rescue
+  errors as JSON instead of 500-ing with a stack trace.
+
+### Added
+- **Sequence layers**: `layer embedding vocab:, dim:`, `layer lstm units:`,
+  `layer gru units:` (RNNs take the last timestep). Best-effort — compile/stub
+  verified, validate against your torch-rb.
+- **LLM configuration**: `model x from openai "id" do system "…"; temperature 0.7;
+  max_tokens 500 end`, threaded into the OpenAI/Ollama request.
+- **Output post-processing**: `predict(x) as :label` returns class indices
+  (argmax) instead of raw logits.
+- **Automatic `/health` endpoint** for every served app.
+- **CSV datasets**: `train m on "data.csv"` reads a CSV (last column = label).
+- **Type-aware Dockerfiles**: Torch apps now install `torch-rb torchvision
+  red-datasets` and include LibTorch setup guidance; LLM/text apps stay slim.
+
+### Changed
+- Version bumped to 1.3.0. Suite grew to 65 examples (incl. execution tests for
+  sequence models, CSV training, `/health`, and `as :label`).
+
+> Note: new Torch ops (RNNs, scheduler args, CIFAR loader, the Torch Dockerfile)
+> are compile/stub-verified, not run against LibTorch in CI.
+
+## [1.2.2]
+
+### Fixed
+- **Inference now works for CNN models.** Routes reshape the JSON payload to the
+  model's input dims via `aura_input_tensor` and run under `eval` + `no_grad`,
+  instead of passing a bare array straight into a Conv2d (which crashed).
+- **LR schedulers get correct constructor arguments** per type (`StepLR`,
+  `ExponentialLR` → `gamma`, `CosineAnnealingLR` → `t_max`) instead of a
+  hard-coded `step_size:`.
+- **Route paths and HTTP verbs are validated/escaped** — paths are emitted via
+  `inspect` (no broken Ruby on a `'` in the path); unknown verbs are rejected at
+  compile time.
+
+### Added / changed
+- **Training is separated from serving.** Training and evaluation only run in
+  training mode (`aura train <file>`, i.e. `AURA_TRAIN=1`); `aura run` loads
+  weights and serves without retraining on every boot.
+- **Unknown LLM providers are rejected** at compile time (previously any provider
+  silently became OpenAI). Supported: `openai`, `ollama`.
+- **Hardened LLM clients** — connection/read timeouts, non-2xx handling, and
+  rescue around the request.
+- **Hardened auth** — constant-time bearer-token comparison
+  (`Rack::Utils.secure_compare`) and an explicit refusal when `AURA_API_TOKEN`
+  is unset.
+- **`environment device`** is honored: `device :cpu` forces CPU; otherwise the
+  app auto-selects CUDA when available.
+- New `aura train` CLI command; expanded runtime tests now execute the training
+  loop (stubbed Torch) and assert training is skipped while serving.
+
+## [1.2.1]
+
+### Fixed
+- Inline and trailing `# ...` comments are stripped before parsing (previously
+  only full-line comments were). `#` inside string literals is preserved.
+- Numeric literals support scientific notation (`1e-4`) and negative values;
+  string literals support escaped quotes (`\"`).
+- Generated apps start the web server under `aura run` (emit `set :run, true`).
+- Use the correct Torch CUDA API (`Torch::CUDA.available?`).
+- Route handlers read the request payload using the key named in
+  `model.predict(<key>)` rather than a fixed key.
+
+### Added
+- Complete training and evaluation loops: forward/backward/optimizer step,
+  optional accuracy metric, learning-rate scheduler stepping, and an automatic
+  `save weights` call after training.
+- Dataset loading for the bundled red-datasets sets (MNIST, Fashion-MNIST,
+  CIFAR), with a clear error and extension point for other sources.
+  Environment variables are loaded from `.env` via dotenv.
+- Transfer-learning models apply `freeze` / `unfreeze all` to the pretrained
+  backbone and build a classification head from `output units:`.
+- Bearer-token authentication for `authenticate with`
+  (`Authorization: Bearer <token>`).
+- Semantic validation for duplicate model names and duplicate routes.
+- Vercel deployment for LLM-only apps via `aura deploy <file> --target vercel`
+  (generates `vercel.json` and a Rack entrypoint); Torch apps are directed to
+  the container/`Dockerfile` path.
+- Runtime test suite that boots generated apps and exercises their routes.
+
+### Changed
+- The gem version is sourced from `Aura::VERSION` (single source of truth).
+- Added `rake build` / `rake release` and `rake bump:patch|minor|major`.
+- The release workflow runs the full test suite, triggers on version tags, and
+  publishes to RubyGems via Trusted Publishing (OIDC).
+
+## [1.2.0]
+
+This release makes the framework actually implement what it has long advertised.
+Previously the transpiler parsed the DSL but emitted little real code (models
+compiled to an identity `forward`, training/routes/datasets produced nothing,
+and `aura deploy` referenced a method that did not exist). The compiler has been
+rebuilt into a real, modular pipeline.
+
+### Added
+- **Real neural-network code generation.** `neural_network` models now compile
+  to `Torch::NN::Module` subclasses with a genuine `forward` pass. Supported
+  layers: `input shape(...)` (with optional `do ... end` preprocessing block),
+  `input text`, `conv2d`, `maxpool2d`, `batchnorm`, `flatten`, `dense`,
+  `dropout`, and `output`. Tensor shapes are tracked so `Conv2d` in-channels and
+  `Linear` in-features are computed automatically.
+- **Real training loops.** `train` emits optimizer, loss criterion, optional LR
+  scheduler, and an epoch loop. New options: `batch_size`, `metrics`.
+- **Web serving.** `route` blocks compile to classic-Sinatra handlers (with
+  `format :json`, `authenticate with`), and `run web on port:` boots the server.
+- **LLM models.** `model <name> from openai "..."` / `from ollama "..."` compile
+  to HTTP client methods (no training loop emitted for LLM models).
+- **`evaluate <model> on "..."`**, **environment config** (`class AuraConfig`),
+  **dataset** declarations, and model persistence (`save weights to` /
+  `load weights from`).
+- **`Aura.parse`** public entry point and **`Aura.build_docker`** (backs
+  `aura deploy`, generating a `Dockerfile` + `.dockerignore`).
+- **Diagnostics.** Parse failures become `Aura::ParseError` with line/column and
+  a source snippet; a semantic pass raises `Aura::SemanticError` for references
+  to undefined models in `train`/`route`/`evaluate`.
+- **Comment support** (`# ...`) in `.aura` files, plus tolerance for blank lines.
+- New tests: `test_examples.rb` (every example/scaffold transpiles to compilable
+  Ruby) and `test_diagnostics.rb`.
+
+### Changed
+- The compiler was split from a single `lib/aura.rb` into focused modules under
+  `lib/aura/` (`parser`, `transformer`, `analyzer`, `codegen`, `emitter`,
+  `diagnostics`, `docker`, `version`).
+- Code generation uses an indentation-aware emitter instead of string
+  concatenation, and classic Sinatra (`require "sinatra"`).
+- `aura init` now scaffolds a parseable app and reports `Created Aura project`;
+  `aura run <missing>` writes a starter template; CLI output is ASCII-only.
+- `torch-rb` is now an **optional** dependency (required only to run models), so
+  the gem installs and CI passes without LibTorch present.
+- Version is sourced from a single `Aura::VERSION` constant (the CLI banner no
+  longer drifts from the gem version).
+
+### Removed
+- Stray scratch files committed at the repo root and a checked-in `*.gem` build
+  artifact.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 John V Teixido
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,120 @@
+# 🌟 Aura: The Advanced AI Web Framework (v1.3.0)
+
+**A [RootSpace.app](https://rootspace.app) Product**  
+**Founded and Developed by [John V. Teixido](https://github.com/johnvteixido)**
+
+[![Ruby Version](https://img.shields.io/badge/ruby-3.3%2B-brightgreen.svg)](https://ruby-lang.org)
+[![Gem Version](https://img.shields.io/gem/v/aura-lang?color=blue)](https://rubygems.org/gems/aura-lang)
+
+Aura is a **professional-grade AI Web Framework** that allows you to build, train, and deploy advanced AI models in a single declarative file. By combining **Torch-rb**, **Torchvision**, and **Sinatra**, Aura bridges the gap between deep learning research and production web services.
+
+## 🚀 Key Features
+- **Layers**: `conv2d`, `maxpool2d`, `batchnorm`, `dropout`, `dense`, plus
+  sequence layers `embedding`, `lstm`, and `gru`.
+- **Transfer Learning**: Bootstrap with pre-trained architectures (ResNet, etc.)
+  via `transfer from :model_name`, with `freeze`/`unfreeze` and a new head.
+- **Advanced Training**: Declarative LR schedulers (`StepLR`, `ExponentialLR`,
+  `CosineAnnealingLR`), optimizers, metrics, and a `train`/`serve` split.
+- **Datasets**: built-in MNIST / Fashion-MNIST / CIFAR loaders, plus **CSV**
+  (`train m on "data.csv"`).
+- **LLMs**: `from openai` / `from ollama` with a config block (`system`,
+  `temperature`, `max_tokens`).
+- **Serving**: typed JSON routes, bearer-token auth, `predict(...) as :label`
+  post-processing, and an automatic `/health` endpoint.
+- **Model Persistence**: native `save` / `load` weight primitives.
+- **Deployment**: type-aware Dockerfiles and a Vercel target (`aura deploy`).
+
+## 🛠️ Installation
+```bash
+gem install aura-lang
+```
+
+> **Torch is optional.** Parsing, transpiling (`aura check`), and building
+> (`aura build` / `aura deploy`) work out of the box. Training and running
+> models additionally require [`torch-rb`](https://github.com/ankane/torch.rb)
+> and LibTorch: `gem install torch-rb`.
+
+### 🔨 Local Installation (From Source)
+If you are developing Aura or want to use the latest unreleased version:
+```bash
+git clone https://github.com/johnvteixido/aura-lang
+cd aura-lang
+gem build aura-lang.gemspec
+gem install ./aura-lang-1.3.0.gem
+```
+
+## 🧠 Example: Transfer Learning Image API
+Build a professional Image Classifier in seconds:
+
+```aura
+# Scaffolding a production vision API
+environment production do
+  device :cuda
+  log_level :info
+end
+
+model vision transfer from :resnet18 do
+  # Fine-tune the head while keeping features frozen
+  freeze until :layer_4
+  output units: 10, activation: :softmax
+end
+
+train vision on "imagenet-subset" do
+  epochs 20
+  optimizer :adam, learning_rate: 0.0001
+  scheduler :step_lr # Advanced LR scheduling
+end
+
+route "/v1/classify" post do
+  authenticate with :token
+  output prediction from vision.predict(image)
+end
+
+run web on port: 8080
+```
+
+> **What runs out of the box:** `aura check` / `build` / `deploy` transpile this
+> to a standalone Sinatra app with no extra setup. **Training and serving** need
+> [`torch-rb`](https://github.com/ankane/torch.rb) + LibTorch installed.
+> Built-in dataset loading covers the [red-datasets](https://github.com/red-data-tools/red-datasets)
+> sets (MNIST / Fashion-MNIST / CIFAR); for any other dataset, the generated
+> loader raises with a clear hook so you can plug your own in.
+
+## 🏗️ Commands
+- `aura init <name>`: Scaffold a new production project.
+- `aura train <file>`: Train the models, persist weights, then exit.
+- `aura run <file>`: Serve the app (loads saved weights; does **not** retrain).
+- `aura check <file>`: Transpile and preview the generated Ruby.
+- `aura build <file>`: Export to standalone Ruby.
+- `aura deploy <file>`: Generate a production `Dockerfile` (add `--target vercel` for LLM-only apps).
+- `aura console`: Interactive debugging with app context.
+
+> Training and serving are separate: `aura train` runs the `train`/`evaluate`
+> blocks and saves weights; `aura run` loads those weights and serves, so the
+> server never retrains on boot.
+
+## 🚢 Deployment
+- **Torch apps** (neural networks, transfer learning, training) run on a
+  container host (Fly.io, Render, Cloud Run; GPU via Modal or Replicate).
+  `aura deploy <file>` generates a production `Dockerfile`. Torch model servers
+  need LibTorch and a long-lived process, so they are not suited to serverless
+  platforms.
+- **LLM-only / text apps** (`from openai` / `from ollama`) run on Vercel's Ruby
+  runtime via `aura deploy <file> --target vercel`, or on any container host.
+
+## 📈 Roadmap
+- [x] CNN & Convolutional Layers
+- [x] Model Persistence (v1.1)
+- [x] Transfer Learning & Schedulers (v1.2)
+- [x] Sequence layers (Embedding/LSTM/GRU), LLM config, CSV datasets (v1.3)
+- [ ] Distributed Training (v1.4)
+- [ ] Native RAG (Retrieval Augmented Generation) Primitives (v1.5)
+
+## ☕ Support Aura Development
+Aura is an open-source project by RootSpace.app. If you find the framework useful, please consider supporting its development.
+
+**[Support Aura on Stripe (Choose what you pay)](https://donate.stripe.com/9B66oH2hHbci9ZNd5jc7u00)**  
+*All donations go directly towards maintaining the infrastructure and developing new features like v1.4 Distributed Training.*
+
+## 📜 License
+MIT

data/Rakefile

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+begin
+  require "bundler/gem_tasks" # build / install / release from the gemspec
+rescue LoadError
+  # Bundler not available; build/release tasks are skipped but `rake test` works.
+end
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs    << "lib"
+  t.pattern = "tests/test_*.rb"
+  t.verbose = true
+end
+
+task default: :test
+
+# --- Release helpers ---------------------------------------------------------
+# One-command version bumps. `rake bump:patch` rewrites lib/aura/version.rb and
+# stamps a fresh CHANGELOG heading. Then commit, tag vX.Y.Z, and push the tag --
+# the GitHub Action (.github/workflows/ruby-gem-push.yml) publishes the gem.
+VERSION_FILE   = File.expand_path("lib/aura/version.rb", __dir__)
+CHANGELOG_FILE = File.expand_path("CHANGELOG.md", __dir__)
+
+def aura_bump(part)
+  current = File.read(VERSION_FILE)[/VERSION\s*=\s*"([^"]+)"/, 1]
+  major, minor, patch = current.split(".").map(&:to_i)
+  case part
+  when :major then major, minor, patch = major + 1, 0, 0
+  when :minor then minor, patch = minor + 1, 0
+  when :patch then patch += 1
+  end
+  nextv = "#{major}.#{minor}.#{patch}"
+  File.write(VERSION_FILE, File.read(VERSION_FILE).sub(/VERSION\s*=\s*"[^"]+"/, %(VERSION = "#{nextv}")))
+  aura_stamp_changelog(nextv)
+  puts "Bumped #{current} -> #{nextv}"
+  puts %(Next: git commit -am "Release v#{nextv}" && git tag v#{nextv} && git push origin HEAD --tags)
+end
+
+def aura_stamp_changelog(version)
+  return unless File.exist?(CHANGELOG_FILE)
+
+  body = File.read(CHANGELOG_FILE)
+  return if body.include?("## [#{version}]")
+
+  entry = "## [#{version}] - #{Time.now.strftime('%Y-%m-%d')}\n\n- _Describe changes here._\n\n"
+  updated = body =~ /^## \[/ ? body.sub(/^## \[/, entry + "## [") : "#{body}\n#{entry}"
+  File.write(CHANGELOG_FILE, updated)
+end
+
+namespace :bump do
+  desc "Bump patch version (x.y.Z)"
+  task(:patch) { aura_bump(:patch) }
+  desc "Bump minor version (x.Y.0)"
+  task(:minor) { aura_bump(:minor) }
+  desc "Bump major version (X.0.0)"
+  task(:major) { aura_bump(:major) }
+end

data/aura-lang.gemspec

@@ -0,0 +1,29 @@
+require_relative "lib/aura/version"
+
+Gem::Specification.new do |s|
+  s.name        = "aura-lang"
+  s.version     = Aura::VERSION
+  s.summary     = "Aura: The Declarative AI Web Framework. A RootSpace.app product founded and developed by John V. Teixido."
+  s.description = "A professional-grade framework for building AI pipelines and AI-integrated web apps with Ruby and Torch. A RootSpace.app product founded and developed by John V. Teixido."
+  s.authors     = ["John V. Teixido"]
+  s.email       = "john@rootspace.app"
+  s.files       = Dir["{bin,lib,examples}/**/*", "README.md", "CHANGELOG.md", "LICENSE", "Rakefile", "aura-lang.gemspec"]
+  s.homepage    = "https://rootspace.app"
+  s.license     = "MIT"
+  s.required_ruby_version = ">= 3.2"
+  s.executables << "aura"
+
+  # Core dependencies needed to parse, transpile, and serve Aura apps.
+  s.add_dependency "parslet", "~> 2.0"
+  s.add_dependency "sinatra", "~> 4.2"
+  s.add_dependency "puma", ">= 7.2", "< 9.0"
+  s.add_dependency "json", "~> 2.7"
+  s.add_dependency "red-datasets", "~> 0.1"
+  s.add_dependency "dotenv", "~> 3.1"
+
+  # NOTE: `torch-rb` (and the LibTorch native library it binds to) is required
+  # only to *train and run* generated models, not to parse/transpile/build.
+  # It is intentionally an optional runtime dependency so the gem installs in
+  # environments without LibTorch. Install it explicitly to run models:
+  #   gem install torch-rb
+end

data/bin/aura

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Make the gem's own lib reachable when run straight from a checkout
+# (e.g. `ruby bin/aura ...`), not just when installed as a gem.
+lib = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "aura"
+require "fileutils"
+
+# The starter app written by `init` / `run` lives in the library
+# (Aura::STARTER_TEMPLATE) so it can't drift from the grammar.
+STARTER_TEMPLATE = Aura::STARTER_TEMPLATE
+
+def show_welcome
+  puts <<~WELCOME
+    Aura Framework v#{Aura::VERSION}
+    A RootSpace.app Product | Developed by John V. Teixido
+
+    Build, Train, and Deploy AI Apps.
+
+    Usage: aura [command]
+      aura run <file.aura>    - Serve your Aura app (loads weights, no training)
+      aura train <file.aura>  - Train the models, persist weights, then exit
+      aura check <file.aura>  - Transpile and preview generated Ruby
+      aura build <file.aura>  - Export to a standalone Sinatra app
+      aura deploy <file.aura> - Generate deployment assets (--target vercel for LLM apps)
+      aura init <name>        - Scaffold a new project
+      aura console            - Open an interactive console (Pry)
+      aura --help             - Show this help
+  WELCOME
+end
+
+# Run a block, turning Aura compile errors into friendly CLI output.
+def guard
+  yield
+rescue Aura::ParseError, Aura::SemanticError, Aura::DeployError => e
+  warn "Error: #{e.message}"
+  exit 1
+end
+
+# Resolve the deploy target from trailing args: `--target vercel`,
+# `--target=vercel`, or `--vercel`. Defaults to "docker".
+def deploy_target(args)
+  args = Array(args)
+  if (i = args.index("--target")) && args[i + 1]
+    args[i + 1]
+  elsif (flag = args.find { |a| a.start_with?("--target=") })
+    flag.split("=", 2).last
+  elsif args.include?("--vercel")
+    "vercel"
+  else
+    "docker"
+  end
+end
+
+command  = ARGV[0]
+filename = ARGV[1]
+
+if command.nil?
+  show_welcome
+  exit 0
+end
+
+case command
+when "run"
+  if filename && File.exist?(filename)
+    guard { Aura.run_file(filename) }
+  else
+    name = filename || "app.aura"
+    puts "File not found: #{name}. Generating a template..."
+    File.write(name, STARTER_TEMPLATE)
+    puts "Created #{name}. Edit it, then run: aura run #{name}"
+  end
+
+when "train"
+  if filename && File.exist?(filename)
+    ENV["AURA_TRAIN"] = "1" # generated code trains (and saves weights) then exits
+    guard { Aura.run_file(filename) }
+  else
+    warn "File not found: #{filename}."
+    exit 1
+  end
+
+when "check"
+  if filename && File.exist?(filename)
+    guard do
+      code = Aura.transpile(File.read(filename))
+      puts "Transpilation successful"
+      puts code
+    end
+  else
+    warn "File not found: #{filename}."
+    exit 1
+  end
+
+when "build"
+  if filename && File.exist?(filename)
+    guard do
+      out_file = filename.sub(/\.aura\z/, ".rb")
+      File.write(out_file, Aura.transpile(File.read(filename)))
+      puts "Built standalone application: #{out_file}"
+    end
+  else
+    warn "File not found: #{filename}."
+    exit 1
+  end
+
+when "deploy"
+  if filename && File.exist?(filename)
+    guard do
+      case deploy_target(ARGV[2..])
+      when "vercel" then Aura.build_vercel(filename)
+      else               Aura.build_docker(filename)
+      end
+    end
+  else
+    warn "File not found: #{filename}."
+    exit 1
+  end
+
+when "init"
+  project_name = filename
+  if project_name.nil?
+    warn "Please provide a project name."
+    exit 1
+  end
+
+  FileUtils.mkdir_p(File.join(project_name, "models"))
+  FileUtils.mkdir_p(File.join(project_name, "data"))
+  File.write(File.join(project_name, "app.aura"), STARTER_TEMPLATE)
+  puts "Created Aura project: #{project_name}"
+  puts "   Next: cd #{project_name} && aura run app.aura"
+
+when "console"
+  begin
+    require "pry"
+    Pry.start
+  rescue LoadError
+    warn "Pry is not installed. Add it with: gem install pry"
+    exit 1
+  end
+
+when "--help", "-h", "help"
+  show_welcome
+
+else
+  warn "Unknown command: #{command}."
+  exit 1
+end

data/examples/assistant.aura

@@ -0,0 +1,12 @@
+# LLM assistant with a system prompt and sampling controls.
+model assistant from openai "gpt-4o" do
+  system "You are a concise, helpful assistant."
+  temperature 0.3
+  max_tokens 512
+end
+
+route "/chat" post do
+  output prediction from assistant.predict(message) format :json
+end
+
+run web on port: 3000

data/examples/chatbot.aura

@@ -0,0 +1,7 @@
+model chatbot from openai "gpt-4"
+
+route "/chat" post do
+  output prediction from chatbot.predict(message) format :json
+end
+
+run web on port: 3000

data/examples/hello.aura

@@ -0,0 +1,10 @@
+route "/hello" get do
+  output prediction from greeter.predict(input) format :json
+end
+
+model greeter neural_network do
+  input text
+  output greeting "Hello from Aura! 🌟"
+end
+
+run web on port: 3000

data/examples/mnist_classifier.aura

@@ -0,0 +1,36 @@
+dataset "mnist" from huggingface "mnist"
+
+environment production do
+  log_level :info
+  device :cuda
+end
+
+model classifier neural_network do
+  # Input 28x28 grayscale image
+  input shape(28, 28, 1)
+  
+  layer conv2d filters: 32, kernel: 3
+  layer maxpool2d size: 2
+  layer batchnorm
+  layer flatten
+  
+  layer dense units: 128, activation: :relu
+  layer dropout rate: 0.2
+  output units: 10, activation: :softmax
+end
+
+train classifier on "mnist" do
+  epochs 10
+  batch_size 64
+  optimizer :adam, learning_rate: 0.0005
+  loss :cross_entropy
+  metrics :accuracy
+end
+
+evaluate classifier on "mnist/test"
+
+route "/v1/predict" post do
+  output prediction from classifier.predict(image) format :json
+end
+
+run web on port: 3000

data/examples/sentiment.aura

@@ -0,0 +1,13 @@
+# Sentiment classifier: embedding -> LSTM -> 2-class output.
+model sentiment neural_network do
+  layer embedding vocab: 20000, dim: 128
+  layer lstm units: 256
+  layer dropout rate: 0.3
+  output units: 2, activation: :softmax
+end
+
+route "/sentiment" post do
+  output prediction from sentiment.predict(tokens) as :label format :json
+end
+
+run web on port: 3000

data/examples/transfer_api.aura

@@ -0,0 +1,25 @@
+# Transfer-learning image API (mirrors the README example).
+# Scaffolding a production vision API
+environment production do
+  device :cuda
+  log_level :info
+end
+
+model vision transfer from :resnet18 do
+  # Fine-tune the head while keeping features frozen
+  freeze until :layer_4
+  output units: 10, activation: :softmax
+end
+
+train vision on "imagenet-subset" do
+  epochs 20
+  optimizer :adam, learning_rate: 0.0001
+  scheduler :step_lr # Advanced LR scheduling
+end
+
+route "/v1/classify" post do
+  authenticate with :token
+  output prediction from vision.predict(image)
+end
+
+run web on port: 8080