keboola-cli 0.63.4__py3-none-any.whl

keboola_agent_cli/commands/tool.py

@@ -0,0 +1,206 @@
+"""MCP tool commands - list and call tools from keboola-mcp-server.
+
+Thin CLI layer: parses arguments, calls McpService, formats output.
+No business logic belongs here.
+"""
+
+import json
+import sys
+from pathlib import Path
+
+import typer
+
+from ..config_store import ConfigStore
+from ..errors import ConfigError, ErrorCode
+from ..output import OutputFormatter, format_tool_result, format_tools_table
+from ._helpers import (
+    check_cli_permission,
+    emit_project_warnings,
+    get_formatter,
+    get_service,
+    resolve_branch,
+    validate_branch_requires_project,
+)
+
+tool_app = typer.Typer(help="MCP tools - interact with Keboola via MCP server")
+
+
+@tool_app.callback(invoke_without_command=True)
+def _tool_permission_check(ctx: typer.Context) -> None:
+    check_cli_permission(ctx, "tool")
+
+
+def _read_input(value: str, formatter: OutputFormatter) -> str:
+    """Read tool input from a string, file (@path), or stdin (-).
+
+    Supports:
+    - Inline JSON string: '{"key": "value"}'
+    - File reference: @payload.json or @/absolute/path.json
+    - Stdin: -
+    """
+    if value == "-":
+        return sys.stdin.read()
+
+    if value.startswith("@"):
+        file_path = Path(value[1:])
+        if not file_path.is_file():
+            formatter.error(
+                message=f"Input file not found: {file_path}",
+                error_code=ErrorCode.INVALID_ARGUMENT,
+            )
+            raise typer.Exit(code=2) from None
+        return file_path.read_text(encoding="utf-8")
+
+    return value
+
+
+def _resolve_branch_str(
+    config_store: ConfigStore,
+    formatter: OutputFormatter,
+    project: str | None,
+    branch: int | None,
+) -> tuple[str | None, str | None]:
+    """Resolve branch and return branch_id as string (for MCP service compatibility)."""
+    proj, branch_id = resolve_branch(config_store, formatter, project, branch)
+    return proj, str(branch_id) if branch_id is not None else None
+
+
+@tool_app.command("list")
+def tool_list(
+    ctx: typer.Context,
+    project: str | None = typer.Option(
+        None,
+        "--project",
+        help="Project alias to query tools from (uses first available if not set)",
+    ),
+    branch: int | None = typer.Option(
+        None,
+        "--branch",
+        help="Development branch ID (requires --project or active branch)",
+    ),
+) -> None:
+    """List available MCP tools from the keboola-mcp-server."""
+    formatter = get_formatter(ctx)
+    service = get_service(ctx, "mcp_service")
+    config_store: ConfigStore = ctx.obj["config_store"]
+
+    validate_branch_requires_project(formatter, branch, project)
+
+    # Auto-resolve active branch from config
+    project, branch_str = _resolve_branch_str(config_store, formatter, project, branch)
+
+    if branch_str and not project:
+        formatter.error(
+            message="--branch requires --project (branch ID is per-project)",
+            error_code=ErrorCode.INVALID_ARGUMENT,
+        )
+        raise typer.Exit(code=2) from None
+
+    aliases = [project] if project else None
+
+    try:
+        result = service.list_tools(aliases=aliases, branch_id=branch_str)
+    except ConfigError as exc:
+        formatter.error(message=exc.message, error_code=ErrorCode.CONFIG_ERROR)
+        raise typer.Exit(code=5) from None
+
+    if formatter.json_mode:
+        formatter.output(result)
+    else:
+        format_tools_table(formatter.console, result)
+        emit_project_warnings(formatter, result)
+
+
+@tool_app.command("call")
+def tool_call(
+    ctx: typer.Context,
+    tool_name: str = typer.Argument(help="Name of the MCP tool to call"),
+    project: str | None = typer.Option(
+        None,
+        "--project",
+        help="Project alias (required for write tools, optional for read tools)",
+    ),
+    tool_input: str | None = typer.Option(
+        None,
+        "--input",
+        help="Tool input as JSON string, @file.json, or - for stdin",
+    ),
+    branch: int | None = typer.Option(
+        None,
+        "--branch",
+        help="Development branch ID (forces single-project mode)",
+    ),
+) -> None:
+    """Call an MCP tool on keboola-mcp-server.
+
+    Read tools (list_*, get_*, search, docs_query, find_*) run across ALL
+    connected projects in parallel and return aggregated results.
+
+    Write tools (create_*, update_*, delete_*, add_*) run on a single project.
+    Use --project to specify the target, or the default project is used.
+
+    If an active branch is set for the project, it is used automatically.
+    Use --branch to override or scope the call to a specific development branch.
+    """
+    formatter = get_formatter(ctx)
+    service = get_service(ctx, "mcp_service")
+    config_store: ConfigStore = ctx.obj["config_store"]
+
+    validate_branch_requires_project(formatter, branch, project)
+
+    # Auto-resolve active branch from config
+    project, branch_str = _resolve_branch_str(config_store, formatter, project, branch)
+
+    if branch_str and not project:
+        formatter.error(
+            message="--branch requires --project (branch ID is per-project)",
+            error_code=ErrorCode.INVALID_ARGUMENT,
+        )
+        raise typer.Exit(code=2) from None
+
+    # Parse tool input JSON (supports inline JSON, @file.json, or - for stdin)
+    parsed_input: dict = {}
+    if tool_input:
+        raw_json = _read_input(tool_input, formatter)
+        try:
+            parsed_input = json.loads(raw_json)
+        except json.JSONDecodeError as exc:
+            formatter.error(
+                message=f"Invalid JSON in --input: {exc}",
+                error_code=ErrorCode.INVALID_ARGUMENT,
+            )
+            raise typer.Exit(code=2) from None
+
+        if not isinstance(parsed_input, dict):
+            formatter.error(
+                message='--input must be a JSON object (e.g. \'{"key": "value"}\')',
+                error_code=ErrorCode.INVALID_ARGUMENT,
+            )
+            raise typer.Exit(code=2) from None
+
+    # Validate + call in a single MCP session (eliminates double subprocess spawn)
+    try:
+        result = service.validate_and_call_tool(
+            tool_name=tool_name,
+            tool_input=parsed_input,
+            alias=project,
+            branch_id=branch_str,
+        )
+    except ConfigError as exc:
+        # ConfigError covers: unknown tool, missing params, config issues
+        error_code = ErrorCode.CONFIG_ERROR
+        exit_code = 5
+        if "Missing required parameter" in exc.message:
+            error_code = ErrorCode.MISSING_PARAMETER
+            exit_code = 2
+        elif "Unknown MCP tool" in exc.message:
+            error_code = ErrorCode.CONFIG_ERROR
+            exit_code = 5
+        formatter.error(message=exc.message, error_code=error_code)
+        raise typer.Exit(code=exit_code) from None
+
+    if formatter.json_mode:
+        formatter.output(result)
+    else:
+        format_tool_result(formatter.console, result)
+        emit_project_warnings(formatter, result)

keboola_agent_cli/commands/version.py

@@ -0,0 +1,186 @@
+"""Version command - show kbagent version and dependency update checks.
+
+Thin CLI layer: calls VersionService and formats output.
+No business logic belongs here.
+"""
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from ._helpers import get_formatter, get_service
+
+
+def _format_dep_standard(text: Text, dep: dict) -> None:
+    """Format a standard dependency (local install with upgrade check)."""
+    name = dep["name"]
+    desc = dep["description"]
+    local = dep.get("local_version")
+    latest = dep.get("latest_version")
+    up_to_date = dep.get("up_to_date")
+
+    if local is None:
+        text.append(f"  {name:<28}", style="dim")
+        text.append("not installed\n", style="red")
+        return
+
+    label = f"{name} ({desc})"
+    text.append(f"  {label:<28}")
+    text.append(f"v{local}")
+
+    if up_to_date is False and latest is not None:
+        text.append(f"    -> v{latest} available", style="yellow")
+        text.append(f" ({dep['upgrade_command']})", style="dim")
+    elif up_to_date is True:
+        text.append("    up to date", style="green")
+    else:
+        text.append("    (update check failed)", style="dim")
+
+    text.append("\n")
+
+
+def _format_dep_auto_update(text: Text, dep: dict) -> None:
+    """Format an auto-updating dependency.
+
+    Since v0.30.1: dependencies are auto-updated by ``auto_update.py`` on
+    kbagent startup (and explicitly by ``kbagent update``). The renderer
+    surfaces the locally installed version + up-to-date status so a user
+    in the terminal sees the staleness signal immediately, not just in
+    JSON mode.
+    """
+    name = dep["name"]
+    desc = dep["description"]
+    local = dep.get("version")
+    latest = dep.get("latest_version")
+    up_to_date = dep.get("up_to_date")
+    install_method = dep.get("install_method", "?")
+    upgrade_cmd = dep.get("upgrade_command", "")
+
+    label = f"{name} ({desc})"
+    text.append(f"  {label:<28}")
+
+    if local is None:
+        if install_method == "none":
+            text.append("not installed", style="yellow")
+            if upgrade_cmd:
+                text.append(f" ({upgrade_cmd})", style="dim")
+        else:
+            text.append("local version unknown", style="dim")
+            if latest:
+                text.append(f"    (latest on PyPI: v{latest})", style="dim")
+        text.append("\n")
+        return
+
+    text.append(f"v{local}")
+
+    if up_to_date is False and latest is not None:
+        text.append(f"    -> v{latest} (auto-updates on next startup)", style="yellow")
+    elif up_to_date is True:
+        text.append("    auto-updates (up to date)", style="green")
+    else:
+        text.append("    (update check failed)", style="dim")
+
+    text.append("\n")
+
+
+def _format_version_panel(console: Console, data: dict) -> None:
+    """Render version information as a Rich panel."""
+    text = Text()
+    kbagent = data["kbagent"]
+    text.append(f"kbagent v{kbagent['version']}", style="bold")
+
+    if kbagent.get("up_to_date") is False and kbagent.get("latest_version"):
+        text.append(f"    -> v{kbagent['latest_version']} available", style="yellow")
+        text.append("  (run: kbagent update)", style="dim")
+    elif kbagent.get("up_to_date") is True:
+        text.append("    up to date", style="green")
+
+    text.append("\n\nDependencies:\n")
+
+    for dep in data["dependencies"]:
+        if dep.get("auto_updates"):
+            _format_dep_auto_update(text, dep)
+        else:
+            _format_dep_standard(text, dep)
+
+    console.print(Panel(text, title="Version Info", border_style="blue"))
+
+
+def version_command(
+    ctx: typer.Context,
+    beta: bool = typer.Option(
+        False,
+        "--beta",
+        help="Report the latest pre-release (beta / rc) instead of the latest stable.",
+    ),
+) -> None:
+    """Show kbagent version and check for dependency updates."""
+    formatter = get_formatter(ctx)
+    version_service = get_service(ctx, "version_service")
+    include_prerelease = beta or _env_opted_into_prerelease()
+    result = version_service.get_versions(include_prerelease=include_prerelease)
+    formatter.output(result, _format_version_panel)
+
+
+def update_command(
+    ctx: typer.Context,
+    beta: bool = typer.Option(
+        False,
+        "--beta",
+        help=(
+            "Opt into pre-release versions (beta / rc). Without this flag (the "
+            "default) and without KBAGENT_INCLUDE_PRERELEASE=1 in env, the "
+            "GitHub /releases/latest endpoint -- which filters out prereleases "
+            "server-side -- is used, so a beta release will never silently "
+            "install. With --beta, the resolver opts into PEP 440 prereleases "
+            "(``uv --prerelease=allow`` / ``pip --pre``)."
+        ),
+    ),
+) -> None:
+    """Update kbagent + keboola-mcp-server to the latest versions.
+
+    Two-stage upgrade (since v0.30.1):
+
+    1. **kbagent** -- ``uv tool install --upgrade`` (preferred) or
+       ``pip install --upgrade`` from the GitHub repository.
+    2. **keboola-mcp-server** -- detects install method and runs the
+       matching upgrade command (``uv tool upgrade`` / ``pip install -U``
+       / ``uvx --refresh``). Always runs, regardless of whether kbagent
+       itself needed an upgrade.
+
+    JSON output reports both stages independently. Human mode prints a
+    one-line summary such as
+    ``kbagent v0.30.0 -> v0.30.1 | keboola-mcp-server v1.49.0 -> v1.59.1``.
+
+    Pre-release channel (since v0.42.0): use ``--beta`` (or set
+    ``KBAGENT_INCLUDE_PRERELEASE=1`` in env) to opt into beta / rc
+    releases. The startup auto-update hook never auto-installs a beta;
+    only this explicit command does.
+    """
+    formatter = get_formatter(ctx)
+    version_service = get_service(ctx, "version_service")
+    include_prerelease = beta or _env_opted_into_prerelease()
+    result = version_service.self_update(include_prerelease=include_prerelease)
+
+    if formatter.json_mode:
+        formatter.output(result)
+    else:
+        if result["updated"]:
+            formatter.success(result["message"])
+        else:
+            formatter.console.print(result["message"])
+
+
+def _env_opted_into_prerelease() -> bool:
+    """Honour ``KBAGENT_INCLUDE_PRERELEASE=1`` as a per-shell opt-in.
+
+    Some users want every kbagent invocation in a session to use the beta
+    channel without re-typing ``--beta`` (e.g. CI smoke-tests for an
+    upcoming release). Mirrors the truthy parse pattern used by
+    ``KBAGENT_SKIP_UPDATE`` so the two env vars behave consistently.
+    """
+    import os
+
+    raw = os.environ.get("KBAGENT_INCLUDE_PRERELEASE", "").strip().lower()
+    return raw in {"1", "true", "yes", "on"}