@kmlckj/licos-ai-cli 0.0.1

package/lib/__templates__/expo/eslint-plugins/forbid-emoji/tech.md

@@ -0,0 +1,94 @@
+# forbid-emoji 技术设计
+
+## 目标
+- 在代码中检测并禁止使用 emoji
+- 覆盖常见的字符串与 JSX 场景，避免明显漏报
+- 保持实现简单、可维护，避免引入新依赖
+
+## 规则命名与对外形态
+- 插件目录：demo/eslint-plugins/forbid-emoji
+- 规则名：forbid-emoji/no-emoji
+- 规则类型：problem
+- 默认等级：error
+
+## 规则行为定义
+### 报错
+当以下任一位置包含 emoji 时，报错：
+- 字符串字面量
+- 模板字符串的静态片段
+- JSXText 文本
+- JSXAttribute 中可静态解析为字符串的值
+
+### 不报错
+以下场景不触发：
+- 标识符、对象键名、属性名中的字符
+- 数值、正则字面量、BigInt
+- 模板字符串的表达式部分（仅检测静态片段）
+- 被用户显式忽略的路径或内容
+
+## 配置项
+```json
+{
+  "ignorePatterns": []
+}
+```
+- ignorePatterns：字符串数组，命中任一正则则跳过该文本片段
+
+## 检测策略
+### AST 访问节点
+- Literal：仅处理 typeof value === 'string'
+- TemplateLiteral：遍历 quasis，使用 cooked 值
+- JSXText：使用 node.value
+- JSXAttribute：可静态解析为字符串时处理
+
+### 忽略策略
+当文本命中 ignorePatterns 的任一正则时，不再做 emoji 检测，减少误报与白名单配置成本。
+
+## Emoji 识别方案
+### 组合序列处理
+考虑到真实文本中的 emoji 组合形式，需要识别以下组合序列并保证命中：
+- 变体选择符：U+FE0F
+- 皮肤色修饰符：U+1F3FB–U+1F3FF
+- ZWJ 组合：U+200D
+- 区域指示符组成的国旗：U+1F1E6–U+1F1FF 的成对序列
+- Keycap 组合：[#*0-9] + U+FE0F? + U+20E3
+
+实现上直接使用完整序列正则匹配，覆盖 ZWJ 连接序列、国旗与 keycap。
+
+### 正则示意
+```
+const RE_EMOJI =
+  /(?:\p{Extended_Pictographic}(?:\uFE0F|[\u{1F3FB}-\u{1F3FF}])?(?:\u200D\p{Extended_Pictographic}(?:\uFE0F|[\u{1F3FB}-\u{1F3FF}])?)*)|(?:[\u{1F1E6}-\u{1F1FF}]{2})|(?:[#*0-9]\uFE0F?\u20E3)/gu
+```
+命中即判定为 emoji。
+
+## 报错信息
+- messageId: noEmoji
+- 文案：禁止在代码中使用 emoji
+
+## 典型示例
+### 触发
+- "hello🙂"
+- `title: "Nice 👍"`
+- <Text>欢迎🎉</Text>
+
+### 不触发
+- const icon = "face-smile"
+- <Text>{user.name}</Text>
+- "hello" + emojiName
+
+## 边界与决策
+- 模板字符串表达式部分：不深入解析，避免执行风险与复杂度
+- 正则字面量：不扫描，避免干扰正则语义
+- 注释：默认不扫描
+- 误报控制：提供 ignorePatterns，由使用者按文件或内容片段进行排除
+
+## 性能考虑
+- 仅在字符串节点上进行扫描
+- 正则预编译并复用
+- 对空字符串与短文本快速返回
+
+## 测试计划
+- 覆盖 Literal、TemplateLiteral、JSXText、JSXAttribute 四类节点
+- 覆盖 ZWJ 组合、变体选择符、国旗、keycap、皮肤色修饰符
+- 覆盖 ignorePatterns 行为

package/lib/__templates__/expo/eslint-plugins/react-native/index.js

@@ -0,0 +1,9 @@
+const wrapScrollViewInView = require('./rule')
+
+const plugin = {
+  rules: {
+    'wrap-horizontal-scrollview-inside-view': wrapScrollViewInView,
+  },
+};
+
+module.exports = plugin

package/lib/__templates__/expo/eslint-plugins/react-native/rule.js

@@ -0,0 +1,64 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: '禁止带有 horizontal: true 属性的 ScrollView 单独使用',
+      recommended: false,
+    },
+    schema: [],
+    messages: {
+      noSiblings: '禁止带有 props.horizontal: true 的 ScrollView 单独使用，需要在 ScrollView 外层使用一个单独的 View 组件进行包裹',
+    },
+  },
+  create(context) {
+    return {
+      JSXElement(node) {
+        const isScrollView = node.openingElement.name.name === 'ScrollView';
+
+        if (!isScrollView) {
+          return;
+        }
+
+        const hasHorizontalProp = node.openingElement.attributes.some(attr => {
+          if (attr.type === 'JSXAttribute' && attr.name.name === 'horizontal') {
+            if (!attr.value) {
+              return true;
+            }
+            if (
+              attr.value.type === 'JSXExpressionContainer' &&
+              attr.value.expression.value === true
+            ) {
+              return true; // horizontal={true}
+            }
+            if (attr.value.type === 'Literal' && attr.value.value === true) {
+              return true; // horizontal={true} 的另一种形式
+            }
+          }
+          return false;
+        });
+
+        if (!hasHorizontalProp) {
+          return;
+        }
+
+        const parent = node.parent;
+
+        if (
+          parent.type === 'JSXFragment' ||
+          parent.type === 'JSXElement'
+        ) {
+          const siblings = parent.children.filter(
+            child => child.type === 'JSXElement' && child !== node
+          );
+
+          if (siblings.length > 0) {
+            context.report({
+              node,
+              messageId: 'noSiblings',
+            });
+          }
+        }
+      },
+    };
+  },
+}

package/lib/__templates__/expo/eslint-plugins/reanimated/index.js

@@ -0,0 +1,9 @@
+const banMixUse = require('./rule')
+
+const plugin = {
+  rules: {
+    'ban-mix-use': banMixUse,
+  },
+};
+
+module.exports = plugin

package/lib/__templates__/expo/eslint-plugins/reanimated/rule.js

@@ -0,0 +1,88 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow passing useAnimatedScrollHandler return value to ScrollView',
+      recommended: 'error',
+    },
+    schema: [],
+    messages: {
+      noUseAnimatedScrollHandlerOnScroll:
+        'Do not pass useAnimatedScrollHandler return value to ScrollView, pass to Animated.ScrollView instead.',
+    },
+  },
+
+  create(context) {
+    // 记录 useAnimatedScrollHandler 的本地名字
+    let useAnimatedScrollHandlerImportName = null;
+    // 记录 ScrollView 的本地名字
+    let scrollViewImportName = null;
+    // 记录调用 useAnimatedScrollHandler 返回值的变量名
+    const animatedScrollHandlerVars = new Set();
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === 'react-native-reanimated') {
+          for (const specifier of node.specifiers) {
+            if (
+              specifier.type === 'ImportSpecifier' &&
+              specifier.imported.name === 'useAnimatedScrollHandler'
+            ) {
+              useAnimatedScrollHandlerImportName = specifier.local.name;
+            }
+          }
+        }
+
+        if (node.source.value === 'react-native') {
+          for (const specifier of node.specifiers) {
+            if (
+              specifier.type === 'ImportSpecifier' &&
+              specifier.imported.name === 'ScrollView'
+            ) {
+              scrollViewImportName = specifier.local.name;
+            }
+          }
+        }
+      },
+
+      VariableDeclarator(node) {
+        if (
+          node.init &&
+          node.init.type === 'CallExpression' &&
+          node.init.callee.type === 'Identifier' &&
+          node.init.callee.name === useAnimatedScrollHandlerImportName
+        ) {
+          if (node.id.type === 'Identifier') {
+            animatedScrollHandlerVars.add(node.id.name);
+          }
+        }
+      },
+
+      JSXOpeningElement(node) {
+        if (
+          node.name.type === 'JSXIdentifier' &&
+          node.name.name === scrollViewImportName
+        ) {
+          for (const attr of node.attributes) {
+            if (
+              attr.type === 'JSXAttribute' &&
+              attr.name.name === 'onScroll' &&
+              attr.value &&
+              attr.value.type === 'JSXExpressionContainer' &&
+              attr.value.expression.type === 'Identifier'
+            ) {
+              const varName = attr.value.expression.name;
+              if (animatedScrollHandlerVars.has(varName)) {
+                context.report({
+                  node: attr,
+                  messageId: 'noUseAnimatedScrollHandlerOnScroll',
+                });
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/lib/__templates__/expo/eslint-plugins/restrict-linear-gradient/index.js

@@ -0,0 +1,9 @@
+const noLinearGradientBackgroundColor = require('./rule')
+
+const plugin = {
+  rules: {
+    'no-linear-gradient-backgroundcolor': noLinearGradientBackgroundColor,
+  },
+}
+
+module.exports = plugin

package/lib/__templates__/expo/eslint-plugins/restrict-linear-gradient/rule.js

@@ -0,0 +1,120 @@
+const LINEAR_GRADIENT_RE = /linear-gradient/i
+
+function getPropertyKeyName(property) {
+  if (!property || property.type !== 'Property') return null
+  if (property.key.type === 'Identifier') return property.key.name
+  if (property.key.type === 'Literal' && typeof property.key.value === 'string') {
+    return property.key.value
+  }
+  return null
+}
+
+function getStaticStringValue(node) {
+  if (!node) return null
+  if (node.type === 'Literal' && typeof node.value === 'string') return node.value
+  if (node.type === 'TemplateLiteral') {
+    return node.quasis.map(quasi => quasi.value?.cooked || '').join('')
+  }
+  return null
+}
+
+function isLinearGradientString(text) {
+  if (!text) return false
+  return LINEAR_GRADIENT_RE.test(text)
+}
+
+function checkStyleObjectExpression(objectExpression, report) {
+  if (!objectExpression || objectExpression.type !== 'ObjectExpression') return
+  for (const property of objectExpression.properties) {
+    if (!property || property.type !== 'Property') continue
+    const keyName = getPropertyKeyName(property)
+    if (keyName !== 'backgroundColor') continue
+    const valueText = getStaticStringValue(property.value)
+    if (isLinearGradientString(valueText)) {
+      report(property.key || property)
+    }
+  }
+}
+
+function isStyleSheetMethodCall(node, methodName) {
+  if (!node || node.type !== 'CallExpression') return false
+  const callee = node.callee
+  if (!callee || callee.type !== 'MemberExpression') return false
+  if (callee.object.type !== 'Identifier' || callee.object.name !== 'StyleSheet') return false
+  if (callee.property.type === 'Identifier') return callee.property.name === methodName
+  return false
+}
+
+function checkStyleExpression(expression, report) {
+  if (!expression) return
+  if (expression.type === 'ObjectExpression') {
+    checkStyleObjectExpression(expression, report)
+    return
+  }
+  if (expression.type === 'ArrayExpression') {
+    for (const element of expression.elements) {
+      if (!element) continue
+      if (element.type === 'SpreadElement') {
+        checkStyleExpression(element.argument, report)
+      } else {
+        checkStyleExpression(element, report)
+      }
+    }
+    return
+  }
+  // 例：StyleSheet.flatten([styles.a, { backgroundColor: 'linear-gradient(...)' }])
+  if (isStyleSheetMethodCall(expression, 'flatten')) {
+    const arg = expression.arguments[0]
+    checkStyleExpression(arg, report)
+    return
+  }
+  // 例：StyleSheet.compose(styles.a, { backgroundColor: `linear-gradient(${angle},#fff,#000)` })
+  if (isStyleSheetMethodCall(expression, 'compose')) {
+    const [first, second] = expression.arguments
+    checkStyleExpression(first, report)
+    checkStyleExpression(second, report)
+  }
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow linear-gradient string in backgroundColor',
+      recommended: 'error',
+    },
+    schema: [],
+    messages: {
+      noLinearGradientBackgroundColor:
+        'backgroundColor 和 linear-gradient 无法一起使用，请将 backgroundColor 改为 experimental_backgroundImage',
+    },
+  },
+
+  create(context) {
+    function report(node) {
+      context.report({ node, messageId: 'noLinearGradientBackgroundColor' })
+    }
+
+    return {
+      CallExpression(node) {
+        if (!isStyleSheetMethodCall(node, 'create')) return
+        const firstArg = node.arguments[0]
+        if (!firstArg || firstArg.type !== 'ObjectExpression') return
+
+        checkStyleObjectExpression(firstArg, report)
+
+        for (const property of firstArg.properties) {
+          if (!property || property.type !== 'Property') continue
+          if (!property.value || property.value.type !== 'ObjectExpression') continue
+          checkStyleObjectExpression(property.value, report)
+        }
+      },
+
+      JSXAttribute(node) {
+        if (!node.name || node.name.name !== 'style') return
+        if (!node.value || node.value.type !== 'JSXExpressionContainer') return
+        checkStyleExpression(node.value.expression, report)
+      },
+    }
+  },
+}

package/lib/__templates__/expo/eslint-plugins/restrict-linear-gradient/tech.md

@@ -0,0 +1,58 @@
+# restrict-linear-gradient 技术设计
+
+## 目标
+- 禁止在 backgroundColor 中使用 linear-gradient 字符串
+- 覆盖 StyleSheet.create 与 JSX style 的常见写法
+- 实现轻量、易维护，不引入新依赖
+
+## 规则命名与对外形态
+- 插件目录：expo/eslint-plugins/restrict-linear-gradient
+- 规则名：restrict-linear-gradient/no-linear-gradient-backgroundcolor
+- 规则类型：problem
+- 默认等级：error
+
+## 规则行为定义
+### 报错
+当以下任一位置出现 backgroundColor 且值包含 linear-gradient( 时，报错：
+- StyleSheet.create 的样式对象中
+- JSX 元素 style 属性内的对象或数组成员
+
+### 不报错
+以下场景不触发：
+- 非 backgroundColor 的属性
+- backgroundColor 的非字符串值
+- 模板字符串包含表达式的动态值
+- 与 style 无关的对象字面量
+
+## 检测策略
+### StyleSheet.create
+遍历 StyleSheet.create 的首个参数对象，检查：
+- 顶层 backgroundColor
+- 每个样式项对应的对象内的 backgroundColor
+
+### JSX style
+定位 JSXAttribute(name=style) 后，检查表达式：
+- ObjectExpression
+- ArrayExpression 的各元素
+- StyleSheet.flatten / StyleSheet.compose 的参数
+
+## 线性渐变识别
+使用正则 /linear-gradient/i 检测字符串字面量与模板字符串静态片段。
+
+## 报错信息
+- messageId: noLinearGradientBackgroundColor
+- 文案：backgroundColor 和 linear-gradient 无法一起使用，请将 backgroundColor 改为 experimental_backgroundImage
+
+## 典型示例
+### 触发
+- StyleSheet.create({ a: { backgroundColor: 'linear-gradient(135deg,#F97316 0%,#FB923C 100%)' } })
+- <View style={{ backgroundColor: "linear-gradient(135deg,#F97316 0%,#FB923C 100%)" }} />
+- <View style={[{ backgroundColor: `linear-gradient(135deg,#F97316 0%,#FB923C 100%)` }]} />
+
+### 不触发
+- { background: 'linear-gradient(...)' }
+- { backgroundColor: someVar }
+
+## 性能考虑
+- 仅扫描目标节点与静态字符串
+- 早返回空节点与非字符串值

package/lib/__templates__/expo/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "expo-express-monorepo",
+  "private": true,
+  "version": "0.0.0",
+  "scripts": {
+    "dev": "bash .licosproj/scripts/dev_run.sh",
+    "build": "bash .licosproj/scripts/prod_build.sh",
+    "start": "bash .licosproj/scripts/prod_run.sh",
+    "preinstall": "npx only-allow pnpm",
+    "lint:client": "npm run lint --prefix ./client",
+    "lint:server": "npm run lint --prefix ./server",
+    "lint:all": "npm run lint --prefix ./client; npm run lint --prefix ./server"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "packageManager": "pnpm@9.0.0",
+  "engines": {
+    "pnpm": ">=9.0.0"
+  },
+  "pnpm": {
+    "overrides": {
+      "esbuild": "0.27.2"
+    },
+    "patchedDependencies": {
+      "expo@54.0.33": "patches/expo@54.0.33.patch"
+    }
+  }
+}

package/lib/__templates__/expo/patches/expo@54.0.33.patch

@@ -0,0 +1,45 @@
+diff --git a/src/async-require/hmr.ts b/src/async-require/hmr.ts
+index 33ce50ee2950c40d2b0553b148710f1e24e44f3d..3d78cb02dd7e96ac9727a2935d8178f2c7e95982 100644
+--- a/src/async-require/hmr.ts
++++ b/src/async-require/hmr.ts
+@@ -216,6 +216,40 @@ const HMRClient: HMRClientNativeInterface = {
+
+     client.on('update-done', () => {
+       hideLoading();
++      if (process.env.EXPO_PUBLIC_COZE_PROJECT_ID && typeof window !== 'undefined' && window.location) {
++        if((window as any).__updateTimeoutId) {
++          clearTimeout((window as any).__updateTimeoutId);
++        }
++        const updateDoneTime = Date.now();
++        (window as any).__updateDoneTime = updateDoneTime;
++        (window as any).__updateTimeoutId = setTimeout(() => {
++          const lastUpdateTime = (window as any).__updateDoneTime;
++          if (lastUpdateTime !== updateDoneTime) return;
++          const checkServerAndReload = (retriesLeft: number) => {
++            if ((window as any).__updateDoneTime !== updateDoneTime) return;
++            fetch(`/favicon.ico?_t=${Date.now()}`)
++              .then((response) => {
++                if (response.status === 200) {
++                  console.warn('[HMR] Server is ready (200), reloading now.');
++                  window.location.reload();
++                } else {
++                  throw new Error(`Server status: ${response.status}`);
++                }
++              }).catch((error) => {
++                console.warn(`[HMR] Check failed (${error.message}). Retries left: ${retriesLeft}`);
++                if (retriesLeft > 0) {
++                  setTimeout(() => {
++                    checkServerAndReload(retriesLeft - 1);
++                  }, 5000);
++                } else {
++                  console.error('[HMR] Server unreachable after 6 attempts. Abort reload.');
++                }
++              });
++          };
++          checkServerAndReload(6);
++        }, 35_000);
++      }
++      console.log('[HMR] Update done.');
+     });
+
+     client.on('error', (data: { type: string; message: string }) => {