Fix #65: Make missing sources fatal error in non-offline mode

In offline mode:
- Missing sources log WARNING (expected)
- Packages written as comments
- mxdev continues

In non-offline mode:
- Missing sources log ERROR (fatal)
- Packages written as comments
- mxdev raises RuntimeError and exits

This prevents silent failures when sources fail to checkout
and makes mxmake two-stage installation more robust.

Tests:
- Updated test_write_dev_sources_missing_directories to use offline mode
- Added test_write_dev_sources_missing_directories_raises_error
- All 7 write_dev_sources tests pass

Author: jensens

CHANGES.md

@@ -20,7 +20,7 @@
   [jensens]
 - Feature: #54: Add `fixed` install mode for non-editable installations to support production and Docker deployments. The new `editable` mode replaces `direct` as the default (same behavior, clearer naming). The `direct` mode is now deprecated but still works with a warning. Install modes: `editable` (with `-e`, for development), `fixed` (without `-e`, for production/Docker), `skip` (clone only).
   [jensens]
-- Fix #65: When generating requirements-mxdev.txt, check if source directories actually exist before writing package references. If a source directory doesn't exist (e.g., when using `mxdev -n` without prior fetch, or in offline mode), write it as a comment with a contextual warning instead of causing pip install to fail later. This fixes the mxmake two-stage installation workflow where `mxdev -n` runs before sources are checked out. Warning messages include context about offline mode when applicable.
+- Fix #65: Check source directories exist before writing to requirements-mxdev.txt. In **offline mode**: missing sources log WARNING and are written as comments (expected behavior). In **non-offline mode**: missing sources log ERROR and mxdev exits with RuntimeError (fatal error indicating checkout failure). This fixes mxmake two-stage installation workflow and prevents silent failures when sources fail to check out.
   [jensens]
 - Fix #35: Add `smart-threading` configuration option to prevent overlapping credential prompts when using HTTPS URLs. When enabled (default), HTTPS packages are processed serially first to ensure clean credential prompts, then other packages are processed in parallel for speed. Can be disabled with `smart-threading = false` if you have credential helpers configured.
   [jensens]

src/mxdev/processing.py

@@ -219,6 +219,7 @@ def write_dev_sources(fio, packages: dict[str, dict[str, typing.Any]], state: St
     from .config import to_bool
 
     offline_mode = to_bool(state.configuration.settings.get("offline", False))
+    missing_sources = []  # Track missing sources for error handling
 
     fio.write("#" * 79 + "\n")
     fio.write("# mxdev development sources\n")
@@ -238,19 +239,25 @@ def write_dev_sources(fio, packages: dict[str, dict[str, typing.Any]], state: St
         install_line = f"""{prefix}./{package['target']}/{name}{subdir}{extras}"""
 
         if not source_path.exists():
-            # Source not checked out yet - write as comment with warning
+            # Source not checked out yet - write as comment
+            missing_sources.append(name)
+
             if offline_mode:
+                # In offline mode, missing sources are expected - log as WARNING
                 reason = (
                     f"Source directory does not exist: {source_path} (package: {name}). "
                     f"This is expected in offline mode. Run mxdev without -n and --offline flags to fetch sources."
                 )
+                logger.warning(reason)
             else:
+                # In non-offline mode, missing sources are a fatal error - log as ERROR
                 reason = (
                     f"Source directory does not exist: {source_path} (package: {name}). "
-                    f"This could be because -n (no-fetch) flag was used or sources haven't been checked out yet. "
+                    f"This indicates a failure in the checkout process. "
                     f"Run mxdev without -n flag to fetch sources."
                 )
-            logger.warning(reason)
+                logger.error(reason)
+
             fio.write(f"# {install_line}  # mxdev: source not checked out\n")
         else:
             # Source exists - write normally
@@ -259,6 +266,14 @@ def write_dev_sources(fio, packages: dict[str, dict[str, typing.Any]], state: St
 
     fio.write("\n\n")
 
+    # In non-offline mode, missing sources are a fatal error
+    if not offline_mode and missing_sources:
+        raise RuntimeError(
+            f"Source directories missing for packages: {', '.join(missing_sources)}. "
+            f"This indicates a failure in the checkout process. "
+            f"Run mxdev without -n flag to fetch sources."
+        )
+
 
 def write_dev_overrides(fio, overrides: dict[str, str], package_keys: list[str]):
     """Create requirements configuration for overridden packages."""

tests/test_processing.py

@@ -673,20 +673,21 @@ def test_write_relative_constraints_path_different_dirs(tmp_path):
 
 
 def test_write_dev_sources_missing_directories(tmp_path, caplog):
-    """Test write_dev_sources with non-existing source directories.
+    """Test write_dev_sources with non-existing source directories in offline mode.
 
-    When source directories don't exist (e.g., when using mxdev -n),
+    When source directories don't exist in offline mode (expected behavior),
     packages should be written as comments with warnings.
     """
     from mxdev.config import Configuration
     from mxdev.processing import write_dev_sources
     from mxdev.state import State
 
-    # Create config without offline mode
+    # Create config WITH offline mode
     config_file = tmp_path / "mx.ini"
     config_file.write_text(
         """[settings]
 requirements-in = requirements.txt
+offline = true
 """
     )
     config = Configuration(str(config_file))
@@ -733,11 +734,70 @@ def test_write_dev_sources_missing_directories(tmp_path, caplog):
     assert "# -e ./sources/missing.package  # mxdev: source not checked out\n" in content
     assert "# ./sources/missing.fixed[test]  # mxdev: source not checked out\n" in content
 
-    # Check warnings were logged
+    # Check warnings were logged (offline mode specific)
     assert "Source directory does not exist" in caplog.text
     assert "missing.package" in caplog.text
     assert "missing.fixed" in caplog.text
-    assert "Run mxdev without -n flag" in caplog.text
+    assert "This is expected in offline mode" in caplog.text
+    assert "Run mxdev without -n and --offline flags" in caplog.text
+
+
+def test_write_dev_sources_missing_directories_raises_error(tmp_path, caplog):
+    """Test write_dev_sources raises RuntimeError when sources missing in non-offline mode.
+
+    When source directories don't exist and we're NOT in offline mode,
+    this is a fatal error - something went wrong earlier in the workflow.
+    """
+    from mxdev.config import Configuration
+    from mxdev.processing import write_dev_sources
+    from mxdev.state import State
+
+    import pytest
+
+    # Create config WITHOUT offline mode (non-offline mode)
+    config_file = tmp_path / "mx.ini"
+    config_file.write_text(
+        """[settings]
+requirements-in = requirements.txt
+"""
+    )
+    config = Configuration(str(config_file))
+    state = State(configuration=config)
+
+    # Define packages but DON'T create source directories
+    packages = {
+        "missing.package": {
+            "target": "sources",
+            "path": str(tmp_path / "sources" / "missing.package"),
+            "extras": "",
+            "subdirectory": "",
+            "install-mode": "editable",
+        },
+        "missing.fixed": {
+            "target": "sources",
+            "path": str(tmp_path / "sources" / "missing.fixed"),
+            "extras": "test",
+            "subdirectory": "",
+            "install-mode": "fixed",
+        },
+    }
+
+    outfile = tmp_path / "requirements.txt"
+
+    # Should raise RuntimeError for missing sources in non-offline mode
+    with pytest.raises(RuntimeError) as exc_info:
+        with open(outfile, "w") as fio:
+            write_dev_sources(fio, packages, state)
+
+    # Error message should contain package names
+    error_msg = str(exc_info.value)
+    assert "missing.package" in error_msg
+    assert "missing.fixed" in error_msg
+    assert "Source directories missing" in error_msg
+
+    # Should log ERROR (not just WARNING)
+    assert any(record.levelname == "ERROR" for record in caplog.records)
+    assert "Source directory does not exist" in caplog.text
 
 
 def test_write_dev_sources_missing_directories_offline_mode(tmp_path, caplog):