speclogician 0.0.0b1__py3-none-any.whl → 0.0.0.dev1__py3-none-any.whl

speclogician/commands/cmd_find.py

@@ -1,256 +0,0 @@
-#
-#   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

@@ -1,202 +0,0 @@
-#
-#   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

@@ -1,149 +0,0 @@
-#
-#   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

@@ -1,101 +0,0 @@
-#
-#   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