@longzai-intelligence-issues/ledger 0.0.2 → 0.0.4

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,10 +1,12 @@
 /**
  * normalize-header（方言头部迁移）
  *
- * 四种历史方言（单行管道引用行 / 粗体标签行 / `## 键: 值` 标题式 / `- ` 列表式）
- * 解析后重排为裁定格式：粗体标签逐行 `**键**: 值`；字段规范序（FIELD_RANK）；
- * 「主题」问题陈述迁正文首个节标题后；residual 原样保留。零丢失守卫：每字段
- * 必须在产物文本在场否则 failed 不落盘；幂等（产物 === 原文 → unchanged）。
+ * 五种历史方言（单行管道引用行 / 粗体标签行 / `## 键: 值` 标题式 / `- ` 列表式 /
+ * `| 键 | 值 |` 表格）与两类复合形态（引用行内粗体键 `> **键**: 值`、标题式隔行值
+ * `## 键` + 下一非空独立行）解析后重排为裁定格式：粗体标签逐行 `**键**: 值`；字段
+ * 规范序（FIELD_RANK）；「主题」问题陈述迁正文首个节标题后；residual 原样保留。
+ * 零丢失守卫：每字段必须在产物文本在场否则 failed 不落盘；幂等（产物 === 原文 →
+ * unchanged）。
  */
 
 import { readFileSync, writeFileSync } from 'node:fs';
@@ -12,6 +14,23 @@ import { join } from 'node:path';
 
 import { CANONICAL_STATUS_LABELS } from '@/parser/format.utils';
 
+/**
+ * 标题式隔行值认定键集（`## 键` + 下一非空独立行为值的复合方言）
+ *
+ * 键限集合防误吞：非元信息键的 `## 节` 仍按正文边界终止头部；值行另有独立
+ * 短行约束（见 parseHeaderDialect 形态七），流水段落首行不受影响。
+ */
+export const HEADING_ALONE_METADATA_KEYS: ReadonlySet<string> = new Set([
+  '优先级',
+  '状态',
+  '立案日期',
+  '日期',
+  '所属域',
+  '来源',
+  '严重程度',
+  '严重度',
+]);
+
 /**
  * 字段规范序（排名值越小越靠前；未入表字段按首现序殿后）
  */
@@ -86,7 +105,8 @@ export type ParsedHeader = {
 };
 
 /**
- * 解析头部方言（五种形态逐行尝试：粗体标签 / 列表式 / 标题式 / 管道引用行 / 表格）
+ * 解析头部方言（五种形态逐行尝试：粗体标签 / 列表式 / 标题式 / 管道引用行 / 表格；
+ * 另含两类复合形态：引用行内粗体键、标题式隔行值）
  *
  * @param lines - 文档行数组
  * @returns 头部解析产物
@@ -113,6 +133,71 @@ export 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;
 
@@ -135,9 +220,9 @@ export 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() ?? '' });
@@ -145,6 +230,60 @@ export 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;
+      }
+    }
+
     /**
      * 形态一：单行管道引用行（`> 优先级 ｜ 状态 ｜ …`）
      */
@@ -164,12 +303,15 @@ export function parseHeaderDialect(lines: string[]): ParsedHeader {
 
       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 {
           unmatched.push(segment);
         }

package/src/parser/registry.parser.ts

@@ -497,6 +497,14 @@ export function parseIssueDoc(
      */
     const line = lines[index] ?? '';
 
+    /**
+     * 标题行跳过（标题正文可含「连接状态：」类词组——如 printer 刷屏案
+     * 标题，非元信息状态行；命中会吞掉后续真状态行致 status-line-missing）
+     */
+    if (line.startsWith('#')) {
+      continue;
+    }
+
     if (STATUS_LINE_LOCATE_PATTERN.test(line)) {
       statusLine = line.trim();
       statusLineNumber = index + 1;