@weotro/dx 0.1.0

package/lib/cli/command-result.js

@@ -0,0 +1 @@
+export const COMMAND_NOT_HANDLED = Symbol('COMMAND_NOT_HANDLED')

package/lib/cli/commands/contracts.js

@@ -0,0 +1,60 @@
+import { existsSync, mkdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { logger } from '../../logger.js'
+import { execManager } from '../../exec.js'
+
+export async function handleContracts(cli, args = []) {
+  const action = args[0] || 'generate'
+  if (!['generate', 'pull'].includes(action)) {
+    logger.error(`不支持的 contracts 子命令: ${action}`)
+    logger.info(`用法: ${cli.invocation} contracts [generate|pull]`)
+    process.exitCode = 1
+    return
+  }
+
+  cli.ensureRepoRoot()
+
+  // starmomo/ai-monorepo compatibility: packages/api-contracts is expected
+  const contractsRoot = join(process.cwd(), 'packages', 'api-contracts')
+  if (!existsSync(contractsRoot)) {
+    logger.error(`未找到 contracts 目录: ${contractsRoot}`)
+    logger.info('期望存在 packages/api-contracts，用于输出生成的 Zod 合约。')
+    process.exitCode = 1
+    return
+  }
+
+  logger.step('导出 OpenAPI 并生成 Zod 合约')
+
+  // 1) Export OpenAPI spec to dist/openapi/backend.json
+  await execManager.executeCommand('npx nx run backend:swagger', {
+    app: 'backend',
+    flags: cli.flags,
+    env: { NX_CACHE: 'false', SKIP_PRISMA_CONNECT: 'true' },
+  })
+
+  // 2) Generate zod client
+  const outputDir = join(contractsRoot, 'src', 'generated')
+  mkdirSync(outputDir, { recursive: true })
+
+  const baseUrl = process.env.OPENAPI_BASE_URL || 'http://localhost:3000/api/v1'
+  logger.info(`使用 API 基地址: ${baseUrl}`)
+
+  const generatorCommand = [
+    'pnpm exec openapi-zod-client',
+    'dist/openapi/backend.json',
+    '--output packages/api-contracts/src/generated/backend.ts',
+    '--api-client-name aiBackendClient',
+    `--base-url "${baseUrl}"`,
+    '--with-alias',
+    '--with-docs',
+    '--with-deprecated',
+    '--export-schemas',
+    '--prettier prettier.config.js',
+  ].join(' ')
+
+  await execManager.executeCommand(generatorCommand, {
+    flags: cli.flags,
+  })
+
+  logger.success('Zod 合约已更新（packages/api-contracts）')
+}

package/lib/cli/commands/core.js

@@ -0,0 +1,533 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+import { logger } from '../../logger.js'
+import { confirmManager } from '../../confirm.js'
+import { execManager } from '../../exec.js'
+import { showHelp, showCommandHelp } from '../help.js'
+
+const DEFAULT_TEST_WORKERS = 8
+
+export function handleHelp(cli, args = []) {
+  if (args[0]) showCommandHelp(args[0], cli)
+  else showHelp(cli)
+}
+
+export async function handleBuild(cli, args) {
+  const target = args[0] || 'all'
+  const environment = cli.determineEnvironment()
+  const envKey = cli.normalizeEnvKey(environment)
+  const explicitEnv =
+    Boolean(cli.flags.dev || cli.flags.prod || cli.flags.staging || cli.flags.test || cli.flags.e2e)
+
+  const buildConfig = cli.commands.build[target]
+  if (!buildConfig) {
+    logger.error(`未找到构建目标: ${target}`)
+    process.exitCode = 1
+    return
+  }
+
+  logger.step(`构建 ${target} (${environment})`)
+
+  // 处理嵌套配置
+  let config = buildConfig
+  if (typeof config === 'object' && !config.command) {
+    const supportsCurrentEnv = Boolean(config[envKey])
+    if (explicitEnv && !supportsCurrentEnv) {
+      const envFlag = cli.getEnvironmentFlagExample(envKey) || `--${envKey}`
+      logger.error(`构建目标 ${target} 不支持 ${envFlag} 环境`)
+      logger.info('显式传入环境标志时，必须是该 target 实际支持的环境。')
+      const available = ['development', 'staging', 'production', 'test', 'e2e']
+        .filter(key => key in config)
+        .map(key => cli.getEnvironmentFlagExample(key) || `--${key}`)
+      if (available.length > 0) {
+        logger.info(`支持的环境: ${available.join(', ')}`)
+        logger.info(`示例: ${cli.invocation} build ${target} ${available[0]}`)
+        if (available.length > 1) {
+          logger.info(`示例: ${cli.invocation} build ${target} ${available[1]}`)
+        }
+      }
+      process.exitCode = 1
+      return
+    }
+
+    // 严格按显式环境选择配置，不做环境回退
+    if (config[envKey]) config = config[envKey]
+    else config = null
+  }
+
+  if (!config) {
+    logger.error(`构建目标 ${target} 未提供 ${cli.getEnvironmentFlagExample(envKey) || envKey} 环境配置`)
+    process.exitCode = 1
+    return
+  }
+
+  if (config.concurrent) {
+    await cli.handleConcurrentCommands(config.commands, 'build', envKey)
+  } else if (config.sequential) {
+    await cli.handleSequentialCommands(config.commands, envKey)
+  } else {
+    await cli.executeCommand(config)
+  }
+}
+
+export async function handleTest(cli, args) {
+  const type = args[0] || 'e2e'
+  const target = args[1] || 'all'
+  const testPaths = args.slice(2) // unit 可选多个测试文件路径；e2e 只使用第一个
+  const testPath = testPaths[0]
+
+  // 解析 -t 参数用于指定特定测试用例（使用原始参数列表）
+  const allArgs = cli.args  // 使用原始参数列表包含所有标志
+  const testNamePattern = resolveTestNamePattern(allArgs)
+  const passthroughArgs = resolvePassthroughArgs(allArgs)
+
+  // 根据测试类型自动设置环境标志
+  if (type === 'e2e' && !cli.flags.e2e) {
+    cli.flags.e2e = true
+  } else if (type === 'unit' && !cli.flags.test) {
+    cli.flags.test = true
+  }
+
+  const typeConfig = cli.commands.test[type]
+  let testConfig = typeConfig?.[target]
+  if (!testConfig && typeConfig?.command) {
+    testConfig = typeConfig
+  }
+
+  if (!testConfig) {
+    logger.error(`未找到测试配置: ${type}.${target}`)
+    process.exit(1)
+    return
+  }
+
+  if (type === 'e2e' && testConfig.requiresPath && testPath) {
+    if (!testConfig.fileCommand) {
+      logger.error(`测试配置错误: test.${type}.${target} 已启用 requiresPath，必须配置 fileCommand`)
+      process.exit(1)
+    }
+
+    const fileCommand = String(testConfig.fileCommand)
+    if (!fileCommand.includes('{TEST_PATH}')) {
+      logger.error(`测试配置错误: test.${type}.${target} 的 fileCommand 必须包含 {TEST_PATH}`)
+      process.exit(1)
+    }
+
+    let directTargetCommand = fileCommand
+    let directTarget = resolveNxTargetDirectCommand(cli, directTargetCommand, ['test:e2e'])
+    if (!directTarget && hasTrailingWorkerComment(fileCommand)) {
+      directTargetCommand = String(testConfig.command || '')
+      directTarget = resolveNxTargetDirectCommand(cli, directTargetCommand, ['test:e2e'])
+    }
+    const normalizedTestPath = normalizeE2eTestPathForCommand(
+      cli,
+      directTarget ? directTargetCommand : fileCommand,
+      testPath,
+    )
+    let command = directTarget
+      ? `${directTarget.command} ${shellEscape(normalizedTestPath)}`
+      : fileCommand.replace('{TEST_PATH}', shellEscape(normalizedTestPath))
+
+    if (testNamePattern) {
+      command += ` -t ${shellEscape(testNamePattern)}`
+    }
+
+    if (passthroughArgs.length > 0) {
+      command += ` ${passthroughArgs.map(shellEscape).join(' ')}`
+    }
+
+    testConfig = {
+      ...testConfig,
+      command: command,
+      ...(directTarget?.cwd ? { cwd: directTarget.cwd } : {}),
+      description: testNamePattern
+        ? `运行单个E2E测试文件的特定用例: ${testPath} -> ${testNamePattern}`
+        : `运行单个E2E测试文件: ${testPath}`
+    }
+
+    if (testNamePattern) {
+      logger.step(`运行 ${type} 测试用例: ${testNamePattern} (文件: ${testPath})`)
+    } else {
+      logger.step(`运行单个 ${type} 测试: ${testPath}`)
+    }
+  } else if (type === 'unit' && testPaths.length > 0) {
+    let command = String(testConfig.command).trim()
+    const useDirectPathArg = shouldUseDirectPathArg(command)
+    const normalizedTestPaths = testPaths.map(path =>
+      useDirectPathArg
+        ? normalizeUnitTestPathForCommand(cli, command, path)
+        : path
+    )
+    const forwardedArgs = useDirectPathArg
+      ? normalizedTestPaths.map(shellEscape)
+      : [`--runTestsByPath ${normalizedTestPaths.map(shellEscape).join(' ')}`]
+
+    if (testNamePattern) {
+      forwardedArgs.push(`-t ${shellEscape(testNamePattern)}`)
+    }
+
+    if (passthroughArgs.length > 0) {
+      forwardedArgs.push(...passthroughArgs.map(shellEscape))
+    }
+
+    command += ` ${forwardedArgs.join(' ')}`
+
+    testConfig = {
+      ...testConfig,
+      command,
+      description: testNamePattern
+        ? `运行单元测试文件的特定用例: ${testPaths.join(', ')} -> ${testNamePattern}`
+        : `运行单元测试文件: ${testPaths.join(', ')}`,
+    }
+
+    if (testNamePattern) {
+      logger.step(`运行 ${type} 测试用例: ${testNamePattern} (文件: ${testPaths.join(', ')})`)
+    } else {
+      logger.step(`运行 ${type} 测试: ${testPaths.join(', ')}`)
+    }
+  } else {
+    logger.step(`运行 ${type} 测试`)
+  }
+
+  testConfig = {
+    ...testConfig,
+    command: appendDefaultTestWorkers(cli, testConfig.command, type),
+  }
+
+  await cli.executeCommand(testConfig)
+}
+
+function shellEscape(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`
+}
+
+function resolveTestNamePattern(args = []) {
+  const aliases = ['-t', '--name', '--test-name-pattern']
+  for (let i = 0; i < args.length; i++) {
+    if (!aliases.includes(args[i])) continue
+    if (i + 1 < args.length) return args[i + 1]
+  }
+  return null
+}
+
+function resolvePassthroughArgs(args = []) {
+  const index = args.indexOf('--')
+  if (index === -1) return []
+  return args.slice(index + 1)
+}
+
+function shouldUseDirectPathArg(command) {
+  const text = String(command || '')
+  return (
+    /\bnx\s+test\b/.test(text) ||
+    /\bnx\.js\s+test\b/.test(text) ||
+    /\bvitest\s+run\b/.test(text)
+  )
+}
+
+function appendDefaultTestWorkers(cli, command, type) {
+  const text = String(command || '').trim()
+  const flag = getDefaultWorkerFlag(type, text)
+  if (!flag) return command
+  if (!text || hasWorkerFlag(text, flag)) return command
+  if (type === 'unit' && commandUsesRunInBand(cli, text)) return command
+
+  if (isNodeEvalCommandWithoutArgSeparator(text)) {
+    return `${text} -- ${flag}=${DEFAULT_TEST_WORKERS}`
+  }
+
+  return `${text} ${flag}=${DEFAULT_TEST_WORKERS}`
+}
+
+function getDefaultWorkerFlag(type, command = '') {
+  if (type === 'e2e') {
+    return /\bvitest\s+run\b/.test(String(command || '')) ? '--maxWorkers' : '--workers'
+  }
+  if (type === 'unit') return '--maxWorkers'
+  return null
+}
+
+function hasWorkerFlag(command, flag) {
+  const escapedFlag = flag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  return new RegExp(`(^|[\\s'"])${escapedFlag}(=|\\s|['"]|$)`).test(String(command || ''))
+}
+
+function hasTrailingWorkerComment(command) {
+  return /\s+#\s*--(?:maxWorkers|workers)(?:=\S+)?\s*$/.test(String(command || ''))
+}
+
+function hasRunInBandFlag(command) {
+  return /(^|[\s'"])(--runInBand|--run-in-band|-i)(=|\s|['"]|$)/.test(String(command || ''))
+}
+
+function commandUsesRunInBand(cli, command) {
+  if (hasRunInBandFlag(command)) return true
+
+  const script = resolveNxUnitPackageTestScript(cli, command)
+  return hasRunInBandFlag(script)
+}
+
+function resolveNxUnitPackageTestScript(cli, command) {
+  const projectRoot = cli?.projectRoot || process.cwd()
+  const nxResolution = extractNxTarget(command, ['test'])
+  if (!nxResolution?.project) return null
+
+  const packagePath = join(projectRoot, 'apps', nxResolution.project, 'package.json')
+  if (!existsSync(packagePath)) return null
+
+  try {
+    const pkg = JSON.parse(readFileSync(packagePath, 'utf8'))
+    return typeof pkg?.scripts?.test === 'string' ? pkg.scripts.test : null
+  } catch {
+    return null
+  }
+}
+
+function isNodeEvalCommandWithoutArgSeparator(command) {
+  return /(^|\s)node\s+-e\s/.test(String(command || '')) && !/\s--(\s|$)/.test(String(command || ''))
+}
+
+function normalizeUnitTestPathForCommand(cli, command, testPath) {
+  const rawPath = String(testPath || '')
+  if (!rawPath) return rawPath
+
+  if (/\bvitest\s+run\b/.test(String(command || ''))) {
+    return rawPath
+  }
+
+  const projectCwd = resolveNxTargetProjectCwd(cli, command, ['test'])
+  if (!projectCwd) return rawPath
+
+  const projectRoot = cli?.projectRoot || process.cwd()
+  const absoluteProjectCwd = join(projectRoot, projectCwd)
+  const absoluteTestPath = join(projectRoot, rawPath)
+  const relativePath = relative(absoluteProjectCwd, absoluteTestPath)
+
+  if (!relativePath || relativePath.startsWith('..')) {
+    return rawPath
+  }
+
+  return relativePath
+}
+
+function normalizeE2eTestPathForCommand(cli, command, testPath) {
+  const rawPath = String(testPath || '')
+  if (!rawPath) return rawPath
+
+  const projectCwd = resolveNxTargetProjectCwd(cli, command, ['test:e2e'])
+  if (!projectCwd) return rawPath
+
+  const projectRoot = cli?.projectRoot || process.cwd()
+  const absoluteProjectCwd = join(projectRoot, projectCwd)
+  const absoluteTestPath = join(projectRoot, rawPath)
+  const relativePath = relative(absoluteProjectCwd, absoluteTestPath)
+
+  if (!relativePath || relativePath.startsWith('..')) {
+    return rawPath
+  }
+
+  return relativePath
+}
+
+function resolveNxTargetDirectCommand(cli, command, targetNames = []) {
+  const projectRoot = cli?.projectRoot || process.cwd()
+  const nxResolution = extractNxTarget(command, targetNames)
+  if (!nxResolution) return null
+
+  const projectDir = join(projectRoot, 'apps', nxResolution.project)
+  const projectConfigPath = join(projectDir, 'project.json')
+  if (!existsSync(projectConfigPath)) return null
+
+  try {
+    const projectConfig = JSON.parse(readFileSync(projectConfigPath, 'utf8'))
+    const resolvedTarget = projectConfig?.targets?.[nxResolution.target]
+    const directCommand = resolvedTarget?.options?.command
+    if (typeof directCommand !== 'string' || directCommand.trim().length === 0) {
+      return null
+    }
+    const cwd = resolvedTarget?.options?.cwd
+    return {
+      command: directCommand.trim(),
+      cwd: typeof cwd === 'string' && cwd.trim().length > 0 ? cwd.trim() : null,
+    }
+  } catch {
+    return null
+  }
+}
+
+function resolveNxTargetProjectCwd(cli, command, targetNames = []) {
+  const projectRoot = cli?.projectRoot || process.cwd()
+  const nxResolution = extractNxTarget(command, targetNames)
+  if (!nxResolution) return null
+
+  const projectDir = join(projectRoot, 'apps', nxResolution.project)
+  const projectConfigPath = join(projectDir, 'project.json')
+  if (!existsSync(projectConfigPath)) return null
+
+  try {
+    const projectConfig = JSON.parse(readFileSync(projectConfigPath, 'utf8'))
+    const resolvedTarget = projectConfig?.targets?.[nxResolution.target]
+    const cwd = resolvedTarget?.options?.cwd
+    if (typeof cwd === 'string' && cwd.trim().length > 0) {
+      return cwd
+    }
+    if (nxResolution.target === 'test:e2e') {
+      const e2eDir = join(projectDir, 'e2e')
+      if (existsSync(e2eDir)) {
+        return relative(projectRoot, e2eDir)
+      }
+    }
+    return relative(projectRoot, dirname(projectConfigPath))
+  } catch {
+    return null
+  }
+}
+
+function extractNxTarget(command, targetNames = []) {
+  const text = String(command || '').trim()
+  const names = Array.isArray(targetNames) && targetNames.length > 0 ? targetNames : ['test']
+
+  for (const targetName of names) {
+    if (targetName === 'test') {
+      const directMatch = text.match(/\bnx(?:\.js)?\s+test\s+([^\s]+)/)
+      if (directMatch?.[1]) {
+        return { project: directMatch[1], target: 'test' }
+      }
+    }
+
+    const escapedTarget = targetName.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
+    const runMatch = text.match(new RegExp(`\\bnx(?:\\.js)?\\s+run\\s+([^:\\s]+):${escapedTarget}\\b`))
+    if (runMatch?.[1]) {
+      return { project: runMatch[1], target: targetName }
+    }
+
+    const directColonMatch = text.match(new RegExp(`\\bnx(?:\\.js)?\\s+${escapedTarget}\\s+([^\\s]+)`))
+    if (directColonMatch?.[1]) {
+      return { project: directColonMatch[1], target: targetName }
+    }
+  }
+
+  return null
+}
+
+export async function handleLint(cli, args) {
+  void args
+  const baseConfig = cli.commands.lint
+  if (!baseConfig || !baseConfig.command) {
+    logger.error('未找到 lint 命令配置')
+    process.exitCode = 1
+    return
+  }
+
+  const config = { ...baseConfig }
+
+  if (cli.flags.fix) {
+    logger.step('运行代码检查（自动修复模式: --fix）')
+    const cmd = String(config.command)
+    // 若已包含 ` -- ` 分隔符，直接在末尾追加 --fix；否则通过 `--` 传递给 Nx 下游
+    config.command = cmd.includes(' -- ')
+      ? `${cmd} --fix`
+      : `${cmd} -- --fix`
+  } else {
+    logger.step('运行代码检查')
+  }
+
+  await cli.executeCommand(config)
+}
+
+export async function handleClean(cli, args) {
+  const target = args[0] || 'all'
+  const cleanConfig = cli.commands.clean[target]
+
+  if (!cleanConfig) {
+    logger.error(`未找到清理目标: ${target}`)
+    process.exitCode = 1
+    return
+  }
+
+  // 危险操作确认
+  if (cleanConfig.dangerous) {
+    const confirmed = await confirmManager.confirmDangerous(
+      `清理操作: ${target}`,
+      '当前环境',
+      cli.flags.Y
+    )
+
+    if (!confirmed) {
+      logger.info('操作已取消')
+      return
+    }
+  }
+
+  logger.step(`清理 ${target}`)
+  await cli.executeCommand(cleanConfig)
+}
+
+export async function handleCache(cli, args) {
+  const action = args[0] || 'clear'
+  const cacheConfig = cli.commands.cache?.[action]
+
+  if (!cacheConfig) {
+    logger.error(`未找到缓存操作: ${action}`)
+    logger.info('用法: dx cache clear')
+    process.exitCode = 1
+    return
+  }
+
+  // 危险操作确认
+  if (cacheConfig.dangerous) {
+    const confirmed = await confirmManager.confirmDangerous(
+      `缓存清理: ${action}`,
+      '当前环境',
+      cli.flags.Y
+    )
+
+    if (!confirmed) {
+      logger.info('操作已取消')
+      return
+    }
+
+    // 二次确认（更醒目）：强调将清理全局 pnpm store 与 ~/.pnpm-store
+    if (!cli.flags.Y && action === 'clear') {
+      const second = await confirmManager.confirm(
+        '二次确认：将清理全局 pnpm store 与 ~/.pnpm-store，可能影响其他项目，是否继续？',
+        false,
+        false
+      )
+      if (!second) {
+        logger.info('操作已取消')
+        return
+      }
+    }
+  }
+
+  logger.step(`执行缓存操作: ${action}`)
+  await cli.executeCommand(cacheConfig)
+}
+
+export async function handleInstall(cli, args) {
+  void args
+  const installConfig = cli.commands.install
+  if (!installConfig) {
+    logger.error('未找到 install 命令配置')
+    process.exitCode = 1
+    return
+  }
+
+  logger.step('安装依赖')
+  await cli.executeCommand(installConfig)
+}
+
+export async function handleStatus(cli, args) {
+  void args
+  logger.step('系统状态')
+
+  const status = execManager.getStatus()
+  console.log(`运行中的进程: ${status.runningProcesses}`)
+
+  if (status.processes.length > 0) {
+    logger.table(
+      status.processes.map(p => [p.id, p.command, `${Math.round(p.duration/1000)}s`]),
+      ['进程ID', '命令', '运行时长']
+    )
+  }
+}