feat: enhance robot alias management and search functionality

- Added methods to the RobotAliasManager for resolving robot IDs to canonical keys and searching by aliases.
- Updated FilterManager to include fallback search by robot aliases, improving dataset search capabilities.
- Added PROMPTS.md to .gitignore to prevent tracking of prompt files.

Author: RogersPyke

.gitignore

@@ -1 +1,2 @@
-/assets
+/assets
+PROMPTS.md

docs/js/modules/@filter/filter-manager.js

@@ -333,10 +333,24 @@ export class FilterManager {
             // Keyword search: match against dataset id/name and robot aliases / friendly names
             if (normalizedQuery) {
                 const texts = this.getSearchableTextsForDataset(ds);
-                const matchesSearch = texts.some(text =>
+                let matchesSearch = texts.some(text =>
                     typeof text === 'string' && text.toLowerCase().includes(normalizedQuery)
                 );
-
+                // Fallback: match by alias reverse lookup (e.g. "宇树" -> robot keys that have this alias)
+                if (!matchesSearch && this.robotAliasManager && typeof this.robotAliasManager.getRobotIdsByAlias === 'function') {
+                    const robotIdsByAlias = this.robotAliasManager.getRobotIdsByAlias(normalizedQuery);
+                    if (robotIdsByAlias.length > 0) {
+                        const dsRobots = Array.isArray(ds.robot) ? ds.robot : (ds.robot != null ? [ds.robot] : []);
+                        const aliasKeysLower = new Set(robotIdsByAlias.map(id => String(id).toLowerCase()));
+                        const getCanonical = typeof this.robotAliasManager.getCanonicalRobotKey === 'function'
+                            ? (r) => this.robotAliasManager.getCanonicalRobotKey(r)
+                            : (r) => (r != null ? String(r) : null);
+                        matchesSearch = dsRobots.some(r => {
+                            const canonical = getCanonical(r);
+                            return canonical != null && aliasKeysLower.has(canonical.toLowerCase());
+                        });
+                    }
+                }
                 if (!matchesSearch) {
                     return false;
                 }

docs/js/modules/robot-aliases.js

@@ -68,12 +68,18 @@ class RobotAliasManager {
 
     /**
      * Get raw alias entry for a robot ID.
+     * Tries exact key first, then case-insensitive match so that dataset robot_type
+     * (e.g. "G1EDU-U3") still resolves to the same entry as alias key "G1edu-u3".
      * @param {string} robotId
      * @returns {{ common_name?: string, aliases?: string[] } | null}
      */
     getAliasEntry(robotId) {
         if (!robotId) return null;
-        return this.aliasMap[robotId] || null;
+        const idStr = String(robotId);
+        if (this.aliasMap[idStr]) return this.aliasMap[idStr];
+        const idLower = idStr.toLowerCase();
+        const key = Object.keys(this.aliasMap).find(k => k.toLowerCase() === idLower);
+        return key ? this.aliasMap[key] : null;
     }
 
     /**
@@ -127,6 +133,50 @@ class RobotAliasManager {
     getAliasKeys() {
         return Object.keys(this.aliasMap);
     }
+
+    /**
+     * Resolve a robot id (may be alias or key) to the canonical key in alias map.
+     * Tries exact key, case-insensitive key, then any key whose common_name or aliases contain this id.
+     * @param {string} robotId
+     * @returns {string|null} Canonical key or null
+     */
+    getCanonicalRobotKey(robotId) {
+        if (!robotId) return null;
+        const idStr = String(robotId).trim();
+        if (this.aliasMap[idStr]) return idStr;
+        const idLower = idStr.toLowerCase();
+        const byKey = Object.keys(this.aliasMap).find(k => k.toLowerCase() === idLower);
+        if (byKey) return byKey;
+        for (const [key, entry] of Object.entries(this.aliasMap)) {
+            if (entry.common_name && String(entry.common_name).toLowerCase() === idLower) return key;
+            if (Array.isArray(entry.aliases) && entry.aliases.some(a => a && String(a).toLowerCase() === idLower)) return key;
+        }
+        return null;
+    }
+
+    /**
+     * Find robot map keys whose tokens (id, common_name, aliases) contain the query.
+     * Used for search: when user types e.g. "宇树", returns ["G1edu-u3"] so that
+     * datasets with robot "G1edu-u3" (or case variant) match even if getSearchTokensForRobot
+     * was not used (e.g. robot_type key mismatch or missing in data).
+     * @param {string} query - Search substring (will be compared case-insensitively for ASCII)
+     * @returns {string[]} Canonical robot keys from alias map that have query in their tokens
+     */
+    getRobotIdsByAlias(query) {
+        if (!query || typeof query !== 'string') return [];
+        const q = query.trim();
+        if (!q) return [];
+        const qLower = q.toLowerCase();
+        const result = [];
+        Object.keys(this.aliasMap).forEach(robotKey => {
+            const tokens = this.getSearchTokensForRobot(robotKey);
+            const hasMatch = tokens.some(t =>
+                typeof t === 'string' && t.toLowerCase().includes(qLower)
+            );
+            if (hasMatch) result.push(robotKey);
+        });
+        return result;
+    }
 }
 
 // Export singleton instance