mapify-cli 3.31.1__tar.gz → 3.31.2__tar.gz

{mapify_cli-3.31.1 → mapify_cli-3.31.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mapify-cli
-Version: 3.31.1
+Version: 3.31.2
 Summary: MAP Framework installer - Modular Agentic Planner for Claude Code
 Project-URL: Homepage, https://github.com/azalio/map-framework
 Project-URL: Repository, https://github.com/azalio/map-framework.git

{mapify_cli-3.31.1 → mapify_cli-3.31.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mapify-cli"
-version = "3.31.1"
+version = "3.31.2"
 description = "MAP Framework installer - Modular Agentic Planner for Claude Code"
 authors = [{ name = "MAP Framework Contributors" }]
 readme = "README.md"

{mapify_cli-3.31.1 → mapify_cli-3.31.2}/src/mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.31.1"
+__version__ = "3.31.2"
 
 # MUST stay the first import: it turns "this interpreter is older than 3.11" into
 # a message that says so, instead of the ImportError raised by `from datetime
@@ -2509,6 +2509,30 @@ def _run_self_upgrade(cmd: list[str]) -> int:
         return 127
 
 
+def _installed_mapify_version() -> str | None:
+    """Read the installed mapify-cli version after a self-upgrade.
+
+    The in-process ``__version__`` predates the upgrade, so ask a fresh
+    interpreter from the same environment. Returns None if it cannot be read.
+    """
+    try:
+        proc = subprocess.run(
+            [
+                sys.executable,
+                "-c",
+                "import importlib.metadata as m; print(m.version('mapify-cli'))",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=30,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    installed = proc.stdout.strip()
+    return installed if proc.returncode == 0 and installed else None
+
+
 @app.command()
 def upgrade():
     """Upgrade the mapify CLI itself to the latest released version.
@@ -2580,12 +2604,38 @@ def upgrade():
         console.print(f"  [cyan]{' '.join(cmd)}[/cyan]")
         raise typer.Exit(1)
 
-    target = latest_version or "the latest release"
+    # A zero exit does not mean the version changed: when PyPI's index lags the
+    # GitHub release, `uv tool upgrade` exits 0 with "Nothing to upgrade".
+    installed = _installed_mapify_version()
     console.print()
-    console.print(
-        f"[bold green]mapify upgraded[/bold green] (was {__version__}, now {target})."
-    )
-    console.print("[dim]Confirm with [cyan]mapify --version[/cyan].[/dim]")
+    if installed is not None and parse_version(installed) <= parse_version(
+        __version__
+    ):
+        if latest_version and parse_version(latest_version) > parse_version(
+            installed
+        ):
+            console.print(
+                f"[yellow]mapify was not upgraded: still {installed}.[/yellow] "
+                f"Release {latest_version} is on GitHub, but the package index "
+                "does not serve it yet (PyPI can lag behind a release). "
+                "Retry [cyan]mapify upgrade[/cyan] later."
+            )
+            raise typer.Exit(1)
+        console.print(
+            f"[green]mapify is already the newest version on the package index "
+            f"({installed}).[/green]"
+        )
+        return
+
+    if installed is not None:
+        console.print(
+            f"[bold green]mapify upgraded[/bold green] (was {__version__}, now {installed})."
+        )
+    else:
+        console.print(
+            "[bold green]Upgrade command finished.[/bold green] "
+            "Confirm the new version with [cyan]mapify --version[/cyan]."
+        )
     console.print(
         "[dim]To refresh this project's MAP files with the new templates, run "
         "[cyan]mapify init . --force[/cyan].[/dim]"

{mapify_cli-3.31.1 → mapify_cli-3.31.2}/tests/test_mapify_cli.py

@@ -4343,6 +4343,7 @@ class TestUpgradeCommand:
         assert result.exit_code == 0
         mock_auto.assert_not_called()
 
+    @mock.patch("mapify_cli._installed_mapify_version", return_value="9.9.9")
     @mock.patch("mapify_cli._run_self_upgrade", return_value=0)
     @mock.patch(
         "mapify_cli._self_upgrade_command",
@@ -4351,10 +4352,10 @@ class TestUpgradeCommand:
     @mock.patch("mapify_cli._mapify_install_kind", return_value="uv-tool")
     @mock.patch("mapify_cli.get_latest_release")
     def test_upgrade_self_upgrades_when_newer(
-        self, mock_get_latest, _mock_kind, _mock_cmd, mock_run, tmp_path
+        self, mock_get_latest, _mock_kind, _mock_cmd, mock_run, _mock_installed, tmp_path
     ):
         """A newer release self-upgrades the mapify CLI and writes no project files."""
-        del _mock_kind, _mock_cmd
+        del _mock_kind, _mock_cmd, _mock_installed
         os.chdir(tmp_path)
         mock_get_latest.return_value = {
             "tag_name": "v9.9.9",
@@ -4369,6 +4370,7 @@ class TestUpgradeCommand:
         assert result.exit_code == 0, result.stdout
         assert "New version available" in normalized
         assert "mapify upgraded" in normalized
+        assert "now 9.9.9" in normalized
         # Directs users at the project-file refresh path
         assert "mapify init . --force" in normalized
         # Shelled out to the self-upgrade command exactly once
@@ -4376,6 +4378,62 @@ class TestUpgradeCommand:
         # upgrade no longer creates any project files
         assert not (tmp_path / ".claude").exists()
 
+    @mock.patch("mapify_cli._installed_mapify_version", return_value="0.0.1")
+    @mock.patch("mapify_cli.__version__", "0.0.1")
+    @mock.patch("mapify_cli._run_self_upgrade", return_value=0)
+    @mock.patch(
+        "mapify_cli._self_upgrade_command",
+        return_value=["uv", "tool", "upgrade", "mapify-cli"],
+    )
+    @mock.patch("mapify_cli._mapify_install_kind", return_value="uv-tool")
+    @mock.patch("mapify_cli.get_latest_release")
+    def test_upgrade_does_not_claim_success_when_version_unchanged(
+        self, mock_get_latest, _mock_kind, _mock_cmd, _mock_run, _mock_installed
+    ):
+        """GitHub has the release but the package index still serves the old
+        version: `uv tool upgrade` exits 0 with "Nothing to upgrade", so the
+        installed version is unchanged. Must not report "mapify upgraded"."""
+        del _mock_kind, _mock_cmd, _mock_run, _mock_installed
+        mock_get_latest.return_value = {"tag_name": "v9.9.9"}
+
+        result = runner.invoke(app, ["upgrade"])
+
+        normalized = " ".join(result.stdout.split())
+        assert result.exit_code == 1, result.stdout
+        assert "mapify upgraded" not in normalized
+        assert "still 0.0.1" in normalized
+        assert "9.9.9" in normalized
+
+    @mock.patch("mapify_cli._installed_mapify_version", return_value=None)
+    @mock.patch("mapify_cli._run_self_upgrade", return_value=0)
+    @mock.patch(
+        "mapify_cli._self_upgrade_command",
+        return_value=["uv", "tool", "upgrade", "mapify-cli"],
+    )
+    @mock.patch("mapify_cli._mapify_install_kind", return_value="uv-tool")
+    @mock.patch("mapify_cli.get_latest_release")
+    def test_upgrade_unknown_installed_version_does_not_claim_target(
+        self, mock_get_latest, _mock_kind, _mock_cmd, _mock_run, _mock_installed
+    ):
+        """If the installed version cannot be read back, do not print the
+        GitHub release as the new version — ask the user to confirm instead."""
+        del _mock_kind, _mock_cmd, _mock_run, _mock_installed
+        mock_get_latest.return_value = {"tag_name": "v9.9.9"}
+
+        result = runner.invoke(app, ["upgrade"])
+
+        normalized = " ".join(result.stdout.split())
+        assert result.exit_code == 0, result.stdout
+        assert "now 9.9.9" not in normalized
+        assert "mapify --version" in normalized
+
+    def test_installed_mapify_version_reads_package_metadata(self):
+        """Reads the version from a fresh interpreter, not the stale in-process
+        ``__version__`` that predates the upgrade."""
+        from importlib.metadata import version
+
+        assert mapify_cli._installed_mapify_version() == version("mapify-cli")
+
     @mock.patch("mapify_cli._run_self_upgrade")
     @mock.patch("mapify_cli.get_latest_release")
     def test_upgrade_already_latest_does_nothing(