feat: generate a summary of meeting summaries

codegen.json

@@ -85,6 +85,7 @@
           "File": "./types/File#TFile",
           "GcalIntegration": "./types/GcalIntegration#GcalIntegrationSource",
           "GenerateGroupsSuccess": "./types/GenerateGroupsSuccess#GenerateGroupsSuccessSource",
+          "GenerateInsightSuccess": "./types/GenerateInsightSuccess#GenerateInsightSuccessSource",
           "GetTemplateSuggestionSuccess": "./types/GetTemplateSuggestionSuccess#GetTemplateSuggestionSuccessSource",
           "IntegrationProviderWebhook": "../../postgres/queries/getIntegrationProvidersByIds#TIntegrationProvider",
           "IntegrationProviderOAuth1": "../../postgres/queries/getIntegrationProvidersByIds#TIntegrationProvider",

packages/client/mutations/GenerateInsightMutation.ts

@@ -0,0 +1,51 @@
+import graphql from 'babel-plugin-relay/macro'
+import {commitMutation} from 'react-relay'
+import {GenerateInsightMutation as TGenerateInsightMutation} from '../__generated__/GenerateInsightMutation.graphql'
+import {StandardMutation} from '../types/relayMutations'
+
+graphql`
+  fragment GenerateInsightMutation_team on GenerateInsightSuccess {
+    wins
+    challenges
+  }
+`
+
+const mutation = graphql`
+  mutation GenerateInsightMutation(
+    $teamId: ID!
+    $startDate: DateTime!
+    $endDate: DateTime!
+    $useSummaries: Boolean
+    $prompt: String
+  ) {
+    generateInsight(
+      teamId: $teamId
+      startDate: $startDate
+      endDate: $endDate
+      useSummaries: $useSummaries
+      prompt: $prompt
+    ) {
+      ... on ErrorPayload {
+        error {
+          message
+        }
+      }
+      ...GenerateInsightMutation_team @relay(mask: false)
+    }
+  }
+`
+
+const GenerateInsightMutation: StandardMutation<TGenerateInsightMutation> = (
+  atmosphere,
+  variables,
+  {onError, onCompleted}
+) => {
+  return commitMutation<TGenerateInsightMutation>(atmosphere, {
+    mutation,
+    variables,
+    onCompleted,
+    onError
+  })
+}
+
+export default GenerateInsightMutation

packages/server/graphql/public/mutations/generateInsight.ts

@@ -0,0 +1,46 @@
+import getKysely from '../../../postgres/getKysely'
+import standardError from '../../../utils/standardError'
+import {MutationResolvers} from '../resolverTypes'
+import {getSummaries} from './helpers/getSummaries'
+import {getTopics} from './helpers/getTopics'
+
+const generateInsight: MutationResolvers['generateInsight'] = async (
+  _source,
+  {teamId, startDate, endDate, useSummaries = true, prompt},
+  {dataLoader}
+) => {
+  if (Number.isNaN(startDate.getTime()) || Number.isNaN(endDate.getTime())) {
+    return standardError(
+      new Error('Invalid date format. Please use ISO 8601 format (e.g., 2024-01-01T00:00:00Z).')
+    )
+  }
+  const oneWeekInMs = 7 * 24 * 60 * 60 * 1000
+  if (endDate.getTime() - startDate.getTime() < oneWeekInMs) {
+    return standardError(new Error('The end date must be at least one week after the start date.'))
+  }
+
+  const response = useSummaries
+    ? await getSummaries(teamId, startDate, endDate, prompt)
+    : await getTopics(teamId, startDate, endDate, dataLoader, prompt)
+
+  if ('error' in response) {
+    return response
+  }
+  const {wins, challenges} = response
+  const pg = getKysely()
+
+  await pg
+    .insertInto('Insight')
+    .values({
+      teamId,
+      wins,
+      challenges,
+      startDateTime: startDate,
+      endDateTime: endDate
+    })
+    .execute()
+
+  return response
+}
+
+export default generateInsight

packages/server/graphql/public/mutations/helpers/getSummaries.ts

@@ -0,0 +1,57 @@
+import yaml from 'js-yaml'
+import getRethink from '../../../../database/rethinkDriver'
+import MeetingRetrospective from '../../../../database/types/MeetingRetrospective'
+import OpenAIServerManager from '../../../../utils/OpenAIServerManager'
+import standardError from '../../../../utils/standardError'
+
+export const getSummaries = async (
+  teamId: string,
+  startDate: Date,
+  endDate: Date,
+  prompt?: string | null
+) => {
+  const r = await getRethink()
+  const MIN_MILLISECONDS = 60 * 1000 // 1 minute
+  const MIN_REFLECTION_COUNT = 3
+
+  const rawMeetings = (await r
+    .table('NewMeeting')
+    .getAll(teamId, {index: 'teamId'})
+    .filter((row: any) =>
+      row('meetingType')
+        .eq('retrospective')
+        .and(row('createdAt').ge(startDate))
+        .and(row('createdAt').le(endDate))
+        .and(row('reflectionCount').gt(MIN_REFLECTION_COUNT))
+        .and(r.table('MeetingMember').getAll(row('id'), {index: 'meetingId'}).count().gt(1))
+        .and(row('endedAt').sub(row('createdAt')).gt(MIN_MILLISECONDS))
+        .and(row.hasFields('summary'))
+    )
+    .run()) as MeetingRetrospective[]
+
+  if (!rawMeetings.length) {
+    return standardError(new Error('No meetings found'))
+  }
+
+  const summaries = rawMeetings.map((meeting) => ({
+    meetingName: meeting.name,
+    date: meeting.createdAt,
+    summary: meeting.summary
+  }))
+
+  const yamlData = yaml.dump(summaries, {
+    noCompatMode: true
+  })
+
+  const openAI = new OpenAIServerManager()
+  const rawInsight = await openAI.generateInsight(yamlData, true, prompt)
+  if (!rawInsight) {
+    return standardError(new Error('No insights generated'))
+  }
+
+  return {
+    wins: rawInsight.wins,
+    challenges: rawInsight.challenges,
+    meetingIds: rawMeetings.map((meeting) => meeting.id)
+  }
+}

packages/server/graphql/public/mutations/helpers/getTopics.ts

@@ -0,0 +1,229 @@
+import yaml from 'js-yaml'
+import getRethink from '../../../../database/rethinkDriver'
+import MeetingRetrospective from '../../../../database/types/MeetingRetrospective'
+import getKysely from '../../../../postgres/getKysely'
+import OpenAIServerManager from '../../../../utils/OpenAIServerManager'
+import sendToSentry from '../../../../utils/sendToSentry'
+import standardError from '../../../../utils/standardError'
+import {DataLoaderWorker} from '../../../graphql'
+
+const getComments = async (reflectionGroupId: string, dataLoader: DataLoaderWorker) => {
+  const pg = getKysely()
+  const IGNORE_COMMENT_USER_IDS = ['parabolAIUser']
+  const discussion = await pg
+    .selectFrom('Discussion')
+    .selectAll()
+    .where('discussionTopicId', '=', reflectionGroupId)
+    .limit(1)
+    .executeTakeFirst()
+  if (!discussion) return null
+  const {id: discussionId} = discussion
+  const rawComments = await dataLoader.get('commentsByDiscussionId').load(discussionId)
+  const humanComments = rawComments.filter((c) => !IGNORE_COMMENT_USER_IDS.includes(c.createdBy))
+  const rootComments = humanComments.filter((c) => !c.threadParentId)
+  rootComments.sort((a, b) => {
+    return a.createdAt.getTime() < b.createdAt.getTime() ? -1 : 1
+  })
+  const comments = await Promise.all(
+    rootComments.map(async (comment) => {
+      const {createdBy, isAnonymous, plaintextContent} = comment
+      const creator = await dataLoader.get('users').loadNonNull(createdBy)
+      const commentAuthor = isAnonymous ? 'Anonymous' : creator.preferredName
+      const commentReplies = await Promise.all(
+        humanComments
+          .filter((c) => c.threadParentId === comment.id)
+          .sort((a, b) => {
+            return a.createdAt.getTime() < b.createdAt.getTime() ? -1 : 1
+          })
+          .map(async (reply) => {
+            const {createdBy, isAnonymous, plaintextContent} = reply
+            const creator = await dataLoader.get('users').loadNonNull(createdBy)
+            const replyAuthor = isAnonymous ? 'Anonymous' : creator.preferredName
+            return {
+              text: plaintextContent,
+              author: replyAuthor
+            }
+          })
+      )
+      return commentReplies.length === 0
+        ? {
+            text: plaintextContent,
+            author: commentAuthor
+          }
+        : {
+            text: plaintextContent,
+            author: commentAuthor,
+            replies: commentReplies
+          }
+    })
+  )
+  return comments
+}
+
+type MeetingLookup = Record<string, string | Date>
+const meetingLookup: MeetingLookup = {}
+
+const processLines = (lines: string[]): string[] => {
+  const meetingURL = 'https://action.parabol.co/meet/'
+  return lines
+    .map((line) => {
+      if (line.includes(meetingURL)) {
+        let processedLine = line
+        const regex = new RegExp(`${meetingURL}\\S+`, 'g')
+        const matches = processedLine.match(regex) || []
+
+        let isValid = true
+        matches.forEach((match) => {
+          const shortMeetingId = match.split(meetingURL)[1]?.split(/[),\s]/)[0] // Split by closing parenthesis, comma, or space
+          const actualMeetingId = shortMeetingId && (meetingLookup[shortMeetingId] as string)
+
+          if (shortMeetingId && actualMeetingId) {
+            processedLine = processedLine.replace(shortMeetingId, actualMeetingId)
+          } else {
+            const error = new Error(
+              `AI hallucinated. Unable to find meetingId for ${shortMeetingId}. Line: ${line}`
+            )
+            sendToSentry(error)
+            isValid = false
+          }
+        })
+        return isValid ? processedLine : ''
+      }
+      return line
+    })
+    .filter((line) => line.trim() !== '')
+}
+
+const processSection = (section: string[]): string[] => {
+  return section
+    .flatMap((item) => {
+      const lines = item.split('\n')
+      return processLines(lines)
+    })
+    .filter((processedItem) => processedItem.trim() !== '')
+}
+
+export const getTopics = async (
+  teamId: string,
+  startDate: Date,
+  endDate: Date,
+  dataLoader: DataLoaderWorker,
+  prompt?: string | null
+) => {
+  const r = await getRethink()
+  const MIN_REFLECTION_COUNT = 3
+  const MIN_MILLISECONDS = 60 * 1000 // 1 minute
+  const rawMeetings = await r
+    .table('NewMeeting')
+    .getAll(teamId, {index: 'teamId'})
+    .filter((row: any) =>
+      row('meetingType')
+        .eq('retrospective')
+        .and(row('createdAt').ge(startDate))
+        .and(row('createdAt').le(endDate))
+        .and(row('reflectionCount').gt(MIN_REFLECTION_COUNT))
+        .and(r.table('MeetingMember').getAll(row('id'), {index: 'meetingId'}).count().gt(1))
+        .and(row('endedAt').sub(row('createdAt')).gt(MIN_MILLISECONDS))
+    )
+    .run()
+
+  const meetings = await Promise.all(
+    rawMeetings.map(async (meeting) => {
+      const {
+        id: meetingId,
+        disableAnonymity,
+        name: meetingName,
+        createdAt: meetingDate
+      } = meeting as MeetingRetrospective
+      const rawReflectionGroups = await dataLoader
+        .get('retroReflectionGroupsByMeetingId')
+        .load(meetingId)
+      const reflectionGroups = Promise.all(
+        rawReflectionGroups
+          .filter((g) => g.voterIds.length > 0)
+          .map(async (group) => {
+            const {id: reflectionGroupId, voterIds, title} = group
+            const [comments, rawReflections] = await Promise.all([
+              getComments(reflectionGroupId, dataLoader),
+              dataLoader.get('retroReflectionsByGroupId').load(group.id)
+            ])
+            const reflections = await Promise.all(
+              rawReflections.map(async (reflection) => {
+                const {promptId, creatorId, plaintextContent} = reflection
+                const [prompt, creator] = await Promise.all([
+                  dataLoader.get('reflectPrompts').load(promptId),
+                  creatorId ? dataLoader.get('users').loadNonNull(creatorId) : null
+                ])
+                const {question} = prompt
+                const creatorName =
+                  disableAnonymity && creator ? creator.preferredName : 'Anonymous'
+                return {
+                  prompt: question,
+                  author: creatorName,
+                  text: plaintextContent
+                }
+              })
+            )
+            const res = {
+              voteCount: voterIds.length,
+              title: title,
+              comments,
+              reflections,
+              meetingName,
+              date: meetingDate,
+              meetingId
+            }
+
+            if (!res.comments || !res.comments.length) {
+              delete (res as any).comments
+            }
+            return res
+          })
+      )
+      return reflectionGroups
+    })
+  )
+
+  const hotTopics = meetings
+    .flat()
+    .filter((t) => t.voteCount > 2)
+    .sort((a, b) => (a.voteCount > b.voteCount ? -1 : 1))
+
+  const idGenerator = {
+    meeting: 1
+  }
+
+  const shortTokenedTopics = hotTopics
+    .map((t) => {
+      const {date, meetingId} = t
+      const shortMeetingId = `m${idGenerator.meeting++}`
+      const shortMeetingDate = new Date(date).toISOString().split('T')[0]
+      meetingLookup[shortMeetingId] = meetingId
+      return {
+        ...t,
+        date: shortMeetingDate,
+        meetingId: shortMeetingId
+      }
+    })
+    .filter((t) => t)
+
+  if (shortTokenedTopics.length === 0) {
+    return standardError(new Error('No meeting content found for the specified date range.'))
+  }
+
+  const yamlData = yaml.dump(shortTokenedTopics, {
+    noCompatMode: true
+  })
+
+  const openAI = new OpenAIServerManager()
+  const rawInsight = await openAI.generateInsight(yamlData, false, prompt)
+  if (!rawInsight) {
+    return standardError(new Error('Unable to generate insight.'))
+  }
+
+  const wins = processSection(rawInsight.wins)
+  const challenges = processSection(rawInsight.challenges)
+  const meetingIds = rawMeetings.map((meeting) => meeting.id)
+
+  return {wins, challenges, meetingIds}
+}