kctl-react 0.6.2__py3-none-any.whl

kctl_react/__init__.py

@@ -0,0 +1,3 @@
+"""kctl-react: Kodemeio React Monorepo CLI."""
+
+__version__ = "0.6.2"

kctl_react/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m kctl_react."""
+
+from kctl_react.cli import app
+
+app()

kctl_react/cli.py

@@ -0,0 +1,201 @@
+"""Main CLI entry point for kctl-react."""
+
+from __future__ import annotations
+
+
+from typing import Annotated
+
+import typer
+from kctl_lib import KctlError, handle_cli_error
+
+from kctl_react import __version__
+from kctl_react.commands.a11y import app as a11y_app
+from kctl_react.commands.affected import app as affected_app
+from kctl_react.commands.apps import app as apps_app
+from kctl_react.commands.build import app as build_app
+from kctl_react.commands.bundle_cmd import app as bundle_app
+from kctl_react.commands.cap import app as cap_app
+from kctl_react.commands.clean import app as clean_app
+from kctl_react.commands.compliance import app as compliance_app
+from kctl_react.commands.codegen import app as codegen_app
+from kctl_react.commands.config_cmd import app as config_app
+from kctl_react.commands.dashboard import app as dashboard_app
+from kctl_react.commands.deploy import app as deploy_app
+from kctl_react.commands.deps import app as deps_app
+from kctl_react.commands.dev import app as dev_app
+from kctl_react.commands.docker_cmd import app as docker_app
+from kctl_react.commands.doctor import app as doctor_app
+from kctl_react.commands.e2e import app as e2e_app
+from kctl_react.commands.env import app as env_app
+from kctl_react.commands.i18n import app as i18n_app
+from kctl_react.commands.lint import app as lint_app
+from kctl_react.commands.maintenance import app as maintenance_app
+from kctl_react.commands.monitor_cmd import app as monitor_app
+from kctl_react.commands.observe import app as observe_app
+from kctl_react.commands.packages import app as packages_app
+from kctl_react.commands.perf import app as perf_app
+from kctl_react.commands.pipeline import app as pipeline_app
+from kctl_react.commands.pwa import app as pwa_app
+from kctl_react.commands.scaffold import app as scaffold_app
+from kctl_react.commands.security import app as security_app
+from kctl_react.commands.skill_cmd import app as skill_app
+from kctl_react.commands.state import app as state_app
+from kctl_react.commands.test_cmd import app as test_app
+from kctl_react.commands.ui_audit import app as ui_audit_app
+from kctl_react.core.callbacks import AppContext
+from kctl_react.core.plugins import discover_and_load_plugins
+from kctl_lib.self_update import notify_if_outdated
+from kctl_lib.tui import add_tui_command
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kctl-react {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-react",
+    help="Kodemeio React Monorepo CLI — manage Vite PWAs + Next.js apps + shared packages.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Suppress info messages")] = False,
+    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile name")] = None,
+    root: Annotated[str | None, typer.Option("--root", help="Monorepo root override")] = None,
+    format: Annotated[str, typer.Option("--format", "-f", help="Output format: pretty, json, csv, yaml")] = "pretty",
+    no_header: Annotated[bool, typer.Option("--no-header", help="Omit header row in CSV output")] = False,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio React Monorepo CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output,
+        quiet=quiet,
+        profile=profile,
+        root_override=root,
+        format=format,
+        no_header=no_header,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-react", __version__)
+
+
+@app.command("info")
+def info_cmd(ctx: typer.Context) -> None:
+    """Show monorepo summary: apps, packages, and CLI version."""
+
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    out.info(f"kctl-react {__version__}")
+    out.info(f"Root: {root}")
+    apps = actx.apps
+    vite_apps = [n for n, info in apps.items() if info.get("framework") == "vite"]
+    next_apps = [n for n, info in apps.items() if info.get("framework") == "nextjs"]
+    out.info(f"Apps ({len(apps)}): {len(vite_apps)} Vite + {len(next_apps)} Next.js")
+    if vite_apps:
+        out.info(f"  Vite: {', '.join(vite_apps)}")
+    if next_apps:
+        out.info(f"  Next.js: {', '.join(next_apps)}")
+    packages = actx.packages
+    out.info(f"Packages ({len(packages)}): {', '.join(packages)}")
+
+
+# Register all command groups
+app.add_typer(affected_app, name="affected")
+app.add_typer(apps_app, name="apps")
+app.add_typer(build_app, name="build")
+app.add_typer(cap_app, name="cap")
+app.add_typer(clean_app, name="clean")
+app.add_typer(codegen_app, name="codegen")
+app.add_typer(compliance_app, name="compliance")
+app.add_typer(config_app, name="config")
+app.add_typer(dashboard_app, name="dashboard")
+app.add_typer(deploy_app, name="deploy")
+app.add_typer(deps_app, name="deps")
+app.add_typer(dev_app, name="dev")
+app.add_typer(doctor_app, name="doctor")
+app.add_typer(e2e_app, name="e2e")
+app.add_typer(env_app, name="env")
+app.add_typer(lint_app, name="lint")
+app.add_typer(packages_app, name="packages")
+app.add_typer(perf_app, name="perf")
+app.add_typer(pipeline_app, name="pipeline")
+app.add_typer(scaffold_app, name="scaffold")
+app.add_typer(security_app, name="security")
+app.add_typer(test_app, name="test")
+app.add_typer(pwa_app, name="pwa")
+app.add_typer(a11y_app, name="a11y")
+app.add_typer(i18n_app, name="i18n")
+app.add_typer(ui_audit_app, name="ui")
+app.add_typer(state_app, name="state")
+app.add_typer(bundle_app, name="bundle")
+app.add_typer(observe_app, name="observe")
+app.add_typer(docker_app, name="docker")
+app.add_typer(monitor_app, name="monitor")
+app.add_typer(maintenance_app, name="maintenance")
+app.add_typer(skill_app, name="skill")
+
+# Load third-party plugins via entry points
+discover_and_load_plugins(app)
+add_tui_command(app, service_key="react", version=__version__)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-react."""
+    actx = ctx.obj
+    out = actx.output
+
+    from kctl_lib.self_update import check_update
+    from kctl_lib.self_update import update as do_update
+
+    latest = check_update("kctl-react", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-react")
+        out.success(f"Updated to {latest}")
+    else:
+        out.success("Already up to date")
+
+
+@app.command()
+def completions(
+    shell: Annotated[str, typer.Argument(help="Shell type: zsh, bash, fish")] = "zsh",
+    install: Annotated[bool, typer.Option("--install", help="Install completions")] = False,
+) -> None:
+    """Generate or install shell completions."""
+    from kctl_lib.completions import get_completion_script, install_completions
+
+    if install:
+        path = install_completions("kctl-react", shell)
+        if path:
+            typer.echo(f"Completions installed to {path}")
+        else:
+            typer.echo(f"Could not install completions for {shell}", err=True)
+            raise typer.Exit(code=1)
+    else:
+        script = get_completion_script("kctl-react", shell)
+        typer.echo(script)
+
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_react/commands/a11y.py

@@ -0,0 +1,78 @@
+"""Accessibility auditing via axe-core."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_react.core.callbacks import AppContext
+from kctl_react.core.runner import run_quiet
+
+app = typer.Typer(help="Accessibility auditing (WCAG 2.1).")
+
+
+@app.command()
+def audit(
+    ctx: typer.Context,
+    app_name: Annotated[str, typer.Argument(help="App name")],
+    url: Annotated[str | None, typer.Option("--url", help="URL to audit")] = None,
+) -> None:
+    """Run axe-core accessibility audit."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    actx.validate_app(app_name)
+    target_url = url or f"http://localhost:{actx.apps[app_name].get('port', 5173)}"
+    # Use lighthouse for a11y if available
+    result = run_quiet(
+        [
+            "npx",
+            "lighthouse",
+            target_url,
+            "--only-categories=accessibility",
+            "--output=json",
+            "--chrome-flags=--headless --no-sandbox",
+        ],
+        cwd=actx.project_root,
+    )
+    if result.returncode != 0:
+        out.warn("Lighthouse not available. Install: npm i -g lighthouse")
+        out.info(f"Manual check: open {target_url} in Chrome DevTools → Lighthouse → Accessibility")
+        return
+    import json
+
+    try:
+        data = json.loads(result.stdout)
+        score = data.get("categories", {}).get("accessibility", {}).get("score", 0) * 100
+        audits = data.get("audits", {})
+        violations = [(k, v) for k, v in audits.items() if v.get("score") == 0 and v.get("details", {}).get("items")]
+        if out.json_mode:
+            out.raw_json({"score": score, "violations": len(violations), "url": target_url})
+            return
+        out.info(f"Accessibility score: {score:.0f}/100")
+        if violations:
+            rows = [
+                [v[0], v[1].get("title", ""), str(len(v[1].get("details", {}).get("items", [])))]
+                for v in violations[:20]
+            ]
+            out.table("Violations", [("ID", "red"), ("Title", ""), ("Elements", "dim")], rows)
+        else:
+            out.success("No accessibility violations found")
+    except (json.JSONDecodeError, KeyError):
+        out.error("Failed to parse Lighthouse output")
+
+
+@app.command()
+def report(ctx: typer.Context, app_name: Annotated[str, typer.Argument(help="App name")]) -> None:
+    """Full WCAG 2.1 AA compliance report."""
+    ctx.invoke(audit, app_name=app_name)
+
+
+@app.command()
+def violations(
+    ctx: typer.Context,
+    app_name: Annotated[str, typer.Argument(help="App name")],
+    severity: Annotated[str, typer.Option("--severity", help="Filter by severity")] = "all",
+) -> None:
+    """List accessibility violations filtered by severity."""
+    ctx.invoke(audit, app_name=app_name)

kctl_react/commands/affected.py

@@ -0,0 +1,170 @@
+"""Git-aware affected app detection."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_react.core.callbacks import AppContext
+from kctl_react.core.git import get_affected_apps, get_changed_files, get_uncommitted_files
+from kctl_react.core.runner import run_turbo
+
+app = typer.Typer(help="Git-aware change detection and targeted operations.")
+
+
+@app.callback(invoke_without_command=True)
+def affected(
+    ctx: typer.Context,
+    base: Annotated[str, typer.Option("--base", "-b", help="Base git ref to compare against.")] = "HEAD~1",
+) -> None:
+    """Show which apps are affected by recent changes.
+
+    Detects changes in apps/, packages/, and root config files.
+    Package changes propagate to all apps that depend on them.
+
+    Examples:
+      kctl-react affected                # Changes since last commit
+      kctl-react affected --base main    # Changes since main branch
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    apps = get_affected_apps(root, base)
+    changed = get_changed_files(root, base) + get_uncommitted_files(root)
+
+    if not apps:
+        out.info("No apps affected by current changes")
+        if out.json_mode:
+            out.raw_json({"affected": [], "changed_files": len(changed)})
+        return
+
+    # Categorize changes
+    app_changes: dict[str, list[str]] = {a: [] for a in apps}
+    pkg_changes: list[str] = []
+
+    for f in changed:
+        parts = f.split("/")
+        if len(parts) >= 3 and parts[0] == "apps" and parts[1] in ("spa", "web", "api") and parts[2] in apps:
+            app_changes[parts[2]].append(f)
+        elif len(parts) >= 2 and parts[0] == "apps" and parts[1] in apps:
+            app_changes[parts[1]].append(f)
+        elif parts[0] == "packages":
+            pkg_changes.append(f)
+
+    rows: list[list[str]] = []
+    json_data: list[dict] = []
+
+    for app_name in apps:
+        direct = len(app_changes.get(app_name, []))
+        reason = f"{direct} file(s)" if direct else "[dim]via package dep[/dim]"
+        rows.append([app_name, reason])
+        json_data.append({"app": app_name, "direct_changes": direct})
+
+    out.table(
+        f"Affected Apps (vs {base})",
+        [("App", "cyan"), ("Reason", "")],
+        rows,
+        data_for_json=json_data,
+    )
+
+    if pkg_changes:
+        out.info(f"{len(pkg_changes)} package file(s) changed")
+    out.success(f"{len(apps)} app(s) affected, {len(changed)} file(s) changed")
+
+
+@app.command()
+def test(
+    ctx: typer.Context,
+    base: Annotated[str, typer.Option("--base", "-b", help="Base git ref.")] = "HEAD~1",
+    coverage: Annotated[bool, typer.Option("--coverage", "-c", help="Run with coverage.")] = False,
+) -> None:
+    """Run tests only for affected apps."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    apps = get_affected_apps(root, base)
+    if not apps:
+        out.success("No apps affected — skipping tests")
+        return
+
+    out.info(f"Running tests for {len(apps)} affected app(s): {', '.join(apps)}")
+    task = "test:ci" if coverage else "test"
+    failed = 0
+
+    for app_name in apps:
+        try:
+            run_turbo(task, root, filter_app=app_name, capture=False, timeout=300)
+        except Exception:
+            failed += 1
+
+    if failed:
+        out.error(f"{failed}/{len(apps)} app(s) failed")
+        raise typer.Exit(1) from None
+    out.success(f"All {len(apps)} affected app(s) passed")
+
+
+@app.command()
+def build(
+    ctx: typer.Context,
+    base: Annotated[str, typer.Option("--base", "-b", help="Base git ref.")] = "HEAD~1",
+) -> None:
+    """Build only affected apps."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    apps = get_affected_apps(root, base)
+    if not apps:
+        out.success("No apps affected — skipping build")
+        return
+
+    out.info(f"Building {len(apps)} affected app(s): {', '.join(apps)}")
+    failed = 0
+
+    for app_name in apps:
+        try:
+            run_turbo("build", root, filter_app=app_name, capture=False, timeout=600)
+        except Exception:
+            failed += 1
+
+    if failed:
+        out.error(f"{failed}/{len(apps)} app(s) failed to build")
+        raise typer.Exit(1) from None
+    out.success(f"All {len(apps)} affected app(s) built")
+
+
+@app.command()
+def lint(
+    ctx: typer.Context,
+    base: Annotated[str, typer.Option("--base", "-b", help="Base git ref.")] = "HEAD~1",
+) -> None:
+    """Lint only affected apps."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    apps = get_affected_apps(root, base)
+    if not apps:
+        out.success("No apps affected — skipping lint")
+        return
+
+    out.info(f"Linting {len(apps)} affected app(s): {', '.join(apps)}")
+    failed = 0
+
+    for app_name in apps:
+        try:
+            run_turbo("lint", root, filter_app=app_name, capture=False, timeout=300)
+            run_turbo("type-check", root, filter_app=app_name, capture=False, timeout=300)
+        except Exception:
+            failed += 1
+
+    if failed:
+        out.error(f"{failed}/{len(apps)} app(s) have lint errors")
+        raise typer.Exit(1) from None
+    out.success(f"All {len(apps)} affected app(s) passed lint")