tlaplus-cli 0.3.1__tar.gz → 0.3.3__tar.gz

{tlaplus_cli-0.3.1/src/tlaplus_cli.egg-info → tlaplus_cli-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tlaplus-cli
-Version: 0.3.1
+Version: 0.3.3
 Summary: TLA+ tools: download TLC, compile custom modules, run model checker
 Author-email: Denis Nikolskiy <codeomatics@gmail.com>
 License-Expression: MIT
@@ -86,7 +86,7 @@ tla tools upgrade
 > [!NOTE]
 > If the target version to upgrade is not yet installed locally, the CLI will automatically download it.
 
-Show the TLC2 version string and absolute path to the pinned version's `tla2tools.jar`:
+Show the absolute path to the pinned version's `tla2tools.jar`:
 ```bash
 tla tools path
 ```
@@ -98,7 +98,6 @@ tla tools path v1.8.0
 
 Example output:
 ```text
-TLC2 Version 2.19 of 08 August 2024 (rev: 5a47802)
 /home/bob/.cache/tla/tools/v1.8.0-5a47802/tla2tools.jar
 ```
 
@@ -139,23 +138,48 @@ For example (runs `queue.tla`):
 tla tlc queue
 ```
 
-> **Note:** Starting from version `0.3.0`, the command structure has changed. To run a model, use `tla tlc <spec>`. For version `0.2.x`, the command was `tla run <spec>`. Since `0.3.0`, management commands are under `tla tools`.
+#### Project-Aware Execution
+
+The CLI intelligently resolves the specification file and its project structure. It will check the following locations:
+1.  `<spec_name>` (if it's a direct path to a file, e.g., `models/my_model.tla`)
+2.  `<spec_name>.tla`
+3.  `spec/<spec_name>.tla` (checks an inner `spec/` folder relative to the spec's location)
+
+Furthermore, it automatically discovers the **project root** by looking for `modules/`, `classes/`, or `lib/` directories adjacent to the spec file or its parent. When a project root is found:
+- The project's `classes/` directory is added to the Java classpath.
+- Any `*.jar` files found in the project's `lib/` directory are added to the Java classpath.
+- The `-DTLA-Library` system property is set to the project's `modules/` directory, allowing TLC to find your custom Java overrides.
+
+To check the currently pinned `tla2tools.jar` path and its TLC version:
+
+```bash
+tla tlc --version
+```
 
 ### Compile Custom Java Modules
 
-Note that modules are compiled using the pinned version of the toolset.
+Java modules (overrides) are compiled using the pinned version of the toolset.
+
+Compile modules in the current project:
+```bash
+tla modules build
+```
 
-Compile modules:
+Compile modules in a specific project path:
 ```bash
-tla build
+tla modules build path/to/project
 ```
 
 Verbose output:
 ```bash
-tla build --verbose
+tla modules build --verbose
 ```
 
-Compiles `.java` files from `workspace/modules/` into `workspace/classes/`.
+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.
+3. Compiles `.java` files from the project's `modules/` directory into its `classes/` directory.
+4. Generates the necessary Java service provider configuration for TLC overrides.
 
 ### Check Java Version
 

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/README.md

@@ -57,7 +57,7 @@ tla tools upgrade
 > [!NOTE]
 > If the target version to upgrade is not yet installed locally, the CLI will automatically download it.
 
-Show the TLC2 version string and absolute path to the pinned version's `tla2tools.jar`:
+Show the absolute path to the pinned version's `tla2tools.jar`:
 ```bash
 tla tools path
 ```
@@ -69,7 +69,6 @@ tla tools path v1.8.0
 
 Example output:
 ```text
-TLC2 Version 2.19 of 08 August 2024 (rev: 5a47802)
 /home/bob/.cache/tla/tools/v1.8.0-5a47802/tla2tools.jar
 ```
 
@@ -110,23 +109,48 @@ For example (runs `queue.tla`):
 tla tlc queue
 ```
 
-> **Note:** Starting from version `0.3.0`, the command structure has changed. To run a model, use `tla tlc <spec>`. For version `0.2.x`, the command was `tla run <spec>`. Since `0.3.0`, management commands are under `tla tools`.
+#### Project-Aware Execution
+
+The CLI intelligently resolves the specification file and its project structure. It will check the following locations:
+1.  `<spec_name>` (if it's a direct path to a file, e.g., `models/my_model.tla`)
+2.  `<spec_name>.tla`
+3.  `spec/<spec_name>.tla` (checks an inner `spec/` folder relative to the spec's location)
+
+Furthermore, it automatically discovers the **project root** by looking for `modules/`, `classes/`, or `lib/` directories adjacent to the spec file or its parent. When a project root is found:
+- The project's `classes/` directory is added to the Java classpath.
+- Any `*.jar` files found in the project's `lib/` directory are added to the Java classpath.
+- The `-DTLA-Library` system property is set to the project's `modules/` directory, allowing TLC to find your custom Java overrides.
+
+To check the currently pinned `tla2tools.jar` path and its TLC version:
+
+```bash
+tla tlc --version
+```
 
 ### Compile Custom Java Modules
 
-Note that modules are compiled using the pinned version of the toolset.
+Java modules (overrides) are compiled using the pinned version of the toolset.
+
+Compile modules in the current project:
+```bash
+tla modules build
+```
 
-Compile modules:
+Compile modules in a specific project path:
 ```bash
-tla build
+tla modules build path/to/project
 ```
 
 Verbose output:
 ```bash
-tla build --verbose
+tla modules build --verbose
 ```
 
-Compiles `.java` files from `workspace/modules/` into `workspace/classes/`.
+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.
+3. Compiles `.java` files from the project's `modules/` directory into its `classes/` directory.
+4. Generates the necessary Java service provider configuration for TLC overrides.
 
 ### Check Java Version
 

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tlaplus-cli"
-version = "0.3.1"
+version = "0.3.3"
 description = "TLA+ tools: download TLC, compile custom modules, run model checker"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -45,7 +45,8 @@ where = ["src"]
 include = ["tlaplus_cli*"]
 
 [tool.setuptools.package-data]
-tlaplus_cli = ["resources/default_config.yaml", "py.typed"]
+tlaplus_cli = ["py.typed"]
+"tlaplus_cli.resources" = ["*.yaml"]
 
 [dependency-groups]
 dev = [
@@ -101,6 +102,7 @@ ignore = [
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = [
     "ARG001", # Unused arguments are common in tests (fixtures)
+    "PLR0913", # Many arguments are common in tests (fixtures)
 ]
 
 [tool.poe.tasks]

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/src/tlaplus_cli/build_tlc_module.py

@@ -1,6 +1,8 @@
 """Compile custom TLC modules (Java)."""
 
+import os
 import subprocess
+from pathlib import Path
 
 import typer
 
@@ -9,10 +11,12 @@ from tlaplus_cli.version_manager import get_pinned_version_dir
 
 
 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."),
 ) -> None:
     """Compile custom Java modules."""
     config = load_config()
+    base_dir = Path(path).resolve() if path is not None else workspace_root()
 
     # Fallback chain: pinned directory -> legacy jar
     pinned_dir = get_pinned_version_dir()
@@ -20,31 +24,29 @@ def build(
     legacy = cache_dir() / "tla2tools.jar"
     jar_path = pinned_jar if (pinned_jar and pinned_jar.exists()) else legacy
 
-    ws_root = workspace_root()
-    modules_dir = ws_root / config.workspace.modules_dir
-    classes_dir = ws_root / config.workspace.classes_dir
-
     if not jar_path.exists():
-        typer.echo("Error: tla2tools.jar not found.", err=True)
-        typer.echo("Run 'tla tlc install' first.", err=True)
+        typer.echo("Error: tla2tools.jar not found.\nRun 'tla tools install' first.", err=True)
         raise typer.Exit(1)
 
+    modules_dir = base_dir / config.workspace.modules_dir
+    classes_dir = base_dir / config.workspace.classes_dir
+
+    lib_dir = base_dir / "lib"
+    lib_jars = sorted(lib_dir.glob("*.jar")) if lib_dir.is_dir() else []
+    classpath = os.pathsep.join([str(jar_path)] + [str(j) for j in lib_jars])
+
     if not modules_dir.exists():
         typer.echo(f"Error: modules directory not found: {modules_dir}", err=True)
         raise typer.Exit(1)
 
-    # Find all .java files in modules dir
     java_files = list(modules_dir.rglob("*.java"))
     if not java_files:
         typer.echo(f"No Java source files found in {modules_dir}", err=True)
         return
 
     typer.echo(f"Compiling {len(java_files)} Java files from {modules_dir} ...")
-
-    # Ensure output dir exists
     classes_dir.mkdir(parents=True, exist_ok=True)
-
-    cmd = ["javac", "-cp", str(jar_path), "-d", str(classes_dir), *[str(f) for f in java_files]]
+    cmd = ["javac", "-cp", classpath, "-d", str(classes_dir), *[str(f) for f in java_files]]
 
     try:
         result = subprocess.run(cmd, check=True, capture_output=not verbose, text=True)
@@ -52,14 +54,11 @@ def build(
         if verbose and result.stdout:
             typer.echo(result.stdout)
 
-        # Create META-INF/services/tlc2.overrides.ITLCOverrides
         meta_inf = classes_dir / "META-INF" / "services"
         meta_inf.mkdir(parents=True, exist_ok=True)
         service_file = meta_inf / "tlc2.overrides.ITLCOverrides"
-
         with service_file.open("w") as f:
             f.write(f"{config.tlc.overrides_class}\n")
-
         typer.echo(f"Created service file at {service_file}")
 
     except subprocess.CalledProcessError as e:

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/src/tlaplus_cli/cli.py

@@ -47,12 +47,15 @@ def root(
 
 # --- Subcommands ---
 
-# Attach typer subgroups for tools and fetch-cache
+# Attach typer subgroups
+modules_app = typer.Typer(name="modules", help="Manage TLA+ Java modules.", no_args_is_help=True)
+modules_app.command(name="build")(build_tlc_cmd)
+
+app.add_typer(modules_app, name="modules")
 app.add_typer(tools_app, name="tools")
 app.add_typer(fetch_cache_app, name="fetch-cache")
 
 app.command(name="tlc")(run_tlc_cmd)
-app.command(name="build")(build_tlc_cmd)
 
 
 @app.command(name="check-java")

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/src/tlaplus_cli/config.py

@@ -1,4 +1,4 @@
-import shutil
+import importlib.resources
 from functools import lru_cache
 from pathlib import Path
 
@@ -37,9 +37,12 @@ def cache_dir() -> Path:
     return Path(platformdirs.user_cache_dir(_APP_NAME))
 
 
-def _default_config_path() -> Path:
-    """Path to the default config shipped with the package."""
-    return Path(__file__).parent / "resources" / "default_config.yaml"
+def _default_config_content() -> str:
+    """Read the default config shipped with the package."""
+    # Safer than __file__, correctly handles zipped wheels and zipapps.
+    return (
+        importlib.resources.files("tlaplus_cli.resources").joinpath("default_config.yaml").read_text(encoding="utf-8")
+    )
 
 
 def _ensure_config() -> Path:
@@ -47,7 +50,8 @@ def _ensure_config() -> Path:
     cp = config_path()
     if not cp.exists():
         cp.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(_default_config_path(), cp)
+        # Write default config to the newly created path
+        cp.write_text(_default_config_content(), encoding="utf-8")
     return cp
 
 

tlaplus_cli-0.3.3/src/tlaplus_cli/project.py

@@ -0,0 +1,31 @@
+"""Project root discovery utilities."""
+
+from pathlib import Path
+
+
+def _is_project_root(directory: Path, modules_dir: Path | str, classes_dir: Path | str, lib_dir: Path | str) -> bool:
+    """Return True if directory contains at least one project structure marker."""
+    return (directory / classes_dir).is_dir() or (directory / modules_dir).is_dir() or (directory / lib_dir).is_dir()
+
+
+def find_project_root(
+    spec_file: Path,
+    *,
+    modules_dir: Path | str,
+    classes_dir: Path | str,
+    lib_dir: Path | str = "lib",
+) -> Path | None:
+    """Resolve the project root relative to a .tla spec file.
+
+    Resolution strategy (in order):
+    1. Check the spec file's own directory.
+    2. Check the parent of the spec file's directory (handles spec/ and tests/ subdirs).
+    3. Return None if neither directory qualifies.
+    """
+    spec_dir = spec_file.parent.resolve()
+
+    for candidate in (spec_dir, spec_dir.parent):
+        if _is_project_root(candidate, modules_dir, classes_dir, lib_dir):
+            return candidate
+
+    return None

tlaplus_cli-0.3.3/src/tlaplus_cli/resources/__init__.py

@@ -0,0 +1 @@
+"""Resources subpackage."""

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/src/tlaplus_cli/run_tlc.py

@@ -2,11 +2,13 @@
 
 import os
 import subprocess
+from pathlib import Path
 
 import typer
 
 from tlaplus_cli.check_java import check_java_version
-from tlaplus_cli.config import cache_dir, load_config, workspace_root
+from tlaplus_cli.config import cache_dir, load_config
+from tlaplus_cli.project import find_project_root
 from tlaplus_cli.version_manager import get_pinned_version_dir
 
 
@@ -62,25 +64,48 @@ def tlc(
     jar_path = pinned_jar if (pinned_jar and pinned_jar.exists()) else legacy
 
     if not jar_path.exists():
-        typer.echo("Error: tla2tools.jar not found.", err=True)
-        typer.echo("Run 'tla tools install' first.", err=True)
+        typer.echo("Error: tla2tools.jar not found.\nRun 'tla tools install' first.", err=True)
         raise typer.Exit(1)
 
-    ws_root = workspace_root()
-    spec_dir = ws_root / config.workspace.spec_dir
-    spec_file = spec_dir / f"{spec}.tla"
-    if not spec_file.exists():
-        typer.echo(f"Error: specification not found: {spec_file}", err=True)
-        raise typer.Exit(1)
-
-    classpath = str(jar_path)
-    classes_path = ws_root / config.workspace.classes_dir
-    if classes_path.exists():
-        classpath = f"{classes_path}{os.pathsep}{classpath}"
+    # Spec resolution logic
+    spec_path = Path(spec)
+    candidates = [spec_path, spec_path.with_suffix(".tla"), spec_path.parent / "spec" / (spec_path.name + ".tla")]
 
-    cmd = ["java", *config.java.opts, "-cp", classpath, config.tlc.java_class, str(spec_file)]
+    spec_file = next((c for c in candidates if c.is_file()), None)
+    if not spec_file:
+        typer.echo("Error: Could not find a TLA+ spec file. Looked in the following locations:", err=True)
+        for c in candidates:
+            typer.echo(f"- {c}", err=True)
+        raise typer.Exit(1)
 
-    typer.echo(f"Running TLC on {spec}.tla ...")
-    typer.echo(f"Command: {' '.join(cmd)}")
-    result = subprocess.run(cmd, cwd=str(spec_dir))
+    spec_file = spec_file.absolute()
+    project_root = find_project_root(
+        spec_file, modules_dir=config.workspace.modules_dir, classes_dir=config.workspace.classes_dir
+    )
+
+    classpath_parts = [str(jar_path)]
+    extra_jvm_opts: list[str] = []
+    if project_root:
+        classes_path = project_root / config.workspace.classes_dir
+        if classes_path.is_dir():
+            classpath_parts.insert(0, str(classes_path))
+        lib_dir = project_root / "lib"
+        if lib_dir.is_dir():
+            classpath_parts.extend(str(j) for j in sorted(lib_dir.glob("*.jar")))
+        modules_path = project_root / config.workspace.modules_dir
+        if modules_path.is_dir():
+            extra_jvm_opts.append(f"-DTLA-Library={modules_path}")
+
+    cmd = [
+        "java",
+        *config.java.opts,
+        *extra_jvm_opts,
+        "-cp",
+        os.pathsep.join(classpath_parts),
+        config.tlc.java_class,
+        spec_file.name,
+    ]
+
+    typer.echo(f"Running TLC on {spec_file.name} ...\nCommand: {' '.join(cmd)}")
+    result = subprocess.run(cmd, cwd=str(spec_file.parent))
     raise typer.Exit(result.returncode)

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/src/tlaplus_cli/tools_manager.py

@@ -205,7 +205,7 @@ def path(version: str = typer.Argument(None)) -> None:
         if pinned_dir:
             jar = pinned_dir / "tla2tools.jar"
             if jar.exists():
-                _print_version_path(pinned_dir, jar)
+                _print_version_path(jar)
                 return
         typer.echo("Error: No pinned version found.", err=True)
         raise typer.Exit(1)
@@ -213,18 +213,15 @@ def path(version: str = typer.Argument(None)) -> None:
     for lv in list_local_versions():
         if lv.name == version:
             jar = lv.path / "tla2tools.jar"
-            _print_version_path(lv.path, jar)
+            _print_version_path(jar)
             return
     typer.echo(f"Error: Version {version} not found locally.", err=True)
     raise typer.Exit(1)
 
 
-def _print_version_path(version_dir: Path, jar_path: Path) -> None:
-    """Print the TLC2 version string (if available) and jar path."""
-    meta = read_version_metadata(version_dir)
-    if meta and meta.get("tlc2_version_string"):
-        typer.echo(meta["tlc2_version_string"])
-    typer.echo(str(jar_path))
+def _print_version_path(jar_path: Path) -> None:
+    """Print the absolute path to tla2tools.jar."""
+    typer.echo(str(jar_path.absolute()))
 
 
 @tools_app.command()

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3/src/tlaplus_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tlaplus-cli
-Version: 0.3.1
+Version: 0.3.3
 Summary: TLA+ tools: download TLC, compile custom modules, run model checker
 Author-email: Denis Nikolskiy <codeomatics@gmail.com>
 License-Expression: MIT
@@ -86,7 +86,7 @@ tla tools upgrade
 > [!NOTE]
 > If the target version to upgrade is not yet installed locally, the CLI will automatically download it.
 
-Show the TLC2 version string and absolute path to the pinned version's `tla2tools.jar`:
+Show the absolute path to the pinned version's `tla2tools.jar`:
 ```bash
 tla tools path
 ```
@@ -98,7 +98,6 @@ tla tools path v1.8.0
 
 Example output:
 ```text
-TLC2 Version 2.19 of 08 August 2024 (rev: 5a47802)
 /home/bob/.cache/tla/tools/v1.8.0-5a47802/tla2tools.jar
 ```
 
@@ -139,23 +138,48 @@ For example (runs `queue.tla`):
 tla tlc queue
 ```
 
-> **Note:** Starting from version `0.3.0`, the command structure has changed. To run a model, use `tla tlc <spec>`. For version `0.2.x`, the command was `tla run <spec>`. Since `0.3.0`, management commands are under `tla tools`.
+#### Project-Aware Execution
+
+The CLI intelligently resolves the specification file and its project structure. It will check the following locations:
+1.  `<spec_name>` (if it's a direct path to a file, e.g., `models/my_model.tla`)
+2.  `<spec_name>.tla`
+3.  `spec/<spec_name>.tla` (checks an inner `spec/` folder relative to the spec's location)
+
+Furthermore, it automatically discovers the **project root** by looking for `modules/`, `classes/`, or `lib/` directories adjacent to the spec file or its parent. When a project root is found:
+- The project's `classes/` directory is added to the Java classpath.
+- Any `*.jar` files found in the project's `lib/` directory are added to the Java classpath.
+- The `-DTLA-Library` system property is set to the project's `modules/` directory, allowing TLC to find your custom Java overrides.
+
+To check the currently pinned `tla2tools.jar` path and its TLC version:
+
+```bash
+tla tlc --version
+```
 
 ### Compile Custom Java Modules
 
-Note that modules are compiled using the pinned version of the toolset.
+Java modules (overrides) are compiled using the pinned version of the toolset.
+
+Compile modules in the current project:
+```bash
+tla modules build
+```
 
-Compile modules:
+Compile modules in a specific project path:
 ```bash
-tla build
+tla modules build path/to/project
 ```
 
 Verbose output:
 ```bash
-tla build --verbose
+tla modules build --verbose
 ```
 
-Compiles `.java` files from `workspace/modules/` into `workspace/classes/`.
+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.
+3. Compiles `.java` files from the project's `modules/` directory into its `classes/` directory.
+4. Generates the necessary Java service provider configuration for TLC overrides.
 
 ### Check Java Version
 

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/src/tlaplus_cli.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/tlaplus_cli/build_tlc_module.py
 src/tlaplus_cli/check_java.py
 src/tlaplus_cli/cli.py
 src/tlaplus_cli/config.py
+src/tlaplus_cli/project.py
 src/tlaplus_cli/py.typed
 src/tlaplus_cli/run_tlc.py
 src/tlaplus_cli/settings.py
@@ -18,11 +19,14 @@ src/tlaplus_cli.egg-info/dependency_links.txt
 src/tlaplus_cli.egg-info/entry_points.txt
 src/tlaplus_cli.egg-info/requires.txt
 src/tlaplus_cli.egg-info/top_level.txt
+src/tlaplus_cli/resources/__init__.py
 src/tlaplus_cli/resources/default_config.yaml
 tests/test_build_tlc_module.py
 tests/test_check_java.py
 tests/test_cli.py
 tests/test_java_module_naming.py
+tests/test_project.py
 tests/test_run_tlc.py
+tests/test_spec_resolution.py
 tests/test_tools_manager.py
 tests/test_version_manager.py

tlaplus_cli-0.3.3/tests/test_build_tlc_module.py

@@ -0,0 +1,161 @@
+import shutil
+
+import pytest
+from typer.testing import CliRunner
+
+from tlaplus_cli.cli import app
+
+runner = CliRunner()
+
+# Define paths relative to the test file
+# Check if javac is available
+JAVAC_AVAILABLE = shutil.which("javac") is not None
+
+
+@pytest.mark.skipif(not JAVAC_AVAILABLE, reason="javac not found")
+def test_build_integration(mocker, tmp_path, queue_dir, base_settings):
+    """
+    Integration test for build_tlc_module.build().
+    Uses the actual files in tla-example and the real tla2tools.jar (if available).
+    Verified output classes are generated in a temporary directory.
+    """
+    # Create a temporary classes directory
+    classes_dir = tmp_path / "classes"
+
+    # Configure base_settings for this test
+    base_settings.workspace.root = queue_dir
+    base_settings.workspace.classes_dir = classes_dir
+
+    # Patch load_config to return our mock config
+    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=base_settings)
+
+    # Patch workspace_root to return the example directory
+    mocker.patch("tlaplus_cli.build_tlc_module.workspace_root", return_value=queue_dir)
+
+    # Run build
+    result = runner.invoke(app, ["modules", "build", "--verbose"])
+    assert result.exit_code == 0, f"Build failed with {result.exit_code}: {result.stdout}"
+
+    # Verify outputs
+    assert classes_dir.exists(), "Classes directory not created"
+
+    # Verify TLCOverrides.class exists
+    # The source is modules/tlc2/overrides/TLCOverrides.java
+    # Package is tlc2.overrides, so output should be in tlc2/overrides/
+    output_class = classes_dir / "tlc2/overrides/TLCOverrides.class"
+    assert output_class.exists(), f"Class file not found at {output_class}"
+
+    # Verify META-INF service file
+    service_file = classes_dir / "META-INF/services/tlc2.overrides.ITLCOverrides"
+    assert service_file.exists(), "Service file not found"
+
+    content = service_file.read_text().strip()
+    assert content == "tlc2.overrides.TLCOverrides", f"Unexpected service file content: {content}"
+
+
+@pytest.mark.skipif(not JAVAC_AVAILABLE, reason="javac not found")
+def test_build_custom_overrides(mocker, tmp_path, queue_dir, base_settings):
+    """
+    Test build with custom overrides class configuration.
+    """
+    classes_dir = tmp_path / "classes"
+
+    # Configure custom override
+    custom_override = "com.example.MyOverrides"
+    base_settings.tlc.overrides_class = custom_override
+    base_settings.workspace.root = queue_dir
+    base_settings.workspace.classes_dir = classes_dir
+
+    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=base_settings)
+    mocker.patch("tlaplus_cli.build_tlc_module.workspace_root", return_value=queue_dir)
+
+    result = runner.invoke(app, ["modules", "build"])
+    assert result.exit_code == 0, f"Build failed: {result.stdout}"
+
+    service_file = classes_dir / "META-INF/services/tlc2.overrides.ITLCOverrides"
+    assert service_file.exists()
+    assert service_file.read_text().strip() == custom_override
+
+
+def test_build_with_explicit_path(mocker, tmp_path, base_settings):
+    """modules build with explicit path uses that path as project root."""
+    project_dir = tmp_path / "my_project"
+    modules_dir = project_dir / "modules"
+    modules_dir.mkdir(parents=True)
+    (modules_dir / "Foo.java").write_text("class Foo {}")
+
+    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=base_settings)
+    mocker.patch("tlaplus_cli.build_tlc_module.workspace_root", return_value=tmp_path)
+
+    mock_run = mocker.patch("tlaplus_cli.build_tlc_module.subprocess.run")
+    mock_run.return_value.returncode = 0
+
+    # Patch jar path to exist
+    pinned_dir = tmp_path / "tools" / "v1.8.0"
+    pinned_dir.mkdir(parents=True)
+    (pinned_dir / "tla2tools.jar").write_bytes(b"fake")
+    mocker.patch("tlaplus_cli.build_tlc_module.get_pinned_version_dir", return_value=pinned_dir)
+
+    result = runner.invoke(app, ["modules", "build", str(project_dir)])
+    assert result.exit_code == 0
+    args, _ = mock_run.call_args
+    cmd = args[0]
+    assert str(project_dir / "classes") in cmd  # -d target
+    assert str(modules_dir / "Foo.java") in cmd  # source file
+
+
+def test_build_without_path_uses_workspace_root(mocker, tmp_path, base_settings):
+    """modules build without path uses workspace_root from config."""
+    project_dir = tmp_path / "workspace"
+    project_dir.mkdir()
+    modules_dir = project_dir / "modules"
+    modules_dir.mkdir()
+    (modules_dir / "Bar.java").write_text("class Bar {}")
+
+    base_settings.workspace.root = project_dir
+    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=base_settings)
+    mocker.patch("tlaplus_cli.build_tlc_module.workspace_root", return_value=project_dir)
+
+    mock_run = mocker.patch("tlaplus_cli.build_tlc_module.subprocess.run")
+    mock_run.return_value.returncode = 0
+
+    # Patch jar path to exist
+    pinned_dir = tmp_path / "tools" / "v1.8.0"
+    pinned_dir.mkdir(parents=True)
+    (pinned_dir / "tla2tools.jar").write_bytes(b"fake")
+    mocker.patch("tlaplus_cli.build_tlc_module.get_pinned_version_dir", return_value=pinned_dir)
+
+    result = runner.invoke(app, ["modules", "build"])
+    assert result.exit_code == 0
+    args, _ = mock_run.call_args
+    cmd = args[0]
+    assert str(project_dir / "classes") in cmd
+    assert str(modules_dir / "Bar.java") in cmd
+
+
+def test_build_includes_lib_jars_in_classpath(mocker, tmp_path, base_settings):
+    """javac classpath includes *.jar files from project lib/ directory."""
+    project_dir = tmp_path / "my_project"
+    (project_dir / "modules").mkdir(parents=True)
+    (project_dir / "modules" / "Foo.java").write_text("class Foo {}")
+    lib_dir = project_dir / "lib"
+    lib_dir.mkdir()
+    extra_jar = lib_dir / "extra.jar"
+    extra_jar.write_bytes(b"fake")
+
+    pinned_dir = tmp_path / "tools" / "v1.8.0"
+    pinned_dir.mkdir(parents=True)
+    tla_jar = pinned_dir / "tla2tools.jar"
+    tla_jar.write_bytes(b"fake")
+
+    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=base_settings)
+    mocker.patch("tlaplus_cli.build_tlc_module.get_pinned_version_dir", return_value=pinned_dir)
+
+    mock_run = mocker.patch("tlaplus_cli.build_tlc_module.subprocess.run")
+    mock_run.return_value.returncode = 0
+
+    result = runner.invoke(app, ["modules", "build", str(project_dir)])
+    assert result.exit_code == 0
+    args, _ = mock_run.call_args
+    cmd_str = " ".join(args[0])
+    assert str(extra_jar) in cmd_str

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/tests/test_java_module_naming.py

@@ -37,21 +37,21 @@ def setup_naming_env(tmp_path, mocker, base_settings, fixture_dir):
     mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=base_settings)
     mocker.patch("tlaplus_cli.build_tlc_module.workspace_root", return_value=fixture_dir)
     mocker.patch("tlaplus_cli.run_tlc.load_config", return_value=base_settings)
-    mocker.patch("tlaplus_cli.run_tlc.workspace_root", return_value=fixture_dir)
 
 
 @pytest.mark.skipif(not JAVA_AVAILABLE, reason="java not found")
 @pytest.mark.skipif(not JAVAC_AVAILABLE, reason="javac not found")
-def test_tlc_overrides_naming_works(tmp_path, mocker, base_settings, capfd, naming_fixed_dir):
+def test_tlc_overrides_naming_works(tmp_path, mocker, base_settings, capfd, naming_fixed_dir, monkeypatch):
     """
     Tests that naming the class 'TLCOverrides' in 'tlc2.overrides' package works.
     This is the currently supported approach.
     """
     setup_naming_env(tmp_path, mocker, base_settings, naming_fixed_dir)
 
-    res_build = runner.invoke(app, ["build"])
+    res_build = runner.invoke(app, ["modules", "build"])
     assert res_build.exit_code == 0, f"Module compilation failed: {res_build.stdout}"
 
+    monkeypatch.chdir(naming_fixed_dir)
     res_tlc = runner.invoke(app, ["tlc", "test_spec"])
     assert res_tlc.exit_code == 0, f"TLC run failed: {res_tlc.stdout}"
 
@@ -61,7 +61,7 @@ def test_tlc_overrides_naming_works(tmp_path, mocker, base_settings, capfd, nami
 
 @pytest.mark.skipif(not JAVA_AVAILABLE, reason="java not found")
 @pytest.mark.skipif(not JAVAC_AVAILABLE, reason="javac not found")
-def test_module_name_class_naming_fails(tmp_path, mocker, base_settings, capfd, naming_dynamic_dir):
+def test_module_name_class_naming_fails(tmp_path, mocker, base_settings, capfd, naming_dynamic_dir, monkeypatch):
     """
     Tests that naming the class after the module ('TestModule') fails to load the override.
     According to current TLC behavior, this doesn't work. We want this test to pass
@@ -69,9 +69,10 @@ def test_module_name_class_naming_fails(tmp_path, mocker, base_settings, capfd,
     """
     setup_naming_env(tmp_path, mocker, base_settings, naming_dynamic_dir)
 
-    res_build = runner.invoke(app, ["build"])
+    res_build = runner.invoke(app, ["modules", "build"])
     assert res_build.exit_code == 0, f"Module compilation failed: {res_build.stdout}"
 
+    monkeypatch.chdir(naming_dynamic_dir)
     res_tlc = runner.invoke(app, ["tlc", "test_spec"])
     assert res_tlc.exit_code == 0, f"TLC run failed: {res_tlc.stdout}"
 

tlaplus_cli-0.3.3/tests/test_project.py

@@ -0,0 +1,50 @@
+from tlaplus_cli.project import find_project_root
+
+
+def test_project_root_at_spec_dir(tmp_path):
+    """Root found at spec's own directory when it contains classes/."""
+    spec = tmp_path / "queue.tla"
+    spec.write_text("MODULE queue\n===\n")
+    (tmp_path / "classes").mkdir()
+    root = find_project_root(spec, modules_dir="modules", classes_dir="classes", lib_dir="lib")
+    assert root == tmp_path
+
+
+def test_project_root_at_parent_of_spec_dir(tmp_path):
+    """Root found one level up when spec is inside a spec/ subdirectory."""
+    spec_subdir = tmp_path / "spec"
+    spec_subdir.mkdir()
+    spec = spec_subdir / "queue.tla"
+    spec.write_text("MODULE queue\n===\n")
+    (tmp_path / "classes").mkdir()
+    root = find_project_root(spec, modules_dir="modules", classes_dir="classes", lib_dir="lib")
+    assert root == tmp_path
+
+
+def test_project_root_none_when_no_structure(tmp_path):
+    """Returns None if neither spec dir nor its parent contain project directories."""
+    spec = tmp_path / "spec" / "queue.tla"
+    spec.parent.mkdir()
+    spec.write_text("MODULE queue\n===\n")
+    root = find_project_root(spec, modules_dir="modules", classes_dir="classes", lib_dir="lib")
+    assert root is None
+
+
+def test_project_root_detected_by_lib(tmp_path):
+    """Root found based on lib/ directory even without classes/."""
+    spec = tmp_path / "tests" / "queue_test.tla"
+    spec.parent.mkdir()
+    spec.write_text("MODULE queue_test\n===\n")
+    (tmp_path / "lib").mkdir()
+    root = find_project_root(spec, modules_dir="modules", classes_dir="classes", lib_dir="lib")
+    assert root == tmp_path
+
+
+def test_project_root_detected_by_modules(tmp_path):
+    """Root found based on modules/ directory alone."""
+    spec = tmp_path / "spec" / "queue.tla"
+    spec.parent.mkdir()
+    spec.write_text("MODULE queue\n===\n")
+    (tmp_path / "modules").mkdir()
+    root = find_project_root(spec, modules_dir="modules", classes_dir="classes", lib_dir="lib")
+    assert root == tmp_path

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/tests/test_run_tlc.py

@@ -27,7 +27,7 @@ def compiled_modules(tmp_path_factory):
 
 @pytest.mark.skipif(not JAVA_AVAILABLE, reason="java not found")
 @pytest.mark.skipif(not JAVAC_AVAILABLE, reason="javac not found")
-def test_tlc_integration(mocker, tmp_path, capfd, queue_dir, base_settings):
+def test_tlc_integration(mocker, tmp_path, capfd, queue_dir, base_settings, monkeypatch):
     """
     Integration test for run_tlc.tlc().
     1. Compiles the modules (prerequisite).
@@ -41,7 +41,6 @@ def test_tlc_integration(mocker, tmp_path, capfd, queue_dir, base_settings):
     base_settings.workspace.classes_dir = classes_dir
 
     mocker.patch("tlaplus_cli.run_tlc.load_config", return_value=base_settings)
-    mocker.patch("tlaplus_cli.run_tlc.workspace_root", return_value=queue_dir)
 
     # We also need to patch build_tlc_module's config loading to compile first
     mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=base_settings)
@@ -49,14 +48,14 @@ def test_tlc_integration(mocker, tmp_path, capfd, queue_dir, base_settings):
     mocker.patch("tlaplus_cli.build_tlc_module.workspace_root", return_value=queue_dir)
 
     # 1. Compile modules
-    res_build = runner.invoke(app, ["build"])
+    res_build = runner.invoke(app, ["modules", "build"])
     assert res_build.exit_code == 0, f"Module compilation failed: {res_build.stdout}"
-
     # 2. Run TLC
     # Verify that classes_dir is populated
     assert (classes_dir / "tlc2/overrides/TLCOverrides.class").exists()
 
     # Run TLC on "queue" spec
+    monkeypatch.chdir(queue_dir)
     res_tlc = runner.invoke(app, ["tlc", "queue"])
     assert res_tlc.exit_code == 0, f"TLC run failed: {res_tlc.stdout}"
 
@@ -73,17 +72,17 @@ def test_tlc_integration(mocker, tmp_path, capfd, queue_dir, base_settings):
 
 
 def test_tlc_version_flag(mocker, capfd, base_settings, tmp_path):
-    """Test that 'tla tlc --version' prints the jar path and version."""
+    """Test that 'tla tlc --version' prints the jar path and only the first line of TLC version."""
     mocker.patch("tlaplus_cli.run_tlc.load_config", return_value=base_settings)
 
     # Create a fake pinned version dir with a jar
-    pinned_dir = tmp_path / "tools" / "v1.8.0-abcdef1"
+    pinned_dir = (tmp_path / "tools" / "v1.8.0-abcdef1").absolute()
     pinned_dir.mkdir(parents=True)
     (pinned_dir / "tla2tools.jar").write_bytes(b"fake jar")
     mocker.patch("tlaplus_cli.run_tlc.get_pinned_version_dir", return_value=pinned_dir)
 
     mock_result = mocker.MagicMock()
-    mock_result.stdout = "TLC2 Version Mock\\nSome other output"
+    mock_result.stdout = "TLC2 Version Mock\nSome other output"
     mock_result.stderr = ""
     mocker.patch("tlaplus_cli.run_tlc.subprocess.run", return_value=mock_result)
 
@@ -92,5 +91,6 @@ def test_tlc_version_flag(mocker, capfd, base_settings, tmp_path):
 
     captured = capfd.readouterr()
     stdout = captured.out + result.stdout
-    assert "tla2tools.jar path:" in stdout
+    assert f"tla2tools.jar path: {pinned_dir / 'tla2tools.jar'}" in stdout
     assert "TLC2 Version Mock" in stdout
+    assert "Some other output" not in stdout

tlaplus_cli-0.3.3/tests/test_spec_resolution.py

@@ -0,0 +1,200 @@
+from pathlib import Path
+
+import pytest
+from typer.testing import CliRunner
+
+from tlaplus_cli.cli import app
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def mock_tlc_env(mocker, tmp_path, base_settings):
+    mocker.patch("tlaplus_cli.run_tlc.load_config", return_value=base_settings)
+    mocker.patch("tlaplus_cli.run_tlc.check_java_version")
+
+    pinned_dir = (tmp_path / "tools" / "v1.8.0").absolute()
+    pinned_dir.mkdir(parents=True)
+    (pinned_dir / "tla2tools.jar").write_bytes(b"fake")
+    mocker.patch("tlaplus_cli.run_tlc.get_pinned_version_dir", return_value=pinned_dir)
+
+    mock_run = mocker.patch("tlaplus_cli.run_tlc.subprocess.run")
+    mock_run.return_value.returncode = 0
+    return mock_run
+
+
+def test_scenario_1_explicit_extension(mock_tlc_env, tmp_path):
+    """Scenario 1: Model with explicit .tla extension in CWD."""
+    spec_name = "my_model.tla"
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path(spec_name).write_text("MODULE my_model\n===\n")
+        result = runner.invoke(app, ["tlc", spec_name])
+
+    assert result.exit_code == 0
+    args, _ = mock_tlc_env.call_args
+    assert "my_model.tla" in args[0]
+
+
+def test_scenario_2_missing_extension_cwd(mock_tlc_env, tmp_path):
+    """Scenario 2: Model with missing .tla extension in CWD."""
+    spec_name = "my_model"
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path(f"{spec_name}.tla").write_text("MODULE my_model\n===\n")
+        result = runner.invoke(app, ["tlc", spec_name])
+
+    assert result.exit_code == 0
+    args, _ = mock_tlc_env.call_args
+    assert "my_model.tla" in args[0]
+
+
+def test_scenario_3_inside_spec_directory_cwd(mock_tlc_env, tmp_path):
+    """Scenario 3: Model inside a spec/ subdirectory in CWD."""
+    spec_name = "my_model"
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("spec").mkdir()
+        Path("spec/my_model.tla").write_text("MODULE my_model\n===\n")
+        result = runner.invoke(app, ["tlc", spec_name])
+
+    assert result.exit_code == 0
+    args, _ = mock_tlc_env.call_args
+    assert "my_model.tla" in args[0]
+
+
+def test_scenario_4_spec_not_found_cwd(mock_tlc_env, tmp_path):
+    """Scenario 4: Spec not found in CWD (validate multiline error)."""
+    spec_name = "missing_model"
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(app, ["tlc", spec_name])
+
+    assert result.exit_code == 1
+    assert "Error: Could not find a TLA+ spec file. Looked in the following locations:" in result.output
+    assert f"- {spec_name}" in result.output
+    assert f"- {spec_name}.tla" in result.output
+    assert f"- spec/{spec_name}.tla" in result.output
+
+
+def test_scenario_5_missing_extension_path(mock_tlc_env, tmp_path):
+    """Scenario 5: Spec missing .tla extension, but inside a specified path."""
+    spec_path = "subdir/my_model"
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("subdir").mkdir()
+        Path("subdir/my_model.tla").write_text("MODULE my_model\n===\n")
+        result = runner.invoke(app, ["tlc", spec_path])
+
+    assert result.exit_code == 0
+    args, _ = mock_tlc_env.call_args
+    assert "my_model.tla" in args[0]
+
+
+def test_scenario_6_inside_spec_directory_path(mock_tlc_env, tmp_path):
+    """Scenario 6: Spec inside a spec/ subdirectory within a specified path."""
+    spec_path = "subdir/my_model"
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("subdir/spec").mkdir(parents=True)
+        Path("subdir/spec/my_model.tla").write_text("MODULE my_model\n===\n")
+        result = runner.invoke(app, ["tlc", spec_path])
+
+    assert result.exit_code == 0
+    args, _ = mock_tlc_env.call_args
+    assert "my_model.tla" in args[0]
+
+
+def test_scenario_7_spec_not_found_path(mock_tlc_env, tmp_path):
+    """Scenario 7: Spec not found with a path (validate exactly where it looked)."""
+    spec_path = "subdir/missing_model"
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        Path("subdir").mkdir()
+        result = runner.invoke(app, ["tlc", spec_path])
+
+    assert result.exit_code == 1
+    assert "Error: Could not find a TLA+ spec file. Looked in the following locations:" in result.output
+    assert f"- {spec_path}" in result.output
+    assert f"- {spec_path}.tla" in result.output
+    assert "- subdir/spec/missing_model.tla" in result.output
+
+
+def test_tlc_classpath_includes_project_classes(mock_tlc_env, tmp_path, base_settings, mocker):
+    """When a classes/ directory exists next to the spec, it must appear in the JVM classpath."""
+    project_dir = tmp_path / "my_project"
+    spec_dir = project_dir
+    spec_dir.mkdir(parents=True)
+    (spec_dir / "queue.tla").write_text("MODULE queue\n===\n")
+    (project_dir / "classes").mkdir()
+
+    mocker.patch("tlaplus_cli.run_tlc.load_config", return_value=base_settings)
+
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(app, ["tlc", str(spec_dir / "queue.tla")])
+
+    assert result.exit_code == 0
+    args, _ = mock_tlc_env.call_args
+    cmd = args[0]
+    cp_index = cmd.index("-cp")
+    classpath = cmd[cp_index + 1]
+    assert str(project_dir / "classes") in classpath
+
+
+def test_tlc_classpath_includes_lib_jars(mock_tlc_env, tmp_path, base_settings, mocker):
+    """When a lib/ directory with JARs exists, they must appear in the JVM classpath."""
+    project_dir = tmp_path / "my_project"
+    spec_dir = project_dir / "spec"
+    spec_dir.mkdir(parents=True)
+    (spec_dir / "queue.tla").write_text("MODULE queue\n===\n")
+    lib_dir = project_dir / "lib"
+    lib_dir.mkdir()
+    extra_jar = lib_dir / "extra.jar"
+    extra_jar.write_bytes(b"fake")
+
+    mocker.patch("tlaplus_cli.run_tlc.load_config", return_value=base_settings)
+
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(app, ["tlc", str(spec_dir / "queue.tla")])
+
+    assert result.exit_code == 0
+    args, _ = mock_tlc_env.call_args
+    cmd = args[0]
+    cp_index = cmd.index("-cp")
+    classpath = cmd[cp_index + 1]
+    assert str(extra_jar) in classpath
+
+
+def test_tlc_tla_library_set_when_modules_dir_exists(mock_tlc_env, tmp_path, base_settings, mocker):
+    """-DTLA-Library is set when a modules/ directory is found."""
+    project_dir = tmp_path / "my_project"
+    spec_dir = project_dir / "tests"
+    spec_dir.mkdir(parents=True)
+    (spec_dir / "queue_test.tla").write_text("MODULE queue_test\n===\n")
+    modules_dir = project_dir / "modules"
+    modules_dir.mkdir()
+
+    mocker.patch("tlaplus_cli.run_tlc.load_config", return_value=base_settings)
+
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(app, ["tlc", str(spec_dir / "queue_test.tla")])
+
+    assert result.exit_code == 0
+    args, _ = mock_tlc_env.call_args
+    cmd = args[0]
+    assert f"-DTLA-Library={modules_dir}" in cmd
+
+
+def test_tlc_no_project_dirs_no_extra_classpath(mock_tlc_env, tmp_path, base_settings, mocker):
+    """A spec without adjacent project dirs has no extra classpath entries."""
+    spec_dir = tmp_path / "standalone"
+    spec_dir.mkdir()
+    (spec_dir / "simple.tla").write_text("MODULE simple\n===\n")
+
+    mocker.patch("tlaplus_cli.run_tlc.load_config", return_value=base_settings)
+
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        result = runner.invoke(app, ["tlc", str(spec_dir / "simple.tla")])
+
+    assert result.exit_code == 0
+    args, _ = mock_tlc_env.call_args
+    cmd = args[0]
+    cp_index = cmd.index("-cp")
+    classpath = cmd[cp_index + 1]
+    # Should only contain the tla2tools.jar
+    assert "tla2tools.jar" in classpath
+    assert "classes" not in classpath
+    assert "lib" not in classpath

{tlaplus_cli-0.3.1 → tlaplus_cli-0.3.3}/tests/test_tools_manager.py

@@ -1,5 +1,6 @@
 import json
 import shutil
+from pathlib import Path
 from unittest.mock import MagicMock
 
 import pytest
@@ -374,23 +375,24 @@ def test_tlc_upgrade_already_up_to_date(mock_github_api, mock_cache, mock_load_c
 
 
 def test_tlc_path_pinned_with_metadata(mock_load_config, mock_cache, installed_v180):
-    """path shows TLC2 version string from metadata then the jar path."""
+    """path strictly outputs the absolute path to tla2tools.jar, even if metadata exists."""
     pin_file = mock_cache / "tools" / "tools-pinned-version.txt"
     pin_file.write_text("v1.8.0-aaaaaaa")
     # Write metadata
-
     meta = {"tlc2_version_string": "TLC2 Version 2.19 of 08 August 2024 (rev: 5a47802)"}
     (installed_v180 / "meta-tla2tools.json").write_text(json.dumps(meta))
 
     result = runner.invoke(app, ["tools", "path"])
     assert result.exit_code == 0
     lines = result.stdout.strip().splitlines()
-    assert lines[0] == "TLC2 Version 2.19 of 08 August 2024 (rev: 5a47802)"
-    assert "tla2tools.jar" in lines[1]
+    assert len(lines) == 1
+    assert "tla2tools.jar" in lines[0]
+    assert Path(lines[0]).is_absolute()
+    assert "TLC2 Version" not in result.stdout
 
 
 def test_tlc_path_pinned_without_metadata(mock_load_config, mock_cache, installed_v180):
-    """path still works when no metadata exists — just shows the jar path."""
+    """path strictly outputs the absolute path to tla2tools.jar when no metadata exists."""
     pin_file = mock_cache / "tools" / "tools-pinned-version.txt"
     pin_file.write_text("v1.8.0-aaaaaaa")
 
@@ -399,28 +401,31 @@ def test_tlc_path_pinned_without_metadata(mock_load_config, mock_cache, installe
     lines = result.stdout.strip().splitlines()
     assert len(lines) == 1
     assert "tla2tools.jar" in lines[0]
+    assert Path(lines[0]).is_absolute()
 
 
 def test_tlc_path_version_with_metadata(mock_load_config, mock_cache, installed_v180):
-    """path <version> shows metadata + jar path for a specific installed version."""
-
+    """path <version> strictly outputs the absolute path for a specific installed version."""
     meta = {"tlc2_version_string": "TLC2 Version 2.19 of 08 August 2024 (rev: 5a47802)"}
     (installed_v180 / "meta-tla2tools.json").write_text(json.dumps(meta))
 
     result = runner.invoke(app, ["tools", "path", "v1.8.0"])
     assert result.exit_code == 0
     lines = result.stdout.strip().splitlines()
-    assert lines[0] == "TLC2 Version 2.19 of 08 August 2024 (rev: 5a47802)"
-    assert "tla2tools.jar" in lines[1]
+    assert len(lines) == 1
+    assert "tla2tools.jar" in lines[0]
+    assert Path(lines[0]).is_absolute()
+    assert "TLC2 Version" not in result.stdout
 
 
 def test_tlc_path_version_without_metadata(mock_load_config, mock_cache, installed_v180):
-    """path <version> works without metadata — just shows jar path."""
+    """path <version> strictly outputs the absolute path when no metadata exists."""
     result = runner.invoke(app, ["tools", "path", "v1.8.0"])
     assert result.exit_code == 0
     lines = result.stdout.strip().splitlines()
     assert len(lines) == 1
     assert "tla2tools.jar" in lines[0]
+    assert Path(lines[0]).is_absolute()
 
 
 def test_tlc_path_not_found(mock_load_config, mock_cache):

tlaplus_cli-0.3.1/tests/test_build_tlc_module.py

@@ -1,77 +0,0 @@
-import shutil
-
-import pytest
-from typer.testing import CliRunner
-
-from tlaplus_cli.cli import app
-
-runner = CliRunner()
-
-# Define paths relative to the test file
-# Check if javac is available
-JAVAC_AVAILABLE = shutil.which("javac") is not None
-
-
-@pytest.mark.skipif(not JAVAC_AVAILABLE, reason="javac not found")
-def test_build_integration(mocker, tmp_path, queue_dir, base_settings):
-    """
-    Integration test for build_tlc_module.build().
-    Uses the actual files in tla-example and the real tla2tools.jar (if available).
-    Verified output classes are generated in a temporary directory.
-    """
-    # Create a temporary classes directory
-    classes_dir = tmp_path / "classes"
-
-    # Configure base_settings for this test
-    base_settings.workspace.root = queue_dir
-    base_settings.workspace.classes_dir = classes_dir
-
-    # Patch load_config to return our mock config
-    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=base_settings)
-
-    # Patch workspace_root to return the example directory
-    mocker.patch("tlaplus_cli.build_tlc_module.workspace_root", return_value=queue_dir)
-
-    # Run build
-    result = runner.invoke(app, ["build", "--verbose"])
-    assert result.exit_code == 0, f"Build failed with {result.exit_code}: {result.stdout}"
-
-    # Verify outputs
-    assert classes_dir.exists(), "Classes directory not created"
-
-    # Verify TLCOverrides.class exists
-    # The source is modules/tlc2/overrides/TLCOverrides.java
-    # Package is tlc2.overrides, so output should be in tlc2/overrides/
-    output_class = classes_dir / "tlc2/overrides/TLCOverrides.class"
-    assert output_class.exists(), f"Class file not found at {output_class}"
-
-    # Verify META-INF service file
-    service_file = classes_dir / "META-INF/services/tlc2.overrides.ITLCOverrides"
-    assert service_file.exists(), "Service file not found"
-
-    content = service_file.read_text().strip()
-    assert content == "tlc2.overrides.TLCOverrides", f"Unexpected service file content: {content}"
-
-
-@pytest.mark.skipif(not JAVAC_AVAILABLE, reason="javac not found")
-def test_build_custom_overrides(mocker, tmp_path, queue_dir, base_settings):
-    """
-    Test build with custom overrides class configuration.
-    """
-    classes_dir = tmp_path / "classes"
-
-    # Configure custom override
-    custom_override = "com.example.MyOverrides"
-    base_settings.tlc.overrides_class = custom_override
-    base_settings.workspace.root = queue_dir
-    base_settings.workspace.classes_dir = classes_dir
-
-    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=base_settings)
-    mocker.patch("tlaplus_cli.build_tlc_module.workspace_root", return_value=queue_dir)
-
-    result = runner.invoke(app, ["build"])
-    assert result.exit_code == 0, f"Build failed: {result.stdout}"
-
-    service_file = classes_dir / "META-INF/services/tlc2.overrides.ITLCOverrides"
-    assert service_file.exists()
-    assert service_file.read_text().strip() == custom_override