skillcaddy 0.27.0

package/lib/specGate.js

@@ -0,0 +1,235 @@
+/**
+ * Spec-pipeline gate decisions.
+ *
+ * These two functions are the single source of truth for whether a tech spec
+ * may enter implementation, and for whether the declared role contract holds.
+ *
+ * Why this lives in lib/ rather than inside the check scripts: the source
+ * directory `personal/` is git-ignored, so anything a CI job needs to verify
+ * must not depend on it. The Python scripts under personal/spec-pipeline/ are
+ * thin shells that call this module, so the gate logic cannot drift between
+ * what a developer runs locally and what CI enforces.
+ *
+ * Both functions are pure: they take file content and return a decision. They
+ * never read or write the filesystem themselves, which is what makes them
+ * testable from fixtures (see test/specGate.test.js).
+ */
+
+/** Words that mean the direction line records a real decision. */
+const PASS_WORDS = ['通过', 'approved', 'approve', 'pass'];
+const REJECT_WORDS = ['拒绝', '驳回', 'rejected', 'reject', 'denied', 'deny'];
+
+/**
+ * `通过 / 拒绝` left unfilled is a template, not a decision. Treating it as
+ * approved would let a copied-through approval block pass the gate.
+ */
+const PLACEHOLDER_RE = /通过\s*\/\s*拒绝|approved\s*\/\s*rejected/i;
+
+/** A real decision carries a when. The template's own <…> marker does not count. */
+const TIME_RE = /\d{4}-\d{2}-\d{2}|\d{2}:\d{2}|20\d{2}/;
+
+// JS has no named groups, so the verdict is captured as group 1.
+const DIRECTION_RE = /^\s*[-*]?\s*(?:方向确认|方向|Direction)\s*[:：]\s*(.*)$/i;
+const APPROVAL_HEADING_RE = /^#{1,6}\s*Approval\b/i;
+const HEADING_RE = /^#{1,6}\s+\S/;
+
+const KNOWN_ROLES = ['author', 'implementer', 'verifier'];
+
+/** Values that look filled but assert nothing. */
+const PLACEHOLDERS = new Set([
+  '', '-', '--', '—', '——', 'n/a', 'na', 'tbd', 'todo',
+  '?', '??', '（无）', '(无)', '无', '待定', '未开始填写', 'x', 'xx'
+]);
+
+const BOUNDARY_RE = /verifier\s*(?:不得|不能|不可)\s*(?:与|和)\s*author\s*(?:同|相同)/i;
+
+function isFilled(value) {
+  return !PLACEHOLDERS.has(String(value ?? '').trim().replace(/^\*+|\*+$/g, '').trim().toLowerCase());
+}
+
+/**
+ * Locate the direction verdict inside `## Approval`.
+ *
+ * Scanning stops at the next heading on purpose: a document must not be able
+ * to pass by parking a "方向确认：通过" line in a later section.
+ *
+ * @returns {{verdict: string|null, line: string|null, sectionFound: boolean}}
+ */
+export function readDirectionVerdict(text) {
+  const lines = text.split('\n');
+  let start = -1;
+  for (let i = 0; i < lines.length; i += 1) {
+    if (APPROVAL_HEADING_RE.test(lines[i].trim())) {
+      start = i + 1;
+      break;
+    }
+  }
+  if (start === -1) return { verdict: null, line: null, sectionFound: false };
+
+  for (const line of lines.slice(start)) {
+    if (HEADING_RE.test(line.trim())) break;
+    const match = DIRECTION_RE.exec(line);
+    if (match) {
+      return { verdict: match[1].trim(), line, sectionFound: true };
+    }
+  }
+  return { verdict: null, line: null, sectionFound: true };
+}
+
+/**
+ * Decide whether a TECH.md is approved to enter implementation.
+ *
+ * @param {string|null} text File content, or null when the file is absent.
+ * @returns {{code: 0|1, reason: string, kind: string}}
+ */
+export function decideApproval(text) {
+  const blocked = (kind, reason) => ({ code: 1, reason: `BLOCKED: ${reason}`, kind });
+
+  if (text === null || text === undefined) {
+    return blocked('missing', 'TECH.md 不存在。方向尚未确认，不得进入实施。');
+  }
+
+  const { verdict, line, sectionFound } = readDirectionVerdict(text);
+
+  if (verdict === null) {
+    if (!sectionFound) {
+      return blocked('no-approval-section',
+        'TECH.md 缺少 `## Approval` 段。批准状态是显式记录，没有它一律按未批准处理。请先运行 spec-direction-gate。');
+    }
+    return blocked('no-verdict',
+      '`## Approval` 段存在，但里面没有方向确认结论。\n'
+      + '  需要形如「- 方向确认：通过（时间：…，确认人：…）」的一行。'
+      + '空的 Approval 段等同于未批准——这正是 spec-draft-intake 产出的状态。');
+  }
+
+  if (PLACEHOLDER_RE.test(verdict)) {
+    return blocked('template',
+      `方向确认仍是未填写的模板：${line.trim()}\n`
+      + '  `通过 / 拒绝` 两个候选都留着，说明结论没写。请补上实际决定、时间与确认人。');
+  }
+
+  if (!TIME_RE.test(verdict) && !TIME_RE.test(line ?? '')) {
+    return blocked('no-timestamp',
+      `方向确认缺少时间戳：${line.trim()}\n`
+      + '  批准记录必须可核验到「谁在什么时候批准了方向」。');
+  }
+
+  const lower = verdict.toLowerCase();
+  const mentioned = (words) => words.some((w) => verdict.includes(w) || lower.includes(w));
+
+  if (mentioned(REJECT_WORDS)) {
+    return blocked('rejected',
+      `方向确认被拒绝：${line.trim()}\n`
+      + '  按流程停止。修改草稿后须从方向确认重新开始，不得直接进入实施。');
+  }
+
+  if (!mentioned(PASS_WORDS)) {
+    return blocked('undecidable',
+      `无法判定方向确认结论：${line.trim()}\n  既没有「通过」也没有「拒绝」，按未批准处理。`);
+  }
+
+  return { code: 0, reason: 'APPROVED: 方向已确认，可以进入实施。', kind: 'approved' };
+}
+
+/**
+ * Parse the role table out of a ROLE.md body.
+ *
+ * @returns {{roles: Record<string, {who: string, session: string}>, order: string[]}}
+ */
+export function extractRoles(text) {
+  const roles = {};
+  const order = [];
+  let inTable = false;
+
+  for (const raw of text.split('\n')) {
+    const line = raw.trim();
+    if (line.startsWith('|')) {
+      inTable = true;
+      const cells = line.replace(/^\||\|$/g, '').split('|').map((c) => c.trim());
+      if (cells.every((c) => /^[-: ]*$/.test(c))) continue; // |---|---| separator
+      const key = cells[0].replace(/^\*+|\*+$/g, '').trim().toLowerCase();
+      for (const role of KNOWN_ROLES) {
+        if (key.includes(role)) {
+          if (!(role in roles)) order.push(role);
+          roles[role] = {
+            who: cells[1] ?? '',
+            session: cells[2] ?? ''
+          };
+          break;
+        }
+      }
+    } else if (inTable && line) {
+      break;
+    }
+  }
+
+  return { roles, order };
+}
+
+/**
+ * Decide whether a declared role contract holds.
+ *
+ * Scope limit, stated plainly because it is easy to overread: this checks the
+ * *declared* contract. A table filled in dishonestly passes. It catches the
+ * common accident — copying a role block and forgetting to change the session —
+ * not the absence of a real session boundary.
+ *
+ * @param {string|null} text File content, or null when the file is absent.
+ * @returns {{code: 0|1, reason: string, kind: string, problems: string[]}}
+ */
+export function decideRoleContract(text) {
+  const violation = (kind, reason, problems = []) => ({
+    code: 1, reason: `VIOLATION: ${reason}`, kind, problems
+  });
+
+  if (text === null || text === undefined) {
+    return violation('missing', 'ROLE.md 不存在。角色边界无法核验，不得开始实施。');
+  }
+
+  const { roles } = extractRoles(text);
+
+  if (Object.keys(roles).length === 0) {
+    return violation('no-table',
+      'ROLE.md 里没有角色表。\n  需要一张表，至少三行：author / implementer / verifier，每行含「谁 / 会话 / 状态」。');
+  }
+
+  const missing = KNOWN_ROLES.filter((role) => !(role in roles));
+  if (missing.length > 0) {
+    return violation('missing-role',
+      `角色表缺少位置：${missing.join(', ')}。\n  三个位置都要显式声明，不能靠默认。`);
+  }
+
+  const problems = [];
+  for (const role of KNOWN_ROLES) {
+    if (!isFilled(roles[role].who)) problems.push(`  - ${role} 的人未填写`);
+    if (!isFilled(roles[role].session)) {
+      problems.push(`  - ${role} 的会话标识未填写（占位符 \`${roles[role].session.trim()}\` 不算）`);
+    }
+  }
+
+  const authorSession = roles.author.session.trim();
+  const verifierSession = roles.verifier.session.trim();
+
+  if (isFilled(authorSession) && isFilled(verifierSession)
+      && authorSession.toLowerCase() === verifierSession.toLowerCase()) {
+    problems.push(
+      `  - verifier 与 author 同为会话 \`${authorSession}\`\n`
+      + '    author 带着自己的权衡上下文验收自己的实现，等于用出题人的答案判卷。验收必须换新会话。'
+    );
+  }
+
+  if (!BOUNDARY_RE.test(text)) {
+    problems.push('  - `## Boundaries` 里没有写明「verifier 不得与 author 同会话」');
+  }
+
+  if (problems.length > 0) {
+    return violation('boundary', `角色契约不满足边界要求：\n${problems.join('\n')}`, problems);
+  }
+
+  return {
+    code: 0,
+    reason: `OK: 三个位置均已声明，verifier 会话 \`${verifierSession}\` 与 author \`${authorSession}\` 不同。边界可核验。`,
+    kind: 'ok',
+    problems: []
+  };
+}

package/lib/tuiActions.js

@@ -0,0 +1,169 @@
+import { syncClaudeSkills } from './claudeStore.js';
+import { executeCollectionEnablement } from './collectionEnablement.js';
+import { updateSkillMetadata } from './skillMetadata.js';
+import { disableSkill, getState } from './skillStore.js';
+import { enableProjectSkill } from './projectActions.js';
+
+const DEFAULT_LIMIT = 20;
+
+export async function loadTuiState(roots, projectPath, options = {}) {
+  return getState(roots, projectPath, options);
+}
+
+export function summarizeState(state) {
+  return {
+    projectPath: state.projectPath,
+    totalSkills: state.stats.total,
+    availableSkills: state.stats.available,
+    enabledAgents: state.enabled.length,
+    enabledClaude: state.claude?.skills?.length || 0,
+    advice: state.advice.length
+  };
+}
+
+export function listSkillChoices(state, options = {}) {
+  const query = normalizeSearch(options.query);
+  const source = options.source || '';
+  const tag = options.tag || '';
+  const limit = Number.isInteger(options.limit) ? options.limit : DEFAULT_LIMIT;
+  const enabledTargets = new Set(
+    enabledSkillsForScope(state, options.scope)
+      .map((skill) => skill.targetPath)
+      .filter(Boolean)
+  );
+
+  return state.skills
+    .filter((skill) => !source || skill.source === source)
+    .filter((skill) => !tag || (skill.tags || []).includes(tag))
+    .filter((skill) => !query || skillMatchesQuery(skill, query))
+    .slice(0, limit)
+    .map((skill, index) => ({
+      index: index + 1,
+      id: skill.id,
+      label: formatSkillLabel(skill),
+      enabled: enabledTargets.has(skill.path),
+      autoEnable: skill.autoEnable,
+      skill
+    }));
+}
+
+export function listEnabledAliases(state, scope = 'project') {
+  const enabled = enabledSkillsForScope(state, scope);
+  return enabled.map((skill, index) => ({
+    index: index + 1,
+    alias: skill.alias,
+    label: `${skill.alias} -> ${skill.targetPath || skill.linkPath}`,
+    canDisable: skill.canDisable ?? skill.isSymlink,
+    skill
+  }));
+}
+
+export function findSkillByChoice(state, value) {
+  const text = String(value || '').trim();
+  if (!text) throw new Error('skill 选择不能为空');
+
+  const byId = state.skills.find((skill) => skill.id === text);
+  if (byId) return byId;
+
+  const byName = state.skills.filter((skill) => skill.name === text);
+  if (byName.length === 1) return byName[0];
+  if (byName.length > 1) {
+    throw new Error(`存在多个同名 skill：${text}，请使用完整 id`);
+  }
+
+  throw new Error(`找不到 skill：${text}`);
+}
+
+export function findSkillByQuery(state, query) {
+  const matches = listSkillChoices(state, { query, limit: 2 });
+  if (matches.length === 0) {
+    throw new Error(`找不到匹配的 skill：${query}`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`多个 skill 匹配：${query}，请从搜索结果序号中选择`);
+  }
+  return matches[0].skill;
+}
+
+export async function enableSkillChoice(roots, state, value, options = {}) {
+  const skill = findSkillByChoice(state, value);
+  return enableProjectSkill(roots, {
+    ...(options.scope === 'project' || !options.scope ? { projectPath: state.projectPath } : {}),
+    ...(options.scope ? { scope: options.scope } : {}),
+    ...(options.globalDir ? { globalDir: options.globalDir } : {}),
+    ...(options.hermesDir ? { hermesDir: options.hermesDir } : {}),
+    skillPath: skill.path,
+    alias: options.alias || skill.name
+  });
+}
+
+export async function enableCollectionChoice(roots, state, skillIds, options = {}) {
+  return executeCollectionEnablement(roots, {
+    ...(options.scope === 'project' || !options.scope ? { projectPath: state.projectPath } : {}),
+    ...(options.scope ? { scope: options.scope } : {}),
+    ...(options.globalDir ? { globalDir: options.globalDir } : {}),
+    ...(options.hermesDir ? { hermesDir: options.hermesDir } : {}),
+    skillIds
+  });
+}
+
+export async function disableAlias(state, alias, options = {}) {
+  return disableSkill({
+    ...(options.scope === 'project' || !options.scope ? { projectPath: state.projectPath } : {}),
+    ...(options.scope ? { scope: options.scope } : {}),
+    ...(options.rootDir ? { rootDir: options.rootDir } : {}),
+    ...(options.globalDir ? { globalDir: options.globalDir } : {}),
+    ...(options.hermesDir ? { hermesDir: options.hermesDir } : {}),
+    alias
+  });
+}
+
+function enabledSkillsForScope(state, scope = 'project') {
+  if (scope === 'global') return state.global || [];
+  if (scope === 'hermes') return state.hermes || [];
+  return state.enabled || [];
+}
+
+export async function syncClaude(state) {
+  return syncClaudeSkills(state.projectPath);
+}
+
+export async function saveSkillMetadata(roots, state, value, metadata) {
+  const skill = findSkillByChoice(state, value);
+  return updateSkillMetadata(roots, {
+    skillPath: skill.path,
+    note: metadata.note ?? skill.note,
+    tags: metadata.tags ?? skill.tags,
+    autoEnable: metadata.autoEnable ?? skill.autoEnable
+  });
+}
+
+export function formatAdvice(advice) {
+  return advice.map((item, index) => ({
+    index: index + 1,
+    severity: item.severity || 'info',
+    title: item.title,
+    detail: item.detail
+  }));
+}
+
+function normalizeSearch(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function skillMatchesQuery(skill, query) {
+  return [
+    skill.id,
+    skill.name,
+    skill.source,
+    skill.collection,
+    skill.description,
+    skill.note,
+    ...(skill.tags || [])
+  ].some((value) => String(value || '').toLowerCase().includes(query));
+}
+
+function formatSkillLabel(skill) {
+  const disabled = skill.autoEnable === false ? ' skip-bulk' : '';
+  return `${skill.id}${disabled} - ${skill.note || skill.description || '无描述'}`;
+}

package/lib/tuiInstall.js

@@ -0,0 +1,133 @@
+import { access, lstat, readFile, realpath } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+const PACKAGE_NAME = 'skillcaddy';
+const COMMAND_ENTRY = 'scripts/tui.js';
+
+export async function getSkillcaddyInstallPaths(rootDir, options = {}) {
+  const sourcePath = path.resolve(rootDir);
+  const globalRoot = options.globalRoot || await getNpmGlobalRoot(options);
+  return {
+    sourcePath,
+    targetPath: path.join(path.resolve(globalRoot), PACKAGE_NAME)
+  };
+}
+
+export async function checkSkillcaddyInstall(rootDir, options = {}) {
+  const paths = await getSkillcaddyInstallPaths(rootDir, options);
+  if (!await isSkillcaddyPackage(paths.sourcePath)) {
+    return {
+      ok: false,
+      status: 'source-invalid',
+      ...paths,
+      message: `Skillcaddy clone does not expose the CLI/TUI command: ${paths.sourcePath}`
+    };
+  }
+
+  const target = await safeLstat(paths.targetPath);
+  if (!target) {
+    return {
+      ok: false,
+      status: 'missing',
+      ...paths,
+      message: `Skillcaddy CLI/TUI command is not linked: ${paths.targetPath}`
+    };
+  }
+
+  let linkTarget;
+  try {
+    linkTarget = await realpath(paths.targetPath);
+  } catch {
+    return {
+      ok: false,
+      status: 'conflict',
+      ...paths,
+      message: `global Skillcaddy package link is broken: ${paths.targetPath}`
+    };
+  }
+
+  const sourceTarget = await realpath(paths.sourcePath);
+  if (linkTarget !== sourceTarget) {
+    return {
+      ok: false,
+      status: 'conflict',
+      ...paths,
+      linkTarget,
+      message: `global Skillcaddy package points elsewhere: ${linkTarget}`
+    };
+  }
+
+  return {
+    ok: true,
+    status: 'installed',
+    ...paths,
+    linkTarget,
+    command: 'skillcaddy',
+    message: 'Skillcaddy CLI/TUI command is linked to this clone'
+  };
+}
+
+export async function installTuiCommand(rootDir, options = {}) {
+  const current = await checkSkillcaddyInstall(rootDir, options);
+  if (current.status === 'installed') {
+    return { ...current, unchanged: true };
+  }
+  if (current.status !== 'missing') {
+    throw new Error(current.message);
+  }
+
+  const linkPackage = options.linkPackage || linkCurrentPackage;
+  await linkPackage(current.sourcePath, options);
+
+  const installed = await checkSkillcaddyInstall(rootDir, options);
+  if (!installed.ok) {
+    throw new Error(installed.message);
+  }
+  return { ...installed, unchanged: false };
+}
+
+export const getCliInstallPaths = getSkillcaddyInstallPaths;
+export const checkCliInstall = checkSkillcaddyInstall;
+export const installCliCommand = installTuiCommand;
+export const getTuiInstallPaths = getSkillcaddyInstallPaths;
+export const checkTuiInstall = checkSkillcaddyInstall;
+export const installSkillcaddyCommand = installTuiCommand;
+
+async function getNpmGlobalRoot(options) {
+  const npmCommand = options.npmCommand || (process.platform === 'win32' ? 'npm.cmd' : 'npm');
+  const { stdout } = await execFileAsync(npmCommand, ['root', '--global'], {
+    encoding: 'utf8'
+  });
+  return stdout.trim();
+}
+
+async function linkCurrentPackage(rootDir, options) {
+  const npmCommand = options.npmCommand || (process.platform === 'win32' ? 'npm.cmd' : 'npm');
+  await execFileAsync(npmCommand, ['link', '--ignore-scripts', '--no-audit', '--no-fund'], {
+    cwd: rootDir,
+    encoding: 'utf8'
+  });
+}
+
+async function isSkillcaddyPackage(rootDir) {
+  try {
+    const packageJson = JSON.parse(await readFile(path.join(rootDir, 'package.json'), 'utf8'));
+    if (packageJson.name !== PACKAGE_NAME || packageJson.bin?.skillcaddy !== COMMAND_ENTRY) return false;
+    await access(path.join(rootDir, COMMAND_ENTRY));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function safeLstat(targetPath) {
+  try {
+    return await lstat(targetPath);
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+}

package/lib/tuiLayout.js

@@ -0,0 +1,94 @@
+const DEFAULT_PAGE_SIZE = 10;
+const TABLE_DIVIDER = ' | ';
+
+export function getSkillPage(choices, page = 1, pageSize = DEFAULT_PAGE_SIZE) {
+  const totalPages = Math.max(1, Math.ceil(choices.length / pageSize));
+  const currentPage = Math.min(Math.max(1, page), totalPages);
+  const start = (currentPage - 1) * pageSize;
+
+  return {
+    currentPage,
+    totalPages,
+    total: choices.length,
+    start: choices.length === 0 ? 0 : start + 1,
+    end: Math.min(start + pageSize, choices.length),
+    choices: choices.slice(start, start + pageSize)
+  };
+}
+
+export function getSkillTableLayout(columns) {
+  const terminalWidth = Number.isFinite(columns) && columns > 0
+    ? Math.floor(columns)
+    : 100;
+  const singleColumn = terminalWidth < 40;
+  const leftWidth = singleColumn
+    ? terminalWidth
+    : Math.min(38, Math.max(20, Math.floor(terminalWidth * 0.36)));
+
+  return {
+    leftWidth,
+    introductionWidth: singleColumn
+      ? 0
+      : terminalWidth - leftWidth - getDisplayWidth(TABLE_DIVIDER)
+  };
+}
+
+export function formatSkillTableHeader(layout) {
+  if (layout.introductionWidth === 0) return 'Skill / 状态';
+  return `${padDisplayWidth('Skill / 状态', layout.leftWidth)}${TABLE_DIVIDER}介绍`;
+}
+
+export function formatSkillTableDivider(layout) {
+  if (layout.introductionWidth === 0) return '-'.repeat(layout.leftWidth);
+  return `${'-'.repeat(layout.leftWidth)}+${'-'.repeat(layout.introductionWidth + 2)}`;
+}
+
+export function formatCompactSkillChoice(choice, indexWidth = 1, layout) {
+  const status = choice.enabled
+    ? '已启用'
+    : choice.skill.autoEnable === false
+      ? '手动添加'
+      : '可添加';
+  const prefix = `${String(choice.index).padStart(indexWidth)}. `;
+  const suffix = `  ${status}`;
+  const label = `${prefix}${choice.skill.name}${suffix}`;
+
+  if (!layout) return label;
+
+  const nameWidth = Math.max(1, layout.leftWidth - getDisplayWidth(prefix) - getDisplayWidth(suffix));
+  const compactLabel = `${prefix}${truncateDisplayWidth(choice.skill.name, nameWidth)}${suffix}`;
+  if (layout.introductionWidth === 0) return compactLabel;
+  return `${padDisplayWidth(compactLabel, layout.leftWidth)}${TABLE_DIVIDER}${truncateDisplayWidth(getSkillIntroduction(choice.skill), layout.introductionWidth)}`;
+}
+
+export function getSkillIntroduction(skill) {
+  return skill.note || skill.description || skill.path;
+}
+
+export function getDisplayWidth(value) {
+  return [...String(value)].reduce((width, character) => width + (isWideCharacter(character) ? 2 : 1), 0);
+}
+
+export function truncateDisplayWidth(value, maxWidth) {
+  const text = String(value);
+  if (getDisplayWidth(text) <= maxWidth) return text;
+
+  let result = '';
+  let width = 0;
+  for (const character of text) {
+    const characterWidth = getDisplayWidth(character);
+    if (width + characterWidth + 1 > maxWidth) break;
+    result += character;
+    width += characterWidth;
+  }
+  return `${result}…`;
+}
+
+function padDisplayWidth(value, width) {
+  return `${value}${' '.repeat(Math.max(0, width - getDisplayWidth(value)))}`;
+}
+
+function isWideCharacter(character) {
+  if (character === '…') return false;
+  return character.codePointAt(0) > 0xff;
+}

package/lib/version.js

@@ -0,0 +1,17 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeRoots } from './roots.js';
+
+/**
+ * Reads name and version from the project's package.json.
+ * @param {string|{ libraryRoot?: string, codeRoot?: string }} roots code root, or a legacy single root
+ * @returns {Promise<{ name: string, version: string }>}
+ */
+export async function readVersion(roots) {
+  const { codeRoot } = normalizeRoots(roots);
+  const pkgPath = path.join(codeRoot, 'package.json');
+  const raw = await readFile(pkgPath, 'utf8');
+  const pkg = JSON.parse(raw);
+
+  return { name: pkg.name, version: pkg.version };
+}