speclogician 0.0.0b1__py3-none-any.whl

speclogician/presentation/renderers/state_instance_summary.py

@@ -0,0 +1,143 @@
+#
+#   Imandra Inc.
+#
+#   presentation/renderers/state_instance_summary.py
+#
+
+from __future__ import annotations
+
+from rich.console import Group
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.text import Text
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.state_instance_summary import StateInstanceSummaryPM
+
+
+def render_state_instance_summary(pm: StateInstanceSummaryPM, *, ctx: RenderCtx):
+    def kv(k: str, v: object, *, k_w: int = 22) -> Text:
+        # left-align key, keep values readable; no fancy tables
+        return Text(f"{k:<{k_w}} {v}")
+
+    blocks: list[Text] = []
+
+    # Header
+    blocks.append(Text("State instance", style="bold"))
+    blocks.append(Rule(style="dim"))
+
+    # Top-level
+    blocks.append(kv("created_at:", pm.created_at))
+    blocks.append(kv("changes:", pm.num_changes))
+    blocks.append(Text(""))
+
+    # Domain model
+    blocks.append(Text("Domain model", style="bold"))
+    blocks.append(kv("base_status:", pm.base_status))
+    blocks.append(kv("has_state/action:", f"{pm.base_has_state} / {pm.base_has_action}"))
+
+    blocks.append(
+        kv(
+            "state preds:",
+            f"{pm.num_state_preds_total} total, "
+            f"{pm.num_state_preds_matched} matched, "
+            f"{pm.num_state_preds_valid_logic} logic-valid, "
+            f"{pm.num_state_preds_errored} errored",
+        )
+    )
+    blocks.append(
+        kv(
+            "action preds:",
+            f"{pm.num_action_preds_total} total, "
+            f"{pm.num_action_preds_matched} matched, "
+            f"{pm.num_action_preds_valid_logic} logic-valid, "
+            f"{pm.num_action_preds_errored} errored",
+        )
+    )
+    blocks.append(
+        kv(
+            "predicates:",
+            f"{pm.num_preds_total} total, "
+            f"{pm.num_preds_matched} matched, "
+            f"{pm.num_preds_valid_logic} logic-valid, "
+            f"{pm.num_preds_errored} errored",
+        )
+    )
+    blocks.append(
+        kv(
+            "transitions:",
+            f"{pm.num_trans_total} total, "
+            f"{pm.num_trans_matched} matched, "
+            f"{pm.num_trans_valid_logic} logic-valid, "
+            f"{pm.num_trans_errored} errored",
+        )
+    )
+    blocks.append(Text(""))
+
+    # Spec / scenarios
+    blocks.append(Text("Spec / scenarios", style="bold"))
+    blocks.append(
+        kv(
+            "scenarios:",
+            f"{pm.num_sc_total} total, "
+            f"{pm.num_sc_missing} missing, "
+            f"{pm.num_sc_matched} matched, "
+            f"{pm.num_sc_inconsistent} inconsistent",
+        )
+    )
+    blocks.append(
+        kv(
+            "conflicts:",
+            f"{pm.num_sc_conflicted} total, "
+            f"{pm.num_sc_overlap} overlap, "
+            f"{pm.num_sc_consumed} consumed",
+        )
+    )
+    blocks.append(Text(""))
+
+    # Artifacts
+    blocks.append(Text("Artifacts", style="bold"))
+    blocks.append(
+        kv(
+            "test traces:",
+            f"{pm.num_test_traces_total} total, "
+            f"{pm.num_test_traces_logic_good} logic-good, "
+            f"{pm.num_test_traces_matched} matched",
+        )
+    )
+    blocks.append(
+        kv(
+            "log traces:",
+            f"{pm.num_log_traces_total} total, "
+            f"{pm.num_log_traces_logic_good} logic-good, "
+            f"{pm.num_log_traces_matched} matched",
+        )
+    )
+
+    # NEW: src + docs (optional)
+    # Only show if ctx allows and the fields exist on the PM (they should, after your model update).
+    if getattr(ctx, "show_artifacts", True):
+        if (pm.num_src_code_arts_total is not None) or (pm.num_src_code_arts_matched is not None):
+            blocks.append(
+                kv(
+                    "src code:",
+                    f"{pm.num_src_code_arts_total} total, "
+                    f"{pm.num_src_code_arts_matched} matched",
+                )
+            )
+        if (pm.num_doc_arts_total is not None) or (pm.num_doc_arts_matched is not None):
+            blocks.append(
+                kv(
+                    "docs:",
+                    f"{pm.num_doc_arts_total} total, "
+                    f"{pm.num_doc_arts_matched} matched",
+                )
+            )
+
+    body = Group(*blocks)
+
+    return Panel(
+        body,
+        title="[bold]Summary[/bold]",
+        border_style="magenta",
+    )

speclogician/presentation/renderers/trace.py

@@ -0,0 +1,122 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/presentation/renderers/trace.py
+#
+
+from __future__ import annotations
+
+from rich import box
+from rich.panel import Panel
+from rich.console import Group
+from rich.rule import Rule
+from rich.table import Table
+from rich.text import Text
+from rich.syntax import Syntax
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.models.trace import TestTracePM, LogTracePM
+from speclogician.presentation.renderers import iml_validity_icon_style_label
+
+
+def _validity_text(iml_valid: str | None) -> Text:
+    icon, style, label = iml_validity_icon_style_label(iml_valid)
+    return Text(f"{icon} {label}", style=f"bold {style}")
+
+
+def _kv_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=True)
+    t.add_column(style="italic dim", no_wrap=True)
+    t.add_column()
+    return t
+
+
+def _code_block(title: str, code: str, *, lang: str) -> Group:
+    # No panel: just a rule + syntax
+    return Group(
+        Rule(f"[bold]{title}[/bold]"),
+        Syntax(code or "", lang, word_wrap=True),
+    )
+
+
+def render_test_trace(pm: TestTracePM, *, ctx: RenderCtx):
+    core = pm.core
+
+    t = _kv_table(ctx)
+
+    if getattr(ctx, "show_ids", False):
+        t.add_row("art_id", Text(core.art_id, style="dim"))
+
+    t.add_row("name", Text(pm.name or "-", style="bold"))
+    if pm.filepath:
+        t.add_row("filepath", Text(pm.filepath))
+    if pm.language:
+        t.add_row("language", Text(pm.language))
+
+    t.add_row("iml_valid", _validity_text(core.iml_validity.iml_valid))
+    if core.iml_validity.err:
+        t.add_row("iml_error", Text(core.iml_validity.err, style="red"))
+
+    if core.time:
+        t.add_row("time", Text(core.time, style="dim"))
+
+    blocks: list[object] = [t]
+
+    if getattr(ctx, "show_code", True):
+        blocks.append(_code_block("given : state", core.given, lang="ocaml"))
+        if core.when:
+            blocks.append(_code_block("when : action", core.when, lang="ocaml"))
+        if core.then:
+            blocks.append(_code_block("then : state", core.then, lang="ocaml"))
+
+        if pm.contents:
+            blocks.append(
+                _code_block(
+                    "original test contents",
+                    pm.contents,
+                    lang=(pm.language or "text"),
+                )
+            )
+
+    return Panel(
+        Group(*blocks),
+        title="[bold]Test trace[/bold]",
+        border_style="cyan",
+    )
+
+
+def render_log_trace(pm: LogTracePM, *, ctx: RenderCtx):
+    core = pm.core
+
+    t = _kv_table(ctx)
+
+    if getattr(ctx, "show_ids", False):
+        t.add_row("art_id", Text(core.art_id, style="dim"))
+
+    t.add_row("filename", Text(pm.filename or "-", style="bold"))
+
+    t.add_row("iml_valid", _validity_text(core.iml_validity.iml_valid))
+    if core.iml_validity.err:
+        t.add_row("iml_error", Text(core.iml_validity.err, style="red"))
+
+    if core.time:
+        t.add_row("time", Text(core.time, style="dim"))
+
+    blocks: list[object] = [t]
+
+    if getattr(ctx, "show_code", True):
+        blocks.append(_code_block("given : state", core.given, lang="ocaml"))
+        if core.when:
+            blocks.append(_code_block("when : action", core.when, lang="ocaml"))
+        if core.then:
+            blocks.append(_code_block("then : state", core.then, lang="ocaml"))
+
+        if pm.contents:
+            blocks.append(_code_block("log contents", pm.contents, lang="text"))
+
+    return Panel(
+        Group(*blocks),
+        title="[bold]Log trace[/bold]",
+        border_style="cyan",
+    )

speclogician/shell/app.py

@@ -0,0 +1,170 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/shell/app.py
+#
+
+from __future__ import annotations
+
+import json
+import argparse
+from pathlib import Path
+from cmd2 import Cmd, with_argparser
+from rich.text import Text
+from rich.align import Align
+from rich.console import RenderableType
+from rich.rule import Rule
+
+from speclogician.utils import console
+from speclogician.state.state import State
+from speclogician.shell.shell_ch import ChangeShell
+
+
+SPEC_LOGICIAN_BANNER = r"""
+.___                           .___                 _________                    .____                 .__       .__               
+|   | _____ _____    ____    __| _/___________     /   _____/_____   ____   ____ |    |    ____   ____ |__| ____ |__|____    ____  
+|   |/     \\__  \  /    \  / __ |\_  __ \__  \    \_____  \\____ \_/ __ \_/ ___\|    |   /  _ \ / ___\|  |/ ___\|  \__  \  /    \ 
+|   |  Y Y  \/ __ \|   |  \/ /_/ | |  | \// __ \_  /        \  |_> >  ___/\  \___|    |__(  <_> ) /_/  >  \  \___|  |/ __ \|   |  \
+|___|__|_|  (____  /___|  /\____ | |__|  (____  / /_______  /   __/ \___  >\___  >_______ \____/\___  /|__|\___  >__(____  /___|  /
+          \/     \/     \/      \/            \/          \/|__|        \/     \/        \/    /_____/         \/        \/     \/ 
+"""
+
+def _print_result(res: object) -> None:
+    """Best-effort printing for ProcessChange* results."""
+    # If your ProcessChange JSON-safe models have .model_dump(), use that.
+    if hasattr(res, "model_dump"):
+        console.print_json(json.dumps(res.model_dump(), indent=2))
+        return
+
+    # Otherwise fall back to repr / dict
+    if isinstance(res, dict):
+        console.print_json(json.dumps(res, indent=2, default=str))
+        return
+
+    console.print(res)
+
+
+class SpecLogicianShell(Cmd):
+    intro = "SpecLogician shell. Type 'help' or '?' to list commands.\n"
+    prompt = "sl> "
+    allow_cli_args = False
+
+    def __init__(self, *args, **kwargs):
+        # Important: prevent cmd2 from parsing outer CLI args
+        self.allow_cli_args = False
+
+        super().__init__(*args, **kwargs)
+
+        # Rich console that writes to the SAME stream cmd2 uses
+        # (cmd2 writes to self.stdout)
+        self.rich = console
+
+        self.state = None
+        self.state_path = None
+
+
+    def preloop(self) -> None:
+        console.print(
+            Align.left(
+                Text(SPEC_LOGICIAN_BANNER, style="bold magenta")
+            )
+        )
+        console.print(
+            Align.left(
+                Text("SpecLogician Interactive Shell - www.speclogician.dev", style="italic dim")
+            )
+        )
+        console.print()
+
+    # ---- helpers ----
+    def rprint(self, *renderables: RenderableType) -> None:
+        """Print rich renderables to cmd2 stdout."""
+        for r in renderables:
+            self.rich.print(r)
+
+    def info(self, msg: str) -> None:
+        self.rich.print(f"[info]{msg}[/info]")
+
+    def ok(self, msg: str) -> None:
+        self.rich.print(f"[ok]✓ {msg}[/ok]")
+
+    def warn(self, msg: str) -> None:
+        self.rich.print(f"[warn]⚠ {msg}[/warn]")
+
+    def err(self, msg: str) -> None:
+        self.rich.print(f"[err]✗ {msg}[/err]")
+
+    # -------------------------
+    # Session management
+    # -------------------------
+
+    # ✅ programmatic API: pass a real State object
+    def open_state(self, st: State, *, path: str | Path | None = None) -> None:
+        self.state = st
+        self.state_path = Path(path) if path is not None else None
+        if self.state_path:
+            self.poutput(f"Loaded state object (path={self.state_path})")
+        else:
+            self.poutput("Loaded state object (in-memory)")
+
+    open_parser = argparse.ArgumentParser()
+    open_parser.add_argument("path", help="Path to state.json")
+    @with_argparser(open_parser)
+    def do_open(self, args) -> None:
+        p = Path(args.path)
+        st = State.from_json(p)  # your actual loader
+        self.open_state(st, path=p)
+
+
+    def do_status(self, _arg) -> None:
+        """Show current state/spec summary."""
+        if self.state is None:
+            self.warn("No state loaded.")
+            return
+
+        cur = self.state.curr_state()
+
+        # Header that won't render as a black rectangle
+        self.rprint(Rule("[bold]Status[/bold]"))
+
+        # Your DomainModel.__rich__ already returns a Table
+        self.rprint(cur)
+
+    def do_save(self, _args) -> None:
+        if not self.state or not self.state_path:
+            self.perror("No state loaded.")
+            return
+        self.state.save_to_path(self.state_path)  # adapt to your actual saver
+        self.poutput(f"Saved {self.state_path}")
+
+
+    # -------------------------
+    # Output mode
+    # -------------------------
+
+    def do_json(self, arg) -> None:
+        """
+        Toggle JSON output mode (affects process_change json flag).
+        Usage:
+          json on
+          json off
+        """
+        a = (arg or "").strip().lower()
+        if a in ("on", "true", "1"):
+            self.json_default = True
+        elif a in ("off", "false", "0"):
+            self.json_default = False
+        else:
+            self.poutput(f"json_default={self.json_default}")
+            return
+        self.poutput(f"json_default={self.json_default}")
+
+    def do_ch(self, _arg) -> None:
+        """Enter the change sub-shell (pred/trans/scenario/base/...)."""
+        ChangeShell(self).cmdloop()
+
+def main():
+    SpecLogicianShell().cmdloop()
+
+if __name__ == "__main__":
+    main()

speclogician/shell/shell_ch.py

@@ -0,0 +1,263 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/shell/ch_shell.py
+#
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Optional
+
+from cmd2 import Cmd, with_argparser
+
+from speclogician.modeling.predicates import PredicateType
+from speclogician.modeling.scenario import ScenarioDelta
+from speclogician.state.change import (
+    DomainModelBaseEdit,
+    PredicateAdd,
+    PredicateEdit,
+    PredicateRemove,
+    TransitionAdd,
+    TransitionEdit,
+    TransitionRemove,
+    ScenarioAdd,
+    ScenarioEdit,
+    ScenarioRemove,
+    # later: AddTestTrace, EditTestTrace, AddLogTrace, ...
+)
+from speclogician.utils.load import load_state
+
+
+def _print_result(cmd: Cmd, res: object) -> None:
+    """
+    Best-effort printer for ProcessChangeResult / ProcessChangeObjectResult.
+    - dict: dump as JSON
+    - pydantic-ish: model_dump
+    - fallback: str()
+    """
+    if isinstance(res, dict):
+        cmd.poutput(json.dumps(res, indent=2, default=str))
+        return
+    if hasattr(res, "model_dump"):
+        cmd.poutput(json.dumps(res.model_dump(mode="json"), indent=2, default=str))  # type: ignore[attr-defined]
+        return
+    cmd.poutput(str(res))
+
+
+def _split_csv(s: Optional[str]) -> list[str]:
+    if not s:
+        return []
+    return [x.strip() for x in s.split(",") if x.strip()]
+
+
+def _merge_dedup_preserve_order(*lists: list[str]) -> list[str]:
+    out: list[str] = []
+    seen: set[str] = set()
+    for xs in lists:
+        for x in xs:
+            if x not in seen:
+                out.append(x)
+                seen.add(x)
+    return out
+
+
+def _delta_from_add(xs: list[str]) -> ScenarioDelta | None:
+    d = ScenarioDelta(add=xs)
+    return None if d.is_empty() else d
+
+
+class ChangeShell(Cmd):
+    """
+    Nested cmd2 shell that exposes the same 'ch' operations as the CLI.
+    """
+
+    prompt = "sl ch> "
+    intro = "Change commands (type 'help' to list, 'exit' to return)\n"
+    allow_cli_args = False
+
+    def __init__(self, parent: Cmd):
+        super().__init__(allow_cli_args=False)
+        self.parent = parent
+
+    # -------------------------
+    # shared accessors
+    # -------------------------
+
+    def _get_state(self):
+        """
+        Use parent.state if present, otherwise load state from default location.
+        """
+        st = getattr(self.parent, "state", None)
+        if st is None:
+            st = load_state()
+            setattr(self.parent, "state", st)
+        return st
+
+    def _json(self) -> bool:
+        return bool(getattr(self.parent, "json_default", False))
+
+    # -------------------------
+    # base-edit  (matches Typer: ch base-edit --src/--file)
+    # -------------------------
+
+    base_edit_parser = argparse.ArgumentParser()
+    g = base_edit_parser.add_mutually_exclusive_group(required=True)
+    g.add_argument("--src", help="IML source code for the domain base component")
+    g.add_argument("--file", type=Path, help="Path to a file containing IML base source code")
+    @with_argparser(base_edit_parser)
+    def do_base_edit(self, args) -> None:
+        st = self._get_state()
+
+        src: str
+        if args.src is not None:
+            src = args.src
+        else:
+            p: Path = args.file
+            src = p.read_text()
+
+        change = DomainModelBaseEdit(new_base_src=src)
+        res = st.process_change(change, json_only=self._json())
+        _print_result(self, res)
+
+    # -------------------------
+    # predicates
+    # -------------------------
+
+    pred_add_parser = argparse.ArgumentParser()
+    pred_add_parser.add_argument("--pred-type", choices=["state", "action"], required=True)
+    pred_add_parser.add_argument("--pred-name", required=True)
+    pred_add_parser.add_argument("--pred-src", required=True)
+    @with_argparser(pred_add_parser)
+    def do_pred_add(self, args) -> None:
+        st = self._get_state()
+        ptype = PredicateType.STATE if args.pred_type == "state" else PredicateType.ACTION
+        change = PredicateAdd(pred_type=ptype, pred_name=args.pred_name, pred_src=args.pred_src)
+        res = st.process_change(change, json_only=self._json())
+        _print_result(self, res)
+
+    pred_edit_parser = argparse.ArgumentParser()
+    pred_edit_parser.add_argument("--pred-name", required=True)
+    pred_edit_parser.add_argument("--pred-src", required=True)
+    @with_argparser(pred_edit_parser)
+    def do_pred_edit(self, args) -> None:
+        st = self._get_state()
+        change = PredicateEdit(pred_name=args.pred_name, pred_src=args.pred_src)
+        res = st.process_change(change, json_only=self._json())
+        _print_result(self, res)
+
+    pred_remove_parser = argparse.ArgumentParser()
+    pred_remove_parser.add_argument("--pred-name", required=True)
+    @with_argparser(pred_remove_parser)
+    def do_pred_remove(self, args) -> None:
+        st = self._get_state()
+        change = PredicateRemove(pred_name=args.pred_name)
+        res = st.process_change(change, json_only=self._json())
+        _print_result(self, res)
+
+    # -------------------------
+    # transitions
+    # -------------------------
+
+    trans_add_parser = argparse.ArgumentParser()
+    trans_add_parser.add_argument("--trans-name", required=True)
+    trans_add_parser.add_argument("--trans-src", required=True)
+    @with_argparser(trans_add_parser)
+    def do_trans_add(self, args) -> None:
+        st = self._get_state()
+        change = TransitionAdd(trans_name=args.trans_name, trans_src=args.trans_src)
+        res = st.process_change(change, json_only=self._json())
+        _print_result(self, res)
+
+    trans_edit_parser = argparse.ArgumentParser()
+    trans_edit_parser.add_argument("--trans-name", required=True)
+    trans_edit_parser.add_argument("--trans-src", required=True)
+    @with_argparser(trans_edit_parser)
+    def do_trans_edit(self, args) -> None:
+        st = self._get_state()
+        change = TransitionEdit(trans_name=args.trans_name, trans_src=args.trans_src)
+        res = st.process_change(change, json_only=self._json())
+        _print_result(self, res)
+
+    trans_remove_parser = argparse.ArgumentParser()
+    trans_remove_parser.add_argument("--trans-name", required=True)
+    @with_argparser(trans_remove_parser)
+    def do_trans_remove(self, args) -> None:
+        st = self._get_state()
+        change = TransitionRemove(trans_name=args.trans_name)
+        res = st.process_change(change, json_only=self._json())
+        _print_result(self, res)
+
+    # -------------------------
+    # scenarios
+    # -------------------------
+
+    scenario_add_parser = argparse.ArgumentParser()
+    scenario_add_parser.add_argument("scenario_name")
+    scenario_add_parser.add_argument("--given", action="append", default=[], help="Repeatable")
+    scenario_add_parser.add_argument("--when", action="append", default=[], help="Repeatable")
+    scenario_add_parser.add_argument("--then", action="append", default=[], help="Repeatable")
+    scenario_add_parser.add_argument("--given-list", default=None)
+    scenario_add_parser.add_argument("--when-list", default=None)
+    scenario_add_parser.add_argument("--then-list", default=None)
+    @with_argparser(scenario_add_parser)
+    def do_scenario_add(self, args) -> None:
+        st = self._get_state()
+
+        given_all = _merge_dedup_preserve_order(args.given, _split_csv(args.given_list))
+        when_all = _merge_dedup_preserve_order(args.when, _split_csv(args.when_list))
+        then_all = _merge_dedup_preserve_order(args.then, _split_csv(args.then_list))
+
+        change = ScenarioAdd(
+            scenario_name=args.scenario_name,
+            given=_delta_from_add(given_all),
+            when=_delta_from_add(when_all),
+            then=_delta_from_add(then_all),
+        )
+        res = st.process_change(change, json_only=self._json())
+        _print_result(self, res)
+
+    scenario_edit_parser = argparse.ArgumentParser()
+    scenario_edit_parser.add_argument("scenario_name")
+    scenario_edit_parser.add_argument("--given", default=None)
+    scenario_edit_parser.add_argument("--when", default=None)
+    scenario_edit_parser.add_argument("--then", default=None)
+    @with_argparser(scenario_edit_parser)
+    def do_scenario_edit(self, args) -> None:
+        st = self._get_state()
+
+        # NOTE: to match CLI behavior, reuse the SAME parser you use in Typer.
+        # If you already have parse_scenario_delta(), import it and use it here.
+        from speclogician.commands.utils import parse_scenario_delta  # adjust import to your actual module
+
+        change = ScenarioEdit(
+            scenario_name=args.scenario_name,
+            given=parse_scenario_delta(args.given),
+            when=parse_scenario_delta(args.when),
+            then=parse_scenario_delta(args.then),
+        )
+        res = st.process_change(change, json_only=self._json())
+        _print_result(self, res)
+
+    scenario_remove_parser = argparse.ArgumentParser()
+    scenario_remove_parser.add_argument("scenario_name")
+    @with_argparser(scenario_remove_parser)
+    def do_scenario_remove(self, args) -> None:
+        st = self._get_state()
+        change = ScenarioRemove(scenario_name=args.scenario_name)
+        res = st.process_change(change, json_only=self._json())
+        _print_result(self, res)
+
+    # -------------------------
+    # navigation
+    # -------------------------
+
+    def do_exit(self, _arg) -> bool:
+        """Return to the main shell."""
+        return True
+
+    def do_EOF(self, _arg) -> bool:
+        """Ctrl-D exits this sub-shell."""
+        return True