kctl-api 0.2.0__py3-none-any.whl

kctl_api/commands/lint_cmd.py

@@ -0,0 +1,81 @@
+"""Linting commands for kctl-api.
+
+Run ruff and mypy checks via project scripts.
+"""
+
+from __future__ import annotations
+
+import subprocess
+
+import typer
+
+from kctl_api.core.callbacks import AppContext
+from kctl_api.core.utils import find_project_root
+
+app = typer.Typer(name="lint", help="Linting — check, fix, strict.", no_args_is_help=True)
+
+
+# ---------------------------------------------------------------------------
+# check
+# ---------------------------------------------------------------------------
+@app.command()
+def check(ctx: typer.Context) -> None:
+    """Run ruff check + mypy via scripts/lint."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    cmd = [str(root / "scripts" / "lint")]
+
+    out.info("Running lint checks ...")
+    result = subprocess.run(cmd, cwd=str(root), capture_output=False)
+    if result.returncode != 0:
+        out.error("Lint checks failed.")
+        raise typer.Exit(result.returncode)
+    out.success("Lint checks passed.")
+
+
+# ---------------------------------------------------------------------------
+# fix
+# ---------------------------------------------------------------------------
+@app.command()
+def fix(ctx: typer.Context) -> None:
+    """Run ruff check --fix to auto-fix lint issues."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+
+    out.info("Auto-fixing lint issues ...")
+    result = subprocess.run(
+        ["ruff", "check", "--fix", "."],
+        cwd=str(root),
+        capture_output=False,
+    )
+    if result.returncode != 0:
+        out.warn("Some issues could not be auto-fixed.")
+    else:
+        out.success("All auto-fixable issues resolved.")
+
+
+# ---------------------------------------------------------------------------
+# strict
+# ---------------------------------------------------------------------------
+@app.command()
+def strict(ctx: typer.Context) -> None:
+    """Run mypy in strict mode."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+
+    out.info("Running mypy strict ...")
+    result = subprocess.run(
+        ["mypy", "--strict", "."],
+        cwd=str(root),
+        capture_output=False,
+    )
+    if result.returncode != 0:
+        out.error("Strict type checking failed.")
+        raise typer.Exit(result.returncode)
+    out.success("Strict type checking passed.")

kctl_api/commands/logs.py

@@ -0,0 +1,258 @@
+"""Log viewing commands for kctl-api.
+
+Follow, search, and filter service logs via docker compose.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import subprocess
+from typing import Annotated
+
+import typer
+
+from kctl_api.core.callbacks import AppContext
+from kctl_api.core.utils import find_project_root
+
+app = typer.Typer(name="logs", help="Log viewer — follow, errors, search, tail.", no_args_is_help=True)
+
+
+def _compose_log_cmd(args: list[str]) -> list[str]:
+    """Build a docker compose logs command."""
+    root = find_project_root()
+    return ["docker", "compose", "-f", str(root / "docker-compose.yml"), "logs", *args]
+
+
+# ---------------------------------------------------------------------------
+# follow
+# ---------------------------------------------------------------------------
+@app.command()
+def follow(
+    ctx: typer.Context,
+    service: Annotated[str | None, typer.Argument(help="Service name (all if omitted).")] = None,
+    tail: Annotated[int, typer.Option("--tail", "-n", help="Initial lines to show.")] = 50,
+) -> None:
+    """Follow service logs in real time."""
+    cmd = _compose_log_cmd(["--follow", "--tail", str(tail)])
+    if service:
+        cmd.append(service)
+    with contextlib.suppress(KeyboardInterrupt):
+        subprocess.run(cmd, capture_output=False)
+
+
+# ---------------------------------------------------------------------------
+# errors
+# ---------------------------------------------------------------------------
+@app.command()
+def errors(
+    ctx: typer.Context,
+    service: Annotated[str | None, typer.Argument(help="Service name (all if omitted).")] = None,
+    tail: Annotated[int, typer.Option("--tail", "-n", help="Lines to scan.")] = 500,
+) -> None:
+    """Show only error-level log lines from services."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    cmd = _compose_log_cmd(["--tail", str(tail)])
+    if service:
+        cmd.append(service)
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        out.error(f"Failed to fetch logs: {result.stderr.strip()}")
+        raise typer.Exit(1)
+
+    error_lines = [
+        line
+        for line in result.stdout.splitlines()
+        if any(kw in line.upper() for kw in ("ERROR", "CRITICAL", "FATAL", "EXCEPTION", "TRACEBACK"))
+    ]
+
+    if not error_lines:
+        out.success("No errors found in recent logs.")
+        return
+
+    out.header(f"Errors ({len(error_lines)} lines)")
+    for line in error_lines:
+        out.text(f"[red]{line}[/red]")
+
+
+# ---------------------------------------------------------------------------
+# search
+# ---------------------------------------------------------------------------
+@app.command()
+def search(
+    ctx: typer.Context,
+    pattern: Annotated[str, typer.Argument(help="Text pattern to search for.")],
+    service: Annotated[str | None, typer.Option("--service", "-s", help="Service name.")] = None,
+    tail: Annotated[int, typer.Option("--tail", "-n", help="Lines to scan.")] = 1000,
+) -> None:
+    """Search service logs for a pattern."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    cmd = _compose_log_cmd(["--tail", str(tail)])
+    if service:
+        cmd.append(service)
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        out.error(f"Failed to fetch logs: {result.stderr.strip()}")
+        raise typer.Exit(1)
+
+    matching = [line for line in result.stdout.splitlines() if pattern.lower() in line.lower()]
+
+    if not matching:
+        out.info(f"No matches for '{pattern}' in recent logs.")
+        return
+
+    out.header(f"Search: '{pattern}' ({len(matching)} matches)")
+    for line in matching:
+        out.text(line)
+
+
+# ---------------------------------------------------------------------------
+# tail
+# ---------------------------------------------------------------------------
+@app.command()
+def tail(
+    ctx: typer.Context,
+    service: Annotated[str | None, typer.Argument(help="Service name (all if omitted).")] = None,
+    lines: Annotated[int, typer.Option("--lines", "-n", help="Number of lines.")] = 100,
+) -> None:
+    """Show the last N lines of service logs."""
+    cmd = _compose_log_cmd(["--tail", str(lines)])
+    if service:
+        cmd.append(service)
+    subprocess.run(cmd, capture_output=False)
+
+
+# ---------------------------------------------------------------------------
+# structured
+# ---------------------------------------------------------------------------
+@app.command()
+def structured(
+    ctx: typer.Context,
+    service: Annotated[str | None, typer.Argument(help="Service name (all if omitted).")] = None,
+    tail_lines: Annotated[int, typer.Option("--tail", "-n", help="Lines to scan.")] = 500,
+    level: Annotated[str | None, typer.Option("--level", "-l", help="Filter by log level.")] = None,
+    event: Annotated[str | None, typer.Option("--event", "-e", help="Filter by event name.")] = None,
+) -> None:
+    """Parse and display JSON (structured) log lines from services."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    cmd = _compose_log_cmd(["--tail", str(tail_lines)])
+    if service:
+        cmd.append(service)
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        out.error(f"Failed to fetch logs: {result.stderr.strip()}")
+        raise typer.Exit(1)
+
+    import json
+
+    parsed: list[dict] = []
+    for line in result.stdout.splitlines():
+        # Try to extract JSON from lines (structlog may have container prefix)
+        json_start = line.find("{")
+        if json_start == -1:
+            continue
+        json_part = line[json_start:]
+        try:
+            entry = json.loads(json_part)
+            parsed.append(entry)
+        except json.JSONDecodeError:
+            continue
+
+    # Filter
+    if level:
+        parsed = [e for e in parsed if e.get("level", e.get("severity", "")).lower() == level.lower()]
+    if event:
+        parsed = [e for e in parsed if event.lower() in str(e.get("event", e.get("msg", ""))).lower()]
+
+    if not parsed:
+        out.info(f"No structured log entries found{' (with filters applied)' if level or event else ''}.")
+        return
+
+    rows = [
+        [
+            str(e.get("timestamp", e.get("time", ""))[:19]),
+            str(e.get("level", e.get("severity", ""))),
+            str(e.get("event", e.get("msg", ""))),
+            str(e.get("logger", e.get("name", ""))),
+        ]
+        for e in parsed[-50:]  # last 50
+    ]
+    out.table(
+        title=f"Structured Logs ({len(parsed)} entries)",
+        columns=[("Timestamp", "dim"), ("Level", "bold"), ("Event", ""), ("Logger", "dim")],
+        rows=rows,
+        data_for_json=parsed[-100:],
+    )
+
+
+# ---------------------------------------------------------------------------
+# correlation
+# ---------------------------------------------------------------------------
+@app.command()
+def correlation(
+    ctx: typer.Context,
+    request_id: Annotated[str, typer.Argument(help="Request ID or correlation ID to trace.")],
+    service: Annotated[str | None, typer.Option("--service", "-s", help="Service name.")] = None,
+    tail_lines: Annotated[int, typer.Option("--tail", "-n", help="Lines to scan.")] = 2000,
+) -> None:
+    """Trace a request across services by correlation/request ID."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    cmd = _compose_log_cmd(["--tail", str(tail_lines)])
+    if service:
+        cmd.append(service)
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        out.error(f"Failed to fetch logs: {result.stderr.strip()}")
+        raise typer.Exit(1)
+
+    import json
+
+    matching_lines: list[dict] = []
+    for line in result.stdout.splitlines():
+        if request_id not in line:
+            continue
+
+        # Try to parse as structured log
+        json_start = line.find("{")
+        if json_start >= 0:
+            try:
+                entry = json.loads(line[json_start:])
+                entry["_raw"] = line
+                matching_lines.append(entry)
+                continue
+            except json.JSONDecodeError:
+                pass
+
+        # Plain text match
+        matching_lines.append({"_raw": line, "event": line.strip()})
+
+    if not matching_lines:
+        out.info(f"No log entries found for request_id: {request_id}")
+        return
+
+    out.header(f"Correlation Trace: {request_id} ({len(matching_lines)} entries)")
+    for entry in matching_lines:
+        ts = entry.get("timestamp", entry.get("time", ""))[:19]
+        level = entry.get("level", entry.get("severity", "INFO"))
+        event = entry.get("event", entry.get("msg", entry.get("_raw", "")))
+        logger = entry.get("logger", entry.get("name", ""))
+
+        color = {"ERROR": "red", "WARNING": "yellow", "WARN": "yellow", "DEBUG": "dim"}.get(level.upper(), "")
+        if color:
+            out.text(f"  [{ts}] [{color}]{level}[/{color}] {logger}: {event}")
+        else:
+            out.text(f"  [{ts}] {level} {logger}: {event}")
+
+    if actx.json_mode:
+        out.raw_json({"request_id": request_id, "entries": matching_lines})

kctl_api/commands/marketplace.py

@@ -0,0 +1,316 @@
+"""Marketplace commands for kctl-api.
+
+Browse, search, install, and manage extensions.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_api.core.callbacks import AppContext
+from kctl_api.core.exceptions import APIError, AuthenticationError
+from kctl_api.core.exceptions import ConnectionError as KctlConnectionError
+
+app = typer.Typer(name="marketplace", help="Extension marketplace — browse, install, publish.", no_args_is_help=True)
+
+_BASE = "/api/v1/marketplace/extensions"
+
+
+# ---------------------------------------------------------------------------
+# list
+# ---------------------------------------------------------------------------
+@app.command(name="list")
+def list_extensions(
+    ctx: typer.Context,
+    page: Annotated[int, typer.Option("--page", "-p", help="Page number.")] = 1,
+    per_page: Annotated[int, typer.Option("--per-page", "-n", help="Items per page.")] = 20,
+    category: Annotated[str | None, typer.Option("--category", "-c", help="Filter by category.")] = None,
+) -> None:
+    """List marketplace extensions."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    params: dict[str, str | int] = {"page": page, "per_page": per_page}
+    if category:
+        params["category"] = category
+
+    try:
+        data = actx.client.get(_BASE, params=params)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    items = data.get("items", []) if isinstance(data, dict) else []
+    total = data.get("total", len(items)) if isinstance(data, dict) else len(items)
+
+    rows: list[list[str]] = []
+    for ext in items:
+        rows.append(
+            [
+                str(ext.get("id", "")),
+                ext.get("name", ""),
+                ext.get("version", ""),
+                ext.get("author", ""),
+                ext.get("category", ""),
+                "[green]yes[/green]" if ext.get("installed") else "[dim]no[/dim]",
+            ]
+        )
+
+    out.table(
+        title=f"Marketplace Extensions (page {page}, {total} total)",
+        columns=[
+            ("ID", "bold"),
+            ("Name", ""),
+            ("Version", ""),
+            ("Author", "dim"),
+            ("Category", ""),
+            ("Installed", ""),
+        ],
+        rows=rows,
+        data_for_json=items,
+    )
+
+
+# ---------------------------------------------------------------------------
+# search
+# ---------------------------------------------------------------------------
+@app.command()
+def search(
+    ctx: typer.Context,
+    query: Annotated[str, typer.Argument(help="Search query.")],
+    page: Annotated[int, typer.Option("--page", "-p", help="Page number.")] = 1,
+    per_page: Annotated[int, typer.Option("--per-page", "-n", help="Items per page.")] = 20,
+) -> None:
+    """Search marketplace extensions by name or description."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    try:
+        data = actx.client.get(_BASE, params={"search": query, "page": page, "per_page": per_page})
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    items = data.get("items", []) if isinstance(data, dict) else []
+    total = data.get("total", len(items)) if isinstance(data, dict) else len(items)
+
+    rows: list[list[str]] = []
+    for ext in items:
+        rows.append(
+            [
+                str(ext.get("id", "")),
+                ext.get("name", ""),
+                ext.get("version", ""),
+                ext.get("description", "")[:60],
+            ]
+        )
+
+    out.table(
+        title=f"Search: '{query}' ({total} results)",
+        columns=[
+            ("ID", "bold"),
+            ("Name", ""),
+            ("Version", ""),
+            ("Description", "dim"),
+        ],
+        rows=rows,
+        data_for_json=items,
+    )
+
+
+# ---------------------------------------------------------------------------
+# get
+# ---------------------------------------------------------------------------
+@app.command(name="get")
+def get_extension(
+    ctx: typer.Context,
+    extension_id: Annotated[str, typer.Argument(help="Extension ID.")],
+) -> None:
+    """Get extension details."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    try:
+        data = actx.client.get(f"{_BASE}/{extension_id}")
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    if not data:
+        out.error(f"Extension not found: {extension_id}")
+        raise typer.Exit(1)
+
+    out.detail(
+        title=f"Extension: {data.get('name', extension_id)}",
+        sections=[
+            ("Details", [(k, str(v)) for k, v in data.items()]),
+        ],
+        data_for_json=data,
+    )
+
+
+# ---------------------------------------------------------------------------
+# install
+# ---------------------------------------------------------------------------
+@app.command()
+def install(
+    ctx: typer.Context,
+    extension_id: Annotated[str, typer.Argument(help="Extension ID to install.")],
+) -> None:
+    """Install a marketplace extension via POST."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    try:
+        result = actx.client.post(f"{_BASE}/{extension_id}/install")
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Extension {extension_id} installed.")
+    if actx.json_mode:
+        out.raw_json(result)
+
+
+# ---------------------------------------------------------------------------
+# uninstall
+# ---------------------------------------------------------------------------
+@app.command()
+def uninstall(
+    ctx: typer.Context,
+    extension_id: Annotated[str, typer.Argument(help="Extension ID to uninstall.")],
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation.")] = False,
+) -> None:
+    """Uninstall a marketplace extension via DELETE."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    if not force:
+        confirm = typer.confirm(f"Uninstall extension {extension_id}?", default=False)
+        if not confirm:
+            out.info("Cancelled.")
+            raise typer.Exit(0)
+
+    try:
+        result = actx.client.delete(f"{_BASE}/{extension_id}/install")
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Extension {extension_id} uninstalled.")
+    if actx.json_mode:
+        out.raw_json(result)
+
+
+# ---------------------------------------------------------------------------
+# publish
+# ---------------------------------------------------------------------------
+@app.command()
+def publish(
+    ctx: typer.Context,
+    manifest_path: Annotated[str, typer.Argument(help="Path to extension manifest JSON.")],
+) -> None:
+    """Publish a new extension via POST /api/v1/marketplace/extensions."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    import json
+    from pathlib import Path
+
+    manifest_file = Path(manifest_path)
+    if not manifest_file.exists():
+        out.error(f"Manifest file not found: {manifest_path}")
+        raise typer.Exit(1)
+
+    try:
+        payload = json.loads(manifest_file.read_text())
+    except json.JSONDecodeError as e:
+        out.error(f"Invalid JSON manifest: {e}")
+        raise typer.Exit(1) from None
+
+    try:
+        result = actx.client.post(_BASE, json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Extension published: {payload.get('name', 'unknown')}")
+    if actx.json_mode:
+        out.raw_json(result)
+
+
+# ---------------------------------------------------------------------------
+# review
+# ---------------------------------------------------------------------------
+@app.command()
+def review(
+    ctx: typer.Context,
+    extension_id: Annotated[str, typer.Argument(help="Extension ID to review.")],
+    rating: Annotated[int, typer.Option("--rating", "-r", help="Rating (1-5).")],
+    comment: Annotated[str | None, typer.Option("--comment", "-c", help="Review comment.")] = None,
+) -> None:
+    """Submit a review for an extension via POST."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    if rating < 1 or rating > 5:
+        out.error("Rating must be between 1 and 5.")
+        raise typer.Exit(1)
+
+    payload: dict = {"rating": rating}
+    if comment:
+        payload["comment"] = comment
+
+    try:
+        result = actx.client.post(f"{_BASE}/{extension_id}/reviews", json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Review submitted for extension {extension_id}.")
+    if actx.json_mode:
+        out.raw_json(result)
+
+
+# ---------------------------------------------------------------------------
+# versions
+# ---------------------------------------------------------------------------
+@app.command()
+def versions(
+    ctx: typer.Context,
+    extension_id: Annotated[str, typer.Argument(help="Extension ID.")],
+) -> None:
+    """List available versions for an extension via GET."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    try:
+        data = actx.client.get(f"{_BASE}/{extension_id}/versions")
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    items = data if isinstance(data, list) else data.get("items", []) if isinstance(data, dict) else []
+
+    rows: list[list[str]] = []
+    for v in items:
+        rows.append(
+            [
+                v.get("version", ""),
+                str(v.get("released_at", "")),
+                v.get("changelog", "")[:60],
+            ]
+        )
+
+    out.table(
+        title=f"Versions: Extension {extension_id}",
+        columns=[
+            ("Version", "bold"),
+            ("Released", "dim"),
+            ("Changelog", ""),
+        ],
+        rows=rows,
+        data_for_json=items,
+    )