@ranger1/dx 0.1.85 → 0.1.86

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/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.86",
   "type": "module",
   "license": "MIT",
   "repository": {