Merge branch 'master' into bugfix/jira-fallback

Author: whitdog47

.nvmrc

@@ -1 +1 @@
-16.13.0
+20.18.0

docker/Dockerfile

@@ -17,7 +17,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     wget \
     && rm -rf /var/lib/apt/lists/*
 
-RUN wget --quiet -O - https://deb.nodesource.com/setup_16.x | bash - \
+RUN wget --quiet -O - https://deb.nodesource.com/setup_20.x | bash - \
     && apt-get install -y nodejs --no-install-recommends
 
 ARG SOURCE_COMMIT
@@ -87,7 +87,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 RUN echo "deb http://apt.postgresql.org/pub/repos/apt bullseye-pgdg main" > /etc/apt/sources.list.d/pgdg.list \
     && wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add -
 
-RUN wget --quiet -O - https://deb.nodesource.com/setup_12.x | bash -
+RUN wget --quiet -O - https://deb.nodesource.com/setup_20.x | bash -
 
 COPY --from=sdist /dist/*.whl /tmp/dist/
 RUN buildDeps="" \
@@ -104,7 +104,21 @@ RUN buildDeps="" \
     pkg-config postgresql-client-14 nodejs \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/* \
-    && npm install mjml --no-cache-dir
+    # mjml has to be installed differently here because
+    # after node 14, docker will install npm files at the
+    # root directoy and fail, so we have to create a new
+    # directory and use it for the install then copy the
+    # files to the root directory to maintain backwards
+    # compatibility for email generation
+    && mkdir -p /mjml_install \
+    # if our workdir is /, then pushd/popd doesn't work
+    # for the npm install. It still tries to install in /,
+    # which npm can't do
+    && cd /mjml_install \
+    && npm install --no-cache-dir mjml \
+    && mv node_modules / \
+    && cd / \
+    && rm -rf /mjml_install
 
 EXPOSE 8000
 VOLUME /var/lib/dispatch/files

src/dispatch/ai/exceptions.py

@@ -0,0 +1,5 @@
+from dispatch.exceptions import DispatchException
+
+
+class GenAIException(DispatchException):
+    pass

src/dispatch/ai/service.py

@@ -0,0 +1,211 @@
+import json
+import logging
+
+from sqlalchemy.orm import Session
+
+from dispatch.case.enums import CaseResolutionReason
+from dispatch.case.models import Case
+from dispatch.plugin import service as plugin_service
+from dispatch.signal import service as signal_service
+
+from .exceptions import GenAIException
+
+log = logging.getLogger(__name__)
+
+
+def generate_case_signal_historical_context(case: Case, db_session: Session) -> str:
+    """
+    Generate historical context for a case stemming from a signal, including related cases and relevant data.
+
+    Args:
+        case (Case): The case object for which historical context is being generated.
+        db_session (Session): The database session used for querying related data.
+
+    Returns:
+        str: A string containing the historical context for the case, or an error message if context generation fails.
+    """
+    # we fetch the first instance id and signal
+    (first_instance_id, first_instance_signal) = signal_service.get_instances_in_case(
+        db_session=db_session, case_id=case.id
+    ).first()
+
+    signal_instance = signal_service.get_signal_instance(
+        db_session=db_session, signal_instance_id=first_instance_id
+    )
+
+    # Check if the signal instance is valid
+    if not signal_instance:
+        message = "Unable to generate historical context. Signal instance not found."
+        log.warning(message)
+        raise GenAIException(message)
+
+    # Check if the signal is valid
+    if not signal_instance.signal:
+        message = "Unable to generate historical context. Signal not found."
+        log.warning(message)
+        raise GenAIException(message)
+
+    # Check if GenAI is enabled for the signal
+    if not signal_instance.signal.genai_enabled:
+        message = (
+            "Unable to generate historical context. GenAI feature not enabled for this detection."
+        )
+        log.warning(message)
+        raise GenAIException(message)
+
+    # we fetch related cases
+    related_cases = []
+    for resolution_reason in CaseResolutionReason:
+        related_cases.extend(
+            signal_service.get_cases_for_signal_by_resolution_reason(
+                db_session=db_session,
+                signal_id=first_instance_signal.id,
+                resolution_reason=resolution_reason,
+            )
+            .from_self()  # NOTE: function deprecated in SQLAlchemy 1.4 and removed in 2.0
+            .filter(Case.id != case.id)
+        )
+
+    # we prepare historical context
+    historical_context = []
+    for related_case in related_cases:
+        historical_context.append("<case>")
+        historical_context.append(f"<case_name>{related_case.name}</case_name>")
+        historical_context.append(f"<case_resolution>{related_case.resolution}</case_resolution")
+        historical_context.append(
+            f"<case_resolution_reason>{related_case.resolution_reason}</case_resolution_reason>"
+        )
+        historical_context.append(
+            f"<case_alert_data>{related_case.signal_instances[0].raw}</case_alert_data>"
+        )
+        conversation_plugin = plugin_service.get_active_instance(
+            db_session=db_session, project_id=case.project.id, plugin_type="conversation"
+        )
+        if conversation_plugin:
+            if related_case.conversation and related_case.conversation.channel_id:
+                # we fetch conversation replies for the related case
+                conversation_replies = conversation_plugin.instance.get_conversation_replies(
+                    conversation_id=related_case.conversation.channel_id,
+                    thread_ts=related_case.conversation.thread_id,
+                )
+                for reply in conversation_replies:
+                    historical_context.append(
+                        f"<case_conversation_reply>{reply}</case_conversation_reply>"
+                    )
+        else:
+            log.warning(
+                "Conversation replies not included in historical context. No conversation plugin enabled."
+            )
+        historical_context.append("</case>")
+
+    return "\n".join(historical_context)
+
+
+def generate_case_signal_summary(case: Case, db_session: Session) -> dict[str, str]:
+    """
+    Generate an analysis summary of a case stemming from a signal.
+
+    Args:
+        case (Case): The case object for which the analysis summary is being generated.
+        db_session (Session): The database session used for querying related data.
+
+    Returns:
+        dict: A dictionary containing the analysis summary, or an error message if the summary generation fails.
+    """
+    # we generate the historical context
+    try:
+        historical_context = generate_case_signal_historical_context(
+            case=case, db_session=db_session
+        )
+    except GenAIException as e:
+        log.warning(f"Error generating GenAI historical context for {case.name}: {str(e)}")
+        raise e
+
+    # we fetch the artificial intelligence plugin
+    genai_plugin = plugin_service.get_active_instance(
+        db_session=db_session, project_id=case.project.id, plugin_type="artificial-intelligence"
+    )
+
+    # we check if the artificial intelligence plugin is enabled
+    if not genai_plugin:
+        message = (
+            "Unable to generate GenAI signal analysis. No artificial-intelligence plugin enabled."
+        )
+        log.warning(message)
+        raise GenAIException(message)
+
+    # we fetch the first instance id and signal
+    (first_instance_id, first_instance_signal) = signal_service.get_instances_in_case(
+        db_session=db_session, case_id=case.id
+    ).first()
+
+    signal_instance = signal_service.get_signal_instance(
+        db_session=db_session, signal_instance_id=first_instance_id
+    )
+
+    # Check if the signal instance is valid
+    if not signal_instance:
+        message = "Unable to generate GenAI signal analysis. Signal instance not found."
+        log.warning(message)
+        raise GenAIException(message)
+
+    # Check if the signal is valid
+    if not signal_instance.signal:
+        message = "Unable to generate GenAI signal analysis. Signal not found."
+        log.warning(message)
+        raise GenAIException(message)
+
+    # Check if GenAI is enabled for the signal
+    if not signal_instance.signal.genai_enabled:
+        message = f"Unable to generate GenAI signal analysis. GenAI feature not enabled for {signal_instance.signal.name}."
+        log.warning(message)
+        raise GenAIException(message)
+
+    # we check if the signal has a prompt defined
+    if not signal_instance.signal.genai_prompt:
+        message = f"Unable to generate GenAI signal analysis. No GenAI prompt defined for {signal_instance.signal.name}."
+        log.warning(message)
+        raise GenAIException(message)
+
+    # we generate the analysis
+    response = genai_plugin.instance.chat_completion(
+        prompt=f"""
+
+        <prompt>
+        {signal_instance.signal.genai_prompt}
+        </prompt>
+
+        <current_event>
+        {str(signal_instance.raw)}
+        </current_event>
+
+        <runbook>
+        {signal_instance.signal.runbook}
+        </runbook>
+
+        <historical_context>
+        {historical_context}
+        </historical_context>
+
+        """
+    )
+
+    try:
+        summary = json.loads(
+            response["choices"][0]["message"]["content"]
+            .replace("```json", "")
+            .replace("```", "")
+            .strip()
+        )
+
+        # we check if the summary is empty
+        if not summary:
+            message = "Unable to generate GenAI signal analysis. We received an empty response from the artificial-intelligence plugin."
+            log.warning(message)
+            raise GenAIException(message)
+
+        return summary
+    except json.JSONDecodeError as e:
+        message = "Unable to generate GenAI signal analysis. Error decoding response from the artificial-intelligence plugin."
+        log.warning(message)
+        raise GenAIException(message) from e

src/dispatch/case/flows.py

@@ -211,6 +211,10 @@ def case_auto_close_flow(case: Case, db_session: Session):
         db_session=db_session,
     )
 
+    if case.conversation and case.has_thread:
+        # we update the case conversation
+        update_conversation(case=case, db_session=db_session)
+
 
 def case_new_create_flow(
     *,

src/dispatch/incident/flows.py

@@ -1,62 +1,57 @@
 import logging
-
 from datetime import datetime
 from typing import Optional
 
 from sqlalchemy.orm import Session
 
-from dispatch.case.models import Case
 from dispatch.case import service as case_service
+from dispatch.case.models import Case
 from dispatch.conference import flows as conference_flows
 from dispatch.conversation import flows as conversation_flows
 from dispatch.database.core import resolve_attr
 from dispatch.decorators import background_task
 from dispatch.document import flows as document_flows
 from dispatch.document.models import Document
-from dispatch.enums import DocumentResourceTypes
-from dispatch.enums import Visibility, EventType
+from dispatch.enums import DocumentResourceTypes, EventType, Visibility
 from dispatch.event import service as event_service
 from dispatch.group import flows as group_flows
-from dispatch.group.enums import GroupType, GroupAction
+from dispatch.group.enums import GroupAction, GroupType
 from dispatch.incident import service as incident_service
 from dispatch.incident.models import IncidentRead
 from dispatch.incident_cost import service as incident_cost_service
 from dispatch.individual import service as individual_service
+from dispatch.individual.models import IndividualContact
 from dispatch.participant import flows as participant_flows
 from dispatch.participant import service as participant_service
 from dispatch.participant.models import Participant
-from dispatch.individual.models import IndividualContact
-from dispatch.team.models import TeamContact
 from dispatch.participant_role import flows as participant_role_flows
 from dispatch.participant_role.models import ParticipantRoleType
 from dispatch.plugin import service as plugin_service
 from dispatch.report.enums import ReportTypes
 from dispatch.report.messaging import send_incident_report_reminder
 from dispatch.service import service as service_service
 from dispatch.storage import flows as storage_flows
+from dispatch.tag.flows import check_for_tag_change
 from dispatch.task.enums import TaskStatus
+from dispatch.team.models import TeamContact
 from dispatch.ticket import flows as ticket_flows
-from dispatch.tag.flows import check_for_tag_change
 
 from .messaging import (
-    # get_suggested_document_items,
+    bulk_participant_announcement_message,
     send_incident_closed_information_review_reminder,
     send_incident_commander_readded_notification,
     send_incident_created_notifications,
     send_incident_management_help_tips_message,
     send_incident_new_role_assigned_notification,
     send_incident_open_tasks_ephemeral_message,
-    send_participant_announcement_message,
-    bulk_participant_announcement_message,
     send_incident_rating_feedback_message,
     send_incident_review_document_notification,
-    # send_incident_suggested_reading_messages,
     send_incident_update_notifications,
     send_incident_welcome_participant_messages,
+    send_participant_announcement_message,
 )
 from .models import Incident, IncidentStatus
 
-
 log = logging.getLogger(__name__)
 
 
@@ -315,13 +310,6 @@ def incident_create_resources(
         # we send the welcome messages to the participant
         send_incident_welcome_participant_messages(user_email, incident, db_session)
 
-        # NOTE: Temporarily disabled until an issue with the Dispatch resolver plugin is resolved
-        # we send a suggested reading message to the participant
-        # suggested_document_items = get_suggested_document_items(incident, db_session)
-        # send_incident_suggested_reading_messages(
-        # 	  incident, suggested_document_items, user_email, db_session
-        # )
-
     bulk_participant_announcement_message(
         participant_emails=user_emails,
         subject=incident,
@@ -1051,13 +1039,6 @@ def incident_add_or_reactivate_participant_flow(
         # we send the welcome messages to the participant
         send_incident_welcome_participant_messages(user_email, incident, db_session)
 
-        # NOTE: Temporarily disabled until an issue with the Dispatch resolver plugin is resolved
-        # we send a suggested reading message to the participant
-        # suggested_document_items = get_suggested_document_items(incident, db_session)
-        # send_incident_suggested_reading_messages(
-        # 	  incident, suggested_document_items, user_email, db_session
-        # )
-
     return participant