shadepix 0.3.0__tar.gz

shadepix-0.3.0/LICENSE

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

shadepix-0.3.0/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: shadepix
+Version: 0.3.0
+Summary: Faceless pixel avatars from your terminal. Zero dependencies.
+Author: Bastien Cochet
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bstcoc/shade
+Keywords: pixel-art,avatar,cli,terminal,generator
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/wordmark.png" width="420" alt="shade">
+</p>
+
+<p align="center">
+  <b>Faceless pixel avatars from your terminal.</b><br>
+  One Python file. Zero dependencies. Every face stays blank.<br><br>
+  <a href="https://bstcoc.github.io/shade/"><b>Try it in your browser →</b></a>
+</p>
+
+<p align="center">
+  <img src="assets/examples.png" alt="Avatars made with shade">
+</p>
+
+## Why
+
+Most avatar makers draw a face. shade draws everything else: hair, beard, hat, clothes, background.
+Eyes are always covered (shades, visor, goggles, a band), and there is no nose and no mouth.
+You get an avatar that feels like you without showing a face.
+
+## Install
+
+```sh
+uv tool install git+https://github.com/bstcoc/shade
+# or: pipx install git+https://github.com/bstcoc/shade
+```
+
+Needs Python 3.10+ and nothing else. Works on macOS, Linux and Windows. The command is `shade`.
+
+## Use it
+
+Run `shade` to open the studio:
+
+<p align="center"><img src="assets/demo.gif" width="760" alt="The shade studio"></p>
+
+- `↑` `↓` pick a setting, `←` `→` change it, and the preview updates live
+- `space` shuffles the look and keeps your size, shape and detail level
+- `⏎` saves a PNG and `g` saves an animated GIF, then you can keep going
+
+You can also make an avatar without the studio:
+
+```sh
+shade curly visor hoodie            # words in any order
+shade topcolor=navy bg=night stars  # colors take group=value
+shade random beanie                 # random look, with a beanie
+shade curly visor gif               # animated GIF: a light streak sweeps the lenses
+shade @egtuw4yi                     # rebuild an avatar from its code
+shade help                          # every group and value
+```
+
+Every avatar has a short code like `@egtuw4yi`. Share it and anyone can rebuild the same avatar.
+
+### What you can change
+
+17 settings: head shape, skin, hair, hair color, beard, hat, hat color, eyewear, lens color, top, top color, extra, background, pattern, detail level (`rich`, `shaded`, `flat`), shape (`rounded`, `circle`, `square`) and size (200, 400 or 1200 px).
+
+## Use it from an agent
+
+shade ships a skill for Claude Code. Install it once and ask for a pixel avatar in plain words:
+
+```sh
+mkdir -p ~/.claude/skills/shade
+curl -fsSL -o ~/.claude/skills/shade/SKILL.md https://raw.githubusercontent.com/bstcoc/shade/main/skills/shade/SKILL.md
+```
+
+## Let any AI design one
+
+```sh
+shade agent
+```
+
+This copies a ready-made prompt to your clipboard. Paste it to any AI and it replies with a `shade` command, or with a pixel grid you render using `shade draw`.
+
+## Draw your own
+
+A grid is a text file. A line like `K #0d0d14` sets a color, every other line is a row of pixels, and `.` is transparent.
+
+```
+K #0d0d14
+r #ff0000
+.K.
+KrK
+.K.
+```
+
+```sh
+shade draw art.txt
+```
+
+## Releases
+
+Every merged release PR publishes a new version to PyPI and GitHub, and the [web demo](https://bstcoc.github.io/shade/) picks it up with its notes. See [CHANGELOG.md](CHANGELOG.md).
+
+## License
+
+[MIT](LICENSE)

shadepix-0.3.0/README.md

@@ -0,0 +1,96 @@
+<p align="center">
+  <img src="assets/wordmark.png" width="420" alt="shade">
+</p>
+
+<p align="center">
+  <b>Faceless pixel avatars from your terminal.</b><br>
+  One Python file. Zero dependencies. Every face stays blank.<br><br>
+  <a href="https://bstcoc.github.io/shade/"><b>Try it in your browser →</b></a>
+</p>
+
+<p align="center">
+  <img src="assets/examples.png" alt="Avatars made with shade">
+</p>
+
+## Why
+
+Most avatar makers draw a face. shade draws everything else: hair, beard, hat, clothes, background.
+Eyes are always covered (shades, visor, goggles, a band), and there is no nose and no mouth.
+You get an avatar that feels like you without showing a face.
+
+## Install
+
+```sh
+uv tool install git+https://github.com/bstcoc/shade
+# or: pipx install git+https://github.com/bstcoc/shade
+```
+
+Needs Python 3.10+ and nothing else. Works on macOS, Linux and Windows. The command is `shade`.
+
+## Use it
+
+Run `shade` to open the studio:
+
+<p align="center"><img src="assets/demo.gif" width="760" alt="The shade studio"></p>
+
+- `↑` `↓` pick a setting, `←` `→` change it, and the preview updates live
+- `space` shuffles the look and keeps your size, shape and detail level
+- `⏎` saves a PNG and `g` saves an animated GIF, then you can keep going
+
+You can also make an avatar without the studio:
+
+```sh
+shade curly visor hoodie            # words in any order
+shade topcolor=navy bg=night stars  # colors take group=value
+shade random beanie                 # random look, with a beanie
+shade curly visor gif               # animated GIF: a light streak sweeps the lenses
+shade @egtuw4yi                     # rebuild an avatar from its code
+shade help                          # every group and value
+```
+
+Every avatar has a short code like `@egtuw4yi`. Share it and anyone can rebuild the same avatar.
+
+### What you can change
+
+17 settings: head shape, skin, hair, hair color, beard, hat, hat color, eyewear, lens color, top, top color, extra, background, pattern, detail level (`rich`, `shaded`, `flat`), shape (`rounded`, `circle`, `square`) and size (200, 400 or 1200 px).
+
+## Use it from an agent
+
+shade ships a skill for Claude Code. Install it once and ask for a pixel avatar in plain words:
+
+```sh
+mkdir -p ~/.claude/skills/shade
+curl -fsSL -o ~/.claude/skills/shade/SKILL.md https://raw.githubusercontent.com/bstcoc/shade/main/skills/shade/SKILL.md
+```
+
+## Let any AI design one
+
+```sh
+shade agent
+```
+
+This copies a ready-made prompt to your clipboard. Paste it to any AI and it replies with a `shade` command, or with a pixel grid you render using `shade draw`.
+
+## Draw your own
+
+A grid is a text file. A line like `K #0d0d14` sets a color, every other line is a row of pixels, and `.` is transparent.
+
+```
+K #0d0d14
+r #ff0000
+.K.
+KrK
+.K.
+```
+
+```sh
+shade draw art.txt
+```
+
+## Releases
+
+Every merged release PR publishes a new version to PyPI and GitHub, and the [web demo](https://bstcoc.github.io/shade/) picks it up with its notes. See [CHANGELOG.md](CHANGELOG.md).
+
+## License
+
+[MIT](LICENSE)

shadepix-0.3.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "shadepix"
+version = "0.3.0"
+description = "Faceless pixel avatars from your terminal. Zero dependencies."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "Bastien Cochet" }]
+keywords = ["pixel-art", "avatar", "cli", "terminal", "generator"]
+
+[project.urls]
+Homepage = "https://github.com/bstcoc/shade"
+
+[project.scripts]
+shade = "shade:main"
+
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+py-modules = ["shade"]

shadepix-0.3.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

shadepix-0.3.0/shade.py

@@ -0,0 +1,875 @@
+#!/usr/bin/env python3
+"""shade: faceless pixel avatars from your terminal. Zero dependencies.
+
+House rule: no eyes, no nose, no mouth. Eyes are always covered and faces stay blank.
+"""
+import os, random, re, shutil, struct, sys, time, zlib
+
+__version__ = "0.3.0"  # x-release-please-version
+
+N, C = 40, 20  # canvas is N x N; a half-width hw covers columns C-hw .. C+hw-1
+FRAMES = 24     # one animation loop; every moving pattern repeats within it
+
+# ── options ──────────────────────────────────────────────────────────────────
+
+SKIN = {"porcelain": "f7dcc9", "light": "edc4a3", "sand": "dcaa80", "tan": "c48c5f",
+        "brown": "93603e", "deep": "62402a", "cocoa": "432c1e"}
+HAIR = {"black": "26232f", "brown": "5a3722", "auburn": "8a422b", "blonde": "e3bd62",
+        "ginger": "d26b33", "gray": "a0a0aa", "white": "ececf2", "blue": "4874e2",
+        "pink": "ec74b2", "green": "45b06f", "purple": "8658da"}
+FABRIC = {"black": "2a2933", "white": "ecebf0", "red": "dc4b4b", "orange": "f28e3e",
+          "yellow": "f3cc4f", "green": "43a96e", "teal": "2fb6ab", "blue": "4074e3",
+          "navy": "2c3a66", "purple": "8254da", "pink": "ef74b2", "olive": "6e7c3e"}
+LENS = {"black": "18171f", "smoke": "40434f", "blue": "2f7bff", "red": "ff3d5e",
+        "gold": "ffb627", "green": "22d18c", "purple": "9b5cff"}
+BG = {"lilac": "b9a3ff", "sky": "6aa8e8", "mint": "8fe3c0", "peach": "ffb38a",
+      "lemon": "ffe27a", "coral": "ff7a7a", "cream": "f3ead8", "night": "22254a",
+      "forest": "2f5d48", "ink": "15141c"}
+
+OPTIONS = {
+    "head": ["round", "oval", "square", "long", "wide"],
+    "skin": SKIN,
+    "hair": ["short", "side", "buzz", "curly", "long", "bun", "mohawk", "spiky", "bald"],
+    "haircolor": HAIR,
+    "beard": ["none", "stubble", "short", "full", "long"],
+    "hat": ["none", "cap", "beanie", "bandana", "headphones"],
+    "hatcolor": FABRIC,
+    "eyes": ["shades", "round", "visor", "band", "goggles", "vr"],
+    "lens": LENS,
+    "top": ["hoodie", "tee", "jacket", "turtleneck"],
+    "topcolor": FABRIC,
+    "extra": ["none", "earring", "chain"],
+    "bg": BG,
+    "pattern": ["plain", "gradient", "dots", "stripes", "stars", "grid"],
+    "detail": ["rich", "shaded", "flat"],
+    "shape": ["rounded", "circle", "square"],
+    "size": ["400px", "1200px", "200px"],
+}
+LABELS = {"haircolor": "hair color", "hatcolor": "hat color", "topcolor": "top color", "bg": "background"}
+DEFAULT = {"head": "round", "skin": "sand", "hair": "side", "haircolor": "brown", "beard": "short",
+           "hat": "none", "hatcolor": "red", "eyes": "shades", "lens": "blue", "top": "hoodie",
+           "topcolor": "orange", "extra": "none", "bg": "lilac", "pattern": "plain",
+           "detail": "rich", "shape": "rounded", "size": "400px"}
+KEEP_ON_SHUFFLE = ("detail", "shape", "size")
+
+# (top row, half-width of each row)
+HEADS = {"round":  (9, [4, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 7, 6, 5, 4]),
+         "oval":   (9, [3, 5, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8, 7, 7, 7, 6, 6, 5, 4, 3]),
+         "square": (9, [6, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 7, 7, 6]),
+         "long":   (8, [4, 5, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 5, 4, 3]),
+         "wide":   (10, [5, 7, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 7, 6, 5])}
+BODY = [9, 12, 13, 14, 14, 15, 15, 15, 15, 15]  # rows 30..39
+
+# Parts whose edges draw an inner outline on what lies beneath them.
+CASTERS = {"head", "hair", "hat", "top", "eyes"}
+STARS = [(4, 5), (33, 4), (36, 15), (3, 22), (35, 27), (8, 13), (29, 9), (5, 34), (13, 3)]
+BAYER = [[0, 8, 2, 10], [12, 4, 14, 6], [3, 11, 1, 9], [15, 7, 13, 5]]
+
+
+# ── colors ───────────────────────────────────────────────────────────────────
+
+def rgb(h):
+    return int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16)
+
+
+def mix(a, b, t):
+    return "".join(f"{round(x + (y - x) * t):02x}" for x, y in zip(rgb(a), rgb(b)))
+
+
+def luma(h):
+    r, g, b = rgb(h)
+    return 0.299 * r + 0.587 * g + 0.114 * b
+
+
+def tone(base, suffix):
+    """'-' shadow (hue-shifted to violet), '--' deep shadow, '+' warm highlight."""
+    return {"": base, "-": mix(base, "2b1f4f", .32), "--": mix(base, "2b1f4f", .5),
+            "+": mix(base, "fff6dc", .35)}[suffix]
+
+
+def palette(o):
+    p = {"skin": SKIN[o["skin"]], "hair": HAIR[o["haircolor"]], "top": FABRIC[o["topcolor"]],
+         "hat": FABRIC[o["hatcolor"]], "lens": LENS[o["lens"]], "frame": "1d1b26",
+         "white": "f1f0f5", "gold": "f6c445", "vr": "d8dae3", "line": "1b1724", "bg": BG[o["bg"]]}
+    p["glint"] = mix(p["lens"], "ffffff", .75)
+    p["stubble"] = mix(p["skin"], p["hair"], .45)
+    p["bg2"] = mix(p["bg"], "ffffff", .18) if luma(p["bg"]) < 110 else mix(p["bg"], "2b1f4f", .12)
+    return p
+
+
+# ── drawing ──────────────────────────────────────────────────────────────────
+
+def compose(o):
+    """Paint every part into {(x, y): [key, z, part]}; higher z wins."""
+    px = {}
+    y0, hws = HEADS[o["head"]]
+    chin, W0, W = y0 + len(hws) - 1, hws[0], max(hws)
+    ey = y0 + 8  # eye line, always covered
+    hw = lambda y: hws[y - y0] if y0 <= y <= chin else 0
+
+    def put(x, y, key, z, part):
+        if 0 <= x < N and 0 <= y < N and z >= px.get((x, y), ("", -1, ""))[1]:
+            px[x, y] = [key, z, part]
+
+    def band(y, h, key, z, part):
+        for x in range(C - h, C + h):
+            put(x, y, key, z, part)
+
+    def disc(cx, cy, r, key, z, part, ymax=N):
+        for y in range(max(0, int(cy - r) - 1), min(ymax, int(cy + r) + 2)):
+            for x in range(int(cx - r) - 1, int(cx + r) + 2):
+                if (x + .5 - cx) ** 2 + (y + .5 - cy) ** 2 <= r * r:
+                    put(x, y, key, z, part)
+
+    def mirror(x, y, key, z, part):  # x measured from the left edge of the canvas
+        put(x, y, key, z, part)
+        put(2 * C - 1 - x, y, key, z, part)
+
+    # body, neck, head
+    for i, h in enumerate(BODY):
+        band(30 + i, h, "top", 3, "top")
+    for y in range(chin - 2, 32):
+        band(y, 3, "skin", 2, "neck")
+    for i, h in enumerate(hws):
+        band(y0 + i, h, "skin", 4, "head")
+    for y in range(ey + 1, ey + 4):
+        mirror(C - hw(y) - 1, y, "skin", 4, "head")
+
+    # top
+    top = o["top"]
+    if top in ("tee", "hoodie"):
+        band(30, 3, "skin", 3.5, "neck")
+        band(31, 2, "skin", 3.5, "neck")
+    if top == "hoodie":
+        for y, h in ((chin - 1, 6), (chin, 7), (chin + 1, 7), (29, 7)):
+            band(y, h, "top", 1.5, "top")
+        for y in range(31, 35):
+            mirror(C - 2, y, "white", 3.2, "top")
+    if top == "jacket":
+        for i, h in enumerate((4, 3, 3, 2, 2, 1)):
+            band(30 + i, h, "white", 3.2, "shirt")
+        for y in range(36, N):
+            put(C - 1, y, "top--", 3.2, "top")
+    if top == "turtleneck":
+        for y in range(chin - 1, 32):
+            band(y, 4, "top", 3.6, "top")
+
+    # beard
+    beard, B = o["beard"], ("hair", 5, "beard")
+    if beard in ("short", "full", "long"):
+        for y in range(ey + 3, ey + 6):
+            h = hw(y)
+            for x in (C - h, C - h + 1, C + h - 2, C + h - 1):
+                put(x, y, *B)
+        for y in range(ey + 6, chin + 1):
+            band(y, hw(y), *B)
+        tail = {"short": [hw(chin) - 2], "full": [hw(chin) - 1, hw(chin) - 3],
+                "long": [hw(chin) - 1, hw(chin) - 2, 3, 3, 2, 2, 1]}[beard]
+        for i, h in enumerate(tail):
+            band(chin + 1 + i, max(h, 1), *B)
+    if beard == "stubble":
+        for y in range(ey + 5, chin + 1):
+            for x in range(C - hw(y), C + hw(y)):
+                if (x + y) % 2 == 0:
+                    put(x, y, "stubble", 5, "beard")
+
+    # hair
+    hair, H, Hb = o["hair"], ("hair", 6, "hair"), ("hair", 1, "back")
+
+    def scalp(extra=1):
+        band(y0 - 2, W0 - 1, *H)
+        band(y0 - 1, W0 + 1, *H)
+        for y in range(y0, y0 + 4):
+            band(y, hw(y) + extra, *H)
+
+    def sideburns():
+        for y in range(y0 + 4, ey + 2):
+            h = hw(y)
+            for x in (C - h - 1, C - h, C + h - 1, C + h):
+                put(x, y, *H)
+
+    if hair in ("short", "side", "spiky", "bun", "long"):
+        scalp()
+        sideburns()
+    if hair in ("short", "spiky", "bun"):
+        for x in range(C - hw(y0 + 4), C + hw(y0 + 4)):
+            if x % 3 != 1:
+                put(x, y0 + 4, *H)
+    if hair == "side":
+        for y, (a, b) in ((y0 + 4, (-9, 5)), (y0 + 5, (-9, 1)), (y0 + 6, (-9, -4))):
+            for x in range(C + a, C + b):
+                put(x, y, *H)
+    if hair == "buzz":
+        band(y0 - 1, W0 - 1, *H)
+        for y in range(y0, y0 + 3):
+            band(y, hw(y), *H)
+    if hair == "curly":
+        disc(C, y0 + 6, W + 4, *Hb, ymax=chin - 3)
+        band(y0 - 3, W0, *H)
+        scalp(extra=2)
+        for x in range(C - hw(y0 + 4), C + hw(y0 + 4)):
+            if x % 2 == 0:
+                put(x, y0 + 4, *H)
+    if hair == "long":
+        band(y0 - 1, W0 + 2, *Hb)
+        for y in range(y0, y0 + 22):
+            band(y, max(hw(y), W - 1) + 2, *Hb)
+        for y in range(y0 + 4, y0 + 20):
+            h = hw(y) or W - 1
+            for x in (C - h - 2, C - h - 1, C - h, C + h - 1, C + h, C + h + 1):
+                put(x, y, *H)
+    if hair == "bun":
+        disc(C, y0 - 3, 3.3, *H)
+    if hair == "mohawk":
+        for y in range(y0 - 5, y0 + 5):
+            band(y, 1 if y == y0 - 5 else 2, *H)
+    if hair == "spiky":
+        for sx, h in ((C - 8, 3), (C - 5, 4), (C - 1, 5), (C + 3, 4), (C + 6, 3)):
+            for j in range(h):
+                r = (h - 1 - j) // 2
+                for x in range(sx - r, sx + r + 2):
+                    put(x, y0 - 2 - j, *H)
+
+    # hat
+    hat, T = o["hat"], ("hat", 7, "hat")
+    if hat in ("cap", "beanie"):
+        for k in [k for k, v in px.items() if v[2] == "hair" and k[1] < y0 + 2]:
+            del px[k]
+    if hat == "cap":
+        band(y0 - 3, W0 - 1, *T)
+        band(y0 - 2, W0 + 1, *T)
+        band(y0 - 1, W0 + 2, *T)
+        for y in range(y0, y0 + 4):
+            band(y, hw(y) + 1, *T)
+        band(y0 + 4, W + 2, *T)
+        band(y0 + 5, W, "hat-", 7, "hat")
+    if hat == "beanie":
+        disc(C, y0 - 5, 2.3, "hat+", 7, "hat")
+        band(y0 - 4, W - 3, *T)
+        band(y0 - 3, W - 1, *T)
+        band(y0 - 2, W, *T)
+        for y in range(y0 - 1, y0 + 6):
+            h = W + 1
+            for x in range(C - h, C + h):
+                put(x, y, "hat-" if y >= y0 + 3 and x % 2 == 0 else "hat", 7, "hat")
+    if hat == "bandana":
+        for y in range(y0 + 1, y0 + 4):
+            for x in range(C - hw(y) - 1, C + hw(y) + 1):
+                put(x, y, "hat+" if y == y0 + 2 and x % 3 == 0 else "hat", 7, "hat")
+        h = hw(y0 + 3)
+        for dx, dy in ((1, 3), (2, 3), (2, 4), (3, 5), (1, 4), (1, 5), (2, 6)):
+            put(C + h + dx, y0 + dy, *T)
+    if hat == "headphones":
+        r = W + 2.5
+        for y in range(y0 - 4, ey + 1):
+            for x in range(N):
+                d = ((x + .5 - C) ** 2 + (y + .5 - ey - 1) ** 2) ** .5
+                if r - 1.4 < d <= r:
+                    put(x, y, *T)
+        h = hw(ey)
+        for y in range(ey - 1, ey + 5):
+            for i in range(3):
+                mirror(C - h - 3 + i, y, "hat-" if i == 2 else "hat", 9.5, "hat")
+
+    # eyes: the slot is always covered
+    eyes, h = o["eyes"], hw(ey)
+    E = ("frame", 8, "eyes")
+    if eyes == "shades":
+        band(ey, h + 1, *E)
+        for x in range(C - h + 1, C - 1):
+            mirror(x, ey + 1, "lens", 8, "eyes")
+        for x in range(C - h + 2, C - 2):
+            mirror(x, ey + 2, "lens", 8, "eyes")
+        put(C - h + 1, ey + 1, "glint", 8, "eyes")
+        put(C - h + 2, ey + 1, "glint", 8, "eyes")
+    if eyes == "round":
+        for cx in (C - 4, C + 4):
+            disc(cx, ey + 1.5, 2.7, "lens", 8, "eyes")
+        put(C - 6, ey + 1, "glint", 8, "eyes")
+        put(C - 5, ey, "glint", 8, "eyes")
+        for x in range(C - h - 1, C - 6):
+            mirror(x, ey + 1, *E)
+        mirror(C - 1, ey + 1, *E)
+    if eyes == "visor":
+        for y in range(ey, ey + 3):
+            band(y, h + 1, "lens", 8, "eyes")
+        for x in range(C - h + 1, C - h + 5):
+            put(x, ey + 1, "glint", 8, "eyes")
+    if eyes == "band":
+        for y in range(ey, ey + 3):
+            band(y, h + 1, "lens", 8, "eyes")
+        for dx, dy in ((1, 2), (2, 3), (1, 4), (3, 4), (2, 5)):
+            put(C + h + dx, ey + dy, "lens", 8, "eyes")
+    if eyes == "goggles":
+        band(ey + 1, h + 1, *E)
+        for cx in (C - 4, C + 4):
+            disc(cx, ey + 1.5, 3.2, "lens", 8, "eyes")
+        put(C - 6, ey + 1, "glint", 8, "eyes")
+        put(C - 5, ey, "glint", 8, "eyes")
+    if eyes == "vr":
+        for y in range(ey - 1, ey + 4):
+            band(y, h + 1, "vr", 8, "eyes")
+        for y in range(ey, ey + 3):
+            band(y, h - 1, "lens", 8, "eyes")
+        put(C + h - 3, ey + 1, "glint", 8, "eyes")
+
+    # extras
+    if o["extra"] == "earring":
+        put(C - hw(ey + 3) - 1, ey + 4, "gold", 9, "extra")
+    if o["extra"] == "chain":
+        for x, y in ((C - 4, 30), (C - 3, 31), (C - 2, 32), (C - 1, 32)):
+            mirror(x, y, "gold", 9, "extra")
+        band(33, 1, "gold", 9, "extra")
+    return px
+
+
+def light(px, o):
+    """Cel shading: right side in shadow, cast shadow under hair, highlights at 'rich'."""
+    if o["detail"] == "flat":
+        return
+    rich = o["detail"] == "rich"
+    boxes = {}
+    for (x, y), (_, _, part) in px.items():
+        b = boxes.setdefault(part, [x, y, x, y])
+        b[:] = min(b[0], x), min(b[1], y), max(b[2], x), max(b[3], y)
+    for (x, y), v in px.items():
+        key, _, part = v
+        if key not in ("skin", "hair", "top", "hat"):
+            continue
+        x0, y0, x1, y1 = boxes[part]
+        cut = x0 + .62 * (x1 - x0 + 1)
+        above = px.get((x, y - 1), ("", 0, ""))[2]
+        if part == "neck" or (part == "head" and above in ("hair", "hat")):
+            v[0] = key + "-"
+        elif x >= cut or (rich and part in ("hair", "back", "hat") and x == int(cut) - 1 and (x + y) % 2 == 0):
+            v[0] = key + "-"
+        elif rich and part in ("hair", "hat", "back") and x < x0 + .3 * (x1 - x0) and y < y0 + .35 * (y1 - y0):
+            v[0] = key + "+"
+        elif rich and o["hair"] == "curly" and key == "hair" and (3 * x + 5 * y) % 7 == 0:
+            v[0] = key + "-"
+
+
+def background(x, y, o, t=0):
+    pat = o["pattern"]
+    if pat == "stripes":
+        x -= t // 3
+    if pat == "dots":
+        x, y = x + t // 6, y + t // 6
+    if pat == "grid":
+        x, y = x - t // 4, y - t // 4
+    alt = {"plain": False, "gradient": BAYER[y % 4][x % 4] < y / N * 18 - 1,
+           "dots": x % 4 == 1 and y % 4 == 1, "stripes": (x + y) % 8 < 2,
+           "grid": x % 6 == 0 or y % 6 == 0,
+           "stars": any((x, y) in ((sx, sy), (sx + 1, sy), (sx - 1, sy), (sx, sy + 1), (sx, sy - 1))
+                        and (sx + sy + t // 6) % 2 == 0 or (x, y) == (sx, sy) for sx, sy in STARS)}[pat]
+    return "bg2" if alt else "bg"
+
+
+def inside(x, y, shape, n=N):
+    if shape == "circle":
+        return (x + .5 - n / 2) ** 2 + (y + .5 - n / 2) ** 2 <= (n / 2) ** 2
+    if shape == "rounded":
+        r = n / 8
+        cx, cy = min(max(x + .5, r), n - r), min(max(y + .5, r), n - r)
+        return (x + .5 - cx) ** 2 + (y + .5 - cy) ** 2 <= r * r
+    return True
+
+
+def render(o, t=0):
+    """Options -> N x N grid of hex colors (None = transparent). t is the animation frame."""
+    px, pal = compose(o), palette(o)
+    light(px, o)
+    lens = [k for k, v in px.items() if v[0] == "lens"]
+    if t and lens and o["eyes"] != "band":  # a light streak sweeps across the lenses
+        lo, hi = min(x + y for x, y in lens), max(x + y for x, y in lens)
+        p = lo - 3 + t * (hi - lo + 6) / 10
+        for x, y in lens:
+            if p <= x + y < p + 2:
+                px[x, y][0] = "glint"
+    color = lambda key: tone(pal[key.rstrip("+-")], key[len(key.rstrip("+-")):])
+    grid = [[None] * N for _ in range(N)]
+    for y in range(N):
+        for x in range(N):
+            if not inside(x, y, o["shape"]):
+                continue
+            key, z, part = px.get((x, y), (background(x, y, o, t), 0, "bg"))
+            caster = None
+            for dx, dy in ((0, -1), (-1, 0), (1, 0), (0, 1)):
+                q = px.get((x + dx, y + dy))
+                if q and q[1] > z and (part == "bg" or q[2] in CASTERS and (q[2] != "eyes" or dy <= 0)):
+                    caster = q
+                    break
+            if caster is None:
+                grid[y][x] = color(key)
+            elif o["detail"] == "rich":
+                grid[y][x] = mix(color(caster[0]), "120e1c", .7)  # colored outline
+            else:
+                grid[y][x] = pal["line"]
+    return grid
+
+
+def png(grid, scale):
+    """Grid of hex/None -> RGBA PNG bytes."""
+    lines = []
+    for row in grid:
+        line = b"".join((bytes.fromhex(c) + b"\xff" if c else b"\0\0\0\0") * scale for c in row)
+        lines += [line] * scale
+    w, h = len(grid[0]) * scale, len(lines)
+    chunk = lambda t, d: struct.pack(">I", len(d)) + t + d + struct.pack(">I", zlib.crc32(t + d))
+    return (b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", struct.pack(">IIBBBBB", w, h, 8, 6, 0, 0, 0))
+            + chunk(b"IDAT", zlib.compress(b"".join(b"\0" + l for l in lines), 9)) + chunk(b"IEND", b""))
+
+
+def lzw(data, min_size):
+    """GIF flavored LZW: variable code size, table reset at 4096 codes."""
+    clear = 1 << min_size
+    out, buf, nbits = bytearray(), 0, 0
+
+    def emit(code):
+        nonlocal buf, nbits
+        buf |= code << nbits
+        nbits += size
+        while nbits >= 8:
+            out.append(buf & 255)
+            buf >>= 8
+            nbits -= 8
+
+    size, nxt, table = min_size + 1, clear + 2, {}
+    emit(clear)
+    w = data[0]
+    for b in data[1:]:
+        if (w, b) in table:
+            w = table[w, b]
+            continue
+        emit(w)
+        if nxt < 4096:
+            table[w, b] = nxt
+            nxt += 1
+            if nxt > 1 << size:
+                size += 1
+        else:
+            emit(clear)
+            size, nxt, table = min_size + 1, clear + 2, {}
+        w = b
+    emit(w)
+    emit(clear + 1)
+    if nbits:
+        out.append(buf & 255)
+    return bytes([min_size]) + b"".join(bytes([len(out[i:i + 255])]) + out[i:i + 255]
+                                        for i in range(0, len(out), 255)) + b"\0"
+
+
+def gif(grids, scale, delay=8):
+    """Grids of hex/None -> looping animated GIF bytes. delay is in 1/100 s per grid."""
+    runs = []  # merge identical consecutive frames into one longer frame
+    for g in grids:
+        if runs and runs[-1][0] == g:
+            runs[-1][1] += delay
+        else:
+            runs.append([g, delay])
+    colors = sorted({c for g, _ in runs for row in g for c in row if c})
+    index = {c: i + 1 for i, c in enumerate(colors)}  # 0 is transparent
+    bits = max(2, len(colors).bit_length())
+    table = b"\0\0\0" + b"".join(bytes.fromhex(c) for c in colors) + b"\0\0\0" * ((1 << bits) - len(colors) - 1)
+    w, h = len(grids[0][0]) * scale, len(grids[0]) * scale
+    out = b"GIF89a" + struct.pack("<HHBBB", w, h, 0xF0 | (bits - 1), 0, 0) + table
+    out += b"\x21\xff\x0bNETSCAPE2.0\x03\x01\0\0\0"
+    for g, d in runs:
+        pixels = b"".join(bytes(index.get(c, 0) for c in row for _ in range(scale)) * scale for row in g)
+        out += b"\x21\xf9\x04" + struct.pack("<BHBB", 0x09, d, 0, 0)
+        out += b"\x2c" + struct.pack("<HHHHB", 0, 0, w, h, 0) + lzw(pixels, bits)
+    return out + b"\x3b"
+
+
+def animate(o):
+    return gif([render(o, t) for t in range(FRAMES)], min(int(o["size"][:-2]), 400) // N)  # ponytail: pure-Python LZW, GIF capped at 400px
+
+
+# ── avatar codes: every look fits in a short shareable code ──────────────────
+
+DIGITS = "0123456789abcdefghijklmnopqrstuvwxyz"
+
+
+def encode(o):
+    n = 0
+    for k, v in OPTIONS.items():
+        n = n * len(v) + list(v).index(o[k])
+    s = ""
+    while n:
+        n, r = divmod(n, 36)
+        s = DIGITS[r] + s
+    return s or "0"
+
+
+def decode(code):
+    n, o = int(code, 36), {}
+    for k, v in reversed(OPTIONS.items()):
+        n, r = divmod(n, len(v))
+        o[k] = list(v)[r]
+    if n:
+        raise ValueError(code)
+    return o
+
+
+def save(o, animated=False):
+    name = f"shade-{encode(o)}.{'gif' if animated else 'png'}"
+    with open(name, "wb") as f:
+        f.write(animate(o) if animated else png(render(o), int(o["size"][:-2]) // N))
+    return name
+
+
+def shuffle(o):
+    return {k: o[k] if k in KEEP_ON_SHUFFLE else random.choice(list(v)) for k, v in OPTIONS.items()}
+
+
+# ── terminal ─────────────────────────────────────────────────────────────────
+
+R = "\x1b[0m"
+fg = lambda h: "\x1b[38;2;%d;%d;%dm" % rgb(h)
+bgc = lambda h: "\x1b[48;2;%d;%d;%dm" % rgb(h)
+DIM, ACCENT, OK = fg("6f6a85"), fg("c4a8ff"), fg("5ee6a0")
+GRADIENT = ["ff6ec7", "b388ff", "6ec8ff"]
+
+FONT = {"S": [".####", "#....", ".###.", "....#", "####."],
+        "H": ["#...#", "#...#", "#####", "#...#", "#...#"],
+        "A": [".###.", "#...#", "#####", "#...#", "#...#"],
+        "D": ["####.", "#...#", "#...#", "#...#", "####."],
+        "E": ["#####", "#....", "####.", "#....", "#####"]}
+
+
+def ramp(t):
+    t = min(max(t, 0), 1) * (len(GRADIENT) - 1)
+    i = min(int(t), len(GRADIENT) - 2)
+    return mix(GRADIENT[i], GRADIENT[i + 1], t - i)
+
+
+def wordmark_grid(word="SHADE", scale=1, shadow="2a2140"):
+    w = len(word) * 6 * scale
+    grid = [[None] * (w + 1) for _ in range(5 * scale + 1)]
+    for i, ch in enumerate(word):
+        for y, row in enumerate(FONT[ch]):
+            for x, c in enumerate(row):
+                if c != "#":
+                    continue
+                for sy in range(scale):
+                    for sx in range(scale):
+                        X, Y = (i * 6 + x) * scale + sx, y * scale + sy
+                        grid[Y + 1][X + 1] = grid[Y + 1][X + 1] or shadow
+                        grid[Y][X] = ramp(X / w)
+    return grid
+
+
+def halfblocks(grid, xs=1):
+    out = []
+    for y in range(0, len(grid), 2):
+        top, bot = grid[y], grid[y + 1] if y + 1 < len(grid) else [None] * len(grid[y])
+        s = ""
+        for t, b in zip(top, bot):
+            if t and b:
+                s += fg(t) + bgc(b) + "▀" * xs + R
+            elif t or b:
+                s += fg(t or b) + ("▀" if t else "▄") * xs + R
+            else:
+                s += " " * xs
+        out.append(s)
+    return out
+
+
+def card(o):
+    edge = fg("3d3852")
+    code = f" @{encode(o)} "
+    rows = [edge + "╭" + "─" * N + "╮" + R]
+    rows += [edge + "│" + R + line + edge + "│" + R for line in halfblocks(render(o))]
+    rows.append(edge + "╰" + "─" * (N - len(code) - 2) + R + DIM + code + edge + "──╯" + R)
+    return rows
+
+
+def visible(s):
+    return len(re.sub(r"\x1b\[[0-9;?]*[a-zA-Z]", "", s))
+
+
+def frame(lines):
+    sys.stdout.write("\x1b[H" + "\x1b[K\n".join(lines) + "\x1b[K\x1b[J")
+    sys.stdout.flush()
+
+
+KEYS = {"\x1b[A": "up", "\xe0H": "up", "k": "up", "\x1b[B": "down", "\xe0P": "down", "j": "down",
+        "\x1b[C": "right", "\xe0M": "right", "l": "right", "\x1b[D": "left", "\xe0K": "left", "h": "left",
+        "\r": "enter", "\n": "enter", " ": "space", "\x1b": "back", "q": "quit", "\x03": "quit"}
+
+
+def key(timeout=None):
+    """Wait for one keypress and name it. Returns None when timeout runs out."""
+    if os.name == "nt":
+        import msvcrt
+        end = None if timeout is None else time.monotonic() + timeout
+        while not msvcrt.kbhit():
+            if end is not None and time.monotonic() >= end:
+                return None
+            time.sleep(0.01)
+        k = msvcrt.getwch()
+        if k in "\x00\xe0":  # arrows arrive as a prefix plus a letter
+            k = "\xe0" + msvcrt.getwch()
+        return KEYS.get(k, k)
+    import select, termios, tty
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        if not select.select([fd], [], [], timeout)[0]:
+            return None
+        k = os.read(fd, 8).decode(errors="ignore")
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    return KEYS.get(k, k)
+
+
+def hint(*pairs):
+    return "  " + "   ".join(f"{fg('d9d4ee')}{k}{R} {DIM}{v}{R}" for k, v in pairs)
+
+
+def value(o, k, selected):
+    v = o[k]
+    text = v
+    if isinstance(OPTIONS[k], dict):
+        text = fg(OPTIONS[k][v]) + "██" + R + " " + v
+    if k == "hatcolor" and o["hat"] == "none":
+        return f"  {DIM}—{R}"
+    if selected:
+        return f"{ACCENT}◂{R} {text} {ACCENT}▸{R}"
+    return f"  {text}"
+
+
+def editor(o, saved):
+    keys, sel, toast = list(OPTIONS), 0, None
+    while True:
+        cols, rows = shutil.get_terminal_size()
+        if cols < 78 or rows < 23:
+            frame(["", f"  Make the window a bit bigger ({cols}x{rows}, needs 78x23).", "",
+                   hint(("esc", "back"))])
+            if key() in ("back", "quit"):
+                return "back"
+            continue
+        title = "".join(f"\x1b[1m{fg(ramp(i / 4))}{c}{R} " for i, c in enumerate("SHADE"))
+        panel = ["  " + title, f"  {DIM}faceless pixel avatars{R}", ""]
+        for i, k in enumerate(keys):
+            label = LABELS.get(k, k)
+            if i == sel:
+                panel.append(f"{ACCENT}›{R} {fg('ffffff')}{label:<11}{R}{value(o, k, True)}")
+            else:
+                panel.append(f"  {DIM}{label:<11}{R}{value(o, k, False)}")
+        left = card(o)
+        lines = [""] + [left[i] + "   " + (panel[i] if i < len(panel) else "") for i in range(len(left))]
+        lines.append(toast or hint(("↑↓", "choose"), ("←→", "change"), ("space", "shuffle"), ("⏎", "png"), ("g", "gif"), ("esc", "menu")))
+        frame(lines)
+        k, toast = key(), None
+        opts = list(OPTIONS[keys[sel]])
+        if k == "up":
+            sel = (sel - 1) % len(keys)
+        elif k == "down":
+            sel = (sel + 1) % len(keys)
+        elif k in ("left", "right"):
+            o[keys[sel]] = opts[(opts.index(o[keys[sel]]) + (1 if k == "right" else -1)) % len(opts)]
+        elif k == "space":
+            o.update(shuffle(o))
+        elif k in ("enter", "g"):
+            saved.append(save(o, animated=k == "g"))
+            toast = f"  {OK}✓ saved{R} {saved[-1]}  {DIM}keep going or esc{R}"
+        elif k in ("back", "quit"):
+            return k
+
+
+def splash():
+    grid = wordmark_grid()
+    w = len(grid[0])
+    for f in range(1, 13):
+        t = 1 - (1 - f / 12) ** 3  # ease-out: fast start, gentle stop
+        cut = int(w * t)
+        frame(["", ""] + ["  " + l for l in halfblocks([row[:cut] for row in grid], 2)])
+        time.sleep(0.016)
+
+
+def menu():
+    saved, items, sel = [], ["create", "surprise me", "agent prompt", "quit"], 0
+    desc = {"create": "build your avatar, piece by piece", "surprise me": "start from a random look",
+            "agent prompt": "let an AI design one for you", "quit": ""}
+    sys.stdout.write("\x1b[?1049h\x1b[?25l")
+    try:
+        splash()
+        while True:
+            lines = ["", ""] + ["  " + l for l in halfblocks(wordmark_grid(), 2)]
+            lines += ["", f"  {DIM}faceless pixel avatars · no eyes, no nose, no mouth{R}", ""]
+            for i, it in enumerate(items):
+                if i == sel:
+                    lines.append(f"  {ACCENT}›{R} {fg('ffffff')}{it:<14}{R}{DIM}{desc[it]}{R}")
+                else:
+                    lines.append(f"    {DIM}{it}{R}")
+            lines += ["", hint(("↑↓", "choose"), ("⏎", "open"), ("q", "quit"))]
+            frame(lines)
+            k = key()
+            if k == "up":
+                sel = (sel - 1) % len(items)
+            elif k == "down":
+                sel = (sel + 1) % len(items)
+            elif k in ("quit", "back") or (k == "enter" and items[sel] == "quit"):
+                break
+            elif k == "enter" and items[sel] == "agent prompt":
+                sys.stdout.write("\x1b[?25h\x1b[?1049l")
+                return agent()
+            elif k == "enter":
+                o = dict(DEFAULT) if items[sel] == "create" else shuffle(DEFAULT)
+                if editor(o, saved) == "quit":
+                    break
+    except KeyboardInterrupt:
+        pass
+    sys.stdout.write("\x1b[?25h\x1b[?1049l")
+    for name in saved:
+        print(f"{OK}✓{R} {name}")
+
+
+# ── commands ─────────────────────────────────────────────────────────────────
+
+def parse(words, o):
+    for w in words:
+        w = w.lower() + ("px" if w.isdigit() else "")
+        if w.startswith("@"):
+            try:
+                o.update(decode(w[1:]))
+            except ValueError:
+                sys.exit(f"shade: '{w}' is not an avatar code")
+            continue
+        if "=" in w:
+            k, v = w.split("=", 1)
+            k = {"background": "bg", "color": "topcolor"}.get(k, k)
+            if k not in OPTIONS or v not in OPTIONS[k]:
+                sys.exit(f"shade: unknown '{w}'. Run: shade help")
+            o[k] = v
+            continue
+        hits = [k for k, v in OPTIONS.items() if w in v]
+        if not hits:
+            sys.exit(f"shade: unknown word '{w}'. Run: shade help")
+        if len(hits) > 1:
+            sys.exit(f"shade: '{w}' fits several groups, say which: " + ", ".join(f"{k}={w}" for k in hits))
+        o[hits[0]] = w
+    return o
+
+
+def show(o, name):
+    print("\n".join("  " + l for l in halfblocks(render(o))) + f"\n\n  {OK}✓ saved{R} {name}  {DIM}@{encode(o)}{R}")
+
+
+def draw(path, size="400px"):
+    """Render a text grid: 'X #rrggbb' lines set colors, other lines are pixels."""
+    colors, rows = {".": None}, []
+    for line in open(path).read().splitlines():
+        parts = line.split()
+        if len(parts) == 2 and len(parts[0]) == 1:
+            colors[parts[0]] = parts[1].lstrip("#").lower()
+        elif len(parts) == 1:
+            rows.append(parts[0])
+    if not rows or len({len(r) for r in rows}) > 1:
+        sys.exit(f"shade: {path}: grid lines must all have the same length")
+    if bad := [k for k, v in colors.items() if v is not None and not re.fullmatch(r"[0-9a-f]{6}", v)]:
+        sys.exit(f"shade: {path}: bad color for {' '.join(bad)}. Use a hex color like: X #ff0000")
+    if missing := set("".join(rows)) - set(colors):
+        sys.exit(f"shade: {path}: no color for {' '.join(sorted(missing))}. Add a line like: X #ff0000")
+    grid = [[colors[c] for c in r] for r in rows]
+    out = os.path.splitext(os.path.basename(path))[0] + ".png"
+    with open(out, "wb") as f:
+        f.write(png(grid, max(1, int(size[:-2]) // max(len(rows), len(rows[0])))))
+    print("\n".join("  " + l for l in halfblocks(grid)) + f"\n\n  {OK}✓ saved{R} {out}")
+
+
+def groups():
+    return "\n".join(f"  {k:<10} {' '.join(v)}" for k, v in OPTIONS.items())
+
+
+AGENT_PROMPT = f"""\
+Design a faceless pixel avatar with `shade`, a terminal tool.
+
+House rule: no eyes, no nose, no mouth. Eyes are always covered and faces stay blank.
+
+Option A (best): reply with one command made of words, one per group, any order.
+Words that exist in several groups need group=value (example: topcolor=navy).
+{groups()}
+Example: shade curly haircolor=pink visor lens=blue hoodie topcolor=navy bg=night stars
+
+Option B: draw it pixel by pixel. Reply with a text file in one code block:
+- color lines: one character, a space, a hex color, like `K #0d0d14`
+- then the grid: one character per pixel, no spaces, every line the same length
+- `.` is transparent. Aim for 32x32. Respect the house rule.
+I render it with: shade draw art.txt
+"""
+
+
+def clipboard():
+    """Absolute path of the system clipboard tool and its encoding. Never resolved from the working folder."""
+    if os.name == "nt":
+        return os.path.join(os.environ.get("SystemRoot", r"C:\Windows"), "System32", "clip.exe"), [], "utf-16"
+    for cmd, *args in (["pbcopy"], ["wl-copy"], ["xclip", "-selection", "clipboard"]):
+        path = shutil.which(cmd)
+        if path and os.path.isabs(path):
+            return path, args, "utf-8"
+    return None, [], ""
+
+
+def agent():
+    path, args, encoding = clipboard()
+    if path and os.path.exists(path):
+        import subprocess
+        subprocess.run([path, *args], input=AGENT_PROMPT.encode(encoding))
+        print(f"{OK}✓ copied to clipboard.{R} Paste it to your AI.\n")
+    print(AGENT_PROMPT)
+
+
+def windows_console():
+    """Turn on UTF-8 output and ANSI colors, which older Windows consoles leave off."""
+    sys.stdout.reconfigure(encoding="utf-8")
+    import ctypes
+    kernel = ctypes.windll.kernel32
+    handle, mode = kernel.GetStdHandle(-11), ctypes.c_uint32()
+    if kernel.GetConsoleMode(handle, ctypes.byref(mode)):
+        kernel.SetConsoleMode(handle, mode.value | 0x0004)  # ENABLE_VIRTUAL_TERMINAL_PROCESSING
+
+
+HELP = f"""\
+shade: faceless pixel avatars
+
+  shade                          open the studio
+  shade curly visor hoodie       make one now, words in any order
+  shade topcolor=navy bg=night   colors take group=value
+  shade random                   surprise me (add words to lock some)
+  shade curly visor gif          animated GIF instead of a PNG
+  shade @code                    rebuild an avatar from its code
+  shade draw art.txt             render your own grid
+  shade agent                    prompt that lets an AI design one
+
+groups:
+{groups()}
+"""
+
+
+def main():
+    if os.name == "nt":
+        windows_console()
+    args = sys.argv[1:]
+    if not args:
+        return menu() if sys.stdin.isatty() and sys.stdout.isatty() else print(HELP)
+    cmd = args[0]
+    if cmd in ("version", "-v", "--version"):
+        print(f"shade {__version__}")
+    elif cmd in ("help", "-h", "--help"):
+        print(HELP)
+    elif cmd == "agent":
+        agent()
+    elif cmd == "draw" and len(args) > 1:
+        draw(args[1], parse(args[2:], dict(DEFAULT))["size"])
+    else:
+        animated = "gif" in args
+        args = [a for a in args if a != "gif"]
+        o = parse(args[1:], shuffle(DEFAULT)) if cmd == "random" else parse(args, dict(DEFAULT))
+        show(o, save(o, animated))
+
+
+if __name__ == "__main__":
+    main()

shadepix-0.3.0/shadepix.egg-info/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: shadepix
+Version: 0.3.0
+Summary: Faceless pixel avatars from your terminal. Zero dependencies.
+Author: Bastien Cochet
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bstcoc/shade
+Keywords: pixel-art,avatar,cli,terminal,generator
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<p align="center">
+  <img src="assets/wordmark.png" width="420" alt="shade">
+</p>
+
+<p align="center">
+  <b>Faceless pixel avatars from your terminal.</b><br>
+  One Python file. Zero dependencies. Every face stays blank.<br><br>
+  <a href="https://bstcoc.github.io/shade/"><b>Try it in your browser →</b></a>
+</p>
+
+<p align="center">
+  <img src="assets/examples.png" alt="Avatars made with shade">
+</p>
+
+## Why
+
+Most avatar makers draw a face. shade draws everything else: hair, beard, hat, clothes, background.
+Eyes are always covered (shades, visor, goggles, a band), and there is no nose and no mouth.
+You get an avatar that feels like you without showing a face.
+
+## Install
+
+```sh
+uv tool install git+https://github.com/bstcoc/shade
+# or: pipx install git+https://github.com/bstcoc/shade
+```
+
+Needs Python 3.10+ and nothing else. Works on macOS, Linux and Windows. The command is `shade`.
+
+## Use it
+
+Run `shade` to open the studio:
+
+<p align="center"><img src="assets/demo.gif" width="760" alt="The shade studio"></p>
+
+- `↑` `↓` pick a setting, `←` `→` change it, and the preview updates live
+- `space` shuffles the look and keeps your size, shape and detail level
+- `⏎` saves a PNG and `g` saves an animated GIF, then you can keep going
+
+You can also make an avatar without the studio:
+
+```sh
+shade curly visor hoodie            # words in any order
+shade topcolor=navy bg=night stars  # colors take group=value
+shade random beanie                 # random look, with a beanie
+shade curly visor gif               # animated GIF: a light streak sweeps the lenses
+shade @egtuw4yi                     # rebuild an avatar from its code
+shade help                          # every group and value
+```
+
+Every avatar has a short code like `@egtuw4yi`. Share it and anyone can rebuild the same avatar.
+
+### What you can change
+
+17 settings: head shape, skin, hair, hair color, beard, hat, hat color, eyewear, lens color, top, top color, extra, background, pattern, detail level (`rich`, `shaded`, `flat`), shape (`rounded`, `circle`, `square`) and size (200, 400 or 1200 px).
+
+## Use it from an agent
+
+shade ships a skill for Claude Code. Install it once and ask for a pixel avatar in plain words:
+
+```sh
+mkdir -p ~/.claude/skills/shade
+curl -fsSL -o ~/.claude/skills/shade/SKILL.md https://raw.githubusercontent.com/bstcoc/shade/main/skills/shade/SKILL.md
+```
+
+## Let any AI design one
+
+```sh
+shade agent
+```
+
+This copies a ready-made prompt to your clipboard. Paste it to any AI and it replies with a `shade` command, or with a pixel grid you render using `shade draw`.
+
+## Draw your own
+
+A grid is a text file. A line like `K #0d0d14` sets a color, every other line is a row of pixels, and `.` is transparent.
+
+```
+K #0d0d14
+r #ff0000
+.K.
+KrK
+.K.
+```
+
+```sh
+shade draw art.txt
+```
+
+## Releases
+
+Every merged release PR publishes a new version to PyPI and GitHub, and the [web demo](https://bstcoc.github.io/shade/) picks it up with its notes. See [CHANGELOG.md](CHANGELOG.md).
+
+## License
+
+[MIT](LICENSE)

shadepix-0.3.0/shadepix.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+shade.py
+shadepix.egg-info/PKG-INFO
+shadepix.egg-info/SOURCES.txt
+shadepix.egg-info/dependency_links.txt
+shadepix.egg-info/entry_points.txt
+shadepix.egg-info/top_level.txt

shadepix-0.3.0/shadepix.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

shadepix-0.3.0/shadepix.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+shade = shade:main

shadepix-0.3.0/shadepix.egg-info/top_level.txt

@@ -0,0 +1 @@
+shade