kctl-react 0.6.2__py3-none-any.whl

kctl_react/commands/pipeline.py

@@ -0,0 +1,289 @@
+"""CI/CD pipeline commands."""
+
+from __future__ import annotations
+
+import time
+from typing import Annotated
+
+import typer
+
+from kctl_react.core.callbacks import AppContext
+from kctl_react.core.exceptions import CommandError
+from kctl_react.core.runner import run
+
+app = typer.Typer(help="CI/CD pipeline gates, affected builds, and releases.")
+
+
+def _run_step(
+    name: str,
+    cmd: list[str],
+    cwd: object,
+    timeout: int = 300,
+) -> dict:
+    """Run a pipeline step and return result dict."""
+    start = time.monotonic()
+    try:
+        run(cmd, cwd=cwd, capture=True, timeout=timeout)
+        elapsed = round(time.monotonic() - start, 1)
+        return {"step": name, "status": "pass", "duration": elapsed, "exit_code": 0, "stderr": ""}
+    except CommandError as e:
+        elapsed = round(time.monotonic() - start, 1)
+        stderr = (e.stderr or "")[-2000:]
+        return {"step": name, "status": "fail", "duration": elapsed, "exit_code": e.returncode, "stderr": stderr}
+    except Exception as e:
+        elapsed = round(time.monotonic() - start, 1)
+        return {"step": name, "status": "fail", "duration": elapsed, "exit_code": -1, "stderr": str(e)[-2000:]}
+
+
+def _run_gate(
+    root: object,
+    app_name: str | None,
+    strict: bool,
+    skip_build: bool,
+) -> list[dict]:
+    """Execute gate pipeline steps and return results."""
+    from pathlib import Path
+
+    root_path = Path(str(root))
+    filter_args = ["--filter", f"@kodemeio/{app_name}"] if app_name else []
+
+    steps: list[tuple[str, list[str], int]] = [
+        ("lint", ["pnpm", "turbo", "run", "lint", *filter_args], 300),
+        ("type-check", ["pnpm", "turbo", "run", "type-check", *filter_args], 300),
+        ("test:ci", ["pnpm", "turbo", "run", "test:ci", *filter_args], 300),
+        ("audit", ["pnpm", "audit"], 120),
+    ]
+
+    if not skip_build:
+        steps.append(("build", ["pnpm", "turbo", "run", "build", *filter_args], 600))
+
+    if strict:
+        # Also run secrets scan (reuse security helpers)
+        steps.append(("secrets", ["echo", "secrets-check"], 10))  # placeholder, handled below
+
+    results: list[dict] = []
+    for step_name, cmd, timeout in steps:
+        if step_name == "secrets":
+            # Run secrets check via internal helper
+            from kctl_react.commands.security import _collect_secrets
+
+            findings = _collect_secrets(root_path, app_name, [], root_path / "packages")
+            # If app_name not specified, scan all apps
+            if not app_name:
+                from kctl_react.core.discovery import discover_apps
+
+                all_apps = list(discover_apps(root_path).keys())
+                findings = _collect_secrets(root_path, None, all_apps, root_path / "packages")
+            result = {
+                "step": "secrets",
+                "status": "pass" if len(findings) == 0 else "fail",
+                "duration": 0.0,
+                "exit_code": 0 if len(findings) == 0 else 1,
+                "stderr": f"{len(findings)} secret(s) found" if findings else "",
+            }
+            results.append(result)
+        else:
+            results.append(_run_step(step_name, cmd, root_path, timeout))
+
+    return results
+
+
+@app.command()
+def gate(
+    ctx: typer.Context,
+    app_name: Annotated[str | None, typer.Argument(help="App name (omit for all)")] = None,
+    strict: Annotated[bool, typer.Option("--strict", help="Also run secrets + headers checks")] = False,
+    skip_build: Annotated[bool, typer.Option("--skip-build", help="Skip the build step")] = False,
+) -> None:
+    """Run full CI gate: lint → type-check → test → audit → build."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    if app_name:
+        actx.validate_app(app_name)
+
+    target = app_name or "all apps"
+    out.info(f"Running pipeline gate for {target}...")
+
+    results = _run_gate(root, app_name, strict, skip_build)
+
+    # Display results
+    rows: list[list[str]] = []
+    for r in results:
+        status = "[green]PASS[/green]" if r["status"] == "pass" else "[red]FAIL[/red]"
+        rows.append([r["step"], status, f"{r['duration']}s", str(r["exit_code"])])
+
+    out.table(
+        f"Pipeline Gate — {target}",
+        [("Step", "cyan"), ("Status", ""), ("Duration", "green"), ("Exit", "dim")],
+        rows,
+        data_for_json=results,
+    )
+
+    passed = sum(1 for r in results if r["status"] == "pass")
+    failed = sum(1 for r in results if r["status"] == "fail")
+
+    if failed == 0:
+        out.success(f"All {passed} steps passed")
+    else:
+        out.error(f"{failed}/{len(results)} step(s) failed")
+        # Show stderr for failed steps
+        for r in results:
+            if r["status"] == "fail" and r["stderr"]:
+                out.text(f"\n[red]{r['step']}[/red] stderr:\n{r['stderr'][:500]}")
+        raise typer.Exit(1) from None
+
+
+@app.command("affected-gate")
+def affected_gate(
+    ctx: typer.Context,
+    base: Annotated[str, typer.Option("--base", help="Git base ref for diff")] = "main",
+    strict: Annotated[bool, typer.Option("--strict", help="Also run secrets checks")] = False,
+) -> None:
+    """Run gate only for apps affected by git changes."""
+    from kctl_react.core.git import get_affected_apps
+
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    out.info(f"Detecting affected apps (vs {base})...")
+    affected = get_affected_apps(root, base)
+
+    if not affected:
+        out.success("No apps affected — nothing to check")
+        if out.json_mode:
+            out.raw_json({"affected": [], "results": {}})
+        return
+
+    out.info(f"Affected apps: {', '.join(affected)}")
+
+    all_results: dict[str, list[dict]] = {}
+    any_failed = False
+
+    for app_name in affected:
+        out.header(app_name)
+        results = _run_gate(root, app_name, strict, skip_build=False)
+        all_results[app_name] = results
+
+        for r in results:
+            if r["status"] == "fail":
+                any_failed = True
+
+    # Summary
+    rows: list[list[str]] = []
+    json_data: list[dict] = []
+
+    for app_name, results in all_results.items():
+        passed = sum(1 for r in results if r["status"] == "pass")
+        total = len(results)
+        status = "[green]PASS[/green]" if passed == total else "[red]FAIL[/red]"
+        duration = sum(r["duration"] for r in results)
+        rows.append([app_name, f"{passed}/{total}", f"{duration:.1f}s", status])
+        json_data.append({"app": app_name, "passed": passed, "total": total, "duration": duration, "steps": results})
+
+    out.table(
+        f"Affected Gate Summary (vs {base})",
+        [("App", "cyan"), ("Steps", "green"), ("Duration", ""), ("Status", "")],
+        rows,
+        data_for_json=json_data,
+    )
+
+    if any_failed:
+        out.error("Some apps have failing steps")
+        raise typer.Exit(1)
+    else:
+        out.success(f"All {len(affected)} affected app(s) passed")
+
+
+@app.command()
+def release(
+    ctx: typer.Context,
+    app_name: Annotated[str, typer.Argument(help="App name")],
+    tag: Annotated[str | None, typer.Option("--tag", "-t", help="Image tag (default: git short SHA)")] = None,
+    push: Annotated[bool, typer.Option("--push", help="Push image to GHCR")] = False,
+) -> None:
+    """Build Docker image for an app and optionally push to GHCR."""
+    from kctl_react.core.git import get_last_commit_hash
+
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    actx.validate_app(app_name)
+
+    # Determine tag
+    image_tag = tag or get_last_commit_hash(root) or "latest"
+    image_name = f"ghcr.io/kodemeio/kodemeio-react/{app_name}:{image_tag}"
+
+    out.info(f"Building Docker image: {image_name}")
+
+    # Build
+    try:
+        run(
+            [
+                "docker",
+                "build",
+                "--build-arg",
+                f"APP_NAME={app_name}",
+                "-t",
+                image_name,
+                ".",
+            ],
+            cwd=root,
+            capture=True,
+            timeout=600,
+        )
+    except CommandError as e:
+        out.error(f"Docker build failed: {e.stderr[:500] if e.stderr else e}")
+        raise typer.Exit(1) from None
+
+    # Get image size
+    image_size = "unknown"
+    try:
+        inspect = run(
+            ["docker", "image", "inspect", image_name, "--format", "{{.Size}}"],
+            cwd=root,
+            capture=True,
+            timeout=10,
+        )
+        size_bytes = int(inspect.stdout.strip())
+        from kctl_react.commands.build import _format_size
+
+        image_size = _format_size(size_bytes)
+    except Exception:
+        pass
+
+    release_info = {
+        "app": app_name,
+        "image": image_name,
+        "tag": image_tag,
+        "size": image_size,
+        "pushed": False,
+    }
+
+    # Push if requested
+    if push:
+        out.info(f"Pushing {image_name}...")
+        try:
+            run(["docker", "push", image_name], cwd=root, capture=True, timeout=300)
+            release_info["pushed"] = True
+            out.success(f"Pushed {image_name}")
+        except CommandError as e:
+            out.error(f"Push failed: {e.stderr[:300] if e.stderr else e}")
+            raise typer.Exit(1) from None
+
+    out.table(
+        f"Release — {app_name}",
+        [("Field", "cyan"), ("Value", "")],
+        [
+            ["Image", image_name],
+            ["Tag", image_tag],
+            ["Size", image_size],
+            ["Pushed", "yes" if release_info["pushed"] else "no"],
+        ],
+        data_for_json=[release_info],
+    )
+
+    out.success(f"Release complete: {image_name}")

kctl_react/commands/pwa.py

@@ -0,0 +1,193 @@
+"""PWA and Service Worker management."""
+
+from __future__ import annotations
+
+import json
+from typing import Annotated
+
+import typer
+
+from kctl_react.core.callbacks import AppContext
+from kctl_react.core.discovery import get_app_dir
+
+app = typer.Typer(help="PWA and Service Worker management (Vite apps).")
+
+
+def _require_vite(actx: AppContext, app_name: str) -> None:
+    """Exit with a warning if the app is not a Vite PWA."""
+    if actx.is_nextjs(app_name):
+        actx.output.warn(
+            f"{app_name} is a Next.js app. PWA commands are for Vite apps only. "
+            "Use next-pwa or @ducanh2912/next-pwa directly for Next.js PWA management."
+        )
+        raise typer.Exit(0)
+
+
+@app.command()
+def status(ctx: typer.Context, app_name: Annotated[str, typer.Argument(help="App name")]) -> None:
+    """Show PWA status — service worker version, precache count, manifest."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    actx.validate_app(app_name)
+    _require_vite(actx, app_name)
+    root = actx.project_root
+    dist = get_app_dir(root, app_name) / "dist"
+    sw = dist / "sw.js"
+    manifest = dist / "manifest.webmanifest"
+    data = {"app": app_name, "sw_exists": sw.exists(), "manifest_exists": manifest.exists()}
+    if sw.exists():
+        content = sw.read_text(errors="ignore")
+        data["sw_size"] = sw.stat().st_size
+        data["precache_count"] = content.count("url:")
+    if manifest.exists():
+        try:
+            m = json.loads(manifest.read_text())
+            data["name"] = m.get("name", "")
+            data["start_url"] = m.get("start_url", "")
+            data["display"] = m.get("display", "")
+            data["icons"] = len(m.get("icons", []))
+        except json.JSONDecodeError:
+            data["manifest_error"] = "Invalid JSON"
+    if out.json_mode:
+        out.raw_json(data)
+        return
+    sections = [("PWA Status", [(k, str(v)) for k, v in data.items()])]
+    out.detail(f"PWA — {app_name}", sections, data_for_json=data)
+
+
+@app.command("cache-list")
+def cache_list(ctx: typer.Context, app_name: Annotated[str, typer.Argument(help="App name")]) -> None:
+    """List precached URLs from service worker manifest."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    actx.validate_app(app_name)
+    _require_vite(actx, app_name)
+    dist = actx.get_app_dir(app_name) / "dist"
+    sw = dist / "sw.js"
+    if not sw.exists():
+        out.warn(f"No built service worker at {sw}")
+        return
+    content = sw.read_text(errors="ignore")
+    # Parse workbox precache manifest entries
+    import re
+
+    urls = re.findall(r'"url"\s*:\s*"([^"]+)"', content)
+    rows = [[url, "precache"] for url in urls]
+    out.table(
+        f"Cached URLs — {app_name}",
+        [("URL", "cyan"), ("Strategy", "dim")],
+        rows,
+        data_for_json=[{"url": u, "strategy": "precache"} for u in urls],
+    )
+
+
+@app.command("cache-clear")
+def cache_clear(ctx: typer.Context, app_name: Annotated[str, typer.Argument(help="App name")]) -> None:
+    """Clear built service worker files."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    actx.validate_app(app_name)
+    _require_vite(actx, app_name)
+    dist = actx.get_app_dir(app_name) / "dist"
+    cleared = 0
+    for f in [dist / "sw.js", dist / "sw.js.map", dist / "workbox-*.js"]:
+        if f.exists():
+            f.unlink()
+            cleared += 1
+    # Also glob workbox files
+    for f in dist.glob("workbox-*.js"):
+        f.unlink()
+        cleared += 1
+    out.success(f"Cleared {cleared} service worker file(s)")
+
+
+@app.command("manifest-validate")
+def manifest_validate(ctx: typer.Context, app_name: Annotated[str, typer.Argument(help="App name")]) -> None:
+    """Validate web app manifest against PWA requirements."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    actx.validate_app(app_name)
+    dist = actx.get_app_dir(app_name) / "dist"
+    manifest_file = dist / "manifest.webmanifest"
+    if not manifest_file.exists():
+        # Check public/ too
+        manifest_file = actx.get_app_dir(app_name) / "public" / "manifest.webmanifest"
+    if not manifest_file.exists():
+        out.error("No manifest.webmanifest found in dist/ or public/")
+        raise typer.Exit(1) from None
+    m = json.loads(manifest_file.read_text())
+    issues = []
+    required = ["name", "short_name", "start_url", "display", "icons"]
+    for key in required:
+        if key not in m:
+            issues.append(f"Missing required field: {key}")
+    if "icons" in m:
+        sizes = [icon.get("sizes", "") for icon in m["icons"]]
+        if "192x192" not in sizes:
+            issues.append("Missing 192x192 icon")
+        if "512x512" not in sizes:
+            issues.append("Missing 512x512 icon")
+    if m.get("display") not in ("standalone", "fullscreen", "minimal-ui"):
+        issues.append(f"display should be standalone/fullscreen/minimal-ui, got: {m.get('display')}")
+    if issues:
+        out.error(f"{len(issues)} issue(s) found:")
+        for issue in issues:
+            out.text(f"  - {issue}")
+        raise typer.Exit(1)
+    out.success("Manifest is valid")
+
+
+@app.command("offline-report")
+def offline_report(ctx: typer.Context, app_name: Annotated[str, typer.Argument(help="App name")]) -> None:
+    """Analyze offline support coverage."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    actx.validate_app(app_name)
+    _require_vite(actx, app_name)
+    # Count total routes vs precached routes
+    app_dir = actx.get_app_dir(app_name) / "src" / "pages"
+    total_pages = len(list(app_dir.glob("**/*.tsx"))) if app_dir.exists() else 0
+    dist = actx.get_app_dir(app_name) / "dist"
+    sw = dist / "sw.js"
+    precached = 0
+    if sw.exists():
+        import re
+
+        precached = len(re.findall(r'"url"\s*:\s*"([^"]+)"', sw.read_text(errors="ignore")))
+    out.table(
+        "Offline Coverage",
+        [("Metric", "cyan"), ("Value", "")],
+        [["Total pages", str(total_pages)], ["Precached assets", str(precached)]],
+        data_for_json=[
+            {"metric": "total_pages", "value": total_pages},
+            {"metric": "precached_assets", "value": precached},
+        ],
+    )
+
+
+@app.command("sw-info")
+def sw_info(ctx: typer.Context, app_name: Annotated[str, typer.Argument(help="App name")]) -> None:
+    """Show vite-plugin-pwa configuration."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    actx.validate_app(app_name)
+    _require_vite(actx, app_name)
+    vite_config = actx.get_app_dir(app_name) / "vite.config.ts"
+    if not vite_config.exists():
+        out.error("No vite.config.ts found")
+        raise typer.Exit(1)
+    content = vite_config.read_text()
+    import re
+
+    register_type = re.search(r"registerType\s*:\s*['\"](\w+)['\"]", content)
+    strategies = re.findall(r"(CacheFirst|NetworkFirst|StaleWhileRevalidate|NetworkOnly|CacheOnly)", content)
+    data = {
+        "register_type": register_type.group(1) if register_type else "unknown",
+        "runtime_caching_strategies": list(set(strategies)),
+        "has_workbox_config": "workbox" in content.lower(),
+    }
+    if out.json_mode:
+        out.raw_json(data)
+        return
+    sections = [("PWA Config", [(k, str(v)) for k, v in data.items()])]
+    out.detail(f"Service Worker Config — {app_name}", sections)