Remove unused PackageRootTreeItem and ProjectPackageRootTreeItem classes

Co-authored-by: karthiknadig <3840081+karthiknadig@users.noreply.github.com>

Author: Copilot

package.json

@@ -361,7 +361,7 @@
                 {
                     "command": "python-envs.refreshPackages",
                     "group": "inline",
-                    "when": "view == env-managers && viewItem == python-package-root"
+                    "when": "view == env-managers && viewItem =~ /.*pythonEnvironment.*/"
                 },
                 {
                     "command": "python-envs.packages",

src/features/envCommands.ts

@@ -30,7 +30,6 @@ import {
     EnvManagerTreeItem,
     EnvTreeItemKind,
     GlobalProjectItem,
-    PackageRootTreeItem,
     PackageTreeItem,
     ProjectEnvironment,
     ProjectItem,
@@ -47,7 +46,7 @@ export async function refreshManagerCommand(context: unknown): Promise<void> {
     }
 }
 
-export async function refreshPackagesCommand(context: unknown, managers?: EnvironmentManagers) {
+export async function refreshPackagesCommand(context: unknown, managers?: EnvironmentManagers): Promise<void> {
     if (context instanceof ProjectEnvironment) {
         const view = context as ProjectEnvironment;
         if (managers) {
@@ -56,10 +55,16 @@ export async function refreshPackagesCommand(context: unknown, managers?: Enviro
                 await pkgManager.refresh(view.environment);
             }
         }
-    } else if (context instanceof PackageRootTreeItem) {
-        const view = context as PackageRootTreeItem;
-        const manager = view.manager;
-        await manager.refresh(view.environment);
+    } else if (context instanceof PythonEnvTreeItem) {
+        const view = context as PythonEnvTreeItem;
+        const envManager =
+            view.parent.kind === EnvTreeItemKind.environmentGroup
+                ? view.parent.parent.manager
+                : view.parent.manager;
+        const pkgManager = managers?.getPackageManager(envManager.preferredPackageManagerId);
+        if (pkgManager) {
+            await pkgManager.refresh(view.environment);
+        }
     } else {
         traceVerbose(`Invalid context for refresh command: ${context}`);
     }

src/features/views/envManagersView.ts

@@ -13,12 +13,10 @@ import {
     EnvTreeItem,
     EnvManagerTreeItem,
     PythonEnvTreeItem,
-    PackageRootTreeItem,
     PackageTreeItem,
     EnvTreeItemKind,
     NoPythonEnvTreeItem,
     EnvInfoTreeItem,
-    PackageRootInfoTreeItem,
     PythonGroupEnvTreeItem,
 } from './treeViewItems';
 import { createSimpleDebounce } from '../../common/utils/debounce';
@@ -31,7 +29,6 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
     >();
     private revealMap = new Map<string, PythonEnvTreeItem>();
     private managerViews = new Map<string, EnvManagerTreeItem>();
-    private packageRoots = new Map<string, PackageRootTreeItem>();
     private selected: Map<string, string> = new Map();
     private disposables: Disposable[] = [];
 
@@ -42,7 +39,6 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
 
         this.disposables.push(
             new Disposable(() => {
-                this.packageRoots.clear();
                 this.revealMap.clear();
                 this.managerViews.clear();
                 this.selected.clear();
@@ -165,32 +161,18 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
             const views: EnvTreeItem[] = [];
 
             if (pkgManager) {
-                const item = new PackageRootTreeItem(parent, pkgManager, environment);
-                this.packageRoots.set(environment.envId.id, item);
-                views.push(item);
+                const packages = await pkgManager.getPackages(environment);
+                if (packages && packages.length > 0) {
+                    views.push(...packages.map((p) => new PackageTreeItem(p, parent, pkgManager)));
+                } else {
+                    views.push(new EnvInfoTreeItem(parent, ProjectViews.noPackages));
+                }
             } else {
                 views.push(new EnvInfoTreeItem(parent, ProjectViews.noPackageManager));
             }
 
             return views;
         }
-
-        if (element.kind === EnvTreeItemKind.packageRoot) {
-            const root = element as PackageRootTreeItem;
-            const manager = root.manager;
-            const environment = root.environment;
-
-            let packages = await manager.getPackages(environment);
-            const views: EnvTreeItem[] = [];
-
-            if (packages) {
-                views.push(...packages.map((p) => new PackageTreeItem(p, root, manager)));
-            } else {
-                views.push(new PackageRootInfoTreeItem(root, ProjectViews.noPackages));
-            }
-
-            return views;
-        }
     }
 
     getParent(element: EnvTreeItem): ProviderResult<EnvTreeItem> {
@@ -219,35 +201,32 @@ export class EnvManagerView implements TreeDataProvider<EnvTreeItem>, Disposable
     }
 
     private onDidChangePackages(args: InternalDidChangePackagesEventArgs) {
-        const pkgRoot = this.packageRoots.get(args.environment.envId.id);
-        if (pkgRoot) {
-            this.fireDataChanged(pkgRoot);
+        const view = Array.from(this.revealMap.values()).find(
+            (v) => v.environment.envId.id === args.environment.envId.id
+        );
+        if (view) {
+            this.fireDataChanged(view);
         }
     }
 
-    private onDidChangePackageManager(args: DidChangePackageManagerEventArgs) {
-        const roots = Array.from(this.packageRoots.values()).filter((r) => r.manager.id === args.manager.id);
-        this.fireDataChanged(roots);
+    private onDidChangePackageManager(_args: DidChangePackageManagerEventArgs) {
+        // Since we removed the packageRoots level, just refresh all environments
+        // This is a simplified approach that isn't as targeted but ensures packages get refreshed
+        this.fireDataChanged(undefined);
     }
 
     public environmentChanged(e: DidChangeEnvironmentEventArgs) {
         const views = [];
         if (e.old) {
             this.selected.delete(e.old.envId.id);
-            let view: EnvTreeItem | undefined = this.packageRoots.get(e.old.envId.id);
-            if (!view) {
-                view = this.managerViews.get(e.old.envId.managerId);
-            }
+            const view: EnvTreeItem | undefined = this.revealMap.get(e.old.envId.id);
             if (view) {
                 views.push(view);
             }
         }
         if (e.new) {
             this.selected.set(e.new.envId.id, e.uri === undefined ? 'global' : e.uri.fsPath);
-            let view: EnvTreeItem | undefined = this.packageRoots.get(e.new.envId.id);
-            if (!view) {
-                view = this.managerViews.get(e.new.envId.managerId);
-            }
+            const view: EnvTreeItem | undefined = this.revealMap.get(e.new.envId.id);
             if (view && !views.includes(view)) {
                 views.push(view);
             }

src/features/views/treeViewItems.ts

@@ -11,8 +11,6 @@ export enum EnvTreeItemKind {
     environmentGroup = 'python-env-group',
     noEnvironment = 'python-no-env',
     package = 'python-package',
-    packageRoot = 'python-package-root',
-    packageRootInfo = 'python-package-root-info',
     managerInfo = 'python-env-manager-info',
     environmentInfo = 'python-env-info',
     packageInfo = 'python-package-info',
@@ -128,28 +126,12 @@ export class NoPythonEnvTreeItem implements EnvTreeItem {
     }
 }
 
-export class PackageRootTreeItem implements EnvTreeItem {
-    public readonly kind = EnvTreeItemKind.packageRoot;
-    public readonly treeItem: TreeItem;
-    constructor(
-        public readonly parent: PythonEnvTreeItem,
-        public readonly manager: InternalPackageManager,
-        public readonly environment: PythonEnvironment,
-    ) {
-        const item = new TreeItem('Packages', TreeItemCollapsibleState.Collapsed);
-        item.contextValue = 'python-package-root';
-        item.description = manager.displayName;
-        item.tooltip = 'Packages installed in this environment';
-        this.treeItem = item;
-    }
-}
-
 export class PackageTreeItem implements EnvTreeItem {
     public readonly kind = EnvTreeItemKind.package;
     public readonly treeItem: TreeItem;
     constructor(
         public readonly pkg: Package,
-        public readonly parent: PackageRootTreeItem,
+        public readonly parent: PythonEnvTreeItem,
         public readonly manager: InternalPackageManager,
     ) {
         const item = new TreeItem(pkg.displayName);
@@ -183,10 +165,10 @@ export class EnvInfoTreeItem implements EnvTreeItem {
 }
 
 export class PackageRootInfoTreeItem implements EnvTreeItem {
-    public readonly kind = EnvTreeItemKind.packageRootInfo;
+    public readonly kind = EnvTreeItemKind.packageInfo;
     public readonly treeItem: TreeItem;
     constructor(
-        public readonly parent: PackageRootTreeItem,
+        public readonly parent: PythonEnvTreeItem,
         name: string,
         description?: string,
         tooltip?: string | MarkdownString,
@@ -209,7 +191,6 @@ export enum ProjectTreeItemKind {
     none = 'project-no-environment',
     environmentInfo = 'environment-info',
     package = 'project-package',
-    packageRoot = 'project-package-root',
     packageRootInfo = 'project-package-root-info',
 }
 
@@ -307,24 +288,6 @@ export class NoProjectEnvironment implements ProjectTreeItem {
     }
 }
 
-export class ProjectPackageRootTreeItem implements ProjectTreeItem {
-    public readonly kind = ProjectTreeItemKind.packageRoot;
-    public readonly id: string;
-    public readonly treeItem: TreeItem;
-    constructor(
-        public readonly parent: ProjectEnvironment,
-        public readonly manager: InternalPackageManager,
-        public readonly environment: PythonEnvironment,
-    ) {
-        const item = new TreeItem('Packages', TreeItemCollapsibleState.Collapsed);
-        this.id = `${this.parent.id}>>>packages`;
-        item.contextValue = 'python-package-root';
-        item.description = manager.displayName;
-        item.tooltip = 'Packages installed in this environment';
-        this.treeItem = item;
-    }
-}
-
 export class NoPackagesEnvironment implements ProjectTreeItem {
     public readonly kind = ProjectTreeItemKind.none;
     public readonly id: string;
@@ -405,7 +368,7 @@ export class ProjectPackageRootInfoTreeItem implements ProjectTreeItem {
     public readonly id: string;
     public readonly treeItem: TreeItem;
     constructor(
-        public readonly parent: ProjectPackageRootTreeItem,
+        public readonly parent: ProjectEnvironment,
         name: string,
         description?: string,
         tooltip?: string | MarkdownString,
@@ -421,7 +384,7 @@ export class ProjectPackageRootInfoTreeItem implements ProjectTreeItem {
         this.treeItem.iconPath = iconPath;
         this.treeItem.command = command;
     }
-    static getId(projectEnv: ProjectPackageRootTreeItem, name: string): string {
+    static getId(projectEnv: ProjectEnvironment, name: string): string {
         return `${projectEnv.id}>>>${name}`;
     }
 }