@trac3er/oh-my-god 2.1.0 → 2.1.4

package/runtime/interaction_journal.py

@@ -6,10 +6,22 @@ import json
 import os
 from pathlib import Path
 import shutil
+import subprocess
 import uuid
 from typing import Any, cast
 
 from runtime.repro_pack import build_repro_pack
+from runtime.rollback_manifest import (
+    classify_side_effect,
+    create_rollback_manifest,
+    record_compensating_action,
+    record_local_restore,
+    record_side_effect,
+    write_rollback_manifest,
+)
+
+
+_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit"})
 
 
 class InteractionJournal:
@@ -19,33 +31,43 @@ class InteractionJournal:
     def __init__(self, project_dir: str):
         self.project_dir = Path(project_dir).resolve()
         self.journal_dir = self.project_dir / ".omg" / "state" / "interaction_journal"
+        self._pending_step_id = ""
 
     def record_step(self, tool: str, metadata: dict[str, object]) -> dict[str, object]:
         step_id = self._new_step_id()
+        self._pending_step_id = step_id
+        normalized_tool = tool.lower().strip()
+        run_id = str(metadata.get("run_id", "")).strip()
+
         rollback_mode = "unsupported"
-        if tool in {"write", "edit"}:
+        if normalized_tool in _MUTATION_TOOLS:
             rollback_mode = self._rollback_mode()
         checkpoint_ref = self._checkpoint_reference(step_id)
 
         shadow_manifest_path = ""
-        if tool in {"write", "edit"}:
+        if normalized_tool in _MUTATION_TOOLS:
             shadow_manifest_path = self._capture_shadow_metadata(metadata)
 
-        repro_pointer = self._build_repro_pointer(step_id)
+        repro_pointer = self._build_repro_pointer(run_id)
+        side_effect_scope = str(metadata.get("side_effect_scope", "")).strip()
 
         payload: dict[str, object] = {
             "schema": "InteractionJournalStep",
             "schema_version": "1.0.0",
             "step_id": step_id,
             "recorded_at": self._utc_now(),
-            "tool": tool,
+            "tool": normalized_tool,
+            "run_id": run_id,
             "metadata": dict(metadata),
             "rollback_mode": rollback_mode,
             "checkpoint_ref": checkpoint_ref,
             "shadow_manifest_path": shadow_manifest_path,
             "repro_pointer": repro_pointer,
         }
+        if side_effect_scope:
+            payload["side_effect_scope"] = side_effect_scope
         self._write_step(step_id, payload)
+        self._pending_step_id = ""
 
         return {
             "step_id": step_id,
@@ -54,7 +76,7 @@ class InteractionJournal:
             "repro_pointer": repro_pointer,
         }
 
-    def undo(self, step_id: str) -> dict[str, str]:
+    def undo(self, step_id: str, run_id: str | None = None) -> dict[str, object]:
         target_step_id = step_id.strip() or self._latest_step_id()
         if not target_step_id:
             return {"status": "noop", "reason": "no journal entries"}
@@ -66,20 +88,106 @@ class InteractionJournal:
         tool = str(step.get("tool", "")).strip()
         metadata = step.get("metadata")
         metadata_obj = cast(dict[str, object], metadata) if isinstance(metadata, dict) else {}
-
-        if tool not in {"write", "edit"}:
-            if self._is_external_side_effect(tool, metadata_obj):
-                return {"status": "unsupported", "reason": "external side effect scope"}
-            return {"status": "unsupported", "reason": "external side effect scope"}
-
-        shadow_manifest_path = str(step.get("shadow_manifest_path", "")).strip()
-        if not shadow_manifest_path:
-            return {"status": "noop", "reason": "missing shadow manifest"}
-
-        restore_result = self._restore_shadow_entry(shadow_manifest_path)
-        if restore_result:
-            return {"status": "ok", "reason": "shadow restore applied"}
-        return {"status": "noop", "reason": "shadow restore unavailable"}
+        manifest_run_id = (
+            (run_id or "").strip()
+            or str(step.get("run_id", "")).strip()
+            or self._derive_run_id(step)
+        )
+        rollback_manifest = create_rollback_manifest(manifest_run_id, target_step_id)
+        side_effect = classify_side_effect(tool, metadata_obj)
+        record_side_effect(rollback_manifest, side_effect)
+        compensating_actions = self._collect_compensating_actions(tool, metadata_obj, side_effect)
+
+        local_restore: dict[str, object] = {"restored": [], "failed": [], "reason": "shadow restore unavailable"}
+        if tool in _MUTATION_TOOLS:
+            shadow_manifest_path = str(step.get("shadow_manifest_path", "")).strip()
+            if shadow_manifest_path:
+                local_restore = self._restore_shadow_entry(target_step_id, shadow_manifest_path)
+                restored_value = local_restore.get("restored")
+                restored_items = cast(list[object], restored_value) if isinstance(restored_value, list) else []
+                for file_path in restored_items:
+                    record_local_restore(rollback_manifest, str(file_path), "restored")
+                failed_value = local_restore.get("failed")
+                failed_items = cast(list[object], failed_value) if isinstance(failed_value, list) else []
+                for failure in failed_items:
+                    if not isinstance(failure, dict):
+                        continue
+                    record_local_restore(
+                        rollback_manifest,
+                        str(failure.get("file", "")),
+                        "failed",
+                        str(failure.get("reason", "")),
+                    )
+            else:
+                local_restore = {"restored": [], "failed": [], "reason": "missing shadow manifest"}
+        elif not compensating_actions:
+            return self._finalize_undo(
+                rollback_manifest,
+                {
+                    "status": "unsupported",
+                    "reason": "external side effect scope",
+                },
+            )
+
+        snapshot_restore = self._restore_checkpoint(step.get("checkpoint_ref"))
+
+        action_results = self._execute_compensating_actions(compensating_actions)
+        for action_result in action_results:
+            record_compensating_action(
+                rollback_manifest,
+                str(action_result.get("effect_type", "external")),
+                str(action_result.get("action", "")),
+                str(action_result.get("command", "")),
+                status=str(action_result.get("status", "failed")),
+            )
+
+        failed_actions = [row for row in action_results if str(row.get("status", "")) == "failed"]
+        restored_files = cast(list[object], local_restore.get("restored", []))
+        failed_restores = cast(list[object], local_restore.get("failed", []))
+        restored_snapshot = snapshot_restore.get("status") == "restored"
+        if failed_actions:
+            return self._finalize_undo(
+                rollback_manifest,
+                {
+                    "status": "rollback_failed",
+                    "reason": "compensating actions failed",
+                    "failed_actions": failed_actions,
+                    "local_restore": local_restore,
+                    "snapshot_restore": snapshot_restore,
+                },
+            )
+
+        if failed_restores:
+            return self._finalize_undo(
+                rollback_manifest,
+                {
+                    "status": "partial",
+                    "reason": str(local_restore.get("reason", "shadow restore partial")),
+                    "local_restore": local_restore,
+                    "snapshot_restore": snapshot_restore,
+                },
+            )
+
+        if restored_files or restored_snapshot or action_results:
+            return self._finalize_undo(
+                rollback_manifest,
+                {
+                    "status": "ok",
+                    "reason": "rollback complete",
+                    "local_restore": local_restore,
+                    "snapshot_restore": snapshot_restore,
+                    "compensating_actions": action_results,
+                },
+            )
+        return self._finalize_undo(
+            rollback_manifest,
+            {
+                "status": "noop",
+                "reason": str(local_restore.get("reason", "shadow restore unavailable")),
+                "local_restore": local_restore,
+                "snapshot_restore": snapshot_restore,
+            },
+        )
 
     def _write_step(self, step_id: str, payload: dict[str, object]) -> None:
         self.journal_dir.mkdir(parents=True, exist_ok=True)
@@ -119,38 +227,60 @@ class InteractionJournal:
                 return ""
 
             run_id = cast(str, begin_shadow_run(str(self.project_dir), metadata={"source": "interaction_journal"}))
-            _ = record_shadow_write(str(self.project_dir), run_id, str(file_path), source="interaction_journal")
+            _ = record_shadow_write(
+                str(self.project_dir),
+                run_id,
+                str(file_path),
+                source="interaction_journal",
+                step_id=self._pending_step_id,
+            )
             manifest_path = self.project_dir / ".omg" / "shadow" / run_id / "manifest.json"
             return str(manifest_path)
         except Exception:
             return ""
 
-    def _restore_shadow_entry(self, shadow_manifest_path: str) -> bool:
+    def _restore_shadow_entry(self, step_id: str, shadow_manifest_path: str) -> dict[str, object]:
+        manifest_path = Path(shadow_manifest_path)
+        run_id = manifest_path.parent.name if manifest_path.name == "manifest.json" else ""
+        if not run_id:
+            return {"restored": [], "failed": [], "reason": "invalid shadow manifest path"}
+
         try:
             module = importlib.import_module("hooks.shadow_manager")
         except Exception:
-            return False
+            return {"restored": [], "failed": [], "reason": "shadow module unavailable"}
 
         restore_fn = getattr(module, "restore_shadow_entry", None)
         if not callable(restore_fn):
-            return False
-
-        call_variants: list[tuple[tuple[Any, ...], dict[str, Any]]] = [
-            ((), {"project_dir": str(self.project_dir), "manifest_path": shadow_manifest_path}),
-            ((), {"project_dir": str(self.project_dir), "shadow_manifest_path": shadow_manifest_path}),
-            ((), {"manifest_path": shadow_manifest_path}),
-            ((str(self.project_dir), shadow_manifest_path), {}),
-            ((shadow_manifest_path,), {}),
-        ]
-        for args, kwargs in call_variants:
-            try:
-                _ = restore_fn(*args, **kwargs)
-                return True
-            except TypeError:
-                continue
-            except Exception:
-                return False
-        return False
+            return {"restored": [], "failed": [], "reason": "restore helper unavailable"}
+
+        try:
+            result = restore_fn(str(self.project_dir), run_id, step_id)
+        except Exception:
+            return {"restored": [], "failed": [], "reason": "shadow restore unavailable"}
+
+        if not isinstance(result, dict):
+            return {"restored": [], "failed": [], "reason": "shadow restore unavailable"}
+
+        restored = result.get("restored") if isinstance(result.get("restored"), list) else []
+        failed = result.get("failed") if isinstance(result.get("failed"), list) else []
+        reason = str(result.get("reason", "shadow restore unavailable"))
+        return {"restored": restored, "failed": failed, "reason": reason}
+
+    def _derive_run_id(self, step: dict[str, object]) -> str:
+        manifest_path = str(step.get("shadow_manifest_path", "")).strip()
+        manifest = Path(manifest_path)
+        if manifest.name == "manifest.json" and manifest.parent.name:
+            return manifest.parent.name
+
+        checkpoint_ref = step.get("checkpoint_ref")
+        if isinstance(checkpoint_ref, dict):
+            snapshot = checkpoint_ref.get("snapshot")
+            if isinstance(snapshot, dict):
+                snapshot_id = snapshot.get("id")
+                if isinstance(snapshot_id, str) and snapshot_id.strip():
+                    return snapshot_id.strip()
+        return "unknown"
 
     def _checkpoint_reference(self, step_id: str) -> dict[str, object] | None:
         try:
@@ -176,9 +306,12 @@ class InteractionJournal:
         except Exception:
             return None
 
-    def _build_repro_pointer(self, step_id: str) -> str | None:
+    def _build_repro_pointer(self, run_id: str) -> str | None:
+        normalized_run_id = run_id.strip()
+        if not normalized_run_id:
+            return None
         try:
-            result = build_repro_pack(str(self.project_dir), step_id)
+            result = build_repro_pack(str(self.project_dir), normalized_run_id)
         except Exception:
             return None
         if result.get("status") != "ok":
@@ -211,6 +344,149 @@ class InteractionJournal:
                 return True
         return False
 
+    def _collect_compensating_actions(
+        self,
+        tool: str,
+        metadata: dict[str, object],
+        side_effect: dict[str, object],
+    ) -> list[dict[str, str]]:
+        action_rows: list[dict[str, str]] = []
+
+        declared = metadata.get("compensating_action")
+        if isinstance(declared, dict):
+            action = str(declared.get("action", "")).strip()
+            command = str(declared.get("command", "")).strip()
+            if action and command:
+                action_rows.append(
+                    {
+                        "effect_type": str(side_effect.get("category", "external")),
+                        "action": action,
+                        "command": command,
+                    }
+                )
+
+        declared_list = metadata.get("compensating_actions")
+        if isinstance(declared_list, list):
+            for item in declared_list:
+                if not isinstance(item, dict):
+                    continue
+                action = str(item.get("action", "")).strip()
+                command = str(item.get("command", "")).strip()
+                if not action or not command:
+                    continue
+                action_rows.append(
+                    {
+                        "effect_type": str(item.get("effect_type", side_effect.get("category", "external"))),
+                        "action": action,
+                        "command": command,
+                    }
+                )
+
+        if tool == "bash" and not action_rows:
+            default_command = str(side_effect.get("default_compensation", "")).strip()
+            if default_command:
+                action_rows.append(
+                    {
+                        "effect_type": str(side_effect.get("category", "external")),
+                        "action": "default compensation",
+                        "command": default_command,
+                    }
+                )
+        return action_rows
+
+    def _restore_checkpoint(self, checkpoint_ref: object) -> dict[str, object]:
+        if not isinstance(checkpoint_ref, dict):
+            return {"status": "skipped", "reason": "checkpoint unavailable"}
+
+        snapshot = checkpoint_ref.get("snapshot")
+        if not isinstance(snapshot, dict):
+            return {"status": "skipped", "reason": "snapshot unavailable"}
+        snapshot_id = str(snapshot.get("id", "")).strip()
+        if not snapshot_id:
+            return {"status": "skipped", "reason": "snapshot unavailable"}
+
+        try:
+            module = importlib.import_module("tools.session_snapshot")
+        except Exception:
+            return {"status": "failed", "reason": "snapshot module unavailable", "snapshot_id": snapshot_id}
+
+        restore_snapshot = getattr(module, "restore_snapshot", None)
+        if not callable(restore_snapshot):
+            return {"status": "failed", "reason": "snapshot restore unavailable", "snapshot_id": snapshot_id}
+
+        try:
+            restored = bool(restore_snapshot(snapshot_id, state_dir=str(self.project_dir / ".omg" / "state")))
+        except Exception:
+            return {"status": "failed", "reason": "snapshot restore unavailable", "snapshot_id": snapshot_id}
+        if restored:
+            return {"status": "restored", "reason": "snapshot restore applied", "snapshot_id": snapshot_id}
+        return {"status": "failed", "reason": "snapshot not found", "snapshot_id": snapshot_id}
+
+    def _execute_compensating_actions(self, actions: list[dict[str, str]]) -> list[dict[str, object]]:
+        results: list[dict[str, object]] = []
+        for action in actions:
+            command = str(action.get("command", "")).strip()
+            if not command:
+                results.append(
+                    {
+                        "effect_type": str(action.get("effect_type", "external")),
+                        "action": str(action.get("action", "")),
+                        "command": command,
+                        "status": "failed",
+                        "reason": "missing command",
+                    }
+                )
+                continue
+            try:
+                completed = subprocess.run(
+                    command,
+                    cwd=str(self.project_dir),
+                    shell=True,
+                    check=False,
+                    capture_output=True,
+                    text=True,
+                )
+            except Exception as exc:
+                results.append(
+                    {
+                        "effect_type": str(action.get("effect_type", "external")),
+                        "action": str(action.get("action", "")),
+                        "command": command,
+                        "status": "failed",
+                        "reason": f"execution error: {exc}",
+                    }
+                )
+                continue
+
+            if completed.returncode == 0:
+                results.append(
+                    {
+                        "effect_type": str(action.get("effect_type", "external")),
+                        "action": str(action.get("action", "")),
+                        "command": command,
+                        "status": "succeeded",
+                    }
+                )
+                continue
+
+            results.append(
+                {
+                    "effect_type": str(action.get("effect_type", "external")),
+                    "action": str(action.get("action", "")),
+                    "command": command,
+                    "status": "failed",
+                    "reason": (completed.stderr or completed.stdout or "command failed").strip() or "command failed",
+                    "exit_code": completed.returncode,
+                }
+            )
+        return results
+
+    def _finalize_undo(self, rollback_manifest: dict[str, object], result: dict[str, object]) -> dict[str, object]:
+        manifest_path = write_rollback_manifest(str(self.project_dir), rollback_manifest)
+        merged = dict(result)
+        merged["manifest_path"] = str(Path(manifest_path).relative_to(self.project_dir)).replace("\\", "/")
+        return merged
+
     def _rollback_mode(self) -> str:
         if shutil.which("git"):
             return "branch+journal+repro"

package/runtime/memory_store.py

@@ -9,12 +9,21 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
+from runtime.profile_io import classify_preference_section, is_destructive_preference
+
 
 class MemoryStoreFullError(Exception):
     """Raised when adding to a store that has reached the 10,000 item limit."""
 
 
 _MAX_ITEMS = 10_000
+_PREFERENCE_SIGNAL_LIMIT = 12
+_PREFERENCE_VALUE_MAX = 160
+_PREFERENCE_ALLOWED_FIELDS = (
+    "preferences.architecture_requests",
+    "preferences.constraints.",
+    "user_vector.tags",
+)
 
 # Type alias for memory items — JSON-like dicts.
 _Item = dict[str, Any]  # pyright: ignore[reportExplicitAny]
@@ -207,9 +216,133 @@ class MemoryStore:
         _ = os.replace(tmp_path, path)
 
 
+def project_preference_signals(
+    project_dir: str,
+    *,
+    store_path: str | None = None,
+    max_signals: int = _PREFERENCE_SIGNAL_LIMIT,
+) -> list[dict[str, Any]]:
+    """Return bounded preference signals scoped to *project_dir*."""
+    canonical_project = os.path.realpath(project_dir)
+    if not canonical_project:
+        return []
+
+    limit = max(1, min(int(max_signals), _PREFERENCE_SIGNAL_LIMIT))
+    store = MemoryStore(store_path=store_path)
+    items = list(reversed(store.list_all()))
+    results: list[dict[str, Any]] = []
+    seen: set[tuple[str, str, str, str]] = set()
+
+    for item in items:
+        signal = _extract_project_signal(item, canonical_project)
+        if signal is None:
+            continue
+
+        signature = (
+            str(signal.get("field", "")),
+            str(signal.get("value", "")),
+            str(signal.get("source", "")),
+            str(signal.get("run_id", "")),
+        )
+        if signature in seen:
+            continue
+        seen.add(signature)
+        results.append(signal)
+        if len(results) >= limit:
+            break
+
+    return results
+
+
+def _extract_project_signal(item: _Item, canonical_project: str) -> dict[str, Any] | None:
+    raw_content = item.get("content")
+    if not isinstance(raw_content, str):
+        return None
+
+    try:
+        payload = json.loads(raw_content)
+    except (TypeError, ValueError, json.JSONDecodeError):
+        return None
+    if not isinstance(payload, dict):
+        return None
+
+    scope = _extract_scope(payload, item)
+    if os.path.realpath(scope) != canonical_project:
+        return None
+
+    field = str(payload.get("field", "")).strip()
+    if not _is_allowed_field(field):
+        return None
+
+    value = _normalize_value(payload.get("value"))
+    if not value:
+        return None
+
+    source = str(payload.get("source", "inferred_observation")).strip().lower() or "inferred_observation"
+    confidence = _clamp_confidence(payload.get("confidence"))
+    contradicted = bool(payload.get("contradicted") is True)
+
+    section = classify_preference_section(field, value)
+    destructive = is_destructive_preference(field, value)
+
+    signal: dict[str, Any] = {
+        "field": field,
+        "value": value,
+        "source": source,
+        "confidence": confidence,
+        "project_scope": canonical_project,
+        "run_id": str(payload.get("run_id", "")).strip(),
+        "updated_at": str(payload.get("updated_at", item.get("updated_at", ""))).strip(),
+        "contradicted": contradicted,
+        "section": section,
+        "destructive": destructive,
+    }
+    return signal
+
+
+def _extract_scope(payload: dict[str, Any], item: _Item) -> str:
+    scope = str(payload.get("project_scope", "")).strip()
+    if scope:
+        return scope
+    tags = item.get("tags", [])
+    if isinstance(tags, list):
+        for tag in tags:
+            text = str(tag)
+            if text.startswith("project_scope:"):
+                return text.split(":", 1)[1].strip()
+    return ""
+
+
+def _is_allowed_field(field: str) -> bool:
+    if field == "preferences.architecture_requests":
+        return True
+    if field == "user_vector.tags":
+        return True
+    return field.startswith("preferences.constraints.")
+
+
+def _normalize_value(raw: Any) -> str:
+    text = " ".join(str(raw).strip().split())
+    if not text:
+        return ""
+    return text[:_PREFERENCE_VALUE_MAX]
+
+
+def _clamp_confidence(raw: Any) -> float:
+    try:
+        score = float(raw)
+    except (TypeError, ValueError):
+        score = 0.0
+    if score < 0.0:
+        return 0.0
+    if score > 1.0:
+        return 1.0
+    return round(score, 3)
+
+
 def _utc_now_iso() -> str:
     """Return current UTC time as ISO 8601 string."""
     return datetime.now(timezone.utc).isoformat()
 
 
-__all__ = ["MemoryStore", "MemoryStoreFullError"]
+__all__ = ["MemoryStore", "MemoryStoreFullError", "project_preference_signals"]