From 35469b1e0dfc5fd88bfa21b9c0b96827990c88f5 Mon Sep 17 00:00:00 2001
From: Alec Thomas <alec@swapoff.org>
Date: Sat, 3 Dec 2022 16:15:00 +1100
Subject: [PATCH] feat: initial commit

---
 .github/workflows/ci.yml      |  27 ++
 .github/workflows/release.yml |  17 +
 .golangci.yml                 |  95 +++++
 .goreleaser.yml               |  37 ++
 COPYING                       |  19 +
 README.md                     | 266 ++++++++++++++
 bin/.go-1.19.3.pkg            |   1 +
 bin/.golangci-lint-1.50.1.pkg |   1 +
 bin/.goreleaser-1.15.0.pkg    |   1 +
 bin/.jq-1.6.pkg               |   1 +
 bin/.reflex-0.3.1.pkg         |   1 +
 bin/.shellcheck-0.8.0.pkg     |   1 +
 bin/README.hermit.md          |   7 +
 bin/activate-hermit           |  21 ++
 bin/go                        |   1 +
 bin/gofmt                     |   1 +
 bin/golangci-lint             |   1 +
 bin/goreleaser                |   1 +
 bin/hermit                    |  43 +++
 bin/hermit.hcl                |   3 +
 bin/jq                        |   1 +
 bin/reflex                    |   1 +
 bin/shellcheck                |   1 +
 cmd/happy/main.go             | 640 ++++++++++++++++++++++++++++++++++
 codewriter/codewriter.go      | 123 +++++++
 codewriter/codewriter_test.go |  22 ++
 go.mod                        |  19 +
 go.sum                        |  15 +
 reflex.conf                   |   5 +
 scripts/e2e-test              |  20 ++
 scripts/happy                 |   6 +
 testdata/main.go              | 165 +++++++++
 testdata/main_api.go          | 181 ++++++++++
 testdata/main_test.go         |  30 ++
 34 files changed, 1774 insertions(+)
 create mode 100644 .github/workflows/ci.yml
 create mode 100644 .github/workflows/release.yml
 create mode 100644 .golangci.yml
 create mode 100644 .goreleaser.yml
 create mode 100644 COPYING
 create mode 100644 README.md
 create mode 120000 bin/.go-1.19.3.pkg
 create mode 120000 bin/.golangci-lint-1.50.1.pkg
 create mode 120000 bin/.goreleaser-1.15.0.pkg
 create mode 120000 bin/.jq-1.6.pkg
 create mode 120000 bin/.reflex-0.3.1.pkg
 create mode 120000 bin/.shellcheck-0.8.0.pkg
 create mode 100644 bin/README.hermit.md
 create mode 100755 bin/activate-hermit
 create mode 120000 bin/go
 create mode 120000 bin/gofmt
 create mode 120000 bin/golangci-lint
 create mode 120000 bin/goreleaser
 create mode 100755 bin/hermit
 create mode 100644 bin/hermit.hcl
 create mode 120000 bin/jq
 create mode 120000 bin/reflex
 create mode 120000 bin/shellcheck
 create mode 100644 cmd/happy/main.go
 create mode 100644 codewriter/codewriter.go
 create mode 100644 codewriter/codewriter_test.go
 create mode 100644 go.mod
 create mode 100644 go.sum
 create mode 100644 reflex.conf
 create mode 100755 scripts/e2e-test
 create mode 100755 scripts/happy
 create mode 100644 testdata/main.go
 create mode 100644 testdata/main_api.go
 create mode 100644 testdata/main_test.go

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..a4ce8bd
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,27 @@
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+name: CI
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: Init Hermit
+        run: ./bin/hermit env -r >> $GITHUB_ENV
+      - name: E2E Test
+        run: e2e-test
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+      - name: Init Hermit
+        run: ./bin/hermit env -r >> $GITHUB_ENV
+      - name: golangci-lint
+        run: golangci-lint run
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..3d06f8f
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,17 @@
+name: Release
+on:
+  push:
+    tags:
+      - 'v*'
+jobs:
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+      with:
+        fetch-depth: 0
+    - run: ./bin/hermit env --raw >> $GITHUB_ENV
+    - run: goreleaser release
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.golangci.yml b/.golangci.yml
new file mode 100644
index 0000000..a8d1b6c
--- /dev/null
+++ b/.golangci.yml
@@ -0,0 +1,95 @@
+run:
+  tests: true
+  skip-dirs:
+    - _examples
+
+output:
+  print-issued-lines: false
+
+linters:
+  enable-all: true
+  disable:
+    - maligned
+    - megacheck
+    - lll
+    - gocyclo
+    - dupl
+    - gochecknoglobals
+    - funlen
+    - godox
+    - wsl
+    - goimports
+    - gomnd
+    - gocognit
+    - goerr113
+    - nolintlint
+    - testpackage
+    - godot
+    - nestif
+    - paralleltest
+    - nlreturn
+    - cyclop
+    - exhaustivestruct
+    - gci
+    - gofumpt
+    - errorlint
+    - exhaustive
+    - ifshort
+    - wrapcheck
+    - stylecheck
+    - nonamedreturns
+    - revive
+    - dupword
+    - exhaustruct
+    - varnamelen
+    - forcetypeassert
+    - ireturn
+    - maintidx
+    - govet
+    - nosnakecase
+    - testableexamples
+    - gochecknoinits
+    - prealloc
+    - forbidigo
+    - goprintffuncname
+
+linters-settings:
+  govet:
+    check-shadowing: true
+  gocyclo:
+    min-complexity: 10
+  dupl:
+    threshold: 100
+  goconst:
+    min-len: 8
+    min-occurrences: 3
+  forbidigo:
+    #forbid:
+    #  - (Must)?NewLexer$
+    exclude_godoc_examples: false
+
+issues:
+  max-per-linter: 0
+  max-same: 0
+  exclude-use-default: false
+  exclude:
+    # Captured by errcheck.
+    - '^(G104|G204):'
+    # Very commonly not checked.
+    - 'Error return value of .(.*\.Help|.*\.MarkFlagRequired|(os\.)?std(out|err)\..*|.*Close|.*Flush|os\.Remove(All)?|.*printf?|os\.(Un)?Setenv). is not checked'
+    - 'exported method (.*\.MarshalJSON|.*\.UnmarshalJSON|.*\.EntityURN|.*\.GoString|.*\.Pos) should have comment or be unexported'
+    - 'comment on exported method'
+    - 'composite literal uses unkeyed fields'
+    - 'declaration of "err" shadows declaration'
+    - 'should not use dot imports'
+    - 'Potential file inclusion via variable'
+    - 'should have comment or be unexported'
+    - 'comment on exported var .* should be of the form'
+    - 'at least one file in a package should have a package comment'
+    - 'string literal contains the Unicode'
+    - 'methods on the same type should have the same receiver name'
+    - '_TokenType_name should be _TokenTypeName'
+    - '`_TokenType_map` should be `_TokenTypeMap`'
+    - 'rewrite if-else to switch statement'
+    - 'comment.*should be of the form'
+    - 'should have comment'
diff --git a/.goreleaser.yml b/.goreleaser.yml
new file mode 100644
index 0000000..c59c49a
--- /dev/null
+++ b/.goreleaser.yml
@@ -0,0 +1,37 @@
+project_name: happy
+release:
+  github:
+    owner: thnxdev
+    name: happy
+brews:
+  -
+    install: bin.install "happy"
+env:
+  - CGO_ENABLED=0
+builds:
+- goos:
+    - linux
+    - darwin
+    - windows
+  goarch:
+    - arm64
+    - amd64
+    - "386"
+  goarm:
+    - "6"
+  dir: ./cmd/happy
+  main: .
+  ldflags: -s -w -X main.version={{.Version}}
+  binary: happy
+archives:
+  -
+    format: tar.gz
+    name_template: '{{ .Binary }}-{{ .Version }}-{{ .Os }}-{{ .Arch }}{{ if .Arm }}v{{
+    .Arm }}{{ end }}'
+    files:
+      - COPYING
+      - README*
+snapshot:
+  name_template: SNAPSHOT-{{ .Commit }}
+checksum:
+  name_template: '{{ .ProjectName }}-{{ .Version }}-checksums.txt'
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..bfa69e8
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,19 @@
+Copyright (C) 2023 thanks.dev
+
+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.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..a7adbe0
--- /dev/null
+++ b/README.md
@@ -0,0 +1,266 @@
+# happy is an opinionated tool for generating request-handler boilerplate for Go 😊 [![CI](https://github.com/thnxdev/happy/actions/workflows/ci.yml/badge.svg)](https://github.com/thnxdev/happy/actions/workflows/ci.yml)
+
+happy automatically generates `http.RequestHandler` boilerplate for routing to Go
+methods annotated with comment directives. The generated code decodes the
+incoming HTTP request into the method's parameters, and encodes method return
+values to HTTP responses.
+
+happy only supports JSON request/response payloads. That said, see
+[below](#escape-hatch) for workarounds that can leverage just happy's routing.
+
+happy's generated code relies on only the standard library.
+
+Here's an example annotated method that happy will generate a request handler for:
+
+```go
+//happy:api GET /users/:id
+func (u *UsersService) GetUser(id string) (User, error) {
+	for _, user := range u.users {
+		if user.ID == id {
+			return user, nil
+		}
+	}
+	return User{}, Errorf(http.StatusNotFound, "user %q not found", id)
+}
+```
+
+The generated request handler will map the path component `:id` to the parameter
+`id`, and JSON encode the response payload or error.
+
+See [below](#example) for a full example.
+
+# Status
+
+happy is usable but has some limitations and missing features:
+
+- Does not support pointers to structs for JSON request payloads, only values.
+- Limited (int and string) type support for path and query parameters.
+- Does not support embedded structs for query parameters.
+- A command to dump the API as an OpenAPI schema.
+
+# Protocol
+
+happy's protocol is in the form of Go comment directives. Each directive must be
+placed on a method, not a free function.
+
+Annotations and methods are in the following form:
+
+```go
+//happy:api <method> <path> [<option>[=<value>] ...]
+func (s Struct) Method([pathVar0, pathVar1 string][, req Request]) ([<response>, ][error]) { ... }
+```
+
+## Options
+
+Options are key+value pairs appended to the end of an annotation and are exposed
+via the following generated method on the service struct:
+
+```go
+HandlerOptions(r *http.Request) map[string]string
+```
+
+This method will return the metadata map associated with the inbound request, or
+`nil`.
+
+A handy pattern is to create a wrapping `http.Handler` that injects the options
+into the inbound request context like so:
+
+```go
+var Options struct{}
+
+type OptionHandler interface {
+	HandlerOptions(*http.Request) map[string]string
+}
+
+func OptionsMiddleware(options OptionHandler, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ctx := context.WithValue(r.Context(), Options, options.HandlerOptions(r))
+		r = r.WithContext(ctx)
+		next.ServeHTTP(w, r)
+	})
+}
+```
+
+## Request signature
+
+The `<path>` value supports variables in the form `:<name>` which are mapped
+directly to method parameters of the same name. These parameters must implement
+`encoding.TextUnmarshaler` or be of type `string` or `int`.
+
+eg.
+
+```go
+//happy:api GET /users/:id
+func (u *UsersService) GetUser(id string) (User, error) { ... }
+```
+
+In addition to path variables and the request payload, happy can pass any of the
+following types to your handler method:
+
+- `*http.Request`
+- `http.ResponseWriter`
+- `context.Context` from the incoming `*http.Request`
+- `io.Reader` for the request body
+
+### Request payload decoding
+
+Finally, a single extra struct parameter can be specified, which will be decoded
+from the request payload. For PUT/POST request the "payload" is the request
+body, for all other request types the "payload" is the URL query parameters. 
+
+eg.
+
+```go
+type Paginate struct {
+	Size int
+}
+
+//happy:api GET /users/
+func (u *UsersService) ListUsers(pagination Paginate) ([]User, error) {
+	// ...
+}
+```
+
+Note: For query parameters, only a limited set of field types are currently
+supported, and embedded structs are not supported.
+
+## Response signature
+
+The return signature of the method is in the form:
+
+```
+[([<response>, ][error])]
+```
+
+That is, the method may return a response, an error, both, or nothing.
+
+ Depending on the type of the `<response>` value, the response will be encoded
+ in the following ways:
+
+ | Type | Encoding |
+ | ---- | -------- |
+ | `nil`/omitted | 204 No Content |
+ | `string` | `text/html` |
+ | `[]byte` | `application/octet-stream` |
+ | `io.Reader` | `application/octet-stream` |
+ | `io.ReadCloser` | `application/octet-stream` |
+ | `*http.Response` | Response structure is used as-is. |
+ | `*` | `application/json` |
+
+## Error handling
+
+If the method returns an error, happy will generate code to check the error
+and return an error response. If the error value implements `http.Handler` that
+will be used to generate the response, otherwise a 500 response will be
+generated.
+
+A rudimentary HTTP error type might look like this:
+
+```go
+type Error struct {
+	Code int
+	Msg string
+}
+
+func (e Error) Error() string { return fmt.Sprintf("%d: %s", e.Code, e.Msg) }
+func (e Error) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	http.Error(w, w.Msg, e.Code)
+}
+```
+
+Additionally, if the receiver implements the following interface it will be used
+to write errors:
+
+```go
+type ErrorHandler interface {
+}
+```
+
+## Escape hatch
+
+If happy's default request/response handling is not to your liking, you can still
+leverage happy's routing by accepting `*http.Request` and `http.ResponseWriter`
+as parameters:
+
+```go
+//happy:api POST /users
+func (s Struct) CreateUser(r *http.Request, w http.ResponseWriter) { ... }
+```
+
+# Example
+
+Create a `main.go` with the following content and run `go generate`. happy will
+create a `main_api.go` file implementing `http.Handler` for `*Service`.
+
+```go
+//go:generate happy
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+// An Error that implements http.Handler to write structured JSON errors.
+type Error struct {
+	code    int
+	message string
+}
+
+func Errorf(code int, format string, args ...interface{}) error {
+	return Error{code, fmt.Sprintf(format, args...)}
+}
+
+func (e Error) Error() string { return e.message }
+
+func (e Error) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(e.code)
+	json.NewEncoder(w).Encode(map[string]string{"error": e.message})
+}
+
+type User struct {
+	ID   int    `json:"id"`
+	Name string `json:"name"`
+}
+
+type Service struct {
+	users []User
+}
+
+//happy:api GET /users/:id
+func (s *Service) GetUser(id int) (User, error) {
+	for _, user := range s.users {
+		if user.ID == id {
+			return user, nil
+		}
+	}
+	return User{}, Errorf(http.StatusNotFound, "user %q not found", id)
+}
+
+//happy:api GET /users
+func (s *Service) ListUsers() ([]User, error) {
+	return s.users, nil
+}
+
+//happy:api POST /users
+func (s *Service) CreateUser(user User) error {
+	for _, u := range s.users {
+		if u.ID == user.ID {
+			return Errorf(http.StatusConflict, "user %d already exists", user.ID)
+		}
+	}
+	s.users = append(s.users, user)
+	return Errorf(http.StatusCreated, "user %d created", user.ID)
+}
+
+func main() {
+	service := &Service{
+		users: []User{{ID: 1, Name: "Alice"}, {ID: 2, Name: "Bob"}},
+	}
+	http.ListenAndServe(":8080", service)
+}
+```
+
+*happy's annotations are vaguely inspired by [Encore](https://encore.dev/).*
\ No newline at end of file
diff --git a/bin/.go-1.19.3.pkg b/bin/.go-1.19.3.pkg
new file mode 120000
index 0000000..383f451
--- /dev/null
+++ b/bin/.go-1.19.3.pkg
@@ -0,0 +1 @@
+hermit
\ No newline at end of file
diff --git a/bin/.golangci-lint-1.50.1.pkg b/bin/.golangci-lint-1.50.1.pkg
new file mode 120000
index 0000000..383f451
--- /dev/null
+++ b/bin/.golangci-lint-1.50.1.pkg
@@ -0,0 +1 @@
+hermit
\ No newline at end of file
diff --git a/bin/.goreleaser-1.15.0.pkg b/bin/.goreleaser-1.15.0.pkg
new file mode 120000
index 0000000..383f451
--- /dev/null
+++ b/bin/.goreleaser-1.15.0.pkg
@@ -0,0 +1 @@
+hermit
\ No newline at end of file
diff --git a/bin/.jq-1.6.pkg b/bin/.jq-1.6.pkg
new file mode 120000
index 0000000..383f451
--- /dev/null
+++ b/bin/.jq-1.6.pkg
@@ -0,0 +1 @@
+hermit
\ No newline at end of file
diff --git a/bin/.reflex-0.3.1.pkg b/bin/.reflex-0.3.1.pkg
new file mode 120000
index 0000000..383f451
--- /dev/null
+++ b/bin/.reflex-0.3.1.pkg
@@ -0,0 +1 @@
+hermit
\ No newline at end of file
diff --git a/bin/.shellcheck-0.8.0.pkg b/bin/.shellcheck-0.8.0.pkg
new file mode 120000
index 0000000..383f451
--- /dev/null
+++ b/bin/.shellcheck-0.8.0.pkg
@@ -0,0 +1 @@
+hermit
\ No newline at end of file
diff --git a/bin/README.hermit.md b/bin/README.hermit.md
new file mode 100644
index 0000000..e889550
--- /dev/null
+++ b/bin/README.hermit.md
@@ -0,0 +1,7 @@
+# Hermit environment
+
+This is a [Hermit](https://github.com/cashapp/hermit) bin directory.
+
+The symlinks in this directory are managed by Hermit and will automatically
+download and install Hermit itself as well as packages. These packages are
+local to this environment.
diff --git a/bin/activate-hermit b/bin/activate-hermit
new file mode 100755
index 0000000..fe28214
--- /dev/null
+++ b/bin/activate-hermit
@@ -0,0 +1,21 @@
+#!/bin/bash
+# This file must be used with "source bin/activate-hermit" from bash or zsh.
+# You cannot run it directly
+#
+# THIS FILE IS GENERATED; DO NOT MODIFY
+
+if [ "${BASH_SOURCE-}" = "$0" ]; then
+  echo "You must source this script: \$ source $0" >&2
+  exit 33
+fi
+
+BIN_DIR="$(dirname "${BASH_SOURCE[0]:-${(%):-%x}}")"
+if "${BIN_DIR}/hermit" noop > /dev/null; then
+  eval "$("${BIN_DIR}/hermit" activate "${BIN_DIR}/..")"
+
+  if [ -n "${BASH-}" ] || [ -n "${ZSH_VERSION-}" ]; then
+      hash -r 2>/dev/null
+    fi
+
+    echo "Hermit environment $("${HERMIT_ENV}"/bin/hermit env HERMIT_ENV) activated"
+fi
diff --git a/bin/go b/bin/go
new file mode 120000
index 0000000..2b403c5
--- /dev/null
+++ b/bin/go
@@ -0,0 +1 @@
+.go-1.19.3.pkg
\ No newline at end of file
diff --git a/bin/gofmt b/bin/gofmt
new file mode 120000
index 0000000..2b403c5
--- /dev/null
+++ b/bin/gofmt
@@ -0,0 +1 @@
+.go-1.19.3.pkg
\ No newline at end of file
diff --git a/bin/golangci-lint b/bin/golangci-lint
new file mode 120000
index 0000000..141cc54
--- /dev/null
+++ b/bin/golangci-lint
@@ -0,0 +1 @@
+.golangci-lint-1.50.1.pkg
\ No newline at end of file
diff --git a/bin/goreleaser b/bin/goreleaser
new file mode 120000
index 0000000..76fa6d9
--- /dev/null
+++ b/bin/goreleaser
@@ -0,0 +1 @@
+.goreleaser-1.15.0.pkg
\ No newline at end of file
diff --git a/bin/hermit b/bin/hermit
new file mode 100755
index 0000000..7fef769
--- /dev/null
+++ b/bin/hermit
@@ -0,0 +1,43 @@
+#!/bin/bash
+#
+# THIS FILE IS GENERATED; DO NOT MODIFY
+
+set -eo pipefail
+
+export HERMIT_USER_HOME=~
+
+if [ -z "${HERMIT_STATE_DIR}" ]; then
+  case "$(uname -s)" in
+  Darwin)
+    export HERMIT_STATE_DIR="${HERMIT_USER_HOME}/Library/Caches/hermit"
+    ;;
+  Linux)
+    export HERMIT_STATE_DIR="${XDG_CACHE_HOME:-${HERMIT_USER_HOME}/.cache}/hermit"
+    ;;
+  esac
+fi
+
+export HERMIT_DIST_URL="${HERMIT_DIST_URL:-https://github.com/cashapp/hermit/releases/download/stable}"
+HERMIT_CHANNEL="$(basename "${HERMIT_DIST_URL}")"
+export HERMIT_CHANNEL
+export HERMIT_EXE=${HERMIT_EXE:-${HERMIT_STATE_DIR}/pkg/hermit@${HERMIT_CHANNEL}/hermit}
+
+if [ ! -x "${HERMIT_EXE}" ]; then
+  echo "Bootstrapping ${HERMIT_EXE} from ${HERMIT_DIST_URL}" 1>&2
+  INSTALL_SCRIPT="$(mktemp)"
+  # This value must match that of the install script
+  INSTALL_SCRIPT_SHA256="180e997dd837f839a3072a5e2f558619b6d12555cd5452d3ab19d87720704e38"
+  if [ "${INSTALL_SCRIPT_SHA256}" = "BYPASS" ]; then
+    curl -fsSL "${HERMIT_DIST_URL}/install.sh" -o "${INSTALL_SCRIPT}"
+  else
+    # Install script is versioned by its sha256sum value
+    curl -fsSL "${HERMIT_DIST_URL}/install-${INSTALL_SCRIPT_SHA256}.sh" -o "${INSTALL_SCRIPT}"
+    # Verify install script's sha256sum
+    openssl dgst -sha256 "${INSTALL_SCRIPT}" | \
+      awk -v EXPECTED="$INSTALL_SCRIPT_SHA256" \
+      '$2!=EXPECTED {print "Install script sha256 " $2 " does not match " EXPECTED; exit 1}'
+  fi
+  /bin/bash "${INSTALL_SCRIPT}" 1>&2
+fi
+
+exec "${HERMIT_EXE}" --level=fatal exec "$0" -- "$@"
diff --git a/bin/hermit.hcl b/bin/hermit.hcl
new file mode 100644
index 0000000..6084415
--- /dev/null
+++ b/bin/hermit.hcl
@@ -0,0 +1,3 @@
+env = {
+  "PATH": "${HERMIT_ENV}/scripts:${PATH}",
+}
diff --git a/bin/jq b/bin/jq
new file mode 120000
index 0000000..d7e067b
--- /dev/null
+++ b/bin/jq
@@ -0,0 +1 @@
+.jq-1.6.pkg
\ No newline at end of file
diff --git a/bin/reflex b/bin/reflex
new file mode 120000
index 0000000..6bb67bc
--- /dev/null
+++ b/bin/reflex
@@ -0,0 +1 @@
+.reflex-0.3.1.pkg
\ No newline at end of file
diff --git a/bin/shellcheck b/bin/shellcheck
new file mode 120000
index 0000000..b3bc96f
--- /dev/null
+++ b/bin/shellcheck
@@ -0,0 +1 @@
+.shellcheck-0.8.0.pkg
\ No newline at end of file
diff --git a/cmd/happy/main.go b/cmd/happy/main.go
new file mode 100644
index 0000000..5eed7c9
--- /dev/null
+++ b/cmd/happy/main.go
@@ -0,0 +1,640 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/token"
+	"go/types"
+	"net/http"
+	"os"
+	"path"
+	"regexp"
+	"strings"
+	"sync"
+	"unicode/utf8"
+
+	"github.com/alecthomas/kong"
+	"golang.org/x/tools/go/packages"
+
+	"github.com/thnxdev/happy/codewriter"
+)
+
+var (
+	version string = "dev"
+	cli     struct {
+		Version kong.VersionFlag `help:"Show version."`
+		List    bool             `help:"List endpoints."`
+		Pkg     string           `arg:"" help:"Package to scan for API definitions." default:"."`
+	}
+	fset = token.NewFileSet()
+	// httpHandlerInterface     = mustLoadInterface("net/http", "Handler")
+	textUnmarshalerInterface = mustLoadInterface("encoding", "TextUnmarshaler")
+)
+
+type directive struct {
+	doc        string
+	method     string
+	pattern    string
+	options    map[string]string
+	pathParams []string
+}
+
+type endpoint struct {
+	decl      *ast.FuncDecl
+	fn        *types.Func
+	signature *types.Signature
+	directive directive
+}
+
+func main() {
+	kctx := kong.Parse(&cli, kong.Vars{"version": version}, kong.Description(`
+happy automatically generates http.RequestHandler boilerplate for routing to Go
+methods annotated with comment directives. The generated code decodes the
+incoming HTTP request into the method's parameters, and encodes method return
+values to HTTP responses.
+
+eg.
+
+  //happy:api GET /users/:id
+  func (s *Server) GetUserByID(id int) (User, error) {
+	// ...
+  }
+
+See https://github.com/thnxdev/happy for more information.
+`), kong.HelpOptions{WrapUpperBound: 90})
+	pkgs, err := packages.Load(&packages.Config{
+		Fset: fset,
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedSyntax | packages.NeedTypes | packages.NeedTypesInfo,
+	}, cli.Pkg)
+	kctx.FatalIfErrorf(err)
+
+	if cli.List {
+		err = listEndpoints(pkgs)
+		kctx.FatalIfErrorf(err)
+		kctx.Exit(0)
+	}
+
+	didWork := false
+	for _, pkg := range pkgs {
+		outPath, endpoints, err := extractEndpoints(pkg)
+		kctx.FatalIfErrorf(err)
+		if len(endpoints) == 0 {
+			continue
+		}
+		didWork = true
+
+		gctx := &genContext{
+			Writer: codewriter.New(pkg.Name),
+			pkg:    pkg,
+		}
+		gctx.Import("net/http", "io", "encoding/json", "strconv")
+		for _, svcEndpoints := range endpoints {
+			generateHandler(gctx, svcEndpoints, makeTree(svcEndpoints))
+			kctx.FatalIfErrorf(err)
+		}
+
+		source := gctx.Bytes()
+		formatted, err := format.Source(source)
+		if err != nil {
+			for i, line := range bytes.Split(source, []byte("\n")) {
+				fmt.Printf("%3d: %s\n", i+1, line)
+			}
+			kctx.FatalIfErrorf(err)
+		}
+		err = os.WriteFile(outPath, formatted, 0600)
+		kctx.FatalIfErrorf(err)
+	}
+
+	if !didWork {
+		kctx.Fatalf("no annotated endpoints found, nothing to do")
+	}
+}
+
+func listEndpoints(pkgs []*packages.Package) error {
+	for _, pkg := range pkgs {
+		_, endpoints, err := extractEndpoints(pkg)
+		if err != nil {
+			return fmt.Errorf("could not list endpoints: %w", err)
+		}
+		if len(endpoints) == 0 {
+			continue
+		}
+
+		for _, handlerEndpoints := range endpoints {
+			for _, endpoint := range handlerEndpoints {
+				dir := endpoint.directive
+				fmt.Printf("%s %s\n", dir.method, dir.pattern)
+				if dir.doc != "" {
+					for _, line := range strings.Split(strings.TrimSpace(dir.doc), "\n") {
+						fmt.Println("  " + line)
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func generateHandler(gctx *genContext, eps []endpoint, tree *tree) {
+	var ptr string
+	var recvType *types.Named
+	recv := eps[0].signature.Recv().Type()
+	if ptrt, ok := recv.(*types.Pointer); ok {
+		ptr = "*"
+		recvType = ptrt.Elem().(*types.Named)
+	}
+	w := gctx.Writer
+	w.L("")
+	w.L("func (h %s%s) HandlerOptions(r *http.Request) map[string]string {", ptr, recvType.Obj().Name())
+	optionsEndpoints := []endpoint{}
+	for _, ep := range eps {
+		if len(ep.directive.options) > 0 {
+			optionsEndpoints = append(optionsEndpoints, ep)
+		}
+	}
+	optionsTree := makeTree(optionsEndpoints)
+	w.In(func(w *codewriter.Writer) {
+		optionsTree.Write(w, "return nil", func(w *codewriter.Writer, ep endpoint) {
+			if len(ep.directive.options) == 0 {
+				w.L("return nil")
+				return
+			}
+			w.L("return %#v", ep.directive.options)
+		})
+		w.L("return nil")
+	})
+	w.L("}")
+	w.L("")
+	w.L("func (h %s%s) ServeHTTP(w http.ResponseWriter, r *http.Request) {", ptr, recvType.Obj().Name())
+	w = w.Push()
+	w.L("var err error")
+	w.L("var res any")
+	tree.Write(w, "return", func(w *codewriter.Writer, ep endpoint) {
+		if err := genEndpoint(gctx, w, ep); err != nil {
+			pos := gctx.Pos(ep.signature.Recv().Pos())
+			panic(fmt.Errorf("%s: failed to generate endpoint: %w", pos, err))
+		}
+		w.L("goto matched")
+	})
+	w.L("  // No match but we don't return a 404 here, to allow the default handler to take control.")
+	w.L("  return")
+	w.L("matched:")
+	w.L("")
+	w.L("// Handle errors")
+	w.L("if err != nil {")
+	w.L("  if herr, ok := err.(http.Handler); ok {")
+	w.L("    herr.ServeHTTP(w, r)")
+	w.L("  } else {")
+	w.L("		 http.Error(w, err.Error(), http.StatusInternalServerError)")
+	w.L("  }")
+	w.L("  return")
+	w.L("}")
+	w.L("")
+	w.L("// Handle response")
+	w.L("switch res := res.(type) {")
+	w.L("case nil:")
+	w.L("  w.WriteHeader(http.StatusNoContent)")
+	w.L("case string:")
+	w.L("  w.Header().Set(\"Content-Type\", \"text/html\")")
+	w.L("  io.WriteString(w, res)")
+	w.L("case []byte:")
+	w.L("  w.Header().Set(\"Content-Type\", \"application/octet-stream\")")
+	w.L("  w.Write(res)")
+	w.L("case *http.Response:")
+	w.L("  headers := w.Header()")
+	w.L("  for k, v := range res.Header {")
+	w.L("    headers[k] = v")
+	w.L("  }")
+	w.L("  w.WriteHeader(res.StatusCode)")
+	w.L("  _, _ = io.Copy(w, res.Body)")
+	w.L("case io.ReadCloser:")
+	w.L("  w.Header().Set(\"Content-Type\", \"application/octet-stream\")")
+	w.L("  _, _ = io.Copy(w, res)")
+	w.L("  res.Close()")
+	w.L("case io.Reader:")
+	w.L("  w.Header().Set(\"Content-Type\", \"application/octet-stream\")")
+	w.L("  _, _ = io.Copy(w, res)")
+	w.L("default:")
+	w.In(func(w *codewriter.Writer) {
+		w.L("data, err := json.Marshal(res)")
+		w.L("if err != nil {")
+		w.L("  http.Error(w, `failed to encode response: ` + err.Error(), http.StatusInternalServerError)")
+		w.L("  return")
+		w.L("}")
+		w.L("w.Header().Set(\"Content-Type\", \"application/json\")")
+		w.L("w.Header().Set(\"Content-Length\", strconv.Itoa(len(data)))")
+		w.L("w.WriteHeader(http.StatusOK)")
+		w.L("w.Write(data)")
+	})
+	w.L("}")
+	w = w.Pop()
+	w.L("}")
+}
+
+//nolint:nakedret
+func extractEndpoints(pkg *packages.Package) (outPath string, endpoints map[string][]endpoint, retErr error) {
+	endpoints = map[string][]endpoint{}
+	for _, file := range pkg.Syntax {
+		ast.Inspect(file, func(node ast.Node) bool {
+			fn, ok := node.(*ast.FuncDecl)
+			if !ok || fn.Doc == nil {
+				return true
+			}
+			for _, line := range fn.Doc.List {
+				if strings.HasPrefix(line.Text, "//happy:api") {
+					pos := pkg.Fset.Position(fn.Pos())
+					dir, err := parseDirective(fn.Doc.Text(), line.Text)
+					if err != nil {
+						retErr = fmt.Errorf("%s: %w", pos, err)
+						return false
+					}
+					fnt := pkg.TypesInfo.Defs[fn.Name].(*types.Func)
+					sig := fnt.Type().(*types.Signature)
+					receiverName := sig.Recv().Type().String()
+					endpoints[receiverName] = append(endpoints[receiverName], endpoint{
+						decl:      fn,
+						fn:        fnt,
+						signature: sig,
+						directive: dir,
+					})
+				}
+			}
+			return true
+		})
+		if retErr != nil {
+			return
+		}
+		if outPath == "" && len(endpoints) > 0 {
+			f := pkg.Fset.File(file.Pos())
+			outPath = strings.TrimSuffix(f.Name(), ".go") + "_api.go"
+		}
+	}
+	return
+}
+
+var nameExtract = regexp.MustCompile(`/:([a-zA-Z0-9]+)`)
+
+// <method> <path> [<option>[=<value>] ...]
+func parseDirective(doc, comment string) (directive, error) {
+	parts := strings.Fields(comment)
+	if len(parts) < 3 {
+		return directive{}, fmt.Errorf("invalid directive, must be in the form //api:http <method> <url> [<option>=<value> ...]: %s", comment)
+	}
+	pattern := parts[2]
+	matches := nameExtract.FindAllStringSubmatchIndex(pattern, -1)
+	dir := directive{
+		doc:     doc,
+		method:  parts[1],
+		pattern: pattern,
+		options: map[string]string{},
+	}
+	for _, parami := range matches {
+		param := pattern[parami[2]:parami[3]]
+		dir.pathParams = append(dir.pathParams, param)
+	}
+
+	for _, option := range parts[3:] {
+		parts := strings.SplitN(option, "=", 2)
+		var value string
+		if len(parts) == 2 {
+			value = parts[1]
+		}
+		dir.options[parts[0]] = value
+	}
+	return dir, nil
+}
+
+func once[T any](f func() T) func() T {
+	var once sync.Once
+	var t T
+	return func() T {
+		once.Do(func() {
+			t = f()
+		})
+		return t
+	}
+}
+
+// Lazy load the compile-time type from a package.
+func mustLoadInterface(pkg, name string) func() *types.Interface {
+	return once[*types.Interface](func() *types.Interface {
+		pkgs, err := packages.Load(&packages.Config{Fset: fset, Mode: packages.NeedTypes}, pkg)
+		if err != nil {
+			panic(err)
+		}
+		if len(pkgs) != 1 {
+			panic("expected one package")
+		}
+		iface := pkgs[0].Types.Scope().Lookup(name)
+		if iface == nil {
+			panic("interface not found")
+		}
+		return iface.Type().Underlying().(*types.Interface)
+	})
+}
+
+// Generate a function for decoding url.Values directly into a struct.
+//
+// Only a limited set of types are currently supported, and embedded structs are not supported.
+func genQueryDecoderFunc(gctx *genContext, paramType types.Type) (name string, err error) {
+	strct, ok := paramType.Underlying().(*types.Struct)
+	if !ok {
+		return "", fmt.Errorf("parameter must be a struct but is %s", paramType)
+	}
+	gctx.Import("net/url")
+	_, typeRef := gctx.TypeRef(paramType)
+	name = "decode" + ucFirst(strings.ReplaceAll(typeRef, ".", ""))
+	w := gctx.Trailer()
+	w.L("func %s(p url.Values, out *%s) (err error) {", name, typeRef)
+	w = w.Push()
+	for i := 0; i < strct.NumFields(); i++ {
+		field := strct.Field(i)
+		fieldName := lcFirst(strings.ReplaceAll(field.Name(), ".", ""))
+		w.L("if q, ok := p[%q]; ok {", fieldName)
+		w = w.Push()
+		switch field.Type().String() {
+		case "int":
+			gctx.Import("strconv")
+			w.L("if out.%s, err = strconv.Atoi(q[len(q)-1]); err != nil {", field.Name())
+			w.L(`  return fmt.Errorf("failed to decode query parameter \"%s\" into type %s: %%w", err)`, fieldName, field.Type())
+			w.L("}")
+		case "string":
+			w.L("out.%s = q[len(q)-1]", field.Name())
+		default:
+			return "", fmt.Errorf("can't decode query parameter into field %s.%s of type %s", paramType, field.Name(), field.Type())
+		}
+		w = w.Pop()
+		w.L("}")
+	}
+	w.L("return nil")
+	w = w.Pop()
+	w.L("}")
+	return name, nil
+}
+
+func ucFirst(s string) string {
+	rn, n := utf8.DecodeRuneInString(s)
+	return strings.ToUpper(string(rn)) + s[n:]
+}
+
+func lcFirst(s string) string {
+	rn, n := utf8.DecodeRuneInString(s)
+	return strings.ToLower(string(rn)) + s[n:]
+}
+
+type genContext struct {
+	pkg *packages.Package
+	*codewriter.Writer
+}
+
+func (g *genContext) Pos(pos token.Pos) token.Position {
+	return g.pkg.Fset.Position(pos)
+}
+
+func (g *genContext) TypeRef(t types.Type) (pkgRef, ref string) {
+	if named, ok := t.(*types.Named); ok {
+		pkgRef = named.Obj().Pkg().Path()
+		ref = named.Obj().Name()
+		if pkgRef == g.pkg.PkgPath {
+			pkgRef = ""
+		} else {
+			ref = path.Base(pkgRef) + "." + ref
+		}
+		return
+	}
+	return "", t.String()
+}
+
+func genEndpoint(gctx *genContext, w *codewriter.Writer, ep endpoint) error {
+	params := ep.signature.Params()
+	isParam := map[string]bool{}
+	for i := 0; i < params.Len(); i++ {
+		isParam[params.At(i).Name()] = true
+	}
+
+	isGroup := map[string]int{}
+	for i, param := range ep.directive.pathParams {
+		isGroup[param] = i + 1
+	}
+
+	args := []string{}
+	for i := 0; i < params.Len(); i++ {
+		param := params.At(i)
+		pos := gctx.Pos(param.Pos())
+		tn := param.Type().String()
+		switch {
+		case tn == "context.Context":
+			args = append(args, "r.Context()")
+
+		case tn == "net/http.ResponseWriter":
+			args = append(args, "w")
+			gctx.Import("net/http")
+
+		case tn == "io.Reader":
+			args = append(args, "r.Body")
+
+		case tn == "*net/http.Request":
+			args = append(args, "r")
+			gctx.Import("net/http")
+
+		case isGroup[param.Name()] != 0:
+			index := isGroup[param.Name()] - 1
+			pkgRef, ref := gctx.TypeRef(param.Type())
+			if pkgRef != "" {
+				gctx.Import(pkgRef)
+			}
+			bt := param.Type().Underlying().String()
+			// Type aliases (eg. type Foo int) are supported if they alias
+			// string or int, or implement encoding.TextUnmarshaler.
+			switch {
+			case types.Implements(param.Type(), textUnmarshalerInterface()) || types.Implements(types.NewPointer(param.Type()), textUnmarshalerInterface()):
+				paramName := fmt.Sprintf("param%d", index)
+				w.L("var %s %s", paramName, ref)
+				w.L("if err := %s.UnmarshalText([]byte(params[%d])); err != nil {", paramName, index)
+				w.L("  http.Error(w, \"%s: \" + err.Error(), http.StatusBadRequest)", param.Name())
+				w.L("  return")
+				w.L("}")
+				args = append(args, paramName)
+
+			case bt == "string":
+				if bt != ref {
+					args = append(args, fmt.Sprintf("%s(matches[%d])", ref, index))
+				} else {
+					args = append(args, fmt.Sprintf("matches[%d]", index))
+				}
+
+			case bt == "int":
+				paramName := fmt.Sprintf("param%d", index)
+				w.L("var %s int", paramName)
+				w.L("%s, err = strconv.Atoi(params[%d])", paramName, index)
+				if bt != ref {
+					args = append(args, fmt.Sprintf("%s(%s)", ref, paramName))
+				} else {
+					args = append(args, paramName)
+				}
+				w.L("if err != nil {")
+				w.L("  http.Error(w, \"%s: \" + err.Error(), http.StatusBadRequest)", param.Name())
+				w.L("  return")
+				w.L("}")
+
+			default:
+				return fmt.Errorf("%s: %s: unsupported named parameter type %q", pos, param.Name(), param.Type())
+			}
+
+		// Not a parameter, so it must be a request body or query parameters.
+		default: // TODO(aat): Handle pointers.
+			paramType, ok := param.Type().(*types.Named)
+			if !ok {
+				return fmt.Errorf("%s: parameter %q does not map to any URL path variables and is of type %q, but must be a struct to be used as a request payload", pos, param.Name(), param.Type())
+			}
+			pkgRef, ref := gctx.TypeRef(param.Type())
+			gctx.Import(pkgRef)
+
+			w.L("var param%d %s", i, ref)
+			gctx.Import("net/http")
+			if ep.directive.method == http.MethodGet || ep.directive.method == http.MethodDelete {
+				decoderFn, err := genQueryDecoderFunc(gctx, paramType)
+				if err != nil {
+					return fmt.Errorf("%s: %w", pos, err)
+				}
+				w.L("if err := %s(r.URL.Query(), &param%d); err != nil {", decoderFn, i)
+				w.L(`  http.Error(w, fmt.Sprintf("Failed to decode query parameters: %s", err), http.StatusBadRequest)`)
+				w.L("  return")
+				w.L("}")
+			} else {
+				gctx.Import("encoding/json")
+				gctx.Import("fmt")
+				w.L("if err := json.NewDecoder(r.Body).Decode(&param%d); err != nil {", i)
+				w.L("  http.Error(w, fmt.Sprintf(\"Failed to decode request body: %%s\", err), http.StatusBadRequest)")
+				w.L("  return")
+				w.L("}")
+			}
+			args = append(args, fmt.Sprintf("param%d", i))
+		}
+	}
+	results := ep.signature.Results()
+	switch results.Len() {
+	case 0:
+	case 2:
+		w.W("  res, err = ")
+		pos := gctx.Pos(results.At(0).Pos())
+		resType := results.At(0).Type()
+		switch resType.String() {
+		case "string", "[]byte", "*net/http.Response":
+		default:
+			switch resType.(type) {
+			case *types.Named, *types.Slice, *types.Map:
+			default:
+				return fmt.Errorf("%s: unsupported return type %s", pos, results.At(0).Type())
+			}
+		}
+	case 1:
+		if results.At(0).Type().String() == "error" {
+			w.W("  err = ")
+			break
+		}
+		fallthrough
+	default:
+		return fmt.Errorf("%s: handler return values must be in the form (error) or (T, error)", ep.fn.Name())
+	}
+	w.L("h.%s(%s)", ep.fn.Name(), strings.Join(args, ", "))
+	if results.Len() == 0 {
+		w.L("return")
+	}
+	return nil
+}
+
+type tree struct {
+	part      string
+	children  []tree
+	endpoints []endpoint
+}
+
+func (t *tree) String() string {
+	if len(t.children) == 0 {
+		return fmt.Sprintf("/%s(%d)", t.part, len(t.endpoints))
+	}
+	childStrings := []string{}
+	for _, child := range t.children {
+		childStrings = append(childStrings, child.String())
+	}
+	return fmt.Sprintf("/%s(%d)[%s]", t.part, len(t.endpoints), strings.Join(childStrings, ", "))
+}
+
+func (t *tree) Write(w *codewriter.Writer, earlyExit string, visitor func(w *codewriter.Writer, endpoint endpoint)) {
+	w.Import("strings")
+	w.L(`parts := strings.Split(r.URL.Path, "/")`)
+	w.L(`var params []string`)
+	w.L(`_ = params`)
+	w.L(`switch parts[0] {`)
+	t.recursiveWrite(w, 0, visitor, earlyExit)
+	w.L(`}`)
+}
+
+func (t *tree) recursiveWrite(w *codewriter.Writer, n int, visitor func(w *codewriter.Writer, endpoint endpoint), earlyExit string) {
+	// Check if we want to match more path components but we've run out.
+	// Variable path component always matches.
+	if !strings.HasPrefix(t.part, ":") {
+		w.L(`case "%s":`, t.part)
+	} else {
+		w.L(`default: // Parameter %s`, t.part)
+		w.L(`  params = append(params, parts[%d])`, n)
+	}
+	w.In(func(w *codewriter.Writer) {
+		w.In(func(w *codewriter.Writer) {
+			w.L(`if len(parts) == %d {`, n+1)
+			w.In(func(w *codewriter.Writer) {
+				if len(t.endpoints) > 0 {
+					w.L(`switch r.Method { // Leaf`)
+					for _, endpoint := range t.endpoints {
+						w.L(`case "%s":`, endpoint.directive.method)
+						w.In(func(w *codewriter.Writer) {
+							visitor(w, endpoint) //nolint:scopelint
+						})
+					}
+					w.L(`}`)
+				}
+				w.L(`%s`, earlyExit)
+			})
+			w.L(`}`)
+			if len(t.children) != 0 {
+				w.L(`switch parts[%d] {`, n+1)
+				for _, child := range t.children {
+					child.recursiveWrite(w, n+1, visitor, earlyExit)
+				}
+				w.L(`}`)
+			} else {
+				w.L(`%s`, earlyExit)
+			}
+		})
+	})
+}
+
+func makeTree(endpoints []endpoint) *tree {
+	out := &tree{}
+	for _, endpoint := range endpoints {
+		updateTree(out, endpoint, strings.Split(endpoint.directive.pattern, "/"))
+	}
+	return out
+}
+
+func updateTree(out *tree, endpoint endpoint, path []string) {
+	if len(path) == 0 || (path[0] == out.part && len(path) == 1) {
+		out.endpoints = append(out.endpoints, endpoint)
+		return
+	}
+	if path[0] == out.part {
+		path = path[1:]
+	}
+	part := path[0]
+	for i, child := range out.children {
+		if child.part == part {
+			updateTree(&out.children[i], endpoint, path[1:])
+			return
+		}
+	}
+	out.children = append(out.children, tree{part: part})
+	updateTree(&out.children[len(out.children)-1], endpoint, path[1:])
+}
diff --git a/codewriter/codewriter.go b/codewriter/codewriter.go
new file mode 100644
index 0000000..b666700
--- /dev/null
+++ b/codewriter/codewriter.go
@@ -0,0 +1,123 @@
+// Package codewriter is a simple helper for writing out source code.
+package codewriter
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+)
+
+type Writer struct {
+	imports *[]string
+	trailer []*Writer
+	w       *bytes.Buffer
+	pkg     string
+	indent  string
+}
+
+func New(pkg string) *Writer {
+	return &Writer{w: &bytes.Buffer{}, pkg: pkg, imports: &[]string{}}
+}
+
+// W writes a formatted string directly to the writer without indentation or newline.
+func (c *Writer) W(format string, args ...interface{}) {
+	fmt.Fprintf(c.w, format, args...)
+}
+
+// L writes a newline-terminated string to the writer.
+func (c *Writer) L(format string, args ...interface{}) {
+	c.W(c.indent+format+"\n", args...)
+}
+
+// In calls "fn" with a Writer that is indented one level.
+func (c *Writer) In(fn func(w *Writer)) {
+	fn(c.Push())
+}
+
+// Push returns a Writer indented one level.
+func (c *Writer) Push() *Writer {
+	out := *c
+	out.indent += "  "
+	return &out
+}
+
+// Pop returns a Writer unindented one level.
+func (c *Writer) Pop() *Writer {
+	out := *c
+	out.indent = out.indent[:len(out.indent)-2]
+	return &out
+}
+
+// Body returns the body of the code, without the package declaration and imports.
+func (c *Writer) Body() string {
+	out := &bytes.Buffer{}
+	c.writeBody(out)
+	return out.String()
+}
+
+// Import adds an import to the generated code.
+func (c *Writer) Import(pkg ...string) {
+	*c.imports = append(*c.imports, pkg...)
+}
+
+// Trailer returns a Writer that will be appended to the end of the code.
+//
+// Useful for writing out helper functions and other globals.
+func (c *Writer) Trailer() *Writer {
+	out := &Writer{imports: c.imports, w: &bytes.Buffer{}}
+	c.trailer = append(c.trailer, out)
+	return out
+}
+
+// String returns the self-contained complete generated code.
+func (c *Writer) String() string {
+	out := &strings.Builder{}
+	c.write(out)
+	return out.String()
+}
+
+// Bytes returns the self-contained complete generated code.
+func (c *Writer) Bytes() []byte {
+	out := &bytes.Buffer{}
+	c.write(out)
+	return out.Bytes()
+}
+
+//nolint:errcheck
+func (c *Writer) write(w io.Writer) {
+	fmt.Fprintf(w, "// Code generated by happy. DO NOT EDIT.\n")
+	fmt.Fprintf(w, "package %s\n", c.pkg)
+	fmt.Fprintf(w, "\n")
+	imports := []string{}
+	seen := map[string]bool{}
+	for _, pkg := range *c.imports {
+		if pkg == "" || seen[pkg] {
+			continue
+		}
+		seen[pkg] = true
+		imports = append(imports, pkg)
+	}
+	sort.Strings(imports)
+	if len(imports) > 0 {
+		fmt.Fprintf(w, "import (\n")
+		for _, pkg := range imports {
+			fmt.Fprintf(w, "  %q\n", pkg)
+		}
+		fmt.Fprintf(w, ")\n")
+		fmt.Fprintf(w, "\n")
+	}
+	io.Copy(w, c.w)
+	for _, trailer := range c.trailer {
+		trailer.writeBody(w)
+	}
+}
+
+//nolint:errcheck
+func (c *Writer) writeBody(w io.Writer) {
+	io.Copy(w, c.w)
+	for _, trailer := range c.trailer {
+		fmt.Fprintln(w, trailer.Body())
+	}
+}
diff --git a/codewriter/codewriter_test.go b/codewriter/codewriter_test.go
new file mode 100644
index 0000000..2d0147e
--- /dev/null
+++ b/codewriter/codewriter_test.go
@@ -0,0 +1,22 @@
+package codewriter_test
+
+import (
+	"testing"
+
+	"github.com/alecthomas/assert/v2"
+	"github.com/thnxdev/happy/codewriter"
+)
+
+func TestCodeWriter(t *testing.T) {
+	w := codewriter.New("pkg")
+	w.L("func hello() {")
+	w.In(func(w *codewriter.Writer) {
+		w.L(`println("hello")`)
+	})
+	w.L("}")
+	expected := `func hello() {
+  println("hello")
+}
+`
+	assert.Equal(t, expected, w.Body())
+}
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..f3f53d9
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,19 @@
+module github.com/thnxdev/happy
+
+go 1.19
+
+require (
+	github.com/alecthomas/kong v0.7.1
+	golang.org/x/tools v0.3.0
+)
+
+require (
+	github.com/alecthomas/repr v0.1.0 // indirect
+	github.com/hexops/gotextdiff v1.0.3 // indirect
+)
+
+require (
+	github.com/alecthomas/assert/v2 v2.2.0
+	golang.org/x/mod v0.7.0 // indirect
+	golang.org/x/sys v0.2.0 // indirect
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..18572e8
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,15 @@
+github.com/alecthomas/assert/v2 v2.2.0 h1:f6L/b7KE2bfA+9O4FL3CM/xJccDEwPVYd5fALBiuwvw=
+github.com/alecthomas/assert/v2 v2.2.0/go.mod h1:b/+1DI2Q6NckYi+3mXyH3wFb8qG37K/DuK80n7WefXA=
+github.com/alecthomas/kong v0.7.1 h1:azoTh0IOfwlAX3qN9sHWTxACE2oV8Bg2gAwBsMwDQY4=
+github.com/alecthomas/kong v0.7.1/go.mod h1:n1iCIO2xS46oE8ZfYCNDqdR0b0wZNrXAIAqro/2132U=
+github.com/alecthomas/repr v0.1.0 h1:ENn2e1+J3k09gyj2shc0dHr/yjaWSHRlrJ4DPMevDqE=
+github.com/alecthomas/repr v0.1.0/go.mod h1:2kn6fqh/zIyPLmm3ugklbEi5hg5wS435eygvNfaDQL8=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
+golang.org/x/mod v0.7.0 h1:LapD9S96VoQRhi/GrNTqeBJFrUjs5UHCAtTlgwA5oZA=
+golang.org/x/mod v0.7.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sys v0.2.0 h1:ljd4t30dBnAvMZaQCevtY0xLLD0A+bRZXbgLMLU1F/A=
+golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/tools v0.3.0 h1:SrNbZl6ECOS1qFzgTdQfWXZM9XBkiA6tkFrH9YSTPHM=
+golang.org/x/tools v0.3.0/go.mod h1:/rWhSS2+zyEVwoJf8YAX6L2f0ntZ7Kn/mGgAWcipA5k=
diff --git a/reflex.conf b/reflex.conf
new file mode 100644
index 0000000..24bbca2
--- /dev/null
+++ b/reflex.conf
@@ -0,0 +1,5 @@
+-r 'main.go$' \
+  happy ./testdata
+  
+-r '\.go$' -s \
+  go run ./testdata
diff --git a/scripts/e2e-test b/scripts/e2e-test
new file mode 100755
index 0000000..46e98d6
--- /dev/null
+++ b/scripts/e2e-test
@@ -0,0 +1,20 @@
+#!/bin/bash
+set -euxo pipefail
+
+happy ./testdata
+go test ./testdata
+go run ./testdata &
+trap 'kill "%%" || true' EXIT INT
+
+sleep 1
+
+# Fail because it's not authenticated
+curl --fail-with-body --data-binary '{"id": 3, "name": "Sally"}' http://localhost:8080/users && (echo "did not expect to succeed!"; exit 1)
+# Succeed
+curl -fsS http://localhost:8080/users | jq | tee /dev/stderr | jq -r '.[].name' | grep Alice
+curl --fail-with-body -u alice:secret --data-binary '{"id": 3, "name": "Sally"}' http://localhost:8080/users
+curl -fsS http://localhost:8080/users | jq | tee /dev/stderr | jq -r '.[].name' | grep Sally
+curl --fail-with-body -u alice:secret http://localhost:8080/users/3 | jq | tee /dev/stderr | jq -r '.name' | grep Sally
+curl -X POST http://localhost:8080/shutdown
+
+echo "Success!"
\ No newline at end of file
diff --git a/scripts/happy b/scripts/happy
new file mode 100755
index 0000000..3392a55
--- /dev/null
+++ b/scripts/happy
@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euo pipefail
+name="$(basename "$0")"
+dir="$(dirname "$0")/.."
+dest="${TMPDIR:-/tmp}/$name"
+(cd "${dir}/cmd/happy" ; go build -trimpath -buildvcs=false -ldflags="-s -w -buildid=" -o "${dest}" .) && exec "${dest}" "$@"
diff --git a/testdata/main.go b/testdata/main.go
new file mode 100644
index 0000000..b856403
--- /dev/null
+++ b/testdata/main.go
@@ -0,0 +1,165 @@
+//go:generate happy
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+)
+
+// An Error that implements http.Handler to write structured JSON errors.
+type Error struct {
+	code    int
+	message string
+}
+
+func Errorf(code int, format string, args ...interface{}) error {
+	return Error{code, fmt.Sprintf(format, args...)}
+}
+
+func (e Error) Error() string { return e.message }
+
+func (e Error) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(e.code)
+	json.NewEncoder(w).Encode(map[string]string{"error": e.message})
+}
+
+type ID int
+
+func (i *ID) UnmarshalJSON(data []byte) error {
+	id, err := strconv.Atoi(string(data))
+	if err != nil {
+		return err
+	}
+	*i = ID(id)
+	return nil
+}
+
+func (i *ID) UnmarshalText(text []byte) error {
+	id, err := strconv.Atoi(string(text))
+	if err != nil {
+		return err
+	}
+	*i = ID(id)
+	return nil
+}
+
+type User struct {
+	ID   ID     `json:"id"`
+	Name string `json:"name"`
+}
+
+type Service struct {
+	users []User
+}
+
+// GetUser by ID.
+//
+//happy:api GET /users/:id
+func (s *Service) GetUser(id ID) (User, error) {
+	for _, user := range s.users {
+		if user.ID == id {
+			return user, nil
+		}
+	}
+	return User{}, Errorf(http.StatusNotFound, "user %d not found", id)
+}
+
+//happy:api GET /users/:id/avatar
+func (s *Service) GetAvatar(id ID) ([]byte, error) {
+	return nil, Errorf(http.StatusNotFound, "avatar %d not found", id)
+}
+
+//happy:api POST /users authenticated
+func (s *Service) CreateUser(r *http.Request, user User) error {
+	username := r.Context().Value(AuthenticatedUser)
+	log.Printf("Authenticated user %s", username)
+	for _, u := range s.users {
+		if u.ID == user.ID {
+			return Errorf(http.StatusConflict, "user %d already exists", user.ID)
+		}
+	}
+	s.users = append(s.users, user)
+	return nil
+}
+
+type Paginate struct {
+	Page int
+	Size int
+}
+
+//happy:api GET /users
+func (s *Service) ListUsers(paginate Paginate) ([]User, error) {
+	return s.users, nil
+}
+
+//happy:api POST /shutdown
+func (s *Service) Shutdown(w http.ResponseWriter) {
+	fmt.Fprintln(w, "Shutting down...")
+	go func() { time.Sleep(time.Second); os.Exit(0) }()
+}
+
+type HAPIOptions interface {
+	HandlerOptions(*http.Request) map[string]string
+}
+
+type HAPIHandler interface {
+	http.Handler
+	HAPIOptions
+}
+
+type forwardHAPIHandler struct {
+	HAPIOptions
+	http.HandlerFunc
+}
+
+var Options struct{}
+
+type HAPIService interface {
+	HandlerOptions(*http.Request) map[string]string
+}
+
+// OptionsMiddleware adds the HAPIOptions to the request context under the key Options.
+func OptionsMiddleware(svc HAPIService, next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ctx := context.WithValue(r.Context(), Options, svc.HandlerOptions(r))
+		r = r.WithContext(ctx)
+		next.ServeHTTP(w, r)
+	})
+}
+
+var AuthenticatedUser struct{}
+
+func AuthMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		options := r.Context().Value(Options).(map[string]string)
+		_, authenticated := options["authenticated"]
+		if !authenticated {
+			next.ServeHTTP(w, r)
+			return
+		}
+		username, password, ok := r.BasicAuth()
+		if !ok || username != "alice" || password != "secret" {
+			http.Error(w, "Unauthorized", http.StatusUnauthorized)
+			return
+		}
+		ctx := context.WithValue(r.Context(), AuthenticatedUser, username)
+		r = r.WithContext(ctx)
+		next.ServeHTTP(w, r)
+	})
+}
+
+func main() {
+	service := &Service{
+		users: []User{{ID: 1, Name: "Alice"}, {ID: 2, Name: "Bob"}},
+	}
+	const address = "127.0.0.1:8080"
+	log.Printf("Starting server on http://%s\n", address)
+	http.ListenAndServe(address, OptionsMiddleware(service, AuthMiddleware(service)))
+}
diff --git a/testdata/main_api.go b/testdata/main_api.go
new file mode 100644
index 0000000..beb7452
--- /dev/null
+++ b/testdata/main_api.go
@@ -0,0 +1,181 @@
+// Code generated by happy. DO NOT EDIT.
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+)
+
+func (h *Service) HandlerOptions(r *http.Request) map[string]string {
+	parts := strings.Split(r.URL.Path, "/")
+	var params []string
+	_ = params
+	switch parts[0] {
+	case "":
+		if len(parts) == 1 {
+			return nil
+		}
+		switch parts[1] {
+		case "users":
+			if len(parts) == 2 {
+				switch r.Method { // Leaf
+				case "POST":
+					return map[string]string{"authenticated": ""}
+				}
+				return nil
+			}
+			return nil
+		}
+	}
+	return nil
+}
+
+func (h *Service) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	var err error
+	var res any
+	parts := strings.Split(r.URL.Path, "/")
+	var params []string
+	_ = params
+	switch parts[0] {
+	case "":
+		if len(parts) == 1 {
+			return
+		}
+		switch parts[1] {
+		case "users":
+			if len(parts) == 2 {
+				switch r.Method { // Leaf
+				case "POST":
+					var param1 User
+					if err := json.NewDecoder(r.Body).Decode(&param1); err != nil {
+						http.Error(w, fmt.Sprintf("Failed to decode request body: %s", err), http.StatusBadRequest)
+						return
+					}
+					err = h.CreateUser(r, param1)
+					goto matched
+				case "GET":
+					var param0 Paginate
+					if err := decodePaginate(r.URL.Query(), &param0); err != nil {
+						http.Error(w, fmt.Sprintf("Failed to decode query parameters: %!s(MISSING)", err), http.StatusBadRequest)
+						return
+					}
+					res, err = h.ListUsers(param0)
+					goto matched
+				}
+				return
+			}
+			switch parts[2] {
+			default: // Parameter :id
+				params = append(params, parts[2])
+				if len(parts) == 3 {
+					switch r.Method { // Leaf
+					case "GET":
+						var param0 ID
+						if err := param0.UnmarshalText([]byte(params[0])); err != nil {
+							http.Error(w, "id: "+err.Error(), http.StatusBadRequest)
+							return
+						}
+						res, err = h.GetUser(param0)
+						goto matched
+					}
+					return
+				}
+				switch parts[3] {
+				case "avatar":
+					if len(parts) == 4 {
+						switch r.Method { // Leaf
+						case "GET":
+							var param0 ID
+							if err := param0.UnmarshalText([]byte(params[0])); err != nil {
+								http.Error(w, "id: "+err.Error(), http.StatusBadRequest)
+								return
+							}
+							res, err = h.GetAvatar(param0)
+							goto matched
+						}
+						return
+					}
+					return
+				}
+			}
+		case "shutdown":
+			if len(parts) == 2 {
+				switch r.Method { // Leaf
+				case "POST":
+					h.Shutdown(w)
+					return
+					goto matched
+				}
+				return
+			}
+			return
+		}
+	}
+	// No match but we don't return a 404 here, to allow the default handler to take control.
+	return
+matched:
+
+	// Handle errors
+	if err != nil {
+		if herr, ok := err.(http.Handler); ok {
+			herr.ServeHTTP(w, r)
+		} else {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+		return
+	}
+
+	// Handle response
+	switch res := res.(type) {
+	case nil:
+		w.WriteHeader(http.StatusNoContent)
+	case string:
+		w.Header().Set("Content-Type", "text/html")
+		io.WriteString(w, res)
+	case []byte:
+		w.Header().Set("Content-Type", "application/octet-stream")
+		w.Write(res)
+	case *http.Response:
+		headers := w.Header()
+		for k, v := range res.Header {
+			headers[k] = v
+		}
+		w.WriteHeader(res.StatusCode)
+		_, _ = io.Copy(w, res.Body)
+	case io.ReadCloser:
+		w.Header().Set("Content-Type", "application/octet-stream")
+		_, _ = io.Copy(w, res)
+		res.Close()
+	case io.Reader:
+		w.Header().Set("Content-Type", "application/octet-stream")
+		_, _ = io.Copy(w, res)
+	default:
+		data, err := json.Marshal(res)
+		if err != nil {
+			http.Error(w, `failed to encode response: `+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.Header().Set("Content-Length", strconv.Itoa(len(data)))
+		w.WriteHeader(http.StatusOK)
+		w.Write(data)
+	}
+}
+func decodePaginate(p url.Values, out *Paginate) (err error) {
+	if q, ok := p["page"]; ok {
+		if out.Page, err = strconv.Atoi(q[len(q)-1]); err != nil {
+			return fmt.Errorf("failed to decode query parameter \"page\" into type int: %w", err)
+		}
+	}
+	if q, ok := p["size"]; ok {
+		if out.Size, err = strconv.Atoi(q[len(q)-1]); err != nil {
+			return fmt.Errorf("failed to decode query parameter \"size\" into type int: %w", err)
+		}
+	}
+	return nil
+}
diff --git a/testdata/main_test.go b/testdata/main_test.go
new file mode 100644
index 0000000..9a09a88
--- /dev/null
+++ b/testdata/main_test.go
@@ -0,0 +1,30 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/alecthomas/assert/v2"
+)
+
+func BenchmarkOptions(b *testing.B) {
+	b.ReportAllocs()
+	req, err := http.NewRequest("GET", "/users", nil)
+	assert.NoError(b, err)
+	svc := &Service{users: []User{{ID: 1, Name: "Alice"}, {ID: 2, Name: "Bob"}}}
+	for i := 0; i < b.N; i++ {
+		svc.HandlerOptions(req)
+	}
+}
+
+func BenchmarkRouting(b *testing.B) {
+	b.ReportAllocs()
+	req, err := http.NewRequest("GET", "/users", nil)
+	assert.NoError(b, err)
+	svc := &Service{users: []User{{ID: 1, Name: "Alice"}, {ID: 2, Name: "Bob"}}}
+	for i := 0; i < b.N; i++ {
+		w := httptest.NewRecorder()
+		svc.ServeHTTP(w, req)
+	}
+}