hyperweave 0.2.3__tar.gz → 0.2.4__tar.gz

{hyperweave-0.2.3 → hyperweave-0.2.4}/CHANGELOG.md

@@ -5,6 +5,36 @@ 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.2.4] - 2026-04-13
+
+### Added
+
+- **Truthful chart rendering.** Charts now reflect what the data actually says. When a GitHub fetch fails, the chart renders a clear `DATA UNAVAILABLE` overlay instead of a synthesized placeholder curve. Brand-new repos with zero stars render `NEW REPO · NO STARS YET`. Every chart carries a status attribute (`fresh`, `stale`, `empty`) that downstream consumers can read.
+- **Adaptive chart axes.** Y-tick values auto-generate from the data range using round numbers (1, 2, 5 × powers of 10), so labels agree with the curve at any scale. X-axis year labels come from actual point timestamps — the old hardcoded `EARLY '24` / `LATE '24` placeholders are gone.
+- **Single-page stargazer granularity.** Repos with ≤30 stars now render with individual stargazer timestamps instead of collapsed samples, so early-stage projects produce visible curves instead of flat lines.
+- **Adaptive strip metric cell pitch.** Strip cells size themselves to fit the widest metric, then propagate that pitch uniformly. Long values no longer overflow; the grid stays balanced.
+
+### Fixed
+
+- **Live state now reflects live data.** Badges, strips, and live routes across HTTP, CLI, and MCP auto-detect pass/fail/warning/critical state from fetched values. Previously this inference ran only inside `hw kit readme`, so a live badge fetching `build=failing` rendered as green ("active") instead of red. Explicit overrides (`?state=passing`, `--state failing`, MCP `state` argument) continue to win.
+- **Generated SVGs advertised the wrong version in their embedded metadata.** The `version` variable that feeds `<hw:artifact version="...">`, `<hw:generator>`, `<hw:genome>`, and `<dc:creator>` was never populated, so every SVG from v0.2.0–v0.2.3 declared itself as `0.1.0` regardless of installed version. The metadata now reflects the real release.
+- **Stats card activity bars blurred on mobile.** Bars now render with a solid fill and pixel-crisp edges rather than a multi-stop vertical gradient. The icy highlight lives in the horizon shelf-glow above the bars, so small-viewport rendering stays sharp.
+- **Strip chrome typography drifted from badge.** Chrome strip metric values render in Orbitron 17px upright, matching the chrome badge — replacing the previous Impact-italic treatment. Chrome strip and chrome badge now share one typographic system.
+- **Strip chrome filter stack caused mobile blur.** Removed specular lighting and the text-shadow filter, both of which rasterized poorly on small frames. Replaced the sheen with vector hairlines so highlights stay pixel-perfect at every size.
+- **Chart axis labels no longer hardcoded.** Both brutalist and chrome chart templates read axis labels from the chart engine; changing the data range updates the labels automatically.
+- **User-Agent header reported the wrong version.** Outbound HTTP requests identify as the installed HyperWeave version rather than a stale `0.1.0`.
+
+### Changed
+
+- **Chart resolver is a three-state machine.** `stale` (fetch failed), `empty` (zero-value repo), or `fresh` (real data). The previous behavior of synthesizing a placeholder curve on failure is removed — data truthfulness is now a rendering contract.
+- **Strip skew is profile-declared.** The hardcoded italic skew on chrome strips has been removed; profiles that want a skew opt in explicitly via a profile field.
+
+### Known follow-ups (not blocking v0.2.4)
+
+- **Chart hero strip placeholders.** The static repo slug and date-range label on charts are not yet data-driven; only the curve and axes are.
+- **Chart/stats data-provenance states lack dedicated styling.** Charts with failed fetches render a `stale` status, but no CSS rule matches it — the visual is covered by the text overlay rather than a distinct chrome color. Same for `empty`.
+- **`loop` artifact status is declared but unused.** The status enum includes `loop`, exposed via MCP schema, but no inference logic produces it and no CSS animation exists for it.
+
 ## [0.2.3] - 2026-04-13
 
 ### Added

{hyperweave-0.2.3 → hyperweave-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperweave
-Version: 0.2.3
+Version: 0.2.4
 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
@@ -325,8 +325,8 @@ Every artifact ships with:
 |---|---|
 | Frame types | 15 (badge, strip, banner, icon, divider, marquee-h/v/counter, receipt, rhythm-strip, master-card, catalog, stats, chart, timeline) |
 | Genomes | 2 (brutalist-emerald, chrome-horizon) |
-| Motion configs | 16 (1 static + 5 border SMIL + 10 kinetic CSS) |
-| Glyphs | 97 (91 Simple Icons + 6 geometric) |
+| Motion configs | 15 (1 static + 5 border SMIL + 9 kinetic CSS) |
+| Glyphs | 99 (93 Simple Icons + 6 geometric) |
 | Divider variants | 5 (block, current, takeoff, void, zeropoint) |
 | Metadata tiers | 5 (Tier 0 silent → Tier 4 reasoning) |
 | Paradigms | 3 per frame (default, brutalist, chrome) — per-frame dispatch from genome |

{hyperweave-0.2.3 → hyperweave-0.2.4}/README.md

@@ -293,8 +293,8 @@ Every artifact ships with:
 |---|---|
 | Frame types | 15 (badge, strip, banner, icon, divider, marquee-h/v/counter, receipt, rhythm-strip, master-card, catalog, stats, chart, timeline) |
 | Genomes | 2 (brutalist-emerald, chrome-horizon) |
-| Motion configs | 16 (1 static + 5 border SMIL + 10 kinetic CSS) |
-| Glyphs | 97 (91 Simple Icons + 6 geometric) |
+| Motion configs | 15 (1 static + 5 border SMIL + 9 kinetic CSS) |
+| Glyphs | 99 (93 Simple Icons + 6 geometric) |
 | Divider variants | 5 (block, current, takeoff, void, zeropoint) |
 | Metadata tiers | 5 (Tier 0 silent → Tier 4 reasoning) |
 | Paradigms | 3 per frame (default, brutalist, chrome) — per-frame dispatch from genome |

{hyperweave-0.2.3 → hyperweave-0.2.4}/src/hyperweave/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.3'
-__version_tuple__ = version_tuple = (0, 2, 3)
+__version__ = version = '0.2.4'
+__version_tuple__ = version_tuple = (0, 2, 4)
 
 __commit_id__ = commit_id = None

{hyperweave-0.2.3 → hyperweave-0.2.4}/src/hyperweave/compose/context.py

@@ -14,6 +14,7 @@ from collections.abc import Callable
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Any
 
+from hyperweave import __version__
 from hyperweave.core.enums import ArtifactStatus, FrameType, MotionId
 
 if TYPE_CHECKING:
@@ -152,6 +153,8 @@ def _base_context(
         # Timestamp
         "created": datetime.now(UTC).isoformat(),
         "created_at": datetime.now(UTC).isoformat(),
+        # Version -- read by templates/components/metadata.svg.j2
+        "version": __version__,
         # Embedded fonts (base64 @font-face CSS)
         "font_faces": _load_font_faces(resolved.genome),
     }

{hyperweave-0.2.3 → hyperweave-0.2.4}/src/hyperweave/compose/engine.py

@@ -11,6 +11,18 @@ def compose(spec: ComposeSpec) -> ComposeResult:
     """Compose an artifact from a ComposeSpec."""
     start = time.monotonic()
 
+    # ── 0. Infer state from value when the caller left the default ──
+    # Any explicit override (?state=failing, --state passing, MCP state arg,
+    # etc.) sets spec.state to something other than "active" and survives
+    # this step untouched. This is the single chokepoint covering HTTP,
+    # CLI, MCP, and kit.
+    if spec.state == "active" and spec.value:
+        from hyperweave.core.state import infer_state
+
+        inferred = infer_state(spec.title, spec.value)
+        if inferred != "active":
+            spec = spec.model_copy(update={"state": inferred})
+
     # ── 1. Resolve genome, profile, frame ──
     from hyperweave.compose.resolver import resolve
 

{hyperweave-0.2.3 → hyperweave-0.2.4}/src/hyperweave/compose/resolver.py

@@ -249,9 +249,8 @@ def resolve_strip(
     height = 52
 
     metrics = _parse_metrics(spec)
-    metric_pitch = profile.get("strip_metric_pitch", 106)
+    min_metric_pitch = profile.get("strip_metric_pitch", 106)
     cell_offset = 12  # gap between first divider and first metric cell
-    status_zone = 56  # 14px indicator + padding
 
     # Glyph zone is ~36px (12 pad + 24 glyph + gap).  Collapse when absent.
     has_glyph = bool(glyph_data and glyph_data.get("path"))
@@ -267,6 +266,42 @@ def resolve_strip(
     # Account for letter-spacing 0.18em on identity text
     id_text_w += len(identity) * 11 * 0.18
     first_divider_x = max(int(identity_x + id_text_w + 14), 80)  # 14px right padding, min 80
+
+    # ── Adaptive cell pitch (preserves the slot grid) ──
+    # Uniform pitch adopts the widest metric's measured width so the slot
+    # grid stays consistent (every cell is the same size), but no metric's
+    # value overflows its cell. This is where adaptivity lives: `for metric
+    # in metrics` varies by payload, and each metric's value width drives
+    # the shared pitch upward when values are long. The status diamond
+    # lives in the dedicated right-edge ``status_zone``, not per-cell.
+    cell_pad = 20  # horizontal breathing room inside each cell
+
+    # Typography params for width measurement. For chrome paradigm these
+    # should match the CSS declared in strip/chrome-defs.j2 (Orbitron 17px
+    # 900 for value, JetBrains Mono 9px 600 for label). Other paradigms
+    # fall back to profile-declared sizes.
+    paradigm = (genome.get("paradigms") or {}).get("strip", "default")
+    if paradigm == "chrome":
+        value_size = 17
+        label_size = 9
+    else:
+        value_size = profile.get("strip_metric_value_size", 18)
+        label_size = profile.get("strip_metric_label_size", 7)
+
+    widest_cell = min_metric_pitch
+    for metric in metrics:
+        raw_value = str(metric.get("value", ""))
+        raw_label = str(metric.get("label", "")).upper()
+        value_w = measure_text(raw_value, font_size=value_size, bold=True, monospace=False)
+        label_w = measure_text(raw_label, font_size=label_size, bold=False, monospace=True)
+        cell_content_w = max(label_w, value_w)
+        needed = int(cell_content_w + cell_pad)
+        if needed > widest_cell:
+            widest_cell = needed
+
+    metric_pitch = widest_cell
+    status_zone = 56  # reserved for right-edge status diamond + padding
+
     n = max(len(metrics), 1)
     width = first_divider_x + cell_offset + n * metric_pitch + status_zone
 
@@ -1629,7 +1664,7 @@ def _resolve_motion(spec: ComposeSpec, genome: dict[str, Any]) -> str:
     return MotionId.STATIC
 
 
-def _parse_metrics(spec: ComposeSpec) -> list[dict[str, str]]:
+def _parse_metrics(spec: ComposeSpec) -> list[dict[str, Any]]:
     metrics: list[dict[str, str]] = []
 
     # Try slots first

hyperweave-0.2.4/src/hyperweave/compose/resolvers/chart.py

@@ -0,0 +1,139 @@
+"""Chart frame resolver — star history / time-series visualization.
+
+Reads pre-fetched connector data from ``spec.connector_data`` and delegates
+the actual SVG math to :mod:`hyperweave.render.chart_engine`.
+
+Three-state truthfulness contract:
+    - ``connector_data is None``         → ``data-hw-status="stale"``, "DATA UNAVAILABLE" overlay
+    - ``current_stars == 0`` (new repo)  → ``data-hw-status="empty"``, "NEW REPO · NO STARS YET" overlay
+    - real points + current_stars > 0    → ``data-hw-status="fresh"``, live chart
+
+The chart never fabricates data. There is no placeholder series — a zero-star
+repo is a legitimate state, and upstream failure is rendered truthfully as
+unavailable rather than masked with demo data.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from hyperweave.render.chart_engine import Viewport, build_chart_svg
+
+if TYPE_CHECKING:
+    from hyperweave.core.models import ComposeSpec
+
+
+# Default milestones for star charts (shown when values cross these thresholds).
+_DEFAULT_MILESTONES: list[int] = [500, 1000, 2000, 5000, 10000]
+
+
+def resolve_chart(
+    spec: ComposeSpec,
+    genome: dict[str, Any],
+    profile: dict[str, Any],
+    **_kw: Any,
+) -> dict[str, Any]:
+    """Resolve the ``chart`` frame into width/height/template/context."""
+    width, height = 900, 500
+
+    # Viewport insets: leave room for hero title at top, axis labels on left,
+    # date labels at bottom, and hero value at right.
+    # Dimensions match the target SVGs in tier2/genomes/.
+    paradigm = genome.get("paradigms", {}).get("chart", "brutalist")
+    vp = (
+        Viewport(x=80, y=160, w=750, h=250)
+        if paradigm == "chrome"
+        else Viewport(x=80, y=150, w=760, h=245)
+    )
+
+    # Three-state machine. "fresh" preserved (not renamed to "live") for
+    # backward compat with the existing data-hw-status contract; "empty" is
+    # new and specifically marks a truthful zero-star state.
+    connector = spec.connector_data
+    raw_points: list[Any]
+    empty_message: str | None
+    if connector is None:
+        # Upstream API failure — no data to trust.
+        status = "stale"
+        raw_points = []
+        current_stars = 0
+        empty_message = "DATA UNAVAILABLE"
+    else:
+        current_stars = int(
+            connector.get("current_stars") or connector.get("stars_total") or 0
+        )
+        raw_points = list(
+            connector.get("points") or connector.get("star_history") or []
+        )
+        if current_stars == 0:
+            # Truthful zero-star state (brand-new repo) — render empty, don't fabricate.
+            status = "empty"
+            raw_points = []
+            empty_message = "NEW REPO · NO STARS YET"
+        elif not raw_points:
+            # Has stars but no history — shouldn't happen after the connector
+            # fix, but degrade truthfully rather than synthesize.
+            status = "stale"
+            empty_message = "HISTORY UNAVAILABLE"
+        else:
+            status = "fresh"
+            empty_message = None
+
+    # Structural hints come from the resolver injection in compose/resolver.py,
+    # but we also read directly from the genome here because this file is
+    # imported before _resolve_paradigm has run (resolvers run INSIDE resolve()).
+    structural = genome.get("structural") or {}
+
+    chart_fragments = build_chart_svg(
+        raw_points,
+        vp,
+        structural,
+        milestones=_DEFAULT_MILESTONES,
+        empty_message=empty_message,
+    )
+
+    repo = connector.get("repo") if connector else None
+    repo = repo or f"{spec.chart_owner}/{spec.chart_repo}".strip("/")
+
+    # Hero identity strings shown at top + right of the standalone chart.
+    title_upper = (repo or "star history").upper()
+    current_display = _format_compact(int(current_stars))
+
+    ctx: dict[str, Any] = {
+        "chart_repo": repo,
+        "chart_title": title_upper,
+        "chart_current_stars": current_display,
+        "chart_viewport_x": vp.x,
+        "chart_viewport_y": vp.y,
+        "chart_viewport_w": vp.w,
+        "chart_viewport_h": vp.h,
+        "chart_defs": chart_fragments["defs"],
+        "chart_axes": chart_fragments["axes"],
+        "chart_gridlines": chart_fragments["gridlines"],
+        "chart_area": chart_fragments["area"],
+        "chart_polyline": chart_fragments["polyline"],
+        "chart_markers": chart_fragments["markers"],
+        "chart_milestones": chart_fragments["milestones"],
+        "chart_y_labels": chart_fragments["y_labels"],
+        "chart_x_labels": chart_fragments["x_labels"],
+        "chart_empty_state": chart_fragments["empty_state"],
+        "data_hw_status": status,
+    }
+    # Surface non-fresh states via the document-level data-hw-status attribute.
+    # "fresh" stays implicit (live data is the default, no status marker needed).
+    if status != "fresh":
+        ctx["status"] = status
+
+    return {
+        "width": width,
+        "height": height,
+        "template": "frames/chart.svg.j2",
+        "context": ctx,
+    }
+
+
+def _format_compact(n: int) -> str:
+    """Render an integer as a compact string (2850 → '2,850', 12847 → '12.8K')."""
+    if n >= 10000:
+        return f"{n / 1000:.1f}K".rstrip("0").rstrip(".")
+    return f"{n:,}"

{hyperweave-0.2.3 → hyperweave-0.2.4}/src/hyperweave/compose/resolvers/stats.py

@@ -124,11 +124,18 @@ def resolve_stats(
     paradigm = genome.get("paradigms", {}).get("stats", "brutalist")
     if paradigm == "chrome":
         embed_vp = Viewport(x=240, y=170, w=220, h=70)
-        chart_points = (
-            connector.get("points")
-            or connector.get("star_history")
-            or _synthetic_series_from_total(int(stars_total or 1200))
-        )
+        # Zero-guard: never default to a 1200-star synthetic curve. When
+        # stars_total is zero, the truthful state is an empty embedded chart.
+        stars_int = int(stars_total or 0)
+        real_points = connector.get("points") or connector.get("star_history")
+        if real_points:
+            chart_points: list[dict[str, Any]] = list(real_points)
+        elif stars_int > 0:
+            # Only synthesize when we know the total — this approximates a
+            # plausible growth curve rather than fabricating it from nothing.
+            chart_points = _synthetic_series_from_total(stars_int)
+        else:
+            chart_points = []
         embed = build_chart_svg(
             chart_points,
             embed_vp,

{hyperweave-0.2.3 → hyperweave-0.2.4}/src/hyperweave/connectors/base.py

@@ -10,6 +10,8 @@ from urllib.parse import urlparse
 
 import httpx
 
+from hyperweave import __version__
+
 # SSRF Protection
 
 ALLOWED_HOSTS: frozenset[str] = frozenset(
@@ -161,7 +163,7 @@ async def fetch(
         )
 
     merged_headers: dict[str, str] = {
-        "User-Agent": "HyperWeave/0.1.0 (https://hyperweave.app)",
+        "User-Agent": f"HyperWeave/{__version__} (https://hyperweave.app)",
         "Accept": "application/json",
     }
     if headers:

{hyperweave-0.2.3 → hyperweave-0.2.4}/src/hyperweave/connectors/github.py

@@ -185,6 +185,37 @@ async def fetch_stargazer_history(
 
     # Step 2: compute total pages
     total_pages = max(1, math.ceil(total_stars / _STARGAZER_PAGE_SIZE))
+
+    # Single-page case: repo has ≤ 30 stars. The "first starred_at of the page"
+    # sampling trick would otherwise collapse to a single aggregated point plus
+    # a duplicate-date "now" point, producing a zero time-range polyline. Use
+    # each stargazer's own timestamp instead — the whole page fits in one call.
+    if total_pages == 1:
+        single_page_url = (
+            f"https://api.github.com/repos/{identifier}/stargazers"
+            f"?per_page={_STARGAZER_PAGE_SIZE}&page=1"
+        )
+        page_payload = await fetch_json(
+            single_page_url,
+            provider=PROVIDER,
+            headers={"Accept": _STARGAZER_ACCEPT_HEADER},
+        )
+        single_page_points: list[dict[str, Any]] = []
+        if isinstance(page_payload, list):
+            for idx, entry in enumerate(page_payload):
+                if isinstance(entry, dict) and entry.get("starred_at"):
+                    single_page_points.append(
+                        {"date": entry["starred_at"], "count": idx + 1}
+                    )
+        single_page_result: dict[str, Any] = {
+            "points": single_page_points,
+            "current_stars": total_stars,
+            "repo": identifier,
+            "ttl": STARGAZER_HISTORY_TTL,
+        }
+        cache.set(cache_key, single_page_result, STARGAZER_HISTORY_TTL)
+        return single_page_result
+
     # Cap the sample count at the number of available pages.
     sample_count = min(sample_pages, total_pages)
 

hyperweave-0.2.4/src/hyperweave/core/state.py

@@ -0,0 +1,45 @@
+"""State inference from label + value strings.
+
+Maps a (label, value) pair to one of the ArtifactStatus member values. Called
+by compose() to auto-populate spec.state when the caller left it at the
+default "active", so that a live badge whose fetched value is "failing"
+renders as failing without every route having to remember to call this.
+
+Inference is deliberately conservative: it returns "active" whenever no rule
+fires, which compose() treats as "caller did not override, leave alone".
+"""
+
+from __future__ import annotations
+
+
+def infer_state(label: str, value: str) -> str:
+    """Infer a semantic state from a (label, value) pair.
+
+    Returns one of: passing, failing, warning, building, critical, active.
+    "active" means "could not infer" — callers should treat it as unchanged.
+    """
+    label_lower = label.lower()
+    value_lower = value.lower()
+
+    if "pass" in value_lower or "success" in value_lower:
+        return "passing"
+    if "fail" in value_lower or "error" in value_lower:
+        return "failing"
+    if "warn" in value_lower:
+        return "warning"
+    if "build" in label_lower and "run" in value_lower:
+        return "building"
+
+    # Percentage-based threshold (e.g. "95%", "72.5%")
+    if value.rstrip("%").replace(".", "").isdigit():
+        try:
+            num = float(value.rstrip("%"))
+            if num >= 90:
+                return "passing"
+            if num >= 70:
+                return "warning"
+            return "critical"
+        except ValueError:
+            pass
+
+    return "active"

{hyperweave-0.2.3 → hyperweave-0.2.4}/src/hyperweave/data/profiles/chrome.yaml

@@ -16,7 +16,7 @@ badge_value_size: 11
 badge_value_weight: 700
 strip_corner: 0
 badge_corner: 0
-strip_accent_width: 6
+strip_accent_width: 4
 strip_metric_pitch: 107
 strip_divider_mode: minimal
 badge_frame_height: 22
@@ -51,7 +51,7 @@ strip_metric_label_y: 17
 strip_metric_value_weight: 800
 strip_metric_value_fill: "var(--dna-ink-primary)"
 strip_metric_value_y: 38
-strip_metric_value_skew: -8
+strip_metric_value_skew: 0
 strip_identity_font: "var(--dna-font-mono, 'Courier New', monospace)"
 strip_metric_label_font: "var(--dna-font-mono, 'Courier New', monospace)"
 

{hyperweave-0.2.3 → hyperweave-0.2.4}/src/hyperweave/kit.py

@@ -31,14 +31,14 @@ def _readme_kit(
     # Parse badges: "build:passing,version:v0.6.3,coverage:92%"
     badge_pairs = _parse_badge_string(badges)
 
-    # Generate badges
+    # Generate badges -- compose() infers state from value at the chokepoint,
+    # so we leave it at the default and let that logic fire.
     for label, value in badge_pairs:
         spec = ComposeSpec(
             type="badge",
             genome_id=genome,
             title=label,
             value=value,
-            state=_infer_state(label, value),
         )
         results[f"badge-{label.lower()}"] = compose(spec)
 
@@ -97,31 +97,3 @@ def _parse_badge_string(badges: str) -> list[tuple[str, str]]:
             k, v = pair.split(":", 1)
             pairs.append((k.strip(), v.strip()))
     return pairs
-
-
-def _infer_state(label: str, value: str) -> str:
-    label_lower = label.lower()
-    value_lower = value.lower()
-
-    if "pass" in value_lower or "success" in value_lower:
-        return "passing"
-    if "fail" in value_lower or "error" in value_lower:
-        return "failing"
-    if "warn" in value_lower:
-        return "warning"
-    if "build" in label_lower and "run" in value_lower:
-        return "building"
-
-    # Percentage-based threshold
-    if value.rstrip("%").replace(".", "").isdigit():
-        try:
-            num = float(value.rstrip("%"))
-            if num >= 90:
-                return "passing"
-            if num >= 70:
-                return "warning"
-            return "critical"
-        except ValueError:
-            pass
-
-    return "active"