fix(engine): strip tracking params from the links results point to (#32)

UrlNormalizer stripped utm_*/fbclid/etc. but only for the dedup key; the
aggregator stored the raw upstream URL, so the link a user clicks still carried
trackers. Add UrlNormalizer.stripTracking (lossless apart from the tracker
params: keeps scheme/host case, path, trailing slash, fragment, param order)
and surface it as the result URL. Covers the in-app results and the served
web page.

Co-authored-by: FlintWave <flintwave@tuta.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 3 people

app/src/main/java/org/searchmob/engine/aggregate/Aggregator.kt

@@ -91,7 +91,9 @@ class Aggregator(
                 buckets[key] =
                     MutableBucket(
                         title = item.title,
-                        url = item.url,
+                        // Surface a tracker-stripped URL so the clicked link drops utm_*/fbclid/etc;
+                        // `key` above is still the lossy normalized form used only for dedup.
+                        url = UrlNormalizer.stripTracking(item.url),
                         snippet = item.snippet,
                         engines = linkedSetOf(item.engineId),
                         score = contribution,

app/src/main/java/org/searchmob/engine/aggregate/UrlNormalizer.kt

@@ -3,14 +3,45 @@ package org.searchmob.engine.aggregate
 import java.net.URI
 
 /**
- * Normalizes a URL for dedup: lowercase scheme/host, drop a leading `www.`, strip a trailing slash,
- * and remove common tracking query parameters (`utm_*`, `fbclid`, `gclid`, ...). Remaining query
- * params are sorted so equivalent URLs collapse deterministically.
+ * URL helpers for the aggregator. [normalize] builds a lossy dedup key (lowercase scheme/host, drop
+ * a leading `www.`, strip a trailing slash, remove tracking params, sort the rest). [stripTracking]
+ * removes the same tracking params but otherwise keeps the URL faithful, for the link shown/clicked.
  */
 object UrlNormalizer {
     private val trackingPrefixes = listOf("utm_")
     private val trackingKeys = setOf("fbclid", "gclid", "gclsrc", "dclid", "msclkid", "mc_eid", "igshid", "ref")
 
+    private fun isTracking(param: String): Boolean {
+        val key = param.substringBefore("=").lowercase()
+        return trackingKeys.contains(key) || trackingPrefixes.any { key.startsWith(it) }
+    }
+
+    /**
+     * Returns [rawUrl] with known tracking params removed, preserving everything else for display:
+     * scheme/host case, path, trailing slash, fragment, and the order of the surviving params. This
+     * is the link the user actually clicks, so unlike [normalize] (a lossy dedup key) it is kept
+     * faithful apart from the trackers. Falls back to the trimmed input if it does not parse.
+     */
+    fun stripTracking(rawUrl: String): String {
+        val trimmed = rawUrl.trim()
+        return try {
+            val uri = URI(trimmed)
+            val query = uri.rawQuery ?: return trimmed
+            val kept =
+                query
+                    .split("&")
+                    .filter { it.isNotBlank() }
+                    .filterNot { isTracking(it) }
+            buildString {
+                append(trimmed.substringBefore("?"))
+                if (kept.isNotEmpty()) append("?").append(kept.joinToString("&"))
+                uri.rawFragment?.let { append("#").append(it) }
+            }
+        } catch (_: Exception) {
+            trimmed
+        }
+    }
+
     fun normalize(rawUrl: String): String {
         val trimmed = rawUrl.trim()
         return try {
@@ -23,10 +54,7 @@ object UrlNormalizer {
                 uri.query
                     ?.split("&")
                     ?.filter { it.isNotBlank() }
-                    ?.filterNot { param ->
-                        val key = param.substringBefore("=").lowercase()
-                        trackingKeys.contains(key) || trackingPrefixes.any { key.startsWith(it) }
-                    }
+                    ?.filterNot { isTracking(it) }
                     ?.sorted()
                     ?.joinToString("&")
                     ?.takeIf { it.isNotEmpty() }

app/src/test/java/org/searchmob/engine/UrlNormalizerTest.kt

@@ -28,4 +28,31 @@ class UrlNormalizerTest {
             UrlNormalizer.normalize("http://www.example.com/x/"),
         )
     }
+
+    @Test
+    fun stripTrackingRemovesTrackersButKeepsTheRestForDisplay() {
+        // Host case, www, trailing slash, fragment, and the surviving param order are all kept.
+        assertEquals(
+            "https://WWW.Example.com/Some/Path/?id=42&q=hi#frag",
+            UrlNormalizer.stripTracking(
+                "https://WWW.Example.com/Some/Path/?id=42&utm_source=n&q=hi&fbclid=a#frag",
+            ),
+        )
+    }
+
+    @Test
+    fun stripTrackingDropsQueryWhenOnlyTrackers() {
+        assertEquals(
+            "https://example.com/p",
+            UrlNormalizer.stripTracking("https://example.com/p?utm_campaign=x&gclid=y"),
+        )
+    }
+
+    @Test
+    fun stripTrackingLeavesCleanUrlsUntouched() {
+        assertEquals(
+            "https://example.com/p/?id=1",
+            UrlNormalizer.stripTracking("https://example.com/p/?id=1"),
+        )
+    }
 }