hypermind 0.30.0__tar.gz → 0.30.1__tar.gz

{hypermind-0.30.0 → hypermind-0.30.1}/CHANGELOG.md

@@ -16,6 +16,11 @@ changes only on major-version bumps.
 
 _Current trunk._
 
+## [0.30.1] — 2026-07-08
+
+### Added
+- **Fancy quality panel with fill animation.** `hmctl orgs ask` now renders the answer + quality rubrics as a colour-graded Rich panel — per-rubric gauges (grounding, **hallucination**, calibration, consensus, …), an overall gauge, and a green/red hallucination callout. On a real terminal the gauges **animate (fill up)** on reveal; piped/CI output renders once. So hallucination and every other metric are now visible clearly, not a plain text list.
+
 ## [0.30.0] — 2026-07-08
 
 ### Added

{hypermind-0.30.0 → hypermind-0.30.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypermind
-Version: 0.30.0
+Version: 0.30.1
 Summary: Federated agent intelligence — reference SDK for the HyperMind SCITT contested-claims profile
 Project-URL: Homepage, https://github.com/ZySec-AI/hypermind
 Project-URL: Documentation, https://github.com/ZySec-AI/hypermind/tree/main/docs

{hypermind-0.30.0 → hypermind-0.30.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypermind"
-version = "0.30.0"
+version = "0.30.1"
 description = "Federated agent intelligence — reference SDK for the HyperMind SCITT contested-claims profile"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"

{hypermind-0.30.0 → hypermind-0.30.1}/src/hmctl/dashboard.py

@@ -176,3 +176,119 @@ class SimDashboard:
         return Panel(
             body, border_style="#00e5ff", title="live simulation", subtitle="hypermind.orgs"
         )
+
+
+# --- fancy quality / answer render (post-run) -----------------------------
+_WORSE = {"hallucination_rate", "dispute_exposure", "calibration_brier"}
+_LABELS = {
+    "provenance_coverage": "provenance",
+    "dispute_exposure": "dispute exposure",
+    "reputation_support": "reputation support",
+    "consensus": "consensus",
+    "abstention_ok": "abstention",
+    "grounding": "grounding",
+    "hallucination_rate": "hallucination",
+    "answer_relevance": "relevance",
+    "context_precision": "context precision",
+    "calibration_brier": "calibration (Brier)",
+    "self_consistency": "self-consistency",
+    "context_recall": "context recall",
+}
+
+
+def _score_colour(good: float) -> str:
+    return "#00ff9c" if good >= 0.8 else "#ffd166" if good >= 0.5 else "#ff5d8f"
+
+
+def _gauge(good: float, width: int = 24) -> Text:
+    filled = int(max(0.0, min(1.0, good)) * width)
+    t = Text()
+    t.append("█" * filled, style=_score_colour(good))
+    t.append("─" * (width - filled), style="grey30")
+    return t
+
+
+def _answer_panel(answer: Any) -> Panel:
+    ans = Text()
+    ans.append(f"{answer.stance.upper()}", style="bold #00e5ff")
+    ans.append(f"   confidence {answer.confidence:.2f}\n\n", style="grey70")
+    reasoning = answer.reasoning or ""
+    ans.append(reasoning[:700] + ("…" if len(reasoning) > 700 else ""), style="white")
+    if answer.contributors:
+        ans.append("\n\ndrew on: ", style="grey54")
+        ans.append(
+            ", ".join(f"{c.label}({c.reputation:.2f})" for c in answer.contributors[:5]),
+            style="grey62",
+        )
+    return Panel(ans, title="🧠 answer", border_style="#00e5ff", padding=(1, 2))
+
+
+def _quality_panel(report: Any, *, reveal: float = 1.0) -> Panel:
+    """Build the quality panel; ``reveal`` in [0,1] scales the gauges for the
+    fill animation (1.0 = final)."""
+    ov = report.overall() or 0.0
+    header = Text()
+    header.append(f"overall {ov * reveal:.2f}/1.00   ", style=f"bold {_score_colour(ov)}")
+    header.append_text(_gauge(ov * reveal))
+
+    grid = Table.grid(padding=(0, 2))
+    grid.add_column(justify="right")
+    grid.add_column()
+    grid.add_column(justify="right")
+    for name, label in _LABELS.items():
+        if name not in report.metrics:
+            continue
+        val = report.metrics[name]
+        good = (1.0 - val) if name in _WORSE else val
+        colour = _score_colour(good)
+        arrow = "↓" if name in _WORSE else "↑"
+        grid.add_row(
+            Text(f"{label} {arrow}", style="grey74"),
+            _gauge(good * reveal, 18),
+            Text(f"{val:.2f}" if reveal >= 1.0 else "", style=f"bold {colour}"),
+        )
+
+    parts: list[Any] = [header, Text(""), grid]
+    if reveal >= 1.0:  # callout + notes appear once the bars have filled
+        halluc = report.metrics.get("hallucination_rate")
+        if halluc is not None:
+            if halluc == 0:
+                parts += [Text(""), Text(
+                    "✓ no hallucination detected — every claim grounded in context",
+                    style="bold #00ff9c")]
+            else:
+                c = Text(f"⚠ {len(report.hallucinated_claims)} unsupported claim(s):",
+                         style="bold #ff5d8f")
+                for claim in report.hallucinated_claims[:4]:
+                    c.append(f"\n    • {claim}", style="#ff5d8f")
+                parts += [Text(""), c]
+        for n in report.notes:
+            parts.append(Text(f"· {n}", style="grey42"))
+    return Panel(
+        Group(*parts),
+        title="📊 answer quality",
+        border_style=_score_colour(ov),
+        subtitle="hypermind.orgs · quality rubrics",
+        padding=(1, 2),
+    )
+
+
+def render_answer_quality(
+    console: Console, answer: Any, report: Any = None, *, animate: bool = True
+) -> None:
+    """Print the answer + a colourful quality panel. On a real terminal the
+    gauges **fill up** with a short reveal animation; piped/CI output renders
+    the final frame once (deterministic, no sleeps)."""
+    console.print(_answer_panel(answer))
+    if report is None:
+        return
+    if animate and console.is_terminal:
+        import time
+
+        frames = 22
+        with Live(console=console, refresh_per_second=60) as live:
+            for f in range(frames + 1):
+                live.update(_quality_panel(report, reveal=f / frames))
+                time.sleep(0.022)
+    else:
+        console.print(_quality_panel(report, reveal=1.0))

{hypermind-0.30.0 → hypermind-0.30.1}/src/hmctl/orgs_cmd.py

@@ -256,9 +256,11 @@ def ask_cmd(
             return answer, report
 
     answer, report = _run(go, dash)
-    answer.print()
-    if report is not None:
-        report.print()
+    from rich.console import Console
+
+    from hmctl.dashboard import render_answer_quality
+
+    render_answer_quality(Console(), answer, report)
 
 
 @orgs.command("distributed")

{hypermind-0.30.0 → hypermind-0.30.1}/src/hypermind/__init__.py

@@ -73,7 +73,7 @@ open = HyperMindAgent.open
 #: is held until the §External & human gates clear (IETF I-D, IANA,
 #: third-party audit, OpenSSF acceptance, ≥3 pilots) — at that point we
 #: cut ``1.0.0`` GA. See ROADMAP.md §Status snapshot.
-__version__ = "0.30.0"
+__version__ = "0.30.1"
 
 #: SLSA build-provenance level committed for every release artefact.
 #: Cosign keyless signing + slsa-github-generator + PEP 740 attestations

{hypermind-0.30.0 → hypermind-0.30.1}/tests/test_cli_orgs.py

@@ -48,13 +48,19 @@ class _Report:
 
 
 class _Answer:
-    def print(self):
-        print("ANSWER-PRINTED")
+    stance = "supports"
+    confidence = 0.88
+    reasoning = "ANSWER-PRINTED reasoning text"
+    contributors: ClassVar = []
 
 
 class _Quality:
-    def print(self):
-        print("QUALITY-PRINTED")
+    metrics: ClassVar = {"grounding": 1.0, "hallucination_rate": 0.0}
+    hallucinated_claims: ClassVar = []
+    notes: ClassVar = ["QUALITY-PRINTED note"]
+
+    def overall(self):
+        return 0.97
 
 
 class _FakeSim:

{hypermind-0.30.0 → hypermind-0.30.1}/tests/test_dashboard.py

@@ -3,10 +3,11 @@
 from __future__ import annotations
 
 import io
+import types
 
 from rich.console import Console
 
-from hmctl.dashboard import SimDashboard, _spark
+from hmctl.dashboard import SimDashboard, _spark, render_answer_quality
 
 
 def _dash() -> SimDashboard:
@@ -54,3 +55,42 @@ def test_spark_scales_and_handles_empty():
     assert str(_spark([]))  # no crash on empty
     s = _spark([0, 1, 2, 3, 4, 8])
     assert len(str(s)) >= 6  # one glyph per value
+
+
+def _answer(reasoning="an answer"):
+    return types.SimpleNamespace(
+        stance="supports", confidence=0.88, reasoning=reasoning,
+        contributors=[types.SimpleNamespace(label="a/O#1", reputation=0.9)],
+    )
+
+
+def _report(halluc, claims=(), notes=()):
+    return types.SimpleNamespace(
+        metrics={"grounding": 1.0, "hallucination_rate": halluc, "consensus": 0.9},
+        hallucinated_claims=list(claims), notes=list(notes), overall=lambda: 0.95,
+    )
+
+
+def test_quality_panel_clean_answer():
+    con = Console(file=io.StringIO(), width=100)
+    render_answer_quality(con, _answer(), _report(0.0, notes=["x: SKIPPED"]))
+    out = con.file.getvalue()
+    assert "answer quality" in out
+    assert "no hallucination" in out
+    assert "hallucination" in out and "grounding" in out
+
+
+def test_quality_panel_flags_hallucination():
+    con = Console(file=io.StringIO(), width=100)
+    render_answer_quality(con, _answer(), _report(1.0, claims=["fabricated stat"]))
+    out = con.file.getvalue()
+    assert "unsupported claim" in out
+    assert "fabricated stat" in out
+
+
+def test_answer_only_without_report():
+    con = Console(file=io.StringIO(), width=100)
+    render_answer_quality(con, _answer("just the answer"), None)
+    out = con.file.getvalue()
+    assert "answer" in out
+    assert "answer quality" not in out  # no report → no quality panel