improved ranking

Author: Xpitfire

interview_coder/PanelView.swift

@@ -786,7 +786,7 @@ private var headerBar: some View { DragHost { headerContent }.zIndex(2) }
                                                 Text(hit.fileURL.lastPathComponent).lineLimit(1)
                                             }
                                             Text(tail).font(.caption2).foregroundStyle(.secondary)
-                                            Text(hit.indexName + String(format: " • %.3f", hit.score)).font(.caption2).foregroundStyle(.secondary)
+                                            Text(hit.indexName + ((hit.score.isFinite && hit.score < 1_000_000) ? String(format: " • %.3f", hit.score) : " • exact")).font(.caption2).foregroundStyle(.secondary)
                                         }
                                         Spacer(minLength: 4)
                                         Button("Open") { NSWorkspace.shared.activateFileViewerSelecting([hit.fileURL]) }.buttonStyle(.plain)

interview_coder/VectorIndexing.swift

@@ -324,6 +324,18 @@ actor VecturaIndexService {
                     }
                 }
             }
+            // Inject exact filename matches (by name only) to ensure visibility
+            if !qExact.isEmpty {
+                let qLower = qExact.lowercased()
+                for entry in sidecar.files.values {
+                    let fname = URL(fileURLWithPath: entry.path).lastPathComponent.lowercased()
+                    if fname == qLower {
+                        let u = URL(fileURLWithPath: entry.path)
+                        // Inject exact match with a strong base score (normalized)
+                        hits.append(.init(id: name + ":exact:" + (entry.id), score: 1.0, text: "", fileURL: u, indexName: name))
+                    }
+                }
+            }
         }
         // Dedup by fileURL to avoid repeats across indices; sort by score desc
         var seen = Set<String>()
@@ -333,17 +345,92 @@ actor VecturaIndexService {
             seen.insert(k)
             return true
         }
-        // Rank exact filename matches first (case-insensitive), then keep score order within groups
-        let isExact: (IndexSearchHit) -> Bool = { h in
-            let name = h.fileURL.lastPathComponent
-            return !qExact.isEmpty && name.compare(qExact, options: [.caseInsensitive, .diacriticInsensitive]) == .orderedSame
+        // Rank by groups with fuzzy name similarity and embedding-first fallback:
+        // 0 exact == query; 1 fuzzy>=0.90; 2 prefix same-ext; 3 embedding-general; 4 fuzzy>=0.75; 5 prefix other-ext; 6 contains; 7 others
+        let nameOf: (IndexSearchHit) -> String = { $0.fileURL.lastPathComponent }
+        let lowerQ = qExact.lowercased()
+        let hasDot = lowerQ.contains(".")
+        let qExt = hasDot ? (lowerQ.split(separator: ".").last.map(String.init) ?? "") : ""
+
+        // Precompute name similarity
+        var simMap: [String: Double] = [:]
+        if !lowerQ.isEmpty {
+            for h in deduped { simMap[h.id] = nameSimilarity(nameOf(h).lowercased(), lowerQ) }
+        }
+
+        func groupRank(_ h: IndexSearchHit) -> Int {
+            let n = nameOf(h)
+            if !qExact.isEmpty && n.compare(qExact, options: [.caseInsensitive, .diacriticInsensitive]) == .orderedSame { return 0 }
+            let sim = simMap[h.id] ?? 0
+            if sim >= 0.90 { return 1 }
+            let nLower = n.lowercased()
+            if !lowerQ.isEmpty && nLower.hasPrefix(lowerQ) {
+                if hasDot && h.fileURL.pathExtension.lowercased() == qExt { return 2 }
+                // different extension prefix match handled later at rank 5
+            }
+            // Embedding-general (none of the name heuristics hit yet)
+            if sim < 0.75 && !( !lowerQ.isEmpty && nLower.contains(lowerQ) ) { return 3 }
+            if sim >= 0.75 { return 4 }
+            if !lowerQ.isEmpty && nLower.hasPrefix(lowerQ) { return 5 }
+            if !lowerQ.isEmpty && nLower.contains(lowerQ) { return 6 }
+            return 7
+        }
+
+        func clamp01(_ x: Double) -> Double { min(1.0, max(0.0, x)) }
+
+        func isExactName(_ h: IndexSearchHit) -> Bool {
+            guard !qExact.isEmpty else { return false }
+            return nameOf(h).compare(qExact, options: [.caseInsensitive, .diacriticInsensitive]) == .orderedSame
+        }
+
+        func combinedScore(_ h: IndexSearchHit) -> Double {
+            let base = clamp01(h.score)
+            let sim = simMap[h.id] ?? 0.0
+            let nLower = nameOf(h).lowercased()
+            let sameExtBonus: Double = (hasDot && h.fileURL.pathExtension.lowercased() == qExt && nLower.hasPrefix(lowerQ)) ? 0.12 : 0.0
+            let containsBonus: Double = (!lowerQ.isEmpty && nLower.contains(lowerQ)) ? 0.03 : 0.0
+            let exactBonus: Double = isExactName(h) ? 0.5 : 0.0
+            let highFuzzyBonus: Double = sim >= 0.90 ? (0.20 * (sim - 0.90) / 0.10) : 0.0
+            let medFuzzyBonus: Double = (sim >= 0.75 && sim < 0.90) ? (0.10 * (sim - 0.75) / 0.15) : 0.0
+            let combined = base + exactBonus + sameExtBonus + max(highFuzzyBonus, medFuzzyBonus) + containsBonus
+            return clamp01(combined)
+        }
+
+        let ranked = deduped.sorted { a, b in
+            // Exact always wins
+            let ea = isExactName(a), eb = isExactName(b)
+            if ea != eb { return ea }
+            let ca = combinedScore(a)
+            let cb = combinedScore(b)
+            if ca != cb { return ca > cb }
+            // Stable tie-breaker: higher base score, then path lexicographically
+            if a.score != b.score { return a.score > b.score }
+            return nameOf(a) < nameOf(b)
         }
-        let exact = deduped.filter(isExact)
-        let others = deduped.filter { !isExact($0) }
-        let ranked = exact + others
         return Array(ranked.prefix(limit))
     }
 
+    // Normalized name similarity in [0,1] via Levenshtein
+    private func nameSimilarity(_ a: String, _ b: String) -> Double {
+        if a == b { return 1.0 }
+        if a.isEmpty || b.isEmpty { return 0.0 }
+        let la = Array(a); let lb = Array(b)
+        let n = la.count; let m = lb.count
+        var prev = Array(0...m)
+        var cur = Array(repeating: 0, count: m + 1)
+        for i in 1...n {
+            cur[0] = i
+            for j in 1...m {
+                let cost = (la[i-1] == lb[j-1]) ? 0 : 1
+                cur[j] = min(prev[j] + 1, cur[j-1] + 1, prev[j-1] + cost)
+            }
+            swap(&prev, &cur)
+        }
+        let dist = prev[m]
+        let maxLen = max(n, m)
+        return max(0.0, 1.0 - Double(dist) / Double(maxLen))
+    }
+
     // MARK: - Paths
     private func baseDirectory() throws -> URL {
         let appSupport = try fm.url(for: .applicationSupportDirectory, in: .userDomainMask, appropriateFor: nil, create: true)