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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tlaplus-cli
-Version: 0.3.3
+Version: 0.3.5
 Summary: TLA+ tools: download TLC, compile custom modules, run model checker
 Author-email: Denis Nikolskiy <codeomatics@gmail.com>
 License-Expression: MIT
@@ -170,6 +170,14 @@ Compile modules in a specific project path:
 tla modules build path/to/project
 ```
 
+Configure a persistent custom modules path:
+```bash
+tla modules path /path/to/custom/modules
+```
+
+> [!TIP]
+> Setting a persistent `module_path` allows `tla modules build` and `tla tlc` to resolve your Java overrides regardless of where the commands are executed.
+
 Verbose output:
 ```bash
 tla modules build --verbose
@@ -221,6 +229,8 @@ tlc:
   java_class: tlc2.TLC
   overrides_class: tlc2.overrides.TLCOverrides
 
+module_path: null         # (Optional) Persistent custom modules path
+
 java:
   min_version: 11
   opts:

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

@@ -141,6 +141,14 @@ Compile modules in a specific project path:
 tla modules build path/to/project
 ```
 
+Configure a persistent custom modules path:
+```bash
+tla modules path /path/to/custom/modules
+```
+
+> [!TIP]
+> Setting a persistent `module_path` allows `tla modules build` and `tla tlc` to resolve your Java overrides regardless of where the commands are executed.
+
 Verbose output:
 ```bash
 tla modules build --verbose
@@ -192,6 +200,8 @@ tlc:
   java_class: tlc2.TLC
   overrides_class: tlc2.overrides.TLCOverrides
 
+module_path: null         # (Optional) Persistent custom modules path
+
 java:
   min_version: 11
   opts:

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tlaplus-cli"
-version = "0.3.3"
+version = "0.3.5"
 description = "TLA+ tools: download TLC, compile custom modules, run model checker"
 readme = "README.md"
 requires-python = ">=3.11"

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

@@ -6,7 +6,7 @@ from pathlib import Path
 
 import typer
 
-from tlaplus_cli.config import cache_dir, load_config, workspace_root
+from tlaplus_cli.config import cache_dir, load_config, save_config, workspace_root
 from tlaplus_cli.version_manager import get_pinned_version_dir
 
 
@@ -28,9 +28,8 @@ def build(
         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
+    modules_dir = Path(config.module_path) if config.module_path else 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])
@@ -71,3 +70,17 @@ def build(
     except FileNotFoundError:
         typer.echo("Error: 'javac' not found. Ensure JDK is installed and in PATH.", err=True)
         raise typer.Exit(1) from None
+
+
+def set_modules_path(path: str = typer.Argument(..., help="Path to the custom Java modules directory.")) -> None:
+    """Configure a persistent custom Java modules path."""
+    config_obj = load_config()
+    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.3.3 → tlaplus_cli-0.3.5}/src/tlaplus_cli/cli.py

@@ -5,6 +5,7 @@ import importlib.metadata
 import typer
 
 from tlaplus_cli.build_tlc_module import build as build_tlc_cmd
+from tlaplus_cli.build_tlc_module import set_modules_path
 from tlaplus_cli.check_java import check_java_version, get_java_version
 from tlaplus_cli.config import load_config
 from tlaplus_cli.run_tlc import tlc as run_tlc_cmd
@@ -50,6 +51,7 @@ def root(
 # 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)
+modules_app.command(name="path")(set_modules_path)
 
 app.add_typer(modules_app, name="modules")
 app.add_typer(tools_app, name="tools")

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

@@ -17,11 +17,31 @@ def load_config() -> Settings:
     Creates a default config on first run.
     """
     cp = _ensure_config()
-    with cp.open() as f:
+    with cp.open(encoding="utf-8") as f:
         data = yaml.safe_load(f)
         return Settings.model_validate(data)
 
 
+def save_config(settings: Settings) -> None:
+    """Save config to the user config directory.
+
+    Uses a defensive deep copy of settings.
+    """
+    cp = config_path()
+    # defensive deep copy as per plan
+    base_settings = settings.model_copy(deep=True)
+
+    # Convert to dict, excluding None values for a cleaner config if desired,
+    # but the plan doesn't specify exclusion. Pydantic's model_dump is good.
+    data = base_settings.model_dump(mode="json")
+
+    with cp.open("w", encoding="utf-8") as f:
+        yaml.safe_dump(data, f, default_flow_style=False)
+
+    # Clear cache to ensure subsequent loads get the new data
+    load_config.cache_clear()
+
+
 def config_dir() -> Path:
     """OS-standard user config directory for this app."""
     return Path(platformdirs.user_config_dir(_APP_NAME))

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

@@ -85,6 +85,15 @@ def tlc(
 
     classpath_parts = [str(jar_path)]
     extra_jvm_opts: list[str] = []
+
+    if config.module_path:
+        custom_path = Path(config.module_path)
+        if custom_path.is_dir():
+            # Phase 4: safely append the custom directory path to the Java -cp mechanism
+            classpath_parts.append(str(custom_path))
+            # Also add to TLA-Library for convenience if TLA modules are there
+            extra_jvm_opts.append(f"-DTLA-Library={custom_path}")
+
     if project_root:
         classes_path = project_root / config.workspace.classes_dir
         if classes_path.is_dir():

{tlaplus_cli-0.3.3 → tlaplus_cli-0.3.5}/src/tlaplus_cli/settings.py

@@ -46,3 +46,4 @@ class Settings(BaseModel):
     workspace: WorkspaceConfig
     tlc: TlcConfig
     java: JavaConfig = Field(default_factory=JavaConfig)
+    module_path: str | None = None

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

@@ -12,9 +12,11 @@ from tlaplus_cli.version_manager import (
     clear_cache,
     clear_pin,
     download_version,
+    download_version_from_url,
     fetch_remote_versions,
     get_pinned_version_dir,
     get_tools_dir,
+    is_url,
     list_local_versions,
     read_version_metadata,
     resolve_latest_version,
@@ -100,6 +102,25 @@ def install(
     version: str = typer.Argument(None),
     force: bool = typer.Option(False, "--force", "-f", help="Force re-download even if already installed."),
 ) -> None:
+    # --- URL install branch ---
+    if version and is_url(version):
+        try:
+            version_dir = download_version_from_url(version)
+            typer.echo("Download complete.")
+        except ValueError as e:
+            typer.echo(f"Error: {e}", err=True)
+            raise typer.Exit(1) from e
+        except Exception as e:
+            typer.echo(f"Error: Failed to download: {e}", err=True)
+            raise typer.Exit(1) from e
+
+        pinned_dir = get_pinned_version_dir()
+        if pinned_dir is None:
+            typer.echo(f"Auto-pinning newly installed version {version_dir.name}")
+            set_pin(version_dir)
+        return
+    # --- end URL branch ---
+
     config = load_config()
     versions, _ = fetch_remote_versions(config.tla.urls.tags, config.tla.urls.releases, config.tla.urls.per_page)
     if not versions:

{tlaplus_cli-0.3.3 → tlaplus_cli-0.3.5}/src/tlaplus_cli/version_manager.py

@@ -6,8 +6,10 @@ import shutil
 import subprocess
 import time
 from dataclasses import asdict, dataclass
+from datetime import UTC, datetime
 from enum import Enum
 from typing import TYPE_CHECKING, Any
+from urllib.parse import urlparse
 
 import requests
 import typer
@@ -22,6 +24,118 @@ if TYPE_CHECKING:
 _SEMVER_RE = re.compile(r"^v?(\d+)\.(\d+)\.(\d+)")
 
 
+def is_url(text: str) -> bool:
+    """Return True if *text* looks like an HTTP(S) URL."""
+    return text.lower().startswith(("http://", "https://"))
+
+
+def extract_version_from_url(url: str) -> str | None:
+    """Scan URL path segments for a semver-like segment (e.g. 'v1.8.0').
+
+    Returns the first matching segment, or None if none is found.
+    """
+    path = urlparse(url).path
+    for segment in path.split("/"):
+        if _SEMVER_RE.match(segment):
+            return segment
+    return None
+
+
+def _utc_now_iso() -> str:
+    """Return the current UTC time in ISO 8601 format, e.g. '2026-04-06T12:51:28Z'."""
+    now = datetime.now(tz=UTC)
+    return now.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def download_version_from_url(url: str) -> Path:
+    """Download tla2tools.jar from *url* and store it in a timestamped version directory.
+
+    The version name is extracted from URL path segments.  The tag (directory suffix) is
+    the ISO 8601 download timestamp.
+
+    Raises:
+        ValueError: if no semver segment can be found in the URL.
+    """
+    version_name = extract_version_from_url(url)
+    if version_name is None:
+        msg = 'could not extract a version name from the URL. The URL must contain a version segment (e.g. "v1.8.0").'
+        raise ValueError(msg)
+
+    tag = _utc_now_iso()
+    tools_dir = get_tools_dir()
+    version_dir = tools_dir / f"{version_name}-{tag}"
+    version_dir.mkdir(parents=True, exist_ok=True)
+    jar_path = version_dir / "tla2tools.jar"
+
+    try:
+        response = requests.get(
+            url,
+            stream=True,
+            timeout=30,
+            headers={"User-Agent": "tlaplus-cli"},
+        )
+        response.raise_for_status()
+        total = int(response.headers.get("content-length", 0))
+
+        with Progress(
+            "[progress.description]{task.description}",
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+        ) as progress:
+            task = progress.add_task(f"Downloading {version_name}...", total=total or None)
+            with jar_path.open("wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+                    progress.update(task, advance=len(chunk))
+    except Exception:
+        shutil.rmtree(version_dir, ignore_errors=True)
+        raise
+
+    write_version_metadata_from_url(version_dir, version_name=version_name, tag=tag, url=url)
+    return version_dir
+
+
+def write_version_metadata_from_url(
+    version_dir: Path,
+    *,
+    version_name: str,
+    tag: str,
+    url: str,
+) -> None:
+    """Write meta-tla2tools.json for a URL-sourced install."""
+    tlc2_version_string = ""
+    try:
+        result = subprocess.run(
+            ["java", "-cp", "tla2tools.jar", "tlc2.TLC", "-version"],
+            cwd=version_dir,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.stdout:
+            tlc2_version_string = result.stdout.strip().split("\n")[0]
+    except Exception as e:
+        typer.echo(f"Warning: Failed to extract TLC version string: {e}", err=True)
+
+    meta_file = version_dir / "meta-tla2tools.json"
+    metadata = {
+        "tag_name": version_name,
+        "sha": "",
+        "published_at": "",
+        "tlc2_version_string": tlc2_version_string,
+        "prerelease": False,
+        "download_url": url,
+        "tag": tag,
+    }
+
+    try:
+        with meta_file.open("w") as f:
+            json.dump(metadata, f, indent=2)
+    except Exception as e:
+        typer.echo(f"Warning: Failed to write metadata: {e}", err=True)
+
+
 def _parse_semver(name: str) -> tuple[int, int, int] | None:
     """Try to extract (major, minor, patch) from a version name like 'v1.8.0'."""
     m = _SEMVER_RE.match(name)
@@ -173,7 +287,8 @@ def list_local_versions() -> list[LocalVersion]:
     result = []
     for d in tools_dir.iterdir():
         if d.is_dir() and not d.is_symlink():
-            parts = d.name.rsplit("-", 1)
+            # Split on the FIRST hyphen so timestamp suffixes are preserved whole
+            parts = d.name.split("-", 1)
             if len(parts) == 2:
                 result.append(LocalVersion(name=parts[0], short_sha=parts[1], path=d))
     return result
@@ -301,7 +416,8 @@ def _fetch_from_api(
         releases_response = requests.get(releases_url, params=params, timeout=10)
         releases_response.raise_for_status()
         releases_data: list[dict[str, Any]] = releases_response.json()
-    except requests.RequestException:
+    except Exception as e:
+        typer.echo(f"⚠ Warning: Failed to fetch remote versions: {e}", err=True)
         return None
     else:
         return tags_data, releases_data

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tlaplus-cli
-Version: 0.3.3
+Version: 0.3.5
 Summary: TLA+ tools: download TLC, compile custom modules, run model checker
 Author-email: Denis Nikolskiy <codeomatics@gmail.com>
 License-Expression: MIT
@@ -170,6 +170,14 @@ Compile modules in a specific project path:
 tla modules build path/to/project
 ```
 
+Configure a persistent custom modules path:
+```bash
+tla modules path /path/to/custom/modules
+```
+
+> [!TIP]
+> Setting a persistent `module_path` allows `tla modules build` and `tla tlc` to resolve your Java overrides regardless of where the commands are executed.
+
 Verbose output:
 ```bash
 tla modules build --verbose
@@ -221,6 +229,8 @@ tlc:
   java_class: tlc2.TLC
   overrides_class: tlc2.overrides.TLCOverrides
 
+module_path: null         # (Optional) Persistent custom modules path
+
 java:
   min_version: 11
   opts:

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

@@ -21,12 +21,9 @@ 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_build_modules_path.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
+tests/test_config.py
+tests/test_modules_path.py
+tests/test_settings.py
+tests/test_tlc_modules_path.py

tlaplus_cli-0.3.5/tests/test_build_modules_path.py

@@ -0,0 +1,50 @@
+from tlaplus_cli.cli import app
+
+
+def test_build_uses_configured_module_path(mocker, tmp_path, base_settings, runner):
+    """Test that build uses module_path from config if available."""
+    # Custom module path
+    custom_modules = tmp_path / "custom_modules"
+    custom_modules.mkdir()
+    (custom_modules / "MyModule.java").write_text("class MyModule {}")
+
+    # Update settings
+    settings = base_settings.model_copy(deep=True)
+    settings.module_path = str(custom_modules)
+    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=settings)
+
+    # Mock subprocess.run
+    mock_run = mocker.patch("tlaplus_cli.build_tlc_module.subprocess.run")
+    mock_run.return_value.returncode = 0
+
+    # Mock jar path
+    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]
+    # Source file should be from custom_modules
+    assert str(custom_modules / "MyModule.java") in cmd
+
+
+def test_build_fails_if_module_path_missing(mocker, tmp_path, base_settings, runner):
+    """Test that build fails if the configured module_path does not exist."""
+    settings = base_settings.model_copy(deep=True)
+    settings.module_path = str(tmp_path / "non_existent")
+    mocker.patch("tlaplus_cli.build_tlc_module.load_config", return_value=settings)
+
+    # Mock jar path
+    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 == 1
+    assert "Error: modules directory not found" in result.output

{tlaplus_cli-0.3.3 → tlaplus_cli-0.3.5}/tests/test_cli.py

@@ -1,11 +1,8 @@
 import pytest
 import typer
-from typer.testing import CliRunner
 
 from tlaplus_cli.cli import app, version_callback
 
-runner = CliRunner()
-
 
 def test_version_callback_exits(mocker):
     """Test version callback exits after printing."""
@@ -22,7 +19,7 @@ def test_version_callback_exits(mocker):
     mock_metadata.assert_called_once_with("tlaplus-cli")
 
 
-def test_cli_version_flag(mocker):
+def test_cli_version_flag(mocker, runner):
     """Test 'tla --version' command."""
     mock_metadata = mocker.patch("importlib.metadata.metadata")
     mock_metadata.return_value = {

tlaplus_cli-0.3.5/tests/test_config.py

@@ -0,0 +1,99 @@
+from tlaplus_cli import config
+
+
+def test_config_paths(mocker, tmp_path):
+    """Test config_dir, config_path, cache_dir return correct paths."""
+    mocker.patch("platformdirs.user_config_dir", return_value=str(tmp_path / "config"))
+    mocker.patch("platformdirs.user_cache_dir", return_value=str(tmp_path / "cache"))
+
+    assert config.config_dir() == tmp_path / "config"
+    assert config.config_path() == tmp_path / "config" / "config.yaml"
+    assert config.cache_dir() == tmp_path / "cache"
+
+
+def test_ensure_config_creates_default(mocker, tmp_path):
+    """_ensure_config creates the config file if it doesn't exist."""
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+    config_path = config_dir / "config.yaml"
+
+    assert not config_path.exists()
+    path = config._ensure_config()
+    assert path == config_path
+    assert config_path.exists()
+    assert "workspace:" in config_path.read_text()
+
+
+def test_load_config_caching(mocker, tmp_path):
+    """load_config should be cached."""
+    config.load_config.cache_clear()
+
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+    config._ensure_config()
+
+    # First call
+    c1 = config.load_config()
+    # Second call should return the same object from cache
+    c2 = config.load_config()
+    assert c1 is c2
+
+
+def test_workspace_root_absolute(mocker, tmp_path):
+    """workspace_root returns absolute path when config has absolute path."""
+    abs_path = (tmp_path / "my_ws").absolute()
+    mock_settings = mocker.MagicMock()
+    mock_settings.workspace.root = str(abs_path)
+    mocker.patch("tlaplus_cli.config.load_config", return_value=mock_settings)
+
+    assert config.workspace_root() == abs_path
+
+
+def test_load_module_path(mocker, tmp_path):
+    """Test that module_path can be loaded from config."""
+    config.load_config.cache_clear()
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+    config_path = config_dir / "config.yaml"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    config_content = """
+tla:
+  urls:
+    tags: https://example.com/tags
+    releases: https://example.com/releases
+    per_page: 30
+workspace:
+  root: .
+  spec_dir: spec
+  modules_dir: modules
+  classes_dir: classes
+tlc:
+  java_class: tlc2.TLC
+  overrides_class: tlc2.overrides.TLCOverrides
+module_path: /custom/path
+"""
+    config_path.write_text(config_content)
+
+    cfg = config.load_config()
+    assert cfg.module_path == "/custom/path"
+
+
+def test_save_config(mocker, tmp_path):
+    """Test saving config preserves module_path and uses deep copy."""
+    config.load_config.cache_clear()
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+    config_path = config_dir / "config.yaml"
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    cfg = config.load_config()
+    cfg.module_path = "/new/path"
+
+    config.save_config(cfg)
+
+    # Reload and check
+    config.load_config.cache_clear()
+    new_cfg = config.load_config()
+    assert new_cfg.module_path == "/new/path"
+    assert "module_path: /new/path" in config_path.read_text()

tlaplus_cli-0.3.5/tests/test_modules_path.py

@@ -0,0 +1,62 @@
+from tlaplus_cli import config
+from tlaplus_cli.cli import app
+
+
+def test_modules_path_success(mocker, tmp_path, runner):
+    """Test successful setting of modules path."""
+    config.load_config.cache_clear()
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+
+    # Create a dummy module directory
+    module_dir = tmp_path / "my_modules"
+    module_dir.mkdir()
+
+    result = runner.invoke(app, ["modules", "path", str(module_dir)])
+
+    assert result.exit_code == 0
+    assert f"Modules path updated to: {module_dir}" in result.output
+
+    # Check config
+    config.load_config.cache_clear()
+    cfg = config.load_config()
+    assert cfg.module_path == str(module_dir)
+
+
+def test_modules_path_invalid_dir(mocker, tmp_path, runner):
+    """Test setting modules path to non-existent directory fails."""
+    config.load_config.cache_clear()
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+
+    invalid_dir = tmp_path / "does_not_exist"
+
+    result = runner.invoke(app, ["modules", "path", str(invalid_dir)])
+
+    assert result.exit_code == 1
+    assert "Error: Path does not exist or is not a directory" in result.output
+
+    # Check config was NOT updated
+    config.load_config.cache_clear()
+    cfg = config.load_config()
+    assert cfg.module_path is None
+
+
+def test_modules_path_file_instead_of_dir(mocker, tmp_path, runner):
+    """Test setting modules path to a file fails."""
+    config.load_config.cache_clear()
+    config_dir = tmp_path / "config"
+    mocker.patch("tlaplus_cli.config.config_dir", return_value=config_dir)
+
+    some_file = tmp_path / "some_file.txt"
+    some_file.write_text("hello")
+
+    result = runner.invoke(app, ["modules", "path", str(some_file)])
+
+    assert result.exit_code == 1
+    assert "Error: Path does not exist or is not a directory" in result.output
+
+    # Check config was NOT updated
+    config.load_config.cache_clear()
+    cfg = config.load_config()
+    assert cfg.module_path is None