# Task ID: 46

**Title:** Implement LLM-based prompt selection service

**Status:** done

**Dependencies:** 45 ✓

**Priority:** high

**Description:** Create a service that uses the heavy LLM to intelligently select relevant prompts based on tags and the full prompt index, understanding synonyms and context.

**Details:**

1. Create `/src/mcplocal/src/services/llm-prompt-selector.service.ts`:
   ```typescript
   export class LlmPromptSelectorService {
     constructor(
       private llmClient: LlmClient,
       private fastLlmClient: LlmClient | null,
       private tagMatcher: TagMatcherService  // fallback
     ) {}
     
     async selectPrompts(tags: string[], promptIndex: PromptIndex[]): Promise<{
       selected: Array<{ name: string; reason: string }>;
       priority10: PromptIndex[];  // Always included
     }> {
       // 1. Extract priority 10 prompts (always included)
       // 2. Generate missing summaries using fast LLM if needed
       // 3. Send to heavy LLM:
       const prompt = `
         Given these keywords: ${tags.join(', ')}
         And this prompt index:
         ${promptIndex.map(p => `- ${p.name}: ${p.summary}`).join('\n')}
         
         Select the most relevant prompts for someone working on tasks
         related to these keywords. Consider synonyms and related concepts.
         Return a ranked JSON array: [{name: string, reason: string}]
       `;
       // 4. Parse LLM response
       // 5. On LLM error, fall back to tag matcher
     }
   }
   ```

2. Handle LLM timeouts and errors gracefully with fallback

3. Validate LLM response format

**Test Strategy:**

- Unit test: Priority 10 prompts always returned regardless of LLM selection
- Unit test: LLM called with correct prompt format (mock)
- Unit test: LLM response parsed correctly
- Unit test: Invalid LLM response falls back to tag matcher
- Unit test: LLM timeout falls back to tag matcher
- Unit test: Missing summaries trigger fast LLM generation
- Unit test: No LLM available uses tag matcher directly
- Integration test: End-to-end selection with mock LLM