banhaten 0.4.0 → 0.5.0

package/src/cli/package-manager.js

@@ -1,238 +1,238 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-import { minimatch } from "minimatch"
-import { parse as parseYaml } from "yaml"
-
-const LOCKFILES = [
-  { manager: "pnpm", name: "pnpm-lock.yaml" },
-  { manager: "yarn", name: "yarn.lock" },
-  { manager: "bun", name: "bun.lockb" },
-  { manager: "bun", name: "bun.lock" },
-  { manager: "npm", name: "npm-shrinkwrap.json" },
-  { manager: "npm", name: "package-lock.json" },
-]
-
-export function packageManagerStatePaths(root) {
-  return [
-    path.join(root, "package.json"),
-    path.join(root, "pnpm-workspace.yaml"),
-    ...LOCKFILES.map(({ name }) => path.join(root, name)),
-  ]
-}
-
-export async function inspectPackageManagerContext(cwd) {
-  const context = await resolvePackageManagerContext(cwd)
-  const paths = new Set(
-    context.evidenceRoots.flatMap((root) => packageManagerStatePaths(root))
-  )
-  const evidence = await Promise.all(
-    [...paths].map(async (filePath) => {
-      try {
-        return { path: filePath, source: await fs.readFile(filePath) }
-      } catch (error) {
-        if (error.code === "ENOENT") return { path: filePath, source: null }
-        throw error
-      }
-    })
-  )
-  const confirmedContext = await resolvePackageManagerContext(cwd)
-  if (!samePackageManagerContext(context, confirmedContext)) {
-    throw new Error("package-manager context changed while preparing the install plan")
-  }
-
-  return { context, evidence }
-}
-
-export async function resolvePackageManagerContext(cwd) {
-  const projectRoot = path.resolve(cwd)
-  const localContext = await inspectPackageManagerRoot(projectRoot)
-  const workspace = await findWorkspaceRoot(projectRoot)
-  if (workspace.root) {
-    const workspaceContext = await inspectPackageManagerRoot(workspace.root)
-    if (workspaceContext) {
-      if (
-        localContext &&
-        localContext.manager !== workspaceContext.manager
-      ) {
-        throw new Error(
-          `${projectRoot} declares packageManager "${localContext.manager}", ` +
-            `but its workspace root uses "${workspaceContext.manager}".`
-        )
-      }
-      return withEvidenceRoots(workspaceContext, workspace.evidenceRoots)
-    }
-  }
-
-  if (localContext) {
-    return withEvidenceRoots(localContext, workspace.evidenceRoots)
-  }
-
-  return {
-    evidenceRoots: workspace.evidenceRoots,
-    lockfilePath: null,
-    manager: "npm",
-    root: projectRoot,
-  }
-}
-
-async function inspectPackageManagerRoot(root) {
-  const packageJson = await readJsonIfValid(path.join(root, "package.json"))
-  const declaredManager = parsePackageManager(packageJson?.packageManager)
-
-  if (declaredManager) {
-    const lockfile = await findManagerLockfile(root, declaredManager)
-    return {
-      lockfilePath: lockfile ? path.join(root, lockfile.name) : null,
-      manager: declaredManager,
-      root,
-    }
-  }
-
-  const lockfiles = []
-  for (const lockfile of LOCKFILES) {
-    if (await exists(path.join(root, lockfile.name))) lockfiles.push(lockfile)
-  }
-
-  const managers = new Set(lockfiles.map(({ manager }) => manager))
-  if (managers.size > 1) {
-    throw new Error(
-      `${root} contains lockfiles for multiple package managers. ` +
-        "Remove stale lockfiles or declare packageManager in package.json."
-    )
-  }
-
-  if (lockfiles.length > 0) {
-    return {
-      lockfilePath: path.join(root, lockfiles[0].name),
-      manager: lockfiles[0].manager,
-      root,
-    }
-  }
-
-  return null
-}
-
-async function findWorkspaceRoot(projectRoot) {
-  let directory = projectRoot
-  const evidenceRoots = []
-
-  while (true) {
-    evidenceRoots.push(directory)
-    if (directory !== projectRoot) {
-      if (await isWorkspaceRoot(directory, projectRoot)) {
-        return { evidenceRoots, root: directory }
-      }
-    }
-
-    if (await exists(path.join(directory, ".git"))) {
-      return { evidenceRoots, root: null }
-    }
-
-    const parent = path.dirname(directory)
-    if (parent === directory) return { evidenceRoots, root: null }
-    directory = parent
-  }
-}
-
-function withEvidenceRoots(context, evidenceRoots) {
-  return { ...context, evidenceRoots }
-}
-
-function samePackageManagerContext(left, right) {
-  return left.manager === right.manager &&
-    left.root === right.root &&
-    left.lockfilePath === right.lockfilePath &&
-    left.evidenceRoots.join("\0") === right.evidenceRoots.join("\0")
-}
-
-async function isWorkspaceRoot(candidate, projectRoot) {
-  const relativeProject = path.relative(candidate, projectRoot).replaceAll("\\", "/")
-  const pnpmPatterns = await readPnpmWorkspacePatterns(
-    path.join(candidate, "pnpm-workspace.yaml")
-  )
-  if (pnpmPatterns && workspacePatternsMatch(pnpmPatterns, relativeProject)) {
-    return true
-  }
-
-  const packageJson = await readJsonIfValid(path.join(candidate, "package.json"))
-  const patterns = Array.isArray(packageJson?.workspaces)
-    ? packageJson.workspaces
-    : packageJson?.workspaces?.packages
-
-  if (!Array.isArray(patterns)) return false
-  return workspacePatternsMatch(patterns, relativeProject)
-}
-
-function workspacePatternsMatch(patterns, value) {
-  const validPatterns = patterns.filter(
-    (pattern) => typeof pattern === "string" && pattern.length <= 512
-  )
-  const included = validPatterns
-    .filter((pattern) => !pattern.startsWith("!"))
-    .some((pattern) => workspacePatternMatches(pattern, value))
-  const excluded = validPatterns
-    .filter((pattern) => pattern.startsWith("!"))
-    .some((pattern) => workspacePatternMatches(pattern.slice(1), value))
-
-  return included && !excluded
-}
-
-function workspacePatternMatches(pattern, value) {
-  try {
-    return minimatch(value, pattern.replace(/^\.\//, "").replace(/\/$/, ""), {
-      dot: true,
-      nocomment: true,
-      nonegate: true,
-    })
-  } catch {
-    return false
-  }
-}
-
-async function readPnpmWorkspacePatterns(filePath) {
-  try {
-    const workspace = parseYaml(await fs.readFile(filePath, "utf8"))
-    return Array.isArray(workspace?.packages) ? workspace.packages : null
-  } catch (error) {
-    if (error.code === "ENOENT" || error.name === "YAMLParseError") return null
-    throw error
-  }
-}
-
-async function findManagerLockfile(root, manager) {
-  for (const lockfile of LOCKFILES) {
-    if (
-      lockfile.manager === manager &&
-      await exists(path.join(root, lockfile.name))
-    ) {
-      return lockfile
-    }
-  }
-
-  return null
-}
-
-async function readJsonIfValid(filePath) {
-  try {
-    return JSON.parse(await fs.readFile(filePath, "utf8"))
-  } catch (error) {
-    if (error.code === "ENOENT" || error instanceof SyntaxError) return null
-    throw error
-  }
-}
-
-async function exists(filePath) {
-  try {
-    await fs.access(filePath)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function parsePackageManager(packageManager) {
-  if (typeof packageManager !== "string") return null
-
-  const name = packageManager.split("@")[0]
-  return ["npm", "pnpm", "yarn", "bun"].includes(name) ? name : null
-}
+import fs from "node:fs/promises"
+import path from "node:path"
+import { minimatch } from "minimatch"
+import { parse as parseYaml } from "yaml"
+
+const LOCKFILES = [
+  { manager: "pnpm", name: "pnpm-lock.yaml" },
+  { manager: "yarn", name: "yarn.lock" },
+  { manager: "bun", name: "bun.lockb" },
+  { manager: "bun", name: "bun.lock" },
+  { manager: "npm", name: "npm-shrinkwrap.json" },
+  { manager: "npm", name: "package-lock.json" },
+]
+
+export function packageManagerStatePaths(root) {
+  return [
+    path.join(root, "package.json"),
+    path.join(root, "pnpm-workspace.yaml"),
+    ...LOCKFILES.map(({ name }) => path.join(root, name)),
+  ]
+}
+
+export async function inspectPackageManagerContext(cwd) {
+  const context = await resolvePackageManagerContext(cwd)
+  const paths = new Set(
+    context.evidenceRoots.flatMap((root) => packageManagerStatePaths(root))
+  )
+  const evidence = await Promise.all(
+    [...paths].map(async (filePath) => {
+      try {
+        return { path: filePath, source: await fs.readFile(filePath) }
+      } catch (error) {
+        if (error.code === "ENOENT") return { path: filePath, source: null }
+        throw error
+      }
+    })
+  )
+  const confirmedContext = await resolvePackageManagerContext(cwd)
+  if (!samePackageManagerContext(context, confirmedContext)) {
+    throw new Error("package-manager context changed while preparing the install plan")
+  }
+
+  return { context, evidence }
+}
+
+export async function resolvePackageManagerContext(cwd) {
+  const projectRoot = path.resolve(cwd)
+  const localContext = await inspectPackageManagerRoot(projectRoot)
+  const workspace = await findWorkspaceRoot(projectRoot)
+  if (workspace.root) {
+    const workspaceContext = await inspectPackageManagerRoot(workspace.root)
+    if (workspaceContext) {
+      if (
+        localContext &&
+        localContext.manager !== workspaceContext.manager
+      ) {
+        throw new Error(
+          `${projectRoot} declares packageManager "${localContext.manager}", ` +
+            `but its workspace root uses "${workspaceContext.manager}".`
+        )
+      }
+      return withEvidenceRoots(workspaceContext, workspace.evidenceRoots)
+    }
+  }
+
+  if (localContext) {
+    return withEvidenceRoots(localContext, workspace.evidenceRoots)
+  }
+
+  return {
+    evidenceRoots: workspace.evidenceRoots,
+    lockfilePath: null,
+    manager: "npm",
+    root: projectRoot,
+  }
+}
+
+async function inspectPackageManagerRoot(root) {
+  const packageJson = await readJsonIfValid(path.join(root, "package.json"))
+  const declaredManager = parsePackageManager(packageJson?.packageManager)
+
+  if (declaredManager) {
+    const lockfile = await findManagerLockfile(root, declaredManager)
+    return {
+      lockfilePath: lockfile ? path.join(root, lockfile.name) : null,
+      manager: declaredManager,
+      root,
+    }
+  }
+
+  const lockfiles = []
+  for (const lockfile of LOCKFILES) {
+    if (await exists(path.join(root, lockfile.name))) lockfiles.push(lockfile)
+  }
+
+  const managers = new Set(lockfiles.map(({ manager }) => manager))
+  if (managers.size > 1) {
+    throw new Error(
+      `${root} contains lockfiles for multiple package managers. ` +
+        "Remove stale lockfiles or declare packageManager in package.json."
+    )
+  }
+
+  if (lockfiles.length > 0) {
+    return {
+      lockfilePath: path.join(root, lockfiles[0].name),
+      manager: lockfiles[0].manager,
+      root,
+    }
+  }
+
+  return null
+}
+
+async function findWorkspaceRoot(projectRoot) {
+  let directory = projectRoot
+  const evidenceRoots = []
+
+  while (true) {
+    evidenceRoots.push(directory)
+    if (directory !== projectRoot) {
+      if (await isWorkspaceRoot(directory, projectRoot)) {
+        return { evidenceRoots, root: directory }
+      }
+    }
+
+    if (await exists(path.join(directory, ".git"))) {
+      return { evidenceRoots, root: null }
+    }
+
+    const parent = path.dirname(directory)
+    if (parent === directory) return { evidenceRoots, root: null }
+    directory = parent
+  }
+}
+
+function withEvidenceRoots(context, evidenceRoots) {
+  return { ...context, evidenceRoots }
+}
+
+function samePackageManagerContext(left, right) {
+  return left.manager === right.manager &&
+    left.root === right.root &&
+    left.lockfilePath === right.lockfilePath &&
+    left.evidenceRoots.join("\0") === right.evidenceRoots.join("\0")
+}
+
+async function isWorkspaceRoot(candidate, projectRoot) {
+  const relativeProject = path.relative(candidate, projectRoot).replaceAll("\\", "/")
+  const pnpmPatterns = await readPnpmWorkspacePatterns(
+    path.join(candidate, "pnpm-workspace.yaml")
+  )
+  if (pnpmPatterns && workspacePatternsMatch(pnpmPatterns, relativeProject)) {
+    return true
+  }
+
+  const packageJson = await readJsonIfValid(path.join(candidate, "package.json"))
+  const patterns = Array.isArray(packageJson?.workspaces)
+    ? packageJson.workspaces
+    : packageJson?.workspaces?.packages
+
+  if (!Array.isArray(patterns)) return false
+  return workspacePatternsMatch(patterns, relativeProject)
+}
+
+function workspacePatternsMatch(patterns, value) {
+  const validPatterns = patterns.filter(
+    (pattern) => typeof pattern === "string" && pattern.length <= 512
+  )
+  const included = validPatterns
+    .filter((pattern) => !pattern.startsWith("!"))
+    .some((pattern) => workspacePatternMatches(pattern, value))
+  const excluded = validPatterns
+    .filter((pattern) => pattern.startsWith("!"))
+    .some((pattern) => workspacePatternMatches(pattern.slice(1), value))
+
+  return included && !excluded
+}
+
+function workspacePatternMatches(pattern, value) {
+  try {
+    return minimatch(value, pattern.replace(/^\.\//, "").replace(/\/$/, ""), {
+      dot: true,
+      nocomment: true,
+      nonegate: true,
+    })
+  } catch {
+    return false
+  }
+}
+
+async function readPnpmWorkspacePatterns(filePath) {
+  try {
+    const workspace = parseYaml(await fs.readFile(filePath, "utf8"))
+    return Array.isArray(workspace?.packages) ? workspace.packages : null
+  } catch (error) {
+    if (error.code === "ENOENT" || error.name === "YAMLParseError") return null
+    throw error
+  }
+}
+
+async function findManagerLockfile(root, manager) {
+  for (const lockfile of LOCKFILES) {
+    if (
+      lockfile.manager === manager &&
+      await exists(path.join(root, lockfile.name))
+    ) {
+      return lockfile
+    }
+  }
+
+  return null
+}
+
+async function readJsonIfValid(filePath) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"))
+  } catch (error) {
+    if (error.code === "ENOENT" || error instanceof SyntaxError) return null
+    throw error
+  }
+}
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function parsePackageManager(packageManager) {
+  if (typeof packageManager !== "string") return null
+
+  const name = packageManager.split("@")[0]
+  return ["npm", "pnpm", "yarn", "bun"].includes(name) ? name : null
+}