speclogician 0.0.0b1__py3-none-any.whl

speclogician/presentation/renderers/instances_list.py

@@ -0,0 +1,120 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/renderers/instances_list.py
+#
+
+from __future__ import annotations
+
+from rich import box
+from rich.panel import Panel
+from rich.table import Table, Column
+from rich.text import Text
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.instances_list import InstancesListPM
+
+
+def _bullet_list(changes: str) -> Text:
+    """
+    Render a comma-separated change list as a left-aligned bullet list.
+    """
+    if not changes:
+        return Text("–", style="dim")
+
+    items = [c.strip() for c in changes.split(",") if c.strip()]
+    if not items:
+        return Text("–", style="dim")
+
+    txt = Text()
+    for i, item in enumerate(items):
+        if i > 0:
+            txt.append("\n")
+        txt.append("• ", style="dim")
+        txt.append(item)
+    return txt
+
+
+def render_instances_list(pm: InstancesListPM, *, ctx: RenderCtx):
+    b = box.MINIMAL if ctx.compact else box.SIMPLE
+
+    columns = [
+        Column(header="State ID", justify="center"),
+        Column(header="Changes", justify="left"),
+        Column(header="Domain model", justify="center"),
+        Column(header="Preds\n# (Errors, Used)", justify="center"),
+        Column(header="Scenarios\n# (Errors, Used)", justify="center"),
+        Column(header="Test traces\n# (Formalized, Matched)", justify="center"),
+        Column(header="Log traces\n# (Formalized, Matched)", justify="center"),
+        Column(header="Src code arts\n# (Matched)", justify="center"),
+        Column(header="Doc arts\n# (Matched)", justify="center"),
+    ]
+
+    t = Table(
+        *columns,
+        title="SpecLogician State List",
+        expand=True,
+        highlight=True,
+        show_edge=False,
+        box=b,
+    )
+
+    for idx, row in enumerate(pm.rows):
+        if idx > 0:
+            t.add_section()  # thin separator between instances
+
+        s = row.summary
+
+        # ---- Domain model ----
+        domain_str = str(getattr(s, "base_status", "unknown"))
+
+        # ---- Predicates (totals) ----
+        preds_total = int(getattr(s, "num_preds_total", 0) or 0)
+        preds_err = int(getattr(s, "num_preds_errored", 0) or 0)
+        preds_used = int(getattr(s, "num_preds_matched", 0) or 0)
+        preds_str = f"{preds_total} ({preds_err}, {preds_used})"
+
+        # These are also available:
+        #   num_state_preds_total / matched / errored
+        #   num_action_preds_total / matched / errored
+
+        # ---- Scenarios ----
+        sc_total = int(getattr(s, "num_sc_total", 0) or 0)
+        sc_missing = int(getattr(s, "num_sc_missing", 0) or 0)
+        sc_inconsistent = int(getattr(s, "num_sc_inconsistent", 0) or 0)
+        sc_conflicted = int(getattr(s, "num_sc_conflicted", 0) or 0)
+
+        # "Errors" bucket includes: missing + inconsistent + conflicted
+        sc_err = sc_missing + sc_inconsistent + sc_conflicted
+        sc_used = int(getattr(s, "num_sc_matched", 0) or 0)
+        sc_str = f"{sc_total} ({sc_err}, {sc_used})"
+
+        # ---- Test traces ----
+        tt_total = int(getattr(s, "num_test_traces_total", 0) or 0)
+        tt_formal = int(getattr(s, "num_test_traces_logic_good", 0) or 0)
+        tt_matched = int(getattr(s, "num_test_traces_matched", 0) or 0)
+        test_str = f"{tt_total} ({tt_formal}, {tt_matched})"
+
+        # ---- Log traces ----
+        lt_total = int(getattr(s, "num_log_traces_total", 0) or 0)
+        lt_formal = int(getattr(s, "num_log_traces_logic_good", 0) or 0)
+        lt_matched = int(getattr(s, "num_log_traces_matched", 0) or 0)
+        log_str = f"{lt_total} ({lt_formal}, {lt_matched})"
+
+        # ---- Data artifacts ----
+        src_matched = int(getattr(s, "num_src_code_arts_matched", 0) or 0)
+        doc_matched = int(getattr(s, "num_doc_arts_matched", 0) or 0)
+
+        t.add_row(
+            Text(row.state_label, style="bold green" if idx == 0 else ""),
+            _bullet_list(row.changes),
+            Text(domain_str),
+            Text(preds_str),
+            Text(sc_str),
+            Text(test_str),
+            Text(log_str),
+            Text(str(src_matched)),
+            Text(str(doc_matched)),
+        )
+
+    return Panel(t, title="[bold]Instances[/bold]", border_style="magenta")

speclogician/presentation/renderers/predicate.py

@@ -0,0 +1,180 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/renderers/predicate.py
+#
+
+from __future__ import annotations
+
+from rich import box
+from rich.console import Group, RenderableType
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.text import Text
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.predicate import PredicatePM, TransitionPM
+from speclogician.utils import IMLValidity
+
+
+# -----------------------------------------------------------------------------
+# small helpers
+# -----------------------------------------------------------------------------
+
+def _meta_table(*, ctx: RenderCtx) -> Table:
+    b = box.MINIMAL if getattr(ctx, "compact", False) else box.SIMPLE
+    t = Table(
+        show_header=False,
+        box=b,
+        show_edge=False,
+        pad_edge=False,
+        expand=False,
+    )
+    # Make keys a bit more prominent than before (consistent with your newer style)
+    t.add_column(style="bold", no_wrap=True)
+    t.add_column(justify="left")
+    return t
+
+
+def _badge(v: IMLValidity) -> Text:
+    # Normalize: v may be enum; keep it robust
+    s = (getattr(v, "value", str(v)) or "").lower()
+
+    if s == "valid":
+        return Text("✓ valid", style="bold green")
+    if s == "invalid":
+        return Text("✗ invalid", style="bold red")
+    if s == "unknown":
+        return Text("? unknown", style="bold yellow")
+    return Text(str(getattr(v, "value", v)), style="bold yellow")
+
+
+def _empty(text: str = "∅ empty") -> Text:
+    return Text(text, style="dim")
+
+
+def _code_block(*, title: str, code: str, lang: str) -> RenderableType:
+    # word_wrap=True tends to look better in narrow terminals
+    return Panel(
+        Syntax(code, lang, line_numbers=False, word_wrap=True),
+        title=title,
+        border_style="cyan",
+    )
+
+
+def _snippet(s: str, *, limit: int = 200) -> str:
+    s2 = (s or "").strip()
+    if not s2:
+        return ""
+    if len(s2) <= limit:
+        return s2
+    return s2[:limit] + "…"
+
+
+def section(t: Table, label: str) -> None:
+    t.add_row(Text(label, style="italic dim"), Text(""))
+
+def field(t: Table, name: str, value: Text | str) -> None:
+    t.add_row(
+        Text(f"  {name}", style="bold"),  # ⬅️ indent
+        value if isinstance(value, Text) else Text(str(value)),
+    )
+
+
+# -----------------------------------------------------------------------------
+# main renderers
+# -----------------------------------------------------------------------------
+
+def render_predicate(pm: PredicatePM, *, ctx: RenderCtx) -> RenderableType:
+    t = _meta_table(ctx=ctx)
+
+    # ── Identity ─────────────────────────────
+    section(t, "Identity")
+    field(t, "name", Text(pm.name or "-", style="bold"))
+    field(t, "signature", Text(pm.signature or "", style="dim"))
+    field(t, "type", Text(str(pm.pred_type), style="cyan"))
+    if ctx.show_ids:
+        field(t, "comp_id", Text(pm.comp_id or "", style="dim"))
+    field(t, "updated", Text(pm.last_updated.isoformat(), style="dim"))
+
+    # ── Logic ────────────────────────────────
+    section(t, "Logic")
+    field(t, "iml_valid", _badge(pm.is_iml_valid))
+    if pm.iml_error:
+        field(t, "iml_error", Text(pm.iml_error, style="red"))
+
+    # ── Connections ──────────────────────────
+    section(t, "Connections")
+    field(t, "linked artifacts", pm.links.total)
+    field(t, "test / log traces", f"{pm.links.test_traces}/{pm.links.log_traces}")
+    field(t, "doc / src refs", f"{pm.links.doc_refs}/{pm.links.src_code_refs}")
+    if pm.links.unresolved_ids:
+        field(t, "unresolved", Text(str(pm.links.unresolved_ids), style="yellow"))
+
+    blocks: list[RenderableType] = [t]
+
+    if ctx.show_code:
+        blocks.append(Text(""))
+        blocks.append(
+            Panel(
+                Syntax(pm.iml or "(* empty *)", "ocaml", word_wrap=True),
+                title="iml",
+                border_style="cyan",
+            )
+        )
+
+    border = "blue" if pm.kind == "state_predicate" else "magenta"
+    return Panel(
+        Group(*blocks),
+        title=f"[bold]Predicate[/bold]: {pm.name or '-'}",
+        border_style=border,
+    )
+
+
+def render_transition(pm: TransitionPM, *, ctx: RenderCtx) -> RenderableType:
+    t = _meta_table(ctx=ctx)
+
+    # Section: identity
+    t.add_row(Text("Identity", style="italic dim"), Text(""))
+    t.add_row(Text("name"), Text(pm.name or "-", style="bold"))
+    t.add_row(Text("signature"), Text(pm.signature or "", style="dim"))
+    if ctx.show_ids:
+        t.add_row(Text("comp_id"), Text(pm.comp_id or "", style="dim"))
+    t.add_row(Text("updated"), Text(pm.last_updated.isoformat(), style="dim"))
+
+    # Section: logic
+    t.add_row(Text("Logic", style="italic dim"), Text(""))
+    t.add_row(Text("iml_valid"), _badge(pm.is_iml_valid))
+    if pm.iml_error:
+        t.add_row(Text("iml_error"), Text(pm.iml_error, style="red"))
+
+    # Section: connections
+    t.add_row(Text("Connections", style="italic dim"), Text(""))
+    t.add_row(Text("linked artifacts"), Text(str(pm.links.total)))
+    t.add_row(Text("test/log traces"), Text(f"{pm.links.test_traces}/{pm.links.log_traces}"))
+    t.add_row(Text("doc/src refs"), Text(f"{pm.links.doc_refs}/{pm.links.src_code_refs}"))
+    if pm.links.unresolved_ids:
+        t.add_row(Text("unresolved"), Text(str(pm.links.unresolved_ids), style="yellow"))
+
+    blocks: list[RenderableType] = [t]
+
+    if ctx.show_code:
+        blocks.append(Text(""))
+        blocks.append(
+            _code_block(
+                title="iml",
+                code=(pm.iml or "(* empty *)"),
+                lang="ocaml",
+            )
+        )
+    else:
+        snip = _snippet(pm.iml or pm.src_code, limit=120)
+        blocks.append(Text(""))
+        blocks.append(Text(f"iml: {snip}" if snip else "iml: ∅", style="dim"))
+
+    return Panel(
+        Group(*blocks),
+        title=f"[bold]Transition[/bold]: {pm.name or '-'}",
+        border_style="green",
+    )

speclogician/presentation/renderers/recommendations.py

@@ -0,0 +1,90 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/renderers/recommendations.py
+#
+
+
+from __future__ import annotations
+
+from rich import box
+from rich.console import Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.recommendations import RecommendationsPM, RecommendationPM
+
+
+def _kind_style(kind: str) -> str:
+    k = (kind or "").lower()
+    if k == "error":
+        return "red"
+    if k == "warning":
+        return "yellow"
+    if k == "info":
+        return "cyan"
+    return "green"  # next
+
+
+def _header(pm: RecommendationsPM) -> Text:
+    parts = []
+    if pm.num_error:
+        parts.append(Text(f"{pm.num_error} error", style="red"))
+    if pm.num_warning:
+        parts.append(Text(f"{pm.num_warning} warning", style="yellow"))
+    if pm.num_next:
+        parts.append(Text(f"{pm.num_next} next", style="green"))
+    if pm.num_info:
+        parts.append(Text(f"{pm.num_info} info", style="cyan"))
+
+    if not parts:
+        return Text("No recommendations", style="dim")
+
+    out = Text(" • ").join(parts)
+    return out
+
+
+def _render_item(r: RecommendationPM, *, show_priority: bool) -> list[Text]:
+    style = _kind_style(r.kind)
+    left = Text(r.kind.upper(), style=f"bold {style}")
+    if show_priority:
+        left.append(f"  p{r.priority}", style="dim")
+    body = Text(r.text)
+    return [left, body]
+
+
+def render_recommendations(pm: RecommendationsPM, *, ctx: RenderCtx) -> Panel:
+    b = box.MINIMAL if ctx.compact else box.SIMPLE
+
+    if pm.count == 0:
+        body = Text("— none —", style="dim")
+        return Panel(body, title="Recommendations", border_style="dim", box=b)
+
+    show_priority = ctx.show_ids  # cheap reuse: if ids are shown, show pri too
+
+    t = Table(
+        box=b,
+        pad_edge=False,
+        show_edge=False,
+        expand=True,
+        show_header=False,
+    )
+    t.add_column(style="dim", no_wrap=True)
+    t.add_column(no_wrap=False)
+
+    # In compact mode, show fewer items (but keep deterministic)
+    items = pm.items
+    if ctx.compact and len(items) > 8:
+        items = items[:8]
+
+    for r in items:
+        left, body = _render_item(r, show_priority=show_priority)
+        t.add_row(left, body)
+
+    blocks = [t]
+    # show a small header line if useful
+    blocks.insert(0, _header(pm))
+
+    return Panel(Group(*blocks), title="Recommendations", border_style="cyan", box=b)

speclogician/presentation/renderers/scenario.py

@@ -0,0 +1,94 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/renderers/scenario.py
+#
+
+from __future__ import annotations
+
+from rich import box
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.scenario import ScenarioPM
+
+
+def _status_style(kind: str) -> str:
+    k = (kind or "").lower()
+    if k == "valid":
+        return "green"
+    if k == "missing":
+        return "yellow"
+    if k == "inconsistent":
+        return "red"
+    return "dim"
+
+
+def _section(label: str) -> Text:
+    return Text(label, style="italic magenta")
+
+
+def _bool_badge(v: bool) -> Text:
+    return Text("✓" if v else "✗", style=("green" if v else "red"))
+
+
+def _names_block(items: list[str], *, empty: str = "—") -> Text:
+    """
+    Render a list of names as plain styled text (no Syntax, no black background).
+    """
+    if not items:
+        return Text(empty, style="dim")
+
+    out = Text()
+    for i, name in enumerate(items):
+        if i:
+            out.append("\n")
+        out.append("• ", style="dim")
+        out.append(name, style="cyan")
+    return out
+
+
+def render_scenario(pm: ScenarioPM, *, ctx: RenderCtx) -> Panel:
+    status_style = _status_style(pm.status.kind)
+
+    title = Text.assemble(
+        ("Scenario: ", "bold"),
+        (pm.name or "(unnamed)", "cyan"),
+    )
+
+    b = box.MINIMAL if ctx.compact else box.SIMPLE
+    t = Table(
+        show_header=False,
+        box=b,
+        pad_edge=False,
+        show_edge=False,
+        expand=False,
+    )
+    t.add_column(style="italic dim", no_wrap=True)
+    t.add_column(no_wrap=False)
+
+    # optional id
+    if ctx.show_ids:
+        t.add_row("comp_id", Text(pm.comp_id, style="dim"))
+
+    # Predicates
+    t.add_row(_section("Predicates"), Text(""))
+    t.add_row("  given", _names_block(pm.given))
+    t.add_row("  when", _names_block(pm.when))
+    t.add_row("  then", _names_block(pm.then))
+
+    # Checks
+    t.add_row(_section("Checks"), Text(""))
+    t.add_row("  given consistent", _bool_badge(pm.given_preds_consistent))
+    t.add_row("  when consistent", _bool_badge(pm.when_preds_consistent))
+    t.add_row("  all consistent", _bool_badge(pm.all_preds_consistent))
+
+    # Missing components
+    if getattr(ctx, "show_missing_components", False) and pm.status.kind == "missing":
+        t.add_row(_section("Missing"), Text(""))
+        t.add_row("  predicates", _names_block(pm.status.missing_preds))
+        t.add_row("  transitions", _names_block(pm.status.missing_trans))
+
+    return Panel(t, title=title, border_style=status_style)

speclogician/presentation/renderers/scenario_complement.py

@@ -0,0 +1,59 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/renderers/scenario_complement.py
+#
+
+from __future__ import annotations
+
+from rich.console import Group
+from rich.panel import Panel
+from rich.text import Text
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.scenario_complement import ScenarioComplementPM
+
+
+def render_scenario_complement(pm: ScenarioComplementPM, ctx: RenderCtx):
+    # Header summary
+    hdr = Text()
+    hdr.append("Regions: ")
+    hdr.append(str(pm.count_regions), style="bold")
+
+    if not pm.regions_preview:
+        return Panel(
+            Group(hdr, Text("— no regions (or not computed yet) —")),
+            title="Scenario Complement",
+        )
+
+    lines = []
+    for r in pm.regions_preview:
+        # One-liner summary
+        line = Text()
+        line.append(r.fp, style="bold")
+        line.append("  ")
+        line.append(f"constraints={r.num_constraints}")
+
+        # If we have extra details, add small indented lines
+        blocks = [line]
+        if r.invariant:
+            blocks.append(Text(f"  inv: {r.invariant}"))
+        if r.constraints_preview:
+            blocks.append(Text(f"  c0: {r.constraints_preview[0]}"))
+            for c in r.constraints_preview[1:]:
+                blocks.append(Text(f"      {c}"))
+        if r.model_eval:
+            blocks.append(Text(f"  eval: {r.model_eval}"))
+        if r.model:
+            blocks.append(Text(f"  model: {r.model}"))
+
+        lines.append(Group(*blocks))
+
+    tail = Text()
+    if pm.count_regions > len(pm.regions_preview):
+        tail.append(f"(showing {len(pm.regions_preview)} of {pm.count_regions})", style="dim")
+
+    return Panel(
+        Group(hdr, *lines, tail),
+        title="Scenario Complement",
+    )