fix: improve UX for activate/deactivate all actions

Author: mohamedsedkiyouzbechi

CHANGELOG.md

@@ -7,11 +7,16 @@ All notable changes to the "promptitude" extension will be documented in this fi
 ### Changed
 
 - Renamed "chatmodes" to "agents" throughout the UI to align with VS Code's current terminology
+- Improved "Activate All" and "Deactivate All" operations to show progress notifications with individual prompt status.
 
 ### Fixed
 
 - Fixed UI bugs including Windows path handling, activate/deactivate button behavior, and cross-platform compatibility issues
 - Fixed prompt details view not opening for inactive prompts on Windows by correctly resolving repository storage paths
+- Fixed "Activate All" to properly create symlinks for all prompts instead of just updating state.
+- Fixed "Deactivate All" to efficiently remove all symlinks directly instead of looping through individual toggles, eliminating unnecessary counting behavior.
+- Fixed issue where prompts that were active before "Activate All" would be in a broken state after "Deactivate All".
+- Fixed prompt details view not refreshing when "Deactivate All" is clicked while viewing an active prompt.
 
 ## [1.5.0] - 2025-11-12
 

src/syncManager.ts

@@ -1079,13 +1079,13 @@ export class SyncManager {
 
         try {
             const repoPath = this.getRepositoryPath(repositoryUrl);
-            this.logger.debug(`Repository storage path: ${repoPath}`);
+            this.logger.info(`Repository storage path: ${repoPath}`);
 
             const sourcePath = this.fileSystem.joinPath(repoPath, promptPath);
-            this.logger.debug(`Source file path: ${sourcePath}`);
+            this.logger.info(`Source file path: ${sourcePath}`);
 
             const sourceExists = await this.fileSystem.fileExists(sourcePath);
-            this.logger.debug(`Source file exists: ${sourceExists}`);
+            this.logger.info(`Source file exists: ${sourceExists}`);
 
             if (!sourceExists) {
                 const errorMsg = `Source file does not exist: ${sourcePath}`;
@@ -1095,12 +1095,13 @@ export class SyncManager {
 
             // Generate unique workspace name if there are conflicts
             const workspaceName = await this.getUniqueWorkspaceName(promptPath, repositoryUrl);
-            this.logger.debug(`Workspace name: ${workspaceName}`);
+            this.logger.info(`Workspace name: ${workspaceName}`);
 
             // Create target path directly in User/prompts/ (no subdirectories)
             const promptsDir = this.config.getPromptsDirectory();
+            this.logger.info(`Prompts directory: ${promptsDir}`);
             const targetPath = this.fileSystem.joinPath(promptsDir, workspaceName);
-            this.logger.debug(`Target path: ${targetPath}`);
+            this.logger.info(`Target path: ${targetPath}`);
 
             await this.createPromptSymlink(sourcePath, targetPath);
             this.logger.info(`✅ Successfully activated prompt: ${promptPath} as ${workspaceName}`);

src/ui/promptCommands.ts

@@ -192,12 +192,75 @@ export class PromptCommandManager {
         }
     }
 
-    private selectAll(): void {
+    private async selectAll(): Promise<void> {
         try {
-            this.treeProvider.selectAll();
-            const count = this.treeProvider.getSelectedPrompts().length;
-            vscode.window.showInformationMessage(`Activated ${count} prompts`);
-            this.logger.debug(`Activated all prompts (${count} total)`);
+            if (!this.syncManager) {
+                vscode.window.showErrorMessage('SyncManager not available');
+                return;
+            }
+
+            // Get all prompts that are currently inactive
+            const allPrompts = this.treeProvider.getAllPrompts();
+            const inactivePrompts = allPrompts.filter(p => !p.active);
+
+            if (inactivePrompts.length === 0) {
+                vscode.window.showInformationMessage('All prompts are already activated');
+                return;
+            }
+
+            // Use withProgress for proper loading indicator
+            await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Notification,
+                title: `Activating ${inactivePrompts.length} prompts`,
+                cancellable: false
+            }, async (progress) => {
+                if (!this.syncManager) {
+                    throw new Error('SyncManager not available');
+                }
+
+                // Activate all inactive prompts by creating symlinks
+                let successCount = 0;
+                const errors: string[] = [];
+
+                for (let i = 0; i < inactivePrompts.length; i++) {
+                    const prompt = inactivePrompts[i];
+                    progress.report({ 
+                        increment: (100 / inactivePrompts.length),
+                        message: `${i + 1}/${inactivePrompts.length}: ${prompt.name}`
+                    });
+
+                    try {
+                        if (!prompt.repositoryUrl) {
+                            errors.push(`${prompt.name}: No repository URL`);
+                            continue;
+                        }
+
+                        const workspaceName = await this.syncManager.activatePrompt(prompt.name, prompt.repositoryUrl);
+                        prompt.workspaceName = workspaceName;
+                        prompt.active = true;
+                        successCount++;
+
+                        // Update details view if this prompt is currently being viewed
+                        this.webviewProvider.updateSelectionStatus(prompt);
+                    } catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        errors.push(`${prompt.name}: ${errorMsg}`);
+                        this.logger.warn(`Failed to activate ${prompt.name}: ${errorMsg}`);
+                    }
+                }
+
+                this.treeProvider.refresh();
+
+                if (successCount === inactivePrompts.length) {
+                    vscode.window.showInformationMessage(`✅ Activated all ${successCount} prompts`);
+                } else if (successCount > 0) {
+                    vscode.window.showWarningMessage(`⚠️ Activated ${successCount}/${inactivePrompts.length} prompts. ${errors.length} failed.`);
+                } else {
+                    vscode.window.showErrorMessage(`❌ Failed to activate prompts: ${errors.join(', ')}`);
+                }
+
+                this.logger.debug(`Activated ${successCount}/${inactivePrompts.length} prompts`);
+            });
         } catch (error) {
             this.logger.error(`Failed to activate all prompts: ${error}`);
             vscode.window.showErrorMessage(`Failed to activate all prompts: ${error}`);
@@ -206,16 +269,67 @@ export class PromptCommandManager {
 
     private async deselectAll(): Promise<void> {
         try {
-            // Get all currently selected prompts before deselecting
-            const selected = [...this.treeProvider.getSelectedPrompts()];
+            if (!this.syncManager) {
+                vscode.window.showErrorMessage('SyncManager not available');
+                return;
+            }
+
+            // Get all currently selected prompts
+            const activePrompts = this.treeProvider.getSelectedPrompts();
 
-            // Deactivate each prompt using toggleSelection to ensure symlinks are removed
-            for (const prompt of selected) {
-                await this.toggleSelection(prompt);
+            if (activePrompts.length === 0) {
+                vscode.window.showInformationMessage('No prompts are currently activated');
+                return;
             }
 
-            vscode.window.showInformationMessage('All prompts deactivated');
-            this.logger.debug('Deactivated all prompts');
+            // Use withProgress for proper loading indicator
+            await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Notification,
+                title: `Deactivating ${activePrompts.length} prompts`,
+                cancellable: false
+            }, async (progress) => {
+                if (!this.syncManager) {
+                    throw new Error('SyncManager not available');
+                }
+
+                // Deactivate all prompts efficiently by removing symlinks directly
+                let successCount = 0;
+                const errors: string[] = [];
+
+                for (let i = 0; i < activePrompts.length; i++) {
+                    const prompt = activePrompts[i];
+                    progress.report({ 
+                        increment: (100 / activePrompts.length),
+                        message: `${i + 1}/${activePrompts.length}: ${prompt.name}`
+                    });
+
+                    try {
+                        const nameToDeactivate = prompt.workspaceName || prompt.name;
+                        await this.syncManager.deactivatePrompt(nameToDeactivate);
+                        prompt.active = false;
+                        successCount++;
+
+                        // Update details view if this prompt is currently being viewed
+                        this.webviewProvider.updateSelectionStatus(prompt);
+                    } catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        errors.push(`${prompt.name}: ${errorMsg}`);
+                        this.logger.warn(`Failed to deactivate ${prompt.name}: ${errorMsg}`);
+                    }
+                }
+
+                this.treeProvider.refresh();
+
+                if (successCount === activePrompts.length) {
+                    vscode.window.showInformationMessage(`✅ Deactivated all ${successCount} prompts`);
+                } else if (successCount > 0) {
+                    vscode.window.showWarningMessage(`⚠️ Deactivated ${successCount}/${activePrompts.length} prompts. ${errors.length} failed.`);
+                } else {
+                    vscode.window.showErrorMessage(`❌ Failed to deactivate prompts: ${errors.join(', ')}`);
+                }
+
+                this.logger.debug(`Deactivated ${successCount}/${activePrompts.length} prompts`);
+            });
         } catch (error) {
             this.logger.error(`Failed to deactivate all prompts: ${error}`);
             vscode.window.showErrorMessage(`Failed to deactivate all prompts: ${error}`);