kctl-react 0.6.2__py3-none-any.whl

kctl_react/commands/lint.py

@@ -0,0 +1,306 @@
+"""Lint and type-check commands."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from kctl_react.core.analyzers import read_tsconfig_strict
+from kctl_react.core.callbacks import AppContext
+from kctl_react.core.discovery import get_app_dir
+from kctl_react.core.exceptions import CommandError
+from kctl_react.core.runner import run, run_turbo
+
+app = typer.Typer(help="Lint, type-check, and format code.")
+
+_SUBCOMMANDS = {"format", "strict-check", "tsconfig-audit", "conventions"}
+
+
+# ---------------------------------------------------------------------------
+# Core logic functions (shared by callback dispatch and @app.command stubs)
+# ---------------------------------------------------------------------------
+
+
+def _run_strict_check(actx: AppContext) -> None:
+    """Check that every app has strict: true in its tsconfig.json."""
+    out = actx.output
+    root = actx.project_root
+
+    rows: list[list[str]] = []
+    json_data: list[dict[str, str]] = []
+    any_not_strict = False
+
+    for app_name in actx.app_names:
+        app_dir = get_app_dir(root, app_name)
+        is_strict = read_tsconfig_strict(app_dir)
+        status = "strict" if is_strict else "[red]NOT strict[/red]"
+        rows.append([app_name, status])
+        json_data.append({"app": app_name, "strict": str(is_strict).lower()})
+        if not is_strict:
+            any_not_strict = True
+
+    out.table(
+        "TypeScript Strict Mode",
+        [("App", "cyan"), ("Status", "green")],
+        rows,
+        data_for_json=json_data,
+    )
+
+    if any_not_strict:
+        out.error("Some apps are missing strict: true in tsconfig.json")
+        raise typer.Exit(1) from None
+
+    out.success("All apps have strict: true")
+
+
+def _run_tsconfig_audit(actx: AppContext) -> None:
+    """Audit tsconfig.json settings for strict and jsx across all apps."""
+    out = actx.output
+    root = actx.project_root
+
+    rows: list[list[str]] = []
+    json_data: list[dict[str, str]] = []
+    any_issues = False
+
+    for app_name in actx.app_names:
+        app_dir = get_app_dir(root, app_name)
+        tsconfig_path = app_dir / "tsconfig.json"
+
+        if not tsconfig_path.exists():
+            rows.append([app_name, "[red]MISSING[/red]", "tsconfig.json not found"])
+            json_data.append({"app": app_name, "status": "MISSING", "issues": "tsconfig.json not found"})
+            any_issues = True
+            continue
+
+        try:
+            text = tsconfig_path.read_text()
+            # Strip single-line // comments (tsconfig allows them)
+            text = re.sub(r"//.*", "", text)
+            data = json.loads(text)
+        except (json.JSONDecodeError, OSError) as exc:
+            rows.append([app_name, "[red]INVALID[/red]", f"Parse error: {exc}"])
+            json_data.append({"app": app_name, "status": "INVALID", "issues": f"Parse error: {exc}"})
+            any_issues = True
+            continue
+
+        compiler_opts = data.get("compilerOptions", {})
+        issues: list[str] = []
+
+        if not compiler_opts.get("strict", False):
+            issues.append("strict: true missing")
+        if compiler_opts.get("jsx") != "react-jsx":
+            issues.append(f'jsx: expected "react-jsx", got {compiler_opts.get("jsx")!r}')
+
+        if issues:
+            issues_str = "; ".join(issues)
+            rows.append([app_name, "[yellow]ISSUES[/yellow]", issues_str])
+            json_data.append({"app": app_name, "status": "ISSUES", "issues": issues_str})
+            any_issues = True
+        else:
+            rows.append([app_name, "[green]OK[/green]", ""])
+            json_data.append({"app": app_name, "status": "OK", "issues": ""})
+
+    out.table(
+        "tsconfig.json Audit",
+        [("App", "cyan"), ("Status", "green"), ("Issues", "yellow")],
+        rows,
+        data_for_json=json_data,
+    )
+
+    if any_issues:
+        out.error("Some apps have tsconfig.json issues")
+        raise typer.Exit(1) from None
+
+    out.success("All apps have consistent tsconfig.json settings")
+
+
+def _run_conventions(actx: AppContext, app_name: str) -> None:
+    """Check a single app for convention violations."""
+    out = actx.output
+    root = actx.project_root
+
+    actx.validate_app(app_name)
+
+    src_dir = get_app_dir(root, app_name) / "src"
+
+    rows: list[list[str]] = []
+    json_data: list[dict[str, str]] = []
+
+    _SKIP_DIRS = {"generated", "node_modules"}
+
+    def _iter_ts_files(base: Path) -> list[Path]:
+        files: list[Path] = []
+        for p in base.rglob("*.ts"):
+            if not any(part in _SKIP_DIRS for part in p.parts):
+                files.append(p)
+        for p in base.rglob("*.tsx"):
+            if not any(part in _SKIP_DIRS for part in p.parts):
+                files.append(p)
+        return files
+
+    if src_dir.is_dir():
+        for file_path in _iter_ts_files(src_dir):
+            try:
+                lines = file_path.read_text().splitlines()
+            except OSError:
+                continue
+            rel = str(file_path.relative_to(get_app_dir(root, app_name)))
+            for line_num, line in enumerate(lines, start=1):
+                if '"use client"' in line or "'use client'" in line:
+                    rows.append([rel, str(line_num), "use client directive", line.strip()])
+                    json_data.append(
+                        {"file": rel, "line": str(line_num), "issue": "use client directive", "code": line.strip()}
+                    )
+                if re.search(r'from\s+["\'](\.\./){2,}', line):
+                    rows.append([rel, str(line_num), "deep relative import", line.strip()])
+                    json_data.append(
+                        {"file": rel, "line": str(line_num), "issue": "deep relative import", "code": line.strip()}
+                    )
+
+    if rows:
+        out.table(
+            f"Convention Issues: {app_name}",
+            [("File", "cyan"), ("Line", "yellow"), ("Issue", "red"), ("Code", "dim")],
+            rows,
+            data_for_json=json_data,
+        )
+        out.error(f"{len(rows)} convention issue(s) found in {app_name}")
+        raise typer.Exit(1) from None
+
+    out.success(f"No convention issues found in {app_name}")
+
+
+# ---------------------------------------------------------------------------
+# Typer commands
+# ---------------------------------------------------------------------------
+
+
+@app.callback(invoke_without_command=True)
+def lint(
+    ctx: typer.Context,
+    app_name: Annotated[str | None, typer.Option("--app", "-a", help="App name to lint (omit for all apps)")] = None,
+    fix: Annotated[bool, typer.Option("--fix", "-f", help="Auto-fix issues.")] = False,
+) -> None:
+    """Run ESLint + TypeScript type-check.
+
+    Examples:
+      kctl-react lint              # Lint all apps
+      kctl-react lint --app sfa   # Lint SFA only
+      kctl-react lint --app sfa --fix
+      kctl-react lint strict-check
+      kctl-react lint tsconfig-audit
+      kctl-react lint conventions sfa
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    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"
+    failed = False
+
+    # ESLint
+    out.info(f"Running ESLint on {target}...")
+    try:
+        run_turbo("lint", root, filter_app=app_name, capture=False, timeout=300)
+        out.success("ESLint passed")
+    except CommandError:
+        out.error("ESLint failed")
+        failed = True
+    except Exception as e:
+        out.error(f"ESLint error: {e}")
+        failed = True
+
+    # TypeScript type-check
+    out.info(f"Running type-check on {target}...")
+    try:
+        run_turbo("type-check", root, filter_app=app_name, capture=False, timeout=300)
+        out.success("Type-check passed")
+    except CommandError:
+        out.error("Type-check failed")
+        failed = True
+    except Exception as e:
+        out.error(f"Type-check error: {e}")
+        failed = True
+
+    if failed:
+        raise typer.Exit(1) from None
+
+    out.success(f"All quality checks passed: {target}")
+
+
+@app.command()
+def format(
+    ctx: typer.Context,
+    check: Annotated[bool, typer.Option("--check", help="Check only, don't fix.")] = False,
+) -> None:
+    """Run Prettier on the codebase."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    if check:
+        out.info("Checking formatting...")
+        cmd = ["pnpm", "format-check"]
+    else:
+        out.info("Formatting code...")
+        cmd = ["pnpm", "format"]
+
+    try:
+        run(cmd, cwd=root, capture=False, timeout=120)
+        out.success("Formatting OK")
+    except CommandError:
+        out.error("Formatting issues found")
+        raise typer.Exit(1) from None
+
+
+@app.command("strict-check")
+def strict_check(ctx: typer.Context) -> None:
+    """Verify all apps have TypeScript strict mode enabled.
+
+    Examples:
+      kctl-react lint strict-check
+      kctl-react --json lint strict-check
+    """
+    actx: AppContext = ctx.obj
+    _run_strict_check(actx)
+
+
+@app.command("tsconfig-audit")
+def tsconfig_audit(ctx: typer.Context) -> None:
+    """Audit tsconfig.json settings for consistency across all apps.
+
+    Checks that each app has strict: true and jsx: react-jsx.
+
+    Examples:
+      kctl-react lint tsconfig-audit
+    """
+    actx: AppContext = ctx.obj
+    _run_tsconfig_audit(actx)
+
+
+@app.command()
+def conventions(
+    ctx: typer.Context,
+    app_name: Annotated[str, typer.Argument(help="App name to check")],
+) -> None:
+    """Check project conventions for an app.
+
+    Scans .ts/.tsx files for anti-patterns:
+      - 'use client' directive (Next.js pattern, wrong for Vite)
+      - Deep relative imports (../../) — should use @/ alias
+
+    Examples:
+      kctl-react lint conventions sfa
+    """
+    actx: AppContext = ctx.obj
+    _run_conventions(actx, app_name)

kctl_react/commands/maintenance.py

@@ -0,0 +1,308 @@
+"""Maintenance commands: health-report, cleanup, dr-status, count-test-files, deps-sync."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+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="Maintenance utilities for the React monorepo.")
+
+# Artifact directories to clean up
+_CLEANUP_TARGETS = [
+    "dist",
+    ".turbo",
+    "coverage",
+    Path("node_modules") / ".cache",
+    Path("node_modules") / ".vite",
+]
+
+
+def _count_test_files(app_dir: Path) -> int:
+    """Count .test.ts and .test.tsx files under <app_dir>/src."""
+    src = app_dir / "src"
+    if not src.is_dir():
+        return 0
+    return len(list(src.rglob("*.test.ts")) + list(src.rglob("*.test.tsx")))
+
+
+def _collect_dep_versions(
+    root: Path,
+    app_names: list[str],
+    package_names: list[str],
+) -> dict[str, dict[str, str]]:
+    """Collect dependency versions from apps and packages.
+
+    Returns: {dep_name: {source_name: version, ...}, ...}
+    """
+    versions: dict[str, dict[str, str]] = {}
+
+    sources: list[tuple[str, Path]] = []
+    for name in app_names:
+        sources.append((name, get_app_dir(root, name) / "package.json"))
+    for name in package_names:
+        sources.append((name, root / "packages" / name / "package.json"))
+
+    for source_name, pkg_file in sources:
+        if not pkg_file.exists():
+            continue
+        try:
+            pkg = json.loads(pkg_file.read_text())
+        except Exception:
+            continue
+        all_deps: dict[str, str] = {}
+        all_deps.update(pkg.get("dependencies", {}))
+        all_deps.update(pkg.get("devDependencies", {}))
+        for dep, ver in all_deps.items():
+            if dep not in versions:
+                versions[dep] = {}
+            versions[dep][source_name] = ver
+
+    return versions
+
+
+@app.command("health-report")
+def health_report(ctx: typer.Context) -> None:
+    """Show per-app health: test file count, codegen status, and dist presence."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    rows: list[list[str]] = []
+    json_data: list[dict] = []
+
+    for name in actx.app_names:
+        app_dir = get_app_dir(root, name)
+        tests = _count_test_files(app_dir)
+        codegen = (app_dir / "src" / "generated").is_dir()
+        built = (app_dir / "dist").is_dir()
+        has_env = (app_dir / ".env").exists()
+
+        codegen_str = "[green]yes[/green]" if codegen else "[red]no[/red]"
+        built_str = "[green]yes[/green]" if built else "[dim]no[/dim]"
+        env_str = "[green]yes[/green]" if has_env else "[dim]no[/dim]"
+
+        rows.append([name, str(tests), codegen_str, built_str, env_str])
+        json_data.append(
+            {
+                "app": name,
+                "tests": tests,
+                "codegen": codegen,
+                "built": built,
+                "env": has_env,
+            }
+        )
+
+    out.table(
+        "Monorepo Health Report",
+        [
+            ("App", "cyan"),
+            ("Tests", "green"),
+            ("Codegen", ""),
+            ("Built", ""),
+            (".env", ""),
+        ],
+        rows,
+        data_for_json=json_data,
+    )
+
+
+@app.command("cleanup")
+def cleanup(
+    ctx: typer.Context,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Show what would be removed without deleting")] = False,
+) -> None:
+    """Remove build artifacts (dist/, .turbo/, coverage/, node_modules/.cache)."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    found: list[dict] = []
+
+    # Check apps
+    for name in actx.app_names:
+        app_dir = get_app_dir(root, name)
+        for target in _CLEANUP_TARGETS:
+            path = app_dir / target
+            if path.exists():
+                found.append({"path": str(path.relative_to(root)), "app": name, "target": str(target)})
+
+    # Check root
+    for target in _CLEANUP_TARGETS:
+        path = root / target
+        if path.exists():
+            found.append({"path": str(path.relative_to(root)), "app": "root", "target": str(target)})
+
+    if not found:
+        out.success("Nothing to clean — workspace is already tidy")
+        if out.json_mode:
+            out.raw_json([])
+        return
+
+    if out.json_mode:
+        out.raw_json(found)
+        return
+
+    label = "[dim](dry-run)[/dim]" if dry_run else ""
+    out.info(f"Cleaning build artifacts {label}...")
+
+    for item in found:
+        path = root / item["path"]
+        if dry_run:
+            out.info(f"  Would remove: {item['path']}")
+        else:
+            try:
+                if path.is_dir():
+                    shutil.rmtree(path)
+                else:
+                    path.unlink()
+                out.info(f"  Removed: {item['path']}")
+            except Exception as e:
+                out.warn(f"  Could not remove {item['path']}: {e}")
+
+    if dry_run:
+        out.info(f"Dry-run complete — {len(found)} item(s) would be removed")
+    else:
+        out.success(f"Cleaned {len(found)} artifact(s)")
+
+
+@app.command("dr-status")
+def dr_status(ctx: typer.Context) -> None:
+    """Check deployment readiness: Dockerfile, docker-compose, and .env files."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    rows: list[list[str]] = []
+    json_data: list[dict] = []
+
+    for name in actx.app_names:
+        app_dir = get_app_dir(root, name)
+
+        dockerfile = (app_dir / "Dockerfile").exists()
+        compose = (app_dir / "docker-compose.yml").exists() or (app_dir / "docker-compose.yaml").exists()
+        env_file = (app_dir / ".env").exists()
+        env_example = (app_dir / ".env.example").exists()
+
+        # Ready when at least Dockerfile is present
+        is_ready = dockerfile
+        status = "[green]ready[/green]" if is_ready else "[yellow]not ready[/yellow]"
+
+        def _icon(v: bool) -> str:
+            return "[green]yes[/green]" if v else "[dim]no[/dim]"
+
+        rows.append([name, _icon(dockerfile), _icon(compose), _icon(env_file), _icon(env_example), status])
+        json_data.append(
+            {
+                "app": name,
+                "build": dockerfile,
+                "docker": compose,
+                "env": env_file,
+                "env_example": env_example,
+                "ready": is_ready,
+            }
+        )
+
+    out.table(
+        "Deployment Readiness Status",
+        [
+            ("App", "cyan"),
+            ("Dockerfile", ""),
+            ("Compose", ""),
+            (".env", ""),
+            (".env.example", ""),
+            ("Status", ""),
+        ],
+        rows,
+        data_for_json=json_data,
+    )
+
+
+@app.command("count-test-files")
+def count_test_files_cmd(ctx: typer.Context) -> None:
+    """Count test files (.test.ts / .test.tsx) per app."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    rows: list[list[str]] = []
+    json_data: list[dict] = []
+    total = 0
+
+    for name in actx.app_names:
+        app_dir = get_app_dir(root, name)
+        count = _count_test_files(app_dir)
+        total += count
+        rows.append([name, str(count)])
+        json_data.append({"app": name, "test_files": count})
+
+    rows.append(["[bold]TOTAL[/bold]", f"[bold]{total}[/bold]"])
+
+    out.table(
+        "Test File Count",
+        [("App", "cyan"), ("Test Files", "green")],
+        rows,
+        data_for_json=json_data,
+    )
+
+
+@app.command("deps-sync")
+def deps_sync(
+    ctx: typer.Context,
+    exclude: Annotated[str | None, typer.Option("--exclude", help="Comma-separated dep names to ignore")] = None,
+) -> None:
+    """Check dependency version consistency across all apps and packages."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    root = actx.project_root
+
+    excluded = {e.strip() for e in exclude.split(",")} if exclude else set()
+
+    # Collect all package names from packages/
+    package_names: list[str] = []
+    packages_dir = root / "packages"
+    if packages_dir.is_dir():
+        for p in sorted(packages_dir.iterdir()):
+            if (p / "package.json").exists():
+                package_names.append(p.name)
+
+    all_versions = _collect_dep_versions(root, actx.app_names, package_names)
+
+    # Find inconsistencies: same dep, multiple different versions
+    inconsistent: list[dict] = []
+    for dep, sources in sorted(all_versions.items()):
+        if dep in excluded:
+            continue
+        unique_versions = set(sources.values())
+        if len(unique_versions) > 1:
+            inconsistent.append({"package": dep, "versions": sources})
+
+    if not inconsistent:
+        out.success("All shared dependencies are in sync")
+        if out.json_mode:
+            out.raw_json([])
+        return
+
+    if out.json_mode:
+        out.raw_json(inconsistent)
+        return
+
+    out.warn(f"Found {len(inconsistent)} inconsistent dependency(s):")
+    rows: list[list[str]] = []
+    for item in inconsistent:
+        for source, ver in item["versions"].items():
+            rows.append([item["package"], source, ver])
+
+    out.table(
+        "Inconsistent Dependencies",
+        [("Package", "cyan"), ("App/Package", "dim"), ("Version", "yellow")],
+        rows,
+        data_for_json=inconsistent,
+    )
+    out.warn("Run `pnpm update <package>` to align versions")

kctl_react/commands/monitor_cmd.py

@@ -0,0 +1,50 @@
+"""Production monitoring."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from kctl_lib.monitor_base import health_check_url, ssl_check
+
+from kctl_react.core.callbacks import AppContext
+
+app = typer.Typer(help="Production monitoring.")
+
+
+@app.command()
+def health(
+    ctx: typer.Context,
+    app_name: Annotated[str, typer.Argument(help="App name")],
+    url: Annotated[str | None, typer.Option("--url")] = None,
+) -> None:
+    """HTTP health check against deployed app."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    actx.validate_app(app_name)
+    target = url or f"https://{app_name}.kodeme.io"
+    result = health_check_url(target)
+    if out.json_mode:
+        out.raw_json(result)
+        return
+    if result["healthy"]:
+        out.success(f"{target} — {result['status_code']} ({result['latency_ms']}ms)")
+    else:
+        out.error(f"{target} — {result.get('error', result.get('status_code', 'unknown'))}")
+
+
+@app.command("ssl")
+def ssl_cmd(ctx: typer.Context, domain: Annotated[str, typer.Argument(help="Domain to check")]) -> None:
+    """Check SSL certificate."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    result = ssl_check(domain)
+    if out.json_mode:
+        out.raw_json(result)
+        return
+    if result.get("valid"):
+        out.success(
+            f"{domain} — SSL valid, expires in {result.get('days_remaining', '?')} days ({result.get('issuer', '')})"
+        )
+    else:
+        out.error(f"{domain} — SSL check failed: {result.get('error', 'unknown')}")

kctl_react/commands/observe.py

@@ -0,0 +1,34 @@
+"""Error tracking and observability."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_react.core.callbacks import AppContext
+
+app = typer.Typer(help="Error tracking and observability.")
+
+
+@app.command()
+def sentry(ctx: typer.Context, app_name: Annotated[str | None, typer.Argument(help="App name")] = None) -> None:
+    """Show recent Sentry issues."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    out.info("Sentry integration — requires SENTRY_AUTH_TOKEN and SENTRY_ORG in env")
+    out.info("Configure via: kctl-react config set sentry_org kodemeio")
+
+
+@app.command()
+def errors(ctx: typer.Context, app_name: Annotated[str | None, typer.Argument(help="App name")] = None) -> None:
+    """Show error trends."""
+    ctx.invoke(sentry, app_name=app_name)
+
+
+@app.command()
+def uptime(ctx: typer.Context, app_name: Annotated[str | None, typer.Argument(help="App name")] = None) -> None:
+    """Show Gatus uptime status."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+    out.info("Gatus integration — check https://status.kodeme.io")