feat: implement hybrid similarity and originality scoring logic for project ranking

models/metadata.backup.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33a3d8e57a016cf66922cbd0c013090f6d11f59712c45dac488dfad056f330ab
+size 775966

models/metadata.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fa65da476454398a5d7b124e338e0e4bc2c8015258b73e09fa28cad448f9a420
-size 773665
+oid sha256:6765e155f8c73dc97d9f9d681291a1bba2a9d6c59c6712dd51a96e0cccce8058
+size 786476

src/similarity_model/hybrid_ranker.py

@@ -40,17 +40,25 @@ def get_dynamic_weights(
     """
     Adaptive weights depending on feature richness.
     Returns (semantic_w, feature_w, coverage_w) — always sum to 1.0
+
+    NOTE: When coverage==0 (DB project has no stored features),
+    always fall back to the high-semantic-weight path so that
+    a rich multi-feature query is not penalised vs a sparse one.
     """
 
-    
+    # No feature evidence at all — rely on semantic regardless of query richness
+    if coverage == 0:
+        return 0.70, 0.20, 0.10
+
+    # Rich features + high overlap → trust features heavily
     if feature_count >= 5 and coverage >= 0.60:
         return 0.40, 0.45, 0.15
 
-    
+    # Sparse query features
     if feature_count <= 2:
         return 0.70, 0.20, 0.10
 
-    
+    # Balanced
     return 0.55, 0.35, 0.10
 
 def compute_hybrid_score(
@@ -109,16 +117,22 @@ def compute_originality(
 ) -> float:
     """
     Originality Score (0-100).
-    Base score is (1 - hybrid_score) * 100.
-    Bonus of up to +10 points when the query has many features
-    that are unique vs the candidate (genuine differentiation signal).
+    Base: (1 - hybrid_score) * 100.
+
+    Uniqueness bonus (+up to 10 pts) is only applied when the DB project
+    actually has stored features (total_query_features > 0 AND there were
+    real feature matches to compare against). While DB features are empty,
+    unique_query_features == total_query_features always, making the bonus
+    a constant +10 noise term — so we skip it until the parquet is rebuilt.
     """
     hybrid_score = clamp(hybrid_score)
 
     originality = 100.0 * (1.0 - hybrid_score)
 
-    # Uniqueness bonus: reward projects whose features don't overlap
-    if total_query_features > 0:
+    # Only apply uniqueness bonus when feature comparison was meaningful
+    # (i.e. the candidate had stored features, so coverage > 0)
+    # Guarded by unique < total to avoid the always-1.0 ratio when DB is empty
+    if total_query_features > 0 and unique_query_features < total_query_features:
         uniqueness_ratio = unique_query_features / total_query_features
         originality = min(100.0, originality + (uniqueness_ratio * 10.0))