gobby 0.2.5__py3-none-any.whl

gobby/install/codex/hooks/hook_dispatcher.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""Codex notify script - forwards interactive Codex events to gobby.
+
+Codex supports a `notify = [...]` command in `~/.codex/config.toml`. This script is
+intended to be installed to `~/.gobby/hooks/codex/notify.py` and configured as that
+notify command.
+
+Codex notify is currently treated as fire-and-forget; this script should never
+block the CLI for long or fail the Codex command on daemon errors.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+DEFAULT_DAEMON_PORT = 8765
+DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
+DEBUG_ENV_VAR = "GOBBY_CODEX_NOTIFY_DEBUG"
+
+
+def _silence_output() -> None:
+    """Prevent notify script output from polluting the interactive Codex UI."""
+    if os.environ.get(DEBUG_ENV_VAR):
+        return
+
+    try:
+        devnull = open(os.devnull, "w", encoding="utf-8")  # noqa: SIM115
+        sys.stdout = devnull
+        sys.stderr = devnull
+    except Exception:
+        # nosec B110 - if silencing fails, still avoid raising/printing
+        pass
+
+
+def _get_daemon_url() -> str:
+    config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
+
+    port = DEFAULT_DAEMON_PORT
+    if config_path.exists():
+        try:
+            import yaml
+
+            with config_path.open(encoding="utf-8") as f:
+                config = yaml.safe_load(f) or {}
+            port = int(config.get("daemon_port", DEFAULT_DAEMON_PORT))
+        except Exception:
+            port = DEFAULT_DAEMON_PORT
+
+    return f"http://localhost:{port}"
+
+
+def _read_event_from_stdin() -> dict[str, Any] | None:
+    try:
+        raw = sys.stdin.read()
+    except Exception:
+        return None
+
+    if not raw.strip():
+        return None
+
+    try:
+        parsed = json.loads(raw)
+    except Exception:
+        return {"raw": raw}
+
+    if isinstance(parsed, dict):
+        return parsed
+    return {"event": parsed}
+
+
+def _extract_text_from_messages(messages: Any) -> str:
+    if not isinstance(messages, list):
+        return ""
+    for message in reversed(messages):
+        if not isinstance(message, dict):
+            continue
+        text = message.get("text") or message.get("content")
+        if isinstance(text, str) and text:
+            return text
+    return ""
+
+
+def _normalize_input_data(event: dict[str, Any] | None) -> dict[str, Any]:
+    event = event or {}
+
+    thread_id = (
+        event.get("session_id")
+        or event.get("thread_id")
+        or event.get("threadId")
+        or event.get("conversation_id")
+        or event.get("conversationId")
+    )
+    if not thread_id and isinstance(event.get("thread"), dict):
+        thread_id = event["thread"].get("id")
+    if not thread_id and isinstance(event.get("session"), dict):
+        thread_id = event["session"].get("id")
+
+    messages = event.get("input_messages") or event.get("inputMessages") or event.get("messages")
+    last_message = (
+        event.get("last_message")
+        or event.get("lastMessage")
+        or event.get("message")
+        or _extract_text_from_messages(messages)
+    )
+
+    event_type = (
+        event.get("event_type")
+        or event.get("eventType")
+        or event.get("type")
+        or event.get("name")
+        or "agent-turn-complete"
+    )
+
+    return {
+        "session_id": thread_id or "",
+        "event_type": event_type,
+        "last_message": last_message or "",
+        "input_messages": messages if isinstance(messages, list) else [],
+    }
+
+
+def main() -> int:
+    _silence_output()
+
+    event = _read_event_from_stdin()
+    input_data = _normalize_input_data(event)
+
+    daemon_url = _get_daemon_url()
+
+    try:
+        httpx.post(
+            f"{daemon_url}/hooks/execute",
+            json={
+                "hook_type": "AgentTurnComplete",
+                "input_data": input_data,
+                "source": "codex",
+            },
+            timeout=2.0,
+        )
+    except Exception:
+        return 0
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

gobby/install/codex/prompts/forget.md

@@ -0,0 +1,7 @@
+# Forget
+
+Delete a memory by ID using gobby-memory MCP tools.
+
+Use the `forget` tool on the `gobby-memory` server with the memory ID provided.
+
+Confirm the memory was deleted.

gobby/install/codex/prompts/memories.md

@@ -0,0 +1,7 @@
+# Memories
+
+List all stored memories using gobby-memory MCP tools.
+
+Use the `list_memories` tool on the `gobby-memory` server.
+
+Display memories in a table format with: ID, Type, Importance, Content (truncated).

gobby/install/codex/prompts/recall.md

@@ -0,0 +1,7 @@
+# Recall
+
+Search and retrieve memories using gobby-memory MCP tools.
+
+Use the `recall` tool on the `gobby-memory` server with the query provided.
+
+Display matching memories with their IDs, types, and importance scores.

gobby/install/codex/prompts/remember.md

@@ -0,0 +1,13 @@
+# Remember
+
+Store a memory for future sessions using gobby-memory MCP tools.
+
+Use the `remember` tool on the `gobby-memory` server with the content provided.
+
+**Memory types:**
+- `preference` - User preferences and coding style choices
+- `fact` - Project facts and technical details
+- `pattern` - Recurring code patterns
+- `context` - Background project context
+
+After storing, confirm the memory was saved and show its ID.

gobby/install/gemini/hooks/hook_dispatcher.py

@@ -0,0 +1,268 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "httpx",
+#     "pyyaml",
+# ]
+# ///
+"""Hook Dispatcher - Routes Gemini CLI hooks to HookManager.
+
+This is a thin wrapper script that receives hook calls from Gemini CLI
+and routes them to the appropriate handler via HookManager.
+
+Gemini CLI invokes hooks with JSON input on stdin and expects JSON output
+on stdout. Exit codes: 0 = allow, 2 = deny.
+
+Usage:
+    hook_dispatcher.py --type SessionStart < input.json > output.json
+    hook_dispatcher.py --type BeforeTool --debug < input.json > output.json
+
+Exit Codes:
+    0 - Success / Allow
+    1 - General error (logged, continues)
+    2 - Deny / Block
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+# Default daemon configuration
+DEFAULT_DAEMON_PORT = 8765
+DEFAULT_CONFIG_PATH = "~/.gobby/config.yaml"
+
+
+def get_daemon_url() -> str:
+    """Get the daemon HTTP URL from config file.
+
+    Reads daemon_port from ~/.gobby/config.yaml if it exists,
+    otherwise uses the default port 8765.
+
+    Returns:
+        Full daemon URL like http://localhost:8765
+    """
+    config_path = Path(DEFAULT_CONFIG_PATH).expanduser()
+
+    if config_path.exists():
+        try:
+            import yaml
+
+            with open(config_path) as f:
+                config = yaml.safe_load(f) or {}
+            port = config.get("daemon_port", DEFAULT_DAEMON_PORT)
+        except Exception:
+            # If config read fails, use default
+            port = DEFAULT_DAEMON_PORT
+    else:
+        port = DEFAULT_DAEMON_PORT
+
+    return f"http://localhost:{port}"
+
+
+def parse_arguments() -> argparse.Namespace:
+    """Parse command line arguments.
+
+    Returns:
+        Parsed arguments with type and debug flags
+    """
+    parser = argparse.ArgumentParser(description="Gemini CLI Hook Dispatcher")
+    parser.add_argument(
+        "--type",
+        required=True,
+        help="Hook type (e.g., SessionStart, BeforeTool)",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    return parser.parse_args()
+
+
+def check_daemon_running(timeout: float = 0.5) -> bool:
+    """Check if gobby daemon is active and responding.
+
+    Performs a quick health check to verify the HTTP server is running
+    before processing hooks. This prevents hook execution when the daemon
+    is stopped, avoiding long timeouts and confusing error messages.
+
+    Args:
+        timeout: Maximum time to wait for response in seconds (default: 0.5)
+
+    Returns:
+        True if daemon is running and responding, False otherwise
+    """
+    try:
+        import httpx
+
+        daemon_url = get_daemon_url()
+        response = httpx.get(
+            f"{daemon_url}/admin/status",
+            timeout=timeout,
+            follow_redirects=False,
+        )
+        return response.status_code == 200
+    except Exception:
+        # Any error (connection refused, timeout, etc.) means client is not running
+        return False
+
+
+def main() -> int:
+    """Main dispatcher execution.
+
+    Returns:
+        Exit code (0=allow, 1=error, 2=deny)
+    """
+    try:
+        # Parse arguments
+        args = parse_arguments()
+    except (argparse.ArgumentError, SystemExit):
+        # Argument parsing failed - return empty dict and exit 1
+        print(json.dumps({}))
+        return 1
+
+    hook_type = args.type  # PascalCase: SessionStart, BeforeTool, etc.
+    debug_mode = args.debug
+
+    # Check if gobby daemon is running before processing hooks
+    if not check_daemon_running():
+        # Daemon is not running - return gracefully without processing
+        print(
+            json.dumps({"status": "daemon_not_running", "message": "gobby daemon is not running"})
+        )
+        return 0  # Exit 0 (allow) - this is expected behavior, not an error
+
+    # Setup logger for dispatcher (not HookManager)
+    import logging
+
+    logger = logging.getLogger("gobby.hooks.gemini.dispatcher")
+    if debug_mode:
+        logging.basicConfig(level=logging.DEBUG)
+    else:
+        logging.basicConfig(level=logging.INFO)
+
+    try:
+        # Read JSON input from stdin
+        input_data = json.load(sys.stdin)
+
+        # Log what Gemini CLI sends us (for debugging hook data issues)
+        logger.info(f"[{hook_type}] Received input keys: {list(input_data.keys())}")
+
+        # Log hook-specific critical fields
+        if hook_type == "SessionStart":
+            logger.info(f"[SessionStart] session_id={input_data.get('session_id')}")
+        elif hook_type == "SessionEnd":
+            logger.info(
+                f"[SessionEnd] session_id={input_data.get('session_id')}, "
+                f"reason={input_data.get('reason')}"
+            )
+        elif hook_type == "BeforeAgent":
+            prompt = input_data.get("prompt", "")
+            prompt_preview = prompt[:100] + "..." if len(prompt) > 100 else prompt
+            logger.info(
+                f"[BeforeAgent] session_id={input_data.get('session_id')}, prompt={prompt_preview}"
+            )
+        elif hook_type == "BeforeTool":
+            tool_name = input_data.get("tool_name") or input_data.get("function_name", "unknown")
+            logger.info(
+                f"[BeforeTool] tool_name={tool_name}, session_id={input_data.get('session_id')}"
+            )
+        elif hook_type == "AfterTool":
+            tool_name = input_data.get("tool_name") or input_data.get("function_name", "unknown")
+            logger.info(
+                f"[AfterTool] tool_name={tool_name}, session_id={input_data.get('session_id')}"
+            )
+        elif hook_type == "BeforeToolSelection":
+            logger.info(f"[BeforeToolSelection] session_id={input_data.get('session_id')}")
+        elif hook_type == "BeforeModel":
+            logger.info(
+                f"[BeforeModel] session_id={input_data.get('session_id')}, "
+                f"model={input_data.get('model', 'unknown')}"
+            )
+        elif hook_type == "AfterModel":
+            logger.info(f"[AfterModel] session_id={input_data.get('session_id')}")
+        elif hook_type == "PreCompress":
+            logger.info(f"[PreCompress] session_id={input_data.get('session_id')}")
+        elif hook_type == "Notification":
+            logger.info(
+                f"[Notification] session_id={input_data.get('session_id')}, "
+                f"message={input_data.get('message')}"
+            )
+        elif hook_type == "AfterAgent":
+            logger.info(f"[AfterAgent] session_id={input_data.get('session_id')}")
+
+        if debug_mode:
+            logger.debug(f"Input data: {input_data}")
+
+    except json.JSONDecodeError as e:
+        # Invalid JSON input - return empty dict and exit 1
+        if debug_mode:
+            logger.error(f"JSON decode error: {e}")
+        print(json.dumps({}))
+        return 1
+
+    # Call daemon HTTP endpoint
+    import httpx
+
+    daemon_url = get_daemon_url()
+    try:
+        response = httpx.post(
+            f"{daemon_url}/hooks/execute",
+            json={
+                "hook_type": hook_type,  # PascalCase for Gemini
+                "input_data": input_data,
+                "source": "gemini",  # Required: identifies CLI source
+            },
+            timeout=30.0,  # Generous timeout for hook processing
+        )
+
+        if response.status_code == 200:
+            # Success - daemon returns result directly
+            result = response.json()
+
+            if debug_mode:
+                logger.debug(f"Output data: {result}")
+
+            # Determine exit code based on decision
+            decision = result.get("decision", "allow")
+
+            # Print JSON output for Gemini CLI
+            if result and result != {}:
+                print(json.dumps(result))
+
+            # Exit code: 0 = allow, 2 = deny
+            if decision == "deny":
+                return 2
+            return 0
+        else:
+            # HTTP error from daemon
+            error_detail = response.text
+            logger.error(
+                f"Daemon returned error: status={response.status_code}, detail={error_detail}"
+            )
+            print(json.dumps({"status": "error", "message": f"Daemon error: {error_detail}"}))
+            return 1
+
+    except httpx.ConnectError:
+        # Daemon not reachable
+        logger.error("Failed to connect to daemon (unreachable)")
+        print(json.dumps({"status": "error", "message": "Daemon unreachable"}))
+        return 1
+
+    except httpx.TimeoutException:
+        # Hook processing took too long
+        logger.error(f"Hook execution timeout: {hook_type}")
+        print(json.dumps({"status": "error", "message": "Hook execution timeout"}))
+        return 1
+
+    except Exception as e:
+        # General error - log and return 1
+        logger.error(f"Hook execution failed: {e}", exc_info=True)
+        print(json.dumps({"status": "error", "message": str(e)}))
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gobby/install/gemini/hooks-template.json

@@ -0,0 +1,138 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "name": "gobby-session-start",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=SessionStart",
+            "timeout": 30000
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "name": "gobby-session-end",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=SessionEnd",
+            "timeout": 30000
+          }
+        ]
+      }
+    ],
+    "BeforeAgent": [
+      {
+        "hooks": [
+          {
+            "name": "gobby-before-agent",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=BeforeAgent",
+            "timeout": 30000
+          }
+        ]
+      }
+    ],
+    "AfterAgent": [
+      {
+        "hooks": [
+          {
+            "name": "gobby-after-agent",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=AfterAgent",
+            "timeout": 30000
+          }
+        ]
+      }
+    ],
+    "BeforeTool": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "name": "gobby-before-tool",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=BeforeTool",
+            "timeout": 30000
+          }
+        ]
+      }
+    ],
+    "AfterTool": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "name": "gobby-after-tool",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=AfterTool",
+            "timeout": 30000
+          }
+        ]
+      }
+    ],
+    "BeforeToolSelection": [
+      {
+        "hooks": [
+          {
+            "name": "gobby-before-tool-selection",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=BeforeToolSelection",
+            "timeout": 30000
+          }
+        ]
+      }
+    ],
+    "BeforeModel": [
+      {
+        "hooks": [
+          {
+            "name": "gobby-before-model",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=BeforeModel",
+            "timeout": 30000
+          }
+        ]
+      }
+    ],
+    "AfterModel": [
+      {
+        "hooks": [
+          {
+            "name": "gobby-after-model",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=AfterModel",
+            "timeout": 30000
+          }
+        ]
+      }
+    ],
+    "PreCompress": [
+      {
+        "hooks": [
+          {
+            "name": "gobby-pre-compress",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=PreCompress",
+            "timeout": 30000
+          }
+        ]
+      }
+    ],
+    "Notification": [
+      {
+        "hooks": [
+          {
+            "name": "gobby-notification",
+            "type": "command",
+            "command": "uv run python \"$PROJECT_PATH/.gemini/hooks/hook_dispatcher.py\" --type=Notification",
+            "timeout": 30000
+          }
+        ]
+      }
+    ]
+  }
+}