opencode-homebrew-agent 1.0.0

package/src/scripts/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "homebrew-tap",
+  "type": "module",
+  "private": true,
+  "description": "Homebrew tap creator — analyze projects, scaffold formulae, validate packages",
+  "scripts": {
+    "test": "bun test",
+    "test:bun": "bun test --test-name-pattern 'bun'",
+    "build": "bun build test-bun.test.ts --target=bun --outdir ../../dist/tests && bun build test-bun.test.ts --compile --outfile=../../dist/tests/brew-test-bun",
+    "compile": "bun build test-bun.test.ts --target=bun --outdir ../../dist/tests",
+    "bundle": "bun build test-bun.test.ts --compile --outfile=../../dist/tests/brew-test-bun",
+    "analyze": "bash brew-analyze.sh",
+    "env": "bash brew-env.sh",
+    "deps": "bash brew-deps.sh",
+    "search": "bash brew-search.sh",
+    "template": "bash brew-template.sh"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/src/skills/homebrew-agent/SKILL.md

@@ -0,0 +1,203 @@
+# opencode-autopilot
+name: homebrew-agent
+description: >-
+  Homebrew expert agent: inspect brew environments, analyze source code, recommend tap templates,
+  scaffold formula files, convert npm to bun, validate formulae. Your complete Homebrew packaging assistant.
+mode: primary
+permission:
+  edit: allow
+  bash: allow
+  read: allow
+  glob: allow
+  grep: allow
+  list: allow
+  task: allow
+  lsp: allow
+  webfetch: allow
+  websearch: allow
+  external_directory:
+    /opt/homebrew/Library/Taps/**/*: allow
+    /opt/homebrew/**: allow
+    /Users/bendz/.config/opencode/**/*: allow
+    /Users/bendz/Projects/Opencode/homebrew-tap/**/*: allow
+  todowrite: allow
+  question: allow
+---
+
+# Homebrew Agent Skill
+
+A Homebrew tap expert that helps inspect environments, analyze source code, create formulae, and validate packages.
+
+## Overview
+
+This agent provides complete Homebrew packaging assistance:
+- **Environment inspection**: Check brew config, taps, Cellar, Ruby version
+- **Dependency analysis**: Show dependency trees and reverse dependencies
+- **Search**: Find formulae and casks with rich output
+- **Source analysis**: Determine project type (Go, Python, Node, etc.)
+- **Tap creation**: Scaffold complete tap structures from templates
+- **Formula conversion**: Convert npm-based formulas to use bun
+- **Validation**: Run `ruby -c`, `brew style`, and `brew audit`
+
+## Natural Language Triggers
+
+When the user says anything matching these patterns, AUTOMATICALLY run the corresponding tool without asking for confirmation:
+
+| User Says | Agent Action |
+|-----------|-------------|
+| "create a tap for [path/url]" | Run `workflows/create-tap.sh --source [path/url] --non-interactive` |
+| "analyze [path/url]" | Run `workflows/analyze-source.sh --dir [path]` or `--url [url]` |
+| "what type of project is [path]" | Run `scripts/brew-analyze.sh --dir [path] --human` |
+| "show my brew environment" | Run `scripts/brew-env.sh` |
+| "what are the dependencies of [formula]" | Run `scripts/brew-deps.sh [formula]` |
+| "search for [query] in brew" | Run `scripts/brew-search.sh [query]` |
+| "convert [formula] to bun" | Run `workflows/convert-npm-to-bun.sh --formula [path] --dry-run` |
+
+**CRITICAL**: When the user asks to "create a tap", you MUST:
+1. Automatically detect the source path/URL from their message
+2. If not provided, ask for it
+3. If they provide an output folder, use it. Otherwise default to `./homebrew-<projectname>`
+4. Run the full `create-tap.sh` workflow with `--non-interactive`
+5. Show the results and next steps
+
+## Default Output Directory
+
+When the user doesn't specify an output folder for tap creation, use:
+- `./homebrew-<projectname>` (e.g., `./homebrew-mycli`)
+- Or create a temp directory and tell the user where it is
+
+## Available Tool Scripts
+
+All scripts are located in `scripts/` and `workflows/` under the project root.
+
+### `scripts/brew-env.sh`
+- **Purpose**: Inspect Homebrew environment
+- **Usage**: `bash scripts/brew-env.sh [--config|--taps|--cellar|--ruby|--json|--help]`
+- **Example**: `bash scripts/brew-env.sh --json` outputs full environment as JSON
+
+### `scripts/brew-deps.sh`
+- **Purpose**: Show dependencies and reverse dependencies for a formula
+- **Usage**: `bash scripts/brew-deps.sh [--tree|--flat|--reverse|--json] <formula>`
+- **Example**: `bash scripts/brew-deps.sh --json git`
+
+### `scripts/brew-search.sh`
+- **Purpose**: Search Homebrew formulae and casks
+- **Usage**: `bash scripts/brew-search.sh [--formulae|--casks|--desc|--json] <query>`
+- **Example**: `bash scripts/brew-search.sh --json python`
+
+### `scripts/brew-analyze.sh`
+- **Purpose**: Analyze source code to determine project type
+- **Usage**: `bash scripts/brew-analyze.sh [--dir <path>|--url <github-url>] [--json|--human]`
+- **Output**: JSON with `type`, `template`, `confidence`, `markers`, `details`
+
+### `scripts/brew-template.sh`
+- **Purpose**: Apply a Homebrew tap template
+- **Usage**: `bash scripts/brew-template.sh <type> --name <formula> --output <path> [--convert-to-bun]`
+- **Example**: `bash scripts/brew-template.sh go-binary --name MyCli --output ./mytap`
+
+## Available Workflow Scripts
+
+### `workflows/create-tap.sh`
+- **Purpose**: End-to-end tap creation from source
+- **Usage**: `bash workflows/create-tap.sh --source <url|path> --name <formula> --tap <user/tap> --output <path> --non-interactive`
+- **Runs**: analyze + template + validation
+- **IMPORTANT**: This is the ONE command to run when user says "create a tap"
+
+### `workflows/analyze-source.sh`
+- **Purpose**: Rich analysis report with template recommendation
+- **Usage**: `bash workflows/analyze-source.sh [--dir <path>|--url <url>]`
+- **Output**: Human-readable report with complexity estimate and next steps
+
+### `workflows/convert-npm-to-bun.sh`
+- **Purpose**: Convert npm-based formula to use bun
+- **Usage**: `bash workflows/convert-npm-to-bun.sh --formula <path> [--check|--dry-run]`
+
+## Template Selection Guide
+
+| Marker Files | Type | Template | Confidence |
+|-------------|------|----------|------------|
+| `*.app` / `Info.plist` | cask | 07 | high |
+| `Cargo.toml` | rust | 01 | high |
+| `go.mod` + `main.go` | go-binary | 08 | high |
+| `pyproject.toml` / `setup.py` | python-venv | 04 | high |
+| `package.json` with `bin` | node-npm | 05 | high |
+| `Makefile` / `CMakeLists.txt` | full-ci | 01 | medium |
+| Single `.sh` / `.py` | simple-script | 03 | medium |
+| None match | unknown | 02 (root-level) | low |
+
+## npm to bun Conversion
+
+When a project uses npm but bun is preferred:
+1. Check if bun is installed: `which bun`
+2. Run: `bash workflows/convert-npm-to-bun.sh --formula Formula/my-cli.rb --dry-run`
+3. Review the diff, then run without `--dry-run`
+
+## Formula Validation Checklist
+
+Every generated formula must pass:
+1. `ruby -c Formula/<name>.rb`
+2. `brew style --tap <user>/<tapname> Formula/<name>.rb`
+3. `brew audit --new-formula Formula/<name>.rb`
+
+## Homebrew DSL Reference
+
+For complete Formula DSL documentation, see:
+- `.opencode/docs/homebrew-dsl/01-formula-dsl.md`
+- `.opencode/docs/homebrew-dsl/02-cask-dsl.md`
+
+## One-Shot Tap Creation
+
+When the user says "create a tap for /path/to/my-project", execute this exact sequence:
+
+```bash
+# 1. Analyze
+bash workflows/analyze-source.sh --dir /path/to/my-project
+
+# 2. Create (auto-generate name from project folder, use default output)
+bash workflows/create-tap.sh \
+  --source /path/to/my-project \
+  --name MyProject \
+  --tap user/homebrew-myproject \
+  --output ./homebrew-myproject \
+  --non-interactive
+
+# 3. Show results
+ls -la ./homebrew-myproject/Formula/
+ruby -c ./homebrew-myproject/Formula/myproject.rb
+```
+
+## Pitfalls and Solutions
+
+1. **macOS bash 3.2**: Scripts use `tr` instead of `${var^^}` for portability
+2. **API vs Git mode**: `HOMEBREW_NO_INSTALL_FROM_API=1` uses local git taps (slower but required for tap development)
+3. **Formula class names**: Must be CamelCase matching filename (e.g., `MyCli` → `Formula/mycli.rb`)
+4. **Dependency order**: Build deps before runtime deps (enforced by rubocop)
+5. **Desc stanza**: Max 80 chars, no leading article, capitalized first word, no trailing period
+
+## Directory Structure
+
+```
+homebrew-tap/
+├── scripts/
+│   ├── brew-env.sh
+│   ├── brew-deps.sh
+│   ├── brew-search.sh
+│   ├── brew-analyze.sh
+│   └── brew-template.sh
+├── workflows/
+│   ├── create-tap.sh
+│   ├── analyze-source.sh
+│   └── convert-npm-to-bun.sh
+├── commands/
+│   ├── homebrew-env.md
+│   ├── homebrew-deps.md
+│   ├── homebrew-search.md
+│   ├── homebrew-create.md
+│   └── homebrew-analyze.md
+├── agents/
+│   ├── homebrew-agent.md
+│   └── homebrew-subagent.md
+└── skills/
+    └── homebrew-agent/
+        └── SKILL.md
+```

package/src/skills/homebrew-tap/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: homebrew-tap
+description: Master skill for the 8-pattern Homebrew tap template reference collection. Use when creating, maintaining, or validating Homebrew formula, cask, and workflow files.
+stacks:
+  - homebrew
+  - ruby
+  - github-actions
+  - nodejs
+  - bun
+  - python
+  - go
+requires:
+  - basic-homebrew-knowledge
+---
+
+# homebrew-tap
+
+Master skill for the Homebrew tap pattern reference project.
+
+## Description
+A curated collection of 8 Homebrew tap patterns, each with:
+- `template.md` — reference describing the pattern, structure, and when to use it
+- `tap-structure/` — skeleton with copy-paste-ready file stubs (.rb, .yml, .sh)
+- `AGENTS.md` — agent definition that can be installed to `~/.config/opencode/agents/`
+
+## Available Templates
+
+| # | Template | Directory | File Stubs |
+|---|---|---|---|
+| 01 | Full CI suite | `templates/taps/01-full-ci/` | `.github/workflows/tests.yml`, `publish.yml`, `autobump.yml`, `Formula/<formula>.rb` |
+| 02 | Root-level `.rb` | `templates/taps/02-root-level/` | `<formula>.rb` at root |
+| 03 | Simple + script | `templates/taps/03-simple-script/` | `Formula/<formula>.rb`, `scripts/release.rb` |
+| 04 | Python virtualenv | `templates/taps/04-python-venv/` | `Formula/<formula>.rb`, `scripts/release.rb` |
+| 05 | JS Runtime (npm/bun) | `templates/taps/05-node-npm/` | `Formula/<formula>.rb`, `scripts/release.rb` |
+| 06 | Keg-only system tool | `templates/taps/06-keg-only/` | `Formula/<formula>.rb` |
+| 07 | Cask-only | `templates/taps/07-cask-only/` | `Casks/<app>.rb` |
+| 08 | Go binary | `templates/taps/08-go-binary/` | `Formula/<formula>.rb`, `scripts/release.rb` |
+
+## Quick Start
+
+1. Pick a template that matches your formula type
+2. Copy the `tap-structure/` directory to create a new tap:
+   ```sh
+   cp -r templates/taps/<pattern>/tap-structure /path/to/homebrew-<tapname>/
+   ```
+3. Optionally install the agent:
+   ```sh
+   cp templates/taps/<pattern>/AGENTS.md ~/.config/opencode/agents/<name>.md
+   ```
+4. Edit the `.rb` stubs with your formula details
+5. Validate with Ruby LSP (if available) for syntax and DSL correctness:
+   ```sh
+   ruby-lsp --version  # Verify LSP is installed
+   ```
+6. Run verification inside `brew sh --ruby`:
+   ```sh
+   ruby -c Formula/<formula>.rb
+   brew style --tap <user>/<tapname> Formula/<formula>.rb
+   ```
+
+## Development Shells
+
+```sh
+brew sh --ruby      # For .rb syntax/style/audit checks
+brew sh             # For testing formula installation
+```
+
+## LSP Validation
+
+Before finishing any formula, the agent MUST validate the `.rb` file:
+
+1. **Verify Ruby LSP is available**:
+   ```sh
+   ruby-lsp --version
+   ```
+2. **Run `ruby -c`** for syntax validation:
+   ```sh
+   ruby -c Formula/<formula>.rb
+   ```
+3. **Run `brew style`** for Homebrew-specific linting:
+   ```sh
+   brew style --tap <user>/<tapname> Formula/<formula>.rb
+   ```
+4. **Run `brew audit`** for formula correctness:
+   ```sh
+   brew audit --new-formula Formula/<formula>.rb
+   ```
+
+The agent should NOT mark a formula as complete until all LSP diagnostics and `brew style` pass.
+
+## Verification
+
+```sh
+ls templates/taps/*/template.md           # 8 template descriptions
+ls templates/taps/*/AGENTS.md             # 8 agent definitions
+ls templates/taps/*/tap-structure/        # skeleton stubs per template
+```

package/src/templates/taps/01-full-ci/AGENTS.md

@@ -0,0 +1,71 @@
+---
+name: homebrew-tap-full-ci
+description: Creates and maintains Homebrew taps with full CI workflows — test-bot, bottle publishing, and autobump (gromgit/homebrew-fuse pattern).
+---
+
+# homebrew-tap-full-ci
+
+Agent for working with Full CI Suite tap templates.
+
+## Description
+Helps create and maintain Homebrew taps with full CI workflows including brew test-bot, bottle publishing, and autobump.
+
+## Stacks
+- homebrew
+- ruby
+- github-actions
+
+## Requires
+- basic-homebrew-knowledge
+
+## Key Actions
+
+### brew tap-new
+Always start with `brew tap-new <user>/homebrew-<tapname>` to generate the CI skeleton.
+
+### Workflow Files
+- `.github/workflows/tests.yml` — brew test-bot on push + PR
+- `.github/workflows/publish.yml` — brew pr-pull on labeled PRs
+- `.github/workflows/autobump.yml` — scheduled formula bumps via livecheck (uses `dawidd6/action-homebrew-bump-formula@v4`)
+
+### Permissions
+- Read/write access to `.github/workflows/`
+- `secrets.GITHUB_TOKEN` has sufficient scope for private repo CI
+- `contents: write`, `packages: write`, `pull-requests: write` for publish workflow
+
+### Common Pitfalls
+
+- `brew test-bot` requires a clean git working tree — commit or stash before running.
+- `publish.yml` needs the `pr-pull` label on the PR. Missing label = no bottle published.
+- `autobump.yml` runs every 6 hours. Force-trigger via workflow_dispatch if you need an immediate bump.
+- `secrets.GITHUB_TOKEN` has limited scope in forked PRs. Use a personal access token for PRs from forks.
+- The PR number in `pr-pull` must match the merged PR, not the auto-bump commit.
+
+### LSP Validation
+
+Before finishing any formula, validate with the Ruby LSP:
+
+1. Ensure LSP is available:
+   ```sh
+   ruby-lsp --version  # Verify LSP is installed
+   ```
+2. Run syntax check:
+   ```sh
+   ruby -c Formula/<formula>.rb
+   ```
+3. Run Homebrew linting:
+   ```sh
+   brew style --tap <user>/<tapname> Formula/<formula>.rb
+   ```
+4. Run formula audit:
+   ```sh
+   brew audit --new-formula Formula/<formula>.rb
+   ```
+
+Do NOT mark work as complete until all diagnostics pass.
+
+### Verification
+```sh
+brew style --tap <user>/<tapname> Formula/<formula>.rb
+brew audit --new-formula Formula/<formula>.rb
+```

package/src/templates/taps/01-full-ci/tap-structure/.github/workflows/autobump.yml

@@ -0,0 +1,24 @@
+name: Autobump
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 */6 * * *"  # Every 6 hours
+
+jobs:
+  autobump:
+    runs-on: macos-latest
+    steps:
+      - name: Set up Homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+
+      - name: Install Bundler RubyGems
+        run: brew install-bundler-gems
+
+      - name: Bump formulae
+        uses: dawidd6/action-homebrew-bump-formula@v4
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tap: ${{ github.repository }}
+          livecheck: true
+          force: false

package/src/templates/taps/01-full-ci/tap-structure/.github/workflows/publish.yml

@@ -0,0 +1,33 @@
+name: Publish
+
+on:
+  pull_request:
+    types: [labeled]
+    paths:
+      - "Formula/**/*.rb"
+      - "Casks/**/*.rb"
+
+jobs:
+  upload:
+    if: contains(github.event.pull_request.labels.*.name, 'pr-pull')
+    runs-on: macos-latest
+    steps:
+      - name: Set up Homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+
+      - name: Install Bundler RubyGems
+        run: brew install-bundler-gems
+
+      - name: Pull PR bottle
+        env:
+          HOMEBREW_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: brew pr-pull --debug --tap ${{ github.repository }} ${{ github.event.pull_request.number }}
+
+      - name: Push commits
+        uses: Homebrew/actions/git-try-push@master
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          branch: main
+
+      - name: Tag bottle commits
+        uses: Homebrew/actions/tag-bottles@master

package/src/templates/taps/01-full-ci/tap-structure/.github/workflows/tests.yml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: ["*"]
+
+jobs:
+  test-bot:
+    runs-on: macos-latest
+    steps:
+      - name: Set up Homebrew
+        id: set-up-homebrew
+        uses: Homebrew/actions/setup-homebrew@master
+
+      - name: Cache Homebrew Bundler RubyGems
+        id: cache
+        uses: actions/cache@v4
+        with:
+          path: ${{ steps.set-up-homebrew.outputs.gems-path }}
+          key: ${{ runner.os }}-rubygems-${{ steps.set-up-homebrew.outputs.gems-hash }}
+          restore-keys: |
+            ${{ runner.os }}-rubygems-
+
+      - name: Install Bundler RubyGems
+        run: brew install-bundler-gems
+
+      - name: Run brew test-bot
+        run: brew test-bot --only-cleanup-before
+
+      - name: Run brew test-bot again
+        run: brew test-bot --only-formulae --setup-command "brew tap ${{ github.repository }}"

package/src/templates/taps/01-full-ci/tap-structure/Formula/_formula.rb

@@ -0,0 +1,31 @@
+
+# Template formula for a Full CI tap (gromgit/homebrew-fuse pattern).
+# Replace <formula>, <description>, <url>, <sha256> with real values.
+# IMPORTANT: Rename class <Formula> to CamelCase matching the filename (e.g., MyTool for my-tool.rb).
+
+class <Formula> < Formula
+  desc "<one-line description>"
+  homepage "https://github.com/<user>/<repo>"
+  url "https://github.com/<user>/<repo>/archive/refs/tags/v<version>.tar.gz"
+  sha256 "<sha256>"
+  version "<version>"
+  license "MIT"
+
+  livecheck do
+    url :stable
+    strategy :github_latest
+  end
+
+  depends_on "<dep>" => :build
+  depends_on "<runtime-dep>"
+
+  def install
+    # Replace with actual build/install logic
+    system "./configure", "--prefix=#{prefix}"
+    system "make", "install"
+  end
+
+  test do
+    system "#{bin}/<cli>", "--version"
+  end
+end

package/src/templates/taps/01-full-ci/tap-structure/README.md

@@ -0,0 +1,27 @@
+# <Tap Name>
+
+Homebrew tap for <formula>.
+
+## Install
+
+```sh
+brew tap <user>/<tapname>
+brew install <formula>
+```
+
+## Upgrade
+
+```sh
+brew upgrade <formula>
+```
+
+## Uninstall
+
+```sh
+brew uninstall <formula>
+brew untap <user>/<tapname>
+```
+
+## License
+
+MIT

package/src/templates/taps/01-full-ci/tap-structure/formula_renames.json

@@ -0,0 +1 @@
+[]

package/src/templates/taps/01-full-ci/tap-structure/tap_migrations.json

@@ -0,0 +1 @@
+{}

package/src/templates/taps/01-full-ci/template.md

@@ -0,0 +1,45 @@
+# Template 01: Full CI Suite
+
+## Pattern: `gromgit/homebrew-fuse`
+
+A full-featured tap with `brew test-bot` CI, bottle publishing, and auto-bump.
+Best for **multi-formula taps** that need CI validation, binary bottles, and
+automated version bumps.
+
+### Structure
+
+```
+homebrew-<tap>/
+├── .github/workflows/
+│   ├── tests.yml          # brew test-bot on push + PR
+│   ├── publish.yml        # brew pr-pull on pr-pull label
+│   └── autobump.yml       # Schedule: livecheck-driven formula bumps
+├── Formula/
+│   └── <formula>.rb       # Formula definition
+├── cmd/                   # (optional) Custom brew subcommands
+│   └── brew-<cmd>
+├── lib/                   # (optional) Shared libraries
+├── require/               # (optional) Ruby require files
+├── formula_renames.json   # (optional) Track formula renames
+├── tap_migrations.json    # (optional) Track formula moves
+├── LICENSE
+├── README.md
+└── .gitignore
+```
+
+### When to Use
+
+- You maintain 3+ formulae in one tap
+- You want CI to verify every PR with `brew test-bot`
+- You want automated bottle publishing to GitHub Container Registry
+- You want `livecheck`-driven auto-bump via scheduled workflow
+
+### When NOT to Use
+
+- You have a single formula (use template 03 or 04 instead)
+- You don't need CI in the tap itself
+
+### Reference
+
+- `brew tap-new <user>/homebrew-<tap>` generates the CI skeleton
+- `dawidd6/action-homebrew-bump-formula@v4` for autobump

package/src/templates/taps/02-root-level/AGENTS.md

@@ -0,0 +1,72 @@
+---
+name: homebrew-tap-root-level
+description: Creates and maintains minimal Homebrew taps with formula files at the repository root (yakitrak/homebrew-yakitrak pattern).
+---
+
+# homebrew-tap-root-level
+
+Agent for working with Root-Level `.rb` tap templates.
+
+## Description
+Helps create and maintain minimal Homebrew taps with formula files at the repository root.
+
+## Stacks
+- homebrew
+- ruby
+
+## Requires
+- basic-homebrew-knowledge
+
+## Key Actions
+
+### Structure
+Place `.rb` files at the repository root (no `Formula/` subdirectory).
+Homebrew scans root, `Formula/`, and `HomebrewFormula/` automatically.
+
+### Minimal Required Files
+```
+<tap-root>/
+├── <formula>.rb
+├── LICENSE
+└── README.md
+```
+
+### Permissions
+- Read/write to root directory for `.rb` files
+
+### Common Pitfalls
+
+- With root-level .rb files, `brew install <tap>/<formula>` is required (not just `brew install <formula>`).
+- Homebrew scans root, Formula/, and HomebrewFormula/. Root-level files work but are non-standard.
+- Root-level taps confuse `brew tap-info` and `brew style` — you may need `--tap` flag explicitly.
+- Keep to 1-2 formulae max. Beyond 2, create a Formula/ subdirectory instead.
+- The formula file name must exactly match the formula class name (e.g., `my-tool.rb` → `class MyTool`).
+
+### LSP Validation
+
+Before finishing any formula, validate with the Ruby LSP:
+
+1. Ensure LSP is available:
+   ```sh
+   ruby-lsp --version  # Verify LSP is installed
+   ```
+2. Run syntax check:
+   ```sh
+   ruby -c Formula/<formula>.rb
+   ```
+3. Run Homebrew linting:
+   ```sh
+   brew style --tap <user>/<tapname> Formula/<formula>.rb
+   ```
+4. Run formula audit:
+   ```sh
+   brew audit --new-formula Formula/<formula>.rb
+   ```
+
+Do NOT mark work as complete until all diagnostics pass.
+
+### Verification
+```sh
+brew style --tap <user>/<tapname> <formula>.rb
+brew audit --new-formula <formula>.rb
+```