waitfor: block until a shell condition holds

--cmd exits 0 (+ optional --matches regex) or --timeout; exit 0/3/1,
last output always printed, --then hook composes with notifyr.
Injectable runner for tests + real-shell integration test.
Spec: doc/tool-parity.md 3.2.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011KikHkfCiC3yELbsMN8fT9

.gitea/workflows/release.yml

@@ -0,0 +1,111 @@
+name: release-tools
+
+# På varje push till master/main: bygg de tools som fått ändringar
+# (linux x64 + arm64) och lägg binärerna på en rullande
+# "<tool>-latest"-release på släppsidan i Gitea.
+on:
+  push:
+    branches: [master, main]
+  workflow_dispatch: {} # manuell körning bygger ALLA tools
+
+jobs:
+  build-release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # hela historiken behövs för diffen mot 'before'
+
+      - name: Detektera ändrade tools
+        id: changed
+        run: |
+          TOOLS="pixel-sprite-maker mesh-tool bitmap-font-maker sfx-maker hitbox-tool"
+          BEFORE="${{ github.event.before }}"
+          CHANGED=""
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ] \
+             || [ -z "$BEFORE" ] \
+             || echo "$BEFORE" | grep -Eq '^0+$' \
+             || ! git cat-file -e "$BEFORE" 2>/dev/null; then
+            echo "första push / manuell körning -> bygger alla tools"
+            CHANGED="$TOOLS"
+          else
+            for t in $TOOLS; do
+              if ! git diff --quiet "$BEFORE" "${{ github.sha }}" -- "$t/"; then
+                CHANGED="$CHANGED $t"
+              fi
+            done
+          fi
+          CHANGED="$(echo $CHANGED)"   # trimma whitespace
+          echo "tools=$CHANGED" >> "$GITHUB_OUTPUT"
+          echo "bygger: ${CHANGED:-inget}"
+
+      - name: Installera Go
+        if: steps.changed.outputs.tools != ''
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24"
+          cache: false
+
+      - name: Testa + bygg (x64 + arm64)
+        if: steps.changed.outputs.tools != ''
+        run: |
+          set -e
+          VERSION="latest-$(git rev-parse --short HEAD)"
+          for t in ${{ steps.changed.outputs.tools }}; do
+            case "$t" in
+              pixel-sprite-maker) BIN=spritec ;;
+              mesh-tool)          BIN=mesht ;;
+              bitmap-font-maker)  BIN=fontc ;;
+              sfx-maker)          BIN=sfxc ;;
+              hitbox-tool)        BIN=hitbox ;;
+              *) echo "okänt tool $t"; exit 1 ;;
+            esac
+            echo "=== $t ($BIN) ==="
+            cd "$t"
+            go test ./...
+            mkdir -p build
+            GOOS=linux GOARCH=amd64 go build -trimpath \
+              -ldflags "-s -w -X main.version=$VERSION" -o "build/$BIN-linux-x64" .
+            GOOS=linux GOARCH=arm64 go build -trimpath \
+              -ldflags "-s -w -X main.version=$VERSION" -o "build/$BIN-linux-arm64" .
+            (cd build && sha256sum "$BIN"-linux-* > checksums.txt && ls -la)
+            cd ..
+          done
+
+      - name: Skapa/uppdatera releaser + ladda upp binärer
+        if: steps.changed.outputs.tools != ''
+        env:
+          API: http://gitea-d:3000/api/v1
+          REPO: ${{ github.repository }}
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -e
+          for t in ${{ steps.changed.outputs.tools }}; do
+            case "$t" in
+              pixel-sprite-maker) BIN=spritec ;;
+              mesh-tool)          BIN=mesht ;;
+              bitmap-font-maker)  BIN=fontc ;;
+              sfx-maker)          BIN=sfxc ;;
+              hitbox-tool)        BIN=hitbox ;;
+            esac
+            TAG="$t-latest"
+            BODY="$t (binär: $BIN) - rullande bygge från senaste master. Commit: ${{ github.sha }}. Arkitekturer: linux x64 + arm64 (Pi5)."
+            rid=$(curl -s -X POST "$API/repos/$REPO/releases" \
+              -H "Authorization: token $TOKEN" -H 'Content-Type: application/json' \
+              -d "{\"tag_name\":\"$TAG\",\"name\":\"$TAG\",\"body\":\"$BODY\"}" | jq -r '.id // empty')
+            [ -z "$rid" ] && rid=$(curl -s "$API/repos/$REPO/releases/tags/$TAG" \
+              -H "Authorization: token $TOKEN" | jq -r '.id')
+            echo "$t -> release id $rid"
+            for f in "$BIN-linux-x64" "$BIN-linux-arm64" checksums.txt; do
+              aid=$(curl -s "$API/repos/$REPO/releases/$rid/assets" \
+                -H "Authorization: token $TOKEN" | jq -r ".[] | select(.name==\"$f\") | .id")
+              if [ -n "$aid" ] && [ "$aid" != "null" ]; then
+                curl -s -X DELETE "$API/repos/$REPO/releases/$rid/assets/$aid" \
+                  -H "Authorization: token $TOKEN" -o /dev/null
+              fi
+              curl -s -X POST "$API/repos/$REPO/releases/$rid/assets?name=$f" \
+                -H "Authorization: token $TOKEN" \
+                -F "attachment=@$t/build/$f" -o /dev/null -w "  $f -> HTTP %{http_code}\n"
+            done
+          done

.gitignore

@@ -0,0 +1,3 @@
+build/
+*.exe
+mesh-tool/examples/downloads/

.vscode/tasks.json

@@ -0,0 +1,92 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "build pixel-sprite-maker",
+      "type": "shell",
+      "command": "go build -trimpath -ldflags '-s -w' -o build/spritec .",
+      "options": { "cwd": "${workspaceFolder}/pixel-sprite-maker" },
+      "group": "build",
+      "problemMatcher": ["$go"]
+    },
+    {
+      "label": "build mesh-tool",
+      "type": "shell",
+      "command": "go build -trimpath -ldflags '-s -w' -o build/mesht .",
+      "options": { "cwd": "${workspaceFolder}/mesh-tool" },
+      "group": "build",
+      "problemMatcher": ["$go"]
+    },
+    {
+      "label": "build bitmap-font-maker",
+      "type": "shell",
+      "command": "go build -trimpath -ldflags '-s -w' -o build/fontc .",
+      "options": { "cwd": "${workspaceFolder}/bitmap-font-maker" },
+      "group": "build",
+      "problemMatcher": ["$go"]
+    },
+    {
+      "label": "test bitmap-font-maker",
+      "type": "shell",
+      "command": "go test ./...",
+      "options": { "cwd": "${workspaceFolder}/bitmap-font-maker" },
+      "group": "test",
+      "problemMatcher": ["$go"]
+    },
+    {
+      "label": "build sfx-maker",
+      "type": "shell",
+      "command": "go build -trimpath -ldflags '-s -w' -o build/sfxc .",
+      "options": { "cwd": "${workspaceFolder}/sfx-maker" },
+      "group": "build",
+      "problemMatcher": ["$go"]
+    },
+    {
+      "label": "test sfx-maker",
+      "type": "shell",
+      "command": "go test ./...",
+      "options": { "cwd": "${workspaceFolder}/sfx-maker" },
+      "group": "test",
+      "problemMatcher": ["$go"]
+    },
+    {
+      "label": "build hitbox-tool",
+      "type": "shell",
+      "command": "go build -trimpath -ldflags '-s -w' -o build/hitbox .",
+      "options": { "cwd": "${workspaceFolder}/hitbox-tool" },
+      "group": "build",
+      "problemMatcher": ["$go"]
+    },
+    {
+      "label": "test hitbox-tool",
+      "type": "shell",
+      "command": "go test ./...",
+      "options": { "cwd": "${workspaceFolder}/hitbox-tool" },
+      "group": "test",
+      "problemMatcher": ["$go"]
+    },
+    {
+      "label": "test pixel-sprite-maker",
+      "type": "shell",
+      "command": "go test ./...",
+      "options": { "cwd": "${workspaceFolder}/pixel-sprite-maker" },
+      "group": "test",
+      "problemMatcher": ["$go"]
+    },
+    {
+      "label": "test mesh-tool",
+      "type": "shell",
+      "command": "go test ./...",
+      "options": { "cwd": "${workspaceFolder}/mesh-tool" },
+      "group": "test",
+      "problemMatcher": ["$go"]
+    },
+    {
+      "label": "build",
+      "dependsOn": ["build pixel-sprite-maker", "build mesh-tool", "build bitmap-font-maker", "build sfx-maker", "build hitbox-tool"],
+      "dependsOrder": "parallel",
+      "group": { "kind": "build", "isDefault": true },
+      "problemMatcher": []
+    }
+  ]
+}

README.md

@@ -1,3 +1,58 @@
 # agent-tools
 
-smal tools for ai agents
+Small, self-contained CLI tools built for **AI agents** to use during
+development work. Every tool is a single static Go binary with a
+text-first interface: input formats an agent can read and write
+directly, and output (names, errors, previews) explicit enough that the
+agent understands the result without opening an image viewer.
+
+| Tool | Binary | What it does |
+|------|--------|--------------|
+| [`pixel-sprite-maker/`](pixel-sprite-maker/) | `spritec` | Turns `.sprite` text files (palette + character grid) into PNG/JPG/SVG pixel art, up to 256x256 px per sprite. Combines several sprites into sprite sheets / animation strips whose **file names document the layout** (`walk_8x8_4x1.png` = 8x8 px frames, 4 columns, 1 row). |
+| [`mesh-tool/`](mesh-tool/) | `mesht` | Creates, inspects and edits 3D models (OBJ + STL). ASCII multi-view rendering + measurements (bbox, volume, watertightness) let an agent *see* a model, edit it (scale/rotate/mirror/merge/primitives) and verify the result. |
+| [`bitmap-font-maker/`](bitmap-font-maker/) | `fontc` | Turns `.font` text files (pixel glyph grids, proportional widths) into font atlases (PNG + JSON metrics) and renders text strings to PNG or the terminal. |
+| [`sfx-maker/`](sfx-maker/) | `sfxc` | Synthesizes retro game sound effects (sfxr-style) from `.sfx` text presets to 16-bit WAV: waves, envelope, pitch slides, vibrato, arpeggio, filters. Deterministic, with built-in presets (jump, coin, laser…). |
+| [`hitbox-tool/`](hitbox-tool/) | `hitbox` | Scans sprite sheet PNGs and writes per-frame collision boxes as JSON from the alpha channel. Understands the spritec sheet naming convention including upscaled sheets. |
+
+Each tool has its own folder, its own README with the full format/CLI
+reference, its own tests and its own dev branch (`dev/<tool>`).
+
+## Planned: agent-capability & homelab-admin tools
+
+[`doc/tool-parity.md`](doc/tool-parity.md) compares Gemini CLI's
+built-in tools with Claude Code's, and specs the CLI tools that close
+the gaps (`notifyr`, `giteactl`, `waitfor`, `cronr`, `fleet`,
+`envaudit`, `reghelper`, `pagepub`, `nbcell`, `wtreectl`, `fanout`) so
+any agent gets the same capabilities via `run_shell_command`. Build
+order and rationale live there and in [`doc/plan.md`](doc/plan.md).
+
+## Building
+
+```bash
+# Arch/Garuda prerequisite:
+sudo pacman -S go
+
+cd <tool>/ && go build -o build/<binary> .    # per tool
+go test ./...                                 # per tool
+```
+
+VS Code: **Terminal → Run Build Task** — `build` builds every tool into
+its own `<tool>/build/` folder; per-tool `build <tool>` and
+`test <tool>` tasks also exist.
+
+## CI / releases
+
+`.gitea/workflows/release.yml` runs on every push to `master`/`main` on
+the self-hosted runner: tools whose folders changed are tested, built
+for **linux x64 + arm64** (the Pi5), and published to a rolling
+release per tool on the repo's release page:
+
+- tag `pixel-sprite-maker-latest` → assets `spritec-linux-x64`, `spritec-linux-arm64`, `checksums.txt`
+- tag `mesh-tool-latest` → assets `mesht-linux-x64`, `mesht-linux-arm64`, `checksums.txt`
+
+A manual `workflow_dispatch` run builds all tools regardless of diffs.
+
+## Branch layout
+
+- `main` — stable, releases are built from here
+- `dev/pixel-sprite-maker`, `dev/mesh-tool` — per-tool development branches

bitmap-font-maker/README.md

@@ -0,0 +1,75 @@
+# bitmap-font-maker (`fontc`)
+
+Turns `.font` text files — pixel glyph grids an agent can read and edit
+directly — into **font atlases (PNG + JSON metrics)** and renders text
+strings to PNG. Proportional widths, unicode glyph names (ÅÄÖ works).
+Go, zero dependencies, single static binary.
+
+## Build
+
+```bash
+# Arch/Garuda: sudo pacman -S go
+cd bitmap-font-maker
+go build -o build/fontc .        # or the VS Code task "build bitmap-font-maker"
+go test ./...
+```
+
+## The `.font` format
+
+```
+# comment
+font: tiny5          optional name
+spacing: 1           px between glyphs (default 1)
+space-width: 3       advance of ' ' (default: width of '0')
+line-height: 7       default: glyph height + 1
+baseline: 5          default: glyph height
+
+glyph A:
+  .#.
+  #.#
+  ###
+  #.#
+  #.#
+
+glyph ::             the char between "glyph " and ":" is literal
+  .
+  #
+  .
+  #
+  .
+```
+
+- `#` = pixel on, `.` = off.
+- **All glyphs share one height; widths may differ** (proportional fonts —
+  `M` can be 5 px wide while `.` is 1 px).
+- Max glyph size 64x64.
+
+## Commands
+
+```bash
+fontc build tiny5.font -o out/tiny5        # -> tiny5.png (atlas) + tiny5.json (metrics)
+fontc render tiny5.font 'HEJ!\nRAD 2' --scale 4 --color '#FFD700' -o title.png
+fontc info tiny5.font                      # validate + list glyphs
+fontc preview tiny5.font 'HELLO'           # draw in the terminal
+```
+
+## Atlas + metrics
+
+The atlas draws glyphs **white on transparent** so game engines can tint
+them. The JSON carries everything a loader needs:
+
+```json
+{
+  "name": "tiny5", "atlas": "tiny5.png",
+  "height": 5, "lineHeight": 6, "baseline": 5,
+  "spacing": 1, "spaceWidth": 3,
+  "glyphs": { "A": {"x": 0, "y": 0, "w": 3, "h": 5, "advance": 4}, ... }
+}
+```
+
+Drawing text in a game: blit `glyphs[c]` from the atlas, advance the
+cursor by `advance`; spaces advance `spaceWidth + spacing`; new lines
+step `lineHeight`.
+
+[`examples/tiny5.font`](examples/tiny5.font) is a complete 3x5 font:
+A-Z, ÅÄÖ, 0-9 and punctuation.

bitmap-font-maker/examples/out/tiny5.json

@@ -0,0 +1,340 @@
+{
+  "name": "tiny5",
+  "atlas": "tiny5.png",
+  "height": 5,
+  "lineHeight": 6,
+  "baseline": 5,
+  "spacing": 1,
+  "spaceWidth": 3,
+  "glyphs": {
+    "!": {
+      "x": 36,
+      "y": 30,
+      "w": 1,
+      "h": 5,
+      "advance": 2
+    },
+    "'": {
+      "x": 24,
+      "y": 36,
+      "w": 1,
+      "h": 5,
+      "advance": 2
+    },
+    "+": {
+      "x": 18,
+      "y": 36,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    ",": {
+      "x": 30,
+      "y": 30,
+      "w": 2,
+      "h": 5,
+      "advance": 3
+    },
+    "-": {
+      "x": 12,
+      "y": 36,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    ".": {
+      "x": 24,
+      "y": 30,
+      "w": 1,
+      "h": 5,
+      "advance": 2
+    },
+    "0": {
+      "x": 6,
+      "y": 24,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "1": {
+      "x": 12,
+      "y": 24,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "2": {
+      "x": 18,
+      "y": 24,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "3": {
+      "x": 24,
+      "y": 24,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "4": {
+      "x": 30,
+      "y": 24,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "5": {
+      "x": 36,
+      "y": 24,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "6": {
+      "x": 0,
+      "y": 30,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "7": {
+      "x": 6,
+      "y": 30,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "8": {
+      "x": 12,
+      "y": 30,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "9": {
+      "x": 18,
+      "y": 30,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    ":": {
+      "x": 6,
+      "y": 36,
+      "w": 1,
+      "h": 5,
+      "advance": 2
+    },
+    "?": {
+      "x": 0,
+      "y": 36,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "A": {
+      "x": 0,
+      "y": 0,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "B": {
+      "x": 6,
+      "y": 0,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "C": {
+      "x": 12,
+      "y": 0,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "D": {
+      "x": 18,
+      "y": 0,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "E": {
+      "x": 24,
+      "y": 0,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "F": {
+      "x": 30,
+      "y": 0,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "G": {
+      "x": 36,
+      "y": 0,
+      "w": 4,
+      "h": 5,
+      "advance": 5
+    },
+    "H": {
+      "x": 0,
+      "y": 6,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "I": {
+      "x": 6,
+      "y": 6,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "J": {
+      "x": 12,
+      "y": 6,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "K": {
+      "x": 18,
+      "y": 6,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "L": {
+      "x": 24,
+      "y": 6,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "M": {
+      "x": 30,
+      "y": 6,
+      "w": 5,
+      "h": 5,
+      "advance": 6
+    },
+    "N": {
+      "x": 36,
+      "y": 6,
+      "w": 4,
+      "h": 5,
+      "advance": 5
+    },
+    "O": {
+      "x": 0,
+      "y": 12,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "P": {
+      "x": 6,
+      "y": 12,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "Q": {
+      "x": 12,
+      "y": 12,
+      "w": 4,
+      "h": 5,
+      "advance": 5
+    },
+    "R": {
+      "x": 18,
+      "y": 12,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "S": {
+      "x": 24,
+      "y": 12,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "T": {
+      "x": 30,
+      "y": 12,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "U": {
+      "x": 36,
+      "y": 12,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "V": {
+      "x": 0,
+      "y": 18,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "W": {
+      "x": 6,
+      "y": 18,
+      "w": 5,
+      "h": 5,
+      "advance": 6
+    },
+    "X": {
+      "x": 12,
+      "y": 18,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "Y": {
+      "x": 18,
+      "y": 18,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "Z": {
+      "x": 24,
+      "y": 18,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "Ä": {
+      "x": 36,
+      "y": 18,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "Å": {
+      "x": 30,
+      "y": 18,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    },
+    "Ö": {
+      "x": 0,
+      "y": 24,
+      "w": 3,
+      "h": 5,
+      "advance": 4
+    }
+  }
+}

bitmap-font-maker/examples/tiny5.font

@@ -0,0 +1,334 @@
+# tiny5 - a 3x5 pixel font (uppercase + digits + Swedish ÅÄÖ).
+# Widths vary: M/W are 5 px, punctuation as narrow as 1 px.
+font: tiny5
+spacing: 1
+space-width: 3
+
+glyph A:
+.#.
+#.#
+###
+#.#
+#.#
+
+glyph B:
+##.
+#.#
+##.
+#.#
+##.
+
+glyph C:
+.##
+#..
+#..
+#..
+.##
+
+glyph D:
+##.
+#.#
+#.#
+#.#
+##.
+
+glyph E:
+###
+#..
+##.
+#..
+###
+
+glyph F:
+###
+#..
+##.
+#..
+#..
+
+glyph G:
+.###
+#...
+#.##
+#..#
+.##.
+
+glyph H:
+#.#
+#.#
+###
+#.#
+#.#
+
+glyph I:
+###
+.#.
+.#.
+.#.
+###
+
+glyph J:
+..#
+..#
+..#
+#.#
+.#.
+
+glyph K:
+#.#
+#.#
+##.
+#.#
+#.#
+
+glyph L:
+#..
+#..
+#..
+#..
+###
+
+glyph M:
+#...#
+##.##
+#.#.#
+#...#
+#...#
+
+glyph N:
+#..#
+##.#
+#.##
+#..#
+#..#
+
+glyph O:
+.#.
+#.#
+#.#
+#.#
+.#.
+
+glyph P:
+##.
+#.#
+##.
+#..
+#..
+
+glyph Q:
+.##.
+#..#
+#..#
+#.#.
+.#.#
+
+glyph R:
+##.
+#.#
+##.
+#.#
+#.#
+
+glyph S:
+.##
+#..
+.#.
+..#
+##.
+
+glyph T:
+###
+.#.
+.#.
+.#.
+.#.
+
+glyph U:
+#.#
+#.#
+#.#
+#.#
+###
+
+glyph V:
+#.#
+#.#
+#.#
+#.#
+.#.
+
+glyph W:
+#...#
+#...#
+#.#.#
+##.##
+#...#
+
+glyph X:
+#.#
+#.#
+.#.
+#.#
+#.#
+
+glyph Y:
+#.#
+#.#
+.#.
+.#.
+.#.
+
+glyph Z:
+###
+..#
+.#.
+#..
+###
+
+glyph Å:
+.#.
+.#.
+#.#
+###
+#.#
+
+glyph Ä:
+#.#
+.#.
+#.#
+###
+#.#
+
+glyph Ö:
+#.#
+.#.
+#.#
+#.#
+.#.
+
+glyph 0:
+###
+#.#
+#.#
+#.#
+###
+
+glyph 1:
+.#.
+##.
+.#.
+.#.
+###
+
+glyph 2:
+##.
+..#
+.#.
+#..
+###
+
+glyph 3:
+###
+..#
+.##
+..#
+###
+
+glyph 4:
+#.#
+#.#
+###
+..#
+..#
+
+glyph 5:
+###
+#..
+##.
+..#
+##.
+
+glyph 6:
+.##
+#..
+###
+#.#
+###
+
+glyph 7:
+###
+..#
+.#.
+.#.
+.#.
+
+glyph 8:
+###
+#.#
+###
+#.#
+###
+
+glyph 9:
+###
+#.#
+###
+..#
+##.
+
+glyph .:
+.
+.
+.
+.
+#
+
+glyph ,:
+..
+..
+..
+.#
+#.
+
+glyph !:
+#
+#
+#
+.
+#
+
+glyph ?:
+###
+..#
+.#.
+...
+.#.
+
+glyph ::
+.
+#
+.
+#
+.
+
+glyph -:
+...
+...
+###
+...
+...
+
+glyph +:
+...
+.#.
+###
+.#.
+...
+
+glyph ':
+#
+#
+.
+.
+.

bitmap-font-maker/font/font.go

@@ -0,0 +1,238 @@
+// Package font parses .font text files and renders bitmap fonts to
+// atlases (PNG + JSON metrics) and text images.
+package font
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// MaxGlyphSize bounds glyph width/height in pixels.
+const MaxGlyphSize = 64
+
+// Glyph is one character's bitmap: rows of booleans (true = pixel on).
+// All glyphs in a font share the same height; widths vary
+// (proportional fonts).
+type Glyph struct {
+	Char rune
+	W, H int
+	Rows [][]bool
+}
+
+// Font is a parsed .font file.
+type Font struct {
+	Name       string
+	Height     int // glyph height, uniform across the font
+	LineHeight int // suggested distance between text baselines
+	Baseline   int // rows from glyph top to the baseline
+	Spacing    int // horizontal px between glyphs
+	SpaceWidth int // advance of ' '
+	Glyphs     map[rune]*Glyph
+	Order      []rune // file order, for stable atlas layout
+}
+
+// ParseFile reads a .font file; the font name defaults to the file name.
+func ParseFile(path string) (*Font, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	ft, err := Parse(f)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", path, err)
+	}
+	if ft.Name == "" {
+		ft.Name = strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+	}
+	return ft, nil
+}
+
+// Parse reads the .font text format:
+//
+//	# comment
+//	font: tiny5            optional name
+//	spacing: 1             px between glyphs (default 1)
+//	space-width: 3         advance of ' ' (default: width of '0' or 3)
+//	line-height: 7         default: glyph height + 1
+//	baseline: 5            default: glyph height
+//
+//	glyph A:
+//	  .#.
+//	  #.#
+//	  ###
+//	  #.#
+//	  #.#
+//
+// Glyph grids use '#' for on and '.' for off. Every glyph must have the
+// same height; widths may differ. The char between "glyph " and the
+// trailing ':' is taken literally (one character, e.g. "glyph ::").
+func Parse(r io.Reader) (*Font, error) {
+	ft := &Font{
+		Spacing:    1,
+		SpaceWidth: -1, // resolved in validate
+		LineHeight: -1,
+		Baseline:   -1,
+		Glyphs:     map[rune]*Glyph{},
+	}
+	var cur *Glyph
+	sc := bufio.NewScanner(r)
+	sc.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+	lineNo := 0
+	flush := func() error {
+		if cur == nil {
+			return nil
+		}
+		if len(cur.Rows) == 0 {
+			return fmt.Errorf("glyph %q has no grid rows", string(cur.Char))
+		}
+		cur.H = len(cur.Rows)
+		cur.W = len(cur.Rows[0])
+		for i, row := range cur.Rows {
+			if len(row) != cur.W {
+				return fmt.Errorf("glyph %q row %d is %d px wide, expected %d", string(cur.Char), i+1, len(row), cur.W)
+			}
+		}
+		if cur.W > MaxGlyphSize || cur.H > MaxGlyphSize {
+			return fmt.Errorf("glyph %q is %dx%d; the maximum is %dx%d", string(cur.Char), cur.W, cur.H, MaxGlyphSize, MaxGlyphSize)
+		}
+		if _, dup := ft.Glyphs[cur.Char]; dup {
+			return fmt.Errorf("glyph %q defined twice", string(cur.Char))
+		}
+		ft.Glyphs[cur.Char] = cur
+		ft.Order = append(ft.Order, cur.Char)
+		cur = nil
+		return nil
+	}
+	for sc.Scan() {
+		lineNo++
+		line := strings.TrimSpace(sc.Text())
+		if line == "" {
+			continue
+		}
+		// '#' starts a comment — except inside a glyph where a line of
+		// only '#'/'.' is a grid row.
+		if strings.HasPrefix(line, "#") && !(cur != nil && isGridLine(line)) {
+			continue
+		}
+		if strings.HasPrefix(strings.ToLower(line), "glyph ") && strings.HasSuffix(line, ":") {
+			if err := flush(); err != nil {
+				return nil, fmt.Errorf("line %d: %w", lineNo, err)
+			}
+			name := strings.TrimSuffix(line[len("glyph "):], ":")
+			runes := []rune(name)
+			if len(runes) != 1 {
+				return nil, fmt.Errorf("line %d: glyph name %q must be exactly one character", lineNo, name)
+			}
+			cur = &Glyph{Char: runes[0]}
+			continue
+		}
+		if cur != nil && isGridLine(line) {
+			row := make([]bool, 0, len(line))
+			for _, r := range line {
+				row = append(row, r == '#')
+			}
+			cur.Rows = append(cur.Rows, row)
+			continue
+		}
+		// header key: value
+		if i := strings.Index(line, ":"); i > 0 && cur == nil {
+			key := strings.ToLower(strings.TrimSpace(line[:i]))
+			val := strings.TrimSpace(line[i+1:])
+			var err error
+			switch key {
+			case "font":
+				ft.Name = val
+			case "spacing":
+				ft.Spacing, err = strconv.Atoi(val)
+			case "space-width":
+				ft.SpaceWidth, err = strconv.Atoi(val)
+			case "line-height":
+				ft.LineHeight, err = strconv.Atoi(val)
+			case "baseline":
+				ft.Baseline, err = strconv.Atoi(val)
+			default:
+				return nil, fmt.Errorf("line %d: unknown setting %q", lineNo, key)
+			}
+			if err != nil {
+				return nil, fmt.Errorf("line %d: %s: %v", lineNo, key, err)
+			}
+			continue
+		}
+		return nil, fmt.Errorf("line %d: unexpected %q (want 'key: value', 'glyph X:' or a #/. grid row)", lineNo, line)
+	}
+	if err := sc.Err(); err != nil {
+		return nil, err
+	}
+	if err := flush(); err != nil {
+		return nil, err
+	}
+	return ft, ft.validate()
+}
+
+// isGridLine reports whether the line consists solely of '#' and '.'.
+func isGridLine(s string) bool {
+	if s == "" {
+		return false
+	}
+	for _, r := range s {
+		if r != '#' && r != '.' {
+			return false
+		}
+	}
+	return true
+}
+
+func (ft *Font) validate() error {
+	if len(ft.Order) == 0 {
+		return fmt.Errorf("font has no glyphs")
+	}
+	ft.Height = ft.Glyphs[ft.Order[0]].H
+	for _, r := range ft.Order {
+		if g := ft.Glyphs[r]; g.H != ft.Height {
+			return fmt.Errorf("glyph %q is %d px tall but %q is %d — all glyphs must share one height",
+				string(r), g.H, string(ft.Order[0]), ft.Height)
+		}
+	}
+	if ft.LineHeight < 0 {
+		ft.LineHeight = ft.Height + 1
+	}
+	if ft.Baseline < 0 {
+		ft.Baseline = ft.Height
+	}
+	if ft.SpaceWidth < 0 {
+		if g, ok := ft.Glyphs['0']; ok {
+			ft.SpaceWidth = g.W
+		} else {
+			ft.SpaceWidth = 3
+		}
+	}
+	if ft.Spacing < 0 {
+		return fmt.Errorf("spacing must be >= 0")
+	}
+	return nil
+}
+
+// MaxGlyphWidth returns the widest glyph's width.
+func (ft *Font) MaxGlyphWidth() int {
+	w := 0
+	for _, r := range ft.Order {
+		if g := ft.Glyphs[r]; g.W > w {
+			w = g.W
+		}
+	}
+	return w
+}
+
+// SortedChars returns the glyph chars sorted by codepoint (JSON stability).
+func (ft *Font) SortedChars() []rune {
+	out := append([]rune(nil), ft.Order...)
+	sort.Slice(out, func(i, j int) bool { return out[i] < out[j] })
+	return out
+}

bitmap-font-maker/font/font_test.go

@@ -0,0 +1,144 @@
+package font
+
+import (
+	"bytes"
+	"encoding/json"
+	"image/color"
+	"strings"
+	"testing"
+)
+
+const tiny = `
+font: t
+spacing: 1
+space-width: 2
+
+glyph A:
+.#.
+#.#
+###
+
+glyph I:
+#
+#
+#
+`
+
+func parseOK(t *testing.T, src string) *Font {
+	t.Helper()
+	ft, err := Parse(strings.NewReader(src))
+	if err != nil {
+		t.Fatalf("parse: %v", err)
+	}
+	return ft
+}
+
+func TestParseBasics(t *testing.T) {
+	ft := parseOK(t, tiny)
+	if ft.Name != "t" || ft.Height != 3 || len(ft.Order) != 2 {
+		t.Errorf("name=%q height=%d glyphs=%d", ft.Name, ft.Height, len(ft.Order))
+	}
+	a := ft.Glyphs['A']
+	if a.W != 3 || a.H != 3 {
+		t.Errorf("A is %dx%d, want 3x3", a.W, a.H)
+	}
+	if !a.Rows[1][0] || a.Rows[0][0] {
+		t.Error("A pixel pattern wrong")
+	}
+	i := ft.Glyphs['I']
+	if i.W != 1 {
+		t.Errorf("I width = %d, want 1 (proportional)", i.W)
+	}
+	if ft.LineHeight != 4 || ft.Baseline != 3 {
+		t.Errorf("defaults: lineHeight=%d baseline=%d", ft.LineHeight, ft.Baseline)
+	}
+}
+
+func TestParseErrors(t *testing.T) {
+	cases := map[string]string{
+		"no glyphs":      "font: x\n",
+		"ragged glyph":   "glyph A:\n##\n#\n",
+		"height differs": "glyph A:\n#\n#\n\nglyph B:\n#\n",
+		"dup glyph":      "glyph A:\n#\n\nglyph A:\n#\n",
+		"bad name":       "glyph AB:\n#\n",
+		"unknown key":    "wat: 3\nglyph A:\n#\n",
+	}
+	for name, src := range cases {
+		if _, err := Parse(strings.NewReader(src)); err == nil {
+			t.Errorf("%s: expected error", name)
+		}
+	}
+}
+
+func TestGlyphNameColon(t *testing.T) {
+	ft := parseOK(t, "glyph ::\n#\n#\n")
+	if _, ok := ft.Glyphs[':']; !ok {
+		t.Error("glyph ':' not parsed")
+	}
+}
+
+func TestAtlasAndMetrics(t *testing.T) {
+	ft := parseOK(t, tiny)
+	img, m := ft.BuildAtlas("t.png")
+	if m.Glyphs["A"].Advance != 4 {
+		t.Errorf("A advance = %d, want 4 (w3 + spacing1)", m.Glyphs["A"].Advance)
+	}
+	g := m.Glyphs["A"]
+	// center-top pixel of A within its atlas cell: (x+1, y+0)
+	if img.NRGBAAt(g.X+1, g.Y).A == 0 {
+		t.Error("A apex pixel missing in atlas")
+	}
+	if img.NRGBAAt(g.X, g.Y).A != 0 {
+		t.Error("A corner should be empty")
+	}
+	var buf bytes.Buffer
+	if err := WriteMetrics(&buf, m); err != nil {
+		t.Fatal(err)
+	}
+	var back Metrics
+	if err := json.Unmarshal(buf.Bytes(), &back); err != nil {
+		t.Fatalf("metrics json invalid: %v", err)
+	}
+	if back.Glyphs["I"].W != 1 {
+		t.Errorf("metrics roundtrip: I.w = %d", back.Glyphs["I"].W)
+	}
+}
+
+func TestRenderText(t *testing.T) {
+	ft := parseOK(t, tiny)
+	white := color.NRGBA{255, 255, 255, 255}
+	img, warns := ft.RenderText("AI", 1, white)
+	if len(warns) != 0 {
+		t.Errorf("warnings: %v", warns)
+	}
+	// width: A(3) + spacing(1) + I(1) = 5
+	if b := img.Bounds(); b.Dx() != 5 || b.Dy() != 3 {
+		t.Errorf("size = %dx%d, want 5x3", b.Dx(), b.Dy())
+	}
+	// I column at x=4
+	if img.NRGBAAt(4, 0).A == 0 {
+		t.Error("I pixel missing")
+	}
+
+	_, warns = ft.RenderText("AXA", 1, white)
+	if len(warns) != 1 {
+		t.Errorf("missing-glyph warning expected, got %v", warns)
+	}
+
+	img, _ = ft.RenderText(`A\nA`, 1, white)
+	if b := img.Bounds(); b.Dy() != ft.LineHeight+ft.Height {
+		t.Errorf("two-line height = %d, want %d", b.Dy(), ft.LineHeight+ft.Height)
+	}
+
+	img2, _ := ft.RenderText("A", 3, white)
+	if b := img2.Bounds(); b.Dx() != 9 || b.Dy() != 9 {
+		t.Errorf("scaled size = %dx%d, want 9x9", b.Dx(), b.Dy())
+	}
+}
+
+func TestSpaceWidthDefaultFromZero(t *testing.T) {
+	ft := parseOK(t, "glyph 0:\n####\n####\n")
+	if ft.SpaceWidth != 4 {
+		t.Errorf("space-width = %d, want 4 (width of '0')", ft.SpaceWidth)
+	}
+}

bitmap-font-maker/font/render.go

@@ -0,0 +1,165 @@
+package font
+
+import (
+	"encoding/json"
+	"fmt"
+	"image"
+	"image/color"
+	"image/png"
+	"io"
+	"strings"
+)
+
+// AtlasGlyph is one glyph's placement in the atlas.
+type AtlasGlyph struct {
+	X       int `json:"x"`
+	Y       int `json:"y"`
+	W       int `json:"w"`
+	H       int `json:"h"`
+	Advance int `json:"advance"` // cursor movement after drawing: W + spacing
+}
+
+// Metrics is the JSON sidecar written next to the atlas PNG.
+type Metrics struct {
+	Name       string                `json:"name"`
+	Atlas      string                `json:"atlas"`
+	Height     int                   `json:"height"`
+	LineHeight int                   `json:"lineHeight"`
+	Baseline   int                   `json:"baseline"`
+	Spacing    int                   `json:"spacing"`
+	SpaceWidth int                   `json:"spaceWidth"`
+	Glyphs     map[string]AtlasGlyph `json:"glyphs"`
+}
+
+// BuildAtlas packs all glyphs into a grid atlas image (white pixels on
+// transparency, so game engines can tint) and returns the metrics.
+// atlasName is stored in the metrics so loaders can find the image.
+func (ft *Font) BuildAtlas(atlasName string) (*image.NRGBA, *Metrics) {
+	n := len(ft.Order)
+	cols := 1
+	for cols*cols < n {
+		cols++
+	}
+	rows := (n + cols - 1) / cols
+	cellW := ft.MaxGlyphWidth() + 1 // 1 px padding against bleed
+	cellH := ft.Height + 1
+	img := image.NewNRGBA(image.Rect(0, 0, cols*cellW, rows*cellH))
+	white := color.NRGBA{255, 255, 255, 255}
+
+	m := &Metrics{
+		Name:       ft.Name,
+		Atlas:      atlasName,
+		Height:     ft.Height,
+		LineHeight: ft.LineHeight,
+		Baseline:   ft.Baseline,
+		Spacing:    ft.Spacing,
+		SpaceWidth: ft.SpaceWidth,
+		Glyphs:     map[string]AtlasGlyph{},
+	}
+	for i, r := range ft.Order {
+		g := ft.Glyphs[r]
+		x0 := (i % cols) * cellW
+		y0 := (i / cols) * cellH
+		drawGlyph(img, g, x0, y0, white)
+		m.Glyphs[string(r)] = AtlasGlyph{X: x0, Y: y0, W: g.W, H: g.H, Advance: g.W + ft.Spacing}
+	}
+	return img, m
+}
+
+func drawGlyph(img *image.NRGBA, g *Glyph, x0, y0 int, c color.NRGBA) {
+	for y, row := range g.Rows {
+		for x, on := range row {
+			if on {
+				img.SetNRGBA(x0+x, y0+y, c)
+			}
+		}
+	}
+}
+
+// RenderText draws text into a new image using the font. scale is an
+// integer upscale factor; unknown characters are skipped with a warning
+// returned. "\n" (literal backslash-n) and real newlines both break lines.
+func (ft *Font) RenderText(text string, scale int, fg color.NRGBA) (*image.NRGBA, []string) {
+	if scale < 1 {
+		scale = 1
+	}
+	text = strings.ReplaceAll(text, `\n`, "\n")
+	lines := strings.Split(text, "\n")
+
+	var warnings []string
+	width := 0
+	for _, line := range lines {
+		if w := ft.lineWidth(line); w > width {
+			width = w
+		}
+	}
+	if width == 0 {
+		width = 1
+	}
+	height := ft.LineHeight*(len(lines)-1) + ft.Height
+
+	small := image.NewNRGBA(image.Rect(0, 0, width, height))
+	for li, line := range lines {
+		x := 0
+		y := li * ft.LineHeight
+		for _, r := range line {
+			if r == ' ' {
+				x += ft.SpaceWidth + ft.Spacing
+				continue
+			}
+			g, ok := ft.Glyphs[r]
+			if !ok {
+				warnings = append(warnings, fmt.Sprintf("no glyph for %q — skipped", string(r)))
+				x += ft.SpaceWidth + ft.Spacing
+				continue
+			}
+			drawGlyph(small, g, x, y, fg)
+			x += g.W + ft.Spacing
+		}
+	}
+	if scale == 1 {
+		return small, warnings
+	}
+	b := small.Bounds()
+	big := image.NewNRGBA(image.Rect(0, 0, b.Dx()*scale, b.Dy()*scale))
+	for y := 0; y < b.Dy(); y++ {
+		for x := 0; x < b.Dx(); x++ {
+			c := small.NRGBAAt(x, y)
+			for dy := 0; dy < scale; dy++ {
+				for dx := 0; dx < scale; dx++ {
+					big.SetNRGBA(x*scale+dx, y*scale+dy, c)
+				}
+			}
+		}
+	}
+	return big, warnings
+}
+
+func (ft *Font) lineWidth(line string) int {
+	x := 0
+	for _, r := range line {
+		if r == ' ' {
+			x += ft.SpaceWidth + ft.Spacing
+			continue
+		}
+		if g, ok := ft.Glyphs[r]; ok {
+			x += g.W + ft.Spacing
+		} else {
+			x += ft.SpaceWidth + ft.Spacing
+		}
+	}
+	if x > 0 {
+		x -= ft.Spacing // no trailing spacing
+	}
+	return x
+}
+
+// WritePNG encodes an image as PNG.
+func WritePNG(w io.Writer, img image.Image) error { return png.Encode(w, img) }
+
+// WriteMetrics encodes metrics as indented JSON.
+func WriteMetrics(w io.Writer, m *Metrics) error {
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "  ")
+	return enc.Encode(m)
+}

bitmap-font-maker/go.mod

@@ -0,0 +1,3 @@
+module gitea.brasse-pc.eu/brasse/agent-tools/bitmap-font-maker
+
+go 1.24

bitmap-font-maker/main.go

@@ -0,0 +1,258 @@
+// fontc turns .font text files (pixel glyph grids) into font atlases
+// (PNG + JSON metrics) and renders text strings to images.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"image/color"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"gitea.brasse-pc.eu/brasse/agent-tools/bitmap-font-maker/font"
+)
+
+var version = "dev"
+
+const usage = `fontc - bitmap font maker for agents
+
+Usage:
+  fontc build <file.font> [flags]     build atlas PNG + metrics JSON
+  fontc render <file.font> <text> [flags]
+                                      render a text string to PNG
+  fontc info <file.font>              validate + list glyphs
+  fontc preview <file.font> <text>    draw text in the terminal
+  fontc version
+
+Build flags:
+  -o <base>        output base name -> <base>.png + <base>.json
+                   (default: font file name without extension)
+
+Render flags:
+  -o <path>        output PNG (default text.png)
+  --scale <n>      integer upscale, default 1
+  --color <c>      text color (#RRGGBB, CSS names not supported here), default #FFFFFF
+  Use \n in <text> for line breaks.
+
+The .font format:
+  font: tiny5          optional name
+  spacing: 1           px between glyphs (default 1)
+  space-width: 3       advance of ' ' (default: width of '0')
+  line-height: 7       default: glyph height + 1
+  baseline: 5          default: glyph height
+
+  glyph A:
+    .#.
+    #.#
+    ###
+    #.#
+    #.#
+
+'#' = pixel on, '.' = off. All glyphs share one height; widths may
+differ (proportional). The atlas draws glyphs in white so engines can
+tint them; metrics JSON carries x/y/w/h/advance per glyph.
+`
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Print(usage)
+		os.Exit(2)
+	}
+	switch os.Args[1] {
+	case "build":
+		cmdBuild(os.Args[2:])
+	case "render":
+		cmdRender(os.Args[2:])
+	case "info":
+		cmdInfo(os.Args[2:])
+	case "preview":
+		cmdPreview(os.Args[2:])
+	case "version", "--version", "-v":
+		fmt.Println("fontc", version)
+	case "help", "--help", "-h":
+		fmt.Print(usage)
+	default:
+		die("unknown command %q — run 'fontc help'", os.Args[1])
+	}
+}
+
+// parseInterspersed lets flags appear before or after positional args.
+func parseInterspersed(fs *flag.FlagSet, args []string) {
+	var flags, pos []string
+	for i := 0; i < len(args); i++ {
+		a := args[i]
+		if len(a) > 1 && a[0] == '-' {
+			flags = append(flags, a)
+			name := strings.TrimLeft(a, "-")
+			if !strings.Contains(name, "=") {
+				f := fs.Lookup(name)
+				isBool := false
+				if f != nil {
+					if bv, ok := f.Value.(interface{ IsBoolFlag() bool }); ok && bv.IsBoolFlag() {
+						isBool = true
+					}
+				}
+				if !isBool && i+1 < len(args) {
+					i++
+					flags = append(flags, args[i])
+				}
+			}
+		} else {
+			pos = append(pos, a)
+		}
+	}
+	fs.Parse(append(flags, pos...))
+}
+
+func cmdBuild(args []string) {
+	fs := flag.NewFlagSet("build", flag.ExitOnError)
+	out := fs.String("o", "", "output base name")
+	parseInterspersed(fs, args)
+	if fs.NArg() != 1 {
+		die("build takes exactly one .font file")
+	}
+	ft, err := font.ParseFile(fs.Arg(0))
+	if err != nil {
+		die("%v", err)
+	}
+	base := *out
+	if base == "" {
+		base = strings.TrimSuffix(fs.Arg(0), filepath.Ext(fs.Arg(0)))
+	}
+	base = strings.TrimSuffix(base, ".png")
+	img, metrics := ft.BuildAtlas(filepath.Base(base) + ".png")
+
+	pngF, err := os.Create(base + ".png")
+	if err != nil {
+		die("%v", err)
+	}
+	defer pngF.Close()
+	if err := font.WritePNG(pngF, img); err != nil {
+		die("%v", err)
+	}
+	jsonF, err := os.Create(base + ".json")
+	if err != nil {
+		die("%v", err)
+	}
+	defer jsonF.Close()
+	if err := font.WriteMetrics(jsonF, metrics); err != nil {
+		die("%v", err)
+	}
+	b := img.Bounds()
+	fmt.Printf("%s.png  (%dx%d atlas, %d glyphs)\n%s.json\n", base, b.Dx(), b.Dy(), len(ft.Order), base)
+}
+
+func parseHexColor(s string) (r, g, b uint8, err error) {
+	s = strings.TrimPrefix(strings.TrimSpace(s), "#")
+	if len(s) != 6 {
+		return 0, 0, 0, fmt.Errorf("color must be #RRGGBB, got %q", s)
+	}
+	var v [3]uint8
+	for i := 0; i < 3; i++ {
+		var n int
+		if _, err := fmt.Sscanf(s[i*2:i*2+2], "%02x", &n); err != nil {
+			return 0, 0, 0, fmt.Errorf("bad hex color %q", s)
+		}
+		v[i] = uint8(n)
+	}
+	return v[0], v[1], v[2], nil
+}
+
+func cmdRender(args []string) {
+	fs := flag.NewFlagSet("render", flag.ExitOnError)
+	out := fs.String("o", "text.png", "output PNG")
+	scale := fs.Int("scale", 1, "integer upscale")
+	col := fs.String("color", "#FFFFFF", "text color #RRGGBB")
+	parseInterspersed(fs, args)
+	if fs.NArg() != 2 {
+		die("render takes a .font file and a text string")
+	}
+	ft, err := font.ParseFile(fs.Arg(0))
+	if err != nil {
+		die("%v", err)
+	}
+	r, g, b, err := parseHexColor(*col)
+	if err != nil {
+		die("%v", err)
+	}
+	img, warnings := ft.RenderText(fs.Arg(1), *scale, rgba(r, g, b))
+	for _, w := range warnings {
+		fmt.Fprintln(os.Stderr, "fontc:", w)
+	}
+	f, err := os.Create(*out)
+	if err != nil {
+		die("%v", err)
+	}
+	defer f.Close()
+	if err := font.WritePNG(f, img); err != nil {
+		die("%v", err)
+	}
+	bd := img.Bounds()
+	fmt.Printf("%s  (%dx%d px)\n", *out, bd.Dx(), bd.Dy())
+}
+
+func cmdInfo(args []string) {
+	if len(args) != 1 {
+		die("info takes exactly one .font file")
+	}
+	ft, err := font.ParseFile(args[0])
+	if err != nil {
+		die("%v", err)
+	}
+	fmt.Printf("font:        %s\n", ft.Name)
+	fmt.Printf("height:      %d px\n", ft.Height)
+	fmt.Printf("line-height: %d px\n", ft.LineHeight)
+	fmt.Printf("baseline:    %d\n", ft.Baseline)
+	fmt.Printf("spacing:     %d px\n", ft.Spacing)
+	fmt.Printf("space-width: %d px\n", ft.SpaceWidth)
+	fmt.Printf("glyphs:      %d\n", len(ft.Order))
+	var chars []string
+	for _, r := range ft.SortedChars() {
+		chars = append(chars, string(r))
+	}
+	fmt.Printf("  %s\n", strings.Join(chars, " "))
+	fmt.Println("valid:       yes")
+}
+
+func cmdPreview(args []string) {
+	if len(args) != 2 {
+		die("preview takes a .font file and a text string")
+	}
+	ft, err := font.ParseFile(args[0])
+	if err != nil {
+		die("%v", err)
+	}
+	img, warnings := ft.RenderText(args[1], 1, rgba(255, 255, 255))
+	for _, w := range warnings {
+		fmt.Fprintln(os.Stderr, "fontc:", w)
+	}
+	b := img.Bounds()
+	for y := 0; y < b.Dy(); y += 2 {
+		var sb strings.Builder
+		for x := 0; x < b.Dx(); x++ {
+			top := img.NRGBAAt(x, y).A >= 128
+			bot := y+1 < b.Dy() && img.NRGBAAt(x, y+1).A >= 128
+			switch {
+			case top && bot:
+				sb.WriteRune('█')
+			case top:
+				sb.WriteRune('▀')
+			case bot:
+				sb.WriteRune('▄')
+			default:
+				sb.WriteByte(' ')
+			}
+		}
+		fmt.Println(sb.String())
+	}
+}
+
+func rgba(r, g, b uint8) color.NRGBA {
+	return color.NRGBA{R: r, G: g, B: b, A: 255}
+}
+
+func die(format string, a ...any) {
+	fmt.Fprintf(os.Stderr, "fontc: "+format+"\n", a...)
+	os.Exit(1)
+}

doc/plan.md

@@ -0,0 +1,63 @@
+# agent-tools — plan
+
+## Goal
+
+A collection of small, agent-friendly CLI tools. The common thread:
+**text in, verifiable artifacts out**. An agent should be able to author
+the input format directly, predict what the output will look like, and
+verify results without a GUI.
+
+## Stack
+
+- Go (single static binaries, zero deps, trivial cross-compile to the
+  Pi5's arm64 runner), one Go module per tool.
+- Targets: linux x64 + linux arm64.
+
+## Deploy target
+
+Pattern A (distributable binaries): rolling `<tool>-latest` release per
+tool on Gitea, built by `.gitea/workflows/release.yml` on push to
+master/main. Only tools whose folders changed get rebuilt.
+
+## Milestones
+
+1. ✅ `pixel-sprite-maker` (`spritec`): .sprite text format → PNG/JPG/SVG,
+   sprite sheets with self-documenting file names, terminal preview.
+2. ✅ `mesh-tool` (`mesht`): OBJ/STL create/inspect/edit with ASCII
+   multi-view rendering, measurements and watertightness checks.
+3. ✅ Per-tool VS Code build tasks → `<tool>/build/`.
+4. ✅ CI: changed-tool detection + per-tool rolling releases.
+
+## Roadmap / expansion ideas (not agreed yet)
+
+- spritec: palette import from image files, GIF export for animations,
+  tile-map composer (map file referencing sprite tiles).
+- mesht: OBJ vertex-color support, simple boolean ops (union via
+  voxelization), PNG snapshot rendering, glTF export.
+- New tools: bitmap-font maker, sound-effect generator (sfxr-style text
+  presets), tiled-map (.tmx) writer.
+
+### Agent-capability tools (see [tool-parity.md](tool-parity.md))
+
+Close the gap between Gemini CLI and Claude Code, plus homelab admin
+tools grounded in infra-Doc history. Suggested order:
+
+1. `notifyr` — send/read on the existing Pi5 ntfy bus (≈ PushNotification).
+2. `giteactl` — Gitea Actions runs, zst CI logs, `wait`/`wait-quiet`
+   build serialization, releases.
+3. `waitfor` — block until a condition holds (≈ Monitor);
+   `cronr` — systemd-user-timer scheduling (≈ CronCreate/List/Delete).
+4. `fleet` — one-shot homelab health snapshot via the read-only
+   claude-docker wrapper.
+5. `envaudit` — compose ↔ `.env` key/inline-secret audit;
+   `reghelper` — registry catalog + prune *plans*;
+   `pagepub` — publish HTML/MD report to a URL (≈ Artifact);
+   `nbcell` — Jupyter cell editing (≈ NotebookEdit);
+   `wtreectl` — disposable git worktrees.
+6. `fanout` — parallel headless-agent orchestration (≈ Workflow); only
+   on concrete need.
+
+## Open questions
+
+- Versioned releases (`vX.Y.Z` tags per tool) on top of the rolling
+  `latest` — add when something depends on a pinned version.

doc/tool-parity.md

@@ -0,0 +1,297 @@
+# Tool parity: Google's agent vs Claude Code
+
+Goal: let Google's agent CLI do everything Claude Code can, by building
+the missing capabilities as small CLI tools in this repo. The agent
+calls them through its shell tool, so every tool follows the house
+rules: **text in, verifiable artifacts out**, single static Go binary,
+self-explanatory output.
+
+**Which Google agent?** Legacy `gemini-cli` is auth-dead for personal
+accounts (verified again 2026-08-05, see infra-Doc
+`hosts/brasse-linux01.md`). The real target is **`agy` (Antigravity
+CLI)** — live-tested in section 2, and its toolset differs from the
+old Gemini CLI docs. Section 1's table is kept for reference since
+Gemini CLI still exists in API-key mode.
+
+A design rule that fell out of the live test: **a dedicated binary
+beats ad-hoc shell because of approval prefixes.** agy (like Claude
+Code) allowlists commands by prefix — `notifyr …` can be approved once
+and forever, while every hand-rolled `for i in $(seq …); do curl …`
+loop is a unique string that needs fresh human approval. Small stable
+CLIs are therefore not just convenience: they are what makes
+unattended agent operation possible at all.
+
+Sources: Gemini CLI tools reference (<https://geminicli.com/docs/reference/tools/>),
+Claude Code's toolset as of 2026-08, live probing of `agy` 1.1.9.
+
+## 1. Already at parity — nothing to build
+
+| Capability | Claude Code | Gemini CLI |
+|---|---|---|
+| Read/write/edit files | `Read` / `Write` / `Edit` | `read_file` / `write_file` / `replace` |
+| Find files / search text / list dirs | `Glob` / `Grep` | `glob` / `grep_search` / `list_directory`, plus `read_many_files` |
+| Shell, incl. background processes | `Bash` (+ background tasks) | `run_shell_command` (+ background processes) |
+| Web | `WebFetch` / `WebSearch` | `web_fetch` / `google_web_search` |
+| Ask the user a structured question | `AskUserQuestion` | `ask_user` |
+| Plan mode | `EnterPlanMode` / `ExitPlanMode` | `enter_plan_mode` / `exit_plan_mode` |
+| Skills / slash commands | `Skill` (`.claude/skills`) | `activate_skill` (`.gemini/skills`) |
+| Persistent memory | file-based memory dir | `save_memory` (simpler, but exists) |
+| Todo/task tracking | `TaskCreate`/`TaskUpdate`/… | `write_todos`, `tracker_*` (experimental) |
+| MCP servers + resources | MCP tools, `ListMcpResources`/`ReadMcpResource` | MCP tools, `list_mcp_resources`/`read_mcp_resource` |
+| Subagents | `Agent` (background, custom types) | subagents (experimental) — weaker, see `fanout` below |
+
+Not worth replicating (harness-internal to Claude Code, no value as a
+CLI): `ToolSearch`, `EndConversation`, `ReportFindings`,
+`ShareOnboardingGuide`, `DesignSync`, remote cloud execution.
+
+## 2. Live test 2026-08-05: `agy` (Antigravity CLI 1.1.9)
+
+Tested interactively in a tmux session (Google AI Pro account, model
+Gemini 3.6 Flash). Its 19 built-in tools, self-enumerated:
+
+`ask_permission`, `ask_question`, `define_subagent`, `generate_image`,
+`grep_search`, `invoke_subagent`, `list_dir`, `list_permissions`,
+`manage_subagents`, `manage_task`, `multi_replace_file_content`,
+`read_url_content`, `replace_file_content`, `run_command`, `schedule`,
+`search_web`, `send_message`, `view_file`, `write_to_file`.
+
+What this changes vs the old Gemini CLI picture:
+
+- **agy has real subagents** (`invoke_subagent`/`define_subagent`/
+  `manage_subagents` + `send_message`) and background-task management
+  (`manage_task`). → `fanout` demoted further; probably never needed.
+- **agy has `schedule`** — one-shot timer or cron expression that wakes
+  the agent with a prompt (same idea as Claude's `ScheduleWakeup`).
+  Confirmed limits, from its schema: it cannot run commands itself,
+  it is **in-memory and dies with the session**, and it cannot reach
+  the phone. → `cronr` (persistent systemd timers) and `notifyr` are
+  still needed; `schedule` complements them within a session.
+- **agy has `generate_image`** — a *reverse* gap: Claude Code has no
+  native image generation. Nothing to build; just worth knowing.
+- No MCP-resource tools, no memory tool and no glob in its toolset
+  (grep/list_dir cover finding files).
+
+Behavior tests run in a scratch arena:
+
+| Test | Result |
+|---|---|
+| Enumerate tools | Clean list of 19 (above) |
+| Edit a text file | Worked, auto-approved in trusted folder |
+| Edit a Jupyter cell, keep `.ipynb` valid | **Passed** — it wrote a `python3 -c` json script rather than text-replacing. Notebook stayed valid. Cost: a per-command approval each time → `nbcell` demoted to nice-to-have (stable prefix + no ad-hoc python). |
+| Wait for a file to appear | Worked via a hand-rolled `for … sleep 1` shell loop — a unique command string needing fresh approval. → exactly the `waitfor` case. |
+| Asked agy which CLI tools *it* wants for the homelab | Its list: ntfy client, `tea` (Gitea CLI), `skopeo`/`crane` (registry), `ofelia`/cron daemon, `ctop`-style fleet status — near-1:1 with section 4, and it independently made the approval-prefix argument. |
+
+**Buy before build:** agy's suggestions overlap with off-the-shelf
+tools. Evaluate first: `tea` (official Gitea CLI — but it does not read
+the Pi5's zst action logs and has no `wait-quiet`, which stay
+`giteactl`'s reason to exist, possibly as a thin layer *on top of*
+`tea`), `skopeo`/`crane` (cover most of `reghelper` — remaining value
+is prune *plans* and size summaries), `ctop` (interactive TUI, not
+agent-friendly output — `fleet` still wins for agents).
+
+## 3. Gaps → tools to build
+
+Ordered by expected value. Each becomes its own folder + binary +
+README, per repo convention.
+
+### 3.1 `cronr` — scheduled/recurring runs *(Claude: `CronCreate`/`CronList`/`CronDelete`, `/loop`)*
+
+agy's built-in `schedule` dies with the session (see section 2).
+`cronr` manages **systemd user timers** so an agent can create
+recurring or one-shot jobs that survive session exit and reboot
+(including "run this prompt every morning" via `agy -p …`).
+
+```
+cronr add nightly-ci-check --schedule "*-*-* 07:00" --cmd 'agy -p "check CI status and notify"'
+cronr add once-reboot-check --at "2026-08-06 03:00" --cmd '…'   # one-shot
+cronr list                    # name, schedule, next run, last result
+cronr logs nightly-ci-check   # journalctl for the unit
+cronr rm nightly-ci-check
+```
+
+Output prints the generated unit files so the result is verifiable.
+No daemon of its own — systemd does the running.
+
+### 3.2 `waitfor` — block until a condition holds *(Claude: `Monitor`)*
+
+Turns "poll every N seconds" into a single blocking tool call, so the
+agent doesn't burn turns polling.
+
+```
+waitfor --cmd "curl -sf https://gitea.brasse-pc.eu/api/healthz" --interval 30s --timeout 20m
+waitfor --cmd "ssh pi5 docker ps --format '{{.Names}}'" --matches 'gitea' --timeout 10m
+waitfor … --then 'notifyr send --msg "gitea is back up"'
+```
+
+Exit 0 = condition met, exit 3 = timeout; last output is printed either
+way. `--then` runs a command on success (composes with `notifyr`).
+
+### 3.3 `notifyr` — push notifications, send **and read** *(Claude: `PushNotification`)*
+
+The ntfy server **already runs on the Pi5** and is the house-wide
+notification bus (topics like `Info`, `pi5-server-fel`, `ci-fel` — see
+infra-Doc `services/observability.md`). `notifyr` is a thin client so
+every agent uses it the same way:
+
+```
+notifyr send --topic ci-fel --title "Build failed" --msg "agent-tools arm64 test: FAIL" --priority high
+notifyr read --topic pi5-server-fel --since 2h     # poll mode: what has alerted lately?
+```
+
+`read` (ntfy's `?poll=1&since=…`) is the underrated half: it lets an
+agent *check what the infra has been complaining about* before/after a
+change. Config (`~/.config/notifyr/config.json`): server URL + token.
+
+### 3.4 `pagepub` — publish an HTML/Markdown report to a URL *(Claude: `Artifact`)*
+
+Claude Code can publish reports as web pages; Gemini cannot. `pagepub`
+rsyncs a file to a static-file host on the Pi5 (nginx container behind
+NPM, e.g. `pages.brasse-pc.eu`) and prints the stable URL.
+
+```
+pagepub publish report.html --slug ci-report     → https://pages.brasse-pc.eu/ci-report/
+pagepub publish notes.md --slug pi5-audit        # .md rendered to HTML with built-in template
+pagepub list | rm <slug>
+```
+
+Requires the static host to exist first (small infra task; goes in
+infra-Doc + NPM proxy host via `npmctl`).
+
+### 3.5 `nbcell` — Jupyter notebook editing *(Claude: `NotebookEdit`)*
+
+`.ipynb` is JSON that's miserable to edit via `replace`. `nbcell`
+exposes cells as text:
+
+```
+nbcell list nb.ipynb                 # index, type, first line, exec count
+nbcell show nb.ipynb 3               # cell source (and outputs with --outputs)
+nbcell edit nb.ipynb 3 --from-file cell.py
+nbcell add nb.ipynb --at 4 --type code --from-file new.py
+nbcell rm nb.ipynb 7
+```
+
+### 3.6 `wtreectl` — disposable git worktrees *(Claude: worktree isolation for agents)*
+
+Claude Code can give each subagent an isolated git worktree. `wtreectl`
+does the same for any agent:
+
+```
+wtreectl new [--branch dev/foo]   # prints the new worktree path
+wtreectl list
+wtreectl clean                    # removes worktrees with no changes
+```
+
+Lets two agent sessions work in the same repo without trampling each
+other.
+
+### 3.7 `fanout` — parallel subagent orchestration *(Claude: `Workflow`, `Agent`)* — roadmap, not agreed
+
+Runs N prompts as parallel headless agent processes (`gemini -p` /
+`claude -p`) with a concurrency cap, collecting each result as JSON in
+an output dir. A poor man's `Workflow`:
+
+```
+fanout run jobs.json --max 3 --out results/
+```
+
+Heavier than the other tools and overlaps with agent-helm's territory —
+park until there's a concrete need.
+
+## 4. Suggested tools from infra history
+
+Grounded in what the agent has already been doing per infra-Doc
+(`maintenance-and-gaps.md`, `services/source-control-and-deploy.md`,
+`services/observability.md`, the per-service "operational quick-ref"
+blocks). These help **any** agent (Claude or Gemini) administer the
+fleet, and they respect the read-only sudo policy
+(`ssh/claude-sudo-policy.md`): everything below is read-or-notify;
+mutations still go through Björn's supervised tmux flow.
+
+### 4.1 `giteactl` — Gitea repos, Actions runs and CI logs
+
+The biggest recurring friction. Today: CI status is polled ad hoc, and
+logs for private repos are only readable as zst files under
+`/srv/storage1/gitea/actions_log/…` on the Pi5. Wraps the Gitea REST +
+Actions API:
+
+```
+giteactl runs <repo> [--limit 5]          # status, branch, duration
+giteactl log <repo> <run> [--job N]       # fetches + decompresses the zst log
+giteactl wait <repo> [--timeout 30m]      # block until latest run finishes; exit 0 = green
+giteactl wait-quiet [--max-active 1]      # block until ≤N heavy builds are running
+giteactl release <repo> [<tag>]           # rolling-release assets + checksums
+```
+
+`wait-quiet` encodes the hard-learned rule "serialize pushes — >2 heavy
+builds take the Pi5 down": `giteactl wait-quiet && git push`.
+Composes with `waitfor`/`notifyr`.
+
+### 4.2 `fleet` — one-shot health snapshot of the whole homelab
+
+Every service doc ends with the same hand-rolled loop over
+`ssh pi5-claude sudo claude-docker ps/inspect …`. `fleet` does that
+loop once, properly:
+
+```
+fleet status          # containers (state, image, restarts), disk/mergerfs fill %, failed systemd units
+fleet status --host brasse-linux01
+fleet checks          # Uptime Kuma monitor states + last ntfy alerts (via notifyr read)
+```
+
+Read-only by construction (claude-docker wrapper + sudo allowlist), so
+it needs no new permissions. Output is a stable text table an agent can
+diff between runs.
+
+### 4.3 `envaudit` — compose ↔ `.env` key auditor
+
+Grounded in a real incident (`${STORAGE1}` undefined in `/srv/.env` →
+bad mount, rollback) and in maintenance-and-gaps' inline-secret
+findings:
+
+```
+envaudit check /srv/dockge-staks --env /srv/.env
+  → UNDEFINED  ${STORAGE1}   used by media-stack/compose.yaml
+  → INLINE     LDAP_ADMIN_PASSWORD  hardcoded in openldap/compose.yaml (should live in .env)
+  → UNUSED     OLD_API_KEY   defined but referenced nowhere
+```
+
+Pure text analysis of compose files — safe to run anywhere, catches the
+two failure classes that have actually happened.
+
+### 4.4 `reghelper` — docker-registry catalog & hygiene
+
+The LAN registry (`192.168.0.19:5000`) has no UI, no auth and no
+cleanup story, and the backup plan explicitly wants it slimmed:
+
+```
+reghelper ls                      # catalog + tags + image sizes
+reghelper tags <image>
+reghelper prune-plan --keep 2     # prints the delete+GC commands (does NOT run them)
+```
+
+`prune-plan` deliberately only *prints* the mutation commands for the
+supervised tmux flow — same pattern as the sudo policy.
+
+### 4.5 Backup status reader — once Backrest/restic exists
+
+future-plans.md has the whole Backrest+restic design chosen but
+unbuilt. When it lands, a `fleet backups` subcommand (last snapshot age
+per source, repo size, last check result) closes the loop — an agent
+can then *verify* backups instead of trusting them. Not a separate
+tool; park under `fleet`.
+
+### Cross-reference
+
+`/home/brasse/repos/dify-agent-tools/` already has a specced-but-unbuilt
+set of FastAPI tools (file/image sorting, face recognition, ST-card
+export…) for the Dify platform. Different runtime (HTTP tools vs CLI
+binaries), same philosophy — don't duplicate those here.
+
+## 5. Suggested build order
+
+1. `notifyr` — smallest, everything else composes with it, ntfy already runs.
+2. `giteactl` — removes the biggest daily friction (CI logs + build serialization).
+3. `waitfor` + `cronr` — turns both agents into unattended operators.
+4. `fleet` — replaces the hand-rolled health loops in every runbook.
+5. `envaudit`, `reghelper`, `pagepub`, `nbcell`, `wtreectl` — as needed.
+6. `fanout` — only if a concrete multi-agent need shows up.

hitbox-tool/README.md

@@ -0,0 +1,66 @@
+# hitbox-tool (`hitbox`)
+
+Scans **sprite sheet PNGs** and writes per-frame **collision boxes as
+JSON**, computed from the alpha channel. Closes the loop with
+[`pixel-sprite-maker`](../pixel-sprite-maker/): render a sheet with
+`spritec`, scan it with `hitbox`, and your game gets both graphics and
+hitboxes without a human drawing rectangles. Go, zero dependencies,
+single static binary.
+
+## Build
+
+```bash
+# Arch/Garuda: sudo pacman -S go
+cd hitbox-tool
+go build -o build/hitbox .        # or the VS Code task "build hitbox-tool"
+go test ./...
+```
+
+## Usage
+
+```bash
+# spritec-named sheets need no flags — layout is parsed from the name,
+# and integer upscales are auto-detected (a _8x8_4x1 sheet that is
+# 256x64 px was rendered at --scale 8, so cells are 64x64):
+hitbox scan walk_8x8_4x1.png -o walk.hitbox.json
+
+hitbox scan boss.png --cell 32x32 -o boss.json   # explicit frame size
+hitbox scan portrait.png                          # whole image = one frame, JSON to stdout
+
+hitbox show walk_8x8_4x1.png --frame 2            # verify visually in the terminal
+
+# tuning:
+--threshold 128     # ignore faint pixels (alpha < 128)
+--shrink 1          # tighter, more forgiving hitboxes (n px per side)
+--pad 2             # generous hitboxes (e.g. pickups)
+```
+
+## Output
+
+```json
+{
+  "image": "walk_8x8_4x1.png",
+  "cellW": 8, "cellH": 8, "cols": 4, "rows": 1,
+  "alphaThreshold": 1,
+  "frames": [
+    { "index": 0, "col": 0, "row": 0, "empty": false,
+      "box": { "x": 1, "y": 0, "w": 5, "h": 8 } },
+    { "index": 1, "col": 1, "row": 0, "empty": true, "box": null }
+  ]
+}
+```
+
+- Boxes are **relative to each frame's top-left corner**.
+- Frame order is row-major (`index = row * cols + col`), matching
+  spritec sheets.
+- Cells with no solid pixels get `"empty": true`.
+
+In game code:
+
+```
+hit = px >= frameX + box.x && px < frameX + box.x + box.w
+   && py >= frameY + box.y && py < frameY + box.y + box.h
+```
+
+`hitbox show` draws each frame with `#` for solid pixels and `+` for the
+box outline, so an agent can verify the result without an image viewer.

hitbox-tool/examples/walk_8x8_4x1.hitbox.json

@@ -0,0 +1,58 @@
+{
+  "image": "examples/walk_8x8_4x1.png",
+  "cellW": 64,
+  "cellH": 64,
+  "cols": 4,
+  "rows": 1,
+  "alphaThreshold": 1,
+  "frames": [
+    {
+      "index": 0,
+      "col": 0,
+      "row": 0,
+      "empty": false,
+      "box": {
+        "x": 8,
+        "y": 0,
+        "w": 40,
+        "h": 64
+      }
+    },
+    {
+      "index": 1,
+      "col": 1,
+      "row": 0,
+      "empty": false,
+      "box": {
+        "x": 8,
+        "y": 0,
+        "w": 40,
+        "h": 64
+      }
+    },
+    {
+      "index": 2,
+      "col": 2,
+      "row": 0,
+      "empty": false,
+      "box": {
+        "x": 8,
+        "y": 0,
+        "w": 40,
+        "h": 64
+      }
+    },
+    {
+      "index": 3,
+      "col": 3,
+      "row": 0,
+      "empty": false,
+      "box": {
+        "x": 8,
+        "y": 0,
+        "w": 40,
+        "h": 64
+      }
+    }
+  ]
+}

hitbox-tool/go.mod

@@ -0,0 +1,3 @@
+module gitea.brasse-pc.eu/brasse/agent-tools/hitbox-tool
+
+go 1.24

hitbox-tool/hitbox/hitbox.go

@@ -0,0 +1,230 @@
+// Package hitbox computes per-frame collision boxes from sprite sheet
+// images by scanning the alpha channel.
+package hitbox
+
+import (
+	"encoding/json"
+	"fmt"
+	"image"
+	"image/png"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+)
+
+// Box is a rectangle relative to its frame's top-left corner.
+type Box struct {
+	X int `json:"x"`
+	Y int `json:"y"`
+	W int `json:"w"`
+	H int `json:"h"`
+}
+
+// Frame is the scan result for one sheet cell.
+type Frame struct {
+	Index int  `json:"index"`
+	Col   int  `json:"col"`
+	Row   int  `json:"row"`
+	Empty bool `json:"empty"`
+	Box   *Box `json:"box"` // nil when Empty
+}
+
+// Sheet is the full scan result; the JSON deliverable.
+type Sheet struct {
+	Image     string  `json:"image"`
+	CellW     int     `json:"cellW"`
+	CellH     int     `json:"cellH"`
+	Cols      int     `json:"cols"`
+	Rows      int     `json:"rows"`
+	Threshold int     `json:"alphaThreshold"`
+	Frames    []Frame `json:"frames"`
+}
+
+// layoutRe matches the spritec sheet naming convention:
+// <base>_<cellW>x<cellH>_<cols>x<rows>.<ext>
+var layoutRe = regexp.MustCompile(`_(\d+)x(\d+)_(\d+)x(\d+)\.[A-Za-z]+$`)
+
+// LayoutFromName extracts cell size and grid from a spritec-style file
+// name. ok is false when the name doesn't follow the convention.
+func LayoutFromName(path string) (cellW, cellH, cols, rows int, ok bool) {
+	m := layoutRe.FindStringSubmatch(filepath.Base(path))
+	if m == nil {
+		return 0, 0, 0, 0, false
+	}
+	cellW, _ = strconv.Atoi(m[1])
+	cellH, _ = strconv.Atoi(m[2])
+	cols, _ = strconv.Atoi(m[3])
+	rows, _ = strconv.Atoi(m[4])
+	return cellW, cellH, cols, rows, true
+}
+
+// InferScale detects integer-upscaled sheets: when the image is exactly
+// s times bigger than the name-declared layout (both axes, s >= 1), the
+// real cell size is cell*s. Returns 0 when the layout doesn't fit.
+func InferScale(imgW, imgH, cellW, cellH, cols, rows int) int {
+	baseW, baseH := cellW*cols, cellH*rows
+	if baseW <= 0 || baseH <= 0 || imgW%baseW != 0 || imgH%baseH != 0 {
+		return 0
+	}
+	s := imgW / baseW
+	if s < 1 || imgH/baseH != s {
+		return 0
+	}
+	return s
+}
+
+// LoadPNG reads a PNG image from disk.
+func LoadPNG(path string) (image.Image, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	img, err := png.Decode(f)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w (only PNG is supported — sheets need an alpha channel)", path, err)
+	}
+	return img, nil
+}
+
+// Scan computes a tight box per frame: the smallest rectangle covering
+// every pixel with alpha >= threshold. shrink/pad (in pixels) contract or
+// expand each box afterwards, clamped to the cell.
+func Scan(img image.Image, name string, cellW, cellH, threshold, shrink, pad int) (*Sheet, error) {
+	b := img.Bounds()
+	if cellW <= 0 || cellH <= 0 {
+		cellW, cellH = b.Dx(), b.Dy() // whole image = one frame
+	}
+	if b.Dx()%cellW != 0 || b.Dy()%cellH != 0 {
+		return nil, fmt.Errorf("image is %dx%d which is not divisible by cell %dx%d",
+			b.Dx(), b.Dy(), cellW, cellH)
+	}
+	if threshold < 1 || threshold > 255 {
+		return nil, fmt.Errorf("alpha threshold %d out of range 1-255", threshold)
+	}
+	cols, rows := b.Dx()/cellW, b.Dy()/cellH
+	sheet := &Sheet{
+		Image: name, CellW: cellW, CellH: cellH,
+		Cols: cols, Rows: rows, Threshold: threshold,
+	}
+	for row := 0; row < rows; row++ {
+		for col := 0; col < cols; col++ {
+			fr := Frame{Index: row*cols + col, Col: col, Row: row}
+			minX, minY := cellW, cellH
+			maxX, maxY := -1, -1
+			for y := 0; y < cellH; y++ {
+				for x := 0; x < cellW; x++ {
+					_, _, _, a := img.At(b.Min.X+col*cellW+x, b.Min.Y+row*cellH+y).RGBA()
+					if int(a>>8) >= threshold {
+						if x < minX {
+							minX = x
+						}
+						if y < minY {
+							minY = y
+						}
+						if x > maxX {
+							maxX = x
+						}
+						if y > maxY {
+							maxY = y
+						}
+					}
+				}
+			}
+			if maxX < 0 {
+				fr.Empty = true
+			} else {
+				box := Box{X: minX, Y: minY, W: maxX - minX + 1, H: maxY - minY + 1}
+				box = adjust(box, shrink-pad, cellW, cellH)
+				fr.Box = &box
+			}
+			sheet.Frames = append(sheet.Frames, fr)
+		}
+	}
+	return sheet, nil
+}
+
+// adjust contracts the box by delta px on every side (negative delta
+// expands), clamped to the cell and to a minimum size of 1x1.
+func adjust(b Box, delta, cellW, cellH int) Box {
+	b.X += delta
+	b.Y += delta
+	b.W -= 2 * delta
+	b.H -= 2 * delta
+	if b.X < 0 {
+		b.W += b.X
+		b.X = 0
+	}
+	if b.Y < 0 {
+		b.H += b.Y
+		b.Y = 0
+	}
+	if b.X+b.W > cellW {
+		b.W = cellW - b.X
+	}
+	if b.Y+b.H > cellH {
+		b.H = cellH - b.Y
+	}
+	if b.W < 1 {
+		b.W = 1
+		if b.X > cellW-1 {
+			b.X = cellW - 1
+		}
+	}
+	if b.H < 1 {
+		b.H = 1
+		if b.Y > cellH-1 {
+			b.Y = cellH - 1
+		}
+	}
+	return b
+}
+
+// WriteJSON encodes the sheet as indented JSON.
+func (s *Sheet) WriteJSON(w io.Writer) error {
+	enc := json.NewEncoder(w)
+	enc.SetIndent("", "  ")
+	return enc.Encode(s)
+}
+
+// Ascii draws one frame with '#' for solid pixels and '+' for the box
+// outline, so results can be verified in a terminal.
+func Ascii(img image.Image, s *Sheet, index, threshold int) string {
+	if index < 0 || index >= len(s.Frames) {
+		return "(no such frame)\n"
+	}
+	fr := s.Frames[index]
+	b := img.Bounds()
+	out := make([]rune, 0, (s.CellW+1)*s.CellH)
+	onBoxEdge := func(x, y int) bool {
+		if fr.Box == nil {
+			return false
+		}
+		bx := fr.Box
+		inX := x >= bx.X && x < bx.X+bx.W
+		inY := y >= bx.Y && y < bx.Y+bx.H
+		edgeX := x == bx.X || x == bx.X+bx.W-1
+		edgeY := y == bx.Y || y == bx.Y+bx.H-1
+		return (inX && inY) && (edgeX || edgeY)
+	}
+	for y := 0; y < s.CellH; y++ {
+		for x := 0; x < s.CellW; x++ {
+			_, _, _, a := img.At(b.Min.X+fr.Col*s.CellW+x, b.Min.Y+fr.Row*s.CellH+y).RGBA()
+			solid := int(a>>8) >= threshold
+			switch {
+			case solid && onBoxEdge(x, y):
+				out = append(out, '#')
+			case solid:
+				out = append(out, '#')
+			case onBoxEdge(x, y):
+				out = append(out, '+')
+			default:
+				out = append(out, '.')
+			}
+		}
+		out = append(out, '\n')
+	}
+	return string(out)
+}

hitbox-tool/hitbox/hitbox_test.go

@@ -0,0 +1,137 @@
+package hitbox
+
+import (
+	"bytes"
+	"encoding/json"
+	"image"
+	"image/color"
+	"testing"
+)
+
+// sheet4 builds a 2x1 sheet of 4x4 cells: frame 0 has a 2x2 blob at
+// (1,1); frame 1 is empty.
+func sheet4() image.Image {
+	img := image.NewNRGBA(image.Rect(0, 0, 8, 4))
+	for y := 1; y <= 2; y++ {
+		for x := 1; x <= 2; x++ {
+			img.SetNRGBA(x, y, color.NRGBA{255, 0, 0, 255})
+		}
+	}
+	return img
+}
+
+func TestScanTightBox(t *testing.T) {
+	s, err := Scan(sheet4(), "test.png", 4, 4, 1, 0, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if s.Cols != 2 || s.Rows != 1 || len(s.Frames) != 2 {
+		t.Fatalf("layout %dx%d frames=%d", s.Cols, s.Rows, len(s.Frames))
+	}
+	f0 := s.Frames[0]
+	if f0.Empty || f0.Box == nil {
+		t.Fatal("frame 0 should have a box")
+	}
+	if *f0.Box != (Box{X: 1, Y: 1, W: 2, H: 2}) {
+		t.Errorf("frame 0 box = %+v", *f0.Box)
+	}
+	f1 := s.Frames[1]
+	if !f1.Empty || f1.Box != nil {
+		t.Errorf("frame 1 should be empty, got %+v", f1)
+	}
+}
+
+func TestScanWholeImageDefault(t *testing.T) {
+	s, err := Scan(sheet4(), "x.png", 0, 0, 1, 0, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(s.Frames) != 1 || s.CellW != 8 || s.CellH != 4 {
+		t.Errorf("whole-image scan: %+v", s)
+	}
+}
+
+func TestScanErrors(t *testing.T) {
+	if _, err := Scan(sheet4(), "x.png", 3, 4, 1, 0, 0); err == nil {
+		t.Error("non-divisible cell size should error")
+	}
+	if _, err := Scan(sheet4(), "x.png", 4, 4, 0, 0, 0); err == nil {
+		t.Error("threshold 0 should error")
+	}
+}
+
+func TestShrinkAndPad(t *testing.T) {
+	img := image.NewNRGBA(image.Rect(0, 0, 4, 4))
+	for y := 0; y < 4; y++ {
+		for x := 0; x < 4; x++ {
+			img.SetNRGBA(x, y, color.NRGBA{0, 0, 0, 255})
+		}
+	}
+	s, _ := Scan(img, "x.png", 4, 4, 1, 1, 0) // shrink 1
+	if *s.Frames[0].Box != (Box{X: 1, Y: 1, W: 2, H: 2}) {
+		t.Errorf("shrunk box = %+v", *s.Frames[0].Box)
+	}
+	s, _ = Scan(img, "x.png", 4, 4, 1, 0, 3) // pad clamps to cell
+	if *s.Frames[0].Box != (Box{X: 0, Y: 0, W: 4, H: 4}) {
+		t.Errorf("padded box = %+v", *s.Frames[0].Box)
+	}
+	s, _ = Scan(img, "x.png", 4, 4, 1, 10, 0) // over-shrink -> min 1x1
+	if s.Frames[0].Box.W < 1 || s.Frames[0].Box.H < 1 {
+		t.Errorf("over-shrunk box = %+v", *s.Frames[0].Box)
+	}
+}
+
+func TestThreshold(t *testing.T) {
+	img := image.NewNRGBA(image.Rect(0, 0, 2, 1))
+	img.SetNRGBA(0, 0, color.NRGBA{0, 0, 0, 100})
+	img.SetNRGBA(1, 0, color.NRGBA{0, 0, 0, 200})
+	s, _ := Scan(img, "x.png", 2, 1, 150, 0, 0)
+	if *s.Frames[0].Box != (Box{X: 1, Y: 0, W: 1, H: 1}) {
+		t.Errorf("threshold box = %+v", *s.Frames[0].Box)
+	}
+	s, _ = Scan(img, "x.png", 2, 1, 50, 0, 0)
+	if *s.Frames[0].Box != (Box{X: 0, Y: 0, W: 2, H: 1}) {
+		t.Errorf("low-threshold box = %+v", *s.Frames[0].Box)
+	}
+}
+
+func TestLayoutFromName(t *testing.T) {
+	w, h, c, r, ok := LayoutFromName("/tmp/walk_8x8_4x1.png")
+	if !ok || w != 8 || h != 8 || c != 4 || r != 1 {
+		t.Errorf("parsed %d %d %d %d ok=%v", w, h, c, r, ok)
+	}
+	if _, _, _, _, ok := LayoutFromName("plain.png"); ok {
+		t.Error("plain.png should not match")
+	}
+}
+
+func TestInferScale(t *testing.T) {
+	// walk_8x8_4x1.png rendered at scale 8 -> 256x64
+	if s := InferScale(256, 64, 8, 8, 4, 1); s != 8 {
+		t.Errorf("scale = %d, want 8", s)
+	}
+	if s := InferScale(32, 8, 8, 8, 4, 1); s != 1 {
+		t.Errorf("unscaled = %d, want 1", s)
+	}
+	if s := InferScale(250, 64, 8, 8, 4, 1); s != 0 {
+		t.Errorf("non-divisible = %d, want 0", s)
+	}
+	if s := InferScale(256, 32, 8, 8, 4, 1); s != 0 {
+		t.Errorf("axis mismatch = %d, want 0", s)
+	}
+}
+
+func TestJSONShape(t *testing.T) {
+	s, _ := Scan(sheet4(), "test.png", 4, 4, 1, 0, 0)
+	var buf bytes.Buffer
+	if err := s.WriteJSON(&buf); err != nil {
+		t.Fatal(err)
+	}
+	var back Sheet
+	if err := json.Unmarshal(buf.Bytes(), &back); err != nil {
+		t.Fatalf("invalid json: %v", err)
+	}
+	if back.Frames[0].Box.W != 2 {
+		t.Errorf("json roundtrip box = %+v", back.Frames[0].Box)
+	}
+}

hitbox-tool/main.go

@@ -0,0 +1,204 @@
+// hitbox scans sprite sheet PNGs and writes per-frame collision boxes
+// as JSON, using the alpha channel to find each frame's solid pixels.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"gitea.brasse-pc.eu/brasse/agent-tools/hitbox-tool/hitbox"
+)
+
+var version = "dev"
+
+const usage = `hitbox - collision box annotator for sprite sheets
+
+Usage:
+  hitbox scan <sheet.png> [flags]     compute per-frame boxes -> JSON
+  hitbox show <sheet.png> [flags]     draw frames + boxes in the terminal
+  hitbox version
+
+Scan flags:
+  --cell <WxH>       frame size, e.g. 8x8. Default: parsed from the
+                     spritec naming convention <name>_<W>x<H>_<C>x<R>.png;
+                     if neither is given the whole image is one frame.
+  --threshold <n>    alpha 1-255 that counts as solid (default 1)
+  --shrink <n>       contract every box by n px per side (forgiving hits)
+  --pad <n>          expand every box by n px per side
+  -o <path>          write JSON here (default: stdout)
+
+Show flags: --cell, --threshold, plus
+  --frame <n>        only this frame index (default: all)
+
+Boxes are relative to each frame's top-left corner. Frame indices are
+row-major (index = row * cols + col), matching spritec sheets.
+In game code: hit if (px,py) inside (frameX + box.x, frameY + box.y,
+box.w, box.h).
+`
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Print(usage)
+		os.Exit(2)
+	}
+	switch os.Args[1] {
+	case "scan":
+		cmdScan(os.Args[2:])
+	case "show":
+		cmdShow(os.Args[2:])
+	case "version", "--version", "-v":
+		fmt.Println("hitbox", version)
+	case "help", "--help", "-h":
+		fmt.Print(usage)
+	default:
+		die("unknown command %q — run 'hitbox help'", os.Args[1])
+	}
+}
+
+// parseInterspersed lets flags appear before or after positional args.
+func parseInterspersed(fs *flag.FlagSet, args []string) {
+	var flags, pos []string
+	for i := 0; i < len(args); i++ {
+		a := args[i]
+		if len(a) > 1 && a[0] == '-' {
+			flags = append(flags, a)
+			name := strings.TrimLeft(a, "-")
+			if !strings.Contains(name, "=") {
+				f := fs.Lookup(name)
+				isBool := false
+				if f != nil {
+					if bv, ok := f.Value.(interface{ IsBoolFlag() bool }); ok && bv.IsBoolFlag() {
+						isBool = true
+					}
+				}
+				if !isBool && i+1 < len(args) {
+					i++
+					flags = append(flags, args[i])
+				}
+			}
+		} else {
+			pos = append(pos, a)
+		}
+	}
+	fs.Parse(append(flags, pos...))
+}
+
+// parseCell resolves the frame size from --cell, or from the spritec
+// naming convention (auto-detecting integer upscales: a sheet named
+// _8x8_4x1 that is 256x64 px was rendered at scale 8, so cells are 64x64).
+func parseCell(spec, path string, imgW, imgH int) (int, int, error) {
+	if spec != "" {
+		parts := strings.SplitN(strings.ToLower(spec), "x", 2)
+		if len(parts) == 2 {
+			w, err1 := strconv.Atoi(parts[0])
+			h, err2 := strconv.Atoi(parts[1])
+			if err1 == nil && err2 == nil && w > 0 && h > 0 {
+				return w, h, nil
+			}
+		}
+		return 0, 0, fmt.Errorf("--cell %q must look like 8x8", spec)
+	}
+	if w, h, cols, rows, ok := hitbox.LayoutFromName(path); ok {
+		if s := hitbox.InferScale(imgW, imgH, w, h, cols, rows); s > 1 {
+			fmt.Fprintf(os.Stderr, "hitbox: image is %dx the named layout — using %dx%d cells\n", s, w*s, h*s)
+			return w * s, h * s, nil
+		}
+		return w, h, nil
+	}
+	return 0, 0, nil // whole image = one frame
+}
+
+func cmdScan(args []string) {
+	fs := flag.NewFlagSet("scan", flag.ExitOnError)
+	cell := fs.String("cell", "", "frame size WxH")
+	threshold := fs.Int("threshold", 1, "solid alpha 1-255")
+	shrink := fs.Int("shrink", 0, "contract boxes n px per side")
+	pad := fs.Int("pad", 0, "expand boxes n px per side")
+	out := fs.String("o", "", "output JSON path (default stdout)")
+	parseInterspersed(fs, args)
+	if fs.NArg() != 1 {
+		die("scan takes exactly one PNG file")
+	}
+	path := fs.Arg(0)
+	img, err := hitbox.LoadPNG(path)
+	if err != nil {
+		die("%v", err)
+	}
+	b := img.Bounds()
+	cw, ch, err := parseCell(*cell, path, b.Dx(), b.Dy())
+	if err != nil {
+		die("%v", err)
+	}
+	sheet, err := hitbox.Scan(img, path, cw, ch, *threshold, *shrink, *pad)
+	if err != nil {
+		die("%v", err)
+	}
+	if *out == "" {
+		if err := sheet.WriteJSON(os.Stdout); err != nil {
+			die("%v", err)
+		}
+		return
+	}
+	f, err := os.Create(*out)
+	if err != nil {
+		die("%v", err)
+	}
+	defer f.Close()
+	if err := sheet.WriteJSON(f); err != nil {
+		die("%v", err)
+	}
+	solid := 0
+	for _, fr := range sheet.Frames {
+		if !fr.Empty {
+			solid++
+		}
+	}
+	fmt.Printf("%s  (%d frames of %dx%d, %d with pixels)\n",
+		*out, len(sheet.Frames), sheet.CellW, sheet.CellH, solid)
+}
+
+func cmdShow(args []string) {
+	fs := flag.NewFlagSet("show", flag.ExitOnError)
+	cell := fs.String("cell", "", "frame size WxH")
+	threshold := fs.Int("threshold", 1, "solid alpha 1-255")
+	frame := fs.Int("frame", -1, "frame index (default: all)")
+	parseInterspersed(fs, args)
+	if fs.NArg() != 1 {
+		die("show takes exactly one PNG file")
+	}
+	path := fs.Arg(0)
+	img, err := hitbox.LoadPNG(path)
+	if err != nil {
+		die("%v", err)
+	}
+	b := img.Bounds()
+	cw, ch, err := parseCell(*cell, path, b.Dx(), b.Dy())
+	if err != nil {
+		die("%v", err)
+	}
+	sheet, err := hitbox.Scan(img, path, cw, ch, *threshold, 0, 0)
+	if err != nil {
+		die("%v", err)
+	}
+	for _, fr := range sheet.Frames {
+		if *frame >= 0 && fr.Index != *frame {
+			continue
+		}
+		if fr.Empty {
+			fmt.Printf("frame %d (col %d, row %d): empty\n\n", fr.Index, fr.Col, fr.Row)
+			continue
+		}
+		fmt.Printf("frame %d (col %d, row %d): box x=%d y=%d w=%d h=%d\n",
+			fr.Index, fr.Col, fr.Row, fr.Box.X, fr.Box.Y, fr.Box.W, fr.Box.H)
+		fmt.Print(hitbox.Ascii(img, sheet, fr.Index, *threshold))
+		fmt.Println()
+	}
+}
+
+func die(format string, a ...any) {
+	fmt.Fprintf(os.Stderr, "hitbox: "+format+"\n", a...)
+	os.Exit(1)
+}

notifyr/README.md

@@ -0,0 +1,62 @@
+# notifyr — ntfy client for agents
+
+Send and **read** notifications on the homelab's ntfy bus
+(`ntfy.brasse-pc.eu`) with one stable command prefix, so any agent can
+alert a human — and check what the infrastructure has been complaining
+about — without hand-rolled `curl` loops that each need a fresh
+approval. Closes the `PushNotification` gap from
+[`doc/tool-parity.md`](../doc/tool-parity.md) §3.3.
+
+## Usage
+
+```
+notifyr send --msg "text" [--topic T] [--title X]
+             [--priority min|low|default|high|urgent] [--tags a,b]
+notifyr read [--topic T] [--since 10m|2h|all] [--limit N]
+notifyr topics          # known topics + which one is the default
+notifyr version
+```
+
+Examples:
+
+```bash
+notifyr send --topic ci-fel --title "Build failed" \
+  --msg "agent-tools arm64 test: FAIL" --priority high
+
+notifyr read --topic pi5-server-fel --since 2h   # what has alerted lately?
+notifyr read --limit 5                           # newest 5 on the default topic
+```
+
+`read` uses ntfy's poll mode (`/json?poll=1&since=…`) and prints one
+greppable line per message:
+
+```
+2026-08-07 00:29:40 [high] (Build failed) agent-tools arm64 test: FAIL  #warning
+```
+
+Exit codes: 0 ok, 1 error (bad config, server unreachable, invalid
+priority…). `read` with zero messages is **not** an error.
+
+## Config
+
+`~/.config/notifyr/config.json`, created with homelab defaults on the
+first run (`NOTIFYR_CONFIG` overrides the path):
+
+```json
+{
+  "server": "https://ntfy.brasse-pc.eu",
+  "token": "",
+  "default_topic": "claude",
+  "topics": { "ci-fel": "failed Gitea Actions builds", "…": "…" }
+}
+```
+
+`topics` is informational — it feeds `notifyr topics` so an agent can
+pick the right bus without reading infra-Doc first. Edit freely.
+
+## Build & test
+
+```bash
+go test ./...
+go build -o build/notifyr .
+```

notifyr/go.mod

@@ -0,0 +1,3 @@
+module gitea.brasse-pc.eu/brasse/agent-tools/notifyr
+
+go 1.24

notifyr/main.go

@@ -0,0 +1,132 @@
+// notifyr sends and reads notifications on the homelab's ntfy bus, so
+// any agent can alert a human and check recent infra alerts the same
+// way. See doc/tool-parity.md §3.3.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+
+	"gitea.brasse-pc.eu/brasse/agent-tools/notifyr/notify"
+)
+
+var version = "dev"
+
+const usage = `notifyr - ntfy client for agents (send and read notifications)
+
+Usage:
+  notifyr send --msg "text" [--topic T] [--title X]
+               [--priority min|low|default|high|urgent] [--tags a,b]
+  notifyr read [--topic T] [--since 10m|2h|all] [--limit N]
+  notifyr topics                    list known topics (from the config)
+  notifyr version
+
+Config: ~/.config/notifyr/config.json (created on first run; override
+path with NOTIFYR_CONFIG). Holds server URL, optional token, the
+default topic and the known-topics table.
+
+Examples:
+  notifyr send --topic ci-fel --title "Build failed" --msg "agent-tools arm64: FAIL" --priority high
+  notifyr read --topic pi5-server-fel --since 2h     # what has alerted lately?
+`
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Print(usage)
+		os.Exit(2)
+	}
+	cfgPath := notify.ConfigPath()
+	switch os.Args[1] {
+	case "send":
+		cmdSend(cfgPath, os.Args[2:])
+	case "read":
+		cmdRead(cfgPath, os.Args[2:])
+	case "topics":
+		cmdTopics(cfgPath)
+	case "version", "--version", "-v":
+		fmt.Println("notifyr", version)
+	case "help", "--help", "-h":
+		fmt.Print(usage)
+	default:
+		die("unknown command %q — run 'notifyr help'", os.Args[1])
+	}
+}
+
+func cmdSend(cfgPath string, args []string) {
+	fs := flag.NewFlagSet("send", flag.ExitOnError)
+	topic := fs.String("topic", "", "topic (default: default_topic from config)")
+	title := fs.String("title", "", "notification title")
+	msg := fs.String("msg", "", "message text (required)")
+	priority := fs.String("priority", "", "min|low|default|high|urgent or 1-5")
+	tags := fs.String("tags", "", "comma-separated tags/emoji shortcodes")
+	fs.Parse(args)
+	cfg, err := notify.LoadConfig(cfgPath)
+	if err != nil {
+		die("%v", err)
+	}
+	if *topic == "" {
+		*topic = cfg.DefaultTopic
+	}
+	var tagList []string
+	if *tags != "" {
+		tagList = strings.Split(*tags, ",")
+	}
+	if err := notify.New(cfg.Server, cfg.Token).Send(*topic, *title, *msg, *priority, tagList); err != nil {
+		die("%v", err)
+	}
+	fmt.Printf("sent to %s/%s\n", cfg.Server, *topic)
+}
+
+func cmdRead(cfgPath string, args []string) {
+	fs := flag.NewFlagSet("read", flag.ExitOnError)
+	topic := fs.String("topic", "", "topic (default: default_topic from config)")
+	since := fs.String("since", "12h", "how far back: 10m, 2h, unix timestamp or all")
+	limit := fs.Int("limit", 0, "print at most N (newest) messages")
+	fs.Parse(args)
+	cfg, err := notify.LoadConfig(cfgPath)
+	if err != nil {
+		die("%v", err)
+	}
+	if *topic == "" {
+		*topic = cfg.DefaultTopic
+	}
+	msgs, err := notify.New(cfg.Server, cfg.Token).Read(*topic, *since, *limit)
+	if err != nil {
+		die("%v", err)
+	}
+	if len(msgs) == 0 {
+		fmt.Printf("no messages on %s since %s\n", *topic, *since)
+		return
+	}
+	for _, m := range msgs {
+		fmt.Println(notify.Format(m))
+	}
+}
+
+func cmdTopics(cfgPath string) {
+	cfg, err := notify.LoadConfig(cfgPath)
+	if err != nil {
+		die("%v", err)
+	}
+	names := make([]string, 0, len(cfg.Topics))
+	for n := range cfg.Topics {
+		names = append(names, n)
+	}
+	sort.Strings(names)
+	for _, n := range names {
+		mark := "  "
+		if n == cfg.DefaultTopic {
+			mark = "* "
+		}
+		fmt.Printf("%s%-18s %s\n", mark, n, cfg.Topics[n])
+	}
+	fmt.Fprintln(os.Stderr, "(* = default topic)")
+}
+
+func die(format string, args ...interface{}) {
+	fmt.Fprintf(os.Stderr, "notifyr: "+format+"\n", args...)
+	os.Exit(1)
+}

notifyr/notify/config.go

@@ -0,0 +1,78 @@
+package notify
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// Config is ~/.config/notifyr/config.json, created with homelab
+// defaults on first run. NOTIFYR_CONFIG overrides the path.
+type Config struct {
+	Server       string            `json:"server"`
+	Token        string            `json:"token"`
+	DefaultTopic string            `json:"default_topic"`
+	Topics       map[string]string `json:"topics"` // known topics -> what they carry (informational)
+}
+
+func DefaultConfig() *Config {
+	return &Config{
+		Server:       "https://ntfy.brasse-pc.eu",
+		Token:        "",
+		DefaultTopic: "claude",
+		Topics: map[string]string{
+			"claude":           "agents' direct notes to Björn",
+			"agent-helm":       "agent-helm events (question waiting, session died)",
+			"Info":             "*arr system events",
+			"media-hamtningar": "media grabbed for download",
+			"media-nytt":       "new media landed in Jellyfin",
+			"pi5-server":       "server maintenance (reboots, watchtower)",
+			"pi5-server-fel":   "server problems: failed units, disk space",
+			"ci-fel":           "failed Gitea Actions builds",
+			"monitoring":       "Uptime Kuma up/down alerts",
+		},
+	}
+}
+
+func ConfigPath() string {
+	if p := os.Getenv("NOTIFYR_CONFIG"); p != "" {
+		return p
+	}
+	dir, err := os.UserConfigDir()
+	if err != nil {
+		dir = "."
+	}
+	return filepath.Join(dir, "notifyr", "config.json")
+}
+
+// LoadConfig reads the config, creating it with defaults on first run.
+func LoadConfig(path string) (*Config, error) {
+	cfg := DefaultConfig()
+	data, err := os.ReadFile(path)
+	if os.IsNotExist(err) {
+		if err := SaveConfig(path, cfg); err != nil {
+			return nil, err
+		}
+		fmt.Fprintf(os.Stderr, "notifyr: created %s\n", path)
+		return cfg, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	if err := json.Unmarshal(data, cfg); err != nil {
+		return nil, fmt.Errorf("%s: %w", path, err)
+	}
+	return cfg, nil
+}
+
+func SaveConfig(path string, cfg *Config) error {
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return err
+	}
+	data, err := json.MarshalIndent(cfg, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(path, append(data, '\n'), 0o600)
+}

notifyr/notify/notify.go

@@ -0,0 +1,165 @@
+// Package notify is a thin client for a ntfy server: publish
+// notifications and poll past ones, so agents can both alert humans
+// and check what the infrastructure has been complaining about.
+package notify
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// Message is one ntfy message as returned by the /json poll endpoint.
+type Message struct {
+	ID       string   `json:"id"`
+	Time     int64    `json:"time"`
+	Event    string   `json:"event"`
+	Topic    string   `json:"topic"`
+	Title    string   `json:"title"`
+	Message  string   `json:"message"`
+	Priority int      `json:"priority"`
+	Tags     []string `json:"tags"`
+}
+
+// Client talks to one ntfy server.
+type Client struct {
+	Server string // e.g. https://ntfy.brasse-pc.eu
+	Token  string // optional bearer token
+	HTTP   *http.Client
+}
+
+func New(server, token string) *Client {
+	return &Client{
+		Server: strings.TrimRight(server, "/"),
+		Token:  token,
+		HTTP:   &http.Client{Timeout: 30 * time.Second},
+	}
+}
+
+func (c *Client) auth(req *http.Request) {
+	if c.Token != "" {
+		req.Header.Set("Authorization", "Bearer "+c.Token)
+	}
+}
+
+// ValidPriority reports whether p is a priority ntfy accepts.
+func ValidPriority(p string) bool {
+	switch p {
+	case "", "1", "2", "3", "4", "5", "min", "low", "default", "high", "max", "urgent":
+		return true
+	}
+	return false
+}
+
+// Send publishes a message to a topic.
+func (c *Client) Send(topic, title, msg, priority string, tags []string) error {
+	if topic == "" {
+		return fmt.Errorf("no topic given (flag --topic or default_topic in the config)")
+	}
+	if msg == "" {
+		return fmt.Errorf("empty message")
+	}
+	if !ValidPriority(priority) {
+		return fmt.Errorf("invalid priority %q (use min|low|default|high|urgent or 1-5)", priority)
+	}
+	req, err := http.NewRequest("POST", c.Server+"/"+url.PathEscape(topic), strings.NewReader(msg))
+	if err != nil {
+		return err
+	}
+	c.auth(req)
+	if title != "" {
+		req.Header.Set("Title", title)
+	}
+	if priority != "" {
+		req.Header.Set("Priority", priority)
+	}
+	if len(tags) > 0 {
+		req.Header.Set("Tags", strings.Join(tags, ","))
+	}
+	resp, err := c.HTTP.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+	if resp.StatusCode >= 300 {
+		return fmt.Errorf("server answered %s: %s", resp.Status, strings.TrimSpace(string(body)))
+	}
+	return nil
+}
+
+// Read polls past messages from a topic. since accepts ntfy's formats:
+// a duration ("10m", "2h"), a unix timestamp, a message id, or "all".
+func (c *Client) Read(topic, since string, limit int) ([]Message, error) {
+	if topic == "" {
+		return nil, fmt.Errorf("no topic given (flag --topic or default_topic in the config)")
+	}
+	if since == "" {
+		since = "all"
+	}
+	u := fmt.Sprintf("%s/%s/json?poll=1&since=%s", c.Server, url.PathEscape(topic), url.QueryEscape(since))
+	req, err := http.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, err
+	}
+	c.auth(req)
+	resp, err := c.HTTP.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= 300 {
+		body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+		return nil, fmt.Errorf("server answered %s: %s", resp.Status, strings.TrimSpace(string(body)))
+	}
+	var out []Message
+	sc := bufio.NewScanner(resp.Body)
+	sc.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+	for sc.Scan() {
+		line := strings.TrimSpace(sc.Text())
+		if line == "" {
+			continue
+		}
+		var m Message
+		if err := json.Unmarshal([]byte(line), &m); err != nil {
+			continue // tolerate junk lines; poll output is one JSON object per line
+		}
+		if m.Event != "message" {
+			continue
+		}
+		out = append(out, m)
+	}
+	if err := sc.Err(); err != nil {
+		return nil, err
+	}
+	if limit > 0 && len(out) > limit {
+		out = out[len(out)-limit:] // keep the newest
+	}
+	return out, nil
+}
+
+// Format renders a message as one stable, greppable line.
+func Format(m Message) string {
+	ts := time.Unix(m.Time, 0).Format("2006-01-02 15:04:05")
+	prio := ""
+	switch {
+	case m.Priority >= 4:
+		prio = " [high]"
+	case m.Priority > 0 && m.Priority <= 2:
+		prio = " [low]"
+	}
+	title := ""
+	if m.Title != "" {
+		title = " (" + m.Title + ")"
+	}
+	tags := ""
+	if len(m.Tags) > 0 {
+		tags = "  #" + strings.Join(m.Tags, " #")
+	}
+	return fmt.Sprintf("%s%s%s %s%s", ts, prio, title, strings.ReplaceAll(m.Message, "\n", " ⏎ "), tags)
+}

notifyr/notify/notify_test.go

@@ -0,0 +1,135 @@
+package notify
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestSendSetsHeadersAndBody(t *testing.T) {
+	var got *http.Request
+	var body string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		got = r
+		b := make([]byte, 1024)
+		n, _ := r.Body.Read(b)
+		body = string(b[:n])
+		fmt.Fprint(w, `{"id":"x"}`)
+	}))
+	defer srv.Close()
+
+	c := New(srv.URL, "tok123")
+	err := c.Send("ci-fel", "Build failed", "arm64 test: FAIL", "high", []string{"warning", "ci"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.URL.Path != "/ci-fel" {
+		t.Errorf("path = %q", got.URL.Path)
+	}
+	if body != "arm64 test: FAIL" {
+		t.Errorf("body = %q", body)
+	}
+	for hdr, want := range map[string]string{
+		"Title":         "Build failed",
+		"Priority":      "high",
+		"Tags":          "warning,ci",
+		"Authorization": "Bearer tok123",
+	} {
+		if v := got.Header.Get(hdr); v != want {
+			t.Errorf("%s = %q, want %q", hdr, v, want)
+		}
+	}
+}
+
+func TestSendValidation(t *testing.T) {
+	c := New("http://example.invalid", "")
+	if err := c.Send("", "", "hello", "", nil); err == nil {
+		t.Error("empty topic accepted")
+	}
+	if err := c.Send("t", "", "", "", nil); err == nil {
+		t.Error("empty message accepted")
+	}
+	if err := c.Send("t", "", "hello", "banana", nil); err == nil {
+		t.Error("bogus priority accepted")
+	}
+}
+
+func TestReadParsesPollOutput(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Query().Get("poll") != "1" {
+			t.Errorf("poll param missing: %s", r.URL.RawQuery)
+		}
+		if r.URL.Query().Get("since") != "2h" {
+			t.Errorf("since = %q", r.URL.Query().Get("since"))
+		}
+		fmt.Fprintln(w, `{"id":"a","time":1754500000,"event":"message","topic":"t","message":"first","priority":3}`)
+		fmt.Fprintln(w, `{"id":"b","time":1754500060,"event":"keepalive","topic":"t"}`)
+		fmt.Fprintln(w, `not json at all`)
+		fmt.Fprintln(w, `{"id":"c","time":1754500120,"event":"message","topic":"t","title":"T","message":"second","priority":5,"tags":["x"]}`)
+	}))
+	defer srv.Close()
+
+	msgs, err := New(srv.URL, "").Read("t", "2h", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(msgs) != 2 {
+		t.Fatalf("got %d messages, want 2 (keepalive + junk filtered)", len(msgs))
+	}
+	if msgs[0].Message != "first" || msgs[1].Title != "T" {
+		t.Errorf("unexpected messages: %+v", msgs)
+	}
+}
+
+func TestReadLimitKeepsNewest(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		for i := 1; i <= 5; i++ {
+			fmt.Fprintf(w, "{\"id\":\"%d\",\"time\":%d,\"event\":\"message\",\"topic\":\"t\",\"message\":\"m%d\"}\n", i, 1754500000+i, i)
+		}
+	}))
+	defer srv.Close()
+	msgs, err := New(srv.URL, "").Read("t", "all", 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(msgs) != 2 || msgs[0].Message != "m4" || msgs[1].Message != "m5" {
+		t.Errorf("limit should keep the newest: %+v", msgs)
+	}
+}
+
+func TestFormatIsOneGreppableLine(t *testing.T) {
+	line := Format(Message{Time: 1754500000, Title: "Backup", Message: "done\nall good", Priority: 4, Tags: []string{"ok"}})
+	if strings.Contains(line, "\n") {
+		t.Error("format must be a single line")
+	}
+	for _, want := range []string{"[high]", "(Backup)", "done", "#ok"} {
+		if !strings.Contains(line, want) {
+			t.Errorf("line %q missing %q", line, want)
+		}
+	}
+}
+
+func TestConfigRoundtrip(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "config.json")
+	cfg, err := LoadConfig(path) // first run creates defaults
+	if err != nil {
+		t.Fatal(err)
+	}
+	if cfg.Server == "" || cfg.DefaultTopic == "" {
+		t.Error("defaults incomplete")
+	}
+	cfg.DefaultTopic = "elsewhere"
+	if err := SaveConfig(path, cfg); err != nil {
+		t.Fatal(err)
+	}
+	again, err := LoadConfig(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if again.DefaultTopic != "elsewhere" {
+		t.Error("saved change did not persist")
+	}
+}

pixel-sprite-maker/README.md

@@ -0,0 +1,86 @@
+# pixel-sprite-maker (`spritec`)
+
+Turns human/agent-readable `.sprite` text files into pixel art (**PNG, JPG, SVG**)
+and combines several sprites into **sprite sheets / animation strips**.
+Written in Go, zero dependencies, single static binary.
+
+## Build
+
+```bash
+# Arch/Garuda: sudo pacman -S go
+cd pixel-sprite-maker
+go build -o build/spritec .        # or run the VS Code task "build pixel-sprite-maker"
+go test ./...
+```
+
+## The `.sprite` format
+
+One file = one sprite. Designed so an agent can *see* the result in the text:
+
+```
+# comment lines start with '#'
+sprite: coin           # optional name
+palette:
+  k = #1A1205    dark outline
+  y = #FFD700    gold
+  Y = gold       CSS names work too — text after the color is a comment
+grid:
+  ..kkkk..
+  .kyyyYk.
+  kyyyYYyk
+  ..kkkk..
+```
+
+Rules:
+
+- **One character = one pixel.** Every grid row must be the same width.
+- Palette keys are exactly one character (any unicode). `#`, `=`, `:` and
+  whitespace are not allowed as keys — so the number of colors is
+  practically unlimited (a-z, A-Z, 0-9, `!@%&*`, unicode…).
+- `.` is **transparent by default**; override it in the palette if you want.
+- Colors: `#RGB`, `#RGBA`, `#RRGGBB`, `#RRGGBBAA`, `rgb(r,g,b)`,
+  `rgba(r,g,b,a)` (alpha 0-255 or 0.0-1.0), all CSS named colors, `none`.
+- Max **256x256** pixels per sprite. Sheets may exceed this; single frames may not.
+
+## Commands
+
+```bash
+spritec render coin.sprite -o coin.png --scale 8      # png/jpg/svg from extension
+spritec render coin.sprite --format svg               # -> coin.svg
+spritec render heart.sprite -o heart.jpg --bg '#222034'  # jpg has no alpha: pick bg
+spritec info coin.sprite                              # validate + palette stats
+spritec preview coin.sprite                           # draw in the terminal (truecolor)
+
+# Sprite sheets / animations — row-major (left→right, then top→bottom):
+spritec sheet walk_1.sprite walk_2.sprite walk_3.sprite walk_4.sprite -o walk           # 1 row
+spritec sheet walk_*.sprite --cols 2 -o walkgrid      # 2D: 2 columns x 2 rows
+```
+
+Flags: `-o` output, `--format png|jpg|svg`, `--scale n` (integer nearest-neighbour
+upscale), `--bg color` + `--quality 1-100` (jpg only), `--cols n` (sheet only).
+
+## Sheet output naming — read the layout from the file name
+
+```
+<name>_<cellW>x<cellH>_<cols>x<rows>.<ext>
+
+walk_8x8_4x1.png   = 8x8 px per frame, 4 columns, 1 row (animation strip)
+tiles_16x16_4x2.png = 16x16 px per frame, 4 columns, 2 rows
+```
+
+Frame order is always **row-major**: index = `row * cols + col`, frame 0 is
+top-left. If the frame count doesn't fill the grid, trailing cells are
+transparent. In game code:
+
+```
+frameX = (index % cols) * cellW
+frameY = (index / cols) * cellH
+```
+
+## Exit codes & errors
+
+`0` on success, `1` on any error, `2` on missing command. Parse errors name
+the exact line/row/column and what was expected, so an agent can fix the
+file without guessing.
+
+Examples live in [`examples/`](examples/); generated output in `examples/out/`.

pixel-sprite-maker/examples/coin.sprite

@@ -0,0 +1,17 @@
+# A small gold coin, 8x8.
+# '.' is transparent by default and never needs a palette entry.
+sprite: coin
+palette:
+  k = #1A1205    dark outline
+  y = #FFD700    gold
+  Y = #FFF3A0    highlight
+  s = #B8860B    shadow
+grid:
+  ..kkkk..
+  .kyyyYk.
+  kyyyYYsk
+  kyyYyysk
+  kyYyyysk
+  kYyyyssk
+  .kysssk.
+  ..kkkk..

pixel-sprite-maker/examples/heart.sprite

@@ -0,0 +1,25 @@
+# A 16x16 heart with shading, shows named colors and rgb().
+sprite: heart
+palette:
+  k = #2B0A10          outline
+  r = crimson          main red
+  R = rgb(255, 90, 110) light red
+  d = #8B1A2B          dark red
+  w = #FFFFFFCC        semi-transparent shine
+grid:
+  ................
+  ..kkk....kkk....
+  .krrRk..kRrrk...
+  krrRRrkkrRrrrk..
+  krRwRrrrrrrrdk..
+  krRwwRrrrrrrdk..
+  krRwRrrrrrrddk..
+  krrRrrrrrrrddk..
+  .krrrrrrrrrdk...
+  ..krrrrrrrdk....
+  ...krrrrrdk.....
+  ....krrrdk......
+  .....krdk.......
+  ......kk........
+  ................
+  ................

pixel-sprite-maker/examples/out/coin.svg

@@ -0,0 +1,34 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 8 8" shape-rendering="crispEdges">
+<rect x="2" y="0" width="4" height="1" fill="#1a1205"/>
+<rect x="1" y="1" width="1" height="1" fill="#1a1205"/>
+<rect x="2" y="1" width="3" height="1" fill="#ffd700"/>
+<rect x="5" y="1" width="1" height="1" fill="#fff3a0"/>
+<rect x="6" y="1" width="1" height="1" fill="#1a1205"/>
+<rect x="0" y="2" width="1" height="1" fill="#1a1205"/>
+<rect x="1" y="2" width="3" height="1" fill="#ffd700"/>
+<rect x="4" y="2" width="2" height="1" fill="#fff3a0"/>
+<rect x="6" y="2" width="1" height="1" fill="#b8860b"/>
+<rect x="7" y="2" width="1" height="1" fill="#1a1205"/>
+<rect x="0" y="3" width="1" height="1" fill="#1a1205"/>
+<rect x="1" y="3" width="2" height="1" fill="#ffd700"/>
+<rect x="3" y="3" width="1" height="1" fill="#fff3a0"/>
+<rect x="4" y="3" width="2" height="1" fill="#ffd700"/>
+<rect x="6" y="3" width="1" height="1" fill="#b8860b"/>
+<rect x="7" y="3" width="1" height="1" fill="#1a1205"/>
+<rect x="0" y="4" width="1" height="1" fill="#1a1205"/>
+<rect x="1" y="4" width="1" height="1" fill="#ffd700"/>
+<rect x="2" y="4" width="1" height="1" fill="#fff3a0"/>
+<rect x="3" y="4" width="3" height="1" fill="#ffd700"/>
+<rect x="6" y="4" width="1" height="1" fill="#b8860b"/>
+<rect x="7" y="4" width="1" height="1" fill="#1a1205"/>
+<rect x="0" y="5" width="1" height="1" fill="#1a1205"/>
+<rect x="1" y="5" width="1" height="1" fill="#fff3a0"/>
+<rect x="2" y="5" width="3" height="1" fill="#ffd700"/>
+<rect x="5" y="5" width="2" height="1" fill="#b8860b"/>
+<rect x="7" y="5" width="1" height="1" fill="#1a1205"/>
+<rect x="1" y="6" width="1" height="1" fill="#1a1205"/>
+<rect x="2" y="6" width="1" height="1" fill="#ffd700"/>
+<rect x="3" y="6" width="3" height="1" fill="#b8860b"/>
+<rect x="6" y="6" width="1" height="1" fill="#1a1205"/>
+<rect x="2" y="7" width="4" height="1" fill="#1a1205"/>
+</svg>

pixel-sprite-maker/examples/out/walkgrid_8x8_2x2.svg

@@ -0,0 +1,57 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16" shape-rendering="crispEdges">
+<rect x="2" y="0" width="3" height="1" fill="#101018"/>
+<rect x="10" y="0" width="3" height="1" fill="#101018"/>
+<rect x="2" y="1" width="1" height="1" fill="#101018"/>
+<rect x="3" y="1" width="2" height="1" fill="#f2c09a"/>
+<rect x="10" y="1" width="1" height="1" fill="#101018"/>
+<rect x="11" y="1" width="2" height="1" fill="#f2c09a"/>
+<rect x="2" y="2" width="1" height="1" fill="#101018"/>
+<rect x="3" y="2" width="2" height="1" fill="#f2c09a"/>
+<rect x="10" y="2" width="1" height="1" fill="#101018"/>
+<rect x="11" y="2" width="2" height="1" fill="#f2c09a"/>
+<rect x="1" y="3" width="1" height="1" fill="#101018"/>
+<rect x="2" y="3" width="3" height="1" fill="#2e5fb7"/>
+<rect x="5" y="3" width="1" height="1" fill="#101018"/>
+<rect x="9" y="3" width="1" height="1" fill="#101018"/>
+<rect x="10" y="3" width="3" height="1" fill="#2e5fb7"/>
+<rect x="13" y="3" width="1" height="1" fill="#101018"/>
+<rect x="2" y="4" width="3" height="1" fill="#2e5fb7"/>
+<rect x="10" y="4" width="3" height="1" fill="#2e5fb7"/>
+<rect x="2" y="5" width="3" height="1" fill="#22406e"/>
+<rect x="10" y="5" width="3" height="1" fill="#22406e"/>
+<rect x="2" y="6" width="1" height="1" fill="#22406e"/>
+<rect x="4" y="6" width="1" height="1" fill="#22406e"/>
+<rect x="9" y="6" width="1" height="1" fill="#22406e"/>
+<rect x="13" y="6" width="1" height="1" fill="#22406e"/>
+<rect x="2" y="7" width="1" height="1" fill="#101018"/>
+<rect x="4" y="7" width="1" height="1" fill="#101018"/>
+<rect x="9" y="7" width="1" height="1" fill="#101018"/>
+<rect x="13" y="7" width="1" height="1" fill="#101018"/>
+<rect x="2" y="8" width="3" height="1" fill="#101018"/>
+<rect x="10" y="8" width="3" height="1" fill="#101018"/>
+<rect x="2" y="9" width="1" height="1" fill="#101018"/>
+<rect x="3" y="9" width="2" height="1" fill="#f2c09a"/>
+<rect x="10" y="9" width="1" height="1" fill="#101018"/>
+<rect x="11" y="9" width="2" height="1" fill="#f2c09a"/>
+<rect x="2" y="10" width="1" height="1" fill="#101018"/>
+<rect x="3" y="10" width="2" height="1" fill="#f2c09a"/>
+<rect x="10" y="10" width="1" height="1" fill="#101018"/>
+<rect x="11" y="10" width="2" height="1" fill="#f2c09a"/>
+<rect x="2" y="11" width="3" height="1" fill="#2e5fb7"/>
+<rect x="5" y="11" width="1" height="1" fill="#101018"/>
+<rect x="9" y="11" width="1" height="1" fill="#101018"/>
+<rect x="10" y="11" width="3" height="1" fill="#2e5fb7"/>
+<rect x="13" y="11" width="1" height="1" fill="#101018"/>
+<rect x="1" y="12" width="1" height="1" fill="#101018"/>
+<rect x="2" y="12" width="3" height="1" fill="#2e5fb7"/>
+<rect x="10" y="12" width="3" height="1" fill="#2e5fb7"/>
+<rect x="2" y="13" width="3" height="1" fill="#22406e"/>
+<rect x="10" y="13" width="3" height="1" fill="#22406e"/>
+<rect x="2" y="14" width="1" height="1" fill="#22406e"/>
+<rect x="4" y="14" width="1" height="1" fill="#22406e"/>
+<rect x="10" y="14" width="2" height="1" fill="#22406e"/>
+<rect x="2" y="15" width="1" height="1" fill="#101018"/>
+<rect x="4" y="15" width="1" height="1" fill="#101018"/>
+<rect x="9" y="15" width="1" height="1" fill="#101018"/>
+<rect x="12" y="15" width="1" height="1" fill="#101018"/>
+</svg>

pixel-sprite-maker/examples/walk_1.sprite

@@ -0,0 +1,16 @@
+# Frame 1/4 of a tiny walking guy, 8x8. Legs together.
+sprite: walk_1
+palette:
+  k = #101018    outline / hair
+  s = #F2C09A    skin
+  b = #2E5FB7    shirt
+  d = #22406E    pants
+grid:
+  ..kkk...
+  ..kss...
+  ..kss...
+  .kbbbk..
+  ..bbb...
+  ..ddd...
+  ..d.d...
+  ..k.k...

pixel-sprite-maker/examples/walk_2.sprite

@@ -0,0 +1,16 @@
+# Frame 2/4 - right leg forward.
+sprite: walk_2
+palette:
+  k = #101018    outline / hair
+  s = #F2C09A    skin
+  b = #2E5FB7    shirt
+  d = #22406E    pants
+grid:
+  ..kkk...
+  ..kss...
+  ..kss...
+  .kbbbk..
+  ..bbb...
+  ..ddd...
+  .d...d..
+  .k...k..

pixel-sprite-maker/examples/walk_3.sprite

@@ -0,0 +1,16 @@
+# Frame 3/4 - legs together again (same pose as 1, arms swung).
+sprite: walk_3
+palette:
+  k = #101018    outline / hair
+  s = #F2C09A    skin
+  b = #2E5FB7    shirt
+  d = #22406E    pants
+grid:
+  ..kkk...
+  ..kss...
+  ..kss...
+  ..bbbk..
+  .kbbb...
+  ..ddd...
+  ..d.d...
+  ..k.k...

pixel-sprite-maker/examples/walk_4.sprite

@@ -0,0 +1,16 @@
+# Frame 4/4 - left leg forward.
+sprite: walk_4
+palette:
+  k = #101018    outline / hair
+  s = #F2C09A    skin
+  b = #2E5FB7    shirt
+  d = #22406E    pants
+grid:
+  ..kkk...
+  ..kss...
+  ..kss...
+  .kbbbk..
+  ..bbb...
+  ..ddd...
+  ..dd....
+  .k..k...

pixel-sprite-maker/go.mod

@@ -0,0 +1,3 @@
+module gitea.brasse-pc.eu/brasse/agent-tools/pixel-sprite-maker
+
+go 1.24

pixel-sprite-maker/main.go

@@ -0,0 +1,313 @@
+// spritec turns agent-friendly .sprite text files into PNG/JPG/SVG pixel
+// art, and combines several sprites into sprite sheets / animation strips.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"gitea.brasse-pc.eu/brasse/agent-tools/pixel-sprite-maker/sprite"
+)
+
+var version = "dev"
+
+const usage = `spritec - pixel sprite maker for agents
+
+Usage:
+  spritec render <file.sprite> [flags]   render one sprite to png/jpg/svg
+  spritec sheet <a.sprite> <b.sprite> ... [flags]
+                                          combine sprites into one sheet image
+  spritec info <file.sprite>              validate a file and print its stats
+  spritec preview <file.sprite>           draw the sprite in the terminal
+  spritec version                         print version
+
+Render flags:
+  -o <path>        output file; its extension picks the format (.png .jpg .svg)
+  --format <f>     png | jpg | svg (default: from -o, else png)
+  --scale <n>      integer upscale factor, default 1
+  --bg <color>     jpg background color (jpg has no alpha), default #FFFFFF
+  --quality <n>    jpg quality 1-100, default 90
+
+Sheet flags (in addition to the render flags):
+  -o <name>        output base name; layout is appended automatically
+  --cols <n>       number of columns, row-major order (default: one row)
+
+Sheet output naming:
+  <name>_<cellW>x<cellH>_<cols>x<rows>.<ext>
+  e.g. walk_16x16_4x2.png = 16x16 px per frame, 4 columns, 2 rows,
+  frames are read left-to-right then top-to-bottom (row-major).
+
+The .sprite format:
+  # comment
+  sprite: coin           optional name
+  palette:
+    . = none             '.' is transparent by default
+    k = #000000          hex, rgb(...), CSS names ('gold') and 'none' work
+    y = gold             anything after the color is a comment
+  grid:
+    ..kk..
+    .kyyk.
+    .kyyk.
+    ..kk..
+
+Each grid character is one pixel; every row must be the same width.
+Max sprite size: 256x256. Sheets may be bigger, single frames may not.
+`
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Print(usage)
+		os.Exit(2)
+	}
+	switch os.Args[1] {
+	case "render":
+		cmdRender(os.Args[2:])
+	case "sheet":
+		cmdSheet(os.Args[2:])
+	case "info":
+		cmdInfo(os.Args[2:])
+	case "preview":
+		cmdPreview(os.Args[2:])
+	case "version", "--version", "-v":
+		fmt.Println("spritec", version)
+	case "help", "--help", "-h":
+		fmt.Print(usage)
+	default:
+		die("unknown command %q — run 'spritec help'", os.Args[1])
+	}
+}
+
+// parseInterspersed lets flags appear before or after positional args
+// (stdlib flag stops at the first positional otherwise).
+func parseInterspersed(fs *flag.FlagSet, args []string) {
+	var flags, pos []string
+	for i := 0; i < len(args); i++ {
+		a := args[i]
+		if len(a) > 1 && a[0] == '-' {
+			flags = append(flags, a)
+			name := strings.TrimLeft(a, "-")
+			if !strings.Contains(name, "=") {
+				f := fs.Lookup(name)
+				isBool := false
+				if f != nil {
+					if bv, ok := f.Value.(interface{ IsBoolFlag() bool }); ok && bv.IsBoolFlag() {
+						isBool = true
+					}
+				}
+				if !isBool && i+1 < len(args) {
+					i++
+					flags = append(flags, args[i])
+				}
+			}
+		} else {
+			pos = append(pos, a)
+		}
+	}
+	fs.Parse(append(flags, pos...))
+}
+
+type renderFlags struct {
+	out     string
+	format  string
+	scale   int
+	bg      string
+	quality int
+}
+
+func addRenderFlags(fs *flag.FlagSet) *renderFlags {
+	rf := &renderFlags{}
+	fs.StringVar(&rf.out, "o", "", "output path")
+	fs.StringVar(&rf.format, "format", "", "png|jpg|svg")
+	fs.IntVar(&rf.scale, "scale", 1, "integer upscale factor")
+	fs.StringVar(&rf.bg, "bg", "#FFFFFF", "jpg background color")
+	fs.IntVar(&rf.quality, "quality", 90, "jpg quality 1-100")
+	return rf
+}
+
+// resolveFormat picks the output format from --format or the -o extension.
+func (rf *renderFlags) resolveFormat() (string, error) {
+	ext := strings.ToLower(strings.TrimPrefix(filepath.Ext(rf.out), "."))
+	if ext == "jpeg" {
+		ext = "jpg"
+	}
+	f := strings.ToLower(rf.format)
+	switch {
+	case f == "" && ext == "":
+		return "png", nil
+	case f == "":
+		f = ext
+	case ext != "" && ext != f:
+		return "", fmt.Errorf("--format %s conflicts with output extension .%s", f, ext)
+	}
+	switch f {
+	case "png", "jpg", "svg":
+		return f, nil
+	}
+	return "", fmt.Errorf("unsupported format %q (png, jpg or svg)", f)
+}
+
+func writeGrid(path, format string, g sprite.PixelGrid, rf *renderFlags) error {
+	bg, err := sprite.ParseColor(rf.bg)
+	if err != nil {
+		return fmt.Errorf("--bg: %w", err)
+	}
+	f, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	switch format {
+	case "png":
+		err = sprite.WritePNG(f, g, rf.scale)
+	case "jpg":
+		err = sprite.WriteJPG(f, g, rf.scale, bg, rf.quality)
+	case "svg":
+		err = sprite.WriteSVG(f, g, rf.scale)
+	}
+	if err != nil {
+		return err
+	}
+	return f.Close()
+}
+
+func cmdRender(args []string) {
+	fs := flag.NewFlagSet("render", flag.ExitOnError)
+	rf := addRenderFlags(fs)
+	parseInterspersed(fs, args)
+	if fs.NArg() != 1 {
+		die("render takes exactly one .sprite file")
+	}
+	in := fs.Arg(0)
+	s, err := sprite.ParseFile(in)
+	if err != nil {
+		die("%v", err)
+	}
+	format, err := rf.resolveFormat()
+	if err != nil {
+		die("%v", err)
+	}
+	out := rf.out
+	if out == "" {
+		out = strings.TrimSuffix(in, filepath.Ext(in)) + "." + format
+	}
+	if err := writeGrid(out, format, s, rf); err != nil {
+		die("%v", err)
+	}
+	w, h := s.Bounds()
+	fmt.Printf("%s  (%dx%d px, scale %d -> %dx%d)\n", out, w, h, rf.scale, w*rf.scale, h*rf.scale)
+}
+
+func cmdSheet(args []string) {
+	fs := flag.NewFlagSet("sheet", flag.ExitOnError)
+	rf := addRenderFlags(fs)
+	cols := fs.Int("cols", 0, "columns in the sheet (default: all sprites in one row)")
+	parseInterspersed(fs, args)
+	if fs.NArg() < 1 {
+		die("sheet needs at least one .sprite file")
+	}
+	var sprites []*sprite.Sprite
+	for _, path := range fs.Args() {
+		s, err := sprite.ParseFile(path)
+		if err != nil {
+			die("%v", err)
+		}
+		sprites = append(sprites, s)
+	}
+	sh, err := sprite.NewSheet(sprites, *cols)
+	if err != nil {
+		die("%v", err)
+	}
+	format, err := rf.resolveFormat()
+	if err != nil {
+		die("%v", err)
+	}
+	base := rf.out
+	if base == "" {
+		base = "sheet"
+	}
+	base = strings.TrimSuffix(base, filepath.Ext(base))
+	out := sh.FileBase(base) + "." + format
+	if err := writeGrid(out, format, sh, rf); err != nil {
+		die("%v", err)
+	}
+	w, h := sh.Bounds()
+	fmt.Printf("%s  (%d frames of %dx%d px in %dx%d grid, total %dx%d px)\n",
+		out, len(sprites), sh.CellW, sh.CellH, sh.Cols, sh.Rows, w*rf.scale, h*rf.scale)
+}
+
+func cmdInfo(args []string) {
+	if len(args) != 1 {
+		die("info takes exactly one .sprite file")
+	}
+	s, err := sprite.ParseFile(args[0])
+	if err != nil {
+		die("%v", err)
+	}
+	fmt.Printf("sprite:  %s\n", s.Name)
+	fmt.Printf("size:    %dx%d px\n", s.W, s.H)
+	fmt.Printf("palette: %d colors\n", len(s.Keys))
+	usage := s.UsageCount()
+	for _, k := range s.Keys {
+		note := ""
+		if usage[k] == 0 {
+			note = "   (unused)"
+		}
+		fmt.Printf("  %s = %-9s  %5d px%s\n", string(k), sprite.FormatColor(s.Palette[k]), usage[k], note)
+	}
+	if _, defined := usage['.']; defined && !contains(s.Keys, '.') {
+		fmt.Printf("  . = none       %5d px   (implicit transparent)\n", usage['.'])
+	}
+	fmt.Println("valid:   yes")
+}
+
+func contains(keys []rune, k rune) bool {
+	for _, x := range keys {
+		if x == k {
+			return true
+		}
+	}
+	return false
+}
+
+// cmdPreview draws the sprite with truecolor half-blocks, two pixel rows
+// per terminal line. Transparent pixels show the terminal background.
+func cmdPreview(args []string) {
+	if len(args) != 1 {
+		die("preview takes exactly one .sprite file")
+	}
+	s, err := sprite.ParseFile(args[0])
+	if err != nil {
+		die("%v", err)
+	}
+	const reset = "\x1b[0m"
+	var b strings.Builder
+	for y := 0; y < s.H; y += 2 {
+		for x := 0; x < s.W; x++ {
+			top, bot := s.At(x, y), sprite.Transparent
+			if y+1 < s.H {
+				bot = s.At(x, y+1)
+			}
+			topOn, botOn := top.A >= 128, bot.A >= 128
+			switch {
+			case topOn && botOn:
+				fmt.Fprintf(&b, "\x1b[38;2;%d;%d;%dm\x1b[48;2;%d;%d;%dm▀%s", top.R, top.G, top.B, bot.R, bot.G, bot.B, reset)
+			case topOn:
+				fmt.Fprintf(&b, "\x1b[38;2;%d;%d;%dm▀%s", top.R, top.G, top.B, reset)
+			case botOn:
+				fmt.Fprintf(&b, "\x1b[38;2;%d;%d;%dm▄%s", bot.R, bot.G, bot.B, reset)
+			default:
+				b.WriteByte(' ')
+			}
+		}
+		b.WriteByte('\n')
+	}
+	fmt.Printf("%s  %dx%d px\n%s", s.Name, s.W, s.H, b.String())
+}
+
+func die(format string, a ...any) {
+	fmt.Fprintf(os.Stderr, "spritec: "+format+"\n", a...)
+	os.Exit(1)
+}

pixel-sprite-maker/sprite/color.go

@@ -0,0 +1,270 @@
+package sprite
+
+import (
+	"fmt"
+	"image/color"
+	"strconv"
+	"strings"
+)
+
+// Transparent is the color used for pixels that should not be drawn.
+var Transparent = color.NRGBA{0, 0, 0, 0}
+
+// ParseColor accepts:
+//
+//	none | transparent | -           -> fully transparent
+//	#RGB #RGBA #RRGGBB #RRGGBBAA     -> hex
+//	rgb(r,g,b) rgba(r,g,b,a)         -> 0-255 channels, alpha 0-255 or 0.0-1.0
+//	CSS named colors                 -> "red", "rebeccapurple", ...
+func ParseColor(s string) (color.NRGBA, error) {
+	t := strings.ToLower(strings.TrimSpace(s))
+	if t == "" {
+		return Transparent, fmt.Errorf("empty color value")
+	}
+	switch t {
+	case "none", "transparent", "-":
+		return Transparent, nil
+	}
+	if strings.HasPrefix(t, "#") {
+		return parseHex(t)
+	}
+	if strings.HasPrefix(t, "rgb(") || strings.HasPrefix(t, "rgba(") {
+		return parseRGBFunc(t)
+	}
+	if c, ok := cssColors[t]; ok {
+		return c, nil
+	}
+	return Transparent, fmt.Errorf("unknown color %q (use #RRGGBB, rgb(r,g,b), a CSS color name, or 'none')", s)
+}
+
+func parseHex(t string) (color.NRGBA, error) {
+	h := t[1:]
+	var r, g, b, a uint64
+	var err error
+	dup := func(s string) (uint64, error) {
+		v, err := strconv.ParseUint(s, 16, 8)
+		return v*16 + v, err
+	}
+	a = 255
+	switch len(h) {
+	case 3, 4:
+		if r, err = dup(h[0:1]); err == nil {
+			if g, err = dup(h[1:2]); err == nil {
+				b, err = dup(h[2:3])
+			}
+		}
+		if err == nil && len(h) == 4 {
+			a, err = dup(h[3:4])
+		}
+	case 6, 8:
+		if r, err = strconv.ParseUint(h[0:2], 16, 8); err == nil {
+			if g, err = strconv.ParseUint(h[2:4], 16, 8); err == nil {
+				b, err = strconv.ParseUint(h[4:6], 16, 8)
+			}
+		}
+		if err == nil && len(h) == 8 {
+			a, err = strconv.ParseUint(h[6:8], 16, 8)
+		}
+	default:
+		return Transparent, fmt.Errorf("hex color %q must be #RGB, #RGBA, #RRGGBB or #RRGGBBAA", t)
+	}
+	if err != nil {
+		return Transparent, fmt.Errorf("invalid hex color %q", t)
+	}
+	return color.NRGBA{uint8(r), uint8(g), uint8(b), uint8(a)}, nil
+}
+
+func parseRGBFunc(t string) (color.NRGBA, error) {
+	open := strings.Index(t, "(")
+	close := strings.Index(t, ")")
+	if close < open {
+		return Transparent, fmt.Errorf("invalid color %q: missing ')'", t)
+	}
+	parts := strings.Split(t[open+1:close], ",")
+	if len(parts) != 3 && len(parts) != 4 {
+		return Transparent, fmt.Errorf("invalid color %q: want rgb(r,g,b) or rgba(r,g,b,a)", t)
+	}
+	var ch [4]uint8
+	ch[3] = 255
+	for i, p := range parts {
+		p = strings.TrimSpace(p)
+		if i == 3 && strings.Contains(p, ".") {
+			// CSS-style fractional alpha 0.0 - 1.0
+			f, err := strconv.ParseFloat(p, 64)
+			if err != nil || f < 0 || f > 1 {
+				return Transparent, fmt.Errorf("invalid alpha %q in %q (want 0.0-1.0 or 0-255)", p, t)
+			}
+			ch[3] = uint8(f*255 + 0.5)
+			continue
+		}
+		v, err := strconv.ParseUint(p, 10, 8)
+		if err != nil {
+			return Transparent, fmt.Errorf("invalid channel %q in %q (want 0-255)", p, t)
+		}
+		ch[i] = uint8(v)
+	}
+	return color.NRGBA{ch[0], ch[1], ch[2], ch[3]}, nil
+}
+
+// FormatColor renders a color the way it should appear in a .sprite file.
+func FormatColor(c color.NRGBA) string {
+	if c.A == 0 {
+		return "none"
+	}
+	if c.A == 255 {
+		return fmt.Sprintf("#%02X%02X%02X", c.R, c.G, c.B)
+	}
+	return fmt.Sprintf("#%02X%02X%02X%02X", c.R, c.G, c.B, c.A)
+}
+
+// cssColors is the full CSS Color Module Level 4 named-color list.
+var cssColors = map[string]color.NRGBA{
+	"aliceblue":            {240, 248, 255, 255},
+	"antiquewhite":         {250, 235, 215, 255},
+	"aqua":                 {0, 255, 255, 255},
+	"aquamarine":           {127, 255, 212, 255},
+	"azure":                {240, 255, 255, 255},
+	"beige":                {245, 245, 220, 255},
+	"bisque":               {255, 228, 196, 255},
+	"black":                {0, 0, 0, 255},
+	"blanchedalmond":       {255, 235, 205, 255},
+	"blue":                 {0, 0, 255, 255},
+	"blueviolet":           {138, 43, 226, 255},
+	"brown":                {165, 42, 42, 255},
+	"burlywood":            {222, 184, 135, 255},
+	"cadetblue":            {95, 158, 160, 255},
+	"chartreuse":           {127, 255, 0, 255},
+	"chocolate":            {210, 105, 30, 255},
+	"coral":                {255, 127, 80, 255},
+	"cornflowerblue":       {100, 149, 237, 255},
+	"cornsilk":             {255, 248, 220, 255},
+	"crimson":              {220, 20, 60, 255},
+	"cyan":                 {0, 255, 255, 255},
+	"darkblue":             {0, 0, 139, 255},
+	"darkcyan":             {0, 139, 139, 255},
+	"darkgoldenrod":        {184, 134, 11, 255},
+	"darkgray":             {169, 169, 169, 255},
+	"darkgreen":            {0, 100, 0, 255},
+	"darkgrey":             {169, 169, 169, 255},
+	"darkkhaki":            {189, 183, 107, 255},
+	"darkmagenta":          {139, 0, 139, 255},
+	"darkolivegreen":       {85, 107, 47, 255},
+	"darkorange":           {255, 140, 0, 255},
+	"darkorchid":           {153, 50, 204, 255},
+	"darkred":              {139, 0, 0, 255},
+	"darksalmon":           {233, 150, 122, 255},
+	"darkseagreen":         {143, 188, 143, 255},
+	"darkslateblue":        {72, 61, 139, 255},
+	"darkslategray":        {47, 79, 79, 255},
+	"darkslategrey":        {47, 79, 79, 255},
+	"darkturquoise":        {0, 206, 209, 255},
+	"darkviolet":           {148, 0, 211, 255},
+	"deeppink":             {255, 20, 147, 255},
+	"deepskyblue":          {0, 191, 255, 255},
+	"dimgray":              {105, 105, 105, 255},
+	"dimgrey":              {105, 105, 105, 255},
+	"dodgerblue":           {30, 144, 255, 255},
+	"firebrick":            {178, 34, 34, 255},
+	"floralwhite":          {255, 250, 240, 255},
+	"forestgreen":          {34, 139, 34, 255},
+	"fuchsia":              {255, 0, 255, 255},
+	"gainsboro":            {220, 220, 220, 255},
+	"ghostwhite":           {248, 248, 255, 255},
+	"gold":                 {255, 215, 0, 255},
+	"goldenrod":            {218, 165, 32, 255},
+	"gray":                 {128, 128, 128, 255},
+	"green":                {0, 128, 0, 255},
+	"greenyellow":          {173, 255, 47, 255},
+	"grey":                 {128, 128, 128, 255},
+	"honeydew":             {240, 255, 240, 255},
+	"hotpink":              {255, 105, 180, 255},
+	"indianred":            {205, 92, 92, 255},
+	"indigo":               {75, 0, 130, 255},
+	"ivory":                {255, 255, 240, 255},
+	"khaki":                {240, 230, 140, 255},
+	"lavender":             {230, 230, 250, 255},
+	"lavenderblush":        {255, 240, 245, 255},
+	"lawngreen":            {124, 252, 0, 255},
+	"lemonchiffon":         {255, 250, 205, 255},
+	"lightblue":            {173, 216, 230, 255},
+	"lightcoral":           {240, 128, 128, 255},
+	"lightcyan":            {224, 255, 255, 255},
+	"lightgoldenrodyellow": {250, 250, 210, 255},
+	"lightgray":            {211, 211, 211, 255},
+	"lightgreen":           {144, 238, 144, 255},
+	"lightgrey":            {211, 211, 211, 255},
+	"lightpink":            {255, 182, 193, 255},
+	"lightsalmon":          {255, 160, 122, 255},
+	"lightseagreen":        {32, 178, 170, 255},
+	"lightskyblue":         {135, 206, 250, 255},
+	"lightslategray":       {119, 136, 153, 255},
+	"lightslategrey":       {119, 136, 153, 255},
+	"lightsteelblue":       {176, 196, 222, 255},
+	"lightyellow":          {255, 255, 224, 255},
+	"lime":                 {0, 255, 0, 255},
+	"limegreen":            {50, 205, 50, 255},
+	"linen":                {250, 240, 230, 255},
+	"magenta":              {255, 0, 255, 255},
+	"maroon":               {128, 0, 0, 255},
+	"mediumaquamarine":     {102, 205, 170, 255},
+	"mediumblue":           {0, 0, 205, 255},
+	"mediumorchid":         {186, 85, 211, 255},
+	"mediumpurple":         {147, 112, 219, 255},
+	"mediumseagreen":       {60, 179, 113, 255},
+	"mediumslateblue":      {123, 104, 238, 255},
+	"mediumspringgreen":    {0, 250, 154, 255},
+	"mediumturquoise":      {72, 209, 204, 255},
+	"mediumvioletred":      {199, 21, 133, 255},
+	"midnightblue":         {25, 25, 112, 255},
+	"mintcream":            {245, 255, 250, 255},
+	"mistyrose":            {255, 228, 225, 255},
+	"moccasin":             {255, 228, 181, 255},
+	"navajowhite":          {255, 222, 173, 255},
+	"navy":                 {0, 0, 128, 255},
+	"oldlace":              {253, 245, 230, 255},
+	"olive":                {128, 128, 0, 255},
+	"olivedrab":            {107, 142, 35, 255},
+	"orange":               {255, 165, 0, 255},
+	"orangered":            {255, 69, 0, 255},
+	"orchid":               {218, 112, 214, 255},
+	"palegoldenrod":        {238, 232, 170, 255},
+	"palegreen":            {152, 251, 152, 255},
+	"paleturquoise":        {175, 238, 238, 255},
+	"palevioletred":        {219, 112, 147, 255},
+	"papayawhip":           {255, 239, 213, 255},
+	"peachpuff":            {255, 218, 185, 255},
+	"peru":                 {205, 133, 63, 255},
+	"pink":                 {255, 192, 203, 255},
+	"plum":                 {221, 160, 221, 255},
+	"powderblue":           {176, 224, 230, 255},
+	"purple":               {128, 0, 128, 255},
+	"rebeccapurple":        {102, 51, 153, 255},
+	"red":                  {255, 0, 0, 255},
+	"rosybrown":            {188, 143, 143, 255},
+	"royalblue":            {65, 105, 225, 255},
+	"saddlebrown":          {139, 69, 19, 255},
+	"salmon":               {250, 128, 114, 255},
+	"sandybrown":           {244, 164, 96, 255},
+	"seagreen":             {46, 139, 87, 255},
+	"seashell":             {255, 245, 238, 255},
+	"sienna":               {160, 82, 45, 255},
+	"silver":               {192, 192, 192, 255},
+	"skyblue":              {135, 206, 235, 255},
+	"slateblue":            {106, 90, 205, 255},
+	"slategray":            {112, 128, 144, 255},
+	"slategrey":            {112, 128, 144, 255},
+	"snow":                 {255, 250, 250, 255},
+	"springgreen":          {0, 255, 127, 255},
+	"steelblue":            {70, 130, 180, 255},
+	"tan":                  {210, 180, 140, 255},
+	"teal":                 {0, 128, 128, 255},
+	"thistle":              {216, 191, 216, 255},
+	"tomato":               {255, 99, 71, 255},
+	"turquoise":            {64, 224, 208, 255},
+	"violet":               {238, 130, 238, 255},
+	"wheat":                {245, 222, 179, 255},
+	"white":                {255, 255, 255, 255},
+	"whitesmoke":           {245, 245, 245, 255},
+	"yellow":               {255, 255, 0, 255},
+	"yellowgreen":          {154, 205, 50, 255},
+}

pixel-sprite-maker/sprite/parse.go

@@ -0,0 +1,186 @@
+package sprite
+
+import (
+	"bufio"
+	"fmt"
+	"image/color"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// MaxSize is the maximum width/height of a single sprite in pixels.
+const MaxSize = 256
+
+// Sprite is a parsed .sprite file: a palette of single-rune keys and a
+// rectangular grid of those keys.
+type Sprite struct {
+	Name    string
+	W, H    int
+	Palette map[rune]color.NRGBA
+	Keys    []rune   // palette keys in file order
+	Rows    [][]rune // H rows of exactly W palette keys
+}
+
+// At returns the color of pixel (x, y). Out-of-range pixels are transparent.
+func (s *Sprite) At(x, y int) color.NRGBA {
+	if x < 0 || y < 0 || x >= s.W || y >= s.H {
+		return Transparent
+	}
+	return s.Palette[s.Rows[y][x]]
+}
+
+// Bounds returns the sprite size in pixels.
+func (s *Sprite) Bounds() (w, h int) { return s.W, s.H }
+
+// ParseFile reads a .sprite file from disk. The sprite name defaults to the
+// file name without extension when the file has no "sprite:" line.
+func ParseFile(path string) (*Sprite, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	s, err := Parse(f)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", path, err)
+	}
+	if s.Name == "" {
+		s.Name = strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+	}
+	return s, nil
+}
+
+// Parse reads the .sprite text format:
+//
+//	# comment lines start with '#'
+//	sprite: coin              (optional name)
+//	palette:
+//	  . = none                (key '.' is transparent by default)
+//	  k = #000000             text after the color is ignored
+//	  y = gold
+//	grid:
+//	  ..kk..
+//	  .kyyk.
+//
+// Palette keys are exactly one character and may not be '#', '=', ':' or
+// whitespace. Every grid row must be the same width; max size is 256x256.
+func Parse(r io.Reader) (*Sprite, error) {
+	s := &Sprite{Palette: map[rune]color.NRGBA{}}
+	const (
+		secNone = iota
+		secPalette
+		secGrid
+	)
+	section := secNone
+	sc := bufio.NewScanner(r)
+	sc.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+	lineNo := 0
+	for sc.Scan() {
+		lineNo++
+		line := strings.TrimSpace(sc.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue // comment or blank ('#' is not a legal palette key)
+		}
+		lower := strings.ToLower(line)
+		switch {
+		case lower == "palette:":
+			section = secPalette
+			continue
+		case lower == "grid:":
+			section = secGrid
+			continue
+		case strings.HasPrefix(lower, "sprite:"):
+			s.Name = strings.TrimSpace(line[len("sprite:"):])
+			continue
+		}
+		switch section {
+		case secPalette:
+			if err := s.parsePaletteLine(line, lineNo); err != nil {
+				return nil, err
+			}
+		case secGrid:
+			row := []rune(line)
+			s.Rows = append(s.Rows, row)
+		default:
+			return nil, fmt.Errorf("line %d: unexpected %q before a 'palette:' or 'grid:' section", lineNo, line)
+		}
+	}
+	if err := sc.Err(); err != nil {
+		return nil, err
+	}
+	return s, s.validate()
+}
+
+func (s *Sprite) parsePaletteLine(line string, lineNo int) error {
+	eq := strings.Index(line, "=")
+	if eq < 0 {
+		return fmt.Errorf("line %d: palette entry %q must look like '<key> = <color>'", lineNo, line)
+	}
+	keyPart := []rune(strings.TrimSpace(line[:eq]))
+	if len(keyPart) != 1 {
+		return fmt.Errorf("line %d: palette key %q must be exactly one character", lineNo, strings.TrimSpace(line[:eq]))
+	}
+	key := keyPart[0]
+	if key == '#' || key == '=' || key == ':' {
+		return fmt.Errorf("line %d: %q is not allowed as a palette key", lineNo, key)
+	}
+	if _, dup := s.Palette[key]; dup {
+		return fmt.Errorf("line %d: palette key %q defined twice", lineNo, key)
+	}
+	val := strings.TrimSpace(line[eq+1:])
+	// The color is the first token; anything after it is a free-text comment.
+	token := val
+	if strings.HasPrefix(strings.ToLower(val), "rgb") {
+		if close := strings.Index(val, ")"); close >= 0 {
+			token = val[:close+1]
+		}
+	} else if i := strings.IndexAny(val, " \t"); i >= 0 {
+		token = val[:i]
+	}
+	c, err := ParseColor(token)
+	if err != nil {
+		return fmt.Errorf("line %d: %w", lineNo, err)
+	}
+	s.Palette[key] = c
+	s.Keys = append(s.Keys, key)
+	return nil
+}
+
+func (s *Sprite) validate() error {
+	if len(s.Rows) == 0 {
+		return fmt.Errorf("no 'grid:' section with at least one row found")
+	}
+	// '.' is transparent unless the file overrides it.
+	if _, ok := s.Palette['.']; !ok {
+		s.Palette['.'] = Transparent
+	}
+	s.H = len(s.Rows)
+	s.W = len(s.Rows[0])
+	if s.W > MaxSize || s.H > MaxSize {
+		return fmt.Errorf("sprite is %dx%d pixels; the maximum is %dx%d", s.W, s.H, MaxSize, MaxSize)
+	}
+	for y, row := range s.Rows {
+		if len(row) != s.W {
+			return fmt.Errorf("grid row %d is %d pixels wide, expected %d (all rows must match row 1)", y+1, len(row), s.W)
+		}
+		for x, key := range row {
+			if _, ok := s.Palette[key]; !ok {
+				return fmt.Errorf("grid row %d, column %d: %q is not defined in the palette", y+1, x+1, string(key))
+			}
+		}
+	}
+	return nil
+}
+
+// UsageCount returns how many grid pixels use each palette key.
+func (s *Sprite) UsageCount() map[rune]int {
+	n := map[rune]int{}
+	for _, row := range s.Rows {
+		for _, k := range row {
+			n[k]++
+		}
+	}
+	return n
+}

pixel-sprite-maker/sprite/render.go

@@ -0,0 +1,75 @@
+package sprite
+
+import (
+	"fmt"
+	"image"
+	"image/color"
+	"image/jpeg"
+	"image/png"
+	"io"
+)
+
+// PixelGrid is anything that can be rendered pixel by pixel: a single
+// Sprite or a composed Sheet.
+type PixelGrid interface {
+	Bounds() (w, h int)
+	At(x, y int) color.NRGBA
+}
+
+// Image renders a PixelGrid to an NRGBA image, scaled up by the integer
+// factor scale (nearest neighbour, keeps pixels crisp).
+func Image(g PixelGrid, scale int) *image.NRGBA {
+	if scale < 1 {
+		scale = 1
+	}
+	w, h := g.Bounds()
+	img := image.NewNRGBA(image.Rect(0, 0, w*scale, h*scale))
+	for y := 0; y < h; y++ {
+		for x := 0; x < w; x++ {
+			c := g.At(x, y)
+			for dy := 0; dy < scale; dy++ {
+				for dx := 0; dx < scale; dx++ {
+					img.SetNRGBA(x*scale+dx, y*scale+dy, c)
+				}
+			}
+		}
+	}
+	return img
+}
+
+// WritePNG encodes g as PNG with transparency preserved.
+func WritePNG(w io.Writer, g PixelGrid, scale int) error {
+	return png.Encode(w, Image(g, scale))
+}
+
+// WriteJPG encodes g as JPEG. JPEG has no alpha channel, so transparent
+// pixels are composited over bg first.
+func WriteJPG(w io.Writer, g PixelGrid, scale int, bg color.NRGBA, quality int) error {
+	if quality < 1 || quality > 100 {
+		return fmt.Errorf("jpg quality %d out of range 1-100", quality)
+	}
+	src := Image(g, scale)
+	b := src.Bounds()
+	flat := image.NewRGBA(b)
+	for y := b.Min.Y; y < b.Max.Y; y++ {
+		for x := b.Min.X; x < b.Max.X; x++ {
+			flat.Set(x, y, blendOver(src.NRGBAAt(x, y), bg))
+		}
+	}
+	return jpeg.Encode(w, flat, &jpeg.Options{Quality: quality})
+}
+
+// blendOver composites src over an opaque background color.
+func blendOver(src, bg color.NRGBA) color.NRGBA {
+	if src.A == 255 {
+		return src
+	}
+	a := uint32(src.A)
+	inv := 255 - a
+	return color.NRGBA{
+		R: uint8((uint32(src.R)*a + uint32(bg.R)*inv) / 255),
+		G: uint8((uint32(src.G)*a + uint32(bg.G)*inv) / 255),
+		B: uint8((uint32(src.B)*a + uint32(bg.B)*inv) / 255),
+		A: 255,
+	}
+}

pixel-sprite-maker/sprite/sheet.go

@@ -0,0 +1,58 @@
+package sprite
+
+import (
+	"fmt"
+	"image/color"
+)
+
+// Sheet lays out several equally sized sprites in a row-major grid:
+// index 0 is top-left, then left-to-right, then next row. A 1D strip is
+// simply a sheet with one row (or one column).
+type Sheet struct {
+	Sprites      []*Sprite
+	Cols, Rows   int
+	CellW, CellH int
+}
+
+// NewSheet composes sprites into a sheet with the given number of columns.
+// cols <= 0 puts everything in a single row. Every sprite must have the
+// same dimensions so the sheet can be indexed cell by cell.
+func NewSheet(sprites []*Sprite, cols int) (*Sheet, error) {
+	if len(sprites) == 0 {
+		return nil, fmt.Errorf("a sheet needs at least one sprite")
+	}
+	w, h := sprites[0].Bounds()
+	for _, sp := range sprites[1:] {
+		sw, sh := sp.Bounds()
+		if sw != w || sh != h {
+			return nil, fmt.Errorf("sprite %q is %dx%d but %q is %dx%d — all sprites in a sheet must be the same size",
+				sp.Name, sw, sh, sprites[0].Name, w, h)
+		}
+	}
+	if cols <= 0 || cols > len(sprites) {
+		cols = len(sprites)
+	}
+	rows := (len(sprites) + cols - 1) / cols
+	return &Sheet{Sprites: sprites, Cols: cols, Rows: rows, CellW: w, CellH: h}, nil
+}
+
+// Bounds returns the total sheet size in pixels.
+func (sh *Sheet) Bounds() (w, h int) { return sh.Cols * sh.CellW, sh.Rows * sh.CellH }
+
+// At returns the pixel at (x, y). Cells past the last sprite (when the
+// sprite count doesn't fill the grid) are transparent.
+func (sh *Sheet) At(x, y int) color.NRGBA {
+	col, row := x/sh.CellW, y/sh.CellH
+	idx := row*sh.Cols + col
+	if idx >= len(sh.Sprites) {
+		return Transparent
+	}
+	return sh.Sprites[idx].At(x%sh.CellW, y%sh.CellH)
+}
+
+// FileBase appends the layout to an output name so the file itself
+// documents cell size and orientation: <base>_<cellW>x<cellH>_<cols>x<rows>
+// e.g. walk_16x16_4x2 = 16x16 cells, 4 columns, 2 rows, read row by row.
+func (sh *Sheet) FileBase(base string) string {
+	return fmt.Sprintf("%s_%dx%d_%dx%d", base, sh.CellW, sh.CellH, sh.Cols, sh.Rows)
+}

pixel-sprite-maker/sprite/sprite_test.go

@@ -0,0 +1,207 @@
+package sprite
+
+import (
+	"bytes"
+	"encoding/xml"
+	"image/color"
+	"strings"
+	"testing"
+)
+
+const coin = `
+# a tiny coin
+sprite: coin
+palette:
+  k = #000000
+  y = gold
+  Y = #FFF3A0 highlight
+grid:
+  .kk.
+  kyYk
+  kyyk
+  .kk.
+`
+
+func parseOK(t *testing.T, src string) *Sprite {
+	t.Helper()
+	s, err := Parse(strings.NewReader(src))
+	if err != nil {
+		t.Fatalf("parse failed: %v", err)
+	}
+	return s
+}
+
+func TestParseBasics(t *testing.T) {
+	s := parseOK(t, coin)
+	if s.Name != "coin" {
+		t.Errorf("name = %q, want coin", s.Name)
+	}
+	if s.W != 4 || s.H != 4 {
+		t.Errorf("size = %dx%d, want 4x4", s.W, s.H)
+	}
+	if got := s.At(0, 0); got.A != 0 {
+		t.Errorf("(0,0) should be transparent via the implicit '.', got %v", got)
+	}
+	if got := s.At(1, 1); got != (color.NRGBA{255, 215, 0, 255}) {
+		t.Errorf("(1,1) = %v, want gold", got)
+	}
+	if got := s.At(2, 1); got != (color.NRGBA{255, 243, 160, 255}) {
+		t.Errorf("(2,1) = %v, want #FFF3A0", got)
+	}
+}
+
+func TestParseErrors(t *testing.T) {
+	cases := map[string]string{
+		"ragged rows":   "palette:\n a = red\ngrid:\naa\naaa\n",
+		"unknown key":   "palette:\n a = red\ngrid:\nab\naa\n",
+		"bad color":     "palette:\n a = notacolor\ngrid:\na\n",
+		"no grid":       "palette:\n a = red\n",
+		"dup key":       "palette:\n a = red\n a = blue\ngrid:\na\n",
+		"multirune key": "palette:\n ab = red\ngrid:\na\n",
+		"colon key":     "palette:\n : = red\ngrid:\n.\n",
+	}
+	for name, src := range cases {
+		if _, err := Parse(strings.NewReader(src)); err == nil {
+			t.Errorf("%s: expected an error", name)
+		}
+	}
+}
+
+func TestMaxSize(t *testing.T) {
+	row := strings.Repeat("a", 257)
+	src := "palette:\n a = red\ngrid:\n" + row + "\n"
+	if _, err := Parse(strings.NewReader(src)); err == nil {
+		t.Error("257 px wide sprite should be rejected")
+	}
+	ok := "palette:\n a = red\ngrid:\n" + strings.Repeat(strings.Repeat("a", 256)+"\n", 256)
+	s := parseOK(t, ok)
+	if s.W != 256 || s.H != 256 {
+		t.Errorf("size = %dx%d, want 256x256", s.W, s.H)
+	}
+}
+
+func TestParseColorForms(t *testing.T) {
+	cases := map[string]color.NRGBA{
+		"none":              {0, 0, 0, 0},
+		"-":                 {0, 0, 0, 0},
+		"#F00":              {255, 0, 0, 255},
+		"#F00A":             {255, 0, 0, 170},
+		"#00FF00":           {0, 255, 0, 255},
+		"#00FF0080":         {0, 255, 0, 128},
+		"rgb(1,2,3)":        {1, 2, 3, 255},
+		"rgba(1,2,3,64)":    {1, 2, 3, 64},
+		"rgba(1, 2, 3, .5)": {1, 2, 3, 128},
+		"RebeccaPurple":     {102, 51, 153, 255},
+	}
+	for in, want := range cases {
+		got, err := ParseColor(in)
+		if err != nil {
+			t.Errorf("ParseColor(%q): %v", in, err)
+			continue
+		}
+		if got != want {
+			t.Errorf("ParseColor(%q) = %v, want %v", in, got, want)
+		}
+	}
+	for _, bad := range []string{"", "#12345", "rgb(300,0,0)", "purpleish"} {
+		if _, err := ParseColor(bad); err == nil {
+			t.Errorf("ParseColor(%q): expected error", bad)
+		}
+	}
+}
+
+func TestImageAndScale(t *testing.T) {
+	s := parseOK(t, coin)
+	img := Image(s, 3)
+	if b := img.Bounds(); b.Dx() != 12 || b.Dy() != 12 {
+		t.Fatalf("scaled bounds = %v, want 12x12", b)
+	}
+	// pixel (1,1) is gold -> block at (3..5, 3..5)
+	if got := img.NRGBAAt(4, 4); got != (color.NRGBA{255, 215, 0, 255}) {
+		t.Errorf("scaled gold pixel = %v", got)
+	}
+	if got := img.NRGBAAt(0, 0); got.A != 0 {
+		t.Errorf("corner should stay transparent, got %v", got)
+	}
+}
+
+func TestSVGOutput(t *testing.T) {
+	s := parseOK(t, coin)
+	var buf bytes.Buffer
+	if err := WriteSVG(&buf, s, 10); err != nil {
+		t.Fatal(err)
+	}
+	out := buf.String()
+	if !strings.Contains(out, `viewBox="0 0 4 4"`) || !strings.Contains(out, `width="40"`) {
+		t.Errorf("svg header wrong:\n%s", out)
+	}
+	// row 2 (y=1) has runs k, yY?, no: k y Y k -> y and Y differ, so no merge.
+	// row 3 (y=2) k yy k -> the two golds merge into one rect of width 2.
+	if !strings.Contains(out, `<rect x="1" y="2" width="2" height="1" fill="#ffd700"/>`) {
+		t.Errorf("expected RLE-merged gold rect:\n%s", out)
+	}
+	var doc struct{ XMLName xml.Name }
+	if err := xml.Unmarshal(buf.Bytes(), &doc); err != nil {
+		t.Errorf("svg is not valid XML: %v", err)
+	}
+}
+
+func TestSheetLayoutAndNaming(t *testing.T) {
+	a := parseOK(t, coin)
+	b := parseOK(t, coin)
+	c := parseOK(t, coin)
+	sh, err := NewSheet([]*Sprite{a, b, c}, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if sh.Cols != 2 || sh.Rows != 2 {
+		t.Errorf("layout = %dx%d, want 2x2", sh.Cols, sh.Rows)
+	}
+	if w, h := sh.Bounds(); w != 8 || h != 8 {
+		t.Errorf("bounds = %dx%d, want 8x8", w, h)
+	}
+	if got := sh.FileBase("walk"); got != "walk_4x4_2x2" {
+		t.Errorf("FileBase = %q, want walk_4x4_2x2", got)
+	}
+	// cell (1,1) in frame 2 (top-right) is gold
+	if got := sh.At(5, 1); got != (color.NRGBA{255, 215, 0, 255}) {
+		t.Errorf("sheet pixel in frame 2 = %v, want gold", got)
+	}
+	// 4th cell (bottom-right) has no sprite -> transparent
+	if got := sh.At(7, 7); got.A != 0 {
+		t.Errorf("empty cell should be transparent, got %v", got)
+	}
+}
+
+func TestSheetSizeMismatch(t *testing.T) {
+	a := parseOK(t, coin)
+	b := parseOK(t, "palette:\n a = red\ngrid:\naa\n")
+	if _, err := NewSheet([]*Sprite{a, b}, 0); err == nil {
+		t.Error("mismatched sprite sizes should be rejected")
+	}
+}
+
+func TestSheetDefaultSingleRow(t *testing.T) {
+	a := parseOK(t, coin)
+	sh, err := NewSheet([]*Sprite{a, a, a}, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if sh.Cols != 3 || sh.Rows != 1 {
+		t.Errorf("default layout = %dx%d, want 3x1", sh.Cols, sh.Rows)
+	}
+}
+
+func TestJPGComposite(t *testing.T) {
+	s := parseOK(t, coin)
+	var buf bytes.Buffer
+	if err := WriteJPG(&buf, s, 1, color.NRGBA{255, 255, 255, 255}, 90); err != nil {
+		t.Fatal(err)
+	}
+	if buf.Len() == 0 {
+		t.Error("empty jpg output")
+	}
+	if err := WriteJPG(&buf, s, 1, Transparent, 150); err == nil {
+		t.Error("quality 150 should be rejected")
+	}
+}

pixel-sprite-maker/sprite/svg.go

@@ -0,0 +1,46 @@
+package sprite
+
+import (
+	"fmt"
+	"io"
+)
+
+// WriteSVG encodes g as an SVG where each horizontal run of same-colored
+// pixels becomes one <rect>. shape-rendering="crispEdges" keeps the pixel
+// look at any zoom. scale only affects the document width/height; the
+// viewBox stays in pixel units.
+func WriteSVG(w io.Writer, g PixelGrid, scale int) error {
+	if scale < 1 {
+		scale = 1
+	}
+	gw, gh := g.Bounds()
+	_, err := fmt.Fprintf(w,
+		`<svg xmlns="http://www.w3.org/2000/svg" width="%d" height="%d" viewBox="0 0 %d %d" shape-rendering="crispEdges">`+"\n",
+		gw*scale, gh*scale, gw, gh)
+	if err != nil {
+		return err
+	}
+	for y := 0; y < gh; y++ {
+		for x := 0; x < gw; {
+			c := g.At(x, y)
+			run := 1
+			for x+run < gw && g.At(x+run, y) == c {
+				run++
+			}
+			if c.A > 0 {
+				opacity := ""
+				if c.A < 255 {
+					opacity = fmt.Sprintf(` fill-opacity="%.3f"`, float64(c.A)/255)
+				}
+				_, err = fmt.Fprintf(w, `<rect x="%d" y="%d" width="%d" height="1" fill="#%02x%02x%02x"%s/>`+"\n",
+					x, y, run, c.R, c.G, c.B, opacity)
+				if err != nil {
+					return err
+				}
+			}
+			x += run
+		}
+	}
+	_, err = io.WriteString(w, "</svg>\n")
+	return err
+}

sfx-maker/README.md

@@ -0,0 +1,68 @@
+# sfx-maker (`sfxc`)
+
+Synthesizes **retro game sound effects** (sfxr-style) from `.sfx` text
+files and writes 16-bit mono **WAV**. Sound design becomes text an agent
+can read, tweak and reason about — no DAW needed. Go, zero
+dependencies, single static binary.
+
+## Build
+
+```bash
+# Arch/Garuda: sudo pacman -S go
+cd sfx-maker
+go build -o build/sfxc .        # or the VS Code task "build sfx-maker"
+go test ./...
+```
+
+## Quick start
+
+```bash
+sfxc preset jump -o jump.sfx      # editable text preset
+sfxc build jump.sfx               # -> jump.wav
+mpv jump.wav                      # listen (or aplay/ffplay)
+
+sfxc preset coin -o coin.wav      # straight to WAV
+sfxc preset coin --seed 3 -o coin3.wav    # deterministic variant
+sfxc info laser.sfx               # validate + summary
+```
+
+Presets: `blip, coin, explosion, hurt, jump, laser, powerup`.
+`--seed 0` is the canonical sound; any other seed nudges pitch/length
+deterministically — ask for three seeds, keep the one that sounds best.
+
+## The `.sfx` format
+
+```
+# comment
+sfx: jump            name
+wave: square         square | saw | sine | triangle | noise
+volume: 0.7          0..1
+attack: 0.01         seconds: fade in
+sustain: 0.08        hold at full volume
+decay: 0.18          fade out (total length = a+s+d, max 10 s)
+freq: 330            start pitch, Hz
+freq-slide: 900      Hz/second (positive = rising, negative = falling)
+duty: 0.5            square pulse width 0.05..0.95 (thinner = buzzier)
+vibrato-depth: 25    pitch wobble, Hz
+vibrato-rate: 9      wobbles per second
+arpeggio: 1.335      multiply pitch by this...
+arpeggio-time: 0.06  ...after this many seconds (classic coin blip)
+lowpass: 2200        cutoff Hz (muffle: explosions, thuds)
+highpass: 300        cutoff Hz (thin out: lasers, clicks)
+sample-rate: 44100   8000-96000
+seed: 1              noise randomness — same seed = same sound
+```
+
+Unknown keys are **errors**, so typos surface immediately. Everything is
+deterministic: same file → byte-identical WAV.
+
+## Recipe intuition for agents
+
+- **Jump**: square wave + rising `freq-slide`.
+- **Coin/pickup**: square + `arpeggio` > 1 shortly after the start.
+- **Laser**: saw + steep negative `freq-slide` + `highpass`.
+- **Explosion**: noise + `lowpass` ~2 kHz + long `decay`.
+- **Hurt**: saw, low pitch, quick fall.
+- **Power-up**: rising slide + `vibrato`.
+
+[`examples/`](examples/) contains all presets as `.sfx` + rendered `.wav`.

sfx-maker/examples/blip.sfx

@@ -0,0 +1,9 @@
+# blip preset (seed 0) — edit freely, then: sfxc build examples/blip.sfx
+sfx: blip
+wave: square
+volume: 0.7
+attack: 0.002
+sustain: 0.03
+decay: 0.05
+freq: 660
+duty: 0.4

sfx-maker/examples/coin.sfx

@@ -0,0 +1,10 @@
+# coin preset (seed 0) — edit freely, then: sfxc build examples/coin.sfx
+sfx: coin
+wave: square
+volume: 0.7
+attack: 0.005
+sustain: 0.08
+decay: 0.25
+freq: 988
+arpeggio: 1.335
+arpeggio-time: 0.06

sfx-maker/examples/explosion.sfx

@@ -0,0 +1,9 @@
+# explosion preset (seed 0) — edit freely, then: sfxc build examples/explosion.sfx
+sfx: explosion
+wave: noise
+volume: 0.7
+attack: 0.01
+sustain: 0.15
+decay: 0.55
+freq-slide: -600
+lowpass: 2200

sfx-maker/examples/hurt.sfx

@@ -0,0 +1,9 @@
+# hurt preset (seed 0) — edit freely, then: sfxc build examples/hurt.sfx
+sfx: hurt
+wave: saw
+volume: 0.7
+attack: 0.005
+sustain: 0.04
+decay: 0.14
+freq: 300
+freq-slide: -700

sfx-maker/examples/jump.sfx

@@ -0,0 +1,9 @@
+# jump preset (seed 0) — edit freely, then: sfxc build examples/jump.sfx
+sfx: jump
+wave: square
+volume: 0.7
+attack: 0.01
+sustain: 0.08
+decay: 0.18
+freq: 330
+freq-slide: 900

sfx-maker/examples/laser.sfx

@@ -0,0 +1,10 @@
+# laser preset (seed 0) — edit freely, then: sfxc build examples/laser.sfx
+sfx: laser
+wave: saw
+volume: 0.7
+attack: 0.005
+sustain: 0.05
+decay: 0.12
+freq: 1400
+freq-slide: -6000
+highpass: 300

sfx-maker/examples/powerup.sfx

@@ -0,0 +1,12 @@
+# powerup preset (seed 0) — edit freely, then: sfxc build examples/powerup.sfx
+sfx: powerup
+wave: square
+volume: 0.7
+attack: 0.01
+sustain: 0.25
+decay: 0.25
+freq: 220
+freq-slide: 700
+duty: 0.4
+vibrato-depth: 25
+vibrato-rate: 9

sfx-maker/go.mod

@@ -0,0 +1,3 @@
+module gitea.brasse-pc.eu/brasse/agent-tools/sfx-maker
+
+go 1.24

sfx-maker/main.go

@@ -0,0 +1,212 @@
+// sfxc synthesizes retro game sound effects from .sfx text files
+// (sfxr-style parameters) and writes 16-bit mono WAV.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"gitea.brasse-pc.eu/brasse/agent-tools/sfx-maker/sfx"
+)
+
+var version = "dev"
+
+const usage = `sfxc - sound effect maker for agents
+
+Usage:
+  sfxc build <file.sfx> [-o out.wav]      synthesize a .sfx file to WAV
+  sfxc preset <name> [-o out.sfx|out.wav] [--seed n]
+                                          write a preset (editable .sfx text,
+                                          or straight to .wav)
+  sfxc info <file.sfx>                    validate + print parameters
+  sfxc version
+
+Presets: blip, coin, explosion, hurt, jump, laser, powerup
+--seed 0 (default) is the canonical sound; other seeds give variants.
+
+The .sfx format (all keys optional, '#' comments):
+  sfx: jump            name
+  wave: square         square | saw | sine | triangle | noise
+  volume: 0.7          0..1
+  attack: 0.01         seconds: fade in
+  sustain: 0.08        hold
+  decay: 0.18          fade out
+  freq: 330            start pitch, Hz
+  freq-slide: 900      Hz per second (negative = falling)
+  duty: 0.5            square pulse width 0.05..0.95
+  vibrato-depth: 25    Hz
+  vibrato-rate: 9      Hz
+  arpeggio: 1.335      pitch multiplier that kicks in at...
+  arpeggio-time: 0.06  ...this many seconds
+  lowpass: 2200        filter cutoff Hz
+  highpass: 300        filter cutoff Hz
+  sample-rate: 44100
+  seed: 1              noise randomness (deterministic)
+
+Play the result with e.g.:  mpv out.wav   or   aplay out.wav
+`
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Print(usage)
+		os.Exit(2)
+	}
+	switch os.Args[1] {
+	case "build":
+		cmdBuild(os.Args[2:])
+	case "preset":
+		cmdPreset(os.Args[2:])
+	case "info":
+		cmdInfo(os.Args[2:])
+	case "version", "--version", "-v":
+		fmt.Println("sfxc", version)
+	case "help", "--help", "-h":
+		fmt.Print(usage)
+	default:
+		die("unknown command %q — run 'sfxc help'", os.Args[1])
+	}
+}
+
+// parseInterspersed lets flags appear before or after positional args.
+func parseInterspersed(fs *flag.FlagSet, args []string) {
+	var flags, pos []string
+	for i := 0; i < len(args); i++ {
+		a := args[i]
+		if len(a) > 1 && a[0] == '-' {
+			flags = append(flags, a)
+			name := strings.TrimLeft(a, "-")
+			if !strings.Contains(name, "=") {
+				f := fs.Lookup(name)
+				isBool := false
+				if f != nil {
+					if bv, ok := f.Value.(interface{ IsBoolFlag() bool }); ok && bv.IsBoolFlag() {
+						isBool = true
+					}
+				}
+				if !isBool && i+1 < len(args) {
+					i++
+					flags = append(flags, args[i])
+				}
+			}
+		} else {
+			pos = append(pos, a)
+		}
+	}
+	fs.Parse(append(flags, pos...))
+}
+
+func writeWAVFile(path string, p *sfx.Params) error {
+	samples := sfx.Render(p)
+	f, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	if err := sfx.WriteWAV(f, samples, p.SampleRate); err != nil {
+		return err
+	}
+	return f.Close()
+}
+
+func cmdBuild(args []string) {
+	fs := flag.NewFlagSet("build", flag.ExitOnError)
+	out := fs.String("o", "", "output .wav (default: input name with .wav)")
+	parseInterspersed(fs, args)
+	if fs.NArg() != 1 {
+		die("build takes exactly one .sfx file")
+	}
+	p, err := sfx.ParseFile(fs.Arg(0))
+	if err != nil {
+		die("%v", err)
+	}
+	path := *out
+	if path == "" {
+		path = strings.TrimSuffix(fs.Arg(0), filepath.Ext(fs.Arg(0))) + ".wav"
+	}
+	if err := writeWAVFile(path, p); err != nil {
+		die("%v", err)
+	}
+	fmt.Printf("%s  (%s, %.2fs, %d Hz)\n", path, p.Wave, p.Duration(), p.SampleRate)
+}
+
+func cmdPreset(args []string) {
+	fs := flag.NewFlagSet("preset", flag.ExitOnError)
+	out := fs.String("o", "", "output file: .sfx (editable text) or .wav (rendered)")
+	seed := fs.Int64("seed", 0, "0 = canonical, other values = variants")
+	parseInterspersed(fs, args)
+	if fs.NArg() != 1 {
+		die("preset takes exactly one preset name (%s)", sfx.PresetNames())
+	}
+	name := fs.Arg(0)
+	p, err := sfx.Preset(name, *seed)
+	if err != nil {
+		die("%v", err)
+	}
+	path := *out
+	if path == "" {
+		path = name + ".sfx"
+	}
+	switch strings.ToLower(filepath.Ext(path)) {
+	case ".wav":
+		if err := writeWAVFile(path, p); err != nil {
+			die("%v", err)
+		}
+		fmt.Printf("%s  (%s preset, seed %d, %.2fs)\n", path, name, *seed, p.Duration())
+	case ".sfx":
+		f, err := os.Create(path)
+		if err != nil {
+			die("%v", err)
+		}
+		defer f.Close()
+		comment := fmt.Sprintf("%s preset (seed %d) — edit freely, then: sfxc build %s", name, *seed, path)
+		if err := p.Write(f, comment); err != nil {
+			die("%v", err)
+		}
+		fmt.Printf("%s  (%s preset, seed %d — edit then 'sfxc build')\n", path, name, *seed)
+	default:
+		die("-o must end in .sfx or .wav")
+	}
+}
+
+func cmdInfo(args []string) {
+	if len(args) != 1 {
+		die("info takes exactly one .sfx file")
+	}
+	p, err := sfx.ParseFile(args[0])
+	if err != nil {
+		die("%v", err)
+	}
+	fmt.Printf("sfx:       %s\n", p.Name)
+	fmt.Printf("wave:      %s\n", p.Wave)
+	fmt.Printf("duration:  %.3fs (attack %.3g + sustain %.3g + decay %.3g)\n",
+		p.Duration(), p.Attack, p.Sustain, p.Decay)
+	if p.Wave != "noise" {
+		fmt.Printf("freq:      %g Hz", p.Freq)
+		if p.FreqSlide != 0 {
+			fmt.Printf("  (slide %+g Hz/s)", p.FreqSlide)
+		}
+		fmt.Println()
+	}
+	if p.ArpFactor != 0 {
+		fmt.Printf("arpeggio:  x%g at %gs\n", p.ArpFactor, p.ArpTime)
+	}
+	if p.VibratoDepth > 0 {
+		fmt.Printf("vibrato:   ±%g Hz at %g Hz\n", p.VibratoDepth, p.VibratoRate)
+	}
+	if p.LowPass > 0 {
+		fmt.Printf("lowpass:   %g Hz\n", p.LowPass)
+	}
+	if p.HighPass > 0 {
+		fmt.Printf("highpass:  %g Hz\n", p.HighPass)
+	}
+	fmt.Printf("volume:    %g\nsamplerate:%d\n", p.Volume, p.SampleRate)
+	fmt.Println("valid:     yes")
+}
+
+func die(format string, a ...any) {
+	fmt.Fprintf(os.Stderr, "sfxc: "+format+"\n", a...)
+	os.Exit(1)
+}

sfx-maker/sfx/params.go

@@ -0,0 +1,223 @@
+// Package sfx synthesizes retro game sound effects (sfxr-style) from
+// text parameter files and renders them to 16-bit mono WAV.
+package sfx
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// Params describes one sound effect. Zero values mean "off" for the
+// optional effects; Defaults() fills the required fields.
+type Params struct {
+	Name string
+	Wave string // square | saw | sine | triangle | noise
+
+	Volume float64 // 0..1 master gain
+
+	// envelope, seconds
+	Attack  float64 // 0 -> Volume
+	Sustain float64 // hold at Volume
+	Decay   float64 // Volume -> 0
+
+	Freq      float64 // start frequency, Hz
+	FreqSlide float64 // Hz per second, may be negative
+	FreqMin   float64 // clamp; sound stops below this (default 20 Hz)
+
+	Duty float64 // square wave duty cycle 0.05..0.95 (default 0.5)
+
+	VibratoDepth float64 // Hz
+	VibratoRate  float64 // Hz
+
+	ArpFactor float64 // frequency multiplier applied at ArpTime (0 = off)
+	ArpTime   float64 // seconds
+
+	LowPass  float64 // cutoff Hz (0 = off)
+	HighPass float64 // cutoff Hz (0 = off)
+
+	SampleRate int   // default 44100
+	Seed       int64 // noise seed (default 1)
+}
+
+// Defaults returns a Params with sensible base values.
+func Defaults() Params {
+	return Params{
+		Wave:       "square",
+		Volume:     0.7,
+		Attack:     0.01,
+		Sustain:    0.1,
+		Decay:      0.15,
+		Freq:       440,
+		FreqMin:    20,
+		Duty:       0.5,
+		SampleRate: 44100,
+		Seed:       1,
+	}
+}
+
+// Duration is the total length of the sound in seconds.
+func (p *Params) Duration() float64 { return p.Attack + p.Sustain + p.Decay }
+
+// Validate checks ranges and returns a helpful error.
+func (p *Params) Validate() error {
+	switch p.Wave {
+	case "square", "saw", "sine", "triangle", "noise":
+	default:
+		return fmt.Errorf("wave %q must be square, saw, sine, triangle or noise", p.Wave)
+	}
+	if p.Volume < 0 || p.Volume > 1 {
+		return fmt.Errorf("volume %g out of range 0-1", p.Volume)
+	}
+	if p.Attack < 0 || p.Sustain < 0 || p.Decay < 0 {
+		return fmt.Errorf("attack/sustain/decay must be >= 0")
+	}
+	if p.Duration() <= 0 {
+		return fmt.Errorf("total duration is 0 — set attack, sustain and/or decay")
+	}
+	if p.Duration() > 10 {
+		return fmt.Errorf("total duration %.2fs is too long (max 10s)", p.Duration())
+	}
+	if p.Wave != "noise" && (p.Freq <= 0 || p.Freq > 20000) {
+		return fmt.Errorf("freq %g out of range 1-20000 Hz", p.Freq)
+	}
+	if p.Duty < 0.05 || p.Duty > 0.95 {
+		return fmt.Errorf("duty %g out of range 0.05-0.95", p.Duty)
+	}
+	if p.SampleRate < 8000 || p.SampleRate > 96000 {
+		return fmt.Errorf("sample-rate %d out of range 8000-96000", p.SampleRate)
+	}
+	return nil
+}
+
+// ParseFile reads a .sfx file; the name defaults to the file name.
+func ParseFile(path string) (*Params, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	p, err := Parse(f)
+	if err != nil {
+		return nil, fmt.Errorf("%s: %w", path, err)
+	}
+	if p.Name == "" {
+		p.Name = strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+	}
+	return p, nil
+}
+
+// Parse reads the .sfx text format: one "key: value" per line,
+// '#' comments. Unknown keys are errors so typos surface immediately.
+func Parse(r io.Reader) (*Params, error) {
+	p := Defaults()
+	sc := bufio.NewScanner(r)
+	lineNo := 0
+	for sc.Scan() {
+		lineNo++
+		line := strings.TrimSpace(sc.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		i := strings.Index(line, ":")
+		if i < 0 {
+			return nil, fmt.Errorf("line %d: want 'key: value', got %q", lineNo, line)
+		}
+		key := strings.ToLower(strings.TrimSpace(line[:i]))
+		val := strings.TrimSpace(line[i+1:])
+		if j := strings.Index(val, " #"); j >= 0 { // trailing comment
+			val = strings.TrimSpace(val[:j])
+		}
+		var err error
+		switch key {
+		case "sfx", "name":
+			p.Name = val
+		case "wave":
+			p.Wave = strings.ToLower(val)
+		case "volume":
+			p.Volume, err = strconv.ParseFloat(val, 64)
+		case "attack":
+			p.Attack, err = strconv.ParseFloat(val, 64)
+		case "sustain":
+			p.Sustain, err = strconv.ParseFloat(val, 64)
+		case "decay":
+			p.Decay, err = strconv.ParseFloat(val, 64)
+		case "freq":
+			p.Freq, err = strconv.ParseFloat(val, 64)
+		case "freq-slide":
+			p.FreqSlide, err = strconv.ParseFloat(val, 64)
+		case "freq-min":
+			p.FreqMin, err = strconv.ParseFloat(val, 64)
+		case "duty":
+			p.Duty, err = strconv.ParseFloat(val, 64)
+		case "vibrato-depth":
+			p.VibratoDepth, err = strconv.ParseFloat(val, 64)
+		case "vibrato-rate":
+			p.VibratoRate, err = strconv.ParseFloat(val, 64)
+		case "arpeggio":
+			p.ArpFactor, err = strconv.ParseFloat(val, 64)
+		case "arpeggio-time":
+			p.ArpTime, err = strconv.ParseFloat(val, 64)
+		case "lowpass":
+			p.LowPass, err = strconv.ParseFloat(val, 64)
+		case "highpass":
+			p.HighPass, err = strconv.ParseFloat(val, 64)
+		case "sample-rate":
+			p.SampleRate, err = strconv.Atoi(val)
+		case "seed":
+			p.Seed, err = strconv.ParseInt(val, 10, 64)
+		default:
+			return nil, fmt.Errorf("line %d: unknown key %q", lineNo, key)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("line %d: %s: bad value %q", lineNo, key, val)
+		}
+	}
+	if err := sc.Err(); err != nil {
+		return nil, err
+	}
+	if err := p.Validate(); err != nil {
+		return nil, err
+	}
+	return &p, nil
+}
+
+// Write renders the params back to the .sfx text format (used by the
+// preset generator so agents get an editable file).
+func (p *Params) Write(w io.Writer, comment string) error {
+	bw := bufio.NewWriter(w)
+	if comment != "" {
+		fmt.Fprintf(bw, "# %s\n", comment)
+	}
+	fmt.Fprintf(bw, "sfx: %s\nwave: %s\nvolume: %g\n", p.Name, p.Wave, p.Volume)
+	fmt.Fprintf(bw, "attack: %g\nsustain: %g\ndecay: %g\n", p.Attack, p.Sustain, p.Decay)
+	if p.Wave != "noise" {
+		fmt.Fprintf(bw, "freq: %g\n", p.Freq)
+	}
+	if p.FreqSlide != 0 {
+		fmt.Fprintf(bw, "freq-slide: %g\n", p.FreqSlide)
+	}
+	if p.Wave == "square" && p.Duty != 0.5 {
+		fmt.Fprintf(bw, "duty: %g\n", p.Duty)
+	}
+	if p.VibratoDepth > 0 && p.VibratoRate > 0 {
+		fmt.Fprintf(bw, "vibrato-depth: %g\nvibrato-rate: %g\n", p.VibratoDepth, p.VibratoRate)
+	}
+	if p.ArpFactor != 0 {
+		fmt.Fprintf(bw, "arpeggio: %g\narpeggio-time: %g\n", p.ArpFactor, p.ArpTime)
+	}
+	if p.LowPass > 0 {
+		fmt.Fprintf(bw, "lowpass: %g\n", p.LowPass)
+	}
+	if p.HighPass > 0 {
+		fmt.Fprintf(bw, "highpass: %g\n", p.HighPass)
+	}
+	if p.Seed != 1 {
+		fmt.Fprintf(bw, "seed: %d\n", p.Seed)
+	}
+	return bw.Flush()
+}

sfx-maker/sfx/presets.go

@@ -0,0 +1,114 @@
+package sfx
+
+import (
+	"fmt"
+	"math/rand"
+	"sort"
+)
+
+// Preset returns ready-made parameters for classic game sounds.
+// seed 0 gives the canonical version; other seeds vary it slightly so
+// agents can generate alternatives ("give me three coin variants").
+func Preset(name string, seed int64) (*Params, error) {
+	p := Defaults()
+	p.Name = name
+	switch name {
+	case "jump":
+		p.Wave = "square"
+		p.Duty = 0.5
+		p.Freq = 330
+		p.FreqSlide = 900
+		p.Attack = 0.01
+		p.Sustain = 0.08
+		p.Decay = 0.18
+	case "coin":
+		p.Wave = "square"
+		p.Duty = 0.5
+		p.Freq = 988
+		p.ArpFactor = 1.335 // up a fourth: B5 -> E6
+		p.ArpTime = 0.06
+		p.Attack = 0.005
+		p.Sustain = 0.08
+		p.Decay = 0.25
+	case "laser":
+		p.Wave = "saw"
+		p.Freq = 1400
+		p.FreqSlide = -6000
+		p.Attack = 0.005
+		p.Sustain = 0.05
+		p.Decay = 0.12
+		p.HighPass = 300
+	case "explosion":
+		p.Wave = "noise"
+		p.Freq = 900
+		p.FreqSlide = -600
+		p.Attack = 0.01
+		p.Sustain = 0.15
+		p.Decay = 0.55
+		p.LowPass = 2200
+	case "hurt":
+		p.Wave = "saw"
+		p.Freq = 300
+		p.FreqSlide = -700
+		p.Attack = 0.005
+		p.Sustain = 0.04
+		p.Decay = 0.14
+	case "powerup":
+		p.Wave = "square"
+		p.Duty = 0.4
+		p.Freq = 220
+		p.FreqSlide = 700
+		p.VibratoDepth = 25
+		p.VibratoRate = 9
+		p.Attack = 0.01
+		p.Sustain = 0.25
+		p.Decay = 0.25
+	case "blip":
+		p.Wave = "square"
+		p.Duty = 0.4
+		p.Freq = 660
+		p.Attack = 0.002
+		p.Sustain = 0.03
+		p.Decay = 0.05
+	default:
+		return nil, fmt.Errorf("unknown preset %q (available: %s)", name, PresetNames())
+	}
+	if seed != 0 {
+		vary(&p, seed)
+	}
+	if err := p.Validate(); err != nil {
+		return nil, fmt.Errorf("preset %s (seed %d): %w", name, seed, err)
+	}
+	return &p, nil
+}
+
+// vary nudges the tonal parameters deterministically from the seed.
+func vary(p *Params, seed int64) {
+	rng := rand.New(rand.NewSource(seed))
+	jitter := func(v, amount float64) float64 {
+		return v * (1 + amount*(rng.Float64()*2-1))
+	}
+	p.Freq = jitter(p.Freq, 0.15)
+	p.FreqSlide = jitter(p.FreqSlide, 0.25)
+	p.Sustain = jitter(p.Sustain, 0.2)
+	p.Decay = jitter(p.Decay, 0.2)
+	if p.ArpFactor != 0 {
+		p.ArpFactor = jitter(p.ArpFactor, 0.05)
+	}
+	p.Seed = seed // noise variation too
+}
+
+var presetNames = []string{"blip", "coin", "explosion", "hurt", "jump", "laser", "powerup"}
+
+// PresetNames lists the available presets, sorted.
+func PresetNames() string {
+	sort.Strings(presetNames)
+	out := ""
+	for i, n := range presetNames {
+		if i > 0 {
+			out += ", "
+		}
+		out += n
+	}
+	return out
+}

sfx-maker/sfx/sfx_test.go

@@ -0,0 +1,164 @@
+package sfx
+
+import (
+	"bytes"
+	"math"
+	"strings"
+	"testing"
+)
+
+func TestParseAndValidate(t *testing.T) {
+	src := `
+# a jump
+sfx: jump
+wave: square
+freq: 330
+freq-slide: 900
+attack: 0.01
+sustain: 0.08
+decay: 0.18
+duty: 0.4
+`
+	p, err := Parse(strings.NewReader(src))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if p.Name != "jump" || p.Wave != "square" || p.Freq != 330 || p.Duty != 0.4 {
+		t.Errorf("parsed wrong: %+v", p)
+	}
+	if math.Abs(p.Duration()-0.27) > 1e-9 {
+		t.Errorf("duration = %g, want 0.27", p.Duration())
+	}
+}
+
+func TestParseErrors(t *testing.T) {
+	cases := map[string]string{
+		"unknown key":  "wat: 3\n",
+		"bad wave":     "wave: wobble\n",
+		"bad value":    "freq: abc\n",
+		"zero length":  "attack: 0\nsustain: 0\ndecay: 0\n",
+		"volume range": "volume: 2\n",
+		"duty range":   "duty: 0.99\n",
+	}
+	for name, src := range cases {
+		if _, err := Parse(strings.NewReader(src)); err == nil {
+			t.Errorf("%s: expected error", name)
+		}
+	}
+}
+
+func TestRenderBasics(t *testing.T) {
+	p := Defaults()
+	p.Wave = "sine"
+	p.Attack, p.Sustain, p.Decay = 0.01, 0.05, 0.05
+	samples := Render(&p)
+	want := int(0.11 * 44100)
+	if len(samples) != want {
+		t.Errorf("samples = %d, want %d", len(samples), want)
+	}
+	var peak float64
+	for _, s := range samples {
+		if math.Abs(s) > peak {
+			peak = math.Abs(s)
+		}
+		if s > 1 || s < -1 {
+			t.Fatalf("sample %g out of range", s)
+		}
+	}
+	if peak < 0.5 {
+		t.Errorf("peak %g suspiciously quiet", peak)
+	}
+	// end of decay should be silent-ish
+	tail := samples[len(samples)-10:]
+	for _, s := range tail {
+		if math.Abs(s) > 0.1 {
+			t.Errorf("tail sample %g not decayed", s)
+		}
+	}
+}
+
+func TestRenderDeterministic(t *testing.T) {
+	p := Defaults()
+	p.Wave = "noise"
+	p.Seed = 42
+	a := Render(&p)
+	b := Render(&p)
+	for i := range a {
+		if a[i] != b[i] {
+			t.Fatalf("noise render not deterministic at sample %d", i)
+		}
+	}
+}
+
+func TestAllWavesAndPresets(t *testing.T) {
+	for _, w := range []string{"square", "saw", "sine", "triangle", "noise"} {
+		p := Defaults()
+		p.Wave = w
+		if s := Render(&p); len(s) == 0 {
+			t.Errorf("wave %s rendered nothing", w)
+		}
+	}
+	for _, name := range []string{"blip", "coin", "explosion", "hurt", "jump", "laser", "powerup"} {
+		p, err := Preset(name, 0)
+		if err != nil {
+			t.Errorf("preset %s: %v", name, err)
+			continue
+		}
+		s := Render(p)
+		var sum float64
+		for _, v := range s {
+			sum += v * v
+		}
+		rms := math.Sqrt(sum / float64(len(s)))
+		if rms < 0.01 {
+			t.Errorf("preset %s is nearly silent (rms %g)", name, rms)
+		}
+		// variants stay valid
+		if _, err := Preset(name, 7); err != nil {
+			t.Errorf("preset %s seed 7: %v", name, err)
+		}
+	}
+	if _, err := Preset("nope", 0); err == nil {
+		t.Error("unknown preset should error")
+	}
+}
+
+func TestWAVRoundTrip(t *testing.T) {
+	p := Defaults()
+	samples := Render(&p)
+	var buf bytes.Buffer
+	if err := WriteWAV(&buf, samples, p.SampleRate); err != nil {
+		t.Fatal(err)
+	}
+	sr, bits, ch, dataBytes, err := ReadWAVHeader(&buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if sr != 44100 || bits != 16 || ch != 1 {
+		t.Errorf("header: sr=%d bits=%d ch=%d", sr, bits, ch)
+	}
+	if dataBytes != len(samples)*2 {
+		t.Errorf("dataBytes = %d, want %d", dataBytes, len(samples)*2)
+	}
+	if buf.Len() != dataBytes {
+		t.Errorf("body length %d != declared %d", buf.Len(), dataBytes)
+	}
+}
+
+func TestParamsWriteRoundTrip(t *testing.T) {
+	p, err := Preset("coin", 3)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var buf bytes.Buffer
+	if err := p.Write(&buf, "test"); err != nil {
+		t.Fatal(err)
+	}
+	back, err := Parse(&buf)
+	if err != nil {
+		t.Fatalf("re-parse of written .sfx failed: %v\n%s", err, buf.String())
+	}
+	if back.Freq != p.Freq || back.ArpFactor != p.ArpFactor || back.Seed != p.Seed {
+		t.Errorf("roundtrip mismatch: %+v vs %+v", back, p)
+	}
+}

sfx-maker/sfx/synth.go

@@ -0,0 +1,122 @@
+package sfx
+
+import (
+	"math"
+	"math/rand"
+)
+
+// Render synthesizes the effect into float64 samples in [-1, 1].
+func Render(p *Params) []float64 {
+	sr := float64(p.SampleRate)
+	n := int(p.Duration() * sr)
+	out := make([]float64, n)
+	rng := rand.New(rand.NewSource(p.Seed))
+
+	phase := 0.0
+	noiseVal := 0.0
+	noiseCounter := 0.0
+
+	// one-pole filter states
+	lpState := 0.0
+	hpState := 0.0
+	hpPrevIn := 0.0
+	dt := 1 / sr
+	lpAlpha := 0.0
+	if p.LowPass > 0 {
+		rc := 1 / (2 * math.Pi * p.LowPass)
+		lpAlpha = dt / (rc + dt)
+	}
+	hpAlpha := 0.0
+	if p.HighPass > 0 {
+		rc := 1 / (2 * math.Pi * p.HighPass)
+		hpAlpha = rc / (rc + dt)
+	}
+
+	for i := 0; i < n; i++ {
+		t := float64(i) / sr
+
+		f := p.Freq + p.FreqSlide*t
+		if p.ArpFactor != 0 && p.ArpTime > 0 && t >= p.ArpTime {
+			f *= p.ArpFactor
+		}
+		if p.VibratoDepth > 0 && p.VibratoRate > 0 {
+			f += p.VibratoDepth * math.Sin(2*math.Pi*p.VibratoRate*t)
+		}
+		if f < p.FreqMin {
+			f = p.FreqMin
+		}
+
+		var s float64
+		if p.Wave == "noise" {
+			// pitched noise: new random value f*4 times per second
+			noiseCounter += f * 4 * dt
+			if noiseCounter >= 1 || i == 0 {
+				noiseCounter = math.Mod(noiseCounter, 1)
+				noiseVal = rng.Float64()*2 - 1
+			}
+			s = noiseVal
+		} else {
+			phase += f * dt
+			ph := math.Mod(phase, 1)
+			switch p.Wave {
+			case "square":
+				if ph < p.Duty {
+					s = 1
+				} else {
+					s = -1
+				}
+			case "saw":
+				s = 2*ph - 1
+			case "triangle":
+				if ph < 0.5 {
+					s = 4*ph - 1
+				} else {
+					s = 3 - 4*ph
+				}
+			case "sine":
+				s = math.Sin(2 * math.Pi * ph)
+			}
+		}
+
+		s *= envelope(p, t)
+
+		if lpAlpha > 0 {
+			lpState += lpAlpha * (s - lpState)
+			s = lpState
+		}
+		if hpAlpha > 0 {
+			hpState = hpAlpha * (hpState + s - hpPrevIn)
+			hpPrevIn = s
+			s = hpState
+		}
+
+		s *= p.Volume
+		if s > 1 {
+			s = 1
+		} else if s < -1 {
+			s = -1
+		}
+		out[i] = s
+	}
+	return out
+}
+
+// envelope is a linear attack / sustain / decay gain in 0..1.
+func envelope(p *Params, t float64) float64 {
+	switch {
+	case t < p.Attack:
+		return t / p.Attack
+	case t < p.Attack+p.Sustain:
+		return 1
+	default:
+		d := t - p.Attack - p.Sustain
+		if p.Decay <= 0 {
+			return 0
+		}
+		g := 1 - d/p.Decay
+		if g < 0 {
+			g = 0
+		}
+		return g
+	}
+}

sfx-maker/sfx/wav.go

@@ -0,0 +1,54 @@
+package sfx
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"math"
+)
+
+// WriteWAV encodes samples ([-1,1] floats) as a 16-bit mono PCM WAV.
+func WriteWAV(w io.Writer, samples []float64, sampleRate int) error {
+	dataLen := len(samples) * 2
+	var hdr [44]byte
+	copy(hdr[0:4], "RIFF")
+	binary.LittleEndian.PutUint32(hdr[4:8], uint32(36+dataLen))
+	copy(hdr[8:12], "WAVE")
+	copy(hdr[12:16], "fmt ")
+	binary.LittleEndian.PutUint32(hdr[16:20], 16)                   // fmt chunk size
+	binary.LittleEndian.PutUint16(hdr[20:22], 1)                    // PCM
+	binary.LittleEndian.PutUint16(hdr[22:24], 1)                    // mono
+	binary.LittleEndian.PutUint32(hdr[24:28], uint32(sampleRate))   // sample rate
+	binary.LittleEndian.PutUint32(hdr[28:32], uint32(sampleRate*2)) // byte rate
+	binary.LittleEndian.PutUint16(hdr[32:34], 2)                    // block align
+	binary.LittleEndian.PutUint16(hdr[34:36], 16)                   // bits per sample
+	copy(hdr[36:40], "data")
+	binary.LittleEndian.PutUint32(hdr[40:44], uint32(dataLen))
+	if _, err := w.Write(hdr[:]); err != nil {
+		return err
+	}
+	buf := make([]byte, 2*len(samples))
+	for i, s := range samples {
+		v := int16(math.Round(s * 32767))
+		binary.LittleEndian.PutUint16(buf[i*2:], uint16(v))
+	}
+	_, err := w.Write(buf)
+	return err
+}
+
+// ReadWAVHeader sanity-parses a WAV header (used in tests and info).
+func ReadWAVHeader(r io.Reader) (sampleRate, bits, channels, dataBytes int, err error) {
+	var hdr [44]byte
+	if _, err = io.ReadFull(r, hdr[:]); err != nil {
+		return
+	}
+	if string(hdr[0:4]) != "RIFF" || string(hdr[8:12]) != "WAVE" {
+		err = fmt.Errorf("not a WAV file")
+		return
+	}
+	channels = int(binary.LittleEndian.Uint16(hdr[22:24]))
+	sampleRate = int(binary.LittleEndian.Uint32(hdr[24:28]))
+	bits = int(binary.LittleEndian.Uint16(hdr[34:36]))
+	dataBytes = int(binary.LittleEndian.Uint32(hdr[40:44]))
+	return
+}

svg-maker/README.md

@@ -0,0 +1,82 @@
+# svg-maker — `svgc`, vector graphics for agents
+
+Builds SVG images from a line-based text format (`.svgd`) that an
+agent can author directly, **verify without a GUI** (terminal preview
++ measurements) and show to a human through agent-helm
+(`helmd share out.svg`). Built for "graphical elements": status cards,
+diagrams, icons, simple illustrations.
+
+## Usage
+
+```
+svgc build <file.svgd> [-o out.svg] [--preview] [--width N]
+svgc preview <file.svgd> [--width N]     truecolor half-block render
+svgc info <file.svgd>                    counts, colors, bbox, warnings
+svgc example                             annotated example to start from
+```
+
+Typical agent flow:
+
+```bash
+svgc example > card.svgd        # start from the example
+# ...edit card.svgd...
+svgc build card.svgd --preview  # writes card.svg + shows what it looks like
+helmd share card.svg --note "status card"   # display it in agent-helm
+```
+
+`build` prints an info block after writing — element counts, colors,
+the drawing's bounding box and **warnings for anything outside the
+canvas** — so mistakes surface as text even without the preview.
+Errors carry line numbers (`card.svgd: line 7: "four" is not a
+number — rect needs: rect <x> <y> <w> <h>`).
+
+## The .svgd format
+
+One element per line, `#` comments, `key=value` attributes last:
+
+```
+canvas 240 120                       # required: width height
+bg #12161f                           # optional background
+def accent #4f9cf9                   # named color, use as $accent
+
+rect 10 10 60 40 fill=$accent rx=6
+circle 120 40 20 fill=#3fca7c stroke=white stroke-width=2
+ellipse 60 90 30 12 fill=gray
+line 10 100 190 100 stroke=red width=3
+polyline 10,20 30,40 50,10 stroke=white
+polygon 20,80 40,60 60,80 fill=#e0a63f
+path M10,10 L50,50 Q70,20 90,50 Z stroke=white
+text 100 60 "Hello agent-helm" size=14 fill=white anchor=middle bold
+group stroke=gray stroke-width=1     # group attrs are inherited
+  line 0 0 10 10
+end
+```
+
+| Piece | Notes |
+|---|---|
+| `canvas w h` | required first; becomes the viewBox and image size |
+| `bg color` | background rect |
+| `def name color` | color variable; `$name` in any fill/stroke |
+| attributes | `fill stroke stroke-width` (alias `width`) `opacity fill-opacity stroke-opacity rx ry anchor size font dash linecap linejoin transform id` + flags `bold italic` |
+| colors | `#rgb`, `#rrggbb`, CSS names, `none`; unknown attribute keys are errors |
+| `path` | subset `M L H V C Q Z`, absolute + relative, commas or spaces |
+| `transform` | raw SVG transform with commas: `transform=rotate(45,50,50)` |
+
+Friendly defaults: `line`/`polyline`/`path` get a visible stroke if
+you give none, `polyline` gets `fill=none` — no invisible elements,
+no accidental filled blobs.
+
+## Preview fidelity
+
+The preview rasterizes the same shape model the emitter writes:
+fills, strokes, opacity and group inheritance are honored. Two
+approximations: `rx` rounded corners render square, and **text renders
+as its baseline box** (real glyphs are a font problem — check text in
+the real render via agent-helm). `info` always reflects true geometry.
+
+## Build & test
+
+```bash
+go test ./...
+go build -o build/svgc .
+```

svg-maker/examples/gauge.svgd

@@ -0,0 +1,12 @@
+# gauge.svgd - example: a small status card
+canvas 240 120
+bg #12161f
+
+def ok    #3fca7c
+def frame #262d3a
+
+rect 8 8 224 104 fill=none stroke=$frame stroke-width=2 rx=10
+circle 40 60 22 fill=none stroke=$ok stroke-width=6
+path M30,60 L38,68 L52,50 stroke=$ok width=5 linecap=round fill=none
+text 76 54 "backups" size=13 fill=#8a93a5
+text 76 76 "all green" size=17 fill=white bold

svg-maker/go.mod

@@ -0,0 +1,3 @@
+module gitea.brasse-pc.eu/brasse/agent-tools/svg-maker
+
+go 1.24

svg-maker/main.go

@@ -0,0 +1,176 @@
+// svgc builds SVG images from .svgd text descriptions — vector
+// graphics an agent can author, verify (terminal preview + info) and
+// share to agent-helm with `helmd share out.svg`.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"gitea.brasse-pc.eu/brasse/agent-tools/svg-maker/svg"
+)
+
+var version = "dev"
+
+const usage = `svgc - SVG maker for agents
+
+Usage:
+  svgc build <file.svgd> [-o out.svg] [--preview] [--width N]
+  svgc preview <file.svgd> [--width N]     draw it in the terminal
+  svgc info <file.svgd>                    counts, colors, bbox, warnings
+  svgc example                             print an annotated example file
+  svgc version
+
+The .svgd format ('#' comments, one element per line):
+  canvas 200 120                       required: width height
+  bg #1a2029                           optional background
+  def accent #4f9cf9                   named color, use as $accent
+  rect 10 10 60 40 fill=$accent rx=6
+  circle 120 40 20 fill=#3fca7c stroke=white stroke-width=2
+  ellipse 60 90 30 12 fill=gray
+  line 10 100 190 100 stroke=red width=3
+  polyline 10,20 30,40 50,10 stroke=white
+  polygon 20,80 40,60 60,80 fill=#e0a63f
+  path M10,10 L50,50 Q70,20 90,50 Z stroke=white
+  text 100 60 "Hello agent-helm" size=14 fill=white anchor=middle bold
+  group stroke=gray stroke-width=1     group attrs are inherited
+    line 0 0 10 10
+  end
+
+Attributes: fill stroke stroke-width|width opacity fill-opacity
+stroke-opacity rx ry anchor size font dash linecap linejoin transform
+id, plus flags bold italic. Colors: #rgb #rrggbb, CSS names, none.
+
+Show the result in agent-helm:  helmd share out.svg --note "diagram"
+`
+
+const exampleFile = `# gauge.svgd - example: a small status card
+canvas 240 120
+bg #12161f
+
+def ok    #3fca7c
+def frame #262d3a
+
+rect 8 8 224 104 fill=none stroke=$frame stroke-width=2 rx=10
+circle 40 60 22 fill=none stroke=$ok stroke-width=6
+path M30,60 L38,68 L52,50 stroke=$ok width=5 linecap=round fill=none
+text 76 54 "backups" size=13 fill=#8a93a5
+text 76 76 "all green" size=17 fill=white bold
+`
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Print(usage)
+		os.Exit(2)
+	}
+	switch os.Args[1] {
+	case "build":
+		cmdBuild(os.Args[2:])
+	case "preview":
+		cmdPreview(os.Args[2:])
+	case "info":
+		cmdInfo(os.Args[2:])
+	case "example":
+		fmt.Print(exampleFile)
+	case "version", "--version", "-v":
+		fmt.Println("svgc", version)
+	case "help", "--help", "-h":
+		fmt.Print(usage)
+	default:
+		die("unknown command %q — run 'svgc help'", os.Args[1])
+	}
+}
+
+func cmdBuild(args []string) {
+	fs := flag.NewFlagSet("build", flag.ExitOnError)
+	out := fs.String("o", "", "output file (default: input with .svg)")
+	preview := fs.Bool("preview", false, "also draw the result in the terminal")
+	width := fs.Int("width", 72, "preview width in characters")
+	pos := parseInterspersed(fs, args)
+	if len(pos) != 1 {
+		die("build takes exactly one .svgd file")
+	}
+	xml, doc := load(pos[0])
+	dst := *out
+	if dst == "" {
+		dst = strings.TrimSuffix(pos[0], filepath.Ext(pos[0])) + ".svg"
+	}
+	if err := os.WriteFile(dst, []byte(xml), 0o644); err != nil {
+		die("%v", err)
+	}
+	fmt.Printf("wrote %s (%d bytes)\n", dst, len(xml))
+	fmt.Print(svg.Info(doc))
+	if *preview {
+		fmt.Print(svg.RenderGrid(doc, *width).ANSI())
+	}
+}
+
+func cmdPreview(args []string) {
+	fs := flag.NewFlagSet("preview", flag.ExitOnError)
+	width := fs.Int("width", 72, "preview width in characters")
+	pos := parseInterspersed(fs, args)
+	if len(pos) != 1 {
+		die("preview takes exactly one .svgd file")
+	}
+	_, doc := load(pos[0])
+	fmt.Print(svg.RenderGrid(doc, *width).ANSI())
+}
+
+func cmdInfo(args []string) {
+	if len(args) != 1 {
+		die("info takes exactly one .svgd file")
+	}
+	_, doc := load(args[0])
+	fmt.Print(svg.Info(doc))
+}
+
+// load reads and builds a .svgd file (attrs normalized), dying with
+// the parser's line-numbered error on failure. Returns the SVG XML
+// and the parsed document.
+func load(path string) (string, *svg.Doc) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		die("%v", err)
+	}
+	xml, doc, err := svg.Build(string(data))
+	if err != nil {
+		die("%s: %v", path, err)
+	}
+	return xml, doc
+}
+
+// parseInterspersed lets flags appear before or after positional args.
+func parseInterspersed(fs *flag.FlagSet, args []string) []string {
+	var flags, pos []string
+	for i := 0; i < len(args); i++ {
+		a := args[i]
+		if len(a) > 1 && a[0] == '-' {
+			flags = append(flags, a)
+			name := strings.TrimLeft(a, "-")
+			if eq := strings.Index(name, "="); eq >= 0 {
+				continue
+			}
+			if f := fs.Lookup(name); f != nil {
+				if bf, ok := f.Value.(interface{ IsBoolFlag() bool }); ok && bf.IsBoolFlag() {
+					continue
+				}
+			}
+			if i+1 < len(args) {
+				i++
+				flags = append(flags, args[i])
+			}
+		} else {
+			pos = append(pos, a)
+		}
+	}
+	fs.Parse(flags)
+	return pos
+}
+
+func die(format string, args ...interface{}) {
+	fmt.Fprintf(os.Stderr, "svgc: "+format+"\n", args...)
+	os.Exit(1)
+}

svg-maker/svg/emit.go

@@ -0,0 +1,135 @@
+package svg
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// Emit renders the document as an SVG file.
+func Emit(d *Doc) string {
+	var b strings.Builder
+	fmt.Fprintf(&b, `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 %s %s" width="%s" height="%s">`,
+		num(d.W), num(d.H), num(d.W), num(d.H))
+	b.WriteString("\n")
+	if d.Bg != "" {
+		fmt.Fprintf(&b, `  <rect width="100%%" height="100%%" fill="%s"/>`+"\n", d.Bg)
+	}
+	for _, el := range d.Elems {
+		emitElem(&b, el, 1)
+	}
+	b.WriteString("</svg>\n")
+	return b.String()
+}
+
+func emitElem(b *strings.Builder, el *Elem, depth int) {
+	ind := strings.Repeat("  ", depth)
+	attrs := attrString(el.Attrs)
+	switch el.Kind {
+	case "rect":
+		fmt.Fprintf(b, `%s<rect x="%s" y="%s" width="%s" height="%s"%s/>`+"\n",
+			ind, num(el.Nums[0]), num(el.Nums[1]), num(el.Nums[2]), num(el.Nums[3]), attrs)
+	case "circle":
+		fmt.Fprintf(b, `%s<circle cx="%s" cy="%s" r="%s"%s/>`+"\n",
+			ind, num(el.Nums[0]), num(el.Nums[1]), num(el.Nums[2]), attrs)
+	case "ellipse":
+		fmt.Fprintf(b, `%s<ellipse cx="%s" cy="%s" rx="%s" ry="%s"%s/>`+"\n",
+			ind, num(el.Nums[0]), num(el.Nums[1]), num(el.Nums[2]), num(el.Nums[3]), attrs)
+	case "line":
+		fmt.Fprintf(b, `%s<line x1="%s" y1="%s" x2="%s" y2="%s"%s/>`+"\n",
+			ind, num(el.Nums[0]), num(el.Nums[1]), num(el.Nums[2]), num(el.Nums[3]), attrs)
+	case "polyline", "polygon":
+		pts := make([]string, len(el.Points))
+		for i, p := range el.Points {
+			pts[i] = num(p[0]) + "," + num(p[1])
+		}
+		fmt.Fprintf(b, `%s<%s points="%s"%s/>`+"\n", ind, el.Kind, strings.Join(pts, " "), attrs)
+	case "path":
+		fmt.Fprintf(b, `%s<path d="%s"%s/>`+"\n", ind, escape(el.D), attrs)
+	case "text":
+		fmt.Fprintf(b, `%s<text x="%s" y="%s"%s>%s</text>`+"\n",
+			ind, num(el.Nums[0]), num(el.Nums[1]), attrs, escape(el.Text))
+	case "group":
+		fmt.Fprintf(b, "%s<g%s>\n", ind, attrs)
+		for _, kid := range el.Kids {
+			emitElem(b, kid, depth+1)
+		}
+		fmt.Fprintf(b, "%s</g>\n", ind)
+	}
+}
+
+// defaults SVG would otherwise pick that surprise agents: lines and
+// paths get a visible stroke if none set; polyline defaults fill=none
+// so it doesn't render as a filled blob.
+func effectiveAttrs(el *Elem) map[string]string {
+	out := map[string]string{}
+	for k, v := range el.Attrs {
+		out[k] = v
+	}
+	switch el.Kind {
+	case "line", "polyline":
+		if out["stroke"] == "" {
+			out["stroke"] = "black"
+		}
+		if el.Kind == "polyline" && out["fill"] == "" {
+			out["fill"] = "none"
+		}
+	case "path":
+		if out["stroke"] == "" && out["fill"] == "" {
+			out["stroke"] = "black"
+			out["fill"] = "none"
+		}
+	}
+	return out
+}
+
+func attrString(attrs map[string]string) string {
+	if len(attrs) == 0 {
+		return ""
+	}
+	keys := make([]string, 0, len(attrs))
+	for k := range attrs {
+		keys = append(keys, k)
+	}
+	sort.Strings(keys)
+	var b strings.Builder
+	for _, k := range keys {
+		fmt.Fprintf(&b, ` %s="%s"`, k, escape(attrs[k]))
+	}
+	return b.String()
+}
+
+func num(f float64) string {
+	return strconv.FormatFloat(f, 'f', -1, 64)
+}
+
+func escape(s string) string {
+	r := strings.NewReplacer("&", "&amp;", "<", "&lt;", ">", "&gt;", `"`, "&quot;")
+	return r.Replace(s)
+}
+
+// normalize applies the effective attrs (visibility defaults) onto the
+// tree before emit/raster so both outputs agree.
+func (d *Doc) normalize() {
+	var walk func(els []*Elem)
+	walk = func(els []*Elem) {
+		for _, el := range els {
+			el.Attrs = effectiveAttrs(el)
+			if el.Kind == "group" {
+				walk(el.Kids)
+			}
+		}
+	}
+	walk(d.Elems)
+}
+
+// Build parses src and emits SVG in one step.
+func Build(src string) (string, *Doc, error) {
+	doc, err := Parse(src)
+	if err != nil {
+		return "", nil, err
+	}
+	doc.normalize()
+	return Emit(doc), doc, nil
+}

svg-maker/svg/info.go

@@ -0,0 +1,143 @@
+package svg
+
+import (
+	"fmt"
+	"math"
+	"sort"
+	"strings"
+)
+
+// Info summarizes a parsed document: element counts, colors, the
+// drawing's bounding box and warnings (things drawn outside the
+// canvas), so an agent can verify a build without looking at pixels.
+func Info(d *Doc) string {
+	counts := map[string]int{}
+	colors := map[string]bool{}
+	minX, minY := math.Inf(1), math.Inf(1)
+	maxX, maxY := math.Inf(-1), math.Inf(-1)
+	var warnings []string
+
+	var walk func(els []*Elem)
+	walk = func(els []*Elem) {
+		for _, el := range els {
+			if el.Kind == "group" {
+				counts["group"]++
+				walk(el.Kids)
+				continue
+			}
+			counts[el.Kind]++
+			for _, key := range []string{"fill", "stroke"} {
+				if c := el.Attrs[key]; c != "" && c != "none" && c != "transparent" {
+					colors[c] = true
+				}
+			}
+			x0, y0, x1, y1, ok := bbox(el)
+			if !ok {
+				continue
+			}
+			minX = math.Min(minX, x0)
+			minY = math.Min(minY, y0)
+			maxX = math.Max(maxX, x1)
+			maxY = math.Max(maxY, y1)
+			if x1 < 0 || y1 < 0 || x0 > d.W || y0 > d.H {
+				warnings = append(warnings, fmt.Sprintf("line %d: %s is entirely outside the canvas", el.Line, el.Kind))
+			} else if x0 < 0 || y0 < 0 || x1 > d.W || y1 > d.H {
+				warnings = append(warnings, fmt.Sprintf("line %d: %s sticks outside the canvas", el.Line, el.Kind))
+			}
+		}
+	}
+	walk(d.Elems)
+
+	var b strings.Builder
+	fmt.Fprintf(&b, "canvas: %gx%g", d.W, d.H)
+	if d.Bg != "" {
+		fmt.Fprintf(&b, "  bg: %s", d.Bg)
+	}
+	b.WriteString("\n")
+	kinds := make([]string, 0, len(counts))
+	for k := range counts {
+		kinds = append(kinds, k)
+	}
+	sort.Strings(kinds)
+	total := 0
+	parts := make([]string, 0, len(kinds))
+	for _, k := range kinds {
+		parts = append(parts, fmt.Sprintf("%s:%d", k, counts[k]))
+		if k != "group" {
+			total += counts[k]
+		}
+	}
+	fmt.Fprintf(&b, "elements: %d (%s)\n", total, strings.Join(parts, " "))
+	if len(colors) > 0 {
+		cl := make([]string, 0, len(colors))
+		for c := range colors {
+			cl = append(cl, c)
+		}
+		sort.Strings(cl)
+		fmt.Fprintf(&b, "colors: %s\n", strings.Join(cl, " "))
+	}
+	if total > 0 && !math.IsInf(minX, 1) {
+		fmt.Fprintf(&b, "drawing bbox: %.4g,%.4g .. %.4g,%.4g\n", minX, minY, maxX, maxY)
+	}
+	for _, w := range warnings {
+		fmt.Fprintf(&b, "warning: %s\n", w)
+	}
+	return b.String()
+}
+
+// bbox computes an element's geometric bounding box (stroke width and
+// transforms not included — good enough for out-of-canvas warnings).
+func bbox(el *Elem) (x0, y0, x1, y1 float64, ok bool) {
+	switch el.Kind {
+	case "rect":
+		return el.Nums[0], el.Nums[1], el.Nums[0] + el.Nums[2], el.Nums[1] + el.Nums[3], true
+	case "circle":
+		cx, cy, r := el.Nums[0], el.Nums[1], el.Nums[2]
+		return cx - r, cy - r, cx + r, cy + r, true
+	case "ellipse":
+		cx, cy, rx, ry := el.Nums[0], el.Nums[1], el.Nums[2], el.Nums[3]
+		return cx - rx, cy - ry, cx + rx, cy + ry, true
+	case "line":
+		return math.Min(el.Nums[0], el.Nums[2]), math.Min(el.Nums[1], el.Nums[3]),
+			math.Max(el.Nums[0], el.Nums[2]), math.Max(el.Nums[1], el.Nums[3]), true
+	case "polyline", "polygon":
+		return pointsBBox(el.Points)
+	case "path":
+		subs, err := flattenPath(el.D)
+		if err != nil {
+			return 0, 0, 0, 0, false
+		}
+		var all [][2]float64
+		for _, sp := range subs {
+			all = append(all, sp...)
+		}
+		return pointsBBox(all)
+	case "text":
+		size := attrFloat(el.Attrs, "font-size", 16)
+		w := 0.6 * size * float64(len([]rune(el.Text)))
+		x, y := el.Nums[0], el.Nums[1]
+		switch el.Attrs["text-anchor"] {
+		case "middle":
+			x -= w / 2
+		case "end":
+			x -= w
+		}
+		return x, y - size, x + w, y, true
+	}
+	return 0, 0, 0, 0, false
+}
+
+func pointsBBox(pts [][2]float64) (x0, y0, x1, y1 float64, ok bool) {
+	if len(pts) == 0 {
+		return 0, 0, 0, 0, false
+	}
+	x0, y0 = pts[0][0], pts[0][1]
+	x1, y1 = x0, y0
+	for _, p := range pts {
+		x0 = math.Min(x0, p[0])
+		y0 = math.Min(y0, p[1])
+		x1 = math.Max(x1, p[0])
+		y1 = math.Max(y1, p[1])
+	}
+	return x0, y0, x1, y1, true
+}

svg-maker/svg/parse.go

@@ -0,0 +1,430 @@
+// Package svg turns .svgd text descriptions into SVG images an agent
+// can verify: build (emit XML), preview (terminal raster) and info
+// (measurements + warnings).
+package svg
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Elem is one drawing element. Kind decides which fields matter:
+//
+//	rect     Nums: x y w h
+//	circle   Nums: cx cy r
+//	ellipse  Nums: cx cy rx ry
+//	line     Nums: x1 y1 x2 y2
+//	polyline Points
+//	polygon  Points
+//	path     D (subset: M L H V C Q Z, absolute + relative)
+//	text     Nums: x y, Text
+//	group    Kids (inherits its Attrs to children)
+type Elem struct {
+	Kind   string
+	Nums   []float64
+	Points [][2]float64
+	D      string
+	Text   string
+	Attrs  map[string]string
+	Line   int
+	Kids   []*Elem
+}
+
+// Doc is a parsed .svgd file.
+type Doc struct {
+	W, H  float64
+	Bg    string
+	Elems []*Elem
+}
+
+// attrKeys maps .svgd attribute names to SVG presentation attributes.
+// Friendly aliases keep the format short; unknown keys are errors so
+// typos surface at build time instead of becoming invisible SVG.
+var attrKeys = map[string]string{
+	"fill":           "fill",
+	"stroke":         "stroke",
+	"stroke-width":   "stroke-width",
+	"width":          "stroke-width", // common shorthand on line/path
+	"opacity":        "opacity",
+	"fill-opacity":   "fill-opacity",
+	"stroke-opacity": "stroke-opacity",
+	"rx":             "rx",
+	"ry":             "ry",
+	"anchor":         "text-anchor",
+	"size":           "font-size",
+	"font":           "font-family",
+	"dash":           "stroke-dasharray",
+	"linecap":        "stroke-linecap",
+	"linejoin":       "stroke-linejoin",
+	"transform":      "transform",
+	"id":             "id",
+}
+
+// flag attributes expand to fixed key/values.
+var flagAttrs = map[string][2]string{
+	"bold":   {"font-weight", "bold"},
+	"italic": {"font-style", "italic"},
+}
+
+type parser struct {
+	defs map[string]string
+	line int
+}
+
+// Parse reads a .svgd document.
+func Parse(src string) (*Doc, error) {
+	p := &parser{defs: map[string]string{}}
+	doc := &Doc{W: 100, H: 100}
+	sawCanvas := false
+
+	stack := []*[]*Elem{&doc.Elems} // group nesting; top = current container
+	groupLines := []int{}
+
+	for i, raw := range strings.Split(src, "\n") {
+		p.line = i + 1
+		line := strings.TrimSpace(raw)
+		if idx := findComment(line); idx >= 0 {
+			line = strings.TrimSpace(line[:idx])
+		}
+		if line == "" {
+			continue
+		}
+		tokens, err := tokenize(line)
+		if err != nil {
+			return nil, p.errf("%v", err)
+		}
+		kind, rest := tokens[0], tokens[1:]
+
+		switch kind {
+		case "canvas":
+			nums, _, err := p.numsAndAttrs(rest, 2, "canvas needs: canvas <width> <height>")
+			if err != nil {
+				return nil, err
+			}
+			if nums[0] <= 0 || nums[1] <= 0 {
+				return nil, p.errf("canvas size must be positive")
+			}
+			doc.W, doc.H = nums[0], nums[1]
+			sawCanvas = true
+
+		case "bg":
+			if len(rest) != 1 {
+				return nil, p.errf("bg needs: bg <color>")
+			}
+			c, err := p.color(rest[0])
+			if err != nil {
+				return nil, err
+			}
+			doc.Bg = c
+
+		case "def":
+			if len(rest) != 2 {
+				return nil, p.errf("def needs: def <name> <color>")
+			}
+			c, err := p.color(rest[1])
+			if err != nil {
+				return nil, err
+			}
+			p.defs[rest[0]] = c
+
+		case "group":
+			attrs, err := p.attrs(rest)
+			if err != nil {
+				return nil, err
+			}
+			g := &Elem{Kind: "group", Attrs: attrs, Line: p.line}
+			*stack[len(stack)-1] = append(*stack[len(stack)-1], g)
+			stack = append(stack, &g.Kids)
+			groupLines = append(groupLines, p.line)
+
+		case "end":
+			if len(stack) == 1 {
+				return nil, p.errf("end without group")
+			}
+			stack = stack[:len(stack)-1]
+			groupLines = groupLines[:len(groupLines)-1]
+
+		default:
+			el, err := p.element(kind, rest)
+			if err != nil {
+				return nil, err
+			}
+			*stack[len(stack)-1] = append(*stack[len(stack)-1], el)
+		}
+	}
+	if len(stack) > 1 {
+		return nil, fmt.Errorf("line %d: group is never closed (missing end)", groupLines[len(groupLines)-1])
+	}
+	if !sawCanvas {
+		return nil, fmt.Errorf("missing canvas line (canvas <width> <height>)")
+	}
+	return doc, nil
+}
+
+func (p *parser) element(kind string, rest []string) (*Elem, error) {
+	el := &Elem{Kind: kind, Line: p.line}
+	var err error
+	switch kind {
+	case "rect":
+		el.Nums, el.Attrs, err = p.numsAndAttrs(rest, 4, "rect needs: rect <x> <y> <w> <h>")
+	case "circle":
+		el.Nums, el.Attrs, err = p.numsAndAttrs(rest, 3, "circle needs: circle <cx> <cy> <r>")
+	case "ellipse":
+		el.Nums, el.Attrs, err = p.numsAndAttrs(rest, 4, "ellipse needs: ellipse <cx> <cy> <rx> <ry>")
+	case "line":
+		el.Nums, el.Attrs, err = p.numsAndAttrs(rest, 4, "line needs: line <x1> <y1> <x2> <y2>")
+	case "polyline", "polygon":
+		el.Points, el.Attrs, err = p.pointsAndAttrs(rest, kind)
+	case "path":
+		var attrs map[string]string
+		var dParts []string
+		split := len(rest)
+		for i, t := range rest {
+			if strings.Contains(t, "=") {
+				split = i
+				break
+			}
+			dParts = append(dParts, t)
+		}
+		attrs, err = p.attrs(rest[split:])
+		el.D, el.Attrs = strings.Join(dParts, " "), attrs
+		if err == nil && el.D == "" {
+			err = p.errf("path needs path data (e.g. path M0,0 L10,10 Z)")
+		}
+		if err == nil {
+			if _, ferr := flattenPath(el.D); ferr != nil {
+				err = p.errf("bad path data: %v", ferr)
+			}
+		}
+	case "text":
+		if len(rest) < 3 {
+			return nil, p.errf(`text needs: text <x> <y> "string" [attrs]`)
+		}
+		var nums []float64
+		nums, err = p.nums(rest[:2], 2, "text needs numeric x y")
+		if err != nil {
+			return nil, err
+		}
+		el.Nums = nums
+		el.Text = rest[2]
+		el.Attrs, err = p.attrs(rest[3:])
+	default:
+		return nil, p.errf("unknown element %q (rect, circle, ellipse, line, polyline, polygon, path, text, group, def, bg, canvas)", kind)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return el, nil
+}
+
+func (p *parser) numsAndAttrs(tokens []string, n int, hint string) ([]float64, map[string]string, error) {
+	if len(tokens) < n {
+		return nil, nil, p.errf("%s", hint)
+	}
+	nums, err := p.nums(tokens[:n], n, hint)
+	if err != nil {
+		return nil, nil, err
+	}
+	attrs, err := p.attrs(tokens[n:])
+	return nums, attrs, err
+}
+
+func (p *parser) nums(tokens []string, n int, hint string) ([]float64, error) {
+	if len(tokens) != n {
+		return nil, p.errf("%s", hint)
+	}
+	out := make([]float64, n)
+	for i, t := range tokens {
+		v, err := strconv.ParseFloat(t, 64)
+		if err != nil {
+			return nil, p.errf("%q is not a number — %s", t, hint)
+		}
+		out[i] = v
+	}
+	return out, nil
+}
+
+func (p *parser) pointsAndAttrs(tokens []string, kind string) ([][2]float64, map[string]string, error) {
+	var pts [][2]float64
+	i := 0
+	for ; i < len(tokens); i++ {
+		t := tokens[i]
+		if strings.Contains(t, "=") {
+			break
+		}
+		xy := strings.Split(t, ",")
+		if len(xy) != 2 {
+			return nil, nil, p.errf("%s point %q must be x,y", kind, t)
+		}
+		x, err1 := strconv.ParseFloat(xy[0], 64)
+		y, err2 := strconv.ParseFloat(xy[1], 64)
+		if err1 != nil || err2 != nil {
+			return nil, nil, p.errf("%s point %q must be numeric x,y", kind, t)
+		}
+		pts = append(pts, [2]float64{x, y})
+	}
+	min := 2
+	if kind == "polygon" {
+		min = 3
+	}
+	if len(pts) < min {
+		return nil, nil, p.errf("%s needs at least %d x,y points", kind, min)
+	}
+	attrs, err := p.attrs(tokens[i:])
+	return pts, attrs, err
+}
+
+func (p *parser) attrs(tokens []string) (map[string]string, error) {
+	out := map[string]string{}
+	for _, t := range tokens {
+		if kv, ok := flagAttrs[t]; ok {
+			out[kv[0]] = kv[1]
+			continue
+		}
+		eq := strings.Index(t, "=")
+		if eq <= 0 {
+			return nil, p.errf("expected attribute key=value, got %q", t)
+		}
+		key, val := t[:eq], t[eq+1:]
+		svgKey, ok := attrKeys[key]
+		if !ok {
+			return nil, p.errf("unknown attribute %q", key)
+		}
+		if val == "" {
+			return nil, p.errf("attribute %s has empty value", key)
+		}
+		if key == "fill" || key == "stroke" {
+			c, err := p.color(val)
+			if err != nil {
+				return nil, err
+			}
+			val = c
+		}
+		if key == "transform" {
+			// commas keep the value one token: rotate(45,50,50)
+			val = strings.ReplaceAll(val, ",", " ")
+		}
+		out[svgKey] = val
+	}
+	return out, nil
+}
+
+// color resolves $vars and validates the value.
+func (p *parser) color(v string) (string, error) {
+	if strings.HasPrefix(v, "$") {
+		c, ok := p.defs[v[1:]]
+		if !ok {
+			return "", p.errf("undefined color variable %s (define it first: def %s #rrggbb)", v, v[1:])
+		}
+		return c, nil
+	}
+	if v == "none" || v == "transparent" {
+		return v, nil
+	}
+	if strings.HasPrefix(v, "#") {
+		hexPart := v[1:]
+		if len(hexPart) != 3 && len(hexPart) != 6 {
+			return "", p.errf("color %q must be #rgb or #rrggbb", v)
+		}
+		for _, r := range hexPart {
+			if !strings.ContainsRune("0123456789abcdefABCDEF", r) {
+				return "", p.errf("color %q has non-hex digits", v)
+			}
+		}
+		return v, nil
+	}
+	for _, r := range v {
+		if (r < 'a' || r > 'z') && (r < 'A' || r > 'Z') {
+			return "", p.errf("color %q must be #hex, a CSS color name, none or $var", v)
+		}
+	}
+	return v, nil // CSS named color — trust the renderer
+}
+
+func (p *parser) errf(format string, args ...interface{}) error {
+	return fmt.Errorf("line %d: %s", p.line, fmt.Sprintf(format, args...))
+}
+
+// tokenize splits a line on whitespace, keeping "quoted strings" as
+// single tokens (quotes stripped).
+func tokenize(line string) ([]string, error) {
+	var out []string
+	var cur strings.Builder
+	inQuote := false
+	for _, r := range line {
+		switch {
+		case r == '"':
+			if inQuote {
+				out = append(out, cur.String())
+				cur.Reset()
+				inQuote = false
+			} else {
+				inQuote = true
+			}
+		case !inQuote && (r == ' ' || r == '\t'):
+			if cur.Len() > 0 {
+				out = append(out, cur.String())
+				cur.Reset()
+			}
+		default:
+			cur.WriteRune(r)
+		}
+	}
+	if inQuote {
+		return nil, fmt.Errorf("unterminated quote")
+	}
+	if cur.Len() > 0 {
+		out = append(out, cur.String())
+	}
+	if len(out) == 0 {
+		return nil, fmt.Errorf("empty line")
+	}
+	return out, nil
+}
+
+// findComment returns the index of a # starting a comment (not inside
+// quotes, and not part of a color like #fff).
+func findComment(line string) int {
+	inQuote := false
+	for i, r := range line {
+		if r == '"' {
+			inQuote = !inQuote
+		}
+		if r == '#' && !inQuote {
+			// a color literal follows =, whitespace-then-hex is a comment
+			if i == 0 {
+				return 0
+			}
+			prev := line[i-1]
+			if prev == ' ' || prev == '\t' {
+				// "... # comment" vs "def accent #fff": colors only appear
+				// after def/bg or key=; a bare hex after a def/bg keyword is
+				// data, so only treat as comment if it is not valid hex-ish
+				rest := line[i+1:]
+				stop := strings.IndexAny(rest, " \t")
+				word := rest
+				if stop >= 0 {
+					word = rest[:stop]
+				}
+				if isHexWord(word) {
+					continue
+				}
+				return i
+			}
+		}
+	}
+	return -1
+}
+
+func isHexWord(w string) bool {
+	if len(w) != 3 && len(w) != 6 {
+		return false
+	}
+	for _, r := range w {
+		if !strings.ContainsRune("0123456789abcdefABCDEF", r) {
+			return false
+		}
+	}
+	return true
+}

svg-maker/svg/path.go

@@ -0,0 +1,195 @@
+package svg
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// flattenPath turns a path-data subset (M L H V C Q Z, absolute and
+// relative) into one or more polylines, used for validation, preview
+// rasterization and measurements. Curves become 16 line segments.
+func flattenPath(d string) ([][][2]float64, error) {
+	tokens, err := pathTokens(d)
+	if err != nil {
+		return nil, err
+	}
+	var subpaths [][][2]float64
+	var cur [][2]float64
+	var x, y, startX, startY float64
+	i := 0
+	cmd := ""
+
+	need := func(n int) ([]float64, error) {
+		if i+n > len(tokens) {
+			return nil, fmt.Errorf("command %s needs %d numbers", cmd, n)
+		}
+		out := make([]float64, n)
+		for j := 0; j < n; j++ {
+			v, err := strconv.ParseFloat(tokens[i+j], 64)
+			if err != nil {
+				return nil, fmt.Errorf("command %s: %q is not a number", cmd, tokens[i+j])
+			}
+			out[j] = v
+		}
+		i += n
+		return out, nil
+	}
+	flush := func() {
+		if len(cur) > 1 {
+			subpaths = append(subpaths, cur)
+		}
+		cur = nil
+	}
+
+	for i < len(tokens) {
+		t := tokens[i]
+		if len(t) == 1 && strings.ContainsAny(t, "MLHVCQZmlhvcqz") {
+			cmd = t
+			i++
+			if cmd == "Z" || cmd == "z" {
+				if len(cur) > 0 {
+					cur = append(cur, [2]float64{startX, startY})
+					x, y = startX, startY
+				}
+				flush()
+				continue
+			}
+		} else if cmd == "" {
+			return nil, fmt.Errorf("path must start with M/m, got %q", t)
+		}
+		// repeated coordinate groups reuse the current command
+		rel := cmd >= "a" // lowercase = relative
+		switch strings.ToUpper(cmd) {
+		case "M":
+			n, err := need(2)
+			if err != nil {
+				return nil, err
+			}
+			if rel {
+				n[0] += x
+				n[1] += y
+			}
+			flush()
+			x, y = n[0], n[1]
+			startX, startY = x, y
+			cur = [][2]float64{{x, y}}
+			cmd = map[bool]string{true: "l", false: "L"}[rel] // subsequent pairs are implicit lineto
+		case "L":
+			n, err := need(2)
+			if err != nil {
+				return nil, err
+			}
+			if rel {
+				n[0] += x
+				n[1] += y
+			}
+			x, y = n[0], n[1]
+			cur = append(cur, [2]float64{x, y})
+		case "H":
+			n, err := need(1)
+			if err != nil {
+				return nil, err
+			}
+			if rel {
+				n[0] += x
+			}
+			x = n[0]
+			cur = append(cur, [2]float64{x, y})
+		case "V":
+			n, err := need(1)
+			if err != nil {
+				return nil, err
+			}
+			if rel {
+				n[0] += y
+			}
+			y = n[0]
+			cur = append(cur, [2]float64{x, y})
+		case "Q":
+			n, err := need(4)
+			if err != nil {
+				return nil, err
+			}
+			if rel {
+				n[0] += x
+				n[1] += y
+				n[2] += x
+				n[3] += y
+			}
+			for s := 1; s <= 16; s++ {
+				t := float64(s) / 16
+				u := 1 - t
+				px := u*u*x + 2*u*t*n[0] + t*t*n[2]
+				py := u*u*y + 2*u*t*n[1] + t*t*n[3]
+				cur = append(cur, [2]float64{px, py})
+			}
+			x, y = n[2], n[3]
+		case "C":
+			n, err := need(6)
+			if err != nil {
+				return nil, err
+			}
+			if rel {
+				n[0] += x
+				n[1] += y
+				n[2] += x
+				n[3] += y
+				n[4] += x
+				n[5] += y
+			}
+			for s := 1; s <= 16; s++ {
+				t := float64(s) / 16
+				u := 1 - t
+				px := u*u*u*x + 3*u*u*t*n[0] + 3*u*t*t*n[2] + t*t*t*n[4]
+				py := u*u*u*y + 3*u*u*t*n[1] + 3*u*t*t*n[3] + t*t*t*n[5]
+				cur = append(cur, [2]float64{px, py})
+			}
+			x, y = n[4], n[5]
+		default:
+			return nil, fmt.Errorf("unsupported path command %q (supported: M L H V C Q Z)", cmd)
+		}
+	}
+	flush()
+	if len(subpaths) == 0 {
+		return nil, fmt.Errorf("path draws nothing")
+	}
+	return subpaths, nil
+}
+
+// pathTokens splits path data into command letters and numbers.
+func pathTokens(d string) ([]string, error) {
+	var out []string
+	var cur strings.Builder
+	flush := func() {
+		if cur.Len() > 0 {
+			out = append(out, cur.String())
+			cur.Reset()
+		}
+	}
+	for _, r := range d {
+		switch {
+		case r == ' ' || r == '\t' || r == ',':
+			flush()
+		case (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z'):
+			flush()
+			out = append(out, string(r))
+		case (r >= '0' && r <= '9') || r == '.' || r == 'e' || r == 'E':
+			cur.WriteRune(r)
+		case r == '-' || r == '+':
+			// sign starts a new number unless it follows an exponent
+			s := cur.String()
+			if cur.Len() > 0 && !strings.HasSuffix(s, "e") && !strings.HasSuffix(s, "E") {
+				flush()
+			}
+			cur.WriteRune(r)
+		default:
+			return nil, fmt.Errorf("unexpected character %q in path data", r)
+		}
+	}
+	flush()
+	if len(out) == 0 {
+		return nil, fmt.Errorf("empty path data")
+	}
+	return out, nil
+}

svg-maker/svg/raster.go

@@ -0,0 +1,332 @@
+package svg
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+)
+
+// Raster renders the document to a small RGBA grid so an agent can see
+// roughly what it drew without an image viewer. Painter's algorithm in
+// document order, 2x2 supersampling, honors fill/stroke/opacity.
+// Text is approximated by its baseline and an underline-box (real
+// glyph rendering is out of scope for a preview).
+type Raster struct {
+	W, H int
+	Pix  [][4]float64 // r g b a, premultiplied-ish blend target
+}
+
+type rgba struct{ r, g, b, a float64 }
+
+// RenderGrid rasterizes doc to cols pixels wide (rows follow aspect).
+func RenderGrid(d *Doc, cols int) *Raster {
+	if cols < 8 {
+		cols = 8
+	}
+	if cols > 400 {
+		cols = 400
+	}
+	rows := int(math.Round(float64(cols) * d.H / d.W))
+	if rows < 1 {
+		rows = 1
+	}
+	if rows > 400 {
+		rows = 400
+	}
+	r := &Raster{W: cols, H: rows, Pix: make([][4]float64, cols*rows)}
+	bg := parseColor(d.Bg)
+	if d.Bg == "" {
+		bg = rgba{0, 0, 0, 0}
+	}
+	for i := range r.Pix {
+		r.Pix[i] = [4]float64{bg.r, bg.g, bg.b, bg.a}
+	}
+	scaleX := d.W / float64(cols)
+	scaleY := d.H / float64(rows)
+
+	var walk func(els []*Elem, inherited map[string]string)
+	walk = func(els []*Elem, inherited map[string]string) {
+		for _, el := range els {
+			attrs := merged(inherited, el.Attrs)
+			if el.Kind == "group" {
+				walk(el.Kids, attrs)
+				continue
+			}
+			r.drawElem(el, attrs, scaleX, scaleY)
+		}
+	}
+	walk(d.Elems, nil)
+	return r
+}
+
+func merged(parent, child map[string]string) map[string]string {
+	if parent == nil {
+		return child
+	}
+	out := map[string]string{}
+	for k, v := range parent {
+		out[k] = v
+	}
+	for k, v := range child {
+		out[k] = v
+	}
+	return out
+}
+
+func (r *Raster) drawElem(el *Elem, attrs map[string]string, sx, sy float64) {
+	fill, hasFill := paint(attrs, "fill", el.Kind)
+	stroke, hasStroke := paint(attrs, "stroke", el.Kind)
+	sw := attrFloat(attrs, "stroke-width", 1)
+	opacity := attrFloat(attrs, "opacity", 1)
+
+	inFill, inStroke := coverageFuncs(el, sw, attrs)
+	if inFill == nil && inStroke == nil {
+		return
+	}
+	for py := 0; py < r.H; py++ {
+		for px := 0; px < r.W; px++ {
+			var fillCov, strokeCov float64
+			for _, dx := range []float64{0.25, 0.75} {
+				for _, dy := range []float64{0.25, 0.75} {
+					ux := (float64(px) + dx) * sx
+					uy := (float64(py) + dy) * sy
+					if hasFill && inFill != nil && inFill(ux, uy) {
+						fillCov += 0.25
+					}
+					if hasStroke && inStroke != nil && inStroke(ux, uy) {
+						strokeCov += 0.25
+					}
+				}
+			}
+			if fillCov > 0 {
+				r.blend(px, py, fill, fillCov*opacity*attrFloat(attrs, "fill-opacity", 1))
+			}
+			if strokeCov > 0 {
+				r.blend(px, py, stroke, strokeCov*opacity*attrFloat(attrs, "stroke-opacity", 1))
+			}
+		}
+	}
+}
+
+// coverageFuncs returns point-inside tests for the fill body and the
+// stroke band of an element, in user coordinates.
+func coverageFuncs(el *Elem, sw float64, attrs map[string]string) (inFill, inStroke func(x, y float64) bool) {
+	half := sw / 2
+	switch el.Kind {
+	case "rect":
+		x0, y0, w, h := el.Nums[0], el.Nums[1], el.Nums[2], el.Nums[3]
+		inFill = func(x, y float64) bool { return x >= x0 && x <= x0+w && y >= y0 && y <= y0+h }
+		inStroke = func(x, y float64) bool {
+			near := func(v, edge float64) bool { return math.Abs(v-edge) <= half }
+			inX := x >= x0-half && x <= x0+w+half
+			inY := y >= y0-half && y <= y0+h+half
+			return (inX && (near(y, y0) || near(y, y0+h))) || (inY && (near(x, x0) || near(x, x0+w)))
+		}
+	case "circle":
+		cx, cy, rad := el.Nums[0], el.Nums[1], el.Nums[2]
+		inFill = func(x, y float64) bool { return math.Hypot(x-cx, y-cy) <= rad }
+		inStroke = func(x, y float64) bool { return math.Abs(math.Hypot(x-cx, y-cy)-rad) <= half }
+	case "ellipse":
+		cx, cy, rx, ry := el.Nums[0], el.Nums[1], el.Nums[2], el.Nums[3]
+		if rx <= 0 || ry <= 0 {
+			return nil, nil
+		}
+		norm := func(x, y float64) float64 {
+			dx, dy := (x-cx)/rx, (y-cy)/ry
+			return math.Sqrt(dx*dx + dy*dy)
+		}
+		inFill = func(x, y float64) bool { return norm(x, y) <= 1 }
+		inStroke = func(x, y float64) bool {
+			// approximate band by comparing scaled radial distance
+			n := norm(x, y)
+			tol := half / math.Min(rx, ry)
+			return math.Abs(n-1) <= tol
+		}
+	case "line":
+		seg := [2][2]float64{{el.Nums[0], el.Nums[1]}, {el.Nums[2], el.Nums[3]}}
+		inStroke = func(x, y float64) bool { return distSeg(x, y, seg[0], seg[1]) <= math.Max(half, 0.5) }
+	case "polyline", "polygon":
+		pts := el.Points
+		inStroke = func(x, y float64) bool {
+			last := len(pts) - 1
+			for i := 0; i < last; i++ {
+				if distSeg(x, y, pts[i], pts[i+1]) <= math.Max(half, 0.5) {
+					return true
+				}
+			}
+			if el.Kind == "polygon" && distSeg(x, y, pts[last], pts[0]) <= math.Max(half, 0.5) {
+				return true
+			}
+			return false
+		}
+		if el.Kind == "polygon" {
+			inFill = func(x, y float64) bool { return pointInPolygon(x, y, pts) }
+		}
+	case "path":
+		subs, err := flattenPath(el.D)
+		if err != nil {
+			return nil, nil
+		}
+		inStroke = func(x, y float64) bool {
+			for _, sp := range subs {
+				for i := 0; i < len(sp)-1; i++ {
+					if distSeg(x, y, sp[i], sp[i+1]) <= math.Max(half, 0.5) {
+						return true
+					}
+				}
+			}
+			return false
+		}
+		inFill = func(x, y float64) bool {
+			in := false
+			for _, sp := range subs {
+				if pointInPolygon(x, y, sp) {
+					in = !in
+				}
+			}
+			return in
+		}
+	case "text":
+		// baseline box: width ~0.6em per char, height 1em above the
+		// baseline, honoring text-anchor — real glyphs are out of scope
+		size := attrFloat(attrs, "font-size", 16)
+		x0, y0 := el.Nums[0], el.Nums[1]
+		w := 0.6 * size * float64(len([]rune(el.Text)))
+		switch attrs["text-anchor"] {
+		case "middle":
+			x0 -= w / 2
+		case "end":
+			x0 -= w
+		}
+		edge := math.Max(size/12, 0.75)
+		inFill = func(x, y float64) bool {
+			return x >= x0 && x <= x0+w && y >= y0-size && y <= y0 &&
+				(y >= y0-edge || y <= y0-size+edge || x <= x0+edge || x >= x0+w-edge)
+		}
+	}
+	return inFill, inStroke
+}
+
+func paint(attrs map[string]string, key, kind string) (rgba, bool) {
+	v := attrs[key]
+	if v == "" {
+		if key == "fill" && kind != "line" && kind != "polyline" && kind != "path" {
+			return rgba{0, 0, 0, 1}, true // SVG default fill is black
+		}
+		return rgba{}, false
+	}
+	if v == "none" || v == "transparent" {
+		return rgba{}, false
+	}
+	return parseColor(v), true
+}
+
+func attrFloat(attrs map[string]string, key string, def float64) float64 {
+	if v, ok := attrs[key]; ok {
+		if f, err := strconv.ParseFloat(v, 64); err == nil {
+			return f
+		}
+	}
+	return def
+}
+
+func (r *Raster) blend(x, y int, c rgba, a float64) {
+	if a <= 0 {
+		return
+	}
+	if a > 1 {
+		a = 1
+	}
+	i := y*r.W + x
+	p := r.Pix[i]
+	p[0] = c.r*a + p[0]*(1-a)
+	p[1] = c.g*a + p[1]*(1-a)
+	p[2] = c.b*a + p[2]*(1-a)
+	p[3] = math.Max(p[3], a)
+	r.Pix[i] = p
+}
+
+func distSeg(x, y float64, a, b [2]float64) float64 {
+	dx, dy := b[0]-a[0], b[1]-a[1]
+	l2 := dx*dx + dy*dy
+	if l2 == 0 {
+		return math.Hypot(x-a[0], y-a[1])
+	}
+	t := ((x-a[0])*dx + (y-a[1])*dy) / l2
+	t = math.Max(0, math.Min(1, t))
+	return math.Hypot(x-(a[0]+t*dx), y-(a[1]+t*dy))
+}
+
+func pointInPolygon(x, y float64, pts [][2]float64) bool {
+	in := false
+	n := len(pts)
+	for i, j := 0, n-1; i < n; j, i = i, i+1 {
+		xi, yi := pts[i][0], pts[i][1]
+		xj, yj := pts[j][0], pts[j][1]
+		if (yi > y) != (yj > y) && x < (xj-xi)*(y-yi)/(yj-yi)+xi {
+			in = !in
+		}
+	}
+	return in
+}
+
+// parseColor handles #rgb/#rrggbb plus the CSS names agents actually
+// use; unknown names render mid-gray rather than failing the preview.
+func parseColor(s string) rgba {
+	s = strings.TrimSpace(strings.ToLower(s))
+	if strings.HasPrefix(s, "#") {
+		h := s[1:]
+		if len(h) == 3 {
+			h = string([]byte{h[0], h[0], h[1], h[1], h[2], h[2]})
+		}
+		if len(h) == 6 {
+			r, err1 := strconv.ParseUint(h[0:2], 16, 8)
+			g, err2 := strconv.ParseUint(h[2:4], 16, 8)
+			b, err3 := strconv.ParseUint(h[4:6], 16, 8)
+			if err1 == nil && err2 == nil && err3 == nil {
+				return rgba{float64(r), float64(g), float64(b), 1}
+			}
+		}
+	}
+	if c, ok := cssColors[s]; ok {
+		return c
+	}
+	return rgba{128, 128, 128, 1}
+}
+
+var cssColors = map[string]rgba{
+	"black": {0, 0, 0, 1}, "white": {255, 255, 255, 1}, "red": {255, 0, 0, 1},
+	"green": {0, 128, 0, 1}, "lime": {0, 255, 0, 1}, "blue": {0, 0, 255, 1},
+	"yellow": {255, 255, 0, 1}, "orange": {255, 165, 0, 1}, "purple": {128, 0, 128, 1},
+	"gray": {128, 128, 128, 1}, "grey": {128, 128, 128, 1}, "silver": {192, 192, 192, 1},
+	"cyan": {0, 255, 255, 1}, "magenta": {255, 0, 255, 1}, "pink": {255, 192, 203, 1},
+	"brown": {165, 42, 42, 1}, "navy": {0, 0, 128, 1}, "teal": {0, 128, 128, 1},
+	"olive": {128, 128, 0, 1}, "maroon": {128, 0, 0, 1}, "aqua": {0, 255, 255, 1},
+	"fuchsia": {255, 0, 255, 1}, "gold": {255, 215, 0, 1},
+}
+
+// ANSI renders the raster with truecolor half-blocks, two pixel rows
+// per text row — same technique as spritec's preview.
+func (r *Raster) ANSI() string {
+	const reset = "\x1b[0m"
+	var b strings.Builder
+	for y := 0; y < r.H; y += 2 {
+		for x := 0; x < r.W; x++ {
+			top := r.Pix[y*r.W+x]
+			var bot [4]float64
+			if y+1 < r.H {
+				bot = r.Pix[(y+1)*r.W+x]
+			}
+			if top[3] == 0 && bot[3] == 0 {
+				b.WriteString(" ")
+				continue
+			}
+			fmt.Fprintf(&b, "\x1b[38;2;%d;%d;%dm\x1b[48;2;%d;%d;%dm▀%s",
+				int(top[0]), int(top[1]), int(top[2]),
+				int(bot[0]), int(bot[1]), int(bot[2]), reset)
+		}
+		b.WriteString("\n")
+	}
+	return b.String()
+}

svg-maker/svg/svg_test.go

@@ -0,0 +1,201 @@
+package svg
+
+import (
+	"strings"
+	"testing"
+)
+
+const sample = `# test scene
+canvas 100 80
+bg #112233
+def accent #4f9cf9
+rect 10 10 30 20 fill=$accent rx=3
+circle 70 30 15 fill=#3fca7c stroke=white stroke-width=2
+line 0 70 100 70 stroke=red width=3
+polygon 10,60 30,40 50,60 fill=#e0a63f
+path M60,60 L80,70 L90,50 Z stroke=white
+text 50 25 "hi & <you>" size=10 fill=white anchor=middle
+group stroke=gray
+  line 5 5 15 15
+end
+`
+
+func TestParseAndEmit(t *testing.T) {
+	xml, doc, err := Build(sample)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if doc.W != 100 || doc.H != 80 || doc.Bg != "#112233" {
+		t.Errorf("canvas/bg wrong: %+v", doc)
+	}
+	for _, want := range []string{
+		`viewBox="0 0 100 80"`,
+		`<rect x="10" y="10" width="30" height="20"`,
+		`fill="#4f9cf9"`, // $accent resolved
+		`rx="3"`,
+		`<circle cx="70" cy="30" r="15"`,
+		`stroke-width="3"`, // width alias
+		`<polygon points="10,60 30,40 50,60"`,
+		`<path d="M60,60 L80,70 L90,50 Z"`,
+		`hi &amp; &lt;you&gt;`, // escaped text
+		`text-anchor="middle"`,
+		`font-size="10"`,
+		`<g stroke="gray">`,
+	} {
+		if !strings.Contains(xml, want) {
+			t.Errorf("emitted SVG missing %q\n%s", want, xml)
+		}
+	}
+}
+
+func TestParseErrorsCarryLineNumbers(t *testing.T) {
+	cases := map[string]string{
+		"canvas 100 100\nrect 1 2 3":                 "line 2",
+		"canvas 100 100\nrect 1 2 3 four":            "not a number",
+		"canvas 100 100\ncircle 1 2 3 glow=yes":      "unknown attribute",
+		"canvas 100 100\nrect 1 2 3 4 fill=$missing": "undefined color variable",
+		"canvas 100 100\nblob 1 2":                   "unknown element",
+		"canvas 100 100\ngroup\nline 1 2 3 4":        "never closed",
+		"canvas 100 100\nend":                        "end without group",
+		"canvas 100 100\npath X10,10":                "path",
+		"canvas 100 100\nrect 1 2 3 4 fill=#zzz":     "non-hex",
+		"rect 1 2 3 4":                               "missing canvas",
+	}
+	for src, want := range cases {
+		_, _, err := Build(src)
+		if err == nil {
+			t.Errorf("no error for %q", src)
+			continue
+		}
+		if !strings.Contains(err.Error(), want) {
+			t.Errorf("error for %q = %q, want substring %q", src, err, want)
+		}
+	}
+}
+
+func TestVisibilityDefaults(t *testing.T) {
+	xml, _, err := Build("canvas 10 10\nline 0 0 10 10\npolyline 0,0 5,5 10,0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(xml, `<line x1="0" y1="0" x2="10" y2="10" stroke="black"/>`) {
+		t.Errorf("line did not get default stroke:\n%s", xml)
+	}
+	if !strings.Contains(xml, `fill="none"`) {
+		t.Errorf("polyline did not get fill=none:\n%s", xml)
+	}
+}
+
+func TestFlattenPath(t *testing.T) {
+	subs, err := flattenPath("M0,0 L10,0 V10 H0 Z")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(subs) != 1 {
+		t.Fatalf("want 1 subpath, got %d", len(subs))
+	}
+	pts := subs[0]
+	last := pts[len(pts)-1]
+	if last[0] != 0 || last[1] != 0 {
+		t.Errorf("Z should close back to start, ended at %v", last)
+	}
+	// curves flatten into many segments
+	subs, err = flattenPath("M0,0 Q50,100 100,0")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(subs[0]) < 10 {
+		t.Errorf("quadratic should flatten to many points, got %d", len(subs[0]))
+	}
+	// relative commands
+	subs, err = flattenPath("m10,10 l10,0 l0,10 z")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := subs[0][2]; got[0] != 20 || got[1] != 20 {
+		t.Errorf("relative path point = %v, want 20,20", got)
+	}
+	if _, err := flattenPath("L10,10"); err == nil {
+		t.Error("path not starting with M should fail")
+	}
+	if _, err := flattenPath("M0,0 A5,5 0 0 1 10,10"); err == nil {
+		t.Error("unsupported arc command should fail")
+	}
+}
+
+func TestRasterShapes(t *testing.T) {
+	doc, err := Parse("canvas 100 100\nbg black\ncircle 50 50 30 fill=red")
+	if err != nil {
+		t.Fatal(err)
+	}
+	doc.normalize()
+	r := RenderGrid(doc, 50)
+	if r.W != 50 || r.H != 50 {
+		t.Fatalf("grid %dx%d, want 50x50", r.W, r.H)
+	}
+	center := r.Pix[25*r.W+25]
+	if center[0] < 200 || center[1] > 50 {
+		t.Errorf("center should be red, got %v", center)
+	}
+	corner := r.Pix[0]
+	if corner[0] > 50 && corner[1] > 50 && corner[2] > 50 {
+		t.Errorf("corner should be black, got %v", corner)
+	}
+}
+
+func TestRasterPolygonFill(t *testing.T) {
+	doc, err := Parse("canvas 100 100\npolygon 0,0 100,0 100,100 0,100 fill=#00ff00")
+	if err != nil {
+		t.Fatal(err)
+	}
+	doc.normalize()
+	r := RenderGrid(doc, 20)
+	mid := r.Pix[10*r.W+10]
+	if mid[1] < 200 {
+		t.Errorf("polygon interior not filled: %v", mid)
+	}
+}
+
+func TestANSIPreviewShape(t *testing.T) {
+	doc, _ := Parse("canvas 40 20\nbg #000000\nrect 0 0 40 20 fill=white")
+	doc.normalize()
+	out := RenderGrid(doc, 40).ANSI()
+	lines := strings.Split(strings.TrimRight(out, "\n"), "\n")
+	if len(lines) != 10 { // 20 pixel rows / 2 per text row
+		t.Errorf("ANSI preview has %d rows, want 10", len(lines))
+	}
+	if !strings.Contains(out, "▀") {
+		t.Error("preview contains no half-block characters")
+	}
+}
+
+func TestInfoWarnsOutsideCanvas(t *testing.T) {
+	doc, err := Parse("canvas 50 50\ncircle 25 25 10 fill=red\nrect 100 100 20 20 fill=blue\nline 40 40 60 60")
+	if err != nil {
+		t.Fatal(err)
+	}
+	doc.normalize()
+	info := Info(doc)
+	for _, want := range []string{
+		"canvas: 50x50",
+		"circle:1",
+		"entirely outside",
+		"sticks outside",
+	} {
+		if !strings.Contains(info, want) {
+			t.Errorf("info missing %q:\n%s", want, info)
+		}
+	}
+}
+
+func TestGroupAttrInheritanceInRaster(t *testing.T) {
+	doc, err := Parse("canvas 10 10\ngroup fill=#ff0000\nrect 0 0 10 10\nend")
+	if err != nil {
+		t.Fatal(err)
+	}
+	doc.normalize()
+	r := RenderGrid(doc, 10)
+	if p := r.Pix[5*r.W+5]; p[0] < 200 {
+		t.Errorf("group fill not inherited: %v", p)
+	}
+}

waitfor/README.md

@@ -0,0 +1,44 @@
+# waitfor — block until a condition holds
+
+Replaces the hand-rolled `while ! curl …; do sleep 5; done` loops that
+each need a fresh approval in an agent session with **one stable
+command prefix**. The agent makes one blocking call instead of burning
+turns polling. Closes the `Monitor` gap from
+[`doc/tool-parity.md`](../doc/tool-parity.md) §3.2.
+
+## Usage
+
+```
+waitfor --cmd "shell command" [--matches regex] [--interval 30s]
+        [--timeout 20m] [--then "shell command"] [--verbose]
+```
+
+The condition holds when `--cmd` exits 0 **and**, if `--matches` is
+given, its combined output matches the regex. The first attempt runs
+immediately; then every `--interval` until `--timeout`.
+
+| Exit | Meaning |
+|------|---------|
+| 0 | condition met (`--then` runs afterwards, if given) |
+| 3 | timeout — last output still printed so the caller sees the state |
+| 1 | usage/config error (empty `--cmd`, bad regex) |
+
+Examples:
+
+```bash
+# wait until Gitea answers again
+waitfor --cmd "curl -sf https://gitea.brasse-pc.eu/api/healthz" --interval 30s --timeout 20m
+
+# wait until a container is listed (read-only Pi5 wrapper)
+waitfor --cmd "ssh pi5-claude sudo claude-docker ps" --matches gitea --timeout 10m
+
+# wait for a file, then notify the phone (composes with notifyr)
+waitfor --cmd "test -f /tmp/report.html" --then 'notifyr send --msg "report is ready"'
+```
+
+## Build & test
+
+```bash
+go test ./...
+go build -o build/waitfor .
+```

waitfor/go.mod

@@ -0,0 +1,3 @@
+module gitea.brasse-pc.eu/brasse/agent-tools/waitfor
+
+go 1.24

waitfor/main.go

@@ -0,0 +1,86 @@
+// waitfor blocks until a shell condition holds — the agent-friendly
+// replacement for hand-rolled poll loops that each need a fresh
+// command approval. See doc/tool-parity.md §3.2.
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+
+	"gitea.brasse-pc.eu/brasse/agent-tools/waitfor/wait"
+)
+
+var version = "dev"
+
+const usage = `waitfor - block until a condition holds
+
+Usage:
+  waitfor --cmd "shell command" [--matches regex] [--interval 30s]
+          [--timeout 20m] [--then "shell command"] [--verbose]
+  waitfor version
+
+The condition holds when --cmd exits 0 and (if given) its combined
+output matches --matches. The first attempt runs immediately.
+
+Exit codes: 0 condition met, 3 timeout, 1 error. The last command
+output is printed either way, so the caller always sees the state.
+
+Examples:
+  waitfor --cmd "curl -sf https://gitea.brasse-pc.eu/api/healthz" --interval 30s --timeout 20m
+  waitfor --cmd "ssh pi5-claude sudo claude-docker ps" --matches gitea --timeout 10m
+  waitfor --cmd "test -f /tmp/done" --then 'notifyr send --msg "done!"'
+`
+
+func main() {
+	if len(os.Args) >= 2 && (os.Args[1] == "version" || os.Args[1] == "--version" || os.Args[1] == "-v") {
+		fmt.Println("waitfor", version)
+		return
+	}
+	if len(os.Args) >= 2 && (os.Args[1] == "help" || os.Args[1] == "--help" || os.Args[1] == "-h") {
+		fmt.Print(usage)
+		return
+	}
+	fs := flag.NewFlagSet("waitfor", flag.ExitOnError)
+	cmd := fs.String("cmd", "", "shell command to poll (required)")
+	matches := fs.String("matches", "", "regex the output must match")
+	interval := fs.Duration("interval", 10*time.Second, "time between attempts")
+	timeout := fs.Duration("timeout", 10*time.Minute, "total time budget")
+	then := fs.String("then", "", "shell command to run when the condition is met")
+	verbose := fs.Bool("verbose", false, "log every attempt to stderr")
+	fs.Usage = func() { fmt.Fprint(os.Stderr, usage) }
+	fs.Parse(os.Args[1:])
+	if *cmd == "" {
+		fmt.Fprint(os.Stderr, usage)
+		os.Exit(1)
+	}
+
+	res, err := wait.Wait(wait.Options{
+		Cmd: *cmd, Matches: *matches, Interval: *interval, Timeout: *timeout, Verbose: *verbose,
+	}, wait.ShellRunner, func(s string) { fmt.Fprintln(os.Stderr, "waitfor: "+s) })
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "waitfor:", err)
+		os.Exit(1)
+	}
+
+	if out := strings.TrimRight(res.LastOut, "\n"); out != "" {
+		fmt.Println(out)
+	}
+	if !res.Met {
+		fmt.Fprintf(os.Stderr, "waitfor: timeout after %s (%d attempts, last exit %d)\n",
+			res.Elapsed.Round(time.Second), res.Attempts, res.LastExit)
+		os.Exit(3)
+	}
+	fmt.Fprintf(os.Stderr, "waitfor: condition met after %s (%d attempts)\n",
+		res.Elapsed.Round(time.Millisecond), res.Attempts)
+	if *then != "" {
+		t := exec.Command("sh", "-c", *then)
+		t.Stdout, t.Stderr = os.Stdout, os.Stderr
+		if err := t.Run(); err != nil {
+			fmt.Fprintf(os.Stderr, "waitfor: --then command failed: %v\n", err)
+		}
+	}
+}

waitfor/wait/wait.go

@@ -0,0 +1,94 @@
+// Package wait blocks until a shell condition holds: run a command
+// every interval until it exits 0 (and, optionally, its output matches
+// a regex) or a timeout expires. One blocking call instead of an
+// agent burning turns on poll loops.
+package wait
+
+import (
+	"fmt"
+	"os/exec"
+	"regexp"
+	"time"
+)
+
+type Options struct {
+	Cmd      string        // shell command to run each attempt (required)
+	Matches  string        // optional regex the output must match
+	Interval time.Duration // between attempts
+	Timeout  time.Duration // total budget
+	Verbose  bool          // progress line per attempt to the log func
+}
+
+type Result struct {
+	Met      bool
+	Attempts int
+	Elapsed  time.Duration
+	LastOut  string
+	LastExit int
+}
+
+// Runner executes a shell command, returning combined output and exit
+// code. Separated out so tests can fake it.
+type Runner func(cmd string) (string, int)
+
+// ShellRunner runs via sh -c with combined stdout+stderr.
+func ShellRunner(cmd string) (string, int) {
+	c := exec.Command("sh", "-c", cmd)
+	out, err := c.CombinedOutput()
+	code := 0
+	if err != nil {
+		code = 1
+		if ee, ok := err.(*exec.ExitError); ok {
+			code = ee.ExitCode()
+		}
+	}
+	return string(out), code
+}
+
+// Wait polls until the condition holds or the timeout expires. The
+// first attempt runs immediately. log receives progress lines when
+// Verbose is set (pass nil otherwise).
+func Wait(opts Options, run Runner, log func(string)) (Result, error) {
+	if opts.Cmd == "" {
+		return Result{}, fmt.Errorf("no command given")
+	}
+	var re *regexp.Regexp
+	if opts.Matches != "" {
+		var err error
+		re, err = regexp.Compile(opts.Matches)
+		if err != nil {
+			return Result{}, fmt.Errorf("bad --matches regex: %v", err)
+		}
+	}
+	if opts.Interval <= 0 {
+		opts.Interval = 10 * time.Second
+	}
+	if opts.Timeout <= 0 {
+		opts.Timeout = 10 * time.Minute
+	}
+	start := time.Now()
+	res := Result{}
+	for {
+		res.Attempts++
+		out, code := run(opts.Cmd)
+		res.LastOut, res.LastExit = out, code
+		met := code == 0 && (re == nil || re.MatchString(out))
+		if opts.Verbose && log != nil {
+			state := "not yet"
+			if met {
+				state = "met"
+			}
+			log(fmt.Sprintf("attempt %d: exit %d, condition %s", res.Attempts, code, state))
+		}
+		if met {
+			res.Met = true
+			res.Elapsed = time.Since(start)
+			return res, nil
+		}
+		if time.Since(start)+opts.Interval > opts.Timeout {
+			res.Elapsed = time.Since(start)
+			return res, nil
+		}
+		time.Sleep(opts.Interval)
+	}
+}

waitfor/wait/wait_test.go

@@ -0,0 +1,92 @@
+package wait
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestMetOnExitZero(t *testing.T) {
+	calls := 0
+	run := func(cmd string) (string, int) {
+		calls++
+		if calls < 3 {
+			return "not ready", 1
+		}
+		return "ready", 0
+	}
+	res, err := Wait(Options{Cmd: "x", Interval: time.Millisecond, Timeout: time.Second}, run, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res.Met || res.Attempts != 3 || res.LastOut != "ready" {
+		t.Errorf("unexpected result: %+v", res)
+	}
+}
+
+func TestMatchesRequiredOnTopOfExitZero(t *testing.T) {
+	calls := 0
+	run := func(cmd string) (string, int) {
+		calls++
+		if calls == 1 {
+			return "gitea starting", 0 // exit 0 but no match yet
+		}
+		return "gitea healthy", 0
+	}
+	res, err := Wait(Options{Cmd: "x", Matches: "healthy", Interval: time.Millisecond, Timeout: time.Second}, run, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res.Met || res.Attempts != 2 {
+		t.Errorf("match should gate success: %+v", res)
+	}
+}
+
+func TestTimeoutReportsLastOutput(t *testing.T) {
+	run := func(cmd string) (string, int) { return "still broken", 7 }
+	res, err := Wait(Options{Cmd: "x", Interval: 5 * time.Millisecond, Timeout: 20 * time.Millisecond}, run, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.Met {
+		t.Error("should have timed out")
+	}
+	if res.LastOut != "still broken" || res.LastExit != 7 {
+		t.Errorf("last output lost: %+v", res)
+	}
+	if res.Attempts < 1 {
+		t.Error("should have tried at least once")
+	}
+}
+
+func TestBadRegexRejected(t *testing.T) {
+	if _, err := Wait(Options{Cmd: "x", Matches: "("}, nil, nil); err == nil {
+		t.Error("bad regex accepted")
+	}
+}
+
+func TestEmptyCommandRejected(t *testing.T) {
+	if _, err := Wait(Options{}, nil, nil); err == nil {
+		t.Error("empty command accepted")
+	}
+}
+
+// Integration: real shell, waiting for a file to appear (the exact
+// case from the agy live test in doc/tool-parity.md).
+func TestShellRunnerFileAppears(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "flag")
+	go func() {
+		time.Sleep(30 * time.Millisecond)
+		os.WriteFile(path, []byte("x"), 0o644)
+	}()
+	res, err := Wait(Options{
+		Cmd: "test -f " + path, Interval: 10 * time.Millisecond, Timeout: 2 * time.Second,
+	}, ShellRunner, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !res.Met {
+		t.Errorf("file never seen: %+v", res)
+	}
+}