@hhhpyb/system-assistant-client 1.3.6 → 1.3.7

package/README.md

@@ -24,7 +24,7 @@ export default {
 
 无需在 `nuxt.config.js` 中配置 `SA_GUIDE_APP_KEY`。模块会在构建时自动将应用标识注入 Nuxt 运行时配置。
 
-模块还会自动接入 `@hhhpyb/guide-compiler`：Nuxt 2/Bridge 的 Webpack 与 Vite 客户端构建均会在不重复挂载的前提下生成 `.nuxt/sa-guide-manifest.json`，无需在业务项目中配置 compiler loader 或 Vite plugin。
+模块已内置 guide compiler：Nuxt 2/Bridge 的 Webpack 与 Vite 客户端构建均会在不重复挂载的前提下生成 `.nuxt/sa-guide-manifest.json`，无需在业务项目额外安装 compiler 或配置 loader、Vite plugin。
 
 ### 应用标识推导
 
@@ -69,7 +69,7 @@ URL 带 `?sa_studio=1` 时自动进入 Studio 点选模式，支持 `sa_app_key`
 
 ## 发布（维护者）
 
-源码：`system-assistant/deployables/sa-guide-sdk/app/v1/system-assistant.client.js`
+源码：`system-assistant/deployables/sa-guide-sdk/app/v1/system-assistant.client.js`；内置 compiler 权威源码：`system-assistant/packages/guide-compiler/src`。
 
 ```bash
 cd packages/system-assistant-client

package/dist/compiler/angular.js

@@ -0,0 +1,15 @@
+import { normalizeOptions, transformInlineTemplates, transformTemplate } from './core.js'
+
+export function transformAngularTemplate(code, id, options = {}, sink = []) {
+  return transformTemplate(code, id, {
+    ...normalizeOptions(options),
+    framework: 'angular',
+  }, sink)
+}
+
+export function transformAngularComponentTs(code, id, options = {}, sink = []) {
+  return transformInlineTemplates(code, id, {
+    ...normalizeOptions(options),
+    framework: 'angular',
+  }, sink)
+}

package/dist/compiler/core.js

@@ -0,0 +1,852 @@
+import crypto from 'node:crypto'
+import path from 'node:path'
+
+const DEFAULT_SENSITIVE_WORDS = [
+  'salary', 'amount', 'money', 'payroll', 'approval-result',
+  '薪资', '工资', '金额', '审批结论', '人员信息', '身份证', '手机号',
+]
+
+const ACTION_ALIASES = [
+  ['add', /^(add|new|create|新增|添加|新建)$/i],
+  ['edit', /^(edit|update|modify|编辑|修改)$/i],
+  ['detail', /^(detail|details|view|show|info|详情|查看)$/i],
+  ['delete', /^(delete|remove|del|删除|移除)$/i],
+  ['search', /^(search|query|find|查询|搜索)$/i],
+  ['export', /^(export|download|导出|下载)$/i],
+  ['import', /^(import|upload|导入|上传)$/i],
+  ['save', /^(save|保存)$/i],
+  ['submit', /^(submit|提交)$/i],
+  ['close', /^(close|cancel|关闭|取消)$/i],
+  ['filter', /^(filter|筛选|过滤)$/i],
+  ['switch', /^(switch|change|tab|切换)$/i],
+]
+
+const TARGET_TAGS = new Set([
+  'button', 'a', 'input', 'textarea', 'select', 'option', 'label',
+  'table', 'thead', 'tbody', 'th', 'td', 'tr', 'form',
+])
+
+const TARGET_COMPONENT_HINTS = [
+  'button', 'btn', 'input', 'select', 'date', 'picker', 'tab', 'tabs', 'menu',
+  'dialog', 'modal', 'drawer', 'table', 'column', 'form', 'toolbar', 'search',
+]
+
+const VOID_TAGS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'])
+
+function findTagCloseIndex(code, start) {
+  let quote = null
+  for (let i = start + 1; i < code.length; i += 1) {
+    const ch = code[i]
+    if (quote) {
+      if (ch === quote && code[i - 1] !== '\\') quote = null
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch
+      continue
+    }
+    if (ch === '>') return i
+  }
+  return -1
+}
+
+function findNextTemplateTag(code, fromIndex = 0) {
+  let i = fromIndex
+  while (i < code.length) {
+    if (code[i] !== '<') {
+      i += 1
+      continue
+    }
+    if (code.startsWith('<!--', i)) {
+      const end = code.indexOf('-->', i + 4)
+      i = end >= 0 ? end + 3 : code.length
+      continue
+    }
+    if (code[i + 1] === '!' || code[i + 1] === '?') {
+      const closeIndex = findTagCloseIndex(code, i)
+      i = closeIndex >= 0 ? closeIndex + 1 : code.length
+      continue
+    }
+    if (code[i + 1] === '/') {
+      const closeTagMatch = code.slice(i + 2).match(/^([A-Za-z][\w.:-]*)/)
+      if (closeTagMatch) {
+        const tag = closeTagMatch[1]
+        const closeIndex = findTagCloseIndex(code, i)
+        if (closeIndex < 0) return null
+        return { index: i, tag, attrs: '', raw: code.slice(i, closeIndex + 1), closeIndex, isClose: true }
+      }
+    }
+    const nameMatch = code.slice(i + 1).match(/^([A-Za-z][\w.:-]*)/)
+    if (!nameMatch) {
+      i += 1
+      continue
+    }
+    const tag = nameMatch[1]
+    const closeIndex = findTagCloseIndex(code, i)
+    if (closeIndex < 0) return null
+    const raw = code.slice(i, closeIndex + 1)
+    const attrs = raw.slice(1 + tag.length, raw.length - 1)
+    return { index: i, tag, attrs, raw, closeIndex, isClose: false }
+  }
+  return null
+}
+
+export function createGuideCompiler(options = {}) {
+  const normalized = normalizeOptions(options)
+  const collected = []
+  return {
+    transformVue2(code, id) {
+      return transformVueSfc(code, id, { ...normalized, framework: 'vue2' }, collected)
+    },
+    transformVue3(code, id) {
+      return transformVueSfc(code, id, { ...normalized, framework: 'vue3' }, collected)
+    },
+    transformAngularTemplate(code, id) {
+      return transformTemplate(code, id, { ...normalized, framework: 'angular' }, collected)
+    },
+    transformAngularComponentTs(code, id) {
+      return transformInlineTemplates(code, id, { ...normalized, framework: 'angular' }, collected)
+    },
+    getManifest(extra = {}) {
+      return buildManifest(collected, normalized, extra)
+    },
+  }
+}
+
+export function normalizeOptions(options = {}) {
+  return {
+    enabled: options.enabled !== false,
+    appKey: sanitizeSegment(options.appKey || 'app') || 'app',
+    idPrefix: sanitizeSegment(options.idPrefix || options.appKey || 'app') || 'app',
+    routePrefix: sanitizeSegment(options.routePrefix || '') || '',
+    menuResolver: options.menuResolver || null,
+    rootDir: options.rootDir || process.cwd(),
+    include: options.include || null,
+    exclude: options.exclude || null,
+    sensitiveWords: [...DEFAULT_SENSITIVE_WORDS, ...(options.sensitiveWords || [])],
+    productionDuplicatePolicy: options.productionDuplicatePolicy || 'block_manual',
+    manifestOutput: options.manifestOutput || '',
+    lowConfidenceThreshold: Number(options.lowConfidenceThreshold || 60),
+  }
+}
+
+export function transformVueSfc(code, id, options = {}, sink = []) {
+  if (!options.enabled) return { code, manifest: buildManifest(sink, options) }
+  return replaceTemplateBlocks(code, (template, startOffset) => (
+    transformTemplate(template, id, options, sink, startOffset).code
+  ))
+}
+
+export function transformTemplate(code, id, options = {}, sink = [], baseOffset = 0) {
+  const opts = normalizeOptions(options)
+  if (!opts.enabled || !shouldProcess(id, opts)) return { code, manifest: buildManifest(sink, opts) }
+
+  const local = []
+  const replacements = []
+  const stack = []
+  let pos = 0
+  let tagInfo = findNextTemplateTag(code, pos)
+  while (tagInfo) {
+    const { index, tag, attrs, raw, closeIndex, isClose } = tagInfo
+    const lowerTag = tag.toLowerCase()
+    if (isClose) {
+      popStack(stack, lowerTag)
+      pos = closeIndex + 1
+      tagInfo = findNextTemplateTag(code, pos)
+      continue
+    }
+    const selfClosing = raw.endsWith('/>') || VOID_TAGS.has(lowerTag)
+
+    const context = stackContext(stack)
+    const classification = classifyTarget(tag, attrs, code, index, context)
+    if (classification.target) {
+      const manualId = getAttr(attrs, 'data-guide-id') || getAttr(attrs, 'data-guide') || getAttr(attrs, 'data-gui-code')
+      const openEnd = code.indexOf('>', index)
+      const simpleText = openEnd >= 0 ? extractElementText(code, openEnd + 1, lowerTag) : ''
+      const evidence = extractEvidence(tag, attrs, simpleText)
+      const source = manualId ? 'manual' : 'auto'
+      const item = buildManifestItem({
+        id,
+        tag,
+        attrs,
+        offset: baseOffset + index,
+        context,
+        classification,
+        evidence,
+        source,
+        manualId,
+        options: opts,
+      })
+      local.push(item)
+      if (!manualId) {
+        const insert = buildDataGuideAttrs(item)
+        const closeIndexInRaw = raw.endsWith('/>') ? raw.length - 2 : raw.length - 1
+        replacements.push({
+          start: index + closeIndexInRaw,
+          end: index + closeIndexInRaw,
+          text: insert,
+        })
+      }
+    }
+
+    if (!selfClosing) {
+      stack.push({
+        tag: lowerTag,
+        kind: classification.kind || '',
+        scope: inferScope(context, attrs, classification.kind),
+        text: extractSimpleText(code, closeIndex + 1),
+        guideId: getAttr(attrs, 'data-guide-id') || getAttr(attrs, 'data-guide') || getAttr(attrs, 'data-gui-code') || '',
+      })
+    }
+    pos = closeIndex + 1
+    tagInfo = findNextTemplateTag(code, pos)
+  }
+
+  resolveDuplicates(local, opts)
+  sink.push(...local)
+  return { code: applyReplacements(code, replacements, local), manifest: buildManifest(sink, opts) }
+}
+
+export function transformInlineTemplates(code, id, options = {}, sink = []) {
+  const opts = normalizeOptions(options)
+  if (!opts.enabled || !shouldProcess(id, { ...opts, include: opts.include || ['.ts'] })) {
+    return { code, manifest: buildManifest(sink, opts) }
+  }
+  const replacements = []
+  const re = /template\s*:\s*(`([\s\S]*?)`|"([^"]*?)"|'([^']*?)')/g
+  let match
+  while ((match = re.exec(code))) {
+    const quote = match[1][0]
+    const template = match[2] || match[3] || match[4] || ''
+    const result = transformTemplate(template, id, { ...opts, include: opts.include || ['.ts'] }, sink, match.index)
+    if (result.code === template) continue
+    replacements.push({
+      start: match.index + match[0].indexOf(match[1]) + 1,
+      end: match.index + match[0].indexOf(match[1]) + match[1].length - 1,
+      text: escapeInlineTemplate(result.code, quote),
+    })
+  }
+  if (!replacements.length) return { code, manifest: buildManifest(sink, opts) }
+  let out = code
+  replacements.slice().reverse().forEach((replacement) => {
+    out = out.slice(0, replacement.start) + replacement.text + out.slice(replacement.end)
+  })
+  return { code: out, manifest: buildManifest(sink, opts) }
+}
+
+export function buildManifest(items = [], options = {}, extra = {}) {
+  const opts = normalizeOptions(options)
+  const manifestItems = dedupeManifestItems(items)
+  return {
+    schema_version: 1,
+    generated_at: extra.generated_at || new Date().toISOString(),
+    app_key: extra.app_key || opts.appKey,
+    id_prefix: opts.idPrefix,
+    items: manifestItems.map((item) => ({ ...item })),
+    diagnostics: manifestDiagnostics(manifestItems, opts),
+  }
+}
+
+export function validateManifestContract(manifest = {}, guide = {}) {
+  const items = Array.isArray(manifest.items) ? manifest.items : []
+  const idSet = new Set(items.map((item) => item.guide_id).filter(Boolean))
+  const manualCounts = countBy(items.filter((item) => item.source === 'manual').map((item) => item.guide_id))
+  const used = collectGuideIdsFromGuide(guide)
+  const missing = used.filter((id) => !idSet.has(id))
+  const duplicateManual = Object.entries(manualCounts)
+    .filter(([, count]) => count > 1)
+    .map(([guide_id, count]) => ({ guide_id, count }))
+  const lowConfidence = items.filter((item) => item.source === 'auto' && Number(item.confidence || 0) < 60)
+  const drift = manifest.diagnostics && manifest.diagnostics.auto_id_drift || null
+  const status = missing.length || duplicateManual.length ? 'block' : (lowConfidence.length || drift && drift.status === 'warn' ? 'warn' : 'allow')
+  return {
+    status,
+    missing,
+    duplicate_manual: duplicateManual,
+    low_confidence: lowConfidence.map((item) => ({
+      guide_id: item.guide_id,
+      confidence: item.confidence,
+      file: item.file,
+      diagnostics: item.diagnostics,
+    })),
+    auto_id_drift: drift,
+    summary: {
+      used: used.length,
+      manifest_items: items.length,
+      missing: missing.length,
+      duplicate_manual: duplicateManual.length,
+      low_confidence: lowConfidence.length,
+      auto_id_drift: drift && drift.status === 'warn' ? 1 : 0,
+    },
+  }
+}
+
+export function compareManifestDrift(previous = {}, current = {}, options = {}) {
+  const threshold = Number(options.autoIdDriftWarnRate || 0.2)
+  const minChanged = Number(options.autoIdDriftWarnMinChanged || 5)
+  const previousItems = Array.isArray(previous.items) ? previous.items : []
+  const currentItems = Array.isArray(current.items) ? current.items : []
+  const previousAuto = previousItems.filter((item) => item && item.source === 'auto' && item.guide_id)
+  const currentAuto = currentItems.filter((item) => item && item.source === 'auto' && item.guide_id)
+  const previousByStableKey = new Map(previousAuto.map((item) => [manifestStableKey(item), item]).filter(([key]) => key))
+  const changedStableKeys = new Set()
+  const changed = currentAuto
+    .map((item) => {
+      const stableKey = manifestStableKey(item)
+      const previousItem = previousByStableKey.get(stableKey)
+      if (!previousItem || previousItem.guide_id === item.guide_id) return null
+      changedStableKeys.add(stableKey)
+      return {
+        stable_key: stableKey,
+        previous_guide_id: previousItem.guide_id,
+        current_guide_id: item.guide_id,
+        file: item.file || previousItem.file || '',
+      }
+    })
+    .filter(Boolean)
+  const previousIds = new Set(previousAuto.map((item) => item.guide_id))
+  const currentIds = new Set(currentAuto.map((item) => item.guide_id))
+  const removed = previousAuto
+    .filter((item) => !currentIds.has(item.guide_id) && !changedStableKeys.has(manifestStableKey(item)))
+    .map((item) => summarizeDriftItem(item))
+  const added = currentAuto
+    .filter((item) => !previousIds.has(item.guide_id) && !changedStableKeys.has(manifestStableKey(item)))
+    .map((item) => summarizeDriftItem(item))
+  const changedCount = removed.length + added.length + changed.length
+  const base = Math.max(previousAuto.length, currentAuto.length, 1)
+  const changedRate = changedCount / base
+  const shouldWarn = changedCount >= minChanged || changedRate > threshold
+  return {
+    auto_id_drift: {
+      status: shouldWarn ? 'warn' : 'allow',
+      previous_auto_count: previousAuto.length,
+      current_auto_count: currentAuto.length,
+      added_count: added.length,
+      removed_count: removed.length,
+      changed_count: changed.length,
+      changed_rate: Number(changedRate.toFixed(4)),
+      added: added.slice(0, 20),
+      removed: removed.slice(0, 20),
+      changed: changed.slice(0, 20),
+    },
+  }
+}
+
+function replaceTemplateBlocks(code, replacer) {
+  const re = /<template([^>]*)>([\s\S]*?)<\/template>/gi
+  let out = ''
+  let last = 0
+  let changed = false
+  let match
+  while ((match = re.exec(code))) {
+    const start = match.index + match[0].indexOf(match[2])
+    out += code.slice(last, start)
+    out += replacer(match[2], start)
+    last = start + match[2].length
+    changed = true
+  }
+  if (!changed) return { code }
+  out += code.slice(last)
+  return { code: out }
+}
+
+function shouldProcess(id, options) {
+  const normalized = id.replace(/\\/g, '/')
+  if (options.exclude && toMatcher(options.exclude)(normalized)) return false
+  if (options.include) return toMatcher(options.include)(normalized)
+  return /\.(vue|html|component\.html)$/i.test(normalized)
+}
+
+function toMatcher(value) {
+  const list = Array.isArray(value) ? value : [value]
+  return (input) => list.some((item) => {
+    if (!item) return false
+    if (item instanceof RegExp) return item.test(input)
+    return input.includes(String(item))
+  })
+}
+
+function escapeInlineTemplate(value, quote) {
+  if (quote === '`') return String(value).replace(/`/g, '\\`')
+  if (quote === '"') return String(value).replace(/"/g, '\\"')
+  return String(value).replace(/'/g, "\\'")
+}
+
+const CLOSE_BUTTON_CLASS_RE = /(?:^|\s)(el-dialog__headerbtn|vxe-modal--close-btn|ant-modal-close|ant-drawer-close|mat-mdc-dialog-close|mat-dialog-close)(?:\s|$)/i
+
+function isCloseButtonClass(className = '') {
+  return CLOSE_BUTTON_CLASS_RE.test(className) || /headerbtn|modal--close|icon-close/i.test(className)
+}
+
+function structuralAttrText(attrs = '') {
+  return String(attrs || '')
+    .replace(/(?:@|v-on:|v-bind:|:)(?:click|tap)[^=]*=\s*(?:"[^"]*"|'[^']*')/gi, ' ')
+    .replace(/\bon[a-z]+\s*=\s*(?:"[^"]*"|'[^']*')/gi, ' ')
+}
+
+function isToolbarActionClass(className = '') {
+  return /btn[_-]|btn-green|btn_green|el-button|ant-btn/i.test(className)
+}
+
+function extractElementText(code, startOffset, tagName) {
+  const closeToken = `</${tagName}`
+  const closeIndex = code.toLowerCase().indexOf(closeToken.toLowerCase(), startOffset)
+  const slice = code.slice(startOffset, closeIndex >= 0 ? closeIndex : Math.min(code.length, startOffset + 240))
+  const langLiteral = slice.match(/\$lang\(\s*['"]([^'"]+)['"]\s*\)/)
+  if (langLiteral) return cleanText(langLiteral[1])
+  return cleanText(slice.replace(/<[^>]+>/g, ' '))
+}
+
+function classifyTarget(tag, attrs, code, offset, context) {
+  const lowerTag = tag.toLowerCase()
+  const componentName = lowerTag.replace(/^[a-z]+-/, '')
+  const attrText = attrs.toLowerCase()
+  const structuralAttrs = structuralAttrText(attrs).toLowerCase()
+  const eventName = extractEventName(attrs)
+  const className = getAttr(attrs, 'class') || ''
+  const role = getAttr(attrs, 'role') || ''
+  const inRow = context.kinds.includes('table') || /(v-for|\*ngfor|ng-repeat)/i.test(attrs)
+  const openEnd = code.indexOf('>', offset)
+  const simpleText = openEnd >= 0 ? extractElementText(code, openEnd + 1, lowerTag) : ''
+
+  if (TARGET_TAGS.has(lowerTag)) {
+    const closeButton = isCloseButtonClass(className)
+    return {
+      target: true,
+      kind: kindFromTag(lowerTag, role, className, inRow),
+      confidence: closeButton ? 80 : 80,
+      overlay_action: closeButton ? 'close' : undefined,
+    }
+  }
+  if (role && /button|tab|menuitem|dialog|table|row|cell|tabpanel/i.test(role)) {
+    return { target: true, kind: kindFromRole(role), confidence: 82 }
+  }
+  if (eventName && /click|tap|select|change|submit/i.test(attrs) && (isToolbarActionClass(className) || simpleText)) {
+    return { target: true, kind: inRow ? 'row_action' : 'button', confidence: 75 }
+  }
+  if (/toolbar|tool-bar|filter|search|query|form|dialog|drawer|modal|btnlist/i.test(className)) {
+    return { target: true, kind: kindFromClass(className), confidence: 66 }
+  }
+  if (TARGET_COMPONENT_HINTS.some((hint) => componentName.includes(hint) || structuralAttrs.includes(hint))) {
+    return { target: true, kind: kindFromComponent(componentName, structuralAttrs, inRow), confidence: 72 }
+  }
+  if (eventName && /click|tap|select|change|submit/i.test(attrs)) {
+    return { target: true, kind: inRow ? 'row_action' : 'button', confidence: 62 }
+  }
+  if (isCloseButtonClass(className)) {
+    const inOverlay = context.scopes.includes('dialog') || context.scopes.includes('drawer') || context.kinds.includes('region')
+    return { target: true, kind: 'button', confidence: inOverlay ? 80 : 72, overlay_action: 'close' }
+  }
+  return { target: false, kind: '', confidence: 0 }
+}
+
+function kindFromTag(tag, role, className, inRow) {
+  if (isCloseButtonClass(className)) return 'button'
+  if (/dialog|modal/.test(className) || role === 'dialog') return 'region'
+  if (/drawer/.test(className)) return 'region'
+  if (tag === 'table') return 'table'
+  if (tag === 'th') return 'column'
+  if (/btnList/.test(className) || inRow && ['button', 'a'].includes(tag)) return 'row_action'
+  if (['input', 'textarea', 'select', 'option'].includes(tag)) return 'input'
+  if (tag === 'form') return 'region'
+  if (role === 'tab') return 'tab'
+  return 'button'
+}
+
+function kindFromRole(role) {
+  if (role === 'tab') return 'tab'
+  if (role === 'dialog' || role === 'tabpanel') return 'region'
+  if (role === 'table') return 'table'
+  if (role === 'cell' || role === 'columnheader') return 'column'
+  if (role === 'menuitem') return 'menu_item'
+  return 'button'
+}
+
+function kindFromComponent(componentName, attrText, inRow) {
+  if (/dialog|modal|drawer|form/.test(componentName) || /dialog|modal|drawer|form/.test(attrText)) return 'region'
+  if (/table/.test(componentName)) return 'table'
+  if (/column/.test(componentName)) return 'column'
+  if (/tab/.test(componentName)) return 'tab'
+  if (/menu/.test(componentName)) return 'menu_item'
+  if (inRow) return 'row_action'
+  if (/input|select|date|picker/.test(componentName)) return 'input'
+  return 'button'
+}
+
+function kindFromClass(className) {
+  if (/dialog|drawer|modal|toolbar|filter|search|query|form/i.test(className)) return 'region'
+  if (/btnList/.test(className)) return 'row_action'
+  return 'button'
+}
+
+function extractEvidence(tag, attrs, simpleText) {
+  const eventName = extractEventName(attrs)
+  return {
+    text: cleanText(simpleText),
+    aria: getAttr(attrs, 'aria-label') || '',
+    title: getAttr(attrs, 'title') || '',
+    placeholder: getAttr(attrs, 'placeholder') || '',
+    name: getAttr(attrs, 'name') || '',
+    eventName,
+    component: tag,
+  }
+}
+
+function buildManifestItem(input) {
+  const { id, tag, attrs, offset, context, classification, evidence, source, manualId, options } = input
+  const file = normalizeFile(id, options.rootDir)
+  const pageContext = resolvePageContext(file, options)
+  const page = pageContext.page
+  const scope = inferScope(context, attrs, classification.kind)
+  const semantic = semanticSegment(evidence) || classification.kind || tag
+  const base = manualId || [options.idPrefix, page, scope, semantic].filter(Boolean).join('.')
+  const hash = shortHash(`${file}:${offset}:${tag}:${semantic}`)
+  const generatedBase = sanitizeGuideId(base) || options.idPrefix
+  const generatedId = source === 'manual' ? manualId : `${generatedBase}__${hash}`
+  const guideId = source === 'manual' ? manualId : generatedId
+  const diagnostics = []
+  const sensitive = findSensitiveParts(guideId, options.sensitiveWords)
+  if (sensitive.length) diagnostics.push({ type: 'sensitive_word', values: sensitive })
+  if (classification.confidence < options.lowConfidenceThreshold) diagnostics.push({ type: 'low_confidence', confidence: classification.confidence })
+  if (source === 'auto' && !semantic) diagnostics.push({ type: 'missing_semantic' })
+  return {
+    guide_id: guideId,
+    source,
+    target_kind: classification.kind || 'element',
+    scope,
+    route: pageContext.route,
+    menu: pageContext.menu,
+    page,
+    file,
+    component: tag,
+    text: evidence.text || '',
+    aria: evidence.aria || '',
+    title: evidence.title || '',
+    event_name: evidence.eventName || (classification.overlay_action === 'close' ? 'close' : ''),
+    row_policy: classification.kind === 'row_action' ? 'first_visible' : '',
+    confidence: source === 'manual' ? 100 : classification.confidence,
+    hash,
+    generated: source === 'auto',
+    diagnostics,
+  }
+}
+
+function resolvePageContext(file, options) {
+  const fallbackPage = pageKeyFromFile(file, options)
+  const fallback = {
+    route: options.routePrefix || '',
+    menu: options.routePrefix || '',
+    page: fallbackPage,
+  }
+  const resolver = options.menuResolver
+  if (!resolver) return fallback
+  let resolved = null
+  if (typeof resolver === 'function') {
+    resolved = resolver({ file, appKey: options.appKey, routePrefix: options.routePrefix, fallbackPage }) || null
+  } else if (resolver && typeof resolver === 'object') {
+    resolved = resolver[file] || resolver[fallbackPage] || null
+  }
+  if (!resolved || typeof resolved !== 'object') return fallback
+  const route = String(resolved.route || resolved.routePath || fallback.route || '')
+  const menu = sanitizeSegment(resolved.menu || resolved.menuKey || resolved.menuCode || route || fallback.menu)
+  const page = sanitizePageKey(resolved.page || resolved.pageInstance || resolved.pageName || fallbackPage)
+  return {
+    route,
+    menu,
+    page,
+  }
+}
+
+function resolveDuplicates(items, options) {
+  const seen = new Map()
+  items.forEach((item) => {
+    const previous = seen.get(item.guide_id)
+    if (!previous) {
+      seen.set(item.guide_id, item)
+      return
+    }
+    if (previous.source === 'manual' && item.source === 'manual') {
+      previous.diagnostics.push({ type: 'duplicate_manual', duplicate_file: item.file })
+      item.diagnostics.push({ type: 'duplicate_manual', duplicate_file: previous.file })
+      return
+    }
+    if (item.source === 'auto') {
+      item.guide_id = `${item.guide_id}__${item.hash}`
+      item.diagnostics.push({ type: previous.source === 'manual' ? 'manual_auto_conflict' : 'auto_duplicate_suffix' })
+      seen.set(item.guide_id, item)
+      return
+    }
+    if (previous.source === 'auto') {
+      previous.guide_id = `${previous.guide_id}__${previous.hash}`
+      previous.diagnostics.push({ type: 'manual_auto_conflict' })
+      seen.set(previous.guide_id, previous)
+      seen.set(item.guide_id, item)
+      return
+    }
+  })
+}
+
+function buildDataGuideAttrs(item) {
+  const attrs = [
+    ` data-guide-id="${escapeAttr(item.guide_id)}"`,
+    ` data-guide-kind="${escapeAttr(item.target_kind)}"`,
+    ` data-guide-scope="${escapeAttr(item.scope)}"`,
+    ' data-guide-generated="true"',
+  ]
+  if (item.row_policy) attrs.push(` data-guide-row-policy="${escapeAttr(item.row_policy)}"`)
+  return attrs.join('')
+}
+
+function applyReplacements(code, replacements, localItems) {
+  if (!replacements.length) return code
+  let out = code
+  const autoItems = localItems.filter((item) => item.source === 'auto')
+  replacements.slice().reverse().forEach((replacement, indexFromEnd) => {
+    const item = autoItems[autoItems.length - 1 - indexFromEnd]
+    const text = item ? buildDataGuideAttrs(item) : replacement.text
+    out = out.slice(0, replacement.start) + text + out.slice(replacement.end)
+  })
+  return out
+}
+
+function manifestDiagnostics(items, options) {
+  const counts = countBy(items.map((item) => item.guide_id))
+  const duplicates = Object.entries(counts).filter(([, count]) => count > 1).map(([guide_id, count]) => ({ guide_id, count }))
+  const manualDuplicates = duplicates.filter((dup) => items.filter((item) => item.guide_id === dup.guide_id && item.source === 'manual').length > 1)
+  const sensitive = items.filter((item) => item.diagnostics.some((diag) => diag.type === 'sensitive_word'))
+  const lowConfidence = items.filter((item) => item.diagnostics.some((diag) => diag.type === 'low_confidence'))
+  return {
+    total: items.length,
+    auto: items.filter((item) => item.source === 'auto').length,
+    manual: items.filter((item) => item.source === 'manual').length,
+    duplicates,
+    manual_duplicates: manualDuplicates,
+    sensitive: sensitive.map((item) => item.guide_id),
+    low_confidence: lowConfidence.map((item) => item.guide_id),
+    status: manualDuplicates.length && options.productionDuplicatePolicy === 'block_manual' ? 'block' : (duplicates.length || sensitive.length || lowConfidence.length ? 'warn' : 'allow'),
+  }
+}
+
+function dedupeManifestItems(items) {
+  const seen = new Set()
+  const out = []
+  ;(items || []).forEach((item) => {
+    if (!item || !item.guide_id) return
+    const key = [
+      item.guide_id,
+      item.source || '',
+      item.file || '',
+      item.component || '',
+      item.hash || '',
+      item.target_kind || '',
+      item.scope || '',
+      item.text || '',
+      item.aria || '',
+      item.title || '',
+      item.event_name || '',
+      item.row_policy || '',
+    ].join('|')
+    if (seen.has(key)) return
+    seen.add(key)
+    out.push(item)
+  })
+  return out
+}
+
+function manifestStableKey(item) {
+  if (!item) return ''
+  return [
+    item.hash || '',
+    item.file || '',
+    item.component || '',
+    item.scope || '',
+    item.target_kind || '',
+    item.text || item.aria || item.title || item.event_name || '',
+  ].join('|')
+}
+
+function summarizeDriftItem(item) {
+  return {
+    guide_id: item.guide_id,
+    file: item.file || '',
+    component: item.component || '',
+    scope: item.scope || '',
+    text: item.text || item.aria || item.title || item.event_name || '',
+  }
+}
+
+function collectGuideIdsFromGuide(guide) {
+  const out = []
+  function visitLocator(locator) {
+    if (!locator || typeof locator !== 'object') return
+    const id = locator.guide_code || locator.guide_id
+    if (id) out.push(id)
+    if (locator.context) visitContext(locator.context)
+    ;(locator.context_stack || []).forEach(visitContext)
+    ;(locator.pre_actions || []).forEach((action) => visitLocator(action && action.target))
+  }
+  function visitContext(context) {
+    if (!context || typeof context !== 'object') return
+    visitLocator(context.root_locator || context.rootLocator)
+  }
+  ;(guide.steps || []).forEach(visitLocator)
+  return Array.from(new Set(out))
+}
+
+function inferScope(context, attrs, kind) {
+  const cls = getAttr(attrs, 'class') || ''
+  if (context.scopes && context.scopes.length) return context.scopes[context.scopes.length - 1]
+  if (/toolbar|tool-bar|operation/i.test(cls) || context.kinds.includes('toolbar')) return 'toolbar'
+  if (/filter|search|query/i.test(cls) || context.kinds.includes('filter')) return 'filter'
+  if (/dialog|modal/i.test(cls) || context.kinds.includes('dialog')) return 'dialog'
+  if (/drawer/i.test(cls) || context.kinds.includes('drawer')) return 'drawer'
+  if (/table|grid/i.test(cls) || context.kinds.includes('table') || kind === 'row_action' || kind === 'column') return 'table'
+  if (/form/i.test(cls) || context.kinds.includes('form')) return 'form'
+  if (/menu/i.test(cls) || context.kinds.includes('menu')) return 'menu'
+  return 'main'
+}
+
+function stackContext(stack) {
+  return {
+    kinds: stack.map((item) => item.kind).filter(Boolean),
+    scopes: stack.map((item) => item.scope).filter(Boolean),
+    guideIds: stack.map((item) => item.guideId).filter(Boolean),
+    texts: stack.map((item) => item.text).filter(Boolean),
+  }
+}
+
+function popStack(stack, lowerTag) {
+  for (let i = stack.length - 1; i >= 0; i -= 1) {
+    const item = stack.pop()
+    if (item.tag === lowerTag) return
+  }
+}
+
+function getAttr(attrs, name) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const re = new RegExp(`(?:^|\\s)(?:[:@\\w.-]+:)?${escaped}\\s*=\\s*("([^"]*)"|'([^']*)'|([^\\s"'=<>` + '`' + `]+))`, 'i')
+  const match = attrs.match(re)
+  return match ? (match[2] || match[3] || match[4] || '') : ''
+}
+
+function extractEventName(attrs) {
+  const patterns = [
+    /(?:@click|v-on:click|:on-click|\(click\)|ng-click|onClick)\s*=\s*"([^"]+)"/i,
+    /(?:@click|v-on:click|:on-click|\(click\)|ng-click|onClick)\s*=\s*'([^']+)'/i,
+  ]
+  for (const pattern of patterns) {
+    const match = attrs.match(pattern)
+    if (match) return normalizeEventName(match[1])
+  }
+  return ''
+}
+
+function normalizeEventName(value) {
+  const raw = String(value || '').split(/[({\s]/)[0].replace(/^this\./, '')
+  const tokens = raw
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .replace(/[_-]+/g, ' ')
+    .split(/\s+/)
+    .filter(Boolean)
+  const last = tokens[tokens.length - 1] || raw
+  return aliasAction(last) || sanitizeSegment(last)
+}
+
+function semanticSegment(evidence) {
+  const textCandidates = [
+    evidence.aria,
+    evidence.title,
+    evidence.placeholder,
+    evidence.name,
+    evidence.text,
+  ].map((item) => aliasAction(item) || sanitizeSegment(item)).filter(Boolean)
+  if (textCandidates.length) return textCandidates[0]
+  const eventName = evidence.eventName || ''
+  if (eventName && !/(?:Dialog|Modal|Drawer)$/i.test(eventName)) {
+    const fromEvent = aliasAction(eventName) || sanitizeSegment(eventName)
+    if (fromEvent) return fromEvent
+  }
+  const fallback = [
+    evidence.eventName,
+    evidence.component,
+  ].map((item) => aliasAction(item) || sanitizeSegment(item)).filter(Boolean)
+  return fallback[0] || ''
+}
+
+function aliasAction(value) {
+  const normalized = cleanText(value)
+  for (const [alias, pattern] of ACTION_ALIASES) {
+    if (pattern.test(normalized)) return alias
+  }
+  return ''
+}
+
+function extractSimpleText(code, offset) {
+  const nextTag = code.indexOf('<', offset)
+  const slice = code.slice(offset, nextTag >= 0 ? nextTag : Math.min(code.length, offset + 120))
+  return cleanText(slice)
+}
+
+function cleanText(value) {
+  return String(value || '').replace(/\{\{[^}]*}}/g, '').replace(/\s+/g, ' ').trim()
+}
+
+function pageKeyFromFile(file, options) {
+  const withoutExt = file.replace(/\.(vue|html|component\.html|ts|js)$/i, '').replace(/\.component$/i, '')
+  const trimmed = withoutExt.replace(/^(src\/)?(views|pages|routes|app)\//, '')
+  return [options.routePrefix, trimmed].filter(Boolean).map(sanitizePath).filter(Boolean).join('.') || 'page'
+}
+
+function normalizeFile(file, rootDir) {
+  const rel = path.relative(rootDir || process.cwd(), file)
+  return (rel && !rel.startsWith('..')) ? rel.replace(/\\/g, '/') : file.replace(/\\/g, '/')
+}
+
+function sanitizeGuideId(value) {
+  return String(value || '')
+    .split('.')
+    .map(sanitizeSegment)
+    .filter(Boolean)
+    .join('.')
+}
+
+function sanitizePath(value) {
+  return String(value || '').split(/[\\/]+/).map(sanitizeSegment).filter(Boolean).join('.')
+}
+
+function sanitizePageKey(value) {
+  return String(value || '').split(/[\\/.]+/).map(sanitizeSegment).filter(Boolean).join('.')
+}
+
+function sanitizeSegment(value) {
+  const raw = String(value || '').trim()
+  if (!raw) return ''
+  const ascii = raw
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^A-Za-z0-9_\-\u4e00-\u9fa5]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+  if (!ascii) return ''
+  return ascii.length > 36 ? ascii.slice(0, 36).replace(/-+$/g, '') : ascii
+}
+
+function shortHash(value) {
+  return crypto.createHash('sha1').update(String(value)).digest('hex').slice(0, 6)
+}
+
+function findSensitiveParts(value, words) {
+  const lower = String(value || '').toLowerCase()
+  return (words || []).filter((word) => word && lower.includes(String(word).toLowerCase()))
+}
+
+function countBy(values) {
+  const counts = {}
+  values.filter(Boolean).forEach((value) => {
+    counts[value] = (counts[value] || 0) + 1
+  })
+  return counts
+}
+
+function escapeAttr(value) {
+  return String(value || '').replace(/&/g, '&amp;').replace(/"/g, '&quot;')
+}

package/dist/compiler/index.js

@@ -0,0 +1,14 @@
+export {
+  createGuideCompiler,
+  transformTemplate,
+  transformInlineTemplates,
+  transformVueSfc,
+  buildManifest,
+  validateManifestContract,
+  compareManifestDrift,
+} from './core.js'
+
+export { transformVue2 } from './vue2.js'
+export { transformVue3 } from './vue3.js'
+export { transformAngularTemplate, transformAngularComponentTs } from './angular.js'
+export { systemAssistantGuideVitePlugin } from './vite.js'

package/dist/compiler/nuxt2.cjs

@@ -0,0 +1,20 @@
+const path = require('path')
+const GuideManifestWebpackPlugin = require('./webpack-plugin.cjs')
+
+module.exports = function setupGuideCompilerNuxt2(config, options) {
+  const opts = Object.assign({}, options || {})
+  const loaderPath = path.resolve(__dirname, 'webpack-loader.cjs')
+  config.module = config.module || {}
+  config.module.rules = config.module.rules || []
+  config.module.rules.unshift({
+    enforce: 'pre',
+    test: /\.vue$/,
+    use: [{
+      loader: loaderPath,
+      options: opts,
+    }],
+  })
+  config.plugins = config.plugins || []
+  config.plugins.push(new GuideManifestWebpackPlugin(opts))
+  return config
+}

package/dist/compiler/vite.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { createGuideCompiler, normalizeOptions } from './core.js'
+
+export function systemAssistantGuideVitePlugin(options = {}) {
+  const normalized = normalizeOptions(options)
+  const compiler = createGuideCompiler(normalized)
+  return {
+    name: 'system-assistant-guide-compiler',
+    enforce: 'pre',
+    transform(code, id) {
+      if (!normalized.enabled) return null
+      if (/\.vue$/i.test(id)) {
+        const result = compiler.transformVue3(code, id)
+        return result.code === code ? null : { code: result.code, map: null }
+      }
+      if (/\.(html|component\.html)$/i.test(id)) {
+        const result = compiler.transformAngularTemplate(code, id)
+        return result.code === code ? null : { code: result.code, map: null }
+      }
+      if (/\.ts$/i.test(id) && /template\s*:/.test(code)) {
+        const result = compiler.transformAngularComponentTs(code, id)
+        return result.code === code ? null : { code: result.code, map: null }
+      }
+      return null
+    },
+    generateBundle() {
+      const manifest = compiler.getManifest()
+      if (normalized.productionDuplicatePolicy === 'block_manual' && manifest.diagnostics.manual_duplicates.length) {
+        const duplicates = manifest.diagnostics.manual_duplicates.map((item) => `${item.guide_id}(${item.count})`).join(', ')
+        throw new Error(`[system-assistant-guide-compiler] 手写 data-guide-id 重复，生产构建已阻断：${duplicates}`)
+      }
+      if (!normalized.manifestOutput) return
+      const outputPath = path.resolve(process.cwd(), normalized.manifestOutput)
+      fs.mkdirSync(path.dirname(outputPath), { recursive: true })
+      fs.writeFileSync(outputPath, JSON.stringify(manifest, null, 2), 'utf8')
+    },
+  }
+}

package/dist/compiler/vue2.js

@@ -0,0 +1,8 @@
+import { normalizeOptions, transformVueSfc } from './core.js'
+
+export function transformVue2(code, id, options = {}, sink = []) {
+  return transformVueSfc(code, id, {
+    ...normalizeOptions(options),
+    framework: 'vue2',
+  }, sink)
+}

package/dist/compiler/vue3.js

@@ -0,0 +1,8 @@
+import { normalizeOptions, transformVueSfc } from './core.js'
+
+export function transformVue3(code, id, options = {}, sink = []) {
+  return transformVueSfc(code, id, {
+    ...normalizeOptions(options),
+    framework: 'vue3',
+  }, sink)
+}

package/dist/compiler/webpack-loader.cjs

@@ -0,0 +1,71 @@
+const crypto = require('crypto')
+
+const state = {
+  files: new Map(),
+  options: {},
+}
+
+function getLoaderOptions(ctx) {
+  if (ctx && typeof ctx.getOptions === 'function') return ctx.getOptions() || {}
+  const query = ctx && ctx.query
+  if (!query) return {}
+  if (typeof query === 'object') return query
+  if (typeof query === 'string') {
+    const text = query.replace(/^\?/, '')
+    if (!text) return {}
+    try {
+      return JSON.parse(text)
+    } catch (e) {
+      return text.split('&').reduce((acc, pair) => {
+        const parts = pair.split('=')
+        if (parts[0]) acc[decodeURIComponent(parts[0])] = decodeURIComponent(parts[1] || '')
+        return acc
+      }, {})
+    }
+  }
+  return {}
+}
+
+function sourceHash(source) {
+  return crypto.createHash('sha1').update(String(source || '')).digest('hex').slice(0, 8)
+}
+
+module.exports = function guideCompilerWebpackLoader(source) {
+  const callback = this.async()
+  const options = getLoaderOptions(this)
+  const resourcePath = this.resourcePath || ''
+  const resourceQuery = this.resourceQuery || ''
+  if (this.cacheable) this.cacheable()
+  if (/type=/.test(resourceQuery)) {
+    callback(null, source)
+    return
+  }
+  state.options = Object.assign({}, state.options, options)
+
+  import('./index.js').then((mod) => {
+    const sink = []
+    const result = /\.vue$/i.test(resourcePath)
+      ? mod.transformVue2(source, resourcePath, options, sink)
+      : mod.transformTemplate(source, resourcePath, options, sink)
+    state.files.set(resourcePath, {
+      hash: sourceHash(source),
+      items: sink,
+    })
+    callback(null, result.code)
+  }, (error) => {
+    callback(error)
+  })
+}
+
+module.exports.getGuideCompilerState = function getGuideCompilerState() {
+  return state
+}
+
+module.exports.getGuideManifestItems = function getGuideManifestItems() {
+  return Array.from(state.files.values()).flatMap((entry) => entry.items || [])
+}
+
+module.exports.resetGuideManifest = function resetGuideManifest() {
+  state.files.clear()
+  state.options = {}
+}

package/dist/compiler/webpack-plugin.cjs

@@ -0,0 +1,33 @@
+const fs = require('fs')
+const path = require('path')
+const loader = require('./webpack-loader.cjs')
+
+class SystemAssistantGuideWebpackPlugin {
+  constructor(options) {
+    this.options = options || {}
+  }
+
+  apply(compiler) {
+    compiler.hooks.emit.tapAsync('SystemAssistantGuideWebpackPlugin', (compilation, done) => {
+      import('./index.js').then((mod) => {
+        const loaderState = loader.getGuideCompilerState()
+        const options = Object.assign({}, loaderState.options || {}, this.options)
+        const manifest = mod.buildManifest(loader.getGuideManifestItems(), options)
+        const json = JSON.stringify(manifest, null, 2)
+        const assetName = options.manifestAsset || 'sa-guide-manifest.json'
+        compilation.assets[assetName] = {
+          source: () => json,
+          size: () => Buffer.byteLength(json),
+        }
+        if (options.manifestOutput) {
+          const outputPath = path.resolve(options.manifestOutput)
+          fs.mkdirSync(path.dirname(outputPath), { recursive: true })
+          fs.writeFileSync(outputPath, json, 'utf8')
+        }
+        done()
+      }, done)
+    })
+  }
+}
+
+module.exports = SystemAssistantGuideWebpackPlugin

package/nuxt.cjs

@@ -1,6 +1,6 @@
 const { resolve } = require('node:path')
 const { readFileSync } = require('node:fs')
-const setupGuideCompilerNuxt2 = require('@hhhpyb/guide-compiler/nuxt2')
+const setupGuideCompilerNuxt2 = require('./dist/compiler/nuxt2.cjs')
 
 const APP_KEY_ENV = 'SA_GUIDE_APP_KEY'
 const GUIDE_COMPILER_WEBPACK_MARKER = Symbol.for('system-assistant.guide-compiler.webpack')
@@ -67,7 +67,7 @@ function installGuideCompilerWebpack(config, options) {
 
 async function installGuideCompilerVite(config, options) {
   if (!config || config[GUIDE_COMPILER_VITE_MARKER]) return config
-  const { systemAssistantGuideVitePlugin } = await import('@hhhpyb/guide-compiler/vite')
+  const { systemAssistantGuideVitePlugin } = await import('./dist/compiler/vite.js')
   config.plugins = config.plugins || []
   if (!config.plugins.some((plugin) => plugin && plugin.name === 'system-assistant-guide-compiler')) {
     config.plugins.push(systemAssistantGuideVitePlugin(options))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hhhpyb/system-assistant-client",
-  "version": "1.3.6",
+  "version": "1.3.7",
   "description": "Nuxt 2 client plugin for System Assistant smart guide SDK",
   "keywords": [
     "nuxt",
@@ -33,12 +33,9 @@
       "optional": true
     }
   },
-  "dependencies": {
-    "@hhhpyb/guide-compiler": "0.1.0"
-  },
   "scripts": {
     "build": "node scripts/copy-dist.js",
-    "test": "node --test test/nuxt.test.cjs",
+    "test": "npm run build && node --test test/nuxt.test.cjs",
     "prepublishOnly": "npm run build"
   }
 }