speclogician 0.0.0b1__py3-none-any.whl

speclogician/presentation/preview/fixtures/trace.py

@@ -0,0 +1,206 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/trace.py
+#
+
+from __future__ import annotations
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.trace import (
+    TraceIMLValidityPM,
+    TraceCorePM,
+    TestTracePM,
+    LogTracePM,
+)
+from speclogician.presentation.renderers.trace import (
+    render_test_trace,
+    render_log_trace,
+)
+
+
+# -----------------------------------------------------------------------------
+# Shared helpers
+# -----------------------------------------------------------------------------
+
+def minimal_iml_validity() -> TraceIMLValidityPM:
+    return TraceIMLValidityPM(iml_valid="unknown", err=None)
+
+def typical_iml_validity_valid() -> TraceIMLValidityPM:
+    return TraceIMLValidityPM(iml_valid="valid", err=None)
+
+def typical_iml_validity_invalid() -> TraceIMLValidityPM:
+    return TraceIMLValidityPM(
+        iml_valid="invalid",
+        err="Parse error: expected ')' at line 1, col 12",
+    )
+
+def edge_iml_validity_invalid_long() -> TraceIMLValidityPM:
+    return TraceIMLValidityPM(
+        iml_valid="invalid",
+        err=(
+            "Type error: cannot unify int and bool in expression "
+            "`if s.x > 0 then 1 else false` (line 42, col 3). "
+            "Hint: check predicate body and variable bindings."
+        ),
+    )
+
+def minimal_trace_core() -> TraceCorePM:
+    return TraceCorePM(
+        art_id="00000000-0000-0000-0000-000000000000",
+        given="",
+        when=None,
+        then=None,
+        time="",
+        iml_validity=minimal_iml_validity(),
+    )
+
+def typical_trace_core_ok(*, art_id: str = "11111111-1111-1111-1111-111111111111") -> TraceCorePM:
+    return TraceCorePM(
+        art_id=art_id,
+        given="{ x = 10 }",
+        when="{ a = 2 }",
+        then="{ x = 12 }",
+        time="2026-01-09T10:12:00Z",
+        iml_validity=typical_iml_validity_valid(),
+    )
+
+def typical_trace_core_invalid(*, art_id: str = "22222222-2222-2222-2222-222222222222") -> TraceCorePM:
+    return TraceCorePM(
+        art_id=art_id,
+        given="{ x = 10 }",
+        when="{ a = 2 }",
+        then="{ x = 12 }",
+        time="2026-01-09T10:13:00Z",
+        iml_validity=typical_iml_validity_invalid(),
+    )
+
+def edge_trace_core_long(*, art_id: str = "99999999-9999-9999-9999-999999999999") -> TraceCorePM:
+    # Deliberately long / multi-line / weird to stress renderers
+    return TraceCorePM(
+        art_id=art_id,
+        given=(
+            "{ x = 10; notes = \"a very long string value that will wrap in tables\"; "
+            "nested = { y = 1234567890; z = -42 } }"
+        ),
+        when="{ a = 2; meta = \"multiline\\nwith newlines\\nand spaces\\n\" }",
+        then="{ x = 12; result = Some \"OK\"; debug = \"a\" ^ \"b\" ^ \"c\" }",
+        time="2026-01-09T10:12:00.123456Z",
+        iml_validity=edge_iml_validity_invalid_long(),
+    )
+
+# -----------------------------------------------------------------------------
+# TestTracePM fixtures
+# -----------------------------------------------------------------------------
+
+def minimal_test_trace_pm() -> TestTracePM:
+    return TestTracePM(
+        core=minimal_trace_core(),
+        name="",
+        filepath="",
+        language=None,
+        contents=None,
+    )
+
+def typical_test_trace_pm(*, with_contents: bool = False, invalid: bool = False) -> TestTracePM:
+    core = typical_trace_core_invalid() if invalid else typical_trace_core_ok()
+    return TestTracePM(
+        core=core,
+        name="Two parent orders, one rejected",
+        filepath="tests/risk/OrderValidationSpec.groovy",
+        language="groovy",
+        contents=(
+            "given: '...'\nwhen: '...'\nthen: '...'\n"
+            if with_contents
+            else None
+        ),
+    )
+
+def edge_test_trace_pm() -> TestTracePM:
+    return TestTracePM(
+        core=edge_trace_core_long(),
+        name="test_" + ("really_long_name_" * 6) + "end",
+        filepath=("very/long/path/" * 8) + "OrderValidationSpec.groovy",
+        language="groovy",
+        contents=(
+            "given: \"A very long test body that includes code\"\n"
+            + ("// line\n" * 60)
+            + "then: \"assert something\"\n"
+        ),
+    )
+
+# -----------------------------------------------------------------------------
+# LogTracePM fixtures
+# -----------------------------------------------------------------------------
+
+def minimal_log_trace_pm() -> LogTracePM:
+    return LogTracePM(
+        core=minimal_trace_core(),
+        filename="",
+        contents=None,
+    )
+
+def typical_log_trace_pm(*, with_contents: bool = False, invalid: bool = False) -> LogTracePM:
+    core = typical_trace_core_invalid() if invalid else typical_trace_core_ok(
+        art_id="33333333-3333-3333-3333-333333333333"
+    )
+    return LogTracePM(
+        core=core,
+        filename="prod_2026-01-09_FIX.log",
+        contents=("8=FIX.4.4|9=...|35=D|..." if with_contents else None),
+    )
+
+def edge_log_trace_pm() -> LogTracePM:
+    return LogTracePM(
+        core=edge_trace_core_long(art_id="aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"),
+        filename="prod_" + ("2026-01-09_" * 5) + "huge_FIX.log",
+        contents=("8=FIX.4.4|9=...|35=D|...\n" * 200),
+    )
+
+# -----------------------------------------------------------------------------
+# Fixture entrypoints for PreviewSpec(make=...)
+# -----------------------------------------------------------------------------
+
+def make_test_trace_pm(ctx: RenderCtx, variant: str) -> TestTracePM:
+    """
+    Entry point used by PreviewSpec(make=...).
+
+    Variants:
+      - typical: valid + includes original contents
+      - minimal: smallest possible (no code blocks / metadata)
+      - edge: long values + invalid + lots of contents
+    """
+    v = (variant or "").strip().lower()
+    if v == "typical":
+        # typical should exercise code rendering; include original contents
+        return typical_test_trace_pm(with_contents=True, invalid=False)
+    if v == "minimal":
+        return minimal_test_trace_pm()
+    if v == "edge":
+        return edge_test_trace_pm()
+    raise ValueError(f"Unknown variant: {variant!r}")
+
+
+def make_log_trace_pm(ctx: RenderCtx, variant: str) -> LogTracePM:
+    """
+    Entry point used by PreviewSpec(make=...).
+
+    Variants:
+      - typical: valid + includes log contents
+      - minimal: smallest possible
+      - edge: long values + invalid + lots of contents
+    """
+    v = (variant or "").strip().lower()
+    if v == "typical":
+        return typical_log_trace_pm(with_contents=True, invalid=False)
+    if v == "minimal":
+        return minimal_log_trace_pm()
+    if v == "edge":
+        return edge_log_trace_pm()
+    raise ValueError(f"Unknown variant: {variant!r}")
+
+def render_test(pm: TestTracePM, ctx: RenderCtx):
+    return render_test_trace(pm, ctx=ctx)
+
+
+def render_log(pm: LogTracePM, ctx: RenderCtx):
+    return render_log_trace(pm, ctx=ctx)

speclogician/presentation/preview/registry.py

@@ -0,0 +1,42 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/registry.py
+#   
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Any
+
+from speclogician.presentation.ctx import RenderCtx
+
+
+@dataclass(frozen=True)
+class PreviewSpec:
+    """
+    A preview entry in the registry.
+    - make(ctx, variant) returns a *PM object* (pydantic model)
+    - render(pm, ctx) returns a Rich renderable
+    """
+    name: str
+    variants: tuple[str, ...]
+    make: Callable[[RenderCtx, str], Any]
+    render: Callable[[Any, RenderCtx], Any]
+
+
+_REGISTRY: dict[str, PreviewSpec] = {}
+
+
+def register(spec: PreviewSpec) -> None:
+    _REGISTRY[spec.name] = spec
+
+
+def get(name: str) -> PreviewSpec:
+    if name not in _REGISTRY:
+        raise KeyError(f"Unknown preview: {name}. Available: {', '.join(sorted(_REGISTRY))}")
+    return _REGISTRY[name]
+
+
+def list_previews() -> list[PreviewSpec]:
+    return [*_REGISTRY.values()]

speclogician/presentation/renderers/__init__.py

@@ -0,0 +1,24 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/renderers/__init__.py (or similar)
+#
+
+from __future__ import annotations
+
+def iml_validity_icon_style_label(iml_valid: str | None) -> tuple[str, str, str]:
+    """
+    Returns: (icon, rich_style, human_label)
+    """
+    v = (iml_valid or "").lower()
+
+    match v:
+        case "valid":
+            return ("✓", "green", "valid")
+        case "invalid":
+            return ("✗", "red", "invalid")
+        case "unknown" | "":
+            return ("…", "yellow", "unknown")
+        case _:
+            # forward-compatible / defensive
+            return ("?", "dim", v)

speclogician/presentation/renderers/container.py

@@ -0,0 +1,136 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/renderers/container.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 rich.rule import Rule
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.container import ArtifactContainerPM
+from speclogician.presentation.renderers.trace import render_test_trace, render_log_trace
+from speclogician.presentation.renderers.data_artifact import render_doc_ref, render_src_code_ref
+
+
+def _group_with_separators(renderables: list[object], *, style: str = "dim") -> Group:
+    """
+    Render list items with a horizontal separator between them.
+    """
+    parts: list[object] = []
+    for i, r in enumerate(renderables):
+        parts.append(r)
+        if i < len(renderables) - 1:
+            parts.append(Rule(style=style))
+    return Group(*parts)
+
+
+def render_artifact_container(pm: ArtifactContainerPM, *, ctx: RenderCtx):
+    b = box.MINIMAL if ctx.compact else box.SIMPLE
+
+    # --- Counts table ---
+    t = Table(
+        show_header=False,
+        box=b,
+        show_edge=False,
+        pad_edge=False,
+        expand=False,          
+    )
+
+    t.add_column(no_wrap=True)
+    t.add_column(
+        justify="right",
+        width=6,
+    )
+
+    def section(title: str) -> None:
+        t.add_row(
+            Text(title, style="bold magenta"),
+            Text(""),
+        )
+
+    def metric(label: str, value: int, *, icon: str = "•") -> None:
+        t.add_row(
+            Text(f"  {icon} {label}", style="dim"),
+            Text(str(value)),
+        )
+
+    c = pm.counts
+
+    section("Test traces")
+    metric("Total", c.num_test_traces_total)
+    metric("Matched", c.num_test_traces_matched, icon="✓")
+    metric("Valid IML", c.num_test_traces_logic_good, icon="✓")
+
+    section("Log traces")
+    metric("Total", c.num_log_traces_total)
+    metric("Matched", c.num_log_traces_matched, icon="✓")
+    metric("Valid IML", c.num_log_traces_logic_good, icon="✓")
+
+    section("Source code refs")
+    metric("Total", c.num_src_code_arts_total)
+    metric("Matched", c.num_src_code_arts_matched, icon="✓")
+
+    section("Doc refs")
+    metric("Total", c.num_doc_arts_total)
+    metric("Matched", c.num_doc_arts_matched, icon="✓")
+
+    if ctx.show_stats_only:
+        return Panel(
+            t,
+            title="[bold]Artifacts[/bold]",
+            border_style="magenta",
+        )
+
+    blocks: list[object] = [Panel(t, title="[bold]Counts[/bold]", border_style="magenta")]
+
+    # --- Split by type ---
+    items = pm.items
+
+    if items.test_traces:
+        rendered = [render_test_trace(x, ctx=ctx) for x in items.test_traces]
+        blocks.append(
+            Panel(
+                _group_with_separators(rendered),
+                title=f"[bold]Test traces[/bold] ({len(items.test_traces)})",
+                border_style="cyan",
+            )
+        )
+
+    if items.log_traces:
+        rendered = [render_log_trace(x, ctx=ctx) for x in items.log_traces]
+        blocks.append(
+            Panel(
+                _group_with_separators(rendered),
+                title=f"[bold]Log traces[/bold] ({len(items.log_traces)})",
+                border_style="cyan",
+            )
+        )
+
+    if items.doc_refs:
+        rendered = [render_doc_ref(x, ctx=ctx) for x in items.doc_refs]
+        blocks.append(
+            Panel(
+                _group_with_separators(rendered),
+                title=f"[bold]Doc refs[/bold] ({len(items.doc_refs)})",
+                border_style="green",
+            )
+        )
+
+    if items.src_code_refs:
+        rendered = [render_src_code_ref(x, ctx=ctx) for x in items.src_code_refs]
+        blocks.append(
+            Panel(
+                _group_with_separators(rendered),
+                title=f"[bold]Src code refs[/bold] ({len(items.src_code_refs)})",
+                border_style="green",
+            )
+        )
+
+    return Panel(Group(*blocks), title="[bold]Artifact container[/bold]", border_style="magenta")

speclogician/presentation/renderers/data_artifact.py

@@ -0,0 +1,144 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/renderers/data_artifact.py
+#
+
+from rich.console import Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.syntax import Syntax
+from rich.rule import Rule
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.data_artifact import DocRefPM, SrcCodeRefPM
+
+
+def _kv_table(ctx: RenderCtx) -> Table:
+    # tighter + predictable widths
+    t = Table(
+        show_header=False,
+        box=None,            # no box for header table
+        show_edge=False,
+        pad_edge=False,
+        expand=True,
+    )
+    t.add_column(style="bold", no_wrap=True, width=10)  # fixed key col
+    t.add_column(ratio=1)                               # value col fills remaining
+    return t
+
+
+def _add_kv(t: Table, k: str, v: str | None, *, style: str | None = None) -> None:
+    if v is None:
+        return
+    v = v.strip()
+    if not v:
+        return
+    t.add_row(Text(k, style="bold"), Text(v, style=style or ""))
+
+
+def render_doc_ref(pm: DocRefPM, *, ctx: RenderCtx):
+    blocks = []
+
+    # Header
+    t = _kv_table(ctx)
+    _add_kv(t, "kind", "doc_ref", style="magenta")
+    if getattr(ctx, "show_ids", False):
+        _add_kv(t, "art_id", pm.core.art_id, style="dim")
+    _add_kv(t, "meta", pm.meta)
+
+    if t.row_count > 0:
+        blocks.append(t)
+
+    # Text section
+    text = (pm.text or "").strip()
+
+    blocks.append(Rule("text"))
+
+    if getattr(ctx, "show_code", True):
+        if text:
+            blocks.append(Syntax(text, "markdown", word_wrap=True))
+        else:
+            blocks.append(Text("(empty)", style="dim"))
+    else:
+        if not text:
+            blocks.append(Text("(empty)", style="dim"))
+        else:
+            snippet = text if len(text) <= 200 else text[:200] + "…"
+            blocks.append(Text(snippet))
+
+    return Panel(Group(*blocks), title="[bold]Doc reference[/bold]", border_style="magenta")
+
+# -----------------------------------------------------------------------------
+# SrcCodeRef
+# -----------------------------------------------------------------------------
+
+def _maybe_code_block(
+    *,
+    title: str,
+    content: str | None,
+    lang: str,
+    show_code: bool,
+) -> list[object]:
+    """
+    Returns renderables for a section that always shows something:
+    - if show_code: Syntax when present, else '(empty)'
+    - if not show_code: snippet when present, else '(empty)'
+    """
+    blocks: list[object] = [Rule(title)]
+    text = (content or "").strip()
+
+    if not text:
+        blocks.append(Text("(empty)", style="dim"))
+        return blocks
+
+    if show_code:
+        blocks.append(Syntax(text, lang, word_wrap=True))
+    else:
+        snippet = text if len(text) <= 200 else text[:200] + "…"
+        blocks.append(Text(snippet))
+    return blocks
+
+
+def render_src_code_ref(pm: SrcCodeRefPM, *, ctx: RenderCtx):
+    blocks: list[object] = []
+
+    # --- header ---
+    t = _kv_table(ctx)
+    _add_kv(t, "kind", "src_code_ref", style="magenta")
+
+    if getattr(ctx, "show_ids", False):
+        _add_kv(t, "art_id", pm.core.art_id, style="dim")
+
+    _add_kv(t, "language", pm.language)
+    _add_kv(t, "file_path", pm.file_path)
+    _add_kv(t, "meta", pm.meta)
+
+    if t.row_count > 0:
+        blocks.append(t)
+
+    show_code = getattr(ctx, "show_code", True)
+
+    # --- src_code section (always visible; shows (empty) if missing) ---
+    lang = (pm.language or "text").lower()
+    blocks.extend(
+        _maybe_code_block(
+            title="src_code",
+            content=pm.src_code,
+            lang=lang,
+            show_code=show_code,
+        )
+    )
+
+    # --- iml_code section (always visible; shows (empty) if missing) ---
+    blocks.extend(
+        _maybe_code_block(
+            title="iml_code",
+            content=pm.iml_code,
+            lang="ocaml",
+            show_code=show_code,
+        )
+    )
+
+    return Panel(Group(*blocks), title="[bold]Source code reference[/bold]", border_style="magenta")

speclogician/presentation/renderers/domain.py

@@ -0,0 +1,123 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/renderers/domain.py
+#
+
+from __future__ import annotations
+
+from rich import box
+from rich.console import Group
+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.domain import DomainModelPM
+
+
+def render_domain_model(pm: DomainModelPM, *, ctx: RenderCtx):
+    b = box.MINIMAL if ctx.compact else box.SIMPLE
+
+    c = pm.counts
+    code = pm.code
+
+    stats = Table(
+        show_header=False,
+        box=b,
+        show_edge=False,
+        pad_edge=False,
+        expand=False,   # ← critical change
+    )
+    stats.add_column(style="dim", no_wrap=True)
+    stats.add_column(justify="right")
+
+    def hdr(label: str) -> None:
+        stats.add_row(Text(label, style="bold magenta"), Text(""))
+
+    def row(label: str, value: object, *, bold: bool = False) -> None:
+        stats.add_row(
+            Text("  " + label),
+            Text(str(value), style="bold" if bold else "")
+        )
+
+    # ----------------------------
+    # Base
+    # ----------------------------
+    hdr("Base")
+    row("Base status", c.base_status, bold=True)
+    row("Has state", c.base_has_state)
+    row("Has action", c.base_has_action)
+
+    # ----------------------------
+    # Predicates
+    # ----------------------------
+    hdr("Predicates")
+    row("State total", c.num_state_preds_total, bold=True)
+    row("State valid", c.num_state_preds_valid_logic)
+    row("State matched", c.num_state_preds_matched)
+
+    row("Action total", c.num_action_preds_total, bold=True)
+    row("Action valid", c.num_action_preds_valid_logic)
+    row("Action matched", c.num_action_preds_matched)
+
+    row("All total", c.num_preds_total, bold=True)
+    row("All valid", c.num_preds_valid_logic)
+    row("All matched", c.num_preds_matched)
+
+    # ----------------------------
+    # Transitions
+    # ----------------------------
+    hdr("Transitions")
+    row("Total", c.num_trans_total, bold=True)
+    row("Valid", c.num_trans_valid_logic)
+    row("Matched", c.num_trans_matched)
+
+    if ctx.show_stats_only or not ctx.show_code:
+        return Panel(stats, title="[bold]Domain model[/bold]", border_style="magenta")
+
+    blocks: list[object] = [
+        Panel(stats, title="[bold]Stats[/bold]", border_style="magenta"),
+    ]
+
+    # Base code
+    if code.base.strip():
+        blocks.append(
+            Panel(
+                Syntax(code.base, "ocaml", word_wrap=True, line_numbers=not ctx.compact),
+                title="Base",
+                border_style="cyan",
+            )
+        )
+
+    # Predicates code
+    if code.state_preds_iml.strip():
+        blocks.append(
+            Panel(
+                Syntax(code.state_preds_iml, "ocaml", word_wrap=True, line_numbers=not ctx.compact),
+                title="State predicates",
+                border_style="green",
+            )
+        )
+
+    if code.action_preds_iml.strip():
+        blocks.append(
+            Panel(
+                Syntax(code.action_preds_iml, "ocaml", word_wrap=True, line_numbers=not ctx.compact),
+                title="Action predicates",
+                border_style="green",
+            )
+        )
+
+    # Transitions code
+    if code.transitions_iml.strip():
+        blocks.append(
+            Panel(
+                Syntax(code.transitions_iml, "ocaml", word_wrap=True, line_numbers=not ctx.compact),
+                title="Transitions",
+                border_style="blue",
+            )
+        )
+
+    return Panel(Group(*blocks), title="[bold]Domain model[/bold]", border_style="magenta")