feat: ensure global rules always appear in search results regardless of minScore or tag filters

dist/rules/indexer.js

@@ -33,16 +33,40 @@ export class RuleIndexer {
     search(query, options = {}) {
         const { openFiles = [], changedFiles = [], tags = [], limit = 6, minScore = 0.15 } = options;
         const results = this.cachedRules.map(rule => this.scorer.scoreRule(rule, query, openFiles, changedFiles, tags));
-        // Sort by score desc
-        const sorted = results
-            .filter(r => r.score >= minScore)
-            .sort((a, b) => b.score - a.score);
+        // Separate global rules from others
+        const globalResults = [];
+        const regularResults = [];
+        results.forEach(r => {
+            const isGlobalRule = r.rule.tags.includes('global') ||
+                r.rule.tags.includes('base') ||
+                r.rule.id.includes('base') ||
+                r.rule.relativePath === 'base.md';
+            if (isGlobalRule) {
+                globalResults.push(r);
+            }
+            else if (r.score >= minScore) {
+                regularResults.push(r);
+            }
+        });
+        // Sort both groups by score desc
+        globalResults.sort((a, b) => b.score - a.score);
+        regularResults.sort((a, b) => b.score - a.score);
         // Diversification and Deduplication logic
         const diversified = [];
         const categoryCounts = {};
         const seenIds = new Set();
-        for (const res of sorted) {
-            // Deduplicate by ID
+        // Always include global rules first (with reduced limit if needed)
+        for (const res of globalResults) {
+            if (seenIds.has(res.rule.id))
+                continue;
+            diversified.push(res);
+            seenIds.add(res.rule.id);
+            // Don't count global rules against category limits
+            if (diversified.length >= limit)
+                break;
+        }
+        // Then add regular rules with diversification
+        for (const res of regularResults) {
             if (seenIds.has(res.rule.id))
                 continue;
             // Determine category from relative path (first dir)

src/rules/indexer.ts

@@ -54,18 +54,45 @@ export class RuleIndexer {
             this.scorer.scoreRule(rule, query, openFiles, changedFiles, tags)
         );
 
-        // Sort by score desc
-        const sorted = results
-            .filter(r => r.score >= minScore)
-            .sort((a, b) => b.score - a.score);
+        // Separate global rules from others
+        const globalResults: SearchResult[] = [];
+        const regularResults: SearchResult[] = [];
+
+        results.forEach(r => {
+            const isGlobalRule = r.rule.tags.includes('global') || 
+                                r.rule.tags.includes('base') || 
+                                r.rule.id.includes('base') ||
+                                r.rule.relativePath === 'base.md';
+            
+            if (isGlobalRule) {
+                globalResults.push(r);
+            } else if (r.score >= minScore) {
+                regularResults.push(r);
+            }
+        });
+
+        // Sort both groups by score desc
+        globalResults.sort((a, b) => b.score - a.score);
+        regularResults.sort((a, b) => b.score - a.score);
 
         // Diversification and Deduplication logic
         const diversified: SearchResult[] = [];
         const categoryCounts: { [cat: string]: number } = {};
         const seenIds = new Set<string>();
 
-        for (const res of sorted) {
-            // Deduplicate by ID
+        // Always include global rules first (with reduced limit if needed)
+        for (const res of globalResults) {
+            if (seenIds.has(res.rule.id)) continue;
+            
+            diversified.push(res);
+            seenIds.add(res.rule.id);
+            
+            // Don't count global rules against category limits
+            if (diversified.length >= limit) break;
+        }
+
+        // Then add regular rules with diversification
+        for (const res of regularResults) {
             if (seenIds.has(res.rule.id)) continue;
 
             // Determine category from relative path (first dir)