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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "mapify-cli"
-version = "3.12.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.12.0 → mapify_cli-3.12.1}/src/mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.12.0"
+__version__ = "3.12.1"
 
 import os
 import subprocess

{mapify_cli-3.12.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.12.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(