feat: upgrade remote scanning and reporting (roast/cli.py)

Author: Rohan5commit

roast/cli.py

@@ -3,23 +3,24 @@
 from __future__ import annotations
 
 from contextlib import nullcontext
+import io
 import logging
 import os
 from pathlib import Path
 import tempfile
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlparse
+from urllib.request import Request, urlopen
+import zipfile
 
 import typer
 from rich.console import Console
 from rich.panel import Panel
 from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from roast.analyzer import analyze
-from roast.reporter import export_html_report, render_terminal_report
-from roast.roaster import (
-    DEFAULT_GROQ_MODEL,
-    DEFAULT_NIM_MODEL,
-    generate_roast,
-)
+from roast.reporter import export_html_report, export_json_report, render_terminal_report
+from roast.roaster import DEFAULT_GROQ_MODEL, DEFAULT_NIM_MODEL, generate_roast
 from roast.scanner import scan_repo
 
 app = typer.Typer(
@@ -30,24 +31,88 @@
 console = Console()
 LOGGER = logging.getLogger(__name__)
 VALID_PROVIDERS = {"auto", "groq", "nim", "openai", "none"}
+GITHUB_API_BASE = "https://api.github.com"
+
+
+def _parse_github_target(value: str) -> tuple[str, str, str | None] | None:
+    parsed = urlparse(value)
+    if parsed.scheme != "https" or parsed.netloc != "github.com":
+        return None
+
+    parts = [part for part in parsed.path.split("/") if part]
+    if len(parts) < 2:
+        raise RuntimeError("GitHub URL must point to a repository, e.g. https://github.com/owner/repo")
+
+    owner = parts[0]
+    repo = parts[1].removesuffix(".git")
+    if len(parts) == 2:
+        return owner, repo, None
+    if len(parts) >= 4 and parts[2] == "tree":
+        ref = "/".join(parts[3:]).strip() or None
+        return owner, repo, ref
+    raise RuntimeError("GitHub URL must point to a repository root or tree ref.")
+
+
+def _github_headers() -> dict[str, str]:
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "User-Agent": "roast-my-code",
+    }
+    github_token = os.getenv("GITHUB_TOKEN")
+    if github_token:
+        headers["Authorization"] = f"Bearer {github_token}"
+    return headers
+
+
+def _extract_archive_root(temp_dir_path: Path) -> Path:
+    extracted_dirs = [child for child in temp_dir_path.iterdir() if child.is_dir()]
+    if len(extracted_dirs) != 1:
+        raise RuntimeError("GitHub archive had an unexpected layout.")
+    return extracted_dirs[0]
+
+
+def _download_github_archive(
+    owner: str,
+    repo: str,
+    ref: str | None,
+    temp_dir: tempfile.TemporaryDirectory[str],
+) -> Path:
+    archive_suffix = f"/{ref}" if ref else ""
+    archive_url = f"{GITHUB_API_BASE}/repos/{owner}/{repo}/zipball{archive_suffix}"
+    request = Request(archive_url, headers=_github_headers())
 
+    try:
+        with urlopen(request) as response:
+            archive_bytes = response.read()
+    except HTTPError as exc:
+        detail = exc.read().decode("utf-8", errors="ignore")
+        if exc.code == 404:
+            hint = " If this repo is private, set GITHUB_TOKEN before running the CLI."
+        else:
+            hint = ""
+        raise RuntimeError(f"Failed to download GitHub archive ({exc.code}).{hint} {detail}".strip()) from exc
+    except URLError as exc:
+        raise RuntimeError(f"Failed to reach GitHub archive endpoint: {exc.reason}") from exc
 
-def _is_github_url(value: str) -> bool:
-    return value.startswith("https://github.com")
+    try:
+        with zipfile.ZipFile(io.BytesIO(archive_bytes)) as archive:
+            archive.extractall(temp_dir.name)
+    except zipfile.BadZipFile as exc:
+        raise RuntimeError("GitHub archive download was not a valid zip file.") from exc
 
+    return _extract_archive_root(Path(temp_dir.name))
 
-def _resolve_scan_target(path_or_url: str) -> tuple[Path, tempfile.TemporaryDirectory[str] | None]:
-    if _is_github_url(path_or_url):
-        from git import Repo
-        from git.exc import GitCommandError
 
+def _resolve_scan_target(path_or_url: str) -> tuple[Path, tempfile.TemporaryDirectory[str] | None]:
+    github_target = _parse_github_target(path_or_url)
+    if github_target:
         temp_dir = tempfile.TemporaryDirectory(prefix="roast-my-code-")
         try:
-            Repo.clone_from(path_or_url, temp_dir.name)
-        except GitCommandError as exc:
+            target_path = _download_github_archive(*github_target, temp_dir=temp_dir)
+        except RuntimeError:
             temp_dir.cleanup()
-            raise RuntimeError(f"Failed to clone GitHub URL: {exc}") from exc
-        return Path(temp_dir.name), temp_dir
+            raise
+        return target_path, temp_dir
 
     local_path = Path(path_or_url).expanduser().resolve()
     if not local_path.exists():
@@ -81,6 +146,18 @@ def _validate_provider(value: str, option_name: str) -> str:
     return normalized
 
 
+def _validate_fail_under(value: int | None) -> int | None:
+    if value is None:
+        return None
+    if not 0 <= value <= 100:
+        raise RuntimeError("fail-under must be between 0 and 100.")
+    return value
+
+
+def _should_fail_quality_gate(overall_score: int, fail_under: int | None) -> bool:
+    return fail_under is not None and overall_score < fail_under
+
+
 def _has_any_configured_llm_key(provider: str, backup_provider: str) -> bool:
     if provider == "auto":
         return any(_provider_has_key(name) for name in ("groq", "nim", "openai"))
@@ -99,6 +176,11 @@ def roast(
         "-o",
         help="Save HTML report to this path.",
     ),
+    json_output: str | None = typer.Option(
+        None,
+        "--json-output",
+        help="Save JSON report to this path.",
+    ),
     model: str = typer.Option(
         DEFAULT_GROQ_MODEL,
         "--model",
@@ -107,7 +189,7 @@ def roast(
     provider: str = typer.Option(
         "auto",
         "--provider",
-        help="Primary provider: auto, groq, nim, openai.",
+        help="Primary provider: auto, groq, nim, openai, none.",
     ),
     backup_provider: str = typer.Option(
         "nim",
@@ -125,7 +207,17 @@ def roast(
         "--extensions",
         help="Comma-separated file extensions to scan.",
     ),
+    include_config: bool = typer.Option(
+        False,
+        "--include-config",
+        help="Include config and documentation files like .toml, .yml, and .md.",
+    ),
     max_files: int = typer.Option(50, "--max-files", help="Max files to scan."),
+    fail_under: int | None = typer.Option(
+        None,
+        "--fail-under",
+        help="Exit with code 1 if the overall score falls below this threshold.",
+    ),
 ) -> None:
     """Roast a local repository path or GitHub URL."""
     logging.basicConfig(level=logging.WARNING, format="%(levelname)s: %(message)s")
@@ -134,6 +226,7 @@ def roast(
     try:
         provider = _validate_provider(provider, "provider")
         backup_provider = _validate_provider(backup_provider, "backup_provider")
+        fail_under = _validate_fail_under(fail_under)
     except RuntimeError as exc:
         console.print(Panel(str(exc), title="Configuration Error", border_style="red"))
         raise typer.Exit(code=1)
@@ -146,9 +239,9 @@ def roast(
             Panel(
                 "[bold red]No LLM API keys found.[/]\n"
                 "Set at least one:\n"
-                "[cyan]export GROQ_API_KEY='...[/cyan]' (recommended free primary)\n"
-                "[cyan]export NVIDIA_NIM_API_KEY='...[/cyan]' (recommended backup)\n"
-                "[cyan]export OPENAI_API_KEY='...[/cyan]' (optional)\n"
+                "[cyan]export GROQ_API_KEY='...'[/cyan] (recommended free primary)\n"
+                "[cyan]export NVIDIA_NIM_API_KEY='...'[/cyan] (recommended backup)\n"
+                "[cyan]export OPENAI_API_KEY='...'[/cyan] (optional)\n"
                 "Or run with [cyan]--no-llm[/] to skip AI roast generation.",
                 title="Configuration Error",
                 border_style="red",
@@ -167,7 +260,7 @@ def roast(
     with context:
         with Progress(SpinnerColumn(), TextColumn("[bold cyan]{task.description}"), transient=True) as progress:
             task_id = progress.add_task("Scanning repository...", total=None)
-            files = scan_repo(target_path, ext_list, max_files=max_files)
+            files = scan_repo(target_path, ext_list, max_files=max_files, include_config=include_config)
             progress.update(task_id, description=f"Running static analysis on {len(files)} files...")
             report = analyze(files)
 
@@ -197,8 +290,23 @@ def roast(
                     roast_result = generate_roast(report, files, no_llm=True)
 
         export_html_report(report, roast_result, output_path=output)
+        if json_output:
+            export_json_report(report, roast_result, output_path=json_output)
         render_terminal_report(report, roast_result, output_path=output, console=console)
+        if json_output:
+            console.print(f"[bold cyan]JSON report saved to: {Path(json_output).expanduser()}[/]")
+
+        overall_score = report.scores.get("Overall", 0)
+        if _should_fail_quality_gate(overall_score, fail_under):
+            console.print(
+                Panel(
+                    f"Overall score {overall_score} is below required threshold {fail_under}.",
+                    title="Quality Gate Failed",
+                    border_style="red",
+                )
+            )
+            raise typer.Exit(code=1)
 
 
 if __name__ == "__main__":
-    app()
+    app()