@mybricks/plugin-ai 0.0.1 → 0.0.2

package/src/agents/workspace-by-knowledges/utils/components-manager.ts

@@ -0,0 +1,145 @@
+export class ComponentsManager {
+  private static isLoaded = false
+  private static aiComponentMap = new Map<string, any>()
+  private static namespaceAbbrevMap = new Map<string, string>() // 缩写 -> 完整namespace
+  private static abbreviationMap = new Map<string, string>() // 完整namespace -> 缩写
+
+  private static init = () => {
+    if (this.isLoaded) {
+      return
+    }
+    if (!window.__comlibs_edit_) {
+      return
+    }
+
+    const forEachComponent = (com: any, callback: (com: any) => void) => {
+      if (com?.namespace) {
+        callback?.(com)
+      }
+      if (Array.isArray(com?.comAray)) {
+        com?.comAray.forEach((child: any) => {
+          forEachComponent(child, callback)
+        })
+      }
+    }
+
+    window.__comlibs_edit_.forEach((comlib: any) => {
+      forEachComponent(comlib, (com) => {
+        if (com?.ai) {
+          this.aiComponentMap.set(com.namespace, {
+            ...com.ai,
+            all: com
+          })
+          
+          const abbreviation = com.namespace
+            .replace('mybricks.normal-pc.antd5.', 'pc.')
+            .replace('mybricks.normal-pc.', 'pc.')
+            .replace('mybricks.harmony.', 'mb.')
+            .replace('mybricks.taro.', 'mb.')
+          
+          // 收集缩写映射关系
+          if (abbreviation !== com.namespace) {
+            this.namespaceAbbrevMap.set(abbreviation, com.namespace)
+            this.abbreviationMap.set(com.namespace, abbreviation)
+          }
+        }
+      })
+    })
+
+    this.isLoaded = true
+  }
+
+  static getRequireComponents = (ns: string): any[] => {
+    this.init()
+
+    let res: any[] = []
+    if (this.aiComponentMap.has(ns)) {
+      const ai = this.aiComponentMap.get(ns)
+      if (Array.isArray(ai.requires)) {
+        res = res.concat(ai.requires)
+      }
+    }
+    return res
+  }
+
+  /**
+   * 判断是否为布局组件（asLayout）
+   */
+  static isLayoutComponent = (namespace: string): boolean => {
+    this.init()
+    const ai = this.aiComponentMap.get(this.getFullNamespace(namespace))
+    return !!ai?.asLayout
+  }
+
+  /**
+   * 获取所有布局组件的 namespace 缩写数组
+   */
+  static getLayoutComponentsAbbreviationNs = (): string[] => {
+    this.init()
+    const res: string[] = []
+
+    this.aiComponentMap.forEach((ai, namespace) => {
+      if (ai?.asLayout) {
+        res.push(this.getAbbreviation(namespace))
+      }
+    })
+
+    return res
+  }
+
+  /**
+   * 根据完整namespace获取缩写
+   * @param namespace 完整的namespace
+   * @returns 缩写namespace，如果没有缩写则返回原namespace
+   */
+  static getAbbreviation = (namespace: string): string => {
+    this.init()
+    return this.abbreviationMap.get(namespace) || namespace
+  }
+
+  /**
+   * 根据缩写获取完整namespace
+   * @param abbreviation 缩写
+   * @returns 完整namespace，如果没有对应的完整namespace则返回原缩写
+   */
+  static getFullNamespace = (abbreviation: string): string => {
+    this.init()
+    return this.namespaceAbbrevMap.get(abbreviation) || abbreviation
+  }
+
+  /**
+   * 重置加载状态（用于测试或重新初始化）
+   */
+  static reset = () => {
+    this.isLoaded = false
+    this.aiComponentMap.clear()
+    this.namespaceAbbrevMap.clear()
+    this.abbreviationMap.clear()
+  }
+
+  static getAiComponent(namespace: string) {
+    this.init()
+    return this.aiComponentMap.get(namespace)
+  }
+
+  /**
+   * 获取所有可用的AI组件列表
+   * @returns 组件列表，包含 namespace, name, abbreviation, description
+   */
+  static getAllComponents(): Array<{ namespace: string; name: string; abbreviation: string; description: string }> {
+    this.init()
+    const components: Array<{ namespace: string; name: string; abbreviation: string; description: string }> = []
+
+    this.aiComponentMap.forEach((ai, namespace) => {
+      components.push({
+        namespace: namespace,
+        name: ai.all?.title || namespace,
+        abbreviation: this.getAbbreviation(namespace),
+        description: ai.all?.description || ''
+      })
+    })
+
+    return components
+  }
+}
+

package/src/agents/workspace-by-knowledges/utils/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Utils 导出
+ */
+
+export * from './components-manager';
+export * from './outline-info';
+export * from './outline-focus';
+

package/src/agents/workspace-by-knowledges/utils/outline-focus.ts

@@ -0,0 +1,178 @@
+import { OutlineInfoManager, type OutlineNode, type SlotInfo } from './outline-info';
+import { ComponentsManager } from './components-manager';
+import { FocusInfo } from '../types';
+
+class PageHierarchyGenerator {
+  static generate(outlineInfo: OutlineNode, currentFocus: FocusInfo): string {
+    const processedData = currentFocus.type === 'uiCom'
+      ? this.filterToFocusedComponent(outlineInfo, currentFocus.comId!)
+      : outlineInfo;
+
+    return this.generateTreeDescription(processedData as OutlineNode, {
+      pageId: currentFocus.pageId,
+      comId: currentFocus.comId,
+    });
+  }
+
+  private static containsComponent(data: OutlineNode, targetId: string): boolean {
+    if (!data) return false;
+    if (data.id === targetId) return true;
+
+    if (data.slots && Array.isArray(data.slots)) {
+      return data.slots.some(slot => {
+        if (slot.components && Array.isArray(slot.components)) {
+          return slot.components.some(component => this.containsComponent(component, targetId));
+        }
+        return false;
+      });
+    }
+    return false;
+  }
+
+  private static hasChildren(data: OutlineNode): boolean {
+    if (!data?.slots || !Array.isArray(data.slots)) {
+      return false;
+    }
+    return data.slots.some(slot => {
+      return slot.components && Array.isArray(slot.components) && slot.components.length > 0;
+    });
+  }
+
+  private static filterToFocusedComponent(data: OutlineNode, targetId: string): OutlineNode | null {
+    if (!data) return null;
+
+    if (data.id === targetId) {
+      return data;
+    }
+
+    if (data.slots && Array.isArray(data.slots)) {
+      const filteredSlots = data.slots.map(slot => {
+        if (slot.components && Array.isArray(slot.components)) {
+          const filteredComponents = slot.components.map(component => {
+            if (this.containsComponent(component, targetId)) {
+              return this.filterToFocusedComponent(component, targetId);
+            } else {
+              const hasChildComponents = this.hasChildren(component);
+              return {
+                ...component,
+                slots: undefined,
+                _hasCollapsedChildren: hasChildComponents
+              };
+            }
+          }).filter(Boolean) as OutlineNode[];
+
+          return filteredComponents.length > 0 ? { ...slot, components: filteredComponents } : null;
+        }
+        return null;
+      }).filter(Boolean) as SlotInfo[];
+
+      if (filteredSlots.length > 0) {
+        return { ...data, slots: filteredSlots };
+      }
+    }
+    return null;
+  }
+
+  private static generateTreeDescription(data: OutlineNode | OutlineNode[], focusInfo: FocusInfo, level = 0): string {
+    const indent = '  '.repeat(level);
+    let result = '';
+
+    if (!data) {
+      return '无内容，代表内容为空';
+    }
+
+    if (Array.isArray(data)) {
+      if (data.length === 0) {
+        return '无内容，代表内容为空';
+      }
+      data.forEach(item => {
+        result += this.generateTreeDescription(item, focusInfo, level);
+      });
+      return result;
+    }
+
+    if (data.asRoot) {
+      if (Array.isArray(data.slots?.[0]?.components)) {
+        data.slots?.[0]?.components.forEach(component => {
+          result += this.generateTreeDescription(component, focusInfo, level);
+        });
+        return result;
+      }
+    }
+
+    if (data.title) {
+      const namespace = data.def?.namespace;
+      const isFocused = data.id === focusInfo.comId ||
+        data.id === focusInfo.pageId;
+      const focusMarker = isFocused ? ' 【当前聚焦】' : '';
+      const collapsedMarker = data._hasCollapsedChildren ? ' 【子组件已折叠】' : '';
+
+      result += `${indent}- ${data.title}[id=${data.id}]${namespace ? `(${ComponentsManager.getAbbreviation(namespace)})` : ''}${focusMarker}${collapsedMarker}\n`;
+    }
+
+    if (data.slots && Array.isArray(data.slots)) {
+      data.slots.forEach(slot => {
+        if (slot.components && Array.isArray(slot.components)) {
+          slot.components.forEach(component => {
+            result += this.generateTreeDescription(component, focusInfo, level + 1);
+          });
+        }
+      });
+    }
+
+    return result;
+  }
+}
+
+class FocusDescriptionGenerator {
+  static generate(currentFocus: FocusInfo): string {
+    const { pageId, comId, title, type } = currentFocus ?? {};
+
+    if (!currentFocus || (!currentFocus.pageId && !currentFocus.comId)) {
+      return '当前没有聚焦到任何页面或组件。';
+    }
+
+    let focusDesc = '';
+
+    switch (type) {
+      case 'uiCom':
+        focusDesc = `组件(title=${title},组件id=${comId})`;
+        break;
+      case 'page':
+      case 'section':
+        focusDesc = `页面(title=${title},页面id=${pageId})`;
+        break;
+      default:
+        focusDesc = `未知类型(title=${title})`;
+    }
+
+    return `当前已聚焦到${focusDesc}中，后续用户的提问，关于"这个"、"此"、"整体"，甚至不提主语，都是指代此元素及其子组件内容。`;
+  }
+}
+
+export class FocusOutlineInfoManager extends OutlineInfoManager {
+  private focusInfo: FocusInfo;
+  private focusPageOutlineInfo: OutlineNode | null;
+
+  constructor({ api, focusInfo }: { api: any, focusInfo: FocusInfo }) {
+    super({ api });
+    this.focusInfo = { ...focusInfo };
+    this.focusPageOutlineInfo = focusInfo?.pageId ? this.getPageOutline(focusInfo.pageId) : null;
+  }
+
+  getFocusPageOutline(): OutlineNode | null {
+    return this.focusPageOutlineInfo;
+  }
+
+  generateFocusHierarchy(): string {
+    if (!this.focusPageOutlineInfo || !this.focusInfo?.pageId) {
+      return '无内容，代表内容为空';
+    }
+    return PageHierarchyGenerator.generate(this.focusPageOutlineInfo, this.focusInfo);
+  }
+
+  generateFocusDescription(): string {
+    return FocusDescriptionGenerator.generate(this.focusInfo);
+  }
+}
+