kctl-api 0.2.0__py3-none-any.whl

kctl_api/commands/automation.py

@@ -0,0 +1,242 @@
+"""Automation template commands for kctl-api.
+
+CRUD for automation templates and manual trigger execution.
+"""
+
+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="automation", help="Automation templates — list, create, update, delete, run.", no_args_is_help=True
+)
+
+_BASE = "/api/v1/automation/templates"
+
+
+# ---------------------------------------------------------------------------
+# list
+# ---------------------------------------------------------------------------
+@app.command(name="list")
+def list_templates(
+    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,
+) -> None:
+    """List automation templates."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    try:
+        data = actx.client.get(_BASE, params={"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 t in items:
+        rows.append(
+            [
+                str(t.get("id", "")),
+                t.get("name", ""),
+                t.get("trigger_type", ""),
+                "[green]yes[/green]" if t.get("enabled") else "[red]no[/red]",
+                str(t.get("created_at", "")),
+            ]
+        )
+
+    out.table(
+        title=f"Automation Templates (page {page}, {total} total)",
+        columns=[
+            ("ID", "bold"),
+            ("Name", ""),
+            ("Trigger", ""),
+            ("Enabled", ""),
+            ("Created", "dim"),
+        ],
+        rows=rows,
+        data_for_json=items,
+    )
+
+
+# ---------------------------------------------------------------------------
+# create
+# ---------------------------------------------------------------------------
+@app.command()
+def create(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Option("--name", "-n", help="Template name.")],
+    trigger_type: Annotated[str, typer.Option("--trigger", "-t", help="Trigger type (e.g. cron, webhook, event).")],
+    config_json: Annotated[str | None, typer.Option("--config", "-c", help="JSON config payload.")] = None,
+) -> None:
+    """Create a new automation template via POST."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    import json
+
+    payload: dict = {"name": name, "trigger_type": trigger_type}
+    if config_json:
+        try:
+            payload["config"] = json.loads(config_json)
+        except json.JSONDecodeError as e:
+            out.error(f"Invalid JSON: {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"Template created: {name}")
+    if actx.json_mode:
+        out.raw_json(result)
+
+
+# ---------------------------------------------------------------------------
+# get
+# ---------------------------------------------------------------------------
+@app.command(name="get")
+def get_template(
+    ctx: typer.Context,
+    template_id: Annotated[str, typer.Argument(help="Template ID.")],
+) -> None:
+    """Get automation template details."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    try:
+        data = actx.client.get(f"{_BASE}/{template_id}")
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    if not data:
+        out.error(f"Template not found: {template_id}")
+        raise typer.Exit(1)
+
+    out.detail(
+        title=f"Template: {data.get('name', template_id)}",
+        sections=[
+            ("Details", [(k, str(v)) for k, v in data.items()]),
+        ],
+        data_for_json=data,
+    )
+
+
+# ---------------------------------------------------------------------------
+# update
+# ---------------------------------------------------------------------------
+@app.command()
+def update(
+    ctx: typer.Context,
+    template_id: Annotated[str, typer.Argument(help="Template ID.")],
+    name: Annotated[str | None, typer.Option("--name", "-n", help="New name.")] = None,
+    enabled: Annotated[bool | None, typer.Option("--enabled/--disabled", help="Enable or disable.")] = None,
+    config_json: Annotated[str | None, typer.Option("--config", "-c", help="JSON config payload.")] = None,
+) -> None:
+    """Update an automation template via PATCH."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    import json
+
+    payload: dict = {}
+    if name:
+        payload["name"] = name
+    if enabled is not None:
+        payload["enabled"] = enabled
+    if config_json:
+        try:
+            payload["config"] = json.loads(config_json)
+        except json.JSONDecodeError as e:
+            out.error(f"Invalid JSON: {e}")
+            raise typer.Exit(1) from None
+
+    if not payload:
+        out.warn("No fields to update.")
+        raise typer.Exit(0)
+
+    try:
+        result = actx.client.patch(f"{_BASE}/{template_id}", json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Template {template_id} updated.")
+    if actx.json_mode:
+        out.raw_json(result)
+
+
+# ---------------------------------------------------------------------------
+# delete
+# ---------------------------------------------------------------------------
+@app.command()
+def delete(
+    ctx: typer.Context,
+    template_id: Annotated[str, typer.Argument(help="Template ID.")],
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation.")] = False,
+) -> None:
+    """Delete an automation template via DELETE."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    if not force:
+        confirm = typer.confirm(f"Delete template {template_id}?", default=False)
+        if not confirm:
+            out.info("Cancelled.")
+            raise typer.Exit(0)
+
+    try:
+        result = actx.client.delete(f"{_BASE}/{template_id}")
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Template {template_id} deleted.")
+    if actx.json_mode:
+        out.raw_json(result)
+
+
+# ---------------------------------------------------------------------------
+# run
+# ---------------------------------------------------------------------------
+@app.command()
+def run(
+    ctx: typer.Context,
+    template_id: Annotated[str, typer.Argument(help="Template ID to trigger.")],
+    data_json: Annotated[str | None, typer.Option("--data", "-d", help="JSON input payload.")] = None,
+) -> None:
+    """Manually trigger an automation template via POST."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    import json
+
+    payload: dict = {}
+    if data_json:
+        try:
+            payload = json.loads(data_json)
+        except json.JSONDecodeError as e:
+            out.error(f"Invalid JSON: {e}")
+            raise typer.Exit(1) from None
+
+    try:
+        result = actx.client.post(f"{_BASE}/{template_id}/run", json=payload)
+    except (AuthenticationError, KctlConnectionError, APIError) as e:
+        out.error(str(e))
+        raise typer.Exit(1) from None
+
+    out.success(f"Template {template_id} triggered.")
+    if actx.json_mode:
+        out.raw_json(result)

kctl_api/commands/build_cmd.py

@@ -0,0 +1,87 @@
+"""Build commands for kctl-api.
+
+Build Docker images for development and production.
+"""
+
+from __future__ import annotations
+
+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="build", help="Docker image builds — dev, prod, all.", no_args_is_help=True)
+
+
+# ---------------------------------------------------------------------------
+# dev
+# ---------------------------------------------------------------------------
+@app.command()
+def dev(
+    ctx: typer.Context,
+    app_name: Annotated[str, typer.Argument(help="App name or 'all'.")] = "all",
+) -> None:
+    """Build development Docker image(s) via scripts/build --dev."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    cmd = [str(root / "scripts" / "build"), app_name, "--dev"]
+
+    out.info(f"Building dev image: {app_name}")
+    result = subprocess.run(cmd, cwd=str(root), capture_output=False)
+    if result.returncode != 0:
+        out.error("Build failed.")
+        raise typer.Exit(result.returncode)
+    out.success(f"Dev build complete: {app_name}")
+
+
+# ---------------------------------------------------------------------------
+# prod
+# ---------------------------------------------------------------------------
+@app.command()
+def prod(
+    ctx: typer.Context,
+    app_name: Annotated[str, typer.Argument(help="App name or 'all'.")] = "all",
+) -> None:
+    """Build production Docker image(s) via scripts/build."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    cmd = [str(root / "scripts" / "build"), app_name]
+
+    out.info(f"Building prod image: {app_name}")
+    result = subprocess.run(cmd, cwd=str(root), capture_output=False)
+    if result.returncode != 0:
+        out.error("Build failed.")
+        raise typer.Exit(result.returncode)
+    out.success(f"Prod build complete: {app_name}")
+
+
+# ---------------------------------------------------------------------------
+# all
+# ---------------------------------------------------------------------------
+@app.command(name="all")
+def build_all(
+    ctx: typer.Context,
+    dev_mode: Annotated[bool, typer.Option("--dev", help="Build in dev mode.")] = False,
+) -> None:
+    """Build all Docker images via scripts/build all."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    cmd = [str(root / "scripts" / "build"), "all"]
+    if dev_mode:
+        cmd.append("--dev")
+
+    out.info("Building all images ...")
+    result = subprocess.run(cmd, cwd=str(root), capture_output=False)
+    if result.returncode != 0:
+        out.error("Build failed.")
+        raise typer.Exit(result.returncode)
+    out.success("All builds complete.")

kctl_api/commands/clean.py

@@ -0,0 +1,182 @@
+"""Artifact cleanup commands for kctl-api.
+
+Clean build artifacts, caches, and __pycache__ directories.
+"""
+
+from __future__ import annotations
+
+import pathlib
+import shutil
+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="clean", help="Cleanup — all, cache, build, pycache.", no_args_is_help=True)
+
+
+def _rm_dirs(patterns: list[str], root: pathlib.Path, dry_run: bool = False) -> list[pathlib.Path]:
+    """Remove directories matching glob patterns under root. Returns removed paths."""
+    removed: list[pathlib.Path] = []
+    skip_dirs = {".venv", ".git", "node_modules"}
+
+    for pattern in patterns:
+        for target in root.rglob(pattern):
+            # Don't clean inside .venv or .git
+            if any(part in skip_dirs for part in target.parts):
+                continue
+            if target.is_dir():
+                removed.append(target)
+                if not dry_run:
+                    shutil.rmtree(target, ignore_errors=True)
+            elif target.is_file():
+                removed.append(target)
+                if not dry_run:
+                    target.unlink(missing_ok=True)
+
+    return removed
+
+
+def _rm_files(patterns: list[str], root: pathlib.Path, dry_run: bool = False) -> list[pathlib.Path]:
+    """Remove files matching glob patterns under root."""
+    removed: list[pathlib.Path] = []
+    skip_dirs = {".venv", ".git", "node_modules"}
+
+    for pattern in patterns:
+        for target in root.rglob(pattern):
+            if any(part in skip_dirs for part in target.parts):
+                continue
+            if target.is_file():
+                removed.append(target)
+                if not dry_run:
+                    target.unlink(missing_ok=True)
+
+    return removed
+
+
+def _display_removed(out: object, removed: list[pathlib.Path], root: pathlib.Path, dry_run: bool) -> None:
+    """Print removed paths."""
+    prefix = "[dim](dry-run)[/dim] " if dry_run else ""
+    for path in removed[:30]:
+        try:
+            rel = path.relative_to(root)
+        except ValueError:
+            rel = path
+        out.text(f"  {prefix}[red]rm[/red] {rel}")  # type: ignore[attr-defined]
+    if len(removed) > 30:
+        out.text(f"  ... and {len(removed) - 30} more")  # type: ignore[attr-defined]
+
+
+# ---------------------------------------------------------------------------
+# all
+# ---------------------------------------------------------------------------
+@app.command(name="all")
+def clean_all(
+    ctx: typer.Context,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Show what would be removed without deleting.")] = False,
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation.")] = False,
+) -> None:
+    """Remove all build artifacts, caches, and __pycache__ directories."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    if not force and not dry_run:
+        confirm = typer.confirm("Remove all build artifacts and caches?", default=False)
+        if not confirm:
+            out.info("Cancelled.")
+            raise typer.Exit(0)
+
+    root = find_project_root()
+    total_removed: list[pathlib.Path] = []
+
+    cache_dirs = [".ruff_cache", ".mypy_cache", ".pytest_cache", ".hypothesis", ".tox"]
+    build_dirs = ["dist", "build", "*.egg-info"]
+    pycache_dirs = ["__pycache__"]
+    coverage_files = [".coverage", "coverage.xml", "htmlcov"]
+
+    total_removed += _rm_dirs(cache_dirs, root, dry_run)
+    total_removed += _rm_dirs(build_dirs, root, dry_run)
+    total_removed += _rm_dirs(pycache_dirs, root, dry_run)
+    total_removed += _rm_dirs(coverage_files, root, dry_run)
+    total_removed += _rm_files(["*.pyc", "*.pyo"], root, dry_run)
+
+    if total_removed:
+        _display_removed(out, total_removed, root, dry_run)
+        action = "Would remove" if dry_run else "Removed"
+        out.success(f"{action} {len(total_removed)} items.")
+    else:
+        out.info("Nothing to clean.")
+
+
+# ---------------------------------------------------------------------------
+# cache
+# ---------------------------------------------------------------------------
+@app.command()
+def cache(
+    ctx: typer.Context,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Show what would be removed.")] = False,
+) -> None:
+    """Remove .ruff_cache, .mypy_cache, .pytest_cache directories."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    patterns = [".ruff_cache", ".mypy_cache", ".pytest_cache", ".hypothesis"]
+    removed = _rm_dirs(patterns, root, dry_run)
+
+    if removed:
+        _display_removed(out, removed, root, dry_run)
+        action = "Would remove" if dry_run else "Removed"
+        out.success(f"{action} {len(removed)} cache directories.")
+    else:
+        out.info("No cache directories found.")
+
+
+# ---------------------------------------------------------------------------
+# build
+# ---------------------------------------------------------------------------
+@app.command()
+def build(
+    ctx: typer.Context,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Show what would be removed.")] = False,
+) -> None:
+    """Remove dist/ and *.egg-info build artifacts."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    patterns = ["dist", "build", "*.egg-info", "*.dist-info"]
+    removed = _rm_dirs(patterns, root, dry_run)
+
+    if removed:
+        _display_removed(out, removed, root, dry_run)
+        action = "Would remove" if dry_run else "Removed"
+        out.success(f"{action} {len(removed)} build artifact directories.")
+    else:
+        out.info("No build artifacts found.")
+
+
+# ---------------------------------------------------------------------------
+# pycache
+# ---------------------------------------------------------------------------
+@app.command()
+def pycache(
+    ctx: typer.Context,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Show what would be removed.")] = False,
+) -> None:
+    """Remove all __pycache__ directories and .pyc/.pyo files."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    removed = _rm_dirs(["__pycache__"], root, dry_run)
+    removed += _rm_files(["*.pyc", "*.pyo"], root, dry_run)
+
+    if removed:
+        _display_removed(out, removed, root, dry_run)
+        action = "Would remove" if dry_run else "Removed"
+        out.success(f"{action} {len(removed)} __pycache__ items.")
+    else:
+        out.info("No __pycache__ directories found.")