From 047d1b56fe327ecf973c1c624d30534429037548 Mon Sep 17 00:00:00 2001
From: slhafzjw <slhafzjw@slhaf.work>
Date: Mon, 18 May 2026 23:05:35 +0800
Subject: [PATCH] refactor(impression): add feature attribute as index, which
 will work with high-confidence impressions

---
 .../core/cognition/impression/Entity.kt       | 36 +++++++++++++++----
 1 file changed, 29 insertions(+), 7 deletions(-)

diff --git a/Partner-Core/src/main/java/work/slhaf/partner/core/cognition/impression/Entity.kt b/Partner-Core/src/main/java/work/slhaf/partner/core/cognition/impression/Entity.kt
index 833eb1cc..c652b406 100644
--- a/Partner-Core/src/main/java/work/slhaf/partner/core/cognition/impression/Entity.kt
+++ b/Partner-Core/src/main/java/work/slhaf/partner/core/cognition/impression/Entity.kt
@@ -8,11 +8,13 @@ import kotlin.concurrent.withLock
 class Entity @JvmOverloads constructor(
     val uuid: String = UUID.randomUUID().toString(),
     private val relations: MutableMap<String, MutableMap<String, Double>> = mutableMapOf(),
-    private val impressions: MutableMap<String, ImpressionData> = mutableMapOf()
+    private val impressions: MutableMap<String, IndexableData> = mutableMapOf(),
+    private val features: MutableMap<String, IndexableData> = mutableMapOf()
 ) {
 
     private val impressionLock = ReentrantLock()
     private val relationLock = ReentrantLock()
+    private val featureLock = ReentrantLock()
 
     @JvmOverloads
     fun updateRelation(
@@ -27,19 +29,39 @@ class Entity @JvmOverloads constructor(
     fun updateImpression(
         impression: String,
         newImpression: String? = null,
-        strength: Double = 1.0
-    ): ImpressionData = impressionLock.withLock {
+        confidence: Double = 1.0
+    ): IndexableData = impressionLock.withLock {
         if (newImpression == null) {
-            impressions.computeIfAbsent(impression) { ImpressionData(strength) }
-                .also { it.confidence = strength }
+            impressions.computeIfAbsent(impression) { IndexableData(confidence) }
+                .also { it.confidence = confidence }
         } else {
             impressions.remove(impression)
-            ImpressionData(strength).also {
+            IndexableData(confidence).also {
                 impressions[newImpression] = it
             }
+        }.also {
+            if (it.confidence >= 0.9) {
+                featureLock.withLock { features[impression] = it }
+            }
         }
     }
 
+    fun updateFeature(feature: String, newFeature: String? = null, confidence: Double = 1.0) = featureLock.withLock {
+        if (newFeature == null) {
+            features.computeIfAbsent(feature){ IndexableData(confidence) }
+                .also { it.confidence = confidence }
+        }else{
+            features.remove(feature)
+            IndexableData(confidence).also {
+                features[newFeature] = it
+            }
+        }
+    }
+
+    fun removeFeature(feature: String) = featureLock.withLock {
+        features.remove(feature)
+    }
+
     fun removeImpression(impression: String) = impressionLock.withLock {
         impressions.remove(impression)
     }
@@ -78,7 +100,7 @@ class Entity @JvmOverloads constructor(
         }.toSet()
     }
 
-    data class ImpressionData(
+    data class IndexableData(
         var confidence: Double
     ) {
         private val vectors: ConcurrentHashMap<String, DoubleArray> = ConcurrentHashMap()