dsh-deps 0.0.1 → 0.1.0

package/lib/plan.mjs

@@ -0,0 +1,205 @@
+/**
+ * 建议顺序 + 体检汇总 + why 解释。全部只读，不写文件。
+ *
+ * 排序判据（写死）：
+ *   1) 先 patch，再 minor，最后 major；
+ *   2) 同组内按「被依赖次数」降序，次数相同按名字升序；
+ *   3) blocked（engines 不兼容 / 当前版本被 yanked）不进入升级队列；
+ *   4) unknown（快照缺失 / 范围不可判定）不猜、不排队，单列。
+ */
+
+import { RISK_RANK, RISK_LABEL, BUMPS } from './classify.mjs'
+
+/** 信号严重度排序（选「最该先看」的建议动作用）。 */
+const SEVERITY_RANK = { blocked: 4, high: 3, medium: 2, info: 1, unknown: 0 }
+
+/** 升级阶段的先后（写死）。 */
+export const PHASES = ['patch', 'minor', 'major']
+
+/** 阶段说明。 */
+export const PHASE_LABEL = { patch: 'patch（同 minor 内）', minor: 'minor（同 major 内）', major: 'major（跨大版本）' }
+
+/** 排序理由（给报告与 README 共用）。 */
+export const ORDER_RATIONALE = '先 patch 后 minor 再 major：小步先行，每一步都能单独测试与回滚，出问题容易二分定位；同组内按被依赖次数降序：被依赖越多，升级收益越大，也越早暴露兼容问题，先升它能让后续升级更安全。blocked 不进队列，unknown 不猜。'
+
+/**
+ * 排序比较器。
+ * @param {object} a 条目 a
+ * @param {object} b 条目 b
+ * @returns {number} 比较结果
+ */
+function compareForOrder(a, b) {
+  const phase = PHASES.indexOf(a.bump) - PHASES.indexOf(b.bump)
+  if (phase !== 0) return phase
+  if (b.dependents !== a.dependents) return b.dependents - a.dependents
+  return a.name.localeCompare(b.name)
+}
+
+/**
+ * 生成升级计划。
+ * @param {object[]} entries 分类后的条目
+ * @param {{countSource?:string}} [options] 选项
+ * @returns {object} 计划
+ */
+export function buildPlan(entries, options = {}) {
+  const actionable = entries.filter((entry) => PHASES.includes(entry.bump) && entry.risk !== 'blocked')
+  const blocked = entries.filter((entry) => entry.risk === 'blocked')
+  const unknown = entries.filter((entry) => entry.bump === 'unknown' && entry.risk !== 'blocked')
+  const pinned = entries.filter((entry) => entry.bump === 'pinned')
+
+  const sorted = actionable.slice().sort(compareForOrder)
+  const order = sorted.map((entry, index) => ({
+    step: index + 1,
+    name: entry.name,
+    bump: entry.bump,
+    risk: entry.risk,
+    current: entry.current,
+    currentVersion: entry.currentVersion,
+    latest: entry.latest,
+    suggested: entry.suggested,
+    dependents: entry.dependents,
+    group: entry.bump,
+    orderReason: `${entry.bump} 组第 ${sorted.filter((item) => item.bump === entry.bump).indexOf(entry) + 1} 个：被 ${entry.dependents} 个包依赖${entry.risk === 'high' ? '，但属于高风险升级，建议单独 PR' : ''}`,
+  }))
+
+  const groups = {
+    patch: order.filter((item) => item.bump === 'patch'),
+    minor: order.filter((item) => item.bump === 'minor'),
+    major: order.filter((item) => item.bump === 'major'),
+  }
+
+  const counts = {
+    total: entries.length,
+    actionable: actionable.length,
+    byBump: Object.fromEntries(BUMPS.map((bump) => [bump, entries.filter((entry) => entry.bump === bump).length])),
+    byRisk: Object.fromEntries(Object.keys(RISK_RANK).map((risk) => [risk, entries.filter((entry) => entry.risk === risk).length])),
+  }
+
+  return {
+    order,
+    groups,
+    blocked: blocked.map(summarize),
+    unknown: unknown.map(summarize),
+    pinned: pinned.map(summarize),
+    rationale: ORDER_RATIONALE,
+    phaseOrder: [...PHASES],
+    counts,
+    countSource: options.countSource ?? 'single-manifest',
+  }
+}
+
+/**
+ * 报告里用的条目摘要（不带 signals 细节）。
+ * @param {object} entry 条目
+ * @returns {object} 摘要
+ */
+function summarize(entry) {
+  return {
+    name: entry.name,
+    bump: entry.bump,
+    risk: entry.risk,
+    current: entry.current,
+    currentVersion: entry.currentVersion,
+    latest: entry.latest,
+    dependents: entry.dependents,
+    reason: entry.reason,
+    action: (entry.signals.slice().sort((a, b) => SEVERITY_RANK[b.severity] - SEVERITY_RANK[a.severity]).find((signal) => signal.action)?.action) ?? null,
+  }
+}
+
+/**
+ * 一次性体检汇总。
+ * @param {object[]} entries 条目
+ * @param {object} plan 计划
+ * @param {object[]} problems 数据问题
+ * @param {{nodeVersion?:string, snapshotProvided?:boolean}} [context] 上下文
+ * @returns {object} 体检结果
+ */
+export function auditReport(entries, plan, problems = [], context = {}) {
+  const counts = plan.counts
+  const serious = entries.filter((entry) => entry.risk === 'high' || entry.risk === 'blocked')
+  const mi = entries.filter((entry) => entry.bump === 'minor')
+  const verdict = entries.length === 0 ? 'empty'
+    : serious.length > 0 ? 'risk'
+      : mi.length > 0 || counts.byBump.unknown > 0 ? 'warn'
+        : 'ok'
+
+  const signals = {}
+  for (const entry of entries) {
+    for (const signal of entry.signals) signals[signal.signal] = (signals[signal.signal] ?? 0) + 1
+  }
+
+  return {
+    verdict,
+    counts,
+    signals,
+    nodeVersion: context.nodeVersion ?? null,
+    snapshotProvided: context.snapshotProvided === true,
+    summary: summarizeVerdict(verdict, counts, serious.length),
+    recommendations: recommendationsFor(entries, plan, problems),
+    problems,
+  }
+}
+
+/**
+ * 结论一句话。
+ * @param {string} verdict 结论
+ * @param {object} counts 计数
+ * @param {number} serious 高风险数
+ * @returns {string} 文案
+ */
+function summarizeVerdict(verdict, counts, serious) {
+  if (verdict === 'empty') return '没有依赖需要规划。'
+  if (verdict === 'risk') return `有 ${serious} 个高风险/被阻塞项：先处理它们，再按建议顺序升其余 ${counts.actionable} 个。`
+  if (verdict === 'warn') return `没有高危项，但有 ${counts.byBump.minor} 个 minor 或 ${counts.byBump.unknown} 个 unknown；按建议顺序小步升。`
+  return `只有低风险升级（${counts.actionable} 个可升），按建议顺序执行即可。`
+}
+
+/**
+ * 建议动作清单。
+ * @param {object[]} entries 条目
+ * @param {object} plan 计划
+ * @param {object[]} problems 数据问题
+ * @returns {string[]} 建议
+ */
+function recommendationsFor(entries, plan, problems) {
+  const list = []
+  if (plan.blocked.length > 0) list.push(`先处理 ${plan.blocked.length} 个被阻塞项（engines 不兼容 / 当前版本被 yanked）：${plan.blocked.map((item) => item.name).join('、')}`)
+  if (plan.counts.byBump.unknown > 0) list.push(`补 ${plan.counts.byBump.unknown} 个 unknown 项的快照（npm view <name> version 写进本地快照），不要凭印象升`)
+  if (plan.counts.byBump.major > 0) list.push(`major 升级共 ${plan.counts.byBump.major} 个：单独 PR、读 CHANGELOG、准备回滚`)
+  if (plan.order.length > 0) list.push(`按 ${plan.order.length} 步顺序执行；每步升完跑测试再进下一步`)
+  if (problems.length > 0) list.push(`先修数据问题：${problems.slice(0, 3).join('；')}`)
+  return list
+}
+
+/**
+ * why：解释一个依赖为什么是这个判定。
+ * @param {string} name 依赖名
+ * @param {object[]} entries 条目
+ * @param {object} context 上下文
+ * @param {object} context.snapshot 快照 Map
+ * @param {object} context.installed installed Map
+ * @param {string} context.nodeVersion Node 版本
+ * @param {object} context.manifest 根 manifest
+ * @returns {object} 解释
+ */
+export function explainEntry(name, entries, context) {
+  const entry = entries.find((item) => item.name === name)
+  if (!entry) return { found: false, name, reason: `依赖清单里没有 ${name}`, checks: [], conclusion: `依赖清单里没有 ${name}：它不是这份 package.json 的依赖，无从判定。` }
+  const snapshotEntry = context.snapshot.get(name)
+  const checks = [
+    { id: 'declared-range', value: entry.current, detail: `package.json 声明 ${entry.section}: ${entry.name} = ${entry.current}` },
+    { id: 'current-version', value: entry.currentVersion, detail: entry.versionSource === 'installed' ? '来自 installed 快照' : entry.versionSource === 'range-floor' ? '取自声明范围下界（不是 lock 里的实际版本）' : '无法确定' },
+    { id: 'snapshot', value: snapshotEntry ? snapshotEntry.latest : null, detail: snapshotEntry ? `本地快照 latest=${snapshotEntry.latest ?? '(缺失)'}` : '本地快照里没有这个包' },
+    { id: 'bump', value: entry.bump, detail: entry.reason },
+    { id: 'risk', value: entry.risk, detail: RISK_LABEL[entry.risk] ?? entry.risk },
+    { id: 'signals', value: entry.signals.map((signal) => signal.signal), detail: entry.signals.map((signal) => signal.detail).join('；') || '没有触发风险信号' },
+  ]
+  if (entry.peer) checks.push({ id: 'peer', value: entry.current, detail: `这是 peerDependency：升级要同时确认宿主支持，并同步 peer 范围` })
+  const conclusion = entry.bump === 'unknown'
+    ? `未判定：${entry.reason}`
+    : entry.bump === 'pinned'
+      ? `无需升级：${entry.reason}`
+      : `判定为 ${entry.bump}（风险 ${entry.risk}）：${entry.reason}`
+  return { found: true, name, entry, checks, conclusion }
+}

package/lib/version.mjs

@@ -0,0 +1,270 @@
+/**
+ * semver 子集：只做「升级规划」需要的解析、比较、范围判定与范围下界。
+ *
+ * 明确支持：`1.2.3` / `^1.2.3` / `~1.2.3` / `>=1.2.3` / `>1.2.3` / `<=` / `<` /
+ * 空格连接的 AND 范围 / `||` OR / `1.x` / `1.2.x` / `*` / 连字符 `1.2.3 - 2.3.4`。
+ *
+ * **明确不支持**（调用方会看到 unknown，而不是猜）：
+ * `npm:` 别名、`git:`/`github:`、`file:`、`link:`、`workspace:`、`latest` 标签、
+ * 以及 npm 的 prerelease 特例（`^1.2.3` 不自动含 `1.3.0-beta`）。
+ */
+
+/** 版本解析失败。 */
+export class SemverError extends Error {
+  /**
+   * @param {string} message 说明
+   */
+  constructor(message) {
+    super(message)
+    this.name = 'SemverError'
+  }
+}
+
+/** 非 semver 的范围前缀：这些一律 unknown，不去猜。 */
+export const UNSUPPORTED_RANGE_PREFIXES = ['npm:', 'git:', 'git+', 'github:', 'file:', 'link:', 'workspace:', 'http:', 'https:', 'portal:', 'patch:']
+
+/**
+ * 解析版本。
+ * @param {unknown} input 版本字符串
+ * @returns {{major:number, minor:number, patch:number, prerelease:string[], raw:string}|null} 解析结果
+ */
+export function parseVersion(input) {
+  if (typeof input !== 'string') return null
+  const text = input.trim().replace(/^v/i, '')
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(text)
+  if (!match) return null
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split('.') : [],
+    raw: text,
+  }
+}
+
+/**
+ * 比较两个版本。
+ * @param {object|string} a 版本 a
+ * @param {object|string} b 版本 b
+ * @returns {number} -1 / 0 / 1
+ */
+export function compareVersions(a, b) {
+  const left = typeof a === 'string' ? parseVersion(a) : a
+  const right = typeof b === 'string' ? parseVersion(b) : b
+  if (!left || !right) throw new SemverError(`无法比较版本：${String(a)} vs ${String(b)}`)
+  for (const key of ['major', 'minor', 'patch']) {
+    if (left[key] !== right[key]) return left[key] > right[key] ? 1 : -1
+  }
+  const leftPre = left.prerelease ?? []
+  const rightPre = right.prerelease ?? []
+  if (leftPre.length === 0 && rightPre.length === 0) return 0
+  if (leftPre.length === 0) return 1
+  if (rightPre.length === 0) return -1
+  for (let i = 0; i < Math.max(leftPre.length, rightPre.length); i++) {
+    const x = leftPre[i]
+    const y = rightPre[i]
+    if (x === undefined) return -1
+    if (y === undefined) return 1
+    const nx = /^\d+$/.test(x)
+    const ny = /^\d+$/.test(y)
+    if (nx && ny) {
+      if (Number(x) !== Number(y)) return Number(x) > Number(y) ? 1 : -1
+    } else if (nx !== ny) {
+      return nx ? -1 : 1
+    } else if (x !== y) {
+      return x > y ? 1 : -1
+    }
+  }
+  return 0
+}
+
+/**
+ * 版本是否严格相等。
+ * @param {string} a 版本 a
+ * @param {string} b 版本 b
+ * @returns {boolean} 是否相等
+ */
+export function versionEquals(a, b) {
+  const left = parseVersion(a)
+  const right = parseVersion(b)
+  return Boolean(left && right && compareVersions(left, right) === 0)
+}
+
+/**
+ * 解析一个比较器（`>=1.2.3` / `^1.2.3` / `1.2.x` …）。
+ * @param {string} token 片段
+ * @returns {object|null} 比较器
+ */
+function parseComparator(token) {
+  const text = token.trim()
+  if (text === '' || text === '*' || text === 'x' || text === 'X') return null
+  const match = /^(>=|<=|>|<|=|\^|~)?\s*v?(\d+|[x*])(?:\.(\d+|[x*]))?(?:\.(\d+|[x*]))?(?:-([0-9A-Za-z.-]+))?$/.exec(text)
+  if (!match) return undefined
+  const op = match[1] ?? ''
+  const wild = (part) => part === undefined || part === 'x' || part === 'X' || part === '*'
+  const nums = [match[2], match[3], match[4]]
+  if (wild(nums[0])) return null
+  const major = Number(nums[0])
+  const minor = wild(nums[1]) ? null : Number(nums[1])
+  const patch = wild(nums[2]) ? null : Number(nums[2])
+  const prerelease = match[5] ? match[5].split('.') : []
+
+  if (op === '^') {
+    if (minor === null) return { op: 'range', from: { major, minor: 0, patch: 0 }, to: { major: major + 1, minor: 0, patch: 0 } }
+    if (patch === null) return { op: 'range', from: { major, minor, patch: 0 }, to: { major: major + 1, minor: 0, patch: 0 } }
+    if (major > 0) return { op: 'range', from: { major, minor, patch }, to: { major: major + 1, minor: 0, patch: 0 } }
+    if (minor > 0) return { op: 'range', from: { major, minor, patch }, to: { major: 0, minor: minor + 1, patch: 0 } }
+    return { op: 'range', from: { major, minor, patch }, to: { major: 0, minor: 0, patch: patch + 1 } }
+  }
+
+  if (op === '~' || (op === '' && (minor === null || patch === null))) {
+    if (minor === null) return { op: 'range', from: { major, minor: 0, patch: 0 }, to: { major: major + 1, minor: 0, patch: 0 } }
+    return { op: 'range', from: { major, minor, patch: patch ?? 0 }, to: { major, minor: minor + 1, patch: 0 } }
+  }
+
+  if (op === '' || op === '=') {
+    if (patch === null) {
+      return minor === null
+        ? { op: 'range', from: { major, minor: 0, patch: 0 }, to: { major: major + 1, minor: 0, patch: 0 } }
+        : { op: 'range', from: { major, minor, patch: 0 }, to: { major, minor: minor + 1, patch: 0 } }
+    }
+    return { op: 'eq', version: { major, minor, patch, prerelease } }
+  }
+
+  const version = { major, minor: minor ?? 0, patch: patch ?? 0, prerelease }
+  return { op, version }
+}
+
+/**
+ * 判断版本是否落在单个比较器集合（AND）里。
+ * @param {object} version 版本
+ * @param {Array<object|null>} comparators 比较器
+ * @returns {boolean} 是否满足
+ */
+function satisfiesSet(version, comparators) {
+  for (const comparator of comparators) {
+    if (comparator === null) continue
+    if (comparator.op === 'eq') {
+      if (compareVersions(version, comparator.version) !== 0) return false
+    } else if (comparator.op === 'range') {
+      if (compareVersions(version, comparator.from) < 0) return false
+      if (compareVersions(version, comparator.to) >= 0) return false
+    } else if (comparator.op === '>=') {
+      if (compareVersions(version, comparator.version) < 0) return false
+    } else if (comparator.op === '>') {
+      if (compareVersions(version, comparator.version) <= 0) return false
+    } else if (comparator.op === '<=') {
+      if (compareVersions(version, comparator.version) > 0) return false
+    } else if (comparator.op === '<') {
+      if (compareVersions(version, comparator.version) >= 0) return false
+    } else {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * 解析范围；不支持或不认识就返回 null（调用方标 unknown）。
+ * @param {unknown} range 范围字符串
+ * @returns {{sets:Array<Array<object>>}|null} 解析结果
+ */
+export function parseRange(range) {
+  if (typeof range !== 'string') return null
+  const text = range.trim()
+  if (text.length === 0) return null
+  const lower = text.toLowerCase()
+  if (UNSUPPORTED_RANGE_PREFIXES.some((prefix) => lower.startsWith(prefix))) return null
+  if (lower === 'latest' || lower === 'next' || lower === 'beta') return null
+
+  const sets = []
+  for (const part of text.split('||')) {
+    const trimmed = part.trim()
+    if (trimmed === '') return null
+    // 连字符范围
+    const hyphen = /^(\S+)\s+-\s+(\S+)$/.exec(trimmed)
+    if (hyphen) {
+      const from = parseComparator(`>=${hyphen[1]}`)
+      const to = parseComparator(`<=${hyphen[2]}`)
+      if (!from || !to) return null
+      sets.push([from, to])
+      continue
+    }
+    const comparators = []
+    for (const token of trimmed.split(/\s+/)) {
+      const comparator = parseComparator(token)
+      if (comparator === undefined) return null
+      comparators.push(comparator)
+    }
+    sets.push(comparators)
+  }
+  return { sets }
+}
+
+/**
+ * 版本是否满足范围。
+ * @param {string} version 版本
+ * @param {string} range 范围
+ * @returns {{supported:boolean, satisfies:boolean, reason?:string}} 判定
+ */
+export function satisfiesRange(version, range) {
+  const parsedVersion = parseVersion(version)
+  if (!parsedVersion) return { supported: false, satisfies: false, reason: `版本不可解析：${version}` }
+  const parsedRange = parseRange(range)
+  if (!parsedRange) return { supported: false, satisfies: false, reason: `范围不可解析：${range}` }
+  const satisfies = parsedRange.sets.some((set) => satisfiesSet(parsedVersion, set))
+  return { supported: true, satisfies }
+}
+
+/**
+ * 范围下界（能代表「当前声明」的最早版本）；无从判断返回 null。
+ * @param {unknown} range 范围
+ * @returns {string|null} 下界版本
+ */
+export function rangeFloor(range) {
+  const parsed = parseRange(range)
+  if (!parsed) return null
+  let best = null
+  for (const set of parsed.sets) {
+    const froms = set.filter((comparator) => comparator && (comparator.op === 'range' || comparator.op === '>=' || comparator.op === '>' || comparator.op === 'eq'))
+    for (const comparator of froms) {
+      const version = comparator.op === 'eq' ? comparator.version : comparator.version ?? comparator.from
+      if (!version) continue
+      if (best === null || compareVersions(version, best) < 0) best = version
+    }
+  }
+  if (best === null) return null
+  return `${best.major}.${best.minor}.${best.patch}${best.prerelease?.length ? `-${best.prerelease.join('.')}` : ''}`
+}
+
+/**
+ * 升级类型：比较两个版本给 patch / minor / major。
+ * @param {string} from 当前
+ * @param {string} to 目标
+ * @returns {'patch'|'minor'|'major'|'same'} 升级类型
+ */
+export function bumpType(from, to) {
+  const left = parseVersion(from)
+  const right = parseVersion(to)
+  if (!left || !right) return 'same'
+  if (compareVersions(left, right) === 0) return 'same'
+  if (left.major !== right.major) return 'major'
+  if (left.minor !== right.minor) return 'minor'
+  return 'patch'
+}
+
+/**
+ * 判断引擎范围是否与当前 Node 兼容。
+ * @param {unknown} engines package.json 的 engines 字段
+ * @param {string} nodeVersion 当前 Node 版本
+ * @returns {{declared:boolean, compatible:boolean|null, range?:string, reason?:string}} 判定
+ */
+export function checkEngines(engines, nodeVersion) {
+  if (engines === null || engines === undefined) return { declared: false, compatible: null }
+  if (typeof engines !== 'object' || Array.isArray(engines)) return { declared: true, compatible: null, reason: 'engines 不是对象' }
+  const range = engines.node
+  if (typeof range !== 'string' || range.trim().length === 0) return { declared: false, compatible: null }
+  const result = satisfiesRange(nodeVersion, range)
+  if (!result.supported) return { declared: true, compatible: null, range, reason: `engines.node 范围不可判定：${range}` }
+  return { declared: true, compatible: result.satisfies, range }
+}

package/package.json

@@ -1,24 +1,52 @@
 {
   "name": "dsh-deps",
-  "version": "0.0.1",
-  "description": "Audit dependency trees for license risk, dupes, abandoned packages and version drift, with an actionable upgrade plan per package. | 审计依赖树：许可证风险、重复包、无人维护包、版本漂移，并按包给出可执行的升级计划。",
+  "version": "0.1.0",
+  "description": "依赖升级规划 DSH 插件：给定 package.json 与本地 registry 快照，算哪些依赖能升、升了有什么风险、按什么顺序升。五档分级写死（patch / minor / major / pinned / unknown）；latest 只来自调用方给的本地快照，缺了就 unknown、绝不联网猜；风险信号具体到 major / engines 不兼容 / deprecated / yanked / peer 破坏，每条给建议动作；建议顺序先 patch 后 minor 再 major、同组按被依赖次数降序并说明理由；只读、不自动改文件（pin 只返回 diff 文本）。零运行时依赖，含 CLI。 | Dependency upgrade planner for DeepSeek Harness: five fixed bump classes, latest only from a caller-provided local snapshot (never network, never guessed), concrete risk signals with actions, and an upgrade order (patch → minor → major, dependents first) with rationale. Read-only: never edits package.json or lockfiles; pin returns a diff only.",
   "keywords": [
     "dsh",
     "dsh-plugin",
     "deepseek-harness",
     "dependencies",
-    "license",
-    "audit",
     "upgrade",
+    "audit",
+    "semver",
     "supply-chain",
-    "依赖"
+    "依赖",
+    "升级"
   ],
   "license": "MIT",
+  "author": "he fangsheng (https://github.com/dongsheng123132)",
   "type": "module",
+  "main": "./plugin.mjs",
+  "bin": {
+    "dsh-deps": "./lib/cli.js"
+  },
+  "exports": {
+    ".": "./plugin.mjs",
+    "./cli": "./lib/cli.js",
+    "./lib/*": "./lib/*",
+    "./package.json": "./package.json"
+  },
   "files": [
-    "README.md"
+    "plugin.mjs",
+    "lib/",
+    "cordis.patch.yml",
+    "dsh-plugin.naming.json",
+    "README.md",
+    "LICENSE"
   ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
   "engines": {
-    "node": ">=22"
+    "node": ">=22",
+    "dsh": ">=0.2.2-rc.1 <0.3.0"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "test:dir": "node --test test/",
+    "check": "node --check plugin.mjs && node scripts/check.mjs"
   }
 }