speclogician 0.0.0b1__py3-none-any.whl

speclogician/presentation/preview/fixtures/smart_find.py

@@ -0,0 +1,140 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/smart_find.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.smart_find import (
+    SmartFindPM,
+    SmartFindCountsPM,
+    SmartFindItemsPM,
+)
+
+from speclogician.presentation.preview.fixtures.trace import (
+    minimal_test_trace_pm,
+    typical_test_trace_pm,
+    edge_test_trace_pm,
+    minimal_log_trace_pm,
+    typical_log_trace_pm,
+    edge_log_trace_pm,
+)
+
+from speclogician.presentation.preview.fixtures.data_artifact import (
+    minimal_doc_ref_pm,
+    typical_doc_ref_pm,
+    edge_doc_ref_pm,
+    minimal_src_code_ref_pm,
+    typical_src_code_ref_pm,
+    edge_src_code_ref_pm,
+)
+
+
+# -----------------------------------------------------------------------------
+# variants
+# -----------------------------------------------------------------------------
+
+def _smart_find_minimal() -> SmartFindPM:
+    needle = ""
+    return SmartFindPM(
+        counts=SmartFindCountsPM(
+            needle=needle,
+            num_test_traces=0,
+            num_log_traces=0,
+            num_doc_refs=0,
+            num_src_code_refs=0,
+        ),
+        items=SmartFindItemsPM(
+            test_traces=[],
+            log_traces=[],
+            doc_refs=[],
+            src_code_refs=[],
+        ),
+    )
+
+
+def _smart_find_typical() -> SmartFindPM:
+    needle = "order size"
+    tt = typical_test_trace_pm(with_contents=False, invalid=False)
+    lt = typical_log_trace_pm(with_contents=False, invalid=False)
+    dr = typical_doc_ref_pm()
+    sr = typical_src_code_ref_pm()
+
+    return SmartFindPM(
+        counts=SmartFindCountsPM(
+            needle=needle,
+            num_test_traces=1,
+            num_log_traces=1,
+            num_doc_refs=1,
+            num_src_code_refs=1,
+        ),
+        items=SmartFindItemsPM(
+            test_traces=[tt],
+            log_traces=[lt],
+            doc_refs=[dr],
+            src_code_refs=[sr],
+        ),
+    )
+
+
+def _smart_find_edge() -> SmartFindPM:
+    needle = "pred_eq_ten OR max_qty (line:42)"
+    # Stress renderers: mix long contents + invalid + lots of items
+    tts = [
+        typical_test_trace_pm(with_contents=True, invalid=True),
+        edge_test_trace_pm(),
+    ]
+    lts = [
+        typical_log_trace_pm(with_contents=True, invalid=True),
+        edge_log_trace_pm(),
+    ]
+    drs = [
+        edge_doc_ref_pm(),
+        typical_doc_ref_pm(),
+        minimal_doc_ref_pm(),
+    ]
+    srs = [
+        edge_src_code_ref_pm(),
+        typical_src_code_ref_pm(),
+        minimal_src_code_ref_pm(),
+    ]
+
+    return SmartFindPM(
+        counts=SmartFindCountsPM(
+            needle=needle,
+            num_test_traces=len(tts),
+            num_log_traces=len(lts),
+            num_doc_refs=len(drs),
+            num_src_code_refs=len(srs),
+        ),
+        items=SmartFindItemsPM(
+            test_traces=tts,
+            log_traces=lts,
+            doc_refs=drs,
+            src_code_refs=srs,
+        ),
+    )
+
+
+# -----------------------------------------------------------------------------
+# top-level fixture entrypoint (matches your preview setup)
+# -----------------------------------------------------------------------------
+
+def make_smart_find_pm(ctx: RenderCtx, variant: str = "typical") -> SmartFindPM:
+    v = (variant or "typical").strip().lower()
+    if v == "minimal":
+        return _smart_find_minimal()
+    if v == "edge":
+        return _smart_find_edge()
+    return _smart_find_typical()
+
+
+# -----------------------------------------------------------------------------
+# renderer adapter (matches other fixtures style)
+# -----------------------------------------------------------------------------
+
+def render(pm: SmartFindPM, ctx: RenderCtx):
+    from speclogician.presentation.renderers.smart_find import render_smart_find
+    return render_smart_find(pm, ctx=ctx)

speclogician/presentation/preview/fixtures/spec.py

@@ -0,0 +1,95 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/spec.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.spec import SpecPM, SpecCountsPM
+
+from .domain_model import make_domain_model_pm
+from .scenario_complement import make_scenario_complement_pm
+
+
+# -----------------------------------------------------------------------------
+# internal constructors
+# -----------------------------------------------------------------------------
+
+def _spec_minimal(ctx: RenderCtx) -> SpecPM:
+    dm = make_domain_model_pm(ctx, variant="minimal")
+    return SpecPM(
+        domain=dm,
+        counts=SpecCountsPM(
+            num_sc_total=0,
+            num_sc_missing=0,
+            num_sc_matched=0,
+            num_sc_inconsistent=0,
+            num_sc_conflicted=0,
+        ),
+        scenario_names=[],
+        scenario_complement=None,
+    )
+
+
+def _spec_typical(ctx: RenderCtx) -> SpecPM:
+    dm = make_domain_model_pm(ctx, variant="typical")
+    return SpecPM(
+        domain=dm,
+        counts=SpecCountsPM(
+            num_sc_total=9,
+            num_sc_missing=1,
+            num_sc_matched=0,
+            num_sc_inconsistent=0,
+            num_sc_conflicted=0,
+        ),
+        scenario_names=[
+            "scenario_1",
+            "scenario_2",
+            "scenario_3",
+            "order_rejects_on_max_qty",
+            "order_accepts_on_small_qty",
+        ],
+        scenario_complement=make_scenario_complement_pm("typical"),
+    )
+
+
+def _spec_edge(ctx: RenderCtx) -> SpecPM:
+    dm = make_domain_model_pm(ctx, variant="edge")
+    # stress: lots of scenarios, some missing + inconsistent + conflicted
+    names = [f"scenario_{i}" for i in range(1, 26)]
+    return SpecPM(
+        domain=dm,
+        counts=SpecCountsPM(
+            num_sc_total=len(names),
+            num_sc_missing=5,
+            num_sc_matched=12,
+            num_sc_inconsistent=3,
+            num_sc_conflicted=2,
+        ),
+        scenario_names=names,
+        scenario_complement=make_scenario_complement_pm("edge"),
+    )
+
+
+# -----------------------------------------------------------------------------
+# public entrypoint (matches other fixtures)
+# -----------------------------------------------------------------------------
+
+def make_spec_pm(ctx: RenderCtx, variant: str = "typical") -> SpecPM:
+    v = (variant or "typical").strip().lower()
+    if v == "minimal":
+        return _spec_minimal(ctx)
+    if v == "edge":
+        return _spec_edge(ctx)
+    return _spec_typical(ctx)
+
+
+# -----------------------------------------------------------------------------
+# renderer adapter (matches other fixtures style)
+# -----------------------------------------------------------------------------
+
+def render(pm: SpecPM, ctx: RenderCtx):
+    from speclogician.presentation.renderers.spec import render_spec
+    return render_spec(pm, ctx=ctx)

speclogician/presentation/preview/fixtures/state_diff.py

@@ -0,0 +1,158 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/state_diff.py
+#
+
+from __future__ import annotations
+
+from rich.console import RenderableType
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.state_diff import StateDiffPM, DiffSectionPM, DiffRowPM
+from speclogician.state.diff import ComparisonOutcome
+from speclogician.presentation.renderers.state_diff import render_state_diff
+
+
+def make_state_diff_pm(ctx: RenderCtx, variant: str) -> StateDiffPM:
+    # keep fixtures deterministic, not dependent on real state
+    if variant == "minimal":
+        return StateDiffPM(has_changes=False, sections=[])
+
+    if variant == "edge":
+        return StateDiffPM(
+            has_changes=True,
+            sections=[
+                DiffSectionPM(
+                    title="Domain Model: Base",
+                    rows=[
+                        DiffRowPM(
+                            label="base_status",
+                            before="UNKNOWN",
+                            after="VALID",
+                            outcome=ComparisonOutcome.IMPROVED,
+                            message="base_status improved",
+                        ),
+                        DiffRowPM(
+                            label="base_has_action",
+                            before=False,
+                            after=False,
+                            outcome=ComparisonOutcome.NO_CHANGE_BAD,
+                            message="still missing action",
+                        ),
+                        DiffRowPM(
+                            label="base_src",
+                            before="type state = ...\n" * 3,
+                            after="type state = int\ntype action = int\n",
+                            outcome=ComparisonOutcome.UNKNOWN,
+                            message="multi-line (unknown comparator)",
+                        ),
+                    ],
+                ),
+                DiffSectionPM(
+                    title="Scenarios",
+                    rows=[
+                        DiffRowPM(
+                            label="num_sc_total",
+                            before=3,
+                            after=5,
+                            outcome=ComparisonOutcome.IMPROVED,
+                            message="more scenarios",
+                        ),
+                        DiffRowPM(
+                            label="num_sc_inconsistent",
+                            before=0,
+                            after=1,
+                            outcome=ComparisonOutcome.DECLINED,
+                            message="introduced inconsistency",
+                        ),
+                    ],
+                ),
+                DiffSectionPM(
+                    title="Coverage: Complement",
+                    rows=[
+                        DiffRowPM(
+                            label="scenario_comp_present",
+                            before=False,
+                            after=True,
+                            outcome=ComparisonOutcome.IMPROVED,
+                            message="complement now computed",
+                        ),
+                        DiffRowPM(
+                            label="num_comp_regions_total",
+                            before=12,
+                            after=4,
+                            outcome=ComparisonOutcome.IMPROVED,
+                            message="fewer uncovered regions",
+                        ),
+                    ],
+                ),
+            ],
+        )
+
+    return StateDiffPM(
+        has_changes=True,
+        sections=[
+            DiffSectionPM(
+                title="Domain Model: Base",
+                rows=[
+                    DiffRowPM(
+                        label="base_status",
+                        before="UNKNOWN",
+                        after="VALID",
+                        outcome=ComparisonOutcome.IMPROVED,
+                        message="base status improved",
+                    ),
+                    DiffRowPM(
+                        label="base_has_state",
+                        before=False,
+                        after=True,
+                        outcome=ComparisonOutcome.IMPROVED,
+                        message="now has state",
+                    ),
+                ],
+            ),
+            DiffSectionPM(
+                title="Scenarios",
+                rows=[
+                    DiffRowPM(
+                        label="num_sc_total",
+                        before=3,
+                        after=5,
+                        outcome=ComparisonOutcome.IMPROVED,
+                        message="more scenarios",
+                    ),
+                    DiffRowPM(
+                        label="num_sc_inconsistent",
+                        before=0,
+                        after=1,
+                        outcome=ComparisonOutcome.DECLINED,
+                        message="inconsistency added",
+                    ),
+                ],
+            ),
+            DiffSectionPM(
+                title="Coverage: Complement",
+                rows=[
+                    DiffRowPM(
+                        label="scenario_comp_present",
+                        before=True,
+                        after=True,
+                        outcome=ComparisonOutcome.NO_CHANGE_GOOD,
+                        message="complement still present",
+                    ),
+                    DiffRowPM(
+                        label="num_comp_regions_total",
+                        before=6,
+                        after=6,
+                        outcome=ComparisonOutcome.NO_CHANGE_BAD,
+                        message="coverage not improving yet",
+                    ),
+                ],
+            ),
+        ],
+    )
+
+
+def render(pm: StateDiffPM, ctx: RenderCtx) -> RenderableType:
+    return render_state_diff(pm, ctx=ctx)

speclogician/presentation/preview/fixtures/state_instance.py

@@ -0,0 +1,128 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/state_instance.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.state_instance import StateInstancePM
+from speclogician.presentation.models.recommendations import (
+    RecommendationPM,
+    RecommendationsPM,
+)
+
+from .state_instance_summary import make_state_instance_summary_pm
+from .spec import make_spec_pm
+from .artifact_container import make_artifact_container_pm
+from .state_diff import make_state_diff_pm
+
+
+# -----------------------------------------------------------------------------
+# Shared recommendations PMs
+# -----------------------------------------------------------------------------
+
+_EMPTY_RECOMMENDATIONS = RecommendationsPM(
+    count=0,
+    items=[],
+    num_error=0,
+    num_warning=0,
+    num_next=0,
+    num_info=0,
+)
+
+_TYPICAL_RECOMMENDATIONS = RecommendationsPM(
+    count=4,
+    items=[
+        RecommendationPM(
+            kind="error",
+            priority=0,
+            text=(
+                "Domain model base declined (VALID → INVALID_IML). "
+                "Fix base IML/type issues before trusting any further analysis."
+            ),
+        ),
+        RecommendationPM(
+            kind="warning",
+            priority=8,
+            text=(
+                "Some scenarios reference predicates/transitions that do not exist yet.\n"
+                "- `HappyPath` missing preds=['p_user_exists'] trans=['t_create_user']\n"
+                "Recommendation: add the missing predicates/transitions or edit the scenarios to match the domain model."
+            ),
+        ),
+        RecommendationPM(
+            kind="next",
+            priority=25,
+            text=(
+                "More transitions are logic-valid (1 → 3). "
+                "Attach these transitions to scenarios’ `then` lists so traces can match end-to-end."
+            ),
+        ),
+        RecommendationPM(
+            kind="info",
+            priority=40,
+            text=(
+                "More log traces matched scenarios (0 → 2). "
+                "Treat these as in-the-wild confirmation and use them to justify model boundaries."
+            ),
+        ),
+    ],
+    num_error=1,
+    num_warning=1,
+    num_next=1,
+    num_info=1,
+)
+
+
+# -----------------------------------------------------------------------------
+# Variants
+# -----------------------------------------------------------------------------
+
+def _state_instance_minimal(ctx: RenderCtx) -> StateInstancePM:
+    return StateInstancePM(
+        summary=make_state_instance_summary_pm(ctx, "minimal"),
+        recommendations=_EMPTY_RECOMMENDATIONS,
+        spec=None,
+        artifacts=None,
+        state_diff=None,
+    )
+
+
+def _state_instance_typical(ctx: RenderCtx) -> StateInstancePM:
+    return StateInstancePM(
+        summary=make_state_instance_summary_pm(ctx, "typical"),
+        recommendations=_TYPICAL_RECOMMENDATIONS,
+        spec=make_spec_pm(ctx, "typical"),
+        artifacts=make_artifact_container_pm(ctx, "typical"),
+        state_diff=make_state_diff_pm(ctx, "typical"),
+    )
+
+
+def _state_instance_edge(ctx: RenderCtx) -> StateInstancePM:
+    return StateInstancePM(
+        summary=make_state_instance_summary_pm(ctx, "edge"),
+        recommendations=_EMPTY_RECOMMENDATIONS,
+        spec=make_spec_pm(ctx, "edge"),
+        artifacts=make_artifact_container_pm(ctx, "edge"),
+        state_diff=make_state_diff_pm(ctx, "edge"),
+    )
+
+
+# -----------------------------------------------------------------------------
+# Public entry point (used by PreviewSpec)
+# -----------------------------------------------------------------------------
+
+def make_state_instance_pm(ctx: RenderCtx, variant: str = "typical") -> StateInstancePM:
+    v = (variant or "typical").strip().lower()
+    if v == "minimal":
+        return _state_instance_minimal(ctx)
+    if v == "edge":
+        return _state_instance_edge(ctx)
+    return _state_instance_typical(ctx)
+
+
+def render(pm: StateInstancePM, ctx: RenderCtx):
+    from speclogician.presentation.renderers.state_instance import render_state_instance
+    return render_state_instance(pm, ctx=ctx)

speclogician/presentation/preview/fixtures/state_instance_summary.py

@@ -0,0 +1,80 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/preview/fixtures/state_instance_summary.py
+#
+
+from __future__ import annotations
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.state_instance_summary import StateInstanceSummaryPM
+from speclogician.presentation.renderers.state_instance_summary import render_state_instance_summary
+
+
+def make_state_instance_summary_pm(ctx: RenderCtx, variant: str) -> StateInstanceSummaryPM:
+    if variant == "minimal":
+        return StateInstanceSummaryPM(
+            created_at="1970-01-01T00:00:00Z",
+            num_changes=0,
+            base_status="UNKNOWN",
+            base_has_state=False,
+            base_has_action=False,
+            num_preds_total=0,
+            num_preds_matched=0,
+            num_trans_total=0,
+            num_trans_valid_logic=0,
+            num_sc_total=0,
+            num_sc_missing=0,
+            num_sc_inconsistent=0,
+            num_sc_conflicted=0,
+            num_test_traces_total=0,
+            num_test_traces_logic_good=0,
+            num_log_traces_total=0,
+            num_log_traces_logic_good=0,
+        )
+
+    if variant == "edge":
+        return StateInstanceSummaryPM(
+            created_at="2026-01-09T10:12:00Z",
+            num_changes=1234,
+            base_status="VALID",
+            base_has_state=True,
+            base_has_action=True,
+            num_preds_total=999,
+            num_preds_matched=888,
+            num_trans_total=77,
+            num_trans_valid_logic=66,
+            num_sc_total=55,
+            num_sc_missing=44,
+            num_sc_inconsistent=33,
+            num_sc_conflicted=22,
+            num_test_traces_total=111,
+            num_test_traces_logic_good=100,
+            num_log_traces_total=200,
+            num_log_traces_logic_good=199,
+        )
+
+    # typical
+    return StateInstanceSummaryPM(
+        created_at="2026-01-09T10:12:00Z",
+        num_changes=2,
+        base_status="VALID",
+        base_has_state=True,
+        base_has_action=True,
+        num_preds_total=12,
+        num_preds_matched=7,
+        num_trans_total=4,
+        num_trans_valid_logic=3,
+        num_sc_total=9,
+        num_sc_missing=1,
+        num_sc_inconsistent=0,
+        num_sc_conflicted=0,
+        num_test_traces_total=8,
+        num_test_traces_logic_good=6,
+        num_log_traces_total=4,
+        num_log_traces_logic_good=4,
+    )
+
+
+def render(pm: StateInstanceSummaryPM, ctx: RenderCtx):
+    return render_state_instance_summary(pm, ctx=ctx)