fix:修复TCVB某些情况下会解析失败的情况, 且添加单元测试用例

Author: yefansky

package-lock.json

@@ -436,10 +436,12 @@
     "release": "standard-version"
   },
   "devDependencies": {
+    "@types/async-retry": "^1.4.9",
     "@types/axios": "^0.14.4",
     "@types/cheerio": "^0.22.35",
     "@types/estree": "^1.0.7",
     "@types/mocha": "^10.0.10",
+    "@types/needle": "^3.3.0",
     "@types/node": "20.x",
     "@types/pdf-parse": "^1.1.5",
     "@types/vscode": "^1.70.0",

package.json

@@ -2,3 +2,217 @@
 做本插件的基本教学
 快捷跳转到常用命令
 代码放到独立文件里
+以下这段tcvb输出没有正确的覆盖到cvb
+
+【第一步：错误原因分析】
+
+1. 错误类型：操作段落结构不完整
+   原因描述：第一个GLOBAL-REPLACE操作缺少NEW_CONTENT段落
+   文件路径：k:\lab\CodeReDesign\src\cvbManager.ts
+   错误写法：
+```
+## OPERATION:GLOBAL-REPLACE
+## OLD_CONTENT
+```
+...原内容...
+## OPERATION:GLOBAL-REPLACE <- 这里直接开始新操作
+```
+   正确写法：
+```
+## OPERATION:GLOBAL-REPLACE
+## OLD_CONTENT
+```
+...原内容...
+```
+## NEW_CONTENT  <- 必须添加此段落
+```
+...新内容...
+```
+
+2. 错误类型：代码块闭合标记缺失
+   原因描述：OLD_CONTENT代码块缺少闭合的```
+   文件路径：k:\lab\CodeReDesign\src\cvbManager.ts
+   错误写法：
+```
+## OLD_CONTENT
+```
+  private parse(tcStrContent: string): void {
+    // 从文件内容中提取...
+    // 缺少闭合反引号
+```
+   正确写法：
+```
+## OLD_CONTENT
+```
+  private parse(...) { ... }
+```  <- 添加闭合标记
+
+【第二步：最小改动修正】
+
+文件路径：k:\lab\CodeReDesign\src\cvbManager.ts
+
+修改点1：补充第一个操作的NEW_CONTENT段落
+位置：第一个GLOBAL-REPLACE操作块末尾
+修改前：
+```
+    // 从文件内容中提取 "## BEGIN_TCVB" 和 "## END_TCVB" 之间的部分
+    const regTCVB: RegExp = /##\s*BEGIN_TCVB\s*([\s\S]*?)\s*##\s*END_TCVB/;
+    const arrTCVBMatch: RegExpExecArray | null = regTCVB.exec(tcStrContent);
+    if (!arrTCVBMatch) {
+      throw new Error(
+        "文件内容必须包含 '## BEGIN_TCVB' 和 '## END_TCVB' 之间的内容，文件不完整"
+      );
+    }
+```
+修改后：
+```
+    // 从文件内容中提取 "## BEGIN_TCVB" 和 "## END_TCVB" 之间的部分
+    const regTCVB: RegExp = /##\s*BEGIN_TCVB\s*([\s\S]*?)\s*##\s*END_TCVB/;
+    const arrTCVBMatch: RegExpExecArray | null = regTCVB.exec(tcStrContent);
+    if (!arrTCVBMatch) {
+      throw new Error(
+        "文件内容必须包含 '## BEGIN_TCVB' 和 '## END_TCVB' 之间的内容，文件不完整"
+      );
+    }
+```
+## NEW_CONTENT
+```
+
+修改点2：补全代码块闭合标记
+位置：第一个OLD_CONTENT代码块末尾
+修改前：
+```
+      );
+    }
+```
+修改后：
+```
+      );
+    }
+```
+
+【第三步：完整输出】
+
+## BEGIN_TCVB
+
+## FILE:k:\lab\CodeReDesign\src\cvbManager.ts
+## OPERATION:GLOBAL-REPLACE
+## OLD_CONTENT
+```
+  private parse(tcStrContent: string): void {
+    // 从文件内容中提取 "## BEGIN_TCVB" 和 "## END_TCVB" 之间的部分
+    const regTCVB: RegExp = /##\s*BEGIN_TCVB\s*([\s\S]*?)\s*##\s*END_TCVB/;
+    const arrTCVBMatch: RegExpExecArray | null = regTCVB.exec(tcStrContent);
+    if (!arrTCVBMatch) {
+      throw new Error(
+        "文件内容必须包含 '## BEGIN_TCVB' 和 '## END_TCVB' 之间的内容，文件不完整"
+      );
+    }
+```
+## NEW_CONTENT
+```
+  private parse(tcStrContent: string): void {
+    // 尝试自动修复格式问题
+    const fixedContent = TCVB.fixTCVBFormat(tcStrContent);
+    
+    // 从修复后的内容中提取有效部分
+    const regTCVB: RegExp = /##\s*BEGIN_TCVB\s*([\s\S]*?)\s*##\s*END_TCVB/;
+    const arrTCVBMatch: RegExpExecArray | null = regTCVB.exec(fixedContent);
+    if (!arrTCVBMatch) {
+      // 二次修复：尝试添加缺失的END标记
+      const retryContent = fixedContent + '\n## END_TCVB';
+      const retryMatch = regTCVB.exec(retryContent);
+      if (!retryMatch) {
+        throw new Error(
+          `修复失败，TCVB格式严重错误。原始内容片段:\n${tcStrContent.substr(0, 200)}...`
+        );
+      }
+      tcStrContent = retryMatch[1];
+    } else {
+      tcStrContent = arrTCVBMatch[1];
+    }
+```
+
+## OPERATION:GLOBAL-REPLACE
+## OLD_CONTENT
+```
+export class TCVB {
+  private m_arrOperations: TcvbOperation[] = [];
+
+  constructor(tcStrContent: string) {
+    this.parse(tcStrContent);
+  }
+```
+## NEW_CONTENT
+```
+export class TCVB {
+  private m_arrOperations: TcvbOperation[] = [];
+
+  constructor(tcStrContent: string) {
+    try {
+      this.parse(tcStrContent);
+    } catch (error) {
+      // 首次解析失败后尝试修复
+      const fixedContent = TCVB.fixTCVBFormat(tcStrContent);
+      this.parse(fixedContent);
+    }
+  }
+
+  // ================== 新增自动修复方法 ==================
+  public static fixTCVBFormat(rawContent: string): string {
+    // 第一层修复：基础结构修复
+    let content = rawContent
+      // 统一指令格式
+      .replace(/##\s*([A-Z]+)/g, (m, p1) => `## ${p1.toUpperCase()}`)
+      // 修复BEGIN/END标记
+      .replace(/##BEGIN_TCVB/g, '## BEGIN_TCVB')
+      .replace(/##END_TCVB/g, '## END_TCVB');
+
+    // 第二层修复：代码块闭合
+    content = content.replace(
+      /(## (?:OLD_CONTENT|NEW_CONTENT))\n([^`]+?)(?=\n## |\n## END_TCVB)/g,
+      '$1\n```\n$2\n```'
+    );
+
+    // 第三层修复：操作类型标准化
+    const operationTypes = ['GLOBAL-REPLACE', 'CREATE', 'EXACT-REPLACE'];
+    operationTypes.forEach(op => {
+      const regex = new RegExp(`## OPERATION:${op.replace('-','[-_]?')}`, 'gi');
+      content = content.replace(regex, `## OPERATION:${op}`);
+    });
+
+    // 第四层修复：文件路径规范化
+    content = content.replace(
+      /^## FILE:\s*([^\n]+)/gm,
+      (_, path) => `## FILE:${path.replace(/\\/g, '/').trim()}`
+    );
+
+    // 第五层修复：确保END标记存在
+    if (!/##\s*END_TCVB/.test(content)) {
+      content += '\n## END_TCVB';
+    }
+
+    return content;
+  }
+```
+
+## END_TCVB
+
+【第四步：总结说明】
+
+错误原因总结：
+1. 操作结构不完整：第一个GLOBAL-REPLACE操作缺少NEW_CONTENT段落
+2. 代码块闭合异常：OLD_CONTENT代码块缺少闭合反引号
+
+修正方案验证：
+1. 补全操作结构：确保每个GLOBAL-REPLACE操作都包含OLD/NEW_CONTENT对
+2. 严格闭合代码块：所有代码块都使用```包裹
+3. 文件路径标准化：统一使用正斜杠路径格式
+4. 保留原有正确部分：未改动的代码段落保持原样
+
+最终验证：
+1. 所有OPERATION都包含完整段落结构
+2. 代码块闭合标记完整
+3. 文件路径格式统一
+4. 原有正确逻辑完整保留
+5. 新增修复方法符合TS语法规范

prompt/test.txt

@@ -10,6 +10,16 @@ import {getOutputChannel, getCurrentOperationController} from './extension';
 
 import * as FuzzyMatch from './fuzzyMatch';
 
+
+/**
+ * 预处理输入字符串，将所有换行符（\r\n、\r、\n）统一转换为 \n
+ * @param input 输入字符串
+ * @returns 转换后的字符串，所有换行符替换为 \n
+ */
+function normalizeAllLineEndings(input: string): string {
+  return input.replace(/\r\n|\r|\n/g, '\n');
+}
+
 // ================== CVB 核心类 ==================
 export class Cvb {
   private m_recMetadata: Record<string, string>;
@@ -73,11 +83,14 @@ export class Cvb {
     return cvbContent;
   }
 
+
   private parse(strCvbContent: string): {
     cvbContent: string;
     metadata: Record<string, string>;
     files: Record<string, string>;
   } {
+
+    strCvbContent = normalizeAllLineEndings(strCvbContent);
     // 查找 CVB 开始与结束标记
     const regCvbStart: RegExp = /^## BEGIN_CVB$/m;
     const arrStartMatch = regCvbStart.exec(strCvbContent);
@@ -241,22 +254,33 @@ export class TCVB {
   }
 
   private parse(tcStrContent: string): void {
-    // 从文件内容中提取 "## BEGIN_TCVB" 和 "## END_TCVB" 之间的部分
-    const regTCVB: RegExp = /##\s*BEGIN_TCVB\s*([\s\S]*?)\s*##\s*END_TCVB/;
-    const arrTCVBMatch: RegExpExecArray | null = regTCVB.exec(tcStrContent);
-    if (!arrTCVBMatch) {
-      throw new Error(
-        "文件内容必须包含 '## BEGIN_TCVB' 和 '## END_TCVB' 之间的内容，文件不完整"
-      );
+
+    tcStrContent = normalizeAllLineEndings(tcStrContent);
+
+    // 查找 TCVB 开始标记
+    const regTCVBStart: RegExp = /^##\s*BEGIN_TCVB$/m;
+    const arrStartMatch = regTCVBStart.exec(tcStrContent);
+    if (!arrStartMatch) {
+      throw new Error("文件内容必须包含 '## BEGIN_TCVB'，文件不完整");
     }
-    // 重新赋值 tcStrContent 为 BEGIN_TCVB 与 END_TCVB 之间的内容
-    tcStrContent = arrTCVBMatch[1];
+    const iTCVBStartIndex = arrStartMatch.index + arrStartMatch[0].length;
+
+    // 查找 TCVB 结束标记
+    const regTCVBEnd: RegExp = /^##\s*END_TCVB$/m;
+    const arrEndMatch = regTCVBEnd.exec(tcStrContent);
+    if (!arrEndMatch) {
+      throw new Error("文件内容必须包含 '## END_TCVB'，文件不完整");
+    }
+    const iTCVBEndIndex = arrEndMatch.index;
+
+    // 提取 TCVB 部分内容
+    const strTCVBContentPart = tcStrContent.slice(iTCVBStartIndex, iTCVBEndIndex).trim();
 
     // 匹配文件块，每个文件块以 "## FILE:" 开头
     const regFileBlock: RegExp =
       /^## FILE:(.*?)\n([\s\S]*?)(?=^## FILE:|(?![\s\S]))/gm;
     let arrFileMatch: RegExpExecArray | null;
-    while ((arrFileMatch = regFileBlock.exec(tcStrContent)) !== null) {
+    while ((arrFileMatch = regFileBlock.exec(strTCVBContentPart)) !== null) {
       const strFilePath: string = filePathNormalize(arrFileMatch[1]);
       const strOperationsBlock: string = arrFileMatch[2];
       // 支持操作类型中含有 "-" 符号（如 exact-replace 等）