@lcap/nasl 3.3.0-beta.0 → 3.4.0-alpha.1

package/out/natural/RequirementExecutor.js

@@ -0,0 +1,692 @@
+"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