| 。',
'可以在表格前用一个 给出一句结论，但主体必须是 table。',
'简单步骤也优先改成表格，不要使用普通项目符号列表作为主体。',
'重点使用 ，路径/接口/字段使用 ，多行示例使用 。',
'不要输出 JavaScript 代码、script 标签或事件属性；需要表格时只输出静态 HTML table，由前端负责显示和导出。',
'允许标签：p、ul、ol、li、table、thead、tbody、tr、th、td、strong、em、code、pre、h3、h4、svg、g、rect、line、polyline、circle、text、path。',
'图文并茂规则：当回答流程、模块关系、数据流、PLC/MQTT 交互、查询导出步骤时，优先在表格后补充一个简洁内联 SVG 图示；SVG 必须是静态图，不得包含脚本、动画或外链。',
'禁止标签：script、style、iframe、form、input、button、link、meta、image、foreignObject。',
'禁止任何 on* 事件属性、javascript: URL、内联脚本。',
'当用户要求制作 Excel、表格、清单、台账、模板时，必须输出可被前端导出的 HTML table；表头用 th，数据行用 td。',
'如果用户要求打开某个模块或页面，只说明目标模块名称和建议页面；实际跳转由前端根据当前用户菜单执行。',
'不要输出 script、style、iframe、form、input、button，不要输出任何 on* 事件属性。',
'当前前端上下文如下：',
JSON.stringify(normalizeClientContext(context)),
'当前可用 MCP 风格工具如下：',
JSON.stringify(tools.map(tool => ({ name: tool.name, description: tool.description }))),
'当前知识库文档如下：',
JSON.stringify(knowledgeBase.index.map(item => ({ id: item.id, title: item.title, category: item.category, summary: item.summary }))),
'页面级索引规模如下：',
JSON.stringify({ pages: generatedKnowledge.pages.length, apiCalls: generatedKnowledge.apiCalls.length }),
'前端任务映射如下：',
JSON.stringify(frontendTaskMap),
'MES 功能目录如下：',
JSON.stringify(catalog)
].join('\n')
const data = await requestJson(`${DEEPSEEK_BASE_URL.replace(/\/$/, '')}/chat/completions`, {
method: 'POST',
headers: {
Authorization: `Bearer ${DEEPSEEK_API_KEY}`
},
body: {
model: DEEPSEEK_MODEL,
messages: [
{ role: 'system', content: systemPrompt },
...toolResults.map(item => ({
role: 'system',
content: `本地工具 ${item.name} 结果：${JSON.stringify(item.result)}`
})),
...messages.slice(-12)
],
temperature: 0.2,
stream: false,
response_format: {
type: 'text'
}
}
})
if (data.statusCode < 200 || data.statusCode >= 300) {
const payload = data.body
throw new Error(payload.error && payload.error.message ? payload.error.message : `DeepSeek request failed: ${data.statusCode}`)
}
return {
message: ensureHtmlMessage(data.body.choices && data.body.choices[0] && data.body.choices[0].message ? data.body.choices[0].message.content : ''),
format: 'html',
model: data.body.model || DEEPSEEK_MODEL,
toolResults
}
}
function ensureHtmlMessage(message) {
const content = String(message || '').trim()
if (!content) return ''
if (/<(p|ul|ol|li|table|thead|tbody|tr|th|td|strong|em|code|pre|h3|h4|svg)[\s>]/i.test(content)) {
if (/]/i.test(content)) return content
return convertHtmlFragmentToTable(content)
}
return convertPlainTextToHtml(content)
}
function convertPlainTextToHtml(content) {
const lines = String(content || '').split(/\r?\n/).map(line => line.trim()).filter(Boolean)
if (!lines.length) return ''
const rows = lines.map((line, index) => {
const normalized = line
.replace(/^#{1,4}\s+/, '')
.replace(/^[-*]\s+/, '')
.replace(/^\d+[.)]\s+/, '')
return '| ' + (index + 1) + ' | ' + escapeHtml(normalized) + ' | '
})
return '| 序号 | 内容 |
|---|
' + rows.join('') + '
'
}
function convertHtmlFragmentToTable(content) {
const blocks = []
const blockRegex = /<(h3|h4|p|li|pre)[^>]*>([\s\S]*?)<\/\1>/gi
let match
while ((match = blockRegex.exec(content))) {
const typeMap = {
h3: '标题',
h4: '标题',
p: '说明',
li: '条目',
pre: '示例'
}
const value = match[2].trim()
if (value) {
blocks.push({
type: typeMap[match[1].toLowerCase()] || '内容',
value
})
}
}
if (!blocks.length) {
const text = stripHtml(content)
return '| 项目 | 内容 |
|---|
| 说明 | ' + escapeHtml(text) + ' |
'
}
const rows = blocks.map(item => '| ' + escapeHtml(item.type) + ' | ' + item.value + ' | ')
return '| 类型 | 内容 |
|---|
' + rows.join('') + '
'
}
function stripHtml(value) {
return String(value || '').replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim()
}
function escapeHtml(value) {
return String(value || '')
.replace(/&/g, '&')
.replace(//g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''')
}
function prefetchLocalContext(messages, context) {
const last = messages.length ? String(messages[messages.length - 1].content || '') : ''
const results = []
if (last) {
results.push({
name: 'mes.search_capabilities',
result: searchCapabilities(last)
})
results.push({
name: 'kb.search',
result: searchKnowledgeBase(last, 5)
})
results.push({
name: 'frontend.task_map',
result: searchFrontendTaskMap(last)
})
results.push({
name: 'frontend.search_pages',
result: searchFrontendPages(last, 8)
})
const contextMatches = searchClientMenus(last, context)
if (contextMatches.length) {
results.push({
name: 'frontend.current_menu_match',
result: contextMatches
})
}
}
return results
}
async function callTool(name, args) {
if (name === 'mes.list_capabilities') {
if (!args.module) return catalog.modules
const keyword = String(args.module).toLowerCase()
return catalog.modules.filter(item => item.name.toLowerCase().includes(keyword))
}
if (name === 'mes.search_capabilities') {
return searchCapabilities(args.keyword || '')
}
if (name === 'kb.list_documents') {
return knowledgeBase.index
}
if (name === 'kb.search') {
return searchKnowledgeBase(args.keyword || '', Number(args.limit || 5))
}
if (name === 'kb.read_document') {
return readKnowledgeDocument(args.id || '', Number(args.maxLength || 12000))
}
if (name === 'frontend.search_pages') {
return searchFrontendPages(args.keyword || '', Number(args.limit || 8))
}
if (name === 'mes.query') {
const type = String(args.type || '1')
if (type !== '1' && type !== '3') {
throw new Error('mes.query only allows type=1 or type=3')
}
return callMesCommonBase({ type, name: args.name, param: args.param || '' })
}
if (name === 'mes.execute') {
const type = String(args.type || '')
if (!MES_AI_ALLOW_WRITE && type !== '1' && type !== '3') {
throw new Error('Write operations are disabled. Set MES_AI_ALLOW_WRITE=1 to enable them.')
}
return callMesCommonBase(args)
}
throw new Error(`Unknown tool: ${name}`)
}
function searchCapabilities(keyword) {
const key = String(keyword || '').trim().toLowerCase()
if (!key) return []
return catalog.modules
.map(module => {
const haystack = JSON.stringify(module).toLowerCase()
if (!haystack.includes(key)) return null
return module
})
.filter(Boolean)
}
function searchFrontendTaskMap(keyword) {
const key = String(keyword || '').toLowerCase()
if (!key) return []
return frontendTaskMap
.map(item => {
const haystack = JSON.stringify(item).toLowerCase()
let score = haystack.includes(key) ? 20 : 0
item.keywords.forEach(word => {
if (key.includes(String(word).toLowerCase()) || haystack.includes(key)) score += 5
})
return score ? Object.assign({ score }, item) : null
})
.filter(Boolean)
.sort((a, b) => b.score - a.score)
.slice(0, 5)
}
function searchClientMenus(keyword, context) {
const key = String(keyword || '').toLowerCase()
const menus = (context && Array.isArray(context.menus)) ? context.menus : []
if (!key || !menus.length) return []
return menus
.map(menu => {
const title = String(menu.title || '').toLowerCase()
let score = 0
if (title && key.includes(title)) score += 40
if (title && title.includes(key)) score += 30
for (let i = 0; i < key.length; i++) {
if (title.includes(key[i])) score += 1
}
return score ? Object.assign({ score }, menu) : null
})
.filter(Boolean)
.sort((a, b) => b.score - a.score)
.slice(0, 8)
}
function searchFrontendPages(keyword, limit) {
const key = String(keyword || '').toLowerCase()
if (!key) return []
const tokens = createSearchTokens(key)
const meaningfulTokens = tokens.filter(token => token && token.length > 1)
const max = Math.max(1, Math.min(Number(limit) || 8, 20))
return generatedKnowledge.pages
.map(page => {
const haystack = JSON.stringify(page).toLowerCase()
let score = haystack.includes(key) ? 30 : 0
key.split(/[\s,，。；;、]+/).forEach(part => {
if (part && haystack.includes(part)) score += 15
})
meaningfulTokens.forEach(token => {
if (token && haystack.includes(token)) score += token.length > 1 ? 4 : 1
})
if (/导出|excel|下载|报表/i.test(key) && page.exports && page.exports.length) score += 12
if (/日志|记录/i.test(key) && /日志|记录/i.test(haystack)) score += 12
if (!score) return null
return {
module: page.module,
title: page.title,
route: page.route,
file: page.file,
buttons: page.buttons,
exports: page.exports,
tableColumns: (page.tableColumns || []).slice(0, 20),
score
}
})
.filter(Boolean)
.sort((a, b) => b.score - a.score)
.slice(0, max)
}
function normalizeClientContext(context) {
const safeContext = context && typeof context === 'object' ? context : {}
const menus = Array.isArray(safeContext.menus) ? safeContext.menus.slice(0, 200).map(menu => ({
title: menu.title,
path: menu.path,
parentTitle: menu.parentTitle
})) : []
return {
route: safeContext.route || '',
routeName: safeContext.routeName || '',
userName: safeContext.userName || '',
menus
}
}
function readJsonIfExists(file, fallback) {
if (!fs.existsSync(file)) return fallback
return JSON.parse(fs.readFileSync(file, 'utf8'))
}
function loadGeneratedKnowledge() {
const generatedDir = path.join(__dirname, 'knowledge', 'generated')
return {
pages: readJsonIfExists(path.join(generatedDir, 'page-catalog.json'), []),
apiCalls: readJsonIfExists(path.join(generatedDir, 'api-calls.json'), []),
databaseInventory: readJsonIfExists(path.join(generatedDir, 'database-inventory.json'), [])
}
}
function loadKnowledgeBase() {
const kbDir = path.join(__dirname, 'knowledge')
const indexPath = path.join(kbDir, 'index.json')
if (!fs.existsSync(indexPath)) {
return { index: [], documents: [] }
}
const index = JSON.parse(fs.readFileSync(indexPath, 'utf8'))
const documents = index.map(item => {
const filePath = path.join(kbDir, item.file)
const content = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : ''
return Object.assign({}, item, { content })
})
return { index, documents }
}
function searchKnowledgeBase(keyword, limit) {
const query = String(keyword || '').trim().toLowerCase()
if (!query) return []
const tokens = createSearchTokens(query)
const max = Math.max(1, Math.min(Number(limit) || 5, 10))
return knowledgeBase.documents
.map(doc => {
const haystack = [
doc.id,
doc.title,
doc.category,
(doc.tags || []).join(' '),
doc.summary,
doc.content
].join('\n').toLowerCase()
let score = haystack.includes(query) ? 20 : 0
tokens.forEach(token => {
if (token && haystack.includes(token)) score += token.length > 1 ? 3 : 1
})
if (!score) return null
return {
id: doc.id,
title: doc.title,
category: doc.category,
tags: doc.tags,
summary: doc.summary,
score,
excerpt: makeExcerpt(doc.content, query, tokens)
}
})
.filter(Boolean)
.sort((a, b) => b.score - a.score)
.slice(0, max)
}
function readKnowledgeDocument(id, maxLength) {
const doc = knowledgeBase.documents.find(item => item.id === id)
if (!doc) {
return { error: `Knowledge document not found: ${id}` }
}
const size = Math.max(1000, Math.min(Number(maxLength) || 12000, 50000))
return {
id: doc.id,
title: doc.title,
category: doc.category,
tags: doc.tags,
summary: doc.summary,
content: doc.content.slice(0, size),
truncated: doc.content.length > size
}
}
function createSearchTokens(query) {
const tokens = new Set()
query.split(/[\s,，。；;、]+/).forEach(token => {
if (token) tokens.add(token)
})
if (/[\u4e00-\u9fa5]/.test(query)) {
for (let i = 0; i < query.length - 1; i++) {
const token = query.slice(i, i + 2)
if (/[\u4e00-\u9fa5]{2}/.test(token)) tokens.add(token)
}
}
return Array.from(tokens)
}
function makeExcerpt(content, query, tokens) {
const lower = content.toLowerCase()
let index = lower.indexOf(query)
if (index === -1) {
for (const token of tokens) {
index = lower.indexOf(token)
if (index !== -1) break
}
}
if (index === -1) return content.slice(0, 300)
const start = Math.max(0, index - 120)
const end = Math.min(content.length, index + 280)
return content.slice(start, end)
}
async function callMesCommonBase(payload) {
const response = await requestText(`${MES_BASE_URL.replace(/\/$/, '')}/submit/MESCommonBase.ashx`, {
method: 'POST',
body: payload
})
try {
return JSON.parse(response.body)
} catch (error) {
return response.body
}
}
function requestJson(url, options) {
return requestText(url, options).then(response => {
try {
return {
statusCode: response.statusCode,
headers: response.headers,
body: JSON.parse(response.body || '{}')
}
} catch (error) {
return {
statusCode: response.statusCode,
headers: response.headers,
body: { error: { message: response.body } }
}
}
})
}
function requestText(url, options) {
return new Promise((resolve, reject) => {
const target = new URL(url)
const transport = target.protocol === 'https:' ? https : http
const body = typeof options.body === 'string' ? options.body : JSON.stringify(options.body || {})
const headers = Object.assign({
'Content-Type': 'application/json',
'Content-Length': Buffer.byteLength(body)
}, options.headers || {})
const req = transport.request({
protocol: target.protocol,
hostname: target.hostname,
port: target.port,
path: `${target.pathname}${target.search}`,
method: options.method || 'GET',
headers
}, res => {
let raw = ''
res.setEncoding('utf8')
res.on('data', chunk => {
raw += chunk
})
res.on('end', () => {
resolve({
statusCode: res.statusCode,
headers: res.headers,
body: raw
})
})
})
req.on('error', reject)
req.setTimeout(120000, () => {
req.destroy(new Error('Upstream request timeout'))
})
if (body) req.write(body)
req.end()
})
}
function setCors(res) {
res.setHeader('Access-Control-Allow-Origin', '*')
res.setHeader('Access-Control-Allow-Headers', 'Content-Type')
res.setHeader('Access-Control-Allow-Methods', 'GET,POST,OPTIONS')
}
function sendJson(res, statusCode, data) {
res.statusCode = statusCode
res.setHeader('Content-Type', 'application/json; charset=utf-8')
if (statusCode === 204) return res.end()
res.end(JSON.stringify(data))
}
function readJson(req) {
return new Promise((resolve, reject) => {
let raw = ''
req.on('data', chunk => {
raw += chunk
if (raw.length > 1024 * 1024) {
reject(new Error('Request body too large'))
req.destroy()
}
})
req.on('end', () => {
if (!raw) return resolve({})
try {
resolve(JSON.parse(raw))
} catch (error) {
reject(new Error('Invalid JSON body'))
}
})
req.on('error', reject)
})
}
function loadEnv(filePath) {
if (!fs.existsSync(filePath)) return
const content = fs.readFileSync(filePath, 'utf8')
content.split(/\r?\n/).forEach(line => {
const trimmed = line.trim()
if (!trimmed || trimmed.startsWith('#')) return
const index = trimmed.indexOf('=')
if (index === -1) return
const key = trimmed.slice(0, index).trim()
const value = trimmed.slice(index + 1).trim()
if (!process.env[key]) process.env[key] = value
})
}
|
|---|