agent-syncer 0.1.0

package/lib/commands/status.js

@@ -0,0 +1,133 @@
+// @ts-check
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadConfig } from '../config.js';
+import { checkBlock } from '../gitignore.js';
+import { STATUS, inspect } from '../link.js';
+import { dim, fail, info, ok, plain, skip, title, warn } from '../log.js';
+import { CONTENT_ROOT, KINDS, TOOLS, plannedLinks } from '../target.js';
+
+/** 统一的相对路径显示（正斜杠，跨平台一致） */
+const rel = (from, to) => path.relative(from, to).split(path.sep).join('/');
+
+/** 统计目录下的条目数；目录不存在返回 null */
+function countEntries(dir) {
+  try {
+    return fs.readdirSync(dir).length;
+  } catch {
+    return null;
+  }
+}
+
+const KIND_LABEL = {
+  skills: 'skills',
+  rules: 'rules',
+  commands: 'commands',
+  agents: 'agents',
+};
+
+/**
+ * agent-syncer status —— 纯只读。报告内容清单与每个链接的健康状况。
+ * @param {{cwd: string, flags: Record<string, any>}} ctx
+ */
+export async function run({ cwd }) {
+  const config = loadConfig(cwd);
+
+  title('agent-syncer status');
+  plain(dim(`项目根：${cwd}`));
+
+  // ---- 内容 ----
+  title(`内容（${CONTENT_ROOT}/）`);
+  const contentRoot = path.resolve(cwd, CONTENT_ROOT);
+  if (!fs.existsSync(contentRoot)) {
+    fail(`${CONTENT_ROOT}/ 不存在——还没有任何内容`);
+  } else {
+    for (const kind of KINDS) {
+      const n = countEntries(path.resolve(contentRoot, kind));
+      if (n === null) {
+        skip(`${KIND_LABEL[kind].padEnd(9)} 无此目录`);
+      } else {
+        ok(`${KIND_LABEL[kind].padEnd(9)} ${String(n).padStart(3)} 项`);
+      }
+    }
+  }
+
+  // ---- 链接 ----
+  if (config.tools.length === 0) {
+    title('链接');
+    warn('未声明任何工具');
+    return 0;
+  }
+  if (!config.exists) {
+    plain(dim(`（未找到 agents.json：${config.warnings.join('；')}）`));
+  }
+
+  const plan = plannedLinks(cwd, config.links);
+  let healthy = 0;
+  let absent = 0;
+  /** @type {string[]} */
+  const problems = [];
+
+  // 按工具分组展示，读起来比一条长清单清楚
+  for (const tool of config.tools) {
+    title(`链接 · ${TOOLS[tool].label}`);
+    for (const item of plan.filter((p) => p.tool === tool)) {
+      const st = inspect(item.target, item.source);
+      const target = rel(cwd, item.target);
+      const source = rel(cwd, item.source);
+
+      switch (st.status) {
+        case STATUS.HEALTHY:
+          ok(`${target.padEnd(20)} ${dim(`→ ${source}`)}`);
+          healthy += 1;
+          break;
+        case STATUS.ABSENT:
+          skip(`${target.padEnd(20)} ${dim('未创建')}`);
+          absent += 1;
+          break;
+        case STATUS.BROKEN:
+          fail(`${target.padEnd(20)} 断链 → ${st.actual ?? st.raw}（目标已不存在）`);
+          problems.push(`${target} 是断链，运行 link 可重建`);
+          break;
+        case STATUS.ELSEWHERE:
+          warn(`${target.padEnd(20)} 指向别处 → ${st.actual}`);
+          problems.push(`${target} 指向别处，确认后可用 link --force 接管`);
+          break;
+        case STATUS.REPLACED:
+          warn(`${target.padEnd(20)} 是实体目录/文件，不是链接`);
+          problems.push(`${target} 是实体目录，link 不会覆盖它`);
+          break;
+        default:
+          fail(`${target.padEnd(20)} 未知状态：${st.status}`);
+          problems.push(`${target} 状态未知：${st.status}`);
+      }
+    }
+  }
+
+  // ---- .gitignore ----
+  title('.gitignore 托管段');
+  const gi = checkBlock(cwd, config.links);
+  if (!gi.present) {
+    warn('未找到 agent-syncer 托管段，运行 link 会写入');
+  } else if (gi.missing.length > 0) {
+    warn(`托管段已存在，但缺少 ${gi.missing.length} 个条目，运行 link 会补齐`);
+    for (const m of gi.missing) plain(dim(`    · ${m}`));
+  } else {
+    ok('完整');
+  }
+
+  // ---- 小结 ----
+  title('小结');
+  plain(`  健康 ${healthy}　未创建 ${absent}${problems.length ? `　问题 ${problems.length}` : ''}`);
+
+  if (problems.length > 0) {
+    title('需要你处理');
+    for (const p of problems) plain(`  · ${p}`);
+    return 1;
+  }
+
+  if (absent > 0) {
+    info(`有 ${absent} 个链接未创建，运行 ${dim('agent-syncer link')} 即可建好`);
+  }
+  return 0;
+}

package/lib/config.js

@@ -0,0 +1,170 @@
+// @ts-check
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  KINDS,
+  TOOL_NAMES,
+  allSpecs,
+  contentDir,
+  isTool,
+  parseSpec,
+  toolsOfSpecs,
+} from './target.js';
+
+export const CONFIG_FILENAME = 'agents.json';
+
+/**
+ * 读取项目配置 agents.json。
+ *
+ * 两种写法都支持：
+ *   { "links": ["claude/skills", "trae/skills"] }   ← 精确到目录（推荐，交互式勾选写出的就是它）
+ *   { "tools": ["claude", "trae"] }                 ← 等价于这些工具的全部条目
+ *
+ * 文件不存在时按「项目里已有哪些工具目录 + .agents/ 下已有哪些内容」推断，
+ * 本轮只做推断、不落盘——让交互式命令去问用户。
+ *
+ * @param {string} projectRoot
+ * @returns {{links: string[], tools: string[], path: string, exists: boolean, inferred: boolean, warnings: string[]}}
+ */
+export function loadConfig(projectRoot) {
+  const cfgPath = path.resolve(projectRoot, CONFIG_FILENAME);
+  /** @type {string[]} */
+  const warnings = [];
+
+  if (!fs.existsSync(cfgPath)) {
+    const links = inferLinks(projectRoot);
+    return {
+      links,
+      tools: toolsOfSpecs(links),
+      path: cfgPath,
+      exists: false,
+      inferred: true,
+      warnings,
+    };
+  }
+
+  /** @type {any} */
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+  } catch (e) {
+    throw new Error(`${CONFIG_FILENAME} 不是合法的 JSON：${/** @type {Error} */ (e).message}`);
+  }
+
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+    throw new Error(`${CONFIG_FILENAME} 的顶层必须是一个对象`);
+  }
+
+  /** @type {string[]} */
+  let links;
+  if (raw.links !== undefined) {
+    links = normalizeLinks(raw.links, warnings);
+  } else if (raw.tools !== undefined) {
+    // 与 links 分支保持一致的排序，否则两种写法会产出不同顺序的 diff
+    links = sortSpecs(normalizeTools(raw.tools, warnings).flatMap(allSpecs));
+  } else {
+    warnings.push(`${CONFIG_FILENAME} 里既没有 links 也没有 tools`);
+    links = [];
+  }
+
+  return {
+    links,
+    tools: toolsOfSpecs(links),
+    path: cfgPath,
+    exists: true,
+    inferred: false,
+    warnings,
+  };
+}
+
+/**
+ * 写入配置。按固定顺序（工具顺序 → 内容类型顺序）排列，
+ * 这样每次勾选后产生的 diff 是稳定的，不会因为点击顺序变来变去。
+ * @param {string} projectRoot @param {string[]} links
+ */
+export function saveConfig(projectRoot, links) {
+  const p = path.resolve(projectRoot, CONFIG_FILENAME);
+  const sorted = sortSpecs(links);
+  fs.writeFileSync(p, `${JSON.stringify({ links: sorted }, null, 2)}\n`);
+  return p;
+}
+
+/** 按 工具顺序 → 内容类型顺序 排序并去重 */
+export function sortSpecs(specs) {
+  const parsed = specs.map((s) => ({ spec: s, ...parseSpec(s) }));
+  parsed.sort((a, b) => {
+    const t = TOOL_NAMES.indexOf(a.tool) - TOOL_NAMES.indexOf(b.tool);
+    return t !== 0 ? t : KINDS.indexOf(a.kind) - KINDS.indexOf(b.kind);
+  });
+  return [...new Set(parsed.map((p) => p.spec))];
+}
+
+/**
+ * 校验并归一化 links 字段
+ * @param {unknown} value @param {string[]} warnings
+ * @returns {string[]}
+ */
+export function normalizeLinks(value, warnings = []) {
+  if (!Array.isArray(value)) {
+    throw new Error('links 必须是字符串数组，例如 ["claude/skills", "trae/skills"]');
+  }
+  /** @type {string[]} */
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== 'string') {
+      throw new Error(`links 里出现了非字符串项：${JSON.stringify(item)}`);
+    }
+    const spec = item.trim();
+    try {
+      parseSpec(spec);
+    } catch (e) {
+      warnings.push(`忽略无效条目 "${item}"：${/** @type {Error} */ (e).message}`);
+      continue;
+    }
+    if (!out.includes(spec)) out.push(spec);
+  }
+  return sortSpecs(out);
+}
+
+/**
+ * 校验并归一化 tools 字段
+ * @param {unknown} value @param {string[]} warnings
+ * @returns {string[]}
+ */
+export function normalizeTools(value, warnings = []) {
+  if (!Array.isArray(value)) {
+    throw new Error('tools 必须是字符串数组，例如 ["claude", "trae", "codex"]');
+  }
+  /** @type {string[]} */
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== 'string') {
+      throw new Error(`tools 里出现了非字符串项：${JSON.stringify(item)}`);
+    }
+    const name = item.trim().toLowerCase();
+    if (!isTool(name)) {
+      warnings.push(`忽略未知工具 "${item}"（可用值：${TOOL_NAMES.join(', ')}）`);
+      continue;
+    }
+    if (!out.includes(name)) out.push(name);
+  }
+  return out;
+}
+
+/**
+ * 没有配置时的推断：只推断「工具目录已存在」且「内容目录已存在」的组合。
+ * 两者缺一都不猜——多猜一个就会凭空建出一个没人要的目录。
+ * @param {string} projectRoot
+ */
+function inferLinks(projectRoot) {
+  /** @type {string[]} */
+  const links = [];
+  for (const tool of TOOL_NAMES) {
+    if (!fs.existsSync(path.resolve(projectRoot, `.${tool}`))) continue;
+    for (const spec of allSpecs(tool)) {
+      const { kind } = parseSpec(spec);
+      if (fs.existsSync(contentDir(projectRoot, kind))) links.push(spec);
+    }
+  }
+  return links;
+}

package/lib/gitignore.js

@@ -0,0 +1,108 @@
+// @ts-check
+import fs from 'node:fs';
+import path from 'node:path';
+import { CONTENT_ROOT, KINDS, TOOLS, parseSpec } from './target.js';
+
+export const BEGIN_MARK = '# >>> agent-sync >>>';
+export const END_MARK = '# <<< agent-sync <<<';
+
+/**
+ * 生成应写入 .gitignore 的托管段。
+ *
+ * 为什么必须忽略这些链接：junction / symlink 记录的是**绝对路径**，
+ * 提交上去在别人的机器上全是错的；更危险的是 git 会**穿透链接**，
+ * 把 .agents/ 里的内容原样再提交一份，仓库里出现两套内容。
+ *
+ * 只忽略**确实建了链接**的目录：如果某个目录是用户自己的实体目录，
+ * 忽略它会导致内容进不了版本库，那是帮倒忙。
+ *
+ * 注意：.claude/settings.json 与 .claude/hooks/ **不能**忽略——
+ * 那些是项目真实配置，需要进版本库。
+ *
+ * @param {string[]} specs 形如 "claude/skills"
+ */
+export function buildBlock(specs) {
+  /** @type {string[]} */
+  const lines = [
+    BEGIN_MARK,
+    '# 由 agent-sync 维护，请勿手工修改此段',
+    `${CONTENT_ROOT}/*`,
+  ];
+
+  // 白名单：只放行真正的内容目录，其余（临时文件、缓存）一律忽略
+  for (const kind of KINDS) {
+    lines.push(`!${CONTENT_ROOT}/${kind}/`);
+    lines.push(`!${CONTENT_ROOT}/${kind}/*`);
+  }
+
+  /** @type {string[]} */
+  const targets = [];
+  for (const spec of specs) {
+    const { tool, kind } = parseSpec(spec);
+    const rel = TOOLS[tool].links[kind];
+    if (!targets.includes(rel)) targets.push(rel);
+  }
+  lines.push(...targets);
+
+  lines.push(END_MARK);
+  return lines.join('\n');
+}
+
+/** 读取 .gitignore 内容，不存在则返回空串 */
+export function readGitignore(projectRoot) {
+  const p = path.resolve(projectRoot, '.gitignore');
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * 只读检查：托管段是否存在、缺哪些条目。
+ * @param {string} projectRoot @param {string[]} specs
+ */
+export function checkBlock(projectRoot, specs) {
+  const content = readGitignore(projectRoot);
+  const start = content.indexOf(BEGIN_MARK);
+  const end = content.indexOf(END_MARK);
+
+  if (start === -1 || end === -1 || end < start) {
+    return { present: false, missing: [], extra: [] };
+  }
+
+  const block = content.slice(start, end);
+  const expected = buildBlock(specs)
+    .split('\n')
+    .filter((l) => l && !l.startsWith('#'));
+  const missing = expected.filter((l) => !block.includes(l));
+
+  return { present: true, missing, extra: [] };
+}
+
+/**
+ * 写入 / 更新托管段。幂等。
+ * @param {string} projectRoot @param {string[]} specs
+ * @param {{dryRun?: boolean}} [opts]
+ */
+export function writeBlock(projectRoot, specs, opts = {}) {
+  const p = path.resolve(projectRoot, '.gitignore');
+  const current = readGitignore(projectRoot);
+  const block = buildBlock(specs);
+
+  const start = current.indexOf(BEGIN_MARK);
+  const end = current.indexOf(END_MARK);
+
+  /** @type {string} */
+  let next;
+  if (start !== -1 && end !== -1 && end > start) {
+    next = current.slice(0, start) + block + current.slice(end + END_MARK.length);
+  } else {
+    const sep = current.length > 0 && !current.endsWith('\n') ? '\n' : '';
+    next = `${current}${sep}${current.length > 0 ? '\n' : ''}${block}\n`;
+  }
+
+  const changed = next !== current;
+  if (changed && !opts.dryRun) fs.writeFileSync(p, next);
+  return { changed, block };
+}

package/lib/link.js

@@ -0,0 +1,220 @@
+// @ts-check
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+
+/**
+ * 链接状态。
+ *
+ * - healthy  链接存在，且指向内容源
+ * - broken   是链接，但它指向的目标已不存在（断链）
+ * - elsewhere 是链接，但指向别处（不是我们管的）
+ * - replaced 路径存在，但不是链接（用户放了实体目录/文件）
+ * - absent   路径不存在
+ */
+export const STATUS = /** @type {const} */ ({
+  HEALTHY: 'healthy',
+  BROKEN: 'broken',
+  ELSEWHERE: 'elsewhere',
+  REPLACED: 'replaced',
+  ABSENT: 'absent',
+});
+
+/**
+ * Windows 路径大小写不敏感，比较前归一化。
+ * @param {string} a @param {string} b
+ */
+export function samePath(a, b) {
+  const na = path.resolve(a);
+  const nb = path.resolve(b);
+  return process.platform === 'win32' ? na.toLowerCase() === nb.toLowerCase() : na === nb;
+}
+
+/** 路径是否存在（含断链，因为 lstat 对断链仍有效） */
+function lexists(p) {
+  try {
+    fs.lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** 是否是链接（对断链也返回 true） */
+export function isSymlink(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 把 readlink 的结果归一化成绝对路径。
+ *
+ * 两种形态都要支持：
+ * - junction 返回绝对路径（Windows 上形如 C:\proj\.agents\skills）
+ * - 相对符号链接返回相对字符串，可能带尾斜杠（形如 .agents/rules/）
+ *
+ * @param {string} linkAbs @param {string} raw
+ */
+export function resolveLinkTarget(linkAbs, raw) {
+  return path.resolve(path.dirname(linkAbs), raw);
+}
+
+/**
+ * 探测一个链接路径当前的状态。
+ * 纯只读，不修改任何东西。
+ *
+ * @param {string} linkAbs
+ * @param {string} expectedTarget
+ * @returns {{status: string, actual?: string, raw?: string, message?: string}}
+ */
+export function inspect(linkAbs, expectedTarget) {
+  if (!lexists(linkAbs)) return { status: STATUS.ABSENT };
+  if (!isSymlink(linkAbs)) return { status: STATUS.REPLACED };
+
+  /** @type {string} */
+  let raw;
+  try {
+    raw = fs.readlinkSync(linkAbs);
+  } catch (e) {
+    return { status: STATUS.BROKEN, message: /** @type {Error} */ (e).message };
+  }
+
+  const actual = resolveLinkTarget(linkAbs, raw);
+
+  if (!fs.existsSync(actual)) {
+    return { status: STATUS.BROKEN, actual, raw };
+  }
+  if (!samePath(actual, expectedTarget)) {
+    return { status: STATUS.ELSEWHERE, actual, raw };
+  }
+  return { status: STATUS.HEALTHY, actual, raw };
+}
+
+/**
+ * 把系统错误归类，好给出可操作的提示。
+ * @param {NodeJS.ErrnoException} e
+ * @param {string} source
+ */
+export function classifyError(e, source) {
+  const code = e.code ?? '';
+  if (process.platform === 'win32' && /^\\\\/.test(source)) {
+    return { reason: 'unc-path', message: '目标位于 UNC 网络路径，Windows 的 junction 不支持' };
+  }
+  if (code === 'EPERM' || code === 'EACCES') {
+    return {
+      reason: 'permission',
+      message:
+        '权限不足。Windows 上目录链接应使用 junction（免管理员），' +
+        '文件链接才需要管理员或开发者模式——本工具只链接目录，出现此错误通常是被杀软或策略拦截',
+    };
+  }
+  if (code === 'EEXIST') return { reason: 'exists', message: '路径已存在' };
+  if (code === 'ENOENT') return { reason: 'missing', message: '父目录或链接目标不存在' };
+  if (code === 'UNKNOWN') {
+    return { reason: 'unknown', message: '未知错误，常见于目标为网络驱动器且不支持重解析点' };
+  }
+  return { reason: code || 'unknown', message: e.message };
+}
+
+/**
+ * 创建链接（原子写：先建临时链接再 rename，失败时原路径不受影响）。
+ *
+ * 调用前应先 inspect()；本函数只负责「路径不存在时创建」这一件事，
+ * 若路径已存在会直接拒绝，绝不覆盖。
+ *
+ * @param {string} source 内容源（绝对路径，必须已存在）
+ * @param {string} target 链接路径
+ * @param {{dryRun?: boolean, log?: (msg: string) => void}} [opts]
+ */
+export function createLink(source, target, opts = {}) {
+  const { dryRun = false } = opts;
+
+  if (!fs.existsSync(source)) {
+    return { ok: false, reason: 'source-missing', message: `内容目录不存在：${source}` };
+  }
+  if (!fs.statSync(source).isDirectory()) {
+    return {
+      ok: false,
+      reason: 'not-a-directory',
+      message: `只链接目录，不链接文件：${source}`,
+    };
+  }
+  if (lexists(target)) {
+    return { ok: false, reason: 'exists', message: '路径已存在，拒绝覆盖' };
+  }
+
+  if (dryRun) return { ok: true, action: 'create', dryRun: true };
+
+  try {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+  } catch (e) {
+    return { ok: false, ...classifyError(/** @type {NodeJS.ErrnoException} */ (e), source) };
+  }
+
+  // Windows 目录必须用 junction：普通目录 symlink 需要管理员权限或开发者模式
+  const type = process.platform === 'win32' ? 'junction' : 'dir';
+  const tmp = `${target}.agent-sync.tmp`;
+
+  try {
+    fs.rmSync(tmp, { force: true, recursive: true });
+    fs.symlinkSync(source, tmp, type);
+    fs.renameSync(tmp, target);
+    return { ok: true, action: 'create' };
+  } catch (e) {
+    try {
+      fs.rmSync(tmp, { force: true, recursive: true });
+    } catch {
+      // 清理失败不影响主流程的错误上报
+    }
+    return { ok: false, ...classifyError(/** @type {NodeJS.ErrnoException} */ (e), source) };
+  }
+}
+
+/**
+ * 删除一个链接。
+ *
+ * 安全约束：**只删链接**。若路径是实体目录或实体文件，一律拒绝——
+ * 那可能是用户自己的东西，绝不代用户做删除决定。
+ *
+ * @param {string} target
+ */
+export function removeLink(target) {
+  if (!lexists(target)) return { ok: true, action: 'noop' };
+  if (!isSymlink(target)) {
+    return { ok: false, reason: 'not-a-link', message: '不是链接，拒绝删除（可能是你自己的目录）' };
+  }
+  try {
+    fs.unlinkSync(target);
+    return { ok: true, action: 'removed' };
+  } catch (e) {
+    return { ok: false, ...classifyError(/** @type {NodeJS.ErrnoException} */ (e), target) };
+  }
+}
+
+/**
+ * 实测当前环境能否创建目录链接。
+ * 在系统临时目录里真建一次再删掉——比检查平台/权限的启发式可靠。
+ */
+export function probeLinkCapability() {
+  const tmpRoot = fs.mkdtempSync(path.join(process.env.TEMP ?? '/tmp', 'agent-sync-probe-'));
+  const src = path.join(tmpRoot, 'src');
+  const dst = path.join(tmpRoot, 'dst');
+  try {
+    fs.mkdirSync(src);
+    createLink(src, dst);
+    const probe = inspect(dst, src);
+    const type = resolveLinkTarget(dst, fs.readlinkSync(dst));
+    return {
+      ok: probe.status === STATUS.HEALTHY,
+      type: process.platform === 'win32' ? 'junction' : 'dir',
+      resolved: type,
+    };
+  } catch (e) {
+    return { ok: false, message: /** @type {Error} */ (e).message };
+  } finally {
+    fs.rmSync(tmpRoot, { force: true, recursive: true });
+  }
+}

package/lib/log.js

@@ -0,0 +1,58 @@
+// @ts-check
+import process from 'node:process';
+
+// 颜色仅在 TTY 下启用，遵循 NO_COLOR 约定
+const useColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+
+// 逐次读取而非模块加载时快照：这样测试可以在 import 之后再关掉输出
+const silent = () => Boolean(process.env.AGENT_SYNC_SILENT);
+
+const ESC = '';
+
+/** @param {string} code */
+const wrap = (code) => (/** @type {string} */ s) =>
+  useColor ? `${ESC}[${code}m${s}${ESC}[0m` : s;
+
+export const dim = wrap('2');
+export const bold = wrap('1');
+export const red = wrap('31');
+export const green = wrap('32');
+export const yellow = wrap('33');
+export const cyan = wrap('36');
+
+export const SYM = {
+  ok: '✅',
+  warn: '⚠️ ',
+  err: '❌',
+  skip: '➖',
+  info: 'ℹ️ ',
+};
+
+/** @param {string} msg */
+export const ok = (msg) => {
+  if (!silent()) console.log(`${SYM.ok} ${msg}`);
+};
+/** @param {string} msg */
+export const warn = (msg) => {
+  if (!silent()) console.log(`${SYM.warn}${yellow(msg)}`);
+};
+/** @param {string} msg */
+export const fail = (msg) => {
+  if (!silent()) console.error(`${SYM.err} ${red(msg)}`);
+};
+/** @param {string} msg */
+export const skip = (msg) => {
+  if (!silent()) console.log(`${SYM.skip} ${dim(msg)}`);
+};
+/** @param {string} msg */
+export const info = (msg) => {
+  if (!silent()) console.log(`${SYM.info}${msg}`);
+};
+/** @param {string} msg */
+export const title = (msg) => {
+  if (!silent()) console.log(`\n${bold(msg)}`);
+};
+/** @param {string} [msg] */
+export const plain = (msg = '') => {
+  if (!silent()) console.log(msg);
+};