Merge branch 'pull_request_conversation_1' into pull_request_conversation_2

Author: anthony-nhs

packages/slackBotFunction/app/slack/slack_events.py

@@ -27,7 +27,6 @@
 from app.services.slack import get_friendly_channel_name, post_error_message
 from app.utils.handler_utils import (
     conversation_key_and_root,
-    extract_conversation_context,
     extract_pull_request_id,
     forward_event_to_pull_request_lambda,
     is_duplicate_event,
@@ -119,7 +118,6 @@ def _handle_session_management(
     user_id: str,
     channel: str,
     thread_ts: str,
-    context_type: str,
     message_ts: str,
 ) -> None:
     """Handle Bedrock session creation and cleanup"""
@@ -131,7 +129,7 @@ def _handle_session_management(
             kb_response["sessionId"],
             user_id,
             channel,
-            thread_ts if context_type == constants.CONTEXT_TYPE_THREAD else None,
+            thread_ts,
             message_ts,
         )
     elif session_id:
@@ -206,7 +204,7 @@ def process_feedback_event(
         client.chat_postMessage(**params)
     except Exception as e:
         logger.error(f"Failed to post channel feedback ack: {e}", extra={"error": traceback.format_exc()})
-        _, _, thread_ts = extract_conversation_context(event)
+        _, thread_ts = conversation_key_and_root(event)
         post_error_message(channel=channel_id, thread_ts=thread_ts, client=client)
 
 
@@ -267,7 +265,7 @@ def process_async_slack_action(body: Dict[str, Any], client: WebClient) -> None:
 def process_async_slack_event(event: Dict[str, Any], event_id: str, client: WebClient) -> None:
     original_message_text = (event.get("text") or "").strip()
     message_text = strip_mentions(message_text=original_message_text)
-    conversation_key, _, thread_ts = extract_conversation_context(event)
+    conversation_key, thread_ts = conversation_key_and_root(event)
     user_id = event.get("user", "unknown")
     channel_id = event["channel"]
     conversation_key, thread_root = conversation_key_and_root(event=event)
@@ -305,13 +303,13 @@ def process_slack_message(event: Dict[str, Any], event_id: str, client: WebClien
     try:
         user_id = event["user"]
         channel = event["channel"]
-        conversation_key, context_type, thread_ts = extract_conversation_context(event)
+        conversation_key, thread_ts = conversation_key_and_root(event)
 
         # Remove Slack user mentions from message text
         user_query = re.sub(r"<@[UW][A-Z0-9]+(\|[^>]+)?>", "", event["text"]).strip()
 
         logger.info(
-            f"Processing {context_type} message from user {user_id}",
+            f"Processing message from user {user_id}",
             extra={"user_query": user_query, "conversation_key": conversation_key, "event_id": event_id},
         )
 
@@ -342,15 +340,14 @@ def process_slack_message(event: Dict[str, Any], event_id: str, client: WebClien
         message_ts = post["ts"]
 
         _handle_session_management(
-            conversation_key,
-            session_data,
-            session_id,
-            kb_response,
-            user_id,
-            channel,
-            thread_ts,
-            context_type,
-            message_ts,
+            conversation_key=conversation_key,
+            session_data=session_data,
+            session_id=session_id,
+            kb_response=kb_response,
+            user_id=user_id,
+            channel=channel,
+            thread_ts=thread_ts,
+            message_ts=message_ts,
         )
 
         # Store Q&A pair for feedback correlation

packages/slackBotFunction/app/slack/slack_handlers.py

@@ -11,14 +11,13 @@
 from functools import lru_cache
 import traceback
 from typing import Any, Dict
-from slack_bolt import Ack, App, BoltRequest
+from slack_bolt import Ack, App
 from slack_sdk import WebClient
 from app.core.config import (
     get_logger,
 )
 from app.utils.handler_utils import (
     conversation_key_and_root,
-    extract_conversation_context,
     extract_session_pull_request_id,
     forward_action_to_pull_request_lambda,
     forward_event_to_pull_request_lambda,
@@ -86,7 +85,7 @@ def feedback_handler(body: Dict[str, Any], client: WebClient) -> None:
 # ================================================================
 
 
-def unified_message_handler(client: WebClient, event: Dict[str, Any], req: BoltRequest, body: Dict[str, Any]) -> None:
+def unified_message_handler(client: WebClient, event: Dict[str, Any], body: Dict[str, Any]) -> None:
     """
     All messages get processed by this code
     If message starts with FEEDBACK_PREFIX then handle feedback message and return
@@ -99,7 +98,6 @@ def unified_message_handler(client: WebClient, event: Dict[str, Any], req: BoltR
         return
     user_id = event.get("user", "unknown")
     conversation_key, _ = conversation_key_and_root(event=event)
-    conversation_key, _, _ = extract_conversation_context(event)
     session_pull_request_id = extract_session_pull_request_id(conversation_key)
     if session_pull_request_id:
         logger.info(

packages/slackBotFunction/app/utils/handler_utils.py

@@ -53,52 +53,60 @@ def respond_with_eyes(event: Dict[str, Any], client: WebClient) -> None:
         logger.warning("Failed to respond with eyes", extra={"error": traceback.format_exc()})
 
 
-def forward_event_to_pull_request_lambda(
-    pull_request_id: str, event: Dict[str, Any], event_id: str, store_pull_request_id: bool
-) -> None:
+def get_pull_request_lambda_arn(pull_request_id: str) -> str:
     cloudformation_client: CloudFormationClient = boto3.client("cloudformation")
-    lambda_client: LambdaClient = boto3.client("lambda")
     try:
         logger.debug("Getting arn for pull request", extra={"pull_request_id": pull_request_id})
         response = cloudformation_client.describe_stacks(StackName=f"epsam-pr-{pull_request_id}")
         outputs = {o["OutputKey"]: o["OutputValue"] for o in response["Stacks"][0]["Outputs"]}
-
         pull_request_lambda_arn = outputs.get("SlackBotLambdaArn")
-        logger.debug("Triggering pull request lambda", extra={"lambda_arn": pull_request_lambda_arn})
+        return pull_request_lambda_arn
+    except Exception as e:
+        logger.error("Failed to get pull request lambda arn", extra={"error": traceback.format_exc()})
+        raise e
+
+
+def forward_event_to_pull_request_lambda(
+    pull_request_id: str, event: Dict[str, Any], event_id: str, store_pull_request_id: bool
+) -> None:
+    lambda_client: LambdaClient = boto3.client("lambda")
+    try:
+        pull_request_lambda_arn = get_pull_request_lambda_arn(pull_request_id=pull_request_id)
+        # strip pull request prefix and id from message text
         message_text = event["text"]
         _, extracted_message = extract_pull_request_id(message_text)
         event["text"] = extracted_message
+
         lambda_payload = {"pull_request_event": True, "slack_event": {"event": event, "event_id": event_id}}
-        response = lambda_client.invoke(
+        logger.debug(
+            "Forwarding event to pull request lambda",
+            extra={"lambda_arn": pull_request_lambda_arn, "lambda_payload": lambda_payload},
+        )
+        lambda_client.invoke(
             FunctionName=pull_request_lambda_arn, InvocationType="Event", Payload=json.dumps(lambda_payload)
         )
         logger.info("Triggered pull request lambda", extra={"lambda_arn": pull_request_lambda_arn})
 
         if store_pull_request_id:
-            conversation_key, _, _ = extract_conversation_context(event)
+            conversation_key, _ = conversation_key_and_root(event)
             item = {"pk": conversation_key, "sk": constants.PULL_REQUEST_SK, "pull_request_id": pull_request_id}
+            store_state_information(item=item)
 
-        store_state_information(item=item)
     except Exception as e:
         logger.error("Failed to trigger pull request lambda", extra={"error": traceback.format_exc()})
         raise e
 
 
 def forward_action_to_pull_request_lambda(body: Dict[str, Any], pull_request_id: str) -> None:
-    cloudformation_client: CloudFormationClient = boto3.client("cloudformation")
     lambda_client: LambdaClient = boto3.client("lambda")
     try:
-        logger.debug("Getting arn for pull request", extra={"pull_request_id": pull_request_id})
-        response = cloudformation_client.describe_stacks(StackName=f"epsam-pr-{pull_request_id}")
-        outputs = {o["OutputKey"]: o["OutputValue"] for o in response["Stacks"][0]["Outputs"]}
-
-        pull_request_lambda_arn = outputs.get("SlackBotLambdaArn")
+        pull_request_lambda_arn = get_pull_request_lambda_arn(pull_request_id=pull_request_id)
         lambda_payload = {"pull_request_action": True, "slack_body": body}
         logger.debug(
             "Forwarding action to pull request lambda",
             extra={"lambda_arn": pull_request_lambda_arn, "lambda_payload": lambda_payload},
         )
-        response = lambda_client.invoke(
+        lambda_client.invoke(
             FunctionName=pull_request_lambda_arn, InvocationType="Event", Payload=json.dumps(lambda_payload)
         )
         logger.info("Triggered pull request lambda", extra={"lambda_arn": pull_request_lambda_arn})
@@ -152,12 +160,13 @@ def strip_mentions(message_text: str) -> str:
     return re.sub(r"<@[UW][A-Z0-9]+(\|[^>]+)?>", "", message_text or "").strip()
 
 
-def extract_pull_request_id(text: str) -> Tuple[str, str]:
+def extract_pull_request_id(text: str) -> Tuple[str | None, str]:
     # Regex: PULL_REQUEST_PREFIX + optional space + number + space + rest of text
     pattern = re.escape(constants.PULL_REQUEST_PREFIX) + r"\s*(\d+)\s+(.+)"
     match = re.match(pattern, text)
     if not match:
-        raise ValueError("Text does not match expected format (#pr <number> <text>)")
+        logger.warning("Can not extract pull request id from text", extra={"text": text})
+        return None, text
     pr_number = int(match.group(1))
     rest_text = match.group(2)
     return pr_number, rest_text
@@ -181,18 +190,6 @@ def conversation_key_and_root(event: Dict[str, Any]) -> Tuple[str, str]:
     return f"{constants.THREAD_PREFIX}{channel_id}#{root}", root
 
 
-def extract_conversation_context(event: Dict[str, Any]) -> Tuple[str, str, str | None]:
-    """Extract conversation key and thread context from event"""
-    channel = event["channel"]
-    # Determine conversation context: DM vs channel thread
-    if event.get("channel_type") == constants.CHANNEL_TYPE_IM:
-        thread_root = event.get("thread_ts", event["ts"])
-        return f"{constants.DM_PREFIX}{channel}#{thread_root}", constants.CONTEXT_TYPE_THREAD, thread_root
-    else:
-        thread_root = event.get("thread_ts", event["ts"])
-        return f"{constants.THREAD_PREFIX}{channel}#{thread_root}", constants.CONTEXT_TYPE_THREAD, thread_root
-
-
 def extract_session_pull_request_id(conversation_key: str) -> str | None:
     """Check if the conversation is associated with a pull request"""
     logger.debug("Checking for existing pull request session", extra={"conversation_key": conversation_key})