loki-mode 5.53.0 → 5.55.0

package/dashboard/activity_logger.py

@@ -0,0 +1,231 @@
+"""
+Activity Logger for Loki Mode Dashboard.
+
+Appends structured JSONL entries to ~/.loki/activity.jsonl with automatic
+rotation at 10MB. Provides query and session-diff capabilities.
+"""
+
+import json
+import logging
+import os
+import threading
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+logger = logging.getLogger("loki-activity")
+
+LOKI_DATA_DIR = os.environ.get("LOKI_DATA_DIR", os.path.expanduser("~/.loki"))
+
+# Valid entity types and actions for validation
+VALID_ENTITY_TYPES = {"task", "agent", "phase", "checkpoint"}
+VALID_ACTIONS = {"created", "status_changed", "completed", "failed", "blocked"}
+
+# Rotation threshold in bytes (10MB)
+MAX_FILE_SIZE = 10 * 1024 * 1024
+
+
+class ActivityLogger:
+    """Thread-safe activity logger that writes JSONL to ~/.loki/activity.jsonl."""
+
+    def __init__(self, data_dir: Optional[str] = None) -> None:
+        self._data_dir = Path(data_dir or LOKI_DATA_DIR)
+        self._log_file = self._data_dir / "activity.jsonl"
+        self._lock = threading.Lock()
+        self._data_dir.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def log_file(self) -> Path:
+        """Return the path to the current activity log file."""
+        return self._log_file
+
+    def _rotate_if_needed(self) -> None:
+        """Rotate the log file if it exceeds MAX_FILE_SIZE."""
+        try:
+            if self._log_file.exists() and self._log_file.stat().st_size >= MAX_FILE_SIZE:
+                timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+                rotated = self._data_dir / f"activity-{timestamp}.jsonl"
+                self._log_file.rename(rotated)
+                logger.info("Rotated activity log to %s", rotated)
+        except OSError as e:
+            logger.warning("Failed to rotate activity log: %s", e)
+
+    def log(
+        self,
+        entity_type: str,
+        entity_id: str,
+        action: str,
+        old_value: Optional[str] = None,
+        new_value: Optional[str] = None,
+        session_id: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """Log an activity entry. Returns the entry dict."""
+        if entity_type not in VALID_ENTITY_TYPES:
+            logger.warning("Invalid entity_type %r (valid: %s)", entity_type, VALID_ENTITY_TYPES)
+        if action not in VALID_ACTIONS:
+            logger.warning("Invalid action %r (valid: %s)", action, VALID_ACTIONS)
+
+        entry: dict[str, Any] = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "entity_type": entity_type,
+            "entity_id": entity_id,
+            "action": action,
+            "old_value": old_value,
+            "new_value": new_value,
+            "session_id": session_id,
+        }
+
+        with self._lock:
+            self._rotate_if_needed()
+            try:
+                with open(self._log_file, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(entry, separators=(",", ":")) + "\n")
+            except OSError as e:
+                logger.error("Failed to write activity entry: %s", e)
+
+        return entry
+
+    def query_since(self, timestamp: str) -> list[dict[str, Any]]:
+        """Return activity entries after the given ISO timestamp."""
+        # Normalize Z-suffix so comparisons work consistently
+        timestamp = timestamp.replace("Z", "+00:00")
+        results: list[dict[str, Any]] = []
+
+        if not self._log_file.exists():
+            return results
+
+        with self._lock:
+            try:
+                with open(self._log_file, "r", encoding="utf-8") as f:
+                    for line in f:
+                        line = line.strip()
+                        if not line:
+                            continue
+                        try:
+                            entry = json.loads(line)
+                            entry_ts = entry.get("timestamp", "").replace("Z", "+00:00")
+                            if entry_ts > timestamp:
+                                results.append(entry)
+                        except json.JSONDecodeError:
+                            continue
+            except OSError as e:
+                logger.error("Failed to read activity log: %s", e)
+
+        return results
+
+    def get_session_diff(self, since_timestamp: Optional[str] = None) -> dict[str, Any]:
+        """Return a structured summary of activity since the given timestamp.
+
+        If no timestamp is provided, defaults to the last 24 hours.
+        """
+        if since_timestamp is None:
+            since_dt = datetime.now(timezone.utc) - timedelta(hours=24)
+            since_timestamp = since_dt.isoformat()
+
+        # Normalize Z-suffix before passing to query_since
+        since_timestamp = since_timestamp.replace("Z", "+00:00")
+
+        entries = self.query_since(since_timestamp)
+
+        now = datetime.now(timezone.utc)
+        try:
+            since_dt = datetime.fromisoformat(since_timestamp.replace("Z", "+00:00"))
+        except (ValueError, AttributeError):
+            since_dt = now
+
+        period_hours = max(0.0, (now - since_dt).total_seconds() / 3600)
+
+        # Build summary counts
+        summary = {
+            "total_changes": len(entries),
+            "tasks_created": 0,
+            "tasks_completed": 0,
+            "tasks_blocked": 0,
+            "phases_transitioned": 0,
+            "checkpoints_created": 0,
+            "errors": 0,
+        }
+
+        highlights: list[str] = []
+        decisions: list[dict[str, str]] = []
+
+        for entry in entries:
+            entity_type = entry.get("entity_type", "")
+            action = entry.get("action", "")
+            entity_id = entry.get("entity_id", "")
+
+            if entity_type == "task":
+                if action == "created":
+                    summary["tasks_created"] += 1
+                    highlights.append(f"Task {entity_id} created")
+                elif action == "completed":
+                    summary["tasks_completed"] += 1
+                    highlights.append(f"Task {entity_id} completed")
+                elif action == "blocked":
+                    summary["tasks_blocked"] += 1
+                    highlights.append(f"Task {entity_id} blocked")
+                elif action == "failed":
+                    summary["errors"] += 1
+                    highlights.append(f"Task {entity_id} failed")
+                elif action == "status_changed":
+                    old_val = entry.get("old_value", "")
+                    new_val = entry.get("new_value", "")
+                    highlights.append(f"Task {entity_id}: {old_val} -> {new_val}")
+
+            elif entity_type == "agent":
+                if action == "failed":
+                    summary["errors"] += 1
+                    highlights.append(f"Agent {entity_id} failed")
+                elif action == "created":
+                    highlights.append(f"Agent {entity_id} created")
+                elif action == "status_changed":
+                    old_val = entry.get("old_value", "")
+                    new_val = entry.get("new_value", "")
+                    highlights.append(f"Agent {entity_id}: {old_val} -> {new_val}")
+                    # Agent status changes may represent decisions
+                    if new_val:
+                        decisions.append({
+                            "timestamp": entry.get("timestamp", ""),
+                            "decision": f"Agent {entity_id} transitioned to {new_val}",
+                            "reasoning": f"Status changed from {old_val} to {new_val}",
+                        })
+
+            elif entity_type == "phase":
+                if action == "status_changed":
+                    summary["phases_transitioned"] += 1
+                    old_val = entry.get("old_value", "")
+                    new_val = entry.get("new_value", "")
+                    highlights.append(f"Phase transition: {old_val} -> {new_val}")
+                    decisions.append({
+                        "timestamp": entry.get("timestamp", ""),
+                        "decision": f"Phase transitioned to {new_val}",
+                        "reasoning": f"Moved from {old_val} to {new_val}",
+                    })
+
+            elif entity_type == "checkpoint":
+                if action == "created":
+                    summary["checkpoints_created"] += 1
+                    highlights.append(f"Checkpoint {entity_id} created")
+
+        return {
+            "since": since_timestamp,
+            "period_hours": round(period_hours, 2),
+            "summary": summary,
+            "highlights": highlights,
+            "decisions": decisions,
+        }
+
+
+# Singleton instance
+_instance: Optional[ActivityLogger] = None
+_instance_lock = threading.Lock()
+
+
+def get_activity_logger(data_dir: Optional[str] = None) -> ActivityLogger:
+    """Get or create the singleton ActivityLogger instance."""
+    global _instance
+    if _instance is None:
+        with _instance_lock:
+            if _instance is None:
+                _instance = ActivityLogger(data_dir=data_dir)
+    return _instance

package/dashboard/failure_extractor.py

@@ -0,0 +1,228 @@
+"""
+Failure Extractor for Loki Mode.
+
+Parses session JSONL log files to identify failure patterns such as
+repeated task failures, excessive RARV cycles, verification failures,
+agent timeouts, and user corrections.
+"""
+
+import hashlib
+import json
+import logging
+import os
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+LOKI_DATA_DIR = os.environ.get("LOKI_DATA_DIR", os.path.expanduser("~/.loki"))
+
+# Keywords/fields used to classify failure categories
+_TIMEOUT_KEYWORDS = ("timeout", "timed out", "deadline exceeded", "killed")
+_VERIFICATION_KEYWORDS = ("verification failed", "verify failed", "assertion", "expect")
+_RETRY_KEYWORDS = ("retry", "retrying", "attempt ", "reattempt")
+
+
+def _hash_pattern(text: str) -> str:
+    """Generate a short deterministic hash for grouping similar errors."""
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()[:12]
+
+
+def _normalize_error(message: str) -> str:
+    """Strip variable parts (timestamps, IDs) to group similar errors."""
+    import re
+    # Remove hex IDs, UUIDs, timestamps, line numbers
+    normalized = re.sub(r"[0-9a-f]{8,}", "<ID>", message)
+    normalized = re.sub(r"\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[^\s]*", "<TS>", normalized)
+    normalized = re.sub(r":\d+:\d+", ":<LINE>", normalized)
+    normalized = re.sub(r"\d+", "<N>", normalized)
+    return normalized.strip()
+
+
+def _classify_failure(entry: dict[str, Any]) -> str | None:
+    """Classify a log entry into a failure category, or None if not a failure."""
+    message = str(entry.get("message", "") or entry.get("error", "")).lower()
+    event_type = str(entry.get("type", "") or entry.get("event", "")).lower()
+    status = str(entry.get("status", "")).lower()
+
+    # Agent timeout
+    if any(kw in message for kw in _TIMEOUT_KEYWORDS) or event_type == "timeout":
+        return "timeout"
+
+    # Verification failure
+    if any(kw in message for kw in _VERIFICATION_KEYWORDS) or event_type == "verification_failed":
+        return "verification"
+
+    # Retry / repeated failure
+    if any(kw in message for kw in _RETRY_KEYWORDS) or event_type in ("retry", "task_retry"):
+        return "retry"
+
+    # RARV cycle excess (iteration count > 2)
+    iteration = entry.get("iteration") or entry.get("rarv_iteration")
+    if iteration is not None:
+        try:
+            if int(iteration) > 2:
+                return "retry"
+        except (ValueError, TypeError):
+            pass
+
+    # Generic error
+    if status in ("failed", "error") or event_type in ("error", "failure", "task_failed"):
+        return "error"
+
+    # User correction
+    if event_type in ("user_correction", "correction", "override"):
+        return "error"
+
+    return None
+
+
+class FailureExtractor:
+    """Extracts and groups failure patterns from Loki session logs."""
+
+    def __init__(self, data_dir: str | None = None) -> None:
+        self._data_dir = Path(data_dir) if data_dir else Path(LOKI_DATA_DIR)
+
+    def _log_paths(self) -> list[Path]:
+        """Return all candidate JSONL log files, newest first."""
+        paths: list[Path] = []
+
+        # Activity log
+        activity = self._data_dir / "activity.jsonl"
+        if activity.is_file():
+            paths.append(activity)
+
+        # Session logs directory
+        logs_dir = self._data_dir / "logs"
+        if logs_dir.is_dir():
+            session_files = sorted(logs_dir.glob("*.jsonl"), reverse=True)
+            paths.extend(session_files)
+
+        return paths
+
+    def _parse_jsonl(self, path: Path, max_lines: int = 50000) -> list[dict[str, Any]]:
+        """Parse a JSONL file, returning list of dicts. Skips malformed lines."""
+        entries: list[dict[str, Any]] = []
+        try:
+            with open(path, "r", encoding="utf-8", errors="replace") as fh:
+                for i, line in enumerate(fh):
+                    if i >= max_lines:
+                        break
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        entries.append(json.loads(line))
+                    except json.JSONDecodeError:
+                        continue
+        except OSError as exc:
+            logger.warning("Failed to read log file %s: %s", path, exc)
+        return entries
+
+    def _extract_session_id(self, entry: dict[str, Any], fallback: str) -> str:
+        """Get session ID from a log entry."""
+        return str(entry.get("session_id") or entry.get("session") or fallback)
+
+    def extract(self, sessions: int = 10) -> dict[str, Any]:
+        """Extract failure patterns from the most recent N sessions.
+
+        Args:
+            sessions: Number of recent sessions to analyze.
+
+        Returns:
+            Structured failure data with patterns grouped by similarity.
+        """
+        log_paths = self._log_paths()
+        if not log_paths:
+            return {
+                "session_count": 0,
+                "total_failures": 0,
+                "patterns": [],
+            }
+
+        # Collect all failure entries across log files
+        # Track sessions seen to respect the session limit
+        failures: list[dict[str, Any]] = []
+        seen_sessions: set[str] = set()
+        session_order: list[str] = []
+
+        for path in log_paths:
+            entries = self._parse_jsonl(path)
+            file_session = path.stem  # use filename as fallback session ID
+
+            for entry in entries:
+                sid = self._extract_session_id(entry, file_session)
+
+                # Track session ordering
+                if sid not in seen_sessions:
+                    seen_sessions.add(sid)
+                    session_order.append(sid)
+
+                category = _classify_failure(entry)
+                if category is not None:
+                    failures.append({
+                        "entry": entry,
+                        "category": category,
+                        "session_id": sid,
+                    })
+
+        # Limit to the most recent N sessions
+        recent_sessions = set(session_order[:sessions])
+        failures = [f for f in failures if f["session_id"] in recent_sessions]
+
+        # Group failures by normalized error message + category
+        groups: dict[str, dict[str, Any]] = defaultdict(lambda: {
+            "category": "",
+            "count": 0,
+            "agent_types": set(),
+            "phases": set(),
+            "representative_error": "",
+            "sessions": set(),
+        })
+
+        for failure in failures:
+            entry = failure["entry"]
+            category = failure["category"]
+            session_id = failure["session_id"]
+
+            raw_message = str(
+                entry.get("message") or entry.get("error") or entry.get("detail") or ""
+            )
+            normalized = _normalize_error(raw_message)
+            group_key = f"{category}:{_hash_pattern(normalized)}"
+
+            group = groups[group_key]
+            group["category"] = category
+            group["count"] += 1
+            group["sessions"].add(session_id)
+
+            if not group["representative_error"]:
+                group["representative_error"] = raw_message[:500]
+
+            agent_type = entry.get("agent_type") or entry.get("agent") or ""
+            if agent_type:
+                group["agent_types"].add(str(agent_type))
+
+            phase = entry.get("phase") or entry.get("stage") or ""
+            if phase:
+                group["phases"].add(str(phase))
+
+        # Build structured output
+        patterns = []
+        for group_key, group in sorted(groups.items(), key=lambda x: x[1]["count"], reverse=True):
+            patterns.append({
+                "pattern_id": _hash_pattern(group_key),
+                "category": group["category"],
+                "count": group["count"],
+                "agent_types": sorted(group["agent_types"]),
+                "phases": sorted(group["phases"]),
+                "representative_error": group["representative_error"],
+                "sessions": sorted(group["sessions"]),
+            })
+
+        return {
+            "session_count": len(recent_sessions),
+            "total_failures": sum(p["count"] for p in patterns),
+            "patterns": patterns,
+        }