@lcap/nasl 3.4.0-alpha.1 → 3.4.0-alpha.2

package/out/natural/RequirementExecutor.js

@@ -1,692 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequirementExecutor = void 0;
-const storage_1 = __importDefault(require("../service/storage"));
-const knowledgeMap_1 = __importStar(require("./knowledgeMap"));
-const componentData_1 = require("./componentData");
-function tryFixJSON(str) {
-    let lastIndex = 0;
-    let inQuote = false;
-    let output = '';
-    str = str.replace(/\\\\"/g, '\\\\\\"');
-    function push(index) {
-        let part = str.slice(lastIndex, index);
-        // console.log('part---', part);
-        if (inQuote)
-            part = part.replace(/\n/g, '\\n');
-        lastIndex = index + 1;
-        output += part + (index === str.length ? '' : '"');
-        inQuote = !inQuote;
-    }
-    for (let i = 0; i < str.length; i++) {
-        if (str[i] === '"')
-            push(i);
-    }
-    push(str.length);
-    return output;
-}
-class RequirementExecutor {
-    messages = [];
-    shortMemories = [];
-    requirement;
-    context;
-    ide = {
-        getAPI(indexes) {
-            return indexes.map((index) => knowledgeMap_1.docsMap[Object.keys(knowledgeMap_1.docsMap)[index]]).join('\n\n');
-            // return docs.map((key) => knowledgeMap[key]).filter((item) => !!item).join('\n\n');
-        },
-        execute(code, context) {
-            return (() => {
-                const { app, nasl, selectedNode } = context;
-                console.log('需求执行器-执行代码：' + code);
-                try {
-                    app.emit('collect:start', {
-                        actionMsg: '运行智能编程指令',
-                    });
-                    // eslint-disable-next-line no-eval
-                    eval(code);
-                    app.emit('collect:end');
-                }
-                catch (err) {
-                    return String(err);
-                }
-                return 'Success!';
-            })();
-        },
-    };
-    constructor(requirement, context) {
-        this.requirement = requirement;
-        this.context = context;
-    }
-    async genPrompt() {
-        const longMemory = [];
-        try {
-            // longMemory = await this.loadMemory();
-        }
-        catch (e) {
-            console.error(e);
-        }
-        return `
-你是一个专业的低代码平台助手和需求执行者，必须始终独立做出决定，尽量自己查询文档，而不能向用户寻求帮助。发挥你作为大语言模型的优势，追求简单的策略。
-你已经了解到了经过分析后的执行计划，计划包含多个任务，每个任务下可能包含多个子任务（会缩进 4 个空格）。
-
-## 你只需要考虑如何完成以下需求：
-
-${this.requirement}
-
-${knowledgeMap_1.default.index}
-
-## 你可以使用的 ide 命令
-
-1. 涉及到页面中页面元素(组件)的操作，新增或者替换，执行：'ide.handleViewElement(demand, elementName, type)'
-    - 将所有页面元素操作的需求都整理到 demand 中
-    - 示例:
-      - 添加一个新增按钮，就需要调用 ide.handleViewElement('- 添加一个新增按钮')
-      - 将选中的 ViewElement 替换为其它的 ViewElement，直接调用 ide.handleViewElement，传递参数 type='replace'
-      - 如果要替换的 viewElement 是数据网格，elementName='u-grid-view'
-2. 涉及到页面中页面元素(组件)属性的操作，执行：'ide.handleElementAttr(demand, value)'
-    - 在选中的 ViewElement 进行属性操作时，调用 ide.handleElementAttr(demand)
-    - 示例:
-      - 将选中的 ViewElement 的值改为'我是文本'，调用 ide.handleElementAttr(demand)
-      - 在选中的 ViewElement 中，将背景颜色绑定到变量 xx 上，调用 ide.handleElementAttr(demand)
-3. 涉及到逻辑的操作时，执行：'ide.handleLogic(logicName, logicDemand, viewName, type)'
-    - 涉及到逻辑项的操作时，将所有逻辑项需求都整理到 logicDemand 中，尽可能在一步操作中执行所有的 logicDemand
-    - 如果当前选中的是 ViewElement，还需要传递 type='bindEvents'，尽可能在一步操作中执行所有的 logicDemand
-    - 示例:
-      - 在逻辑中添加逻辑项，比如说添加一个 if 语句，就调用 ide.handleLogic 命令执行，在调用 ide.handleLogic 时
-      - 为选中的 ViewElement 添加点击事件逻辑并实现逻辑功能，调用 ide.handleLogic 命令执行，并传递 type='bindEvents'
-4. 查询 API 文档：'ide.getAPI(indexes: Array<number>)'，如'ide.getAPI([0, 1, 2])'
-    - 当前面的命令无法匹配用户需求时，你可以查询 API 文档，尽可能一次性多的获取相关文档
-    - 如果要添加实体属性，需要考虑类型，请加入查询：类型标注相关文档
-    - 如果要了解默认数据源在哪里，请加入查询：应用和默认数据库相关文档
-    - 当需求中需要考虑类型时，请加入查询：类型标注文档。
-5. 执行 IDE 的操作，其中代码为 JS 脚本：'ide.execute(code: string)'
-6. 当完成计划时：command name 及 args 为 'ide.complete(reason: string)'
-    1. 优先执行以上命令，对比原始需求和解决当前需求的短期记忆，如果已经完成原始需求的执行，调用 ide.complete 命令
-
-## 目前 API 文档目录
-
-${Object.keys(knowledgeMap_1.docsMap).map((key, index) => `${index}. ${key}`).join('\n')}
-
-### 限制
-
-- 由于 8000 左右 token 数的限制，一次处理多个任务、查询多个文档容易溢出，建议一次只处理一个任务。
-- 在记忆中已经查询过的文档不要再去查询了。
-- 你只能使用已列举出的 ide 中的命令
-- ide 下的命令需串行执行，不能嵌套
-  - 将 ide.execute 和 ide.handleLogic 分别执行，不要在 ide.execute 中执行 ide.handleLogic 或者 handleLogic 方法以及其他 ide 的命令!
-  - 替换组件和绑定变量的操作需要分开执行，依次调用 ide.handleViewElement 和 ide.handleElementAttr
-  - 涉及到逻辑的操作，整理逻辑相关的所有需求，调用 ide.handleLogic，在一次命令调用中执行完所有的需求
-    - 例如: 为已存在的 ViewElement 添加点击事件并实现事件逻辑，直接执行 ide.handleLogic、传入参数 type='bindEvents' 即可
-- 所有命令传参的值必须匹配正则: /^[a-zA-Z0-9_]+$/，如 viewName、logicName 等
-
-## 你解决当前需求的短期记忆
-
-${this.shortMemories.slice(-9).map((memory, index) => `
-
-### 你的思考和命令${index}
-
-${JSON.stringify(memory.reply, null, 4)}
-
-### 结果${index}
-
-${memory.result}
-`).join('\n') || '暂无'}
-
-## 你曾经解决需求的长期记忆
-
-${(longMemory.join('\n')) || '暂无'}
-
-## 资源
-
-- 短期和长期的记忆管理
-- GPT-4
-
-## 要求
-
-1. 在后续的所有回答中，你必须以 JSON 格式回复，内容用中文作答，格式如下：
-
-{
-  "thoughts": {
-    "text": "thought",
-    "reasoning": "reasoning",
-    "criticism": "我生成的这段代码，可能在 API 中没有定义",
-    "currentTask": "- 任务 2\\n - 子任务 1\\n - 子任务 2\\n - 子任务 3"
-  },
-  "command": {
-    "name": "command name",
-    "args": {
-      "code": "value",
-      "logicDemand": "- 子任务 1\\n - 子任务 2\\n - 子任务 3"
-    }
-  }
-}
-
-1. 按照上述格式，内容用中文作答，把你的思考放在"thoughts.text"字段中
-2. 确保回复可以被 JavaScript 的 JSON.parse 解析！
-`;
-    }
-    async chatWithGPT() {
-        const res = await storage_1.default.post('/api/gpt/chatGPT', {
-            messages: this.messages,
-        });
-        const result = res.data.result;
-        if (result) {
-            const answer = result.choices[0]?.message.content.trim() + '\n';
-            // this.messages.push({
-            //     role: 'assistant',
-            //     content: answer,
-            // });
-            console.log(result.usage);
-            return answer;
-        }
-        else {
-            console.error(res.data);
-            throw new Error(res.data);
-        }
-    }
-    async saveMemory(memory) {
-        const res = await storage_1.default.post('/api/memory/saveMemory', `
-### 你的思考和命令
-${JSON.stringify(memory.reply, null, 4)}
-
-### 结果
-${memory.result}
-`);
-        const data = res.data;
-        if (data.code === 200) {
-            //
-        }
-        else {
-            console.error(res.data);
-            throw new Error(res.data);
-        }
-    }
-    async loadMemory() {
-        const res = await storage_1.default.post('/api/memory/loadMemory', {
-            text: `### 你的需求
-${this.requirement}
-` + this.shortMemories.slice(-9).map((memory, index) => `
-### 你的思考和命令${index}
-${JSON.stringify(memory.reply, null, 4)}
-
-### 结果${index}
-${memory.result}
-`).join('\n'),
-            k: 5,
-        });
-        const data = res.data;
-        if (data.code === 200) {
-            const result = data.result;
-            return result;
-        }
-        else {
-            console.error(res.data);
-            throw new Error(res.data);
-        }
-    }
-    async chatWithGPTAndParseJSON() {
-        const answer = await this.chatWithGPT();
-        let json;
-        try {
-            json = JSON.parse(answer);
-            console.log('需求执行器-回复：' + JSON.stringify(json, null, 4));
-            return json;
-        }
-        catch (e) {
-            const fixed = tryFixJSON(answer);
-            try {
-                json = JSON.parse(fixed);
-                console.log('需求执行器-回复：' + JSON.stringify(json, null, 4));
-                return json;
-            }
-            catch (ee) {
-                console.log(fixed);
-                throw e;
-            }
-        }
-    }
-    async next() {
-        this.messages = [{
-                role: 'system',
-                content: await this.genPrompt(),
-            }];
-        if (!this.shortMemories.length)
-            console.log(this.messages[0].content);
-        return this.chatWithGPTAndParseJSON();
-    }
-    async execute(context, cb) {
-        const reply = await this.next();
-        cb && cb(reply);
-        if (this.shortMemories.length > 10) {
-            throw new Error('执行超过10次，可能存在问题！');
-        }
-        else if (reply.command.name === 'ide.complete') {
-            //
-        }
-        else {
-            let result;
-            if (reply.command.name === 'ide.getAPI')
-                result = this.ide.getAPI(reply.command.args.indexes);
-            else if (reply.command.name === 'ide.execute')
-                result = this.ide.execute(reply.command.args.code, context);
-            else if (reply.command.name === 'ide.handleLogic')
-                result = await this.handleLogic({ ...reply.command.args, context });
-            else if (reply.command.name === 'ide.handleViewElement')
-                result = await this.handleViewElement({ ...reply.command.args, context });
-            else if (reply.command.name === 'ide.handleElementAttr')
-                result = await this.handleElementAttr({ ...reply.command.args, context });
-            console.log('需求执行器-执行结果：' + result);
-            const memory = { requirement: this.requirement, reply, result };
-            this.shortMemories.push(memory);
-            // this.shortMemories = this.shortMemories.slice(-2);
-            // const lastMemory = this.shortMemories[this.shortMemories.length - 1];
-            if (reply.command.name === 'ide.execute') {
-                try {
-                    await this.saveMemory(memory);
-                }
-                catch (e) { }
-                // if (result === 'Success!' && reply.thoughts.currentTaskIndex === reply.thoughts.totalTaskCount) {
-                //     return;
-                // }
-            }
-            // 重复执行
-            await this.execute(context, cb);
-        }
-    }
-    async handleLogic(logicParams) {
-        const { logicDemand, context, type } = logicParams;
-        let { app, nasl, selectedNode } = context;
-        const Window = window;
-        selectedNode = Window.globalData.$n0;
-        const requirements = [
-            '如果要查询，则使用 nasl.oql.query，尽量用一句 SQL 包含更多信息',
-            '优先使用 nasl.util 中的内置函数',
-            '禁止使用 Array 的方法，其中 map 方法请使用 ListTransform',
-            '禁止使用 Number 的 toFixed 方法，保留小数使用 FormatNumber',
-            '禁止使用 String 的 方法，字符串截取用 SubString 函数',
-            '当前日期请使用 CurrDateTime()',
-            // '声明过的变量已经初始化',
-            '分支情况请使用 switch',
-            '数字循环请使用 while',
-            '禁止使用 import',
-            '禁止打印结果日志',
-            '直接输出代码结果，其他描述请以注释的形式出现',
-            '返回的实现须为函数并且必须使用符合语法的语句',
-        ];
-        let logicItem;
-        console.log('lemon ~ selectedNode:', selectedNode);
-        if (selectedNode.concept === 'Logic') {
-            logicItem = selectedNode;
-        }
-        else if (selectedNode.concept === 'ViewElement' && type === 'bindEvents') {
-            logicItem = selectedNode.addBindEvent('click').addLogic('click');
-        }
-        const getRequirement = () => `/*
-有以下要求：
-${requirements.map((line) => '- ' + line).join('\n')}
-
-请在当前函数的“当前位置”中只要实现：
-${logicDemand}
-
-## 返回示例1
-// 筛选商品
-function load1(params: nasl.ui.DataSourceParams) {
-  result.list = nasl.util.ListFilter(result.list, (item) => item.product.supplierId === id);
-  // 不要 return
-}
-## 返回示例2
-// 校验表单输入
-function formValidate() {
-  const validateResult: ValidateEvent = $refs.form1.validate();
-  if (validateResult.valid) {
-      const newProduct = product;
-      newProduct.suppilerId = id;
-      ProductEntity.create(newProduct);
-      nasl.ui.showMessage("创建成功");
-      $refs.modal1.close();
-      $refs.gridView.reload();
-  } else{
-    nasl.ui.showMessage("创建失败");
-  }
-}
-*/`;
-        console.log('lemon', logicItem);
-        let prompt = nasl.genNaturalTS(app, logicItem);
-        prompt += getRequirement();
-        this.messages = [{
-                role: 'user',
-                content: prompt,
-            }];
-        const res = await storage_1.default.post('/api/gpt/chatGPT', {
-            messages: this.messages,
-        });
-        const result = res.data.result;
-        if (result) {
-            const answer = result.choices[0]?.message.content.trim() + '\n';
-            try {
-                await nasl.transformTSCodeEx(answer, logicItem, context);
-                return 'Success!';
-            }
-            catch (e) {
-                console.log('TS 转换 NASL 失败！请检查浏览器日志。');
-                return String(e);
-            }
-        }
-        else {
-            return String(res.data);
-        }
-    }
-    // 处理页面上对于元素的操作
-    async handleViewElement(elementParams) {
-        const { demand, context, viewName, elementName = 'uLinearLayout1', type } = elementParams;
-        let { app, nasl, selectedNode } = context;
-        if (type === 'bindEvents') {
-            const result = await this.handleLogic({ context, type, logicDemand: demand });
-            return result;
-        }
-        if (type === 'replace') {
-            selectedNode.delete();
-            selectedNode = selectedNode.parentNode;
-        }
-        if (elementParams.elementName === 'u-grid-view') {
-            selectedNode.addGridViewByEntity('Product');
-            return 'Success';
-        }
-        let templateList;
-        try {
-            templateList = await this.getViewElementTemplate(demand, context);
-            if (templateList.length <= 0)
-                throw new Error('请求失败');
-            console.log('lemon ~ templateList:', templateList);
-            try {
-                const codeList = await this.handleViewElementTemplate(demand, templateList, context);
-                console.log('lemon ~ codeList:', codeList);
-                let nodePath;
-                if (viewName && app.findViewByName(viewName)) {
-                    nodePath = app.findViewByName(viewName).findElementByName(elementName).nodePath;
-                }
-                else if (selectedNode.concept === 'View') {
-                    nodePath = selectedNode.findElementByName(elementName).nodePath;
-                }
-                else if (selectedNode.concept === 'ViewElement') {
-                    nodePath = selectedNode.nodePath;
-                }
-                else {
-                    return 'error';
-                }
-                const position = 'append';
-                codeList.forEach((code) => {
-                    const data = {
-                        code,
-                        nodePath,
-                        position, // 没有时会添加到最顶层
-                    };
-                    selectedNode.addBlock(data);
-                });
-                console.log('lemon', selectedNode);
-                return 'Success!';
-            }
-            catch (e) {
-                return String(e);
-            }
-        }
-        catch (e) {
-            return String(e);
-        }
-    }
-    // 根据用户需求获取到对应的组件 code
-    async getViewElementTemplate(demand, context) {
-        this.messages = [{
-                role: 'user',
-                content: this.getViewPrompt(demand),
-            }];
-        const res = await storage_1.default.post('/api/gpt/chatGPT', {
-            messages: this.messages,
-        });
-        const result = res.data.result;
-        if (result) {
-            const answer = result.choices[0]?.message.content.trim() + '\n';
-            const elementList = Object.keys(JSON.parse(answer));
-            console.log('lemon getViewElementTemplate', elementList, answer);
-            const templateList = elementList.map((el) => {
-                const ind = JSON.parse(answer)[el].index;
-                const code = context.nasl.config.allNodesAPI[el]?.blocks[ind]?.code;
-                if (!code)
-                    throw new Error('组件名称错误，获取组件模板失败, 请重试');
-                return code;
-            });
-            return templateList;
-        }
-    }
-    getViewPrompt(demand) {
-        return `
-        ## 组件定义如下:
-        ${JSON.stringify(componentData_1.componentData)}
-
-        ## 用户的需求如下:
-        ${demand}
-
-        ## 注意:
-        1. 你需要根据用户的需求参照组件定义获取到对应的组件名称，除了i-ico之外，其它组件都是 'u-' 的格式
-        1. 必须按照下面指定的格式的格式返回，确保回复可以被 JavaScript 的 JSON.parse 解析！
-
-        { "componentName": { "reason": "原因", index: "模板索引" } }
-
-        ## 示例:
-        { "i-ico": { "reason": "用于展示刷新图标和文本", "index": 1 } }
-        { "u-rate": { "reason": "用于替换文本组件为五星评分组件", "index": 0 } }
-        { "u-button": { "reason": "用于添加一个图标按钮组件", "index": 3 } }
-        `;
-    }
-    // 再次处理组件模板，得到与需求融合后的组件模板
-    async handleViewElementTemplate(demand, templateList, context) {
-        const prompt = `
-      ## 组件的 template 如下
-      ${JSON.stringify(templateList)}
-
-      ## 用户的需求如下
-      ${demand}
-
-      ## 注意
-      1. 请根据需求，在 template 基础上仅替换默认文字信息，但是不要修改标签名称
-      1. 仅可以使用template中提供的标签名称，不能修改
-        - 例如 不能修改标签组件名称 <u-grid-view>
-      1. 按照提供的原 template 格式返回新的 template!
-      eg:
-      "[新的template]"
-      `;
-        this.messages = [{
-                role: 'user',
-                content: prompt,
-            }];
-        const res = await storage_1.default.post('/api/gpt/chatGPT', {
-            messages: this.messages,
-        });
-        const result = res.data.result;
-        if (result) {
-            const answer = result.choices[0]?.message.content.trim() + '\n';
-            const codeList = JSON.parse(answer);
-            return codeList;
-        }
-    }
-    async handleElementAttr(elementParams) {
-        const { demand, context } = elementParams;
-        const { app, nasl, selectedNode } = context;
-        try {
-            const options = await this.getCorrectParams(demand, selectedNode);
-            console.log('lemonhandle-getCorrectParams-传入的option', options);
-            try {
-                for (let i = 0; i < options.length; i++) {
-                    let option = options[i];
-                    option = {
-                        ...option,
-                        // eslint-disable-next-line no-await-in-loop
-                        value: option.type === 'dynamic' ? await this.getExpression(option.demand, context) : option.value,
-                    };
-                    console.log('lemonhandle-最终拿到的option', option);
-                    try {
-                        selectedNode.updateBindAttr(option);
-                    }
-                    catch (e) {
-                        return String(e);
-                    }
-                }
-                return 'Success';
-            }
-            catch (e) {
-                return String(e);
-            }
-        }
-        catch (e) {
-            return String(e);
-        }
-    }
-    async getCorrectParams(demand, selectedNode) {
-        const curAttrGroups = selectedNode.getCurrentElementAttrGroups();
-        const prompt = `
-        ## 组件的所有属性定义如下
-        ${JSON.stringify(curAttrGroups)}
-
-        ## 用户的需求如下
-        ${demand}
-
-        ## 注意
-        1. 请根据需求结合属性定义，分析并返回用户想要修改属性的 name、value，以及所属的 concept
-        2. 如果涉及到表达式或者绑定或者动态的值时，type的值为'dynamic'
-        3. 按照以下格式返回数据，确保回复可以被 JavaScript 的 JSON.parse 解析！
-
-        [{ concept, type, name, value, demand }]
-        `;
-        this.messages = [{
-                role: 'user',
-                content: prompt,
-            }];
-        const res = await storage_1.default.post('/api/gpt/chatGPT', {
-            messages: this.messages,
-        });
-        const result = res.data.result;
-        if (result) {
-            const answer = result.choices[0]?.message.content.trim() + '\n';
-            return JSON.parse(answer);
-        }
-    }
-    async getExpression(demand, context) {
-        const { app, nasl, selectedNode } = context;
-        const requirements = [
-            '如果要查询，则使用 nasl.oql.query，尽量用一句 SQL 包含更多信息',
-            '优先使用 nasl.util 中的内置函数',
-            '禁止使用 Array 的方法，其中 map 方法请使用 ListTransform',
-            '禁止使用 Number 的 toFixed 方法，保留小数使用 FormatNumber',
-            '禁止使用 String 的 方法，字符串截取用 SubString 函数',
-            '当前日期请使用 CurrDateTime()',
-            '分支情况请使用 switch',
-            '禁止使用 import',
-            '禁止打印结果日志',
-            '不要新建变量',
-            '涉及到颜色转换为 HEX 格式的值',
-            '直接输出代码结果，其他描述请以注释的形式出现',
-            '回复必须是函数并且必须使用符合语法的语句',
-        ];
-        const getRequirement = () => `/*
-## 有以下要求：
-${requirements.map((line) => '- ' + line).join('\n')}
-
-## 返回示例 1
-export function logic2() {
-  return nasl.util.FormatDateTime(variable1, "YYYY-MM-DD HH:mm");
-}
-## 返回示例 2
-export function setBackgroundColor(): string {
-  switch (varibable) {
-      case SupplierStatusEnum.enable:
-          return "#0f0";
-      case SupplierStatusEnum.disable:
-          return "#7f827f";
-  }
-}
-## 返回示例 3
-export function bindLevel() {
-  return current.item.supplier.level;
-}
-
-## 请在当前函数的“当前位置”中只要实现：
-${demand}
-*/`;
-        let prompt = nasl.genNaturalTS(app, selectedNode);
-        prompt += getRequirement();
-        this.messages = [{
-                role: 'user',
-                content: prompt,
-            }];
-        const res = await storage_1.default.post('/api/gpt/chatGPT', {
-            messages: this.messages,
-        });
-        const result = res.data.result;
-        if (result) {
-            const answer = result.choices[0]?.message.content.trim() + '\n';
-            console.log('lemon ~ getExpression ~ answer:', answer);
-            try {
-                const body = nasl.transformTSCodeToExpression(answer, context);
-                console.log('lemon ~ RequirementExecutor ~ getExpression ~ body:', body);
-                return body[0];
-            }
-            catch (e) {
-                console.log('TS 转换 NASL 失败！请检查浏览器日志。');
-                return String(e);
-            }
-        }
-    }
-}
-exports.RequirementExecutor = RequirementExecutor;
-exports.default = RequirementExecutor;
-// console.log(tryFixJSON(`{
-//     {
-//         "thoughts": {
-//             "text": "thought",
-//             "reasoning": "reasoning",
-//             "currentTask": "- 任务1
-//     - 任务2
-//     - 任务3",
-//             "criticism": "我生成的这段代码，可能在 API 中没有定义"
-//         },
-//         "command": {
-//             "name": "command name",
-//             "args": {
-//                 "code": "value"
-//             }
-//         }
-//     }
-// }`));
-// - 对于不清楚定义的 API，先不要急着生成执行脚本，考虑是不是要先获取一下 API 文档，然后在后面的步骤中再生成执行脚本
-// - 一般初次执行时，你最好先获取需要的 API 文档。尽可能一次性多的获取相关文档
-// 2. 把当前执行的任务放在"thoughts.currentTask"中，把当前执行的任务的索引（从1开始）放在"thoughts.currentTaskIndex"中
-// "currentTaskIndex": 2,
-// "totalTaskCount": 3,
-//# sourceMappingURL=RequirementExecutor.js.map