Refactor: Remove Fuse.js dependency and enhance fuzzy search implementation

Author: ruturaj-browserstack

package-lock.json

@@ -39,7 +39,6 @@
     "browserstack-local": "^1.5.6",
     "dotenv": "^16.5.0",
     "form-data": "^4.0.2",
-    "fuse.js": "^7.1.0",
     "pino": "^9.6.0",
     "pino-pretty": "^13.0.0",
     "zod": "^3.24.3"

package.json

@@ -1,39 +1,64 @@
-/**
- * Creates a configured Fuse instance for token-based fuzzy search.
- * @param list Array of items to search
- * @param keys Keys in each item to index
- * @param options Optional Fuse.js options overrides
- */
-export async function createFuzzySearcher<T>(
-  list: T[],
-  keys: Array<keyof T | string>,
-  options?: any,
-): Promise<any> {
-  const { default: Fuse } = await import("fuse.js");
+// 1. Compute Levenshtein distance between two strings
+function levenshtein(a: string, b: string): number {
+  const dp: number[][] = Array(a.length + 1)
+    .fill(0)
+    .map(() => Array(b.length + 1).fill(0));
+  for (let i = 0; i <= a.length; i++) dp[i][0] = i;
+  for (let j = 0; j <= b.length; j++) dp[0][j] = j;
 
-  const defaultOptions = {
-    keys: keys as string[],
-    threshold: 0.6,
-    includeScore: true,
-    useExtendedSearch: false,
-    tokenize: true,
-    matchAllTokens: false,
-    ...options,
-  };
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1, // deletion
+        dp[i][j - 1] + 1, // insertion
+        dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1), // substitution
+      );
+    }
+  }
+  return dp[a.length][b.length];
+}
 
-  return new Fuse(list, defaultOptions);
+// 2. Score one item against the query (normalized score 0–1)
+function scoreItem<T>(
+  item: T,
+  keys: Array<keyof T | string>,
+  queryTokens: string[],
+): number {
+  let best = Infinity;
+  for (const key of keys) {
+    const field = String(item[key as keyof T] ?? "").toLowerCase();
+    const fieldTokens = field.split(/\s+/);
+    const tokenScores = queryTokens.map((qt) => {
+      const minNormalized = Math.min(
+        ...fieldTokens.map((ft) => {
+          const rawDist = levenshtein(ft, qt);
+          const maxLen = Math.max(ft.length, qt.length);
+          return maxLen === 0 ? 0 : rawDist / maxLen; // normalized 0–1
+        }),
+      );
+      return minNormalized;
+    });
+    const avg = tokenScores.reduce((a, b) => a + b, 0) / tokenScores.length;
+    best = Math.min(best, avg);
+  }
+  return best;
 }
 
-/**
- * Performs a fuzzy token search over any list, with dynamic keys and options.
- */
-export async function fuzzySearch<T>(
+// 3. The search entrypoint
+export function customFuzzySearch<T>(
   list: T[],
   keys: Array<keyof T | string>,
   query: string,
   limit: number = 5,
-  options?: any,
-): Promise<T[]> {
-  const fuse = await createFuzzySearcher(list, keys, options);
-  return fuse.search(query, { limit }).map((result: any) => result.item);
+  maxDistance: number = 0.6,
+): T[] {
+  const q = query.toLowerCase().trim();
+  const queryTokens = q.split(/\s+/);
+
+  return list
+    .map((item) => ({ item, score: scoreItem(item, keys, queryTokens) }))
+    .filter((x) => x.score <= maxDistance)
+    .sort((a, b) => a.score - b.score)
+    .slice(0, limit)
+    .map((x) => x.item);
 }

src/lib/fuzzy.ts

@@ -1,4 +1,4 @@
-import { fuzzySearch } from "../../lib/fuzzy";
+import { customFuzzySearch } from "../../lib/fuzzy";
 import { DeviceEntry } from "./start-session";
 
 /**
@@ -9,12 +9,11 @@ export async function fuzzySearchDevices(
   query: string,
   limit: number = 5,
 ): Promise<DeviceEntry[]> {
-  const top_match = await fuzzySearch(
+  const top_match = customFuzzySearch(
     devices,
     ["device", "display_name"],
     query,
     limit,
   );
-  console.error("[fuzzySearchDevices] Top match:", top_match);
   return top_match;
 }

src/tools/applive-utils/fuzzy-search.ts

@@ -50,9 +50,19 @@ export async function startSession(args: StartSessionArgs): Promise<string> {
 
     desiredPlatformVersion = requiredVersion;
   }
-  const filtered = allDevices.filter(
-    (d) => d.os === desiredPlatform && d.os_version === desiredPlatformVersion,
-  );
+  const filtered = allDevices.filter((d) => {
+    if (d.os !== desiredPlatform) return false;
+
+    // Attempt to compare as floats
+    try {
+      const versionA = parseFloat(d.os_version);
+      const versionB = parseFloat(desiredPlatformVersion);
+      return versionA === versionB;
+    } catch {
+      // Fallback to exact string match if parsing fails
+      return d.os_version === desiredPlatformVersion;
+    }
+  });
 
   // Fuzzy match
   const matches = await fuzzySearchDevices(filtered, desiredPhone);
@@ -70,9 +80,11 @@ export async function startSession(args: StartSessionArgs): Promise<string> {
     matches.splice(0, matches.length, exactMatch); // Replace matches with the exact match
   } else if (matches.length >= 1) {
     const names = matches.map((d) => d.display_name).join(", ");
-    throw new Error(
-      `Multiple/Alternative devices found: [${names}]. Select one out of them.`,
-    );
+    const error_message =
+      matches.length === 1
+        ? `Alternative device found: ${names}. Would you like to use it?`
+        : `Multiple devices found: ${names}. Please select one.`;
+    throw new Error(`${error_message}`);
   }
 
   const { app_url } = await uploadApp(appPath);