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

package/src/generator/genReleaseBody.ts

@@ -1,13 +1,32 @@
 import {
   App,
+  Assignment,
+  BatchAssignment,
+  CallFunction,
+  CallInterface,
+  CallLogic,
+  ForEachStatement,
+  IfStatement,
+  Logic,
+  LogicItem,
+  Match,
+  MatchCase,
+  MemberExpression,
   Role,
+  SwitchCase,
+  SwitchStatement,
   View,
   ViewElement,
+  WhileStatement,
+  StringInterpolation,
   Frontend,
+  ExternalDestination,
+  NewComposite,
+  SelectMembers,
+  NewList,
 } from '../concepts';
 import { genFrontendBundleFiles } from './genBundleFiles';
 import { genPermissionData, genLogicAuthFlag } from './permission';
-
 import * as utils from '../utils';
 
 interface ServerValidationData {
@@ -16,6 +35,11 @@ interface ServerValidationData {
   uuid: string;
 }
 
+interface FileData {
+  name: string;
+  content: string;
+}
+
 interface ReleaseData {
   env: string;
   debug: boolean;
@@ -37,178 +61,154 @@ interface ReleaseData {
   frontends: Array<Frontend>;
   validations: InputServerValidationData;
   logPublishFunc: Function;
-  appSpecification?: number;
 }
 
 type InputServerValidationData = { [key in string]: ServerValidationData[] };
 
-async function mergeBodyData(app: App, opt: ReleaseData) {
-  await utils.delay(500);
-  utils.timeline.time('组装初始 Body 数据');
+function getValidationMap(serverData: InputServerValidationData) {
+  const map = new Map<string, ServerValidationData>();
 
-  const authReport: ReturnType<typeof getAuthReport> = getAuthReport(app, opt.frontends);
-  opt.logPublishFunc?.(`[权限] "[${app.title}]" 分析权限数据成功！`);
-  const logicPageResourceDtoList = await genPermissionData(app);
-  const releaseFrontends = app.frontends.map((frontend) => ({
-    name: frontend.name,
-    type: frontend.type,
-    path: frontend.path,
-    selected: opt.frontends.includes(frontend),
-    title: frontend.title,
-  }));
-  const body = {
-    ...authReport, // 如果发布需要上报权限，导出源码不需要
-    logicPageResourceDtoList,
-    logicAuthFlag: genLogicAuthFlag(app),
-    reportIdList: findAllReportIdList(app, opt.frontends),
-    appId: app.id,
-    env: opt.env,
-    replicas: opt.replicas,
-    appSpecification: opt.appSpecification,
-    callbackLogicsName: app.getExtensionsCallbackLogics(),
-    frontends: releaseFrontends,
-    callLogicValidations: {},
-    files: [] as Array<{ name: string; content: string }>,
-  };
-
-  if (logicPageResourceDtoList) {
-    Object.assign(body, { logicPageResourceDtoList });
-  }
+  Object.values(serverData).forEach((logic) => {
+    logic.forEach((item) => {
+      map.set(item.uuid, item);
+    });
+  });
 
-  utils.timeline.timeEnd('组装初始 Body 数据');
-  return body;
+  return map;
 }
 
-async function getCalllogicData(app: App, releaseData: ReleaseData) {
-  function getValidationMap(serverData: InputServerValidationData) {
-      const map = new Map<string, ServerValidationData>();
-      Object.values(serverData).forEach((logic) => {
-        logic.forEach((item) => {
-            map.set(item.uuid, item);
-        });
+function clearValidationMap(serverData: InputServerValidationData) {
+  Object.values(serverData).forEach((logic) => {
+    logic.forEach((item) => {
+      item.rules = [];
+      item.failureRules = [];
     });
-    return map;
-  }
+  });
 
-  function clearValidationMap(serverData: InputServerValidationData) {
-    Object.values(serverData).forEach((logic) => {
-        logic.forEach((item) => {
-            item.rules = [];
-            item.failureRules = [];
-        });
-    });
-    return serverData;
-  }
+  return serverData;
+}
+
+function mergeValidation(serverData: InputServerValidationData, nasl: App) {
+  const map = getValidationMap(serverData);
 
-  function mergeValidation(serverData: InputServerValidationData, nasl: App) {
-    const map = getValidationMap(serverData);
+  if (map.size === 0) {
+    return {};
+  }
 
-    if (map.size === 0) {
-      return {};
+  nasl.traverseChildren((node) => {
+    if (node.concept === 'CallLogic' && 'uuid' in node && node.validation && map.has(node.uuid)) {
+      const data = map.get(node.uuid);
+      const naslRules = node.validation.rules.map((rule) => rule.toJSON());
+      data.rules = [...naslRules, ...data.rules];
     }
+  });
 
-    nasl.traverseChildren((node) => {
-      if (
-          node.concept === 'CallLogic' &&
-          'uuid' in node &&
-          node.validation &&
-          map.has(node.uuid)
-      ) {
-          const data = map.get(node.uuid)!;
-          const naslRules = node.validation.rules.map((rule) => rule.toJSON());
-          data.rules = [...naslRules, ...data.rules];
-      }
-    });
+  return serverData;
+}
 
-    return serverData;
-  }
+/**
+ * 移除密码的验证规则
+ * @description 之后可能移除
+ */
+function removePasswordValidation(serverData: InputServerValidationData, nasl: App) {
+  const validationMap = getValidationMap(serverData);
 
-  /**
-   * 移除密码的验证规则
-   * @description 之后可能移除
-   */
-  function removePasswordValidation(serverData: InputServerValidationData, nasl: App) {
-    const validationMap = getValidationMap(serverData);
+  if (validationMap.size === 0) {
+    return {};
+  }
 
-    if (validationMap.size === 0) {
-      return {};
+  const passwordCallLogicUuid = new Set<string>();
+  const removeRuleNames = [
+    'rangeLength',
+    'pattern',
+    '^az',
+    '^az09',
+    '^az09_',
+    '^azAZ',
+    '^azAZ09',
+    '^azAZ09_',
+    'az09$',
+    'azAZ09$',
+    '^09$',
+    '^az09$',
+    '^az09-$',
+    '^az09-.$',
+    '^azAZ09$',
+    '^azAZ09-$',
+    '^azAZ09_$',
+    '^azAZ09-_$',
+  ];
+
+  // 获取所有调用加密函数的调用节点 uuid
+  nasl.traverseChildren((node) => {
+    if (node.concept !== 'CallLogic' || !('uuid' in node)) {
+      return;
     }
 
-    const passwordCallLogicUuid = new Set<string>();
-    const removeRuleNames = [
-        "rangeLength",
-        "pattern",
-        "^az",
-        "^az09",
-        "^az09_",
-        "^azAZ",
-        "^azAZ09",
-        "^azAZ09_",
-        "az09$",
-        "azAZ09$",
-        "^09$",
-        "^az09$",
-        "^az09-$",
-        "^az09-.$",
-        "^azAZ09$",
-        "^azAZ09-$",
-        "^azAZ09_$",
-        "^azAZ09-_$",
-    ];
-
-    // 获取所有调用加密函数的调用节点 uuid
-    nasl.traverseChildren((node) => {
-      if (node.concept !== 'CallLogic' || !('uuid' in node)) {
-        return;
-      }
-      const calledLogicPath = `${node.calleeNamespace}.${node.calleeName}`;
-
-      if (
-        Boolean(node.uuid) &&
-        (
-          calledLogicPath === 'app.dataSources.defaultDS.entities.LCAPUser.logics.update' ||
-          calledLogicPath === 'app.dataSources.defaultDS.entities.LCAPUser.logics.create' ||
-          calledLogicPath.includes('encrypt')
-        )
-      ) {
-        passwordCallLogicUuid.add(node.uuid);
-      }
-    });
+    const calledLogicPath = `${node.calleeNamespace}.${node.calleeName}`;
 
-    if (passwordCallLogicUuid.size === 0) {
-      return serverData;
+    if (
+      Boolean(node.uuid) &&
+      (calledLogicPath === 'app.dataSources.defaultDS.entities.LCAPUser.logics.update' ||
+        calledLogicPath === 'app.dataSources.defaultDS.entities.LCAPUser.logics.create' ||
+        calledLogicPath.includes('encrypt'))
+    ) {
+      passwordCallLogicUuid.add(node.uuid);
     }
+  });
 
-    passwordCallLogicUuid.forEach((uuid) => {
-      const validation = validationMap.get(uuid);
+  if (passwordCallLogicUuid.size === 0) {
+    return serverData;
+  }
 
-      if (!validation) {
-        return;
-      }
+  passwordCallLogicUuid.forEach((uuid) => {
+    const validation = validationMap.get(uuid);
 
-      for (let i = 0; i < validation.rules.length; i++) {
-        const current = validation.rules[i];
+    if (!validation) {
+      return;
+    }
 
-        if (removeRuleNames.includes((current as any).calleeName)) {
-          validation.rules.splice(i, 1);
-          i--;
-        }
-      }
-    });
+    for (let i = 0; i < validation.rules.length; i++) {
+      const current = validation.rules[i];
 
-    return serverData;
-  }
+      if (removeRuleNames.includes((current as any).calleeName)) {
+        validation.rules.splice(i, 1);
+        i--;
+      }
+    }
+  });
 
-  await utils.delay(500);
+  return serverData;
+}
 
+export async function genReleaseBody(app: App, releaseData: ReleaseData) {
   const {
+    env,
+    debug,
+    replicas,
+    realRelease,
+    appInfo,
+    staticUrl,
+    frontends = [],
     validations = {},
+    logPublishFunc = (): void => undefined,
   } = releaseData;
   const {
-      preferenceMap: {
-          serverValidationRules,
-      },
+    preferenceMap: { serverValidationRules },
   } = app;
+
+  const authReport: ReturnType<typeof getAuthReport> = getAuthReport(app, frontends);
+  logPublishFunc(`[权限] "[${app.title}]" 分析权限数据成功！`);
+  const logicPageResourceDtoList = await genPermissionData(app);
+
+  const releaseFrontends = app.frontends.map((frontend) => ({
+    name: frontend.name,
+    type: frontend.type,
+    path: frontend.path,
+    selected: frontends.includes(frontend),
+    title: frontend.title,
+  }));
+
   const serverValidationRulesBySwitch =
     serverValidationRules === 'custom'
       ? // 自定义
@@ -218,85 +218,69 @@ async function getCalllogicData(app: App, releaseData: ReleaseData) {
         validations
       : // 关闭
         clearValidationMap(validations);
+  const removedPasswordValidation = removePasswordValidation(serverValidationRulesBySwitch, app);
+  const body = {
+    ...authReport, // 如果发布需要上报权限，导出源码不需要
+    logicPageResourceDtoList,
+    logicAuthFlag: genLogicAuthFlag(app),
+    reportIdList: findAllReportIdList(app, frontends),
+    appId: app.id,
+    env,
+    replicas,
+    callbackLogicsName: app.getExtensionsCallbackLogics(),
+    frontends: releaseFrontends,
+    callLogicValidations: removedPasswordValidation,
+    files: [] as Array<{ name: string; content: string }>,
+  };
 
-  return removePasswordValidation(serverValidationRulesBySwitch, app);
-}
-
-async function getNaslAnnotatedJSON(app: App, opt: ReleaseData) {
-  await utils.delay(500);
-
-  utils.timeline.time('获取全量标注');
+  if (logicPageResourceDtoList) {
+    Object.assign(body, { logicPageResourceDtoList });
+  }
 
-  let NaslAnnotatedJSON: any;
+  let NaslAnnotatedJSON;
   try {
     NaslAnnotatedJSON = await (app as any).naslServer.getNaslAnnotatedJSON(app, true);
-    opt.logPublishFunc?.(`[语言] "[${app.title}]" 获取类型标注成功！`);
-
-    // 打印传给服务端的 nasl,为了服务端排查问题方便
-    if (globalThis.window) {
-      console.info(NaslAnnotatedJSON, '标注后的nasl');
-    }
+    logPublishFunc(`[语言] "[${app.title}]" 获取类型标注成功！`);
   } catch (err) {
     console.error(err);
-    throw new Error('代码标注失败，请稍后重试！或刷新后重试！');
-  }
-  // 如果是发布，就排除 views，导出源码就不排除
-  if (opt.realRelease) {
-    NaslAnnotatedJSON.frontends.forEach((frontend: Frontend) => {
-      delete (frontend as any).views;
-    });
+    throw new Error(`代码标注失败，原因是：${err.message}，请稍后重试！或刷新后重试！`);
   }
 
-  utils.timeline.timeEnd('获取全量标注');
-
-  return {
-    name: 'nasl-annotated.json',
-    content: JSON.stringify(NaslAnnotatedJSON),
-  };
-}
-
-async function getFrontendBundleFiles(app: App, opt: ReleaseData) {
-  await utils.delay(500);
-
-  utils.timeline.time('生成页面代码');
-
-  let files: utils.GetPromise<ReturnType<typeof genFrontendBundleFiles>> = [];
-
-  if (opt.frontends && opt.frontends.length) {
-    opt.logPublishFunc?.(`[代码] "[${app.title}]" appApi.staticResourceSync生成页面代码：开始`);
-    files = await genFrontendBundleFiles(app, opt.frontends, {
-      ...opt.appInfo,
-      env: opt.env,
-      debug: opt.debug,
+  // 可能所有的前端都不选
+  let files: FileData[] = [];
+  if (frontends && frontends.length) {
+    logPublishFunc(`[代码] "[${app.title}]" 生成页面代码：开始`);
+    files = genFrontendBundleFiles(app, frontends, {
+      ...appInfo,
+      env,
+      debug,
       appid: app.id,
       devDnsAddr: (app as any).devDnsAddr,
       miniEnable: (app as any).miniEnable,
     } as any);
-
     if (files && files.length === 0) {
       throw new Error('前端代码生成失败');
     }
 
-    if (opt.staticUrl) {
-      files = replaceAssetUrl(files, opt.appInfo.USER_STATIC_URL, opt.staticUrl);
-    }
-
-    opt.logPublishFunc?.(`[代码] "[${app.title}]" 生成页面代码：完成！`);
+    if (staticUrl) files = replaceAssetUrl(files, appInfo.USER_STATIC_URL, staticUrl);
+    logPublishFunc(`[代码] "[${app.title}]" 生成页面代码：完成！`);
   }
 
-  utils.timeline.timeEnd('生成页面代码');
-  return files;
-}
+  // 如果是发布，就排除views，导出源码就不排除
+  if (realRelease) {
+    NaslAnnotatedJSON.frontends.forEach((frontend: Frontend) => {
+      delete frontend.views;
+    });
+  }
+  const jsonString = JSON.stringify(NaslAnnotatedJSON);
 
-export async function genReleaseBody(app: App, opt: ReleaseData) {
-  const body = await mergeBodyData(app, opt);
-  const callLogicValidations = await getCalllogicData(app, opt);
-  const annotationFile = await getNaslAnnotatedJSON(app, opt);
-  const files = await getFrontendBundleFiles(app, opt);
+  // 打印传给服务端的nasl,为了服务端排查问题方便
+  if (globalThis.window) {
+    console.info(NaslAnnotatedJSON, '标注后的nasl');
+  }
 
-  files.push(annotationFile);
+  files.push({ name: 'nasl-annotated.json', content: jsonString });
   body.files = files;
-  body.callLogicValidations = callLogicValidations;
 
   return body;
 }

package/src/index.ts

@@ -10,3 +10,4 @@ export * from './eventBus';
 export * as breakpoint from './breakpoint';
 export { loadApp, loadAppSync, handleApp, batchAction, batchQuery, mountDatabaseTypes } from './service/storage/init';
 export { createService } from './service/creator';
+export * from './natural';

package/src/natural/RequirementAnalyzer.ts

@@ -0,0 +1,208 @@
+import axios from '../service/storage';
+import knowledgeMap from './knowledgeMap';
+
+interface GPTAnalyzerReply {
+    thoughts: {
+        text: string,
+        reasoning: string,
+        plan: string,
+        criticism: string
+    },
+    executable: boolean,
+}
+
+export class RequirementAnalyzer {
+    messages: Array<{ role: 'system' | 'user' | 'assistant', content: string }> = [];
+    requirement: string;
+    context: any;
+
+    genPrompt() {
+        return `
+你是一个专业的低代码平台助手和需求分析师。
+
+现在用户的需求是：
+${this.requirement}
+
+## 示例
+你需要尽可能的帮助用户梳理成可执行的计划，汇总到"thoughts.plan"字段中。计划包含多个任务，每个任务下可能包含多个子任务（会缩进4个空格）。
+如果你认为需求比较明确并且该计划可执行，那么将 executable 设置为 true。
+如果你认为该计划还不完善，将 executable 设置为 false，继续询问用户的问题放入"thoughts.text"字段中。
+
+### 示例1
+当用户的需求非常明确时，你可以直接用 confirm 命令问用户是否确认执行；
+
+比如用户的需求是：“删除一个 Student 实体”，那么你可以生成执行计划：
+- 在默认数据源中，删除一个 Student 实体
+
+### 示例2
+当用户的需求非常明确时，你可以直接用 confirm 命令问用户是否确认执行；
+
+比如用户的需求是：“添加一个任务面板”，你可以分析：
+  面板为一个页面组件，这个组件下没有东西
+那么你可以生成执行计划：
+- 在当前选中节点中，添加一个任务面板组件
+
+### 示例3
+当用户的需求比较明确时，你可以列出你的计划，然后用 confirm 命令问用户是否确认执行；
+
+比如用户的需求是：“添加一个学生实体”，那么你可以生成执行计划：
+
+- 添加一个 Student 实体
+    - 添加一个 name 实体属性
+    - 添加一个 gender 实体属性
+    - 添加一个 age 实体属性
+
+### 示例4
+当用户的需求比较明确时，你可以列出你的计划，然后用 confirm 命令问用户是否确认执行；
+
+比如用户的需求是：“添加一个学生实体，以及添加一组管理页面”，那么你可以生成执行计划：
+
+- 添加一个 Student 实体
+    - 添加一个 name 实体属性
+    - 添加一个 gender 实体属性
+    - 添加一个 age 实体属性
+- 根据 Student 实体，在 dashboard 页面下，添加一组增删改查的管理页面
+
+### 示例5
+如果用户的需求是搭建xxx系统，一般是分解成两个任务：添加相关实体，然后再添加各实体的管理页面。
+
+比如用户的需求是：“我要搭建一个学生管理系统”，那么你可以生成执行计划：
+
+- 添加一个 Student 实体
+    - （你可以补充）
+- 添加一个 Teacher 实体
+    - （你可以补充）
+- 根据 Student 实体，在 dashboard 页面下，添加一组增删改查的管理页面
+- 根据 Teacher 实体，在 dashboard 页面下，添加一组增删改查的管理页面
+
+### 示例6
+
+当用户想要替换组件时，对应两步操作：替换组件+绑定变量到新组件；参考以下两个例子：
+
+- 比如用户的需求是 '将组件替换为五星评分组件'，那么你可以生成计划
+  - 将选中的组件替换为五星评分组件
+  - 将评分值绑定当前项的等级变量
+- 比如用户的需求是 '当前选中替换为标签，...'，那么你可以生成计划
+  - 将选中的组件替换为标签组件
+    - 设置文本值为变量 supplier.status 转换的 text
+    - 设置背景颜色为启用时绿色、禁用时灰色
+    - 设置字体颜色为启用时白色、禁用时黑色
+
+### 示例7
+
+当用户想要新增按钮组件时，按钮组件分为主要按钮和图标按钮，明确用户想要添加的是哪一种：
+- 主要按钮只设置文本
+- 图标按钮可设置图标+文本，也可仅设置图标
+  - 导出图标名称为 upload
+
+例如：
+- 用户需求为'添加一个按钮，图标为刷新，点击后刷新表格', 那么你可以生成计划
+  - 在当前选中组件中，添加一个纯图标按钮组件
+    - 设置图标为刷新
+  - 为按钮添加点击事件
+    - 在点击事件中，执行刷新表格 tabView 的操作
+- 用户需求为'添加一个按钮，按钮文本为“导出 excel”，并加一个图标。点击后能将表格导出 excel'，那么你可以生成计划
+  - 在选中的组件中添加一个按钮组件
+    - 设置按钮图标为 upload
+    - 设置按钮文本为 '导出 excel'
+  - 为按钮添加点击事件
+    - 调用 tabView 的导出 excel 方法
+
+${knowledgeMap.index}
+
+- 当前低代码平台暂时不支持实体之间的关联关系，不需要询问或处理关联关系的事情。
+- 添加一组增删改查的管理页面作为一个任务，不需要展开子任务。
+- 你需要将plan尽可能的概括，使用'总分'的格式，不要破坏任务的连贯性
+- 替换组件和绑定变量的操作需要分步执行
+- 涉及到组件替换、属性、逻辑的操作，直接执行即可
+
+## 用户上下文
+
+${this.context.selectedNode ? '用户选中了一个 name 为' + this.context.selectedNode.name + '的 ' + this.context.selectedNode.concept : '用户未选择任何节点'}
+
+## 注意
+
+1. 尽量帮用户想象一些细节，再问用户是否确认执行
+1. 在后续的所有回答中，你必须按照 以下指定的JSON 格式回复！格式如下：
+
+{
+    "thoughts": {
+        "text": "thought",
+        "reasoning": "reasoning",
+        "plan": "- 任务1\\n- 任务2\\n    - 子任务1\\n    - 子任务2\\n    - 子任务3\\n- 任务3",
+        "criticism": "constructive self-criticism"
+    },
+    "executable": true
+}
+
+## 要求
+1. 按照上述格式，内容用中文作答，把你想问用户的内容以问题的形式放在"thoughts.text"字段中
+2. 当用户已经选中了一个 View 时，默认用户决定在选中的 View 操作，不要再询问用户要在哪个页面操作！
+3. 确保你回复的整体内容可以被 JavaScript 的 JSON.parse 解析！
+`;
+    }
+
+    async chatWithGPT() {
+        const res = await axios.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 {
+            return JSON.stringify({ status: 'error' });
+        }
+    }
+
+    async chatWithGPTAndParseJSON() {
+        const answer = await this.chatWithGPT();
+        const json: GPTAnalyzerReply = JSON.parse(answer);
+        console.log('需求分析器-回复：' + JSON.stringify(json, null, 4));
+        return json;
+    }
+
+    async next(input: string | boolean) {
+        if (!this.messages.length) {
+            const prompt = this.genPrompt();
+            console.log(prompt);
+            this.messages = [{
+                role: 'system',
+                content: prompt,
+            }];
+        } else if (typeof input === 'string') {
+            this.messages.push({
+                role: 'user',
+                content: input,
+            });
+        } else {
+            throw new Error();
+        }
+
+        return this.chatWithGPTAndParseJSON();
+    }
+}
+
+export default RequirementAnalyzer;
+
+// 你可以使用的命令，无需参数
+// 1. 询问：'ask'
+// 2. 确认是否要执行：'confirm'，
+
+// ### 示例四
+
+// 当用户的需求不明确时，你可以大致列出你不完善的计划，将 executable 设置为 false。
+
+// 比如用户的需求是：“我要一个实体”，那么你可以生成执行计划：
+
+// - 添加一个客户实体
+// - 添加一组客户的增删改查的管理页面
+
+// 以及如下问题
+// - 只需要添加一个客户实体吗？
+// - 客户管理页面需要添加在哪个页面下？