Revert "implement jaccard distance"

This reverts commit 1b0718e.

Author: nickoferrall

packages/client/utils/smartGroup/computeJaccardDistanceMatrix.ts

@@ -1,5 +1,11 @@
-import {computeJaccardDistanceMatrix} from './computeJaccardDistanceMatrix'
+import computeDistanceMatrix from './computeDistanceMatrix'
+import getAllLemmasFromReflections from './getAllLemmasFromReflections'
 import getGroupMatrix from './getGroupMatrix'
+import getTitleFromComputedGroup from './getTitleFromComputedGroup'
+
+/*
+ * Read each reflection, parse the content for entities (i.e. nouns), group the reflections based on common themes
+ */
 
 type Entity = {
   lemma: string
@@ -21,70 +27,79 @@ export type GroupingOptions = {
   maxReductionPercent?: number
 }
 
-function groupReflections<
-  T extends {id: string; reflectionGroupId: string; plaintextContent: string}
->(reflections: T[], groupingOptions: GroupingOptions) {
-  const reflectionTexts = reflections.map((r) => r.plaintextContent || '')
-
-  const distanceMatrix = computeJaccardDistanceMatrix(reflectionTexts)
+const groupReflections = <
+  T extends {entities: any[]; reflectionGroupId: string; id: string; plaintextContent: string}
+>(
+  reflections: T[],
+  groupingOptions: GroupingOptions
+) => {
+  const allReflectionEntities = reflections.map(({entities}) => entities)
+  const oldReflectionGroupIds = reflections.map(({reflectionGroupId}) => reflectionGroupId)
 
+  // create a unique array of all entity names mentioned in the meeting's reflect phase
+  const uniqueLemmaArr = getAllLemmasFromReflections(allReflectionEntities)
+  // create a distance vector for each reflection
+  const distanceMatrix = computeDistanceMatrix(allReflectionEntities, uniqueLemmaArr)
   const {
     groups: groupedArrays,
     thresh,
     nextThresh
   } = getGroupMatrix(distanceMatrix, groupingOptions)
-
-  const updatedReflections: Array<{
-    reflectionId: string
-    oldReflectionGroupId: string
-    sortOrder: number
-    reflectionGroupId: string
-  }> = []
-
-  const reflectionGroupMapping: Record<string, string> = {}
-  const oldReflectionGroupIds = reflections.map((r) => r.reflectionGroupId)
-
+  // replace the arrays with reflections
+  const updatedReflections = [] as GroupedReflectionRes[]
+  const reflectionGroupMapping = {} as Record<string, string>
   const updatedGroups = groupedArrays.map((group) => {
+    // look up the reflection by its vector, put them all in the same group
     let reflectionGroupId = ''
-
     const groupedReflectionsRes = group.map((reflectionDistanceArr, sortOrder) => {
       const idx = distanceMatrix.indexOf(reflectionDistanceArr)
       const reflection = reflections[idx]!
       reflectionGroupId = reflectionGroupId || reflection.reflectionGroupId
       return {
         reflectionId: reflection.id,
+        entities: reflection.entities,
         oldReflectionGroupId: reflection.reflectionGroupId,
         sortOrder,
         reflectionGroupId
-      }
+      } as GroupedReflectionRes
     })
 
+    const groupedReflectionEntities = groupedReflectionsRes
+      .map(({entities}) => entities)
+      .filter(Boolean)
+    const smartTitle = getTitleFromComputedGroup(
+      uniqueLemmaArr,
+      group,
+      groupedReflectionEntities,
+      reflections
+    )
+
     updatedReflections.push(...groupedReflectionsRes)
-    groupedReflectionsRes.forEach(({oldReflectionGroupId}) => {
-      reflectionGroupMapping[oldReflectionGroupId] = reflectionGroupId
+
+    groupedReflectionsRes.forEach((groupedReflection) => {
+      reflectionGroupMapping[groupedReflection.oldReflectionGroupId] = reflectionGroupId
     })
 
     return {
       id: reflectionGroupId,
-      smartTitle: '',
-      title: ''
+      smartTitle,
+      title: smartTitle
     }
   })
 
   const newReflectionGroupIds = new Set(
     updatedReflections.map(({reflectionGroupId}) => reflectionGroupId)
   )
   const removedReflectionGroupIds = oldReflectionGroupIds.filter(
-    (oldId) => !newReflectionGroupIds.has(oldId)
+    (groupId) => !newReflectionGroupIds.has(groupId)
   )
-
   return {
     autoGroupThreshold: thresh,
     groups: updatedGroups,
     groupedReflectionsRes: updatedReflections,
     reflectionGroupMapping,
     removedReflectionGroupIds,
-    nextThresh
+    nextThresh: nextThresh as number
   }
 }