@longzai-intelligence-issues/ledger 0.0.1

package/src/__tests__/numbering/numbering.core.test.ts

@@ -0,0 +1,318 @@
+import { describe, expect, test } from 'bun:test';
+
+import {
+  auditCoverage,
+  computeNextNumber,
+  extractFileKey,
+  extractSlugSegment,
+  keyLeadingNumber,
+  scanScopeForFindings,
+} from '@/numbering/numbering.core';
+
+/**
+ * numericPrefix 规则
+ */
+const RULE = { kind: 'numericPrefix' } as const;
+
+describe('extractFileKey', () => {
+  test('numericPrefix：前缀数字 + 分隔符', () => {
+    expect(extractFileKey('0001-a-b.md', RULE)).toBe('0001');
+    expect(extractFileKey('0012.foo.md', RULE)).toBe('0012');
+    expect(extractFileKey('0035_bar.md', RULE)).toBe('0035');
+    expect(extractFileKey('0035 bar.md', RULE)).toBe('0035');
+    expect(extractFileKey('42.md', RULE)).toBe('42');
+  });
+
+  test('无键文件返回 null（不占号）', () => {
+    expect(extractFileKey('README.md', RULE)).toBeNull();
+    expect(extractFileKey('notes-0001.md', RULE)).toBeNull();
+  });
+
+  test('compositePrefix / numericSuffix / customPattern', () => {
+    expect(extractFileKey('12-34-report.md', { kind: 'compositePrefix', groups: 2 })).toBe('12-34');
+    expect(extractFileKey('feedback-7.md', { kind: 'numericSuffix' })).toBe('7');
+    expect(extractFileKey('page-3-note-9.md', { kind: 'numericSuffix' })).toBe('9');
+    expect(extractFileKey('R0007-x.md', { kind: 'customPattern', pattern: 'R(?<key>\\d+)' })).toBe(
+      '0007',
+    );
+    expect(
+      extractFileKey('no-match.md', { kind: 'customPattern', pattern: 'R(?<key>\\d+)' }),
+    ).toBeNull();
+  });
+});
+
+describe('keyLeadingNumber', () => {
+  test('前导数值', () => {
+    expect(keyLeadingNumber('0035')).toBe(35);
+    expect(keyLeadingNumber('12-34')).toBe(12);
+    expect(keyLeadingNumber('abc')).toBeNull();
+  });
+});
+
+describe('computeNextNumber', () => {
+  test('max+1 顺延取首个空闲', () => {
+    const result = computeNextNumber({
+      basenames: ['0001-a.md', '0003-c.md'],
+      rule: RULE,
+      reserved: [],
+    });
+
+    expect(result).toEqual({ ok: true, number: '0004', skippedOccupied: 0, skippedReserved: 0 });
+  });
+
+  test('跳过磁盘空洞已占号与保留号', () => {
+    const result = computeNextNumber({
+      basenames: ['0005-e.md', '0006-f.md'],
+      rule: RULE,
+      reserved: ['0007'],
+    });
+
+    expect(result).toEqual({ ok: true, number: '0008', skippedOccupied: 0, skippedReserved: 1 });
+
+    const withHole = computeNextNumber({
+      basenames: ['0001-a.md', '0003-c.md', '0004-d.md'],
+      rule: RULE,
+      reserved: [],
+    });
+
+    expect(withHole.ok).toBe(true);
+    expect(withHole.ok === true && withHole.number).toBe('0005');
+  });
+
+  test('宽度随数值最大键现行形态（3→4 位自然越界）', () => {
+    const result = computeNextNumber({
+      basenames: ['999-last.md'],
+      rule: RULE,
+      reserved: [],
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.ok === true && result.number).toBe('1000');
+  });
+
+  test('空范围拒绝取号', () => {
+    const result = computeNextNumber({ basenames: ['README.md'], rule: RULE, reserved: [] });
+
+    expect(result.ok).toBe(false);
+    expect(result.ok === false && result.error).toContain('人工定号');
+  });
+
+  test('无键文件不占号（README 不影响）', () => {
+    const result = computeNextNumber({
+      basenames: ['0001-a.md', 'README.md'],
+      rule: RULE,
+      reserved: [],
+    });
+
+    expect(result.ok && result.number).toBe('0002');
+  });
+});
+
+describe('extractSlugSegment', () => {
+  test('剥键与扩展名取 slug 段', () => {
+    expect(extractSlugSegment('0048-runs-list-grace.md')).toBe('runs-list-grace');
+  });
+
+  test('非前缀数字形态返回 null', () => {
+    expect(extractSlugSegment('README.md')).toBeNull();
+  });
+
+  test('无扩展名返回 null', () => {
+    expect(extractSlugSegment('0048-runs')).toBeNull();
+  });
+});
+
+describe('scanScopeForFindings', () => {
+  /**
+   * 扫描入参基座
+   */
+  const baseInput = {
+    scopeKey: 'root',
+    rule: RULE,
+    reserved: [] as Array<{ number: string; reason: string }>,
+    allowlist: [],
+    slugDigitAllowlist: [] as string[],
+    toRepoRelative: (basename: string) => `docs/issues/${basename}`,
+    fullMode: true,
+  };
+
+  test('撞号（豁免精确覆盖前）', () => {
+    const findings = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['0053-a.md', '0053-b.md'],
+    });
+
+    expect(findings).toHaveLength(1);
+    expect(findings[0]?.kind).toBe('duplicate');
+    expect(findings[0]?.message).toContain('0053');
+  });
+
+  test('豁免精确覆盖（排序文件集双向相等）免报', () => {
+    const findings = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['0053-b.md', '0053-a.md'],
+      allowlist: [
+        {
+          scopeKey: 'root',
+          number: '0053',
+          files: ['docs/issues/0053-a.md', 'docs/issues/0053-b.md'],
+          status: '维持现状',
+          reason: '历史撞号',
+        },
+      ],
+    });
+
+    expect(findings).toEqual([]);
+  });
+
+  test('豁免文件集不精确（漂移）判 duplicate 且条目 stale', () => {
+    const findings = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['0053-a.md', '0053-b.md'],
+      allowlist: [
+        {
+          scopeKey: 'root',
+          number: '0053',
+          files: ['docs/issues/0053-a.md'],
+          status: '维持现状',
+          reason: 'r',
+        },
+      ],
+    });
+
+    expect(findings.some((f) => f.kind === 'duplicate')).toBe(true);
+    expect(findings.some((f) => f.kind === 'allowlistStale')).toBe(true);
+  });
+
+  test('保留号被占用（报文含理由）', () => {
+    const findings = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['0081-x.md'],
+      reserved: [{ number: '0081', reason: '历史空洞不回收' }],
+    });
+
+    expect(findings[0]?.kind).toBe('reservedOccupied');
+    expect(findings[0]?.message).toContain('历史空洞不回收');
+  });
+
+  test('零填充位数混用', () => {
+    const findings = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['0035-a.md', '0123-b.md', '123-c.md'],
+    });
+
+    expect(findings.some((f) => f.kind === 'widthInconsistent')).toBe(true);
+  });
+
+  test('无填充自然增长族不判混用', () => {
+    const findings = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['1-a.md', '9-b.md', '35-c.md'],
+    });
+
+    expect(findings.some((f) => f.kind === 'widthInconsistent')).toBe(false);
+  });
+
+  test('豁免条目无现行撞号组判 stale（棘轮只许缩短）', () => {
+    const findings = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['0001-a.md'],
+      allowlist: [
+        {
+          scopeKey: 'root',
+          number: '0099',
+          files: ['docs/issues/0099-a.md', 'docs/issues/0099-b.md'],
+          status: '待清偿',
+          reason: 'r',
+        },
+      ],
+    });
+
+    expect(findings[0]?.kind).toBe('allowlistStale');
+  });
+
+  test('slug 含数字违规与白名单豁免', () => {
+    const findings = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['0048-runs-list-grace.md', '0049-model-v2.md'],
+      slugDigitPolicy: 'forbid',
+      slugDigitAllowlist: ['docs/issues/0049-model-v2.md'],
+    });
+
+    expect(findings).toEqual([]);
+  });
+
+  test('slug 含数字未豁免违规', () => {
+    const findings = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['0049-model-v2.md'],
+      slugDigitPolicy: 'forbid',
+    });
+
+    expect(findings[0]?.kind).toBe('slugContainsDigit');
+  });
+
+  test('全量档白名单失效对账（增量档关闭）', () => {
+    const full = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['0001-a.md'],
+      slugDigitPolicy: 'forbid',
+      slugDigitAllowlist: ['docs/issues/0099-ghost.md'],
+    });
+
+    expect(full.some((f) => f.kind === 'slugDigitAllowlistStale')).toBe(true);
+
+    const incremental = scanScopeForFindings({
+      ...baseInput,
+      basenames: ['0001-a.md'],
+      slugDigitPolicy: 'forbid',
+      slugDigitAllowlist: ['docs/issues/0099-ghost.md'],
+      fullMode: false,
+    });
+
+    expect(incremental.some((f) => f.kind === 'slugDigitAllowlistStale')).toBe(false);
+  });
+});
+
+describe('auditCoverage', () => {
+  test('未覆盖编号文件按目录聚合 coverageGap', () => {
+    const findings = auditCoverage({
+      files: ['docs/decisions/0001-x.md', 'docs/decisions/0002-y.md', 'docs/issues/0001-z.md'],
+      numberishPattern: '^\\d{1,4}[-._]',
+      registryDirs: ['docs/issues'],
+      pending: [],
+    });
+
+    expect(findings).toHaveLength(1);
+    expect(findings[0]?.kind).toBe('coverageGap');
+    expect(findings[0]?.message).toContain('docs/decisions');
+    expect(findings[0]?.message).toContain('0001-x.md');
+  });
+
+  test('pending 覆盖免报且未命中判 pendingStale', () => {
+    const findings = auditCoverage({
+      files: ['docs/reports/0005-r.md'],
+      numberishPattern: '^\\d{1,4}[-._]',
+      registryDirs: [],
+      pending: [
+        { glob: 'docs/reports/*.md', reason: '规划中' },
+        { glob: 'docs/plans/*.md', reason: '规划中' },
+      ],
+    });
+
+    expect(findings).toHaveLength(1);
+    expect(findings[0]?.kind).toBe('pendingStale');
+    expect(findings[0]?.message).toContain('docs/plans/*.md');
+  });
+
+  test('非形似编号文件不入判定面', () => {
+    const findings = auditCoverage({
+      files: ['docs/notes/README.md'],
+      numberishPattern: '^\\d{1,4}[-._]',
+      registryDirs: [],
+      pending: [],
+    });
+
+    expect(findings).toEqual([]);
+  });
+});

package/src/__tests__/parser/guide-fixture.utils.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from 'bun:test';
+
+import {
+  GUIDE_FIXTURE_END_MARK,
+  GUIDE_FIXTURE_START_MARK,
+  loadIssueFileFormatGuide,
+  sliceGuideFixtureSample,
+} from '@/parser/guide-fixture.utils';
+import { renderIssueTemplateSkeleton } from '@/template/issue-template.renderer';
+
+/**
+ * 指南全文（每次测试现读真源，杜绝缓存漂移）
+ */
+const guide = loadIssueFileFormatGuide();
+
+describe('格式指南活样板零漂移', () => {
+  test('指南存在且夹具标记在位', () => {
+    expect(guide.includes(GUIDE_FIXTURE_START_MARK)).toBe(true);
+    expect(guide.includes(GUIDE_FIXTURE_END_MARK)).toBe(true);
+  });
+
+  test('活样板与骨架渲染真源逐字一致', () => {
+    expect(sliceGuideFixtureSample(guide)).toBe(renderIssueTemplateSkeleton().replace(/\n+$/, ''));
+  });
+});
+
+describe('sliceGuideFixtureSample 负路径', () => {
+  test('起点标记缺席显式抛错', () => {
+    expect(() => sliceGuideFixtureSample(`正文\n${GUIDE_FIXTURE_END_MARK}`)).toThrow(
+      '起点标记缺席',
+    );
+  });
+
+  test('终点标记缺席显式抛错', () => {
+    expect(() => sliceGuideFixtureSample(`正文\n${GUIDE_FIXTURE_START_MARK}`)).toThrow(
+      '终点标记缺席',
+    );
+  });
+
+  test('标记次序颠倒显式抛错', () => {
+    expect(() =>
+      sliceGuideFixtureSample(`${GUIDE_FIXTURE_END_MARK}\n正文\n${GUIDE_FIXTURE_START_MARK}`),
+    ).toThrow('次序颠倒');
+  });
+});

package/src/__tests__/parser/registry.parser.test.ts

@@ -0,0 +1,316 @@
+import { describe, expect, test } from 'bun:test';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+
+import {
+  parseCriteriaBlock,
+  parseIssueDoc,
+  parseRegistryFileName,
+  scanRegistryDir,
+} from '@/parser/registry.parser';
+
+/**
+ * 基准样例文档（粗体标签形态头部）
+ */
+const SAMPLE_DOC = [
+  '# 0001 - 样例问题标题',
+  '',
+  '**优先级**: P2',
+  '**状态**: 🔴 待处理',
+  '**立案日期**: 2026-09-14',
+  '**所属域**: 样例域',
+  '**来源**: 用户裁定（2026-09-14）',
+  '**沿革**: [0002](./0002-prior-issue.md)',
+  '**阻塞**: [0003](./0003-blocker.md)；[0004]',
+  '',
+  '## 一、问题动机',
+  '',
+  '> 问题原文',
+  '',
+  '## 二、现状与证据',
+  '',
+  '排查记录',
+  '',
+  '## 三、处置方向',
+  '',
+  '【1】备选方案和分析',
+  '',
+  '## 四、处置结果/验证口径',
+  '',
+  '处置完成',
+].join('\n');
+
+describe('parseRegistryFileName', () => {
+  test('命中口径：编号 + slug + .md', () => {
+    expect(parseRegistryFileName('0035-runs-list-grace.md')).toEqual({
+      id: '0035',
+      slug: 'runs-list-grace',
+    });
+  });
+
+  test('3 位编号同样命中', () => {
+    expect(parseRegistryFileName('035-a.md')).toEqual({ id: '035', slug: 'a' });
+  });
+
+  test('README 不命中', () => {
+    expect(parseRegistryFileName('README.md')).toBeNull();
+  });
+
+  test('无 slug 段不命中', () => {
+    expect(parseRegistryFileName('0001.md')).toBeNull();
+  });
+
+  test('5 位编号不命中（口径 3-4 位）', () => {
+    expect(parseRegistryFileName('00001-too-long.md')).toBeNull();
+  });
+});
+
+describe('parseIssueDoc 状态行', () => {
+  test('粗体标签形态定位成功并归类 red', () => {
+    const record = parseIssueDoc('0001-sample.md', SAMPLE_DOC, 0);
+
+    expect(record?.status).toBe('red');
+    expect(record?.statusLineNumber).toBe(4);
+    expect(record?.title).toBe('0001 - 样例问题标题');
+  });
+
+  test('半角冒号裸键形态同样定位', () => {
+    const record = parseIssueDoc('0001-sample.md', '状态: 🟡 处理中（等待上游发版才能复测）', 0);
+
+    expect(record?.status).toBe('yellow');
+    expect(record?.pendingReason).toBe('等待上游发版才能复测');
+  });
+
+  test('窗口外（第 31 行起）不定位，归 unknown', () => {
+    const record = parseIssueDoc(
+      '0001-sample.md',
+      `${Array.from({ length: 30 }, () => '正文行').join('\n')}\n状态: 🔴 待处理`,
+      0,
+    );
+
+    expect(record?.status).toBe('unknown');
+    expect(record?.statusLineNumber).toBe(0);
+  });
+
+  test('挂起原因不足 4 字符判 null', () => {
+    const record = parseIssueDoc('0001-sample.md', '状态: 🟡 处理中（等待）', 0);
+
+    expect(record?.status).toBe('yellow');
+    expect(record?.pendingReason).toBeNull();
+  });
+
+  test('旧格式黄灯归类 legacy-yellow', () => {
+    const record = parseIssueDoc('0001-sample.md', '**状态**: 🟡 某旧写法', 0);
+
+    expect(record?.status).toBe('legacy-yellow');
+  });
+
+  test('规范绿灯归类 green', () => {
+    const record = parseIssueDoc(
+      '0001-sample.md',
+      '**状态**: 🟢 已处置（修复完成——判据证据锚点见处置段）',
+      0,
+    );
+
+    expect(record?.status).toBe('green');
+  });
+
+  test('旧格式绿灯归类 legacy-green', () => {
+    const record = parseIssueDoc('0001-sample.md', '**状态**: 🟢 done', 0);
+
+    expect(record?.status).toBe('legacy-green');
+  });
+
+  test('已冻结优先归类 frozen', () => {
+    const record = parseIssueDoc('0001-sample.md', '**状态**: ⚪ 已冻结（用户裁定暂停推进）', 0);
+
+    expect(record?.status).toBe('frozen');
+  });
+
+  test('已取消归类 canceled 并提取括注原因', () => {
+    const record = parseIssueDoc('0001-sample.md', '**状态**: ⚫ 已取消（重复立案并入 0002）', 0);
+
+    expect(record?.status).toBe('canceled');
+    expect(record?.pendingReason).toBe('重复立案并入 0002');
+  });
+});
+
+describe('parseIssueDoc 处置段', () => {
+  test('处置段在位且终态内容非占位', () => {
+    const record = parseIssueDoc('0001-sample.md', SAMPLE_DOC, 0);
+
+    expect(record?.hasDispositionSection).toBe(true);
+    expect(record?.dispositionIsPlaceholder).toBe(false);
+  });
+
+  test('窗口内命中占位模式判占位', () => {
+    const record = parseIssueDoc(
+      '0001-sample.md',
+      '状态: 🟢 已处置\n\n## 四、处置结果/验证口径\n\n（处置中）\n',
+      0,
+    );
+
+    expect(record?.dispositionIsPlaceholder).toBe(true);
+  });
+
+  test('正文状语形态不计占位', () => {
+    const record = parseIssueDoc(
+      '0001-sample.md',
+      '状态: 🟢 已处置\n\n## 四、处置结果/验证口径\n\n处置中新核实的证据链如下。\n',
+      0,
+    );
+
+    expect(record?.dispositionIsPlaceholder).toBe(false);
+  });
+
+  test('占位出现在窗口外（第 9 行起）不计', () => {
+    const record = parseIssueDoc(
+      '0001-sample.md',
+      [
+        '状态: 🟢 已处置',
+        '## 四、处置结果/验证口径',
+        ...Array.from({ length: 8 }, () => '正文行'),
+        '（待回填）',
+      ].join('\n'),
+      0,
+    );
+
+    expect(record?.dispositionIsPlaceholder).toBe(false);
+  });
+});
+
+describe('parseIssueDoc 证据锚点与沿革阻塞', () => {
+  test('证据锚点块两种标题形态均在位判定', () => {
+    const evidenceClose = parseIssueDoc(
+      '0001-sample.md',
+      '状态: 🟢 已处置\n\n## 四、处置结果/验证口径\n\n证据锚点（末次通过零执行收口）：\n- 退出码 0\n',
+      0,
+    );
+
+    const rerunClose = parseIssueDoc(
+      '0001-sample.md',
+      '状态: 🟢 已处置\n\n## 四、处置结果/验证口径\n\n判据执行证据（证书化收口）：\n- 证书指纹 abc\n',
+      0,
+    );
+
+    expect(evidenceClose?.hasEvidenceAnchorBlock).toBe(true);
+    expect(rerunClose?.hasEvidenceAnchorBlock).toBe(true);
+  });
+
+  test('沿革阻塞引用提取（链接与纯编号两形态）', () => {
+    const record = parseIssueDoc('0001-sample.md', SAMPLE_DOC, 0);
+
+    expect(record?.historyRefs).toEqual([{ number: '0002', slug: 'prior-issue' }]);
+    expect(record?.blockedByRefs).toEqual([
+      { number: '0003', slug: 'blocker' },
+      { number: '0004', slug: null },
+    ]);
+  });
+
+  test('裸键元信息行（无粗体）同样提取', () => {
+    const record = parseIssueDoc('0001-sample.md', '沿革: [0007](./0007-x.md)', 0);
+
+    expect(record?.historyRefs).toEqual([{ number: '0007', slug: 'x' }]);
+  });
+});
+
+describe('parseCriteriaBlock', () => {
+  test('合法块解析（summary + 多判据 + 注释行跳过）', () => {
+    const raw = [
+      '```criteria',
+      '# 注释行',
+      'summary: 判据全绿',
+      '单包测试|test|packages/demo|bun run test',
+      '类型检查|typecheck|packages/demo|bun run typecheck',
+      '```',
+    ].join('\n');
+
+    const parsed = parseCriteriaBlock(raw);
+
+    expect(parsed.summary).toBe('判据全绿');
+    expect(parsed.criteria).toHaveLength(2);
+    expect(parsed.criteria[0]).toEqual({
+      label: '单包测试',
+      channel: 'test',
+      cwd: 'packages/demo',
+      command: 'bun run test',
+    });
+  });
+
+  test('多块拒收并带第二块行号', () => {
+    const raw = ['```criteria', 'a|b|c|d', '```', '正文', '```criteria', 'e|f|g|h', '```'].join(
+      '\n',
+    );
+
+    expect(() => parseCriteriaBlock(raw)).toThrow('第二块');
+  });
+
+  test('未闭合拒收', () => {
+    const raw = ['```criteria', 'a|b|c|d'].join('\n');
+
+    expect(() => parseCriteriaBlock(raw)).toThrow('未闭合');
+  });
+
+  test('判据非四段拒收并带行号', () => {
+    const raw = ['```criteria', 'summary: s', '只有三段|b|c', '```'].join('\n');
+
+    expect(() => parseCriteriaBlock(raw)).toThrow('第 3 行');
+  });
+
+  test('channel 不合法拒收', () => {
+    const raw = ['```criteria', '标签|<channel>|cwd|cmd', '```'].join('\n');
+
+    expect(() => parseCriteriaBlock(raw)).toThrow('channel');
+  });
+
+  test('summary 空值与重复均拒收', () => {
+    expect(() =>
+      parseCriteriaBlock(['```criteria', 'summary: ', 'a|b|c|d', '```'].join('\n')),
+    ).toThrow('summary 值为空');
+
+    expect(() =>
+      parseCriteriaBlock(['```criteria', 'summary: a', 'summary: b', 'a|b|c|d', '```'].join('\n')),
+    ).toThrow('summary 重复');
+  });
+
+  test('空块（零判据）拒收', () => {
+    expect(() => parseCriteriaBlock(['```criteria', 'summary: s', '```'].join('\n'))).toThrow(
+      '至少一条判据',
+    );
+  });
+
+  test('块缺席拒收', () => {
+    expect(() => parseCriteriaBlock('无块的文档')).toThrow('未找到');
+  });
+});
+
+describe('parseIssueDoc criteria 错误记录', () => {
+  test('畸形块记录 criteriaError 不中断读档', () => {
+    const raw = ['状态: 🟡 处理中（补充判据中）', '', '```criteria', '坏行', '```'].join('\n');
+
+    const record = parseIssueDoc('0001-sample.md', raw, 0);
+
+    expect(record?.criteria).toBeNull();
+    expect(record?.criteriaError).toContain('第 4 行');
+  });
+});
+
+describe('scanRegistryDir', () => {
+  test('目录缺席返回空数组', () => {
+    expect(scanRegistryDir('/nonexistent/registry-dir')).toEqual([]);
+  });
+
+  test('只收口径内文件并按编号升序', () => {
+    const dir = `${import.meta.dir}/__tmp-scan__`;
+
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(`${dir}/0002-second.md`, '状态: 🔴 待处理');
+    writeFileSync(`${dir}/0001-first.md`, '状态: 🔴 待处理');
+    writeFileSync(`${dir}/README.md`, '说明文件不收编');
+
+    const records = scanRegistryDir(dir);
+
+    expect(records.map((record) => record.id)).toEqual(['0001', '0002']);
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+});