yee88 0.1.0__py3-none-any.whl

takopi/cli/doctor.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+import anyio
+import typer
+
+from ..config import ConfigError
+from ..engines import list_backend_ids
+from ..ids import RESERVED_CHAT_COMMANDS
+from ..runtime_loader import resolve_plugins_allowlist
+from ..settings import TakopiSettings, TelegramTopicsSettings
+from ..telegram.client import TelegramClient
+from ..telegram.topics import _validate_topics_setup_for
+
+DoctorStatus = Literal["ok", "warning", "error"]
+
+
+@dataclass(frozen=True, slots=True)
+class DoctorCheck:
+    label: str
+    status: DoctorStatus
+    detail: str | None = None
+
+    def render(self) -> str:
+        if self.detail:
+            return f"- {self.label}: {self.status} ({self.detail})"
+        return f"- {self.label}: {self.status}"
+
+
+def _doctor_file_checks(settings: TakopiSettings) -> list[DoctorCheck]:
+    files = settings.transports.telegram.files
+    if not files.enabled:
+        return [DoctorCheck("file transfer", "ok", "disabled")]
+    if files.allowed_user_ids:
+        count = len(files.allowed_user_ids)
+        detail = f"restricted to {count} user id(s)"
+        return [DoctorCheck("file transfer", "ok", detail)]
+    return [DoctorCheck("file transfer", "warning", "enabled for all users")]
+
+
+def _doctor_voice_checks(settings: TakopiSettings) -> list[DoctorCheck]:
+    if not settings.transports.telegram.voice_transcription:
+        return [DoctorCheck("voice transcription", "ok", "disabled")]
+    api_key = settings.transports.telegram.voice_transcription_api_key
+    if api_key:
+        return [
+            DoctorCheck("voice transcription", "ok", "voice_transcription_api_key set")
+        ]
+    if os.environ.get("OPENAI_API_KEY"):
+        return [DoctorCheck("voice transcription", "ok", "OPENAI_API_KEY set")]
+    return [DoctorCheck("voice transcription", "error", "API key not set")]
+
+
+async def _doctor_telegram_checks(
+    token: str,
+    chat_id: int,
+    topics: TelegramTopicsSettings,
+    project_chat_ids: tuple[int, ...],
+) -> list[DoctorCheck]:
+    checks: list[DoctorCheck] = []
+    client_factory = _resolve_cli_attr("TelegramClient") or TelegramClient
+    validate_topics = (
+        _resolve_cli_attr("_validate_topics_setup_for") or _validate_topics_setup_for
+    )
+    bot = client_factory(token)
+    try:
+        me = await bot.get_me()
+        if me is None:
+            checks.append(
+                DoctorCheck("telegram token", "error", "failed to fetch bot info")
+            )
+            checks.append(DoctorCheck("chat_id", "error", "skipped (token invalid)"))
+            if topics.enabled:
+                checks.append(DoctorCheck("topics", "error", "skipped (token invalid)"))
+            else:
+                checks.append(DoctorCheck("topics", "ok", "disabled"))
+            return checks
+        bot_label = f"@{me.username}" if me.username else f"id={me.id}"
+        checks.append(DoctorCheck("telegram token", "ok", bot_label))
+        chat = await bot.get_chat(chat_id)
+        if chat is None:
+            checks.append(DoctorCheck("chat_id", "error", f"unreachable ({chat_id})"))
+        else:
+            checks.append(DoctorCheck("chat_id", "ok", f"{chat.type} ({chat_id})"))
+        if topics.enabled:
+            try:
+                await validate_topics(
+                    bot=bot,
+                    topics=topics,
+                    chat_id=chat_id,
+                    project_chat_ids=project_chat_ids,
+                )
+                checks.append(DoctorCheck("topics", "ok", f"scope={topics.scope}"))
+            except ConfigError as exc:
+                checks.append(DoctorCheck("topics", "error", str(exc)))
+        else:
+            checks.append(DoctorCheck("topics", "ok", "disabled"))
+    except Exception as exc:  # noqa: BLE001
+        checks.append(DoctorCheck("telegram", "error", str(exc)))
+    finally:
+        await bot.close()
+    return checks
+
+
+def run_doctor(
+    *,
+    load_settings_fn: Callable[[], tuple[TakopiSettings, Path]],
+    telegram_checks: Callable[
+        [str, int, TelegramTopicsSettings, tuple[int, ...]],
+        Awaitable[list[DoctorCheck]],
+    ],
+    file_checks: Callable[[TakopiSettings], list[DoctorCheck]],
+    voice_checks: Callable[[TakopiSettings], list[DoctorCheck]],
+) -> None:
+    try:
+        settings, config_path = load_settings_fn()
+    except ConfigError as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    if settings.transport != "telegram":
+        typer.echo(
+            "error: takopi doctor currently supports the telegram transport only.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    allowlist = resolve_plugins_allowlist(settings)
+    engine_ids = list_backend_ids(allowlist=allowlist)
+    try:
+        projects_cfg = settings.to_projects_config(
+            config_path=config_path,
+            engine_ids=engine_ids,
+            reserved=RESERVED_CHAT_COMMANDS,
+        )
+    except ConfigError as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+
+    tg = settings.transports.telegram
+    project_chat_ids = projects_cfg.project_chat_ids()
+    telegram_checks_result = anyio.run(
+        telegram_checks,
+        tg.bot_token,
+        tg.chat_id,
+        tg.topics,
+        project_chat_ids,
+    )
+    if telegram_checks_result is None:
+        telegram_checks_result = []
+    checks = [
+        *telegram_checks_result,
+        *file_checks(settings),
+        *voice_checks(settings),
+    ]
+    typer.echo("takopi doctor")
+    for check in checks:
+        typer.echo(check.render())
+    if any(check.status == "error" for check in checks):
+        raise typer.Exit(code=1)
+
+
+def _resolve_cli_attr(name: str) -> object | None:
+    cli_module = sys.modules.get("takopi.cli")
+    if cli_module is None:
+        return None
+    return getattr(cli_module, name, None)

takopi/cli/init.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+import typer
+
+from ..config import ConfigError, write_config
+from ..config_migrations import migrate_config
+from ..ids import RESERVED_CHAT_COMMANDS
+from ..settings import TakopiSettings, validate_settings_data
+from .config import _config_path_display
+
+
+def _prompt_alias(value: str | None, *, default_alias: str | None = None) -> str:
+    if value is not None:
+        alias = value
+    elif default_alias:
+        alias = typer.prompt("project alias", default=default_alias)
+    else:
+        alias = typer.prompt("project alias")
+    alias = alias.strip()
+    if not alias:
+        typer.echo("error: project alias cannot be empty", err=True)
+        raise typer.Exit(code=1)
+    return alias
+
+
+def _default_alias_from_path(path: Path) -> str | None:
+    name = path.name
+    if not name:
+        return None
+    name = name.removesuffix(".git")
+    return name or None
+
+
+def _ensure_projects_table(config: dict, config_path: Path) -> dict:
+    projects = config.setdefault("projects", {})
+    if not isinstance(projects, dict):
+        raise ConfigError(f"Invalid `projects` in {config_path}; expected a table.")
+    return projects
+
+
+def run_init(
+    *,
+    alias: str | None,
+    default: bool,
+    load_or_init_config_fn: Callable[[], tuple[dict, Path]],
+    resolve_main_worktree_root_fn: Callable[[Path], Path | None],
+    resolve_default_base_fn: Callable[[Path], str | None],
+    list_backend_ids_fn: Callable[..., list[str]],
+    resolve_plugins_allowlist_fn: Callable[[TakopiSettings], list[str] | None],
+) -> None:
+    config, config_path = load_or_init_config_fn()
+    if config_path.exists():
+        applied = migrate_config(config, config_path=config_path)
+        if applied:
+            write_config(config, config_path)
+
+    cwd = Path.cwd()
+    project_path = resolve_main_worktree_root_fn(cwd) or cwd
+    default_alias = _default_alias_from_path(project_path)
+    alias = _prompt_alias(alias, default_alias=default_alias)
+
+    settings = validate_settings_data(config, config_path=config_path)
+    allowlist = resolve_plugins_allowlist_fn(settings)
+    engine_ids = list_backend_ids_fn(allowlist=allowlist)
+    projects_cfg = settings.to_projects_config(
+        config_path=config_path,
+        engine_ids=engine_ids,
+        reserved=RESERVED_CHAT_COMMANDS,
+    )
+
+    alias_key = alias.lower()
+    if alias_key in {engine.lower() for engine in engine_ids}:
+        raise ConfigError(
+            f"Invalid project alias {alias!r}; aliases must not match engine ids."
+        )
+    if alias_key in RESERVED_CHAT_COMMANDS:
+        raise ConfigError(
+            f"Invalid project alias {alias!r}; aliases must not match reserved commands."
+        )
+
+    existing = projects_cfg.projects.get(alias_key)
+    if existing is not None:
+        overwrite = typer.confirm(
+            f"project {existing.alias!r} already exists, overwrite?",
+            default=False,
+        )
+        if not overwrite:
+            raise typer.Exit(code=1)
+
+    projects = _ensure_projects_table(config, config_path)
+    if existing is not None and existing.alias in projects:
+        projects.pop(existing.alias, None)
+
+    default_engine = settings.default_engine
+    worktree_base = resolve_default_base_fn(project_path)
+
+    entry: dict[str, object] = {
+        "path": str(project_path),
+        "worktrees_dir": ".worktrees",
+        "default_engine": default_engine,
+    }
+    if worktree_base:
+        entry["worktree_base"] = worktree_base
+
+    projects[alias] = entry
+    if default:
+        config["default_project"] = alias
+
+    write_config(config, config_path)
+    typer.echo(f"saved project {alias!r} to {_config_path_display(config_path)}")

takopi/cli/onboarding_cmd.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+from functools import partial
+from pathlib import Path
+from typing import Any, cast
+
+import anyio
+import typer
+
+from ..config import ConfigError, load_or_init_config, write_config
+from ..config_migrations import migrate_config
+from ..logging import setup_logging
+from ..settings import TakopiSettings
+from ..telegram import onboarding
+from .init import _ensure_projects_table
+from .run import _load_settings_optional
+
+
+def chat_id(
+    token: str | None = typer.Option(
+        None,
+        "--token",
+        help="Telegram bot token (defaults to config if available).",
+    ),
+    project: str | None = typer.Option(
+        None,
+        "--project",
+        help="Project alias to print a chat_id snippet for.",
+    ),
+) -> None:
+    """Capture a Telegram chat id and exit."""
+    setup_logging_fn = cast(
+        Callable[..., None],
+        _resolve_cli_attr("setup_logging") or setup_logging,
+    )
+    load_settings_optional_fn = cast(
+        Callable[[], tuple[TakopiSettings | None, Path | None]],
+        _resolve_cli_attr("_load_settings_optional") or _load_settings_optional,
+    )
+    onboarding_mod = cast(
+        Any,
+        _resolve_cli_attr("onboarding") or onboarding,
+    )
+    load_or_init_config_fn = cast(
+        Callable[[], tuple[dict, Path]],
+        _resolve_cli_attr("load_or_init_config") or load_or_init_config,
+    )
+    ensure_projects_table_fn = cast(
+        Callable[[dict, Path], dict],
+        _resolve_cli_attr("_ensure_projects_table") or _ensure_projects_table,
+    )
+    migrate_config_fn = cast(
+        Callable[..., object],
+        _resolve_cli_attr("migrate_config") or migrate_config,
+    )
+    write_config_fn = cast(
+        Callable[[dict, Path], None],
+        _resolve_cli_attr("write_config") or write_config,
+    )
+
+    setup_logging_fn(debug=False, cache_logger_on_first_use=False)
+    if token is None:
+        settings, _ = load_settings_optional_fn()
+        if settings is not None:
+            tg = settings.transports.telegram
+            token = tg.bot_token or None
+    chat = anyio.run(partial(onboarding_mod.capture_chat_id, token=token))
+    if chat is None:
+        raise typer.Exit(code=1)
+    if project:
+        project = project.strip()
+        if not project:
+            raise ConfigError("Invalid `--project`; expected a non-empty string.")
+
+        config, config_path = load_or_init_config_fn()
+        if config_path.exists():
+            applied = migrate_config_fn(config, config_path=config_path)
+            if applied:
+                write_config_fn(config, config_path)
+
+        projects = ensure_projects_table_fn(config, config_path)
+        entry = projects.get(project)
+        if entry is None:
+            lowered = project.lower()
+            for key, value in projects.items():
+                if isinstance(key, str) and key.lower() == lowered:
+                    entry = value
+                    project = key
+                    break
+        if entry is None:
+            raise ConfigError(
+                f"Unknown project {project!r}; run `takopi init {project}` first."
+            )
+        if not isinstance(entry, dict):
+            raise ConfigError(
+                f"Invalid `projects.{project}` in {config_path}; expected a table."
+            )
+        entry["chat_id"] = chat.chat_id
+        write_config_fn(config, config_path)
+        typer.echo(f"updated projects.{project}.chat_id = {chat.chat_id}")
+        return
+
+    typer.echo(f"chat_id = {chat.chat_id}")
+
+
+def onboarding_paths() -> None:
+    """Print all possible onboarding paths."""
+    setup_logging_fn = cast(
+        Callable[..., None],
+        _resolve_cli_attr("setup_logging") or setup_logging,
+    )
+    onboarding_mod = cast(
+        Any,
+        _resolve_cli_attr("onboarding") or onboarding,
+    )
+    setup_logging_fn(debug=False, cache_logger_on_first_use=False)
+    onboarding_mod.debug_onboarding_paths()
+
+
+def _resolve_cli_attr(name: str) -> object | None:
+    cli_module = sys.modules.get("takopi.cli")
+    if cli_module is None:
+        return None
+    return getattr(cli_module, name, None)

takopi/cli/plugins.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable
+from importlib.metadata import EntryPoint
+from pathlib import Path
+from typing import cast
+
+import typer
+
+from ..commands import get_command
+from ..config import ConfigError
+from ..engines import get_backend
+from ..ids import RESERVED_COMMAND_IDS, RESERVED_ENGINE_IDS
+from ..plugins import (
+    COMMAND_GROUP,
+    ENGINE_GROUP,
+    PluginLoadError,
+    TRANSPORT_GROUP,
+    entrypoint_distribution_name,
+    get_load_errors,
+    is_entrypoint_allowed,
+    list_entrypoints,
+    normalize_allowlist,
+)
+from ..runtime_loader import resolve_plugins_allowlist
+from ..settings import TakopiSettings, load_settings_if_exists
+from ..transports import get_transport
+
+
+def _load_settings_optional() -> tuple[TakopiSettings | None, Path | None]:
+    try:
+        loaded = load_settings_if_exists()
+    except ConfigError:
+        return None, None
+    if loaded is None:
+        return None, None
+    return loaded
+
+
+def _print_entrypoints(
+    label: str,
+    entrypoints: list[EntryPoint],
+    *,
+    allowlist: set[str] | None,
+    entrypoint_distribution_name_fn: Callable[[EntryPoint], str | None],
+    is_entrypoint_allowed_fn: Callable[[EntryPoint, set[str] | None], bool],
+) -> None:
+    typer.echo(f"{label}:")
+    if not entrypoints:
+        typer.echo("  (none)")
+        return
+    for ep in entrypoints:
+        dist = entrypoint_distribution_name_fn(ep) or "unknown"
+        status = ""
+        if allowlist is not None:
+            allowed = is_entrypoint_allowed_fn(ep, allowlist)
+            status = " enabled" if allowed else " disabled"
+        typer.echo(f"  {ep.name} ({dist}){status}")
+
+
+def plugins_cmd(
+    load: bool = typer.Option(
+        False,
+        "--load/--no-load",
+        help="Load plugins to validate and surface import errors.",
+    ),
+) -> None:
+    """List discovered plugins and optionally validate them."""
+    load_settings_optional = cast(
+        Callable[[], tuple[TakopiSettings | None, Path | None]],
+        _resolve_cli_attr("_load_settings_optional") or _load_settings_optional,
+    )
+    resolve_plugins_allowlist_fn = cast(
+        Callable[[TakopiSettings | None], list[str] | None],
+        _resolve_cli_attr("resolve_plugins_allowlist") or resolve_plugins_allowlist,
+    )
+    list_entrypoints_fn = cast(
+        Callable[..., list[EntryPoint]],
+        _resolve_cli_attr("list_entrypoints") or list_entrypoints,
+    )
+    get_backend_fn = cast(
+        Callable[..., object],
+        _resolve_cli_attr("get_backend") or get_backend,
+    )
+    get_transport_fn = cast(
+        Callable[..., object],
+        _resolve_cli_attr("get_transport") or get_transport,
+    )
+    get_command_fn = cast(
+        Callable[..., object],
+        _resolve_cli_attr("get_command") or get_command,
+    )
+    get_load_errors_fn = cast(
+        Callable[[], tuple[PluginLoadError, ...]],
+        _resolve_cli_attr("get_load_errors") or get_load_errors,
+    )
+    entrypoint_distribution_name_fn = cast(
+        Callable[[EntryPoint], str | None],
+        _resolve_cli_attr("entrypoint_distribution_name")
+        or entrypoint_distribution_name,
+    )
+    is_entrypoint_allowed_fn = cast(
+        Callable[[EntryPoint, set[str] | None], bool],
+        _resolve_cli_attr("is_entrypoint_allowed") or is_entrypoint_allowed,
+    )
+    normalize_allowlist_fn = cast(
+        Callable[[list[str] | None], set[str] | None],
+        _resolve_cli_attr("normalize_allowlist") or normalize_allowlist,
+    )
+
+    settings_hint, _ = load_settings_optional()
+    allowlist = resolve_plugins_allowlist_fn(settings_hint)
+
+    allowlist_set = normalize_allowlist_fn(allowlist)
+    engine_eps = list_entrypoints_fn(
+        ENGINE_GROUP,
+        reserved_ids=RESERVED_ENGINE_IDS,
+    )
+    transport_eps = list_entrypoints_fn(TRANSPORT_GROUP)
+    command_eps = list_entrypoints_fn(
+        COMMAND_GROUP,
+        reserved_ids=RESERVED_COMMAND_IDS,
+    )
+
+    _print_entrypoints(
+        "engine backends",
+        engine_eps,
+        allowlist=allowlist_set,
+        entrypoint_distribution_name_fn=entrypoint_distribution_name_fn,
+        is_entrypoint_allowed_fn=is_entrypoint_allowed_fn,
+    )
+    _print_entrypoints(
+        "transport backends",
+        transport_eps,
+        allowlist=allowlist_set,
+        entrypoint_distribution_name_fn=entrypoint_distribution_name_fn,
+        is_entrypoint_allowed_fn=is_entrypoint_allowed_fn,
+    )
+    _print_entrypoints(
+        "command backends",
+        command_eps,
+        allowlist=allowlist_set,
+        entrypoint_distribution_name_fn=entrypoint_distribution_name_fn,
+        is_entrypoint_allowed_fn=is_entrypoint_allowed_fn,
+    )
+
+    if load:
+        for ep in engine_eps:
+            if allowlist_set is not None and not is_entrypoint_allowed_fn(
+                ep, allowlist_set
+            ):
+                continue
+            try:
+                get_backend_fn(ep.name, allowlist=allowlist)
+            except ConfigError:
+                continue
+        for ep in transport_eps:
+            if allowlist_set is not None and not is_entrypoint_allowed_fn(
+                ep, allowlist_set
+            ):
+                continue
+            try:
+                get_transport_fn(ep.name, allowlist=allowlist)
+            except ConfigError:
+                continue
+        for ep in command_eps:
+            if allowlist_set is not None and not is_entrypoint_allowed_fn(
+                ep, allowlist_set
+            ):
+                continue
+            try:
+                get_command_fn(ep.name, allowlist=allowlist)
+            except ConfigError:
+                continue
+
+    errors = get_load_errors_fn()
+    if errors:
+        typer.echo("errors:")
+        for err in errors:
+            group = err.group
+            if group == ENGINE_GROUP:
+                group = "engine"
+            elif group == TRANSPORT_GROUP:
+                group = "transport"
+            elif group == COMMAND_GROUP:
+                group = "command"
+            dist = err.distribution or "unknown"
+            typer.echo(f"  {group} {err.name} ({dist}): {err.error}")
+
+
+def _resolve_cli_attr(name: str) -> object | None:
+    cli_module = sys.modules.get("takopi.cli")
+    if cli_module is None:
+        return None
+    return getattr(cli_module, name, None)