@jaguilar87/gaia-ops 4.4.0 → 4.7.2

package/dist/gaia-ops/hooks/modules/context/compact_context_builder.py

@@ -0,0 +1,215 @@
+"""Compact context builder for post-compaction re-injection.
+
+Builds a lightweight context summary from session data sources.
+Each source is independent and fail-safe.
+"""
+from __future__ import annotations
+
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+
+from ..core.paths import get_plugin_data_dir
+
+logger = logging.getLogger(__name__)
+
+# Defaults
+DEFAULT_MAX_SNAPSHOTS = 5
+DEFAULT_ANOMALY_WINDOW_HOURS = 1
+DEFAULT_MAX_EVENTS = 5
+
+
+def build_compact_context(
+    *,
+    max_snapshots: int = DEFAULT_MAX_SNAPSHOTS,
+    anomaly_window_hours: int = DEFAULT_ANOMALY_WINDOW_HOURS,
+    max_events: int = DEFAULT_MAX_EVENTS,
+) -> str:
+    """Build compact context for post-compaction re-injection.
+
+    Returns a markdown string with 4 blocks:
+    1. Orchestrator identity reminder
+    2. Session activity summary (from run-snapshots.jsonl)
+    3. Active anomalies (from anomalies.jsonl)
+    4. Recent session events (from context.json)
+
+    Each block is independent — if a source fails, the others still produce output.
+    """
+    blocks = []
+
+    # Block 1: Orchestrator identity (always present, static)
+    blocks.append(_build_identity_block())
+
+    # Block 2: Session activity from run-snapshots.jsonl
+    activity = _build_activity_block(max_snapshots)
+    if activity:
+        blocks.append(activity)
+
+    # Block 3: Active anomalies from anomalies.jsonl
+    anomalies = _build_anomalies_block(anomaly_window_hours)
+    if anomalies:
+        blocks.append(anomalies)
+
+    # Block 4: Recent events from context.json
+    events = _build_events_block(max_events)
+    if events:
+        blocks.append(events)
+
+    return "\n\n".join(blocks)
+
+
+def _build_identity_block() -> str:
+    """Static orchestrator identity reminder."""
+    return (
+        "# Post-Compaction Context Refresh\n\n"
+        "You are the orchestrator. Dispatch work via Agent, resume agents via "
+        "SendMessage(to: agentId), get user approval via AskUserQuestion. "
+        "Never execute infrastructure commands directly.\n"
+        "Agents: cloud-troubleshooter, gitops-operator, terraform-architect, "
+        "devops-developer, speckit-planner, gaia-system"
+    )
+
+
+def _build_activity_block(max_snapshots: int) -> str | None:
+    """Build session activity summary from run-snapshots.jsonl."""
+    snapshots_path = (
+        get_plugin_data_dir() / "project-context" / "workflow-episodic-memory" / "run-snapshots.jsonl"
+    )
+    if not snapshots_path.exists():
+        return None
+
+    try:
+        lines = snapshots_path.read_text().splitlines()
+        # Take last N lines
+        recent = lines[-max_snapshots:] if len(lines) > max_snapshots else lines
+
+        entries = []
+        for line in recent:
+            if not line.strip():
+                continue
+            try:
+                snap = json.loads(line)
+                agent = snap.get("agent", "unknown")
+                status = snap.get("plan_status", "unknown")
+                prompt = snap.get("prompt", "")[:80]
+                cmd_count = snap.get("commands_executed_count", 0)
+                entries.append(f"- {agent} → {status} ({prompt}, {cmd_count} commands)")
+            except json.JSONDecodeError:
+                continue
+
+        if not entries:
+            return None
+
+        return "## Session Activity\n" + "\n".join(entries)
+
+    except Exception as e:
+        logger.debug("Failed to build activity block (non-fatal): %s", e)
+        return None
+
+
+def _build_anomalies_block(window_hours: int) -> str | None:
+    """Build active anomalies summary from anomalies.jsonl."""
+    anomaly_path = (
+        get_plugin_data_dir() / "project-context" / "workflow-episodic-memory" / "anomalies.jsonl"
+    )
+    if not anomaly_path.exists():
+        return None
+
+    try:
+        lines = anomaly_path.read_text().splitlines()[-20:]
+        cutoff = datetime.now().timestamp() - (window_hours * 3600)
+
+        critical_types: list[str] = []
+        warning_types: list[str] = []
+
+        for line in lines:
+            if not line.strip():
+                continue
+            try:
+                entry = json.loads(line)
+                ts = entry.get("timestamp", "")
+                if ts:
+                    try:
+                        entry_time = datetime.fromisoformat(ts).timestamp()
+                        if entry_time < cutoff:
+                            continue
+                    except (ValueError, TypeError):
+                        continue
+
+                for anomaly in entry.get("anomalies", []):
+                    severity = anomaly.get("severity", "")
+                    atype = anomaly.get("type", "unknown")
+                    if severity == "critical":
+                        critical_types.append(atype)
+                    elif severity == "warning":
+                        warning_types.append(atype)
+            except json.JSONDecodeError:
+                continue
+
+        if not critical_types and not warning_types:
+            return None
+
+        parts = []
+        if critical_types:
+            unique = sorted(set(critical_types))
+            parts.append(f"- {len(critical_types)} critical: {', '.join(unique)}")
+        if warning_types:
+            unique = sorted(set(warning_types))
+            parts.append(f"- {len(warning_types)} warning: {', '.join(unique)}")
+
+        return "## Active Anomalies\n" + "\n".join(parts)
+
+    except Exception as e:
+        logger.debug("Failed to build anomalies block (non-fatal): %s", e)
+        return None
+
+
+def _build_events_block(max_events: int) -> str | None:
+    """Build recent events summary from session context.json."""
+    context_path = Path(".claude/session/active/context.json")
+    if not context_path.exists():
+        return None
+
+    try:
+        with open(context_path) as f:
+            context = json.load(f)
+
+        events = context.get("critical_events", [])
+        if not events:
+            return None
+
+        # Take last N events
+        recent = events[-max_events:]
+
+        lines = []
+        for event in recent:
+            etype = event.get("event_type", "")
+            ts = event.get("timestamp", "")[:16]
+
+            if etype == "git_commit":
+                msg = event.get("commit_message", "")
+                hash_val = event.get("commit_hash", "")[:7]
+                if hash_val and msg:
+                    lines.append(f"- [{ts}] Commit {hash_val}: {msg}")
+            elif etype == "git_push":
+                branch = event.get("branch", "")
+                if branch:
+                    lines.append(f"- [{ts}] Pushed to {branch}")
+            elif etype == "file_modifications":
+                count = event.get("modification_count", 0)
+                if count:
+                    lines.append(f"- [{ts}] Modified {count} files")
+            elif etype == "infrastructure_change":
+                cmd = event.get("command", "")
+                if cmd:
+                    lines.append(f"- [{ts}] Infrastructure: {cmd}")
+
+        if not lines:
+            return None
+
+        return "## Recent Events\n" + "\n".join(lines)
+
+    except Exception as e:
+        logger.debug("Failed to build events block (non-fatal): %s", e)
+        return None

package/dist/gaia-ops/hooks/modules/context/context_cache.py

@@ -0,0 +1,129 @@
+"""
+Context cache for PreToolUse -> SubagentStart handoff.
+
+PreToolUse:Agent builds context (needs the prompt for surface routing) but the
+context must reach the subagent, not the orchestrator.  SubagentStart is where
+context should be injected, but SubagentStart does not receive the prompt.
+
+Solution: PreToolUse caches the built context to a temp file keyed by
+session_id.  SubagentStart reads and consumes the cache (one-shot).
+
+Cache location: /tmp/gaia-context-cache/{session_id}-{timestamp}.json
+TTL: 60 seconds (stale files cleaned on write).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+CACHE_DIR = Path("/tmp/gaia-context-cache")
+CACHE_TTL_SECONDS = 60
+
+
+def write_context_cache(
+    session_id: str,
+    context: str,
+    agent_type: str = "",
+) -> Path:
+    """Write context to a cache file for later consumption by SubagentStart.
+
+    Args:
+        session_id: Hook session identifier (shared between PreToolUse and SubagentStart).
+        context: The full additionalContext string to inject into the subagent.
+        agent_type: The agent type (for logging/diagnostics).
+
+    Returns:
+        Path to the written cache file.
+    """
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Clean stale files first
+    _cleanup_stale_caches()
+
+    timestamp = int(time.time() * 1000)
+    cache_file = CACHE_DIR / f"{session_id}-{timestamp}.json"
+    payload = {
+        "context": context,
+        "agent_type": agent_type,
+        "timestamp": timestamp,
+    }
+
+    cache_file.write_text(json.dumps(payload))
+    logger.info(
+        "Cached context for session=%s agent=%s (%d bytes) -> %s",
+        session_id, agent_type, len(context), cache_file.name,
+    )
+    return cache_file
+
+
+def read_context_cache(session_id: str) -> Optional[dict]:
+    """Read and consume the most recent context cache for a session.
+
+    Returns the cache payload dict if found, or None if no cache exists.
+    The cache file is deleted after reading (one-shot consumption).
+
+    Args:
+        session_id: Hook session identifier.
+
+    Returns:
+        Dict with keys: context, agent_type, timestamp.  Or None.
+    """
+    if not CACHE_DIR.exists():
+        logger.debug("No cache directory found")
+        return None
+
+    # Find all cache files for this session, sorted by timestamp (newest first)
+    prefix = f"{session_id}-"
+    candidates = sorted(
+        [f for f in CACHE_DIR.iterdir() if f.name.startswith(prefix) and f.suffix == ".json"],
+        key=lambda p: p.stat().st_mtime,
+        reverse=True,
+    )
+
+    if not candidates:
+        logger.debug("No cache files found for session=%s", session_id)
+        return None
+
+    cache_file = candidates[0]
+    try:
+        payload = json.loads(cache_file.read_text())
+        logger.info(
+            "Read context cache for session=%s agent=%s from %s",
+            session_id, payload.get("agent_type", "unknown"), cache_file.name,
+        )
+        # One-shot: delete after reading
+        cache_file.unlink(missing_ok=True)
+
+        # Clean up any older duplicates for this session
+        for stale in candidates[1:]:
+            stale.unlink(missing_ok=True)
+
+        return payload
+
+    except (json.JSONDecodeError, OSError) as exc:
+        logger.warning("Failed to read cache file %s: %s", cache_file, exc)
+        cache_file.unlink(missing_ok=True)
+        return None
+
+
+def _cleanup_stale_caches() -> None:
+    """Remove cache files older than CACHE_TTL_SECONDS."""
+    if not CACHE_DIR.exists():
+        return
+
+    cutoff = time.time() - CACHE_TTL_SECONDS
+    for f in CACHE_DIR.iterdir():
+        if f.suffix == ".json":
+            try:
+                if f.stat().st_mtime < cutoff:
+                    f.unlink(missing_ok=True)
+                    logger.debug("Cleaned stale cache: %s", f.name)
+            except OSError:
+                pass

package/dist/gaia-ops/hooks/modules/context/context_freshness.py

@@ -0,0 +1,145 @@
+"""
+Context freshness checker for SessionStart hook.
+
+Determines whether project-context.json is fresh enough to skip a rescan.
+Uses metadata.scan_config.last_scan (preferred) or file mtime as fallback.
+
+Public API:
+    - check_freshness(project_root: Path) -> FreshnessResult
+"""
+
+import json
+import logging
+import os
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Optional
+
+from ..core.paths import find_claude_dir
+
+logger = logging.getLogger(__name__)
+
+# Context freshness threshold (hours) -- env var overrides default
+DEFAULT_FRESHNESS_HOURS = 24
+
+
+@dataclass(frozen=True)
+class FreshnessResult:
+    """Result of a context freshness check."""
+
+    is_fresh: bool
+    reason: str
+    age_hours: float = 0.0
+
+
+def _get_context_path() -> Path:
+    """Return path to project-context.json."""
+    claude_dir = find_claude_dir()
+    return claude_dir / "project-context" / "project-context.json"
+
+
+def _read_staleness_from_context(context_path: Path) -> Optional[int]:
+    """Read staleness_hours from metadata.scan_config in the context file.
+
+    Returns None if the file cannot be read or the field is absent.
+    """
+    if not context_path.is_file():
+        return None
+    try:
+        with open(context_path, "r") as f:
+            data = json.load(f)
+        return (
+            int(
+                data.get("metadata", {})
+                .get("scan_config", {})
+                .get("staleness_hours", 0)
+            )
+            or None
+        )
+    except (json.JSONDecodeError, OSError, ValueError, TypeError):
+        return None
+
+
+def _get_effective_threshold() -> int:
+    """Determine the effective freshness threshold in hours."""
+    return int(
+        os.environ.get(
+            "GAIA_SCAN_STALENESS_HOURS",
+            os.environ.get("CONTEXT_FRESHNESS_HOURS", str(DEFAULT_FRESHNESS_HOURS)),
+        )
+    )
+
+
+def check_freshness(project_root: Path = None) -> FreshnessResult:
+    """Check if project-context.json exists and is fresh (< threshold).
+
+    Args:
+        project_root: Unused, kept for API compatibility. Context path
+            is resolved via find_claude_dir().
+
+    Returns:
+        FreshnessResult with is_fresh, reason, and age_hours.
+    """
+    context_path = _get_context_path()
+
+    if not context_path.exists():
+        logger.info("project-context.json not found at %s", context_path)
+        return FreshnessResult(is_fresh=False, reason="missing", age_hours=0.0)
+
+    # Determine effective threshold: env var > context file > default
+    effective_hours = _get_effective_threshold()
+    ctx_hours = _read_staleness_from_context(context_path)
+    if ctx_hours and not os.environ.get("GAIA_SCAN_STALENESS_HOURS"):
+        effective_hours = ctx_hours
+
+    try:
+        # Try metadata.scan_config.last_scan first (more accurate)
+        with open(context_path, "r") as f:
+            data = json.load(f)
+        last_scan = data.get("metadata", {}).get("scan_config", {}).get("last_scan")
+
+        if last_scan:
+            scan_dt = datetime.fromisoformat(last_scan)
+            now = datetime.now(timezone.utc)
+            age = now - scan_dt
+            age_hours = age.total_seconds() / 3600.0
+            threshold = timedelta(hours=effective_hours)
+
+            if age > threshold:
+                logger.info(
+                    "project-context.json is stale (last_scan age: %s, threshold: %sh)",
+                    age,
+                    effective_hours,
+                )
+                return FreshnessResult(
+                    is_fresh=False, reason="stale", age_hours=age_hours
+                )
+
+            logger.debug("project-context.json is fresh (last_scan age: %s)", age)
+            return FreshnessResult(
+                is_fresh=True, reason="fresh", age_hours=age_hours
+            )
+
+        # Fallback: use file mtime
+        mtime = datetime.fromtimestamp(context_path.stat().st_mtime)
+        age = datetime.now() - mtime
+        age_hours = age.total_seconds() / 3600.0
+        threshold = timedelta(hours=effective_hours)
+
+        if age > threshold:
+            logger.info(
+                "project-context.json is stale (mtime age: %s, threshold: %sh)",
+                age,
+                effective_hours,
+            )
+            return FreshnessResult(
+                is_fresh=False, reason="stale", age_hours=age_hours
+            )
+
+        logger.debug("project-context.json is fresh (mtime age: %s)", age)
+        return FreshnessResult(is_fresh=True, reason="fresh", age_hours=age_hours)
+
+    except Exception as e:
+        logger.warning("Error checking context freshness: %s", e)
+        return FreshnessResult(is_fresh=False, reason="error", age_hours=0.0)