kctl-api 0.2.0__py3-none-any.whl

kctl_api/commands/deps.py

@@ -0,0 +1,289 @@
+"""Dependency management commands for kctl-api.
+
+Audit, outdated, licenses, graph, and size analysis.
+"""
+
+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="deps", help="Dependency management — audit, outdated, licenses, graph, size.", no_args_is_help=True
+)
+
+
+def _run_uv(args: list[str], cwd: str | None = None) -> subprocess.CompletedProcess:
+    return subprocess.run(["uv", *args], capture_output=True, text=True, cwd=cwd)
+
+
+# ---------------------------------------------------------------------------
+# audit
+# ---------------------------------------------------------------------------
+@app.command()
+def audit(
+    ctx: typer.Context,
+    fix: Annotated[bool, typer.Option("--fix", help="Attempt to upgrade vulnerable packages.")] = False,
+) -> None:
+    """Run security audit via uv or pip-audit."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    out.info("Running dependency security audit ...")
+
+    # Try pip-audit first (more detailed), fall back to uv
+    import shutil
+
+    if shutil.which("pip-audit"):
+        cmd = ["pip-audit", "--format", "json"]
+        result = subprocess.run(cmd, capture_output=True, text=True, cwd=str(root))
+
+        if result.returncode == 0:
+            import json
+
+            try:
+                data = json.loads(result.stdout)
+                vulns = data.get("vulnerabilities", [])
+                if not vulns:
+                    out.success("No vulnerabilities found (pip-audit).")
+                    return
+
+                rows = [
+                    [v.get("name", ""), v.get("version", ""), v.get("id", ""), v.get("fix_versions", [""])[0]]
+                    for v in vulns
+                ]
+                out.table(
+                    title=f"Vulnerabilities ({len(vulns)})",
+                    columns=[("Package", "bold"), ("Version", ""), ("ID", "red"), ("Fix Version", "green")],
+                    rows=rows,
+                    data_for_json=vulns,
+                )
+                raise typer.Exit(1)
+            except Exception:
+                pass
+
+        out.text(result.stdout)
+        if result.returncode != 0:
+            out.text(result.stderr)
+    else:
+        # Fall back to uv audit (uv >= 0.4)
+        result = _run_uv(["audit"], cwd=str(root))
+        if result.returncode == 0 and not result.stdout.strip():
+            out.success("No vulnerabilities found (uv audit).")
+        else:
+            out.text(result.stdout)
+            if result.stderr:
+                out.text(result.stderr)
+            out.info("For detailed audit: uv add --dev pip-audit && pip-audit")
+
+
+# ---------------------------------------------------------------------------
+# outdated
+# ---------------------------------------------------------------------------
+@app.command()
+def outdated(ctx: typer.Context) -> None:
+    """Show outdated packages across all workspace members."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    out.info("Checking for outdated packages ...")
+
+    result = _run_uv(["pip", "list", "--outdated", "--format", "json"], cwd=str(root))
+
+    if result.returncode != 0:
+        # Try without --format json
+        result = _run_uv(["pip", "list", "--outdated"], cwd=str(root))
+        out.text(result.stdout or "(no output)")
+        return
+
+    import json
+
+    try:
+        packages = json.loads(result.stdout)
+    except Exception:
+        out.text(result.stdout or "(no output)")
+        return
+
+    if not packages:
+        out.success("All packages are up to date.")
+        return
+
+    rows = [[p.get("name", ""), p.get("version", ""), p.get("latest_version", "")] for p in packages]
+    out.table(
+        title=f"Outdated Packages ({len(packages)})",
+        columns=[("Package", "bold"), ("Current", "yellow"), ("Latest", "green")],
+        rows=rows,
+        data_for_json=packages,
+    )
+    out.info("Upgrade: uv sync --upgrade")
+
+
+# ---------------------------------------------------------------------------
+# licenses
+# ---------------------------------------------------------------------------
+@app.command()
+def licenses(
+    ctx: typer.Context,
+    allow: Annotated[str | None, typer.Option("--allow", help="Comma-separated allowed license patterns.")] = None,
+) -> None:
+    """Generate a license report for all installed packages."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+
+    # Try pip-licenses
+    import shutil
+
+    if shutil.which("pip-licenses"):
+        result = subprocess.run(["pip-licenses", "--format", "json"], capture_output=True, text=True, cwd=str(root))
+        if result.returncode == 0:
+            import json
+
+            try:
+                data = json.loads(result.stdout)
+                allowed_list = [a.strip().upper() for a in (allow or "").split(",")] if allow else []
+
+                flagged = []
+                for pkg in data:
+                    lic = pkg.get("License", "UNKNOWN").upper()
+                    if allowed_list and not any(a in lic for a in allowed_list):
+                        flagged.append(pkg)
+
+                display = flagged if (allowed_list and flagged) else data
+                rows = [[p.get("Name", ""), p.get("Version", ""), p.get("License", "")] for p in display[:100]]
+                out.table(
+                    title=f"Package Licenses ({len(display)} of {len(data)})",
+                    columns=[("Package", "bold"), ("Version", ""), ("License", "")],
+                    rows=rows,
+                    data_for_json=display,
+                )
+                if allowed_list and flagged:
+                    out.warn(f"{len(flagged)} packages with non-allowed licenses.")
+                    raise typer.Exit(1)
+                return
+            except Exception:
+                pass
+
+    # Fall back: parse from uv pip list
+    out.info("pip-licenses not installed. Install: uv add --dev pip-licenses")
+    result = _run_uv(["pip", "show", "--format", "columns"], cwd=str(root))
+    if result.stdout:
+        out.text(result.stdout[:3000])
+
+
+# ---------------------------------------------------------------------------
+# graph
+# ---------------------------------------------------------------------------
+@app.command()
+def graph(ctx: typer.Context) -> None:
+    """Show the dependency graph via uv tree."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    out.info("Generating dependency graph ...")
+
+    result = _run_uv(["tree", "--all-packages"], cwd=str(root))
+    if result.returncode != 0:
+        # Try without --all-packages
+        result = _run_uv(["tree"], cwd=str(root))
+
+    if result.stdout:
+        typer.echo(result.stdout)
+    if result.stderr and result.returncode != 0:
+        out.error(result.stderr.strip())
+        raise typer.Exit(result.returncode)
+
+
+# ---------------------------------------------------------------------------
+# size
+# ---------------------------------------------------------------------------
+@app.command()
+def size(
+    ctx: typer.Context,
+    top: Annotated[int, typer.Option("--top", "-n", help="Show top N packages by size.")] = 20,
+) -> None:
+    """Show installed package sizes."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    import os
+
+    out.info(f"Analyzing package sizes (top {top}) ...")
+
+    # Get site-packages directory
+    try:
+        import site
+
+        site_dirs = site.getsitepackages()
+    except Exception:
+        site_dirs = []
+
+    result = _run_uv(["pip", "list", "--format", "json"])
+    packages: list[dict] = []
+    if result.returncode == 0:
+        import json
+
+        try:
+            pkg_list = json.loads(result.stdout)
+        except Exception:
+            pkg_list = []
+
+        for site_dir in site_dirs:
+            if not os.path.isdir(site_dir):
+                continue
+            for pkg_info in pkg_list:
+                pkg_name = pkg_info.get("name", "")
+                # Estimate size from dist-info directory
+                dist_name = pkg_name.replace("-", "_")
+                size_bytes = 0
+                for entry in os.scandir(site_dir):
+                    if entry.name.lower().startswith(dist_name.lower()):
+                        try:
+                            for root_dir, _dirs, files in os.walk(entry.path):
+                                size_bytes += sum(
+                                    os.path.getsize(os.path.join(root_dir, f))
+                                    for f in files
+                                    if not os.path.islink(os.path.join(root_dir, f))
+                                )
+                        except Exception:
+                            pass
+                if size_bytes > 0:
+                    packages.append(
+                        {
+                            "name": pkg_name,
+                            "version": pkg_info.get("version", ""),
+                            "size_bytes": size_bytes,
+                            "size_kb": round(size_bytes / 1024),
+                        }
+                    )
+            break  # Only use first site dir
+
+    if not packages:
+        out.warn(
+            "Could not determine package sizes. "
+            "Try: du -sh $(python -c 'import site; print(site.getsitepackages()[0])')"
+        )
+        return
+
+    packages.sort(key=lambda x: -x["size_bytes"])
+    display = packages[:top]
+
+    rows = [[p["name"], p["version"], f"{p['size_kb']} KB"] for p in display]
+    out.table(
+        title=f"Top {top} Packages by Size",
+        columns=[("Package", "bold"), ("Version", ""), ("Size", "")],
+        rows=rows,
+        data_for_json=display,
+    )
+
+    total_mb = round(sum(p["size_bytes"] for p in packages) / 1024 / 1024, 1)
+    out.info(f"Total installed: ~{total_mb} MB ({len(packages)} packages)")

kctl_api/commands/dev.py

@@ -0,0 +1,136 @@
+"""Development server commands for kctl-api.
+
+Start, stop, rebuild, and manage the dev environment.
+"""
+
+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="dev", help="Development environment — up, down, rebuild, logs.", no_args_is_help=True)
+
+
+# ---------------------------------------------------------------------------
+# up
+# ---------------------------------------------------------------------------
+@app.command()
+def up(
+    ctx: typer.Context,
+    build: Annotated[bool, typer.Option("--build", help="Rebuild images before starting.")] = False,
+    odoo_mm: Annotated[bool, typer.Option("--odoo-mm", help="Include Odoo-MM.")] = False,
+    plane_mm: Annotated[bool, typer.Option("--plane-mm", help="Include Plane-MM.")] = False,
+    all_services: Annotated[bool, typer.Option("--all", help="Include all optional services.")] = False,
+) -> None:
+    """Start the development stack via scripts/dev."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    cmd = [str(root / "scripts" / "dev")]
+    if build:
+        cmd.append("--build")
+    if odoo_mm:
+        cmd.append("--odoo-mm")
+    if plane_mm:
+        cmd.append("--plane-mm")
+    if all_services:
+        cmd.append("--all")
+
+    out.info("Starting dev environment ...")
+    result = subprocess.run(cmd, cwd=str(root), capture_output=False)
+    if result.returncode != 0:
+        out.error("Failed to start dev environment.")
+        raise typer.Exit(result.returncode)
+
+
+# ---------------------------------------------------------------------------
+# down
+# ---------------------------------------------------------------------------
+@app.command()
+def down(ctx: typer.Context) -> None:
+    """Stop the development stack."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    cmd = ["docker", "compose", "-f", str(root / "docker-compose.yml"), "down"]
+
+    out.info("Stopping dev environment ...")
+    result = subprocess.run(cmd, capture_output=False)
+    if result.returncode != 0:
+        out.error("Failed to stop dev environment.")
+        raise typer.Exit(result.returncode)
+    out.success("Dev environment stopped.")
+
+
+# ---------------------------------------------------------------------------
+# rebuild
+# ---------------------------------------------------------------------------
+@app.command()
+def rebuild(
+    ctx: typer.Context,
+    service: Annotated[str | None, typer.Argument(help="Service name (all if omitted).")] = None,
+) -> None:
+    """Rebuild and restart docker compose services."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    cmd = ["docker", "compose", "-f", str(root / "docker-compose.yml"), "up", "--build", "-d"]
+    if service:
+        cmd.append(service)
+
+    out.info(f"Rebuilding {service if service else 'all services'} ...")
+    result = subprocess.run(cmd, capture_output=False)
+    if result.returncode != 0:
+        out.error("Rebuild failed.")
+        raise typer.Exit(result.returncode)
+    out.success("Rebuild complete.")
+
+
+# ---------------------------------------------------------------------------
+# logs
+# ---------------------------------------------------------------------------
+@app.command()
+def logs(
+    ctx: typer.Context,
+    service: Annotated[str | None, typer.Argument(help="Service name (all if omitted).")] = None,
+    follow: Annotated[bool, typer.Option("--follow", "-f", help="Follow log output.")] = False,
+    tail: Annotated[int, typer.Option("--tail", "-n", help="Number of lines.")] = 100,
+) -> None:
+    """View docker compose logs."""
+    root = find_project_root()
+    cmd = ["docker", "compose", "-f", str(root / "docker-compose.yml"), "logs", "--tail", str(tail)]
+    if follow:
+        cmd.append("--follow")
+    if service:
+        cmd.append(service)
+    subprocess.run(cmd, capture_output=False)
+
+
+# ---------------------------------------------------------------------------
+# attach
+# ---------------------------------------------------------------------------
+@app.command()
+def attach(
+    ctx: typer.Context,
+    service: Annotated[str, typer.Argument(help="Service name to attach to.")],
+) -> None:
+    """Attach to a running container's shell."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    root = find_project_root()
+    cmd = ["docker", "compose", "-f", str(root / "docker-compose.yml"), "exec", service, "/bin/sh"]
+
+    out.info(f"Attaching to {service} ...")
+    result = subprocess.run(cmd, capture_output=False)
+    if result.returncode != 0:
+        out.error(f"Failed to attach to {service}.")
+        raise typer.Exit(result.returncode)

kctl_api/commands/docker_cmd.py

@@ -0,0 +1,252 @@
+"""Docker management commands for kctl-api.
+
+Image management, container inspection, network, volumes, and system info.
+"""
+
+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="docker", help="Docker management — images, containers, network, volumes, system.", no_args_is_help=True
+)
+
+
+def _compose_cmd(args: list[str], compose_file: str | None = None) -> list[str]:
+    root = find_project_root()
+    cf = compose_file or str(root / "docker-compose.yml")
+    return ["docker", "compose", "-f", cf, *args]
+
+
+# ---------------------------------------------------------------------------
+# images
+# ---------------------------------------------------------------------------
+@app.command()
+def images(ctx: typer.Context) -> None:
+    """List Docker images for the project."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    result = subprocess.run(
+        ["docker", "images", "--format", "json"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        out.error(f"docker images failed: {result.stderr.strip()}")
+        raise typer.Exit(1)
+
+    import json
+
+    image_list: list[dict] = []
+    for line in result.stdout.strip().splitlines():
+        if line.strip():
+            try:
+                image_list.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+
+    # Filter to project images
+    root = find_project_root()
+    project_name = root.name.replace("-", "")
+
+    project_images = [
+        img
+        for img in image_list
+        if project_name in (img.get("Repository") or "").lower() or "kodemeio" in (img.get("Repository") or "").lower()
+    ] or image_list[:20]
+
+    rows = [
+        [
+            img.get("Repository", ""),
+            img.get("Tag", ""),
+            img.get("Size", ""),
+            img.get("CreatedSince", img.get("CreatedAt", "")),
+        ]
+        for img in project_images
+    ]
+    out.table(
+        title=f"Docker Images ({len(project_images)})",
+        columns=[("Repository", "bold"), ("Tag", ""), ("Size", ""), ("Created", "")],
+        rows=rows,
+        data_for_json=project_images,
+    )
+
+
+# ---------------------------------------------------------------------------
+# containers
+# ---------------------------------------------------------------------------
+@app.command()
+def containers(
+    ctx: typer.Context,
+    all_containers: Annotated[bool, typer.Option("--all", "-a", help="Show stopped containers too.")] = False,
+) -> None:
+    """List running (or all) Docker containers."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    cmd = ["docker", "ps", "--format", "json"]
+    if all_containers:
+        cmd.append("--all")
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        out.error(f"docker ps failed: {result.stderr.strip()}")
+        raise typer.Exit(1)
+
+    import json
+
+    container_list: list[dict] = []
+    for line in result.stdout.strip().splitlines():
+        if line.strip():
+            try:
+                container_list.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+
+    rows = [
+        [
+            c.get("Names", c.get("Name", "")),
+            c.get("Image", ""),
+            c.get("Status", ""),
+            c.get("Ports", ""),
+        ]
+        for c in container_list
+    ]
+    out.table(
+        title=f"Containers ({len(container_list)})",
+        columns=[("Name", "bold"), ("Image", ""), ("Status", ""), ("Ports", "")],
+        rows=rows,
+        data_for_json=container_list,
+    )
+
+
+# ---------------------------------------------------------------------------
+# network
+# ---------------------------------------------------------------------------
+@app.command()
+def network(ctx: typer.Context) -> None:
+    """List Docker networks and show which containers are attached."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    result = subprocess.run(
+        ["docker", "network", "ls", "--format", "json"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        out.error(f"docker network ls failed: {result.stderr.strip()}")
+        raise typer.Exit(1)
+
+    import json
+
+    networks: list[dict] = []
+    for line in result.stdout.strip().splitlines():
+        if line.strip():
+            try:
+                networks.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+
+    rows = [
+        [
+            n.get("Name", ""),
+            n.get("Driver", ""),
+            n.get("Scope", ""),
+            "[green]yes[/green]" if n.get("Name") == "dokploy-network" else "",
+        ]
+        for n in networks
+    ]
+    out.table(
+        title=f"Docker Networks ({len(networks)})",
+        columns=[("Name", "bold"), ("Driver", ""), ("Scope", ""), ("Dokploy", "")],
+        rows=rows,
+        data_for_json=networks,
+    )
+
+    # Check dokploy-network
+    has_dokploy = any(n.get("Name") == "dokploy-network" for n in networks)
+    if not has_dokploy:
+        out.warn("dokploy-network not found. Create it: docker network create dokploy-network")
+
+
+# ---------------------------------------------------------------------------
+# volumes
+# ---------------------------------------------------------------------------
+@app.command()
+def volumes(ctx: typer.Context) -> None:
+    """List Docker volumes used by the project."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    result = subprocess.run(
+        ["docker", "volume", "ls", "--format", "json"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        out.error(f"docker volume ls failed: {result.stderr.strip()}")
+        raise typer.Exit(1)
+
+    import json
+
+    volume_list: list[dict] = []
+    for line in result.stdout.strip().splitlines():
+        if line.strip():
+            try:
+                volume_list.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+
+    rows = [[v.get("Name", ""), v.get("Driver", ""), v.get("Labels", "")] for v in volume_list]
+    out.table(
+        title=f"Docker Volumes ({len(volume_list)})",
+        columns=[("Name", "bold"), ("Driver", ""), ("Labels", "")],
+        rows=rows,
+        data_for_json=volume_list,
+    )
+
+
+# ---------------------------------------------------------------------------
+# system
+# ---------------------------------------------------------------------------
+@app.command()
+def system(ctx: typer.Context) -> None:
+    """Show Docker system disk usage and resource summary."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    result = subprocess.run(
+        ["docker", "system", "df"],
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        out.error(f"docker system df failed: {result.stderr.strip()}")
+        raise typer.Exit(1)
+
+    out.text(result.stdout)
+
+    # Also show info summary
+    info_result = subprocess.run(
+        [
+            "docker",
+            "info",
+            "--format",
+            "Containers: {{.Containers}} running / Images: {{.Images}} / Memory: {{.MemTotal}}",
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if info_result.returncode == 0:
+        out.text(info_result.stdout.strip())
+
+    if actx.json_mode:
+        out.raw_json({"output": result.stdout})