speclogician 0.0.0b1__py3-none-any.whl

speclogician/shell/shell_view.py

@@ -0,0 +1,153 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/shell/shell_view.py
+#
+
+from __future__ import annotations
+
+import json
+from cmd2 import Cmd, with_argparser
+import argparse
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.api import (
+    present_state_instance,
+    present_spec,
+    present_domain_model,
+    present_artifact_container,
+    present_instances_list,
+)
+from speclogician.utils import console
+
+
+def _mk_ctx(args) -> RenderCtx:
+    return RenderCtx(
+        compact=getattr(args, "compact", False),
+        show_stats_only=getattr(args, "stats_only", False),
+        show_code=not getattr(args, "no_code", False),
+        show_ids=getattr(args, "ids", False),
+        show_art_ids=getattr(args, "art_ids", False),
+    )
+
+
+class ViewShell(Cmd):
+    prompt = "sl:view> "
+    allow_cli_args = False
+
+    def __init__(self, parent_shell, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parent = parent_shell
+        self.rich = console
+
+    # ---- shared flags for all view commands ----
+    def _add_common(self, p: argparse.ArgumentParser) -> None:
+        p.add_argument("--idx", type=int, default=0)
+        p.add_argument("--json", action="store_true")
+        p.add_argument("--compact", action="store_true")
+        p.add_argument("--stats-only", dest="stats_only", action="store_true")
+        p.add_argument("--no-code", action="store_true")
+        p.add_argument("--ids", action="store_true")
+        p.add_argument("--art-ids", dest="art_ids", action="store_true")
+
+    def _emit(self, x, *, json_only: bool) -> None:
+        if json_only:
+            self.rich.print_json(json.dumps(x, indent=2, default=str))
+        else:
+            self.rich.print(x)
+
+    def do_back(self, _arg) -> bool:
+        """Return to main shell."""
+        return True
+
+    do_exit = do_back
+    do_quit = do_back
+
+    # ----------------------
+    # view state/spec/domain/artifacts/instances
+    # ----------------------
+
+    state_p = argparse.ArgumentParser()
+    _ = state_p.add_argument
+    # common
+    # (cmd2 doesn't support easy composition; just call helper)
+    # We'll patch it in __init__? easiest: do it here:
+    # (but need self, so do it in method; use a helper below instead)
+
+    @with_argparser(argparse.ArgumentParser())
+    def do_state(self, args) -> None:
+        """View full state instance."""
+        if self.parent.state is None:
+            self.perror("No state loaded.")
+            return
+
+        # build parser on the fly so we can reuse helper
+        p = argparse.ArgumentParser()
+        self._add_common(p)
+        a = p.parse_args(args.argv)
+
+        si = self.parent.state.instances[a.idx]
+        rctx = _mk_ctx(a)
+        out = present_state_instance(si, ctx=rctx, json_only=a.json)
+        self._emit(out, json_only=a.json)
+
+    @with_argparser(argparse.ArgumentParser())
+    def do_spec(self, args) -> None:
+        if self.parent.state is None:
+            self.perror("No state loaded.")
+            return
+        p = argparse.ArgumentParser()
+        self._add_common(p)
+        a = p.parse_args(args.argv)
+
+        si = self.parent.state.instances[a.idx]
+        rctx = _mk_ctx(a)
+        out = present_spec(si.spec, ctx=rctx, json_only=a.json)
+        self._emit(out, json_only=a.json)
+
+    @with_argparser(argparse.ArgumentParser())
+    def do_domain(self, args) -> None:
+        if self.parent.state is None:
+            self.perror("No state loaded.")
+            return
+        p = argparse.ArgumentParser()
+        self._add_common(p)
+        a = p.parse_args(args.argv)
+
+        si = self.parent.state.instances[a.idx]
+        rctx = _mk_ctx(a)
+        out = present_domain_model(si.spec.domain_model, ctx=rctx, json_only=a.json)
+        self._emit(out, json_only=a.json)
+
+    @with_argparser(argparse.ArgumentParser())
+    def do_artifacts(self, args) -> None:
+        if self.parent.state is None:
+            self.perror("No state loaded.")
+            return
+        p = argparse.ArgumentParser()
+        self._add_common(p)
+        a = p.parse_args(args.argv)
+
+        si = self.parent.state.instances[a.idx]
+        rctx = _mk_ctx(a)
+        out = present_artifact_container(si.art_container, ctx=rctx, json_only=a.json)
+        self._emit(out, json_only=a.json)
+
+    @with_argparser(argparse.ArgumentParser())
+    def do_instances(self, args) -> None:
+        if self.parent.state is None:
+            self.perror("No state loaded.")
+            return
+        p = argparse.ArgumentParser()
+        # instances view doesn’t need --idx but keep flags consistent:
+        p.add_argument("--json", action="store_true")
+        p.add_argument("--compact", action="store_true")
+        p.add_argument("--stats-only", dest="stats_only", action="store_true")
+        p.add_argument("--no-code", action="store_true")
+        p.add_argument("--ids", action="store_true")
+        p.add_argument("--art-ids", dest="art_ids", action="store_true")
+        a = p.parse_args(args.argv)
+
+        rctx = _mk_ctx(a)
+        out = present_instances_list(self.parent.state.instances, ctx=rctx, json_only=a.json)
+        self._emit(out, json_only=a.json)

speclogician/state/change.py

@@ -0,0 +1,428 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/state/change.py
+#   
+
+from __future__ import annotations
+
+from rich.panel import Panel
+from rich.text import Text
+from rich.console import Group
+from pydantic import BaseModel, Field, computed_field, model_validator
+from typing import Literal, Optional
+
+from ..modeling.domain import PredicateType
+from ..modeling.scenario import ScenarioDelta
+
+ProcessChangeStage = Literal["apply_change", "analyze_change", "calc_diff", "ok"]
+
+class StateChange(BaseModel):
+    """ StateChange """
+
+    meta : str | None = None
+
+    @computed_field
+    @property
+    def kind(self) -> str:
+        return self.__class__.__name__
+
+    def short_str(self) -> str:
+        return f"[bold deep_blue_sky]{self.kind}[/bold deep_blue_sky]"
+
+    def __rich__(self) -> Panel:
+        rows: list[Text] = []
+        for k, v in self.model_dump(exclude_none=True, exclude={"kind"}).items():
+            rows.append(Text(f"{k} = {v!r}"))
+        return Panel(
+            Group(*rows),
+            title=f"[italic]{self.__class__.__name__}[/]",
+            title_align="left",
+        )
+
+# ----------------------------
+# Domain Base
+# ----------------------------
+
+class DomainModelBaseEdit(StateChange):
+    """ Edit the base component of domain model """
+    new_base_src : str = Field(..., description="IML source code of the base component")
+
+    def short_str(self) -> str:
+        return "[bold deep_sky_blue]DomainModelBaseEdit[/bold deep_sky_blue]"
+
+    def __str__ (self) -> str:
+        return ""
+
+# ----------------------------
+# Predicates
+# ----------------------------
+
+class PredicateAdd(StateChange):
+    """ Add a new predicate """
+    pred_type : PredicateType = Field(..., description="Predicate add")
+    pred_name : str = Field(..., description="predicate name (no spaces). no signature.")
+    pred_src : str = Field(..., description="predicate source code")
+
+    def short_str(self):
+        """ """
+        return "[bold deep_blue_sky]PredicateAdd[/bold deep_blue_sky]"
+
+    def __str__(self):
+        return ""
+
+class PredicateEdit(StateChange):
+    """ Edit an existing predicate """
+    pred_name : str = Field(..., description="Predicate name (no spaces)")
+    pred_src : str = Field(..., description="Predicate source code. No signature.")
+
+    def short_str(self):
+        return "[bold deep_blue_sky]PredicateEdit[/bold deep_blue_sky]: [bold]name[/bold]={self.pred_name}"
+
+    def __str__(self):
+        return f'PredicateEdit: {self.pred_name}'
+    
+class PredicateRemove(StateChange):
+    """ Remove an existing predicate """
+    pred_name : str = Field(..., description="Predicate name to remove")
+
+    def short_str(self) -> str:
+        return f'PredicateRemove: name = {self.pred_name}'
+
+    def __str__(self) -> str:
+        return 'PredicateRemove'
+
+# ----------------------------
+# Transitions
+# ----------------------------
+
+class TransitionAdd(StateChange):
+    """ Add a new transition function """
+    trans_name : str = Field(..., description="Transition name")
+    trans_src : str = Field(..., description="Transition source code. No signature.")
+
+    def short_str(self) -> str:
+        return ''
+
+    def __str__(self) -> str:
+        return 'TransitionAdd: '
+    
+class TransitionEdit(StateChange):
+    """ Edit an existing transition function """
+    trans_name : str = Field(..., description="Transition name")
+    trans_src : str = Field(..., description="Updated transition code. No signature.")
+
+    def short_str(self):
+        return f"[bold deep_blue_sky]TransitionEdit[/bold deep_blue_sky]: [bold]trans_name[/bold]: {self.trans_name}"
+
+    def __str__(self):
+        return "TransitionEdit: "
+
+class TransitionRemove(StateChange):
+    """ Remove an existing transition function """
+    trans_name : str = Field(..., description="Transition name")
+
+    def short_str(self):
+        return f"[bold deep_blue_sky]TransitionRemove[/bold deep_blue_sky]: [bold]trans_name[/bold]: {self.trans_name}"
+
+    def __str__(self):
+        return "TransitionRemove: "
+
+# ----------------------------
+# Scenarios
+# ----------------------------
+
+class ScenarioAdd(StateChange):
+    """
+    Add a new scenario using set-delta semantics.
+    For creation, deltas must be add-only (remove must be empty).
+    """
+    scenario_name: str
+    given: Optional[ScenarioDelta] = None
+    when: Optional[ScenarioDelta] = None
+    then: Optional[ScenarioDelta] = None
+
+    @model_validator(mode="after")
+    def _add_only(self) -> "ScenarioAdd":
+        for sec_name, delta in (("given", self.given), ("when", self.when), ("then", self.then)):
+            if delta is not None and not delta.is_add_only():
+                raise ValueError(f"ScenarioAdd.{sec_name}: 'remove' is not allowed when creating a scenario")
+        return self
+
+    def short_str(self) -> str:
+        return f"ScenarioAdd: name={self.scenario_name}"
+
+Section = Literal["given", "when", "then"]
+
+class ScenarioEdit(StateChange):
+    scenario_name: str
+    given: ScenarioDelta | None = None
+    when: ScenarioDelta | None = None
+    then: ScenarioDelta | None = None
+
+    @model_validator(mode="after")
+    def _must_have_some_delta(self) -> "ScenarioEdit":
+        deltas = [d for d in (self.given, self.when, self.then) if d is not None]
+
+        if not deltas:
+            raise ValueError("At least one of given/when/then must be provided.")
+
+        if all(d.is_empty() for d in deltas):
+            raise ValueError("ScenarioEdit has no effect: all provided deltas are empty.")
+
+        return self
+
+    def short_str(self) -> str:
+        parts = []
+        for sec in ("given", "when", "then"):
+            delta = getattr(self, sec)
+            if delta:
+                if delta.add:
+                    parts.append(f"{sec} +{delta.add}")
+                if delta.remove:
+                    parts.append(f"{sec} -{delta.remove}")
+        return f"ScenarioStepsEdit[{self.scenario_name}]: " + ", ".join(parts)
+
+class ScenarioRemove(StateChange):
+    """ Remove an existing scenario """
+    scenario_name : str = Field(..., description="Name of the scenario to remove")
+    
+    def short_str(self):
+        return f"[bold deep_blue_sky]ScenarioRemove[/bold deep_blue_sky]: [bold]Name:[/bold]{self.scenario_name}"
+
+# ----------------------------
+# Test traces
+# ----------------------------
+
+class RemoveTraceArtifact(StateChange):
+    """Remove an existing trace artifact (TestTrace or LogTrace)."""
+    art_id: str = Field(description="Artifact ID")
+
+    def short_str(self) -> str:
+        return (
+            f"[bold deep_blue_sky]RemoveTraceArtifact[/bold deep_blue_sky]: "
+            f"[bold]ArtID[/bold]: {self.art_id}"
+        )
+
+class AddTestTrace(StateChange):
+    """Add a new TestTrace."""
+    art_id: str | None = Field(description="Artifact ID")
+
+    # TraceArtifact core
+    given: str = Field(description="Concrete state value (IML expression)")
+    when: Optional[str] = Field(default=None, description="Optional concrete action value (IML expression)")
+    then: Optional[str] = Field(default=None, description="Optional resulting state value (IML expression)")
+    time: str = Field(default="", description="Optional timestamp")
+
+    # TestTrace fields
+    name: str = Field(description="Test case name (not unique)")
+    filepath: str = Field(default="", description="Original test filepath")
+    language: Optional[str] = Field(default=None, description="Language of the original test source")
+    contents: Optional[str] = Field(default=None, description="Original test contents")
+
+    def short_str(self) -> str:
+        return (
+            f"[bold deep_blue_sky]AddTestTrace[/bold deep_blue_sky]: "
+            f"[bold]ArtID[/bold]: {self.art_id}"
+        )
+
+class EditTestTrace(StateChange):
+    """Edit an existing TestTrace (patch semantics: only non-None fields are applied)."""
+    art_id: str = Field(description="Artifact ID")
+
+    # TraceArtifact core (patch)
+    given: Optional[str] = Field(default=None, description="Concrete state value (IML expression)")
+    when: Optional[str] = Field(default=None, description="Optional concrete action value (IML expression)")
+    then: Optional[str] = Field(default=None, description="Optional resulting state value (IML expression)")
+    time: Optional[str] = Field(default=None, description="Optional timestamp")
+
+    # TestTrace fields (patch)
+    name: Optional[str] = Field(default=None, description="Test case name (not unique)")
+    filepath: Optional[str] = Field(default=None, description="Original test filepath")
+    language: Optional[str] = Field(default=None, description="Language of the original test source")
+    contents: Optional[str] = Field(default=None, description="Original test contents")
+
+    @model_validator(mode="after")
+    def _must_change_something(self) -> EditTestTrace:
+        if (
+            self.given is None
+            and self.when is None
+            and self.then is None
+            and self.time is None
+            and self.name is None
+            and self.filepath is None
+            and self.language is None
+            and self.contents is None
+        ):
+            raise ValueError(
+                "EditTestTrace must provide at least one of: "
+                "given, when, then, time, name, filepath, language, or contents"
+            )
+        return self
+
+    def short_str(self) -> str:
+        return (
+            f"[bold deep_blue_sky]EditTestTrace[/bold deep_blue_sky]: "
+            f"[bold]ArtID[/bold]: {self.art_id}"
+        )
+
+# ----------------------------
+# Log traces
+# ----------------------------
+
+class AddLogTrace(StateChange):
+    """Add a new LogTrace."""
+    art_id: str | None = Field(description="Artifact ID")
+
+    # TraceArtifact core
+    given: str = Field(description="Concrete state value (IML expression)")
+    when: Optional[str] = Field(default=None, description="Optional concrete action value (IML expression)")
+    then: Optional[str] = Field(default=None, description="Optional resulting state value (IML expression)")
+    time: str = Field(default="", description="Optional timestamp")
+
+    # LogTrace fields
+    filename: str = Field(description="Log filename (not unique)")
+    contents: str = Field(description="Log entry contents")
+
+    def short_str(self) -> str:
+        return (
+            f"[bold deep_blue_sky]AddLogTrace[/bold deep_blue_sky]: "
+            f"[bold]ArtID[/bold]: {self.art_id}"
+        )
+
+class EditLogTrace(StateChange):
+    """Edit an existing LogTrace (patch semantics: only non-None fields are applied)."""
+    art_id: str = Field(description="Artifact ID")
+
+    # TraceArtifact core (patch)
+    given: Optional[str] = Field(default=None, description="Concrete state value (IML expression)")
+    when: Optional[str] = Field(default=None, description="Optional concrete action value (IML expression)")
+    then: Optional[str] = Field(default=None, description="Optional resulting state value (IML expression)")
+    time: Optional[str] = Field(default=None, description="Optional timestamp")
+
+    # LogTrace fields (patch)
+    filename: Optional[str] = Field(default=None, description="Log filename (not unique)")
+    contents: Optional[str] = Field(default=None, description="Log entry contents")
+
+    @model_validator(mode="after")
+    def _must_change_something(self) -> EditLogTrace:
+        if (
+            self.given is None
+            and self.when is None
+            and self.then is None
+            and self.time is None
+            and self.filename is None
+            and self.contents is None
+        ):
+            raise ValueError(
+                "EditLogTrace must provide at least one of: "
+                "given, when, then, time, filename, or contents"
+            )
+        return self
+
+    def short_str(self) -> str:
+        return (
+            f"[bold deep_blue_sky]EditLogTrace[/bold deep_blue_sky]: "
+            f"[bold]ArtID[/bold]: {self.art_id}"
+        )
+
+# ----------------------------
+# RemoveDataArtifact
+# ----------------------------
+
+class RemoveDataArtifact(StateChange):
+    """ Remove an existing data artifact """
+    art_id: str = Field(description="Artifact ID")
+    def short_str(self) -> str:
+        return "[bold deep_blue_sky]RemoveDataArtifact[/bold deep_blue_sky]"
+
+# ----------------------------
+# Documentation references
+# ----------------------------
+
+class AddDocRef(StateChange):
+    """Add a new documentation reference artifact."""
+    art_id: str | None = Field(description="Artifact ID")
+    text: str = Field(description="Documentation text")
+    meta: str | None = Field(default=None, description="Optional metadata")
+
+    def short_str(self) -> str:
+        return f"[bold deep_blue_sky]AddDocRef[/bold deep_blue_sky]: [bold]ArtID[/bold]: {self.art_id}"
+
+class EditDocRef(StateChange):
+    """Edit an existing DocRef."""
+    art_id: str = Field(description="Artifact ID")
+    text: str | None = Field(default=None, description="New documentation text")
+    meta: str | None = Field(default=None, description="New metadata")
+
+    @model_validator(mode="after")
+    def _must_change_something(self) -> "EditDocRef":
+        if self.text is None and self.meta is None:
+            raise ValueError("EditDocRef must provide at least one of: text or meta")
+        return self
+
+    def short_str(self) -> str:
+        return f"[bold deep_blue_sky]EditDocRef[/bold deep_blue_sky]: [bold]ArtID[/bold]: {self.art_id}"
+    
+# ----------------------------
+# Source code references
+# ----------------------------
+
+class AddSrcCodeRef(StateChange):
+    """Add a new source code reference artifact."""
+    art_id: str | None = Field(description="Artifact ID")
+    src_code: str = Field(description="Source code")
+    language: str | None = Field(default=None, description="Programming language")
+    file_path: str | None = Field(default=None, description="Optional file path")
+    iml_code: str | None = Field(default=None, description="Optional IML formalization")
+    meta: str | None = Field(default=None, description="Optional metadata")
+
+    def short_str(self) -> str:
+        return f"[bold deep_blue_sky]AddSrcCodeRef[/bold deep_blue_sky]: [bold]ArtID[/bold]: {self.art_id}"
+    
+class EditSrcCodeRef(StateChange):
+    """Edit an existing SrcCodeRef."""
+    art_id: str = Field(description="Artifact ID")
+    src_code: str | None = Field(default=None, description="Updated source code")
+    language: str | None = Field(default=None, description="Updated language")
+    file_path: str | None = Field(default=None, description="Updated file path")
+    iml_code: str | None = Field(default=None, description="Updated IML formalization")
+    meta: str | None = Field(default=None, description="Updated metadata")
+
+    @model_validator(mode="after")
+    def _must_change_something(self) -> EditSrcCodeRef:
+        if (
+            self.src_code is None
+            and self.language is None
+            and self.file_path is None
+            and self.iml_code is None
+            and self.meta is None
+        ):
+            raise ValueError(
+                "EditSrcCodeRef must provide at least one of: "
+                "src_code, language, file_path, iml_code, or meta"
+            )
+        return self
+
+    def short_str(self) -> str:
+        return f"[bold deep_blue_sky]EditSrcCodeRef[/bold deep_blue_sky]: [bold]ArtID[/bold]: {self.art_id}"
+
+# ----------------------------
+# Links in the ArtifactMap
+# ----------------------------
+
+class LinkArtifactsComponents(StateChange):
+    """ Add a link between a non-executable arifact (e.g. source code or documentation) and a model component """
+    art_id : str = Field(description="Artifact ID")
+    comp_name : str = Field(description="Component name")
+
+    def short_str(self) -> str:
+        return "[bold deep_blue_sky]LinkArtifactComponents[/bold deep_blue_sky]"
+
+class RemoveArtComponentLink(StateChange):
+    """ Remove a link between a non-executable arifact (e.g. source code or documentation) and a model component """
+    art_id : str = Field(description="Artifact ID")
+    comp_name : str = Field(description="Component name")
+
+    def short_str(self) -> str:
+        return "[bold deep_blue_sky]RemoveArtComponentLink[/bold deep_blue_sky]"

speclogician/state/change_result.py

@@ -0,0 +1,32 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/state/change_result.py
+#
+
+from __future__ import annotations
+
+from typing import Literal, TypedDict
+
+from ..state.change import StateChange
+from ..state.inst import StateInstance
+from ..state.diff import StateDiff
+from typing import  Union
+
+class ProcessChangeError(TypedDict):
+    ok: Literal[False]
+    stage: Literal["apply_change", "analyze_change", "calc_diff", "refresh_stats"]
+    error: Exception
+    change: StateChange
+    old_state: StateInstance
+
+class ProcessChangeSuccess(TypedDict):
+    ok: Literal[True]
+    stage: Literal["ok"]
+    change: StateChange
+    old_state: StateInstance
+    new_state: StateInstance
+    state_diff: StateDiff | None # this is because it could potentially be the first state instance
+    new_num_instances: int
+
+ProcessChangeResult = Union[ProcessChangeError, ProcessChangeSuccess]