initial temporary state manager

karthiknadig · karthiknadig · commit b4748ccdf2fa · 2025-11-28T09:26:40.000-08:00
diff --git a/package.json b/package.json
@@ -272,12 +272,24 @@
                 "category": "Python Envs",
                 "icon": "$(copy)"
             },
+            {
+                "command": "python-envs.copyEnvPathCopied",
+                "title": "%python-envs.copyEnvPathCopied.title%",
+                "category": "Python Envs",
+                "icon": "$(check)"
+            },
             {
                 "command": "python-envs.copyProjectPath",
                 "title": "%python-envs.copyProjectPath.title%",
                 "category": "Python Envs",
                 "icon": "$(copy)"
             },
+            {
+                "command": "python-envs.copyProjectPathCopied",
+                "title": "%python-envs.copyProjectPathCopied.title%",
+                "category": "Python Envs",
+                "icon": "$(check)"
+            },
             {
                 "command": "python-envs.terminal.revertStartupScriptChanges",
                 "title": "%python-envs.terminal.revertStartupScriptChanges.title%",
@@ -381,10 +393,18 @@
                     "command": "python-envs.copyEnvPath",
                     "when": "false"
                 },
+                {
+                    "command": "python-envs.copyEnvPathCopied",
+                    "when": "false"
+                },
                 {
                     "command": "python-envs.copyProjectPath",
                     "when": "false"
                 },
+                {
+                    "command": "python-envs.copyProjectPathCopied",
+                    "when": "false"
+                },
                 {
                     "command": "python-envs.createAny",
                     "when": "false"
@@ -438,7 +458,12 @@
                 {
                     "command": "python-envs.copyEnvPath",
                     "group": "inline",
-                    "when": "view == env-managers && viewItem =~ /.*pythonEnvironment.*/"
+                    "when": "view == env-managers && viewItem =~ /.*pythonEnvironment.*/ && viewItem =~ /^((?!copied).)*$/"
+                },
+                {
+                    "command": "python-envs.copyEnvPathCopied",
+                    "group": "inline",
+                    "when": "view == env-managers && viewItem =~ /.*pythonEnvironment.*/ && viewItem =~ /.*copied.*/"
                 },
                 {
                     "command": "python-envs.uninstallPackage",
@@ -448,7 +473,12 @@
                 {
                     "command": "python-envs.copyEnvPath",
                     "group": "inline",
-                    "when": "view == python-projects && viewItem == python-env"
+                    "when": "view == python-projects && viewItem =~ /python-env/ && viewItem =~ /^((?!copied).)*$/"
+                },
+                {
+                    "command": "python-envs.copyEnvPathCopied",
+                    "group": "inline",
+                    "when": "view == python-projects && viewItem =~ /python-env/ && viewItem =~ /.*copied.*/"
                 },
                 {
                     "command": "python-envs.remove",
@@ -471,7 +501,12 @@
                 {
                     "command": "python-envs.copyProjectPath",
                     "group": "inline",
-                    "when": "view == python-projects && viewItem =~ /.*python-workspace.*/"
+                    "when": "view == python-projects && viewItem =~ /.*python-workspace.*/ && viewItem =~ /^((?!copied).)*$/"
+                },
+                {
+                    "command": "python-envs.copyProjectPathCopied",
+                    "group": "inline",
+                    "when": "view == python-projects && viewItem =~ /.*python-workspace.*/ && viewItem =~ /.*copied.*/"
                 },
                 {
                     "command": "python-envs.revealProjectInExplorer",
diff --git a/package.nls.json b/package.nls.json
@@ -21,7 +21,9 @@
     "python-envs.addPythonProjectGivenResource.title": "Add as Python Project",
     "python-envs.removePythonProject.title": "Remove Python Project",
     "python-envs.copyEnvPath.title": "Copy Environment Path",
+    "python-envs.copyEnvPathCopied.title": "Copied!",
     "python-envs.copyProjectPath.title": "Copy Project Path",
+    "python-envs.copyProjectPathCopied.title": "Copied!",
     "python-envs.create.title": "Create Environment",
     "python-envs.createAny.title": "Create Environment",
     "python-envs.set.title": "Set Project Environment",
diff --git a/src/extension.ts b/src/extension.ts
@@ -65,6 +65,7 @@ import { EnvManagerView } from './features/views/envManagersView';
 import { ProjectView } from './features/views/projectView';
 import { PythonStatusBarImpl } from './features/views/pythonStatusBar';
 import { updateViewsAndStatus } from './features/views/revealHandler';
+import { TemporaryStateManager } from './features/views/temporaryStateManager';
 import { ProjectItem } from './features/views/treeViewItems';
 import {
     collectEnvironmentInfo,
@@ -146,10 +147,14 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
     setPythonApi(envManagers, projectManager, projectCreators, terminalManager, envVarManager);
     const api = await getPythonApi();
     const sysPythonManager = createDeferred<SysPythonManager>();
-    const managerView = new EnvManagerView(envManagers);
+
+    const temporaryStateManager = new TemporaryStateManager();
+    context.subscriptions.push(temporaryStateManager);
+
+    const managerView = new EnvManagerView(envManagers, temporaryStateManager);
     context.subscriptions.push(managerView);
 
-    const workspaceView = new ProjectView(envManagers, projectManager);
+    const workspaceView = new ProjectView(envManagers, projectManager, temporaryStateManager);
     context.subscriptions.push(workspaceView);
     workspaceView.initialize();
 
@@ -283,9 +288,21 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
         }),
         commands.registerCommand('python-envs.copyEnvPath', async (item) => {
             await copyPathToClipboard(item);
+            if (item?.environment?.envId) {
+                temporaryStateManager.setState(item.environment.envId.id, 'copied');
+            }
+        }),
+        commands.registerCommand('python-envs.copyEnvPathCopied', () => {
+            // No-op: provides the checkmark icon
         }),
         commands.registerCommand('python-envs.copyProjectPath', async (item) => {
             await copyPathToClipboard(item);
+            if (item?.project?.uri) {
+                temporaryStateManager.setState(item.project.uri.fsPath, 'copied');
+            }
+        }),
+        commands.registerCommand('python-envs.copyProjectPathCopied', () => {
+            // No-op: provides the checkmark icon
         }),
         commands.registerCommand('python-envs.revealProjectInExplorer', async (item) => {
             await revealProjectInExplorer(item);
diff --git a/src/features/views/envManagersView.ts b/src/features/views/envManagersView.ts
@@ -1,5 +1,7 @@
 import { Disposable, Event, EventEmitter, ProviderResult, TreeDataProvider, TreeItem, TreeView, window } from 'vscode';
 import { DidChangeEnvironmentEventArgs, EnvironmentGroupInfo, PythonEnvironment } from '../../api';
+import { ProjectViews } from '../../common/localize';
+import { createSimpleDebounce } from '../../common/utils/debounce';
 import {
     DidChangeEnvironmentManagerEventArgs,
     DidChangePackageManagerEventArgs,
@@ -9,18 +11,19 @@ import {
     InternalEnvironmentManager,
     InternalPackageManager,
 } from '../../internal.api';
+import { TemporaryStateManager } from './temporaryStateManager';
 import {
-    EnvTreeItem,
+    EnvInfoTreeItem,
     EnvManagerTreeItem,
-    PythonEnvTreeItem,
-    PackageTreeItem,
+    EnvTreeItem,
     EnvTreeItemKind,
     NoPythonEnvTreeItem,
-    EnvInfoTreeItem,
+    PackageTreeItem,
+    PythonEnvTreeItem,
     PythonGroupEnvTreeItem,
 } from './treeViewItems';
-import { createSimpleDebounce } from '../../common/utils/debounce';
-import { ProjectViews } from '../../common/localize';
+
+const COPIED_STATE = 'copied';
 
 export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable {
     private treeView: TreeView<EnvTreeItem>;
@@ -32,7 +35,7 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
     private selected: Map<string, string> = new Map();
     private disposables: Disposable[] = [];
 
-    public constructor(public providers: EnvironmentManagers) {
+    public constructor(public providers: EnvironmentManagers, private stateManager: TemporaryStateManager) {
         this.treeView = window.createTreeView<EnvTreeItem>('env-managers', {
             treeDataProvider: this,
         });
@@ -59,6 +62,15 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
                 this.onDidChangePackageManager(p);
             }),
         );
+
+        this.disposables.push(
+            this.stateManager.onDidChangeState(({ itemId }) => {
+                const view = this.revealMap.get(itemId);
+                if (view) {
+                    this.fireDataChanged(view);
+                }
+            }),
+        );
     }
 
     dispose() {
@@ -77,6 +89,17 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
     onDidChangeTreeData: Event<void | EnvTreeItem | EnvTreeItem[] | null | undefined> = this.treeDataChanged.event;
 
     getTreeItem(element: EnvTreeItem): TreeItem | Thenable<TreeItem> {
+        if (element.kind === EnvTreeItemKind.environment && element instanceof PythonEnvTreeItem) {
+            const itemId = element.environment.envId.id;
+            const currentContext = element.treeItem.contextValue ?? '';
+            if (this.stateManager?.hasState(itemId, COPIED_STATE)) {
+                if (!currentContext.includes(COPIED_STATE)) {
+                    element.treeItem.contextValue = currentContext + COPIED_STATE + ';';
+                }
+            } else if (currentContext.includes(COPIED_STATE)) {
+                element.treeItem.contextValue = currentContext.replace(COPIED_STATE + ';', '');
+            }
+        }
         return element.treeItem;
     }
 
@@ -202,7 +225,7 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
 
     private onDidChangePackages(args: InternalDidChangePackagesEventArgs) {
         const view = Array.from(this.revealMap.values()).find(
-            (v) => v.environment.envId.id === args.environment.envId.id
+            (v) => v.environment.envId.id === args.environment.envId.id,
         );
         if (view) {
             this.fireDataChanged(view);
diff --git a/src/features/views/projectView.ts b/src/features/views/projectView.ts
@@ -14,6 +14,7 @@ import { ProjectViews } from '../../common/localize';
 import { createSimpleDebounce } from '../../common/utils/debounce';
 import { onDidChangeConfiguration } from '../../common/workspace.apis';
 import { EnvironmentManagers, PythonProjectManager } from '../../internal.api';
+import { TemporaryStateManager } from './temporaryStateManager';
 import {
     GlobalProjectItem,
     NoProjectEnvironment,
@@ -25,6 +26,8 @@ import {
     ProjectTreeItemKind,
 } from './treeViewItems';
 
+const COPIED_STATE = 'copied';
+
 export class ProjectView implements TreeDataProvider<ProjectTreeItem> {
     private treeView: TreeView<ProjectTreeItem>;
     private _treeDataChanged: EventEmitter<ProjectTreeItem | ProjectTreeItem[] | null | undefined> = new EventEmitter<
@@ -35,7 +38,11 @@ export class ProjectView implements TreeDataProvider<ProjectTreeItem> {
     private packageRoots: Map<string, ProjectEnvironment> = new Map();
     private disposables: Disposable[] = [];
     private debouncedUpdateProject = createSimpleDebounce(500, () => this.updateProject());
-    public constructor(private envManagers: EnvironmentManagers, private projectManager: PythonProjectManager) {
+    public constructor(
+        private envManagers: EnvironmentManagers,
+        private projectManager: PythonProjectManager,
+        private stateManager: TemporaryStateManager,
+    ) {
         this.treeView = window.createTreeView<ProjectTreeItem>('python-projects', {
             treeDataProvider: this,
         });
@@ -69,6 +76,20 @@ export class ProjectView implements TreeDataProvider<ProjectTreeItem> {
                 }
             }),
         );
+
+        this.disposables.push(
+            this.stateManager.onDidChangeState(({ itemId }) => {
+                const projectView = this.projectViews.get(itemId);
+                if (projectView) {
+                    this._treeDataChanged.fire(projectView);
+                    return;
+                }
+                const envView = Array.from(this.revealMap.values()).find((v) => v.environment.envId.id === itemId);
+                if (envView) {
+                    this._treeDataChanged.fire(envView);
+                }
+            }),
+        );
     }
 
     initialize(): void {
@@ -121,6 +142,27 @@ export class ProjectView implements TreeDataProvider<ProjectTreeItem> {
         this._treeDataChanged.event;
 
     getTreeItem(element: ProjectTreeItem): TreeItem | Thenable<TreeItem> {
+        if (element.kind === ProjectTreeItemKind.project && element instanceof ProjectItem) {
+            const itemId = element.project.uri.fsPath;
+            const currentContext = element.treeItem.contextValue ?? '';
+            if (this.stateManager?.hasState(itemId, COPIED_STATE)) {
+                if (!currentContext.includes(COPIED_STATE)) {
+                    element.treeItem.contextValue = currentContext + ';' + COPIED_STATE;
+                }
+            } else if (currentContext.includes(COPIED_STATE)) {
+                element.treeItem.contextValue = currentContext.replace(';' + COPIED_STATE, '');
+            }
+        } else if (element.kind === ProjectTreeItemKind.environment && element instanceof ProjectEnvironment) {
+            const itemId = element.environment.envId.id;
+            const currentContext = element.treeItem.contextValue ?? '';
+            if (this.stateManager?.hasState(itemId, COPIED_STATE)) {
+                if (!currentContext.includes(COPIED_STATE)) {
+                    element.treeItem.contextValue = currentContext + ';' + COPIED_STATE;
+                }
+            } else if (currentContext.includes(COPIED_STATE)) {
+                element.treeItem.contextValue = currentContext.replace(';' + COPIED_STATE, '');
+            }
+        }
         return element.treeItem;
     }
 
diff --git a/src/features/views/temporaryStateManager.ts b/src/features/views/temporaryStateManager.ts
@@ -0,0 +1,74 @@
+import { Disposable, Event, EventEmitter } from 'vscode';
+
+const DEFAULT_TIMEOUT_MS = 2000;
+
+/**
+ * Manages temporary state for tree items that auto-clears after a timeout.
+ * Useful for visual feedback like showing a checkmark after copying,
+ * or highlighting a recently selected environment.
+ */
+export class TemporaryStateManager implements Disposable {
+    private activeItems: Map<string, Set<string>> = new Map();
+    private timeouts: Map<string, NodeJS.Timeout> = new Map();
+    private readonly _onDidChangeState = new EventEmitter<{ itemId: string; stateKey: string }>();
+
+    public readonly onDidChangeState: Event<{ itemId: string; stateKey: string }> = this._onDidChangeState.event;
+
+    constructor(private readonly timeoutMs: number = DEFAULT_TIMEOUT_MS) {}
+
+    /**
+     * Sets a temporary state on an item. After the timeout, the state is automatically cleared.
+     */
+    public setState(itemId: string, stateKey: string): void {
+        const timeoutKey = `${itemId}:${stateKey}`;
+        const existingTimeout = this.timeouts.get(timeoutKey);
+        if (existingTimeout) {
+            clearTimeout(existingTimeout);
+        }
+
+        let states = this.activeItems.get(itemId);
+        if (!states) {
+            states = new Set();
+            this.activeItems.set(itemId, states);
+        }
+        states.add(stateKey);
+        this._onDidChangeState.fire({ itemId, stateKey });
+
+        const timeout = setTimeout(() => {
+            this.clearState(itemId, stateKey);
+        }, this.timeoutMs);
+
+        this.timeouts.set(timeoutKey, timeout);
+    }
+
+    /**
+     * Clears a specific state from an item.
+     */
+    public clearState(itemId: string, stateKey: string): void {
+        const timeoutKey = `${itemId}:${stateKey}`;
+        this.timeouts.delete(timeoutKey);
+
+        const states = this.activeItems.get(itemId);
+        if (states) {
+            states.delete(stateKey);
+            if (states.size === 0) {
+                this.activeItems.delete(itemId);
+            }
+        }
+        this._onDidChangeState.fire({ itemId, stateKey });
+    }
+
+    /**
+     * Checks if an item has a specific state.
+     */
+    public hasState(itemId: string, stateKey: string): boolean {
+        return this.activeItems.get(itemId)?.has(stateKey) ?? false;
+    }
+
+    public dispose(): void {
+        this.timeouts.forEach((timeout) => clearTimeout(timeout));
+        this.timeouts.clear();
+        this.activeItems.clear();
+        this._onDidChangeState.dispose();
+    }
+}
diff --git a/src/test/features/views/temporaryStateManager.unit.test.ts b/src/test/features/views/temporaryStateManager.unit.test.ts
