xiaoyuan-assistant 0.5.45

package/src/core/localCommandParser.js

@@ -0,0 +1,434 @@
+function normalize(text = '') {
+  return String(text)
+    .toLowerCase()
+    .replace(/[，。！？、；：,.!?;:()（）“”"'‘’]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/**
+ * 把一句自然语言拆成最小、可独立执行的指令片段。
+ * action 与 analysis 都会单独成为 step，顺序严格保持不变。
+ */
+export function splitLocalCommands(message = '', manifest = {}) {
+  const raw = String(message || '').replace(/\s+/g, ' ').trim()
+  if (!raw) return []
+
+  // 1) 明确连接词/标点优先切分；后续每段仍会继续做“能力锚点”切分。
+  const explicit = raw
+    .split(/(?:\s*(?:然后|接着|随后|之后|再|并且|并|以及|同时|另外|其次|最后|再然后)\s*)|\s*[；;。！？]\s*|\s*\n+\s*/)
+    .map((item) => item.trim())
+    .filter(Boolean)
+
+  const candidates = mergeCapabilities(manifest.functions, manifest.domElements)
+
+  const splitByAnchors = (text) => {
+    const localText = String(text || '').trim()
+    if (!localText) return []
+
+    const anchors = []
+    const lowerRaw = localText.toLowerCase()
+
+    const addAnchor = (value, item) => {
+      const needle = String(value ?? '').trim()
+      if (!needle) return
+      const lowerNeedle = needle.toLowerCase()
+      let from = 0
+      while (from < localText.length) {
+        const idx = lowerRaw.indexOf(lowerNeedle, from)
+        if (idx < 0) break
+        anchors.push({
+          start: idx,
+          end: idx + needle.length,
+          value,
+          item
+        })
+        from = idx + Math.max(1, needle.length)
+      }
+    }
+
+    for (const item of candidates) {
+      for (const value of item.params || []) addAnchor(value, item)
+    }
+
+    // 年份是“动态参数”：当前页面可能尚未渲染出年份 DOM，也必须先完成拆分。
+    const yearMatches = [...localText.matchAll(/(?:19|20)\d{2}年?/g)]
+    for (const match of yearMatches) {
+      const value = match[0]
+      const preferred = candidates.find((item) => {
+        const corpus = normalize(`${item.name || ''} ${item.description || ''}`)
+        return /年份|年|时间/.test(corpus) || /changeyear/i.test(String(item.name || ''))
+      })
+      if (preferred) {
+        addAnchor(value, preferred)
+      }
+    }
+
+    if (!anchors.length) return [localText]
+
+    // 长匹配优先，避免“物联监测”同时命中“监测”造成错误切分。
+    anchors.sort((a, b) => a.start - b.start || (b.end - b.start) - (a.end - a.start))
+    const filtered = []
+    for (const anchor of anchors) {
+      const overlap = filtered.some((item) => anchor.start < item.end && anchor.end > item.start)
+      if (!overlap) filtered.push(anchor)
+    }
+    filtered.sort((a, b) => a.start - b.start)
+
+    if (filtered.length <= 1) return [localText]
+
+    const chunks = []
+
+    // 关键修复：每个“参数锚点”定义一个真实指令边界。
+    // 示例：
+    // “切换到物联监测切换到基地资源切换到集成监管时间切换到2024”
+    // =>
+    // “切换到物联监测”
+    // “切换到基地资源”
+    // “切换到集成监管”
+    // “时间切换到2024”
+    for (let i = 0; i < filtered.length; i += 1) {
+      const current = filtered[i]
+      const start = i === 0 ? 0 : filtered[i - 1].end
+      const end = current.end
+      let chunk = localText.slice(start, end).trim()
+
+      chunk = chunk
+        .replace(/^(?:然后|接着|随后|之后|再|并且|并|以及|同时|另外|其次|最后|再然后|和|且|，|,|、)+/i, '')
+        .trim()
+
+      if (chunk) chunks.push(chunk)
+    }
+
+    // 最后一个参数之后如果还有自然语言，必须保留为独立指令，尤其是：
+    // “切换到2024，查看一下土壤墒情数据”
+    const last = filtered[filtered.length - 1]
+    const tail = localText.slice(last.end).trim()
+      .replace(/^(?:然后|接着|随后|之后|再|并且|并|以及|同时|另外|其次|最后|再然后|和|且|，|,|、)+/i, '')
+      .trim()
+    if (tail) chunks.push(tail)
+
+    return chunks
+  }
+
+  // 即使存在连接词，也继续检查每个片段内部是否粘连了多个动作。
+  // 这样“切换到A，并切换到B切换到C时间切换到2024”也能拆开。
+  const source = explicit.length > 1 ? explicit : [raw]
+  const result = []
+  for (const item of source) {
+    result.push(...splitByAnchors(item))
+  }
+
+  return result.filter(Boolean)
+}
+
+function valueText(value) {
+  return normalize(typeof value === 'object' ? JSON.stringify(value) : value)
+}
+
+function valueInText(value, text) {
+  const v = valueText(value)
+  const t = normalize(text)
+  return Boolean(v && t && t.includes(v))
+}
+
+function buildCompactText(text = '') {
+  return normalize(text).replace(/\s/g, '')
+}
+
+function phraseScore(clause, phrase) {
+  const a = buildCompactText(clause)
+  const b = buildCompactText(phrase)
+  if (!a || !b) return 0
+  if (a.includes(b)) return Math.min(12, 4 + b.length / 2)
+  // 很轻量的中文关键词重叠，不做昂贵的全 DOM 模糊搜索。
+  let hit = 0
+  for (const ch of new Set(b)) if (a.includes(ch)) hit += 1
+  return hit / Math.max(3, b.length) * 3
+}
+
+function isAnalysisClause(text = '') {
+  return /(分析|研判|评估|判断|原因|趋势|风险|建议|情况|长势|预测|对比|比较|统计|为什么|是否异常|异常)/i.test(String(text))
+}
+
+function looksLikeDataInspectionClause(text = '', dataSources = []) {
+  const value = String(text || '')
+  if (!/查看|获取|看看|看一下|查询|了解|读取|展示/.test(value)) return false
+  if (!/数据|信息|墒情|土壤|气象|天气|湿度|水分|温度|养分|氮|磷|钾|盐分|玉米|长势|病虫害/.test(value)) return false
+  if (!dataSources.length) return true
+  return dataSources.some((source) => scoreDataSource(value, source) > 0)
+}
+
+function normalizeParamKey(value) {
+  return typeof value === 'object' ? JSON.stringify(value) : String(value ?? '')
+}
+
+function mergeCapabilities(functions = [], domElements = []) {
+  const map = new Map()
+
+  for (const item of functions) {
+    if (!item?.name) continue
+    map.set(item.name, {
+      name: item.name,
+      description: item.description || '',
+      params: Array.isArray(item.params) ? [...item.params] : [],
+      registered: true
+    })
+  }
+
+  for (const item of domElements) {
+    if (!item?.name) continue
+    const existing = map.get(item.name)
+    if (!existing) {
+      map.set(item.name, {
+        name: item.name,
+        description: item.description || '',
+        params: Array.isArray(item.params) ? [...item.params] : [],
+        registered: false
+      })
+      continue
+    }
+
+    if (!existing.description && item.description) {
+      existing.description = item.description
+    }
+
+    const seen = new Set(existing.params.map(normalizeParamKey))
+    for (const value of item.params || []) {
+      const key = normalizeParamKey(value)
+      if (!seen.has(key)) {
+        seen.add(key)
+        existing.params.push(value)
+      }
+    }
+  }
+
+  return [...map.values()]
+}
+
+
+const BUILTIN_ALIASES = [
+  {
+    name: 'refreshPage',
+    aliases: ['刷新页面', '刷新一下页面', '刷新当前页面', '重新加载页面', '重载页面']
+  },
+  {
+    name: 'goBack',
+    aliases: ['返回上一页', '返回上一个页面', '退回上一页', '后退', '返回上级页面', '回到上一页']
+  },
+  {
+    name: 'goForward',
+    aliases: ['前进', '前往下一页', '前往下一个页面', '进入下一页', '下一页']
+  },
+  {
+    name: 'openDataCenter',
+    aliases: ['打开数据中台', '进入数据中台', '前往数据中台', '打开数据平台', '进入数据平台']
+  },
+  {
+    name: 'closeDataCenter',
+    aliases: ['关闭数据中台', '退出数据中台', '关闭数据平台', '退出数据平台', '离开数据中台']
+  },
+  {
+    name: 'scrollPageTop',
+    aliases: ['滚动到顶部', '回到顶部', '返回顶部', '页面顶部']
+  },
+  {
+    name: 'scrollPageBottom',
+    aliases: ['滚动到底部', '到页面底部', '页面底部']
+  }
+]
+
+function matchBuiltinAlias(clause = '', candidates = []) {
+  const text = normalize(clause)
+  if (!text) return null
+  for (const item of BUILTIN_ALIASES) {
+    const candidate = candidates.find((v) => v.name === item.name)
+    if (!candidate) continue
+    const alias = item.aliases.find((value) => text.includes(normalize(value)))
+    if (alias) return { item: candidate, value: undefined }
+  }
+  return null
+}
+
+function inferGenericAction(clause, candidates = []) {
+  const text = String(clause || '')
+  const yearMatch = text.match(/((?:19|20)\d{2})年?/)
+  if (yearMatch) {
+    // 即使目标页面尚未加载、data-ai-param 尚未出现在 DOM，
+    // 年份这种明确语义也可以先确定 Function；执行时再等待对应 DOM。
+    const yearCandidates = candidates.filter((item) => {
+      const corpus = normalize([item.name || '', item.description || ''].join(' '))
+      return /年份|年|时间/.test(corpus) || /changeyear/i.test(String(item.name || ''))
+    })
+    const preferred = yearCandidates.find((item) => /changeyear/i.test(String(item.name || ''))) || yearCandidates[0]
+    if (preferred) return { item: preferred, value: yearMatch[1] }
+  }
+  return null
+}
+
+function extractParamFromClause(clause, item) {
+  const params = Array.isArray(item.params) ? item.params : []
+
+  // 1. 优先匹配页面真实存在的 data-ai-param。
+  for (const value of params) {
+    if (valueInText(value, clause)) return value
+  }
+
+  // 2. 常见自然语言参数提取：2023年 / A001地块 / 40厘米等。
+  const year = clause.match(/((?:19|20)\d{2})年?/)
+  if (year && params.some((v) => String(v) === year[1])) return year[1]
+
+  const number = clause.match(/(?:切换|选择|设置|定位|打开|进入|到|为|成)\s*([\u4e00-\u9fa5A-Za-z0-9_-]{1,50})/)
+  if (number) {
+    const candidate = number[1]
+    const matched = params.find((v) => String(v) === candidate)
+    if (matched !== undefined) return matched
+  }
+
+  return undefined
+}
+
+function scoreCapability(clause, item) {
+  const text = normalize(clause)
+  let score = 0
+
+  const param = extractParamFromClause(clause, item)
+  if (param !== undefined) score += 100
+
+  if (item.name && text.includes(normalize(item.name))) score += 30
+
+  if (item.description) {
+    score += phraseScore(clause, item.description)
+  }
+
+  // 操作动词 + 描述动词的小加分。
+  const verbs = ['切换', '打开', '关闭', '进入', '选择', '定位', '放大', '缩小', '显示', '隐藏', '查看', '跳转']
+  const hasVerb = verbs.some((verb) => text.includes(verb))
+  if (hasVerb && item.description) score += 2
+
+  return score
+}
+
+function pickBestAction(clause, candidates = []) {
+  const ranked = candidates
+    .map((item) => ({ item, score: scoreCapability(clause, item) }))
+    .sort((a, b) => b.score - a.score)
+
+  const best = ranked[0]
+  if (!best || best.score < 4) return null
+
+  const second = ranked[1]
+  // 有明确参数命中时，不因为第二候选存在而误判；参数通常就是最可靠的目标信息。
+  const bestParam = extractParamFromClause(clause, best.item)
+  if (bestParam !== undefined) return { item: best.item, value: bestParam }
+
+  if (second && best.score - second.score < 2) return null
+  return { item: best.item, value: undefined }
+}
+
+function scoreDataSource(clause, source) {
+  const text = buildCompactText(clause)
+  const corpus = buildCompactText([
+    source.name || '',
+    source.description || '',
+    ...Object.entries(source.schema || {}).flatMap(([key, value]) => [key, value?.description || ''])
+  ].join(' '))
+
+  let score = 0
+  if (source.name && text.includes(buildCompactText(source.name))) score += 20
+
+  const keywords = [
+    '土壤', '墒情', '湿度', '水分', '温度', '氮', '磷', '钾', '盐分',
+    '气象', '天气', '雨量', '降雨', '风速', '光照',
+    '玉米', '作物', '长势', '病虫害', '虫害', '病害'
+  ]
+  for (const keyword of keywords) {
+    if (text.includes(keyword) && corpus.includes(keyword)) score += 5
+  }
+
+  score += phraseScore(clause, source.description || '')
+  return score
+}
+
+function pickDataSourcesForClause(clause, dataSources = []) {
+  const ranked = dataSources
+    .map((source) => ({ source, score: scoreDataSource(clause, source) }))
+    .sort((a, b) => b.score - a.score)
+
+  const best = ranked[0]
+  if (!best || best.score <= 0) return []
+
+  return ranked
+    .filter((item) => item.score >= Math.max(3, best.score * 0.5))
+    .slice(0, 3)
+    .map((item) => ({ name: item.source.name, params: {} }))
+}
+
+/**
+ * 纯 JS 解析：
+ * 1. 先拆分连续自然语言；
+ * 2. action：根据 data-ai-description + data-ai-param 精确选出 function；
+ * 3. analysis：仅选择 DataSource，真正分析留给 Analyzer AI；
+ * 4. 只有 action 无法确定时，才允许 Manager 回退到 Planner AI。
+ */
+export function parseLocalCommands(message, manifest = {}) {
+  const clauses = splitLocalCommands(message, manifest)
+  if (!clauses.length) return { ok: false, steps: [], reason: 'empty' }
+
+  const candidates = mergeCapabilities(manifest.functions, manifest.domElements)
+  const dataSources = Array.isArray(manifest.dataSources) ? manifest.dataSources : []
+  const steps = []
+  let unresolved = []
+
+  for (const clause of clauses) {
+    if (isAnalysisClause(clause) || looksLikeDataInspectionClause(clause, dataSources)) {
+      const requests = pickDataSourcesForClause(clause, dataSources)
+      if (!requests.length) {
+        unresolved.push(clause)
+        continue
+      }
+
+      const analysisInstruction = String(clause)
+        .replace(/^(?:年|年份|时间)\s*[,，、]?\s*/i, '')
+        .replace(/^(?:请|请帮我|帮我|帮忙|麻烦|想看一下|想看看|想了解|查看一下|查看|看一下|看看|查询一下|查询|获取一下|获取|读取一下|读取|展示一下|展示|分析一下|分析|分析下|看下|了解一下|了解)\s*/i, '')
+        .trim()
+
+      steps.push({
+        type: 'analysis',
+        dataRequests: requests,
+        instruction: analysisInstruction || clause
+      })
+      continue
+    }
+
+    let matched = matchBuiltinAlias(clause, candidates)
+    if (!matched) matched = pickBestAction(clause, candidates)
+    if (!matched) matched = inferGenericAction(clause, candidates)
+    if (!matched) {
+      unresolved.push(clause)
+      continue
+    }
+
+    steps.push({
+      type: 'action',
+      function: matched.item.name,
+      params: matched.value !== undefined ? { value: matched.value } : {}
+    })
+  }
+
+  // 只有全部步骤都能本地确定时才算 local-only；混合场景也保留已解析步骤，交给 Manager 决定是否补一次 Planner。
+  return {
+    ok: steps.length > 0 && unresolved.length === 0,
+    partial: steps.length > 0 && unresolved.length > 0,
+    steps,
+    unresolved,
+    reason: unresolved.length ? `unresolved:${unresolved.join(' | ')}` : 'local-complete'
+  }
+}
+
+export function looksLikeAnalysisLocal(message = '') {
+  const text = String(message || '')
+  // 明确分析类请求，或“查看/查询/获取 + 数据类信息”也属于数据分析流程，
+  // 需要把 DataSource 清单带入本地解析，不能因为没有“分析”二字而漏掉。
+  return isAnalysisClause(text) || /(查看|获取|看看|看一下|查询|了解|读取|展示).*(数据|信息|墒情|土壤|气象|天气|湿度|水分|温度|养分|氮|磷|钾|盐分|玉米|长势|病虫害)/.test(text)
+}