@comate/zulu 0.7.1 → 0.7.3

package/comate-engine/plugins/paddle/dist/index.js

@@ -1,1011 +0,0 @@
-import { SkillProvider, TaskProgressChunkStream, StringChunkStream, TextModel, ElementChunkStream, FallbackProvider } from '@comate/plugin-host';
-import fs, { readFileSync } from 'fs';
-import { fileURLToPath } from 'node:url';
-import path, { dirname } from 'path';
-import path$1 from 'node:path';
-import assert from 'assert';
-import childProcess from 'child_process';
-import os from 'os';
-
-class HelpSkillProvider extends SkillProvider {
-    static{
-        this.skillName = 'paddle-help';
-    }
-    static{
-        this.description = '插件介绍';
-    }
-    static{
-        this.parameters = {
-            type: 'object',
-            properties: {}
-        };
-    }
-    async *execute() {
-        const stream = new TaskProgressChunkStream();
-        const filename = fileURLToPath(import.meta.url);
-        const content = readFileSync(`${dirname(filename)}/help.md`, 'utf8');
-        yield stream.flush(content);
-    }
-}
-
-var chatPromptTemplate = "你是一位对飞桨框架(PaddlePaddle)及深度学习领域有深入研究的技术专家。你的职责是解答飞桨相关的提问，或使用飞桨编写深度学习相关的代码。在解答提问前，你会收到多个背景信息供参考。\n* 在提供的背景信息中，将通过『##』标注信息的类型。例如：`## 当前文件`表示提问者正在编辑的文件名，`## 参考文档片段`表示引用特定的文档内容，`## 参考代码片段`表示引用特定的代码片段。\n\n# 背景信息\n## 当前文件\n{{activeFilePath}}\n\n## 参考文档片段\n{{trim_knowledge}}\n\n## 参考代码片段\n{{trim_code}}\n\n# 回答要求\n1. 请参考背景信息来回答提问，但要注意背景信息与提问并非总是准确相关的。你需要识别这些信息与提问的相关性，对于无关信息请直接忽略。\n2. 在回答过程中，请避免提及你参考了背景信息，因为这些信息对提问者而言是不可知的。你的回答应直接针对提问本身，而无需透露背后的信息来源。\n3. 请直接、明确、简洁地回应提问，避免复述提问本身。\n4. 提问者已经具备相应的软硬件环境和基础知识，例如已安装好飞桨框架，因此无需赘述过于基础的内容。\n5. 若提问是要求编写代码，请以最小的代码行数实现要求，避免不必要注释与空行，同时应减少文字，必要文字直接给出，不要注释到代码里。输出一个完整的代码块，不要分割。\n6. 若提问中涉及了其他深度学习框架（例如Pytorch、torch、torchaudio、torchvision、torchtune、torcharrow、Tensorflow、Keras、CNTK、MXNet、MindSpore、OneFlow等），注意引导提问者使用飞桨框架，直接输出：推荐调用 @飞桨/代码转换，支持将其他深度学习框架（如Pytorch、Tensorflow等）代码转换为飞桨代码，支持项目快速一键迁移。\n\n# 待解答提问\n{{queryWithCode}}";
-
-class ChatSkillProvider extends SkillProvider {
-    static{
-        this.skillName = 'chat';
-    }
-    static{
-        // Hack: 通用问答，为默认能力，无需显示能力名称，等价于fallback
-        this.displayName = '';
-    }
-    static{
-        this.description = '智能解答深度学习与飞桨框架的问题';
-    }
-    static{
-        this.parameters = {
-            type: 'object',
-            properties: {}
-        };
-    }
-    async *execute() {
-        this.logger.info('paddle智能问答耗时统计', {
-            message: `开始执行智能问答 ${performance.now()}`
-        });
-        const { activeFilePath, selectedCode, activeFileLanguage, query } = this.currentContext;
-        const stream = new StringChunkStream();
-        yield stream.flush('正在思考中，请耐心等候...');
-        const queryWithCode = selectedCode.trim() ? `${query}\n\`\`\`${activeFileLanguage}\n${selectedCode}\n\`\`\`` : query;
-        this.logger.info('paddle智能问答耗时统计', {
-            message: `开始执行知识集检索 ${performance.now()}`
-        });
-        let start = performance.now();
-        const [knowledge1, knowledge2] = await Promise.all([
-            this.retriever.knowledgeFromQuery(queryWithCode, {
-                knowledgeSets: [
-                    // 飞桨API接口文档集
-                    {
-                        uuid: '564a9ebb-a3b1-4d5b-ad28-27c0ab6d78fe',
-                        type: 'NORMAL'
-                    }
-                ],
-                queryRewrite: true,
-                topK: 7
-            }),
-            this.retriever.knowledgeFromQuery(queryWithCode, {
-                knowledgeSets: [
-                    // 飞桨框架与生态文档集
-                    {
-                        uuid: '7ece94ce-e39a-414e-8ca5-d80ed4cf300b',
-                        type: 'NORMAL'
-                    }
-                ],
-                queryRewrite: true,
-                topK: 8
-            })
-        ]);
-        this.logger.info('paddle智能问答耗时统计', {
-            message: `知识集检索结束，耗时${performance.now() - start}ms`
-        });
-        start = performance.now();
-        const trim_knowledge = [
-            ...knowledge1,
-            ...knowledge2
-        ];
-        const trim_code = [
-            ''
-        ];
-        const prompt = this.llm.createPrompt(chatPromptTemplate, {
-            activeFilePath,
-            trim_knowledge,
-            trim_code,
-            queryWithCode
-        });
-        const chunks = this.llm.askForTextStreaming(prompt, {
-            model: TextModel.ErnieBot128,
-            modelOptions: {
-                temperature: 0.3,
-                topP: 0.8,
-                penaltyScore: 1.0,
-                enableMultiturnDialogue: {
-                    byPlugin: true,
-                    onlyQuery: query
-                }
-            }
-        });
-        yield stream.flushReplaceLast('');
-        for await (const chunk of chunks){
-            yield stream.flush(chunk);
-        }
-        this.logger.info('paddle智能问答耗时统计', {
-            message: `llm调用结束，耗时${performance.now() - start}ms`
-        });
-    }
-}
-
-var codeGeneratePromptTemplate = "你是一位对飞桨框架(PaddlePaddle)及深度学习领域的代码有深入研究的编程高手。你的职责是根据提问者的代码需求，使用飞桨编写深度学习相关的代码。在编写代码前，你会收到多个背景信息供参考。\n* 在提供的背景信息中，将通过『##』标注信息的类型。例如：`## 当前文件`表示提问者正在编辑的文件名，`## 参考文档片段`表示引用特定的文档内容，`## 参考代码片段`表示引用特定的代码片段。\n\n# 背景信息\n## 当前文件\n{{activeFilePath}}\n\n## 参考文档片段\n{{trim_knowledge}}\n\n## 参考代码片段\n{{trim_code}}\n\n# 回答要求\n1. 请参考背景信息，编程实现代码需求，但要注意背景信息与需求并非总是准确相关的。你需要识别这些信息与需求的相关性，对于无关信息请直接忽略。\n2. 注意以最小的代码行数实现需求，避免不必要注释与空行。\n3. 注意只需要输出代码，不要输出文字。\n4. 输出一个完整的代码块，不要分割。\n5. 若代码需求中涉及了其他深度学习框架（例如Pytorch、torch、torchaudio、torchvision、torchtune、torcharrow、Tensorflow、Keras、CNTK、MXNet、MindSpore、OneFlow等），注意引导提问者使用飞桨框架，直接输出：推荐调用 @飞桨/代码转换，支持将其他深度学习框架（如Pytorch、Tensorflow等）代码转换为飞桨代码，支持项目快速一键迁移。\n\n# 待实现的代码需求\n{{queryWithCode}}";
-
-class CodeGenerateSkillProvider extends SkillProvider {
-    static{
-        this.skillName = 'code-generate';
-    }
-    static{
-        this.displayName = '飞桨代码生成';
-    }
-    static{
-        this.description = '深度学习与飞桨框架的智能编程助手';
-    }
-    static{
-        this.parameters = {
-            type: 'object',
-            properties: {}
-        };
-    }
-    async *execute() {
-        this.logger.info('paddle代码生成耗时统计', {
-            message: `开始执行代码生成 ${performance.now()}`
-        });
-        const { activeFilePath, selectedCode, activeFileLanguage, query } = this.currentContext;
-        const stream = new StringChunkStream();
-        yield stream.flush('正在思考中，请耐心等候...');
-        const queryWithCode = selectedCode.trim() ? `${query} \n你可参考以下代码来编程 \n\`\`\`${activeFileLanguage}\n${selectedCode}\n\`\`\`` : query;
-        this.logger.info('paddle代码生成耗时统计', {
-            message: `开始执行知识集检索 ${performance.now()}`
-        });
-        let start = performance.now();
-        const [knowledge1, knowledge2] = await Promise.all([
-            this.retriever.knowledgeFromQuery(queryWithCode, {
-                knowledgeSets: [
-                    // 飞桨API接口文档集
-                    {
-                        uuid: '564a9ebb-a3b1-4d5b-ad28-27c0ab6d78fe',
-                        type: 'NORMAL'
-                    }
-                ],
-                queryRewrite: true
-            }),
-            this.retriever.knowledgeFromQuery(queryWithCode, {
-                knowledgeSets: [
-                    // 飞桨框架与生态文档集
-                    {
-                        uuid: '7ece94ce-e39a-414e-8ca5-d80ed4cf300b',
-                        type: 'NORMAL'
-                    }
-                ],
-                queryRewrite: true,
-                topK: 5
-            })
-        ]);
-        this.logger.info('paddle代码生成耗时统计', {
-            message: `知识集检索结束，耗时${performance.now() - start}ms`
-        });
-        start = performance.now();
-        const trim_knowledge = [
-            ...knowledge1,
-            ...knowledge2
-        ];
-        const trim_code = [
-            ''
-        ];
-        const prompt = this.llm.createPrompt(codeGeneratePromptTemplate, {
-            activeFilePath,
-            trim_knowledge,
-            trim_code,
-            queryWithCode
-        });
-        const chunks = this.llm.askForTextStreaming(prompt, {
-            model: TextModel.ErnieBot128,
-            modelOptions: {
-                temperature: 0.1,
-                topP: 0.8,
-                penaltyScore: 1.0,
-                enableMultiturnDialogue: false
-            }
-        });
-        let start_flush = false;
-        for await (const chunk of chunks){
-            if (start_flush) {
-                yield stream.flush(chunk);
-            } else {
-                if (chunk.includes('```')) {
-                    start_flush = true;
-                    yield stream.flushReplaceLast('');
-                    yield stream.flush(chunk);
-                }
-            }
-        }
-        if (!start_flush) {
-            yield stream.flushReplaceLast('未生成任何代码，请清晰描述您的代码需求，以便我充分理解。');
-        }
-        this.logger.info('paddle代码生成耗时统计', {
-            message: `llm调用结束，耗时${performance.now() - start}ms`
-        });
-    }
-}
-
-function jsx(type, props) {
-    // 按照React的逻辑，`boolean`、`null`、`undefined`是不会显示出来的
-    const children = Array.isArray(props.children) ? props.children.filter((v)=>v != null && typeof v !== 'boolean') : props.children;
-    return {
-        type,
-        ...props,
-        children
-    };
-}
-
-var codeConvertPromptTemplate = "你是一位对各种深度学习框架(例如飞桨PaddlePaddle、Pytorch、Tensorflow、Keras、CNTK、MXNet、MindSpore、OneFlow等)的代码有深入研究的编程高手。你的职责是将飞桨之外的其他深度学习框架代码转写为飞桨代码。在转写代码前，你会收到多个背景信息和转写示例供参考。\n* 在提供的背景信息中，将通过『##』标注信息的类型。例如：`## 参考文档片段`表示引用特定的文档内容，`## 参考代码片段`表示引用特定的代码片段。\n\n# 背景信息\n## 参考文档片段\n{{trim_knowledge}}\n\n## 参考代码片段\n{{trim_code}}\n\n# 转写示例\n## 输入\n```python\nimport torch\nx = torch.tensor([[4., 5., 6.], [1., 2., 3.], [4., 9., 10.]])\ny = torch.tensor([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]])\nresult = torch.matmul(x, y)\n```\n## 输出\n```python\nimport paddle\nx = paddle.to_tensor(data=[[4.0, 5.0, 6.0], [1.0, 2.0, 3.0], [4.0, 9.0, 10.0]])\ny = paddle.to_tensor(data=[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])\nresult = paddle.matmul(x=x, y=y)\n```\n\n# 转写要求\n1. 请参考背景信息与转写示例来转写，但要注意背景信息与待转写代码并非总是准确相关的。你需要识别这些信息的相关性，对于无关信息请直接忽略。\n2. 转写示例以Pytorch代码为例，实际输入可能是任意深度学习框架的代码，无论任何输入，输出都是飞桨的代码\n3. 注意输出只需要转写后的代码，文字解释以代码注释形式给出，不要直接输出任何文字\n4. 若待转写代码中没有其他深度学习框架的代码，则无需转写，直接回复：待转写代码与深度学习无关，无法转写到飞桨。\n\n# 待转写代码\n```{{language}}\n{{in_content}}\n```\n";
-
-function getLanguageFromFilePath(filePath) {
-    const extension = filePath.split('.').pop();
-    switch(extension){
-        case 'bat':
-            return 'bat';
-        case 'c':
-            return 'c';
-        case 'cc':
-            return 'cpp';
-        case 'cu':
-            return 'cuda-cpp';
-        case 'go':
-            return 'go';
-        case 'js':
-            return 'javascript';
-        case 'ts':
-            return 'typescript';
-        case 'py':
-            return 'python';
-        case 'sh':
-            return 'shellscript';
-        case 'yaml':
-            return 'yaml';
-        // 可以继续添加其他语言扩展名的情况
-        default:
-            return ''; // 如果不知道扩展名对应的语言，返回空字符串
-    }
-}
-
-function rmDir(dirPath, logger) {
-    try {
-        if (!fs.existsSync(dirPath)) {
-            return;
-        }
-        let entries = fs.readdirSync(dirPath, {
-            withFileTypes: true
-        });
-        if (entries.length === 0) {
-            // 目录为空，直接删除
-            fs.rmdirSync(dirPath);
-            logger.info(`目录 ${dirPath} 删除成功`);
-            return;
-        }
-        for (let entry of entries){
-            let fullPath = path.join(dirPath, entry.name);
-            if (entry.isDirectory()) {
-                rmDir(fullPath, logger);
-            } else {
-                fs.unlinkSync(fullPath);
-            }
-        }
-        logger.info(`目录 ${dirPath} 删除成功`);
-    } catch  {
-        logger.error(`目录 ${dirPath} 删除失败`);
-    }
-    fs.rmdirSync(dirPath);
-}
-function getAllFilesPath(dirPath, logger) {
-    let fileNames = [];
-    const files = fs.readdirSync(dirPath);
-    for (const file of files){
-        const fullPath = path.join(dirPath, file);
-        const stats = fs.statSync(fullPath);
-        if (stats.isDirectory()) {
-            // 如果是目录，则递归调用
-            fileNames = fileNames.concat(getAllFilesPath(fullPath));
-        } else {
-            // 如果是文件，只添加文件名到列表中
-            fileNames.push(fullPath);
-        }
-    }
-    return fileNames;
-}
-function readFiles(filePaths, baseDir, logger) {
-    return filePaths.map((file)=>{
-        try {
-            // 同步读取文件内容
-            const res = fs.readFileSync(file, 'utf8');
-            return `\`\`\`\n${res}\`\`\``;
-        } catch (error) {
-            logger.error(`Error reading file ${file}: ${error}`);
-            return ''; // 或者你可以返回一个特定的错误消息或null
-        }
-    });
-}
-function readFile(filePath, logger) {
-    try {
-        // 同步读取文件内容
-        const res = fs.readFileSync(filePath, 'utf8');
-        return res;
-    } catch (error) {
-        logger.error(`Error reading file ${filePath}: ${error}`);
-        return ''; // 或者你可以返回一个特定的错误消息或null
-    }
-}
-function ifOverSize(files, baseDir, logger) {
-    const limit = 5 * 1024 * 1024; // 5MB in bytes
-    let totalSize = 0;
-    for (const file of files){
-        const filePath = file;
-        try {
-            const stats = fs.statSync(filePath);
-            if (stats.isFile()) {
-                totalSize += stats.size;
-                if (totalSize > limit) {
-                    return true;
-                }
-            } else {
-                logger.error(`${filePath} is not a file, skipping.`);
-            }
-        } catch (error) {
-            logger.error(`Error statting file ${filePath}: ${error}`);
-        }
-    }
-    return false;
-}
-
-const TEMP = os.tmpdir();
-function exec(command) {
-    return new Promise((resolve, reject)=>{
-        childProcess.exec(command, (error, stdout)=>{
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve(stdout);
-        });
-    });
-}
-class CodeConvertSkillProvider extends SkillProvider {
-    static{
-        this.skillName = 'code-convert';
-    }
-    static{
-        this.displayName = '飞桨代码转换';
-    }
-    static{
-        this.description = '将其他深度学习框架（例如Pytorch、Tensorflow、Keras等）的代码转换为飞桨的代码';
-    }
-    static{
-        this.parameters = {
-            type: 'object',
-            properties: {}
-        };
-    }
-    #cwd;
-    #pluginDir;
-    constructor(init){
-        super(init);
-        this.#cwd = init.cwd;
-        this.tempDir = path$1.resolve(TEMP, 'paddle_project');
-        console.log('temp', TEMP);
-        const entryFileName = fileURLToPath(import.meta.url);
-        // 取entryFileName的上两级目录
-        this.#pluginDir = path$1.resolve(entryFileName, '..', '..');
-        const paconvertWhl = path$1.join(this.#pluginDir, 'assets', 'paconvert-3.0.1-py3-none-any.whl');
-        exec('paconvert -h').then((stdout)=>{
-            this.logger.info(`paconvert已安装，无需再次安装: ${stdout}`);
-        }).catch(()=>{
-            exec(`python3 -m pip install -U ${paconvertWhl}`).then((stdout)=>{
-                this.logger.info(`python3安装paconvert成功: ${stdout}`);
-            }).catch(()=>{
-                exec(`python3.9 -m pip install -U ${paconvertWhl}`).then((stdout)=>{
-                    this.logger.info(`python3.9安装paconvert成功: ${stdout}`);
-                }).catch(()=>{
-                    exec(`python3.10 -m pip install -U ${paconvertWhl}`).then((stdout)=>{
-                        this.logger.info(`python3.10安装paconvert成功: ${stdout}`);
-                    }).catch(()=>{
-                        exec(`python3.11 -m pip install -U ${paconvertWhl}`).then((stdout)=>{
-                            this.logger.info(`python3.11安装paconvert成功: ${stdout}`);
-                        }).catch(()=>{
-                            exec(`python3.12 -m pip install -U ${paconvertWhl}`).then((stdout)=>{
-                                this.logger.info(`python3.12安装paconvert成功: ${stdout}`);
-                            }).catch(()=>{
-                                exec(`python3.13 -m pip install -U ${paconvertWhl}`).then((stdout)=>{
-                                    this.logger.info(`python3.13安装paconvert成功: ${stdout}`);
-                                }).catch(()=>{
-                                    exec(`python -m pip install -U ${paconvertWhl}`).then((stdout)=>{
-                                        this.logger.info(`python安装paconvert成功: ${stdout}`);
-                                    }).catch((error)=>{
-                                        this.logger.error(`paconvert安装失败: ${error.message}`);
-                                    });
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
-    }
-    async *handleCommand(commandName, data) {
-        console.log('commandName', commandName);
-        console.log('commandNameData', data);
-        const { files } = data;
-        const stream = new ElementChunkStream();
-        if (commandName === 'commitMessage:confirmIssue') {
-            yield stream.flushReplaceLast(/*#__PURE__*/ jsx("p", {
-                children: /*#__PURE__*/ jsx("ul", {
-                    children: files.map((item)=>/*#__PURE__*/ jsx("li", {
-                            children: /*#__PURE__*/ jsx("file-link", {
-                                showIcon: true,
-                                to: path$1.join('./paddle_project', item.replace(this.tempDir, '')),
-                                line: 2,
-                                children: item.replace(this.tempDir, '')
-                            })
-                        }))
-                })
-            }));
-            yield stream.flush(/*#__PURE__*/ jsx("markdown", {
-                children: `完成转换，已经将所有文件写入目录\`${path$1.join(this.#cwd, 'paddle_project')}\`中，您可点击文件链接查看。\n\n\n`
-            }));
-        }
-    }
-    /**
-     * 执行转换任务并返回任务进度块
-     *
-     * @returns 异步迭代器，返回 TaskProgressChunk 类型的任务进度块
-     */ async *execute() {
-        this.logger.info('paddle代码转换耗时统计', {
-            message: `开始执行环境适配 ${Date.now()}`
-        });
-        const stream = new ElementChunkStream();
-        const { query, selectedCode, activeFileContent, activeFilePath, activeFileLanguage } = this.currentContext;
-        let use_paconvert = true;
-        let in_content = '';
-        // 绝对路径
-        let in_dir = '';
-        // 相对路径
-        let in_rdir = '';
-        let language = activeFileLanguage;
-        const fs = await this.requestWorkspaceFileSystem();
-        // 优先级1: 用户选择的文件/目录
-        const selectedKnowledgeList = this.retriever.selectedKnowledgeList();
-        if (selectedKnowledgeList.length) {
-            if (selectedKnowledgeList[0].type === 'FILE') {
-                in_content = selectedKnowledgeList[0].content;
-                in_dir = path$1.resolve(this.#cwd, selectedKnowledgeList[0].path);
-                in_rdir = selectedKnowledgeList[0].path;
-                language = getLanguageFromFilePath(selectedKnowledgeList[0].name);
-            } else if (selectedKnowledgeList[0].type == 'FOLDER') {
-                in_content = 'FOLDER';
-                in_dir = path$1.resolve(this.#cwd, selectedKnowledgeList[0].path);
-                in_rdir = selectedKnowledgeList[0].path;
-            } else if (selectedKnowledgeList[0].type === 'CURRENT_FILE') {
-                in_content = activeFileContent;
-                in_dir = path$1.resolve(this.#cwd, activeFilePath);
-                in_rdir = activeFilePath;
-            } else if (selectedKnowledgeList[0].type === 'REPO') {
-                in_content = 'FOLDER';
-                in_dir = path$1.resolve(this.#cwd);
-            }
-        }
-        // 优先级2: query为相对路径
-        if (!in_content && fs && query.trim().length > 0) {
-            const queryTrim = query.trim();
-            try {
-                const stat = await fs.stat(queryTrim);
-                if (stat.type === 'file') {
-                    in_content = await fs.readFile(queryTrim, 'utf-8');
-                    in_dir = path$1.resolve(this.#cwd, queryTrim);
-                    in_rdir = queryTrim;
-                    language = getLanguageFromFilePath(queryTrim);
-                }
-                if (stat.type === 'directory') {
-                    in_content = 'FOLDER';
-                    in_dir = path$1.resolve(this.#cwd, queryTrim);
-                    in_rdir = queryTrim;
-                }
-            } catch (e) {
-                this.logger.error('解析query中的路径失败: ' + e.message);
-            }
-        }
-        // 优先级3: 选中代码
-        if (!in_content && selectedCode) {
-            in_content = selectedCode;
-            use_paconvert = false;
-        }
-        // 优先级4: 当前文件
-        if (!in_content && activeFilePath) {
-            in_content = activeFileContent;
-            in_dir = path$1.resolve(this.#cwd, activeFilePath);
-        }
-        // 无任何输入，报错
-        if (!in_content) {
-            this.logger.error('未检测到待转换的代码！');
-            yield stream.flush(/*#__PURE__*/ jsx("markdown", {
-                children: '未检测到待转换的代码，您可通过以下方式指定：\n1. 直接回车则转换当前文件\n2. 使用 # 选择文件或目录\n3. 直接输入相对路径\n4. 框选代码\n\n'
-            }));
-            return;
-        }
-        if (in_content.includes('tensorflow') || in_content.includes('keras')) {
-            use_paconvert = false;
-        }
-        if (!fs) {
-            use_paconvert = false;
-        }
-        // Python环境检查
-        if (use_paconvert) {
-            try {
-                await exec('python3 --version');
-            } catch (e) {
-                try {
-                    await exec('python --version');
-                } catch (e) {
-                    this.logger.error(`未检测到Python解释器: ${e.message}`);
-                    yield stream.flush(/*#__PURE__*/ jsx("markdown", {
-                        children: '未检测到Python解释器，建议安装3.8版本及以上的Python，安装后可支持Pytorch项目整个目录的 **批量/长文本转换**，转换速度更快、准确率更高，一键迁移到飞桨框架。'
-                    }));
-                    use_paconvert = false;
-                }
-            }
-        }
-        // PaConvert环境检查
-        if (use_paconvert) {
-            // 检测是否安装了paconvert
-            try {
-                await exec('paconvert -h');
-            } catch (e) {
-                yield stream.flush(/*#__PURE__*/ jsx("markdown", {
-                    children: '正在配置环境中，请稍等...\n\n'
-                }));
-                const paconvertWhl = path$1.join(this.#pluginDir, 'assets', 'paconvert-3.0.1-py3-none-any.whl');
-                try {
-                    await exec(`python3 -m pip install -U ${paconvertWhl}`);
-                    await exec(`paconvert -h`);
-                    yield stream.flushReplaceLast(/*#__PURE__*/ jsx("markdown", {
-                        children: '配置成功，开始转换...\n\n'
-                    }));
-                } catch (e) {
-                    try {
-                        await exec(`python -m pip install -U ${paconvertWhl}`);
-                        await exec(`paconvert -h`);
-                        yield stream.flushReplaceLast(/*#__PURE__*/ jsx("markdown", {
-                            children: '配置成功，开始转换...\n\n'
-                        }));
-                    } catch (e) {
-                        this.logger.error(`paconvert安装失败: ${e.message}`);
-                        yield stream.flushReplaceLast(/*#__PURE__*/ jsx("markdown", {
-                            children: '未成功安装飞桨代码转换工具paconvert，安装后可支持Pytorch项目整个目录的 **批量/长文本转换**，转换速度更快、准确率更高，一键迁移到飞桨框架。推荐安装：\n\n'
-                        }));
-                        yield stream.flush(/*#__PURE__*/ jsx("code-block", {
-                            language: "bash",
-                            closed: false,
-                            children: 'pip3 install -U paconvert'
-                        }));
-                        yield stream.flush(/*#__PURE__*/ jsx("markdown", {
-                            children: '由于未安装该工具，将使用 **普通转换方式**。\n\n'
-                        }));
-                        use_paconvert = false;
-                    }
-                }
-            }
-        }
-        if (in_dir) {
-            if (in_content === 'FOLDER') {
-                yield stream.flush(/*#__PURE__*/ jsx("markdown", {
-                    children: `正在转换整个目录：\`${in_dir}\`，批量转换时间可能较长，请耐心等待...\n\n`
-                }));
-            } else {
-                yield stream.flush(/*#__PURE__*/ jsx("markdown", {
-                    children: `正在转换单个文件：\`${in_dir}\`，请稍等...\n\n`
-                }));
-            }
-        } else if (selectedCode) {
-            yield stream.flush(/*#__PURE__*/ jsx("markdown", {
-                children: '正在转换选中代码...\n\n'
-            }));
-        }
-        // 使用PaConvert转换
-        if (use_paconvert) {
-            assert(fs, '文件系统不存在');
-            const log_file = path$1.resolve(this.#cwd, '.convert.log');
-            if (in_content === 'FOLDER') {
-                const out_dir = this.tempDir;
-                //批量之前删除临时目录里的内容 兼容windows
-                rmDir(out_dir, this.logger);
-                //批量之前删除本地的paddle_project
-                rmDir(path$1.resolve(this.#cwd, 'paddle_project'), this.logger);
-                try {
-                    // 检查目录合法性
-                    console.log('待转换目录', in_dir);
-                    const in_files = getAllFilesPath(in_dir, this.logger);
-                    console.log('待转换目录中的文件', in_files);
-                    const overSize = ifOverSize(in_files, this.#cwd, this.logger);
-                    if (overSize) {
-                        yield stream.flushReplaceLast(/*#__PURE__*/ jsx("markdown", {
-                            children: '选择目录中文件过大，无法进行转换，请减少文件数量，或选择单个文件进行转换。\n\n'
-                        }));
-                        return;
-                    }
-                    // 调用paconvert tool转换
-                    await exec(`paconvert --in_dir ${in_dir} --out_dir ${out_dir} --log_dir ${log_file} --exc_patterns ${out_dir} --log_level WARNING --log_markdown`);
-                    // 展示转换结果
-                    const out_files = getAllFilesPath(this.tempDir, this.logger);
-                    console.log('目录转换文件', out_files);
-                    const out_content = readFiles(out_files, this.#cwd, this.logger);
-                    console.log('目录转换文件内容', out_content);
-                    yield stream.flushReplaceLast(/*#__PURE__*/ jsx("p", {
-                        children: [
-                            /*#__PURE__*/ jsx("ul", {
-                                children: out_files.map((item)=>/*#__PURE__*/ jsx("li", {
-                                        children: /*#__PURE__*/ jsx("p", {
-                                            children: item.replace(this.tempDir, '')
-                                        })
-                                    }))
-                            }),
-                            /*#__PURE__*/ jsx("flex", {
-                                inline: true,
-                                verticalStartAlign: true,
-                                children: /*#__PURE__*/ jsx("command-button", {
-                                    commandName: "commitMessage:confirmIssue",
-                                    variant: "text",
-                                    action: "acceptDir",
-                                    actionData: {
-                                        includeHiddenStatsCode: true,
-                                        newText: out_content.join('\n'),
-                                        from: this.tempDir,
-                                        to: path$1.join(this.#cwd, 'paddle_project')
-                                    },
-                                    propagation: true,
-                                    data: {
-                                        files: out_files,
-                                        from: this.tempDir,
-                                        to: path$1.join(this.#cwd, 'paddle_project')
-                                    },
-                                    tooltipText: "批量采纳",
-                                    children: "批量采纳"
-                                })
-                            }),
-                            /*#__PURE__*/ jsx("markdown", {
-                                children: `点击 **批量采纳** 可以将所有文件写入目录\`${path$1.join(this.#cwd, 'paddle_project')}\`中。\n\n\n`
-                            })
-                        ]
-                    }));
-                } catch (e) {
-                    this.logger.error(`paconvert转换目录${in_dir}失败，失败原因：${e.message}`);
-                    yield stream.flushReplaceLast(/*#__PURE__*/ jsx("markdown", {
-                        children: `转换失败，失败原因：\n\`\`\`\n${e.message}\n\`\`\`\n\n您可尝试选择单个文件进行转换。\n\n`
-                    }));
-                    return;
-                }
-            } else {
-                const fileName = path$1.basename(in_dir);
-                const out_dir = path$1.resolve(this.tempDir, fileName);
-                try {
-                    // 检查文件合法性
-                    if (in_content.length > 1000000) {
-                        yield stream.flushReplaceLast(/*#__PURE__*/ jsx("markdown", {
-                            children: '文本代码长度超过限制，请减少文本代码长度，或框选代码进行转换。\n\n'
-                        }));
-                        return;
-                    }
-                    // 调用paconvert tool转换
-                    await exec(`paconvert --in_dir ${in_dir} --out_dir ${out_dir} --log_dir ${log_file} --log_level WARNING --log_markdown`);
-                    // 展示转换结果
-                    const out_content = readFile(out_dir, this.logger);
-                    console.log('单文件转换结果', out_content);
-                    yield stream.flushReplaceLast(/*#__PURE__*/ jsx("code-block", {
-                        language: language,
-                        closed: false,
-                        children: `${out_content}`
-                    }));
-                    exec(`rm -rf ${out_dir}`).then(()=>{
-                        this.logger.info(`转换结果临时保存文件 ${out_dir} 删除成功`);
-                    }).catch(()=>{
-                        this.logger.error(`转换结果临时保存文件 ${out_dir} 删除失败`);
-                    });
-                } catch (e) {
-                    this.logger.error(`paconvert转换单文件${in_dir}失败，失败原因：${e.message}`);
-                    use_paconvert = false;
-                    if (in_content.length > 200000) {
-                        yield stream.flushReplaceLast(/*#__PURE__*/ jsx("markdown", {
-                            children: '待转换的代码长度超过限制，请减少代码量。\n\n'
-                        }));
-                        return;
-                    }
-                }
-            }
-            // 打印转换日志，如果改为使用大模型，则不打印
-            if (use_paconvert) {
-                try {
-                    const log_content = await fs.readFile('.convert.log', 'utf8');
-                    yield stream.flush(/*#__PURE__*/ jsx("markdown", {
-                        children: `\n\n${log_content}\n`
-                    }));
-                    exec(`rm -rf ${log_file}`).then(()=>{
-                        this.logger.info(`转换的日志 ${log_file} 删除成功`);
-                    }).catch(()=>{
-                        this.logger.error(`转换的日志 ${log_file} 删除失败`);
-                    });
-                } catch (e) {
-                    this.logger.error('paconvert转换日志文件读取失败: ', e.message);
-                }
-                return;
-            }
-        }
-        // 大模型转换
-        if (!use_paconvert) {
-            this.logger.info('paddle代码转换耗时统计', {
-                message: `paconvert无法转换，使用大模型转换 ${Date.now()}`
-            });
-            if (in_content == 'FOLDER') {
-                // 无法支持，报错
-                this.logger.error('转换整个目录时，仅能使用paconvert转换，需修复paconvert环境问题');
-                yield stream.flushReplaceLast(/*#__PURE__*/ jsx("markdown", {
-                    children: '**大模型转换方式** 不支持整个目录批量转换，请安装飞桨代码转换工具paconvert以支持 **批量转换**，或者选择单个文件进行转换。\n\n'
-                }));
-                yield stream.flush(/*#__PURE__*/ jsx("code-block", {
-                    language: "bash",
-                    closed: false,
-                    children: 'pip3 install -U paconvert'
-                }));
-                return;
-            }
-            this.logger.info('paddle代码转换耗时统计', {
-                message: `开始执行知识集检索 ${Date.now()}`
-            });
-            let start = Date.now();
-            const knowledge = await this.retriever.knowledgeFromQuery(in_content, {
-                knowledgeSets: [
-                    // 飞桨API接口映射文档集
-                    {
-                        uuid: 'a53c6ee5-3bcf-46cd-80b7-103c6d028389',
-                        type: 'NORMAL'
-                    }
-                ],
-                queryRewrite: false
-            });
-            this.logger.info('paddled代码转换耗时统计', {
-                message: `知识集检索结束，耗时${Date.now() - start}ms`
-            });
-            start = Date.now();
-            const trim_knowledge = knowledge;
-            const trim_code = [
-                ''
-            ];
-            const prompt = this.llm.createPrompt(codeConvertPromptTemplate, {
-                trim_knowledge,
-                trim_code,
-                language,
-                in_content
-            });
-            const chunks = this.llm.askForTextStreaming(prompt, {
-                model: TextModel.ErnieBot128,
-                modelOptions: {
-                    temperature: 0.1,
-                    topP: 0.8,
-                    penaltyScore: 1.0,
-                    enableMultiturnDialogue: false
-                }
-            });
-            let res = '';
-            yield stream.flushReplaceLast(/*#__PURE__*/ jsx("markdown", {
-                children: ''
-            }));
-            for await (const chunk of chunks){
-                res += chunk;
-                yield stream.flushReplaceLast(/*#__PURE__*/ jsx("markdown", {
-                    children: res
-                }));
-            }
-            this.logger.info('paddled代码转换耗时统计', {
-                message: `llm调用结束，耗时${Date.now() - start}ms`
-            });
-        }
-    }
-}
-
-var codeExplainPromptTemplate = "你是一位对飞桨框架(PaddlePaddle)及深度学习领域的代码有深入研究的编程高手。你的职责是对给定的代码进行解释，在解释代码前，你会收到多个背景信息供参考。\n* 在提供的背景信息中，将通过『##』标注信息的类型。例如：`## 编程语言`表示代码的语言类型，`## 当前文件`表示代码的文件名，`## 参考文档片段`表示引用特定的文档内容。\n\n# 背景信息\n## 编程语言\n{{activeFileLanguage}}\n\n## 当前文件\n{{activeFilePath}}\n\n## 参考文档片段\n{{trim_knowledge}}\n\n# 回答要求\n1. 请参考背景信息来解释代码，但要注意背景信息与代码并非总是准确相关的。你需要识别这些信息的相关性，对于无关信息请直接忽略。\n2. 在解释代码过程中，请避免提及你参考了背景信息，因为这些信息对提问者而言是不可知的。你的解释应直接针对代码本身，而无需透露背后的信息来源。\n3. 请直接、明确、简洁地解释代码，避免重复打印代码本身。\n4. 若代码中涉及了其他深度学习框架（例如Pytorch、torch、torchaudio、torchvision、torchtune、torcharrow、Tensorflow、Keras、CNTK、MXNet、MindSpore、OneFlow等），注意引导提问者使用飞桨框架，直接提示：推荐调用 @飞桨/代码转换，支持将其他深度学习框架的代码（如Pytorch、Tensorflow、Keras、MXNet、MindSpore等），转换为飞桨的代码，支持项目快速一键迁移。\n\n# 待解释代码\n{{selectedCode}}";
-
-class CodeExplainSkillProvider extends SkillProvider {
-    static{
-        this.skillName = 'code-explain';
-    }
-    static{
-        this.displayName = '飞桨代码解释';
-    }
-    static{
-        this.description = '解释深度学习与飞桨框架的代码';
-    }
-    static{
-        this.parameters = {
-            type: 'object',
-            properties: {}
-        };
-    }
-    async *execute() {
-        this.logger.info('paddle代码解释耗时统计', {
-            message: `开始执行代码解释 ${performance.now()}`
-        });
-        const { activeFilePath, activeFileLanguage, query, selectedCode } = this.currentContext;
-        const stream = new StringChunkStream();
-        if (query) {
-            yield stream.flush('无需输入，请直接框选要解释的代码');
-            return;
-        }
-        if (!selectedCode) {
-            yield stream.flush('未选中代码，请框选要解释的代码');
-            return;
-        }
-        yield stream.flush('正在思考中，请耐心等候...');
-        this.logger.info('paddle代码解释耗时统计', {
-            message: `开始执行知识集检索 ${performance.now()}`
-        });
-        let start = performance.now();
-        const knowledge = await this.retriever.knowledgeFromQuery(selectedCode, {
-            knowledgeSets: [
-                // 飞桨API接口文档集
-                {
-                    uuid: '564a9ebb-a3b1-4d5b-ad28-27c0ab6d78fe',
-                    type: 'NORMAL'
-                },
-                // 飞桨框架与生态文档集
-                {
-                    uuid: '7ece94ce-e39a-414e-8ca5-d80ed4cf300b',
-                    type: 'NORMAL'
-                }
-            ],
-            queryRewrite: false
-        });
-        this.logger.info('paddle代码解释耗时统计', {
-            message: `知识集检索结束，耗时${performance.now() - start}ms`
-        });
-        start = performance.now();
-        const trim_knowledge = knowledge;
-        const prompt = this.llm.createPrompt(codeExplainPromptTemplate, {
-            activeFileLanguage,
-            activeFilePath,
-            trim_knowledge,
-            selectedCode
-        });
-        const chunks = this.llm.askForTextStreaming(prompt, {
-            model: TextModel.ErnieBot128,
-            modelOptions: {
-                temperature: 0.3,
-                topP: 0.8,
-                penaltyScore: 1.0,
-                enableMultiturnDialogue: false
-            }
-        });
-        yield stream.flushReplaceLast('');
-        for await (const chunk of chunks){
-            yield stream.flush(chunk);
-        }
-        this.logger.info('paddle代码解释耗时统计', {
-            message: `llm调用结束，耗时${performance.now() - start}ms`
-        });
-    }
-}
-
-class CustomFallbackProvider extends FallbackProvider {
-    static{
-        this.description = '智能解答深度学习与飞桨框架的问题';
-    }
-    async *handleQuery() {
-        try {
-            this.logger.info('paddle智能问答耗时统计', {
-                message: `开始执行智能问答 ${performance.now()}`
-            });
-            const { activeFilePath, selectedCode, activeFileLanguage, query } = this.currentContext;
-            const stream = new StringChunkStream();
-            yield stream.flush('正在思考中，请耐心等候...');
-            const queryWithCode = selectedCode.trim() ? `${query}\n\`\`\`${activeFileLanguage}\n${selectedCode}\n\`\`\`` : query;
-            this.logger.info('paddle智能问答耗时统计', {
-                message: `开始执行知识集检索 ${performance.now()}`
-            });
-            let start = performance.now();
-            const [knowledge1, knowledge2] = await Promise.all([
-                this.retriever.knowledgeFromQuery(queryWithCode, {
-                    knowledgeSets: [
-                        // 飞桨API接口文档集
-                        {
-                            uuid: '564a9ebb-a3b1-4d5b-ad28-27c0ab6d78fe',
-                            type: 'NORMAL'
-                        }
-                    ],
-                    queryRewrite: true,
-                    topK: 7
-                }),
-                this.retriever.knowledgeFromQuery(queryWithCode, {
-                    knowledgeSets: [
-                        // 飞桨框架与生态文档集
-                        {
-                            uuid: '7ece94ce-e39a-414e-8ca5-d80ed4cf300b',
-                            type: 'NORMAL'
-                        }
-                    ],
-                    queryRewrite: true,
-                    topK: 8
-                })
-            ]);
-            this.logger.info('paddle智能问答耗时统计', {
-                message: `知识集检索结束，耗时${performance.now() - start}ms`
-            });
-            start = performance.now();
-            const trim_knowledge = [
-                ...knowledge1,
-                ...knowledge2
-            ];
-            const trim_code = [
-                ''
-            ];
-            const prompt = this.llm.createPrompt(chatPromptTemplate, {
-                activeFilePath,
-                trim_knowledge,
-                trim_code,
-                queryWithCode
-            });
-            const chunks = this.llm.askForTextStreaming(prompt, {
-                model: TextModel.ErnieBot128,
-                modelOptions: {
-                    temperature: 0.3,
-                    topP: 0.8,
-                    penaltyScore: 1.0,
-                    enableMultiturnDialogue: {
-                        byPlugin: true,
-                        onlyQuery: query
-                    }
-                }
-            });
-            // ******************  调试代码，调试时再打开 ***************  /
-            /*
-            yield stream.flush('\n\n---\n\n');
-
-            yield stream.flush(`\n\n共检索到${trim_knowledge.length}条知识：\n\n`);
-            yield stream.flush('---\n\n');
-            const state = {
-                text_length: 0,
-                code_length: 0,
-            };
-            for (const text of trim_knowledge) {
-                yield stream.flush(text.split('\n').map(v => '> ' + v).join('\n'));
-                yield stream.flush('\n\n---\n\n');
-                state.text_length += text.length;
-            }
-            yield stream.flush(`文本总字符长度: ${state.text_length}\n\n`);
-            yield stream.flush('---\n\n');
-
-            yield stream.flush(`\n\n共检索到${trim_code.length}条代码：\n\n`);
-            yield stream.flush('---\n\n');
-            for (const text of trim_code) {
-                yield stream.flush(text.split('\n').map(v => '> ' + v).join('\n'));
-                yield stream.flush('\n\n---\n\n');
-                state.code_length += text.length;
-            }
-            yield stream.flush(`代码总字符长度: ${state.code_length}\n\n`);
-            yield stream.flush('---\n\n');
-
-            yield stream.flush('\n\n以下为 queryWithCode:\n\n');
-            yield stream.flush(`${queryWithCode}`);
-            yield stream.flush('\n\n---');
-            */ // ************************************************************  /
-            yield stream.flushReplaceLast('');
-            for await (const chunk of chunks){
-                yield stream.flush(chunk);
-            }
-            this.logger.info('paddle智能问答耗时统计', {
-                message: `llm调用结束，耗时${performance.now() - start}ms`
-            });
-        } catch (ex) {
-            console.error(ex);
-        }
-    }
-}
-
-function setup({ registry }) {
-    registry.registerSkillProvider('paddle-help', HelpSkillProvider);
-    registry.registerSkillProvider('code-generate', CodeGenerateSkillProvider);
-    registry.registerSkillProvider('code-convert', CodeConvertSkillProvider);
-    registry.registerSkillProvider('code-explain', CodeExplainSkillProvider);
-    registry.registerSkillProvider('chat', ChatSkillProvider);
-    registry.registerFallbackProvider('fallback', CustomFallbackProvider, true);
-}
-
-export { setup };