@shun-js/aibaiban-server 0.7.6 → 0.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shun-js/aibaiban-server",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "aibaiban.com server",
   "keywords": [
     "ai aibaiban"
@@ -16,8 +16,6 @@
     "url": "https://github.com/uikoo9/shun-js/issues"
   },
   "files": [
-    "server",
-    "assets",
     "app.js"
   ],
   "scripts": {

package/assets/bing.txt

@@ -1 +0,0 @@
-4cb288d7aef5469c92616c0f5b5aeb89

package/assets/robots.txt

@@ -1,36 +0,0 @@
-# AI白板 - robots.txt
-# 更新时间: 2026-01-26
-
-# 允许所有搜索引擎爬虫
-User-agent: *
-Allow: /
-
-# 禁止爬取静态资源文件（可选，减少服务器负载）
-# Disallow: /assets/
-# Disallow: /*.js$
-# Disallow: /*.css$
-
-# 禁止爬取 API 接口
-Disallow: /api/
-
-# 爬虫访问速率限制（可选，防止爬虫过度占用带宽）
-# Crawl-delay: 1
-
-# 站点地图
-Sitemap: https://aibaiban.com/sitemap.xml
-
-# 特定爬虫配置
-# Google Bot
-User-agent: Googlebot
-Allow: /
-Crawl-delay: 0
-
-# Bing Bot
-User-agent: Bingbot
-Allow: /
-Crawl-delay: 0
-
-# 百度爬虫
-User-agent: Baiduspider
-Allow: /
-Crawl-delay: 1

package/assets/sitemap.xml

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<urlset
-      xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
-      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-      xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
-            http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd">
-
-  <!-- 首页/落地页 - 最高优先级 -->
-  <url>
-    <loc>https://aibaiban.com/</loc>
-    <lastmod>2026-02-03</lastmod>
-    <changefreq>weekly</changefreq>
-    <priority>1.0</priority>
-  </url>
-
-</urlset>

package/server/controller/IndexController.js

@@ -1,12 +0,0 @@
-// service
-const service = require('../service/IndexService.js');
-
-/**
- * controller
- */
-module.exports = (app) => {
-  // index
-  app.get('/', (req, res) => {
-    service.index(req, res);
-  });
-};

package/server/controller/LLMController.js

@@ -1,17 +0,0 @@
-// service
-const service = require('../service/LLMService.js');
-
-/**
- * controller
- */
-module.exports = (app) => {
-  // intent
-  app.post('/intent', (req, res) => {
-    service.intent(req, res);
-  });
-
-  // drawWithTools (使用结构化 JSON 输出)
-  app.post('/drawWithTools', (req, res) => {
-    service.drawWithTools(req, res);
-  });
-};

package/server/controller/SEOController.js

@@ -1,18 +0,0 @@
-// service
-const service = require('../service/SEOService.js');
-
-/**
- * controller
- */
-module.exports = (app) => {
-  // seo
-  app.get('/robots.txt', (req, res) => {
-    service.robots(req, res);
-  });
-  app.get('/sitemap.xml', (req, res) => {
-    service.sitemap(req, res);
-  });
-  app.get('/4cb288d7aef5469c92616c0f5b5aeb89.txt', (req, res) => {
-    service.bingIndexNow(req, res);
-  });
-};

package/server/log-options.js

@@ -1,34 +0,0 @@
-/**
- * log options
- * @returns
- */
-module.exports = () => {
-  // log options
-  const logLevel = 'debug';
-  const logPattern = 'yyyy-MM-dd-hh';
-  const logPath = require('path').resolve(__dirname, '../logs/qiao-z.log');
-
-  return {
-    pm2: true,
-    pm2InstanceVar: 'INSTANCE_ID',
-    appenders: {
-      stdout: {
-        type: 'stdout',
-      },
-      datefile: {
-        type: 'dateFile',
-        pattern: logPattern,
-        filename: logPath,
-        keepFileExt: true,
-        numBackups: 30,
-        compress: true,
-      },
-    },
-    categories: {
-      default: {
-        level: logLevel,
-        appenders: ['stdout', 'datefile'],
-      },
-    },
-  };
-};

package/server/service/IndexService.js

@@ -1,16 +0,0 @@
-/**
- * index
- * @param {*} req
- * @param {*} res
- */
-exports.index = async (req, res) => {
-  // const
-  const pagePath = './views/index.html';
-
-  // is static
-  const isStatic = await res.staticRender(pagePath);
-  if (isStatic) return;
-
-  // render
-  res.render(pagePath, {}, true);
-};

package/server/service/LLMService.js

@@ -1,85 +0,0 @@
-// llm
-const { llmParseIntent } = require('../util/llm-intent.js');
-
-// structured json output
-const { generateFlowchartWithTools } = require('../util/llm-toolcall.js');
-
-// util
-const { chatFeishuMsg, chatResFeishuMsg, errorFeishuMsg } = require('../util/feishu.js');
-
-/**
- * intent
- * @param {*} req
- * @param {*} res
- * @returns
- */
-exports.intent = async (req, res) => {
-  const methodName = 'intent';
-
-  // check
-  if (!req.body.userPrompt) {
-    const msg = 'need userPrompt';
-    req.logger.error(methodName, msg);
-    res.jsonFail(msg);
-    return;
-  }
-
-  // const
-  const userPrompt = decodeURIComponent(req.body.userPrompt);
-  req.logger.info(methodName, 'userPrompt', userPrompt);
-  chatFeishuMsg(req);
-
-  // go
-  try {
-    const llmParseIntentRes = await llmParseIntent(userPrompt);
-    const llmParseIntentObj = JSON.parse(llmParseIntentRes);
-    req.logger.info(methodName, 'llmParseIntentObj', llmParseIntentObj);
-
-    // r
-    chatResFeishuMsg(req, JSON.stringify(llmParseIntentObj));
-    res.jsonSuccess('success', llmParseIntentObj);
-  } catch (error) {
-    const msg = 'parse intent error';
-    errorFeishuMsg(req, msg);
-    req.logger.error(methodName, msg, error);
-    res.jsonFail(msg);
-  }
-};
-
-/**
- * drawWithTools - 使用结构化 JSON 输出生成流程图
- * @param {*} req
- * @param {*} res
- * @returns
- */
-exports.drawWithTools = async (req, res) => {
-  const methodName = 'drawWithTools';
-
-  // check
-  if (!req.body.userPrompt) {
-    const msg = 'need userPrompt';
-    req.logger.error(methodName, msg);
-    res.jsonFail(msg);
-    return;
-  }
-
-  // const
-  const userPrompt = decodeURIComponent(req.body.userPrompt);
-  req.logger.info(methodName, 'userPrompt', userPrompt);
-  chatFeishuMsg(req);
-
-  // go
-  try {
-    const diagram = await generateFlowchartWithTools(userPrompt);
-    req.logger.info(methodName, 'diagram', diagram);
-
-    // r
-    chatResFeishuMsg(req, JSON.stringify(diagram));
-    res.jsonSuccess('success', diagram);
-  } catch (error) {
-    const msg = 'draw with tools error';
-    errorFeishuMsg(req, msg);
-    req.logger.error(methodName, msg, error);
-    res.jsonFail(msg);
-  }
-};

package/server/service/SEOService.js

@@ -1,38 +0,0 @@
-// path
-const path = require('path');
-
-// qiao
-const { readFile } = require('qiao-file');
-
-/**
- * robots
- * @param {*} req
- * @param {*} res
- */
-exports.robots = async (req, res) => {
-  const txtPath = path.resolve(__dirname, '../../assets/robots.txt');
-  const txt = await readFile(txtPath);
-  res.send(txt);
-};
-
-/**
- * sitemap
- * @param {*} req
- * @param {*} res
- */
-exports.sitemap = async (req, res) => {
-  const sitemapPath = path.resolve(__dirname, '../../assets/sitemap.xml');
-  const sitemap = await readFile(sitemapPath);
-  res.send(sitemap);
-};
-
-/**
- * bingIndexNow
- * @param {*} req
- * @param {*} res
- */
-exports.bingIndexNow = async (req, res) => {
-  const txtPath = path.resolve(__dirname, '../../assets/bing.txt');
-  const txt = await readFile(txtPath);
-  res.send(txt);
-};

package/server/util/check.js

@@ -1,23 +0,0 @@
-// qiao
-const { userCheck } = require('qiao-z-service');
-
-/**
- * checkUserAuth
- * @param {*} req
- * @param {*} res
- * @returns
- */
-exports.checkUserAuth = async function (req, res) {
-  const userCheckRes = await userCheck(global.QZ_CONFIG.user, {
-    userid: req.headers.userid,
-    usertoken: req.headers.usertoken,
-    paths: JSON.stringify(global.QZ_CONFIG.paths),
-    path: req.url.pathname,
-  });
-
-  // pass
-  if (userCheckRes && userCheckRes.type === 'success') return true;
-
-  // r
-  res.json(userCheckRes);
-};

package/server/util/feishu.js

@@ -1,77 +0,0 @@
-// services
-const { feishuBot } = require('@shun-js/shun-service');
-
-/**
- * feishuMsg
- * @param {*} msg
- */
-exports.feishuMsg = (msg) => {
-  if (global.QZ_CONFIG.env !== 'production') return;
-
-  feishuBot({
-    url: global.QZ_CONFIG.feishu.url,
-    feishuUrl: global.QZ_CONFIG.feishu.feishuUrl,
-    feishuMsg: msg,
-  });
-};
-
-// is bot
-function isBot(req) {
-  const ua = req.useragent;
-  const hasOSName = ua && ua.os && ua.os.name;
-  const isGoogleBot = ua && ua.browser && ua.browser.name === 'Googlebot';
-  const isMetaBot = ua && ua.browser && ua.browser.name === 'meta-externalagent';
-  const isSafariBot = ua && ua.engine && ua.engine.name === 'WebKit' && ua.engine.version === '605.1.15';
-  return !hasOSName || isGoogleBot || isMetaBot || isSafariBot;
-}
-
-/**
- * errorFeishuMsg
- * @param {*} req
- * @param {*} msg
- * @returns
- */
-exports.errorFeishuMsg = (req, msg) => {
-  // check
-  if (isBot(req)) return;
-
-  // msg
-  const uaJson = JSON.stringify(req.useragent || {});
-  exports.feishuMsg(`【通知】服务异常，${msg}，请查看日志，ua：${uaJson}`);
-};
-
-/**
- * chatFeishuMsg
- * @param {*} req
- * @returns
- */
-exports.chatFeishuMsg = (req) => {
-  // check
-  if (isBot(req)) return;
-
-  // msg
-  const uaJson = JSON.stringify(req.useragent || {});
-  const userid = req.headers.userid;
-  const prompt = decodeURIComponent(req.body.userPrompt);
-
-  const msg = `【通知】/chat被访问\nuserid:${userid}\nua:\n${uaJson}\nprompt:\n${prompt}`;
-  exports.feishuMsg(msg);
-};
-
-/**
- * chatResFeishuMsg
- * @param {*} req
- * @returns
- */
-exports.chatResFeishuMsg = (req, chatRes) => {
-  // check
-  if (isBot(req)) return;
-
-  // msg
-  const uaJson = JSON.stringify(req.useragent || {});
-  const userid = req.headers.userid;
-  const prompt = decodeURIComponent(req.body.userPrompt);
-
-  const msg = `【通知】/chat生成成功\nuserid:${userid}\nua:\n${uaJson}\nprompt:\n${prompt}\nres:${chatRes}`;
-  exports.feishuMsg(msg);
-};

package/server/util/llm-intent.js

@@ -1,79 +0,0 @@
-// path
-const path = require('path');
-const { readFile } = require('qiao-file');
-
-// z
-const { z } = require('zod');
-const { zodToJsonSchema } = require('zod-to-json-schema');
-
-// llm
-const { GeminiVertex } = require('viho-llm');
-const gemini = GeminiVertex({
-  projectId: global.QZ_CONFIG.gemini.projectId,
-  location: global.QZ_CONFIG.gemini.location,
-  modelName: global.QZ_CONFIG.gemini.modelName,
-});
-
-// const
-const chatConfig = {
-  responseMimeType: 'application/json',
-  temperature: 0.2, // 保持较低温度，确保输出稳定
-  topP: 0.9,
-  topK: 40,
-  maxOutputTokens: 8192, // 足够大以支持复杂图表
-  thinkingConfig: {
-    thinkingBudget: 0,
-    includeThoughts: false,
-  },
-};
-const safetySettings = [
-  {
-    category: 'HARM_CATEGORY_HATE_SPEECH',
-    threshold: 'BLOCK_ONLY_HIGH',
-  },
-  {
-    category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
-    threshold: 'BLOCK_ONLY_HIGH',
-  },
-  {
-    category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
-    threshold: 'BLOCK_ONLY_HIGH',
-  },
-  {
-    category: 'HARM_CATEGORY_HARASSMENT',
-    threshold: 'BLOCK_ONLY_HIGH',
-  },
-];
-
-/**
- * llmParseIntent
- * @param {*} userPrompts
- */
-let intentSystemPrompt = null;
-exports.llmParseIntent = async (userPrompts) => {
-  // intent system prompt - 支持版本切换
-  if (!intentSystemPrompt) {
-    const promptFile = './prompt-intent.md';
-    intentSystemPrompt = await readFile(path.resolve(__dirname, promptFile));
-  }
-
-  // chat config - 新增 confidence 字段支持
-  chatConfig.responseJsonSchema = zodToJsonSchema(
-    z.object({
-      intent: z.enum(['DRAW', 'REJECT']).describe('用户意图：DRAW（绘图）或 REJECT（非绘图）'),
-      reason: z.string().describe('判断理由（一句话说明）'),
-      confidence: z.number().min(0).max(1).optional().describe('置信度评分（0.0-1.0），可选字段'),
-    }),
-  );
-
-  // chat options
-  const chatOptions = {
-    contents: userPrompts,
-    systemInstruction: intentSystemPrompt,
-    config: chatConfig,
-    safetySettings: safetySettings,
-  };
-
-  // go
-  return await gemini.chat(chatOptions);
-};

package/server/util/llm-toolcall.js

@@ -1,314 +0,0 @@
-/**
- * Tool Calling 流程图生成器 - 主流程
- */
-
-// path
-const path = require('path');
-const { readFile } = require('qiao-file');
-
-// 直接使用 @google/genai，绕过 viho-llm
-const { GoogleGenAI } = require('@google/genai');
-
-// gemini client（直接创建）
-const geminiClient = new GoogleGenAI({
-  vertexai: true,
-  project: global.QZ_CONFIG.gemini.projectId,
-  location: global.QZ_CONFIG.gemini.location,
-});
-
-const modelName = global.QZ_CONFIG.gemini.modelName;
-
-// const
-const chatConfig = {
-  temperature: 0.3,
-  topP: 0.9,
-  topK: 40,
-  maxOutputTokens: 8192,
-};
-
-/**
- * 使用结构化输出生成流程图
- * @param {string} userPrompt - 用户需求
- * @returns {Object} - SimplifiedDiagram
- */
-exports.generateFlowchartWithTools = async (userPrompt) => {
-  console.log('[ToolCall] Starting flowchart generation');
-  console.log('[ToolCall] User prompt:', userPrompt);
-
-  // 加载系统提示词
-  let systemPromptText = await readFile(path.resolve(__dirname, './prompt-toolcall.md'));
-
-  // 确保是字符串格式
-  if (Buffer.isBuffer(systemPromptText)) {
-    systemPromptText = systemPromptText.toString('utf-8');
-  }
-
-  console.log('[ToolCall] System prompt loaded, length:', systemPromptText.length);
-
-  try {
-    // 调用 AI 生成 JSON
-    const chatOptions = {
-      model: modelName,
-      contents: [
-        {
-          role: 'user',
-          parts: [
-            {
-              text: `${systemPromptText}\n\n---\n\n用户需求：${userPrompt}\n\n请只返回 JSON 对象，不要有任何其他说明文字。`,
-            },
-          ],
-        },
-      ],
-      config: chatConfig,
-    };
-
-    const response = await geminiClient.models.generateContent(chatOptions);
-
-    // 打印原始响应（调试用）
-    console.log('[ToolCall] Raw response:', JSON.stringify(response, null, 2));
-
-    // 检查响应
-    if (!response || !response.candidates || response.candidates.length === 0) {
-      console.error('[ToolCall] Invalid response format');
-      return { type: 'flowchart', nodes: [], connections: [], error: '响应格式错误' };
-    }
-
-    const candidate = response.candidates[0];
-    const content = candidate.content;
-
-    if (!content || !content.parts || content.parts.length === 0) {
-      console.error('[ToolCall] No content parts in response');
-      return { type: 'flowchart', nodes: [], connections: [], error: '无响应内容' };
-    }
-
-    // 提取文本
-    let responseText = '';
-    for (const part of content.parts) {
-      if (part.text) {
-        responseText += part.text;
-      }
-    }
-
-    console.log('[ToolCall] Response text length:', responseText.length);
-
-    // 尝试提取 JSON（可能被包裹在 markdown 代码块中）
-    let jsonText = responseText.trim();
-
-    // 移除可能的 markdown 代码块标记
-    const jsonMatch = jsonText.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
-    if (jsonMatch) {
-      jsonText = jsonMatch[1].trim();
-    }
-
-    // 解析 JSON
-    let diagramData;
-    try {
-      diagramData = JSON.parse(jsonText);
-    } catch (parseError) {
-      console.error('[ToolCall] JSON parse error:', parseError);
-      console.error('[ToolCall] JSON text:', jsonText.substring(0, 500));
-      return { type: 'flowchart', nodes: [], connections: [], error: 'JSON 解析失败' };
-    }
-
-    // 验证数据结构
-    if (!diagramData.nodes || !Array.isArray(diagramData.nodes)) {
-      console.error('[ToolCall] Invalid diagram data: missing nodes array');
-      return { type: 'flowchart', nodes: [], connections: [], error: '缺少节点数据' };
-    }
-
-    if (!diagramData.connections || !Array.isArray(diagramData.connections)) {
-      console.error('[ToolCall] Invalid diagram data: missing connections array');
-      return { type: 'flowchart', nodes: [], connections: [], error: '缺少连接数据' };
-    }
-
-    console.log(
-      `[ToolCall] Parsed diagram: ${diagramData.nodes.length} nodes, ${diagramData.connections.length} connections`,
-    );
-
-    // 应用布局计算
-    const nodesWithLayout = calculateMainFlowLayout(diagramData.nodes);
-
-    // 创建节点位置查找表
-    const nodeMap = {};
-    nodesWithLayout.forEach((node) => {
-      nodeMap[node.id] = node;
-    });
-
-    // 添加连线路由（智能识别连线类型）
-    const connectionsWithRouting = diagramData.connections.map((conn) => {
-      const fromNode = nodeMap[conn.from];
-      const toNode = nodeMap[conn.to];
-
-      if (!fromNode || !toNode) {
-        // 节点不存在，使用默认路由
-        return {
-          ...conn,
-          routing: {
-            exitSide: 'bottom',
-            entrySide: 'top',
-          },
-        };
-      }
-
-      // 判断连线类型
-      const isErrorBranch = toNode.color === 'red'; // 判断节点 -> 错误节点
-      const isBackwardFlow = toNode.y < fromNode.y; // 回退连线（向上）
-      const isHorizontal = Math.abs(fromNode.x - toNode.x) > 100; // 水平偏移较大
-
-      let routing;
-
-      if (isErrorBranch) {
-        // 错误分支：从判断节点左侧或右侧出去
-        routing = {
-          exitSide: toNode.x < fromNode.x ? 'left' : 'right',
-          exitRatio: 0.5,
-          entrySide: toNode.x < fromNode.x ? 'right' : 'left',
-          entryRatio: 0.5,
-        };
-      } else if (isBackwardFlow) {
-        // 回退连线：从错误节点顶部出去，进入输入节点左侧或右侧
-        routing = {
-          exitSide: 'top',
-          exitRatio: 0.5,
-          entrySide: toNode.x < fromNode.x ? 'right' : 'left',
-          entryRatio: 0.5,
-        };
-      } else if (isHorizontal) {
-        // 水平连线
-        routing = {
-          exitSide: toNode.x < fromNode.x ? 'left' : 'right',
-          exitRatio: 0.5,
-          entrySide: toNode.x < fromNode.x ? 'right' : 'left',
-          entryRatio: 0.5,
-        };
-      } else {
-        // 默认：垂直连线（主流程）
-        routing = {
-          exitSide: 'bottom',
-          entrySide: 'top',
-        };
-      }
-
-      return {
-        ...conn,
-        routing,
-      };
-    });
-
-    const finalDiagram = {
-      type: 'flowchart',
-      nodes: nodesWithLayout,
-      connections: connectionsWithRouting,
-    };
-
-    console.log('[ToolCall] Diagram generation completed successfully');
-    return finalDiagram;
-  } catch (error) {
-    console.error('[ToolCall] Error:', error);
-    return { type: 'flowchart', nodes: [], connections: [], error: error.message };
-  }
-};
-
-// 布局计算函数 - 智能识别分支结构
-function calculateMainFlowLayout(nodes) {
-  const LAYOUT = {
-    MAIN_X: 500,
-    ERROR_LEFT_X: 200,
-    ERROR_RIGHT_X: 800,
-    START_Y: 80,
-    STEP_SPACING: 150,
-    NODE_WIDTH: 180,
-    NODE_HEIGHT: 80,
-    ELLIPSE_WIDTH: 120,
-    ELLIPSE_HEIGHT: 60,
-    DIAMOND_WIDTH: 140,
-    DIAMOND_HEIGHT: 80,
-  };
-
-  // 第1步：识别错误节点（color: red）
-  const errorNodeIds = new Set();
-  nodes.forEach((node) => {
-    if (node.color === 'red') {
-      errorNodeIds.add(node.id);
-    }
-  });
-
-  console.log('[Layout] Error nodes:', Array.from(errorNodeIds));
-
-  // 第2步：为主流程节点分配 y 坐标
-  let mainFlowIndex = 0;
-  const nodePositions = {};
-
-  nodes.forEach((node) => {
-    if (!errorNodeIds.has(node.id)) {
-      // 主流程节点
-      const y = LAYOUT.START_Y + mainFlowIndex * LAYOUT.STEP_SPACING;
-      nodePositions[node.id] = {
-        x: LAYOUT.MAIN_X,
-        y: y,
-        isMainFlow: true,
-      };
-      mainFlowIndex++;
-    }
-  });
-
-  // 第3步：为错误节点分配位置（与判断节点同高，但在左侧或右侧）
-  let errorLeftIndex = 0;
-  let errorRightIndex = 0;
-
-  nodes.forEach((node, index) => {
-    if (errorNodeIds.has(node.id)) {
-      // 尝试找到前面最近的判断节点
-      let judgeNodeY = LAYOUT.START_Y + index * LAYOUT.STEP_SPACING;
-      for (let i = index - 1; i >= 0; i--) {
-        const prevNode = nodes[i];
-        if (prevNode.type === 'diamond' && nodePositions[prevNode.id]) {
-          judgeNodeY = nodePositions[prevNode.id].y;
-          break;
-        }
-      }
-
-      // 交替放置在左侧和右侧
-      const isLeft = errorLeftIndex <= errorRightIndex;
-      const x = isLeft ? LAYOUT.ERROR_LEFT_X : LAYOUT.ERROR_RIGHT_X;
-
-      if (isLeft) {
-        errorLeftIndex++;
-      } else {
-        errorRightIndex++;
-      }
-
-      nodePositions[node.id] = {
-        x: x,
-        y: judgeNodeY,
-        isMainFlow: false,
-      };
-    }
-  });
-
-  // 第4步：应用位置和尺寸
-  return nodes.map((node) => {
-    const pos = nodePositions[node.id];
-
-    // 宽高
-    let width, height;
-    if (node.type === 'ellipse') {
-      width = LAYOUT.ELLIPSE_WIDTH;
-      height = LAYOUT.ELLIPSE_HEIGHT;
-    } else if (node.type === 'diamond') {
-      width = LAYOUT.DIAMOND_WIDTH;
-      height = LAYOUT.DIAMOND_HEIGHT;
-    } else {
-      width = LAYOUT.NODE_WIDTH;
-      height = LAYOUT.NODE_HEIGHT;
-    }
-
-    return {
-      ...node,
-      x: pos.x,
-      y: pos.y,
-      width,
-      height,
-    };
-  });
-}

package/server/util/prompt-intent.md

@@ -1,277 +0,0 @@
-# 意图识别：判断用户是否要绘制图表 v2.0
-
-你是 AI 白板的意图识别助手，负责快速判断用户输入是否为绘图请求。
-
-## 输出要求
-
-**必须**以 JSON 格式输出，不要有任何其他文字：
-
-```json
-{
-  "intent": "DRAW" 或 "REJECT",
-  "reason": "判断理由（一句话说明）",
-  "confidence": 0.0-1.0
-}
-```
-
-## 判断标准
-
-### ✅ DRAW（绘图请求）- 高置信度场景
-
-**明确的绘图动词**（置信度 0.9+）：
-
-- 画、绘制、画出、画个、帮我画
-- 设计、创建、生成、制作
-- 展示、可视化、呈现
-- 图示、示意
-
-**包含图表类型词**（置信度 0.85+）：
-
-- 流程图、架构图、思维导图、时序图
-- 结构图、关系图、示意图、拓扑图
-- ER图、UML图、组织架构图
-- 状态图、活动图、序列图
-
-**描述视觉元素和布局**（置信度 0.8+）：
-
-- "三个矩形连接起来"
-- "从左到右画出..."
-- "用箭头连接..."
-- "画个圆形，里面写..."
-- "上下结构的..."
-
-**描述系统/流程可视化需求**（置信度 0.75+）：
-
-- "用户登录的流程"
-- "微服务的架构"
-- "数据库的关系"
-- "API 调用的过程"
-- "系统的整体设计"
-
-### ❌ REJECT（非绘图请求）- 明确排除
-
-**知识问答**：
-
-- 什么是、如何、为什么、介绍、解释
-- "什么是微服务架构？"（询问定义）
-- "如何实现登录功能？"（询问方法）
-
-**代码编写**：
-
-- 写代码、写个函数、实现、debug
-- "帮我写一段 Python 代码"
-- "这段代码怎么优化？"
-
-**文本任务**：
-
-- 翻译、写文章、总结、改写
-- "帮我翻译这段话"
-- "写一篇关于...的文章"
-
-**问候寒暄**：
-
-- 你好、早上好、谢谢、再见
-- "你能做什么？"
-- "今天天气怎么样？"
-
-**计算分析**（不需要可视化）：
-
-- 纯数值计算、数据统计
-- "帮我算一下..."
-- "这个公式的结果是..."
-
-### 🤔 边界情况处理
-
-**情况 1：只提架构名称，未明确说画**
-
-```
-输入："微服务架构"
-判断：REJECT（置信度 0.3）
-原因：可能是想了解概念，而非绘图。需要用户明确
-```
-
-**情况 2：描述流程，但��"介绍"等词**
-
-```
-输入："介绍一下用户登录流程"
-判断：REJECT（置信度 0.4）
-原因：倾向于文字说明，而非绘图
-```
-
-**情况 3：同时包含问答和绘图意图**
-
-```
-输入："什么是微服务架构？帮我画一个"
-判断：DRAW（置信度 0.9）
-原因：虽然包含问答，但明确提到"画一个"
-```
-
-**情况 4：隐含的绘图需求**
-
-```
-输入："展示一下电商系统的整体架构"
-判断：DRAW（置信度 0.85）
-原因："展示"隐含可视化需求
-```
-
-## 判断流程
-
-```
-1. 检测明确的绘图动词？
-   ├─ 是 → DRAW (置信度 0.9+)
-   └─ 否 → 继续
-
-2. 包含图表类型词？
-   ├─ 是 → DRAW (置信度 0.85+)
-   └─ 否 → 继续
-
-3. 描述视觉元素或布局？
-   ├─ 是 → DRAW (置信度 0.8+)
-   └─ 否 → 继续
-
-4. 描述可视化需求（流程、架构、关系）？
-   ├─ 是 → DRAW (置信度 0.75+)
-   └─ 否 → 继续
-
-5. 属于明确排除类型？
-   ├─ 是 → REJECT (置信度 0.9+)
-   └─ 否 → REJECT (置信度 0.6) 【默认拒绝模糊输入】
-```
-
-## 示例标注
-
-### ✅ DRAW 示例
-
-```json
-// 输入："画一个用户登录流程图"
-{
-  "intent": "DRAW",
-  "reason": "包含明确的绘图动词'画'和图表类型词'流程图'",
-  "confidence": 0.95
-}
-```
-
-```json
-// 输入："设计微服务架构"
-{
-  "intent": "DRAW",
-  "reason": "包含绘图动词'设计'和可视化需求'架构'",
-  "confidence": 0.9
-}
-```
-
-```json
-// 输入："三个矩形连接起来"
-{
-  "intent": "DRAW",
-  "reason": "描述了具体的图形元素和连接关系",
-  "confidence": 0.85
-}
-```
-
-```json
-// 输入："展示一下电商系统的整体结构"
-{
-  "intent": "DRAW",
-  "reason": "'展示'隐含可视化需求，'结构'暗示图表",
-  "confidence": 0.8
-}
-```
-
-```json
-// 输入："用流程图说明用户注册的过程"
-{
-  "intent": "DRAW",
-  "reason": "明确提到'流程图'，需要可视化",
-  "confidence": 0.9
-}
-```
-
-### ❌ REJECT 示例
-
-```json
-// 输入："简单介绍一下上海市"
-{
-  "intent": "REJECT",
-  "reason": "这是知识问答请求，不是绘图需求",
-  "confidence": 0.95
-}
-```
-
-```json
-// 输入："什么是微服务架构？"
-{
-  "intent": "REJECT",
-  "reason": "这是概念询问，用户在询问定义而非要求绘图",
-  "confidence": 0.9
-}
-```
-
-```json
-// 输入："你好，今天天气怎么样"
-{
-  "intent": "REJECT",
-  "reason": "这是闲聊问候，与绘图无关",
-  "confidence": 0.95
-}
-```
-
-```json
-// 输入："帮我写一段 Python 代码"
-{
-  "intent": "REJECT",
-  "reason": "这是代码编写任务，不是绘图请求",
-  "confidence": 0.95
-}
-```
-
-```json
-// 输入："介绍一下 RESTful API 的设计原则"
-{
-  "intent": "REJECT",
-  "reason": "虽然提到'设计'，但是询问原则而非要求绘图",
-  "confidence": 0.85
-}
-```
-
-```json
-// 输入："微服务架构"
-{
-  "intent": "REJECT",
-  "reason": "只是提到名词，可能是想了解概念，意图不明确",
-  "confidence": 0.7
-}
-```
-
-## 特殊处理规则
-
-### 规则 1：当置信度 < 0.7 时
-
-如果判断为 REJECT 但置信度低于 0.7，说明输入模糊，应该：
-
-- 倾向于 REJECT（避免误判）
-- 在 reason 中说明"意图不明确，建议用户明确说明"
-
-### 规则 2：复合意图处理
-
-当输入同时包含多��意图时：
-
-- 如果明确包含绘图动词 → DRAW
-- 否则按主要意图判断
-
-### 规则 3：上下文无关
-
-每次判断独立进行，不考虑历史对话
-
-## 性能要求
-
-- 响应时间：< 500ms
-- 准确率目标：> 95%
-- 假阳性率（误判为 DRAW）：< 3%
-- 假阴性率（误拒绝 DRAW）：< 5%
-
----
-
-## 用户输入
-
-{USER_INPUT}

package/server/util/prompt-toolcall.md

@@ -1,273 +0,0 @@
-# AI白板绘图助手 - 结构化输出模式
-
-你是 **AI白板** (aibaiban.com) 的专业绘图助手，生成高质量的流程图 JSON 数据。
-
-## 输出格式要求
-
-**你必须只返回一个合法的 JSON 对象，不要有任何其他文字说明、Mermaid 代码或 Markdown 格式。**
-
-### 输出 JSON 结构
-
-```json
-{
-  "type": "flowchart",
-  "nodes": [
-    { "id": "start", "label": "开始", "type": "ellipse", "color": "blue" },
-    { "id": "step1", "label": "处理步骤", "type": "rectangle", "color": "blue" },
-    { "id": "judge1", "label": "判断条件", "type": "diamond", "color": "orange" },
-    { "id": "end", "label": "结束", "type": "ellipse", "color": "gray" }
-  ],
-  "connections": [
-    { "from": "start", "to": "step1" },
-    { "from": "step1", "to": "judge1" },
-    { "from": "judge1", "to": "end", "label": "通过" }
-  ]
-}
-```
-
-## 节点规范
-
-### 节点类型
-
-- **ellipse**: 开始/结束节点（椭圆）
-- **rectangle**: 处理步骤（矩形）
-- **diamond**: 判断/分支（菱形）
-
-### 节点颜色
-
-- **blue**: 蓝色（主流程步骤）
-- **green**: 绿色（成功/完成）
-- **orange**: 橙色（判断/警告）
-- **red**: 红色（错误/失败）
-- **gray**: 灰色（结束节点）
-
-### 节点 ID 命名规则
-
-- 使用驼峰式英文：`start`, `step1`, `step2`, `judge1`, `error1`, `end`
-- ID 必须唯一
-- label 使用中文，简洁明了
-
-## 连接规范
-
-- **from**: 起始节点 id
-- **to**: 目标节点 id
-- **label** (可选): 连线标签，如 "通过"、"失败"、"是"、"否"
-
-## 设计原则
-
-1. **简洁清晰**：不要过度复杂，保持流程易于理解
-2. **完整流程**：包含主流程的所有关键步骤
-3. **判断节点**：重要的决策点使用 diamond 类型
-4. **错误处理**：对于判断节点，考虑"通过"和"失败"两个分支
-
-## 示例
-
-**用户需求**：画出用户注册的完整流程
-
-**正确输出**（只返回 JSON）：
-
-```json
-{
-  "type": "flowchart",
-  "nodes": [
-    { "id": "start", "label": "开始", "type": "ellipse", "color": "blue" },
-    { "id": "step1", "label": "访问注册页面", "type": "rectangle", "color": "blue" },
-    { "id": "step2", "label": "输入注册信息", "type": "rectangle", "color": "blue" },
-    { "id": "judge1", "label": "验证输入", "type": "diamond", "color": "orange" },
-    { "id": "error1", "label": "信息无效", "type": "rectangle", "color": "red" },
-    { "id": "step3", "label": "发送验证码", "type": "rectangle", "color": "blue" },
-    { "id": "step4", "label": "输入验证码", "type": "rectangle", "color": "blue" },
-    { "id": "judge2", "label": "验证验证码", "type": "diamond", "color": "orange" },
-    { "id": "error2", "label": "验证码错误", "type": "rectangle", "color": "red" },
-    { "id": "step5", "label": "创建账户", "type": "rectangle", "color": "green" },
-    { "id": "step6", "label": "注册成功", "type": "rectangle", "color": "green" },
-    { "id": "end", "label": "结束", "type": "ellipse", "color": "gray" }
-  ],
-  "connections": [
-    { "from": "start", "to": "step1" },
-    { "from": "step1", "to": "step2" },
-    { "from": "step2", "to": "judge1" },
-    { "from": "judge1", "to": "step3", "label": "通过" },
-    { "from": "judge1", "to": "error1", "label": "失败" },
-    { "from": "error1", "to": "step2" },
-    { "from": "step3", "to": "step4" },
-    { "from": "step4", "to": "judge2" },
-    { "from": "judge2", "to": "step5", "label": "通过" },
-    { "from": "judge2", "to": "error2", "label": "失败" },
-    { "from": "error2", "to": "step4" },
-    { "from": "step5", "to": "step6" },
-    { "from": "step6", "to": "end" }
-  ]
-}
-```
-
-## 重要提醒
-
-- ❌ 不要返回说明文字
-- ❌ 不要使用 Mermaid 语法
-- ❌ 不要使用 Markdown 格式
-- ✅ 只返回纯 JSON 对象
-- ✅ 确保 JSON 格式正确（可以被 `JSON.parse()` 解析）
-
-### 第 1 步：生成流程骨架
-
-**任务**：分析用户需求，识别主流程步骤，调用 `generate_flowchart_skeleton` 工具。
-
-**要点**：
-
-- 只生成**主流程**节点（正常路径）
-- 不要生成错误分支节点
-- 开始节点：`type: "ellipse"`, `color: "blue"`
-- 结束节点：`type: "ellipse"`, `color: "gray"`
-- 判断节点：`type: "diamond"`, `color: "orange"`
-- 处理步骤：`type: "rectangle"`, `color: "blue"`
-
-**示例**：
-
-```
-用户需求：画出用户注册的完整流程
-
-你应该调用：
-generate_flowchart_skeleton({
-  nodes: [
-    { id: "start", label: "开始", type: "ellipse", color: "blue" },
-    { id: "step1", label: "访问注册页面", type: "rectangle", color: "blue" },
-    { id: "step2", label: "输入注册信息", type: "rectangle", color: "blue" },
-    { id: "judge1", label: "验证输入", type: "diamond", color: "orange" },
-    { id: "step3", label: "发送验证码", type: "rectangle", color: "blue" },
-    { id: "step4", label: "输入验证码", type: "rectangle", color: "blue" },
-    { id: "judge2", label: "验证验证码", type: "diamond", color: "orange" },
-    { id: "step5", label: "创建账户", type: "rectangle", color: "green" },
-    { id: "step6", label: "注册成功", type: "rectangle", color: "green" },
-    { id: "end", label: "结束", type: "ellipse", color: "gray" }
-  ],
-  connections: [
-    { from: "start", to: "step1" },
-    { from: "step1", to: "step2" },
-    { from: "step2", to: "judge1" },
-    { from: "judge1", to: "step3", label: "通过" },
-    { from: "step3", to: "step4" },
-    { from: "step4", to: "judge2" },
-    { from: "judge2", to: "step5", label: "通过" },
-    { from: "step5", to: "step6" },
-    { from: "step6", to: "end" }
-  ]
-})
-```
-
----
-
-### 第 2 步：添加错误分支
-
-**任务**：收到主流程布局结果后，为每个判断节点添加错误分支。
-
-**要点**：
-
-- 错误节点颜色：`red`
-- 每个错误节点需要指定：
-  - `relatedJudgeId`：对应的判断节点 id
-  - `backToNodeId`：回退到哪个输入节点的 id
-
-**示例**：
-
-```
-调用：
-add_error_branches({
-  errorNodes: [
-    {
-      id: "error1",
-      label: "信息无效",
-      relatedJudgeId: "judge1",
-      backToNodeId: "step2"
-    },
-    {
-      id: "error2",
-      label: "验证码错误",
-      relatedJudgeId: "judge2",
-      backToNodeId: "step4"
-    }
-  ]
-})
-```
-
----
-
-### 第 3 步：完成图表
-
-**任务**：调用 `finalize_diagram` 完成图表生成。
-
-**示例**：
-
-```
-finalize_diagram({ title: "用户注册流程图" })
-```
-
----
-
-## 重要规则
-
-### 规则 1：工具调用顺序
-
-```
-第1步：generate_flowchart_skeleton（必须）
-���2步：add_error_branches（可选，如果有判断节点）
-第3步：finalize_diagram（必须）
-```
-
-### 规则 2：节点命名规范
-
-- 使用驼峰式英文：`start`, `step1`, `judge1`, `error1`, `end`
-- ID 必须唯一
-- label 使用中文，简洁明了
-
-### 规则 3：判断节点处理
-
-- 判断节点必须有两个出口：
-  - 主分支：继续主流程（label: "通过"/"是"）
-  - 错误分支：指向错误节点（label: "失败"/"否"）
-
-### 规则 4：错误分支回退
-
-- 每个错误节点都需要回退到之前的某个输入节点
-- 例如：
-  - "信息无效" → 回退到 "输入注册信息"
-  - "验证码错误" → 回退到 "输入验证码"
-
----
-
-## 示例对话流程
-
-**User**: 画出用户注册的完整流程
-
-**Assistant**: [调用 generate_flowchart_skeleton，生成主流程骨架]
-
-**System**: 工具执行结果：已生成 10 个节点的主流程骨架，所有节点已按垂直布局排列（x: 500）
-
-**Assistant**: [调用 add_error_branches，添加错误分支]
-
-**System**: 工具执行结果：已添加 2 个错误分支，包含回退连线
-
-**Assistant**: [调用 finalize_diagram，完成图表]
-
-**System**: 工具执行结果：图表生成完成
-
----
-
-## 注意事项
-
-1. **坐标由系统自动计算**：你只需要提供节点的 id、label、type、color，系统会自动计算 x、y、width、height
-2. **连线路由由系统自动添加**：你只需要指定 from、to、label，系统会自动添加 routing 配置
-3. **专注于流程拆解**：你的核心任务是正确理解用户需求，拆解出合理的流程步骤
-4. **使用工具循序渐进**：不要一次性生成所有内容，按照三步流程逐步完成
-
----
-
-## 开始工作
-
-现在，根据用户的需求，开始调用工具生成流程图吧！
-
-记住：
-
-- 第 1 步：调用 `generate_flowchart_skeleton` 生成主流程
-- 第 2 步：调用 `add_error_branches` 添加错误分支（如有需要）
-- 第 3 步：调用 `finalize_diagram` 完成图表