@ranger1/dx 0.1.85 → 0.1.87

package/codex/skills/pagination-dto-audit-fixer/scripts/pagination_dto_audit.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import re
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Iterable
+
+
+PAGINATION_KEYS = (
+    "items",
+    "data",
+    "total",
+    "page",
+    "limit",
+    "pageSize",
+    "currentPage",
+)
+
+RESPONSE_HINTS = (
+    "Pagination",
+    "Paginated",
+    "ListResponse",
+    "PageResult",
+)
+
+
+@dataclass
+class Finding:
+    kind: str
+    path: str
+    line: int
+    symbol: str
+    message: str
+
+
+@dataclass
+class ClassBlock:
+    name: str
+    extends_name: str
+    body: str
+    start: int
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="审计 backend 分页 DTO 规范")
+    parser.add_argument("--workspace", required=True, help="仓库根目录")
+    parser.add_argument(
+        "--include-glob",
+        action="append",
+        default=["apps/backend/src/**/*.ts"],
+        help="附加扫描 glob，可重复传入",
+    )
+    parser.add_argument("--output-json", help="输出 JSON 文件路径")
+    return parser.parse_args()
+
+
+def iter_files(workspace: Path, globs: Iterable[str]) -> list[Path]:
+    seen: set[Path] = set()
+    files: list[Path] = []
+    for pattern in globs:
+        for path in workspace.glob(pattern):
+            if not path.is_file():
+                continue
+            if path in seen:
+                continue
+            seen.add(path)
+            files.append(path)
+    return sorted(files)
+
+
+def has_pagination_signal(block: str) -> bool:
+    hit_count = sum(1 for key in PAGINATION_KEYS if re.search(rf"\b{re.escape(key)}\b", block))
+    has_total = re.search(r"\btotal\b", block) is not None
+    has_items_or_data = re.search(r"\b(items|data)\b", block) is not None
+    has_page_signal = re.search(r"\b(page|limit|pageSize|currentPage)\b", block) is not None
+    return hit_count >= 3 and has_total and has_items_or_data and has_page_signal
+
+
+def line_no(content: str, index: int) -> int:
+    return content.count("\n", 0, index) + 1
+
+
+def iter_export_classes(content: str) -> list[ClassBlock]:
+    header_pattern = re.compile(
+        r"export\s+class\s+(?P<name>\w+)\s*(?:extends\s+(?P<extends>[^{\n]+))?\s*{",
+        re.MULTILINE,
+    )
+    classes: list[ClassBlock] = []
+    for match in header_pattern.finditer(content):
+        brace_start = match.end() - 1
+        depth = 0
+        index = brace_start
+        while index < len(content):
+            char = content[index]
+            if char == "{":
+                depth += 1
+            elif char == "}":
+                depth -= 1
+                if depth == 0:
+                    body = content[brace_start + 1 : index]
+                    classes.append(
+                        ClassBlock(
+                            name=match.group("name"),
+                            extends_name=(match.group("extends") or "").strip(),
+                            body=body,
+                            start=match.start(),
+                        )
+                    )
+                    break
+            index += 1
+    return classes
+
+
+def scan_request_dtos(path: Path, content: str) -> list[Finding]:
+    findings: list[Finding] = []
+    path_text = str(path)
+    is_dto_file = "/dto/" in path_text or path.name.endswith(".dto.ts")
+    for class_block in iter_export_classes(content):
+        name = class_block.name
+        extends_name = class_block.extends_name
+        body = class_block.body
+        if not is_dto_file:
+            continue
+        if "/responses/" in path_text or ".response." in path.name or "Response" in name:
+            continue
+        if not name.endswith("Dto"):
+            continue
+        if name == "BasePaginationRequestDto":
+            continue
+        if extends_name == "BasePaginationRequestDto":
+            continue
+        if not re.search(r"\b(page|limit|pageSize|currentPage)\b", body):
+            continue
+        findings.append(
+            Finding(
+                kind="request-dto-not-standard",
+                path=str(path),
+                line=line_no(content, class_block.start),
+                symbol=name,
+                message="请求 DTO 包含分页字段，但未继承 BasePaginationRequestDto",
+            )
+        )
+    return findings
+
+
+def scan_response_dtos(path: Path, content: str) -> list[Finding]:
+    findings: list[Finding] = []
+    path_text = str(path)
+    is_dto_file = "/dto/" in path_text or path.name.endswith(".dto.ts")
+    for class_block in iter_export_classes(content):
+        name = class_block.name
+        extends_name = class_block.extends_name
+        body = class_block.body
+        if not is_dto_file:
+            continue
+        if (
+            "/requests/" in path_text
+            or ".request." in path.name
+            or "Request" in name
+            or name == "BasePaginationRequestDto"
+        ):
+            continue
+        if "BasePaginationResponseDto" in extends_name:
+            continue
+        if not (has_pagination_signal(body) or any(hint in name for hint in RESPONSE_HINTS)):
+            continue
+        findings.append(
+            Finding(
+                kind="response-dto-not-standard",
+                path=str(path),
+                line=line_no(content, class_block.start),
+                symbol=name,
+                message="响应 DTO 命中分页信号，但未继承 BasePaginationResponseDto",
+            )
+        )
+    return findings
+
+
+def scan_manual_returns(path: Path, content: str) -> list[Finding]:
+    findings: list[Finding] = []
+    return_pattern = re.compile(r"return\s*{(?P<body>[\s\S]*?)}", re.MULTILINE)
+    for match in return_pattern.finditer(content):
+        body = match.group("body")
+        if not has_pagination_signal(body):
+            continue
+        findings.append(
+            Finding(
+                kind="manual-pagination-return",
+                path=str(path),
+                line=line_no(content, match.start()),
+                symbol="return",
+                message="检测到手工拼装分页返回结构，建议改为统一分页 DTO",
+            )
+        )
+    return findings
+
+
+def scan_file(path: Path) -> list[Finding]:
+    try:
+        content = path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        return []
+    findings: list[Finding] = []
+    findings.extend(scan_request_dtos(path, content))
+    findings.extend(scan_response_dtos(path, content))
+    findings.extend(scan_manual_returns(path, content))
+    return findings
+
+
+def print_report(findings: list[Finding]) -> None:
+    if not findings:
+        print("未发现疑似非标准分页 DTO 或手工分页返回结构。")
+        return
+    grouped: dict[str, list[Finding]] = {}
+    for finding in findings:
+        grouped.setdefault(finding.kind, []).append(finding)
+    print(f"共发现 {len(findings)} 个问题：")
+    for kind in sorted(grouped):
+        print(f"\n[{kind}] {len(grouped[kind])} 个")
+        for finding in grouped[kind]:
+            print(f"- {finding.path}:{finding.line} {finding.symbol} -> {finding.message}")
+
+
+def main() -> int:
+    args = parse_args()
+    workspace = Path(args.workspace).resolve()
+    files = iter_files(workspace, args.include_glob)
+    findings: list[Finding] = []
+    for path in files:
+        findings.extend(scan_file(path))
+    print_report(findings)
+    if args.output_json:
+        output = Path(args.output_json)
+        output.write_text(
+            json.dumps([asdict(finding) for finding in findings], ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+        )
+        print(f"\nJSON 已输出到 {output}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/lib/cli/commands/core.js

@@ -94,22 +94,34 @@ export async function handleTest(cli, args) {
     cli.flags.test = true
   }
 
-  let testConfig = cli.commands.test[type]?.[target] || cli.commands.test[type]
+  const typeConfig = cli.commands.test[type]
+  let testConfig = typeConfig?.[target]
+  if (!testConfig && typeConfig?.command) {
+    testConfig = typeConfig
+  }
 
   if (!testConfig) {
     logger.error(`未找到测试配置: ${type}.${target}`)
-    process.exitCode = 1
+    process.exit(1)
     return
   }
 
-  // 如果提供了测试文件路径，使用专门的单文件测试配置
-  if (testPath && type === 'e2e' && target === 'backend') {
-    let command = `npx nx test:e2e backend -- ${testPath}`
+  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 command = fileCommand.replace('{TEST_PATH}', shellEscape(testPath))
 
-    // 如果指定了测试用例名称，添加 -t 参数
     if (testNamePattern) {
-      const escapedPattern = String(testNamePattern).replace(/(["`\\$])/g, '\\$1')
-      command += ` -t "${escapedPattern}"`
+      command += ` -t ${shellEscape(testNamePattern)}`
     }
 
     testConfig = {
@@ -132,6 +144,10 @@ export async function handleTest(cli, args) {
   await cli.executeCommand(testConfig)
 }
 
+function shellEscape(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`
+}
+
 export async function handleLint(cli, args) {
   void args
   const baseConfig = cli.commands.lint

package/lib/cli/dx-cli.js

@@ -608,17 +608,27 @@ class DxCli {
   }
 
   validateTestPositionals(positionalArgs) {
-    if (positionalArgs.length === 0) return
-
     const [type = 'e2e', target = 'all', testPath] = positionalArgs
 
-    if (type === 'e2e' && target === 'backend' && !testPath) {
-      logger.error('dx test e2e backend 必须提供测试文件或目录路径')
-      logger.info(`示例: ${this.invocation} test e2e backend apps/backend/e2e/auth`)
-      logger.info(
-        `示例: ${this.invocation} test e2e backend apps/backend/e2e/auth/auth.login.e2e-spec.ts -t "should login"`,
-      )
-      logger.info('说明: 为避免误触发全量 E2E，backend E2E 仅允许按文件或目录增量执行')
+    if (type !== 'e2e') return
+
+    if (target === 'all') {
+      logger.error('dx test e2e all 不受支持，请指定 target 和测试文件或目录路径')
+      process.exit(1)
+    }
+
+    const testConfig = this.commands?.test?.[type]?.[target]
+    if (!testConfig) return
+    if (!testConfig.requiresPath) return
+
+    if (!testPath) {
+      logger.error(`dx test e2e ${target} 必须提供测试文件或目录路径`)
+      logger.info(`示例: ${this.invocation} test e2e ${target} apps/${target}/e2e/health`)
+      process.exit(1)
+    }
+
+    if (testPath === 'all') {
+      logger.error(`dx test e2e ${target} 不支持 all，必须提供测试文件或目录路径`)
       process.exit(1)
     }
   }

package/lib/cli/help.js

@@ -43,10 +43,10 @@ export function showHelp() {
     '',
     '  test [type] [target] [path] [-t pattern]  运行测试',
     '    type: e2e, unit (默认: e2e)',
-    '    target: backend, all (默认: all)',
-    '    path: 测试文件或目录路径 (必填，仅支持 e2e backend)',
+    '    target: 由 commands.json 的 test.<type>.<target> 决定（e2e 默认会拒绝隐式 all）',
+    '    path: 测试文件或目录路径 (guarded e2e target 必填，例如 backend/quantify)',
     '    -t pattern: 指定测试用例名称模式 (可选，需要和 path 一起使用)',
-    '    说明: backend E2E 禁止无路径全量执行',
+    '    说明: guarded E2E target 禁止无路径或 all 全量执行，dx test e2e all 也不受支持',
     '',
     '  worktree [action] [num...] Git Worktree管理',
     '    action: make, del, list, clean',
@@ -94,6 +94,8 @@ export function showHelp() {
     '  dx test e2e backend apps/backend/e2e/auth     # 按目录运行后端 E2E',
     '  dx test e2e backend apps/backend/e2e/activity/activity.admin.e2e-spec.ts  # 运行单个E2E测试文件',
     '  dx test e2e backend apps/backend/e2e/activity/activity.admin.e2e-spec.ts -t "should list all activity definitions"  # 运行特定测试用例',
+    '  dx test e2e quantify apps/quantify/e2e/health/health.e2e-spec.ts  # 运行 Quantify E2E 文件',
+    '  dx test e2e all          # 不受支持，必须指定 target 和 path',
     '  dx deploy front --staging # 部署前端到 Vercel（staging）',
     '  dx deploy backend --prod  # 构建 backend 制品并上传/部署到远端主机',
     '  dx deploy backend --build-only # 仅构建 backend 制品，不执行远端部署',
@@ -255,17 +257,20 @@ test 命令用法:
 
 参数说明:
   type: e2e, unit (默认: e2e)
-  target: backend, all (默认: all)
-  path: 仅 e2e backend 支持，且必须提供文件或目录路径
+  target: 由 commands.json 的 test.<type>.<target> 决定
+  path: guarded e2e target 必须提供文件或目录路径
   -t pattern: 指定测试用例名称模式，需要和 path 一起使用
 
 限制说明:
-  backend E2E 禁止无路径全量执行，缺少 path 时命令会直接报错退出。
+  guarded E2E target 禁止无路径全量执行。
+  guarded E2E target 也不支持把 path 写成 all。
+  dx test e2e all 不受支持，必须显式指定 target 和 path。
 
 常见示例:
   dx test e2e backend apps/backend/e2e/auth
   dx test e2e backend apps/backend/e2e/auth/auth.login.e2e-spec.ts
   dx test e2e backend apps/backend/e2e/auth/auth.login.e2e-spec.ts -t "should login"
+  dx test e2e quantify apps/quantify/e2e/health/health.e2e-spec.ts
   dx test unit front
   dx test unit admin
 `)

package/lib/codex-initial.js

@@ -4,6 +4,49 @@ import os from 'node:os'
 
 import { logger } from './logger.js'
 
+const REQUIRED_CODEX_CONFIG = [
+  {
+    section: 'features',
+    values: {
+      multi_agent: 'true',
+    },
+  },
+  {
+    section: 'agents',
+    values: {
+      max_threads: '15',
+    },
+  },
+  {
+    section: 'agents.fixer',
+    values: {
+      description: '"bugfix 代理"',
+      config_file: '"agents/fixer.toml"',
+    },
+  },
+  {
+    section: 'agents.orchestrator',
+    values: {
+      description: '"pr 修复流程编排代理"',
+      config_file: '"agents/orchestrator.toml"',
+    },
+  },
+  {
+    section: 'agents.reviewer',
+    values: {
+      description: '"代码评审代理"',
+      config_file: '"agents/reviewer.toml"',
+    },
+  },
+  {
+    section: 'agents.spark',
+    values: {
+      description: '"通用执行代理"',
+      config_file: '"agents/spark.toml"',
+    },
+  },
+]
+
 async function collectAllFiles(dir) {
   const out = []
 
@@ -39,6 +82,110 @@ async function ensureDir(path) {
   await fs.mkdir(path, { recursive: true })
 }
 
+function escapeRegExp(input) {
+  return String(input).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function ensureTrailingNewline(text) {
+  if (!text) return ''
+  return text.endsWith('\n') ? text : `${text}\n`
+}
+
+function upsertTomlSection(content, { section, values }) {
+  const header = `[${section}]`
+  const sectionPattern = new RegExp(`^\\[${escapeRegExp(section)}\\]\\s*$`, 'm')
+  const sectionHeaderMatch = content.match(sectionPattern)
+  let nextContent = content
+  let changedKeys = 0
+  let createdSection = false
+
+  if (!sectionHeaderMatch) {
+    const blockLines = [header, ...Object.entries(values).map(([key, value]) => `${key} = ${value}`), '']
+    nextContent = ensureTrailingNewline(content)
+    if (nextContent.length > 0 && !nextContent.endsWith('\n\n')) {
+      nextContent += '\n'
+    }
+    nextContent += `${blockLines.join('\n')}\n`
+    return {
+      content: nextContent,
+      changedKeys: Object.keys(values).length,
+      createdSection: true,
+    }
+  }
+
+  const sectionStart = sectionHeaderMatch.index
+  const sectionBodyStart = sectionStart + sectionHeaderMatch[0].length
+  const remaining = content.slice(sectionBodyStart)
+  const nextHeaderMatch = remaining.match(/\n(?=\[[^\]]+\]\s*$)/m)
+  const sectionEnd =
+    nextHeaderMatch && typeof nextHeaderMatch.index === 'number'
+      ? sectionBodyStart + nextHeaderMatch.index + 1
+      : content.length
+
+  const beforeSection = content.slice(0, sectionStart)
+  const originalSectionText = content.slice(sectionStart, sectionEnd)
+  const trailing = content.slice(sectionEnd)
+  const sectionLines = originalSectionText.split('\n')
+
+  for (const [key, value] of Object.entries(values)) {
+    const desiredLine = `${key} = ${value}`
+    const keyPattern = new RegExp(`^${escapeRegExp(key)}\\s*=`, 'm')
+    const lineIndex = sectionLines.findIndex(line => keyPattern.test(line.trim()))
+
+    if (lineIndex === -1) {
+      let insertIndex = sectionLines.length
+      while (insertIndex > 1 && sectionLines[insertIndex - 1] === '') {
+        insertIndex--
+      }
+      sectionLines.splice(insertIndex, 0, desiredLine)
+      changedKeys++
+      continue
+    }
+
+    if (sectionLines[lineIndex].trim() !== desiredLine) {
+      sectionLines[lineIndex] = desiredLine
+      changedKeys++
+    }
+  }
+
+  const updatedSectionText = ensureTrailingNewline(sectionLines.join('\n'))
+  nextContent = `${beforeSection}${updatedSectionText}${trailing}`
+
+  return { content: nextContent, changedKeys, createdSection }
+}
+
+async function ensureCodexConfig({ codexDir }) {
+  const configPath = join(codexDir, 'config.toml')
+  let content = ''
+
+  try {
+    content = await fs.readFile(configPath, 'utf8')
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error
+  }
+
+  let changedKeys = 0
+  let createdSections = 0
+  let nextContent = content
+
+  for (const sectionConfig of REQUIRED_CODEX_CONFIG) {
+    const result = upsertTomlSection(nextContent, sectionConfig)
+    nextContent = result.content
+    changedKeys += result.changedKeys
+    if (result.createdSection) createdSections++
+  }
+
+  if (nextContent !== content || content === '') {
+    await fs.writeFile(configPath, ensureTrailingNewline(nextContent), 'utf8')
+  }
+
+  return {
+    configPath,
+    changedKeys,
+    createdSections,
+  }
+}
+
 async function assertDirExists(path, label) {
   try {
     const st = await fs.stat(path)
@@ -116,10 +263,11 @@ export async function runCodexInitial(options = {}) {
   if (!packageRoot) throw new Error('runCodexInitial: 缺少 packageRoot')
 
   const homeDir = options.homeDir || os.homedir()
+  const codexDir = join(homeDir, '.codex')
   const srcSkills = join(packageRoot, 'codex', 'skills')
-  const dstSkills = join(homeDir, '.codex', 'skills')
+  const dstSkills = join(codexDir, 'skills')
   const srcCodexAgents = join(packageRoot, 'codex', 'agents')
-  const dstCodexAgents = join(homeDir, '.codex', 'agents')
+  const dstCodexAgents = join(codexDir, 'agents')
 
   await assertDirExists(srcSkills, '模板目录 codex/skills')
   await assertDirExists(srcCodexAgents, '模板目录 codex/agents')
@@ -129,8 +277,12 @@ export async function runCodexInitial(options = {}) {
 
   const skillsStats = await copySkillsDirectories({ srcSkillsDir: srcSkills, dstSkillsDir: dstSkills })
   const codexAgentsStats = await copyDirMerge({ srcDir: srcCodexAgents, dstDir: dstCodexAgents })
+  const configStats = await ensureCodexConfig({ codexDir })
 
-  logger.success(`已初始化 Codex 模板到: ${join(homeDir, '.codex')}`)
+  logger.success(`已初始化 Codex 模板到: ${codexDir}`)
   logger.info(`skills: ${skillsStats.copiedDirs} 个目录，覆盖复制 ${skillsStats.copiedFiles} 个文件 -> ${dstSkills}`)
   logger.info(`codex agents: 覆盖复制 ${codexAgentsStats.fileCount} 个文件 -> ${dstCodexAgents}`)
+  logger.info(
+    `config.toml: 修复 ${configStats.changedKeys} 个配置项，新增 ${configStats.createdSections} 个分组 -> ${configStats.configPath}`,
+  )
 }

package/lib/exec.js

@@ -12,6 +12,25 @@ import { confirmManager } from './confirm.js'
 
 const execPromise = promisify(nodeExec)
 
+export function sanitizeChildEnv(inputEnv = {}) {
+  const env = { ...inputEnv }
+  const noColor = env.NO_COLOR
+  const forceColor = env.FORCE_COLOR
+
+  // 某些工具链（npm/pnpm/chalk）会在子进程链路里自动打开 FORCE_COLOR，
+  // 这会与继承下去的 NO_COLOR 冲突并触发 "NO_COLOR is ignored" 警告。
+  // 这里优先移除 NO_COLOR，避免在 dx 执行链路中重复打印噪音告警。
+  if (noColor !== undefined && noColor !== null && String(noColor) !== '') {
+    delete env.NO_COLOR
+  }
+
+  if (forceColor === undefined || forceColor === null || String(forceColor) === '') {
+    delete env.FORCE_COLOR
+  }
+
+  return env
+}
+
 export class ExecManager {
   constructor() {
     this.runningProcesses = new Map()
@@ -222,12 +241,12 @@ export class ExecManager {
         const result = await this.spawnCommand(fullCommand, {
           cwd: cwd || process.cwd(),
           stdio,
-          env: {
+          env: sanitizeChildEnv({
             ...process.env,
             NODE_ENV: nodeEnvForProcess,
             ...forcedEnv,
             ...extraEnv,
-          },
+          }),
           timeout,
         })
 

package/lib/run-with-version-env.js

@@ -1,4 +1,5 @@
 import { spawn, execSync } from 'node:child_process'
+import { sanitizeChildEnv } from './exec.js'
 import { readFile } from 'node:fs/promises'
 import { resolve, join, dirname } from 'node:path'
 import { existsSync } from 'node:fs'
@@ -147,7 +148,7 @@ export async function runWithVersionEnv(argv = []) {
 
   const child = spawn(command[0], command.slice(1), {
     stdio: 'inherit',
-    env,
+    env: sanitizeChildEnv(env),
     shell: false
   })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ranger1/dx",
-  "version": "0.1.85",
+  "version": "0.1.87",
   "type": "module",
   "license": "MIT",
   "repository": {