@longzai-intelligence-issues/ledger 0.0.1 → 0.0.3

package/src/migrate/migrate-legacy.vocab.ts

@@ -0,0 +1,242 @@
+/**
+ * migrate-legacy 词表与纯规范化函数（无 IO，自 migrate-legacy.core 拆出守文件行上限）
+ *
+ * 字段值粗体清理、pre-emoji 状态词表匹配与五态规范化、优先级档位映射、H1 规范化。
+ */
+
+import { LEGACY_STATUS_VOCABULARY } from '@/parser/format.utils';
+
+/**
+ * 状态词匹配产物
+ */
+type StatusWordMatch = {
+  /**
+   * 词表档位
+   */
+  tier: 'green' | 'red' | 'deferred' | 'canceled' | 'inProgress' | 'frozen';
+
+  /**
+   * 命中词
+   */
+  word: string;
+};
+
+/**
+ * 状态值规范化产物
+ */
+type CanonicalStatusValue = {
+  /**
+   * 规范状态值（五态灯位 + 溯源括注）
+   */
+  value: string;
+
+  /**
+   * 词表档位
+   */
+  tier: StatusWordMatch['tier'];
+
+  /**
+   * 命中词（原词溯源）
+   */
+  word: string;
+};
+
+/**
+ * 清理字段值（去首尾空白与粗体星号——覆盖三种历史形态：整体包裹 `**值**`、
+ * 前导无尾随 `**值`、词中包裹 `**词**（括注）`）
+ *
+ * @param value - 原值
+ * @returns 清理后值
+ */
+export function cleanValue(value: string): string {
+  return value
+    .trim()
+    .replace(/^\*\*/, '')
+    .replace(/\*\*$/, '')
+    .replace(/\*\*(?=[（(])/, '')
+    .trim();
+}
+
+/**
+ * 在状态值中匹配 pre-emoji 词表
+ *
+ * @param value - 清理后的状态值
+ * @returns 命中档位与词；未命中为 null
+ */
+function matchStatusWord(value: string): StatusWordMatch | null {
+  /**
+   * 档位遍历序（frozen 最先——冻结态优先识别并拒绝迁移）
+   */
+  const tiers: StatusWordMatch['tier'][] = [
+    'frozen',
+    'green',
+    'deferred',
+    'canceled',
+    'inProgress',
+    'red',
+  ];
+
+  for (const tier of tiers) {
+    for (const word of LEGACY_STATUS_VOCABULARY[tier]) {
+      if (value.startsWith(word)) {
+        return { tier, word };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * 状态值切分产物（首个括注内容与词后剩余文本）
+ */
+type StatusValueSplit = {
+  /**
+   * 首个括注内容（无括注为空串）
+   */
+  paren: string;
+
+  /**
+   * 括注后的剩余文本
+   */
+  rest: string;
+};
+
+/**
+ * 提取状态值中的首个括注与其余文本
+ *
+ * @param value - 清理后的状态值
+ * @param word - 命中词
+ * @returns 括注内容与词后剩余文本
+ */
+function splitStatusValue(value: string, word: string): StatusValueSplit {
+  /**
+   * 词后文本
+   */
+  const afterWord = value.slice(word.length).trim();
+
+  /**
+   * 首个括注匹配
+   */
+  const parenMatch = /^[（(]([^）)]*)[）)]/.exec(afterWord);
+
+  if (parenMatch === null) {
+    return { paren: '', rest: afterWord };
+  }
+
+  return {
+    paren: (parenMatch[1] ?? '').trim(),
+    rest: afterWord.slice((parenMatch[0] ?? '').length).trim(),
+  };
+}
+
+/**
+ * 规范化状态值（pre-emoji 词 → 五态灯位；原词与括注零丢失保留）
+ *
+ * @param value - 清理后的状态值
+ * @returns 规范值与档位；不可机械迁移为 null（须人工）
+ */
+export function canonicalizeStatusValue(value: string): CanonicalStatusValue | null {
+  /**
+   * 词表命中
+   */
+  const match = matchStatusWord(value);
+
+  if (match === null) {
+    return null;
+  }
+
+  /**
+   * 括注与剩余文本
+   */
+  const { paren, rest } = splitStatusValue(value, match.word);
+
+  /**
+   * 括注段收集器（顺序：括注 → 剩余 → 原词溯源）
+   */
+  const parts = [paren, rest, `原「${match.word}」`].filter((part) => part !== '');
+
+  switch (match.tier) {
+    case 'frozen':
+      return null;
+
+    case 'green':
+      return { value: `🟢 已处置（${parts.join('；')}）`, tier: match.tier, word: match.word };
+
+    case 'red':
+      return { value: `🔴 待处理（${parts.join('；')}）`, tier: match.tier, word: match.word };
+
+    case 'deferred':
+      return {
+        value: `🔴 待处理（${[paren === '' ? '延期' : paren, `原「${match.word}」`].join('；')}）`,
+        tier: match.tier,
+        word: match.word,
+      };
+
+    case 'canceled':
+      return paren === '' || paren.length < 4
+        ? null
+        : { value: `⚫ 已取消（${parts.join('；')}）`, tier: match.tier, word: match.word };
+
+    case 'inProgress':
+      return paren.length < 4
+        ? null
+        : { value: `🟡 处理中（${paren}）`, tier: match.tier, word: match.word };
+  }
+}
+
+/**
+ * 严重程度/中文优先级 → P 档位映射
+ *
+ * @param value - 原值（高/中/低或 P1/P2/P3）
+ * @returns P 档位；不可映射为 null
+ */
+export function mapPriorityValue(value: string): 'P1' | 'P2' | 'P3' | null {
+  /**
+   * 严重程度中文档位与 P 档位的等价映射表（P 档位原样透传）
+   */
+  const table: Record<string, 'P1' | 'P2' | 'P3'> = {
+    高: 'P1',
+    中: 'P2',
+    低: 'P3',
+    P1: 'P1',
+    P2: 'P2',
+    P3: 'P3',
+  };
+
+  return table[cleanValue(value)] ?? null;
+}
+
+/**
+ * H1 规范化产物
+ */
+type CanonicalH1 = {
+  /**
+   * 规范标题行（`# NNNN - 标题核心`）
+   */
+  line: string;
+
+  /**
+   * 标题核心（剥离既有编号与分隔符变体后的标题文本）
+   */
+  titleCore: string;
+};
+
+/**
+ * H1 标题规范化：`# NNNN - 标题`（剥离既有编号与分隔符变体）
+ *
+ * @param h1 - 原一级标题行
+ * @param number - 文件名编号
+ * @returns 规范标题行与标题核心
+ */
+export function canonicalizeH1(h1: string, number: string): CanonicalH1 {
+  /**
+   * 标题核心（去行首 `# ` 与既有编号 + 分隔符变体——含 em-dash 与叠用形态）
+   */
+  const titleCore = h1
+    .replace(/^#\s+/, '')
+    .replace(new RegExp(`^${number}\\s*(?:[-—―·.．：:－]+\\s*)?`), '')
+    .trim();
+
+  return { line: `# ${number} - ${titleCore}`, titleCore };
+}

package/src/normalize/normalize-header.commands.ts

@@ -1,15 +1,36 @@
 /**
  * normalize-header（方言头部迁移）
  *
- * 四种历史方言（单行管道引用行 / 粗体标签行 / `## 键: 值` 标题式 / `- ` 列表式）
- * 解析后重排为裁定格式：粗体标签逐行 `**键**: 值`；字段规范序（FIELD_RANK）；
- * 「主题」问题陈述迁正文首个节标题后；residual 原样保留。零丢失守卫：每字段
- * 必须在产物文本在场否则 failed 不落盘；幂等（产物 === 原文 → unchanged）。
+ * 五种历史方言（单行管道引用行 / 粗体标签行 / `## 键: 值` 标题式 / `- ` 列表式 /
+ * `| 键 | 值 |` 表格）与两类复合形态（引用行内粗体键 `> **键**: 值`、标题式隔行值
+ * `## 键` + 下一非空独立行）解析后重排为裁定格式：粗体标签逐行 `**键**: 值`；字段
+ * 规范序（FIELD_RANK）；「主题」问题陈述迁正文首个节标题后；residual 原样保留。
+ * 零丢失守卫：每字段必须在产物文本在场否则 failed 不落盘；幂等（产物 === 原文 →
+ * unchanged）。
  */
 
 import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
+import { CANONICAL_STATUS_LABELS } from '@/parser/format.utils';
+
+/**
+ * 标题式隔行值认定键集（`## 键` + 下一非空独立行为值的复合方言）
+ *
+ * 键限集合防误吞：非元信息键的 `## 节` 仍按正文边界终止头部；值行另有独立
+ * 短行约束（见 parseHeaderDialect 形态七），流水段落首行不受影响。
+ */
+export const HEADING_ALONE_METADATA_KEYS: ReadonlySet<string> = new Set([
+  '优先级',
+  '状态',
+  '立案日期',
+  '日期',
+  '所属域',
+  '来源',
+  '严重程度',
+  '严重度',
+]);
+
 /**
  * 字段规范序（排名值越小越靠前；未入表字段按首现序殿后）
  */
@@ -35,6 +56,12 @@ export type NormalizeHeaderFileInput = {
    * issue 文件仓库相对路径
    */
   file: string;
+
+  /**
+   * 无可识别状态行时的显式灯位（--status 语义；frozen 不在此通道——冻结唯一合法
+   * 写入路径是 freeze 命令，其裁定语硬门不可绕过）
+   */
+  status?: 'red' | 'yellow' | 'green' | 'canceled';
 };
 
 /**
@@ -60,7 +87,7 @@ export type NormalizeHeaderResult = {
 /**
  * 头部解析产物
  */
-type ParsedHeader = {
+export type ParsedHeader = {
   /**
    * 字段键值对（保序）
    */
@@ -78,12 +105,13 @@ type ParsedHeader = {
 };
 
 /**
- * 解析头部方言（四种形态逐行尝试）
+ * 解析头部方言（五种形态逐行尝试：粗体标签 / 列表式 / 标题式 / 管道引用行 / 表格；
+ * 另含两类复合形态：引用行内粗体键、标题式隔行值）
  *
  * @param lines - 文档行数组
  * @returns 头部解析产物
  */
-function parseHeaderDialect(lines: string[]): ParsedHeader {
+export function parseHeaderDialect(lines: string[]): ParsedHeader {
   /**
    * 字段收集器
    */
@@ -105,6 +133,71 @@ function parseHeaderDialect(lines: string[]): ParsedHeader {
      */
     const line = lines[index] ?? '';
 
+    /**
+     * 形态七：标题式隔行值（`## 键` 单独成行 + 下一非空独立行为值）
+     *
+     * 值行须为独立短行：非结构前缀（# > * | ` -）、非键值形态自身、长度上限
+     * 40——三者合力防吞流水段落首行；键限 HEADING_ALONE_METADATA_KEYS。
+     */
+    const aloneMatch = /^##\s+([^：:]{1,10})\s*$/.exec(line);
+
+    if (aloneMatch !== null && HEADING_ALONE_METADATA_KEYS.has(aloneMatch[1]?.trim() ?? '')) {
+      /**
+       * 值行下标（跳过标题行与值行之间的空行）
+       */
+      let valueIndex = index + 1;
+
+      while (valueIndex < lines.length && (lines[valueIndex] ?? '').trim() === '') {
+        valueIndex += 1;
+      }
+
+      /**
+       * 候选值行（去空白）
+       */
+      const valueLine = (lines[valueIndex] ?? '').trim();
+
+      /**
+       * 独立短行判定（非结构前缀 / 非键值形态 / 长度上限）
+       */
+      const isBareValue =
+        valueLine !== '' &&
+        !/^[#>*|`-]/.test(valueLine) &&
+        !/^[^：:]{1,8}[：:]/.test(valueLine) &&
+        valueLine.length <= 40;
+
+      if (isBareValue) {
+        fields.push({ key: aloneMatch[1]?.trim() ?? '', value: valueLine });
+
+        /**
+         * 值后空行下标（跳过值行与下一非空行之间的空行）
+         */
+        let afterBlanks = valueIndex + 1;
+
+        while (afterBlanks < lines.length && (lines[afterBlanks] ?? '').trim() === '') {
+          afterBlanks += 1;
+        }
+
+        /**
+         * 后继非空行（判定是否又一标题式隔行值对——是则越过空行续扫，否则
+         * 空行照常终止头部区）
+         */
+        const nextLine = lines[afterBlanks] ?? '';
+
+        /**
+         * 后继行的标题式隔行值匹配（连续元信息对判定）
+         */
+        const nextAloneMatch = /^##\s+([^：:]{1,10})\s*$/.exec(nextLine);
+
+        index =
+          nextAloneMatch !== null &&
+          HEADING_ALONE_METADATA_KEYS.has(nextAloneMatch[1]?.trim() ?? '')
+            ? afterBlanks - 1
+            : valueIndex;
+
+        continue;
+      }
+    }
+
     if (line.startsWith('## ') || (line === '' && fields.length > 0 && index > 4)) {
       bodyStartIndex = index;
 
@@ -127,9 +220,9 @@ function parseHeaderDialect(lines: string[]): ParsedHeader {
     }
 
     /**
-     * 形态二/四：粗体标签行 / 列表式
+     * 形态二/四/六：粗体标签行 / 列表式 / 列表+粗体复合（`- **键**: 值`）
      */
-    const labeledMatch = /^(?:\*\*|- )([^*：:]{1,8})(?:\*\*)?\s*[：:]\s*(.+)$/.exec(line);
+    const labeledMatch = /^(?:\*\*|- \*\*|- )([^*：:]{1,8})(?:\*\*)?\s*[：:]\s*(.+)$/.exec(line);
 
     if (labeledMatch !== null) {
       fields.push({ key: labeledMatch[1]?.trim() ?? '', value: labeledMatch[2]?.trim() ?? '' });
@@ -137,6 +230,60 @@ function parseHeaderDialect(lines: string[]): ParsedHeader {
       continue;
     }
 
+    /**
+     * 形态七：多行元信息（`- 键：` 空值 + 缩进子项——子项文本以「；」并入单行值）
+     */
+    const multiLineKeyMatch = /^(?:\*\*|- \*\*|- )([^*：:]{1,8})(?:\*\*)?\s*[：:]\s*$/.exec(line);
+
+    if (multiLineKeyMatch !== null) {
+      /**
+       * 子项行收集器（缩进深于键行者；子项文本去列表标记后原样保留）
+       */
+      const childTexts: string[] = [];
+
+      /**
+       * 键行缩进宽度
+       */
+      const keyIndent = line.length - line.trimStart().length;
+
+      /**
+       * 子项游标
+       */
+      let childIndex = index + 1;
+
+      while (childIndex < lines.length) {
+        /**
+         * 候选子项行
+         */
+        const childLine = lines[childIndex] ?? '';
+
+        if (childLine.trim() === '') {
+          break;
+        }
+
+        /**
+         * 子项缩进
+         */
+        const childIndent = childLine.length - childLine.trimStart().length;
+
+        if (childIndent <= keyIndent) {
+          break;
+        }
+
+        childTexts.push(childLine.trim().replace(/^-\s*/, ''));
+
+        childIndex += 1;
+      }
+
+      if (childTexts.length > 0) {
+        fields.push({ key: multiLineKeyMatch[1]?.trim() ?? '', value: childTexts.join('；') });
+
+        index = childIndex - 1;
+
+        continue;
+      }
+    }
+
     /**
      * 形态一：单行管道引用行（`> 优先级 ｜ 状态 ｜ …`）
      */
@@ -149,19 +296,87 @@ function parseHeaderDialect(lines: string[]): ParsedHeader {
         .split(/[｜|]/)
         .map((segment) => segment.trim());
 
+      /**
+       * 未命中键值的段（零段命中时整行原样入 residual——保 `> ` 前缀原貌）
+       */
+      const unmatched: string[] = [];
+
       for (const segment of segments) {
         /**
-         * 段内键值切分
+         * 段内键值切分（键清理粗体包裹——`> **键**: 值` 复合形态与粗体标签行同口径）
          */
         const pairMatch = /^([^：:]{1,8})\s*[：:]\s*(.+)$/.exec(segment);
 
         if (pairMatch !== null) {
-          fields.push({ key: pairMatch[1]?.trim() ?? '', value: pairMatch[2]?.trim() ?? '' });
+          fields.push({
+            key: (pairMatch[1] ?? '').replace(/^\*+|\*+$/g, '').trim(),
+            value: pairMatch[2]?.trim() ?? '',
+          });
         } else {
-          residuals.push(segment);
+          unmatched.push(segment);
         }
       }
 
+      if (unmatched.length === segments.length) {
+        residuals.push(line);
+      } else {
+        residuals.push(...unmatched);
+      }
+
+      continue;
+    }
+
+    /**
+     * 形态五：表格方言（两列表 `| 键 | 值 |`；表头行与分隔行为表格脚手架，键值
+     * 提取后丢弃——脚手架无独立语义，保留会在规范头部产出破碎表格残片）
+     */
+    const tableMatch = /^\|([^|]*)\|([^|]*)\|$/.exec(line.trim());
+
+    if (tableMatch !== null) {
+      /**
+       * 键单元格 / 值单元格
+       */
+      const keyCell = (tableMatch[1] ?? '').trim();
+
+      /**
+       * 值单元格（数据行切键值的值侧）
+       */
+      const valueCell = (tableMatch[2] ?? '').trim();
+
+      /**
+       * 分隔行形态（单元格仅 dashes/colons——`| --- | --- |`）
+       */
+      const separatorCellPattern = /^:?-{2,}:?$/;
+
+      /**
+       * 本行是否分隔行
+       */
+      const isSeparator =
+        separatorCellPattern.test(keyCell) && separatorCellPattern.test(valueCell);
+
+      /**
+       * 次行（表头行判定：分隔行紧前的一行是表头）
+       */
+      const nextMatch = /^\|([^|]*)\|([^|]*)\|$/.exec((lines[index + 1] ?? '').trim());
+
+      /**
+       * 次行是否表格分隔行（当前行为表头行的判定依据）
+       */
+      const nextIsTableSeparator =
+        nextMatch !== null &&
+        separatorCellPattern.test((nextMatch[1] ?? '').trim()) &&
+        separatorCellPattern.test((nextMatch[2] ?? '').trim());
+
+      if (isSeparator || (nextIsTableSeparator && keyCell !== '')) {
+        continue;
+      }
+
+      if (keyCell !== '') {
+        fields.push({ key: keyCell, value: valueCell });
+      } else {
+        residuals.push(line);
+      }
+
       continue;
     }
 
@@ -187,6 +402,16 @@ function fieldSortKey(key: string, firstSeenRank: number): number {
  */
 export type NormalizeOutcome = 'rewritten' | 'unchanged' | 'skipped';
 
+/**
+ * normalizeHeader 迁移选项（无可识别状态行时的显式灯位注入）
+ */
+export type NormalizeHeaderOptions = {
+  /**
+   * 显式灯位（--status 语义；frozen 不在此通道——冻结唯一合法写入路径是 freeze）
+   */
+  status?: NormalizeHeaderFileInput['status'];
+};
+
 /**
  * 迁移产物
  */
@@ -206,9 +431,10 @@ export type NormalizeResult = {
  * 迁移单份文档头部
  *
  * @param raw - 文档全文
+ * @param options - 迁移选项（无可识别状态行时的显式灯位注入）
  * @returns 迁移产物
  */
-export function normalizeHeader(raw: string): NormalizeResult {
+export function normalizeHeader(raw: string, options?: NormalizeHeaderOptions): NormalizeResult {
   /**
    * 文档行数组
    */
@@ -220,12 +446,19 @@ export function normalizeHeader(raw: string): NormalizeResult {
   const parsed = parseHeaderDialect(lines);
 
   /**
-   * 「状态」字段定位（无状态行 skipped——灯位属语义判断，不猜灯）
+   * 「状态」字段定位（无状态行且未给 --status 则 skipped——灯位属语义判断，不猜灯）
    */
   const hasStatus = parsed.fields.some((field) => field.key === '状态');
 
   if (!hasStatus) {
-    return { content: raw, outcome: 'skipped' };
+    if (options?.status === undefined) {
+      return { content: raw, outcome: 'skipped' };
+    }
+
+    /**
+     * 显式灯位注入（--status）：以规范标签落状态行，排入 FIELD_RANK 规范序
+     */
+    parsed.fields.push({ key: '状态', value: CANONICAL_STATUS_LABELS[options.status] });
   }
 
   /**
@@ -328,7 +561,7 @@ export function normalizeHeaderFile(input: NormalizeHeaderFileInput): NormalizeH
   /**
    * 迁移产物
    */
-  const normalized = normalizeHeader(raw);
+  const normalized = normalizeHeader(raw, { status: input.status });
 
   if (normalized.outcome === 'skipped') {
     return {

package/src/numbering/numbering.core.ts

@@ -325,9 +325,9 @@ export type ScopeScanInput = {
   allowlist: readonly NumberingAllowlistEntry[];
 
   /**
-   * slug 数字策略（'forbid' 启用判定）
+   * slug 数字策略（'forbid' 启用判定；'allow' 整域放行跳过判定）
    */
-  slugDigitPolicy?: 'forbid';
+  slugDigitPolicy?: 'forbid' | 'allow';
 
   /**
    * slug 数字白名单 glob（仓库相对路径命中豁免）
@@ -503,7 +503,7 @@ export function scanScopeForFindings(input: ScopeScanInput): NumberingFinding[]
     });
   });
 
-  if (input.slugDigitPolicy === 'forbid') {
+  if (input.slugDigitPolicy !== 'allow') {
     /**
      * slug 白名单命中集合（全量档失效对账用）
      */