0

src/api/yjbdc/aiController.js

@@ -1,5 +1,6 @@
 import axios from 'axios';
 import config from '../../config/index.js';
+import { enhanceFormsOfWords } from './enhanceFormsOfWords.js';
 
 /**
  * AI平台接口类
@@ -217,7 +218,7 @@ class AIProviderFactory {
  * @param {string} provider - AI提供者名称，默认为'volces'
  * @returns {Promise<string>} - 返回生成的文章JSON字符串
  */
-export async function generateArticle(content, provider = 'volces1-5') {
+async function generateArticle(content, provider = 'volces1-5') {
     try {
         const aiProvider = AIProviderFactory.getProvider(provider);
         const result = await aiProvider.generateArticle(content);
@@ -229,381 +230,52 @@ export async function generateArticle(content, provider = 'volces1-5') {
 }
 
 /**
- * 计算两个字符串之间的Levenshtein距离（编辑距离）
- * @param {string} a - 第一个字符串
- * @param {string} b - 第二个字符串
- * @returns {number} - 编辑距离
+ * 验证并修复JSON结构
+ * @param {string} jsonString - 需要验证和修复的JSON字符串
+ * @returns {string} - 返回修复后的JSON字符串
  */
-function levenshteinDistance(a, b) {
-    const matrix = [];
-    
-    // 初始化矩阵
-    for (let i = 0; i <= b.length; i++) {
-        matrix[i] = [i];
-    }
-    
-    for (let j = 0; j <= a.length; j++) {
-        matrix[0][j] = j;
-    }
-    
-    // 填充矩阵
-    for (let i = 1; i <= b.length; i++) {
-        for (let j = 1; j <= a.length; j++) {
-            if (b.charAt(i - 1) === a.charAt(j - 1)) {
-                matrix[i][j] = matrix[i - 1][j - 1];
-            } else {
-                matrix[i][j] = Math.min(
-                    matrix[i - 1][j - 1] + 1, // 替换
-                    matrix[i][j - 1] + 1,     // 插入
-                    matrix[i - 1][j] + 1      // 删除
-                );
-            }
-        }
-    }
-    
-    return matrix[b.length][a.length];
-}
-
-/**
- * 增强FormsOfWords，检测文章中单词的变形形式和拼写错误
- * @param {Object} jsonObj - 解析后的JSON对象
- * @param {string} userWords - 用户提供的单词列表，逗号分隔
- * @returns {Object} - 增强后的JSON对象
- */
-export function enhanceFormsOfWords(jsonObj, userWords) {
-    if (!jsonObj || !userWords) return jsonObj;
-    
-    // 将用户提供的单词转换为数组并去除空格
-    const userWordsList = userWords.split(',').map(word => word.trim().toLowerCase());
-    
-    // 如果没有ArticleEnglish或FormsOfWords，直接返回
-    if (!jsonObj.ArticleEnglish || !Array.isArray(jsonObj.ArticleEnglish)) {
-        return jsonObj;
-    }
-    
-    // 确保FormsOfWords存在
-    if (!jsonObj.FormsOfWords) {
-        jsonObj.FormsOfWords = [];
-    }
-    
-    // 从文章中提取所有单词
-    const allWordsInArticle = [];
-    jsonObj.ArticleEnglish.forEach(sentence => {
-        // 移除标点符号，分割成单词
-        const words = sentence.toLowerCase()
-            .replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g, " ")
-            .replace(/\s+/g, " ")
-            .split(" ");
-        
-        words.forEach(word => {
-            if (word) allWordsInArticle.push(word.trim());
-        });
-    });
-    
-    // 常见的后缀列表
-    const commonSuffixes = [
-        'ed', 'ing', 's', 'es', 'er', 'est', 'ful', 'ly', 'ment', 'ness', 'ity', 
-        'tion', 'sion', 'ation', 'able', 'ible', 'al', 'ial', 'ic', 'ical', 'ious', 
-        'ous', 'ive', 'less', 'y'
-    ];
-    
-    // 不规则动词变化表（部分常见的）
-    const irregularVerbs = {
-        'go': ['went', 'gone', 'goes', 'going'],
-        'be': ['am', 'is', 'are', 'was', 'were', 'been', 'being'],
-        'do': ['did', 'done', 'does', 'doing'],
-        'have': ['has', 'had', 'having'],
-        'say': ['said', 'says', 'saying'],
-        'make': ['made', 'makes', 'making'],
-        'take': ['took', 'taken', 'takes', 'taking'],
-        'come': ['came', 'comes', 'coming'],
-        'see': ['saw', 'seen', 'sees', 'seeing'],
-        'know': ['knew', 'known', 'knows', 'knowing'],
-        'get': ['got', 'gotten', 'gets', 'getting'],
-        'give': ['gave', 'given', 'gives', 'giving'],
-        'find': ['found', 'finds', 'finding'],
-        'think': ['thought', 'thinks', 'thinking'],
-        'tell': ['told', 'tells', 'telling'],
-        'become': ['became', 'becomes', 'becoming'],
-        'show': ['showed', 'shown', 'shows', 'showing'],
-        'leave': ['left', 'leaves', 'leaving'],
-        'feel': ['felt', 'feels', 'feeling'],
-        'put': ['puts', 'putting'],
-        'bring': ['brought', 'brings', 'bringing'],
-        'begin': ['began', 'begun', 'begins', 'beginning'],
-        'keep': ['kept', 'keeps', 'keeping'],
-        'hold': ['held', 'holds', 'holding'],
-        'write': ['wrote', 'written', 'writes', 'writing'],
-        'stand': ['stood', 'stands', 'standing'],
-        'hear': ['heard', 'hears', 'hearing'],
-        'let': ['lets', 'letting'],
-        'mean': ['meant', 'means', 'meaning'],
-        'set': ['sets', 'setting'],
-        'meet': ['met', 'meets', 'meeting'],
-        'run': ['ran', 'runs', 'running'],
-        'pay': ['paid', 'pays', 'paying'],
-        'sit': ['sat', 'sits', 'sitting'],
-        'speak': ['spoke', 'spoken', 'speaks', 'speaking'],
-        'lie': ['lay', 'lain', 'lies', 'lying'],
-        'lead': ['led', 'leads', 'leading'],
-        'read': ['read', 'reads', 'reading'],
-        'sleep': ['slept', 'sleeps', 'sleeping'],
-        'win': ['won', 'wins', 'winning'],
-        'understand': ['understood', 'understands', 'understanding'],
-        'draw': ['drew', 'drawn', 'draws', 'drawing'],
-        'sing': ['sang', 'sung', 'sings', 'singing'],
-        'fall': ['fell', 'fallen', 'falls', 'falling'],
-        'fly': ['flew', 'flown', 'flies', 'flying'],
-        'grow': ['grew', 'grown', 'grows', 'growing'],
-        'lose': ['lost', 'loses', 'losing'],
-        'teach': ['taught', 'teaches', 'teaching'],
-        'eat': ['ate', 'eaten', 'eats', 'eating'],
-        'drink': ['drank', 'drunk', 'drinks', 'drinking']
-    };
-    
-    // 不规则形容词比较级和最高级
-    const irregularAdjectives = {
-        'good': ['better', 'best'],
-        'bad': ['worse', 'worst'],
-        'far': ['further', 'furthest', 'farther', 'farthest'],
-        'little': ['less', 'least'],
-        'many': ['more', 'most'],
-        'much': ['more', 'most']
-    };
-    
-    // 收集所有单词形式
-    const allForms = new Set();
-    
-    userWordsList.forEach(originalWord => {
-        // 添加原始单词
-        allForms.add(originalWord);
-        
-        // 检查不规则动词
-        if (irregularVerbs[originalWord]) {
-            irregularVerbs[originalWord].forEach(form => allForms.add(form));
-        }
-        
-        // 检查不规则形容词
-        if (irregularAdjectives[originalWord]) {
-            irregularAdjectives[originalWord].forEach(form => allForms.add(form));
-        }
-        
-        // 检查文章中的所有单词，寻找可能的变形和拼写错误
-        allWordsInArticle.forEach(articleWord => {
-            // 检查是否是原始单词
-            if (articleWord === originalWord) {
-                allForms.add(articleWord);
-                return;
-            }
-            
-            // 检查拼写错误，使用更严格的条件
-            // 1. 对于短单词（长度<=4），只接受编辑距离为1的情况
-            // 2. 对于中等长度单词（4<长度<=8），只接受编辑距离为1的情况
-            // 3. 对于长单词（长度>8），允许编辑距离为2，但有额外限制
-            if (originalWord.length >= 5 && originalWord.length <= 8) {
-                // 短单词和中等长度单词使用相同的严格条件
-                if (articleWord[0] === originalWord[0] && // 首字母必须相同
-                    Math.abs(articleWord.length - originalWord.length) <= 1 && // 长度差不超过1
-                    levenshteinDistance(originalWord, articleWord) === 1) { // 编辑距离恰好为1
-                    allForms.add(articleWord);
-                }
-            } else {
-                // 长单词（长度>8）的条件
-                if (articleWord[0] === originalWord[0]) { // 首字母必须相同
-                    const editDistance = levenshteinDistance(originalWord, articleWord);
-                    
-                    if (editDistance === 1) {
-                        // 编辑距离为1的情况，长度差不超过1
-                        if (Math.abs(articleWord.length - originalWord.length) <= 1) {
-                            allForms.add(articleWord);
-                        }
-                    } else if (editDistance === 2) {
-                        // 编辑距离为2的情况，需要更严格的条件
-                        // 长度差不超过1且单词长度大于8
-                        if (Math.abs(articleWord.length - originalWord.length) <= 1) {
-                            allForms.add(articleWord);
-                        }
-                    }
-                }
-            }
-            
-            // 检查是否是通过添加后缀形成的变形
-            for (const suffix of commonSuffixes) {
-                if (articleWord.endsWith(suffix)) {
-                    const stem = articleWord.slice(0, -suffix.length);
-                    
-                    // 处理双写字母的情况（如：running -> run）
-                    if (stem.length > 0 && stem[stem.length-1] === stem[stem.length-2]) {
-                        const possibleStem = stem.slice(0, -1);
-                        if (possibleStem === originalWord) {
-                            allForms.add(articleWord);
-                            continue;
-                        }
-                    }
-                    
-                    // 处理去e加ing的情况（如：writing -> write）
-                    if (suffix === 'ing' && originalWord.endsWith('e') && stem + 'e' === originalWord) {
-                        allForms.add(articleWord);
-                        continue;
-                    }
-                    
-                    // 处理y变i的情况（如：studies -> study）
-                    if ((suffix === 'es' || suffix === 'ed') && originalWord.endsWith('y') && 
-                        stem + 'y' === originalWord) {
-                        allForms.add(articleWord);
-                        continue;
-                    }
-                    
-                    // 直接比较
-                    if (stem === originalWord) {
-                        allForms.add(articleWord);
-                    }
-                }
-            }
-        });
-    });
-    
-    // 更新FormsOfWords
-    jsonObj.FormsOfWords = Array.from(new Set([...jsonObj.FormsOfWords, ...allForms]));
-    
-    return jsonObj;
-}
-
-/**
- * 校验和修复JSON结构
- * @param {string} jsonString - JSON字符串
- * @returns {string} - 修复后的JSON字符串
- */
-export function validateAndFixJSON(jsonString) {
+function validateAndFixJSON(jsonString) {
     try {
-        //console.log(jsonString);
-        // 解析JSON字符串为对象
-        let jsonObj = JSON.parse(jsonString);
+        // 尝试解析JSON
+        const parsed = JSON.parse(jsonString);
+        return jsonString;
+    } catch (error) {
+        console.error("JSON解析错误，尝试修复:", error);
         
-        // 校验和修复Question数组中的每个问题对象
-        if (jsonObj.Question && Array.isArray(jsonObj.Question)) {
-            jsonObj.Question = jsonObj.Question.map(question => {
-                // 创建一个修复后的问题对象
-                const fixedQuestion = {};
-                
-                // 确保QuestionEnglish字段存在
-                if (question.QuestionEnglish) {
-                    fixedQuestion.QuestionEnglish = question.QuestionEnglish;
-                }
-                
-                // 检查QuestionChinese字段，如果不存在但有第二个QuestionEnglish，则使用它
-                if (question.QuestionChinese) {
-                    fixedQuestion.QuestionChinese = question.QuestionChinese;
-                } else if (Object.keys(question).filter(key => key === 'QuestionEnglish').length > 1) {
-                    // 找到第二个QuestionEnglish的值
-                    const keys = Object.keys(question);
-                    let foundFirst = false;
-                    for (const key of keys) {
-                        if (key === 'QuestionEnglish') {
-                            if (foundFirst) {
-                                fixedQuestion.QuestionChinese = question[key];
-                                break;
-                            }
-                            foundFirst = true;
-                        }
-                    }
-                }
-                
-                // 确保OptionsEnglish字段存在且为数组
-                if (question.OptionsEnglish && Array.isArray(question.OptionsEnglish)) {
-                    fixedQuestion.OptionsEnglish = question.OptionsEnglish;
-                } else {
-                    fixedQuestion.OptionsEnglish = ["A.", "B.", "C.", "D."];
-                }
-                
-                // 确保OptionsChinese字段存在且为数组
-                if (question.OptionsChinese && Array.isArray(question.OptionsChinese)) {
-                    fixedQuestion.OptionsChinese = question.OptionsChinese;
-                } else {
-                    fixedQuestion.OptionsChinese = ["A.", "B.", "C.", "D."];
-                }
-                
-                // 确保Answer字段存在
-                if (question.Answer) {
-                    fixedQuestion.Answer = question.Answer;
-                } else {
-                    fixedQuestion.Answer = "A";
-                }
-                
-                return fixedQuestion;
-            });
-        }
+        // 尝试修复常见的JSON错误
+        let fixedJson = jsonString;
         
-        // 确保其他必要字段存在
-        if (!jsonObj.ArticleEnglish || !Array.isArray(jsonObj.ArticleEnglish)) {
-            jsonObj.ArticleEnglish = ["No content available"];
-        }
+        // 修复缺少引号的键
+        fixedJson = fixedJson.replace(/(\s*?)(\w+)(\s*?):/g, '"$2":');
         
-        if (!jsonObj.ArticleChinese || !Array.isArray(jsonObj.ArticleChinese)) {
-            jsonObj.ArticleChinese = ["无可用内容"];
-        }
+        // 修复单引号
+        fixedJson = fixedJson.replace(/'/g, '"');
         
-        if (!jsonObj.FormsOfWords || !Array.isArray(jsonObj.FormsOfWords)) {
-            jsonObj.FormsOfWords = [];
-        } else {
-            // 处理FormsOfWords数组，提取所有单词
-            const processedFormsOfWords = [];
-            
-            for (const item of jsonObj.FormsOfWords) {
-                if (typeof item !== 'string') {
-                    continue; // 跳过非字符串项
-                }
-                
-                // 处理冒号分隔格式："word1: word2"
-                if (item.includes(':')) {
-                    const [leftWord, rightWord] = item.split(':').map(word => word.trim());
-                    if (leftWord) processedFormsOfWords.push(leftWord);
-                    if (rightWord) processedFormsOfWords.push(rightWord);
-                    continue;
-                }
-                
-                // 处理括号分隔格式："word1(word2)" 或 "word1(word2, word3)"
-                const bracketMatch = item.match(/^([^(]+)\(([^)]+)\)$/);
-                if (bracketMatch) {
-                    const outsideWord = bracketMatch[1].trim();
-                    const insideWords = bracketMatch[2].split(',').map(word => word.trim());
-                    
-                    if (outsideWord) processedFormsOfWords.push(outsideWord);
-                    for (const word of insideWords) {
-                        if (word) processedFormsOfWords.push(word);
-                    }
-                    continue;
-                }
-                
-                // 如果不符合上述格式，检查是否包含逗号
-                if (item.includes(',')) {
-                    // 如果包含逗号，按逗号分割并添加每个单词
-                    const words = item.split(',').map(word => word.trim());
-                    for (const word of words) {
-                        if (word) processedFormsOfWords.push(word);
-                    }
-                } else {
-                    // 单个单词，直接添加
-                    processedFormsOfWords.push(item);
-                }
-            }
-            
-            // 去除空字符串并去重
-            const uniqueFormsOfWords = [...new Set(processedFormsOfWords.filter(word => word))];
-            
-            // 用去重后的数组替换原数组
-            jsonObj.FormsOfWords = uniqueFormsOfWords;
-        }
+        // 修复尾部逗号
+        fixedJson = fixedJson.replace(/,\s*}/g, '}');
+        fixedJson = fixedJson.replace(/,\s*\]/g, ']');
         
-        // 将修复后的对象转回JSON字符串
-        return JSON.stringify(jsonObj);
-    } catch (jsonError) {
-        console.error("JSON解析或修复错误:", jsonError);
-        // 如果解析失败，保留原始结果
-        return jsonString;
+        // 尝试解析修复后的JSON
+        try {
+            JSON.parse(fixedJson);
+            console.log("JSON修复成功");
+            return fixedJson;
+        } catch (error2) {
+            console.error("JSON修复失败:", error2);
+            // 如果修复失败，返回原始字符串
+            return jsonString;
+        }
     }
 }
 
+// 导出所有函数
+export {
+    generateArticle,
+    enhanceFormsOfWords, 
+    validateAndFixJSON
+};
+
+// 默认导出，保持向后兼容性
 export default {
     generateArticle,
     enhanceFormsOfWords,

src/api/yjbdc/enhanceFormsOfWords.js

@@ -0,0 +1,167 @@
+/**
+ * 计算两个字符串之间的Levenshtein距离（编辑距离）
+ * @param {string} a - 第一个字符串
+ * @param {string} b - 第二个字符串
+ * @returns {number} - 编辑距离
+ */
+function levenshteinDistance(a, b) {
+    if (a.length === 0) return b.length;
+    if (b.length === 0) return a.length;
+    
+    const matrix = [];
+    
+    // 初始化矩阵
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    
+    // 填充矩阵
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            } else {
+                matrix[i][j] = Math.min(
+                    matrix[i - 1][j - 1] + 1, // 替换
+                    matrix[i][j - 1] + 1,     // 插入
+                    matrix[i - 1][j] + 1      // 删除
+                );
+            }
+        }
+    }
+    
+    return matrix[b.length][a.length];
+}
+
+/**
+ * 增强FormsOfWords，检测文章中单词的变形形式和拼写错误
+ * @param {Object} jsonObj - 解析后的JSON对象
+ * @param {string} userWords - 用户提供的单词列表，逗号分隔
+ * @returns {Object} - 增强后的JSON对象，其中FormsOfWords是字符串数组
+ */
+export function enhanceFormsOfWords(jsonObj, userWords) {
+    if (!jsonObj || !userWords) return jsonObj;
+    
+    // 将用户提供的单词转换为数组并去除空格
+    const userWordsList = userWords.split(',').map(word => word.trim().toLowerCase()).filter(word => word);
+    
+    // 如果没有用户单词或没有ArticleEnglish，直接返回
+    if (userWordsList.length === 0 || !jsonObj.ArticleEnglish || !Array.isArray(jsonObj.ArticleEnglish)) {
+        return jsonObj;
+    }
+    
+    // 创建FormsOfWords数组，首先包含所有用户输入的单词
+    const formsOfWordsArray = [...userWordsList];
+    
+    // 存储原始句子和小写句子的映射，用于保留大小写
+    const originalSentences = {};
+    const allSentencesLower = [];
+    
+    // 从文章中提取所有单词
+    const allWordsInArticle = [];
+    
+    jsonObj.ArticleEnglish.forEach(sentence => {
+        // 保存原始句子
+        const sentenceLower = sentence.toLowerCase();
+        originalSentences[sentenceLower] = sentence;
+        allSentencesLower.push(sentenceLower);
+        
+        // 移除标点符号，分割成单词
+        const words = sentenceLower
+            .replace(/[.,\/#!$%\^&\*;:{}=\-_`~()]/g, " ")
+            .replace(/\s+/g, " ")
+            .split(" ");
+        
+        words.forEach(word => {
+            if (word) allWordsInArticle.push(word.trim());
+        });
+    });
+    
+    // 常见的后缀列表
+    const commonSuffixes = ['ed', 'ing', 's', 'es', 'er', 'est', 'ly'];
+    
+    // 处理用户提供的每个单词
+    userWordsList.forEach(originalInput => {
+        // 跳过空输入
+        if (!originalInput) return;
+        
+        // 在文章中查找匹配和相似的单词
+        const matchedForms = [];
+        
+        allWordsInArticle.forEach(articleWord => {
+            // 跳过空单词
+            if (!articleWord) return;
+            
+            // 检查是否应该添加这个单词
+            let shouldAdd = false;
+            
+            // 完全匹配
+            if (articleWord === originalInput) {
+                shouldAdd = true;
+            } 
+            // 前缀匹配，但要求前缀至少3个字符
+            else if ((articleWord.startsWith(originalInput) && originalInput.length >= 3) || 
+                     (originalInput.startsWith(articleWord) && articleWord.length >= 3)) {
+                shouldAdd = true;
+            } 
+            // 编辑距离检查，但要求首字母相同且长度相近
+            else if (articleWord[0] === originalInput[0] && 
+                     Math.abs(articleWord.length - originalInput.length) <= 2 &&
+                     levenshteinDistance(articleWord, originalInput) <= 1) {
+                shouldAdd = true;
+            }
+            // 检查常见后缀
+            else {
+                for (const suffix of commonSuffixes) {
+                    if (articleWord === originalInput + suffix) {
+                        shouldAdd = true;
+                        break;
+                    }
+                }
+            }
+            
+            if (shouldAdd) {
+                // 在原始句子中查找单词，以保留大小写
+                let originalForm = null;
+                
+                for (const sentenceLower of allSentencesLower) {
+                    const originalSentence = originalSentences[sentenceLower];
+                    // 使用正则表达式查找单词，确保匹配完整单词而不是部分
+                    const wordRegex = new RegExp(`\\b${articleWord.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')}\\b`, 'i');
+                    const match = originalSentence.match(wordRegex);
+                    
+                    if (match) {
+                        originalForm = match[0];
+                        break;
+                    }
+                }
+                
+                // 如果找不到原始形式，使用小写形式
+                if (!originalForm) {
+                    originalForm = articleWord;
+                }
+                
+                // 添加到匹配形式列表
+                if (!matchedForms.includes(originalForm)) {
+                    matchedForms.push(originalForm);
+                }
+            }
+        });
+        
+        // 将找到的匹配形式添加到结果数组中
+        matchedForms.forEach(form => {
+            if (!formsOfWordsArray.includes(form)) {
+                formsOfWordsArray.push(form);
+            }
+        });
+    });
+    
+    // 将结果数组赋值给jsonObj.FormsOfWords
+    jsonObj.FormsOfWords = formsOfWordsArray;
+    
+    return jsonObj;
+}

src/api/yjbdc/yjbdcController.js

@@ -284,8 +284,14 @@ export async function GenerateArticle(ctx) {
                 // 将增强后的对象转回JSON字符串
                 result2 = JSON.stringify(enhancedJsonObj);
                 console.log("FormsOfWords已增强，添加了单词变形和拼写错误检测");
+                
+                // 记录增强后的单词数量
+                if (enhancedJsonObj.FormsOfWords && Array.isArray(enhancedJsonObj.FormsOfWords)) {
+                    console.log(`增强了${enhancedJsonObj.FormsOfWords.length}个单词的变形形式`);
+                }
             } catch (error) {
                 console.error("增强FormsOfWords时出错:", error);
+                console.error(error.stack); // 添加堆栈跟踪以便更好地调试
             }
             
             let param2={};

test-enhance.mjs

@@ -0,0 +1,22 @@
+import { enhanceFormsOfWords } from './src/api/yjbdc/aiController.js';
+
+// 创建一个测试用例
+const testJson = {
+  ArticleEnglish: [
+    "The quick brown fox jumps over the lazy dog.",
+    "She is running in the park every morning.",
+    "They have been working on this project for months.",
+    "I went to the store yesterday and bought some groceries.",
+    "The children are playing with their new toys."
+  ],
+  FormsOfWords: []
+};
+
+// 测试单词列表
+const testWords = "fox, run, go, play, work";
+
+// 调用函数
+const result = enhanceFormsOfWords(testJson, testWords);
+
+// 打印结果
+console.log(JSON.stringify(result, null, 2));

test-syntax.mjs

@@ -0,0 +1,3 @@
+import { enhanceFormsOfWords } from './src/api/yjbdc/aiController.js';
+
+console.log('函数语法检查通过');