feat(remove-environment): add commands to remove environment and reveal folder

- Implemented `pyneide.removeEnvironment` command to delete the downloaded
  Python environment and plugins, freeing up disk space.
- Added `pyneide.revealEnvironmentFolder` command to open the environment
  folder in the file manager.
- Updated status bar to include options for removing the environment and
  revealing the folder.
- Enhanced changelog to document these new features.

Author: wallneradam

CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- **Remove Environment.** The status bar menu (and the `PyneIDE: Remove
+  Environment` command) now deletes what PyneIDE downloaded — the Python
+  environment with its installed plugins, and optionally the Pine language
+  server — after showing how much each one takes. Until now the only way out
+  was a clean reinstall, and uninstalling the extension left the whole
+  environment on disk. **Reveal Environment Folder** opens that location in the
+  file manager.
+
 ### Changed
 
 - **PyneCore pin 6.7.0 → 6.10.2.** The managed environment installs the newer

README.md

@@ -189,7 +189,10 @@ view keeps your Scripts, Data, and Output in one place.
 2. Open a folder and run **PyneIDE: Initialize Pyne Project** — it scaffolds a
    runnable demo plus sample data.
 3. When prompted, let PyneIDE **set up the Python environment** (a one-time download
-   of `uv` + Python + PyneCore into extension storage).
+   of `uv` + Python + PyneCore into extension storage). It stays there when the
+   extension is uninstalled, so **PyneIDE: Remove Environment** is there to delete
+   it again and give the disk space back; **PyneIDE: Reveal Environment Folder**
+   shows where it lives.
 4. Press **Run** on the demo and watch the chart appear.
 5. To run your own **Pine**: open a `.pine` file, **Sign In** with your PyneSys API
    key when prompted, then Run — it compiles in the cloud and runs like any other

package.json

@@ -89,6 +89,16 @@
         "title": "Get Started",
         "category": "PyneIDE"
       },
+      {
+        "command": "pyneide.removeEnvironment",
+        "title": "Remove Environment",
+        "category": "PyneIDE"
+      },
+      {
+        "command": "pyneide.revealEnvironmentFolder",
+        "title": "Reveal Environment Folder",
+        "category": "PyneIDE"
+      },
       {
         "command": "pyneide.showEnvironmentLog",
         "title": "Show Environment Log",

src/env/bootstrap.ts

@@ -115,7 +115,8 @@ function logInterpreterDiag(info: VerifyInfo, log: Logger): void {
   }
 }
 
-function markerPath(storageDir: string): string {
+/** The `env.json` marker describing what the managed venv was built from. */
+export function markerPath(storageDir: string): string {
   return path.join(storageDir, 'env.json');
 }
 

src/env/remove.ts

@@ -0,0 +1,132 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { markerPath } from './bootstrap';
+import type { Logger } from './constants';
+import { managedPythonDir, managedVenvDir, uvDir } from './uv';
+
+/**
+ * Everything PyneIDE downloads lives in globalStorage, which VS Code does NOT
+ * delete when the extension is uninstalled — without this module the ~250 MB
+ * managed environment is only removable by hand. Kept vscode-free like the
+ * rest of src/env; the command UI lives in `removeCommand.ts`.
+ */
+
+export type RemovableId = 'python' | 'pine-ls';
+
+export interface RemovableComponent {
+  id: RemovableId;
+  label: string;
+  /** What removing it costs later, shown as the picker row's detail. */
+  note: string;
+  /** Existing paths only — the picker never offers what is not on disk. */
+  paths: string[];
+  bytes: number;
+}
+
+/**
+ * Directories owned by other modules. Passed in rather than imported so this
+ * module does not reach into src/pinels and src/plugins (and so src/env keeps
+ * its one-way dependencies).
+ */
+export interface ComponentLocations {
+  /** `src/pinels/installer.ts` `pineLsRoot()`. */
+  pineLsRoot: string;
+  /** `src/plugins/installed.ts` `cliWorkdir()`. */
+  cliWorkdir: string;
+}
+
+/**
+ * The removable components that currently exist on disk, with their sizes.
+ * The Python environment is one component on purpose: uv, the standalone
+ * CPython and the venv are useless without each other.
+ */
+export async function removableComponents(
+  storageDir: string,
+  locations: ComponentLocations
+): Promise<RemovableComponent[]> {
+  const python = [
+    uvDir(storageDir),
+    managedPythonDir(storageDir),
+    managedVenvDir(storageDir),
+    markerPath(storageDir),
+    locations.cliWorkdir,
+  ].filter((target) => fs.existsSync(target));
+  const pineLs = [locations.pineLsRoot].filter((target) => fs.existsSync(target));
+
+  const components: RemovableComponent[] = [];
+  if (python.length > 0) {
+    components.push({
+      id: 'python',
+      label: 'Python environment',
+      note: 'uv, the standalone Python, the virtual environment and any installed plugins',
+      paths: python,
+      bytes: await totalBytes(python),
+    });
+  }
+  if (pineLs.length > 0) {
+    components.push({
+      id: 'pine-ls',
+      label: 'Pine language server',
+      note: 'Installing it again needs an internet connection',
+      paths: pineLs,
+      bytes: await totalBytes(pineLs),
+    });
+  }
+  return components;
+}
+
+async function totalBytes(paths: string[]): Promise<number> {
+  let total = 0;
+  for (const target of paths) total += await pathBytes(target);
+  return total;
+}
+
+/**
+ * Size of a file or directory tree. Symlinks are measured, never followed:
+ * a standalone CPython links the same libraries several times over, so
+ * following them would report several times the size actually freed.
+ */
+async function pathBytes(target: string): Promise<number> {
+  let stat: fs.Stats;
+  try {
+    stat = await fs.promises.lstat(target);
+  } catch {
+    return 0;
+  }
+  if (!stat.isDirectory()) return stat.size;
+  let total = 0;
+  let entries: fs.Dirent[];
+  try {
+    entries = await fs.promises.readdir(target, { withFileTypes: true });
+  } catch {
+    return total;
+  }
+  for (const entry of entries) {
+    total += await pathBytes(path.join(target, entry.name));
+  }
+  return total;
+}
+
+/**
+ * Delete the given paths. `maxRetries` is what makes this work on Windows,
+ * where a file a just-stopped process still holds fails with EBUSY/EPERM for
+ * a moment; a path that stays locked throws and the caller reports it.
+ */
+export async function removePaths(paths: string[], log: Logger): Promise<void> {
+  for (const target of paths) {
+    log(`Removing ${target}`);
+    await fs.promises.rm(target, {
+      recursive: true,
+      force: true,
+      maxRetries: 5,
+      retryDelay: 200,
+    });
+  }
+}
+
+/** Size for a menu row: whole MB, since these are tens to hundreds of MB. */
+export function formatBytes(bytes: number): string {
+  if (bytes < 1_000_000) return '<1 MB';
+  return `${Math.round(bytes / 1_000_000)} MB`;
+}

src/env/removeCommand.ts

@@ -0,0 +1,158 @@
+import * as fs from 'node:fs';
+
+import * as vscode from 'vscode';
+
+import { pineLsRoot } from '../pinels/installer';
+import type { PineLsService } from '../pinels/service';
+import { cliWorkdirPath } from '../plugins/installed';
+import { SETUP_DOWNLOAD_MB } from './constants';
+import type { EnvManager } from './manager';
+import {
+  formatBytes,
+  removableComponents,
+  removePaths,
+  type RemovableComponent,
+} from './remove';
+
+interface PickItem extends vscode.QuickPickItem {
+  component: RemovableComponent;
+}
+
+/**
+ * "Remove Environment" and "Reveal Environment Folder".
+ *
+ * Uninstalling the extension leaves globalStorage behind, so without a remove
+ * command the only way to get the disk space back is to find the folder by
+ * hand — which is also why Reveal sits next to it.
+ */
+export function registerRemoveEnvironment(
+  context: vscode.ExtensionContext,
+  manager: EnvManager,
+  pineLs: PineLsService,
+  output: vscode.OutputChannel
+): vscode.Disposable[] {
+  const storageDir = context.globalStorageUri.fsPath;
+  return [
+    vscode.commands.registerCommand('pyneide.removeEnvironment', () =>
+      removeEnvironment(storageDir, manager, pineLs, output)
+    ),
+    vscode.commands.registerCommand('pyneide.revealEnvironmentFolder', async () => {
+      // globalStorage is created lazily, so it may not exist before a setup.
+      await fs.promises.mkdir(storageDir, { recursive: true });
+      await vscode.commands.executeCommand('revealFileInOS', vscode.Uri.file(storageDir));
+    }),
+  ];
+}
+
+async function removeEnvironment(
+  storageDir: string,
+  manager: EnvManager,
+  pineLs: PineLsService,
+  output: vscode.OutputChannel
+): Promise<void> {
+  if (manager.state.kind === 'working') {
+    void vscode.window.showInformationMessage(
+      'PyneIDE: the environment is busy. Wait for it to finish (or cancel it) before removing it.'
+    );
+    return;
+  }
+
+  const components = await vscode.window.withProgress(
+    { location: vscode.ProgressLocation.Window, title: 'PyneIDE: measuring the environment…' },
+    () =>
+      removableComponents(storageDir, {
+        pineLsRoot: pineLsRoot(storageDir),
+        cliWorkdir: cliWorkdirPath(storageDir),
+      })
+  );
+  if (components.length === 0) {
+    void vscode.window.showInformationMessage(
+      'PyneIDE: there is nothing to remove — no downloaded environment was found.'
+    );
+    return;
+  }
+
+  const picked = await vscode.window.showQuickPick(
+    components.map((component) => toItem(component)),
+    {
+      title: 'PyneIDE — Remove Environment',
+      placeHolder: 'Select what to delete from PyneIDE storage',
+      canPickMany: true,
+    }
+  );
+  if (!picked || picked.length === 0) return;
+
+  const selected = picked.map((item) => item.component);
+  const freed = selected.reduce((sum, component) => sum + component.bytes, 0);
+  const lines = selected.map(
+    (component) => `${component.label} — ${formatBytes(component.bytes)}`
+  );
+  const reinstall = selected.some((component) => component.id === 'python')
+    ? ` Setting the Python environment up again downloads about ${SETUP_DOWNLOAD_MB} MB.`
+    : '';
+  const confirm = await vscode.window.showWarningMessage(
+    'Remove the downloaded PyneIDE environment?',
+    {
+      modal: true,
+      detail:
+        `${lines.join('\n')}\n\nFrees about ${formatBytes(freed)}. ` +
+        `This cannot be undone.${reinstall}\n\n` +
+        'Your scripts, data and project files are not touched.',
+    },
+    'Remove'
+  );
+  if (confirm !== 'Remove') return;
+
+  const removingPineLs = selected.some((component) => component.id === 'pine-ls');
+  try {
+    // The server runs from the directory about to be deleted; on Windows that
+    // alone makes the removal fail.
+    if (removingPineLs) await pineLs.stopServer();
+    await vscode.window.withProgress(
+      {
+        location: vscode.ProgressLocation.Notification,
+        title: 'PyneIDE: removing the environment',
+        cancellable: false,
+      },
+      async () => {
+        for (const component of selected) {
+          await removePaths(component.paths, (message) => output.appendLine(message));
+        }
+      }
+    );
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    output.appendLine(`Removing the environment failed: ${message}`);
+    const choice = await vscode.window.showErrorMessage(
+      `PyneIDE: removing the environment failed: ${message}. ` +
+        'A running PyneIDE process may still hold files open — reloading the window releases them.',
+      'Reload Window',
+      'Show Log'
+    );
+    if (choice === 'Reload Window') {
+      await vscode.commands.executeCommand('workbench.action.reloadWindow');
+    } else if (choice === 'Show Log') {
+      output.show();
+    }
+    return;
+  }
+
+  await manager.check();
+  if (removingPineLs) await pineLs.restart();
+  void vscode.window.showInformationMessage(
+    `PyneIDE: removed ${selected.map((component) => component.label.toLowerCase()).join(' and ')}. ` +
+      `Freed about ${formatBytes(freed)}.`
+  );
+}
+
+function toItem(component: RemovableComponent): PickItem {
+  return {
+    label: component.label,
+    description: formatBytes(component.bytes),
+    detail: component.note,
+    // The Python environment is what the disk space is in, and reinstalling it
+    // is one click; the Pine LS has to be downloaded again, so it is opt-in.
+    picked: component.id === 'python',
+    component,
+  };
+}

src/env/statusBar.ts

@@ -245,10 +245,20 @@ export class EnvStatusBar {
           label: '$(tools) Repair Environment (clean reinstall)',
           action: () => void this.manager.setup({ recreate: true }),
         },
+        {
+          label: '$(trash) Remove Environment…',
+          description: 'Delete what PyneIDE downloaded and free the disk space',
+          action: () => void vscode.commands.executeCommand('pyneide.removeEnvironment'),
+        },
         {
           label: '$(new-folder) Initialize Pyne Project',
           action: () => void vscode.commands.executeCommand('pyneide.createWorkspace'),
         },
+        {
+          label: '$(folder-opened) Reveal Environment Folder',
+          description: 'Where PyneIDE keeps Python, PyneCore and the Pine language server',
+          action: () => void vscode.commands.executeCommand('pyneide.revealEnvironmentFolder'),
+        },
         {
           label: '$(output) Show Environment Log',
           action: () => void vscode.commands.executeCommand('pyneide.showEnvironmentLog'),