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

{tlaplus_cli-0.4.2/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.4.2
+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
@@ -156,6 +157,12 @@ To check the currently pinned `tla2tools.jar` path and its TLC version:
 tla tlc --version
 ```
 
+To inspect the exact Java command that will be executed without running it:
+
+```bash
+tla tlc <spec_name> --show-command
+```
+
 ### Compile Custom Java Modules
 
 Java modules (overrides) are compiled using the pinned version of the toolset.
@@ -177,8 +184,9 @@ tla modules path /path/to/custom/modules
 
 View or reset the custom modules path:
 ```bash
-tla modules path         # View current path
-tla modules path none    # Reset to default
+tla modules path          # View current path
+tla modules path none     # Reset to default
+tla modules path --resolved  # Show fully resolved paths for current context
 ```
 
 Configure a persistent custom modules dependencies (lib) path:
@@ -200,6 +208,11 @@ Verbose output:
 tla modules build --verbose
 ```
 
+Show compilation command:
+```bash
+tla modules build --show-command
+```
+
 The build command:
 1. Resolves the project root (defaults to `workspace.root` from config).
 2. Includes `lib/*.jar` files from the project root in the `javac` classpath.

{tlaplus_cli-0.4.2 → tlaplus_cli-0.6.0}/README.md

@@ -127,6 +127,12 @@ To check the currently pinned `tla2tools.jar` path and its TLC version:
 tla tlc --version
 ```
 
+To inspect the exact Java command that will be executed without running it:
+
+```bash
+tla tlc <spec_name> --show-command
+```
+
 ### Compile Custom Java Modules
 
 Java modules (overrides) are compiled using the pinned version of the toolset.
@@ -148,8 +154,9 @@ tla modules path /path/to/custom/modules
 
 View or reset the custom modules path:
 ```bash
-tla modules path         # View current path
-tla modules path none    # Reset to default
+tla modules path          # View current path
+tla modules path none     # Reset to default
+tla modules path --resolved  # Show fully resolved paths for current context
 ```
 
 Configure a persistent custom modules dependencies (lib) path:
@@ -171,6 +178,11 @@ Verbose output:
 tla modules build --verbose
 ```
 
+Show compilation command:
+```bash
+tla modules build --show-command
+```
+
 The build command:
 1. Resolves the project root (defaults to `workspace.root` from config).
 2. Includes `lib/*.jar` files from the project root in the `javac` classpath.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tlaplus-cli"
-version = "0.4.2"
+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.4.2 → tlaplus_cli-0.6.0}/src/tlaplus_cli/cli.py

@@ -30,7 +30,7 @@ def version_callback(value: bool) -> None:
 
 @app.callback()
 def root(
-    version: bool = typer.Option(  # noqa: ARG001
+    _: bool = typer.Option(
         None,
         "--version",
         "-v",

{tlaplus_cli-0.4.2 → tlaplus_cli-0.6.0}/src/tlaplus_cli/cmd/modules/__init__.py

@@ -2,4 +2,4 @@ import typer
 
 app = typer.Typer(name="modules", help="Manage TLA+ Java modules.", no_args_is_help=True)
 
-from . import build, lib, path  # noqa: F401, E402
+from . import build, install, lib, path  # noqa: F401, E402

{tlaplus_cli-0.4.2 → tlaplus_cli-0.6.0}/src/tlaplus_cli/cmd/modules/build.py

@@ -4,17 +4,28 @@ from pathlib import Path
 import typer
 
 from tlaplus_cli.cmd.modules import app
-from tlaplus_cli.tlc.compiler import compile_modules
+from tlaplus_cli.tlc.compiler import build_compile_command, compile_modules
 
 
 @app.command(name="build")
 def build(
     path: str | None = typer.Argument(None, help="Project root directory (defaults to workspace root)."),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Show compilation output."),
+    show_command: bool = typer.Option(False, "--show-command", help="Print the command instead of executing it."),
 ) -> None:
     """Compile custom Java modules."""
     base_dir = Path(path).resolve() if path is not None else None
 
+    if show_command:
+        try:
+            cmd = build_compile_command(base_dir)
+        except FileNotFoundError as e:
+            typer.echo(f"Error: {e}", err=True)
+            raise typer.Exit(1) from None
+        if cmd:
+            typer.echo(" ".join(cmd))
+        return
+
     typer.echo("Compiling Java files ...")
     try:
         classes_dir = compile_modules(base_dir, verbose)

tlaplus_cli-0.6.0/src/tlaplus_cli/cmd/modules/install.py

@@ -0,0 +1,75 @@
+import requests
+import typer
+
+from tlaplus_cli import ui
+from tlaplus_cli.cmd.modules import app
+from tlaplus_cli.config.loader import load_config
+from tlaplus_cli.versioning import (
+    download_version,
+    download_version_from_url,
+    fetch_remote_versions,
+    is_url,
+)
+from tlaplus_cli.versioning.paths import get_modules_dir
+
+
+@app.command(name="install-community")
+def install_community(
+    version: str = typer.Argument(
+        None, help="Version tag (e.g. 'v202412171801') or a direct URL to CommunityModules.jar."
+    ),
+    force: bool = typer.Option(False, "--force", "-f", help="Re-download if already installed."),
+) -> None:
+    """Download and install a specific version of CommunityModules."""
+    base_dir = get_modules_dir()
+    jar_name = "CommunityModules.jar"
+
+    if version and is_url(version):
+        try:
+            version_dir = download_version_from_url(version, base_dir=base_dir, jar_name=jar_name)
+        except (requests.RequestException, OSError, ValueError) as e:
+            ui.error(f"Failed to download: {e}")
+            raise typer.Exit(1) from e
+        else:
+            ui.success(f"Successfully installed from URL to {version_dir}")
+            return
+
+    config = load_config()
+    if not config.tla.community_modules:
+        ui.error("Community modules URLs not configured in settings.")
+        raise typer.Exit(1)
+
+    versions, status = fetch_remote_versions(
+        config.tla.community_modules.tags,
+        config.tla.community_modules.releases,
+        config.tla.community_modules.per_page,
+        asset_name=jar_name,
+    )
+
+    if not versions:
+        ui.error(f"Could not fetch remote versions (status: {status.value})")
+        raise typer.Exit(1)
+
+    target = None
+    if version:
+        target = next((v for v in versions if v.name == version), None)
+        if not target:
+            ui.error(f"Version {version} not found.")
+            raise typer.Exit(1)
+    else:
+        # Default to latest non-prerelease
+        target = next((v for v in versions if not v.prerelease), versions[0])
+        ui.info(f"No version specified, selecting latest stable release: {target.name}")
+
+    # Check if already installed
+    target_dir = base_dir / f"{target.name}-{target.short_sha}"
+    if target_dir.exists() and not force:
+        ui.info(f"Version {target.name} is already installed at {target_dir}")
+        return
+
+    try:
+        version_dir = download_version(target, force=force, base_dir=base_dir, jar_name=jar_name)
+        ui.success(f"Successfully installed {target.name} to {version_dir}")
+    except (requests.RequestException, OSError) as e:
+        ui.error(f"Failed to download: {e}")
+        raise typer.Exit(1) from e

tlaplus_cli-0.6.0/src/tlaplus_cli/cmd/modules/path.py

@@ -0,0 +1,72 @@
+from pathlib import Path
+
+import typer
+
+from tlaplus_cli.cmd.modules import app
+from tlaplus_cli.config.loader import load_config, save_config, workspace_root
+from tlaplus_cli.java.classpath import ClasspathResolver, ResolveMode, SubdirType
+from tlaplus_cli.tlc.compiler import get_tlc_jar_path
+
+
+@app.command(name="path")
+def set_modules_path(
+    path: str | None = typer.Argument(None, help="Path to the custom Java modules directory, or 'none' to reset."),
+    resolved: bool = typer.Option(False, "--resolved", help="Show the actual resolved paths for the current context."),
+) -> None:
+    """Configure or view custom Java modules source path."""
+    config_obj = load_config()
+
+    if resolved:
+        resolver = ClasspathResolver(config_obj, project_root=workspace_root(), tool_jar=get_tlc_jar_path())
+
+        # Source path (modules)
+        tla_library = resolver.get_tla_library_property()
+        typer.echo(f"Source Path: {tla_library or 'None'}")
+
+        # Classes path
+        classes_dir = resolver.get_project_path(SubdirType.CLASSES)
+        typer.echo(f"Classes Path: {classes_dir or 'None'}")
+
+        # Library path (JARs)
+        libs = resolver.resolve(ResolveMode.RUNTIME)
+        # Filter out classes_dir and tool_jar to show only libs
+        tool_jar = get_tlc_jar_path()
+        only_libs = [p for p in libs if p != str(classes_dir) and p != str(tool_jar)]
+
+        lib_str = "None"
+        if only_libs:
+            lib_str = f"{len(only_libs)} JARs"
+
+        typer.echo(f"Library Path: {lib_str}")
+        if only_libs:
+            for lib in only_libs:
+                typer.echo(f"  - {lib}")
+
+        # Tool Jar
+        typer.echo(f"Tool Jar: {tool_jar}")
+        return
+
+    if path is None:
+        if config_obj.module_path:
+            typer.echo(f"Current modules path: {config_obj.module_path}")
+        else:
+            default_path = workspace_root() / config_obj.workspace.modules_dir
+            typer.echo("Custom modules path is not set.")
+            typer.echo(f"Defaulting to: {default_path}")
+        return
+
+    if path.lower() == "none":
+        config_obj.module_path = None
+        save_config(config_obj)
+        typer.echo("Custom modules path reset to default.")
+        return
+
+    p = Path(path).resolve()
+
+    if not p.is_dir():
+        typer.echo(f"Error: Path does not exist or is not a directory: {p}", err=True)
+        raise typer.Exit(1)
+
+    config_obj.module_path = str(p)
+    save_config(config_obj)
+    typer.echo(f"Modules path updated to: {p}")

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

@@ -0,0 +1,159 @@
+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.formatter import TlcFormatter
+from tlaplus_cli.tlc.models import CheckState, ModelCheckResult
+from tlaplus_cli.tlc.runner import (
+    build_tlc_command,
+    get_tlc_version,
+    resolve_spec_file,
+    run_tlc,
+)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        jar_path = get_tlc_jar_path()
+        typer.echo(f"tla2tools.jar path: {jar_path}")
+
+        if not jar_path.exists():
+            ui.error(f"tla2tools.jar not found at {jar_path}")
+            typer.echo("Run 'tla tools install' first.", err=True)
+            raise typer.Exit(1)
+
+        version_str = get_tlc_version()
+        if version_str:
+            typer.echo(version_str)
+
+        raise typer.Exit(0)
+
+
+def _show_diagnostic_info(spec: str, spec_name: str) -> None:
+    """Show diagnostic info before running TLC."""
+    version_str = get_tlc_version() or "unknown"
+    typer.echo(f"Running TLC ({version_str}) on {spec_name} ...")
+
+    # Check if we have TLA-Library
+    try:
+        config = load_config()
+        spec_file, _ = resolve_spec_file(spec)
+        project_root = find_project_root(
+            spec_file,
+            modules_dir=config.workspace.modules_dir,
+            classes_dir=config.workspace.classes_dir,
+        )
+        jar_path = get_tlc_jar_path()
+        resolver = ClasspathResolver(config, project_root=project_root, tool_jar=jar_path)
+        tla_library = resolver.get_tla_library_property()
+        if tla_library:
+            ui.info(f"TLA-Library: {tla_library}")
+    except Exception:
+        pass  # nosec
+
+
+# PLR0912: This command handler orchestrates multiple output types (errors, warnings, results, progress);
+# splitting it would fragment the CLI's primary user-facing logic.
+# 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.
+    version: bool | None = typer.Option(  # noqa: ARG001
+        None,
+        "--version",
+        help="Print the path to tla2tools.jar and its version.",
+        callback=version_callback,
+        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)
+    except FileNotFoundError as e:
+        ui.error(str(e))
+        raise typer.Exit(1) from None
+
+    if show_command:
+        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)
+
+    tlc_version = get_tlc_version() or "unknown"
+    formatter = TlcFormatter(tlc_version=tlc_version)
+    layout = formatter.create_layout()
+
+    try:
+        final_result: list[ModelCheckResult] = []
+
+        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, 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:
+                    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).")
+                for warn_info in res.warnings:
+                    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:
+        ui.error(str(e))
+        raise typer.Exit(1) from None
+
+    raise typer.Exit(exit_code)

{tlaplus_cli-0.4.2 → tlaplus_cli-0.6.0}/src/tlaplus_cli/cmd/tools/meta/sync.py

@@ -2,6 +2,7 @@ import typer
 
 from tlaplus_cli.cmd.tools.meta import app
 from tlaplus_cli.config.loader import load_config
+from tlaplus_cli.ui import warn
 from tlaplus_cli.versioning import (
     fetch_remote_versions,
     list_local_versions,
@@ -28,6 +29,6 @@ def meta_sync() -> None:
             write_version_metadata(lv.path, target)
             typer.echo(f"Synced metadata for {lv.path.name}")
         else:
-            typer.echo(f"⚠ Warning: Could not find remote data for {lv.name}", err=True)
+            warn(f"Could not find remote data for {lv.name}")
 
     typer.echo("Metadata sync complete.")

{tlaplus_cli-0.4.2 → tlaplus_cli-0.6.0}/src/tlaplus_cli/cmd/tools/uninstall.py

@@ -5,6 +5,7 @@ import typer
 
 from tlaplus_cli.cmd.tools import app
 from tlaplus_cli.config.loader import cache_dir
+from tlaplus_cli.ui import warn
 from tlaplus_cli.versioning import (
     clear_pin,
     get_pinned_version_dir,
@@ -24,12 +25,12 @@ def _resolve_uninstall_targets(versions: list[str]) -> list[Path]:
             if legacy.exists():
                 targets.append(legacy)
             else:
-                typer.echo("⚠ Warning: Default (legacy) tla2tools.jar not found.", err=True)
+                warn("Default (legacy) tla2tools.jar not found.")
             continue
 
         matching = sorted([lv for lv in local_versions if lv.name == v], key=lambda x: x.path.name)
         if not matching:
-            typer.echo(f"⚠ Warning: Version {v} not found locally.", err=True)
+            warn(f"Version {v} not found locally.")
             continue
 
         if len(matching) > 1:

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

@@ -13,6 +13,7 @@ class TlaUrls(BaseModel):
 
 class TlaConfig(BaseModel):
     urls: TlaUrls
+    community_modules: TlaUrls | None = None
 
 
 class WorkspaceConfig(BaseModel):
@@ -25,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):