tlaplus-cli 0.5.0__tar.gz → 0.6.0__tar.gz

{tlaplus_cli-0.5.0/src/tlaplus_cli.egg-info → tlaplus_cli-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tlaplus-cli
-Version: 0.5.0
+Version: 0.6.0
 Summary: TLA+ tools: download TLC, compile custom modules, run model checker
 Author-email: Denis Nikolskiy <codeomatics@gmail.com>
 License-Expression: MIT
@@ -25,6 +25,7 @@ Requires-Dist: pyyaml<7.0,>=6.0
 Requires-Dist: platformdirs<5.0,>=4.0
 Requires-Dist: pydantic<3.0.0,>=2.12.5
 Requires-Dist: truststore<1.0.0,>=0.9.0
+Requires-Dist: rich<14.0.0,>=13.7.0
 Dynamic: license-file
 
 # TLA+ CLI

{tlaplus_cli-0.5.0 → tlaplus_cli-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tlaplus-cli"
-version = "0.5.0"
+version = "0.6.0"
 description = "TLA+ tools: download TLC, compile custom modules, run model checker"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -15,6 +15,7 @@ dependencies = [
     "platformdirs>=4.0,<5.0",
     "pydantic>=2.12.5,<3.0.0",
     "truststore>=0.9.0,<1.0.0",
+    "rich>=13.7.0,<14.0.0",
 ]
 authors = [
     {name = "Denis Nikolskiy", email = "codeomatics@gmail.com"}

{tlaplus_cli-0.5.0 → tlaplus_cli-0.6.0}/src/tlaplus_cli/cmd/tlc.py

@@ -1,11 +1,14 @@
 import typer
+from rich.console import Console
+from rich.live import Live
 
 from tlaplus_cli import ui
 from tlaplus_cli.config.loader import load_config
 from tlaplus_cli.java.classpath import ClasspathResolver
 from tlaplus_cli.project import find_project_root
 from tlaplus_cli.tlc.compiler import get_tlc_jar_path
-from tlaplus_cli.tlc.models import CheckState, CheckStatus, ModelCheckResult
+from tlaplus_cli.tlc.formatter import TlcFormatter
+from tlaplus_cli.tlc.models import CheckState, ModelCheckResult
 from tlaplus_cli.tlc.runner import (
     build_tlc_command,
     get_tlc_version,
@@ -31,18 +34,6 @@ def version_callback(value: bool) -> None:
         raise typer.Exit(0)
 
 
-def print_progress(result: ModelCheckResult) -> None:
-    """Callback to print progress from ModelCheckResult."""
-    if result.status == CheckStatus.SuccessorStatesComputing and result.initial_states_stat:
-        last_stat = result.initial_states_stat[-1]
-        # Use carriage return to update the same line for progress
-        msg = f"Progress: {last_stat.total} states generated, {last_stat.distinct} distinct states found"
-        typer.echo(f"\r{msg}", err=True, nl=False)
-    elif result.status == CheckStatus.Finished:
-        # Final newline after progress
-        typer.echo("", err=True)
-
-
 def _show_diagnostic_info(spec: str, spec_name: str) -> None:
     """Show diagnostic info before running TLC."""
     version_str = get_tlc_version() or "unknown"
@@ -68,7 +59,8 @@ def _show_diagnostic_info(spec: str, spec_name: str) -> None:
 
 # PLR0912: This command handler orchestrates multiple output types (errors, warnings, results, progress);
 # splitting it would fragment the CLI's primary user-facing logic.
-def tlc(  # noqa: PLR0912
+# PLR0915: Too many statements.
+def tlc(  # noqa: PLR0912, PLR0915
     spec: str = typer.Argument(help="Name of the TLA+ specification (without .tla extension)."),
     # Typer requires the parameter in the signature to register the CLI option;
     # since the logic is in the eager callback, the value is not used here.
@@ -80,49 +72,69 @@ def tlc(  # noqa: PLR0912
         is_eager=True,
     ),
     show_command: bool = typer.Option(False, "--show-command", help="Print the command instead of executing it."),
+    _refresh_interval: float | None = typer.Option(
+        None,
+        "--refresh-interval",
+        help="Refresh interval for the output (seconds).",
+    ),
+    coverage: bool = typer.Option(False, "--coverage", help="Enable code coverage visualization."),
 ) -> None:
     """Run TLC model checker on a TLA+ specification."""
     # version argument is handled by version_callback (is_eager=True)
     try:
-        _, spec_name = resolve_spec_file(spec)
+        _, _spec_name = resolve_spec_file(spec)
     except FileNotFoundError as e:
         ui.error(str(e))
         raise typer.Exit(1) from None
 
     if show_command:
-        try:
-            cmd = build_tlc_command(spec)
-        except FileNotFoundError as e:
-            ui.error(str(e))
+        cmd = build_tlc_command(spec)
+        if coverage:
+            cmd.extend(["-coverage", "1"])
+        if not cmd:
             raise typer.Exit(1) from None
         typer.echo(" ".join(cmd))
         raise typer.Exit(0)
 
-    _show_diagnostic_info(spec, spec_name)
+    tlc_version = get_tlc_version() or "unknown"
+    formatter = TlcFormatter(tlc_version=tlc_version)
+    layout = formatter.create_layout()
 
     try:
-        # We need the parser to get the final result, so we'll wrap run_tlc
-        # or capture the result from the last callback.
         final_result: list[ModelCheckResult] = []
 
-        def wrapped_callback(res: ModelCheckResult) -> None:
-            print_progress(res)
-            if not final_result:
-                final_result.append(res)
-            else:
-                final_result[0] = res
+        with Live(layout, refresh_per_second=4, screen=False):
+
+            def wrapped_callback(res: ModelCheckResult) -> None:
+                formatter.update(layout, res)
+
+                if not final_result:
+                    final_result.append(res)
+                else:
+                    final_result[0] = res
 
-        exit_code = run_tlc(spec, callback=wrapped_callback)
+            exit_code = run_tlc(spec, callback=wrapped_callback, coverage=coverage)
 
         if final_result:
             res = final_result[0]
+
+            if res.sany_errors:
+                console = Console()
+                spec_file, _ = resolve_spec_file(spec)
+                for sany_err in res.sany_errors:
+                    console.print(formatter.render_sany_error(sany_err, spec_file))
+
             if res.state == CheckState.Success:
                 ui.success("Model checking completed successfully.")
             elif res.state == CheckState.Error:
                 ui.error(f"Model checking failed with {len(res.errors)} error(s).")
                 for err in res.errors:
-                    for line in err.lines:
-                        typer.echo(f"  {line}", err=True)
+                    if err.error_trace:
+                        console = Console()
+                        console.print(formatter.render_error_trace(err.error_trace))
+                    else:
+                        for line in err.lines:
+                            typer.echo(f"  {line}", err=True)
 
             if res.warnings:
                 ui.warn(f"Found {len(res.warnings)} warning(s).")
@@ -130,6 +142,14 @@ def tlc(  # noqa: PLR0912
                     for line in warn_info.lines:
                         typer.echo(f"  {line}", err=True)
 
+            if res.coverage_stat:
+                console = Console()
+                console.print(formatter.render_coverage_table(res.coverage_stat))
+
+                # Show inline coverage for the main spec
+                spec_file, _ = resolve_spec_file(spec)
+                console.print(formatter.render_inline_coverage(res.coverage_stat, spec_file))
+
             if res.duration:
                 ui.info(f"Duration: {res.duration}ms")
     except FileNotFoundError as e:

{tlaplus_cli-0.5.0 → tlaplus_cli-0.6.0}/src/tlaplus_cli/config/schema.py

@@ -26,6 +26,7 @@ class WorkspaceConfig(BaseModel):
 class TlcConfig(BaseModel):
     java_class: str = "tlc2.TLC"
     overrides_class: str = "tlc2.overrides.TLCOverrides"
+    refresh_interval: float = 1.0
 
 
 class JavaConfig(BaseModel):

{tlaplus_cli-0.5.0 → tlaplus_cli-0.6.0}/src/tlaplus_cli/resources/default_config.yaml

@@ -19,6 +19,7 @@ workspace:
 tlc:
   java_class: tlc2.TLC
   overrides_class: tlc2.overrides.TLCOverrides
+  refresh_interval: 1.0
 
 java:
   min_version: 11

tlaplus_cli-0.6.0/src/tlaplus_cli/tlc/formatter.py

@@ -0,0 +1,409 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from rich.align import Align
+from rich.console import Group
+from rich.layout import Layout
+from rich.table import Table
+from rich.text import Text
+from rich.tree import Tree
+
+from tlaplus_cli.tlc.models import (
+    CheckState,
+    CoverageItem,
+    ErrorTraceItem,
+    ModelCheckResult,
+    TlaValue,
+)
+from tlaplus_cli.tlc.sany import SanyMessage
+
+
+@dataclass
+class _Section:
+    """A named section in the TLC display."""
+
+    name: str
+    renderable: Any = field(default_factory=lambda: Text(""))
+    size: int | None = None
+
+    def update(self, renderable: Any) -> None:
+        """Update the section content."""
+        self.renderable = renderable
+
+    def __rich__(self) -> Any:
+        return self.renderable
+
+
+class TlcDisplay:
+    """A dynamic display that grows as content is added."""
+
+    def __init__(self) -> None:
+        self.children: list[_Section] = []
+        self.renderable: Any = Text("")
+
+    def __getitem__(self, name: str) -> _Section:
+        for child in self.children:
+            if child.name == name:
+                return child
+        raise KeyError(name)
+
+    def update(self, renderable: Any) -> None:
+        """Update root renderable (used before splitting)."""
+        self.renderable = renderable
+
+    def split_column(self, *sections: _Section) -> None:
+        """Set the active sections."""
+        self.children = list(sections)
+
+    def __rich__(self) -> Group:
+        if not self.children:
+            return Group(self.renderable)
+        return Group(*self.children)
+
+
+@dataclass
+class ValueDiff:
+    key: str | int
+    value: str
+    tag: str  # "added", "modified", "unchanged"
+    children: list["ValueDiff"] = field(default_factory=list)
+
+
+class LogDeduplicator:
+    """Groups consecutive identical logs into a single line with a count badge."""
+
+    def __init__(self) -> None:
+        self.last_line: str | None = None
+        self.count: int = 1
+
+    def process(self, line: str) -> str:
+        stripped_line = line.strip()
+        if stripped_line == self.last_line:
+            self.count += 1
+            return f"{stripped_line} ({self.count})"
+
+        self.last_line = stripped_line
+        self.count = 1
+        return stripped_line
+
+
+class TlcFormatter:
+    """Generates Rich layout for TLC model checking."""
+
+    def __init__(self, tlc_version: str = "unknown") -> None:
+        self.info_dedup = LogDeduplicator()
+        self.tlc_version = tlc_version
+
+    def render_sany_error(self, error: SanyMessage, spec_path: Path) -> Text:
+        """Render SANY error with source code highlight."""
+        result = Text()
+        result.append(f"✖ SANY Error: {error.message}\n", style="bold red")
+        result.append(f"  file://{spec_path}#L{error.range_start_line}\n\n", style="dim")
+
+        if error.range_start_line is not None:
+            try:
+                with spec_path.open() as f:
+                    lines = f.readlines()
+
+                start_line = max(0, error.range_start_line - 3)
+                end_line = min(len(lines), (error.range_end_line or error.range_start_line) + 2)
+
+                for i in range(start_line, end_line):
+                    line_num = i + 1
+                    line_content = lines[i].rstrip()
+                    if line_num == error.range_start_line:
+                        result.append(f"{line_num:4} │ ", style="bold")
+                        result.append(f"{line_content}\n")
+                        # Add caret
+                        col_start = error.range_start_col or 1
+                        col_end = error.range_end_col or col_start + 1
+                        caret_len = max(1, col_end - col_start)
+                        caret_line = "     │ " + " " * (col_start - 1) + "▲" * caret_len
+                        result.append(f"{caret_line}\n", style="bold red")
+                        msg = f"line {error.range_start_line}, col {col_start} to {col_end}"
+                        result.append(f"     │ {' ' * (col_start - 1)}└── Error here: {msg}\n", style="dim")
+                    else:
+                        result.append(f"{line_num:4} │ {line_content}\n", style="dim")
+
+            except OSError:
+                result.append("  (Source code unavailable)\n", style="dim")
+
+        return result
+
+    def diff_values(self, old_val: TlaValue | None, new_val: TlaValue) -> ValueDiff:
+        """Recursively diff two TlaValue trees."""
+        if old_val is None:
+            return ValueDiff(
+                key=new_val.key,
+                value=new_val.value,
+                tag="added",
+                children=[self.diff_values(None, child) for child in new_val.children],
+            )
+
+        if old_val.value == new_val.value:
+            return ValueDiff(
+                key=new_val.key,
+                value=new_val.value,
+                tag="unchanged",
+                children=[
+                    self.diff_values(old_child, new_child)
+                    for old_child, new_child in zip(old_val.children, new_val.children, strict=False)
+                ],
+            )
+
+        # Values are different, but maybe some children are the same
+        tag = "modified"
+        children = []
+        # Match children by key
+        old_children_map = {c.key: c for c in old_val.children}
+        for new_child in new_val.children:
+            old_child = old_children_map.get(new_child.key)
+            children.append(self.diff_values(old_child, new_child))
+
+        return ValueDiff(
+            key=new_val.key,
+            value=new_val.value,
+            tag=tag,
+            children=children,
+        )
+
+    def render_value_diff(self, diff: ValueDiff, tree: Tree | None = None) -> Tree:
+        """Render a ValueDiff into a Rich Tree."""
+        style = ""
+        prefix = ""
+        if diff.tag == "added":
+            style = "green"
+            prefix = "[bold green]A[/] "
+        elif diff.tag == "modified":
+            style = "yellow"
+            prefix = "[bold yellow]M[/] "
+        elif diff.tag == "unchanged":
+            style = "dim"
+
+        label = Text()
+        if prefix:
+            label.append(Text.from_markup(prefix))
+        label.append(f"{diff.key} = ")
+        label.append(diff.value, style=style)
+
+        node = Tree(label) if tree is None else tree.add(label)
+
+        for child in diff.children:
+            self.render_value_diff(child, node)
+
+        return node
+
+    def render_error_trace(self, trace: list[ErrorTraceItem]) -> Tree:
+        """Render a full error trace as a Tree."""
+        root = Tree("Counterexample (Error Trace)")
+        last_variables: dict[str | int, TlaValue] = {}
+
+        for item in trace:
+            state_label = Text(f"State {item.num}: {item.action}")
+            if item.module:
+                state_label.append(f" in {item.module}", style="italic")
+
+            state_node = root.add(state_label)
+
+            # Sort variables to ensure consistent order
+            sorted_vars = sorted(item.variables, key=lambda v: str(v.key))
+
+            for var in sorted_vars:
+                old_var = last_variables.get(var.key)
+                diff = self.diff_values(old_var, var)
+                self.render_value_diff(diff, state_node)
+                last_variables[var.key] = var
+
+        return root
+
+    def render_coverage_table(self, coverage: list[CoverageItem]) -> Table:
+        """Render action coverage table."""
+        table = Table(title="Action Coverage", expand=True)
+        table.add_column("Module")
+        table.add_column("Action")
+        table.add_column("Total States", justify="right")
+        table.add_column("Unique States", justify="right")
+
+        for item in coverage:
+            table.add_row(
+                item.module,
+                item.action,
+                f"{item.total:,}",
+                f"{item.distinct:,}",
+            )
+        return table
+
+    def render_inline_coverage(self, coverage: list[CoverageItem], spec_path: Path) -> Text:
+        """Render inline spec coverage."""
+        result = Text()
+        result.append("\nInline Coverage View:\n", style="bold")
+        result.append(" Coverage   Line │ Source Code\n", style="dim")
+        result.append("─────────── ─────┼─────────────────────────────────────────────\n", style="dim")
+
+        try:
+            with spec_path.open() as f:
+                lines = f.readlines()
+
+            # Map lines to coverage
+            line_coverage: dict[int, list[CoverageItem]] = {}
+            for item in coverage:
+                if item.module == spec_path.stem:
+                    for line_idx in range(item.range_start_line, item.range_end_line + 1):
+                        if line_idx not in line_coverage:
+                            line_coverage[line_idx] = []
+                        line_coverage[line_idx].append(item)
+
+            for i, line_content in enumerate(lines):
+                line_num = i + 1
+                cov_items = line_coverage.get(line_num, [])
+
+                cov_str = ""
+                style = ""
+                line_text = line_content.rstrip()
+                if cov_items:
+                    max_distinct = max(item.distinct for item in cov_items)
+                    cov_str = f"{max_distinct:,}"
+                    if max_distinct == 0:
+                        style = "bold red"
+                        line_text += "  <-- UNREACHED"
+
+                result.append(f"{cov_str:>11} {line_num:5} │ ", style="dim")
+                result.append(f"{line_text}\n", style=style)
+
+        except OSError:
+            result.append("  (Source code unavailable)\n", style="dim")
+
+        return result
+
+    def create_layout(self) -> Any:
+        """Create the initial layout structure with only the header."""
+        layout = TlcDisplay()
+        layout.update(Text(f"Starting TLC model checker (version {self.tlc_version}).", style="bold"))
+        return layout
+
+    def update(self, layout: Any, result: ModelCheckResult) -> None:
+        """Main update entry point that manages layout structure and content."""
+        self._ensure_layout_structure(layout, result)
+        self.update_header(layout, result)
+        if self._has_child(layout, "clock"):
+            self.update_clock(layout, result)
+        if self._has_child(layout, "logs"):
+            self.update_logs(layout, result)
+        if self._has_child(layout, "stats"):
+            self.update_stats(layout, result)
+
+    def _has_child(self, layout: Any, name: str) -> bool:
+        """Check if a layout has a child with the given name."""
+        return any(child.name == name for child in layout.children)
+
+    def _ensure_layout_structure(self, layout: Any, result: ModelCheckResult) -> None:
+        """Dynamically add sections as data becomes available."""
+        has_logs = bool(result.output_lines)
+        has_stats = bool(result.initial_states_stat)
+        has_clock = bool(result.start_date_time or result.process_info or result.duration)
+
+        # Build expected structure in desired order:
+        # 1. Header
+        # 2. Status Info (clock)
+        # 3. TLC instance info (logs)
+        # 4. State Space Progress (stats) - grows infinitely at the bottom
+        new_layouts = [_Section(name="header", size=2)]
+        if has_clock:
+            new_layouts.append(_Section(name="clock", size=7))
+        if has_logs:
+            new_layouts.append(_Section(name="logs"))
+        if has_stats:
+            new_layouts.append(_Section(name="stats"))
+
+        # Check if we need to update
+        current_names = [lay.name for lay in layout.children]
+        expected_names = [lay.name for lay in new_layouts]
+
+        if current_names != expected_names:
+            layout.split_column(*new_layouts)
+
+    def update_header(self, layout: Any, _result: ModelCheckResult) -> None:
+        """Update header."""
+        # _result is unused for now but kept for signature consistency
+        header_text = Text(f"Starting TLC model checker (version {self.tlc_version}).", style="bold")
+        if self._has_child(layout, "header"):
+            layout["header"].update(header_text)
+        else:
+            layout.update(header_text)
+
+    def update_stats(self, layout: Layout, result: ModelCheckResult) -> None:
+        table = Table(title="State Space Progress", expand=True)
+        table.add_column("Time")
+        table.add_column("Diameter", justify="right")
+        table.add_column("Found", justify="right")
+        table.add_column("Distinct", justify="right")
+        table.add_column("Queue", justify="right")
+
+        for item in result.initial_states_stat:
+            table.add_row(
+                item.timestamp,
+                str(item.diameter),
+                f"{item.total:,}",
+                f"{item.distinct:,}",
+                f"{item.queue_size:,}",
+            )
+        layout["stats"].update(table)
+
+    def update_logs(self, layout: Layout, result: ModelCheckResult) -> None:
+        """Update logs panel with TLC output."""
+        deduped_logs: list[str] = []
+        temp_dedup = LogDeduplicator()
+        for line in result.output_lines:
+            processed = temp_dedup.process(line)
+            if temp_dedup.count > 1 and deduped_logs:
+                deduped_logs[-1] = processed
+            else:
+                deduped_logs.append(processed)
+
+        log_lines = Text()
+        for line in deduped_logs[-10:]:
+            log_lines.append(f"{line}\n")
+
+        layout["logs"].update(Group(Align.center(Text("TLC instance info", style="bold")), log_lines))
+
+    def update_clock(self, layout: Layout, result: ModelCheckResult) -> None:
+        """Update info panel at the bottom with clock and TLC stats."""
+        layout["clock"].update(StatusInfoRenderable(result))
+
+
+class StatusInfoRenderable:
+    """Renderable that computes elapsed time dynamically."""
+
+    def __init__(self, result: ModelCheckResult) -> None:
+        self.result = result
+
+    def __rich__(self) -> Group:
+        """Render the status info group."""
+        status_text = self.result.status.name
+        if self.result.state == CheckState.Stopped:
+            status_text = "canceled"
+
+        if not self.result.start_date_time:
+            elapsed_str = "00:00:00"
+            elapsed_style = "dim"
+        else:
+            if self.result.state == CheckState.Running:
+                elapsed = datetime.now() - self.result.start_date_time
+            else:
+                elapsed = (self.result.end_date_time or datetime.now()) - self.result.start_date_time
+            seconds = int(elapsed.total_seconds())
+            hours, remainder = divmod(seconds, 3600)
+            minutes, seconds = divmod(remainder, 60)
+            elapsed_str = f"{hours:02}:{minutes:02}:{seconds:02}"
+            elapsed_style = "bold cyan"
+
+        info_text = Text()
+        info_text.append(f"Elapsed time: {elapsed_str}\n", style=elapsed_style)
+        info_text.append(f"Status: {status_text}\n")
+
+        if self.result.state == CheckState.Running:
+            info_text.append("Stop with Ctrl + C", style="yellow")
+
+        return Group(Align.center(Text("Status Info", style="bold")), info_text)

{tlaplus_cli-0.5.0 → tlaplus_cli-0.6.0}/src/tlaplus_cli/tlc/models.py

@@ -6,6 +6,7 @@ Ported and adapted from ts-output-parser/model/check.ts.
 from dataclasses import dataclass, field
 from datetime import datetime
 from enum import Enum
+from typing import Any
 
 
 class CheckState(Enum):
@@ -127,4 +128,5 @@ class ModelCheckResult:
     workers_count: int = 0
     collision_probability: str | None = None
     output_lines: list[str] = field(default_factory=list)
+    sany_errors: list[Any] = field(default_factory=list)
     trace_file_path: str | None = None

{tlaplus_cli-0.5.0 → tlaplus_cli-0.6.0}/src/tlaplus_cli/tlc/parser.py

@@ -139,6 +139,8 @@ class TlcParser:
         if code == codes.TLC_STARTING.num:
             self._parse_starting(message.lines)
             self.result.status = CheckStatus.Starting
+        elif code == codes.TLC_VERSION.num:
+            self.result.process_info = "".join(message.lines).strip()
         elif code == codes.TLC_PROGRESS_STATS.num:
             self._parse_progress_stats(message.lines)
             self.result.status = CheckStatus.SuccessorStatesComputing

{tlaplus_cli-0.5.0 → tlaplus_cli-0.6.0}/src/tlaplus_cli/tlc/runner.py

@@ -8,8 +8,9 @@ from tlaplus_cli.java import validate_java_version
 from tlaplus_cli.java.classpath import ClasspathResolver, ResolveMode
 from tlaplus_cli.project import find_project_root
 from tlaplus_cli.tlc.compiler import get_tlc_jar_path
-from tlaplus_cli.tlc.models import ModelCheckResult
+from tlaplus_cli.tlc.models import CheckState, ModelCheckResult
 from tlaplus_cli.tlc.parser import TlcParser
+from tlaplus_cli.tlc.sany import SanyParser
 
 
 def resolve_spec_file(spec: str) -> tuple[Path, str]:
@@ -66,7 +67,7 @@ def build_tlc_command(spec: str) -> list[str]:
     ]
 
 
-def run_tlc(spec: str, callback: Callable[[ModelCheckResult], None] | None = None) -> int:
+def run_tlc(spec: str, callback: Callable[[ModelCheckResult], None] | None = None, coverage: bool = False) -> int:  # noqa: PLR0912
     """Run TLC model checker on a TLA+ specification. Returns exit code."""
     config = load_config()
     validate_java_version(config.java.min_version)
@@ -76,12 +77,15 @@ def run_tlc(spec: str, callback: Callable[[ModelCheckResult], None] | None = Non
 
     # Ensure tool mode is enabled for structured output
     if "-tool" not in cmd:
-        # Insert -tool after java class name or at some reasonable position
-        # TLC usually expects options before the spec file name.
-        # cmd is ["java", ..., "tlc2.TLC", "spec.tla"]
         cmd.insert(-1, "-tool")
 
+    if coverage and "-coverage" not in cmd:
+        # coverage expects a number of minutes between stats, default to 1
+        cmd.insert(-1, "-coverage")
+        cmd.insert(-1, "1")
+
     parser = TlcParser()
+    sany_parser = SanyParser()
 
     try:
         with subprocess.Popen(
@@ -92,15 +96,35 @@ def run_tlc(spec: str, callback: Callable[[ModelCheckResult], None] | None = Non
             text=True,
             bufsize=1,
         ) as process:
-            if process.stdout:
-                for line in process.stdout:
-                    if line.startswith("@!@!@"):
+            try:
+                if process.stdout:
+                    for line in process.stdout:
+                        if line.startswith("@!@!@"):
+                            parser.process_line(line)
+                        else:
+                            sany_parser.process_line(line)
+                            # We also pass non-SANY, non-TLC-tool-mode lines to the TLC parser
+                            # so they end up in output_lines
+                            parser.process_line(line)
+
+                        if callback:
+                            res = parser.get_result()
+                            res.sany_errors = sany_parser.get_errors()
+                            callback(res)
+            except KeyboardInterrupt:
+                # Stop the TLC process gracefully
+                process.terminate()
+                # Parse remaining output if any
+                if process.stdout:
+                    for line in process.stdout:
                         parser.process_line(line)
-                    else:
-                        print(line, end="", flush=True)
+                        if callback:
+                            callback(parser.get_result())
 
-                    if callback:
-                        callback(parser.get_result())
+                if callback:
+                    res = parser.get_result()
+                    res.state = CheckState.Stopped
+                    callback(res)
 
             process.wait()
             return process.returncode

{tlaplus_cli-0.5.0 → tlaplus_cli-0.6.0/src/tlaplus_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tlaplus-cli
-Version: 0.5.0
+Version: 0.6.0
 Summary: TLA+ tools: download TLC, compile custom modules, run model checker
 Author-email: Denis Nikolskiy <codeomatics@gmail.com>
 License-Expression: MIT
@@ -25,6 +25,7 @@ Requires-Dist: pyyaml<7.0,>=6.0
 Requires-Dist: platformdirs<5.0,>=4.0
 Requires-Dist: pydantic<3.0.0,>=2.12.5
 Requires-Dist: truststore<1.0.0,>=0.9.0
+Requires-Dist: rich<14.0.0,>=13.7.0
 Dynamic: license-file
 
 # TLA+ CLI

{tlaplus_cli-0.5.0 → tlaplus_cli-0.6.0}/src/tlaplus_cli.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ src/tlaplus_cli/resources/default_config.yaml
 src/tlaplus_cli/tlc/__init__.py
 src/tlaplus_cli/tlc/codes.py
 src/tlaplus_cli/tlc/compiler.py
+src/tlaplus_cli/tlc/formatter.py
 src/tlaplus_cli/tlc/models.py
 src/tlaplus_cli/tlc/parser.py
 src/tlaplus_cli/tlc/runner.py

{tlaplus_cli-0.5.0 → tlaplus_cli-0.6.0}/src/tlaplus_cli.egg-info/requires.txt

@@ -4,3 +4,4 @@ pyyaml<7.0,>=6.0
 platformdirs<5.0,>=4.0
 pydantic<3.0.0,>=2.12.5
 truststore<1.0.0,>=0.9.0
+rich<14.0.0,>=13.7.0