Add create action items context menu feature (#131)

jsonify · web-flow · commit 7eedf4e18cae · 2025-12-11T09:44:51.000-08:00
* Add action items extraction context menu feature

- Add ActionItemsService for AI-powered action item extraction using VS Code LLM API
- Add ActionItemsCommands with two format options: checkboxes and bullets
- Create submenu "Create Action Items" in Noted editor context menu
- Insert extracted action items below selection with "## Action Items" header
- Show "No action items identified" when AI finds no actionable content

* Fix action items extraction to not insert when no items found

- Add NO_ACTION_ITEMS_MESSAGE constant for consistent string comparison
- Add MAX_INPUT_CHARACTERS constant to replace magic number
- Return early without inserting when no action items identified
- Use constants in prompt and truncation logic
diff --git a/package.json b/package.json
@@ -686,6 +686,16 @@
         "title": "Summarize Selection",
         "icon": "$(sparkle)"
       },
+      {
+        "command": "noted.extractActionItemsCheckboxes",
+        "title": "As Checkboxes",
+        "icon": "$(checklist)"
+      },
+      {
+        "command": "noted.extractActionItemsBullets",
+        "title": "As Bullet Points",
+        "icon": "$(list-unordered)"
+      },
       {
         "command": "noted.batchGenerateTags",
         "title": "Noted: Batch Generate Tags",
@@ -802,6 +812,10 @@
       {
         "id": "noted.editorContext",
         "label": "Noted"
+      },
+      {
+        "id": "noted.actionItemsMenu",
+        "label": "Create Action Items"
       }
     ],
     "menus": {
@@ -816,15 +830,30 @@
           "when": "editorHasSelection",
           "group": "2_ai@1"
         },
+        {
+          "submenu": "noted.actionItemsMenu",
+          "when": "editorHasSelection",
+          "group": "2_ai@2"
+        },
         {
           "command": "noted.summarizeCurrentNote",
           "when": "resourcePath =~ /Notes.*\\.(txt|md)$/",
-          "group": "2_ai@2"
+          "group": "2_ai@3"
         },
         {
           "command": "noted.generateTagsCurrentNote",
           "when": "resourcePath =~ /Notes.*\\.(txt|md)$/",
-          "group": "2_ai@3"
+          "group": "2_ai@4"
+        }
+      ],
+      "noted.actionItemsMenu": [
+        {
+          "command": "noted.extractActionItemsCheckboxes",
+          "group": "1_format@1"
+        },
+        {
+          "command": "noted.extractActionItemsBullets",
+          "group": "1_format@2"
         }
       ],
       "editor/context": [
diff --git a/src/commands/actionItemsCommands.ts b/src/commands/actionItemsCommands.ts
@@ -0,0 +1,99 @@
+/**
+ * Action Items extraction command handlers
+ * All commands are designed to be registered in extension.ts
+ */
+
+import * as vscode from 'vscode';
+import { ActionItemsService, ActionItemFormat } from '../services/actionItemsService';
+
+/**
+ * Class-based command handlers for Action Items extraction
+ */
+export class ActionItemsCommands {
+    constructor(
+        private actionItemsService: ActionItemsService
+    ) {}
+
+    /**
+     * Handle extracting action items from selection with checkboxes format
+     */
+    public async handleExtractActionItemsCheckboxes(): Promise<void> {
+        await this.extractActionItemsFromSelection('checkboxes');
+    }
+
+    /**
+     * Handle extracting action items from selection with bullets format
+     */
+    public async handleExtractActionItemsBullets(): Promise<void> {
+        await this.extractActionItemsFromSelection('bullets');
+    }
+
+    /**
+     * Common implementation for extracting action items from selection
+     */
+    private async extractActionItemsFromSelection(format: ActionItemFormat): Promise<void> {
+        const editor = vscode.window.activeTextEditor;
+        if (!editor) {
+            vscode.window.showErrorMessage('No editor is currently open');
+            return;
+        }
+
+        const selection = editor.selection;
+        if (selection.isEmpty) {
+            vscode.window.showErrorMessage('No text is selected. Please select some text to extract action items from.');
+            return;
+        }
+
+        const selectedText = editor.document.getText(selection);
+        if (!selectedText.trim()) {
+            vscode.window.showErrorMessage('Selected text is empty or contains only whitespace');
+            return;
+        }
+
+        try {
+            await vscode.window.withProgress(
+                {
+                    location: vscode.ProgressLocation.Notification,
+                    title: 'Extracting action items...',
+                    cancellable: true
+                },
+                async (progress, token) => {
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+
+                    const actionItems = await this.actionItemsService.extractActionItems(
+                        selectedText,
+                        format,
+                        token
+                    );
+
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+
+                    // Check if no action items were found
+                    if (actionItems === ActionItemsService.NO_ACTION_ITEMS_MESSAGE) {
+                        vscode.window.showInformationMessage('No action items were identified in the selected text');
+                        return;
+                    }
+
+                    // Insert action items at the end of the line containing the selection's end point
+                    const endLine = editor.document.lineAt(selection.end.line);
+                    const insertPosition = endLine.range.end;
+
+                    // Format the action items with header (extra blank line before header)
+                    const actionItemsText = `\n\n## Action Items\n\n${actionItems}\n`;
+
+                    await editor.edit(editBuilder => {
+                        editBuilder.insert(insertPosition, actionItemsText);
+                    });
+
+                    vscode.window.showInformationMessage('Action items inserted below selection');
+                }
+            );
+        } catch (error) {
+            vscode.window.showErrorMessage(`Failed to extract action items: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
diff --git a/src/extension.ts b/src/extension.ts
@@ -75,6 +75,8 @@ import {
     handleClearUndoHistory
 } from './commands/undoCommands';
 import { SummarizationCommands } from './commands/summarizationCommands';
+import { ActionItemsService } from './services/actionItemsService';
+import { ActionItemsCommands } from './commands/actionItemsCommands';
 import {
     handleSuggestTags
 } from './commands/autoTagCommands';
@@ -539,6 +541,10 @@ export function activate(context: vscode.ExtensionContext) {
     // Initialize summarization command handlers
     const summarizationCommands = new SummarizationCommands(summarizationService, context, notesProvider);
 
+    // Initialize action items service and commands
+    const actionItemsService = new ActionItemsService();
+    const actionItemsCommands = new ActionItemsCommands(actionItemsService);
+
     // Initialize auto-tagging service (Phase 4)
     const autoTagService = new AutoTagService();
 
@@ -2085,6 +2091,14 @@ export function activate(context: vscode.ExtensionContext) {
         await summarizationCommands.handleSummarizeSelection();
     });
 
+    let extractActionItemsCheckboxes = vscode.commands.registerCommand('noted.extractActionItemsCheckboxes', async () => {
+        await actionItemsCommands.handleExtractActionItemsCheckboxes();
+    });
+
+    let extractActionItemsBullets = vscode.commands.registerCommand('noted.extractActionItemsBullets', async () => {
+        await actionItemsCommands.handleExtractActionItemsBullets();
+    });
+
     let summarizeRecent = vscode.commands.registerCommand('noted.summarizeRecent', async () => {
         await summarizationCommands.handleSummarizeRecent();
     });
@@ -2230,7 +2244,7 @@ export function activate(context: vscode.ExtensionContext) {
         showPreview, showMarkdownToolbar,
         undoCommand, redoCommand, showUndoHistory, clearUndoHistory,
         renameSymbol,
-        summarizeNote, summarizeCurrentNote, summarizeSelection, summarizeRecent, summarizeWeek, summarizeMonth, summarizeCustomRange, clearSummaryCache, summarizeSearchResults,
+        summarizeNote, summarizeCurrentNote, summarizeSelection, extractActionItemsCheckboxes, extractActionItemsBullets, summarizeRecent, summarizeWeek, summarizeMonth, summarizeCustomRange, clearSummaryCache, summarizeSearchResults,
         showSummaryHistory, compareSummaries, restoreSummaryVersion, clearSummaryHistory, showSummaryHistoryStats,
         createPromptTemplate, editPromptTemplate, deletePromptTemplate, duplicatePromptTemplate, listPromptTemplates, viewTemplateVariables,
         suggestTags,
diff --git a/src/services/actionItemsService.ts b/src/services/actionItemsService.ts
@@ -0,0 +1,118 @@
+/**
+ * AI-powered action items extraction service using VS Code Language Model API
+ * Extracts actionable items from selected text using GitHub Copilot
+ */
+
+import * as vscode from 'vscode';
+import { selectAIModel } from './aiModelService';
+
+/**
+ * Format options for action items
+ */
+export type ActionItemFormat = 'checkboxes' | 'bullets';
+
+/**
+ * Service for extracting action items from text using AI
+ */
+export class ActionItemsService {
+    /** Message returned when no action items are found */
+    public static readonly NO_ACTION_ITEMS_MESSAGE = 'No action items identified';
+
+    /** Maximum characters to send to the AI model */
+    private static readonly MAX_INPUT_CHARACTERS = 16000;
+
+    /**
+     * Check if Language Model API is available
+     */
+    private async isLanguageModelAvailable(): Promise<boolean> {
+        try {
+            await selectAIModel();
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    /**
+     * Check if AI features are enabled
+     */
+    private isAIEnabled(): boolean {
+        const config = vscode.workspace.getConfiguration('noted.ai');
+        return config.get<boolean>('enabled', true);
+    }
+
+    /**
+     * Build prompt for action item extraction
+     */
+    private buildActionItemsPrompt(selectedText: string, format: ActionItemFormat): string {
+        const formatInstruction = format === 'checkboxes'
+            ? 'Use checkbox format: - [ ] Action item description'
+            : 'Use bullet point format: - Action item description';
+
+        return `Analyze the following text and extract any actionable items, tasks, or to-dos.
+
+Text to analyze:
+---
+${selectedText}
+---
+
+Instructions:
+- Extract clear, specific action items from the text
+- ${formatInstruction}
+- Include any mentioned deadlines, assignees, or priorities in parentheses
+- Group related items together if applicable
+- If no clear action items can be identified, respond with exactly: "${ActionItemsService.NO_ACTION_ITEMS_MESSAGE}"
+- Do not include any preamble or explanation, only the action items list
+
+Action items:`;
+    }
+
+    /**
+     * Extract action items from selected text
+     * @param selectedText The text to analyze for action items
+     * @param format The format for action items (checkboxes or bullets)
+     * @param token Cancellation token
+     * @returns Extracted action items or "No action items identified"
+     */
+    async extractActionItems(
+        selectedText: string,
+        format: ActionItemFormat,
+        token: vscode.CancellationToken
+    ): Promise<string> {
+        // Check if AI is enabled
+        if (!this.isAIEnabled()) {
+            throw new Error('AI features are disabled. Enable them in settings: noted.ai.enabled');
+        }
+
+        // Check if Language Model API is available
+        if (!(await this.isLanguageModelAvailable())) {
+            throw new Error('GitHub Copilot is not available. Please install and enable GitHub Copilot to use AI features.');
+        }
+
+        // Truncate if too large
+        const truncatedText = selectedText.length > ActionItemsService.MAX_INPUT_CHARACTERS
+            ? selectedText.substring(0, ActionItemsService.MAX_INPUT_CHARACTERS) + '\n\n[Text truncated for analysis]'
+            : selectedText;
+
+        // Build prompt
+        const prompt = this.buildActionItemsPrompt(truncatedText, format);
+
+        // Call Language Model API
+        try {
+            const model = await selectAIModel();
+            const messages = [vscode.LanguageModelChatMessage.User(prompt)];
+
+            const response = await model.sendRequest(messages, {}, token);
+
+            let result = '';
+            for await (const chunk of response.text) {
+                result += chunk;
+            }
+
+            return result.trim();
+
+        } catch (error) {
+            throw new Error(`Failed to extract action items: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
