✨: 新增多語言支援，包含繁體中文的區段標題和驗證訊息

Author: Minidoracat

src/core/i18n/section-titles.ts

@@ -0,0 +1,91 @@
+/**
+ * 多語言區段標題映射
+ * 支援英文和繁體中文的標題識別
+ */
+
+/**
+ * 規範文件的區段標題
+ */
+export const SPEC_SECTIONS = {
+  /** 目的區段 */
+  PURPOSE: ['Purpose', '目的'],
+  /** 需求區段 */
+  REQUIREMENTS: ['Requirements', '需求'],
+} as const;
+
+/**
+ * 變更文件的區段標題
+ */
+export const CHANGE_SECTIONS = {
+  /** 為什麼區段 */
+  WHY: ['Why', '為什麼'],
+  /** 變更內容區段 */
+  WHAT_CHANGES: ['What Changes', '變更內容'],
+} as const;
+
+/**
+ * 差異類型的區段標題
+ */
+export const DELTA_SECTIONS = {
+  /** 新增需求 */
+  ADDED: ['ADDED Requirements', '新增需求'],
+  /** 修改需求 */
+  MODIFIED: ['MODIFIED Requirements', '修改需求'],
+  /** 移除需求 */
+  REMOVED: ['REMOVED Requirements', '移除需求'],
+  /** 重新命名需求 */
+  RENAMED: ['RENAMED Requirements', '重新命名需求'],
+} as const;
+
+/**
+ * 需求區塊的標題前綴
+ */
+export const REQUIREMENT_PREFIXES = ['Requirement:', '需求：'] as const;
+
+/**
+ * 情境的標題前綴
+ */
+export const SCENARIO_PREFIXES = ['Scenario:', '情境：'] as const;
+
+/**
+ * 將標題陣列轉換為小寫，用於 case-insensitive 比對
+ */
+export function normalizeTitle(title: string): string {
+  return title.toLowerCase().trim();
+}
+
+/**
+ * 檢查標題是否匹配多語言標題列表
+ * @param title 要檢查的標題
+ * @param titleVariants 支援的標題變體（英文、繁體中文）
+ * @returns 是否匹配
+ */
+export function matchesTitle(title: string, titleVariants: readonly string[]): boolean {
+  const normalizedTitle = normalizeTitle(title);
+  return titleVariants.some(variant => normalizeTitle(variant) === normalizedTitle);
+}
+
+/**
+ * 從標題列表中找到匹配的標題（遞迴搜尋包含 children）
+ * @param sections 區段列表
+ * @param titleVariants 支援的標題變體
+ * @returns 找到的區段或 undefined
+ */
+export function findSectionByTitleVariants<T extends { title: string; children?: T[] }>(
+  sections: T[],
+  titleVariants: readonly string[]
+): T | undefined {
+  for (const section of sections) {
+    if (matchesTitle(section.title, titleVariants)) {
+      return section;
+    }
+    // 遞迴搜尋子區段
+    if (section.children && section.children.length > 0) {
+      const child = findSectionByTitleVariants(section.children, titleVariants);
+      if (child) {
+        return child;
+      }
+    }
+  }
+  return undefined;
+}

src/core/parsers/change-parser.ts

@@ -1,5 +1,6 @@
 import { MarkdownParser, Section } from './markdown-parser.js';
 import { Change, Delta, DeltaOperation, Requirement } from '../schemas/index.js';
+import { CHANGE_SECTIONS, DELTA_SECTIONS, findSectionByTitleVariants } from '../i18n/section-titles.js';
 import path from 'path';
 import { promises as fs } from 'fs';
 
@@ -19,24 +20,27 @@ export class ChangeParser extends MarkdownParser {
 
   async parseChangeWithDeltas(name: string): Promise<Change> {
     const sections = this.parseSections();
-    const why = this.findSection(sections, 'Why')?.content || '';
-    const whatChanges = this.findSection(sections, 'What Changes')?.content || '';
-    
+    const whySection = findSectionByTitleVariants(sections, CHANGE_SECTIONS.WHY);
+    const whatChangesSection = findSectionByTitleVariants(sections, CHANGE_SECTIONS.WHAT_CHANGES);
+
+    const why = whySection?.content || '';
+    const whatChanges = whatChangesSection?.content || '';
+
     if (!why) {
-      throw new Error('Change must have a Why section');
+      throw new Error('變更必須包含為什麼區段');
     }
-    
+
     if (!whatChanges) {
-      throw new Error('Change must have a What Changes section');
+      throw new Error('變更必須包含變更內容區段');
     }
 
     // Parse deltas from the What Changes section (simple format)
     const simpleDeltas = this.parseDeltas(whatChanges);
-    
+
     // Check if there are spec files with delta format
     const specsDir = path.join(this.changeDir, 'specs');
     const deltaDeltas = await this.parseDeltaSpecs(specsDir);
-    
+
     // Combine both types of deltas, preferring delta format if available
     const deltas = deltaDeltas.length > 0 ? deltaDeltas : simpleDeltas;
 
@@ -84,85 +88,86 @@ export class ChangeParser extends MarkdownParser {
   private parseSpecDeltas(specName: string, content: string): Delta[] {
     const deltas: Delta[] = [];
     const sections = this.parseSectionsFromContent(content);
-    
-    // Parse ADDED requirements
-    const addedSection = this.findSection(sections, 'ADDED Requirements');
+
+    // Parse ADDED requirements (支援多語言)
+    const addedSection = findSectionByTitleVariants(sections, DELTA_SECTIONS.ADDED);
     if (addedSection) {
       const requirements = this.parseRequirements(addedSection);
       requirements.forEach(req => {
         deltas.push({
           spec: specName,
           operation: 'ADDED' as DeltaOperation,
-          description: `Add requirement: ${req.text}`,
+          description: `新增需求：${req.text}`,
           // Provide both single and plural forms for compatibility
           requirement: req,
           requirements: [req],
         });
       });
     }
-    
-    // Parse MODIFIED requirements
-    const modifiedSection = this.findSection(sections, 'MODIFIED Requirements');
+
+    // Parse MODIFIED requirements (支援多語言)
+    const modifiedSection = findSectionByTitleVariants(sections, DELTA_SECTIONS.MODIFIED);
     if (modifiedSection) {
       const requirements = this.parseRequirements(modifiedSection);
       requirements.forEach(req => {
         deltas.push({
           spec: specName,
           operation: 'MODIFIED' as DeltaOperation,
-          description: `Modify requirement: ${req.text}`,
+          description: `修改需求：${req.text}`,
           requirement: req,
           requirements: [req],
         });
       });
     }
-    
-    // Parse REMOVED requirements
-    const removedSection = this.findSection(sections, 'REMOVED Requirements');
+
+    // Parse REMOVED requirements (支援多語言)
+    const removedSection = findSectionByTitleVariants(sections, DELTA_SECTIONS.REMOVED);
     if (removedSection) {
       const requirements = this.parseRequirements(removedSection);
       requirements.forEach(req => {
         deltas.push({
           spec: specName,
           operation: 'REMOVED' as DeltaOperation,
-          description: `Remove requirement: ${req.text}`,
+          description: `移除需求：${req.text}`,
           requirement: req,
           requirements: [req],
         });
       });
     }
-    
-    // Parse RENAMED requirements
-    const renamedSection = this.findSection(sections, 'RENAMED Requirements');
+
+    // Parse RENAMED requirements (支援多語言)
+    const renamedSection = findSectionByTitleVariants(sections, DELTA_SECTIONS.RENAMED);
     if (renamedSection) {
       const renames = this.parseRenames(renamedSection.content);
       renames.forEach(rename => {
         deltas.push({
           spec: specName,
           operation: 'RENAMED' as DeltaOperation,
-          description: `Rename requirement from "${rename.from}" to "${rename.to}"`,
+          description: `重新命名需求：從「${rename.from}」改為「${rename.to}」`,
           rename,
         });
       });
     }
-    
+
     return deltas;
   }
 
   private parseRenames(content: string): Array<{ from: string; to: string }> {
     const renames: Array<{ from: string; to: string }> = [];
     const lines = ChangeParser.normalizeContent(content).split('\n');
-    
+
     let currentRename: { from?: string; to?: string } = {};
-    
+
     for (const line of lines) {
-      const fromMatch = line.match(/^\s*-?\s*FROM:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
-      const toMatch = line.match(/^\s*-?\s*TO:\s*`?###\s*Requirement:\s*(.+?)`?\s*$/);
-      
+      // 支援多語言：FROM: 或 從：, ### Requirement: 或 ### 需求：
+      const fromMatch = line.match(/^\s*-?\s*(?:FROM:|從：)\s*`?###\s*(?:Requirement:|需求：)\s*(.+?)`?\s*$/);
+      const toMatch = line.match(/^\s*-?\s*(?:TO:|至：)\s*`?###\s*(?:Requirement:|需求：)\s*(.+?)`?\s*$/);
+
       if (fromMatch) {
         currentRename.from = fromMatch[1].trim();
       } else if (toMatch) {
         currentRename.to = toMatch[1].trim();
-        
+
         if (currentRename.from && currentRename.to) {
           renames.push({
             from: currentRename.from,
@@ -172,7 +177,7 @@ export class ChangeParser extends MarkdownParser {
         }
       }
     }
-    
+
     return renames;
   }
 

src/core/parsers/markdown-parser.ts

@@ -1,4 +1,5 @@
 import { Spec, Change, Requirement, Scenario, Delta, DeltaOperation } from '../schemas/index.js';
+import { SPEC_SECTIONS, CHANGE_SECTIONS, findSectionByTitleVariants } from '../i18n/section-titles.js';
 
 export interface Section {
   level: number;
@@ -23,16 +24,17 @@ export class MarkdownParser {
 
   parseSpec(name: string): Spec {
     const sections = this.parseSections();
-    const purpose = this.findSection(sections, 'Purpose')?.content || '';
-    
-    const requirementsSection = this.findSection(sections, 'Requirements');
-    
+    const purposeSection = findSectionByTitleVariants(sections, SPEC_SECTIONS.PURPOSE);
+    const requirementsSection = findSectionByTitleVariants(sections, SPEC_SECTIONS.REQUIREMENTS);
+
+    const purpose = purposeSection?.content || '';
+
     if (!purpose) {
-      throw new Error('Spec must have a Purpose section');
+      throw new Error('規範必須包含目的區段');
     }
-    
+
     if (!requirementsSection) {
-      throw new Error('Spec must have a Requirements section');
+      throw new Error('規範必須包含需求區段');
     }
 
     const requirements = this.parseRequirements(requirementsSection);
@@ -50,15 +52,18 @@ export class MarkdownParser {
 
   parseChange(name: string): Change {
     const sections = this.parseSections();
-    const why = this.findSection(sections, 'Why')?.content || '';
-    const whatChanges = this.findSection(sections, 'What Changes')?.content || '';
-    
+    const whySection = findSectionByTitleVariants(sections, CHANGE_SECTIONS.WHY);
+    const whatChangesSection = findSectionByTitleVariants(sections, CHANGE_SECTIONS.WHAT_CHANGES);
+
+    const why = whySection?.content || '';
+    const whatChanges = whatChangesSection?.content || '';
+
     if (!why) {
-      throw new Error('Change must have a Why section');
+      throw new Error('變更必須包含為什麼區段');
     }
-    
+
     if (!whatChanges) {
-      throw new Error('Change must have a What Changes section');
+      throw new Error('變更必須包含變更內容區段');
     }
 
     const deltas = this.parseDeltas(whatChanges);