feat(cli): phase 18 - reintegrate patch proposal engine

Author: hrabanazviking

mythic_vibe_cli/app.py

@@ -941,6 +941,14 @@ def _help(text: str) -> str:
         help="Baseline git ref (e.g. v1.2.3 or a sha) to compare against HEAD",
     )
     add_runtime_options(rollback, json_output=True)
+    # Phase 18: Reintegrate Patch Proposal Engine
+    patch = sub.add_parser("patch", help=_help("Manage patch proposals"))
+    patch_sub = patch.add_subparsers(dest="patch_command", required=True)
+    patch_propose = patch_sub.add_parser("propose", help=_help("Propose a safe file patch"))
+    patch_propose.add_argument("--file", required=True, help="Target file to patch")
+    patch_propose.add_argument("--content", required=True, help="Proposed file content")
+    patch_propose.add_argument("--path", default=".", help="Project directory (default: current directory)")
+    add_runtime_options(patch_propose, json_output=True)
 
     # PH-11 Slice 11.7: `mythic-vibe security audit`.
     security = sub.add_parser(

mythic_vibe_cli/commands.py

@@ -4390,6 +4390,42 @@ def cmd_docker_dispatch(args: argparse.Namespace) -> int:
     return USER_INPUT_ERROR
 
 
+def cmd_patch_propose(args: argparse.Namespace) -> int:
+    from .patch.manager import PatchManager
+    
+    root = Path(getattr(args, "path", ".")).resolve()
+    target_file = getattr(args, "file", "")
+    content = getattr(args, "content", "")
+    
+    if not target_file or not content:
+        write_error("--file and --content are required.")
+        return USER_INPUT_ERROR
+        
+    pm = PatchManager(project_root=root)
+    proposal = pm.propose(target_file, content)
+    
+    payload = {
+        "command": "patch propose",
+        "target_file": proposal.target_file,
+        "status": "staged",
+    }
+    
+    if _flag(args, "json"):
+        write_json(payload)
+        return SUCCESS
+        
+    write_line(f"Patch proposed for {proposal.target_file}. Use `/patch apply` in the companion shell to apply.")
+    return SUCCESS
+
+
+def cmd_patch_dispatch(args: argparse.Namespace) -> int:
+    sub = getattr(args, "patch_command", "")
+    if sub == "propose":
+        return cmd_patch_propose(args)
+    write_error(f"Unknown patch subcommand: {sub!r}")
+    return USER_INPUT_ERROR
+
+
 def cmd_release(args: argparse.Namespace) -> int:
     """PH-12 Slice 12.3 — semver-aware release helper.
 
@@ -7756,6 +7792,7 @@ def cmd_drift(args: argparse.Namespace) -> int:
     "security": cmd_security_dispatch,
     "ci": cmd_ci_dispatch,
     "docker": cmd_docker_dispatch,
+    "patch": cmd_patch_dispatch,
     "release": cmd_release,
     "rollback": cmd_rollback,
     "policy": cmd_policy_dispatch,

mythic_vibe_cli/patch/manager.py

@@ -7,6 +7,7 @@
 
 from __future__ import annotations
 
+import json
 import difflib
 from dataclasses import dataclass
 from pathlib import Path
@@ -32,16 +33,56 @@ def generate_diff(self) -> str:
         )
         return "".join(diff)
 
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "target_file": self.target_file,
+            "original_content": self.original_content,
+            "proposed_content": self.proposed_content,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, str]) -> "PatchProposal":
+        return cls(
+            target_file=data["target_file"],
+            original_content=data["original_content"],
+            proposed_content=data["proposed_content"],
+        )
+
 
 class PatchManager:
-    """Manages the active patch proposal in the current session."""
+    """Manages the active patch proposal across the session via file persistence."""
+
+    def __init__(self, project_root: str | Path | None = None) -> None:
+        if project_root is None:
+            self.project_root = Path.cwd()
+        else:
+            self.project_root = Path(project_root).resolve()
+            
+        self.state_file = self.project_root / ".mythic" / "active_patch.json"
+
+    def _read_active(self) -> PatchProposal | None:
+        if not self.state_file.exists():
+            return None
+        try:
+            data = json.loads(self.state_file.read_text(encoding="utf-8"))
+            return PatchProposal.from_dict(data)
+        except Exception:
+            return None
 
-    def __init__(self) -> None:
-        self._active_patch: PatchProposal | None = None
+    def _write_active(self, proposal: PatchProposal | None) -> None:
+        self.state_file.parent.mkdir(parents=True, exist_ok=True)
+        if proposal is None:
+            if self.state_file.exists():
+                self.state_file.unlink()
+        else:
+            self.state_file.write_text(json.dumps(proposal.to_dict(), indent=2), encoding="utf-8")
 
     def propose(self, target_file: str | Path, proposed_content: str) -> PatchProposal:
         """Stages a patch for review."""
-        path = Path(target_file).resolve()
+        path = Path(target_file)
+        if not path.is_absolute():
+            path = self.project_root / path
+        path = path.resolve()
 
         try:
             original_content = path.read_text(encoding="utf-8") if path.exists() else ""
@@ -53,36 +94,38 @@ def propose(self, target_file: str | Path, proposed_content: str) -> PatchPropos
             original_content=original_content,
             proposed_content=proposed_content,
         )
-        self._active_patch = proposal
+        self._write_active(proposal)
         return proposal
 
     def get_active(self) -> PatchProposal | None:
         """Returns the currently active patch proposal, if any."""
-        return self._active_patch
+        return self._read_active()
 
     def apply_active(self) -> bool:
         """Applies the active patch to the file system and clears it."""
-        if not self._active_patch:
+        active = self._read_active()
+        if not active:
             return False
 
-        path = Path(self._active_patch.target_file)
+        path = Path(active.target_file)
         path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_text(self._active_patch.proposed_content, encoding="utf-8")
-        self._active_patch = None
+        path.write_text(active.proposed_content, encoding="utf-8")
+        self._write_active(None)
         return True
 
     def reject_active(self) -> bool:
         """Rejects the active patch and clears it."""
-        if not self._active_patch:
+        if not self._read_active():
             return False
 
-        self._active_patch = None
+        self._write_active(None)
         return True
 
     def get_diff(self) -> str:
         """Returns the unified diff of the active patch."""
-        if not self._active_patch:
+        active = self._read_active()
+        if not active:
             return "No active patch proposal."
-        return self._active_patch.generate_diff()
+        return active.generate_diff()
 
 __all__ = ["PatchProposal", "PatchManager"]

mythic_vibe_cli/repl.py

@@ -364,10 +364,11 @@ def _known_command_names(_main: Callable[[list[str]], int]) -> set[str]:
 2. INSPECT the repository using file and directory search tools if context is missing.
 3. RETRIEVE memory or knowledge if asked.
 4. PROPOSE a structured plan using tools if the task is complex.
-5. EDIT code, run tests, and execute commands to achieve the goal.
+5. EDIT code using the `mythic_vibe_patch` tool with argv `["propose", "--file", "...", "--content", "..."]`. The user will review and apply the patch.
 6. REMEMBER the results of your actions.
 
 Workspace Safety Protocol:
+- Always use the `mythic_vibe_patch` tool to propose code edits. Do NOT expect the user to manually edit files unless specifically requested.
 - Always use `workspace diff` to review your own changes before making a commit.
 - You must ask the user for explicit confirmation before executing `workspace commit` or `workspace push`.