mapify-cli 3.11.0__tar.gz → 3.12.1__tar.gz

{mapify_cli-3.11.0 → mapify_cli-3.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapify-cli
-Version: 3.11.0
+Version: 3.12.1
 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.11.0 → mapify_cli-3.12.1}/pyproject.toml

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

{mapify_cli-3.11.0 → mapify_cli-3.12.1}/src/mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.11.0"
+__version__ = "3.12.1"
 
 import os
 import subprocess
@@ -70,12 +70,12 @@ from mapify_cli.delivery import (
     create_evaluator_content as create_evaluator_content,
     create_reflector_content as create_reflector_content,
     create_documentation_reviewer_content as create_documentation_reviewer_content,
-    create_agent_files,
-    create_reference_files,
-    create_command_files,
-    create_skill_files,
-    create_hook_files,
-    create_config_files,
+    create_agent_files as create_agent_files,
+    create_reference_files as create_reference_files,
+    create_command_files as create_command_files,
+    create_skill_files as create_skill_files,
+    create_hook_files as create_hook_files,
+    create_config_files as create_config_files,
     create_commands_dir as create_commands_dir,
 )
 from mapify_cli.config import (
@@ -1259,32 +1259,62 @@ def doctor(debug: bool = typer.Option(False, "--debug", help="Enable debug loggi
             console.print(f"  • {path_name}")
 
 
+def _mapify_install_kind() -> str:
+    """Classify how this mapify CLI is installed.
+
+    Returns one of:
+      - ``"uv-tool"``: installed via ``uv tool install`` (self-upgradeable with uv)
+      - ``"pip"``:     installed into a regular/virtualenv site-packages (pip -U)
+      - ``"source"``:  running from a source checkout / editable install
+        (self-upgrade disabled — the user owns the tree)
+    """
+    pkg = str(Path(__file__).resolve()).replace("\\", "/")
+    if "/uv/tools/" in pkg:
+        return "uv-tool"
+    if "/site-packages/" in pkg or "/dist-packages/" in pkg:
+        return "pip"
+    return "source"
+
+
+def _self_upgrade_command(kind: str) -> Optional[List[str]]:
+    """Return the argv that upgrades mapify-cli for ``kind``, or None if unknown."""
+    if kind == "uv-tool":
+        uv = shutil.which("uv")
+        return [uv, "tool", "upgrade", "mapify-cli"] if uv else None
+    if kind == "pip":
+        return [sys.executable, "-m", "pip", "install", "--upgrade", "mapify-cli"]
+    return None
+
+
+def _run_self_upgrade(cmd: List[str]) -> int:
+    """Run the self-upgrade command, streaming its output. Returns the exit code.
+
+    Returns ``127`` when the executable is not found. Isolated into its own
+    function so tests can stub the subprocess invocation without patching the
+    module-level ``subprocess`` used by many other commands.
+    """
+    try:
+        return subprocess.run(cmd, check=False).returncode
+    except FileNotFoundError:
+        return 127
+
+
 @app.command()
 def upgrade():
-    """Upgrade MAP agents to the latest version."""
-    show_banner()
-    project_path = Path.cwd()
-
-    if not is_map_initialized(project_path):
-        console.print(
-            "[yellow]MAP Framework not initialized in this directory.[/yellow]"
-        )
-        console.print("Run: [cyan]mapify init .[/cyan]")
-        raise typer.Exit(0)
+    """Upgrade the mapify CLI itself to the latest released version.
 
-    if _detect_provider(project_path) == "codex":
-        console.print(
-            "[yellow]Codex projects: re-run "
-            "[cyan]mapify init . --provider codex --force[/cyan] to refresh.[/yellow]"
-        )
-        raise typer.Exit(0)
+    This refreshes the installed ``mapify-cli`` package (the tool), not the
+    files inside a project. After upgrading, run ``mapify init . --force`` to
+    refresh a project's shipped MAP files with the new templates.
+    """
+    show_banner()
 
-    console.print("[cyan]Checking for updates...[/cyan]")
+    console.print("[cyan]Checking for the latest release...[/cyan]")
     latest_release = get_latest_release("azalio", "map-framework")
-    latest_version = None
+    latest_version: Optional[str] = None
 
     if latest_release and latest_release.get("tag_name"):
-        latest_version = latest_release["tag_name"].lstrip("v")
+        latest_version = str(latest_release["tag_name"]).lstrip("v")
         if parse_version(latest_version) > parse_version(__version__):
             console.print(
                 f"[yellow]New version available:[/yellow] {latest_version} "
@@ -1294,97 +1324,61 @@ def upgrade():
                 console.print(f"Release: [cyan]{latest_release['html_url']}[/cyan]")
         else:
             console.print(
-                f"[green]You are on the latest installed version ({__version__}).[/green]"
+                f"[green]Already on the latest release ({__version__}).[/green]"
             )
+            console.print("[dim]Nothing to upgrade.[/dim]")
+            raise typer.Exit(0)
     else:
         console.print(
-            "[dim]Could not fetch release metadata; refreshing local templates anyway.[/dim]"
+            "[dim]Could not fetch release metadata; attempting upgrade anyway.[/dim]"
         )
 
-    tracker = StepTracker("Upgrade MAP Framework Files")
-
-    # Track drift across all file types
-    from mapify_cli.delivery.managed_file_copier import DriftReport
-
-    drift_report = DriftReport()
+    kind = _mapify_install_kind()
 
-    existing_project_mcp = read_project_mcp_json(project_path / ".mcp.json")
-    existing_server_names = []
-    if existing_project_mcp:
-        existing_server_names = list(existing_project_mcp.get("mcpServers", {}).keys())
-
-    tracker.add("agents", "Refresh agent templates")
-    tracker.start("agents")
-    agent_count = create_agent_files(project_path, existing_server_names, drift_report)
-    tracker.complete("agents", f"{agent_count} files")
-
-    tracker.add("commands", "Refresh slash commands")
-    tracker.start("commands")
-    command_count = create_command_files(project_path, drift_report)
-    tracker.complete("commands", f"{command_count} files")
-
-    tracker.add("skills", "Refresh skills")
-    tracker.start("skills")
-    skill_count = create_skill_files(project_path)
-    tracker.complete("skills", f"{skill_count} folders")
-
-    tracker.add("references", "Refresh reference files")
-    tracker.start("references")
-    ref_count = create_reference_files(project_path, drift_report)
-    tracker.complete("references", f"{ref_count} files")
-
-    tracker.add("hooks", "Refresh shared hooks")
-    tracker.start("hooks")
-    hook_count = create_hook_files(project_path, drift_report)
-    tracker.complete("hooks", f"{hook_count} files")
-
-    tracker.add("configs", "Refresh config files")
-    tracker.start("configs")
-    config_count = create_config_files(project_path, drift_report)
-    tracker.complete("configs", f"{config_count} files")
-
-    tracker.add("permissions", "Merge local approvals")
-    tracker.start("permissions")
-    create_or_merge_project_settings_local(project_path)
-    tracker.complete("permissions", "settings.local.json updated")
+    if kind == "source":
+        source_root = Path(__file__).resolve().parents[2]
+        console.print(
+            "[yellow]Running from a source checkout — self-upgrade is disabled.[/yellow]"
+        )
+        console.print(f"[dim]Source: {source_root}[/dim]")
+        console.print(
+            "[dim]Update with [cyan]git pull[/cyan] "
+            "(then re-install the tool if needed).[/dim]"
+        )
+        raise typer.Exit(0)
 
-    if (project_path / ".claude" / "mcp_config.json").exists() or (
-        project_path / ".mcp.json"
-    ).exists():
-        tracker.add("mcp", "Preserve MCP config")
-        tracker.complete("mcp", "left unchanged")
+    cmd = _self_upgrade_command(kind)
+    if cmd is None:
+        console.print(
+            "[red]Could not determine how to upgrade mapify automatically.[/red]"
+        )
+        console.print(
+            "Upgrade manually: [cyan]uv tool upgrade mapify-cli[/cyan] "
+            "or [cyan]pip install --upgrade mapify-cli[/cyan]"
+        )
+        raise typer.Exit(1)
 
     console.print()
-    console.print(tracker.render())
+    console.print(f"[cyan]Upgrading mapify-cli...[/cyan] [dim]({' '.join(cmd)})[/dim]")
+    exit_code = _run_self_upgrade(cmd)
 
-    # Show drift warnings if any files were modified by the user
-    if drift_report.has_drift:
+    if exit_code != 0:
         console.print()
         console.print(
-            f"[yellow]⚠ {len(drift_report.drifted_files)} file(s) had local modifications:[/yellow]"
-        )
-        for r in drift_report.drifted_files:
-            try:
-                rel = r.dest.relative_to(project_path)
-            except ValueError:
-                rel = r.dest
-            backup_note = ""
-            if r.backed_up and r.backup_path:
-                try:
-                    backup_rel = r.backup_path.relative_to(project_path)
-                except ValueError:
-                    backup_rel = r.backup_path
-                backup_note = f" → backup: [cyan]{backup_rel}[/cyan]"
-            console.print(f"  [yellow]•[/yellow] {rel}{backup_note}")
-        console.print(
-            "[dim]Your changes were backed up to .bak files. "
-            "Review and re-apply any customizations if needed.[/dim]"
+            f"[red]Upgrade command failed (exit {exit_code}).[/red] Run it manually:"
         )
+        console.print(f"  [cyan]{' '.join(cmd)}[/cyan]")
+        raise typer.Exit(1)
 
+    target = latest_version or "the latest release"
     console.print()
-    console.print("[bold green]Upgrade complete.[/bold green]")
     console.print(
-        "[dim]Note: upgrade refreshes shipped MAP files but does not overwrite project-specific MCP selections.[/dim]"
+        f"[bold green]mapify upgraded[/bold green] (was {__version__}, now {target})."
+    )
+    console.print("[dim]Confirm with [cyan]mapify --version[/cyan].[/dim]")
+    console.print(
+        "[dim]To refresh this project's MAP files with the new templates, run "
+        "[cyan]mapify init . --force[/cyan].[/dim]"
     )
 
 

{mapify_cli-3.11.0 → mapify_cli-3.12.1}/src/mapify_cli/delivery/managed_file_copier.py

@@ -49,6 +49,7 @@ class CopyResult:
     backup_path: Optional[Path] = None
     reason: str = ""
     first_install: bool = False
+    migrated: bool = False
 
 
 @dataclass
@@ -754,50 +755,49 @@ def copy_managed_file(
         return result
 
     if fence_result.state == "no_fence":
-        # INV-T / D10: Phase B install (metadata present, no fence)
-        # Treat as fully managed (current behavior, no regression) + emit notice
-        notice = (
-            f"MIGRATION: {dest}: Phase B install detected (metadata present, no fence). "
-            "Treating as fully managed. Re-install with mapify to add fence structure."
-        )
-        print(notice, file=sys.stderr)
-
-        # Compute hash of clean dest content to detect drift
+        # INV-T / D10: legacy unfenced install (metadata present, no fence markers).
+        # Silently upgrade it to the fenced layout — exactly what a fresh install
+        # writes (Case A).  Legacy unfenced files were fully managed (no user tail),
+        # so the entire body becomes the managed region inside the fence.
+        #
+        # This migration is one-time and invisible by design: once the fence is
+        # written, the next copy_managed_file() run finds state == "found" and takes
+        # the normal merge path, so this branch never fires for that file again.
+        # We deliberately emit NO per-file notice — a routine, self-healing upgrade
+        # should not flood stderr with alarming lines on every `mapify init`.
         stored_hash = existing_meta.get("template_hash", "")
         _, clean_dest = extract_metadata(dest_content, ext)
         current_hash = compute_hash(clean_dest)
 
         result = CopyResult(src=src, dest=dest)
-        result.reason = notice
-
-        if stored_hash and current_hash == stored_hash:
-            # No drift; upgrade metadata only
-            final_text = injected
-            try:
-                _atomic_write(dest, final_text)
-                result.success = True
-            except OSError as exc:
-                result.success = False
-                result.reason += f" write failed: {exc}"
-        else:
-            # Drift or unknown hash → backup + overwrite fully managed
-            if stored_hash:
-                result.drifted = True
-                ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S")
-                backup_path = dest.with_suffix(f"{dest.suffix}.{ts}.bak")
-                try:
-                    shutil.copy2(dest, backup_path)
-                    result.backed_up = True
-                    result.backup_path = backup_path
-                except OSError:
-                    result.reason += " (backup failed)"
-            final_text = injected
+        result.migrated = True
+        result.reason = "upgraded legacy unfenced file to fenced layout"
+
+        # Back up only when the user modified the previously fully-managed body
+        # (hash drift), mirroring the fenced-merge drift-backup behavior.
+        if stored_hash and current_hash != stored_hash:
+            result.drifted = True
+            ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S")
+            backup_path = dest.with_suffix(f"{dest.suffix}.{ts}.bak")
             try:
-                _atomic_write(dest, final_text)
-                result.success = True
-            except OSError as exc:
-                result.success = False
-                result.reason += f" write failed: {exc}"
+                shutil.copy2(dest, backup_path)
+                result.backed_up = True
+                result.backup_path = backup_path
+            except OSError:
+                result.reason += " (backup failed)"
+
+        final_text = _build_fenced_content(
+            metadata_line=meta_prefix.rstrip("\n"),
+            start_token=start_token,
+            end_token=end_token,
+            managed_body=body_after_meta,
+        )
+        try:
+            _atomic_write(dest, final_text)
+            result.success = True
+        except OSError as exc:
+            result.success = False
+            result.reason = f"write failed: {exc}"
 
         return result
 

{mapify_cli-3.11.0 → mapify_cli-3.12.1}/tests/test_managed_file_copier.py

@@ -608,43 +608,53 @@ class TestFenceAwareMerge:
 
     # ------------------------------------------------------------------ VC3
     @pytest.mark.parametrize("ext,start_tok,end_tok", _FENCE_FORMATS)
-    def test_vc3_phase_b_no_fence_fully_managed_no_regression(
+    def test_vc3_legacy_unfenced_upgraded_to_fenced_silently(
         self, tmp_path, ext: str, start_tok: str, end_tok: str, capsys: pytest.CaptureFixture[str]
     ) -> None:
-        """VC3 [INV-T]: Phase B file (metadata, no fence) → fully managed + migration notice."""
+        """VC3 [INV-T]: legacy unfenced file (metadata, no fence) is silently upgraded
+        to the fenced layout — fence markers added, no alarming per-file stderr output,
+        and the migration is one-time (idempotent on re-copy)."""
         src_body = _src_body_for(ext)
         src = tmp_path / f"tmpl{ext}"
         src.write_text(src_body, encoding="utf-8")
         dest = tmp_path / f"dest{ext}"
 
-        # Simulate a Phase B install: inject metadata but NO fence
+        # Simulate a legacy install: inject metadata but NO fence
         template_hash = compute_hash(src_body)
         phase_b_content = inject_metadata(src_body, ext, "1.0.0", template_hash)
         dest.write_text(phase_b_content, encoding="utf-8")
 
-        # Re-copy with Phase C copier
+        # Re-copy: migration should complete by adding the fence
         r = copy_managed_file(src, dest, "1.1.0")
-        assert r.success, f"Phase B → C migration failed: {r.reason}"
+        assert r.success, f"legacy → fenced migration failed: {r.reason}"
+        assert r.migrated, "result must flag the one-time legacy → fenced migration"
 
-        # Must have written something (fully managed — no fence added on Phase B migration;
-        # fence only comes with a full re-install via `mapify init`)
-        del start_tok, end_tok  # Phase B path doesn't add fence tokens by design
         content = dest.read_text(encoding="utf-8")
-        assert "MAP-MANAGED" in content, "Metadata must be present after re-copy"
+        assert "MAP-MANAGED" in content, "Metadata must be present after migration"
+        # The migration must now write the fence markers (the whole point of the fix).
+        assert start_tok in content, f"start fence {start_tok!r} missing after migration"
+        assert end_tok in content, f"end fence {end_tok!r} missing after migration"
         # Check key lines of the managed body are present (shebang may be reordered)
         for line in src_body.splitlines():
             stripped = line.strip()
             if stripped and not stripped.startswith("#!"):
                 assert stripped in content, (
-                    f"Body line {stripped!r} missing from re-copied content"
+                    f"Body line {stripped!r} missing from migrated content"
                 )
 
-        # Migration notice must appear on stderr
+        # No alarming per-file notice should reach stderr — the upgrade is silent.
         stderr_out = capsys.readouterr().err
-        assert "MIGRATION" in stderr_out or "Phase B" in stderr_out or "no fence" in stderr_out.lower(), (
-            f"Migration notice expected in stderr; got: {stderr_out!r}"
+        assert "MIGRATION" not in stderr_out and "Phase B" not in stderr_out, (
+            f"legacy upgrade must be silent; got stderr: {stderr_out!r}"
         )
 
+        # Idempotent: a second copy now finds a proper fence (state == 'found'),
+        # so it takes the normal merge path and does NOT re-migrate.
+        r2 = copy_managed_file(src, dest, "1.1.0")
+        assert r2.success
+        assert not r2.migrated, "migration must be one-time, not repeated on every copy"
+        assert capsys.readouterr().err == "", "re-copy of a fenced file must be silent"
+
     # ------------------------------------------------------------------ VC4
     @pytest.mark.parametrize("ext,start_tok,end_tok", _FENCE_FORMATS)
     def test_vc4_deleted_fence_user_owned_not_overwritten(