@mybricks/plugin-ai 0.0.2 → 0.0.3

package/src/api/cloud-components.ts

@@ -1,129 +0,0 @@
-import { jsonSafeParse } from "./../tools/utils";
-import { context } from "../context";
-
-export interface CloudComponentMeta {
-  summary?: string;
-  description?: string;
-  [key: string]: any;
-}
-
-export interface CloudComponent {
-  namespace: string;
-  title?: string;
-  meta?: string;
-  summary?: string;
-  [key: string]: any;
-}
-
-interface CloudComponentsApiResponse {
-  data?: {
-    list?: CloudComponent[];
-    [key: string]: any;
-  };
-  list?: CloudComponent[];
-  [key: string]: any;
-}
-
-/**
- * 查询云组件列表（固定 URL）
- */
-export async function fetchCloudComponents(): Promise<CloudComponent[]> {
-  const url = `/api/material/list?type=component&tags=${encodeURIComponent('含提示词')}&page=1&pageSize=50`;
-
-  try {
-    const res = await fetch(url, { method: "GET" });
-    if (!res.ok) {
-      throw new Error(`Request failed with status ${res.status}`);
-    }
-
-    const json = (await res.json()) as CloudComponentsApiResponse;
-
-    console.log('json', json);
-    const list =
-      (json && json.data && Array.isArray(json.data.list) && json.data.list) ||
-      (Array.isArray(json.list) ? json.list : []) ||
-      [];
-
-    return list;
-  } catch (error) {
-    console.error("[plugin-ai] fetchCloudComponents error:", error);
-    return [];
-  }
-}
-
-/**
- * 将云组件列表转为「允许使用的组件」的 XML 片段
- * 约定：
- * - namespace 必填
- * - meta.summary 作为 description 使用（若无则尝试其它字段）
- * - 云组件统一视为 UI 组件
- */
-export function buildCloudComponentsPrompts(
-  components: CloudComponent[]
-): string {
-  if (!Array.isArray(components) || !components.length) {
-    return "";
-  }
-
-  return `<可以使用的MyBricks复合组件>
-  复合组件是封装好的MyBricks组件，通常比普通组件的功能更强大，但是没那么灵活，因此在使用时，需要根据具体需求选择合适的组件。
-  ${components.filter((item) => !!item?.namespace).map((item) => {
-
-    const meta = jsonSafeParse(item.meta as string || "{}");
-
-    return `<component>
-    <namespace>${item.namespace}</namespace>
-    <title>${item.title || ""}</title>
-    <description>${meta?.ai?.prompts?.summary || ""}</description>
-    ${meta?.ai?.prompts?.usage || ""}
-  </component>
-  `}).join("\n")}
-</可以使用的MyBricks复合组件>
-  `;
-}
-
-/**
- * 创建 getAllComDefPrompts 方法，返回原有组件信息 + 云组件信息
- */
-export function createGetAllComDefPrompts(
-  getAllComDefPrompts: (() => string) | undefined
-): () => string {
-  // 若未启用云组件，则直接返回原有的 getAllComDefPrompts（不请求云组件）
-  if (!context.useCloudComponents) {
-    return (): string => {
-      return getAllComDefPrompts?.() ?? "";
-    };
-  }
-
-  let cloudPrompts = "";
-  fetchCloudComponents()
-    .then((list) => {
-      cloudPrompts = buildCloudComponentsPrompts(list);
-    })
-    .catch((error) => {
-      console.error(
-        "[plugin-ai] createGetAllComDefPrompts fetchCloudComponents error:",
-        error
-      );
-      // 失败就保持 cloudPrompts 为空，只使用原有组件定义
-    });
-
-  return (): string => {
-    const base = getAllComDefPrompts?.() ?? "";
-
-    console.log('cloudPrompts', cloudPrompts);
-
-    if (!cloudPrompts) {
-      // 若云组件尚未加载完成，则只返回原有组件定义，避免影响正常使用
-      return base;
-    }
-
-    if (!base) {
-      return cloudPrompts;
-    }
-
-    return `${cloudPrompts}\n${base}\n`;
-  };
-}
-
-

package/src/api-record-replay/README.md

@@ -1,187 +0,0 @@
-# API 收集和回放功能
-
-## 概述
-
-该模块提供了对 `createPage`、`createCanvas`、`updatePage`、`updateUiCom`、`updateLogicCom` 这些 API 的收集和回放功能。
-
-## 使用方式
-
-### 在浏览器控制台中使用
-
-所有功能都通过 `window.APIRecordReplay` 对象提供：
-
-#### 1. 开始录制
-
-```javascript
-// 开始录制 API 调用
-window.APIRecordReplay.start();
-```
-
-#### 2. 执行操作
-
-录制开始后，所有对 `createPage`、`createCanvas`、`updatePage`、`updateUiCom`、`updateLogicCom` 的调用都会被自动记录。
-
-#### 3. 停止录制
-
-```javascript
-// 停止录制
-window.APIRecordReplay.stop();
-```
-
-#### 4. 导出记录
-
-```javascript
-// 导出为 JSON 字符串
-const jsonString = window.APIRecordReplay.dump();
-console.log(jsonString);
-
-// 或者获取记录数组
-const records = window.APIRecordReplay.getRecords();
-console.log(records);
-```
-
-#### 5. 回放记录
-
-```javascript
-// 回放当前录制的记录
-await window.APIRecordReplay.replay();
-
-// 或者从 JSON 字符串回放
-const jsonString = '[...]'; // 之前导出的 JSON
-await window.APIRecordReplay.replayFromJSON(jsonString);
-
-// 或者回放指定的记录数组
-const records = window.APIRecordReplay.getRecords();
-await window.APIRecordReplay.replay(records);
-```
-
-#### 6. 回放选项
-
-```javascript
-// 带选项的回放
-await window.APIRecordReplay.replay(undefined, {
-  // 忽略时间间隔，立即执行
-  ignoreDelay: false,
-  
-  // 时间间隔倍数（1.0 = 正常速度，2.0 = 2倍速，0.5 = 0.5倍速）
-  delayMultiplier: 1.0,
-  
-  // 每个操作执行前的回调
-  onBeforeAction: (action, index) => {
-    console.log(`准备执行操作 ${index}: ${action.type}`);
-  },
-  
-  // 每个操作执行后的回调
-  onAfterAction: (action, index, result) => {
-    console.log(`操作 ${index} 完成:`, result);
-  },
-  
-  // 回放完成后的回调
-  onComplete: () => {
-    console.log('回放完成');
-  },
-  
-  // 回放出错时的回调
-  onError: (error, action, index) => {
-    console.error(`操作 ${index} 出错:`, error);
-  }
-});
-```
-
-#### 7. 其他操作
-
-```javascript
-// 检查是否正在录制
-const isRecording = window.APIRecordReplay.isRecording();
-console.log('正在录制:', isRecording);
-
-// 清空记录
-window.APIRecordReplay.clear();
-```
-
-## 完整示例
-
-```javascript
-// 1. 开始录制
-window.APIRecordReplay.start();
-
-// 2. 执行一些操作（这些操作会被自动记录）
-// await context.designer.createPage('canvas-id', 'Page Title');
-// await context.designer.createCanvas();
-// await context.designer.updatePage(...args);
-// await context.designer.updateUiCom(...args);
-// await context.designer.updateLogicCom(...args);
-
-// 3. 停止录制
-window.APIRecordReplay.stop();
-
-// 4. 导出记录
-const jsonString = window.APIRecordReplay.dump();
-console.log('导出的 JSON:', jsonString);
-
-// 5. 保存到文件或复制到剪贴板
-// copy(jsonString); // 如果浏览器支持
-
-// 6. 回放记录
-await window.APIRecordReplay.replay({
-  onBeforeAction: (action, index) => {
-    console.log(`执行操作 ${index + 1}: ${action.type}`);
-  },
-  onComplete: () => {
-    console.log('回放完成');
-  }
-});
-```
-
-## 记录格式
-
-记录的 JSON 格式如下：
-
-```json
-[
-  {
-    "type": "createPage",
-    "params": ["canvas-id", "Page Title", { "config": "value" }],
-    "delay": 0,
-    "timestamp": 1234567890123
-  },
-  {
-    "type": "createCanvas",
-    "params": [],
-    "delay": 100,
-    "timestamp": 1234567890223
-  },
-  {
-    "type": "updatePage",
-    "params": [["action1"], "ing"],
-    "delay": 50,
-    "timestamp": 1234567890273
-  },
-  {
-    "type": "updateUiCom",
-    "params": ["comId", ["action1"], "ing"],
-    "delay": 30,
-    "timestamp": 1234567890303
-  },
-  {
-    "type": "updateLogicCom",
-    "params": ["comId", ["action1"], "ing"],
-    "delay": 30,
-    "timestamp": 1234567890333
-  }
-]
-```
-
-- `type`: 操作类型（'createPage' | 'createCanvas' | 'updatePage' | 'updateUiCom' | 'updateLogicCom'）
-- `params`: 调用参数数组
-- `delay`: 距离上一次调用的时间间隔（毫秒）
-- `timestamp`: 时间戳（可选，用于调试）
-
-## 注意事项
-
-1. 录制功能会自动在 API 调用时记录，无需手动调用记录方法
-2. 函数参数会被序列化为特殊标记，无法完全还原
-3. 回放时会按照原始时间间隔执行，确保使用 `await` 等待完成
-4. 如果 API 调用失败，默认会继续执行后续操作，错误会通过 `onError` 回调通知
-5. 回放使用的是当前上下文中的 API，确保 API 可用
-

package/src/api-record-replay/index.ts

@@ -1,11 +0,0 @@
-/**
- * API 收集和回放统一导出
- */
-
-import { apiRecorder, RecordedAction, RecordedActionType } from './recorder';
-import { replay, replayFromJSON, ReplayAPI, ReplayOptions } from './replayer';
-import { APIRecordReplayManager } from './manager';
-
-export { apiRecorder, replay, replayFromJSON, APIRecordReplayManager };
-export type { RecordedAction, RecordedActionType, ReplayAPI, ReplayOptions };
-

package/src/api-record-replay/manager.ts

@@ -1,168 +0,0 @@
-/**
- * API 记录和回放管理器
- * 提供录制、dump 和回放功能
- */
-
-import { apiRecorder, RecordedAction } from './recorder';
-import { replay, replayFromJSON, ReplayAPI, ReplayOptions } from './replayer';
-import { context } from '../context';
-
-/**
- * 获取 API 实例的辅助函数
- * 从 context.designer 获取 API
- */
-function getAPI() {
-  return context.designer;
-}
-
-/**
- * API 记录和回放管理器
- * 提供录制、dump 和回放功能
- */
-export class APIRecordReplayManager {
-  /**
-   * 开始录制 API 调用
-   */
-  start() {
-    apiRecorder.start();
-    console.log('[APIRecordReplay] 开始录制');
-  }
-
-  /**
-   * 停止录制
-   */
-  stop() {
-    apiRecorder.stop();
-    console.log('[APIRecordReplay] 停止录制');
-  }
-
-  /**
-   * 导出录制的 JSON 字符串
-   * @returns JSON 字符串
-   */
-  dump(): string {
-    const json = apiRecorder.dump();
-    console.log('[APIRecordReplay] 导出记录:', json);
-    return json;
-  }
-
-  /**
-   * 获取记录数组
-   * @returns 记录数组
-   */
-  getRecords(): RecordedAction[] {
-    return apiRecorder.getRecords();
-  }
-
-  /**
-   * 清空记录
-   */
-  clear() {
-    apiRecorder.clear();
-    console.log('[APIRecordReplay] 已清空记录');
-  }
-
-  /**
-   * 检查是否正在录制
-   * @returns 是否正在录制
-   */
-  isRecording(): boolean {
-    return apiRecorder.getRecording();
-  }
-
-  /**
-   * 回放记录的 API 调用
-   * @param records 记录数组（可选，如果不提供则使用当前录制的记录）
-   * @param options 回放选项（可选）
-   */
-  async replay(records?: RecordedAction[], options?: ReplayOptions) {
-    const api = getAPI();
-    if (!api) {
-      console.error('[APIRecordReplay] API 不可用');
-      return;
-    }
-
-    const replayAPI: ReplayAPI = {
-      createPage: api.createPage!.bind(api),
-      createCanvas: api.createCanvas!.bind(api),
-      updatePage: api.updatePage!.bind(api),
-      updateUiCom: api.updateUiCom!.bind(api),
-      updateLogicCom: api.updateLogicCom!.bind(api),
-      createDiagram: api.createDiagram!.bind(api),
-      updateDiagram: api.updateDiagram!.bind(api)
-    };
-
-    const recordsToReplay = records || apiRecorder.getRecords();
-    
-    if (recordsToReplay.length === 0) {
-      console.warn('[APIRecordReplay] 没有可回放的记录');
-      return;
-    }
-
-    console.log(`[APIRecordReplay] 开始回放 ${recordsToReplay.length} 条记录`);
-    
-    await replay(recordsToReplay, replayAPI, {
-      onBeforeAction: (action, index) => {
-        console.log(`[APIRecordReplay] 执行操作 ${index + 1}/${recordsToReplay.length}: ${action.type}`);
-        options?.onBeforeAction?.(action, index);
-      },
-      onAfterAction: (action, index, result) => {
-        options?.onAfterAction?.(action, index, result);
-      },
-      onComplete: () => {
-        console.log('[APIRecordReplay] 回放完成');
-        options?.onComplete?.();
-      },
-      onError: (error, action, index) => {
-        console.error(`[APIRecordReplay] 回放出错:`, error);
-        options?.onError?.(error, action, index);
-      },
-      ...options
-    });
-  }
-
-  /**
-   * 从 JSON 字符串回放
-   * @param jsonString JSON 字符串
-   * @param options 回放选项（可选）
-   */
-  async replayFromJSON(jsonString: string, options?: ReplayOptions) {
-    const api = getAPI();
-    if (!api) {
-      console.error('[APIRecordReplay] API 不可用');
-      return;
-    }
-
-    const replayAPI: ReplayAPI = {
-      createPage: api.createPage!.bind(api),
-      createCanvas: api.createCanvas!.bind(api),
-      updatePage: api.updatePage!.bind(api),
-      updateUiCom: api.updateUiCom!.bind(api),
-      updateLogicCom: api.updateLogicCom!.bind(api),
-      createDiagram: api.createDiagram!.bind(api),
-      updateDiagram: api.updateDiagram!.bind(api)
-    };
-
-    console.log('[APIRecordReplay] 从 JSON 开始回放');
-    
-    await replayFromJSON(jsonString, replayAPI, {
-      onBeforeAction: (action, index) => {
-        console.log(`[APIRecordReplay] 执行操作 ${index + 1}: ${action.type}`);
-        options?.onBeforeAction?.(action, index);
-      },
-      onAfterAction: (action, index, result) => {
-        options?.onAfterAction?.(action, index, result);
-      },
-      onComplete: () => {
-        console.log('[APIRecordReplay] 回放完成');
-        options?.onComplete?.();
-      },
-      onError: (error, action, index) => {
-        console.error(`[APIRecordReplay] 回放出错:`, error);
-        options?.onError?.(error, action, index);
-      },
-      ...options
-    });
-  }
-}
-

package/src/api-record-replay/replayer.ts

@@ -1,148 +0,0 @@
-/**
- * API 调用回放模块
- * 根据记录的 JSON 序列执行回放
- */
-
-import { RecordedAction, RecordedActionType } from './recorder';
-
-export interface ReplayOptions {
-  /** 是否忽略时间间隔，立即执行 */
-  ignoreDelay?: boolean;
-  /** 时间间隔的倍数（用于加速或减速回放） */
-  delayMultiplier?: number;
-  /** 每个操作执行前的回调 */
-  onBeforeAction?: (action: RecordedAction, index: number) => void;
-  /** 每个操作执行后的回调 */
-  onAfterAction?: (action: RecordedAction, index: number, result: any) => void;
-  /** 回放完成后的回调 */
-  onComplete?: () => void;
-  /** 回放出错时的回调 */
-  onError?: (error: Error, action: RecordedAction, index: number) => void;
-}
-
-export interface ReplayAPI {
-  createPage: (id: string, title: string, config?: any) => Promise<{ id: string; onProgress: Function; }>;
-  createCanvas: () => Promise<{ id: string; title: string; }>;
-  updatePage: (...params: any[]) => Promise<void>;
-  updateUiCom: (...params: any[]) => Promise<void>;
-  updateLogicCom: (...params: any[]) => Promise<void>;
-  createDiagram: (...params: any[]) => Promise<any>;
-  updateDiagram: (...params: any[]) => Promise<any>;
-}
-
-/**
- * 回放记录的 API 调用
- * @param records 记录的 API 调用序列
- * @param api API 实现对象
- * @param options 回放选项
- */
-export async function replay(
-  records: RecordedAction[],
-  api: ReplayAPI,
-  options: ReplayOptions = {}
-): Promise<void> {
-  const {
-    ignoreDelay = false,
-    delayMultiplier = 1,
-    onBeforeAction,
-    onAfterAction,
-    onComplete,
-    onError,
-  } = options;
-
-  for (let i = 0; i < records.length; i++) {
-    const action = records[i];
-
-    try {
-      // 执行前回调
-      onBeforeAction?.(action, i);
-
-      // 等待时间间隔
-      if (!ignoreDelay && action.delay > 0) {
-        const delay = action.delay * delayMultiplier;
-        await sleep(delay);
-      }
-
-      // 执行 API 调用
-      let result: any;
-      switch (action.type) {
-        case 'createPage': {
-          const [id, title, config] = action.params;
-          result = await api.createPage(id, title, config);
-          break;
-        }
-        case 'createCanvas': {
-          result = await api.createCanvas();
-          break;
-        }
-        case 'updatePage': {
-          // updatePage 的参数是展开的，需要展开传递
-          result = await api.updatePage(...action.params);
-          break;
-        }
-        case 'updateUiCom': {
-          // updateUiCom 的参数是展开的，需要展开传递
-          result = await api.updateUiCom(...action.params);
-          break;
-        }
-        case 'updateLogicCom': {
-          // updateLogicCom 的参数是展开的，需要展开传递
-          result = await api.updateLogicCom(...action.params);
-          break;
-        }
-        case 'createDiagram': {
-          // createDiagram 的参数是展开的，需要展开传递
-          result = await api.createDiagram(...action.params);
-          break;
-        }
-        case 'updateDiagram': {
-          // updateDiagram 的参数是展开的，需要展开传递
-          result = await api.updateDiagram(...action.params);
-          break;
-        }
-        default:
-          throw new Error(`Unknown action type: ${(action as any).type}`);
-      }
-
-      // 执行后回调
-      onAfterAction?.(action, i, result);
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      onError?.(err, action, i);
-      
-      // 根据选项决定是否继续执行
-      // 默认继续执行，只记录错误
-      console.error(`Replay error at action ${i} (${action.type}):`, err);
-    }
-  }
-
-  // 完成回调
-  onComplete?.();
-}
-
-/**
- * 从 JSON 字符串加载并回放
- * @param jsonString JSON 字符串
- * @param api API 实现对象
- * @param options 回放选项
- */
-export async function replayFromJSON(
-  jsonString: string,
-  api: ReplayAPI,
-  options: ReplayOptions = {}
-): Promise<void> {
-  try {
-    const records: RecordedAction[] = JSON.parse(jsonString);
-    await replay(records, api, options);
-  } catch (error) {
-    throw new Error(`Failed to parse replay JSON: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-/**
- * 睡眠函数
- */
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-