deploy.py

"""Deploy subcommand: generate MCP JSON config for a target IDE."""

from __future__ import annotations

import json
import sys
from pathlib import Path

from vendors.codegrave_directive import CODEGRAVE_SYSTEM_DIRECTIVE

DEPLOY_DEFAULTS: dict[str, Path] = {
    "claude": Path(".mcp.json"),
    "opencode": Path.home() / ".config" / "opencode" / "opencode.json",
    "windsurf": Path.home() / ".codeium" / "windsurf" / "mcp_config.json",
    "cline": Path.home() / ".cline" / "mcp.json",
    "copilot": Path.home() / ".copilot" / "mcp-config.json",
}

SERVER_KEY = "codegrave"


def _resolve_binary() -> str:
    if getattr(sys, "frozen", False):
        return sys.executable

    binary_name = "codegrave.exe" if sys.platform == "win32" else "codegrave"
    cwd_path = Path.cwd() / "dist" / binary_name
    if cwd_path.exists():
        return str(cwd_path)

    script_dir = Path(__file__).resolve().parent
    dev_path = script_dir / "dist" / binary_name
    if dev_path.exists():
        return str(dev_path)

    print("Error: Binary not found. Run './please build' first.")
    sys.exit(1)


def _load_existing(path: Path) -> dict:
    if not path.exists():
        return {}

    try:
        return json.loads(path.read_text(encoding="utf-8"))
    except json.JSONDecodeError:
        print(f"Warning: {path.name} is corrupted. Backing up and recreating.")
        path.rename(path.with_suffix(".json.bak"))
        return {}


def _generate_claude_config(binary: str) -> dict:
    return {
        "mcpServers": {
            SERVER_KEY: {
                "command": binary,
                "args": [],
            }
        }
    }


def _generate_copilot_config(binary: str) -> dict:
    """Copilot CLI uses "type": "local" + "tools": ["*"] schema."""
    return {
        "mcpServers": {
            SERVER_KEY: {
                "type": "local",
                "command": binary,
                "args": [],
                "tools": ["*"],
            }
        }
    }


def _generate_opencode_config(binary: str) -> dict:
    return {
        "mcp": {
            SERVER_KEY: {
                "type": "local",
                "command": [binary],
                "enabled": True,
            }
        },
        "agent": {
            SERVER_KEY: {
                "description": "Autonomous software engineer bound to a localized memory of dead bugs.",
                "mode": "primary",
                "tools": {
                    "write": True,
                    "edit": True,
                    "bash": True,
                },
                "prompt": "{file:./prompts/codegrave.txt}",
            }
        },
        "default_agent": SERVER_KEY,
    }


def _merge_config(existing: dict, generated: dict) -> dict:
    merged = dict(existing)

    for top_key in generated:
        if top_key in merged and isinstance(merged[top_key], dict) and isinstance(generated[top_key], dict):
            merged[top_key] = dict(merged[top_key])
            merged[top_key].update(generated[top_key])
        else:
            merged[top_key] = generated[top_key]

    return merged


def _write_json(path: Path, data: dict) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")


def deploy(target: str, dump_path: Path | None = None, binary_path: str | None = None) -> None:
    if binary_path is not None:
        if not Path(binary_path).exists():
            print(f"Error: Binary not found at {binary_path}. Run './please build' first.")
            sys.exit(1)
        binary = binary_path
    else:
        binary = _resolve_binary()

    if target == "claude":
        generated = _generate_claude_config(binary)
    elif target == "opencode":
        generated = _generate_opencode_config(binary)
    elif target == "windsurf":
        generated = _generate_claude_config(binary)  # same schema as claude
    elif target == "cline":
        generated = _generate_claude_config(binary)  # same schema as claude
    elif target == "copilot":
        generated = _generate_copilot_config(binary)
    else:
        print(f"Error: Unknown deploy target '{target}'.")
        sys.exit(1)

    if dump_path is not None:
        _write_json(dump_path, generated)
        print(f"MCP config written to {dump_path}")
        return

    default_path = DEPLOY_DEFAULTS[target]
    existing = _load_existing(default_path.resolve())
    merged = _merge_config(existing, generated)
    _write_json(default_path.resolve(), merged)

    if target == "opencode":
        prompt_dir = default_path.resolve().parent / "prompts"
        prompt_dir.mkdir(parents=True, exist_ok=True)
        prompt_file = prompt_dir / "codegrave.txt"
        prompt_file.write_text(CODEGRAVE_SYSTEM_DIRECTIVE, encoding="utf-8")

    print(f"MCP config written to {default_path.resolve()}")
    if target == "opencode":
        print(f"Agent prompt written to {default_path.resolve().parent / 'prompts' / 'codegrave.txt'}")
    print(f"Server key: {SERVER_KEY} -> {binary}")