code-puppy-core-plugins 0.0.2__py3-none-any.whl

code_puppy_core_plugins/hook_manager/register_callbacks.py

@@ -0,0 +1,227 @@
+"""
+Hook Manager plugin – registers callbacks for interactive hook management.
+
+Provides:
+  /hooks           – Launch interactive TUI menu (shows global + project hooks)
+  /hooks list      – Quick text listing of all configured hooks
+  /hooks enable    – Enable all hooks (both global and project)
+  /hooks disable   – Disable all hooks (both global and project)
+  /hooks status    – Show summary counts per event type
+"""
+
+import logging
+from typing import Any, List, Optional, Tuple
+
+from code_puppy.callbacks import register_callback
+
+logger = logging.getLogger(__name__)
+
+_COMMAND_NAME = "hooks"
+_ALIASES = ("hook",)
+
+
+# ---------------------------------------------------------------------------
+# /help entry
+# ---------------------------------------------------------------------------
+
+
+def _hooks_command_help() -> List[Tuple[str, str]]:
+    """Advertise /hooks in the /help menu."""
+    return [
+        (
+            "hooks",
+            "Manage Claude Code hooks (global + project) – browse, enable/disable, inspect",
+        ),
+        ("hook", "Alias for /hooks"),
+    ]
+
+
+# ---------------------------------------------------------------------------
+# /hooks command handler
+# ---------------------------------------------------------------------------
+
+
+def _handle_hooks_command(command: str, name: str) -> Optional[Any]:
+    """Handle /hooks (and /hook) slash commands.
+
+    Sub-commands
+    ------------
+    /hooks           Launch interactive TUI menu (shows both global and project hooks)
+    /hooks list      Print all hooks as text
+    /hooks enable    Enable every hook (both global and project)
+    /hooks disable   Disable every hook (both global and project)
+    /hooks status    Show counts per event type
+    """
+    if name not in (_COMMAND_NAME, *_ALIASES):
+        return None  # Not our command – pass through
+    import copy
+
+    from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
+
+    from .config import (
+        _load_global_hooks_config,
+        _load_project_hooks_config,
+        flatten_all_hooks,
+        save_global_hooks_config,
+        save_hooks_config,
+    )
+
+    tokens = command.split()
+    subcommand = tokens[1].lower() if len(tokens) > 1 else ""
+
+    # ------------------------------------------------------------------ list
+    if subcommand == "list":
+        entries = flatten_all_hooks()
+        if not entries:
+            emit_info("No hooks configured.")
+            emit_info("Add hooks to .claude/settings.json (project):")
+            emit_info('  { "hooks": { "PreToolUse": [ ... ] } }')
+            emit_info("Or to ~/.code_puppy/hooks.json (global)")
+            return True
+        emit_info(f"\U0001f3a3 Hooks ({len(entries)} total)\n")
+
+        # Group by source for clarity
+        project_hooks = [e for e in entries if e.source == "project"]
+        global_hooks = [e for e in entries if e.source == "global"]
+
+        if project_hooks:
+            emit_info("📁 PROJECT HOOKS (.claude/settings.json):")
+            for entry in project_hooks:
+                status = (
+                    "\U0001f7e2 enabled " if entry.enabled else "\U0001f534 disabled"
+                )
+                emit_info(
+                    f"  {status}  [{entry.event_type}]  matcher={entry.display_matcher}"
+                )
+                emit_info(f"      {entry.display_command}")
+                emit_info("")
+
+        if global_hooks:
+            emit_info("🌍 GLOBAL HOOKS (~/.code_puppy/hooks.json):")
+            for entry in global_hooks:
+                status = (
+                    "\U0001f7e2 enabled " if entry.enabled else "\U0001f534 disabled"
+                )
+                emit_info(
+                    f"  {status}  [{entry.event_type}]  matcher={entry.display_matcher}"
+                )
+                emit_info(f"      {entry.display_command}")
+                emit_info("")
+
+        return True
+    # --------------------------------------------------------------- enable
+    if subcommand == "enable":
+        count = 0
+
+        # Enable all project hooks
+        project_config = _load_project_hooks_config()
+        project_cfg = copy.deepcopy(project_config)
+        for groups in project_cfg.values():
+            if not isinstance(groups, list):
+                continue
+            for group in groups:
+                for hook in group.get("hooks", []):
+                    hook["enabled"] = True
+                    count += 1
+        if project_config:
+            save_hooks_config(project_cfg)
+
+        # Enable all global hooks
+        global_config = _load_global_hooks_config()
+        global_cfg = copy.deepcopy(global_config)
+        for groups in global_cfg.values():
+            if not isinstance(groups, list):
+                continue
+            for group in groups:
+                for hook in group.get("hooks", []):
+                    hook["enabled"] = True
+                    count += 1
+        if global_config:
+            save_global_hooks_config(global_cfg)
+
+        emit_success(f"\u2705 Enabled {count} hook(s).")
+        return True
+    # -------------------------------------------------------------- disable
+    if subcommand == "disable":
+        count = 0
+
+        # Disable all project hooks
+        project_config = _load_project_hooks_config()
+        project_cfg = copy.deepcopy(project_config)
+        for groups in project_cfg.values():
+            if not isinstance(groups, list):
+                continue
+            for group in groups:
+                for hook in group.get("hooks", []):
+                    hook["enabled"] = False
+                    count += 1
+        if project_config:
+            save_hooks_config(project_cfg)
+
+        # Disable all global hooks
+        global_config = _load_global_hooks_config()
+        global_cfg = copy.deepcopy(global_config)
+        for groups in global_cfg.values():
+            if not isinstance(groups, list):
+                continue
+            for group in groups:
+                for hook in group.get("hooks", []):
+                    hook["enabled"] = False
+                    count += 1
+        if global_config:
+            save_global_hooks_config(global_cfg)
+
+        emit_warning(f"\U0001f534 Disabled {count} hook(s).")
+        return True
+    # --------------------------------------------------------------- status
+    if subcommand == "status":
+        entries = flatten_all_hooks()
+        if not entries:
+            emit_info("No hooks configured.")
+            return True
+        from collections import Counter
+
+        by_event: Counter = Counter()
+        enabled_by_event: Counter = Counter()
+        by_source: Counter = Counter()
+
+        for entry in entries:
+            by_event[entry.event_type] += 1
+            by_source[entry.source] += 1
+            if entry.enabled:
+                enabled_by_event[entry.event_type] += 1
+
+        emit_info(
+            f"\U0001f4ca Hook status  "
+            f"({sum(enabled_by_event.values())}/{len(entries)} enabled)\n"
+        )
+        for event_type, total in sorted(by_event.items()):
+            enabled = enabled_by_event[event_type]
+            bar = "\u2588" * enabled + "\u2591" * (total - enabled)
+            emit_info(f"  {event_type:<20} {bar} {enabled}/{total}")
+
+        emit_info(
+            f"\nSources: {by_source['project']} project, {by_source['global']} global"
+        )
+        emit_info("")
+        return True
+    # ----------------------------------------------- unknown sub-command
+    if subcommand and subcommand not in ("", "tui"):
+        emit_error(f"Unknown sub-command: {subcommand}")
+        emit_info("Usage: /hooks [list|enable|disable|status]")
+        return True
+    # --------------------------------------------------- default: TUI menu
+    from .hooks_menu import show_hooks_menu
+
+    show_hooks_menu()
+    return True
+
+
+# ---------------------------------------------------------------------------
+# Register callbacks
+# ---------------------------------------------------------------------------
+
+register_callback("custom_command_help", _hooks_command_help)
+register_callback("custom_command", _handle_hooks_command)
+
+logger.info("Hook Manager plugin loaded")

code_puppy_core_plugins/meta_oauth/__init__.py

@@ -0,0 +1 @@
+"""Meta Muse OAuth integration for Code Puppy."""

code_puppy_core_plugins/meta_oauth/config.py

@@ -0,0 +1,55 @@
+"""Configuration for Meta Muse device-code OAuth."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from code_puppy import config
+
+META_OAUTH_CONFIG: dict[str, Any] = {
+    "auth_base_url": "https://auth.meta.com",
+    "device_authorization_path": "/oidc/device/authorization/",
+    "device_token_path": "/oidc/device/token/",
+    "device_code_grant": "urn:ietf:params:oauth:grant-type:device_code",
+    # Public client used by the official Muse Code launcher.
+    "client_id": "1031625952748946",
+    "api_origin": "https://api.meta.ai",
+    "api_base_url": "https://api.meta.ai/v1",
+    "mint_url": "https://api.meta.ai/muse-code/key",
+    "catalog_url": "https://api.meta.ai/muse-code/models",
+    "api_version": "1.0.0",
+    "request_timeout": 30,
+    "poll_timeout": 1_800,
+    "prefix": "meta-",
+    "default_model": "muse-spark-1.2-contributor",
+}
+
+# Used when Meta's richer model catalogue is temporarily unavailable.
+FALLBACK_MODELS: dict[str, dict[str, Any]] = {
+    "muse-spark-1.2-contributor": {
+        "context_length": 1_007_997,
+        "supported_settings": ["reasoning_effort"],
+    },
+    "muse-spark-1.2": {
+        "context_length": 1_007_997,
+        "supported_settings": ["reasoning_effort"],
+    },
+}
+
+
+def get_token_storage_path() -> Path:
+    """Return Code Puppy's private Meta credential path."""
+    data_dir = Path(config.DATA_DIR)
+    data_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+    return data_dir / "meta_oauth.json"
+
+
+def get_muse_auth_path() -> Path:
+    """Return the official Muse CLI credential path."""
+    override = os.getenv("MUSE_AUTH_PATH")
+    if override:
+        return Path(override).expanduser()
+    config_home = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
+    return config_home / "muse" / "auth.json"

code_puppy_core_plugins/meta_oauth/oauth_flow.py

@@ -0,0 +1,109 @@
+"""Interactive Meta Muse device-code OAuth flow."""
+
+from __future__ import annotations
+
+import time
+import webbrowser
+from typing import Any
+
+from code_puppy.i18n import t
+from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
+from code_puppy.tools.common import should_suppress_browser
+
+from .config import META_OAUTH_CONFIG
+from .utils import (
+    discover_models,
+    load_credentials,
+    mint_api_credentials,
+    poll_device_token,
+    request_device_authorization,
+    save_credentials,
+)
+
+
+def _open_verification_page(url: str) -> None:
+    if should_suppress_browser():
+        emit_info(t("oauth.meta.browser.headless", url=url))
+        return
+    try:
+        if not webbrowser.open(url):
+            emit_warning(t("oauth.meta.browser.manual", url=url))
+    except Exception as exc:  # noqa: BLE001
+        emit_warning(t("oauth.meta.browser.failed", error=str(exc), url=url))
+
+
+def _poll_for_access_token(device: dict[str, Any]) -> dict[str, Any] | None:
+    interval = max(int(device.get("interval") or 5), 1)
+    lifetime = min(
+        max(int(device.get("expires_in") or 900), 60),
+        int(META_OAUTH_CONFIG["poll_timeout"]),
+    )
+    deadline = time.monotonic() + lifetime
+
+    while time.monotonic() < deadline:
+        state, payload = poll_device_token(str(device["device_code"]))
+        if state == "authorized":
+            return payload
+        if state == "slow_down":
+            interval += 5
+        elif state == "access_denied":
+            emit_error(t("oauth.meta.auth.denied"))
+            return None
+        elif state == "expired_token":
+            break
+        elif state != "authorization_pending":
+            emit_error(t("oauth.meta.auth.failed", error=state))
+            return None
+        time.sleep(interval)
+
+    emit_error(t("oauth.meta.auth.expired"))
+    return None
+
+
+def run_oauth_flow() -> bool:
+    """Authenticate a Meta account, mint a Model API key, and save it."""
+    existing = load_credentials()
+    if existing and existing.get("api_key"):
+        emit_warning(t("oauth.meta.auth.overwrite"))
+
+    try:
+        device = request_device_authorization()
+    except Exception as exc:  # noqa: BLE001
+        emit_error(t("oauth.meta.auth.start_failed", error=str(exc)))
+        return False
+
+    url = str(
+        device.get("verification_uri_complete") or device.get("verification_uri") or ""
+    )
+    code = str(device.get("user_code") or "")
+    if not url or not code or not device.get("device_code"):
+        emit_error(t("oauth.meta.auth.invalid_response"))
+        return False
+
+    emit_info(t("oauth.meta.auth.open", url=url))
+    emit_info(t("oauth.meta.auth.code", code=code))
+    _open_verification_page(url)
+    emit_info(t("oauth.meta.auth.waiting"))
+
+    try:
+        token_payload = _poll_for_access_token(device)
+        if not token_payload:
+            return False
+        access_token = str(token_payload.get("access_token") or "")
+        if not access_token:
+            raise RuntimeError(t("oauth.meta.auth.no_access_token"))
+
+        credentials = mint_api_credentials(access_token)
+        credentials["access_token"] = access_token
+        credentials["refresh_token"] = token_payload.get("refresh_token", "")
+        credentials["obtained_via"] = "device_code"
+        credentials["models"] = discover_models(credentials)
+        if not save_credentials(credentials):
+            emit_error(t("oauth.meta.auth.save_failed"))
+            return False
+    except Exception as exc:  # noqa: BLE001
+        emit_error(t("oauth.meta.auth.failed", error=str(exc)))
+        return False
+
+    emit_success(t("oauth.meta.auth.success"))
+    return True

code_puppy_core_plugins/meta_oauth/register_callbacks.py

@@ -0,0 +1,154 @@
+"""Callbacks for Meta Muse OAuth authentication and model registration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from code_puppy.callbacks import register_callback
+from code_puppy.i18n import t
+from code_puppy.messaging import emit_info, emit_success, emit_warning
+from code_puppy.model_switching import set_model_and_reload_agent
+
+from .config import FALLBACK_MODELS, META_OAUTH_CONFIG, get_token_storage_path
+from .oauth_flow import run_oauth_flow
+from .utils import discover_models, load_credentials
+
+_PREFIX = str(META_OAUTH_CONFIG["prefix"])
+_DEFAULT_MODEL = f"{_PREFIX}{META_OAUTH_CONFIG['default_model']}"
+_model_cache: dict[str, dict[str, Any]] | None = None
+
+
+def _custom_help() -> list[tuple[str, str]]:
+    return [
+        ("meta-auth", t("oauth.meta.help.auth")),
+        ("meta-status", t("oauth.meta.help.status")),
+        ("meta-logout", t("oauth.meta.help.logout")),
+    ]
+
+
+def _get_model_specs(credentials: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    global _model_cache
+    stored = credentials.get("models")
+    if isinstance(stored, dict):
+        valid = {
+            model_id: spec
+            for model_id, spec in stored.items()
+            if isinstance(model_id, str) and isinstance(spec, dict)
+        }
+        if valid:
+            return valid
+    if _model_cache is None:
+        try:
+            _model_cache = discover_models(credentials)
+        except Exception:  # noqa: BLE001 - catalogue outage must not break startup
+            _model_cache = dict(FALLBACK_MODELS)
+    return _model_cache
+
+
+def _meta_model_names(credentials: dict[str, Any] | None = None) -> list[str]:
+    credentials = credentials or load_credentials()
+    if not credentials:
+        return []
+    return [f"{_PREFIX}{model_id}" for model_id in _get_model_specs(credentials)]
+
+
+def _load_meta_models() -> dict[str, Any]:
+    """Inject Muse models when an API key is available."""
+    credentials = load_credentials()
+    if not credentials:
+        return {}
+    return {
+        f"{_PREFIX}{model_id}": {
+            "type": "meta_oauth",
+            "provider": "meta",
+            "name": model_id,
+            "context_length": int(spec.get("context_length") or 128_000),
+            "supported_settings": list(spec.get("supported_settings") or []),
+            "oauth_source": "meta-oauth-plugin",
+        }
+        for model_id, spec in _get_model_specs(credentials).items()
+    }
+
+
+def _handle_meta_status() -> None:
+    credentials = load_credentials()
+    if not credentials:
+        emit_warning(t("oauth.meta.status.none"))
+        emit_info(t("oauth.meta.status.hint"))
+        return
+    emit_success(t("oauth.meta.status.authenticated"))
+    emit_info(
+        t("oauth.meta.status.source", source=credentials.get("_source", "unknown"))
+    )
+    emit_info(
+        t("oauth.meta.status.models", models=", ".join(_meta_model_names(credentials)))
+    )
+
+
+def _handle_meta_logout() -> None:
+    path = get_token_storage_path()
+    if path.exists():
+        path.unlink()
+        emit_info(t("oauth.meta.logout.removed"))
+    remaining = load_credentials()
+    if remaining:
+        emit_warning(
+            t("oauth.meta.logout.external", source=remaining.get("_source", "external"))
+        )
+    else:
+        emit_success(t("oauth.meta.logout.success"))
+
+
+def _handle_custom_command(command: str, name: str) -> bool | None:
+    del command
+    if name == "meta-auth":
+        if run_oauth_flow():
+            set_model_and_reload_agent(_DEFAULT_MODEL)
+        return True
+    if name == "meta-status":
+        _handle_meta_status()
+        return True
+    if name == "meta-logout":
+        _handle_meta_logout()
+        return True
+    return None
+
+
+def _create_meta_oauth_model(
+    model_name: str, model_config: dict[str, Any], config: dict[str, Any]
+) -> Any:
+    """Create a Muse model using Meta's OpenAI Responses-compatible API."""
+    del config
+    from pydantic_ai.models.openai import OpenAIResponsesModel
+
+    from code_puppy.http_utils import create_async_client
+    from code_puppy.provider_identity import make_openai_provider
+
+    credentials = load_credentials()
+    if not credentials:
+        emit_warning(
+            t("oauth.meta.model.no_credentials", model=model_config.get("name"))
+        )
+        return None
+
+    client = create_async_client(
+        headers={"x-api-version": str(META_OAUTH_CONFIG["api_version"])},
+        model_name=model_name,
+    )
+    provider = make_openai_provider(
+        "meta",
+        api_key=credentials["api_key"],
+        base_url=credentials["api_base_url"],
+        http_client=client,
+    )
+    return OpenAIResponsesModel(model_name=model_config["name"], provider=provider)
+
+
+def _register_model_types() -> list[dict[str, Any]]:
+    return [{"type": "meta_oauth", "handler": _create_meta_oauth_model}]
+
+
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)
+register_callback("register_model_type", _register_model_types)
+register_callback("load_models_config", _load_meta_models)