bytefun-ai-mcp 1.13.98 → 1.13.99

package/build/appCodeRule.js

@@ -0,0 +1,288 @@
+export const understandingCodeFrameworkTemplate = `
+# **必须先理解项目代码框架11个知识点**
+## 1. **理解View组件的声明规则**
+  - 这不是html、react等开发，这是一个新的开发框架，是基于src/lib/uilib文件夹里面的UI组件库来开发的
+  - View组件的基类是BaseView，容器基类是BaseContainerView，所有View组件都继承自BaseView
+  - 查看'src/lib/uilib/'文件夹下面的文件名字，理解总共有多少种UI组件
+  - View组件的声明必须在类文件开始时先声明，并且必须要声明具体的View组件类型，不得声明为BaseView，不得在任何函数体里面通过findViewById来声明View组件，比如：
+    - ✅ 正确的写法：
+    \`\`\`typescript
+    public class HomePage extends Page {
+      private nameTextView: TextView = this.findViewById('nameTextView') as TextView
+      ....
+    }
+    \`\`\`
+    - ❌ 错误的写法（没有声具体的View组件类型）：
+    \`\`\`typescript
+    private nameTextView = this.findViewById('nameTextView')
+    \`\`\`
+    - ❌ 错误的写法（在函数体里面通过findViewById来声明View组件）：
+    \`\`\`typescript
+    private oneFunction() {
+      const nameTextView: TextView = this.findViewById('nameTextView') as TextView
+      ....
+    }
+    \`\`\`
+  - 所有View组件的选中状态、聚焦状态、禁用状态的变化都必须通过\`setStation(station: ViewStation)\`函数来设置，不能直接设置组件的UI属性，只需要设置组件的station属性即可自动更新组件的UI样式
+  - 所有View组件的显示、隐藏占位、隐藏不占位的设置都必须使用View的\`visibility\`属性进行设置，不得使用\`station\`属性。
+  - 所有View组件的normal、readOnly、focus、selected、disabled状态的设置都必须使用View的\`station\`属性进行设置。
+
+## 2. **理解唯一的能力方法AllFunction.ts以及json相关代码**
+  - 使用'read_file'工具阅读并理解'src/lib/AllFunction.ts'文件，理解该工程能使用的唯一的能力方法
+  - 请严格按照唯一的能力方法AllFunction.ts，不要新增、删除或修改任何AllFunction接口声明；也不要调用其他未在AllFunction中出现的函数或模块
+  
+## 3. **理解Ref、watch**
+  - Ref的数据类型只能是以下5中类型：数字使用Ref<number>，字符串使用Ref<string>，布尔量使用Ref<boolean>，对象使用Ref<any>，数组使用Ref<Array<any>>或Ref<Array<any> | null>或Ref<any[]>或Ref<any[] | null>。
+  - 使用'read_file'工具阅读并理解'src/lib/Ref.ts'文件，理解Ref和watch的定义用法
+  - watch是监听Ref的变化，然后做相关UI更新或其他业务逻辑，第一个参数是监听的Ref数组，第二个参数是监听的回调函数，回调函数中可以做相关UI更新或其他业务逻辑。
+  - Ref是响应式数据源，watch是监听Ref的变化，然后做相关UI更新或其他业务逻辑，比如：
+  \`\`\`typescript
+  private nameTextRef: Ref<string> = ref('')
+  private otherCountRef: Ref<number> = ref(0)
+  watch([this.nameTextRef, this.otherCountRef], () => {
+    // 可以先相关的UI更新或业务逻辑
+    if (this.otherCountRef.value > 5) {
+      this.nameTextView.text = this.nameTextRef.value + '5'
+     } else {
+      this.nameTextView.text = this.nameTextRef.value + '10'
+    }
+  })
+  \`\`\`
+  - \`src/lib/uilib/Ref.ts\`里面的\`watch\`函数，第一个入参\`refs: Ref<T>[]\`绝对禁止先声明局ref数组部变量再传入，正确的写法应该是直接写数组：\`[ref1, ref2]\`就行
+  - ❌ 错误的写法：
+    \`\`\` typescript
+    const refArray = [ref1, ref2]
+    watch(refArray, (newValues: T[]) => {
+        // 监听ref1和ref2的变化
+    })
+    \`\`\`
+  - ✅ 正确的写法：
+    \`\`\` typescript
+    watch([ref1, ref2], (newValues: T[]) => {
+        // 监听ref1和ref2的变化
+    })
+    \`\`\`
+
+## 4. **理解setDataList方法的静态数据与动态数据场景**
+  - 对于动态数据容器ViewPager、ListView的setDataList方法，如果数据是动态的，比如：从后端接口获取的，才能使用setDataList方法来设置数据。静态数据已经在UI页面上写好了，你不得使用setDataList方法来设置数据。
+  - 判断标准：如果UI页面中已经有完整的轮播项目/列表项目，就是静态数据，如果是网络API返回的数据列表就是动态数据。
+  - ✅ 静态数据容器（UI页面中已写好内容）：不使用setDataList()
+  - ✅ 动态数据容器（需要从API获取）：才使用setDataList()
+
+## 5. **View组件，理解每个组件可能里面已经有了响应式数据源，如果组件里面已经有了响应式数据源，那么你不得再自己创建ref变量或者使用onSelectChange等回调触发UI更新**
+  - 例子：ViewPager的currentSelectIndex和currentSelectIndexRef属性已经是响应式数据源，可以直接使用currentSelectIndexRef来绑定自动更新UI。
+    public initView() {
+      this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length
+    }
+  - 例子：ViewPager的currentSelectIndex和currentSelectIndexRef属性已经是响应式数据源，可以直接使用currentSelectIndexRef来绑定自动更新UI，比如：
+    \`\`\`typescript
+    public initView() {
+      watch([this.viewPager.currentSelectIndexRef], () => {
+        this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length
+      })
+    \`\`\`
+  - tab组件和轮播组件的选择变化监听，必须使用\`ViewPager\`或\`TabContainer\`的\`onSelectChange(func: (item: any, position: number) => void)\`函数来监听选择变化
+
+## 6. **理解页面跳转**
+  - 页面跳转必须使用AllFunction.startPage实现，startPage传入Page的子类对象，如：AllFunction.startPage(new ProductPage(this.productID))。
+  - ❌ 页面跳转不需考虑模块化、循环依赖、渐进式开发，绝对禁止屏蔽页面跳转的代码，所有页面都已经存在，不会出现编译出错的，必须明确写上页面跳转的代码和目标页面所需的跳转参数。
+  - 在Application.ts设置跳转启动页，比如：	
+    // 应用网站启动时回调的第一个函数，用于初始化一些全局的东西。
+    protected onApplicationCreate(): void {
+      AllFunction.startPage(new SplashPage())
+    }
+  - ✅ 引入其他类只允许一种写法：在类文件顶部进行import：import GuidePage from '../guidePage/guidePage'。
+  - ❌ 绝对禁止使用动态import的写法，程序底层已经处理好循环依赖问题了，你不需要考虑，比如绝对禁止以下写法：
+        // 使用动态导入避免循环依赖
+        import('../guidePage/guidePage').then(({ default: GuidePage }) => {
+            AllFunction.startPage(new GuidePage())
+        })
+  - ❌ 绝对禁止使用require的写法，程序底层已经处理好循环依赖问题了，你不需要考虑，比如绝对禁止以下写法：
+        require('../guidePage/guidePage').default
+  - ✅ 正确的写法是：AllFunction.startPage(new GuidePage())。然后在类文件顶部进行import：import GuidePage from '../guidePage/guidePage'。
+  - 如果页面跳转需要传递参数，那么需要使用Page的子类构造函数来传递参数，比如：AllFunction.startPage(new GuidePage(this.productID))。
+  - 在实现页面跳转代码的时候，必须严格按照以下三步来实现：
+      - **第一步：先分析跳转的目标页面需要传递哪些参数**
+      - **第二步：修改目标页面构造函数**：
+      \`\`\`typescript
+      export default class ReadingPage extends Page {
+          private bookId: number
+          private chapterTitle: string
+          
+          constructor(bookId: number, chapterTitle: string) {
+              super()
+              this.bookId = bookId
+              this.chapterTitle = chapterTitle
+          }
+      }
+      \`\`\`
+      - **第三步：修改跳转代码**
+      \`\`\`typescript
+      const bookData = this.readingHistoryDataRef.value[0]
+      AllFunction.startPage(new ReadingPage(bookData.id, bookData.chapterTitle))
+      \`\`\`
+
+## 7. **理解基础开发规则**
+  - lib文件夹里面的代码文件都是内置框架代码，绝对禁止对lib文件夹的代码进行增删改操作
+  - 所有Page的子类，都允许添加构造函数和构造函数的参数，这些参数就用来页面跳转时页面之间传递数据使用，比如：商品列表页ProjectListPage跳到商品详情页ProjectDetailPage，那么ProjectListPage应该要传给ProjectDetailPage一个参数：productID。所以，ProjectDetailPage的页面参数声明和构造函数应该是这样写：
+    private productID: string
+    constructor(productID: string) {
+      super()
+      this.productID = productID
+    }。
+  - 任何页面（特别是闪屏页）的业务逻辑绝对不能放到Application.ts进行处理，Application.ts只进行全局网络拦截处理、全局静态变量、全局静态方法的定义和实现
+  - 如果是多个页面共用的数据变量，可以考虑声明为全局静态变量，并在Application.ts中进行声明。
+  - 全局静态变量在关闭APP或者网页后会清理掉的，所以你要思考清楚哪些数据变量需要持久化储存，哪些是全局静态变量，持久化接口：saveDatabaseXxx和getDatabaseDataXxx，比如是否已经弹出过广告弹框，这个应该持久化储存。
+  - 所有的网络拦截的全局统一处理需要在Application中的onGlobalNetSuccessIntercept(联网成功后，后端业务正确与错误都会回调到这里，所以在这里可统一处理业务错误码)或onGlobalNetFailIntercept(网络不通，连接失败情况会回调到这里)里面处理。
+  - 页面内的网络请求业务处理不得写在Application的onGlobalNetSuccessIntercept里面。
+  - 声明全局变量、局部变量必须要声明数据类型，并且绝对禁止使用any，请使用具体类型来声明
+  - 字符串不得直接进行boolean运算然后赋值给boolean类型的变量，需要在字符串前面添加两个非运算：!!。比如正确的写法：const isAdd = !!this.inputView.text && isNew
+  - 所有的toast提示，必须调用AllFunction.showToast方法来显示，并且如用户描述没有明确说明需要toast提示，你不得擅自进行Toast提示。
+  - 延时执行AllFunction.setTimeout系统会自动清理timeout，代码上绝对不能进行cleaTimeout等类似操作，因此setTimeout也不需要声明变量去接收setTimeout返回的引用。
+  - 轮播ViewPager对应的索引指示器容器，这个索引指示器不需要额外代码实现指示器点的切换UI更新逻辑，本身ViewPager与IndicatorContainer底层已经实现了切换的UI更新逻辑的了，只需要viewPager.bindIndicator(indicatorContainer)即可。
+  - 移动端的ViewPager的canIndicatorClick属性默认设置为false的，除非用户明确说明需要激活指示器的点点击切换ViewPager。
+  - 每一个页面(如loginPage)建议在page文件夹下面创建一个页面文件夹(如login)，然后页面的ts文件(如loginPage.ts)创建在页面文件夹下面，页面文件夹下如果需要还可创建一个页面数据ts文件(如loginPageData.ts)，这样如loginPage负责业务逻辑和交互逻辑，如loginPageData负责数据声明定义、初始化与管理等。
+
+## 8. **理解后端API接口的定义与使用**
+  - 使用'read_file'工具读取'src/backendApi/backendApiInfo.md'后端API使用说明文件，必须缓存记住所有可用的后端API接口列表。
+  - 后端API接口的定义与使用，必须使用src/backendApi文件夹里面的各种API类中定义的方法，不允许使用未在backendApi文件夹中定义的后端API，比如：backendApi/account/getUserInfo.ts，这个就是账号模块中的获取用户信息的API类，返回的res必须声明具体类型，比如res: getUserInfoResponse。
+  - request接口只需定义即可，不需要实现，底层已经实现。
+  - API类代码示例：
+    \`\`\`typescript
+    import BaseApi from '../BaseApi'
+
+    // 账号系统-账号密码登录接口请求数据
+    export interface postClientBizAuthLoginRequest {
+        username?: string
+        password?: string
+        key?: string
+        captcha?: string
+    }
+
+    // 账号系统-账号密码登录接口返回数据
+    export interface postClientBizAuthLoginResponse {
+                    code: number
+                    msg: string
+                    data: {
+        access_token: string
+        }
+    }
+
+    // 账号系统-账号密码登录接口失败返回数据
+    export interface apiFailInfo {
+        msg: string
+        code: number
+    }
+
+    // 账号系统-账号密码登录接口
+    export default class postClientBizAuthLogin extends BaseApi  {
+
+        public static request_ArtuX1d8a6A(
+            request: postClientBizAuthLoginRequest,
+            success: (res: postClientBizAuthLoginResponse) => void,
+            fail: (error: apiFailInfo) => void
+        ): void { }
+
+    }
+    \`\`\`
+  - API类的使用方式：先import API类，然后调用API类的request方法，比如：
+    import { postClientBizAuthLogin } from '../../backendApi/account/postClientBizAuthLogin'
+    ...
+    const request: postClientBizAuthLoginRequest = {
+      username: 'admin',
+      password: '123456',
+      key: '123456',
+      captcha: '123456'
+    }
+    postClientBizAuthLogin.request_ArtuX1d8a6A(request, (response: postClientBizAuthLogoutResponse) => {
+      // 请求成功后的处理
+    }, (error: apiFailInfo) => {
+      // 请求失败后的处理
+    })
+    ...
+
+## 9. **理解调用后端api接口返回数据后与UI数据绑定**
+  - 在调用后端api接口返回数据后，需要根据vtype来做不同的数据绑定，比如：
+    - vtype="verticalListView"、vtype="horizontalListView"、vtype="viewPager"类型的节点组件，需要使用setDataList方法来绑定数据，比如：
+      this.xxxVerticalListView.setDataList(response.data.list)、this.xxxHorizontalListView.setDataList(response.data.list)、this.xxxViewPager.setDataList(response.data.list)
+    - vtype="listItemCard"、vtype="oneViewPagerContent"类型的节点组件，需要深度遍历它的第1个item的孩子，然后结合后端api返回的xxxResponse的数据结构给第1个item设置数据，注意只需给第1个item节点设置数据，而不是所有item节点都设置数据，比如：
+      \`\`\`typescript
+      // 后端xxxApi返回的xxxResponse数据结构
+      export interface getRecommendBookListResponse {
+          code: number
+          msg: string
+          data: {
+              list: [
+                  {
+                      id: number // 书籍ID
+                      title: string // 书籍标题
+                      author: string // 作者名称
+                      coverUrl: string // 封面图片URL
+                      description: string // 书籍简介
+                      categoryName: string // 分类名称
+                  }
+              ] // 书籍列表
+              total: number // 总数量
+              page: number // 当前页码
+              size: number // 每页数量
+          }
+      }
+      ...
+      // 设置书籍列表数据
+      this.recommendBookList.setDataList(getRecommendBookListResponse.data.list)
+      // 设置第1个item节点数据
+      this.recommendBookCover1.src = getRecommendBookListResponse.data.list[0].coverUrl
+      this.recommendBookTitle1.text = getRecommendBookListResponse.data.list[0].title
+      this.recommendBookAuthor1.text = getRecommendBookListResponse.data.list[0].author
+      ...
+      // 设置轮播数据
+      this.recommendViewPager.setDataList(getRecommendBookListResponse.data.list)
+      // 设置第1个item节点数据
+      this.recommendImage1.src = getRecommendBookListResponse.data.list[0].coverUrl
+      this.carouselTitle1.text = getRecommendBookListResponse.data.list[0].title
+      ...
+      \`\`\`
+
+## 10. 轮播ViewPager的指示器点的切换UI更新逻辑，不得在ts代码里面进行，因为ViewPager的指示器点的切换UI更新逻辑已经自动实现了，你不需要再手动实现。
+
+## 11. 禁用以下6种代码写法
+- 1、禁止在函数里面定义内部函数，必须定义函数为全局函数
+  - ❌ 错误的写法：
+  \`\`\`typescript
+  private initView(): void {
+      const countCardData: number = () => {
+          // xxx代码
+      }
+      const count = countCardData()
+  }
+  \`\`\`
+  - ✅ 正确的写法是：
+  \`\`\`typescript
+  private initView(): void {
+      const count = this.countCardData()
+  }
+  private countCardData(): number {
+    // xxx代码
+  }
+  \`\`\`
+- 2、禁止使用for.in循环，必须使用fori循环的写法，那么就需要结合Object.keys(xxx)来先获取到对象的keys，再fori遍历对象属性
+  - ❌ 错误的写法：
+  \`\`\`typescript
+  for (const key in hotReviewObj) {
+      updatedReview[key] = hotReviewObj[key];
+  }
+  \`\`\`
+  - ✅ 正确的写法是：
+  \`\`\`typescript
+  const keys = Object.keys(hotReviewsData);
+  for (let i = 0; i < keys.length; i++) {
+      updatedReview[key] = hotReviewsData[keys[i]];
+  }
+  \`\`\`
+- 3、任何方法函数定义，绝对禁止使用async和Promise，不允许使用Promise.race、Promise.all等Promise相关方法，所有异步操作必须使用箭头函数。
+- 4、禁止使用正则，请使用字符串操作来替换实现
+- 5、禁止使用lib.dom.d.ts文件里面的方法，因为lib.dom.d.ts文件里面的方法都是浏览器环境的方法，不允许在Node.js环境下使用。
+- 6、禁止修改、新增、删除src/lib文件夹及其所有子文件夹中的文件。
+
+`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appCodeRule.js","sourceRoot":"","sources":["../src/appCodeRule.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kCAAkC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8RjD,CAAC","sourcesContent":["export const understandingCodeFrameworkTemplate = `\n# **必须先理解项目代码框架11个知识点**\n## 1. **理解View组件的声明规则**\n  - 这不是html、react等开发，这是一个新的开发框架，是基于src/lib/uilib文件夹里面的UI组件库来开发的\n  - View组件的基类是BaseView，容器基类是BaseContainerView，所有View组件都继承自BaseView\n  - 查看'src/lib/uilib/'文件夹下面的文件名字，理解总共有多少种UI组件\n  - View组件的声明必须在类文件开始时先声明，并且必须要声明具体的View组件类型，不得声明为BaseView，不得在任何函数体里面通过findViewById来声明View组件，比如：\n    - ✅ 正确的写法：\n    \\`\\`\\`typescript\n    public class HomePage extends Page {\n      private nameTextView: TextView = this.findViewById('nameTextView') as TextView\n      ....\n    }\n    \\`\\`\\`\n    - ❌ 错误的写法（没有声具体的View组件类型）：\n    \\`\\`\\`typescript\n    private nameTextView = this.findViewById('nameTextView')\n    \\`\\`\\`\n    - ❌ 错误的写法（在函数体里面通过findViewById来声明View组件）：\n    \\`\\`\\`typescript\n    private oneFunction() {\n      const nameTextView: TextView = this.findViewById('nameTextView') as TextView\n      ....\n    }\n    \\`\\`\\`\n  - 所有View组件的选中状态、聚焦状态、禁用状态的变化都必须通过\\`setStation(station: ViewStation)\\`函数来设置，不能直接设置组件的UI属性，只需要设置组件的station属性即可自动更新组件的UI样式\n  - 所有View组件的显示、隐藏占位、隐藏不占位的设置都必须使用View的\\`visibility\\`属性进行设置，不得使用\\`station\\`属性。\n  - 所有View组件的normal、readOnly、focus、selected、disabled状态的设置都必须使用View的\\`station\\`属性进行设置。\n\n## 2. **理解唯一的能力方法AllFunction.ts以及json相关代码**\n  - 使用'read_file'工具阅读并理解'src/lib/AllFunction.ts'文件，理解该工程能使用的唯一的能力方法\n  - 请严格按照唯一的能力方法AllFunction.ts，不要新增、删除或修改任何AllFunction接口声明；也不要调用其他未在AllFunction中出现的函数或模块\n  \n## 3. **理解Ref、watch**\n  - Ref的数据类型只能是以下5中类型：数字使用Ref<number>，字符串使用Ref<string>，布尔量使用Ref<boolean>，对象使用Ref<any>，数组使用Ref<Array<any>>或Ref<Array<any> | null>或Ref<any[]>或Ref<any[] | null>。\n  - 使用'read_file'工具阅读并理解'src/lib/Ref.ts'文件，理解Ref和watch的定义用法\n  - watch是监听Ref的变化，然后做相关UI更新或其他业务逻辑，第一个参数是监听的Ref数组，第二个参数是监听的回调函数，回调函数中可以做相关UI更新或其他业务逻辑。\n  - Ref是响应式数据源，watch是监听Ref的变化，然后做相关UI更新或其他业务逻辑，比如：\n  \\`\\`\\`typescript\n  private nameTextRef: Ref<string> = ref('')\n  private otherCountRef: Ref<number> = ref(0)\n  watch([this.nameTextRef, this.otherCountRef], () => {\n    // 可以先相关的UI更新或业务逻辑\n    if (this.otherCountRef.value > 5) {\n      this.nameTextView.text = this.nameTextRef.value + '5'\n     } else {\n      this.nameTextView.text = this.nameTextRef.value + '10'\n    }\n  })\n  \\`\\`\\`\n  - \\`src/lib/uilib/Ref.ts\\`里面的\\`watch\\`函数，第一个入参\\`refs: Ref<T>[]\\`绝对禁止先声明局ref数组部变量再传入，正确的写法应该是直接写数组：\\`[ref1, ref2]\\`就行\n  - ❌ 错误的写法：\n    \\`\\`\\` typescript\n    const refArray = [ref1, ref2]\n    watch(refArray, (newValues: T[]) => {\n        // 监听ref1和ref2的变化\n    })\n    \\`\\`\\`\n  - ✅ 正确的写法：\n    \\`\\`\\` typescript\n    watch([ref1, ref2], (newValues: T[]) => {\n        // 监听ref1和ref2的变化\n    })\n    \\`\\`\\`\n\n## 4. **理解setDataList方法的静态数据与动态数据场景**\n  - 对于动态数据容器ViewPager、ListView的setDataList方法，如果数据是动态的，比如：从后端接口获取的，才能使用setDataList方法来设置数据。静态数据已经在UI页面上写好了，你不得使用setDataList方法来设置数据。\n  - 判断标准：如果UI页面中已经有完整的轮播项目/列表项目，就是静态数据，如果是网络API返回的数据列表就是动态数据。\n  - ✅ 静态数据容器（UI页面中已写好内容）：不使用setDataList()\n  - ✅ 动态数据容器（需要从API获取）：才使用setDataList()\n\n## 5. **View组件，理解每个组件可能里面已经有了响应式数据源，如果组件里面已经有了响应式数据源，那么你不得再自己创建ref变量或者使用onSelectChange等回调触发UI更新**\n  - 例子：ViewPager的currentSelectIndex和currentSelectIndexRef属性已经是响应式数据源，可以直接使用currentSelectIndexRef来绑定自动更新UI。\n    public initView() {\n      this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length\n    }\n  - 例子：ViewPager的currentSelectIndex和currentSelectIndexRef属性已经是响应式数据源，可以直接使用currentSelectIndexRef来绑定自动更新UI，比如：\n    \\`\\`\\`typescript\n    public initView() {\n      watch([this.viewPager.currentSelectIndexRef], () => {\n        this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length\n      })\n    \\`\\`\\`\n  - tab组件和轮播组件的选择变化监听，必须使用\\`ViewPager\\`或\\`TabContainer\\`的\\`onSelectChange(func: (item: any, position: number) => void)\\`函数来监听选择变化\n\n## 6. **理解页面跳转**\n  - 页面跳转必须使用AllFunction.startPage实现，startPage传入Page的子类对象，如：AllFunction.startPage(new ProductPage(this.productID))。\n  - ❌ 页面跳转不需考虑模块化、循环依赖、渐进式开发，绝对禁止屏蔽页面跳转的代码，所有页面都已经存在，不会出现编译出错的，必须明确写上页面跳转的代码和目标页面所需的跳转参数。\n  - 在Application.ts设置跳转启动页，比如：\t\n    // 应用网站启动时回调的第一个函数，用于初始化一些全局的东西。\n    protected onApplicationCreate(): void {\n      AllFunction.startPage(new SplashPage())\n    }\n  - ✅ 引入其他类只允许一种写法：在类文件顶部进行import：import GuidePage from '../guidePage/guidePage'。\n  - ❌ 绝对禁止使用动态import的写法，程序底层已经处理好循环依赖问题了，你不需要考虑，比如绝对禁止以下写法：\n        // 使用动态导入避免循环依赖\n        import('../guidePage/guidePage').then(({ default: GuidePage }) => {\n            AllFunction.startPage(new GuidePage())\n        })\n  - ❌ 绝对禁止使用require的写法，程序底层已经处理好循环依赖问题了，你不需要考虑，比如绝对禁止以下写法：\n        require('../guidePage/guidePage').default\n  - ✅ 正确的写法是：AllFunction.startPage(new GuidePage())。然后在类文件顶部进行import：import GuidePage from '../guidePage/guidePage'。\n  - 如果页面跳转需要传递参数，那么需要使用Page的子类构造函数来传递参数，比如：AllFunction.startPage(new GuidePage(this.productID))。\n  - 在实现页面跳转代码的时候，必须严格按照以下三步来实现：\n      - **第一步：先分析跳转的目标页面需要传递哪些参数**\n      - **第二步：修改目标页面构造函数**：\n      \\`\\`\\`typescript\n      export default class ReadingPage extends Page {\n          private bookId: number\n          private chapterTitle: string\n          \n          constructor(bookId: number, chapterTitle: string) {\n              super()\n              this.bookId = bookId\n              this.chapterTitle = chapterTitle\n          }\n      }\n      \\`\\`\\`\n      - **第三步：修改跳转代码**\n      \\`\\`\\`typescript\n      const bookData = this.readingHistoryDataRef.value[0]\n      AllFunction.startPage(new ReadingPage(bookData.id, bookData.chapterTitle))\n      \\`\\`\\`\n\n## 7. **理解基础开发规则**\n  - lib文件夹里面的代码文件都是内置框架代码，绝对禁止对lib文件夹的代码进行增删改操作\n  - 所有Page的子类，都允许添加构造函数和构造函数的参数，这些参数就用来页面跳转时页面之间传递数据使用，比如：商品列表页ProjectListPage跳到商品详情页ProjectDetailPage，那么ProjectListPage应该要传给ProjectDetailPage一个参数：productID。所以，ProjectDetailPage的页面参数声明和构造函数应该是这样写：\n    private productID: string\n    constructor(productID: string) {\n      super()\n      this.productID = productID\n    }。\n  - 任何页面（特别是闪屏页）的业务逻辑绝对不能放到Application.ts进行处理，Application.ts只进行全局网络拦截处理、全局静态变量、全局静态方法的定义和实现\n  - 如果是多个页面共用的数据变量，可以考虑声明为全局静态变量，并在Application.ts中进行声明。\n  - 全局静态变量在关闭APP或者网页后会清理掉的，所以你要思考清楚哪些数据变量需要持久化储存，哪些是全局静态变量，持久化接口：saveDatabaseXxx和getDatabaseDataXxx，比如是否已经弹出过广告弹框，这个应该持久化储存。\n  - 所有的网络拦截的全局统一处理需要在Application中的onGlobalNetSuccessIntercept(联网成功后，后端业务正确与错误都会回调到这里，所以在这里可统一处理业务错误码)或onGlobalNetFailIntercept(网络不通，连接失败情况会回调到这里)里面处理。\n  - 页面内的网络请求业务处理不得写在Application的onGlobalNetSuccessIntercept里面。\n  - 声明全局变量、局部变量必须要声明数据类型，并且绝对禁止使用any，请使用具体类型来声明\n  - 字符串不得直接进行boolean运算然后赋值给boolean类型的变量，需要在字符串前面添加两个非运算：!!。比如正确的写法：const isAdd = !!this.inputView.text && isNew\n  - 所有的toast提示，必须调用AllFunction.showToast方法来显示，并且如用户描述没有明确说明需要toast提示，你不得擅自进行Toast提示。\n  - 延时执行AllFunction.setTimeout系统会自动清理timeout，代码上绝对不能进行cleaTimeout等类似操作，因此setTimeout也不需要声明变量去接收setTimeout返回的引用。\n  - 轮播ViewPager对应的索引指示器容器，这个索引指示器不需要额外代码实现指示器点的切换UI更新逻辑，本身ViewPager与IndicatorContainer底层已经实现了切换的UI更新逻辑的了，只需要viewPager.bindIndicator(indicatorContainer)即可。\n  - 移动端的ViewPager的canIndicatorClick属性默认设置为false的，除非用户明确说明需要激活指示器的点点击切换ViewPager。\n  - 每一个页面(如loginPage)建议在page文件夹下面创建一个页面文件夹(如login)，然后页面的ts文件(如loginPage.ts)创建在页面文件夹下面，页面文件夹下如果需要还可创建一个页面数据ts文件(如loginPageData.ts)，这样如loginPage负责业务逻辑和交互逻辑，如loginPageData负责数据声明定义、初始化与管理等。\n\n## 8. **理解后端API接口的定义与使用**\n  - 使用'read_file'工具读取'src/backendApi/backendApiInfo.md'后端API使用说明文件，必须缓存记住所有可用的后端API接口列表。\n  - 后端API接口的定义与使用，必须使用src/backendApi文件夹里面的各种API类中定义的方法，不允许使用未在backendApi文件夹中定义的后端API，比如：backendApi/account/getUserInfo.ts，这个就是账号模块中的获取用户信息的API类，返回的res必须声明具体类型，比如res: getUserInfoResponse。\n  - request接口只需定义即可，不需要实现，底层已经实现。\n  - API类代码示例：\n    \\`\\`\\`typescript\n    import BaseApi from '../BaseApi'\n\n    // 账号系统-账号密码登录接口请求数据\n    export interface postClientBizAuthLoginRequest {\n        username?: string\n        password?: string\n        key?: string\n        captcha?: string\n    }\n\n    // 账号系统-账号密码登录接口返回数据\n    export interface postClientBizAuthLoginResponse {\n                    code: number\n                    msg: string\n                    data: {\n        access_token: string\n        }\n    }\n\n    // 账号系统-账号密码登录接口失败返回数据\n    export interface apiFailInfo {\n        msg: string\n        code: number\n    }\n\n    // 账号系统-账号密码登录接口\n    export default class postClientBizAuthLogin extends BaseApi  {\n\n        public static request_ArtuX1d8a6A(\n            request: postClientBizAuthLoginRequest,\n            success: (res: postClientBizAuthLoginResponse) => void,\n            fail: (error: apiFailInfo) => void\n        ): void { }\n\n    }\n    \\`\\`\\`\n  - API类的使用方式：先import API类，然后调用API类的request方法，比如：\n    import { postClientBizAuthLogin } from '../../backendApi/account/postClientBizAuthLogin'\n    ...\n    const request: postClientBizAuthLoginRequest = {\n      username: 'admin',\n      password: '123456',\n      key: '123456',\n      captcha: '123456'\n    }\n    postClientBizAuthLogin.request_ArtuX1d8a6A(request, (response: postClientBizAuthLogoutResponse) => {\n      // 请求成功后的处理\n    }, (error: apiFailInfo) => {\n      // 请求失败后的处理\n    })\n    ...\n\n## 9. **理解调用后端api接口返回数据后与UI数据绑定**\n  - 在调用后端api接口返回数据后，需要根据vtype来做不同的数据绑定，比如：\n    - vtype=\"verticalListView\"、vtype=\"horizontalListView\"、vtype=\"viewPager\"类型的节点组件，需要使用setDataList方法来绑定数据，比如：\n      this.xxxVerticalListView.setDataList(response.data.list)、this.xxxHorizontalListView.setDataList(response.data.list)、this.xxxViewPager.setDataList(response.data.list)\n    - vtype=\"listItemCard\"、vtype=\"oneViewPagerContent\"类型的节点组件，需要深度遍历它的第1个item的孩子，然后结合后端api返回的xxxResponse的数据结构给第1个item设置数据，注意只需给第1个item节点设置数据，而不是所有item节点都设置数据，比如：\n      \\`\\`\\`typescript\n      // 后端xxxApi返回的xxxResponse数据结构\n      export interface getRecommendBookListResponse {\n          code: number\n          msg: string\n          data: {\n              list: [\n                  {\n                      id: number // 书籍ID\n                      title: string // 书籍标题\n                      author: string // 作者名称\n                      coverUrl: string // 封面图片URL\n                      description: string // 书籍简介\n                      categoryName: string // 分类名称\n                  }\n              ] // 书籍列表\n              total: number // 总数量\n              page: number // 当前页码\n              size: number // 每页数量\n          }\n      }\n      ...\n      // 设置书籍列表数据\n      this.recommendBookList.setDataList(getRecommendBookListResponse.data.list)\n      // 设置第1个item节点数据\n      this.recommendBookCover1.src = getRecommendBookListResponse.data.list[0].coverUrl\n      this.recommendBookTitle1.text = getRecommendBookListResponse.data.list[0].title\n      this.recommendBookAuthor1.text = getRecommendBookListResponse.data.list[0].author\n      ...\n      // 设置轮播数据\n      this.recommendViewPager.setDataList(getRecommendBookListResponse.data.list)\n      // 设置第1个item节点数据\n      this.recommendImage1.src = getRecommendBookListResponse.data.list[0].coverUrl\n      this.carouselTitle1.text = getRecommendBookListResponse.data.list[0].title\n      ...\n      \\`\\`\\`\n\n## 10. 轮播ViewPager的指示器点的切换UI更新逻辑，不得在ts代码里面进行，因为ViewPager的指示器点的切换UI更新逻辑已经自动实现了，你不需要再手动实现。\n\n## 11. 禁用以下6种代码写法\n- 1、禁止在函数里面定义内部函数，必须定义函数为全局函数\n  - ❌ 错误的写法：\n  \\`\\`\\`typescript\n  private initView(): void {\n      const countCardData: number = () => {\n          // xxx代码\n      }\n      const count = countCardData()\n  }\n  \\`\\`\\`\n  - ✅ 正确的写法是：\n  \\`\\`\\`typescript\n  private initView(): void {\n      const count = this.countCardData()\n  }\n  private countCardData(): number {\n    // xxx代码\n  }\n  \\`\\`\\`\n- 2、禁止使用for.in循环，必须使用fori循环的写法，那么就需要结合Object.keys(xxx)来先获取到对象的keys，再fori遍历对象属性\n  - ❌ 错误的写法：\n  \\`\\`\\`typescript\n  for (const key in hotReviewObj) {\n      updatedReview[key] = hotReviewObj[key];\n  }\n  \\`\\`\\`\n  - ✅ 正确的写法是：\n  \\`\\`\\`typescript\n  const keys = Object.keys(hotReviewsData);\n  for (let i = 0; i < keys.length; i++) {\n      updatedReview[key] = hotReviewsData[keys[i]];\n  }\n  \\`\\`\\`\n- 3、任何方法函数定义，绝对禁止使用async和Promise，不允许使用Promise.race、Promise.all等Promise相关方法，所有异步操作必须使用箭头函数。\n- 4、禁止使用正则，请使用字符串操作来替换实现\n- 5、禁止使用lib.dom.d.ts文件里面的方法，因为lib.dom.d.ts文件里面的方法都是浏览器环境的方法，不允许在Node.js环境下使用。\n- 6、禁止修改、新增、删除src/lib文件夹及其所有子文件夹中的文件。\n\n`;\n"]}

package/build/index.js

@@ -53,6 +53,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: []
                 }
             },
+            {
+                name: 'understanding_code_framework_prompt',
+                description: 'Return prompt for understanding project code framework',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
+            },
             {
                 name: 'optimize_code_design_prompt',
                 description: 'Optimize prompt for code logic design thinking before development, generating detailed design documentation',
@@ -307,6 +316,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }
                     ]
                 };
+            case 'understanding_code_framework_prompt':
+                const appCodeFrameworkText = await promptOptimizer.understandingAppCodeFrameworkPrompt();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: appCodeFrameworkText
+                        }
+                    ]
+                };
             case 'optimize_code_design_prompt':
                 const optimizedCodeDesignPrompt = await promptOptimizer.optimizeCodeDesignPrompt(args.user_input);
                 return {
@@ -484,4 +503,4 @@ async function main() {
     console.error('ByteFun AI Prompt MCP server running on stdio');
 }
 main().catch(console.error);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\nimport { Server } from '@modelcontextprotocol/sdk/server/index.js';\nimport { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';\nimport {\n  CallToolRequestSchema,\n  ListToolsRequestSchema,\n  Tool,\n} from '@modelcontextprotocol/sdk/types.js';\nimport { PromptOptimizer } from './prompt-optimizer.js';\n\nconst server = new Server(\n  {\n    name: 'bytefun-ai-prompt',\n    version: '1.0.0',\n  }\n);\n\nconst promptOptimizer = new PromptOptimizer();\n\n\n\n// List available tools\nserver.setRequestHandler(ListToolsRequestSchema, async () => {\n  return {\n    tools: [\n      {\n        name: 'optimize_product_design_prompt',\n        description: 'Optimize prompt for product and business logic design',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            industry: {\n              type: 'string',\n              description: 'The industry that the APP or website belongs to'\n            },\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for product and business logic design'\n            }\n          },\n          required: ['industry', 'user_input']\n        }\n      },\n      {\n        name: 'optimize_ui_design_prompt',\n        description: 'Optimize prompt for UI design by reading page list and requirements from doc file',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for UI design'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      {\n        name: 'ui_design_guide_prompt',\n        description: 'Return comprehensive UI design guide prompt with strict execution rules',\n        inputSchema: {\n          type: 'object',\n          properties: {},\n          required: []\n        }\n      },\n      {\n        name: 'optimize_code_design_prompt',\n        description: 'Optimize prompt for code logic design thinking before development, generating detailed design documentation',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for code logic design thinking'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      {\n        name: 'implement_logic_code_prompt',\n        description: 'Optimize prompt for TypeScript code development by adding code development rules and marking user input',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for code development'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      // {\n      //   name: 'optimize_hand_drawn_ui_design_prompt',\n      //   description: 'Analyze hand-drawn UI design sketches and extract detailed information for UI design',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input with hand-drawn UI design sketch that needs to be analyzed'\n      //       }\n      //     },\n      //     required: ['user_input']\n      //   }\n      // },\n      // {\n      //   name: 'optimize_ui_design_thinking_prompt',\n      //   description: 'Optimize prompt for UI design thinking process before actual design work, generating detailed UI design thinking documentation',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input prompt that needs to be optimized for UI design thinking process'\n      //       }\n      //     },\n      //     required: ['user_input']\n      //   }\n      // },\n\n      {\n        name: 'optimize_backend_design_prompt',\n        description: 'Optimize prompt for backend database and API interface design by reading module business logic documents',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for backend database and API interface design'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      // {\n      //   name: 'functional_module_business_logic_prompt',\n      //   description: 'Optimize prompt for functional module business logic analysis based on product requirements document',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       functionalModule: {\n      //         type: 'string',\n      //         description: 'The functional module currently being designed'\n      //       },\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input prompt that needs to be optimized for functional module business logic analysis'\n      //       }\n      //     },\n      //     required: ['functionalModule', 'user_input']\n      //   }\n      // },\n\n      // {\n      //   name: 'talk_to_editor',\n      //   description: 'Establish long connection with editor backend using Socket.IO. Before calling this tool, you must first use read_file to read .bytefun/project.json and get projectID and uid values. This tool will wait for backend messages and return tasks to execute.',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       projectID: {\n      //         type: 'number',\n      //         description: 'Project ID from .bytefun/project.json configuration file'\n      //       },\n      //       uid: {\n      //         type: 'number',\n      //         description: 'User ID from .bytefun/project.json configuration file'\n      //       }\n      //     },\n      //     required: ['projectID', 'uid']\n      //   }\n      // },\n      // {\n      //   name: 'talk_to_editor_rules',\n      //   description: 'Get AI behavior rules for interacting with talk_to_editor tool. Returns detailed instructions on how AI should maintain continuous conversation and wait for backend control.',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {},\n      //     required: []\n      //   }\n      // },\n      {\n        name: 'implement_backend_code_prompt',\n        description: 'Optimize prompt for backend code development by reading backend design documents and applying coding standards',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for backend code development'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      {\n        name: 'optimize_ui_design_edit_prompt',\n        description: 'Optimize prompt for UI design modification and editing tasks, returning detailed UI design specifications',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for UI design modification'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      // {\n      //   name: 'optimize_ui_design_replenish_prompt',\n      //   description: 'Optimize prompt for UI design HTML replenishment and attribute completion',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input prompt that needs to be optimized for UI design HTML replenishment'\n      //       }\n      //     },\n      //     required: ['user_input']\n      //   }\n      // },\n      {\n        name: 'optimize_jump_page_code_prompt',\n        description: 'Optimize prompt for page navigation code development based on UI design progress and jumping rules',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for page navigation code development'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      // {\n      //   name: 'optimize_declarative_ui_prompt',\n      //   description: 'Optimize prompt for declarative UI design using JSON format to describe UI components and interfaces',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input prompt that needs to be optimized for declarative UI design'\n      //       }\n      //     },\n      //     required: ['user_input']\n      //   }\n      // },\n      {\n        name: 'optimize_ui_spec_design_prompt',\n        description: 'Optimize prompt for UI specification design based on product requirements document to complete UI design standards',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for UI specification design'\n            }\n          },\n          required: ['user_input']\n        }\n      }\n      // {\n      //   name: 'implement_ui_code_prompt',\n      //   description: 'Return prompt for implementing UI code with strict execution steps',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input describing UI code implementation requirements'\n      //       }\n      //     },\n      //     required: ['user_input']\n      //   }\n      // }\n    ] as Tool[]\n  };\n});\n\n// Handle tool calls\nserver.setRequestHandler(CallToolRequestSchema, async (request) => {\n  const { name, arguments: args } = request.params;\n\n  if (!args) {\n    throw new Error('Missing arguments');\n  }\n\n  try {\n    switch (name) {\n      case 'optimize_product_design_prompt':\n        const optimizedProductDesignPrompt = await promptOptimizer.optimizeProductDesignPrompt(args.industry as string, args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedProductDesignPrompt\n            }\n          ]\n        };\n\n      case 'optimize_ui_design_prompt':\n        const optimizedUIPrompt = await promptOptimizer.optimizeUIDesignPrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedUIPrompt\n            }\n          ]\n        };\n\n      case 'ui_design_guide_prompt':\n        const uiDesignGuideText = await promptOptimizer.uiDesignGuidePrompt();\n        return {\n          content: [\n            {\n              type: 'text',\n              text: uiDesignGuideText\n            }\n          ]\n        };\n\n      case 'optimize_code_design_prompt':\n        const optimizedCodeDesignPrompt = await promptOptimizer.optimizeCodeDesignPrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedCodeDesignPrompt\n            }\n          ]\n        };\n\n      case 'implement_logic_code_prompt':\n        const optimizedCodePrompt = await promptOptimizer.optimizeCodePrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedCodePrompt\n            }\n          ]\n        };\n\n      // case 'optimize_hand_drawn_ui_design_prompt':\n      //   const optimizedHandDrawnPrompt = await promptOptimizer.optimizeHandDrawnUIDesignPrompt(args.user_input as string);\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: optimizedHandDrawnPrompt\n      //       }\n      //     ]\n      //   };\n\n      // case 'optimize_ui_design_thinking_prompt':\n      //   const optimizedUIDesignThinkingPrompt = await promptOptimizer.optimizeUIDesignThinkingPrompt(args.user_input as string);\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: optimizedUIDesignThinkingPrompt\n      //       }\n      //     ]\n      //   };\n\n      case 'optimize_backend_design_prompt':\n        const optimizedBackendDesignPrompt = await promptOptimizer.optimizeBackendDesignPrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedBackendDesignPrompt\n            }\n          ]\n        };\n\n      case 'functional_module_business_logic_prompt':\n        const optimizedFunctionalModulePrompt = await promptOptimizer.optimizeFunctionalModulePrompt(args.functionalModule as string, args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedFunctionalModulePrompt\n            }\n          ]\n        };\n\n\n      // case 'talk_to_editor':\n      //   const projectID = args.projectID as number || 0;\n      //   const uid = args.uid as number || 0;\n        \n      //   const talkResult = await promptOptimizer.talkToEditor({\n      //     projectID,\n      //     uid\n      //   });\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: talkResult\n      //       }\n      //     ]\n      //   };\n\n      // case 'talk_to_editor_rules':\n      //   const rulesResult = await promptOptimizer.talkToEditorRules();\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: rulesResult\n      //       }\n      //     ]\n      //   };\n\n      case 'implement_backend_code_prompt':\n        const optimizedBackendCodePrompt = await promptOptimizer.optimizeBackendCodePrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedBackendCodePrompt\n            }\n          ]\n        };\n\n      case 'optimize_ui_design_edit_prompt':\n        const optimizedUIDesignEditPrompt = await promptOptimizer.optimizeUIDesignEditPrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedUIDesignEditPrompt\n            }\n          ]\n        };\n\n      case 'optimize_jump_page_code_prompt':\n        const optimizedJumpPageCodePrompt = await promptOptimizer.optimizeJumpPageCodePrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedJumpPageCodePrompt\n            }\n          ]\n        };\n\n      // case 'optimize_declarative_ui_prompt':\n      //   const optimizedDeclarativeUIPrompt = await promptOptimizer.optimizeDeclarativeUIPrompt(args.user_input as string);\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: optimizedDeclarativeUIPrompt\n      //       }\n      //     ]\n      //   };\n\n      case 'optimize_ui_spec_design_prompt':\n        const optimizedUISpecDesignPrompt = await promptOptimizer.optimizeUISpecDesignPrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedUISpecDesignPrompt\n            }\n          ]\n        };\n\n      // case 'optimize_ui_design_replenish_prompt':\n      //   const optimizedUIDesignReplenishPrompt = await promptOptimizer.optimizeUIDesignReplenishPrompt(args.user_input as string);\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: optimizedUIDesignReplenishPrompt\n      //       }\n      //     ]\n      //   };\n\n      // case 'implement_ui_code_prompt':\n      //   const implementUICodeText = await promptOptimizer.implementUICodePrompt(args.user_input as string);\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: implementUICodeText\n      //       }\n      //     ]\n      //   };\n\n      default:\n        throw new Error(`Unknown tool: ${name}`);\n    }\n  } catch (error) {\n    return {\n      content: [\n        {\n          type: 'text',\n          text: `Error: ${error instanceof Error ? error.message : String(error)}`\n        }\n      ],\n      isError: true\n    };\n  }\n});\n\nasync function main() {\n  const transport = new StdioServerTransport();\n  await server.connect(transport);\n  console.error('ByteFun AI Prompt MCP server running on stdio');\n}\n\nmain().catch(console.error);"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\nimport { Server } from '@modelcontextprotocol/sdk/server/index.js';\nimport { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';\nimport {\n  CallToolRequestSchema,\n  ListToolsRequestSchema,\n  Tool,\n} from '@modelcontextprotocol/sdk/types.js';\nimport { PromptOptimizer } from './prompt-optimizer.js';\n\nconst server = new Server(\n  {\n    name: 'bytefun-ai-prompt',\n    version: '1.0.0',\n  }\n);\n\nconst promptOptimizer = new PromptOptimizer();\n\n\n\n// List available tools\nserver.setRequestHandler(ListToolsRequestSchema, async () => {\n  return {\n    tools: [\n      {\n        name: 'optimize_product_design_prompt',\n        description: 'Optimize prompt for product and business logic design',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            industry: {\n              type: 'string',\n              description: 'The industry that the APP or website belongs to'\n            },\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for product and business logic design'\n            }\n          },\n          required: ['industry', 'user_input']\n        }\n      },\n      {\n        name: 'optimize_ui_design_prompt',\n        description: 'Optimize prompt for UI design by reading page list and requirements from doc file',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for UI design'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      {\n        name: 'ui_design_guide_prompt',\n        description: 'Return comprehensive UI design guide prompt with strict execution rules',\n        inputSchema: {\n          type: 'object',\n          properties: {},\n          required: []\n        }\n      },\n      {\n        name: 'understanding_code_framework_prompt',\n        description: 'Return prompt for understanding project code framework',\n        inputSchema: {\n          type: 'object',\n          properties: {},\n          required: []\n        }\n      },\n      {\n        name: 'optimize_code_design_prompt',\n        description: 'Optimize prompt for code logic design thinking before development, generating detailed design documentation',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for code logic design thinking'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      {\n        name: 'implement_logic_code_prompt',\n        description: 'Optimize prompt for TypeScript code development by adding code development rules and marking user input',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for code development'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      // {\n      //   name: 'optimize_hand_drawn_ui_design_prompt',\n      //   description: 'Analyze hand-drawn UI design sketches and extract detailed information for UI design',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input with hand-drawn UI design sketch that needs to be analyzed'\n      //       }\n      //     },\n      //     required: ['user_input']\n      //   }\n      // },\n      // {\n      //   name: 'optimize_ui_design_thinking_prompt',\n      //   description: 'Optimize prompt for UI design thinking process before actual design work, generating detailed UI design thinking documentation',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input prompt that needs to be optimized for UI design thinking process'\n      //       }\n      //     },\n      //     required: ['user_input']\n      //   }\n      // },\n\n      {\n        name: 'optimize_backend_design_prompt',\n        description: 'Optimize prompt for backend database and API interface design by reading module business logic documents',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for backend database and API interface design'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      // {\n      //   name: 'functional_module_business_logic_prompt',\n      //   description: 'Optimize prompt for functional module business logic analysis based on product requirements document',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       functionalModule: {\n      //         type: 'string',\n      //         description: 'The functional module currently being designed'\n      //       },\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input prompt that needs to be optimized for functional module business logic analysis'\n      //       }\n      //     },\n      //     required: ['functionalModule', 'user_input']\n      //   }\n      // },\n\n      // {\n      //   name: 'talk_to_editor',\n      //   description: 'Establish long connection with editor backend using Socket.IO. Before calling this tool, you must first use read_file to read .bytefun/project.json and get projectID and uid values. This tool will wait for backend messages and return tasks to execute.',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       projectID: {\n      //         type: 'number',\n      //         description: 'Project ID from .bytefun/project.json configuration file'\n      //       },\n      //       uid: {\n      //         type: 'number',\n      //         description: 'User ID from .bytefun/project.json configuration file'\n      //       }\n      //     },\n      //     required: ['projectID', 'uid']\n      //   }\n      // },\n      // {\n      //   name: 'talk_to_editor_rules',\n      //   description: 'Get AI behavior rules for interacting with talk_to_editor tool. Returns detailed instructions on how AI should maintain continuous conversation and wait for backend control.',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {},\n      //     required: []\n      //   }\n      // },\n      {\n        name: 'implement_backend_code_prompt',\n        description: 'Optimize prompt for backend code development by reading backend design documents and applying coding standards',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for backend code development'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      {\n        name: 'optimize_ui_design_edit_prompt',\n        description: 'Optimize prompt for UI design modification and editing tasks, returning detailed UI design specifications',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for UI design modification'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      // {\n      //   name: 'optimize_ui_design_replenish_prompt',\n      //   description: 'Optimize prompt for UI design HTML replenishment and attribute completion',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input prompt that needs to be optimized for UI design HTML replenishment'\n      //       }\n      //     },\n      //     required: ['user_input']\n      //   }\n      // },\n      {\n        name: 'optimize_jump_page_code_prompt',\n        description: 'Optimize prompt for page navigation code development based on UI design progress and jumping rules',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for page navigation code development'\n            }\n          },\n          required: ['user_input']\n        }\n      },\n      // {\n      //   name: 'optimize_declarative_ui_prompt',\n      //   description: 'Optimize prompt for declarative UI design using JSON format to describe UI components and interfaces',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input prompt that needs to be optimized for declarative UI design'\n      //       }\n      //     },\n      //     required: ['user_input']\n      //   }\n      // },\n      {\n        name: 'optimize_ui_spec_design_prompt',\n        description: 'Optimize prompt for UI specification design based on product requirements document to complete UI design standards',\n        inputSchema: {\n          type: 'object',\n          properties: {\n            user_input: {\n              type: 'string',\n              description: 'User input prompt that needs to be optimized for UI specification design'\n            }\n          },\n          required: ['user_input']\n        }\n      }\n      // {\n      //   name: 'implement_ui_code_prompt',\n      //   description: 'Return prompt for implementing UI code with strict execution steps',\n      //   inputSchema: {\n      //     type: 'object',\n      //     properties: {\n      //       user_input: {\n      //         type: 'string',\n      //         description: 'User input describing UI code implementation requirements'\n      //       }\n      //     },\n      //     required: ['user_input']\n      //   }\n      // }\n    ] as Tool[]\n  };\n});\n\n// Handle tool calls\nserver.setRequestHandler(CallToolRequestSchema, async (request) => {\n  const { name, arguments: args } = request.params;\n\n  if (!args) {\n    throw new Error('Missing arguments');\n  }\n\n  try {\n    switch (name) {\n      case 'optimize_product_design_prompt':\n        const optimizedProductDesignPrompt = await promptOptimizer.optimizeProductDesignPrompt(args.industry as string, args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedProductDesignPrompt\n            }\n          ]\n        };\n\n      case 'optimize_ui_design_prompt':\n        const optimizedUIPrompt = await promptOptimizer.optimizeUIDesignPrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedUIPrompt\n            }\n          ]\n        };\n\n      case 'ui_design_guide_prompt':\n        const uiDesignGuideText = await promptOptimizer.uiDesignGuidePrompt();\n        return {\n          content: [\n            {\n              type: 'text',\n              text: uiDesignGuideText\n            }\n          ]\n        };\n\n      case 'understanding_code_framework_prompt':\n        const appCodeFrameworkText = await promptOptimizer.understandingAppCodeFrameworkPrompt();\n        return {\n          content: [\n            {\n              type: 'text',\n              text: appCodeFrameworkText\n            }\n          ]\n        };\n\n      case 'optimize_code_design_prompt':\n        const optimizedCodeDesignPrompt = await promptOptimizer.optimizeCodeDesignPrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedCodeDesignPrompt\n            }\n          ]\n        };\n\n      case 'implement_logic_code_prompt':\n        const optimizedCodePrompt = await promptOptimizer.optimizeCodePrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedCodePrompt\n            }\n          ]\n        };\n\n      // case 'optimize_hand_drawn_ui_design_prompt':\n      //   const optimizedHandDrawnPrompt = await promptOptimizer.optimizeHandDrawnUIDesignPrompt(args.user_input as string);\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: optimizedHandDrawnPrompt\n      //       }\n      //     ]\n      //   };\n\n      // case 'optimize_ui_design_thinking_prompt':\n      //   const optimizedUIDesignThinkingPrompt = await promptOptimizer.optimizeUIDesignThinkingPrompt(args.user_input as string);\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: optimizedUIDesignThinkingPrompt\n      //       }\n      //     ]\n      //   };\n\n      case 'optimize_backend_design_prompt':\n        const optimizedBackendDesignPrompt = await promptOptimizer.optimizeBackendDesignPrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedBackendDesignPrompt\n            }\n          ]\n        };\n\n      case 'functional_module_business_logic_prompt':\n        const optimizedFunctionalModulePrompt = await promptOptimizer.optimizeFunctionalModulePrompt(args.functionalModule as string, args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedFunctionalModulePrompt\n            }\n          ]\n        };\n\n\n      // case 'talk_to_editor':\n      //   const projectID = args.projectID as number || 0;\n      //   const uid = args.uid as number || 0;\n        \n      //   const talkResult = await promptOptimizer.talkToEditor({\n      //     projectID,\n      //     uid\n      //   });\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: talkResult\n      //       }\n      //     ]\n      //   };\n\n      // case 'talk_to_editor_rules':\n      //   const rulesResult = await promptOptimizer.talkToEditorRules();\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: rulesResult\n      //       }\n      //     ]\n      //   };\n\n      case 'implement_backend_code_prompt':\n        const optimizedBackendCodePrompt = await promptOptimizer.optimizeBackendCodePrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedBackendCodePrompt\n            }\n          ]\n        };\n\n      case 'optimize_ui_design_edit_prompt':\n        const optimizedUIDesignEditPrompt = await promptOptimizer.optimizeUIDesignEditPrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedUIDesignEditPrompt\n            }\n          ]\n        };\n\n      case 'optimize_jump_page_code_prompt':\n        const optimizedJumpPageCodePrompt = await promptOptimizer.optimizeJumpPageCodePrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedJumpPageCodePrompt\n            }\n          ]\n        };\n\n      // case 'optimize_declarative_ui_prompt':\n      //   const optimizedDeclarativeUIPrompt = await promptOptimizer.optimizeDeclarativeUIPrompt(args.user_input as string);\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: optimizedDeclarativeUIPrompt\n      //       }\n      //     ]\n      //   };\n\n      case 'optimize_ui_spec_design_prompt':\n        const optimizedUISpecDesignPrompt = await promptOptimizer.optimizeUISpecDesignPrompt(args.user_input as string);\n        return {\n          content: [\n            {\n              type: 'text',\n              text: optimizedUISpecDesignPrompt\n            }\n          ]\n        };\n\n      // case 'optimize_ui_design_replenish_prompt':\n      //   const optimizedUIDesignReplenishPrompt = await promptOptimizer.optimizeUIDesignReplenishPrompt(args.user_input as string);\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: optimizedUIDesignReplenishPrompt\n      //       }\n      //     ]\n      //   };\n\n      // case 'implement_ui_code_prompt':\n      //   const implementUICodeText = await promptOptimizer.implementUICodePrompt(args.user_input as string);\n      //   return {\n      //     content: [\n      //       {\n      //         type: 'text',\n      //         text: implementUICodeText\n      //       }\n      //     ]\n      //   };\n\n      default:\n        throw new Error(`Unknown tool: ${name}`);\n    }\n  } catch (error) {\n    return {\n      content: [\n        {\n          type: 'text',\n          text: `Error: ${error instanceof Error ? error.message : String(error)}`\n        }\n      ],\n      isError: true\n    };\n  }\n});\n\nasync function main() {\n  const transport = new StdioServerTransport();\n  await server.connect(transport);\n  console.error('ByteFun AI Prompt MCP server running on stdio');\n}\n\nmain().catch(console.error);\n"]}

package/build/prompt-optimizer.d.ts

@@ -86,6 +86,7 @@ export declare class PromptOptimizer {
      * 注意：此方法专门处理UI前端代码实现需求，严格按步骤规则执行
      */
     implementUICodePrompt(userInput: string): Promise<string>;
+    understandingAppCodeFrameworkPrompt(): Promise<string>;
     /**
      * 与编辑器建立长连接，通过Socket.IO接收后端控制指令
      * 该方法会使用单例Socket连接等待后端消息，3分钟超时返回空任务

package/build/prompt-optimizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-optimizer.d.ts","sourceRoot":"","sources":["../src/prompt-optimizer.ts"],"names":[],"mappings":"AAkBA,qBAAa,eAAe;IAE1B;;;OAGG;IACG,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIvF;;;OAGG;IACG,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAO5D;;;OAGG;IACG,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIhE;;;OAGG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;IAI5C;;;;OAIG;IACG,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUlE;;;OAGG;IACG,+BAA+B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUzE;;;OAGG;IACG,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUrE;;;;OAIG;IACG,8BAA8B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUxE;;;OAGG;IACG,8BAA8B,CAAC,gBAAgB,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAelG;;;;OAIG;IACG,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUnE;;;;OAIG;IACG,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUpE;;;OAGG;IACG,+BAA+B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUzE;;;;OAIG;IACG,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIpE;;;;OAIG;IACG,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIrE;;;;OAIG;IACG,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIpE;;;OAGG;IACG,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAO/D;;;OAGG;IACG,YAAY,CAAC,UAAU,EAAE;QAC7B,SAAS,EAAE,MAAM,CAAC;QAClB,GAAG,EAAE,MAAM,CAAC;KACb,GAAG,OAAO,CAAC,MAAM,CAAC;IAyFnB;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;CA0H3C"}
+{"version":3,"file":"prompt-optimizer.d.ts","sourceRoot":"","sources":["../src/prompt-optimizer.ts"],"names":[],"mappings":"AAmBA,qBAAa,eAAe;IAE1B;;;OAGG;IACG,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIvF;;;OAGG;IACG,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAO5D;;;OAGG;IACG,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIhE;;;OAGG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;IAI5C;;;;OAIG;IACG,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUlE;;;OAGG;IACG,+BAA+B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUzE;;;OAGG;IACG,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUrE;;;;OAIG;IACG,8BAA8B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUxE;;;OAGG;IACG,8BAA8B,CAAC,gBAAgB,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAelG;;;;OAIG;IACG,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUnE;;;;OAIG;IACG,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUpE;;;OAGG;IACG,+BAA+B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAUzE;;;;OAIG;IACG,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIpE;;;;OAIG;IACG,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIrE;;;;OAIG;IACG,0BAA0B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIpE;;;OAGG;IACG,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOzD,mCAAmC,IAAI,OAAO,CAAC,MAAM,CAAC;IAI5D;;;OAGG;IACG,YAAY,CAAC,UAAU,EAAE;QAC7B,SAAS,EAAE,MAAM,CAAC;QAClB,GAAG,EAAE,MAAM,CAAC;KACb,GAAG,OAAO,CAAC,MAAM,CAAC;IAyFnB;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;CA0H3C"}