code-mower 0.5.0b5__py3-none-any.whl

code_mower/cloud_client/git_metadata.py

@@ -0,0 +1,46 @@
+"""Safe Git metadata helpers for Code Mower Cloud uploads."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+
+def run_git(repo_path: Path, args: list[str]) -> str:
+    """Return stdout for a best-effort git command, or an empty string."""
+    try:
+        completed = subprocess.run(
+            ["git", *args],
+            cwd=repo_path,
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+    except OSError:
+        return ""
+    if completed.returncode != 0:
+        return ""
+    return completed.stdout.strip()
+
+
+def repo_slug_from_remote(remote_url: str) -> str:
+    remote = remote_url.strip()
+    if not remote:
+        return ""
+    if remote.startswith("git@github.com:"):
+        remote = remote.removeprefix("git@github.com:")
+    elif remote.startswith("https://github.com/"):
+        remote = remote.removeprefix("https://github.com/")
+    elif remote.startswith("http://github.com/"):
+        remote = remote.removeprefix("http://github.com/")
+    else:
+        return ""
+    remote = remote.removesuffix(".git").strip("/")
+    parts = remote.split("/")
+    if len(parts) >= 2 and parts[0] and parts[1]:
+        return f"{parts[0]}/{parts[1]}"
+    return ""
+
+
+def detect_repo_slug(repo_path: Path) -> str:
+    return repo_slug_from_remote(run_git(repo_path, ["config", "--get", "remote.origin.url"]))

code_mower/cloud_client/manifest.py

@@ -0,0 +1,39 @@
+"""Bundle manifest loading and path validation helpers."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .bundle import BUNDLE_MANIFEST_FILENAME, is_bundle_manifest
+from .errors import CloudBundleError
+
+
+def load_bundle_manifest(bundle_dir: Path) -> dict[str, Any]:
+    manifest_path = bundle_dir / BUNDLE_MANIFEST_FILENAME
+    if not manifest_path.is_file():
+        raise CloudBundleError(f"bundle manifest not found: {manifest_path}")
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise CloudBundleError(f"unable to read bundle manifest {manifest_path}: {exc}") from exc
+    if not is_bundle_manifest(manifest):
+        raise CloudBundleError(f"unsupported bundle manifest schema in {manifest_path}")
+    return manifest
+
+
+def report_path_from_manifest(bundle_dir: Path, target: str) -> Path:
+    if not target or target.startswith("/") or ".." in Path(target).parts:
+        raise CloudBundleError(f"unsafe report target in bundle manifest: {target!r}")
+    path = bundle_dir / target
+    try:
+        resolved = path.resolve()
+        bundle_resolved = bundle_dir.resolve()
+    except OSError as exc:
+        raise CloudBundleError(f"unable to resolve bundle report path {path}: {exc}") from exc
+    if not resolved.is_relative_to(bundle_resolved):
+        raise CloudBundleError(f"report target escapes bundle directory: {target!r}")
+    if not resolved.is_file():
+        raise CloudBundleError(f"bundle report file is missing: {target!r}")
+    return resolved

code_mower/cloud_client/operations.py

@@ -0,0 +1,448 @@
+"""High-level CodeMower.com upload operations."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from .. import code_mower_telemetry
+from .bundle import MAX_EVENT_COUNT
+from .doctor import run_cloud_doctor
+from .dogfood import build_dogfood_dry_run_preview, build_dogfood_plan, default_dogfood_reports
+from .endpoints import is_local_http_endpoint
+from .errors import CloudBundleError
+from .events import (
+    build_dogfood_event,
+    build_workflow_run_event,
+    run_gh_run_list,
+)
+from .export import build_cloud_bundle
+from .git_metadata import detect_repo_slug
+from .setup import DEFAULT_INSTALL_ID_ENV, DEFAULT_TEAM_ID_ENV
+from .upload import build_upload_payload, post_upload_payload
+
+
+def dogfood_upload(
+    *,
+    repo_path: Path,
+    output_dir: Path,
+    reports: list[tuple[Path, str]],
+    events: list[dict[str, Any]],
+    repo_slug: str,
+    team_id: str,
+    install_id: str,
+    source: str,
+    endpoint: str,
+    token_env: str,
+    include_reports: bool,
+    yes: bool,
+    timeout: float,
+) -> dict[str, Any]:
+    repo_path = repo_path.expanduser().resolve()
+    detected_repo_slug = repo_slug or detect_repo_slug(repo_path)
+    if not detected_repo_slug:
+        raise CloudBundleError(
+            "unable to detect repo slug; pass --repo-slug OWNER/REPO"
+        )
+    resolved_team_id = team_id or os.environ.get(DEFAULT_TEAM_ID_ENV, "")
+    resolved_install_id = install_id or os.environ.get(DEFAULT_INSTALL_ID_ENV, "")
+    resolved_reports = reports or default_dogfood_reports(repo_path)
+    dogfood_plan = build_dogfood_plan(
+        repo_slug=detected_repo_slug,
+        team_id=resolved_team_id,
+        install_id=resolved_install_id,
+        source=source,
+        reports=resolved_reports,
+        events=events,
+    )
+    all_events = [
+        build_dogfood_event(
+            repo_path=repo_path,
+            plan=dogfood_plan,
+        ),
+        *events,
+    ]
+    export_result = build_cloud_bundle(
+        reports=resolved_reports,
+        events=all_events,
+        output_dir=output_dir,
+        repo_slug=detected_repo_slug,
+        team_id=resolved_team_id,
+        install_id=resolved_install_id,
+        anonymous=False,
+    )
+    doctor_result = run_cloud_doctor(
+        bundle_dir=output_dir,
+        endpoint=endpoint,
+        token_env=token_env,
+        require_token=yes,
+    )
+    if doctor_result["failures"]:
+        return {
+            "mode": "cloud-dogfood",
+            "status": "doctor_failed",
+            "export": export_result,
+            "doctor": doctor_result,
+        }
+    payload = build_upload_payload(
+        bundle_dir=output_dir,
+        include_reports=include_reports,
+    )
+    if not yes:
+        return {
+            "mode": "cloud-dogfood",
+            "status": "dry_run",
+            "export": export_result,
+            "doctor": doctor_result,
+            "upload": build_dogfood_dry_run_preview(endpoint=endpoint, payload=payload),
+        }
+    token = os.environ.get(token_env, "")
+    if not token and not is_local_http_endpoint(endpoint):
+        raise CloudBundleError(
+            f"{token_env} is not set; refusing non-local upload without a token"
+        )
+    return {
+        "mode": "cloud-dogfood",
+        "status": "uploaded",
+        "export": export_result,
+        "doctor": doctor_result,
+        "upload": post_upload_payload(
+            payload=payload,
+            endpoint=endpoint,
+            token=token,
+            timeout=timeout,
+        ),
+    }
+
+
+def catch_up_upload(
+    *,
+    repo_path: Path,
+    output_dir: Path,
+    repo_slug: str,
+    team_id: str,
+    install_id: str,
+    source: str,
+    limit: int,
+    endpoint: str,
+    token_env: str,
+    yes: bool,
+    timeout: float,
+    include_git_ref: bool,
+) -> dict[str, Any]:
+    if limit < 1 or limit > MAX_EVENT_COUNT:
+        raise CloudBundleError(f"--limit must be between 1 and {MAX_EVENT_COUNT}")
+    repo_path = repo_path.expanduser().resolve()
+    detected_repo_slug = repo_slug or detect_repo_slug(repo_path)
+    if not detected_repo_slug:
+        raise CloudBundleError(
+            "unable to detect repo slug; pass --repo-slug OWNER/REPO"
+        )
+    resolved_team_id = team_id or os.environ.get(DEFAULT_TEAM_ID_ENV, "")
+    resolved_install_id = install_id or os.environ.get(DEFAULT_INSTALL_ID_ENV, "")
+    runs = run_gh_run_list(
+        repo_slug=detected_repo_slug,
+        limit=limit,
+        repo_path=repo_path,
+    )
+    events = [
+        build_workflow_run_event(
+            repo_slug=detected_repo_slug,
+            team_id=resolved_team_id,
+            install_id=resolved_install_id,
+            source=source,
+            run=run,
+            include_git_ref=include_git_ref,
+        )
+        for run in runs
+    ]
+    export_result = build_cloud_bundle(
+        reports=[],
+        events=events,
+        output_dir=output_dir,
+        repo_slug=detected_repo_slug,
+        team_id=resolved_team_id,
+        install_id=resolved_install_id,
+        anonymous=False,
+    )
+    doctor_result = run_cloud_doctor(
+        bundle_dir=output_dir,
+        endpoint=endpoint,
+        token_env=token_env,
+        require_token=yes,
+    )
+    if doctor_result["failures"]:
+        return {
+            "mode": "cloud-catch-up",
+            "status": "doctor_failed",
+            "repo_slug": detected_repo_slug,
+            "run_count": len(runs),
+            "export": export_result,
+            "doctor": doctor_result,
+        }
+    payload = build_upload_payload(bundle_dir=output_dir, include_reports=False)
+    if not yes:
+        return {
+            "mode": "cloud-catch-up",
+            "status": "dry_run",
+            "repo_slug": detected_repo_slug,
+            "run_count": len(runs),
+            "export": export_result,
+            "doctor": doctor_result,
+            "upload": build_dogfood_dry_run_preview(endpoint=endpoint, payload=payload),
+        }
+    token = os.environ.get(token_env, "")
+    if not token and not is_local_http_endpoint(endpoint):
+        raise CloudBundleError(
+            f"{token_env} is not set; refusing non-local upload without a token"
+        )
+    return {
+        "mode": "cloud-catch-up",
+        "status": "uploaded",
+        "repo_slug": detected_repo_slug,
+        "run_count": len(runs),
+        "export": export_result,
+        "doctor": doctor_result,
+        "upload": post_upload_payload(
+            payload=payload,
+            endpoint=endpoint,
+            token=token,
+            timeout=timeout,
+        ),
+    }
+
+
+def reviewer_runs_upload(
+    *,
+    repo_path: Path,
+    verdicts: Path,
+    output_dir: Path,
+    repo_slug: str,
+    team_id: str,
+    install_id: str,
+    limit: int,
+    endpoint: str,
+    token_env: str,
+    yes: bool,
+    timeout: float,
+    include_git_ref: bool,
+) -> dict[str, Any]:
+    if limit < 1 or limit > MAX_EVENT_COUNT:
+        raise CloudBundleError(f"--limit must be between 1 and {MAX_EVENT_COUNT}")
+    repo_path = repo_path.expanduser().resolve()
+    detected_repo_slug = repo_slug or detect_repo_slug(repo_path)
+    if not detected_repo_slug:
+        raise CloudBundleError(
+            "unable to detect repo slug; pass --repo-slug OWNER/REPO"
+        )
+    resolved_team_id = team_id or os.environ.get(DEFAULT_TEAM_ID_ENV, "")
+    resolved_install_id = install_id or os.environ.get(DEFAULT_INSTALL_ID_ENV, "")
+    try:
+        events = code_mower_telemetry.export_reviewer_run_events_from_verdicts(
+            verdicts,
+            repo=detected_repo_slug,
+            limit=limit,
+            include_git_ref=include_git_ref,
+        )
+    except ValueError as exc:
+        raise CloudBundleError(str(exc)) from exc
+    if not events:
+        return {
+            "mode": "cloud-reviewer-runs",
+            "status": "no_events",
+            "repo_slug": detected_repo_slug,
+            "event_count": 0,
+            "verdicts": str(verdicts.expanduser()),
+            "git_ref_included": include_git_ref,
+        }
+    export_result = build_cloud_bundle(
+        reports=[],
+        events=events,
+        output_dir=output_dir,
+        repo_slug=detected_repo_slug,
+        team_id=resolved_team_id,
+        install_id=resolved_install_id,
+        anonymous=False,
+    )
+    doctor_result = run_cloud_doctor(
+        bundle_dir=output_dir,
+        endpoint=endpoint,
+        token_env=token_env,
+        require_token=yes,
+    )
+    if doctor_result["failures"]:
+        return {
+            "mode": "cloud-reviewer-runs",
+            "status": "doctor_failed",
+            "repo_slug": detected_repo_slug,
+            "event_count": len(events),
+            "export": export_result,
+            "doctor": doctor_result,
+        }
+    payload = build_upload_payload(bundle_dir=output_dir, include_reports=False)
+    if not yes:
+        return {
+            "mode": "cloud-reviewer-runs",
+            "status": "dry_run",
+            "repo_slug": detected_repo_slug,
+            "event_count": len(events),
+            "export": export_result,
+            "doctor": doctor_result,
+            "upload": build_dogfood_dry_run_preview(endpoint=endpoint, payload=payload),
+        }
+    token = os.environ.get(token_env, "")
+    if not token and not is_local_http_endpoint(endpoint):
+        raise CloudBundleError(
+            f"{token_env} is not set; refusing non-local upload without a token"
+        )
+    return {
+        "mode": "cloud-reviewer-runs",
+        "status": "uploaded",
+        "repo_slug": detected_repo_slug,
+        "event_count": len(events),
+        "export": export_result,
+        "doctor": doctor_result,
+        "upload": post_upload_payload(
+            payload=payload,
+            endpoint=endpoint,
+            token=token,
+            timeout=timeout,
+        ),
+    }
+
+
+def parse_repo_sync_spec(spec: str) -> tuple[str, Path]:
+    if "=" not in spec:
+        return "", Path(spec)
+    repo_slug, repo_path = spec.split("=", 1)
+    repo_slug = repo_slug.strip()
+    repo_path = repo_path.strip()
+    if not repo_slug or not repo_path:
+        raise CloudBundleError(
+            "--repo entries must be PATH or OWNER/REPO=PATH for repo-sync"
+        )
+    return repo_slug, Path(repo_path)
+
+
+def repo_sync_output_name(repo_slug: str, repo_path: Path, index: int) -> str:
+    raw = repo_slug.replace("/", "__") if repo_slug else repo_path.name
+    cleaned = "".join(
+        ch.lower() if ch.isalnum() else "-" for ch in raw.strip()
+    ).strip("-")
+    return f"{cleaned or 'repo'}-{index + 1}"
+
+
+def repo_sync_upload(
+    *,
+    repo_specs: list[str],
+    output_dir: Path,
+    modes: list[str],
+    team_id: str,
+    install_id: str,
+    source_prefix: str,
+    limit: int,
+    endpoint: str,
+    token_env: str,
+    include_reports: bool,
+    include_git_ref: bool,
+    yes: bool,
+    timeout: float,
+) -> dict[str, Any]:
+    selected_modes = modes or ["dogfood", "reviewer-runs"]
+    repos: list[dict[str, Any]] = []
+    error_count = 0
+    step_statuses: list[str] = []
+
+    for index, spec in enumerate(repo_specs):
+        repo_slug, repo_path = parse_repo_sync_spec(spec)
+        repo_path = repo_path.expanduser().resolve()
+        repo_output_dir = output_dir / repo_sync_output_name(repo_slug, repo_path, index)
+        repo_result: dict[str, Any] = {
+            "repo_spec": spec,
+            "repo_slug": repo_slug,
+            "repo_path": str(repo_path),
+            "steps": [],
+        }
+
+        for mode in selected_modes:
+            try:
+                if mode == "dogfood":
+                    step_result = dogfood_upload(
+                        repo_path=repo_path,
+                        output_dir=repo_output_dir / "dogfood",
+                        reports=[],
+                        events=[],
+                        repo_slug=repo_slug,
+                        team_id=team_id,
+                        install_id=install_id,
+                        source=f"{source_prefix}-dogfood",
+                        endpoint=endpoint,
+                        token_env=token_env,
+                        include_reports=include_reports,
+                        yes=yes,
+                        timeout=timeout,
+                    )
+                elif mode == "catch-up":
+                    step_result = catch_up_upload(
+                        repo_path=repo_path,
+                        output_dir=repo_output_dir / "catch-up",
+                        repo_slug=repo_slug,
+                        team_id=team_id,
+                        install_id=install_id,
+                        source=f"{source_prefix}-catch-up",
+                        limit=limit,
+                        endpoint=endpoint,
+                        token_env=token_env,
+                        yes=yes,
+                        timeout=timeout,
+                        include_git_ref=include_git_ref,
+                    )
+                elif mode == "reviewer-runs":
+                    step_result = reviewer_runs_upload(
+                        repo_path=repo_path,
+                        verdicts=code_mower_telemetry.default_verdict_artifact_dir(),
+                        output_dir=repo_output_dir / "reviewer-runs",
+                        repo_slug=repo_slug,
+                        team_id=team_id,
+                        install_id=install_id,
+                        limit=limit,
+                        endpoint=endpoint,
+                        token_env=token_env,
+                        yes=yes,
+                        timeout=timeout,
+                        include_git_ref=include_git_ref,
+                    )
+                else:  # pragma: no cover - argparse constrains modes.
+                    raise CloudBundleError(f"unsupported repo-sync mode: {mode}")
+            except CloudBundleError as exc:
+                step_result = {
+                    "mode": f"cloud-{mode}",
+                    "status": "error",
+                    "error": str(exc),
+                }
+            repo_result["repo_slug"] = repo_result["repo_slug"] or str(
+                step_result.get("repo_slug") or ""
+            )
+            repo_result["steps"].append(step_result)
+            step_status = str(step_result.get("status") or "")
+            step_statuses.append(step_status)
+            if step_result.get("status") in {"error", "doctor_failed"}:
+                error_count += 1
+
+        repos.append(repo_result)
+
+    status = "dry_run" if not yes else "uploaded"
+    if error_count:
+        status = "partial"
+    elif yes and not any(step_status == "uploaded" for step_status in step_statuses):
+        status = "no_events"
+    return {
+        "mode": "cloud-repo-sync",
+        "status": status,
+        "repo_count": len(repos),
+        "step_count": sum(len(repo["steps"]) for repo in repos),
+        "error_count": error_count,
+        "modes": selected_modes,
+        "repos": repos,
+    }

code_mower/cloud_client/reports.py

@@ -0,0 +1,45 @@
+"""Bundle report payload construction helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from .bundle import MAX_REPORT_UPLOAD_BYTES
+from .errors import CloudBundleError
+from .manifest import report_path_from_manifest
+
+
+def included_report_payloads(
+    manifest: dict[str, Any],
+    bundle_dir: Path,
+    *,
+    include_reports: bool,
+) -> list[dict[str, Any]]:
+    payloads: list[dict[str, Any]] = []
+    for entry in manifest.get("included_reports", []):
+        if not isinstance(entry, dict):
+            raise CloudBundleError("bundle manifest has a non-object included_reports entry")
+        target = str(entry.get("target", ""))
+        report_payload = {
+            "kind": entry.get("kind", ""),
+            "target": target,
+            "bytes": entry.get("bytes", 0),
+            "source_basename": entry.get("source_basename", ""),
+        }
+        if include_reports:
+            path = report_path_from_manifest(bundle_dir, target)
+            size = path.stat().st_size
+            if size > MAX_REPORT_UPLOAD_BYTES:
+                raise CloudBundleError(
+                    f"refusing to upload {target}: {size} bytes exceeds "
+                    f"{MAX_REPORT_UPLOAD_BYTES} byte limit"
+                )
+            try:
+                report_payload["text"] = path.read_text(encoding="utf-8")
+            except UnicodeDecodeError as exc:
+                raise CloudBundleError(f"report is not UTF-8 text: {target}") from exc
+            except OSError as exc:
+                raise CloudBundleError(f"unable to read report {target}: {exc}") from exc
+        payloads.append(report_payload)
+    return payloads