1st round of human review

* Renaming things from `cli-bug-prediction*` to `code-review-local*`
* The killswtch for the feature was created but was not being used. Added to the endpint.
* Resolving some mypy complaints

! Still no local tests end-to-end. There are probably bugs lurking

Author: giovanni-guidini

src/sentry/api/endpoints/organization_cli_bug_prediction.py

@@ -24,9 +24,9 @@
 
 
 @region_silo_endpoint
-class OrganizationCliBugPredictionEndpoint(OrganizationEndpoint):
+class OrganizationCodeReviewLocalEndpoint(OrganizationEndpoint):
     """
-    Handle CLI-initiated bug prediction requests.
+    Handle local code review requests from sentry-cli.
 
     Synchronously polls Seer and returns results.
     """
@@ -39,7 +39,7 @@ class OrganizationCliBugPredictionEndpoint(OrganizationEndpoint):
 
     def post(self, request: Request, organization: Organization) -> Response:
         """
-        Trigger bug prediction for a git diff from sentry-cli.
+        Trigger local code review for a git diff from sentry-cli.
 
         This endpoint:
         1. Validates the request (diff size, file count, etc.)
@@ -50,22 +50,29 @@ def post(self, request: Request, organization: Organization) -> Response:
 
         Returns 200 with predictions on success, various error codes on failure.
         """
+        # Check if feature is globally enabled
+        if not settings.CODE_REVIEW_LOCAL_ENABLED:
+            return Response(
+                {"detail": "Local code review is not enabled"},
+                status=503,
+            )
+
         # Check feature flag
-        if not features.has("organizations:cli-bug-prediction", organization):
+        if not features.has("organizations:code-review-local", organization):
             return Response(
-                {"detail": "CLI bug prediction is not enabled for this organization"},
+                {"detail": "Local code review is not enabled for this organization"},
                 status=403,
             )
 
         # Rate limiting
-        user_key = f"cli_bug_prediction:user:{request.user.id}"
-        org_key = f"cli_bug_prediction:org:{organization.id}"
+        user_key = f"code_review_local:user:{request.user.id}"
+        org_key = f"code_review_local:org:{organization.id}"
 
-        user_limit, user_window = settings.CLI_BUG_PREDICTION_USER_RATE_LIMIT
-        org_limit, org_window = settings.CLI_BUG_PREDICTION_ORG_RATE_LIMIT
+        user_limit, user_window = settings.CODE_REVIEW_LOCAL_USER_RATE_LIMIT
+        org_limit, org_window = settings.CODE_REVIEW_LOCAL_ORG_RATE_LIMIT
 
         if ratelimits.backend.is_limited(user_key, limit=user_limit, window=user_window):
-            metrics.incr("cli_bug_prediction.rate_limited", tags={"type": "user"})
+            metrics.incr("code_review_local.rate_limited", tags={"type": "user"})
             return Response(
                 {
                     "detail": f"Rate limit exceeded. Maximum {user_limit} requests per {user_window // 3600} hour(s) per user"
@@ -74,7 +81,7 @@ def post(self, request: Request, organization: Organization) -> Response:
             )
 
         if ratelimits.backend.is_limited(org_key, limit=org_limit, window=org_window):
-            metrics.incr("cli_bug_prediction.rate_limited", tags={"type": "org"})
+            metrics.incr("code_review_local.rate_limited", tags={"type": "org"})
             return Response(
                 {
                     "detail": f"Organization rate limit exceeded. Maximum {org_limit} requests per {org_window // 3600} hour(s)"
@@ -90,13 +97,8 @@ def post(self, request: Request, organization: Organization) -> Response:
         validated_data = serializer.validated_data
         repo_data = validated_data["repository"]
         diff = validated_data["diff"]
-        current_branch = validated_data.get("current_branch")
         commit_message = validated_data.get("commit_message")
 
-        # Record rate limits
-        ratelimits.backend.record(user_key, limit=user_limit, window=user_window)
-        ratelimits.backend.record(org_key, limit=org_limit, window=org_window)
-
         # Resolve repository
         try:
             repository = self._resolve_repository(
@@ -115,20 +117,23 @@ def post(self, request: Request, organization: Organization) -> Response:
 
         # Log request
         logger.info(
-            "cli_bug_prediction.request",
+            "code_review_local.request",
             extra={
                 "organization_id": organization.id,
                 "user_id": request.user.id,
                 "repository_id": repository.id,
                 "diff_size_bytes": len(diff),
-                "has_commit_message": commit_message is not None,
-                "has_current_branch": current_branch is not None,
             },
         )
 
-        metrics.incr("cli_bug_prediction.request", tags={"org": organization.slug})
+        metrics.incr("code_review_local.request", tags={"org": organization.slug})
 
         # Trigger Seer
+        # user.id is guaranteed to be non-None since this endpoint requires authentication
+        user_id = request.user.id
+        assert user_id is not None
+        user_name = request.user.username or getattr(request.user, "email", None) or str(user_id)
+
         try:
             trigger_response = trigger_cli_bug_prediction(
                 repo_provider=repo_data["provider"],
@@ -139,35 +144,35 @@ def post(self, request: Request, organization: Organization) -> Response:
                 diff=diff,
                 organization_id=organization.id,
                 organization_slug=organization.slug,
-                user_id=request.user.id,
-                user_name=request.user.username or request.user.email or str(request.user.id),
+                user_id=user_id,
+                user_name=user_name,
                 commit_message=commit_message,
             )
         except (UrllibTimeoutError, MaxRetryError):
             logger.exception(
-                "cli_bug_prediction.trigger.timeout",
+                "code_review_local.trigger.timeout",
                 extra={
                     "organization_id": organization.id,
                     "user_id": request.user.id,
                 },
             )
             return Response(
-                {"detail": "Bug prediction service is temporarily unavailable"}, status=503
+                {"detail": "Code review service is temporarily unavailable"}, status=503
             )
         except ValueError:
             logger.exception(
-                "cli_bug_prediction.trigger.error",
+                "code_review_local.trigger.error",
                 extra={
                     "organization_id": organization.id,
                     "user_id": request.user.id,
                 },
             )
-            return Response({"detail": "Failed to start bug prediction analysis"}, status=502)
+            return Response({"detail": "Failed to start code review analysis"}, status=502)
 
         run_id = trigger_response["run_id"]
 
         logger.info(
-            "cli_bug_prediction.seer_triggered",
+            "code_review_local.seer_triggered",
             extra={
                 "seer_run_id": run_id,
                 "organization_id": organization.id,
@@ -179,19 +184,19 @@ def post(self, request: Request, organization: Organization) -> Response:
         try:
             final_response = self._poll_seer_for_results(
                 run_id=run_id,
-                timeout_seconds=settings.CLI_BUG_PREDICTION_TIMEOUT,
-                poll_interval_seconds=settings.CLI_BUG_PREDICTION_POLL_INTERVAL,
+                timeout_seconds=settings.CODE_REVIEW_LOCAL_TIMEOUT,
+                poll_interval_seconds=settings.CODE_REVIEW_LOCAL_POLL_INTERVAL,
             )
         except TimeoutError:
             logger.exception(
-                "cli_bug_prediction.timeout",
+                "code_review_local.timeout",
                 extra={
                     "seer_run_id": run_id,
                     "organization_id": organization.id,
                     "user_id": request.user.id,
                 },
             )
-            metrics.incr("cli_bug_prediction.timeout")
+            metrics.incr("code_review_local.timeout")
             return Response(
                 {
                     "detail": "Analysis exceeded maximum processing time (10 minutes). Please try again with a smaller diff."
@@ -202,23 +207,23 @@ def post(self, request: Request, organization: Organization) -> Response:
             # Seer returned error status
             status_code, error_code, error_message = self._map_seer_error_to_response(str(e))
             logger.exception(
-                "cli_bug_prediction.seer_error",
+                "code_review_local.seer_error",
                 extra={
                     "seer_run_id": run_id,
                     "organization_id": organization.id,
                     "user_id": request.user.id,
                     "mapped_status": status_code,
                 },
             )
-            metrics.incr("cli_bug_prediction.seer_error", tags={"error_code": error_code})
+            metrics.incr("code_review_local.seer_error", tags={"error_code": error_code})
             return Response({"detail": error_message}, status=status_code)
 
         # Success
         predictions = final_response.get("predictions", [])
         diagnostics = final_response.get("diagnostics", {})
 
         logger.info(
-            "cli_bug_prediction.completed",
+            "code_review_local.completed",
             extra={
                 "seer_run_id": run_id,
                 "organization_id": organization.id,
@@ -228,8 +233,8 @@ def post(self, request: Request, organization: Organization) -> Response:
             },
         )
 
-        metrics.incr("cli_bug_prediction.completed", tags={"status": "success"})
-        metrics.incr("cli_bug_prediction.predictions", amount=len(predictions))
+        metrics.incr("code_review_local.completed", tags={"status": "success"})
+        metrics.incr("code_review_local.predictions", amount=len(predictions))
 
         response_data = {
             "status": final_response.get("status"),
@@ -289,7 +294,7 @@ def _poll_seer_for_results(
 
             attempt += 1
             logger.debug(
-                "cli_bug_prediction.polling",
+                "code_review_local.polling",
                 extra={
                     "seer_run_id": run_id,
                     "attempt": attempt,
@@ -302,7 +307,7 @@ def _poll_seer_for_results(
             except (UrllibTimeoutError, MaxRetryError):
                 # If status check times out, wait and retry
                 logger.warning(
-                    "cli_bug_prediction.poll.timeout",
+                    "code_review_local.poll.timeout",
                     extra={"seer_run_id": run_id, "attempt": attempt},
                 )
                 time.sleep(poll_interval_seconds)
@@ -362,4 +367,4 @@ def _map_seer_error_to_response(self, seer_error_message: str) -> tuple[int, str
             )
 
         # Default to bad gateway for unknown Seer errors
-        return (502, "bad_gateway", "Bug prediction service encountered an error")
+        return (502, "bad_gateway", "Code review service encountered an error")

src/sentry/api/urls.py

@@ -11,9 +11,7 @@
     OrganizationAuthTokenDetailsEndpoint,
 )
 from sentry.api.endpoints.organization_auth_tokens import OrganizationAuthTokensEndpoint
-from sentry.api.endpoints.organization_cli_bug_prediction import (
-    OrganizationCliBugPredictionEndpoint,
-)
+from sentry.api.endpoints.organization_cli_bug_prediction import OrganizationCodeReviewLocalEndpoint
 from sentry.api.endpoints.organization_events_root_cause_analysis import (
     OrganizationEventsRootCauseAnalysisEndpoint,
 )
@@ -2402,9 +2400,9 @@ def create_group_urls(name_prefix: str) -> list[URLPattern | URLResolver]:
         name="sentry-api-0-organization-autofix-automation-settings",
     ),
     re_path(
-        r"^(?P<organization_id_or_slug>[^/]+)/bug-prediction/cli-review/$",
-        OrganizationCliBugPredictionEndpoint.as_view(),
-        name="sentry-api-0-organization-cli-bug-prediction",
+        r"^(?P<organization_id_or_slug>[^/]+)/code-review/local-review/$",
+        OrganizationCodeReviewLocalEndpoint.as_view(),
+        name="sentry-api-0-organization-code-review-local",
     ),
     re_path(
         r"^(?P<organization_id_or_slug>[^/]+)/seer-rpc/(?P<method_name>\w+)/$",

src/sentry/conf/server.py

@@ -2855,12 +2855,12 @@ def custom_parameter_sort(parameter: dict) -> tuple[str, int]:
 # For encrypting the access token for the GHE integration
 SEER_GHE_ENCRYPT_KEY: str | None = os.getenv("SEER_GHE_ENCRYPT_KEY")
 
-# CLI Bug Prediction
-CLI_BUG_PREDICTION_ENABLED = True
-CLI_BUG_PREDICTION_TIMEOUT = 600  # 10 minutes in seconds
-CLI_BUG_PREDICTION_POLL_INTERVAL = 2  # seconds between Seer polls
-CLI_BUG_PREDICTION_USER_RATE_LIMIT = (10, 3600)  # 10 per hour
-CLI_BUG_PREDICTION_ORG_RATE_LIMIT = (100, 3600)  # 100 per hour
+# Code Review Local (sentry-cli review command)
+CODE_REVIEW_LOCAL_ENABLED = True
+CODE_REVIEW_LOCAL_TIMEOUT = 600  # 10 minutes in seconds
+CODE_REVIEW_LOCAL_POLL_INTERVAL = 2  # seconds between Seer polls
+CODE_REVIEW_LOCAL_USER_RATE_LIMIT = (10, 3600)  # 10 per hour
+CODE_REVIEW_LOCAL_ORG_RATE_LIMIT = (100, 3600)  # 100 per hour
 
 # Used to validate RPC requests from the Overwatch service
 OVERWATCH_RPC_SHARED_SECRET: list[str] | None = None

src/sentry/features/temporary.py

@@ -68,8 +68,8 @@ def register_temporary_features(manager: FeatureManager) -> None:
     manager.add("organizations:detailed-data-for-seer", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=False)
     # Enable GenAI features such as Autofix and Issue Summary
     manager.add("organizations:autofix-seer-preferences", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=True)
-    # Enable CLI bug prediction for sentry-cli review command
-    manager.add("organizations:cli-bug-prediction", OrganizationFeature, FeatureHandlerStrategy.INTERNAL, api_expose=False, default=False)
+    # Enable local code review for sentry-cli review command
+    manager.add("organizations:code-review-local", OrganizationFeature, FeatureHandlerStrategy.INTERNAL, api_expose=False, default=False)
     # Enables Route Preloading
     manager.add("organizations:route-intent-preloading", OrganizationFeature, FeatureHandlerStrategy.FLAGPOLE, api_expose=True)
     # Enable Prevent AI code review to run per commit

src/sentry/seer/cli_bug_prediction.py

@@ -14,7 +14,7 @@
 # Connection pool for CLI bug prediction requests
 seer_cli_bug_prediction_connection_pool = connection_from_url(
     settings.SEER_DEFAULT_URL,
-    timeout=settings.CLI_BUG_PREDICTION_TIMEOUT,
+    timeout=settings.CODE_REVIEW_LOCAL_TIMEOUT,
 )