skyltmax_config 1.0.0 → 2.0.0

data/scripts/peer-deps/audit.js

@@ -1,132 +0,0 @@
-#!/usr/bin/env node
-
-import { existsSync, realpathSync } from "node:fs"
-import { readFile } from "node:fs/promises"
-import { createRequire } from "node:module"
-import { dirname, resolve } from "node:path"
-import { fileURLToPath } from "node:url"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const defaultManifestPath = resolve(__dirname, "..", "..", "package.json")
-const defaultConsumerRoot = process.env.INIT_CWD ?? process.env.npm_config_local_prefix ?? process.cwd()
-
-async function readManifest(path) {
-  const raw = await readFile(path, "utf8")
-  return JSON.parse(raw)
-}
-
-function createConsumerRequire(root) {
-  const candidate = resolve(root, "package.json")
-  if (existsSync(candidate)) {
-    return createRequire(candidate)
-  }
-
-  return createRequire(import.meta.url)
-}
-
-export async function auditPeerDependencies({
-  manifestPath = defaultManifestPath,
-  consumerRoot = defaultConsumerRoot,
-} = {}) {
-  const manifest = await readManifest(manifestPath)
-  const peers = Object.entries(manifest.peerDependencies ?? {})
-
-  if (!peers.length) {
-    return {
-      peers,
-      missing: [],
-      mismatched: [],
-    }
-  }
-
-  const requireFromConsumer = createConsumerRequire(consumerRoot)
-  const missing = []
-  const mismatched = []
-
-  for (const [name, expectedVersion] of peers) {
-    let resolvedPackageJson
-    try {
-      resolvedPackageJson = requireFromConsumer.resolve(`${name}/package.json`)
-    } catch (error) {
-      missing.push({ name, expectedVersion, reason: error.message })
-      continue
-    }
-
-    try {
-      const pkg = JSON.parse(await readFile(resolvedPackageJson, "utf8"))
-      const actualVersion = pkg.version
-      if (actualVersion !== expectedVersion) {
-        mismatched.push({ name, expectedVersion, actualVersion })
-      }
-    } catch (error) {
-      mismatched.push({ name, expectedVersion, actualVersion: "unknown", reason: error.message })
-    }
-  }
-
-  return {
-    peers,
-    missing,
-    mismatched,
-  }
-}
-
-export function formatAuditMessage({ missing, mismatched }) {
-  if (!missing.length && !mismatched.length) {
-    return null
-  }
-
-  const lines = ["[skyltmax-config] Peer dependency check detected issues:"]
-
-  if (missing.length) {
-    lines.push("  Missing peers:")
-    for (const item of missing) {
-      lines.push(`    - ${item.name}@${item.expectedVersion}`)
-    }
-  }
-
-  if (mismatched.length) {
-    lines.push("  Version mismatches:")
-    for (const item of mismatched) {
-      const details = item.actualVersion ? ` (found ${item.actualVersion})` : ""
-      lines.push(`    - ${item.name}@${item.expectedVersion}${details}`)
-    }
-  }
-
-  lines.push('  Run "npx skyltmax-config-peers" to install the correct versions.')
-
-  return lines.join("\n")
-}
-
-export async function runPostinstallAudit() {
-  try {
-    const result = await auditPeerDependencies()
-    const message = formatAuditMessage(result)
-
-    if (message) {
-      console.warn(message)
-    }
-  } catch (error) {
-    console.warn(`[skyltmax-config] Peer dependency check skipped: ${error.message}`)
-  }
-}
-
-const isDirectExecution = (() => {
-  const [argvPath] = process.argv.slice(1, 2)
-
-  if (!argvPath) return false
-
-  try {
-    return realpathSync(argvPath) === realpathSync(__filename)
-  } catch (error) {
-    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-      return false
-    }
-
-    throw error
-  }
-})()
-
-if (isDirectExecution) {
-  runPostinstallAudit()
-}

data/scripts/peer-deps/install.js

@@ -1,206 +0,0 @@
-#!/usr/bin/env node
-import { spawn } from "node:child_process"
-import { existsSync, realpathSync } from "node:fs"
-import { readFile } from "node:fs/promises"
-import { dirname, resolve } from "node:path"
-import { fileURLToPath } from "node:url"
-
-const HELP = `Usage: skyltmax-config-peers [options]
-
-Options:
-  --manager <name>   npm | pnpm | bun (auto-detected by default)
-  --dry-run          Print the install command without running it
-  --help             Show this help message
-`
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-const defaultManifestPath = resolve(__dirname, "..", "..", "package.json")
-
-export async function loadPeerDependencies(manifestPath = defaultManifestPath) {
-  const manifest = JSON.parse(await readFile(manifestPath, "utf8"))
-  const peers = manifest.peerDependencies ?? {}
-  return Object.entries(peers).map(([name, version]) => `${name}@${version}`)
-}
-
-export function detectManager({ managerArg, userAgent = "", cwd = process.cwd() } = {}) {
-  if (managerArg) return managerArg
-
-  if (userAgent.startsWith("pnpm/")) return "pnpm"
-  if (userAgent.startsWith("bun/")) return "bun"
-  if (userAgent.startsWith("npm/")) return "npm"
-
-  if (existsSync(resolve(cwd, "pnpm-lock.yaml"))) return "pnpm"
-  if (existsSync(resolve(cwd, "bun.lockb"))) return "bun"
-  if (existsSync(resolve(cwd, "package-lock.json"))) return "npm"
-
-  return "npm"
-}
-
-export function findPnpmWorkspaceRoot(startDir) {
-  let current = resolve(startDir)
-
-  while (true) {
-    if (existsSync(resolve(current, "pnpm-workspace.yaml")) || existsSync(resolve(current, "pnpm-workspace.yml"))) {
-      return current
-    }
-
-    const parent = dirname(current)
-
-    if (parent === current) {
-      return undefined
-    }
-
-    current = parent
-  }
-}
-
-export function buildInstallCommand(manager, packages, { cwd = process.cwd() } = {}) {
-  if (!packages.length) {
-    throw new Error("No peer dependencies to install.")
-  }
-
-  if (manager === "pnpm") {
-    const workspaceRoot = findPnpmWorkspaceRoot(cwd)
-    const args = ["add", "-D", "--save-exact", ...packages]
-
-    if (workspaceRoot) {
-      args.splice(2, 0, "-w")
-    }
-
-    return {
-      command: "pnpm",
-      args,
-      cwd: workspaceRoot ?? cwd,
-    }
-  }
-
-  if (manager === "npm") {
-    return {
-      command: "npm",
-      args: ["install", "--save-dev", "--save-exact", ...packages],
-      cwd,
-    }
-  }
-
-  if (manager === "bun") {
-    return {
-      command: "bun",
-      args: ["add", "--dev", "--exact", ...packages],
-      cwd,
-    }
-  }
-
-  const supported = "npm, pnpm, bun"
-  throw new Error(`Unsupported package manager: ${manager}. Supported managers: ${supported}`)
-}
-
-export function formatCommand({ command, args }) {
-  return `${command} ${args.join(" ")}`
-}
-
-export async function prepareInstall({
-  managerArg,
-  cwd = process.cwd(),
-  env = process.env,
-  manifestPath = defaultManifestPath,
-} = {}) {
-  const packages = await loadPeerDependencies(manifestPath)
-
-  if (packages.length === 0) {
-    return { packages: [] }
-  }
-
-  const manager = detectManager({ managerArg, userAgent: env.npm_config_user_agent ?? "", cwd })
-  const command = buildInstallCommand(manager, packages, { cwd })
-
-  return {
-    manager,
-    packages,
-    command: command.command,
-    args: command.args,
-    cwd: command.cwd ?? cwd,
-    printable: formatCommand(command),
-  }
-}
-
-export async function runCli({ args = process.argv.slice(2), env = process.env, cwd = process.cwd() } = {}) {
-  if (args.includes("--help")) {
-    process.stdout.write(HELP)
-    return 0
-  }
-
-  const argValue = flag => {
-    const index = args.indexOf(flag)
-    if (index === -1) return undefined
-    return args[index + 1]
-  }
-
-  const managerArg = argValue("--manager")
-  const dryRun = args.includes("--dry-run")
-
-  try {
-    const result = await prepareInstall({ managerArg, cwd, env })
-
-    if (!result.packages || result.packages.length === 0) {
-      process.stdout.write("No peer dependencies found on @skyltmax/config.\n")
-      return 0
-    }
-
-    if (dryRun) {
-      process.stdout.write(`${result.printable}\n`)
-      return 0
-    }
-
-    process.stdout.write(`Running: ${result.printable}\n`)
-
-    const child = spawn(result.command, result.args, {
-      stdio: "inherit",
-      cwd: result.cwd,
-    })
-
-    return await new Promise((resolve, reject) => {
-      child.on("close", code => {
-        if (code === 0) {
-          resolve(0)
-        } else {
-          reject(new Error(`${result.command} exited with code ${code}`))
-        }
-      })
-
-      child.on("error", error => {
-        reject(error)
-      })
-    })
-  } catch (error) {
-    process.stderr.write(`${error.message}\n`)
-    return 1
-  }
-}
-
-const isDirectExecution = (() => {
-  const [argvPath] = process.argv.slice(1, 2)
-
-  if (!argvPath) return false
-
-  try {
-    return realpathSync(argvPath) === realpathSync(__filename)
-  } catch (error) {
-    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-      return false
-    }
-
-    throw error
-  }
-})()
-
-if (isDirectExecution) {
-  runCli()
-    .then(code => {
-      process.exit(code)
-    })
-    .catch(error => {
-      process.stderr.write(`${error.message}\n`)
-      process.exit(1)
-    })
-}

data/tests/check-peers.test.js

@@ -1,76 +0,0 @@
-import { mkdtemp, writeFile, mkdir } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { fileURLToPath } from "node:url"
-import { describe, expect, test } from "vitest"
-
-import { auditPeerDependencies, formatAuditMessage } from "../scripts/peer-deps/audit.js"
-
-const fixturePath = relative => fileURLToPath(new URL(`./fixtures/${relative}`, import.meta.url))
-
-async function createPackage(root, name, version) {
-  const parts = name.split("/")
-  const packageDir = join(root, "node_modules", ...parts)
-  await mkdir(packageDir, { recursive: true })
-  await writeFile(join(packageDir, "package.json"), JSON.stringify({ name, version }), "utf8")
-}
-
-async function createProjectRoot() {
-  const root = await mkdtemp(join(tmpdir(), "skyltmax-check-peers-"))
-  await writeFile(join(root, "package.json"), JSON.stringify({ name: "example", version: "1.0.0" }), "utf8")
-  return root
-}
-
-describe("check-peers audit", () => {
-  test("returns empty when all peers match", async () => {
-    const root = await createProjectRoot()
-    await createPackage(root, "eslint", "9.39.1")
-    await createPackage(root, "prettier", "3.6.2")
-
-    const result = await auditPeerDependencies({
-      manifestPath: fixturePath("manifest-with-peers.json"),
-      consumerRoot: root,
-    })
-
-    expect(result.missing).toEqual([])
-    expect(result.mismatched).toEqual([])
-    expect(formatAuditMessage(result)).toBeNull()
-  })
-
-  test("detects missing peers", async () => {
-    const root = await createProjectRoot()
-    await createPackage(root, "eslint", "9.39.1")
-
-    const result = await auditPeerDependencies({
-      manifestPath: fixturePath("manifest-with-peers.json"),
-      consumerRoot: root,
-    })
-
-    expect(result.missing.map(item => item.name)).toEqual(["prettier"])
-    const message = formatAuditMessage(result)
-    expect(message).toContain("Missing peers")
-    expect(message).toContain("prettier@3.6.2")
-  })
-
-  test("detects version mismatches", async () => {
-    const root = await createProjectRoot()
-    await createPackage(root, "eslint", "9.0.0")
-    await createPackage(root, "prettier", "3.6.2")
-
-    const result = await auditPeerDependencies({
-      manifestPath: fixturePath("manifest-with-peers.json"),
-      consumerRoot: root,
-    })
-
-    expect(result.mismatched).toEqual([
-      {
-        name: "eslint",
-        expectedVersion: "9.39.1",
-        actualVersion: "9.0.0",
-      },
-    ])
-    const message = formatAuditMessage(result)
-    expect(message).toContain("Version mismatches")
-    expect(message).toContain("eslint@9.39.1 (found 9.0.0)")
-  })
-})

data/tests/fixtures/manifest-no-peers.json

@@ -1,3 +0,0 @@
-{
-  "name": "example"
-}

data/tests/fixtures/manifest-with-peers.json

@@ -1,6 +0,0 @@
-{
-  "peerDependencies": {
-    "eslint": "9.39.1",
-    "prettier": "3.6.2"
-  }
-}

data/tests/install-peers.test.js

@@ -1,115 +0,0 @@
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { fileURLToPath } from "node:url"
-import { describe, expect, test } from "vitest"
-
-import {
-  buildInstallCommand,
-  detectManager,
-  formatCommand,
-  loadPeerDependencies,
-  prepareInstall,
-} from "../scripts/peer-deps/install.js"
-
-const fixturePath = relative => fileURLToPath(new URL(`./fixtures/${relative}`, import.meta.url))
-
-describe("install-peers helper", () => {
-  test("loadPeerDependencies returns pinned peers", async () => {
-    const peers = await loadPeerDependencies(fixturePath("manifest-with-peers.json"))
-    expect(peers).toEqual(["eslint@9.39.1", "prettier@3.6.2"])
-  })
-
-  test("loadPeerDependencies handles missing peers", async () => {
-    const peers = await loadPeerDependencies(fixturePath("manifest-no-peers.json"))
-    expect(peers).toEqual([])
-  })
-
-  test("detectManager respects explicit flag", () => {
-    const manager = detectManager({ managerArg: "pnpm" })
-    expect(manager).toBe("pnpm")
-  })
-
-  test("detectManager infers from user agent", () => {
-    const manager = detectManager({ userAgent: "pnpm/9.0.0 npm/?" })
-    expect(manager).toBe("pnpm")
-  })
-
-  test("detectManager infers from lockfile", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "skyltmax-config-"))
-    await writeFile(join(dir, "bun.lockb"), "")
-    const manager = detectManager({ cwd: dir })
-    expect(manager).toBe("bun")
-  })
-
-  test("buildInstallCommand supports npm", () => {
-    const result = buildInstallCommand("npm", ["eslint@9.39.1"])
-    expect(result.command).toBe("npm")
-    expect(result.args).toEqual(["install", "--save-dev", "--save-exact", "eslint@9.39.1"])
-    expect(formatCommand(result)).toBe("npm install --save-dev --save-exact eslint@9.39.1")
-  })
-
-  test("buildInstallCommand adds -w flag in pnpm workspaces", async () => {
-    const workspaceDir = await mkdtemp(join(tmpdir(), "skyltmax-config-workspace-"))
-    await writeFile(join(workspaceDir, "pnpm-workspace.yaml"), "packages:\n  - packages/*\n")
-    const packageDir = join(workspaceDir, "packages", "app")
-    await mkdir(packageDir, { recursive: true })
-
-    const result = buildInstallCommand("pnpm", ["eslint@9.39.1"], { cwd: packageDir })
-
-    expect(result.command).toBe("pnpm")
-    expect(result.args).toEqual(["add", "-D", "-w", "--save-exact", "eslint@9.39.1"])
-    expect(result.cwd).toBe(workspaceDir)
-  })
-
-  test("buildInstallCommand throws on unsupported manager", () => {
-    expect(() => buildInstallCommand("yarn", ["eslint@9.39.1"])).toThrow(/Unsupported package manager/)
-  })
-
-  test("prepareInstall returns printable command", async () => {
-    const result = await prepareInstall({
-      managerArg: "npm",
-      env: {},
-      cwd: process.cwd(),
-      manifestPath: fixturePath("manifest-with-peers.json"),
-    })
-
-    expect(result.manager).toBe("npm")
-    expect(result.packages).toEqual(["eslint@9.39.1", "prettier@3.6.2"])
-    expect(result.printable).toBe("npm install --save-dev --save-exact eslint@9.39.1 prettier@3.6.2")
-  })
-
-  test("prepareInstall targets pnpm workspace root", async () => {
-    const workspaceDir = await mkdtemp(join(tmpdir(), "skyltmax-config-workspace-"))
-    await writeFile(join(workspaceDir, "pnpm-workspace.yaml"), "packages:\n  - packages/*\n")
-    const manifestPath = join(workspaceDir, "package.json")
-    await writeFile(manifestPath, JSON.stringify({ peerDependencies: { eslint: "9.39.1" } }, null, 2))
-
-    const packageDir = join(workspaceDir, "packages", "app")
-    await mkdir(packageDir, { recursive: true })
-
-    const result = await prepareInstall({
-      managerArg: "pnpm",
-      env: {},
-      cwd: packageDir,
-      manifestPath,
-    })
-
-    expect(result.manager).toBe("pnpm")
-    expect(result.packages).toEqual(["eslint@9.39.1"])
-    expect(result.args).toEqual(["add", "-D", "-w", "--save-exact", "eslint@9.39.1"])
-    expect(result.cwd).toBe(workspaceDir)
-    expect(result.printable).toBe("pnpm add -D -w --save-exact eslint@9.39.1")
-  })
-
-  test("prepareInstall returns empty when no peers", async () => {
-    const result = await prepareInstall({
-      managerArg: "npm",
-      env: {},
-      cwd: process.cwd(),
-      manifestPath: fixturePath("manifest-no-peers.json"),
-    })
-
-    expect(result.packages).toEqual([])
-  })
-})