@jaguilar87/gaia 5.0.7 → 5.0.9

package/gaia/approvals/revert.py

@@ -1,282 +0,0 @@
-"""gaia.approvals.revert -- Inverse-command derivation for approval revert.
-
-Per D14 (plan design decision), revert works by querying EXECUTED events
-for an approval, deriving candidate inverse commands using a hardcoded
-best-effort mapping, and presenting them for user confirmation.
-
-Public API:
-    InverseCommand     -- dataclass for a candidate inverse operation
-    derive_inverse(event) -> InverseCommand | None
-    derive_inverses_for_approval(approval_id, con) -> list[InverseCommand]
-
-The InverseCommand dataclass carries:
-    event_id: int          -- the original EXECUTED event id
-    original_command: str  -- the original command (from payload or metadata)
-    inverse_command: str | None  -- the derived inverse, or None if NOT REVERSIBLE
-    reversible: bool       -- False when no inverse can be derived
-    notes: str             -- human-readable explanation
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import sqlite3
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-
-@dataclass
-class InverseCommand:
-    """Candidate inverse operation for an EXECUTED approval event."""
-
-    event_id: int
-    original_command: str
-    inverse_command: Optional[str]
-    reversible: bool
-    notes: str
-
-
-# ---------------------------------------------------------------------------
-# Hardcoded verb -> inverse mapping (D14)
-# ---------------------------------------------------------------------------
-
-# Pattern-based inverse rules. Each entry is (pattern_re, inverse_template_fn).
-# The pattern is matched against the original command. The template function
-# receives the re.Match object and returns the inverse command string.
-_INVERSE_RULES: list[tuple[re.Pattern, Any]] = []
-
-
-def _rule(pattern: str):
-    """Decorator to register an inverse rule."""
-    def decorator(fn):
-        _INVERSE_RULES.append((re.compile(pattern), fn))
-        return fn
-    return decorator
-
-
-@_rule(r"^gaia\s+brief\s+set-status\s+(\S+)\s+done\s*$")
-def _brief_done_to_pending(m):
-    brief_id = m.group(1)
-    return f"gaia brief set-status {brief_id} pending"
-
-
-@_rule(r"^gaia\s+brief\s+set-status\s+(\S+)\s+active\s*$")
-def _brief_active_to_draft(m):
-    brief_id = m.group(1)
-    return f"gaia brief set-status {brief_id} draft"
-
-
-@_rule(r"^gaia\s+brief\s+set-status\s+(\S+)\s+pending\s*$")
-def _brief_pending_to_draft(m):
-    brief_id = m.group(1)
-    return f"gaia brief set-status {brief_id} draft"
-
-
-@_rule(r"^git\s+branch\s+(\S+)\s*$")
-def _git_branch_create_to_delete(m):
-    branch = m.group(1)
-    if branch.startswith("-"):
-        # Already a delete flag -- not a create
-        return None
-    return f"git branch -D {branch}"
-
-
-@_rule(r"^git\s+branch\s+-[bB]\s+(\S+)\s*$")
-def _git_branch_b_to_delete(m):
-    branch = m.group(1)
-    return f"git branch -D {branch}"
-
-
-@_rule(r"^rm\s+(.+)\s*$")
-def _rm_not_reversible(_m):
-    # rm has no generic inverse; caller sees NOT REVERSIBLE
-    return None
-
-
-def _derive_from_command_string(command: str) -> InverseCommand | None:
-    """Apply hardcoded rules to a single command string.
-
-    Returns an InverseCommand on the first match, or None when no rule matches.
-    """
-    cmd = command.strip()
-    for pattern, fn in _INVERSE_RULES:
-        m = pattern.match(cmd)
-        if m:
-            inverse = fn(m)
-            if inverse is not None:
-                return InverseCommand(
-                    event_id=0,
-                    original_command=cmd,
-                    inverse_command=inverse,
-                    reversible=True,
-                    notes=f"Derived from pattern: {pattern.pattern}",
-                )
-            else:
-                return InverseCommand(
-                    event_id=0,
-                    original_command=cmd,
-                    inverse_command=None,
-                    reversible=False,
-                    notes="NOT REVERSIBLE -- matched pattern has no safe inverse",
-                )
-    return None
-
-
-def _is_file_create(payload: dict, original_cmd: str) -> bool:
-    """Heuristic: detect if the payload represents a file creation."""
-    commands = payload.get("commands") or []
-    scope = payload.get("scope") or ""
-    # A Write tool on a new path is stored with 'write' or 'create' in operation.
-    operation = (payload.get("operation") or "").lower()
-    if "write" in operation or "create" in operation:
-        return True
-    # If the scope looks like a file path and command is a write-like verb
-    if scope and ("write" in original_cmd.lower() or "create" in original_cmd.lower()):
-        return True
-    return False
-
-
-def derive_inverse(event: Dict[str, Any]) -> InverseCommand:
-    """Derive a candidate inverse command for a single EXECUTED event.
-
-    Best-effort approach per D14:
-    - Tries hardcoded verb patterns first.
-    - Detects file create -> suggests rm <path>.
-    - Falls through to "NOT REVERSIBLE" with original command for reference.
-
-    Args:
-        event: A dict from store.replay_for_approval() representing an
-            EXECUTED event row. Must have 'id', 'payload_json', and
-            optionally 'metadata_json'.
-
-    Returns:
-        InverseCommand with reversible=True if an inverse was derived, or
-        reversible=False with inverse_command=None and a "NOT REVERSIBLE"
-        note.
-    """
-    event_id = event.get("id", 0)
-    payload_json = event.get("payload_json") or ""
-    metadata_json = event.get("metadata_json") or ""
-
-    payload: dict = {}
-    if payload_json:
-        try:
-            payload = json.loads(payload_json)
-        except (json.JSONDecodeError, TypeError):
-            pass
-
-    metadata: dict = {}
-    if metadata_json:
-        try:
-            metadata = json.loads(metadata_json)
-        except (json.JSONDecodeError, TypeError):
-            pass
-
-    # Collect commands to try inverting.
-    commands = payload.get("commands") or []
-    exact_content = payload.get("exact_content") or ""
-
-    # Build list of individual command strings to invert.
-    cmd_strings: list[str] = []
-    if commands:
-        cmd_strings = [str(c).strip() for c in commands if c]
-    elif exact_content:
-        # Split newline-separated commands per D13.
-        cmd_strings = [l.strip() for l in exact_content.splitlines() if l.strip()]
-
-    if not cmd_strings:
-        # No commands found -- check operation field.
-        operation = payload.get("operation") or ""
-        if operation:
-            cmd_strings = [operation]
-
-    if not cmd_strings:
-        return InverseCommand(
-            event_id=event_id,
-            original_command="(no command recorded)",
-            inverse_command=None,
-            reversible=False,
-            notes="NOT REVERSIBLE -- no command data found in event payload",
-        )
-
-    # For multi-command events, try to invert each command.
-    # If ALL have inverses, return a compound inverse. If any fails, NOT REVERSIBLE.
-    inverses = []
-    original_summary = "; ".join(cmd_strings)
-
-    for cmd in cmd_strings:
-        result = _derive_from_command_string(cmd)
-        if result is None:
-            # No rule matched -- check for file create heuristic.
-            scope = payload.get("scope") or ""
-            if scope and _is_file_create(payload, cmd):
-                # Suggest rm <scope> as the inverse.
-                scope_path = scope.strip()
-                inverses.append(
-                    InverseCommand(
-                        event_id=event_id,
-                        original_command=cmd,
-                        inverse_command=f"rm {scope_path}",
-                        reversible=True,
-                        notes=f"File create detected -- inverse is rm {scope_path} (requires confirm)",
-                    )
-                )
-            else:
-                return InverseCommand(
-                    event_id=event_id,
-                    original_command=original_summary,
-                    inverse_command=None,
-                    reversible=False,
-                    notes=f"NOT REVERSIBLE -- no inverse rule matches: {cmd!r}",
-                )
-        else:
-            result.event_id = event_id
-            inverses.append(result)
-
-    if len(inverses) == 1:
-        return inverses[0]
-
-    # Multiple inverses -- combine into a compound inverse.
-    combined_inverse = " && ".join(ic.inverse_command for ic in inverses if ic.inverse_command)
-    combined_notes = "; ".join(ic.notes for ic in inverses)
-    return InverseCommand(
-        event_id=event_id,
-        original_command=original_summary,
-        inverse_command=combined_inverse if combined_inverse else None,
-        reversible=bool(combined_inverse),
-        notes=combined_notes,
-    )
-
-
-def derive_inverses_for_approval(
-    approval_id: str,
-    con: sqlite3.Connection,
-) -> List[InverseCommand]:
-    """Return a list of InverseCommand for all EXECUTED events of an approval.
-
-    Args:
-        approval_id: The P-{uuid4} approval identifier.
-        con: An open sqlite3.Connection.
-
-    Returns:
-        List of InverseCommand, one per EXECUTED event, in insertion order.
-        Empty list if no EXECUTED events exist.
-    """
-    cur = con.execute(
-        "SELECT id, payload_json, metadata_json FROM approval_events "
-        "WHERE approval_id = ? AND event_type = 'EXECUTED' "
-        "ORDER BY id ASC",
-        (approval_id,),
-    )
-    rows = cur.fetchall()
-    result = []
-    for row in rows:
-        event = {
-            "id": row[0],
-            "payload_json": row[1],
-            "metadata_json": row[2],
-        }
-        result.append(derive_inverse(event))
-    return result

package/tools/context/deep_merge.py

@@ -1,159 +0,0 @@
-"""
-Deep merge utility for project-context.json updates.
-
-Merges two dicts recursively following the gaia-ops merge decision tree:
-  1. Key missing in current  -> ADD
-  2. Both values are dicts   -> RECURSE (deep merge)
-  3. Both values are lists   -> UNION (primitives: sorted set union;
-                                       dicts with "name": merge by name;
-                                       other dicts: concatenate + deduplicate)
-  4. Both values are scalars -> OVERWRITE (new replaces old)
-  5. Type mismatch           -> OVERWRITE with warning
-
-No-Delete Policy: keys in current but NOT in update are always preserved.
-"""
-
-import copy
-import json
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-def deep_merge(current: dict, update: dict) -> tuple[dict, dict]:
-    """Merge *update* into *current* returning ``(merged, diff)``.
-
-    Parameters
-    ----------
-    current:
-        The existing data (will NOT be mutated).
-    update:
-        New data to merge on top of *current*.
-
-    Returns
-    -------
-    tuple[dict, dict]
-        ``merged`` – the result of the merge.
-        ``diff``   – audit trail recording changes (``{key: {old, new}}``).
-    """
-    merged = copy.deepcopy(current)
-    diff: dict = {}
-
-    for key, new_value in update.items():
-        if key not in merged:
-            # Rule 1: ADD missing key
-            merged[key] = copy.deepcopy(new_value)
-            continue
-
-        old_value = merged[key]
-
-        # Rule 2: Both dicts -> recurse
-        if isinstance(old_value, dict) and isinstance(new_value, dict):
-            sub_merged, sub_diff = deep_merge(old_value, new_value)
-            merged[key] = sub_merged
-            if sub_diff:
-                diff[key] = sub_diff
-            continue
-
-        # Rule 3: Both lists -> union strategy
-        if isinstance(old_value, list) and isinstance(new_value, list):
-            merged_list = _merge_lists(old_value, new_value)
-            if merged_list != old_value:
-                diff[key] = {"old": old_value, "new": merged_list}
-            merged[key] = merged_list
-            continue
-
-        # Rule 5: Type mismatch -> overwrite with warning
-        if type(old_value) is not type(new_value):
-            logger.warning(
-                "Type mismatch for key '%s': %s -> %s. New value wins.",
-                key,
-                type(old_value).__name__,
-                type(new_value).__name__,
-            )
-            diff[key] = {"old": old_value, "new": new_value}
-            merged[key] = copy.deepcopy(new_value)
-            continue
-
-        # Rule 4: Both scalars -> overwrite
-        if old_value != new_value:
-            diff[key] = {"old": old_value, "new": new_value}
-        merged[key] = copy.deepcopy(new_value)
-
-    return merged, diff
-
-
-# ---------------------------------------------------------------------------
-# List merge helpers
-# ---------------------------------------------------------------------------
-
-def _merge_lists(current: list, update: list) -> list:
-    """Merge two lists following the union strategy.
-
-    a) All items are primitives (str, int, float, bool) -> sorted set union.
-    b) Items are dicts with a ``"name"`` key -> merge by name, preserve missing.
-    c) Otherwise -> concatenate, deduplicate by JSON equality.
-    """
-    if _all_primitives(current) and _all_primitives(update):
-        return sorted(set(current) | set(update))
-
-    if _all_dicts_with_name(current) and _all_dicts_with_name(update):
-        return _merge_named_dicts(current, update)
-
-    # Fallback: concatenate + deduplicate by JSON equality
-    return _concat_deduplicate(current, update)
-
-
-def _all_primitives(items: list) -> bool:
-    """Return True if every item is a primitive (str, int, float, bool)."""
-    return all(isinstance(i, (str, int, float, bool)) for i in items)
-
-
-def _all_dicts_with_name(items: list) -> bool:
-    """Return True if every item is a dict containing a ``"name"`` key."""
-    return bool(items) and all(
-        isinstance(i, dict) and "name" in i for i in items
-    )
-
-
-def _merge_named_dicts(current: list[dict], update: list[dict]) -> list[dict]:
-    """Merge lists of dicts by their ``"name"`` field.
-
-    - Matching names: deep-merge the dict fields.
-    - Names only in current: preserved (no-delete).
-    - Names only in update: appended.
-    """
-    result_by_name: dict[str, dict] = {}
-    order: list[str] = []
-
-    # Seed with current entries (preserves order + no-delete)
-    for item in current:
-        name = item["name"]
-        result_by_name[name] = copy.deepcopy(item)
-        order.append(name)
-
-    # Merge / add from update
-    for item in update:
-        name = item["name"]
-        if name in result_by_name:
-            merged_item, _ = deep_merge(result_by_name[name], item)
-            result_by_name[name] = merged_item
-        else:
-            result_by_name[name] = copy.deepcopy(item)
-            order.append(name)
-
-    return [result_by_name[n] for n in order]
-
-
-def _concat_deduplicate(current: list, update: list) -> list:
-    """Concatenate two lists, deduplicating by JSON equality."""
-    seen: list[str] = []
-    result: list = []
-
-    for item in current + update:
-        serialized = json.dumps(item, sort_keys=True)
-        if serialized not in seen:
-            seen.append(serialized)
-            result.append(copy.deepcopy(item))
-
-    return result

package/tools/migration/migrate_04_harness_events.py

@@ -1,132 +0,0 @@
-#!/usr/bin/env python3
-"""
-migrate_04_harness_events.py
-
-Convierte events.jsonl -> archivo SQL con INSERT batched.
-
-Reglas:
-  - Solo I/O sobre filesystem.
-  - NO importa sqlite3.
-  - `id` es AUTOINCREMENT en la tabla; NO lo insertamos.
-  - `payload` = json.dumps(record) entero -- preserva todos los campos.
-  - Idempotencia: harness_events NO tiene UNIQUE constraint útil.
-    Aplicar una sola vez. Re-ejecuciones requieren DELETE WHERE project=...
-
-CLI args (parametrización cross-workspace):
-  --project   workspace name (default: 'me')
-  --src       path al events.jsonl (default: ws/me)
-  --out       path al SQL de salida (default: /tmp/migrate_04_harness_events.sql)
-  --fragment  emite solo INSERTs (sin BEGIN/COMMIT)
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-DEFAULT_PROJECT = "me"
-DEFAULT_SRC = Path("/home/jorge/ws/me/.claude/events/events.jsonl")
-DEFAULT_OUT = Path("/tmp/migrate_04_harness_events.sql")
-BATCH_SIZE = 200
-
-COLUMNS = ["project", "ts", "type", "source", "agent", "result", "severity", "payload"]
-
-
-def sql_quote(value) -> str:
-    if value is None:
-        return "NULL"
-    if isinstance(value, bool):
-        return "1" if value else "0"
-    if isinstance(value, (int, float)):
-        if isinstance(value, float) and (value != value or value in (float("inf"), float("-inf"))):
-            return "NULL"
-        return str(value)
-    s = str(value)
-    return "'" + s.replace("'", "''") + "'"
-
-
-def extract_row(record: dict, project: str) -> dict:
-    return {
-        "project": project,
-        "ts": record.get("ts"),
-        "type": record.get("type"),
-        "source": record.get("source"),
-        "agent": record.get("agent"),
-        "result": record.get("result"),
-        "severity": record.get("severity"),
-        "payload": json.dumps(record, ensure_ascii=False, separators=(",", ":")),
-    }
-
-
-def row_values_sql(row: dict) -> str:
-    return "(" + ",".join(sql_quote(row.get(col)) for col in COLUMNS) + ")"
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="Generate INSERT SQL for harness_events table.")
-    parser.add_argument("--project", default=DEFAULT_PROJECT)
-    parser.add_argument("--src", default=str(DEFAULT_SRC), help="path to events.jsonl")
-    parser.add_argument("--out", default=str(DEFAULT_OUT))
-    parser.add_argument("--fragment", action="store_true")
-    args = parser.parse_args()
-
-    project = args.project
-    src = Path(args.src)
-    out = Path(args.out)
-    fragment = args.fragment
-
-    if not src.exists():
-        print(f"[migrate_04:{project}] ERROR: source not found: {src}", file=sys.stderr)
-        return 1
-
-    rows = []
-    skipped = 0
-    total_lines = 0
-
-    with src.open("r", encoding="utf-8") as f:
-        for line in f:
-            total_lines += 1
-            s = line.strip()
-            if not s:
-                continue
-            try:
-                rec = json.loads(s)
-            except json.JSONDecodeError:
-                skipped += 1
-                continue
-            if not rec.get("ts") or not rec.get("type"):
-                skipped += 1
-                continue
-            rows.append(extract_row(rec, project))
-
-    cols_csv = ",".join(COLUMNS)
-    insert_prefix = f"INSERT INTO harness_events ({cols_csv}) VALUES\n"
-
-    with out.open("w", encoding="utf-8") as fh:
-        fh.write(f"-- Generated by migrate_04_harness_events.py\n")
-        fh.write(f"-- Project: {project}\n")
-        fh.write(f"-- Source: {src}\n")
-        fh.write(f"-- Total source lines: {total_lines}\n")
-        fh.write(f"-- Records to insert:  {len(rows)}\n")
-        fh.write(f"-- Skipped:            {skipped}\n")
-        fh.write("--\n")
-        fh.write("-- WARNING: harness_events sin PK natural; aplicar 2 veces duplica filas.\n")
-        if not fragment:
-            fh.write("BEGIN TRANSACTION;\n")
-
-        for i in range(0, len(rows), BATCH_SIZE):
-            batch = rows[i : i + BATCH_SIZE]
-            fh.write(insert_prefix)
-            fh.write(",\n".join(row_values_sql(r) for r in batch))
-            fh.write(";\n")
-
-        if not fragment:
-            fh.write("COMMIT;\n")
-
-    print(f"[migrate_04:{project}] wrote {out} ({len(rows)} rows, {skipped} skipped)")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/tools/migration/migrate_04_harness_events.sh

@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-# migrate_04_harness_events.sh
-# Wrapper: regenera el .sql desde events.jsonl y lo carga en ~/.gaia/gaia.db.
-#
-# OJO: harness_events no tiene PK natural. Re-ejecutar este wrapper duplica
-# filas. Si necesitas re-ejecutar limpio, primero elimina las filas con:
-#   sqlite3 ~/.gaia/gaia.db "DELETE FROM harness_events WHERE project='me';"
-set -euo pipefail
-
-HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PY_SCRIPT="${HERE}/migrate_04_harness_events.py"
-SQL_FILE="/tmp/migrate_04_harness_events.sql"
-DB_PATH="${HOME}/.gaia/gaia.db"
-
-# Paso 1: regenerar el .sql.
-echo "[migrate_04] regenerando ${SQL_FILE} ..."
-python3 "${PY_SCRIPT}"
-
-# Paso 2: aplicar el SQL (interceptado por el hook).
-echo "[migrate_04] aplicando ${SQL_FILE} en ${DB_PATH} ..."
-sqlite3 "${DB_PATH}" < "${SQL_FILE}"
-
-echo "[migrate_04] OK"