@brms/ai-skills 0.1.0

package/skills/brms-prototype-generator/scripts/validate-generated.mjs

@@ -0,0 +1,838 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+const args = process.argv.slice(2)
+
+function usage() {
+  console.error('Usage: node scripts/validate-generated.mjs <generated-files-or-dirs...> [--repo-root <repo>]')
+}
+
+function parseArgs(argv) {
+  const paths = []
+  let repoRoot = process.cwd()
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === '--repo-root') {
+      repoRoot = argv[i + 1]
+      i += 1
+    } else if (arg === '--help' || arg === '-h') {
+      usage()
+      process.exit(0)
+    } else {
+      paths.push(arg)
+    }
+  }
+
+  if (!paths.length) {
+    usage()
+    process.exit(2)
+  }
+
+  return { repoRoot: path.resolve(repoRoot), paths }
+}
+
+function walk(target) {
+  if (!fs.existsSync(target)) return []
+  const stat = fs.statSync(target)
+  if (stat.isFile()) return [target]
+  if (!stat.isDirectory()) return []
+
+  return fs.readdirSync(target, { withFileTypes: true }).flatMap((entry) => {
+    const child = path.join(target, entry.name)
+    if (entry.isDirectory()) return walk(child)
+    return [child]
+  })
+}
+
+function lineNumber(text, index) {
+  return text.slice(0, index).split(/\r?\n/).length
+}
+
+function addIssue(issues, severity, file, line, message) {
+  issues.push({ severity, file, line, message })
+}
+
+function hasMarkerNear(text, index, markerPattern, lineWindow = 3) {
+  const beforeLines = text.slice(0, index).split(/\r?\n/)
+  const snippet = beforeLines.slice(Math.max(0, beforeLines.length - lineWindow - 1)).join('\n')
+  return markerPattern.test(snippet)
+}
+
+function findClosingBrace(text, openBraceIndex) {
+  let depth = 0
+  for (let i = openBraceIndex; i < text.length; i += 1) {
+    const char = text[i]
+    if (char === '{') depth += 1
+    if (char === '}') {
+      depth -= 1
+      if (depth === 0) return i
+    }
+  }
+  return -1
+}
+
+function findClosingPair(text, openIndex, openChar, closeChar) {
+  let depth = 0
+  let quote = ''
+  let escaped = false
+
+  for (let i = openIndex; i < text.length; i += 1) {
+    const char = text[i]
+
+    if (quote) {
+      if (escaped) {
+        escaped = false
+      } else if (char === '\\') {
+        escaped = true
+      } else if (char === quote) {
+        quote = ''
+      }
+      continue
+    }
+
+    if (char === '"' || char === "'" || char === '`') {
+      quote = char
+      continue
+    }
+    if (char === openChar) depth += 1
+    if (char === closeChar) {
+      depth -= 1
+      if (depth === 0) return i
+    }
+  }
+
+  return -1
+}
+
+function findFunctionBlocks(script) {
+  const blocks = []
+  const patterns = [
+    /(?:^|\n)\s*(?:async\s+)?function\s+\w+\s*\([^)]*\)\s*\{/g,
+    /(?:^|\n)\s*(?:const|let)\s+\w+\s*=\s*(?:async\s*)?(?:\([^)]*\)|\w+)\s*=>\s*\{/g,
+    /(?:^|\n)\s*onMounted\s*\(\s*(?:async\s*)?\(\)\s*=>\s*\{/g,
+  ]
+
+  for (const pattern of patterns) {
+    for (const match of script.matchAll(pattern)) {
+      const openBraceIndex = script.indexOf('{', match.index)
+      if (openBraceIndex === -1) continue
+      const closeBraceIndex = findClosingBrace(script, openBraceIndex)
+      if (closeBraceIndex === -1) continue
+      blocks.push({
+        index: match.index,
+        openBraceIndex,
+        closeBraceIndex,
+        text: script.slice(match.index, closeBraceIndex + 1),
+      })
+    }
+  }
+
+  return blocks.sort((a, b) => a.index - b.index)
+}
+
+function extractDefaultRouteObjects(text) {
+  const defaultMatch = /export\s+default\s*\[/.exec(text)
+  if (!defaultMatch)
+    return []
+
+  const arrayOpen = text.indexOf('[', defaultMatch.index)
+  const arrayClose = findClosingPair(text, arrayOpen, '[', ']')
+  if (arrayOpen === -1 || arrayClose === -1)
+    return []
+
+  const objects = []
+  let i = arrayOpen + 1
+  while (i < arrayClose) {
+    if (/\s|,/.test(text[i])) {
+      i += 1
+      continue
+    }
+    if (text[i] !== '{') {
+      i += 1
+      continue
+    }
+    const objectClose = findClosingPair(text, i, '{', '}')
+    if (objectClose === -1 || objectClose > arrayClose)
+      break
+
+    const block = text.slice(i, objectClose + 1)
+    objects.push({
+      index: i,
+      text: block,
+      path: /\bpath\s*:\s*['"]([^'"]+)['"]/.exec(block)?.[1] || '',
+      name: /\bname\s*:\s*['"]([^'"]+)['"]/.exec(block)?.[1] || '',
+      component: /\bcomponent\s*:\s*['"]([^'"]+)['"]/.exec(block)?.[1] || '',
+      hasChildren: /\bchildren\s*:\s*\[/.test(block),
+      isHide: /\bisHide\s*:\s*true\b/.test(block),
+    })
+    i = objectClose + 1
+  }
+
+  return objects
+}
+
+function validatePageCode(code) {
+  if (!/^[A-Z0-9]{6,}$/.test(code)) {
+    return 'Page code must be 6+ uppercase letters/digits, for example DMDA01. Do not generate short codes such as KQ01.'
+  }
+  return ''
+}
+
+function pageCodeFromComponent(component) {
+  const clean = component.replaceAll('\\', '/').replace(/\.vue$/i, '')
+  return clean.split('/').filter(Boolean).at(-1) || ''
+}
+
+function validateViewPath(file, repoRoot, issues) {
+  const normalized = path.relative(repoRoot, file).replaceAll(path.sep, '/')
+  const match = /(?:^|\/)src\/views\/([A-Z0-9]{2})\/([A-Z0-9]{2})\/([A-Z0-9]+)\.vue$/.exec(normalized)
+  if (!match)
+    return
+
+  const [, moduleCode, submoduleCode, pageCode] = match
+  const pageCodeMessage = validatePageCode(pageCode)
+  if (pageCodeMessage)
+    addIssue(issues, 'error', file, 1, pageCodeMessage)
+
+  const expectedPrefix = `${moduleCode}${submoduleCode}`
+  if (!pageCode.startsWith(expectedPrefix)) {
+    addIssue(
+      issues,
+      'error',
+      file,
+      1,
+      `Generated page file path must match the page code prefix: ${pageCode}.vue should live under src/views/${pageCode.slice(0, 2)}/${pageCode.slice(2, 4)}/.`,
+    )
+  }
+}
+
+function getTemplateContent(text) {
+  const match = /<template\b[^>]*>([\s\S]*?)<\/template>/i.exec(text)
+  if (!match) return null
+  return { content: match[1], offset: match.index + match[0].indexOf(match[1]) }
+}
+
+function countTopLevelRoots(template) {
+  let depth = 0
+  let roots = 0
+  let firstRootIndex = -1
+  const tagRegex = /<!--[\s\S]*?-->|<\/?([A-Za-z][\w.-]*)(?:\s[^>]*)?>/g
+
+  for (const match of template.matchAll(tagRegex)) {
+    const raw = match[0]
+    const tag = match[1]
+    if (!tag || raw.startsWith('<!--')) continue
+    if (/^<!/.test(raw)) continue
+    const isClosing = raw.startsWith('</')
+    const isSelfClosing = /\/>$/.test(raw)
+
+    if (isClosing) {
+      depth = Math.max(0, depth - 1)
+      continue
+    }
+
+    if (depth === 0) {
+      roots += 1
+      if (firstRootIndex === -1) firstRootIndex = match.index
+    }
+
+    if (!isSelfClosing) depth += 1
+  }
+
+  return { roots, firstRootIndex }
+}
+
+function inspectMockMarkers(file, text, issues, { isVue, isDataFile }) {
+  const hasAnyMockDataMarker = /@brms-mock-data\b/.test(text)
+  const hasExplicitInterfaceMarker = /@brms-explicit-interface\b/.test(text)
+  const mockDataMarker = /@brms-mock-data\b/
+  const mockHandlerMarker = /@brms-mock-handler\b/
+  const explicitInterfaceMarker = /@brms-explicit-interface\b/
+
+  if (isVue) {
+    for (const match of text.matchAll(/<VxePlusTable\b[\s\S]*?(?:\/>|<\/VxePlusTable>)/g)) {
+      const tag = match[0]
+      if (/(?::data|v-bind:data)\s*=/.test(tag) && !/serviceConfig|service-config/.test(tag) && !hasAnyMockDataMarker) {
+        addIssue(
+          issues,
+          'error',
+          file,
+          lineNumber(text, match.index),
+          'Mock-backed VxePlusTable :data requires a searchable @brms-mock-data marker near the local mock data source.',
+        )
+      }
+    }
+  }
+
+  const scriptMatch = isVue
+    ? /<script\b[^>]*>([\s\S]*?)<\/script>/i.exec(text)
+    : { 1: text, index: 0 }
+  if (!scriptMatch)
+    return
+
+  const script = scriptMatch[1]
+  const scriptOffset = scriptMatch.index + (isVue ? scriptMatch[0].indexOf(script) : 0)
+
+  const mockDataPatterns = [
+    /\b(?:export\s+)?(?:const|let|var)\s+\w*mock\w*\s*(?::[^=]+)?=/gi,
+    /\b(?:export\s+)?(?:const|let|var)\s+\w+\s*=\s*ref(?:<[^>]+>)?\(\s*\w*mock\w*/gi,
+  ]
+  if (isDataFile) {
+    mockDataPatterns.push(/\bexport\s+const\s+\w+\s*(?::[^=]+)?=\s*(?:\[|\{)/g)
+  }
+
+  const reportedMockDataLines = new Set()
+  for (const pattern of mockDataPatterns) {
+    for (const match of script.matchAll(pattern)) {
+      const absoluteIndex = scriptOffset + match.index
+      const line = lineNumber(text, absoluteIndex)
+      if (reportedMockDataLines.has(line))
+        continue
+      if (!hasMarkerNear(text, absoluteIndex, mockDataMarker)) {
+        reportedMockDataLines.add(line)
+        addIssue(
+          issues,
+          'error',
+          file,
+          line,
+          'Mock data declarations must have // @brms-mock-data <source-or-page>: <purpose> within the previous 3 lines.',
+        )
+      }
+    }
+  }
+
+  const mockHandlerEvidence = /TODO:\s*接入.*接口|ElMessage\.info\s*\(\s*['"]TODO:.*接口|\.value\s*=\s*[^;\n]*(?:\.filter\s*\(|\.map\s*\()|(?:\.push|\.splice)\s*\(|\b(?:upsertLocalRow|saveLocalForm|queryLocalDetail|matchesQuery)\s*\(/s
+  for (const block of findFunctionBlocks(script)) {
+    if (!mockHandlerEvidence.test(block.text))
+      continue
+    const absoluteIndex = scriptOffset + block.index
+    const hasMockHandlerMarker = hasMarkerNear(text, absoluteIndex, mockHandlerMarker)
+    const hasExplicitNear = hasMarkerNear(text, absoluteIndex, explicitInterfaceMarker)
+
+    if (!hasMockHandlerMarker && !hasExplicitNear) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        lineNumber(text, absoluteIndex),
+        'Mock data handlers must have // @brms-mock-handler <source-or-page>: <operation> within the previous 3 lines.',
+      )
+    }
+    if (hasMockHandlerMarker && (hasExplicitNear || hasExplicitInterfaceMarker && /\bEiCommunicator\b|\bserviceConfig\b|service-config/.test(block.text))) {
+      addIssue(
+        issues,
+        'warn',
+        file,
+        lineNumber(text, absoluteIndex),
+        '@brms-mock-handler appears near explicit interface code; remove stale mock markers after wiring the real interface.',
+      )
+    }
+  }
+}
+
+function inspectEditModel(file, text, issues) {
+  const tableRegex = /<VxePlusTable\b[\s\S]*?(?:\/>|<\/VxePlusTable>)/g
+  const tableMatches = [...text.matchAll(tableRegex)]
+  const editTableMatches = tableMatches.filter(match => /\b(?::is-edit|is-edit)\s*(?:=|\/?>|\s)/.test(match[0]))
+  const formModalMatches = [...text.matchAll(/<vxe-modal\b[\s\S]*?<VxePlusForm\b[\s\S]*?<\/vxe-modal>/g)]
+  const hasFormEditModal = formModalMatches.some(match => /@confirm\s*=|编辑|新增/.test(match[0]))
+
+  if (hasFormEditModal) {
+    for (const match of editTableMatches) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        lineNumber(text, match.index),
+        'Choose one edit model: dialog edit pages must not set VxePlusTable :is-edit="true"; row edit uses :is-edit and column editRender without an edit modal.',
+      )
+    }
+  }
+
+  const columnBlockRegex = /createColumns\s*\(([\s\S]*?)\n\s*\]\s*(?:,\s*\{[\s\S]*?\})?\s*\)\s*;?/g
+  if (hasFormEditModal) {
+    for (const match of text.matchAll(columnBlockRegex)) {
+      const block = match[1]
+      if (/\beditRender\s*:/.test(block)) {
+        addIssue(
+          issues,
+          'error',
+          file,
+          lineNumber(text, match.index),
+          'Dialog edit pages must not put editRender on normal table columns; editRender belongs to the VxePlusTable row edit pattern.',
+        )
+      }
+    }
+  }
+
+  for (const match of text.matchAll(/@cell-click\s*=/g)) {
+    addIssue(
+      issues,
+      'warn',
+      file,
+      lineNumber(text, match.index),
+      'Avoid @cell-click in generated tables; use tableLink for business-field navigation and toolbarButtons for add/edit/delete.',
+    )
+  }
+
+  const scriptMatch = /<script\b[^>]*>([\s\S]*?)<\/script>/i.exec(text)
+  if (!scriptMatch)
+    return
+
+  const script = scriptMatch[1]
+  const scriptOffset = scriptMatch.index + scriptMatch[0].indexOf(script)
+  const cellClickFunctionPatterns = [
+    /(?:^|\n)\s*(?:async\s+)?function\s+handleCellClick\s*\([^)]*\)\s*\{/g,
+    /(?:^|\n)\s*(?:const|let)\s+handleCellClick\s*=\s*(?:async\s*)?(?:\([^)]*\)|\w+)\s*=>\s*\{/g,
+    /(?:^|\n)\s*(?:cellClick|onCellClick)\s*:\s*(?:async\s*)?(?:\([^)]*\)|\w+)\s*=>\s*\{/g,
+  ]
+
+  for (const pattern of cellClickFunctionPatterns) {
+    for (const match of script.matchAll(pattern)) {
+      const openBraceIndex = script.indexOf('{', match.index)
+      if (openBraceIndex === -1) continue
+      const closeBraceIndex = findClosingBrace(script, openBraceIndex)
+      if (closeBraceIndex === -1) continue
+      const block = script.slice(match.index, closeBraceIndex + 1)
+      const line = lineNumber(text, scriptOffset + match.index)
+      if (/\bhandleEdit\s*\(|\beditingId\b|\bmodal\.value\s*=\s*true/.test(block)) {
+        addIssue(
+          issues,
+          'error',
+          file,
+          line,
+          'Do not use cell-click/handleCellClick to open an edit modal; use toolbarButtonClick, selected row handling, or tableLink.',
+        )
+      } else {
+        addIssue(
+          issues,
+          'warn',
+          file,
+          line,
+          'Only keep cell-click when the product doc explicitly requires row-level navigation; otherwise use tableLink or toolbarButtons.',
+        )
+      }
+    }
+  }
+}
+
+function inspectVue(file, text, issues, repoRoot) {
+  validateViewPath(file, repoRoot, issues)
+
+  const hasExplicitInterfaceMarker = /@brms-explicit-interface\b/.test(text)
+  const hasValidExplicitInterfaceMarker = /@brms-explicit-interface\s+[^\n:]+:\s*[A-Za-z]\w*\.[A-Za-z]\w*/.test(text)
+
+  const templateInfo = getTemplateContent(text)
+  if (templateInfo) {
+    const { roots, firstRootIndex } = countTopLevelRoots(templateInfo.content)
+    if (roots !== 1) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        lineNumber(text, templateInfo.offset + Math.max(firstRootIndex, 0)),
+        `Generated Vue templates must have exactly one top-level root; found ${roots}. Put dialogs inside the main root wrapper.`,
+      )
+    }
+  }
+
+  const unknownComponents = [
+    'VxePlusDialog',
+    'FileUploadDialog',
+    'UploadDialog',
+    'BxUploadDialog',
+    'AttachmentDialog',
+  ]
+  for (const component of unknownComponents) {
+    const pattern = new RegExp(`<${component}\\b|</${component}>|\\b${component}\\b`)
+    const match = pattern.exec(text)
+    if (match) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        lineNumber(text, match.index),
+        `Do not use unknown generated component ${component}; follow references/05-dialog-patterns.md.`,
+      )
+    }
+  }
+
+  for (const match of text.matchAll(/\btitlePrefix\s*:/g)) {
+    addIssue(
+      issues,
+      'error',
+      file,
+      lineNumber(text, match.index),
+      'Do not use titlePrefix as required validation; put required validators in formOption.rules keyed by field.',
+    )
+  }
+
+  for (const match of text.matchAll(/\bitems\s*:\s*\[/g)) {
+    const openIndex = text.indexOf('[', match.index)
+    const closeIndex = findClosingPair(text, openIndex, '[', ']')
+    if (openIndex === -1 || closeIndex === -1)
+      continue
+    const itemsBlock = text.slice(openIndex, closeIndex + 1)
+    for (const requiredMatch of itemsBlock.matchAll(/\brequired\s*:\s*true\b/g)) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        lineNumber(text, openIndex + requiredMatch.index),
+        'Do not put required: true inside formOption.items; required validation must live in formOption.rules.',
+      )
+    }
+  }
+
+  for (const match of text.matchAll(/<el-upload\b/g)) {
+    addIssue(
+      issues,
+      'warn',
+      file,
+      lineNumber(text, match.index),
+      'Avoid hand-written el-upload in generated prototypes; attachment actions must call useFileUpload().openFileBFSS0001.',
+    )
+  }
+
+  const containerRegex = /<BxContainer\b[\s\S]*?<\/BxContainer>|<bx-container\b[\s\S]*?<\/bx-container>/g
+  for (const match of text.matchAll(containerRegex)) {
+    const block = match[0]
+    if (/<template\s+#(?:left|right|default|custom-btn)\b[\s\S]*?<(?:el-button|vxe-button)\b/i.test(block)) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        lineNumber(text, match.index),
+        'Do not put generated action buttons in BxContainer slots unless explicitly requested; use table toolbarButtons or query card buttons.',
+      )
+    }
+  }
+
+  for (const match of text.matchAll(/<BxContainer\b[^>]*custom-btn-list\s*=\s*["'][\s\S]*?["'][^>]*>/g)) {
+    const tag = match[0]
+    if (/新增|编辑|删除|add|edit|del|delete|ADD|EDIT|DEL|DELETE/.test(tag)) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        lineNumber(text, match.index),
+        'Do not put generated add/edit/delete actions in BxContainer custom-btn-list; use VxePlusTable toolbarButtons to avoid duplicate header/table buttons.',
+      )
+    }
+  }
+
+  const modalRegex = /<vxe-modal\b[\s\S]*?<\/vxe-modal>/g
+  for (const match of text.matchAll(modalRegex)) {
+    const block = match[0]
+    const line = lineNumber(text, match.index)
+    const openTag = /<vxe-modal\b[^>]*>/i.exec(block)?.[0] || ''
+    if (/附件|上传|upload|attachment/i.test(block)) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        line,
+        'Do not write custom attachment modals; attachment actions must call useFileUpload().openFileBFSS0001.',
+      )
+    }
+    if (/<VxePlusForm\b[^>]*:form-config\s*=/.test(block)) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        line,
+        'Dialog VxePlusForm must use :form-options, not :form-config.',
+      )
+    }
+    const formCount = (block.match(/<VxePlusForm\b/g) || []).length
+    const containerCount = (block.match(/<(?:BxContainer|bx-container)\b/g) || []).length
+    if (formCount === 1 && containerCount > 0) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        line,
+        'Do not wrap a simple one-section dialog form with BxContainer; the vxe-modal title is enough.',
+      )
+    }
+    if (/\bshow-footer\b/.test(openTag)) {
+      const requiredButtonProps = [
+        'show-cancel-button',
+        'show-confirm-button',
+        'cancel-button-text',
+        'confirm-button-text',
+      ]
+      const missingProps = requiredButtonProps.filter(prop => !new RegExp(`\\b${prop}\\b`).test(openTag))
+      if (missingProps.length) {
+        addIssue(
+          issues,
+          'error',
+          file,
+          line,
+          `vxe-modal with show-footer must explicitly set ${missingProps.join(', ')} so generated dialogs render cancel/confirm buttons.`,
+        )
+      }
+      if (/<template\s+#footer\b/i.test(block)) {
+        addIssue(
+          issues,
+          'warn',
+          file,
+          line,
+          'Prefer built-in vxe-modal confirm/cancel button props with @confirm over custom footer slots in generated form dialogs.',
+        )
+      }
+    }
+  }
+
+  if (/附件|上传|attachment|upload/i.test(text)) {
+    const importsUseFileUpload = /useFileUpload/.test(text)
+    const callsOpenFileBFSS0001 = /openFileBFSS0001\s*\(/.test(text)
+    const customAttachmentModal = /<vxe-modal\b[\s\S]*?(附件|上传|upload|attachment)[\s\S]*?<\/vxe-modal>/i.test(text)
+      || /<el-dialog\b[\s\S]*?(附件|上传|upload|attachment)[\s\S]*?<\/el-dialog>/i.test(text)
+      || /<el-upload\b/i.test(text)
+    if (customAttachmentModal && (!importsUseFileUpload || !callsOpenFileBFSS0001)) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        1,
+        'Attachment upload/view must use useFileUpload().openFileBFSS0001 instead of a custom modal/upload component.',
+      )
+    }
+  }
+
+  const scriptMatch = /<script\b[^>]*>([\s\S]*?)<\/script>/i.exec(text)
+  if (scriptMatch && /<script\b[^>]*\blang=["']ts["'][^>]*>/i.test(scriptMatch[0])) {
+    const script = scriptMatch[1]
+    const jsxMatch = /\breturn\s*<\s*[A-Za-z][\w-]*/.exec(script)
+      || /=>\s*<\s*[A-Za-z][\w-]*/.exec(script)
+    if (jsxMatch) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        lineNumber(text, scriptMatch.index + jsxMatch.index),
+        'Do not write JSX/TSX in generated .vue files; use Vue template slots instead.',
+      )
+    }
+  }
+
+  const tableRegex = /<VxePlusTable\b[\s\S]*?(?:\/>|<\/VxePlusTable>)/g
+  for (const match of text.matchAll(tableRegex)) {
+    const tag = match[0]
+    const line = lineNumber(text, match.index)
+    const hasColumns = /:columns\s*=/.test(tag)
+    const hasData = /(?::data|v-bind:data)\s*=/.test(tag)
+    const hasBackendConfig = /serviceConfig|service-config/.test(tag)
+
+    if (hasColumns && !hasData && !hasBackendConfig) {
+      addIssue(issues, 'error', file, line, 'VxePlusTable with columns must bind mock data using :data="...".')
+    }
+    if (hasBackendConfig && !hasExplicitInterfaceMarker) {
+      addIssue(issues, 'error', file, line, 'serviceConfig/service-config is allowed only when the source document explicitly names the interface; add @brms-explicit-interface with the source and service.method.')
+    }
+  }
+
+  const columnBlockRegex = /createColumns\s*\(([\s\S]*?)\n\s*\]\s*(?:,\s*\{[\s\S]*?\})?\s*\)\s*;?/g
+  for (const match of text.matchAll(columnBlockRegex)) {
+    const block = match[1]
+    const line = lineNumber(text, match.index)
+    if (/(field\s*:\s*['"](?:action|actions|operation|operate)['"])|(title\s*:\s*['"]操作['"])/i.test(block)) {
+      addIssue(issues, 'error', file, line, 'Do not generate action/operation table columns.')
+    }
+    if (/type\s*:\s*['"]checkbox['"]/.test(block)) {
+      addIssue(issues, 'error', file, line, 'Do not generate checkbox columns inside createColumns; use :show-checkbox="true".')
+    }
+    if (!/\{\s*width\s*:\s*undefined\s*\}/.test(match[0]) && /field\s*:/.test(block)) {
+      addIssue(issues, 'warn', file, line, 'Prefer createColumns([...], { width: undefined }) for generated data columns.')
+    }
+  }
+
+  const alwaysForbiddenBackend = [
+    /from\s+['"]@\/api['"]/,
+    /\bhttp\.(send|get|post|form)\s*\(/,
+  ]
+  for (const pattern of alwaysForbiddenBackend) {
+    const match = pattern.exec(text)
+    if (match) {
+      addIssue(issues, 'error', file, lineNumber(text, match.index), 'Generated prototypes must not use REST/http APIs; BRMS explicit interfaces should use EiInfo/EiCommunicator.')
+    }
+  }
+
+  const explicitBackend = [
+    /\bEiCommunicator\b/,
+    /from\s+['"]@eplat\/ei['"]/,
+    /\bserviceConfig\b/,
+    /service-config/,
+  ]
+  for (const pattern of explicitBackend) {
+    const match = pattern.exec(text)
+    if (match && !hasExplicitInterfaceMarker) {
+      addIssue(issues, 'error', file, lineNumber(text, match.index), 'EiInfo/serviceConfig backend wiring requires an @brms-explicit-interface marker proving the product document named the service and method.')
+    }
+  }
+
+  if (hasExplicitInterfaceMarker) {
+    if (/\bEiCommunicator\.send\s*\(/.test(text) && !/new\s+EiInfo\s*\(/.test(text)) {
+      addIssue(issues, 'warn', file, 1, 'Explicit EiCommunicator.send usage should normally build an EiInfo request object.')
+    }
+    if (/\bserviceConfig\b/.test(text) && !/serviceName\s*:\s*['"][^'"]+['"]/.test(text)) {
+      addIssue(issues, 'error', file, 1, 'Explicit serviceConfig must include a concrete serviceName.')
+    }
+    if (!hasValidExplicitInterfaceMarker) {
+      addIssue(issues, 'error', file, 1, '@brms-explicit-interface marker must include the source document/section and service.method, for example: @brms-explicit-interface product-doc: BMBF56.query.')
+    }
+  }
+
+  for (const match of text.matchAll(/<BxContainer\b[^>]*custom-btn-auto[^>]*>/g)) {
+    const tag = match[0]
+    if (/结果|列表|项目列表|数据列表|Result|List/i.test(tag)) {
+      addIssue(issues, 'error', file, lineNumber(text, match.index), 'Do not put custom-btn-auto on result/table headers.')
+    }
+  }
+
+  for (const match of text.matchAll(/path\s*:\s*['"]\/web\/(?:[A-Z0-9]+\/)+[A-Z0-9]+['"]/g)) {
+    addIssue(
+      issues,
+      'error',
+      file,
+      lineNumber(text, match.index),
+      'Runtime navigation must use /web/<PAGE_CODE>, for example /web/DMDA01, not /web/DM/DA/DMDA01.',
+    )
+  }
+
+  for (const match of text.matchAll(/['"]\/web\/(?:[A-Z0-9]+\/)+[A-Z0-9]+['"]/g)) {
+    addIssue(
+      issues,
+      'error',
+      file,
+      lineNumber(text, match.index),
+      'Runtime navigation/link strings must use /web/<PAGE_CODE>, for example /web/DMDA01, not /web/DM/DA/DMDA01.',
+    )
+  }
+
+  for (const match of text.matchAll(/path\s*:\s*['"]\/web\/([A-Z0-9]+)['"]/g)) {
+    const code = match[1]
+    const pageCodeMessage = validatePageCode(code)
+    if (pageCodeMessage)
+      addIssue(issues, 'error', file, lineNumber(text, match.index), pageCodeMessage)
+  }
+
+  inspectEditModel(file, text, issues)
+}
+
+function inspectRoute(file, text, issues) {
+  if (/[\\/]localMenu\.ts$/.test(file)) {
+    addIssue(issues, 'error', file, 1, 'Do not edit localMenu.ts for generated prototypes; create a fresh route config file.')
+  }
+
+  if (!/export\s+default\s+\[/.test(text)) {
+    addIssue(issues, 'warn', file, 1, 'Generated route config should default-export an array.')
+  }
+
+  const topLevelRoutes = extractDefaultRouteObjects(text)
+  const parentRoutes = topLevelRoutes.filter(route => route.hasChildren)
+  const topLevelPageRoutes = topLevelRoutes.filter(route => route.component && !route.hasChildren)
+  if (parentRoutes.length === 1 && topLevelPageRoutes.length) {
+    const parent = parentRoutes[0]
+    const childCodes = [...parent.text.matchAll(/\b(?:name|path)\s*:\s*['"]\/?([A-Z0-9]{6,})['"]/g)]
+      .map(match => match[1])
+      .filter(code => !/Menu$/.test(code))
+    const childPrefixes = new Set(childCodes.map(code => code.slice(0, 4)))
+
+    for (const route of topLevelPageRoutes) {
+      const code = pageCodeFromComponent(route.component) || route.name || route.path.replace(/^\//, '')
+      if (!validatePageCode(code) && childPrefixes.has(code.slice(0, 4))) {
+        addIssue(
+          issues,
+          'error',
+          file,
+          lineNumber(text, route.index),
+          `${code} belongs inside the same parent menu children as ${[...childPrefixes][0]} pages${route.isHide ? ' with meta.isHide: true' : ''}; do not put generated detail/jump-only pages as top-level route siblings.`,
+        )
+      }
+    }
+  }
+
+  for (const match of text.matchAll(/path\s*:\s*['"]\/(?:[A-Z0-9]+\/)+([A-Z][A-Z0-9]*)['"]/g)) {
+    addIssue(
+      issues,
+      'error',
+      file,
+      lineNumber(text, match.index),
+      'Generated dynamic route path must be /<PAGE_CODE> because auth.ts prefixes it with /web; keep physical folders only in component.',
+    )
+  }
+
+  for (const match of text.matchAll(/\b(?:path|name)\s*:\s*['"]\/?([A-Z0-9]+)['"]/g)) {
+    const code = match[1]
+    if (/Menu$/.test(code))
+      continue
+    const pageCodeMessage = validatePageCode(code)
+    if (pageCodeMessage)
+      addIssue(issues, 'error', file, lineNumber(text, match.index), pageCodeMessage)
+  }
+
+  for (const match of text.matchAll(/\bcomponent\s*:\s*['"]([^'"]+)['"]/g)) {
+    const component = match[1]
+    const code = pageCodeFromComponent(component)
+    const pageCodeMessage = validatePageCode(code)
+    if (pageCodeMessage) {
+      addIssue(issues, 'error', file, lineNumber(text, match.index), pageCodeMessage)
+      continue
+    }
+
+    const expectedComponent = `/${code.slice(0, 2)}/${code.slice(2, 4)}/${code}`
+    if (component !== expectedComponent) {
+      addIssue(
+        issues,
+        'error',
+        file,
+        lineNumber(text, match.index),
+        `Generated route component must match page code folders: ${code} should use component '${expectedComponent}'.`,
+      )
+    }
+  }
+}
+
+const { repoRoot, paths } = parseArgs(args)
+const files = paths
+  .map((target) => path.resolve(repoRoot, target))
+  .flatMap(walk)
+  .filter((file) => /\.(vue|ts)$/.test(file))
+
+const issues = []
+
+for (const file of files) {
+  const text = fs.readFileSync(file, 'utf8')
+  if (file.endsWith('.vue')) {
+    inspectMockMarkers(file, text, issues, { isVue: true, isDataFile: false })
+    inspectVue(file, text, issues, repoRoot)
+  }
+  if (path.basename(file) === 'data.ts') {
+    inspectMockMarkers(file, text, issues, { isVue: false, isDataFile: true })
+  }
+  if (file.includes(`${path.sep}routers${path.sep}config${path.sep}`) && file.endsWith('.ts')) {
+    inspectRoute(file, text, issues)
+  }
+}
+
+const rel = (file) => path.relative(repoRoot, file).replaceAll(path.sep, '/')
+const errors = issues.filter((issue) => issue.severity === 'error')
+const warnings = issues.filter((issue) => issue.severity === 'warn')
+
+if (!issues.length) {
+  console.log('Generated prototype static validation passed.')
+  process.exit(0)
+}
+
+for (const issue of issues) {
+  console.log(`${issue.severity.toUpperCase()} ${rel(issue.file)}:${issue.line} ${issue.message}`)
+}
+
+console.log('')
+console.log(`Static validation found ${errors.length} error(s) and ${warnings.length} warning(s).`)
+process.exit(errors.length ? 1 : 0)