kctl-api 0.7.4__tar.gz → 0.9.0__tar.gz

{kctl_api-0.7.4 → kctl_api-0.9.0}/.gitignore

@@ -31,3 +31,6 @@ Thumbs.db
 # Environment
 .env
 .env.local
+
+# Agent memory (claude-mem regenerates AGENTS.md locally; not a committed guide)
+AGENTS.md

{kctl_api-0.7.4 → kctl_api-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kctl-api
-Version: 0.7.4
+Version: 0.9.0
 Summary: Kodemeio API CLI - manage your FastAPI platform
 Author-email: Kodemeio <dev@kodeme.io>
 License-Expression: MIT
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: System :: Systems Administration
 Requires-Python: >=3.12
 Requires-Dist: httpx>=0.28.0
-Requires-Dist: kctl-lib>=0.12.0
+Requires-Dist: kctl-lib>=0.13.0
 Provides-Extra: all
 Requires-Dist: asyncpg>=0.30.0; extra == 'all'
 Requires-Dist: redis>=5.0.0; extra == 'all'

{kctl_api-0.7.4 → kctl_api-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kctl-api"
-version = "0.7.4"
+version = "0.9.0"
 description = "Kodemeio API CLI - manage your FastAPI platform"
 license = "MIT"
 requires-python = ">=3.12"
@@ -20,7 +20,7 @@ classifiers = [
     "Topic :: System :: Systems Administration",
 ]
 dependencies = [
-    "kctl-lib>=0.12.0",
+    "kctl-lib>=0.13.0",
     "httpx>=0.28.0",
 ]
 

{kctl_api-0.7.4 → kctl_api-0.9.0}/src/kctl_api/__init__.py

@@ -1,3 +1,3 @@
 """kctl-api: Kodemeio API CLI."""
 
-__version__ = "0.7.4"
+__version__ = "0.9.0"

kctl_api-0.9.0/src/kctl_api/_register.py

@@ -0,0 +1,127 @@
+"""Command-group registration for kctl-api (extracted from cli.py to keep it thin)."""
+
+from __future__ import annotations
+
+import typer
+from kctl_lib.ai_summary import add_ai_summary_command
+
+from kctl_api import __version__
+from kctl_api.commands.ai import app as ai_app
+from kctl_api.commands.aliases import register_aliases
+from kctl_api.commands.apps import app as apps_app
+from kctl_api.commands.auth import app as auth_app
+from kctl_api.commands.automation import app as automation_app
+from kctl_api.commands.build_cmd import app as build_app
+from kctl_api.commands.clean import app as clean_app
+from kctl_api.commands.config_cmd import app as config_app
+from kctl_api.commands.dashboard import app as dashboard_app
+from kctl_api.commands.db import app as db_app
+from kctl_api.commands.deploy import app as deploy_app
+from kctl_api.commands.deps import app as deps_app
+from kctl_api.commands.dev import app as dev_app
+from kctl_api.commands.docker_cmd import app as docker_app
+from kctl_api.commands.doctor_cmd import app as doctor_app
+from kctl_api.commands.doctor_cmd import build_checks as _doctor_build_checks
+from kctl_api.commands.env import app as env_app
+from kctl_api.commands.files import app as files_app
+from kctl_api.commands.fmt_cmd import app as fmt_app
+from kctl_api.commands.health import app as health_app
+from kctl_api.commands.jobs import app as jobs_app
+from kctl_api.commands.lint_cmd import app as lint_app
+from kctl_api.commands.logs import app as logs_app
+from kctl_api.commands.marketplace import app as marketplace_app
+from kctl_api.commands.monitor_cmd import app as monitor_app
+from kctl_api.commands.notifications import app as notifications_app
+from kctl_api.commands.odoo_proxy import app as odoo_app
+from kctl_api.commands.openapi import app as openapi_app
+from kctl_api.commands.perf import app as perf_app
+from kctl_api.commands.rate_limit import app as rate_limit_app
+from kctl_api.commands.realtime import app as realtime_app
+from kctl_api.commands.redis_cmd import app as redis_app
+from kctl_api.commands.routes_cmd import app as routes_app
+from kctl_api.commands.saas import app as saas_app
+from kctl_api.commands.scaffold import app as scaffold_app
+from kctl_api.commands.security_cmd import app as security_app
+from kctl_api.commands.services import app as services_app
+from kctl_api.commands.shell import app as shell_app
+from kctl_api.commands.skill_cmd import app as skill_app
+from kctl_api.commands.streams import app as streams_app
+from kctl_api.commands.stripe_cmd import app as stripe_app
+from kctl_api.commands.tenant_ai import app as tenant_ai_app
+from kctl_api.commands.test_cmd import app as test_app
+from kctl_api.commands.users import app as users_app
+from kctl_api.commands.webhooks import app as webhooks_app
+from kctl_api.commands.workflows import app as workflows_app
+from kctl_api.commands.ws import app as ws_app
+
+
+def register_all(app: typer.Typer) -> None:
+    """Register all command groups on *app* in the canonical order."""
+    # Authentication & access
+    app.add_typer(config_app, name="config")
+    app.add_typer(auth_app, name="auth")
+    app.add_typer(health_app, name="health")
+
+    # API resources
+    app.add_typer(users_app, name="users")
+    app.add_typer(files_app, name="files")
+    app.add_typer(jobs_app, name="jobs")
+    app.add_typer(workflows_app, name="workflows")
+    app.add_typer(automation_app, name="automation")
+    app.add_typer(notifications_app, name="notifications")
+    app.add_typer(webhooks_app, name="webhooks")
+    app.add_typer(marketplace_app, name="marketplace")
+    app.add_typer(saas_app, name="saas")
+    app.add_typer(stripe_app, name="stripe")
+    app.add_typer(odoo_app, name="odoo")
+    app.add_typer(realtime_app, name="realtime")
+
+    # AI platform
+    app.add_typer(ai_app, name="ai")
+    app.add_typer(tenant_ai_app, name="tenant-ai")
+
+    # Infrastructure
+    app.add_typer(db_app, name="db")
+    app.add_typer(redis_app, name="redis")
+    app.add_typer(streams_app, name="streams")
+    app.add_typer(services_app, name="services")
+    app.add_typer(deploy_app, name="deploy")
+    app.add_typer(apps_app, name="apps")
+    app.add_typer(docker_app, name="docker")
+
+    # Development tools
+    app.add_typer(dev_app, name="dev")
+    app.add_typer(test_app, name="test")
+    app.add_typer(lint_app, name="lint")
+    app.add_typer(fmt_app, name="fmt")
+    app.add_typer(build_app, name="build")
+    app.add_typer(scaffold_app, name="scaffold")
+    app.add_typer(shell_app, name="shell")
+
+    # API analysis & testing
+    app.add_typer(openapi_app, name="openapi")
+    app.add_typer(routes_app, name="routes")
+    app.add_typer(rate_limit_app, name="rate-limit")
+    app.add_typer(ws_app, name="ws")
+    app.add_typer(perf_app, name="perf")
+
+    # Environment & security
+    app.add_typer(doctor_app, name="doctor")
+    add_ai_summary_command(
+        doctor_app, cli_name="kctl-api", version=__version__, app=app, get_checks=_doctor_build_checks
+    )
+    app.add_typer(env_app, name="env")
+    app.add_typer(security_app, name="security")
+    app.add_typer(deps_app, name="deps")
+    app.add_typer(clean_app, name="clean")
+
+    # Observability & monitoring
+    app.add_typer(logs_app, name="logs")
+    app.add_typer(dashboard_app, name="dashboard")
+    app.add_typer(monitor_app, name="monitor")
+
+    # Skill generation
+    app.add_typer(skill_app, name="skill")
+
+    # Short aliases
+    register_aliases(app)

kctl_api-0.9.0/src/kctl_api/cli.py

@@ -0,0 +1,130 @@
+"""Main CLI entry point for kctl-api."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from kctl_lib import KctlError, cli_entrypoint, handle_cli_error, register_introspection_commands
+from kctl_lib.self_update import notify_if_outdated
+from kctl_lib.tui import add_tui_command
+
+from kctl_api import __version__
+from kctl_api._register import register_all
+from kctl_api.core.callbacks import AppContext
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kctl-api {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-api",
+    help="Kodemeio API CLI - manage your FastAPI platform.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Suppress info messages")] = False,
+    output_format: Annotated[
+        str, typer.Option("--format", "-f", help="Output format: pretty, json, csv, yaml")
+    ] = "pretty",
+    no_header: Annotated[bool, typer.Option("--no-header", help="Omit table headers (for scripting)")] = False,
+    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile name")] = None,
+    url: Annotated[str | None, typer.Option("--url", help="API URL override")] = None,
+    ai_url: Annotated[str | None, typer.Option("--ai-url", help="AI API URL override")] = None,
+    api_key: Annotated[str | None, typer.Option("--api-key", help="API key override")] = None,
+    database_url: Annotated[str | None, typer.Option("--database-url", help="Database URL override")] = None,
+    redis_url: Annotated[str | None, typer.Option("--redis-url", help="Redis URL override")] = None,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio API CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output or output_format == "json",
+        quiet=quiet,
+        format=output_format,
+        no_header=no_header,
+        profile=profile,
+        url_override=url,
+        ai_url_override=ai_url,
+        api_key_override=api_key,
+        database_url_override=database_url,
+        redis_url_override=redis_url,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-api", __version__)
+
+
+register_all(app)
+
+# Load plugins via entry points
+from kctl_api.core.plugins import discover_and_load_plugins  # noqa: E402
+
+discover_and_load_plugins(app)
+
+add_tui_command(app, service_key="api", version=__version__)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-api."""
+    actx = ctx.obj
+    out = actx.output
+
+    from kctl_lib.self_update import check_update
+    from kctl_lib.self_update import update as do_update
+
+    latest = check_update("kctl-api", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-api")
+        out.success(f"Updated to {latest}")
+    else:
+        out.success("Already up to date")
+
+
+@app.command()
+def completions(
+    shell: Annotated[str, typer.Argument(help="Shell type: zsh, bash, fish")] = "zsh",
+    install: Annotated[bool, typer.Option("--install", help="Install completions")] = False,
+) -> None:
+    """Generate or install shell completions."""
+    from kctl_lib.completions import get_completion_script, install_completions
+
+    if install:
+        path = install_completions("kctl-api", shell)
+        if path:
+            typer.echo(f"Completions installed to {path}")
+        else:
+            typer.echo(f"Could not install completions for {shell}", err=True)
+            raise typer.Exit(code=1)
+    else:
+        script = get_completion_script("kctl-api", shell)
+        typer.echo(script)
+
+
+# Wrap app so KctlError subclasses surface as clean user-facing messages.
+app = cli_entrypoint(app)
+register_introspection_commands(app)
+
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

{kctl_api-0.7.4 → kctl_api-0.9.0}/src/kctl_api/commands/doctor_cmd.py

@@ -8,8 +8,10 @@ from __future__ import annotations
 import asyncio
 import shutil
 import subprocess
+from dataclasses import dataclass
 
 import typer
+from kctl_lib.doctor_base import CheckResult, DoctorCheck
 
 from kctl_api.core.callbacks import AppContext
 from kctl_api.core.utils import find_project_root
@@ -136,6 +138,80 @@ def _run_all_checks(actx: AppContext) -> list[dict]:
     return checks
 
 
+@dataclass
+class _DictCheck:
+    """Adapter: wraps a no-arg callable returning a dict into DoctorCheck."""
+
+    _fn: object  # callable[[], dict]
+    name: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.name:
+
+            self.name = getattr(self._fn, "__name__", "check").replace("_check_", "").replace("_", " ").title()
+
+    def run(self) -> CheckResult:
+        try:
+            result = self._fn()  # type: ignore[operator]
+            status = "ok" if result.get("ok") else "fail"
+            msg_parts = []
+            if result.get("version"):
+                msg_parts.append(result["version"])
+            if result.get("issue"):
+                msg_parts.append(result["issue"])
+            message = "; ".join(msg_parts) or ("OK" if status == "ok" else "failed")
+            return CheckResult(name=self.name, status=status, message=message)
+        except Exception as exc:
+            return CheckResult(name=self.name, status="warn", message=str(exc))
+
+
+@dataclass
+class _AsyncDictCheck:
+    """Adapter: wraps an async callable returning a dict into DoctorCheck."""
+
+    _fn: object  # async callable[[AppContext], dict]
+    _actx: AppContext
+    name: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.name:
+            self.name = (
+                getattr(self._fn, "__name__", "check")
+                .replace("_check_", "")
+                .replace("_async", "")
+                .replace("_", " ")
+                .title()
+            )
+
+    def run(self) -> CheckResult:
+        try:
+            result = asyncio.run(self._fn(self._actx))  # type: ignore[operator]
+            status = "ok" if result.get("ok") else "fail"
+            msg_parts = []
+            if result.get("version"):
+                msg_parts.append(result["version"])
+            if result.get("issue"):
+                msg_parts.append(result["issue"])
+            message = "; ".join(msg_parts) or ("OK" if status == "ok" else "failed")
+            return CheckResult(name=self.name, status=status, message=message)
+        except Exception as exc:
+            return CheckResult(name=self.name, status="warn", message=str(exc))
+
+
+def build_checks(ctx: typer.Context) -> list[DoctorCheck]:
+    """Return the standard list of doctor checks (no side effects)."""
+    actx: AppContext = ctx.obj
+    return [
+        _DictCheck(_fn=_check_python, name="Python"),
+        _DictCheck(_fn=lambda: _check_binary("uv", "--version"), name="uv"),
+        _DictCheck(_fn=lambda: _check_binary("docker", "--version"), name="Docker"),
+        _DictCheck(_fn=lambda: _check_binary("git", "--version"), name="git"),
+        _DictCheck(_fn=_check_env_file, name=".env"),
+        _AsyncDictCheck(_fn=_check_postgres_async, _actx=actx, name="PostgreSQL"),
+        _AsyncDictCheck(_fn=_check_redis_async, _actx=actx, name="Redis"),
+    ]
+
+
 # ---------------------------------------------------------------------------
 # check
 # ---------------------------------------------------------------------------

{kctl_api-0.7.4 → kctl_api-0.9.0}/tests/test_config_cmd.py

@@ -3,13 +3,11 @@
 from __future__ import annotations
 
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 
-import pytest
 from typer.testing import CliRunner
 
 from kctl_api.cli import app
-from kctl_api.core.config import ServiceConfig
 
 runner = CliRunner()
 

kctl_api-0.9.0/tests/test_doctor_ai_summary.py

@@ -0,0 +1,16 @@
+import json
+
+from typer.testing import CliRunner
+
+from kctl_api.cli import app
+
+runner = CliRunner()
+
+
+def test_doctor_ai_summary_json_runs():
+    result = runner.invoke(app, ["--json", "doctor", "ai-summary"])
+    assert result.exit_code == 0
+    out = result.output
+    data = json.loads(out[out.index("{"):])  # tolerate a leading notify/update line
+    assert data["cli"] == "kctl-api"
+    assert "health" in data and "checks" in data

{kctl_api-0.7.4 → kctl_api-0.9.0}/tests/test_users.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from unittest.mock import MagicMock, patch
 
-import pytest
 from typer.testing import CliRunner
 
 from kctl_api.cli import app

kctl_api-0.7.4/src/kctl_api/cli.py

@@ -1,245 +0,0 @@
-"""Main CLI entry point for kctl-api."""
-
-from __future__ import annotations
-
-from typing import Annotated
-
-import typer
-from kctl_lib import KctlError, cli_entrypoint, handle_cli_error, register_introspection_commands
-from kctl_lib.self_update import notify_if_outdated
-from kctl_lib.tui import add_tui_command
-
-from kctl_api import __version__
-from kctl_api.core.callbacks import AppContext
-
-
-def version_callback(value: bool) -> None:
-    if value:
-        typer.echo(f"kctl-api {__version__}")
-        raise typer.Exit()
-
-
-app = typer.Typer(
-    name="kctl-api",
-    help="Kodemeio API CLI - manage your FastAPI platform.",
-    no_args_is_help=True,
-    rich_markup_mode="rich",
-    pretty_exceptions_enable=False,
-)
-
-
-@app.callback()
-def main(
-    ctx: typer.Context,
-    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
-    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Suppress info messages")] = False,
-    output_format: Annotated[
-        str, typer.Option("--format", "-f", help="Output format: pretty, json, csv, yaml")
-    ] = "pretty",
-    no_header: Annotated[bool, typer.Option("--no-header", help="Omit table headers (for scripting)")] = False,
-    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile name")] = None,
-    url: Annotated[str | None, typer.Option("--url", help="API URL override")] = None,
-    ai_url: Annotated[str | None, typer.Option("--ai-url", help="AI API URL override")] = None,
-    api_key: Annotated[str | None, typer.Option("--api-key", help="API key override")] = None,
-    database_url: Annotated[str | None, typer.Option("--database-url", help="Database URL override")] = None,
-    redis_url: Annotated[str | None, typer.Option("--redis-url", help="Redis URL override")] = None,
-    version: Annotated[
-        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
-    ] = False,
-) -> None:
-    """Kodemeio API CLI."""
-    ctx.ensure_object(dict)
-    ctx.obj = AppContext(
-        json_mode=json_output or output_format == "json",
-        quiet=quiet,
-        format=output_format,
-        no_header=no_header,
-        profile=profile,
-        url_override=url,
-        ai_url_override=ai_url,
-        api_key_override=api_key,
-        database_url_override=database_url,
-        redis_url_override=redis_url,
-    )
-    notify_if_outdated(ctx.obj.output, "kctl-api", __version__)
-
-
-def _register_commands() -> None:
-    """Register all command groups (lazy imports for fast startup)."""
-    from kctl_api.commands.ai import app as ai_app
-    from kctl_api.commands.aliases import register_aliases
-    from kctl_api.commands.apps import app as apps_app
-    from kctl_api.commands.auth import app as auth_app
-    from kctl_api.commands.automation import app as automation_app
-    from kctl_api.commands.build_cmd import app as build_app
-    from kctl_api.commands.clean import app as clean_app
-    from kctl_api.commands.config_cmd import app as config_app
-    from kctl_api.commands.dashboard import app as dashboard_app
-    from kctl_api.commands.db import app as db_app
-    from kctl_api.commands.deploy import app as deploy_app
-    from kctl_api.commands.deps import app as deps_app
-    from kctl_api.commands.dev import app as dev_app
-    from kctl_api.commands.docker_cmd import app as docker_app
-    from kctl_api.commands.doctor_cmd import app as doctor_app
-    from kctl_api.commands.env import app as env_app
-    from kctl_api.commands.files import app as files_app
-    from kctl_api.commands.fmt_cmd import app as fmt_app
-    from kctl_api.commands.health import app as health_app
-    from kctl_api.commands.jobs import app as jobs_app
-    from kctl_api.commands.lint_cmd import app as lint_app
-    from kctl_api.commands.logs import app as logs_app
-    from kctl_api.commands.marketplace import app as marketplace_app
-    from kctl_api.commands.monitor_cmd import app as monitor_app
-    from kctl_api.commands.notifications import app as notifications_app
-    from kctl_api.commands.odoo_proxy import app as odoo_app
-    from kctl_api.commands.openapi import app as openapi_app
-    from kctl_api.commands.perf import app as perf_app
-    from kctl_api.commands.rate_limit import app as rate_limit_app
-    from kctl_api.commands.realtime import app as realtime_app
-    from kctl_api.commands.redis_cmd import app as redis_app
-    from kctl_api.commands.routes_cmd import app as routes_app
-    from kctl_api.commands.saas import app as saas_app
-    from kctl_api.commands.scaffold import app as scaffold_app
-    from kctl_api.commands.security_cmd import app as security_app
-    from kctl_api.commands.services import app as services_app
-    from kctl_api.commands.shell import app as shell_app
-    from kctl_api.commands.streams import app as streams_app
-    from kctl_api.commands.stripe_cmd import app as stripe_app
-    from kctl_api.commands.tenant_ai import app as tenant_ai_app
-    from kctl_api.commands.test_cmd import app as test_app
-    from kctl_api.commands.users import app as users_app
-    from kctl_api.commands.webhooks import app as webhooks_app
-    from kctl_api.commands.workflows import app as workflows_app
-    from kctl_api.commands.ws import app as ws_app
-
-    # Authentication & access
-    app.add_typer(config_app, name="config")
-    app.add_typer(auth_app, name="auth")
-    app.add_typer(health_app, name="health")
-
-    # API resources
-    app.add_typer(users_app, name="users")
-    app.add_typer(files_app, name="files")
-    app.add_typer(jobs_app, name="jobs")
-    app.add_typer(workflows_app, name="workflows")
-    app.add_typer(automation_app, name="automation")
-    app.add_typer(notifications_app, name="notifications")
-    app.add_typer(webhooks_app, name="webhooks")
-    app.add_typer(marketplace_app, name="marketplace")
-    app.add_typer(saas_app, name="saas")
-    app.add_typer(stripe_app, name="stripe")
-    app.add_typer(odoo_app, name="odoo")
-    app.add_typer(realtime_app, name="realtime")
-
-    # AI platform
-    app.add_typer(ai_app, name="ai")
-    app.add_typer(tenant_ai_app, name="tenant-ai")
-
-    # Infrastructure
-    app.add_typer(db_app, name="db")
-    app.add_typer(redis_app, name="redis")
-    app.add_typer(streams_app, name="streams")
-    app.add_typer(services_app, name="services")
-    app.add_typer(deploy_app, name="deploy")
-    app.add_typer(apps_app, name="apps")
-    app.add_typer(docker_app, name="docker")
-
-    # Development tools
-    app.add_typer(dev_app, name="dev")
-    app.add_typer(test_app, name="test")
-    app.add_typer(lint_app, name="lint")
-    app.add_typer(fmt_app, name="fmt")
-    app.add_typer(build_app, name="build")
-    app.add_typer(scaffold_app, name="scaffold")
-    app.add_typer(shell_app, name="shell")
-
-    # API analysis & testing
-    app.add_typer(openapi_app, name="openapi")
-    app.add_typer(routes_app, name="routes")
-    app.add_typer(rate_limit_app, name="rate-limit")
-    app.add_typer(ws_app, name="ws")
-    app.add_typer(perf_app, name="perf")
-
-    # Environment & security
-    app.add_typer(doctor_app, name="doctor")
-    app.add_typer(env_app, name="env")
-    app.add_typer(security_app, name="security")
-    app.add_typer(deps_app, name="deps")
-    app.add_typer(clean_app, name="clean")
-
-    # Observability & monitoring
-    app.add_typer(logs_app, name="logs")
-    app.add_typer(dashboard_app, name="dashboard")
-    app.add_typer(monitor_app, name="monitor")
-
-    # Skill generation
-    from kctl_api.commands.skill_cmd import app as skill_app
-
-    app.add_typer(skill_app, name="skill")
-
-    # Short aliases
-    register_aliases(app)
-
-
-_register_commands()
-
-# Load plugins via entry points
-from kctl_api.core.plugins import discover_and_load_plugins  # noqa: E402
-
-discover_and_load_plugins(app)
-
-add_tui_command(app, service_key="api", version=__version__)
-
-
-@app.command("self-update")
-def self_update_cmd(ctx: typer.Context) -> None:
-    """Check for updates and upgrade kctl-api."""
-    actx = ctx.obj
-    out = actx.output
-
-    from kctl_lib.self_update import check_update
-    from kctl_lib.self_update import update as do_update
-
-    latest = check_update("kctl-api", __version__)
-    if latest:
-        out.info(f"Updating to {latest}...")
-        do_update("kctl-api")
-        out.success(f"Updated to {latest}")
-    else:
-        out.success("Already up to date")
-
-
-@app.command()
-def completions(
-    shell: Annotated[str, typer.Argument(help="Shell type: zsh, bash, fish")] = "zsh",
-    install: Annotated[bool, typer.Option("--install", help="Install completions")] = False,
-) -> None:
-    """Generate or install shell completions."""
-    from kctl_lib.completions import get_completion_script, install_completions
-
-    if install:
-        path = install_completions("kctl-api", shell)
-        if path:
-            typer.echo(f"Completions installed to {path}")
-        else:
-            typer.echo(f"Could not install completions for {shell}", err=True)
-            raise typer.Exit(code=1)
-    else:
-        script = get_completion_script("kctl-api", shell)
-        typer.echo(script)
-
-
-# Wrap app so KctlError subclasses surface as clean user-facing messages.
-app = cli_entrypoint(app)
-register_introspection_commands(app)
-
-def _run() -> None:
-    """Entry point with error handling."""
-    try:
-        app()
-    except KctlError as e:
-        handle_cli_error(e)
-
-
-if __name__ == "__main__":
-    _run()