Fix Summarize and Generate Tags features (#120)

jsonify · claude · web-flow · commit 6e81ee4cfd74 · 2025-11-16T20:53:32.000-08:00
* feat: add global AI model selection for all AI features

Add unified AI model preference that applies to all AI-powered features:
- Template generation
- Tag generation
- Note summarization
- Semantic search

Changes:
- Add noted.ai.preferredModel configuration setting
- Update aiModelService to check global config first, with fallback to templates.preferredModel for backwards compatibility
- Refactor TagGenerator, SummarizationService, and SemanticSearchEngine to use centralized selectAIModel()
- Update "Select AI Model" command to set global preference
- Add getAvailableModels() and formatModelForDisplay() helper functions
- Remove hardcoded model selections (vendor: 'copilot', family: 'gpt-4o')

Users can now choose their preferred LLM once for all AI features via:
- Command: "Noted: Select AI Model"
- Config: noted.ai.preferredModel
- Priority: Claude Sonnet → Opus → GPT-4 → Gemini → any available

Resolves user request for unified LLM model control across all AI features.

* refactor: improve AI model selection organization

Code review improvements:
- Move handleSelectAIModel from templateCommands.ts to new aiCommands.ts
  - Better organization since this command now affects all AI features, not just templates
- Simplify formatModelForDisplay return type
  - Remove redundant id property (detail already contains model.id)
  - Caller uses model.id directly from original object
- Update import in extension.ts to reflect new location

No functional changes, purely organizational improvements.

* docs: update Select AI Model tooltip to reflect global scope

Update tooltip in Templates &amp; Recent &gt; Manage section to clarify that
Select AI Model now affects all AI features, not just templates.

Old: "Choose which AI model to use for template generation"
New: "Choose AI model for all features (templates, tagging, summarization, search)"

This aligns the UI description with the recent changes that unified
AI model selection across all features.

---------

Co-authored-by: Claude &lt;noreply@anthropic.com&gt;
diff --git a/package.json b/package.json
@@ -1212,6 +1212,11 @@
           "default": true,
           "description": "Enable AI-powered summarization features"
         },
+        "noted.ai.preferredModel": {
+          "type": "string",
+          "default": "",
+          "description": "Preferred AI model ID for all AI features (tagging, summarization, search, templates). Empty = automatic selection. Use 'Noted: Select AI Model' command to choose from available models."
+        },
         "noted.ai.summaryLength": {
           "type": "string",
           "enum": [
diff --git a/src/commands/aiCommands.ts b/src/commands/aiCommands.ts
@@ -0,0 +1,78 @@
+import * as vscode from 'vscode';
+import { getAvailableModels, formatModelForDisplay } from '../services/aiModelService';
+
+/**
+ * Command: Select preferred AI model for all AI features
+ * Sets the global AI model preference used by templates, tagging, summarization, and search
+ */
+export async function handleSelectAIModel(): Promise<void> {
+    try {
+        // Get all available models
+        const models = await getAvailableModels();
+
+        if (models.length === 0) {
+            vscode.window.showErrorMessage(
+                'No AI models available. Please install GitHub Copilot, Claude, or another LLM extension.'
+            );
+            return;
+        }
+
+        // Get current preference (check both global and template-specific for backwards compatibility)
+        const config = vscode.workspace.getConfiguration('noted');
+        const currentModelId = config.get<string>('ai.preferredModel') || config.get<string>('templates.preferredModel') || '';
+
+        // Build quick pick items
+        interface ModelQuickPickItem extends vscode.QuickPickItem {
+            modelId: string;
+        }
+
+        const items: ModelQuickPickItem[] = models.map(model => {
+            const formatted = formatModelForDisplay(model);
+            const isSelected = model.id === currentModelId;
+            const icon = isSelected ? '$(check)' : '$(circle-outline)';
+
+            return {
+                modelId: model.id,
+                label: `${icon} ${formatted.label}`,
+                description: formatted.description,
+                detail: formatted.detail,
+                picked: isSelected
+            };
+        });
+
+        // Add "Automatic" option at the top
+        items.unshift({
+            modelId: '',
+            label: `${currentModelId === '' ? '$(check)' : '$(circle-outline)'} Automatic (Recommended)`,
+            description: 'Smart selection based on availability',
+            detail: 'Priority: Claude Sonnet → Opus → GPT-4 → Gemini',
+            picked: currentModelId === ''
+        });
+
+        // Show picker
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: 'Select AI model for all AI features (templates, tagging, summarization, search)',
+            title: 'AI Model Selection',
+            matchOnDescription: true,
+            matchOnDetail: true
+        });
+
+        if (!selected) {
+            return;
+        }
+
+        // Save preference to global config
+        await config.update('ai.preferredModel', selected.modelId, vscode.ConfigurationTarget.Global);
+
+        const modelName = selected.modelId === '' ? 'Automatic selection' : selected.label.replace(/\$\(.*?\)\s/, '');
+        vscode.window.showInformationMessage(
+            `AI model set to: ${modelName}\n\nThis will be used for templates, tagging, summarization, and search.`
+        );
+    } catch (error) {
+        if (error instanceof Error) {
+            vscode.window.showErrorMessage(`Failed to select AI model: ${error.message}`);
+        } else {
+            vscode.window.showErrorMessage('Failed to select AI model: Unknown error');
+        }
+    }
+}
diff --git a/src/commands/templateCommands.ts b/src/commands/templateCommands.ts
@@ -431,78 +431,6 @@ async function openTemplate(templateId: string): Promise<void> {
     }
 }
 
-/**
- * Command: Select preferred AI model for template generation
- */
-export async function handleSelectAIModel(): Promise<void> {
-    try {
-        // Get all available models
-        const models = await templateGenerator.getAvailableModels();
-
-        if (models.length === 0) {
-            vscode.window.showErrorMessage(
-                'No AI models available. Please install GitHub Copilot, Claude, or another LLM extension.'
-            );
-            return;
-        }
-
-        // Get current preference
-        const config = vscode.workspace.getConfiguration('noted');
-        const currentModelId = config.get<string>('templates.preferredModel');
-
-        // Build quick pick items
-        interface ModelQuickPickItem extends vscode.QuickPickItem {
-            modelId: string;
-        }
-
-        const items: ModelQuickPickItem[] = models.map(model => {
-            const isSelected = model.id === currentModelId;
-            const icon = isSelected ? '$(check)' : '$(circle-outline)';
-
-            return {
-                modelId: model.id,
-                label: `${icon} ${model.name}`,
-                description: `${model.vendor}`,
-                detail: model.description,
-                picked: isSelected
-            };
-        });
-
-        // Add "Automatic" option at the top
-        items.unshift({
-            modelId: '',
-            label: `${currentModelId === '' ? '$(check)' : '$(circle-outline)'} Automatic (Recommended)`,
-            description: 'Smart selection based on availability',
-            detail: 'Uses Claude > GPT > Gemini > any available model',
-            picked: currentModelId === ''
-        });
-
-        // Show picker
-        const selected = await vscode.window.showQuickPick(items, {
-            placeHolder: 'Select AI model for template generation',
-            title: 'AI Model Selection',
-            matchOnDescription: true,
-            matchOnDetail: true
-        });
-
-        if (!selected) {
-            return;
-        }
-
-        // Save preference
-        await config.update('templates.preferredModel', selected.modelId, vscode.ConfigurationTarget.Global);
-
-        const modelName = selected.modelId === '' ? 'Automatic selection' : selected.label.replace(/\$\(.*?\)\s/, '');
-        vscode.window.showInformationMessage(`AI model set to: ${modelName}`);
-    } catch (error) {
-        if (error instanceof Error) {
-            vscode.window.showErrorMessage(`Failed to select AI model: ${error.message}`);
-        } else {
-            vscode.window.showErrorMessage('Failed to select AI model: Unknown error');
-        }
-    }
-}
-
 /**
  * Command: Migrate legacy templates to JSON format
  */
diff --git a/src/extension.ts b/src/extension.ts
@@ -77,10 +77,12 @@ import { SummarizationCommands } from './commands/summarizationCommands';
 import {
     handleSuggestTags
 } from './commands/autoTagCommands';
+import {
+    handleSelectAIModel
+} from './commands/aiCommands';
 import {
     handleCreateTemplateWithAI,
     handleEnhanceTemplate,
-    handleSelectAIModel,
     handleMigrateTemplates,
     handleCreateUserStoryWithAI
 } from './commands/templateCommands';
diff --git a/src/providers/templatesTreeProvider.ts b/src/providers/templatesTreeProvider.ts
@@ -187,7 +187,7 @@ export class TemplatesTreeProvider implements vscode.TreeDataProvider<TreeItem>
                 '⚙️ Select AI Model',
                 'noted.selectAIModel',
                 'settings-gear',
-                'Choose which AI model to use for template generation'
+                'Choose AI model for all features (templates, tagging, summarization, search)'
             ),
             new ActionButtonItem(
                 'Template Variables',
diff --git a/src/search/SemanticSearchEngine.ts b/src/search/SemanticSearchEngine.ts
@@ -7,6 +7,7 @@ import * as vscode from 'vscode';
 import * as path from 'path';
 import { SmartSearchResult, MatchInfo, SemanticSearchConfig } from './types';
 import { readFile, getFileStats } from '../services/fileSystemService';
+import { selectAIModel } from '../services/aiModelService';
 
 export class SemanticSearchEngine {
     private config: SemanticSearchConfig;
@@ -21,15 +22,12 @@ export class SemanticSearchEngine {
     }
 
     /**
-     * Check if Copilot/LLM is available
+     * Check if LLM is available
      */
     async isAvailable(): Promise<boolean> {
         try {
-            const models = await vscode.lm.selectChatModels({
-                vendor: 'copilot',
-                family: 'gpt-4o',
-            });
-            return models.length > 0;
+            await selectAIModel();
+            return true;
         } catch (error) {
             return false;
         }
@@ -51,16 +49,7 @@ export class SemanticSearchEngine {
         }
 
         // Select model once at the beginning
-        const models = await vscode.lm.selectChatModels({
-            vendor: 'copilot',
-            family: 'gpt-4o',
-        });
-
-        if (models.length === 0) {
-            throw new Error('Copilot LLM is not available. Please sign in to GitHub Copilot.');
-        }
-
-        const model = models[0];
+        const model = await selectAIModel();
         const results: SmartSearchResult[] = [];
         const maxResults = options.maxResults || this.config.maxCandidates;
         const filesToProcess = noteFiles.slice(0, maxResults);
diff --git a/src/services/aiModelService.ts b/src/services/aiModelService.ts
@@ -6,15 +6,19 @@ import * as vscode from 'vscode';
  *
  * This is a shared utility used by:
  * - Template generation (TemplateGenerator)
- * - User story creation (templateCommands)
+ * - Tag generation (TagGenerator)
+ * - Summarization (SummarizationService)
+ * - Semantic search (SemanticSearchEngine)
  * - Any other AI-powered features
  *
  * @returns Selected language model
  * @throws Error if no models are available
  */
 export async function selectAIModel(): Promise<vscode.LanguageModelChat> {
     const config = vscode.workspace.getConfiguration('noted');
-    const preferredModelId = config.get<string>('templates.preferredModel');
+
+    // Check global AI model preference first, then fall back to template-specific (backwards compatibility)
+    const preferredModelId = config.get<string>('ai.preferredModel') || config.get<string>('templates.preferredModel');
 
     // Get all available models
     const allModels = await vscode.lm.selectChatModels({});
@@ -96,3 +100,30 @@ export async function selectAIModel(): Promise<vscode.LanguageModelChat> {
     // Last resort: Return first available model
     return allModels[0];
 }
+
+/**
+ * Get all available AI models with metadata
+ * Used by the model selection command
+ *
+ * @returns Array of available models with vendor, family, and ID info
+ */
+export async function getAvailableModels(): Promise<vscode.LanguageModelChat[]> {
+    return await vscode.lm.selectChatModels({});
+}
+
+/**
+ * Format a model for display in quick pick
+ * @param model - Language model to format
+ * @returns Object with label, description, and detail for quick pick
+ */
+export function formatModelForDisplay(model: vscode.LanguageModelChat): {
+    label: string;
+    description: string;
+    detail: string;
+} {
+    return {
+        label: model.name || model.id,
+        description: `${model.vendor} - ${model.family}`,
+        detail: model.id
+    };
+}
diff --git a/src/services/summarizationService.ts b/src/services/summarizationService.ts
@@ -3,6 +3,7 @@ import { readFile } from './fileSystemService';
 import * as crypto from 'crypto';
 import { PromptTemplate } from './promptTemplateService';
 import { SummaryHistoryService } from './summaryHistoryService';
+import { selectAIModel } from './aiModelService';
 
 /**
  * Options for note summarization
@@ -62,12 +63,12 @@ export class SummarizationService {
     }
 
     /**
-     * Check if Language Model API is available (Copilot)
+     * Check if Language Model API is available
      */
     private async isLanguageModelAvailable(): Promise<boolean> {
         try {
-            const models = await vscode.lm.selectChatModels({ vendor: 'copilot' });
-            return models && models.length > 0;
+            await selectAIModel();
+            return true;
         } catch (error) {
             return false;
         }
@@ -333,12 +334,7 @@ Summary requirements:
 
         // Call Language Model API
         try {
-            const models = await vscode.lm.selectChatModels({ vendor: 'copilot' });
-            if (!models || models.length === 0) {
-                throw new Error('No Copilot models available');
-            }
-
-            const model = models[0];
+            const model = await selectAIModel();
             const messages = [vscode.LanguageModelChatMessage.User(prompt)];
 
             const response = await model.sendRequest(messages, {}, new vscode.CancellationTokenSource().token);
@@ -454,12 +450,7 @@ ${note.content}
 
         // Call Language Model API
         try {
-            const models = await vscode.lm.selectChatModels({ vendor: 'copilot' });
-            if (!models || models.length === 0) {
-                throw new Error('No Copilot models available');
-            }
-
-            const model = models[0];
+            const model = await selectAIModel();
             const messages = [vscode.LanguageModelChatMessage.User(prompt)];
 
             const response = await model.sendRequest(messages, {}, new vscode.CancellationTokenSource().token);
diff --git a/src/tagging/TagGenerator.ts b/src/tagging/TagGenerator.ts
@@ -1,6 +1,7 @@
 import * as vscode from 'vscode';
 import { NoteTag } from './TagParser';
 import * as crypto from 'crypto';
+import { selectAIModel } from '../services/aiModelService';
 
 /**
  * Cache entry for tag generation results
@@ -54,18 +55,8 @@ export class TagGenerator {
                 return [];
             }
 
-            // Select a language model
-            const models = await vscode.lm.selectChatModels({
-                vendor: 'copilot',
-                family: 'gpt-4o'
-            });
-
-            if (models.length === 0) {
-                // No model available
-                throw new Error('GitHub Copilot is not available. Please sign in to use auto-tagging.');
-            }
-
-            const model = models[0];
+            // Select the appropriate language model using shared service
+            const model = await selectAIModel();
 
             // Build the prompt
             const prompt = this.buildTagPrompt(content, maxTags);
