@epxing/business 0.0.0-stage → 5.3.0-beta.2

package/dist/src/base/AiSkillEditor.vue.js

@@ -0,0 +1,1176 @@
+import "codemirror/lib/codemirror.css";
+import "codemirror/mode/markdown/markdown.js";
+import "codemirror/addon/display/placeholder.js";
+import __cjsReq0 from "codemirror";
+import { component } from "@epxing/core/src/mixins";
+import "highlight.js/styles/base16/atelier-forest.min.css";
+import { loadMarkdownDeps, escapeFallback } from "@epxing/components/src/ai-chat-page/markdown";
+const __compatRequireEnsure = (_deps, cb) => Promise.resolve().then(() => cb && cb());
+function injectSourceLine(tokens, idx, options, _env, slf) {
+  const token = tokens[idx];
+  if (token.map && token.nesting >= 0) {
+    token.attrSet("data-source-line", String(token.map[0]));
+  }
+  return slf.renderToken(tokens, idx, options);
+}
+let md = null;
+function buildMd(markdownit, hljs) {
+  const md2 = markdownit({
+    highlight(str, lang) {
+      if (lang && hljs.getLanguage(lang)) {
+        try {
+          return '<pre><code class="hljs">' + hljs.highlight(str, {
+            language: lang,
+            ignoreIllegals: true
+          }).value + "</code></pre>";
+        } catch (__) {
+        }
+      }
+      return '<pre><code class="hljs">' + md2.utils.escapeHtml(str) + "</code></pre>";
+    }
+  });
+  md2.renderer.rules.link_open = function(tokens, idx, options, _env, self) {
+    if (tokens[idx].attrIndex("target") === -1) {
+      tokens[idx].attrPush(["target", "_blank"]);
+      tokens[idx].attrPush(["rel", "noopener noreferrer"]);
+    }
+    return self.renderToken(tokens, idx, options);
+  };
+  md2.renderer.rules.paragraph_open = injectSourceLine;
+  md2.renderer.rules.heading_open = injectSourceLine;
+  md2.renderer.rules.blockquote_open = injectSourceLine;
+  md2.renderer.rules.bullet_list_open = injectSourceLine;
+  md2.renderer.rules.ordered_list_open = injectSourceLine;
+  md2.renderer.rules.list_item_open = injectSourceLine;
+  md2.renderer.rules.table_open = injectSourceLine;
+  md2.renderer.rules.hr = injectSourceLine;
+  return md2;
+}
+function renderMd(text) {
+  return md ? md.render(text) : escapeFallback(text);
+}
+const _sfc_main = {
+  name: "epx-base-ai-skill-editor",
+  mixins: [component],
+  props: {
+    value: {
+      type: String,
+      default: ""
+    },
+    formData: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    // 关联的 agent id，用于加载工具列表
+    agentId: {
+      type: String,
+      default: ""
+    },
+    pageType: String,
+    // 单个保存模式：显示保存按钮，点击后保存当前内容
+    singleSave: {
+      type: Boolean,
+      default: false
+    },
+    // 动态参数树（流程节点变量等）。传入后快捷插入弹窗显示「动态参数」tab，预览中将 {{code}} 渲染为参数标签
+    globalParamsData: {
+      type: Array,
+      default() {
+        return [];
+      }
+    },
+    // 是否启用「公式」插入（复用 epx-rule）
+    showFormula: {
+      type: Boolean,
+      default: false
+    }
+  },
+  computed: {
+    // 组件标题：优先使用 prop title，其次使用 $configs.attriLabel，最后使用 compTitle
+    componentTitle() {
+      return this.title || this.$configs.attriLabel || this.compTitle || "技能编辑器";
+    },
+    // 组件类型：从 $configs 获取
+    componentType() {
+      return this.$configs.componentType || this.pageType;
+    },
+    // 是否为详情/只读模式
+    isDetailMode() {
+      return this.componentType === "DETAIL" || this.componentType === "READONLY";
+    },
+    // 是否启用单个保存模式：优先 prop，其次 $configs 配置
+    isSingleSave() {
+      return this.singleSave || this.$configs.singleSave === true;
+    },
+    // 是否有可插入的动态参数
+    hasDynamicParam() {
+      return Array.isArray(this.globalParamsData) && this.globalParamsData.length > 0;
+    },
+    // 动态参数 code -> 显示名 映射（用于预览渲染）
+    paramNameMap() {
+      const map = {};
+      const walk = (list) => {
+        (list || []).forEach((node) => {
+          if (node.code) map[node.code] = node.text;
+          if (node.children && node.children.length) walk(node.children);
+        });
+      };
+      walk(this.globalParamsData);
+      return map;
+    }
+  },
+  data() {
+    return {
+      editor: null,
+      hasContent: false,
+      isFullscreen: false,
+      editorMode: "split",
+      // edit | split | preview
+      saving: false,
+      // 保存中状态
+      contentChanged: false,
+      // 内容是否已修改
+      lastSavedContent: "",
+      // 上次保存的内容
+      // 快捷插入弹窗
+      quickInsertVisible: false,
+      quickInsertTab: "function",
+      // 记录触发 / 时的光标位置，用于插入后删除 /
+      slashCursor: null,
+      // 提示词函数
+      functionList: [],
+      // 提示词模板
+      templateList: [],
+      // 对象接口
+      apiActiveTab: "frame",
+      selectedEntity: null,
+      apiList: [],
+      apiTotal: 0,
+      // 通用接口
+      frameApiList: [],
+      frameApiTotal: 0,
+      frameApiCurrentPage: 1,
+      frameApiPageSize: 10,
+      // 外部接口
+      externalApiList: [],
+      externalApiTotal: 0,
+      externalApiCurrentPage: 1,
+      externalApiPageSize: 10,
+      // 子智能体
+      subAgentList: [],
+      subAgentTotal: 0,
+      subAgentCurrentPage: 1,
+      subAgentPageSize: 10,
+      // 内置工具
+      sysToolList: [],
+      sysToolTotal: 0,
+      sysToolCurrentPage: 1,
+      sysToolPageSize: 10,
+      // 技能
+      skillActiveTab: "system",
+      skillList: [],
+      skillTotal: 0,
+      skillCurrentPage: 1,
+      skillPageSize: 10,
+      // 配置文档（树形）
+      docTree: [],
+      docFilterText: "",
+      // 公式（epx-rule）
+      ruleInfo: "",
+      formulaLibrary: [],
+      formulaCursor: null,
+      mdReady: false
+    };
+  },
+  created() {
+    loadMarkdownDeps().then((d) => {
+      if (!md) md = buildMd(d.markdownit, d.hljs);
+      this.mdReady = true;
+      this.updatePreview(this.editor ? this.editor.getValue() : this.value || "");
+    });
+  },
+  watch: {
+    // 外部 value prop 变化时同步
+    value(val) {
+      if (this.editor && !this._emitting && val !== this.editor.getValue()) {
+        this.editor.setValue(val || "");
+        this.hasContent = (val || "").length > 0;
+      }
+    },
+    // formData 变化时，从 updateField 字段同步到编辑器
+    formData: {
+      deep: true,
+      handler(val) {
+        if (!this.editor || this._emitting) return;
+        const field = this.$configs.updateField || this.$configs.fieldKey;
+        if (!field) return;
+        const newVal = val && val[field] || "";
+        if (newVal !== this.editor.getValue()) {
+          this.editor.setValue(newVal);
+          this.hasContent = newVal.length > 0;
+        }
+      }
+    },
+    // 配置文档树过滤
+    docFilterText(val) {
+      if (this.$refs.docTree) this.$refs.docTree.filter(val);
+    }
+  },
+  mounted() {
+    this.initEditor();
+    this.loadFunctionList();
+    this.loadTemplateList();
+    this.loadFrameApiList();
+    this.loadExternalApiList();
+    this.loadSubAgentList();
+    this.loadSysToolList();
+    if (this.isSingleSave) this.loadSkillList();
+    if (this.showFormula) this.loadFormulaLibrary();
+    this.loadDocTree();
+  },
+  beforeUnmount() {
+    clearTimeout(this._scrollLockTimer);
+    window.removeEventListener("resize", this.invalidateAnchorCache);
+    if (this.editor) {
+      this.editor.toTextArea();
+      this.editor = null;
+    }
+  },
+  methods: {
+    // ─── 初始化编辑器 ────────────────────────────────────────────
+    initEditor() {
+      __compatRequireEnsure([], () => {
+        const CodeMirror = __cjsReq0;
+        globalThis.codemirror = CodeMirror;
+        this.editor = CodeMirror.fromTextArea(this.$refs.textarea, {
+          mode: "markdown",
+          lineWrapping: true,
+          lineNumbers: false,
+          autofocus: false,
+          inputStyle: "contenteditable",
+          placeholder: '输入 "/" 可快捷插入工具和函数'
+        });
+        const field = this.$configs.updateField || this.$configs.fieldKey;
+        const initialValue = field && this.formData && this.formData[field] || this.value || "";
+        if (initialValue) {
+          this.editor.setValue(initialValue);
+          this.hasContent = true;
+        }
+        this.lastSavedContent = this.editor.getValue();
+        this.editor.on("change", (editor, change) => {
+          const val = editor.getValue();
+          this.hasContent = val.length > 0;
+          this.contentChanged = val !== this.lastSavedContent;
+          this.emitChange(val);
+          this.updatePreview(val);
+          if (change.origin === "+input" && change.text && change.text[0] === "/") {
+            this.slashCursor = {
+              line: change.from.line,
+              ch: change.from.ch
+            };
+            this.$nextTick(() => {
+              this.openQuickInsert();
+            });
+          }
+        });
+        if (this.isSingleSave) {
+          this.editor.on("blur", () => {
+            if (this.contentChanged && !this.saving) {
+              this.saveContent(true);
+            }
+          });
+        }
+        this.editor.on("scroll", this.handleEditorScroll);
+        window.addEventListener("resize", this.invalidateAnchorCache);
+        this.updatePreview(this.editor.getValue());
+        this.$nextTick(() => {
+          if (this.editor) this.editor.refresh();
+        });
+      });
+    },
+    // 保存（点击保存按钮触发；silent=true 时为失焦自动保存，不弹成功提示）
+    saveContent(silent = false) {
+      const field = this.$configs.updateField || this.$configs.fieldKey;
+      if (!field || !this.$metaId || !this.formData.ID) {
+        if (!silent) this.$message.warning("保存配置不完整");
+        return;
+      }
+      const value = this.editor ? this.editor.getValue() : "";
+      this.saving = true;
+      this.$http.save({
+        action: "update",
+        entityId: this.$metaId,
+        bean: {
+          ID: this.formData.ID,
+          [field]: value
+        }
+      }).then(() => {
+        this.lastSavedContent = value;
+        this.contentChanged = false;
+        this.emitChange(value, true);
+        if (!silent) this.$message.success("保存成功");
+      }).catch((err) => {
+        this.$message.error(err.message || "保存失败");
+      }).finally(() => {
+        this.saving = false;
+      });
+    },
+    // ─── 全屏切换 ────────────────────────────────────────────────
+    // --- emit change with formData
+    // singleSave 模式：编辑过程中不向父级实时传播（避免外层表单实时写回/保存），
+    // 仅在保存成功后通过 force=true 显式同步一次
+    emitChange(val, force = false) {
+      if (this.isSingleSave && !force) return;
+      this._emitting = true;
+      const field = this.$configs.updateField || this.$configs.fieldKey;
+      if (field) {
+        this.$emit("change", {
+          ...this.formData,
+          [field]: val
+        });
+      } else {
+        this.$emit("change", val);
+      }
+      this.$emit("input", val);
+      this.$nextTick(() => {
+        this._emitting = false;
+      });
+    },
+    toggleFullscreen() {
+      this.isFullscreen = !this.isFullscreen;
+      this.invalidateAnchorCache();
+      this.$nextTick(() => {
+        if (this.editor) this.editor.refresh();
+      });
+    },
+    // ─── 编辑模式切换 ────────────────────────────────────────────────
+    setEditorMode(mode) {
+      this.editorMode = mode;
+      this.invalidateAnchorCache();
+      this.$nextTick(() => {
+        if (this.editor) this.editor.refresh();
+      });
+    },
+    // ─── 分屏滚动联动（按源码行号精确对齐） ──────────────────────────
+    handleEditorScroll() {
+      this.syncScroll("editor");
+    },
+    handlePreviewScroll() {
+      this.syncScroll("preview");
+    },
+    invalidateAnchorCache() {
+      this._anchorCache = null;
+    },
+    // 用带来源标记的短时锁，避免左右互相触发形成回环
+    syncScroll(source) {
+      if (this.isDetailMode || this.editorMode !== "split" || !this.editor) return;
+      const previewEl = this.$refs.previewPane;
+      if (!previewEl) return;
+      if (this._scrollLock && this._scrollLock !== source) return;
+      this._scrollLock = source;
+      if (source === "editor") this.syncPreviewFromEditor(previewEl);
+      else this.syncEditorFromPreview(previewEl);
+      clearTimeout(this._scrollLockTimer);
+      this._scrollLockTimer = setTimeout(() => {
+        this._scrollLock = null;
+      }, 60);
+    },
+    // 编辑区 → 预览区：取编辑区顶部对应的源码行，插值到预览区对应锚点位置
+    syncPreviewFromEditor(previewEl) {
+      const anchors = this.buildScrollAnchors(previewEl);
+      const line = this.editorLineAtPixel(this.editor.getScrollInfo().top);
+      const {
+        before,
+        after
+      } = this.bracketAnchors(anchors, line, "line");
+      const span = after.line - before.line;
+      const frac = span > 0 ? (line - before.line) / span : 0;
+      previewEl.scrollTop = before.top + frac * (after.top - before.top);
+    },
+    // 预览区 → 编辑区：取预览区顶部对应的源码行，换算回编辑区像素
+    syncEditorFromPreview(previewEl) {
+      const anchors = this.buildScrollAnchors(previewEl);
+      const top = previewEl.scrollTop;
+      const {
+        before,
+        after
+      } = this.bracketAnchors(anchors, top, "top");
+      const span = after.top - before.top;
+      const frac = span > 0 ? (top - before.top) / span : 0;
+      const line = before.line + frac * (after.line - before.line);
+      this.editor.scrollTo(null, this.editorPixelAtLine(line));
+    },
+    // 构建预览区锚点：[{ line(编辑器行号), top(内容内绝对像素) }]，含首尾哨兵；带缓存
+    buildScrollAnchors(previewEl) {
+      if (this._anchorCache) return this._anchorCache;
+      const offset = this._previewLineOffset || 0;
+      const containerTop = previewEl.getBoundingClientRect().top;
+      const anchors = [{
+        line: offset,
+        top: 0
+      }];
+      const contentEl = this.$refs.preview;
+      if (contentEl) {
+        const nodes = contentEl.querySelectorAll("[data-source-line]");
+        for (let i = 0; i < nodes.length; i++) {
+          const line = parseInt(nodes[i].getAttribute("data-source-line"), 10);
+          if (isNaN(line)) continue;
+          const top = nodes[i].getBoundingClientRect().top - containerTop + previewEl.scrollTop;
+          anchors.push({
+            line: line + offset,
+            top
+          });
+        }
+      }
+      anchors.push({
+        line: this.editor.lineCount(),
+        top: previewEl.scrollHeight
+      });
+      this._anchorCache = anchors;
+      return anchors;
+    },
+    // 在锚点数组里按 key(line/top) 找到夹住 value 的前后两个锚点
+    bracketAnchors(anchors, value, key) {
+      let before = anchors[0];
+      let after = anchors[anchors.length - 1];
+      for (let i = 0; i < anchors.length; i++) {
+        if (anchors[i][key] <= value) {
+          before = anchors[i];
+        } else {
+          after = anchors[i];
+          break;
+        }
+      }
+      return {
+        before,
+        after
+      };
+    },
+    // 编辑区局部像素 → 分数行号
+    editorLineAtPixel(px) {
+      const lineCount = this.editor.lineCount();
+      const line = this.editor.lineAtHeight(px, "local");
+      const top = this.editor.heightAtLine(line, "local");
+      const bottom = this.editor.heightAtLine(Math.min(line + 1, lineCount), "local");
+      const frac = bottom > top ? (px - top) / (bottom - top) : 0;
+      return line + Math.max(0, Math.min(1, frac));
+    },
+    // 分数行号 → 编辑区局部像素
+    editorPixelAtLine(line) {
+      const lineCount = this.editor.lineCount();
+      const intLine = Math.max(0, Math.min(Math.floor(line), lineCount - 1));
+      const top = this.editor.heightAtLine(intLine, "local");
+      const bottom = this.editor.heightAtLine(Math.min(intLine + 1, lineCount), "local");
+      return top + (line - intLine) * (bottom - top);
+    },
+    // ─── 更新预览 ────────────────────────────────────────────────────
+    updatePreview(val) {
+      if (!this.$refs.preview) return;
+      const processed = val || "";
+      const fmMatch = processed.match(/^\n*---\n([\s\S]*?)\n---(?:\n|$)/);
+      let contentWithoutFm = processed;
+      let toolsMap = {};
+      if (fmMatch) {
+        toolsMap = this.parseFrontmatterToolsMap(fmMatch[1]);
+        contentWithoutFm = processed.slice(fmMatch[0].length);
+      }
+      this._previewLineOffset = fmMatch ? (fmMatch[0].match(/\n/g) || []).length : 0;
+      this.invalidateAnchorCache();
+      contentWithoutFm = contentWithoutFm.replace(/<tool-card\s+id="([^"]+)"\s*\/?>/gi, (match, id) => {
+        return `[[TOOL_CARD:${id}]]`;
+      });
+      contentWithoutFm = contentWithoutFm.replace(/<tool-name\s+id="([^"]+)"\s*\/?>/gi, (match, id) => {
+        return `[[TOOL_NAME:${id}]]`;
+      });
+      contentWithoutFm = contentWithoutFm.replace(/<doc-name\s+id=["']([^"']*)["']\s*\/?>/gi, (match, id) => {
+        return `[[DOC_NAME:${id}]]`;
+      });
+      contentWithoutFm = contentWithoutFm.replace(/#\{([^}]+)\}/g, (match, func) => {
+        return `[[FUNC:${func}]]`;
+      });
+      if (this.hasDynamicParam) {
+        contentWithoutFm = contentWithoutFm.replace(/\{\{([^{}]+)\}\}/g, (match, code) => {
+          return `[[PARAM:${code.trim()}]]`;
+        });
+      }
+      let html = renderMd(contentWithoutFm);
+      html = html.replace(/\[\[TOOL_CARD:([^\]]+)\]\]/g, (match, id) => {
+        const displayName = toolsMap[id] || id || "";
+        return `<span class="tool-tag tool-tag--card">${displayName}</span>`;
+      });
+      html = html.replace(/\[\[TOOL_NAME:([^\]]+)\]\]/g, (match, id) => {
+        const displayName = toolsMap[id] || id || "";
+        return `<span class="tool-tag tool-tag--name">${displayName}</span>`;
+      });
+      html = html.replace(/\[\[DOC_NAME:([^\]]*)\]\]/g, (match, id) => {
+        const displayName = toolsMap[id] || id || "";
+        return `<span class="tool-tag tool-tag--doc">${displayName}</span>`;
+      });
+      html = html.replace(/\[\[FUNC:([^\]]+)\]\]/g, (match, func) => {
+        const funcName = func.replace(/\(\)$/, "").replace(/\(.*\)$/, "");
+        return `<span class="tool-tag tool-tag--func">${funcName}</span>`;
+      });
+      html = html.replace(/\[\[PARAM:([^\]]+)\]\]/g, (match, code) => {
+        const displayName = this.paramNameMap[code] || code;
+        return `<span class="tool-tag tool-tag--param">${displayName}</span>`;
+      });
+      this.$refs.preview.innerHTML = html;
+    },
+    // 解析 frontmatter 中所有区块（tools/docs）的 id -> name 映射
+    parseFrontmatterToolsMap(fmContent) {
+      const toolsMap = {};
+      let current = null;
+      fmContent.split("\n").forEach((line) => {
+        const idMatch = line.match(/^\s*-\s+id:\s*(.+)$/);
+        const nameMatch = line.match(/^\s+name:\s*(.+)$/);
+        if (idMatch) {
+          current = {
+            id: idMatch[1].trim()
+          };
+        } else if (current && nameMatch) {
+          toolsMap[current.id] = nameMatch[1].trim();
+          current = null;
+        }
+      });
+      return toolsMap;
+    },
+    // ─── 快捷插入弹窗 ────────────────────────────────────────────
+    openQuickInsert() {
+      this.quickInsertVisible = true;
+      this.quickInsertTab = this.hasDynamicParam ? "dynamicParam" : "function";
+    },
+    onDialogClose() {
+      if (this.slashCursor && this.editor) {
+        const from = this.slashCursor;
+        const to = {
+          line: from.line,
+          ch: from.ch + 1
+        };
+        const ch = this.editor.getRange(from, to);
+        if (ch === "/") {
+          this.editor.replaceRange("", from, to);
+        }
+      }
+      this.slashCursor = null;
+      this.editor && this.editor.focus();
+    },
+    // --- 删除触发 / 并关闭弹窗
+    closeAndCleanSlash() {
+      if (this.slashCursor && this.editor) {
+        const from = this.slashCursor;
+        const to = {
+          line: from.line,
+          ch: from.ch + 1
+        };
+        const ch = this.editor.getRange(from, to);
+        if (ch === "/") {
+          this.editor.replaceRange("", from, to);
+        }
+      }
+      this.slashCursor = null;
+      this.quickInsertVisible = false;
+    },
+    // --- 解析 frontmatter，返回 { hasFrontmatter, tools, docs, fmLength }
+    // 支持 tools（工具）与 docs（配置文档）多个区块
+    parseFrontmatter() {
+      const value = this.editor.getValue();
+      const fmMatch = value.match(/^\n*---\n([\s\S]*?)\n---\n*/);
+      if (!fmMatch) {
+        return {
+          hasFrontmatter: false,
+          tools: [],
+          docs: [],
+          fmLength: 0
+        };
+      }
+      const fmText = fmMatch[1];
+      const fmLength = fmMatch[0].length;
+      const sections = {
+        tools: [],
+        docs: []
+      };
+      let section = null;
+      let current = null;
+      fmText.split("\n").forEach((line) => {
+        const sectionMatch = line.match(/^([A-Za-z_]\w*):\s*$/);
+        if (sectionMatch) {
+          section = sectionMatch[1];
+          if (!sections[section]) sections[section] = [];
+          current = null;
+          return;
+        }
+        const idMatch = line.match(/^\s*-\s+id:\s*(.+)$/);
+        if (idMatch && section) {
+          current = {
+            id: idMatch[1].trim()
+          };
+          sections[section].push(current);
+          return;
+        }
+        if (current && section) {
+          const kv = line.match(/^\s+([A-Za-z_]\w*):\s*(.*)$/);
+          if (kv) current[kv[1]] = kv[2].trim();
+        }
+      });
+      return {
+        hasFrontmatter: true,
+        tools: sections.tools || [],
+        docs: sections.docs || [],
+        fmLength
+      };
+    },
+    // --- 生成 frontmatter 文本（标准 YAML 格式，列表项前两个空格缩进）
+    buildFrontmatter(tools, docs) {
+      const hasTools = tools && tools.length > 0;
+      const hasDocs = docs && docs.length > 0;
+      if (!hasTools && !hasDocs) return "";
+      let fm = "---\n";
+      if (hasTools) {
+        fm += "tools:\n";
+        tools.forEach((t) => {
+          fm += `  - id: ${t.id}
+`;
+          fm += `    type: ${t.type}
+`;
+          fm += `    name: ${t.name}
+`;
+          if (t.meta) fm += `    meta: ${t.meta}
+`;
+        });
+      }
+      if (hasDocs) {
+        fm += "docs:\n";
+        docs.forEach((d) => {
+          fm += `  - id: ${d.id}
+`;
+          fm += `    name: ${d.name}
+`;
+        });
+      }
+      fm += "---\n";
+      return fm;
+    },
+    // --- 将工具写入 frontmatter 并在光标处插入 tool-card 标签
+    insertTool(toolEntry) {
+      if (!this.editor) return;
+      this.closeAndCleanSlash();
+      const {
+        hasFrontmatter,
+        tools,
+        docs,
+        fmLength
+      } = this.parseFrontmatter();
+      const value = this.editor.getValue();
+      const exists = tools.some((t) => t.id === toolEntry.id);
+      if (!exists) tools.push(toolEntry);
+      const newFm = this.buildFrontmatter(tools, docs);
+      const newValue = hasFrontmatter ? newFm + value.slice(fmLength) : newFm + value;
+      const cursor = this.editor.getCursor();
+      const fmLineCount = newFm.split("\n").length - 1;
+      const oldFmLineCount = hasFrontmatter ? value.slice(0, fmLength).split("\n").length - 1 : 0;
+      const lineDelta = fmLineCount - oldFmLineCount;
+      this.editor.setValue(newValue);
+      const newLine = Math.max(0, cursor.line + lineDelta);
+      this.editor.setCursor({
+        line: newLine,
+        ch: cursor.ch
+      });
+      const tagCursor = this.editor.getCursor();
+      const tag = `<tool-card id="${toolEntry.id}" />`;
+      this.editor.replaceRange(tag, tagCursor);
+      this.editor.setCursor({
+        line: tagCursor.line,
+        ch: tagCursor.ch + tag.length
+      });
+      this.editor.focus();
+      const val = this.editor.getValue();
+      this.emitChange(val);
+      this.updatePreview(val);
+    },
+    // --- 将工具写入 frontmatter 并在光标处插入 tool-name 标签
+    insertToolName(toolEntry) {
+      if (!this.editor) return;
+      this.closeAndCleanSlash();
+      const {
+        hasFrontmatter,
+        tools,
+        docs,
+        fmLength
+      } = this.parseFrontmatter();
+      const value = this.editor.getValue();
+      const exists = tools.some((t) => t.id === toolEntry.id);
+      if (!exists) tools.push(toolEntry);
+      const newFm = this.buildFrontmatter(tools, docs);
+      const newValue = hasFrontmatter ? newFm + value.slice(fmLength) : newFm + value;
+      const cursor = this.editor.getCursor();
+      const fmLineCount = newFm.split("\n").length - 1;
+      const oldFmLineCount = hasFrontmatter ? value.slice(0, fmLength).split("\n").length - 1 : 0;
+      const lineDelta = fmLineCount - oldFmLineCount;
+      this.editor.setValue(newValue);
+      const newLine = Math.max(0, cursor.line + lineDelta);
+      this.editor.setCursor({
+        line: newLine,
+        ch: cursor.ch
+      });
+      const tagCursor = this.editor.getCursor();
+      const tag = `<tool-name id="${toolEntry.id}" />`;
+      this.editor.replaceRange(tag, tagCursor);
+      this.editor.setCursor({
+        line: tagCursor.line,
+        ch: tagCursor.ch + tag.length
+      });
+      this.editor.focus();
+      const val = this.editor.getValue();
+      this.emitChange(val);
+      this.updatePreview(val);
+    },
+    // --- 插入函数：生成 {{ code }} 格式文本
+    insertFunction(item) {
+      if (!this.editor) return;
+      this.closeAndCleanSlash();
+      const cursor = this.editor.getCursor();
+      const code = item.FUNC_VAR || item.METHOD || item.CODE || item.NAME;
+      const text = `#{${code}()}`;
+      this.editor.replaceRange(text, cursor);
+      this.editor.focus();
+      this.editor.setCursor({
+        line: cursor.line,
+        ch: cursor.ch + text.length
+      });
+      const val = this.editor.getValue();
+      this.emitChange(val);
+    },
+    // --- 插入模板（直接插入内容文本）
+    insertTemplate(item) {
+      if (!this.editor) return;
+      this.closeAndCleanSlash();
+      const cursor = this.editor.getCursor();
+      this.editor.replaceRange(item.CONTENT || item.TITLE, cursor);
+      this.editor.focus();
+      const val = this.editor.getValue();
+      this.emitChange(val);
+    },
+    // --- 插入对象接口
+    insertApi(item) {
+      const entityId = item.ENTITY || this.selectedEntity && (this.selectedEntity.id || this.selectedEntity);
+      this.insertTool({
+        id: `${entityId}:${item.ID}`,
+        type: "function",
+        name: this.buildApiToolName(item),
+        meta: entityId || void 0
+      });
+    },
+    // --- 插入外部接口
+    insertExternalApi(item) {
+      this.insertTool({
+        id: item.ID,
+        type: "api",
+        name: item.NAME
+      });
+    },
+    // --- 插入子智能体
+    insertSubAgent(item) {
+      this.insertTool({
+        id: item.ID,
+        type: "subagent",
+        name: item.NAME
+      });
+    },
+    // --- 插入通用接口名称
+    insertFrameApiName(item) {
+      this.insertToolName({
+        id: `${item.ENTITY}:${item.ID}`,
+        type: "function",
+        name: this.buildApiToolName(item),
+        meta: item.ENTITY || void 0
+      });
+    },
+    // --- 插入对象接口名称
+    insertApiName(item) {
+      const entityId = item.ENTITY || this.selectedEntity && (this.selectedEntity.id || this.selectedEntity);
+      this.insertToolName({
+        id: `${entityId}:${item.ID}`,
+        type: "function",
+        name: this.buildApiToolName(item),
+        meta: entityId || void 0
+      });
+    },
+    // 构造对象接口的工具名：对象名_接口名（防止重名）
+    buildApiToolName(item) {
+      const entityName = item["ENTITY#"] || this.selectedEntity && this.selectedEntity.name || "";
+      const apiName = item.LABEL || item.NAME || "";
+      return entityName ? `${entityName}_${apiName}` : apiName;
+    },
+    // --- 插入外部接口名称
+    insertExternalApiName(item) {
+      this.insertToolName({
+        id: item.ID,
+        type: "api",
+        name: item.NAME
+      });
+    },
+    // --- 插入子智能体名称
+    insertSubAgentName(item) {
+      this.insertToolName({
+        id: item.ID,
+        type: "subagent",
+        name: item.NAME
+      });
+    },
+    // --- 插入内置工具
+    insertSysTool(item) {
+      this.insertTool({
+        id: item.CODE,
+        type: "sys_tool",
+        name: item.NAME
+      });
+    },
+    // --- 插入内置工具名称
+    insertSysToolName(item) {
+      this.insertToolName({
+        id: item.CODE,
+        type: "sys_tool",
+        name: item.NAME
+      });
+    },
+    // ─── 动态参数 ────────────────────────────────────────────────
+    // 插入动态参数：以 {{code}} 文本插入到光标处
+    insertDynamicParam(node) {
+      if (!node || !node.leaf) return;
+      this.insertTextAtSlash(`{{${node.code}}}`);
+    },
+    // 删除触发的 / 后，在该位置插入纯文本
+    insertTextAtSlash(text) {
+      if (!this.editor) return;
+      this.closeAndCleanSlash();
+      const cursor = this.editor.getCursor();
+      this.editor.replaceRange(text, cursor);
+      this.editor.setCursor({
+        line: cursor.line,
+        ch: cursor.ch + text.length
+      });
+      this.editor.focus();
+      const val = this.editor.getValue();
+      this.emitChange(val);
+      this.updatePreview(val);
+    },
+    // ─── 公式 ────────────────────────────────────────────────────
+    loadFormulaLibrary() {
+      this.$http.$request({
+        action: "getDesignFunction",
+        entityId: "FM_EL_DESIGN",
+        node: "root",
+        systemId: this.SYSTEM,
+        enable: "1"
+      }).then((data) => {
+        this.formulaLibrary = data;
+      }).catch(() => {
+      });
+    },
+    // 打开公式编辑器（先清掉触发的 / 并记录插入位置）
+    openFormulaEditor() {
+      if (!this.editor) return;
+      this.closeAndCleanSlash();
+      this.formulaCursor = this.editor.getCursor();
+      this.ruleInfo = "{}";
+      this.$nextTick(() => {
+        if (this.$refs.rule) this.$refs.rule.setting();
+      });
+    },
+    // 公式确认：插入表达式文本（与原编辑器存储格式保持一致）
+    // val 来自 epx-rule 的 update:model-value（仅在用户点击确认时触发，不受本组件自身重置 ruleInfo 影响）
+    onFormulaChange(val) {
+      this.ruleInfo = val;
+      let param = {};
+      try {
+        param = JSON.parse(val);
+      } catch (error) {
+        param = {
+          el: val
+        };
+      }
+      const text = param.el || "";
+      this.ruleInfo = "";
+      if (!text || !this.editor) {
+        this.formulaCursor = null;
+        return;
+      }
+      const cursor = this.formulaCursor || this.editor.getCursor();
+      this.editor.replaceRange(text, cursor);
+      this.editor.setCursor({
+        line: cursor.line,
+        ch: cursor.ch + text.length
+      });
+      this.editor.focus();
+      this.formulaCursor = null;
+      const newVal = this.editor.getValue();
+      this.emitChange(newVal);
+      this.updatePreview(newVal);
+    },
+    // ─── 数据加载 ────────────────────────────────────────────────
+    loadFunctionList() {
+      Promise.all([this.$http.$post({
+        action: "list",
+        entityId: "FM_FUNCTION",
+        "scope.TYPE": "AI_FUN"
+      }), this.$http.$post({
+        action: "list",
+        entityId: "FM_AI_FUNCTION",
+        "scope.ENABLE#not": "0",
+        "scope.TYPE": "static_var"
+      })]).then(([fnData, varData]) => {
+        this.functionList = [...fnData.entitys || [], ...varData.entitys || []];
+      }).catch(() => {
+      });
+    },
+    loadTemplateList() {
+      this.$http.list({
+        entityId: "FM_AI_PROMPT",
+        "scope.IS_COMMON_USE": "1"
+      }).then((data) => {
+        this.templateList = data.entitys || [];
+      }).catch(() => {
+      });
+    },
+    // 标签页切换
+    handleApiTabChange(tab) {
+      if (tab.name === "frame" && this.frameApiList.length === 0) {
+        this.loadFrameApiList();
+      }
+    },
+    // 加载通用接口列表
+    loadFrameApiList() {
+      this.$http.list({
+        action: "list",
+        entityId: "FM_ENTITY_API",
+        page: this.frameApiCurrentPage,
+        limit: this.frameApiPageSize,
+        "scope.FRAME_API": "1",
+        columnFieldNames: "ID,ENTITY,ENTITY#,NAME,LABEL#,PARAM_EXPLAIN,FRAME_API"
+      }).then((data) => {
+        this.frameApiList = data.entitys || [];
+        this.frameApiTotal = data.total || 0;
+      }).catch(() => {
+      });
+    },
+    // 通用接口分页切换
+    handleFrameApiPageChange(page) {
+      this.frameApiCurrentPage = page;
+      this.loadFrameApiList();
+    },
+    // 插入通用接口
+    insertFrameApi(item) {
+      this.insertTool({
+        id: `${item.ENTITY}:${item.ID}`,
+        type: "function",
+        name: this.buildApiToolName(item),
+        meta: item.ENTITY || void 0
+      });
+    },
+    handleEntityChange(value) {
+      this.selectedEntity = value;
+      this.loadApiList();
+    },
+    loadApiList() {
+      if (!this.selectedEntity) {
+        this.apiList = [];
+        this.apiTotal = 0;
+        return;
+      }
+      const entityId = this.selectedEntity.id || this.selectedEntity;
+      this.$http.list({
+        action: "getEntityAllApi",
+        entityId: "FM_ENTITY_API",
+        metaId: entityId,
+        columnFieldNames: "ID,ENTITY#,NAME,LABEL#,PARAM_EXPLAIN"
+      }).then((data) => {
+        this.apiList = data.entitys || [];
+        this.apiTotal = data.entitys ? data.entitys.length : 0;
+      }).catch(() => {
+      });
+    },
+    loadExternalApiList() {
+      this.$http.list({
+        action: "list",
+        entityId: "FM_API_IN",
+        page: this.externalApiCurrentPage,
+        limit: this.externalApiPageSize,
+        columnFieldNames: "ID,NAME#,URL,NOTICE,METHOD"
+      }).then((data) => {
+        this.externalApiList = data.entitys || [];
+        this.externalApiTotal = data.total || 0;
+      }).catch(() => {
+      });
+    },
+    handleExternalApiPageChange(page) {
+      this.externalApiCurrentPage = page;
+      this.loadExternalApiList();
+    },
+    loadSubAgentList() {
+      this.$http.list({
+        action: "list",
+        entityId: "FM_SERVICE",
+        page: this.subAgentCurrentPage,
+        limit: this.subAgentPageSize,
+        "scope.TYPE": "agent",
+        columnFieldNames: "ID,NAME#,CODE,NOTE,IMAGE"
+      }).then((data) => {
+        this.subAgentList = data.entitys || [];
+        this.subAgentTotal = data.total || 0;
+      }).catch(() => {
+      });
+    },
+    handleSubAgentPageChange(page) {
+      this.subAgentCurrentPage = page;
+      this.loadSubAgentList();
+    },
+    // ─── 内置工具 ────────────────────────────────────────────────
+    loadSysToolList() {
+      this.$http.list({
+        action: "list",
+        entityId: "FM_AI_SYS_TOOL",
+        page: this.sysToolCurrentPage,
+        limit: this.sysToolPageSize,
+        "scope.ENABLE": "1",
+        columnFieldNames: "ID,NAME,CODE,DESC,ENABLE"
+      }).then((data) => {
+        this.sysToolList = data.entitys || [];
+        this.sysToolTotal = data.total || 0;
+      }).catch(() => {
+      });
+    },
+    handleSysToolPageChange(page) {
+      this.sysToolCurrentPage = page;
+      this.loadSysToolList();
+    },
+    // ─── 技能 ────────────────────────────────────────────────────
+    loadSkillList() {
+      const params = {
+        action: "list",
+        entityId: "FM_AI_SKILL",
+        page: this.skillCurrentPage,
+        limit: this.skillPageSize,
+        "scope.STATUS": "1",
+        columnFieldNames: "ID,NAME#,CODE,DESC,STATUS"
+      };
+      if (this.skillActiveTab === "platform") {
+        params["scope.SYSTEM|CODE"] = window.BASE_SYSTEM_ID;
+      } else {
+        params["scope.SYSTEM"] = this.SYSTEM;
+      }
+      this.$http.list(params).then((data) => {
+        this.skillList = data.entitys || [];
+        this.skillTotal = data.total || 0;
+      }).catch(() => {
+      });
+    },
+    handleSkillTabChange() {
+      this.skillCurrentPage = 1;
+      this.loadSkillList();
+    },
+    handleSkillPageChange(page) {
+      this.skillCurrentPage = page;
+      this.loadSkillList();
+    },
+    // 插入技能：以 `技能编号` 形式插入到光标处
+    insertSkill(item) {
+      if (!this.editor) return;
+      this.closeAndCleanSlash();
+      const code = item.CODE || item.NAME;
+      const text = "`" + code + "`";
+      const cursor = this.editor.getCursor();
+      this.editor.replaceRange(text, cursor);
+      this.editor.focus();
+      this.editor.setCursor({
+        line: cursor.line,
+        ch: cursor.ch + text.length
+      });
+      const val = this.editor.getValue();
+      this.emitChange(val);
+      this.updatePreview(val);
+    },
+    // ─── 配置文档（树形） ─────────────────────────────────────────
+    loadDocTree() {
+      this.$http.$post({
+        action: "getTree",
+        entityId: "FM_AI_DOC",
+        up_field: "UP",
+        scopeParams: JSON.stringify([]),
+        node: "root",
+        order_field: "",
+        order_mode: ""
+      }).then((data) => {
+        this.docTree = data || [];
+      }).catch(() => {
+      });
+    },
+    filterDocNode(value, data) {
+      if (!value) return true;
+      return (data.text || data.title || "").indexOf(value) !== -1;
+    },
+    // 点击树节点：叶子节点(文档)作为工具插入；目录节点由 el-tree 自动展开
+    onDocNodeClick(data) {
+      if (data.leaf) this.insertDoc(data);
+    },
+    // 插入配置文档：写入 frontmatter 的 docs 区块，并在光标处插入 doc-name 标签
+    insertDoc(item) {
+      if (!this.editor) return;
+      this.closeAndCleanSlash();
+      const docEntry = {
+        id: item.ID || item.id,
+        name: item.TITLE || item.text || item.title || ""
+      };
+      const {
+        hasFrontmatter,
+        tools,
+        docs,
+        fmLength
+      } = this.parseFrontmatter();
+      const value = this.editor.getValue();
+      const exists = docs.some((d) => d.id === docEntry.id);
+      if (!exists) docs.push(docEntry);
+      const newFm = this.buildFrontmatter(tools, docs);
+      const newValue = hasFrontmatter ? newFm + value.slice(fmLength) : newFm + value;
+      const cursor = this.editor.getCursor();
+      const fmLineCount = newFm.split("\n").length - 1;
+      const oldFmLineCount = hasFrontmatter ? value.slice(0, fmLength).split("\n").length - 1 : 0;
+      const lineDelta = fmLineCount - oldFmLineCount;
+      this.editor.setValue(newValue);
+      const newLine = Math.max(0, cursor.line + lineDelta);
+      this.editor.setCursor({
+        line: newLine,
+        ch: cursor.ch
+      });
+      const tagCursor = this.editor.getCursor();
+      const tag = `<doc-name id="${docEntry.id}" />`;
+      this.editor.replaceRange(tag, tagCursor);
+      this.editor.setCursor({
+        line: tagCursor.line,
+        ch: tagCursor.ch + tag.length
+      });
+      this.editor.focus();
+      const val = this.editor.getValue();
+      this.emitChange(val);
+      this.updatePreview(val);
+    },
+    // ─── 对外暴露：获取内容 ──────────────────────────────────────
+    getValue() {
+      return this.editor ? this.editor.getValue() : "";
+    },
+    setValue(val) {
+      if (this.editor) {
+        this.editor.setValue(val || "");
+        this.hasContent = (val || "").length > 0;
+      }
+    }
+  }
+};
+export {
+  _sfc_main as default
+};