@epxing/cli 0.5.0-beta.0 → 0.5.0-beta.10

package/dist/skills/epxing-frontend-vue3-migrate/scripts/fix-eval-paths.cjs

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+// 将参数占位符中的动态属性读取迁移为公开路径读取；业务表达式只报告。
+const fs = require('node:fs')
+const path = require('node:path')
+const { createRequire } = require('node:module')
+
+function dependencies (project) {
+  const requireProject = createRequire(path.join(project, 'package.json'))
+  try {
+    return {
+      parser: requireProject('@babel/parser'),
+      traverse: requireProject('@babel/traverse').default,
+      sfc: requireProject('@vue/compiler-sfc')
+    }
+  } catch (error) {
+    throw new Error('需要目标工程已安装的 @babel/parser、@babel/traverse 和 @vue/compiler-sfc；未自动安装依赖。' + error.message)
+  }
+}
+
+function nameOf (node) {
+  return node?.name || node?.value
+}
+
+function componentObject (nodePath) {
+  if (!nodePath?.isObjectExpression()) return false
+  const parent = nodePath.parentPath
+  return parent?.isExportDefaultDeclaration() ||
+    (parent?.isCallExpression() && nameOf(parent.node.callee) === 'defineComponent' &&
+      parent.node.arguments[0] === nodePath.node)
+}
+
+function thisOwner (nodePath) {
+  let fn = nodePath.getFunctionParent()
+  while (fn?.isArrowFunctionExpression()) fn = fn.getFunctionParent()
+  if (!fn || (!fn.isObjectMethod() && !fn.isFunctionExpression())) return null
+  let member = fn.isObjectMethod() ? fn : fn.parentPath
+  if (!member?.isObjectMethod() && !member?.isObjectProperty()) return null
+  // 普通嵌套函数会改变 this，不能仅因位于组件文件中就自动处理。
+  let object = member.parentPath
+  for (let level = 0; level < 4 && object?.isObjectExpression(); level++) {
+    if (componentObject(object)) {
+      return ['methods', 'computed', 'watch', 'created', 'mounted', 'render',
+        'beforeCreate', 'beforeMount', 'updated', 'beforeUpdate',
+        'unmounted', 'beforeUnmount', 'data', 'setup'].includes(nameOf(member.node.key))
+        ? (nameOf(member.node.key) === 'setup' ? null : fn)
+        : null
+    }
+    member = object.parentPath
+    if (!member?.isObjectProperty()) return null
+    object = member.parentPath
+  }
+  return null
+}
+
+function placeholderRegex (node) {
+  return node?.type === 'RegExpLiteral' &&
+    /(?:\\\$\\\[|#\\\[|#\\\{)/.test(node.pattern)
+}
+
+function replaceCall (node) {
+  return node?.type === 'CallExpression' && node.callee.type === 'MemberExpression' &&
+    !node.callee.computed && node.callee.property.name === 'replace' &&
+    placeholderRegex(node.arguments[0])
+}
+
+function placeholderKey (argPath) {
+  if (!argPath.isIdentifier()) return false
+  const binding = argPath.scope.getBinding(argPath.node.name)
+  if (!binding || !binding.constant) return false
+  const fn = binding.scope.path
+  if (binding.kind === 'param' && fn.isFunction() &&
+      fn.node.params[1]?.type === 'Identifier' && fn.node.params[1].name === argPath.node.name &&
+      replaceCall(fn.parentPath.node) && fn.parentPath.node.arguments[1] === fn.node) return true
+  if (!binding.path.isVariableDeclarator() || !replaceCall(binding.path.node.init)) return false
+  const callback = binding.path.node.init.arguments[1]
+  if (callback?.type === 'StringLiteral') return callback.value === '$1'
+  if (!callback || !['ArrowFunctionExpression', 'FunctionExpression'].includes(callback.type)) return false
+  const capture = callback.params[1]
+  if (capture?.type !== 'Identifier') return false
+  const body = callback.body.type === 'BlockStatement'
+    ? (callback.body.body.length === 1 && callback.body.body[0].type === 'ReturnStatement'
+        ? callback.body.body[0].argument : null)
+    : callback.body
+  return body?.type === 'Identifier' && body.name === capture.name
+}
+
+function contextFor (callPath, root) {
+  if (root === 'this') return thisOwner(callPath) ? { root } : null
+  const binding = callPath.scope.getBinding(root)
+  if (binding) {
+    if (!binding.constant || !binding.path.isVariableDeclarator() ||
+        binding.path.node.init?.type !== 'ThisExpression' || !thisOwner(binding.path)) return null
+    return { root }
+  }
+  // 只在已证实属于组件的词法 this 中修复旧代码缺少的常见别名。
+  return ['that', '_this'].includes(root) && thisOwner(callPath) ? { root: 'this' } : null
+}
+
+function analyzeCode (code, { filename, lang = '', offset = 0, source = code }, deps) {
+  const plugins = []
+  if (/tsx?$/.test(lang) || /\.[cm]?tsx?$/.test(filename)) plugins.push('typescript')
+  if (lang !== 'ts' && !/\.[cm]?ts$/.test(filename)) plugins.push('jsx')
+  const ast = deps.parser.parse(code, { sourceType: 'unambiguous', plugins })
+  const edits = []
+  const findings = []
+  deps.traverse(ast, {
+    CallExpression (callPath) {
+      const node = callPath.node
+      if (node.callee.type !== 'Identifier' || node.callee.name !== 'eval') return
+      // 同名业务函数不是全局 eval。
+      if (callPath.scope.getBinding('eval')) return
+      const finding = {
+        file: filename,
+        line: source.slice(0, offset + node.start).split('\n').length,
+        kind: 'review',
+        reason: '表达式、配置解析或未知路径来源，保留原代码并人工核对上下文。',
+        before: code.slice(node.start, node.end)
+      }
+      const value = node.arguments[0]
+      if (node.arguments.length === 1 && value?.type === 'TemplateLiteral' &&
+          value.expressions.length === 1 && value.quasis[1].value.cooked === '') {
+        const prefix = value.quasis[0].value.cooked
+        const match = /^(this|[A-Za-z_$][\w$]*)(\.[A-Za-z_$][\w$]*)*\.$/.exec(prefix)
+        const exprPath = callPath.get('arguments.0.expressions.0')
+        if (match && placeholderKey(exprPath)) {
+          const context = contextFor(callPath, match[1])
+          if (context) {
+            const object = context.root + prefix.slice(match[1].length, -1)
+            const key = code.slice(value.expressions[0].start, value.expressions[0].end)
+            const after = context.root + '.$_.get(' + object + ', ' + key + ')'
+            edits.push({ start: offset + node.start, end: offset + node.end, text: after })
+            Object.assign(finding, { kind: 'automatic', after, reason: '参数占位符路径读取，上下文已确认。' })
+          } else {
+            finding.reason = '参数占位符命中，但别名或 this 上下文无法确认。'
+          }
+        }
+      }
+      findings.push(finding)
+    }
+  })
+  return { edits, findings }
+}
+
+function analyzeFile (filename, source, deps) {
+  if (!filename.endsWith('.vue')) return analyzeCode(source, { filename }, deps)
+  const parsed = deps.sfc.parse(source, { filename })
+  if (parsed.errors.length) throw new Error(parsed.errors.map(e => e.message || e).join('; '))
+  const result = { edits: [], findings: [] }
+  for (const block of [parsed.descriptor.script, parsed.descriptor.scriptSetup]) {
+    if (!block) continue
+    if (block.src) {
+      result.findings.push({ file: filename, line: block.loc.start.line, kind: 'review', reason: '外部 script src 需核对是否在本次 src 扫描范围内。' })
+      continue
+    }
+    const part = analyzeCode(block.content, {
+      filename, lang: block.lang || '', offset: block.loc.start.offset, source
+    }, deps)
+    result.edits.push(...part.edits)
+    result.findings.push(...part.findings)
+  }
+  const template = parsed.descriptor.template
+  for (const match of (template?.content || '').matchAll(/\beval\s*\(/g)) {
+    result.findings.push({ file: filename, line: template.loc.start.line + template.content.slice(0, match.index).split('\n').length - 1, kind: 'review', reason: '模板内 eval 需人工核对模板上下文。' })
+  }
+  return result
+}
+
+function sourceFiles (directory) {
+  const result = []
+  for (const entry of fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (entry.isSymbolicLink()) continue
+    const file = path.join(directory, entry.name)
+    if (entry.isDirectory() && !['node_modules', '.git', '.cache', 'dist', 'lib'].includes(entry.name)) result.push(...sourceFiles(file))
+    else if (entry.isFile() && /\.(vue|[cm]?js|jsx|[cm]?ts|tsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) result.push(file)
+  }
+  return result
+}
+
+function migrate ({ project, apply = false, reportFile }, deps = dependencies(project)) {
+  project = path.resolve(project)
+  const src = path.join(project, 'src')
+  if (!fs.existsSync(src)) throw new Error('目标必须是包含 src 的前端工程：' + project)
+  const files = sourceFiles(src)
+  const pending = []
+  const findings = []
+  const errors = []
+  for (const file of files) {
+    const source = fs.readFileSync(file, 'utf8')
+    try {
+      const result = analyzeFile(file, source, deps)
+      findings.push(...result.findings)
+      if (result.edits.length) {
+        let changed = source
+        for (const edit of result.edits.sort((a, b) => b.start - a.start)) changed = changed.slice(0, edit.start) + edit.text + changed.slice(edit.end)
+        pending.push({ file, source, changed })
+      }
+    } catch (error) {
+      errors.push({ file, message: error.message })
+    }
+  }
+  const report = {
+    version: 1, project, mode: apply ? 'apply' : 'preview', filesScanned: files.length,
+    automatic: findings.filter(f => f.kind === 'automatic').length,
+    review: findings.filter(f => f.kind === 'review').length,
+    filesChanged: [], findings, errors
+  }
+  // 先完成全部解析；任一文件失败时不修改源码。
+  if (apply && !errors.length && pending.length) {
+    const backupRoot = path.join(project, '.cache', 'eval-path-backups')
+    fs.mkdirSync(backupRoot, { recursive: true })
+    const backup = fs.mkdtempSync(path.join(backupRoot, 'run-'))
+    for (const entry of pending) {
+      const target = path.join(backup, path.relative(project, entry.file))
+      fs.mkdirSync(path.dirname(target), { recursive: true })
+      fs.writeFileSync(target, entry.source)
+    }
+    // 防止扫描到写入之间覆盖其它人的新改动。
+    for (const entry of pending) if (fs.readFileSync(entry.file, 'utf8') !== entry.source) throw new Error('扫描后文件已变化，未写入源码：' + entry.file)
+    for (const entry of pending) fs.writeFileSync(entry.file, entry.changed)
+    report.backup = backup
+    report.filesChanged = pending.map(entry => entry.file)
+  }
+  report.exitCode = errors.length ? 1 : ((report.review || (!apply && report.automatic)) ? 2 : 0)
+  if (reportFile) {
+    fs.mkdirSync(path.dirname(path.resolve(reportFile)), { recursive: true })
+    fs.writeFileSync(reportFile, JSON.stringify(report, null, 2) + '\n')
+  }
+  return report
+}
+
+if (require.main === module) {
+  try {
+    const args = process.argv.slice(2)
+    if (args.includes('--help')) {
+      console.log('用法：node fix-eval-paths.cjs <前端工程> [--apply] [--report <JSON文件>]\n默认只读预览；--apply 先备份后改写。退出码：0 已处理，2 有待修复/待复核项，1 解析或依赖失败。')
+    } else {
+      const options = { project: null, apply: false }
+      for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--apply') options.apply = true
+        else if (args[i] === '--report' && args[i + 1] && !args[i + 1].startsWith('--')) options.reportFile = args[++i]
+        else if (!args[i].startsWith('--') && !options.project) options.project = path.resolve(args[i])
+        else throw new Error('未知或不完整参数：' + args[i])
+      }
+      if (!options.project) throw new Error('请指定前端工程；使用 --help 查看用法。')
+      const report = migrate(options)
+      console.log(JSON.stringify(report, null, 2))
+      process.exitCode = report.exitCode
+    }
+  } catch (error) {
+    console.error(error.message)
+    process.exitCode = 1
+  }
+}
+
+module.exports = { dependencies, analyzeCode, analyzeFile, migrate }