Add package manager command classes

Author: edvilme

src/managers/base/commands/availableVersions.ts

@@ -0,0 +1,31 @@
+import type { Pep440Version } from '@renovatebot/pep440';
+import { explain as parsePep440Version } from '@renovatebot/pep440';
+import { BaseExecuteArgs, PackageManagerCommand } from './packageManagerCommand';
+
+/**
+ * Arguments for available versions command execution (change per execution).
+ */
+export interface AvailableVersionsExecuteArgs extends BaseExecuteArgs {
+    packageName: string;
+    pythonVersion: string;
+    includePrerelease?: boolean;
+}
+
+/**
+ * Template class for availableVersions commands.
+ * Subclasses implement concrete package-manager-specific logic.
+ */
+export abstract class AvailableVersionsCommand extends PackageManagerCommand {
+    protected static readonly configSection = 'availableVersionsCommandArgs';
+    protected abstract buildCommand(executeArgs: AvailableVersionsExecuteArgs): string[];
+    protected parseVersions(versions: string[], includePrerelease?: boolean): Pep440Version[] {
+        let parsed = Array.from(new Set(versions))
+            .map((version) => parsePep440Version(version.trim()))
+            .filter((version): version is Pep440Version => version !== null);
+        if (includePrerelease === false) {
+            parsed = parsed.filter((version) => !/[ab]|rc|dev/i.test(version.public));
+        }
+        return parsed;
+    }
+    abstract execute(executeArgs: AvailableVersionsExecuteArgs): Promise<Pep440Version[]>;
+}

src/managers/base/commands/index.ts

@@ -0,0 +1,7 @@
+export { AvailableVersionsCommand, type AvailableVersionsExecuteArgs } from './availableVersions';
+export { InstallCommand, type InstallExecuteArgs } from './install';
+export { ListCommand } from './list';
+export { ListDirectNamesCommand } from './listDirectNames';
+export { BaseExecuteArgs, CommandConstructorOptions, PackageManagerCommand } from './packageManagerCommand';
+export { UninstallCommand, type UninstallExecuteArgs } from './uninstall';
+export { VersionCommand } from './version';

src/managers/base/commands/install.ts

@@ -0,0 +1,19 @@
+import { BaseExecuteArgs, PackageManagerCommand } from './packageManagerCommand';
+
+/**
+ * Arguments for install command execution (change per execution).
+ */
+export interface InstallExecuteArgs extends BaseExecuteArgs {
+    packages: { packageName: string; version?: string }[];
+    upgrade?: boolean;
+}
+
+/**
+ * Template class for install commands.
+ * Subclasses implement concrete package-manager-specific logic.
+ */
+export abstract class InstallCommand extends PackageManagerCommand {
+    protected static readonly configSection = 'installCommandArgs';
+    protected abstract buildCommand(executeArgs: InstallExecuteArgs): string[];
+    abstract execute(executeArgs: InstallExecuteArgs): Promise<void>;
+}

src/managers/base/commands/list.ts

@@ -0,0 +1,12 @@
+import { PackageInfo } from '../../../api';
+import { BaseExecuteArgs, PackageManagerCommand } from './packageManagerCommand';
+
+/**
+ * Template class for list commands.
+ * Subclasses implement concrete package-manager-specific logic.
+ */
+export abstract class ListCommand extends PackageManagerCommand {
+    protected static readonly configSection = 'listCommandArgs';
+    protected timeout = 30000;
+    abstract execute(executeArgs?: BaseExecuteArgs): Promise<PackageInfo[]>;
+}

src/managers/base/commands/listDirectNames.ts

@@ -0,0 +1,11 @@
+import { BaseExecuteArgs, PackageManagerCommand } from './packageManagerCommand';
+
+/**
+ * Template class for listDirectNames commands.
+ * Subclasses implement concrete package-manager-specific logic.
+ */
+export abstract class ListDirectNamesCommand extends PackageManagerCommand {
+    protected static readonly configSection = 'listDirectNamesCommandArgs';
+    protected timeout = 30000;
+    abstract execute(executeArgs?: BaseExecuteArgs): Promise<Set<string>>;
+}

src/managers/base/commands/packageManagerCommand.ts

@@ -0,0 +1,46 @@
+import { CancellationToken, LogOutputChannel, WorkspaceConfiguration } from 'vscode';
+import { getConfiguration } from '../../../common/workspace.apis';
+
+/**
+ * Base interface for all command execute arguments.
+ * Provides optional cancellation token that all commands can use.
+ */
+export interface BaseExecuteArgs {
+    cancellationToken?: CancellationToken;
+}
+
+/**
+ * Constructor options shared by all package manager commands.
+ */
+export interface CommandConstructorOptions {
+    pythonExecutable: string;
+    cwd?: string;
+    log?: LogOutputChannel;
+}
+
+/**
+ * Base class for all package manager commands.
+ * Provides common properties and minimal interface for subclasses.
+ */
+export abstract class PackageManagerCommand {
+    protected static readonly configSection?: string;
+
+    protected pythonExecutable: string;
+    protected cwd?: string;
+    protected log?: LogOutputChannel;
+    protected timeout: number = 300000;
+    protected config?: WorkspaceConfiguration;
+
+    constructor(options: CommandConstructorOptions) {
+        this.pythonExecutable = options.pythonExecutable;
+        this.cwd = options.cwd;
+        this.log = options.log;
+        const configSection = (this.constructor as typeof PackageManagerCommand).configSection;
+        this.config = configSection ? getConfiguration(`python-envs.packageManager.${configSection}`) : undefined;
+    }
+
+    /**
+     * Subclasses implement to build the command arguments.
+     */
+    protected abstract buildCommand(executeArgs: BaseExecuteArgs): string[];
+}

src/managers/base/commands/uninstall.ts

@@ -0,0 +1,18 @@
+import { BaseExecuteArgs, PackageManagerCommand } from './packageManagerCommand';
+
+/**
+ * Arguments for uninstall command execution (change per execution).
+ */
+export interface UninstallExecuteArgs extends BaseExecuteArgs {
+    packages: { packageName: string; version?: string }[];
+}
+
+/**
+ * Template class for uninstall commands.
+ * Subclasses implement concrete package-manager-specific logic.
+ */
+export abstract class UninstallCommand extends PackageManagerCommand {
+    protected static readonly configSection = 'uninstallCommandArgs';
+    protected abstract buildCommand(executeArgs: UninstallExecuteArgs): string[];
+    abstract execute(executeArgs: UninstallExecuteArgs): Promise<void>;
+}

src/managers/base/commands/version.ts

@@ -0,0 +1,11 @@
+import type { Pep440Version } from '@renovatebot/pep440';
+import { BaseExecuteArgs, PackageManagerCommand } from './packageManagerCommand';
+
+/**
+ * Template class for version commands.
+ * Subclasses implement concrete package-manager-specific logic.
+ */
+export abstract class VersionCommand extends PackageManagerCommand {
+    protected static readonly configSection = 'versionCommandArgs';
+    abstract execute(executeArgs?: BaseExecuteArgs): Promise<Pep440Version | undefined>;
+}

src/managers/builtin/commands/availableVersions.ts

@@ -0,0 +1,93 @@
+import type { Pep440Version } from '@renovatebot/pep440';
+import { AvailableVersionsCommand, type AvailableVersionsExecuteArgs } from '../../base/commands/index';
+import { runPython, runUV } from '../helpers';
+
+/**
+ * Pip available versions command.
+ * Parsed command: `python -m pip index versions <package> --json --python-version <version>`
+ * Official documentation: https://pip.pypa.io/en/stable/cli/pip_index/
+ */
+export class PipAvailableVersionsCommand extends AvailableVersionsCommand {
+    protected buildCommand(executeArgs: AvailableVersionsExecuteArgs): string[] {
+        return [
+            '-m',
+            'pip',
+            'index',
+            'versions',
+            executeArgs.packageName,
+            '--json',
+            '--python-version',
+            executeArgs.pythonVersion,
+        ];
+    }
+
+    async execute(executeArgs: AvailableVersionsExecuteArgs): Promise<Pep440Version[]> {
+        const output = await runPython(
+            this.pythonExecutable,
+            this.buildCommand(executeArgs),
+            undefined,
+            this.log,
+            executeArgs.cancellationToken,
+            this.timeout,
+        );
+        const match = output.match(/{[\s\S]*}/);
+        if (!match) {
+            return [];
+        }
+
+        try {
+            const parsed = JSON.parse(match[0]) as { versions?: string[] };
+            return this.parseVersions(
+                Array.isArray(parsed.versions) ? parsed.versions : [],
+                executeArgs.includePrerelease,
+            );
+        } catch {
+            return [];
+        }
+    }
+}
+
+/**
+ * UV available versions command.
+ * Parsed command: `uv tool run pip index versions <package> --json --python-version <version>`
+ * Official documentation: https://docs.astral.sh/uv/pip/
+ */
+export class UvAvailableVersionsCommand extends AvailableVersionsCommand {
+    protected buildCommand(executeArgs: AvailableVersionsExecuteArgs): string[] {
+        return [
+            'tool',
+            'run',
+            'pip',
+            'index',
+            'versions',
+            executeArgs.packageName,
+            '--json',
+            '--python-version',
+            executeArgs.pythonVersion,
+        ];
+    }
+
+    async execute(executeArgs: AvailableVersionsExecuteArgs): Promise<Pep440Version[]> {
+        const output = await runUV(
+            this.buildCommand(executeArgs),
+            undefined,
+            this.log,
+            executeArgs.cancellationToken,
+            this.timeout,
+        );
+        const match = output.match(/{[\s\S]*}/);
+        if (!match) {
+            return [];
+        }
+
+        try {
+            const parsed = JSON.parse(match[0]) as { versions?: string[] };
+            return this.parseVersions(
+                Array.isArray(parsed.versions) ? parsed.versions : [],
+                executeArgs.includePrerelease,
+            );
+        } catch {
+            return [];
+        }
+    }
+}

src/managers/builtin/commands/factory.ts

@@ -0,0 +1,13 @@
+import { CommandConstructorOptions } from '../../base/commands/index';
+import { shouldUseUv } from '../helpers';
+
+type CommandConstructor<T> = new (options: CommandConstructorOptions) => T;
+
+export async function createPipOrUvCommand<T, P extends T, U extends T>(
+    options: CommandConstructorOptions,
+    environmentPath: string,
+    PipCommand: CommandConstructor<P>,
+    UvCommand: CommandConstructor<U>,
+): Promise<T> {
+    return (await shouldUseUv(options.log, environmentPath)) ? new UvCommand(options) : new PipCommand(options);
+}