Add normalizePackageName

Author: edvilme

src/managers/builtin/pipPackageManager.ts

@@ -21,7 +21,7 @@ import {
 } from '../../api';
 import { updatePackagesAndNotify } from '../common/packageChanges';
 import { getWorkspacePackagesToInstall } from './pipUtils';
-import { managePackages, refreshPipDirectPackageNames, refreshPipPackages } from './utils';
+import { managePackages, normalizePackageName, refreshPipDirectPackageNames, refreshPipPackages } from './utils';
 import { VenvManager } from './venvManager';
 
 export class PipPackageManager implements PackageManager, Disposable {
@@ -137,6 +137,6 @@ export class PipPackageManager implements PackageManager, Disposable {
 
     async getDirectPackageNames(environment: PythonEnvironment): Promise<Set<string> | undefined> {
         const data = await refreshPipDirectPackageNames(environment, this.log);
-        return data ? new Set(data) : undefined;
+        return data ? new Set(data.map(normalizePackageName)) : undefined;
     }
 }

src/managers/builtin/utils.ts

@@ -380,3 +380,7 @@ export async function resolveSystemPythonEnvironmentPath(
     }
     return undefined;
 }
+
+export function normalizePackageName(name: string): string {
+    return name.replace(/[-_.]+/g, '-').toLowerCase();
+}

src/managers/common/packageChanges.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 import { Package, PackageChangeKind, PackageManager, PythonEnvironment } from '../../api';
+import { normalizePackageName } from '../builtin/utils';
 
 /**
  * Callback invoked with the computed changes when at least one change is detected.
@@ -15,17 +16,17 @@ export type PackageChangesCallback = (changes: { kind: PackageChangeKind; pkg: P
  * @returns An array of changes indicating which packages were added or removed.
  */
 export function getPackageChanges(before: Package[], after: Package[]): { kind: PackageChangeKind; pkg: Package }[] {
-    const beforeSet = new Set(before.map(({ name, version }) => `${name}==${version}`));
-    const afterSet = new Set(after.map(({ name, version }) => `${name}==${version}`));
+    const beforeSet = new Set(before.map(({ name, version }) => `${normalizePackageName(name)}==${version}`));
+    const afterSet = new Set(after.map(({ name, version }) => `${normalizePackageName(name)}==${version}`));
     const changes: { kind: PackageChangeKind; pkg: Package }[] = [];
 
     for (const pkg of after) {
-        if (!beforeSet.has(`${pkg.name}==${pkg.version}`)) {
+        if (!beforeSet.has(`${normalizePackageName(pkg.name)}==${pkg.version}`)) {
             changes.push({ kind: PackageChangeKind.add, pkg });
         }
     }
     for (const pkg of before) {
-        if (!afterSet.has(`${pkg.name}==${pkg.version}`)) {
+        if (!afterSet.has(`${normalizePackageName(pkg.name)}==${pkg.version}`)) {
             changes.push({ kind: PackageChangeKind.remove, pkg });
         }
     }
@@ -55,7 +56,9 @@ export async function updatePackagesAndNotify(
 
     if (afterDirectDependenciesNames && afterDirectDependenciesNames.size > 0) {
         for (const pkg of after) {
-            (pkg as { isTransitive?: boolean }).isTransitive = !afterDirectDependenciesNames.has(pkg.name);
+            (pkg as { isTransitive?: boolean }).isTransitive = !afterDirectDependenciesNames.has(
+                normalizePackageName(pkg.name),
+            );
         }
     }
 

src/managers/poetry/poetryPackageManager.ts

@@ -24,6 +24,7 @@ import {
 } from '../../api';
 import { spawnProcess } from '../../common/childProcess.apis';
 import { showErrorMessage, showInputBox, withProgress } from '../../common/window.apis';
+import { normalizePackageName } from '../builtin/utils';
 import { updatePackagesAndNotify } from '../common/packageChanges';
 import { PoetryManager } from './poetryManager';
 import { getPoetry } from './poetryUtils';
@@ -272,7 +273,8 @@ export class PoetryPackageManager implements PackageManager, Disposable {
                 .split('\n')
                 .map((line) => line.trim())
                 .map((line) => line.match(/^([a-zA-Z0-9_-]+)/)?.[1] ?? '')
-                .filter((name) => !!name);
+                .filter((name) => !!name)
+                .map(normalizePackageName);
             return new Set(names);
         } catch (err) {
             this.log.error(`Error fetching direct package names with Poetry: ${err}`);

src/test/managers/builtin/normalizePackageName.unit.test.ts

@@ -0,0 +1,46 @@
+import assert from 'assert';
+import { normalizePackageName } from '../../../managers/builtin/utils';
+
+suite('normalizePackageName', () => {
+    test('should lowercase names', () => {
+        assert.strictEqual(normalizePackageName('Requests'), 'requests');
+        assert.strictEqual(normalizePackageName('NUMPY'), 'numpy');
+    });
+
+    test('should replace underscores with hyphens', () => {
+        assert.strictEqual(normalizePackageName('my_package'), 'my-package');
+    });
+
+    test('should replace dots with hyphens', () => {
+        assert.strictEqual(normalizePackageName('zope.interface'), 'zope-interface');
+    });
+
+    test('should collapse consecutive separators into a single hyphen', () => {
+        assert.strictEqual(normalizePackageName('my__package'), 'my-package');
+        assert.strictEqual(normalizePackageName('my_-package'), 'my-package');
+        assert.strictEqual(normalizePackageName('my_.package'), 'my-package');
+    });
+
+    test('should handle mixed separators and casing', () => {
+        assert.strictEqual(normalizePackageName('My_Package.Name'), 'my-package-name');
+        assert.strictEqual(normalizePackageName('Foo-Bar_Baz'), 'foo-bar-baz');
+    });
+
+    test('should return already-normalized names unchanged', () => {
+        assert.strictEqual(normalizePackageName('requests'), 'requests');
+        assert.strictEqual(normalizePackageName('my-package'), 'my-package');
+    });
+
+    test('should handle single-word names', () => {
+        assert.strictEqual(normalizePackageName('pip'), 'pip');
+    });
+
+    test('should produce equal results for equivalent package names', () => {
+        const variants = ['My_Package', 'my-package', 'my.package', 'My.Package', 'MY_PACKAGE', 'my_package'];
+        const normalized = variants.map(normalizePackageName);
+        assert.ok(
+            normalized.every((n) => n === normalized[0]),
+            `All variants should normalize to the same value, got: ${JSON.stringify(normalized)}`,
+        );
+    });
+});