hyperweave 0.3.8__tar.gz → 0.3.10__tar.gz

{hyperweave-0.3.8 → hyperweave-0.3.10}/.gitignore

@@ -36,3 +36,7 @@ assets/cards/cards-2x2-v2.svg
 assets/cards/cards-2x2-v3.svg
 assets/cards/cards-2x2.svg
 assets/cards/halftone-card-triangle.svg
+assets/demos/
+scripts/analyze_audio.py
+scripts/generate_demo_charts.py
+scripts/render_demo_video.py

{hyperweave-0.3.8 → hyperweave-0.3.10}/CHANGELOG.md

@@ -5,6 +5,66 @@ All notable changes to HyperWeave are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.10] - 2026-05-22
+
+v0.3.10 finishes the layout hardening started in v0.3.9. Badges, strips, stats cards, charts, and older frame templates now place their content from measured layout values instead of template-side math. The visible result is tighter automata badges, cleaner headers, and more consistent glyph alignment.
+
+### Added
+
+- **Stats and chart layout modules** — Stats cards and star charts now compute their frame, header, axis, metric, and footer positions before rendering.
+- **Glyph measurement** — Provider glyphs are measured from their SVG paths and scaled by visible ink, so sparse marks like Docker no longer look smaller than dense marks like GitHub.
+- **Inter font metrics** — Inter now includes generated width, bearing, and vertical-bound data for more accurate text measurement.
+- **Template safeguards** — Automated checks now prevent coordinate math, hardcoded geometry, and literal colors from returning to templates.
+
+### Changed
+
+- **Badges** — Automata bookends, glyphs, labels, separators, values, and trailing edges now use balanced visible spacing.
+- **Glyph alignment** — Badge glyphs align to measured text centers where text uses a normal baseline, while chrome keeps its centered-baseline alignment.
+- **Stats cards** — Identity text, bio text, metric slots, activity bars, language bars, and footer positions now share the same measured layout path.
+- **Star charts** — Header labels, project/provider titles, axes, milestones, and chart labels now come from chart layout data instead of template constants.
+- **Strips** — Strip layout is split into named groups for core content, chrome details, cellular details, status marks, and bookends.
+- **Other frames** — Receipt, rhythm-strip, icon, marquee, divider, catalog, and motion-border templates now consume precomputed geometry.
+- **Gradients** — Standard SVG gradient endpoints are literal SVG values again; only material-specific chrome offsets remain configurable.
+
+### Fixed
+
+- **Automata stat headers** — Usernames and bio summaries keep visible breathing room.
+- **Automata badges** — Compact badges no longer leave extra empty space between the cellular bookend, glyph, label, value, and right edge.
+- **Badge text spacing** — Text bearings and visible ink widths now drive separator and edge spacing.
+- **Chart headers** — Header labels are generated from the project and provider instead of a hardcoded `HYPERWEAVE · GITHUB` string.
+- **Brutalist charts** — Prototype number labels no longer render in star charts.
+- **Template colors** — Specimen colors now flow through named context values or CSS roles instead of literal template hex values.
+
+### Removed
+
+- **Master-card** — The unused master-card render path was removed instead of migrated.
+
+## [0.3.9] - 2026-05-22
+
+Badge, strip, stat card, and star chart frames now measure rendered content before placing text, glyphs, seams, and markers. Chrome, brutalist, and automata outputs share more consistent typography, spacing, and variant colors across frame types.
+
+### Fixed
+
+- **Badges** — Missing glyph/status zones collapse, provider glyphs align to text, and long chrome status labels keep even padding.
+- **Chrome frames** — Badge, strip, stat card, and chart identity slots share Orbitron typography and variant glyph color.
+- **Font metrics** — Chakra Petch and Barlow Condensed now use real per-weight advance widths instead of scalar bold expansion.
+- **Stats cards** — Header identity, bio text, metric slots, and language footer placement measure content before positioning.
+- **Star charts** — Date labels use even calendar spacing, milestone labels avoid collisions, and chrome markers use variant color instead of fixed green.
+- **Strips** — Metric cells and identity zones adapt to measured labels, values, subtitles, and glyph presence.
+- **Connectors** — npm download metrics use the public stats endpoint.
+
+### Added
+
+- **Font metrics** — Per-weight measurements and visible text bounds for Orbitron, JetBrains Mono, Chakra Petch, and Barlow Condensed.
+- **Render checks** — Direct, HTTP, and MCP outputs are compared across the release matrix.
+
+### Changed
+
+- **Automata help text** — MCP help now lists all 16 automata tones.
+- **Automata badges** — Default badge output now uses the compact 20px form; explicit larger requests still use the 32px form.
+- **Strip rendering** — Identity glyph, icon box, divider, and status coordinates now flow from resolver context.
+- **Release tooling** — `just tag` accepts versions with or without the leading `v` and refreshes package version metadata after tagging.
+
 ## [0.3.8] - 2026-05-19
 
 Every artifact request now emits one greppable `HW_REQUEST` access-log line to stdout, so Fly.io's log stream reveals which GitHub repos embed HyperWeave SVGs via Camo's referer header. Health and metrics probes stay silent so 30-second checks don't drown the signal.
@@ -90,7 +150,7 @@ Receipt hero reads `token volume · $cost` with a four-cell decomposition strip
 
 - 1198 tests pass.
 
-## [0.3.4] - 2026-05-13
+## [0.3.4] - 2026-05-16
 
 `install-hook` now detects Claude Code and Codex automatically. A new `hyperweave doctor` command shows hook status, transcripts, and recent receipts at a glance.
 

{hyperweave-0.3.8 → hyperweave-0.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperweave
-Version: 0.3.8
+Version: 0.3.10
 Summary: Headless visual output layer for AI agents. One API call → self-contained SVG.
 Project-URL: Repository, https://github.com/InnerAura/hyperweave
 Project-URL: Issues, https://github.com/InnerAura/hyperweave/issues
@@ -57,6 +57,10 @@ Description-Content-Type: text/markdown
 </p>
 
 <!--
+AI agents need to explain what they did, what they found, and what changed — HyperWeave gives them a visual language that works anywhere.
+
+---
+
 A brand agent for repos.
 Generate a cohesive visual identity layer for README, profile, status, and releases — automatically.
 
@@ -730,7 +734,7 @@ Every artifact ships with:
 | Glyphs | 99 (93 Simple Icons + 6 geometric) |
 | Divider variants | 8 &mdash; 3 genome-themed (`band` chrome, `seam` brutalist, `dissolve` automata) + 5 genome-agnostic (`block`, `current`, `takeoff`, `void`, `zeropoint`) at <code>/a/inneraura/dividers/</code> |
 | Metadata tiers | 5 (Tier 0 silent &rarr; Tier 4 reasoning) |
-| Bundled fonts | 3 (JetBrains Mono, Orbitron, Chakra Petch — base64-embedded) |
+| Bundled fonts | 4 families / 5 weights (JetBrains Mono, Orbitron, Chakra Petch, Barlow Condensed 700/900 — base64-embedded) |
 
 Stack: Pydantic, FastAPI, FastMCP v3, Jinja2, Typer.
 

{hyperweave-0.3.8 → hyperweave-0.3.10}/README.md

@@ -23,6 +23,10 @@
 </p>
 
 <!--
+AI agents need to explain what they did, what they found, and what changed — HyperWeave gives them a visual language that works anywhere.
+
+---
+
 A brand agent for repos.
 Generate a cohesive visual identity layer for README, profile, status, and releases — automatically.
 
@@ -696,7 +700,7 @@ Every artifact ships with:
 | Glyphs | 99 (93 Simple Icons + 6 geometric) |
 | Divider variants | 8 &mdash; 3 genome-themed (`band` chrome, `seam` brutalist, `dissolve` automata) + 5 genome-agnostic (`block`, `current`, `takeoff`, `void`, `zeropoint`) at <code>/a/inneraura/dividers/</code> |
 | Metadata tiers | 5 (Tier 0 silent &rarr; Tier 4 reasoning) |
-| Bundled fonts | 3 (JetBrains Mono, Orbitron, Chakra Petch — base64-embedded) |
+| Bundled fonts | 4 families / 5 weights (JetBrains Mono, Orbitron, Chakra Petch, Barlow Condensed 700/900 — base64-embedded) |
 
 Stack: Pydantic, FastAPI, FastMCP v3, Jinja2, Typer.
 

{hyperweave-0.3.8 → hyperweave-0.3.10}/justfile

@@ -54,7 +54,11 @@ version-refresh:
     @uv run python -c "import hyperweave; print(f'_version.py refreshed to {hyperweave.__version__}')"
 
 tag VERSION MESSAGE:
-    git tag -a {{VERSION}} -m "{{MESSAGE}}"
+    #!/usr/bin/env bash
+    set -euo pipefail
+    VER="{{VERSION}}"
+    [[ "$VER" == v* ]] || VER="v$VER"
+    git tag -a "$VER" -m "{{MESSAGE}}"
     just version-refresh
-    @echo ""
-    @echo "Tagged {{VERSION}}. Push with: git push --follow-tags"
+    echo ""
+    echo "Tagged $VER. Push with: git push --follow-tags"

hyperweave-0.3.10/scripts/extract_font_metrics.py

@@ -0,0 +1,327 @@
+#!/usr/bin/env python3
+"""Extract per-codepoint advance widths from bundled WOFF2 fonts.
+
+HyperWeave bundles fonts as base64-encoded WOFF2 in
+``src/hyperweave/data/fonts/*.b64`` (so the whole font registry ships
+as plain-text files, diffable in git). This script decodes each font,
+reads its ``hmtx`` table via ``fontTools``, and emits a JSON file at
+``src/hyperweave/data/font-metrics/{slug}.json`` matching the existing
+``inter.json`` schema:
+
+    {
+      "font_family": "Orbitron",
+      "baseline_size_px": 20,
+      "units": "tenths_of_pixels",
+      "bold_expansion_factor": 1.0,
+      "fallback_width": 110,
+      "widths": { " ": 78, "A": 145, ... }
+    }
+
+The baseline size is chosen close to the font's dominant rendered size
+in HyperWeave (20px for Orbitron in stats hero values, 11px for
+Inter in badge labels). Widths are stored in tenths-of-pixels at the
+baseline size, so a glyph of 145 tenths at baseline 20px renders as
+14.5px wide at 20px and ~7.25px wide at 10px (linear scaling).
+
+Usage:
+    uv run python scripts/extract_font_metrics.py orbitron --baseline 20
+    uv run python scripts/extract_font_metrics.py jetbrains-mono --baseline 11
+    uv run python scripts/extract_font_metrics.py --all
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import sys
+from io import BytesIO
+from pathlib import Path
+
+from fontTools.pens.boundsPen import BoundsPen
+from fontTools.ttLib import TTFont
+from fontTools.varLib.instancer import instantiateVariableFont
+
+ROOT = Path(__file__).resolve().parent.parent
+FONTS_DIR = ROOT / "src" / "hyperweave" / "data" / "fonts"
+METRICS_DIR = ROOT / "src" / "hyperweave" / "data" / "font-metrics"
+
+# ASCII printable characters we shipped in inter.json (space through ~).
+SUPPORTED_ASCII = [chr(c) for c in range(0x20, 0x7F)]
+
+
+def load_font_from_b64(path: Path) -> TTFont:
+    """Decode a base64-encoded WOFF2 payload and return a TTFont."""
+    raw_b64 = path.read_text()
+    return TTFont(BytesIO(base64.b64decode(raw_b64)))
+
+
+def extract_widths_and_bearings(
+    font: TTFont, baseline_size_px: int
+) -> tuple[dict[str, int], dict[str, list[int]], dict[str, list[int]]]:
+    """Return per-char (advance_widths, ink_bearings, vertical_bounds).
+
+    Advance widths follow the original schema — tenths-of-pixels at
+    ``baseline_size_px``. Ink bearings are returned as
+    ``{char: [lsb_tenths, rsb_tenths]}`` where:
+
+    * ``lsb`` is the distance from the glyph's origin to the leftmost
+      visible ink (left side bearing in the OpenType sense)
+    * ``rsb`` is the distance from the rightmost visible ink to the
+      advance width (right side bearing)
+
+    These let the text-measurement layer compute *visible-ink width* as
+    ``advance - first_char.lsb - last_char.rsb`` — the corrected width
+    that places downstream cursor work (badge seam placement, stat card
+    bio_x derivation) at the actual visible end of text, not at the
+    advance position which includes invisible trailing side-bearing.
+
+    Whitespace glyphs (no ink) return ``[0, advance]`` so subtracting
+    them produces zero visible width — correct behavior for an
+    all-whitespace string.
+    """
+    cmap = font.getBestCmap()
+    hmtx = font["hmtx"]
+    glyph_set = font.getGlyphSet()
+    units_per_em = font["head"].unitsPerEm
+    scale = baseline_size_px / units_per_em
+    widths: dict[str, int] = {}
+    bearings: dict[str, list[int]] = {}
+    vertical_bounds: dict[str, list[int]] = {}
+    for ch in SUPPORTED_ASCII:
+        codepoint = ord(ch)
+        if codepoint not in cmap:
+            continue
+        glyph_name = cmap[codepoint]
+        advance_design_units, _lsb_design = hmtx[glyph_name]
+        widths[ch] = round(advance_design_units * scale * 10)
+
+        # Compute visible-ink bounds via BoundsPen. Whitespace glyphs draw
+        # nothing; pen.bounds is None — treat as "no visible ink" so the
+        # entire advance is left+right bearing (rsb consumes the advance).
+        pen = BoundsPen(glyph_set)
+        try:
+            glyph_set[glyph_name].draw(pen)
+        except Exception:
+            # Defensive: a malformed glyph shouldn't crash the extraction.
+            bearings[ch] = [0, widths[ch]]
+            vertical_bounds[ch] = [0, 0]
+            continue
+        if pen.bounds is None:
+            bearings[ch] = [0, widths[ch]]
+            vertical_bounds[ch] = [0, 0]
+            continue
+        xmin, _ymin, xmax, _ymax = pen.bounds
+        lsb_px_at_baseline = xmin * scale  # ink-left from glyph origin
+        rsb_px_at_baseline = (advance_design_units - xmax) * scale  # advance - ink-right
+        bearings[ch] = [round(lsb_px_at_baseline * 10), round(rsb_px_at_baseline * 10)]
+        vertical_bounds[ch] = [round(_ymin * scale * 10), round(_ymax * scale * 10)]
+    return widths, bearings, vertical_bounds
+
+
+def compute_fallback_width(widths: dict[str, int]) -> int:
+    """Median-ish fallback width for codepoints outside the supported set."""
+    if not widths:
+        return 60
+    sorted_widths = sorted(widths.values())
+    return sorted_widths[len(sorted_widths) // 2]
+
+
+def emit_metrics_json(
+    family: str,
+    baseline_size_px: int,
+    widths: dict[str, int],
+    bold_expansion_factor: float,
+    aliases: list[str],
+    is_monospace: bool = False,
+    char_width_px: float = 0.0,
+    bearings: dict[str, list[int]] | None = None,
+    vertical_bounds: dict[str, list[int]] | None = None,
+    widths_by_weight: dict[str, dict[str, int]] | None = None,
+    bearings_by_weight: dict[str, dict[str, list[int]]] | None = None,
+    vertical_bounds_by_weight: dict[str, dict[str, list[int]]] | None = None,
+) -> dict[str, object]:
+    """Build the JSON dict matching inter.json schema (plus registry fields).
+
+    ``bearings`` is a v0.3.9 addition for per-glyph ink-width measurement
+    (used by ``measure_text_ink_width`` in core/text.py). Optional —
+    loaders that predate the field fall back to advance-width behavior.
+    """
+    result: dict[str, object] = {
+        "font_family": family,
+        "baseline_size_px": baseline_size_px,
+        "units": "tenths_of_pixels",
+        "bold_expansion_factor": bold_expansion_factor,
+        "fallback_width": compute_fallback_width(widths),
+        "aliases": aliases,
+        "is_monospace": is_monospace,
+        "char_width_px": char_width_px,
+        "widths": widths,
+    }
+    if bearings:
+        result["bearings"] = bearings
+    if vertical_bounds:
+        result["vertical_bounds"] = vertical_bounds
+    if widths_by_weight:
+        result["widths_by_weight"] = widths_by_weight
+    if bearings_by_weight:
+        result["bearings_by_weight"] = bearings_by_weight
+    if vertical_bounds_by_weight:
+        result["vertical_bounds_by_weight"] = vertical_bounds_by_weight
+    return result
+
+
+# Known font configs. Add entries here to extend.
+FONT_CONFIGS: dict[str, dict[str, object]] = {
+    "inter": {
+        "family": "Inter",
+        "baseline_size_px": 11,
+        "bold_expansion_factor": 1.0,
+        "aliases": ["inter", "system-ui", "sans-serif", "-apple-system", "blinkmacsystemfont", "segoe ui"],
+        "is_monospace": False,
+        "char_width_px": 0.0,
+        "metric_weights": [400, 700, 800, 900],
+    },
+    "orbitron": {
+        "family": "Orbitron",
+        "baseline_size_px": 20,
+        "bold_expansion_factor": 1.0,
+        "aliases": ["orbitron"],
+        "is_monospace": False,
+        "char_width_px": 0.0,
+        "metric_weights": [400, 700, 800, 900],
+    },
+    "jetbrains-mono": {
+        "family": "JetBrains Mono",
+        "baseline_size_px": 11,
+        "bold_expansion_factor": 1.0,  # true monospace — no bold width change
+        "aliases": ["jetbrains mono", "jetbrains-mono", "sf mono", "menlo", "monospace"],
+        "is_monospace": True,
+        # char_width_px populated below from extracted widths (median).
+        "char_width_px": 0.0,
+    },
+    "chakra-petch": {
+        "family": "Chakra Petch",
+        "baseline_size_px": 12,  # dominant rendered size in automata badge value text
+        "bold_expansion_factor": 1.0,
+        "aliases": ["chakra petch", "chakra-petch"],
+        "is_monospace": False,
+        "char_width_px": 0.0,
+        "metric_weights": [400, 700, 900],
+        "metric_weight_sources": {
+            "400": "chakra-petch",
+            "700": "chakra-petch",
+            "900": "chakra-petch",
+        },
+    },
+    "barlow-condensed-900": {
+        "family": "Barlow Condensed",
+        "baseline_size_px": 18,  # dominant rendered size in brutalist strip value text
+        "bold_expansion_factor": 1.0,  # 900 is the heaviest weight shipped; no further expansion
+        "aliases": ["barlow condensed", "barlow-condensed", "barlow condensed 900"],
+        "is_monospace": False,
+        "char_width_px": 0.0,
+        "metric_weights": [400, 700, 900],
+        "metric_weight_sources": {
+            "400": "barlow-condensed-700",
+            "700": "barlow-condensed-700",
+            "900": "barlow-condensed-900",
+        },
+    },
+}
+
+
+def load_metric_font_for_weight(slug: str, base_font: TTFont, config: dict[str, object], weight_int: int) -> TTFont:
+    """Return the font face used to extract metrics for ``weight_int``.
+
+    Variable fonts are instantiated by axis value. Static families can declare
+    ``metric_weight_sources`` to map weights to bundled font slugs.
+    """
+    weight_sources = config.get("metric_weight_sources")
+    if isinstance(weight_sources, dict):
+        source_slug = str(weight_sources.get(str(weight_int), slug))
+        source_path = FONTS_DIR / f"{source_slug}.b64"
+        if not source_path.exists():
+            raise FileNotFoundError(f"Missing font source for weight {weight_int}: {source_path}")
+        return load_font_from_b64(source_path)
+    if "fvar" in base_font:
+        return instantiateVariableFont(base_font, {"wght": weight_int}, inplace=False)
+    return base_font
+
+
+def extract_one(slug: str) -> Path:
+    """Extract one font to ``data/font-metrics/{slug}.json``."""
+    if slug not in FONT_CONFIGS:
+        raise ValueError(f"Unknown font slug '{slug}'. Known: {sorted(FONT_CONFIGS)}")
+    config = FONT_CONFIGS[slug]
+    b64_path = FONTS_DIR / f"{slug}.b64"
+    if not b64_path.exists():
+        raise FileNotFoundError(f"Missing font source: {b64_path}")
+
+    font = load_font_from_b64(b64_path)
+    baseline = int(config["baseline_size_px"])
+    widths, bearings, vertical_bounds = extract_widths_and_bearings(font, baseline)
+    widths_by_weight: dict[str, dict[str, int]] = {}
+    bearings_by_weight: dict[str, dict[str, list[int]]] = {}
+    vertical_bounds_by_weight: dict[str, dict[str, list[int]]] = {}
+    metric_weights = config.get("metric_weights")
+    if isinstance(metric_weights, list):
+        for weight in metric_weights:
+            weight_int = int(weight)
+            weight_font = load_metric_font_for_weight(slug, font, config, weight_int)
+            weight_widths, weight_bearings, weight_vertical_bounds = extract_widths_and_bearings(weight_font, baseline)
+            key = str(weight_int)
+            widths_by_weight[key] = weight_widths
+            bearings_by_weight[key] = weight_bearings
+            vertical_bounds_by_weight[key] = weight_vertical_bounds
+
+    char_width_px = float(config["char_width_px"])
+    is_mono = bool(config["is_monospace"])
+    if is_mono and char_width_px == 0.0 and widths:
+        # Monospace: all chars have the same advance; pick the first mapped width.
+        advance_tenths = next(iter(widths.values()))
+        char_width_px = advance_tenths / 10.0
+
+    data = emit_metrics_json(
+        family=str(config["family"]),
+        baseline_size_px=baseline,
+        widths=widths,
+        bold_expansion_factor=float(config["bold_expansion_factor"]),
+        aliases=list(config["aliases"]),  # type: ignore[arg-type]
+        is_monospace=is_mono,
+        char_width_px=char_width_px,
+        bearings=bearings,
+        vertical_bounds=vertical_bounds,
+        widths_by_weight=widths_by_weight,
+        bearings_by_weight=bearings_by_weight,
+        vertical_bounds_by_weight=vertical_bounds_by_weight,
+    )
+
+    out_path = METRICS_DIR / f"{slug}.json"
+    METRICS_DIR.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n")
+    return out_path
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("slugs", nargs="*", help="Font slugs to extract (e.g. orbitron jetbrains-mono).")
+    parser.add_argument("--all", action="store_true", help="Extract every font in FONT_CONFIGS.")
+    args = parser.parse_args()
+
+    if args.all:
+        slugs = sorted(FONT_CONFIGS.keys())
+    elif args.slugs:
+        slugs = args.slugs
+    else:
+        parser.print_help()
+        return 1
+
+    for slug in slugs:
+        out = extract_one(slug)
+        sys.stdout.write(f"  wrote {out.relative_to(ROOT)}\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())