feat: normalize packageManager field when parsing

src/_utils.ts

@@ -158,3 +158,16 @@ export function doesDependencyExist(
     return false;
   }
 }
+
+export function sanitizePackageManagerName(
+  name: string,
+): [any, string | undefined] {
+  const sanitized = name.replace(/^\W+/, "");
+  if (name !== sanitized) {
+    return [
+      sanitized,
+      `Abnormal characters found in \`packageManager\` field, sanitizing from \`'${name}'\` to \`'${sanitized}'\``,
+    ];
+  }
+  return [name, undefined];
+}

src/cli.ts

@@ -85,14 +85,27 @@ const detect = defineCommand({
       type: "string",
       description: "Current working directory",
     },
+    warn: {
+      type: "boolean",
+      description: "Log warnings",
+      default: true,
+    },
   },
   run: async ({ args }) => {
     const cwd = resolve(args.cwd || ".");
     const packageManager = await detectPackageManager(cwd);
+
+    if (args.warn && packageManager?.warnings) {
+      for (const warning of packageManager.warnings) {
+        consola.warn(warning);
+      }
+    }
+
     if (!packageManager) {
       consola.error(`Cannot detect package manager in \`${cwd}\``);
       return process.exit(1);
     }
+
     consola.log(
       `Detected package manager in \`${cwd}\`: \`${packageManager.name}@${packageManager.version}\``,
     );

src/package-manager.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { join, resolve } from "pathe";
-import { findup } from "./_utils";
+import { findup, sanitizePackageManagerName } from "./_utils";
 import type { PackageManager } from "./types";
 
 export type DetectPackageManagerOptions = {
@@ -92,8 +92,10 @@ export async function detectPackageManager(
             await readFile(packageJSONPath, "utf8"),
           );
           if (packageJSON?.packageManager) {
-            const [name, version = "0.0.0"] =
+            const [rawName, version = "0.0.0"] =
               packageJSON.packageManager.split("@");
+            const [name, sanitizationWarning] =
+              sanitizePackageManagerName(rawName);
             const majorVersion = version.split(".")[0];
             const packageManager =
               packageManagers.find(
@@ -105,6 +107,7 @@ export async function detectPackageManager(
               command: name,
               version,
               majorVersion,
+              warnings: [sanitizationWarning].filter(Boolean) as string[],
             };
           }
         }

src/types.ts

@@ -7,6 +7,7 @@ export type PackageManager = {
   majorVersion?: string;
   lockFile?: string | string[];
   files?: string[];
+  warnings?: string[];
 };
 
 export type OperationOptions = {

test/_utils.test.ts

@@ -1,5 +1,8 @@
 import { expect, it, describe } from "vitest";
-import { resolveOperationOptions } from "../src/_utils";
+import {
+  sanitizePackageManagerName,
+  resolveOperationOptions,
+} from "../src/_utils";
 
 describe("internal utils", () => {
   describe("resolveOperationOptions", () => {
@@ -8,4 +11,20 @@ describe("internal utils", () => {
       expect(r.packageManager.name).toBe("yarn");
     });
   });
+
+  describe("parsePackageManagerName", () => {
+    it("preserves valid (unknown) name", () => {
+      const [name, warning] = sanitizePackageManagerName("unknownName@0.0.0");
+      expect(name).toBe("unknownName@0.0.0");
+      expect(warning).toMatchInlineSnapshot(`undefined`);
+    });
+
+    it("sanitize abnormal characters with warning", () => {
+      const [name, warning] = sanitizePackageManagerName("~^&#-!yarn@0.0.0");
+      expect(name).toBe("yarn@0.0.0");
+      expect(warning).toMatchInlineSnapshot(
+        `"Abnormal characters found in \`packageManager\` field, sanitizing from \`'~^&#-!yarn@0.0.0'\` to \`'yarn@0.0.0'\`"`,
+      );
+    });
+  });
 });