# Task ID: 45

**Title:** Implement tag-matching algorithm for prompt selection

**Status:** done

**Dependencies:** 44 ✓

**Priority:** high

**Description:** Create a deterministic keyword-based tag matching algorithm as the no-LLM fallback for prompt selection, with byte-budget allocation and priority weighting.

**Details:**

1. Create `/src/mcplocal/src/services/tag-matcher.service.ts`:
   ```typescript
   interface MatchedPrompt {
     prompt: PromptIndex;
     score: number;
     matchedTags: string[];
   }
   
   export class TagMatcherService {
     constructor(private byteBudget: number = 8192) {}
     
     matchPrompts(tags: string[], promptIndex: PromptIndex[]): {
       fullContent: PromptIndex[];    // Prompts to include in full
       indexOnly: PromptIndex[];      // Prompts to include as index entries
       remaining: PromptIndex[];      // Non-matched prompts (names only)
     } {
       // 1. Priority 10 prompts: always included (score = Infinity)
       // 2. For each prompt, compute score:
       //    - Check tags against summary + chapters (case-insensitive substring)
       //    - score = matching_tags_count * priority
       // 3. Sort by score descending
       // 4. Fill byte budget from top:
       //    - Include full content until budget exhausted
       //    - Remaining matched: include as index entries
       //    - Non-matched: names only
     }
     
     private computeScore(tags: string[], prompt: PromptIndex): number {
       if (prompt.priority === 10) return Infinity;
       const matchingTags = tags.filter(tag => 
         this.matchesPrompt(tag.toLowerCase(), prompt)
       );
       return matchingTags.length * prompt.priority;
     }
     
     private matchesPrompt(tag: string, prompt: PromptIndex): boolean {
       const searchText = [
         prompt.summary || '',
         ...(prompt.chapters || [])
       ].join(' ').toLowerCase();
       return searchText.includes(tag);
     }
   }
   ```

2. Handle edge cases: empty tags, no prompts, all priority 10, etc.

**Test Strategy:**

- Unit test: Priority 10 prompts always included regardless of tags
- Unit test: Score calculation: matching_tags * priority
- Unit test: Case-insensitive matching
- Unit test: Substring matching in summary and chapters
- Unit test: Byte budget exhaustion stops full content inclusion
- Unit test: Matched prompts beyond budget become index entries
- Unit test: Non-matched prompts listed as names only
- Unit test: Sorting by score descending
- Unit test: Empty tags returns priority 10 only
- Unit test: No prompts returns empty result