loki-mode 6.60.0 → 6.62.0

package/integrations/openclaw/bridge/schema_map.py

@@ -0,0 +1,180 @@
+"""Event schema mapping between Loki Mode and OpenClaw gateway.
+
+Loki Mode emits events in two formats:
+
+1. Individual JSON files in .loki/events/pending/ (via events/emit.sh):
+   {"id", "type", "source", "timestamp", "payload": {"action", ...}}
+   Here "type" is a category (e.g. "session") and payload.action is the verb.
+
+2. JSONL entries in .loki/events.jsonl (via emit_event_json in run.sh):
+   {"timestamp", "type", "data": {...}}
+   Here "type" is already compound (e.g. "session_start", "phase_change").
+
+This module normalizes both into a canonical "type.action" key for lookup,
+then maps to OpenClaw gateway message format.
+"""
+
+# Mapping table: canonical event key -> OpenClaw message definition.
+#
+# Canonical keys use dot notation: "session.start", "phase.change", etc.
+# The map_event() function normalizes both Loki formats into these keys.
+LOKI_TO_OPENCLAW = {
+    "session.start": {
+        "openclaw_method": "sessions_send",
+        "template": "Loki Mode started. Provider: {provider}. PRD: {prd_path}",
+    },
+    "session.stop": {
+        "openclaw_method": "sessions_send",
+        "template": "Loki Mode stopped. Reason: {reason}.",
+    },
+    "session.end": {
+        "openclaw_method": "sessions_send",
+        "template": "Session ended. Result: {result}. Reason: {reason}",
+    },
+    "phase.change": {
+        "openclaw_method": "sessions_send",
+        "template": "Phase transition: {from_phase} -> {to_phase} (iteration {iteration})",
+    },
+    "iteration.start": {
+        "openclaw_method": "sessions_send",
+        "template": "Iteration {iteration} started. Phase: {phase}",
+    },
+    "iteration.complete": {
+        "openclaw_method": "sessions_send",
+        "template": "Iteration {iteration} complete. Phase: {phase}",
+    },
+    "task.complete": {
+        "openclaw_method": "sessions_send",
+        "template": "Task completed: {task_id} - {action}",
+    },
+    "error.failed": {
+        "openclaw_method": "sessions_send",
+        "template": "[ERROR] {error}. Command: {command}",
+    },
+    "council.vote": {
+        "openclaw_method": "sessions_send",
+        "template": "Council vote: {verdict} ({votes_for}/{votes_total} votes)",
+    },
+    "council.verdict": {
+        "openclaw_method": "sessions_send",
+        "template": "Council verdict: {verdict} ({votes_for}/{votes_total} votes)",
+    },
+    "budget.exceeded": {
+        "openclaw_method": "sessions_send",
+        "template": "[BUDGET] Limit exceeded. Current: ${current_cost}. Limit: ${budget_limit}",
+    },
+    "budget.warning": {
+        "openclaw_method": "sessions_send",
+        "template": "[BUDGET] Current spend: ${current_cost}. Limit: ${budget_limit}",
+    },
+    "code_review.start": {
+        "openclaw_method": "sessions_send",
+        "template": "Code review started. Files: {file_count}",
+    },
+    "code_review.complete": {
+        "openclaw_method": "sessions_send",
+        "template": "Code review complete. Result: {result}",
+    },
+    "watchdog.alert": {
+        "openclaw_method": "sessions_send",
+        "template": "[WATCHDOG] {reason}",
+    },
+}
+
+# Underscore-separated type names from emit_event_json (e.g. "session_start")
+# are normalized to dot notation by replacing the first underscore with a dot.
+# This dict handles cases where the underscore split is ambiguous.
+_UNDERSCORE_OVERRIDES = {
+    "phase_change": "phase.change",
+    "iteration_start": "iteration.start",
+    "iteration_complete": "iteration.complete",
+    "session_start": "session.start",
+    "session_end": "session.end",
+    "budget_exceeded": "budget.exceeded",
+    "code_review_start": "code_review.start",
+    "code_review_complete": "code_review.complete",
+    "council_vote": "council.vote",
+    "watchdog_alert": "watchdog.alert",
+}
+
+
+def _normalize_event_key(loki_event: dict) -> str:
+    """Derive canonical dot-notation key from either Loki event format.
+
+    Format 1 (emit.sh individual files):
+        type="session", payload.action="start" -> "session.start"
+
+    Format 2 (events.jsonl from emit_event_json):
+        type="session_start" -> "session.start"
+    """
+    event_type = loki_event.get("type", "")
+
+    # Check override table first (handles underscore-compound types)
+    if event_type in _UNDERSCORE_OVERRIDES:
+        return _UNDERSCORE_OVERRIDES[event_type]
+
+    # Format 1: type + payload.action
+    payload = loki_event.get("payload") or loki_event.get("data") or {}
+    if isinstance(payload, dict):
+        action = payload.get("action", "")
+        if action:
+            return f"{event_type}.{action}"
+
+    # Fallback: replace first underscore with dot
+    if "_" in event_type:
+        parts = event_type.split("_", 1)
+        return f"{parts[0]}.{parts[1]}"
+
+    return event_type
+
+
+def map_event(loki_event: dict):  # -> Optional[dict]
+    """Map a Loki event to OpenClaw gateway message format.
+
+    Accepts either Loki event format (individual JSON file or JSONL entry).
+
+    Args:
+        loki_event: Dict from either format. Common fields:
+            - type: Event type string
+            - timestamp: ISO timestamp
+            For emit.sh format: id, source, payload
+            For JSONL format: data (dict of key-value pairs)
+
+    Returns:
+        OpenClaw message dict with "method" and "params", or None if the
+        event type is not mapped.
+    """
+    canonical_key = _normalize_event_key(loki_event)
+    mapping = LOKI_TO_OPENCLAW.get(canonical_key)
+    if not mapping:
+        return None
+
+    # Extract payload from either format
+    payload = loki_event.get("payload") or loki_event.get("data") or {}
+    if isinstance(payload, str):
+        # JSONL format sometimes has data as a plain string
+        payload = {"data": payload}
+
+    try:
+        message = mapping["template"].format_map(_SafeFormatDict(payload))
+    except (KeyError, ValueError):
+        message = f"{canonical_key}: {payload}"
+
+    return {
+        "method": mapping["openclaw_method"],
+        "params": {
+            "message": message,
+            "source": "loki-bridge",
+            "event_type": canonical_key,
+            "timestamp": loki_event.get("timestamp", ""),
+            "loki_event_id": loki_event.get("id", ""),
+        },
+    }
+
+
+class _SafeFormatDict(dict):
+    """Dict subclass that returns placeholder text for missing keys
+    instead of raising KeyError during str.format_map()."""
+
+    def __missing__(self, key: str) -> str:
+        return f"<{key}>"

package/integrations/openclaw/bridge/watcher.py

@@ -0,0 +1,100 @@
+"""File watcher for Loki Mode event directories.
+
+Polls .loki/events/pending/ for new JSON event files and monitors
+.loki/dashboard-state.json for changes. Calls a user-supplied callback
+with each new event dict.
+
+Uses stdlib only -- no external dependencies, no threads.
+"""
+
+import json
+import os
+import time
+
+
+class LokiFileWatcher:
+    """Synchronous polling watcher for Loki Mode flat-file events.
+
+    Args:
+        loki_dir: Path to the .loki directory (e.g. ".loki" or "/tmp/project/.loki").
+        on_event: Callback receiving a single dict (the parsed event).
+        poll_interval: Seconds between directory polls (default 1.0).
+    """
+
+    def __init__(
+        self,
+        loki_dir: str,
+        on_event,
+        poll_interval: float = 1.0,
+    ):
+        self.loki_dir = os.path.abspath(loki_dir)
+        self.pending_dir = os.path.join(self.loki_dir, "events", "pending")
+        self.state_file = os.path.join(self.loki_dir, "dashboard-state.json")
+        self.on_event = on_event
+        self.poll_interval = poll_interval
+
+        self._processed: set[str] = set()
+        self._last_state_mtime: float = 0.0
+        self._running = False
+
+    def start(self) -> None:
+        """Run the poll loop. Blocks until stop() is called or interrupted."""
+        self._running = True
+        self._ensure_dirs()
+
+        while self._running:
+            self._poll_pending()
+            self._poll_state()
+            time.sleep(self.poll_interval)
+
+    def stop(self) -> None:
+        """Signal the poll loop to exit after the current iteration."""
+        self._running = False
+
+    def _ensure_dirs(self) -> None:
+        """Create watched directories if they do not exist."""
+        os.makedirs(self.pending_dir, exist_ok=True)
+
+    def _poll_pending(self) -> None:
+        """Scan pending directory for new JSON event files."""
+        try:
+            entries = os.listdir(self.pending_dir)
+        except OSError:
+            return
+
+        for name in sorted(entries):
+            if not name.endswith(".json") or name in self._processed:
+                continue
+            filepath = os.path.join(self.pending_dir, name)
+            event = self._read_json(filepath)
+            if event is not None:
+                self.on_event(event)
+            self._processed.add(name)
+
+    def _poll_state(self) -> None:
+        """Check dashboard-state.json for modifications."""
+        try:
+            mtime = os.path.getmtime(self.state_file)
+        except OSError:
+            return
+
+        if mtime <= self._last_state_mtime:
+            return
+
+        self._last_state_mtime = mtime
+        state = self._read_json(self.state_file)
+        if state is not None:
+            self.on_event({
+                "type": "dashboard_state",
+                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                "payload": state,
+            })
+
+    @staticmethod
+    def _read_json(path: str):  # -> Optional[dict]
+        """Read and parse a JSON file, returning None on any error."""
+        try:
+            with open(path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (OSError, json.JSONDecodeError, ValueError):
+            return None

package/integrations/openclaw/scripts/format-progress.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+# Format loki status into human-readable progress message
+# Reads JSON from stdin (output of poll-status.sh), outputs formatted text
+# suitable for posting to Slack, Discord, or web channels.
+#
+# Usage: ./poll-status.sh /path/to/project | ./format-progress.sh
+
+set -euo pipefail
+
+python3 -c "
+import json, sys
+
+try:
+    s = json.load(sys.stdin)
+
+    # Check for error
+    if 'error' in s:
+        print('Loki Mode [ERROR] - ' + s['error'])
+        suggestion = s.get('suggestion')
+        if suggestion:
+            print('Suggestion: ' + suggestion)
+        sys.exit(0)
+
+    status = s.get('status', 'unknown').upper()
+    phase = s.get('phase') or 'N/A'
+    iteration = s.get('iteration', 0)
+    completed = s.get('tasks_completed', 0)
+    total = s.get('tasks_total', 0)
+    failed = s.get('tasks_failed', 0)
+    pending = s.get('tasks_pending', 0)
+    budget_used = s.get('budget_used')
+    budget_limit = s.get('budget_limit')
+    elapsed = s.get('elapsed_minutes', 0)
+    provider = s.get('provider', 'unknown')
+    verdict = s.get('council_verdict')
+    version = s.get('version', '')
+
+    lines = []
+
+    # Header line
+    header = 'Loki Mode [' + status + '] - ' + phase + ' (iteration ' + str(iteration) + ')'
+    if version:
+        header += ' | v' + version
+    lines.append(header)
+
+    # Task progress
+    task_line = 'Tasks: ' + str(completed) + '/' + str(total) + ' complete'
+    if failed:
+        task_line += ', ' + str(failed) + ' failed'
+    if pending:
+        task_line += ', ' + str(pending) + ' pending'
+    lines.append(task_line)
+
+    # Cost and timing
+    info_parts = []
+    if budget_used is not None:
+        cost_str = '\$' + '{:.2f}'.format(budget_used)
+        if budget_limit:
+            cost_str += ' / \$' + '{:.2f}'.format(budget_limit) + ' budget'
+        info_parts.append('Cost: ' + cost_str)
+    info_parts.append('Time: ' + '{:.0f}'.format(elapsed) + 'm')
+    info_parts.append('Provider: ' + provider)
+    lines.append(' | '.join(info_parts))
+
+    # Council verdict (if available)
+    if verdict:
+        lines.append('Council: ' + verdict)
+
+    # Warnings
+    if failed > 0:
+        lines.append('WARNING: ' + str(failed) + ' task(s) failed -- check loki logs')
+    if status == 'UNKNOWN':
+        lines.append('WARNING: Session status unknown -- process may have crashed')
+
+    print('\\n'.join(lines))
+except json.JSONDecodeError:
+    print('Loki Mode [ERROR] - Failed to parse status JSON')
+except Exception as e:
+    print('Loki Mode [ERROR] - ' + str(e))
+"

package/integrations/openclaw/scripts/poll-status.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+# Poll loki status and output structured progress for OpenClaw channel routing
+# Usage: poll-status.sh [workdir]
+#
+# Reads loki status --json output and enriches it with budget data
+# from .loki/metrics/budget.json and council verdict from .loki/council/state.json.
+# Outputs a single JSON object suitable for channel message formatting.
+
+set -euo pipefail
+
+WORKDIR="${1:-.}"
+cd "$WORKDIR" || { echo '{"error": "Cannot access workdir: '"$WORKDIR"'"}'; exit 1; }
+
+# Get base status from loki CLI
+STATUS_JSON=$(loki status --json 2>/dev/null)
+if [ $? -ne 0 ]; then
+    echo '{"error": "loki status failed", "suggestion": "Is loki installed and a session running?"}'
+    exit 1
+fi
+
+# Enrich with budget and council data (not included in loki status --json)
+python3 -c "
+import json, sys, os
+
+try:
+    s = json.load(sys.stdin)
+    tc = s.get('task_counts', {})
+
+    output = {
+        'status': s.get('status', 'unknown'),
+        'phase': s.get('phase'),
+        'iteration': s.get('iteration', 0),
+        'tasks_completed': tc.get('completed', 0),
+        'tasks_total': tc.get('total', 0),
+        'tasks_failed': tc.get('failed', 0),
+        'tasks_pending': tc.get('pending', 0),
+        'elapsed_minutes': round(s.get('elapsed_time', 0) / 60, 1),
+        'provider': s.get('provider', 'claude'),
+        'version': s.get('version', 'unknown'),
+        'pid': s.get('pid'),
+        'dashboard_url': s.get('dashboard_url'),
+    }
+
+    # Read budget data from flat file (not in loki status --json)
+    budget_file = os.path.join('.loki', 'metrics', 'budget.json')
+    if os.path.isfile(budget_file):
+        try:
+            with open(budget_file) as f:
+                budget = json.load(f)
+            output['budget_used'] = round(budget.get('budget_used', 0), 2)
+            output['budget_limit'] = budget.get('budget_limit')
+        except Exception:
+            output['budget_used'] = None
+            output['budget_limit'] = None
+    else:
+        output['budget_used'] = None
+        output['budget_limit'] = None
+
+    # Read council verdict from flat file (not in loki status --json)
+    council_file = os.path.join('.loki', 'council', 'state.json')
+    if os.path.isfile(council_file):
+        try:
+            with open(council_file) as f:
+                council = json.load(f)
+            output['council_verdict'] = council.get('verdict')
+        except Exception:
+            output['council_verdict'] = None
+    else:
+        output['council_verdict'] = None
+
+    print(json.dumps(output, indent=2))
+except Exception as e:
+    print(json.dumps({'error': str(e)}))
+" <<< "$STATUS_JSON"