@xenonbyte/req-2-plan 0.4.2 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xenonbyte/req-2-plan",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Requirement-to-PLAN workflow CLI and agent integration installer.",
   "bin": {
     "r2p": "bin/r2p.js"

package/tools/workflow_cli/context_pack.py

@@ -6,6 +6,11 @@ import os
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
 
+try:
+    import tomllib  # Python 3.11+
+except ImportError:  # pragma: no cover - older interpreters: pyproject parsing degrades to a no-op
+    tomllib = None
+
 from tools.workflow_cli.repo_baseline import SKIP_DIRS, scan_repo_baseline
 
 _CONFIG_NAMES = {
@@ -39,6 +44,41 @@ def _append_npm_dependencies(pack: ProjectContextPack, dependencies: object, *,
         pack.dependencies.append(dep)
 
 
+def _append_pyproject_facts(pack: ProjectContextPack, repo_path: Path) -> None:
+    """Collect PEP 621 [project] dependencies and a pytest signal from pyproject.toml.
+
+    Poetry/PDM private tables are out of scope; without tomllib (Python < 3.11)
+    this is a no-op, matching the pack's best-effort scan semantics."""
+    pyproject = repo_path / "pyproject.toml"
+    if tomllib is None or not pyproject.exists():
+        return
+    try:
+        data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+    except (tomllib.TOMLDecodeError, OSError, UnicodeDecodeError):
+        return
+    project = data.get("project")
+    project = project if isinstance(project, dict) else {}
+    raw_deps = project.get("dependencies")
+    specs = [s for s in raw_deps if isinstance(s, str)] if isinstance(raw_deps, list) else []
+    optional = project.get("optional-dependencies")
+    optional_specs: list[str] = []
+    if isinstance(optional, dict):
+        for group in optional.values():
+            if isinstance(group, list):
+                optional_specs.extend(s for s in group if isinstance(s, str))
+    if (specs or optional_specs) and "pip" not in pack.package_managers:
+        pack.package_managers.append("pip")
+    for spec in specs:
+        pack.dependencies.append({"name": spec, "version": "", "ecosystem": "pip"})
+    for spec in optional_specs:
+        pack.dependencies.append({"name": spec, "version": "", "ecosystem": "pip", "dev": True})
+    tool = data.get("tool")
+    has_pytest_config = isinstance(tool, dict) and isinstance(tool.get("pytest"), dict)
+    mentions_pytest = any(s.lower().startswith("pytest") for s in specs + optional_specs)
+    if (has_pytest_config or mentions_pytest) and "python -m pytest" not in pack.test_commands:
+        pack.test_commands.append("python -m pytest")
+
+
 def build_context_pack(repo_path: Path) -> ProjectContextPack:
     repo_path = Path(repo_path).resolve()
     baseline = scan_repo_baseline(repo_path)
@@ -68,6 +108,8 @@ def build_context_pack(repo_path: Path) -> ProjectContextPack:
         if not pack.test_commands:
             pack.test_commands.append("python -m pytest")
 
+    _append_pyproject_facts(pack, repo_path)
+
     for root, dirs, files in os.walk(repo_path):
         dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith(".")]
         rel_root = Path(root).relative_to(repo_path)

package/tools/workflow_cli/gates.py

@@ -431,13 +431,14 @@ def _check_plan_context_pack(run_dir: Path) -> list[str]:
 
 def _check_plan_file_refs(run_dir: Path, content: str) -> list[str]:
     """Hard-check Files paths against the Context Pack repo_root. create-type tasks
-    are exempt; the part after '::' (a symbol) is advisory and not checked (no AST pack yet)."""
+    must target paths that do not exist yet (R19); the part after '::' (a symbol) is
+    advisory and not checked (no AST pack yet)."""
     repo_root = _context_pack_repo_root(run_dir)
     if repo_root is None:
         return []  # no usable ground truth; standard tier blocks via _check_plan_context_pack
     issues: list[str] = []
     for body in _iter_plan_task_bodies(content):
-        skip_missing_path = _normalized_change_type(_task_change_type(body)) == "create"
+        is_create = _normalized_change_type(_task_change_type(body)) == "create"
         files_field = _plan_task_field_body(body, "Files")
         for path_part in _plan_task_file_paths(files_field):
             path = Path(path_part)
@@ -453,11 +454,18 @@ def _check_plan_file_refs(run_dir: Path, content: str) -> list[str]:
                 )
                 continue
             if not resolved.exists():
-                if not skip_missing_path:
+                if not is_create:
                     issues.append(
                         f"PLAN-TASK Files references missing path {path_part!r} "
                         "(mark the task 'Change Type: create' if it is a new file)."
                     )
+            elif is_create:
+                # R19: create must not silently mean "overwrite an existing file".
+                issues.append(
+                    f"PLAN-TASK Files references path {path_part!r} that already exists "
+                    "under 'Change Type: create'; use 'modify' for existing files or "
+                    "split the task."
+                )
     return issues
 
 

package/tools/workflow_cli/install.py

@@ -10,6 +10,8 @@ import json
 import hashlib
 import shutil
 import shlex
+import stat
+from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
@@ -40,6 +42,21 @@ KNOWN_OBSOLETE_PLATFORM_TARGETS = {
 }
 
 
+@dataclass
+class _FileSnapshot:
+    path: Path
+    content: bytes
+    mode: int
+
+
+@dataclass
+class _InstallSnapshot:
+    manifest_path: Path
+    manifest_text: str
+    files: list[_FileSnapshot]
+    backup_files: list[_FileSnapshot]
+
+
 def _now_ts() -> str:
     """Return UTC timestamp for backup filenames."""
     return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S")
@@ -84,17 +101,24 @@ class InstallService:
             )
 
         manifest_path = self._manifest_path(platform)
-        if manifest_path.exists():
-            self.uninstall(platform)
+        backup_dir = self.manifest_root / "install" / "backups" / platform
+        self._validate_install_plan(platform, manifest_path, backup_dir)
+        prior_install = (
+            self._capture_install_snapshot(platform, manifest_path)
+            if manifest_path.exists()
+            else None
+        )
 
         installed_paths: list[str] = []
         backups: list[dict[str, str]] = []
         written: list[Path] = []
-        backup_dir = self.manifest_root / "install" / "backups" / platform
+        manifest_written = False
 
         try:
+            if prior_install is not None:
+                self.uninstall(platform)
+
             bin_dir = self.manifest_root / "bin"
-            bin_dir.mkdir(parents=True, exist_ok=True)
 
             # Copy bin scripts
             for src in sorted(self.repo_root.glob("tools/r2p-*")):
@@ -104,7 +128,7 @@ class InstallService:
                         src.read_text(encoding="utf-8"),
                         self.repo_root,
                     )
-                    _safe_write(
+                    self._write_managed_file(
                         dest, content, backups, installed_paths, written, backup_dir
                     )
                     shutil.copymode(str(src), str(dest))
@@ -120,7 +144,7 @@ class InstallService:
                 skill_src = template_dir / "SKILL.md"
                 skill_dest = platform_home / "skills" / "r2p" / "SKILL.md"
                 content = _render(skill_src.read_text(), R2P_VERSION, str(bin_dir))
-                _safe_write(
+                self._write_managed_file(
                     skill_dest, content, backups, installed_paths, written, backup_dir
                 )
 
@@ -129,7 +153,7 @@ class InstallService:
                 for src in sorted(cmd_dir.glob("r2p-*.md")):
                     dest = platform_home / "commands" / src.name
                     content = _render(src.read_text(), R2P_VERSION, str(bin_dir))
-                    _safe_write(
+                    self._write_managed_file(
                         dest, content, backups, installed_paths, written, backup_dir
                     )
 
@@ -139,7 +163,7 @@ class InstallService:
                 for src in sorted(skills_dir.glob("r2p-*/SKILL.md")):
                     dest = platform_home / "skills" / src.parent.name / "SKILL.md"
                     content = _render(src.read_text(), R2P_VERSION, str(bin_dir))
-                    _safe_write(
+                    self._write_managed_file(
                         dest, content, backups, installed_paths, written, backup_dir
                     )
 
@@ -149,7 +173,7 @@ class InstallService:
                 for src in sorted(cmd_dir.glob("r2p-*.toml")):
                     dest = platform_home / "commands" / src.name
                     content = _render(src.read_text(), R2P_VERSION, str(bin_dir))
-                    _safe_write(
+                    self._write_managed_file(
                         dest, content, backups, installed_paths, written, backup_dir
                     )
 
@@ -162,8 +186,10 @@ class InstallService:
                 "r2p_version": R2P_VERSION,
                 "schema_version": SCHEMA_VERSION,
             }
+            self._validate_install_path(manifest_path, field="manifest")
             manifest_path.parent.mkdir(parents=True, exist_ok=True)
             manifest_path.write_text(_dump_manifest(manifest), encoding="utf-8")
+            manifest_written = True
 
             # Remove obsolete managed shared wrappers (e.g. a 0.1.2 r2p-adapt) that
             # are no longer part of the current template set, across all manifests.
@@ -172,6 +198,12 @@ class InstallService:
 
         except Exception:
             # Rollback: remove written files, restore backups
+            if manifest_written:
+                # A pre-existing manifest is impossible here: a fresh install
+                # never had one, and a reinstall's uninstall already removed
+                # it — prior-manifest restoration is owned by
+                # _restore_install_snapshot below.
+                manifest_path.unlink(missing_ok=True)
             for path in reversed(written):
                 try:
                     path.unlink(missing_ok=True)
@@ -183,6 +215,9 @@ class InstallService:
                 if backup_path.exists():
                     target_path.parent.mkdir(parents=True, exist_ok=True)
                     shutil.copy2(str(backup_path), str(target_path))
+                    backup_path.unlink(missing_ok=True)
+            if prior_install is not None:
+                self._restore_install_snapshot(prior_install)
             raise
 
     def uninstall(self, platform: str) -> dict:
@@ -488,31 +523,39 @@ class InstallService:
         if platform not in SUPPORTED_PLATFORMS:
             raise ValueError(f"unsafe_manifest: unsupported_platform {platform!r}")
 
+        targets = set(self._install_targets(platform))
+        bin_dir = self.manifest_root / "bin"
+        targets.update(bin_dir / name for name in KNOWN_OBSOLETE_SHARED_WRAPPERS)
+
+        platform_home = self.platform_homes[platform]
+        for parts in KNOWN_OBSOLETE_PLATFORM_TARGETS.get(platform, ()):
+            targets.add(platform_home.joinpath(*parts))
+
+        return targets
+
+    def _install_targets(self, platform: str) -> list[Path]:
         bin_dir = self.manifest_root / "bin"
-        targets = {
+        targets = [
             bin_dir / src.name
             for src in sorted(self.repo_root.glob("tools/r2p-*"))
             if src.is_file()
-        }
-        targets.update(bin_dir / name for name in KNOWN_OBSOLETE_SHARED_WRAPPERS)
+        ]
 
         template_dir = (
             self.repo_root / "tools" / "workflow_cli" / "agent_templates" / platform
         )
         platform_home = self.platform_homes[platform]
-        for parts in KNOWN_OBSOLETE_PLATFORM_TARGETS.get(platform, ()):
-            targets.add(platform_home.joinpath(*parts))
 
         if platform == "claude":
-            targets.add(platform_home / "skills" / "r2p" / "SKILL.md")
+            targets.append(platform_home / "skills" / "r2p" / "SKILL.md")
             for src in sorted((template_dir / "commands").glob("r2p-*.md")):
-                targets.add(platform_home / "commands" / src.name)
+                targets.append(platform_home / "commands" / src.name)
         elif platform == "codex":
             for src in sorted((template_dir / "skills").glob("r2p-*/SKILL.md")):
-                targets.add(platform_home / "skills" / src.parent.name / "SKILL.md")
+                targets.append(platform_home / "skills" / src.parent.name / "SKILL.md")
         elif platform == "gemini":
             for src in sorted((template_dir / "commands").glob("r2p-*.toml")):
-                targets.add(platform_home / "commands" / src.name)
+                targets.append(platform_home / "commands" / src.name)
 
         return targets
 
@@ -703,6 +746,99 @@ class InstallService:
         except (OSError, UnicodeDecodeError, ValueError):
             return None
 
+    def _capture_install_snapshot(
+        self,
+        platform: str,
+        manifest_path: Path,
+    ) -> _InstallSnapshot:
+        manifest = _load_manifest(manifest_path)
+        self._validate_manifest_for_uninstall(platform, manifest)
+        files: list[_FileSnapshot] = []
+        backup_files: list[_FileSnapshot] = []
+
+        for path_str in manifest.get("installed_paths", []):
+            snapshot = self._snapshot_file(Path(path_str))
+            if snapshot is not None:
+                files.append(snapshot)
+
+        for backup in manifest.get("backups", []):
+            snapshot = self._snapshot_file(Path(backup["backup"]))
+            if snapshot is not None:
+                backup_files.append(snapshot)
+
+        return _InstallSnapshot(
+            manifest_path=manifest_path,
+            manifest_text=manifest_path.read_text(encoding="utf-8"),
+            files=files,
+            backup_files=backup_files,
+        )
+
+    def _snapshot_file(self, path: Path) -> _FileSnapshot | None:
+        if not path.is_file():
+            return None
+        return _FileSnapshot(
+            path=path,
+            content=path.read_bytes(),
+            mode=stat.S_IMODE(path.stat().st_mode),
+        )
+
+    def _restore_install_snapshot(self, snapshot: _InstallSnapshot) -> None:
+        for file_snapshot in snapshot.files + snapshot.backup_files:
+            file_snapshot.path.parent.mkdir(parents=True, exist_ok=True)
+            file_snapshot.path.write_bytes(file_snapshot.content)
+            try:
+                file_snapshot.path.chmod(file_snapshot.mode)
+            except OSError:
+                pass
+        snapshot.manifest_path.parent.mkdir(parents=True, exist_ok=True)
+        snapshot.manifest_path.write_text(snapshot.manifest_text, encoding="utf-8")
+
+    def _validate_install_path(self, path: Path, *, field: str) -> None:
+        """Reject install writes that would follow untrusted symlinks."""
+        if path.is_symlink():
+            raise ValueError(f"unsafe_install: {field}_is_symlink")
+        normalized = self._normalize_without_resolving_symlinks(path)
+        try:
+            self._reject_symlinked_ancestors(normalized, field=field)
+        except ValueError as exc:
+            raise ValueError(
+                str(exc).replace("unsafe_manifest:", "unsafe_install:", 1)
+            ) from exc
+
+    def _validate_install_backup_dir(self, backup_dir: Path) -> None:
+        probe = backup_dir / "__r2p_probe__"
+        normalized = self._normalize_without_resolving_symlinks(probe)
+        try:
+            self._reject_symlinked_ancestors(normalized, field="backup_dir")
+        except ValueError as exc:
+            raise ValueError(
+                str(exc).replace("unsafe_manifest:", "unsafe_install:", 1)
+            ) from exc
+
+    def _validate_install_plan(
+        self,
+        platform: str,
+        manifest_path: Path,
+        backup_dir: Path,
+    ) -> None:
+        for target in self._install_targets(platform):
+            self._validate_install_path(target, field="install_destination")
+        self._validate_install_path(manifest_path, field="manifest")
+        self._validate_install_backup_dir(backup_dir)
+
+    def _write_managed_file(
+        self,
+        dest: Path,
+        content: str,
+        backups: list[dict[str, str]],
+        installed_paths: list[str],
+        written: list[Path],
+        backup_dir: Path,
+    ) -> None:
+        self._validate_install_path(dest, field="install_destination")
+        self._validate_install_backup_dir(backup_dir)
+        _safe_write(dest, content, backups, installed_paths, written, backup_dir)
+
 
 # ---------------------------------------------------------------------------
 # Internal helpers

package/tools/workflow_cli/version.py

@@ -1 +1 @@
-R2P_VERSION = "0.4.2"
+R2P_VERSION = "0.4.4"