gobby 0.2.5__py3-none-any.whl

gobby/cli/installers/antigravity.py

@@ -0,0 +1,65 @@
+"""
+Antigravity agent installation for Gobby MCP.
+
+This module handles installing Gobby MCP server configuration
+for the Antigravity agent (internal tool).
+
+Note: Antigravity does not currently support hooks, so only MCP
+configuration is installed.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from .shared import configure_mcp_server_json, install_shared_skills
+
+logger = logging.getLogger(__name__)
+
+
+def install_antigravity(project_path: Path) -> dict[str, Any]:
+    """Install Gobby integration for Antigravity agent (MCP only).
+
+    Antigravity does not support hooks, so this only configures
+    the MCP server in ~/.gemini/antigravity/mcp_config.json.
+
+    Args:
+        project_path: Path to the project root (unused, kept for API compatibility)
+
+    Returns:
+        Dict with installation results including success status
+    """
+    result: dict[str, Any] = {
+        "success": False,
+        "hooks_installed": [],
+        "workflows_installed": [],
+        "commands_installed": [],
+        "skills_installed": [],
+        "mcp_configured": False,
+        "mcp_already_configured": False,
+        "error": None,
+    }
+
+    # Configure MCP server in Antigravity's MCP config (~/.gemini/antigravity/mcp_config.json)
+    mcp_config = Path.home() / ".gemini" / "antigravity" / "mcp_config.json"
+
+    # Install shared skills to ~/.antigravity/skills/ (Standard Antigravity location)
+    try:
+        skills_path = Path.home() / ".antigravity" / "skills"
+        skills = install_shared_skills(skills_path)
+        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
+    except Exception as e:
+        logger.error(f"Failed to install shared skills: {e}")
+        # Proceeding despite skill install failure
+
+    mcp_result = configure_mcp_server_json(mcp_config)
+
+    if mcp_result["success"]:
+        result["mcp_configured"] = mcp_result.get("added", False)
+        result["mcp_already_configured"] = mcp_result.get("already_configured", False)
+        result["success"] = True
+    else:
+        result["error"] = mcp_result.get("error", "Unknown error configuring MCP")
+        logger.error(f"Failed to configure MCP server: {result['error']}")
+
+    return result

gobby/cli/installers/claude.py

@@ -0,0 +1,363 @@
+"""
+Claude Code installation for Gobby hooks.
+
+This module handles installing and uninstalling Gobby hooks
+and workflows for Claude Code CLI.
+"""
+
+import json
+import logging
+import os
+import tempfile
+import time
+from pathlib import Path
+from shutil import copy2
+from typing import Any
+
+from gobby.cli.utils import get_install_dir
+
+from .shared import (
+    configure_mcp_server_json,
+    install_cli_content,
+    install_shared_content,
+    install_shared_skills,
+    remove_mcp_server_json,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def install_claude(project_path: Path) -> dict[str, Any]:
+    """Install Gobby integration for Claude Code (hooks, workflows).
+
+    Args:
+        project_path: Path to the project root
+
+    Returns:
+        Dict with installation results including success status and installed items
+    """
+    hooks_installed: list[str] = []
+    result: dict[str, Any] = {
+        "success": False,
+        "hooks_installed": hooks_installed,
+        "workflows_installed": [],
+        "commands_installed": [],
+        "mcp_configured": False,
+        "mcp_already_configured": False,
+        "error": None,
+    }
+
+    claude_path = project_path / ".claude"
+    settings_file = claude_path / "settings.json"
+
+    # Ensure .claude subdirectories exist
+    claude_path.mkdir(parents=True, exist_ok=True)
+    hooks_dir = claude_path / "hooks"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+
+    # Get source files
+    install_dir = get_install_dir()
+    claude_install_dir = install_dir / "claude"
+    install_hooks_dir = claude_install_dir / "hooks"
+
+    # Hook files to copy
+    hook_files = {
+        "hook_dispatcher.py": True,  # Make executable
+        "validate_settings.py": True,  # Make executable
+    }
+
+    source_hooks_template = claude_install_dir / "hooks-template.json"
+
+    # Verify all source files exist
+    missing_files = []
+    for filename in hook_files.keys():
+        source_file = install_hooks_dir / filename
+        if not source_file.exists():
+            missing_files.append(str(source_file))
+
+    if not source_hooks_template.exists():
+        missing_files.append(str(source_hooks_template))
+
+    if missing_files:
+        result["error"] = f"Missing source files: {missing_files}"
+        return result
+
+    # Copy hook files
+    try:
+        for filename, make_executable in hook_files.items():
+            source_file = install_hooks_dir / filename
+            target_file = hooks_dir / filename
+
+            if target_file.exists():
+                target_file.unlink()
+
+            copy2(source_file, target_file)
+            if make_executable:
+                target_file.chmod(0o755)
+    except OSError as e:
+        logger.error(f"Failed to copy hook files: {e}")
+        result["error"] = f"Failed to copy hook files: {e}"
+        return result
+
+    # Install shared content (workflows)
+    try:
+        shared = install_shared_content(claude_path, project_path)
+    except Exception as e:
+        logger.error(f"Failed to install shared content: {e}")
+        result["error"] = f"Failed to install shared content: {e}"
+        return result
+
+    # Install CLI-specific content (can override shared)
+    try:
+        cli = install_cli_content("claude", claude_path)
+    except Exception as e:
+        logger.error(f"Failed to install CLI content: {e}")
+        result["error"] = f"Failed to install CLI content: {e}"
+        return result
+
+    result["workflows_installed"] = shared["workflows"] + cli["workflows"]
+    result["commands_installed"] = cli.get("commands", [])
+    result["plugins_installed"] = shared.get("plugins", [])
+
+    # Install shared skills (SKILL.md)
+    try:
+        skills = install_shared_skills(claude_path / "skills")
+        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
+    except Exception as e:
+        logger.error(f"Failed to install shared skills: {e}")
+        result["error"] = f"Failed to install shared skills: {e}"
+        # Proceeding despite skill install failure
+
+    # Backup existing settings.json if it exists
+    backup_file = None
+    if settings_file.exists():
+        timestamp = int(time.time())
+        backup_file = claude_path / f"settings.json.{timestamp}.backup"
+        try:
+            copy2(settings_file, backup_file)
+        except OSError as e:
+            logger.error(f"Failed to create backup of settings.json: {e}")
+            result["error"] = f"Failed to create backup: {e}"
+            return result
+
+        # Verify backup exists
+        if not backup_file.exists():
+            logger.error("Backup file was not created successfully")
+            result["error"] = "Backup file was not created successfully"
+            return result
+
+    # Load existing settings or create empty
+    existing_settings: dict[str, Any] = {}
+    if settings_file.exists():
+        try:
+            with open(settings_file) as f:
+                existing_settings = json.load(f)
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse settings.json: {e}")
+            result["error"] = f"Failed to parse settings.json: {e}"
+            return result
+        except OSError as e:
+            logger.error(f"Failed to read settings.json: {e}")
+            result["error"] = f"Failed to read settings.json: {e}"
+            return result
+
+    # Load Gobby hooks from template
+    try:
+        with open(source_hooks_template) as f:
+            gobby_settings_str = f.read()
+    except OSError as e:
+        logger.error(f"Failed to read hooks template: {e}")
+        result["error"] = f"Failed to read hooks template: {e}"
+        return result
+
+    # Replace $PROJECT_PATH with absolute project path
+    abs_project_path = str(project_path.resolve())
+    gobby_settings_str = gobby_settings_str.replace("$PROJECT_PATH", abs_project_path)
+
+    try:
+        gobby_settings = json.loads(gobby_settings_str)
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to parse hooks template: {e}")
+        result["error"] = f"Failed to parse hooks template: {e}"
+        return result
+
+    # Ensure hooks section exists
+    if "hooks" not in existing_settings:
+        existing_settings["hooks"] = {}
+
+    # Merge Gobby hooks
+    gobby_hooks = gobby_settings.get("hooks", {})
+    for hook_type, hook_config in gobby_hooks.items():
+        existing_settings["hooks"][hook_type] = hook_config
+        hooks_installed.append(hook_type)
+
+    # Write merged settings back using atomic write
+    try:
+        fd, temp_path = tempfile.mkstemp(dir=str(claude_path), suffix=".tmp", prefix="settings_")
+        try:
+            with os.fdopen(fd, "w") as f:
+                json.dump(existing_settings, f, indent=2)
+                f.flush()
+                os.fsync(f.fileno())
+            # Atomic replace
+            os.replace(temp_path, settings_file)
+        except Exception:
+            # Clean up temp file if it still exists
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+            raise
+    except OSError as e:
+        logger.error(f"Failed to write settings.json: {e}")
+        # Attempt to restore from backup if we have one
+        if backup_file and backup_file.exists():
+            try:
+                copy2(backup_file, settings_file)
+                logger.info("Restored settings.json from backup after write failure")
+            except OSError as restore_error:
+                logger.error(f"Failed to restore from backup: {restore_error}")
+        result["error"] = f"Failed to write settings.json: {e}"
+        return result
+
+    # Configure MCP server in global settings (~/.claude.json)
+    # Note: Claude Code uses ~/.claude.json for user-scoped MCP servers
+    global_settings = Path.home() / ".claude.json"
+    mcp_result = configure_mcp_server_json(global_settings)
+    if mcp_result["success"]:
+        result["mcp_configured"] = mcp_result.get("added", False)
+        result["mcp_already_configured"] = mcp_result.get("already_configured", False)
+    else:
+        # MCP config failure is non-fatal, just log it
+        logger.warning(f"Failed to configure MCP server: {mcp_result['error']}")
+
+    result["success"] = True
+    return result
+
+
+def uninstall_claude(project_path: Path) -> dict[str, Any]:
+    """Uninstall Gobby integration from Claude Code.
+
+    Args:
+        project_path: Path to the project root
+
+    Returns:
+        Dict with uninstallation results including success status and removed items
+    """
+    hooks_removed: list[str] = []
+    files_removed: list[str] = []
+
+    result: dict[str, Any] = {
+        "success": False,
+        "hooks_removed": hooks_removed,
+        "files_removed": files_removed,
+        "mcp_removed": False,
+        "error": None,
+    }
+
+    claude_path = project_path / ".claude"
+    settings_file = claude_path / "settings.json"
+    hooks_dir = claude_path / "hooks"
+
+    if not settings_file.exists():
+        result["error"] = f"Settings file not found: {settings_file}"
+        return result
+
+    # Backup settings.json with verification
+    timestamp = int(time.time())
+    backup_file = claude_path / f"settings.json.{timestamp}.backup"
+    try:
+        copy2(settings_file, backup_file)
+    except OSError as e:
+        logger.error(f"Failed to create backup of settings.json: {e}")
+        result["error"] = f"Failed to create backup: {e}"
+        return result
+
+    # Verify backup exists before proceeding
+    if not backup_file.exists():
+        logger.error("Backup file was not created successfully")
+        result["error"] = "Backup file was not created successfully"
+        return result
+
+    # Read and parse settings.json
+    try:
+        with open(settings_file) as f:
+            settings = json.load(f)
+    except json.JSONDecodeError as e:
+        logger.error(f"Failed to parse settings.json: {e}")
+        result["error"] = f"Failed to parse settings.json: {e}"
+        return result
+    except OSError as e:
+        logger.error(f"Failed to read settings.json: {e}")
+        result["error"] = f"Failed to read settings.json: {e}"
+        return result
+
+    if "hooks" in settings:
+        hook_types = [
+            "SessionStart",
+            "SessionEnd",
+            "UserPromptSubmit",
+            "PreToolUse",
+            "PostToolUse",
+            "PreCompact",
+            "Notification",
+            "Stop",
+            "SubagentStart",
+            "SubagentStop",
+            "PermissionRequest",
+        ]
+
+        for hook_type in hook_types:
+            if hook_type in settings["hooks"]:
+                del settings["hooks"][hook_type]
+                hooks_removed.append(hook_type)
+
+        # Write to temp file and atomically replace
+        try:
+            # Create temp file in same directory for atomic replace
+            fd, temp_path = tempfile.mkstemp(
+                dir=str(claude_path), suffix=".tmp", prefix="settings_"
+            )
+            try:
+                with os.fdopen(fd, "w") as f:
+                    json.dump(settings, f, indent=2)
+                    f.flush()
+                    os.fsync(f.fileno())
+                # Atomic replace
+                os.replace(temp_path, settings_file)
+            except Exception:
+                # Clean up temp file if it still exists
+                if os.path.exists(temp_path):
+                    os.unlink(temp_path)
+                raise
+        except OSError as e:
+            logger.error(f"Failed to write settings.json: {e}")
+            # Attempt to restore from backup
+            try:
+                copy2(backup_file, settings_file)
+                logger.info("Restored settings.json from backup after write failure")
+            except OSError as restore_error:
+                logger.error(f"Failed to restore from backup: {restore_error}")
+            result["error"] = f"Failed to write settings.json: {e}"
+            return result
+
+    # Remove hook files
+    hook_files = [
+        "hook_dispatcher.py",
+        "validate_settings.py",
+        "README.md",
+        "HOOK_SCHEMAS.md",
+    ]
+
+    for filename in hook_files:
+        file_path = hooks_dir / filename
+        if file_path.exists():
+            file_path.unlink()
+            files_removed.append(filename)
+
+    # Remove MCP server from global settings (~/.claude.json)
+    global_settings = Path.home() / ".claude.json"
+    mcp_result = remove_mcp_server_json(global_settings)
+    if mcp_result["success"]:
+        result["mcp_removed"] = mcp_result.get("removed", False)
+
+    result["success"] = True
+    return result

gobby/cli/installers/codex.py

@@ -0,0 +1,192 @@
+"""
+Codex CLI installation for Gobby hooks.
+
+This module handles installing and uninstalling Gobby notify integration
+for OpenAI Codex CLI.
+"""
+
+import json
+import logging
+import re
+from pathlib import Path
+from shutil import copy2
+from typing import Any
+
+from gobby.cli.utils import get_install_dir
+
+from .shared import (
+    configure_mcp_server_toml,
+    install_cli_content,
+    install_shared_content,
+    install_shared_skills,
+    remove_mcp_server_toml,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def install_codex_notify() -> dict[str, Any]:
+    """Install Codex notify script and configure ~/.codex/config.toml.
+
+    Returns:
+        Dict with installation results including success status and installed items
+    """
+    files_installed: list[str] = []
+    result: dict[str, Any] = {
+        "success": False,
+        "files_installed": files_installed,
+        "workflows_installed": [],
+        "commands_installed": [],
+        "config_updated": False,
+        "mcp_configured": False,
+        "mcp_already_configured": False,
+        "error": None,
+    }
+
+    install_dir = get_install_dir()
+    source_notify = install_dir / "codex" / "hooks" / "hook_dispatcher.py"
+    if not source_notify.exists():
+        result["error"] = f"Missing source file: {source_notify}"
+        return result
+
+    # Install hook dispatcher to ~/.gobby/hooks/codex/hook_dispatcher.py
+    notify_dir = Path.home() / ".gobby" / "hooks" / "codex"
+    notify_dir.mkdir(parents=True, exist_ok=True)
+    target_notify = notify_dir / "hook_dispatcher.py"
+
+    if target_notify.exists():
+        target_notify.unlink()
+
+    copy2(source_notify, target_notify)
+    target_notify.chmod(0o755)
+    files_installed.append(str(target_notify))
+
+    # Install shared content - workflows to ~/.gobby
+    codex_home = Path.home() / ".codex"
+    gobby_home = Path.home()  # workflows go to ~/.gobby/workflows/
+
+    shared = install_shared_content(codex_home, gobby_home)
+    # Install CLI-specific content (can override shared)
+    cli = install_cli_content("codex", codex_home)
+
+    # Install shared skills (SKILL.md)
+    try:
+        skills = install_shared_skills(codex_home / "skills")
+        result["commands_installed"].extend([f"{s} (skill)" for s in skills])
+    except Exception as e:
+        logger.error(f"Failed to install shared skills: {e}")
+        # Proceeding despite skill install failure
+
+    result["workflows_installed"] = shared["workflows"] + cli["workflows"]
+    result["commands_installed"] = cli.get("commands", [])
+    result["plugins_installed"] = shared.get("plugins", [])
+
+    # Update ~/.codex/config.toml
+    codex_config_dir = codex_home
+
+    codex_config_dir.mkdir(parents=True, exist_ok=True)
+    codex_config_path = codex_config_dir / "config.toml"
+
+    notify_command = ["python3", str(target_notify)]
+    notify_line = f"notify = {json.dumps(notify_command)}"
+
+    try:
+        if codex_config_path.exists():
+            existing = codex_config_path.read_text(encoding="utf-8")
+        else:
+            existing = ""
+
+        pattern = re.compile(r"(?m)^\s*notify\s*=.*$")
+        if pattern.search(existing):
+            updated = pattern.sub(notify_line, existing)
+        else:
+            updated = (existing.rstrip() + "\n\n" if existing.strip() else "") + notify_line + "\n"
+
+        if updated != existing:
+            if codex_config_path.exists():
+                backup_path = codex_config_path.with_suffix(".toml.bak")
+                backup_path.write_text(existing, encoding="utf-8")
+
+            codex_config_path.write_text(updated, encoding="utf-8")
+            result["config_updated"] = True
+
+        # Configure MCP server in global config (~/.codex/config.toml)
+        mcp_result = configure_mcp_server_toml(codex_config_path)
+        if mcp_result["success"]:
+            result["mcp_configured"] = mcp_result.get("added", False)
+            result["mcp_already_configured"] = mcp_result.get("already_configured", False)
+        else:
+            # MCP config failure is non-fatal, just log it
+            logger.warning(f"Failed to configure MCP server: {mcp_result['error']}")
+
+        result["success"] = True
+        return result
+
+    except Exception as e:
+        result["error"] = f"Failed to update Codex config: {e}"
+        return result
+
+
+def uninstall_codex_notify() -> dict[str, Any]:
+    """Uninstall Codex notify script and remove from ~/.codex/config.toml.
+
+    Returns:
+        Dict with uninstallation results including success status and removed items
+    """
+    files_removed: list[str] = []
+    result: dict[str, Any] = {
+        "success": False,
+        "files_removed": files_removed,
+        "config_updated": False,
+        "mcp_removed": False,
+        "error": None,
+    }
+
+    # Remove hook dispatcher from ~/.gobby/hooks/codex/hook_dispatcher.py
+    notify_file = Path.home() / ".gobby" / "hooks" / "codex" / "hook_dispatcher.py"
+    if notify_file.exists():
+        notify_file.unlink()
+        files_removed.append(str(notify_file))
+
+    # Try to remove empty parent directories
+    notify_dir = notify_file.parent
+    try:
+        if notify_dir.exists() and not any(notify_dir.iterdir()):
+            notify_dir.rmdir()
+    except Exception:
+        pass  # nosec B110 - best-effort cleanup, directory removal is non-critical
+
+    # Update ~/.codex/config.toml to remove notify line
+    codex_config_path = Path.home() / ".codex" / "config.toml"
+
+    try:
+        if codex_config_path.exists():
+            existing = codex_config_path.read_text(encoding="utf-8")
+
+            # Remove notify = [...] line
+            pattern = re.compile(r"(?m)^\s*notify\s*=.*$\n?")
+            if pattern.search(existing):
+                updated = pattern.sub("", existing)
+
+                # Clean up multiple blank lines
+                updated = re.sub(r"\n{3,}", "\n\n", updated)
+
+                if updated != existing:
+                    # Backup before modifying
+                    backup_path = codex_config_path.with_suffix(".toml.bak")
+                    backup_path.write_text(existing, encoding="utf-8")
+
+                    codex_config_path.write_text(updated, encoding="utf-8")
+                    result["config_updated"] = True
+
+        # Remove MCP server from config
+        mcp_result = remove_mcp_server_toml(codex_config_path)
+        if mcp_result["success"]:
+            result["mcp_removed"] = mcp_result.get("removed", False)
+
+        result["success"] = True
+        return result
+
+    except Exception as e:
+        result["error"] = f"Failed to update Codex config: {e}"
+        return result