speclogician 0.0.0b1__py3-none-any.whl

speclogician/commands/cmd_find.py

@@ -0,0 +1,256 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/commands/find_cmd.py
+#
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+from rich.table import Table
+
+from .utils import get_state
+from ..utils import console
+
+app = typer.Typer(help="Find various components of the state")
+
+
+# -----------------------------------------------------------------------------
+# helpers
+# -----------------------------------------------------------------------------
+
+def _matches_component(q: str, *, name: str, src_code: str) -> bool:
+    qq = (q or "").lower()
+    return (qq in (name or "").lower()) or (qq in (src_code or "").lower())
+
+
+def _emit_json(payload: dict[str, Any]) -> None:
+    # Keep stdout clean for machine mode (matches your convention elsewhere)
+    import json as _json
+    typer.echo(_json.dumps(payload, indent=2, sort_keys=True))
+
+
+def _preview(src: str, n: int = 160) -> str:
+    return (src or "")[:n].replace("\n", " ")
+
+
+# -----------------------------------------------------------------------------
+# predicates
+# -----------------------------------------------------------------------------
+
+@app.command(name="predicates", help="Search state/action predicates by name or source text")
+def search_predicates(
+    ctx: typer.Context,
+    q: str = typer.Argument(..., help="Search string (name or source snippet)"),
+    kind: str = typer.Option(
+        "all",
+        "--kind",
+        help="Search scope: all|state|action",
+    ),
+    json_only: bool = typer.Option(
+        False,
+        "--json",
+        help="Emit JSON only (no rich output)",
+    ),
+) -> None:
+    state = get_state(ctx=ctx)
+    dm = state.curr_state().spec.domain_model
+
+    k = (kind or "all").lower().strip()
+    if k not in ("all", "state", "action"):
+        raise typer.BadParameter("kind must be one of: all|state|action")
+
+    matches: list[dict[str, Any]] = []
+
+    if k in ("all", "state"):
+        for p in getattr(dm, "state_preds", []):
+            name = getattr(p, "name", "")
+            src_code = getattr(p, "src_code", "")
+            if _matches_component(q, name=name, src_code=src_code):
+                matches.append(
+                    {
+                        "type": "StatePredicate",
+                        "kind": getattr(p, "kind", "state_predicate"),
+                        "name": name,
+                        "src_preview": _preview(src_code),
+                    }
+                )
+
+    if k in ("all", "action"):
+        for p in getattr(dm, "action_preds", []):
+            name = getattr(p, "name", "")
+            src_code = getattr(p, "src_code", "")
+            if _matches_component(q, name=name, src_code=src_code):
+                matches.append(
+                    {
+                        "type": "ActionPredicate",
+                        "kind": getattr(p, "kind", "action_predicate"),
+                        "name": name,
+                        "src_preview": _preview(src_code),
+                    }
+                )
+
+    # Deterministic output (nice for tests)
+    matches.sort(key=lambda m: (m.get("type", ""), m.get("name", "")))
+
+    if json_only:
+        _emit_json(
+            {
+                "query": q,
+                "kind": k,
+                "count": len(matches),
+                "results": matches,
+            }
+        )
+        return
+
+    t = Table(title=f"Predicate search for {q!r}", show_header=True, header_style="bold")
+    t.add_column("Type", no_wrap=True)
+    t.add_column("Name", no_wrap=True)
+    t.add_column("Preview")
+    for m in matches:
+        prev = m["src_preview"]
+        t.add_row(m["type"], m["name"], prev + ("…" if len(prev) == 160 else ""))
+    console.print(t)
+
+
+# -----------------------------------------------------------------------------
+# transitions
+# -----------------------------------------------------------------------------
+
+@app.command(name="transitions", help="Search transition functions by name or source text")
+def search_transitions(
+    ctx: typer.Context,
+    q: str = typer.Argument(..., help="Search string (name or source snippet)"),
+    json_only: bool = typer.Option(
+        False,
+        "--json",
+        help="Emit JSON only (no rich output)",
+    ),
+) -> None:
+    state = get_state(ctx=ctx)
+    dm = state.curr_state().spec.domain_model
+
+    matches: list[dict[str, Any]] = []
+
+    for tr in getattr(dm, "transitions", []):
+        name = getattr(tr, "name", "")
+        src_code = getattr(tr, "src_code", "")
+        if _matches_component(q, name=name, src_code=src_code):
+            matches.append(
+                {
+                    "type": "Transition",
+                    "kind": getattr(tr, "kind", "transition"),
+                    "name": name,
+                    "src_preview": _preview(src_code),
+                }
+            )
+
+    matches.sort(key=lambda m: m.get("name", ""))
+
+    if json_only:
+        _emit_json(
+            {
+                "query": q,
+                "count": len(matches),
+                "results": matches,
+            }
+        )
+        return
+
+    t = Table(title=f"Transition search for {q!r}", show_header=True, header_style="bold")
+    t.add_column("Name", no_wrap=True)
+    t.add_column("Preview")
+    for m in matches:
+        prev = m["src_preview"]
+        t.add_row(m["name"], prev + ("…" if len(prev) == 160 else ""))
+    console.print(t)
+
+
+# -----------------------------------------------------------------------------
+# artifacts (smart_find + PM renderer)
+# -----------------------------------------------------------------------------
+
+@app.command("artifacts")
+def search_artifacts(
+    ctx: typer.Context,
+    q: str = typer.Argument(..., help="Search string"),
+    kind: str = typer.Option(
+        "all",
+        "--kind",
+        help="Search scope: all|tests|logs|docs|src",
+    ),
+    json_only: bool = typer.Option(
+        False,
+        "--json",
+        help="Emit JSON only (no rich output)",
+    ),
+    ids: bool = typer.Option(
+        False,
+        "--ids",
+        help="Show artifact IDs in rich output",
+    ),
+    compact: bool = typer.Option(
+        False,
+        "--compact",
+        help="Use compact tables/panels in rich output",
+    ),
+    show_empty: bool = typer.Option(
+        False,
+        "--show-empty",
+        help="Render empty sections in rich output",
+    ),
+    max_per_type: int = typer.Option(
+        50,
+        "--max-per-type",
+        min=1,
+        help="Maximum results to show per artifact type",
+    ),
+) -> None:
+    """Smart text search across artifacts (tests/logs/docs/src)."""
+    state = get_state(ctx=ctx)
+    ac = state.curr_state().art_container
+
+    k = (kind or "all").lower().strip()
+    include: set[str] | None
+    if k in ("all", "*"):
+        include = None
+    elif k in ("tests", "test"):
+        include = {"test"}
+    elif k in ("logs", "log"):
+        include = {"log"}
+    elif k in ("docs", "doc"):
+        include = {"doc"}
+    elif k in ("src", "source"):
+        include = {"src"}
+    else:
+        raise typer.BadParameter("kind must be one of: all|tests|logs|docs|src")
+
+    # --- search ---
+    res = ac.smart_find(q, include=include, max_per_type=max_per_type)
+
+    # --- build PM + render ---
+    from speclogician.presentation.ctx import RenderCtx
+    from speclogician.presentation.builders.smart_find import build_smart_find_pm
+    from speclogician.presentation.renderers.smart_find import render_smart_find
+
+    rctx = RenderCtx(
+        show_art_ids=ids,
+        show_ids=ids,
+        compact=compact,
+        show_empty_sections=show_empty,  # now a real field on RenderCtx
+    )
+
+    pm = build_smart_find_pm(res, rctx)
+
+    if json_only:
+        payload = pm.model_dump()
+        # test-friendly extra metadata
+        payload["query"] = q
+        payload["kind"] = k
+        _emit_json(payload)
+        return
+
+    console.print(render_smart_find(pm, ctx=rctx))

speclogician/commands/cmd_view.py

@@ -0,0 +1,202 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/cli/view_cmd.py
+#   
+
+from __future__ import annotations
+
+import json
+from typing import Optional
+import typer
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.api import (
+    present_state_instance,
+    present_spec,
+    present_domain_model,
+    present_artifact_container,
+    present_state_diff,
+    present_instances_list,
+)
+
+from .utils import get_state
+
+app = typer.Typer(help="View components of the current state (rich or JSON).")
+
+
+def _mk_ctx(
+    *,
+    compact: bool,
+    show_stats_only: bool,
+    show_code: bool,
+    show_ids: bool,
+    show_art_ids: bool,
+) -> RenderCtx:
+    return RenderCtx(
+        compact=compact,
+        show_stats_only=show_stats_only,
+        show_code=show_code,
+        show_ids=show_ids,
+        show_art_ids=show_art_ids,
+    )
+
+
+def _emit(obj: object, *, json_only: bool) -> None:
+    if json_only:
+        typer.echo(json.dumps(obj, indent=2, default=str))
+    else:
+        # rich renderables can be printed by your console; if you want,
+        # import speclogician.utils.console and console.print(obj)
+        from speclogician.utils import console
+        console.print(obj)
+
+
+# ---------------------------
+# view state (full)
+# ---------------------------
+
+@app.command("state")
+def view_state(
+    ctx: typer.Context,
+    idx: Optional[int] = typer.Option(None, "--idx", help="State instance index (default: latest/0)"),
+    json_only: bool = typer.Option(False, "--json", help="Emit JSON only"),
+    compact: bool = typer.Option(False, "--compact"),
+    show_stats_only: bool = typer.Option(False, "--stats-only"),
+    show_code: bool = typer.Option(True, "--code/--no-code"),
+    show_ids: bool = typer.Option(False, "--ids"),
+    show_art_ids: bool = typer.Option(False, "--art-ids"),
+) -> None:
+    st = get_state(ctx)
+    i = 0 if idx is None else idx
+    si = st.instances[i]
+
+    rctx = _mk_ctx(
+        compact=compact,
+        show_stats_only=show_stats_only,
+        show_code=show_code,
+        show_ids=show_ids,
+        show_art_ids=show_art_ids,
+    )
+
+    out = present_state_instance(si, ctx=rctx, json_only=json_only)
+    _emit(out, json_only=json_only)
+
+
+# ---------------------------
+# view spec
+# ---------------------------
+
+@app.command("spec")
+def view_spec_cmd(
+    ctx: typer.Context,
+    idx: Optional[int] = typer.Option(None, "--idx"),
+    json_only: bool = typer.Option(False, "--json"),
+    compact: bool = typer.Option(False, "--compact"),
+    show_stats_only: bool = typer.Option(False, "--stats-only"),
+    show_code: bool = typer.Option(True, "--code/--no-code"),
+    show_ids: bool = typer.Option(False, "--ids"),
+    show_art_ids: bool = typer.Option(False, "--art-ids"),
+) -> None:
+    st = get_state(ctx)
+    i = 0 if idx is None else idx
+    si = st.instances[i]
+
+    rctx = _mk_ctx(compact=compact, show_stats_only=show_stats_only, show_code=show_code, show_ids=show_ids, show_art_ids=show_art_ids)
+    out = present_spec(si.spec, ctx=rctx, json_only=json_only)
+    _emit(out, json_only=json_only)
+
+
+# ---------------------------
+# view domain model
+# ---------------------------
+
+@app.command("domain")
+def view_domain_cmd(
+    ctx: typer.Context,
+    idx: Optional[int] = typer.Option(None, "--idx"),
+    json_only: bool = typer.Option(False, "--json"),
+    compact: bool = typer.Option(False, "--compact"),
+    show_stats_only: bool = typer.Option(False, "--stats-only"),
+    show_code: bool = typer.Option(True, "--code/--no-code"),
+    show_ids: bool = typer.Option(False, "--ids"),
+    show_art_ids: bool = typer.Option(False, "--art-ids"),
+) -> None:
+    st = get_state(ctx)
+    i = 0 if idx is None else idx
+    si = st.instances[i]
+
+    rctx = _mk_ctx(compact=compact, show_stats_only=show_stats_only, show_code=show_code, show_ids=show_ids, show_art_ids=show_art_ids)
+    out = present_domain_model(si.spec.domain_model, ctx=rctx, json_only=json_only)
+    _emit(out, json_only=json_only)
+
+
+# ---------------------------
+# view artifacts container
+# ---------------------------
+
+@app.command("artifacts")
+def view_artifacts_cmd(
+    ctx: typer.Context,
+    idx: Optional[int] = typer.Option(None, "--idx"),
+    json_only: bool = typer.Option(False, "--json"),
+    compact: bool = typer.Option(False, "--compact"),
+    show_stats_only: bool = typer.Option(False, "--stats-only"),
+    show_code: bool = typer.Option(True, "--code/--no-code"),
+    show_ids: bool = typer.Option(False, "--ids"),
+    show_art_ids: bool = typer.Option(False, "--art-ids"),
+) -> None:
+    st = get_state(ctx)
+    i = 0 if idx is None else idx
+    si = st.instances[i]
+
+    rctx = _mk_ctx(compact=compact, show_stats_only=show_stats_only, show_code=show_code, show_ids=show_ids, show_art_ids=show_art_ids)
+    out = present_artifact_container(si.art_container, ctx=rctx, json_only=json_only)
+    _emit(out, json_only=json_only)
+
+
+# ---------------------------
+# view diff (latest instance must have it computed/stored, or compute outside)
+# ---------------------------
+
+@app.command("diff")
+def view_diff_cmd(
+    ctx: typer.Context,
+    idx: Optional[int] = typer.Option(None, "--idx"),
+    json_only: bool = typer.Option(False, "--json"),
+    compact: bool = typer.Option(False, "--compact"),
+    show_stats_only: bool = typer.Option(False, "--stats-only"),
+    show_code: bool = typer.Option(True, "--code/--no-code"),
+    show_ids: bool = typer.Option(False, "--ids"),
+    show_art_ids: bool = typer.Option(False, "--art-ids"),
+) -> None:
+    st = get_state(ctx)
+    i = 0 if idx is None else idx
+    si = st.instances[i]
+
+    if si.state_diff is None:
+        raise typer.BadParameter("No state_diff available on this instance.")
+
+    rctx = _mk_ctx(compact=compact, show_stats_only=show_stats_only, show_code=show_code, show_ids=show_ids, show_art_ids=show_art_ids)
+    out = present_state_diff(si.state_diff, ctx=rctx, json_only=json_only)
+    _emit(out, json_only=json_only)
+
+
+# ---------------------------
+# view list of instances
+# ---------------------------
+
+@app.command("instances")
+def view_instances_cmd(
+    ctx: typer.Context,
+    json_only: bool = typer.Option(False, "--json"),
+    compact: bool = typer.Option(False, "--compact"),
+    show_stats_only: bool = typer.Option(False, "--stats-only"),
+    show_code: bool = typer.Option(True, "--code/--no-code"),
+    show_ids: bool = typer.Option(False, "--ids"),
+    show_art_ids: bool = typer.Option(False, "--art-ids"),
+) -> None:
+    st = get_state(ctx)
+    rctx = _mk_ctx(compact=compact, show_stats_only=show_stats_only, show_code=show_code, show_ids=show_ids, show_art_ids=show_art_ids)
+    out = present_instances_list(st.instances, ctx=rctx, json_only=json_only)
+    _emit(out, json_only=json_only)

speclogician/commands/runner.py

@@ -0,0 +1,149 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/commands/runner.py
+#
+
+from __future__ import annotations
+
+import json
+import typer
+from enum import Enum
+from datetime import datetime
+from typing import NoReturn, Any
+from rich.console import Console
+
+from speclogician.state.change import StateChange
+from speclogician.state.state import State  # adjust import
+from speclogician.state.change_result import (
+    ProcessChangeResult,
+    ProcessChangeError,
+    ProcessChangeSuccess,
+)
+
+from speclogician.presentation.ctx import RenderCtx
+from speclogician.presentation.builders.state_instance import build_state_instance_pm
+from speclogician.presentation.builders.state_diff import build_state_diff_pm
+
+from speclogician.presentation.renderers.state_instance import render_state_instance
+from speclogician.presentation.renderers.state_diff import render_state_diff  # assuming you have it
+
+console = Console()
+
+
+def _dump_json(obj: Any) -> str:
+    def _default(o: Any):
+        if hasattr(o, "model_dump"):
+            return o.model_dump(mode="json")
+        if isinstance(o, Enum):
+            return o.value
+        if isinstance(o, datetime):
+            return o.isoformat()
+        raise TypeError(f"Object of type {type(o).__name__} is not JSON serializable")
+
+    return json.dumps(
+        obj,
+        default=_default,
+        indent=2,
+        sort_keys=True,
+    )
+
+def run_change_and_render(
+    st: State,
+    change: StateChange,
+    *,
+    json_only: bool,
+) -> NoReturn:
+    """
+    Unified runner for CLI commands.
+
+    - json_only=True: emits JSON PM payload to stdout (stable, parseable).
+    - json_only=False: pretty-prints PMs via Rich renderers.
+    """
+
+    # Always take the object path so we can drive presentation from PMs.
+    result_obj: ProcessChangeResult = st.process_change(change, json_only=json_only)
+    st.save()
+
+    # -------------------------
+    # Error branch
+    # -------------------------
+    if not result_obj["ok"]:
+        err_res: ProcessChangeError = result_obj
+
+        # Build ctx from the old state if possible
+        old_state = err_res["old_state"]
+        ctx = RenderCtx(
+            art_cont=old_state.art_container,
+            art_map=old_state.art_map,
+        )
+
+        old_pm = build_state_instance_pm(old_state, ctx=ctx)
+
+        if json:
+            payload = {
+                "ok": False,
+                "stage": err_res["stage"],
+                "change": err_res["change"].model_dump(mode="json"),
+                "error": {
+                    "type": type(err_res["error"]).__name__,
+                    "message": str(err_res["error"]),
+                },
+                "old_state": old_pm.model_dump(mode="json"),
+            }
+            typer.echo(_dump_json(payload))
+            raise typer.Exit(code=1)
+
+        # human output
+        console.print(f"[bold red]Error[/bold red] stage={err_res['stage']}")
+        console.print(f"[red]{type(err_res['error']).__name__}: {err_res['error']}[/red]\n")
+        console.print("[bold]Old state[/bold]")
+        console.print(render_state_instance(old_pm, ctx=ctx))
+        raise typer.Exit(code=1)
+
+    # -------------------------
+    # Success branch
+    # -------------------------
+    ok_res: ProcessChangeSuccess = result_obj
+
+    old_state = ok_res["old_state"]
+    new_state = ok_res["new_state"]
+    sd = ok_res["state_diff"]
+
+    # Prefer new-state context for presentation (has freshest art_map/art_cont)
+    ctx = RenderCtx(
+        art_cont=new_state.art_container,
+        art_map=new_state.art_map,
+    )
+
+    old_pm = build_state_instance_pm(old_state, ctx=ctx)
+    new_pm = build_state_instance_pm(new_state, ctx=ctx)
+    diff_pm = build_state_diff_pm(sd, ctx=ctx)
+
+    if json:
+        payload = {
+            "ok": True,
+            "stage": "ok",
+            "change": ok_res["change"].model_dump(mode="json"),
+            "old_state": old_pm.model_dump(mode="json"),
+            "new_state": new_pm.model_dump(mode="json"),
+            "state_diff": diff_pm.model_dump(mode="json"),
+            "new_num_instances": ok_res["new_num_instances"],
+        }
+        typer.echo(_dump_json(payload))
+        raise typer.Exit(code=0)
+
+    # human output
+    console.print("[bold]Old state[/bold]")
+    console.print(render_state_instance(old_pm, ctx=ctx))
+    console.print()
+
+    console.print("[bold]New state[/bold]")
+    console.print(render_state_instance(new_pm, ctx=ctx))
+    console.print()
+
+    console.print("[bold]Diff[/bold]")
+    console.print(render_state_diff(diff_pm, ctx=ctx))
+    console.print()
+
+    raise typer.Exit(code=0)

speclogician/commands/utils.py

@@ -0,0 +1,101 @@
+#
+#   Imandra Inc.
+#
+#   speclogician/commands/utils.py
+#
+
+from __future__ import annotations
+from collections.abc import Mapping, Sequence
+
+import json
+from pathlib import Path
+from typing import TypeVar
+
+import typer
+from ..utils.load import load_state
+from ..state.change import StateChange
+from ..state.state import State
+
+from ..modeling.scenario import ScenarioDelta
+
+T = TypeVar("T", bound=StateChange)
+
+def get_state(ctx: typer.Context) -> State:
+    state = ctx.obj.state
+    if state is None:
+        state = load_state()
+    return state
+
+def normalize_string_escapes(v: str) -> str:
+    """
+    Convert escaped sequences like '\\n', '\\t' into actual characters.
+    """
+    try:
+        return v.encode("utf-8").decode("unicode_escape")
+    except Exception:
+        return v
+
+def normalize_data(obj):
+    if isinstance(obj, str):
+        return normalize_string_escapes(obj)
+
+    if isinstance(obj, Mapping):
+        return {k: normalize_data(v) for k, v in obj.items()}
+
+    if isinstance(obj, Sequence) and not isinstance(obj, (str, bytes)):
+        return [normalize_data(v) for v in obj]
+
+    return obj
+
+
+def parse_scenario_delta(value: str | None) -> ScenarioDelta | None:
+    """
+    Parse a ScenarioDelta from CLI input.
+
+    Accepted forms:
+      1) None / "" -> None
+      2) Comma-separated tokens:
+           "+p1,+p2,-p3"   => add=["p1","p2"], remove=["p3"]
+           "p1,p2"         => add=["p1","p2"], remove=[]
+           "-p3"           => add=[], remove=["p3"]
+      3) JSON:
+           '{"add":["p1"],"remove":["p2"]}'
+         or a path to a JSON file containing that object.
+
+    Validation (dedup, identifier check, overlap) is enforced by ScenarioDelta itself.
+    """
+    if value is None:
+        return None
+
+    s = value.strip()
+    if not s:
+        return None
+
+    # File path to JSON
+    p = Path(s)
+    if p.exists() and p.is_file():
+        data = json.loads(p.read_text())
+        delta = ScenarioDelta.model_validate(data)
+        return None if delta.is_empty() else delta
+
+    # Inline JSON
+    if s.startswith("{"):
+        data = json.loads(s)
+        delta = ScenarioDelta.model_validate(data)
+        return None if delta.is_empty() else delta
+
+    # Token format: "+a,+b,-c" or "a,b"
+    add: list[str] = []
+    remove: list[str] = []
+
+    for tok in (t.strip() for t in s.split(",") if t.strip()):
+        if tok.startswith("+"):
+            add.append(tok[1:].strip())
+        elif tok.startswith("-"):
+            remove.append(tok[1:].strip())
+        else:
+            # default: treat as add
+            add.append(tok)
+
+    delta = ScenarioDelta(add=add, remove=remove)
+    return None if delta.is_empty() else delta