mapify-cli 3.30.0__tar.gz → 3.30.1__tar.gz

{mapify_cli-3.30.0 → mapify_cli-3.30.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mapify-cli
-Version: 3.30.0
+Version: 3.30.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.30.0 → mapify_cli-3.30.1}/pyproject.toml

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

{mapify_cli-3.30.0 → mapify_cli-3.30.1}/src/mapify_cli/__init__.py

@@ -23,7 +23,7 @@ Or install globally:
     mapify check
 """
 
-__version__ = "3.30.0"
+__version__ = "3.30.1"
 
 # 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
@@ -1495,13 +1495,18 @@ def init(
             raise typer.Exit(1) from exc
 
     if provider == "codex":
-        # Codex provider: install .agents/.codex files + .map/scripts/ (skip-if-exists)
+        # Codex provider: install .agents/.codex files + .map/scripts/
+        # (.map/scripts policy is documented on create_codex_files)
         from mapify_cli.delivery.providers import CodexProvider
 
         tracker.add("create-codex", "Create Codex files")
         tracker.start("create-codex")
         codex_provider = CodexProvider()
-        counts = codex_provider.install(project_path)
+        try:
+            counts = codex_provider.install(project_path)
+        except RuntimeError as exc:
+            console.print(f"[red]Error:[/red] {exc}")
+            raise typer.Exit(1) from exc
         total = sum(counts.values())
         tracker.complete("create-codex", f"{total} files")
 

{mapify_cli-3.30.0 → mapify_cli-3.30.1}/src/mapify_cli/auto_update.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import tomllib
 from dataclasses import dataclass, replace
 from datetime import UTC, datetime
 from enum import StrEnum
@@ -45,6 +46,33 @@ _DEFAULT_INSTALL_EXACT_VERSION = install_exact_version
 LOCK_TIMEOUT_SECONDS = 0.0
 REFRESH_BARRIER_TIMEOUT_SECONDS = 0.0
 
+FRAMEWORK_SOURCE_REPO_MESSAGE = (
+    "This project is the mapify-cli source repository; its provider trees are "
+    "rendered from src/mapify_cli/templates_src/ by `make render-templates` "
+    "and are never installed by the updater."
+)
+
+
+def is_framework_source_repo(project_path: Path) -> bool:
+    """Return True when ``project_path`` is the mapify-cli source repository.
+
+    The framework repo's generated trees (``.claude/``, ``.codex/``,
+    ``.agents/``, ``.map/scripts/``) are fence-free renders of
+    ``src/mapify_cli/templates_src/``. Running the provider refresh there
+    re-installs the shipped templates with fences and ``MAP-MANAGED`` headers
+    over 100+ tracked files and leaves a ``.bak`` beside each (#462).
+    """
+    project_path = Path(project_path)
+    if not (project_path / "src" / "mapify_cli" / "templates_src").is_dir():
+        return False
+    try:
+        with (project_path / "pyproject.toml").open("rb") as handle:
+            pyproject = tomllib.load(handle)
+    except (OSError, tomllib.TOMLDecodeError):
+        return False
+    project = pyproject.get("project")
+    return isinstance(project, dict) and project.get("name") == "mapify-cli"
+
 
 class UpdateMode(StrEnum):
     """Whether an update check was initiated by a skill or explicitly by a user."""
@@ -714,6 +742,17 @@ def check_and_update(
 
     completed_result: UpdateResult | None = None
     try:
+        if is_framework_source_repo(project_path):
+            # Intent: the framework repo is never an install target. Its
+            # generated trees are the rendered source of truth (#462).
+            if mode is UpdateMode.AUTOMATIC:
+                return UpdateResult(
+                    UpdateStatus.SKIPPED,
+                    current_version,
+                    message=FRAMEWORK_SOURCE_REPO_MESSAGE,
+                )
+            return _error(current_version, FRAMEWORK_SOURCE_REPO_MESSAGE)
+
         if (
             mode is UpdateMode.AUTOMATIC
             and not load_map_config(project_path).updates_auto

{mapify_cli-3.30.0 → mapify_cli-3.30.1}/src/mapify_cli/delivery/codex_copier.py

@@ -15,6 +15,9 @@ from pathlib import Path
 from typing import Any
 
 from mapify_cli.delivery.file_copier import (
+    _IGNORED_TEMPLATE_NAMES,
+    _IGNORED_TEMPLATE_SUFFIXES,
+    _copy_map_path,
     _extract_requires_block,
     _get_version,
     _load_template_skill_catalog,
@@ -65,14 +68,12 @@ def _copy_tree(
     """
     count = 0
     dst_dir.mkdir(parents=True, exist_ok=True)
-    ignored_names = {"__pycache__", ".DS_Store"}
-    ignored_suffixes = {".pyc", ".pyo"}
     for src_file in src_dir.rglob("*"):
         if not src_file.is_file():
             continue
-        if any(part in ignored_names for part in src_file.parts):
+        if any(part in _IGNORED_TEMPLATE_NAMES for part in src_file.parts):
             continue
-        if src_file.suffix in ignored_suffixes:
+        if src_file.suffix in _IGNORED_TEMPLATE_SUFFIXES:
             continue
         rel = src_file.relative_to(src_dir)
         target = dst_dir / rel
@@ -90,6 +91,20 @@ def _copy_tree(
 _EXEC_SUFFIXES = frozenset((".py", ".sh"))
 
 
+def _first_symlink_component(root: Path, dest: Path) -> Path | None:
+    """Return the first component of *dest* below *root* that is a symlink.
+
+    Checked component by component (``.map``, then ``.map/scripts``) so a
+    linked ancestor cannot redirect the runtime install outside *root*.
+    """
+    current = root
+    for part in dest.relative_to(root).parts:
+        current = current / part
+        if current.is_symlink():
+            return current
+    return None
+
+
 def _managed_codex_hook_names(hooks_dir_src: Path) -> frozenset[str]:
     """Names of the scripts mapify ships into .codex/hooks/ — the MAP-owned set."""
     if not hooks_dir_src.is_dir():
@@ -250,9 +265,11 @@ def create_codex_files(project_path: Path) -> dict[str, int]:
     Watched files (skills, agents, config, AGENTS.md, hooks) are installed
     fence-aware so a re-install preserves any user content below the fence;
     hooks.json is merged without MAP metadata because Codex validates top-level
-    keys strictly; .map/scripts is MAP-owned (fenced=False, skip-if-exists).
+    keys strictly; .map/scripts is MAP-owned and refreshed exactly like the
+    Claude provider's tree (``_copy_map_path``: shipped scripts are overwritten,
+    a drifted managed copy is backed up to ``.bak.<ts>`` first, project-added
+    files are left alone).
 
-    Skips .map/scripts/ if the directory already exists.
     Never creates or modifies any .claude/ path.
 
     Args:
@@ -264,6 +281,8 @@ def create_codex_files(project_path: Path) -> dict[str, int]:
     """
     templates_dir = get_templates_dir()
     codex_templates = templates_dir / "codex"
+    map_scripts_src = templates_dir / "map" / "scripts"
+    map_scripts_dst = project_path / ".map" / "scripts"
 
     empty_counts: dict[str, int] = {
         "skills": 0,
@@ -277,6 +296,14 @@ def create_codex_files(project_path: Path) -> dict[str, int]:
     if not codex_templates.exists():
         return empty_counts
 
+    if map_scripts_src.exists():
+        link = _first_symlink_component(project_path, map_scripts_dst)
+        if link is not None:
+            raise RuntimeError(
+                f"{link} is a symbolic link; mapify will not install .map/scripts "
+                "through it. Replace the link with a real directory and re-run."
+            )
+
     counts: dict[str, int] = dict(empty_counts)
     codex_dir = project_path / ".codex"
     agents_dir = project_path / ".agents"
@@ -391,19 +418,11 @@ def create_codex_files(project_path: Path) -> dict[str, int]:
             counts["docs"] += 1
 
     # ------------------------------------------------------------------
-    # 6. .map/scripts/ — skip-if-exists (do not overwrite user scripts)
-    #    MAP-owned: install fenced=False (no fence) when absent.
+    # 6. .map/scripts/ — MAP-owned, same policy as the Claude provider:
+    #    shipped scripts are refreshed (.bak.<ts> on drift), project-added
+    #    files are never touched.
     # ------------------------------------------------------------------
-    map_scripts_dst = project_path / ".map" / "scripts"
-    if not map_scripts_dst.exists():
-        map_scripts_src = templates_dir / "map" / "scripts"
-        if map_scripts_src.exists():
-            counts["scripts"] = _copy_tree(
-                map_scripts_src,
-                map_scripts_dst,
-                version,
-                fenced=False,
-                executable_suffixes=_EXEC_SUFFIXES,
-            )
+    if map_scripts_src.exists():
+        counts["scripts"] = _copy_map_path(map_scripts_src, map_scripts_dst, version)
 
     return counts

{mapify_cli-3.30.0 → mapify_cli-3.30.1}/src/mapify_cli/templates/map/scripts/map_step_runner.py

@@ -5277,7 +5277,7 @@ def ensure_human_artifacts(branch: str | None = None) -> dict:
         if path.exists():
             existing.append(file_name)
             continue
-        path.write_text(content, encoding="utf-8")
+        _write_text_file(path, content)
         created.append(file_name)
 
     return {
@@ -9577,9 +9577,7 @@ def ensure_active_issues_file(branch: str | None = None) -> dict:
     issues_file = branch_dir / "active-issues.json"
     if not issues_file.exists():
         payload = {**ACTIVE_ISSUES_DEFAULT, "updated_at": datetime.now(UTC).isoformat()}
-        issues_file.write_text(
-            json.dumps(payload, indent=2, ensure_ascii=True) + "\n", encoding="utf-8"
-        )
+        _write_json_file(issues_file, payload)
         return {"status": "success", "path": str(issues_file), "created": True}
     return {"status": "success", "path": str(issues_file), "created": False}
 
@@ -12836,10 +12834,7 @@ def ensure_known_issues_file(branch: str | None = None) -> dict:
     branch_dir.mkdir(parents=True, exist_ok=True)
     issues_file = branch_dir / "known-issues.json"
     if not issues_file.exists():
-        issues_file.write_text(
-            json.dumps(KNOWN_ISSUES_DEFAULT, indent=2, ensure_ascii=True) + "\n",
-            encoding="utf-8",
-        )
+        _write_json_file(issues_file, KNOWN_ISSUES_DEFAULT)
         return {"status": "success", "path": str(issues_file), "created": True}
     return {"status": "success", "path": str(issues_file), "created": False}
 
@@ -12853,7 +12848,8 @@ def add_known_issue(
     """Append a known issue / accepted blocker entry."""
     ensure_known_issues_file(branch)
     issues_file = get_branch_dir(branch) / "known-issues.json"
-    payload = json.loads(issues_file.read_text(encoding="utf-8"))
+    raw = _read_json_file(issues_file)
+    payload: dict[str, Any] = dict(raw) if raw is not None else dict(KNOWN_ISSUES_DEFAULT)
     payload.setdefault("issues", []).append(
         {
             "title": title,

{mapify_cli-3.30.0 → mapify_cli-3.30.1}/src/mapify_cli/templates_src/map/scripts/map_step_runner.py.jinja

@@ -5252,7 +5252,7 @@ def ensure_human_artifacts(branch: str | None = None) -> dict:
         if path.exists():
             existing.append(file_name)
             continue
-        path.write_text(content, encoding="utf-8")
+        _write_text_file(path, content)
         created.append(file_name)
 
     return {
@@ -9552,9 +9552,7 @@ def ensure_active_issues_file(branch: str | None = None) -> dict:
     issues_file = branch_dir / "active-issues.json"
     if not issues_file.exists():
         payload = {**ACTIVE_ISSUES_DEFAULT, "updated_at": datetime.now(UTC).isoformat()}
-        issues_file.write_text(
-            json.dumps(payload, indent=2, ensure_ascii=True) + "\n", encoding="utf-8"
-        )
+        _write_json_file(issues_file, payload)
         return {"status": "success", "path": str(issues_file), "created": True}
     return {"status": "success", "path": str(issues_file), "created": False}
 
@@ -12811,10 +12809,7 @@ def ensure_known_issues_file(branch: str | None = None) -> dict:
     branch_dir.mkdir(parents=True, exist_ok=True)
     issues_file = branch_dir / "known-issues.json"
     if not issues_file.exists():
-        issues_file.write_text(
-            json.dumps(KNOWN_ISSUES_DEFAULT, indent=2, ensure_ascii=True) + "\n",
-            encoding="utf-8",
-        )
+        _write_json_file(issues_file, KNOWN_ISSUES_DEFAULT)
         return {"status": "success", "path": str(issues_file), "created": True}
     return {"status": "success", "path": str(issues_file), "created": False}
 
@@ -12828,7 +12823,8 @@ def add_known_issue(
     """Append a known issue / accepted blocker entry."""
     ensure_known_issues_file(branch)
     issues_file = get_branch_dir(branch) / "known-issues.json"
-    payload = json.loads(issues_file.read_text(encoding="utf-8"))
+    raw = _read_json_file(issues_file)
+    payload: dict[str, Any] = dict(raw) if raw is not None else dict(KNOWN_ISSUES_DEFAULT)
     payload.setdefault("issues", []).append(
         {
             "title": title,

{mapify_cli-3.30.0 → mapify_cli-3.30.1}/tests/test_auto_update.py

@@ -39,6 +39,7 @@ from mapify_cli.update_state import (
 from mapify_cli.update_versions import ReleaseHighlights, StableVersion, VersionTargets
 
 NOW = datetime(2026, 8, 13, 12, 0, tzinfo=UTC)
+REPO_ROOT = Path(__file__).resolve().parents[1]
 
 
 @pytest.fixture(autouse=True)
@@ -441,6 +442,91 @@ def test_source_install_is_silent_skip_automatically_and_error_manually(
     assert "owner-managed" in manual.message
 
 
+def _write_framework_fingerprint(project: Path, *, name: str = "mapify-cli") -> None:
+    (project / "src" / "mapify_cli" / "templates_src").mkdir(parents=True)
+    (project / "pyproject.toml").write_text(
+        f'[project]\nname = "{name}"\nversion = "0.0.0"\n', encoding="utf-8"
+    )
+
+
+def test_framework_source_repo_is_silent_skip_automatically_and_error_manually(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """#462: never install the shipped templates over the rendered dev trees."""
+    _write_framework_fingerprint(tmp_path)
+    fetch = Mock(side_effect=AssertionError("network must not run"))
+    monkeypatch.setattr(auto_update, "fetch_version_targets", fetch)
+    refresh = Mock(side_effect=AssertionError("provider refresh must not run"))
+    monkeypatch.setattr(auto_update, "refresh_installed_providers", refresh)
+
+    automatic = check_and_update(tmp_path, "3.29.1", UpdateMode.AUTOMATIC, now=NOW)
+    manual = check_and_update(tmp_path, "3.29.1", UpdateMode.MANUAL, now=NOW)
+
+    assert automatic.status is UpdateStatus.SKIPPED
+    assert automatic.message == auto_update.FRAMEWORK_SOURCE_REPO_MESSAGE
+    assert manual.status is UpdateStatus.ERROR
+    assert manual.message == auto_update.FRAMEWORK_SOURCE_REPO_MESSAGE
+    assert "make render-templates" in manual.message
+    fetch.assert_not_called()
+    refresh.assert_not_called()
+    # No update state, lock, or provider file is written in either mode.
+    assert not (tmp_path / ".map").exists()
+
+
+def test_framework_source_repo_skip_ignores_config_and_throttle(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    _write_framework_fingerprint(tmp_path)
+    _write_config(tmp_path, "updates.auto: true\n")
+    write_update_state(tmp_path, UpdateState(last_attempt_at="2026-08-01T00:00:00Z"))
+    attempt_before = read_update_state(tmp_path).last_attempt_at
+    fetch = Mock(side_effect=AssertionError("network must not run"))
+    monkeypatch.setattr(auto_update, "fetch_version_targets", fetch)
+
+    result = check_and_update(tmp_path, "3.29.1", UpdateMode.AUTOMATIC, now=NOW)
+
+    assert result.status is UpdateStatus.SKIPPED
+    assert result.message == auto_update.FRAMEWORK_SOURCE_REPO_MESSAGE
+    assert read_update_state(tmp_path).last_attempt_at == attempt_before
+    fetch.assert_not_called()
+
+
+def test_this_repository_is_the_framework_source_repo(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """The real dev checkout must trip the guard, not only a synthetic fixture."""
+    assert auto_update.is_framework_source_repo(REPO_ROOT)
+    fetch = Mock(side_effect=AssertionError("network must not run"))
+    monkeypatch.setattr(auto_update, "fetch_version_targets", fetch)
+
+    result = check_and_update(REPO_ROOT, "3.29.1", UpdateMode.AUTOMATIC, now=NOW)
+
+    assert result.status is UpdateStatus.SKIPPED
+    assert result.message == auto_update.FRAMEWORK_SOURCE_REPO_MESSAGE
+    fetch.assert_not_called()
+
+
+@pytest.mark.parametrize(
+    ("pyproject", "templates_src"),
+    [
+        pytest.param('[project]\nname = "mapify-cli"\n', False, id="no-templates-src"),
+        pytest.param('[project]\nname = "other-package"\n', True, id="other-name"),
+        pytest.param('[tool.x]\nname = "mapify-cli"\n', True, id="no-project-table"),
+        pytest.param("name = [unterminated\n", True, id="malformed-toml"),
+        pytest.param(None, True, id="no-pyproject"),
+    ],
+)
+def test_partial_framework_fingerprint_is_an_ordinary_project(
+    tmp_path: Path, pyproject: str | None, templates_src: bool
+) -> None:
+    if pyproject is not None:
+        (tmp_path / "pyproject.toml").write_text(pyproject, encoding="utf-8")
+    if templates_src:
+        (tmp_path / "src" / "mapify_cli" / "templates_src").mkdir(parents=True)
+
+    assert not auto_update.is_framework_source_repo(tmp_path)
+
+
 def test_lock_contention_skips_automatic_and_errors_manual(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:

{mapify_cli-3.30.0 → mapify_cli-3.30.1}/tests/test_map_step_runner.py

@@ -4868,6 +4868,18 @@ class TestEnsureActiveIssuesFile:
 
         assert issues_file.read_text(encoding="utf-8") == custom_content
 
+    def test_corrupt_file_is_not_written_partially(self, branch_workspace):
+        """File creation is atomic: reader never sees partial JSON (#464)."""
+        issues_file = branch_workspace / "active-issues.json"
+        # simulate a corrupt file left by a crash mid-write
+        issues_file.write_text("{corrupt", encoding="utf-8")
+
+        # ensure_active_issues_file skips creation if file exists (even corrupt)
+        result = map_step_runner.ensure_active_issues_file()
+        assert result["created"] is False
+        # the corrupt file is NOT overwritten by ensure_*; replace_active_issues must be used
+        assert issues_file.read_text(encoding="utf-8") == "{corrupt"
+
 
 # ---------------------------------------------------------------------------
 # replace_active_issues — focused unit tests
@@ -5185,6 +5197,14 @@ class TestEnsureKnownIssuesFile:
 
         assert issues_file.read_text(encoding="utf-8") == original
 
+    def test_new_file_write_is_valid_json(self, branch_workspace):
+        """ensure_known_issues_file writes valid JSON (atomic write, #464)."""
+        result = map_step_runner.ensure_known_issues_file()
+
+        assert result["created"] is True
+        data = json.loads((branch_workspace / "known-issues.json").read_text(encoding="utf-8"))
+        assert data == {"issues": []}
+
 
 # ---------------------------------------------------------------------------
 # add_known_issue — focused unit tests
@@ -5244,6 +5264,20 @@ class TestAddKnownIssue:
         )
         assert data["issues"][0]["status"] == "accepted"
 
+    def test_add_known_issue_recovers_from_corrupt_file(self, branch_workspace):
+        """add_known_issue does not crash on corrupt known-issues.json (#464)."""
+        issues_file = branch_workspace / "known-issues.json"
+        # simulate a file left corrupt by a crash mid-write
+        issues_file.write_text("{corrupt json", encoding="utf-8")
+
+        # must not raise JSONDecodeError; should recover to an empty issues list
+        result = map_step_runner.add_known_issue("Post-crash issue", "accepted")
+
+        assert result["status"] == "success"
+        assert result["count"] == 1
+        data = json.loads(issues_file.read_text(encoding="utf-8"))
+        assert data["issues"][0]["title"] == "Post-crash issue"
+
 
 # ---------------------------------------------------------------------------
 # run_test_gate — focused unit tests