@weotro/dx 0.1.0

package/lib/codex-initial.js

@@ -0,0 +1,271 @@
+import { promises as fs } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
+import os from 'node:os'
+
+import { logger } from './logger.js'
+
+const TEMP_DIR_PATTERN = /^\..+\.(tmp|backup)-\d+-\d+$/
+
+// 历史上曾在 skills/ 目录托管、但后续已删除的 skill 名称。
+// 来源：git log --all --diff-filter=A --name-only -- 'skills/*' | sed -n 's#^skills/\([^/]*\)/.*#\1#p' | sort -u
+// 再减去当前 skills/ 现存名单。
+// 这些名字需要在 ~/.agents、~/.claude、~/.codex 三处彻底清理（软链或真实目录都清）。
+// 将来从 skills/ 删除新的 skill 时，把它追加到这里即可。
+const DELETED_SKILLS = [
+  'autospec',
+  'backend-audit-fixer',
+  'backend-layering-audit-fixer',
+  'e2e-audit-fixer',
+  'env-accessor-audit-fixer',
+  'error-handling-audit-fixer',
+  'feature-decide-plan-execute',
+  'git-commit-and-pr',
+  'issues-batch-deliver',
+  'multi-pr-feature-delivery',
+  'naming-convention-audit',
+  'omc-reference',
+  'pagination-dto-audit-fixer',
+  'pr-ship',
+  'pr-train-ship',
+]
+
+async function collectSkillNames(dir) {
+  const entries = await fs.readdir(dir, { withFileTypes: true })
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name)
+}
+
+async function collectAllFiles(dir) {
+  const out = []
+
+  async function walk(current) {
+    const entries = await fs.readdir(current, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const full = join(current, entry.name)
+      if (entry.isDirectory()) {
+        if (entry.name === '__pycache__' || entry.name === '.pytest_cache') {
+          continue
+        }
+        await walk(full)
+        continue
+      }
+      if (!entry.isFile()) continue
+
+      const lowerName = entry.name.toLowerCase()
+      if (lowerName.endsWith('.pyc') || lowerName.endsWith('.pyo') || lowerName.endsWith('.pyd')) continue
+      out.push(full)
+    }
+  }
+
+  await walk(dir)
+  return out
+}
+
+async function ensureDir(path) {
+  await fs.mkdir(path, { recursive: true })
+}
+
+async function pathExists(path) {
+  try {
+    await fs.access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function lstatIfExists(path) {
+  try {
+    return await fs.lstat(path)
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+async function assertDirExists(path, label) {
+  try {
+    const st = await fs.stat(path)
+    if (!st.isDirectory()) {
+      throw new Error(`${label} 不是目录: ${path}`)
+    }
+  } catch (error) {
+    if (error?.message?.startsWith(`${label} 不是目录:`)) {
+      throw error
+    }
+    const message = error?.message || String(error)
+    throw new Error(`${label} 不存在或不可访问: ${path}\n${message}`)
+  }
+}
+
+async function copyDirMerge({ srcDir, dstDir }) {
+  const entries = await fs.readdir(srcDir, { withFileTypes: true })
+  let fileCount = 0
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+
+    const srcSkillDir = join(srcDir, entry.name)
+    const dstSkillDir = join(dstDir, entry.name)
+    const token = `${process.pid}-${Date.now()}`
+    const tmpSkillDir = join(dstDir, `.${entry.name}.tmp-${token}`)
+    const backupSkillDir = join(dstDir, `.${entry.name}.backup-${token}`)
+    let hasBackup = false
+
+    try {
+      const files = await collectAllFiles(srcSkillDir)
+      fileCount += files.length
+      await ensureDir(tmpSkillDir)
+      for (const file of files) {
+        const rel = relative(srcSkillDir, file)
+        const target = join(tmpSkillDir, rel)
+        await ensureDir(dirname(target))
+        await fs.copyFile(file, target)
+      }
+
+      if (await pathExists(dstSkillDir)) {
+        await fs.rename(dstSkillDir, backupSkillDir)
+        hasBackup = true
+      }
+      await fs.rename(tmpSkillDir, dstSkillDir)
+      if (hasBackup) {
+        await fs.rm(backupSkillDir, { recursive: true, force: true })
+      }
+    } catch (error) {
+      await fs.rm(tmpSkillDir, { recursive: true, force: true })
+      if (hasBackup && !(await pathExists(dstSkillDir))) {
+        await fs.rename(backupSkillDir, dstSkillDir)
+        hasBackup = false
+      }
+      if (hasBackup) {
+        await fs.rm(backupSkillDir, { recursive: true, force: true })
+      }
+      throw error
+    }
+  }
+
+  return { fileCount }
+}
+
+async function removeManagedNonSymlinkSkills(skillsDir, skillNames) {
+  for (const skillName of skillNames) {
+    const target = join(skillsDir, skillName)
+    const stat = await lstatIfExists(target)
+    if (!stat) continue
+    if (stat.isSymbolicLink()) continue
+    await fs.rm(target, { recursive: true, force: true })
+  }
+}
+
+// 彻底清理指定名称的 skill：无论是软链还是真实目录/文件都删除。
+// 用于历史上已从 skills/ 删除的 skill，需在各目标目录连根拔除。
+// 这是尽力而为的清理：单个名字清理失败（如权限问题）只记录并继续，
+// 不抛出，避免一个陈旧副本的异常阻断整个 skill 同步主流程。
+async function purgeSkills(skillsDir, skillNames) {
+  let purged = 0
+  let failed = 0
+  for (const skillName of skillNames) {
+    const target = join(skillsDir, skillName)
+    let stat
+    try {
+      stat = await lstatIfExists(target)
+    } catch (error) {
+      logger.warn(`清理历史 skill 失败（跳过）: ${target} — ${error?.message || String(error)}`)
+      failed++
+      continue
+    }
+    if (!stat) continue
+    try {
+      await fs.rm(target, { recursive: true, force: true })
+      purged++
+    } catch (error) {
+      logger.warn(`清理历史 skill 失败（跳过）: ${target} — ${error?.message || String(error)}`)
+      failed++
+    }
+  }
+  return { purged, failed }
+}
+
+async function removeStaleTempDirs(skillsDir) {
+  const entries = await fs.readdir(skillsDir, { withFileTypes: true })
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue
+    if (!TEMP_DIR_PATTERN.test(entry.name)) continue
+    await fs.rm(join(skillsDir, entry.name), { recursive: true, force: true })
+  }
+}
+
+async function linkSkillsToClaude({ skillNames, agentsSkillsDir, claudeSkillsDir }) {
+  for (const skillName of skillNames) {
+    const srcSkillDir = join(agentsSkillsDir, skillName)
+    const claudeSkillPath = join(claudeSkillsDir, skillName)
+
+    let stat
+    try {
+      stat = await fs.lstat(claudeSkillPath)
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error
+    }
+
+    if (stat?.isSymbolicLink()) {
+      const currentTarget = await fs.readlink(claudeSkillPath)
+      if (currentTarget === srcSkillDir) continue
+      await fs.rm(claudeSkillPath, { recursive: true, force: true })
+    } else if (stat) {
+      await fs.rm(claudeSkillPath, { recursive: true, force: true })
+    }
+
+    await fs.symlink(srcSkillDir, claudeSkillPath, 'dir')
+  }
+}
+
+export async function runCodexInitial(options = {}) {
+  const packageRoot = options.packageRoot
+  if (!packageRoot) throw new Error('runCodexInitial: 缺少 packageRoot')
+
+  const homeDir = options.homeDir || os.homedir()
+  const srcSkillsDir = join(packageRoot, 'skills')
+  const agentsSkillsDir = join(homeDir, '.agents', 'skills')
+  const claudeSkillsDir = join(homeDir, '.claude', 'skills')
+  const codexSkillsDir = join(homeDir, '.codex', 'skills')
+
+  await assertDirExists(srcSkillsDir, '模板目录 skills')
+  const skillNames = await collectSkillNames(srcSkillsDir)
+
+  // 护栏：已删除名单不得与现存 skill 重叠，否则会把刚同步的 skill 又清掉（自相矛盾）。
+  const overlap = DELETED_SKILLS.filter((name) => skillNames.includes(name))
+  if (overlap.length > 0) {
+    throw new Error(`DELETED_SKILLS 与现存 skills/ 重叠，需修正名单: ${overlap.join(', ')}`)
+  }
+
+  await ensureDir(codexSkillsDir)
+  await ensureDir(claudeSkillsDir)
+  await ensureDir(agentsSkillsDir)
+
+  await removeManagedNonSymlinkSkills(codexSkillsDir, skillNames)
+  await removeManagedNonSymlinkSkills(claudeSkillsDir, skillNames)
+
+  // 清理历史上已删除的 skill：在 agents/claude/codex 三处连根拔除（含 agents 真实副本与软链）。
+  // 先清 claude（指向 agents 的软链宿主），再清 agents/codex（真实副本），
+  // 避免中途失败时留下指向已删除 agents target 的悬空软链。
+  const purgeClaude = await purgeSkills(claudeSkillsDir, DELETED_SKILLS)
+  const purgeAgents = await purgeSkills(agentsSkillsDir, DELETED_SKILLS)
+  const purgeCodex = await purgeSkills(codexSkillsDir, DELETED_SKILLS)
+
+  await removeStaleTempDirs(agentsSkillsDir)
+  const copyStats = await copyDirMerge({ srcDir: srcSkillsDir, dstDir: agentsSkillsDir })
+  await removeStaleTempDirs(agentsSkillsDir)
+  await linkSkillsToClaude({ skillNames, agentsSkillsDir, claudeSkillsDir })
+
+  logger.success('已初始化 skills 模板')
+  logger.info(`agents skills: 覆盖复制 ${copyStats.fileCount} 个文件 -> ${agentsSkillsDir}`)
+  logger.info(`claude skills: 已创建 ${skillNames.length} 个软链接 -> ${claudeSkillsDir}`)
+  logger.info(`codex skills: 已清理 ${skillNames.length} 个包内托管 skill 的旧副本 -> ${codexSkillsDir}`)
+  logger.info(
+    `已删除 skill 清理: agents ${purgeAgents.purged} / claude ${purgeClaude.purged} / codex ${purgeCodex.purged}`,
+  )
+  const purgeFailed = purgeClaude.failed + purgeAgents.failed + purgeCodex.failed
+  if (purgeFailed > 0) {
+    logger.warn(`已删除 skill 清理: ${purgeFailed} 个目标清理失败（已跳过，详见上方告警）`)
+  }
+}

package/lib/confirm.js

@@ -0,0 +1,213 @@
+import { createInterface } from 'node:readline'
+import { logger } from './logger.js'
+
+export class ConfirmManager {
+  constructor() {
+    this.rl = null
+  }
+
+  // 判断是否启用自动确认（CI 或显式环境变量）
+  isAutoYes(skipFlag = false) {
+    if (skipFlag) return true
+    const ci = String(process.env.CI || '').toLowerCase()
+    const autoYes = String(process.env.AI_CLI_YES || process.env.YES || '').toLowerCase()
+    // 常见 CI 环境会设置 CI=true；也支持自定义 AI_CLI_YES/YES 变量
+    return ci === 'true' || ci === '1' || autoYes === 'true' || autoYes === '1'
+  }
+
+  // 基础确认
+  async confirm(message, defaultValue = false, skipFlag = false) {
+    if (this.isAutoYes(skipFlag)) {
+      logger.info(`跳过确认: ${message}`)
+      return true
+    }
+
+    const prompt = defaultValue ? `${message} [Y/n]: ` : `${message} [y/N]: `
+
+    return new Promise(resolve => {
+      this.rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      })
+
+      this.rl.question(prompt, answer => {
+        this.rl.close()
+
+        const normalized = answer.toLowerCase().trim()
+        if (normalized === '') {
+          resolve(defaultValue)
+        } else {
+          resolve(['y', 'yes', '是', 'true', '1'].includes(normalized))
+        }
+      })
+    })
+  }
+
+  // 危险操作确认
+  async confirmDangerous(operation, environment = 'unknown', skipFlag = false) {
+    if (this.isAutoYes(skipFlag)) {
+      logger.warn(`跳过危险操作确认: ${operation}`)
+      return true
+    }
+
+    logger.separator()
+    logger.warn('警告: 即将执行危险操作')
+    console.log(`操作: ${operation}`)
+    console.log(`环境: ${environment}`)
+
+    if (environment === 'production' || environment === '生产环境') {
+      console.log(`🔥 此操作将在生产环境执行，可能导致数据丢失或服务中断`)
+      console.log(`🔥 请确保您已经：`)
+      console.log(`   1. 备份了重要数据`)
+      console.log(`   2. 通知了相关团队成员`)
+      console.log(`   3. 确认了操作的必要性`)
+    } else {
+      console.log(`此操作可能导致数据丢失，请谨慎操作`)
+    }
+
+    logger.separator()
+
+    // 对于生产环境，需要两次确认
+    if (environment === 'production' || environment === '生产环境') {
+      const firstConfirm = await this.confirm('您确定要在生产环境执行此危险操作吗？', false, false)
+      if (!firstConfirm) {
+        return false
+      }
+
+      console.log(`\n请再次确认，输入操作名称以继续: ${operation}`)
+      return new Promise(resolve => {
+        this.rl = createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        })
+
+        this.rl.question('请输入操作名称: ', answer => {
+          this.rl.close()
+          resolve(answer.trim() === operation)
+        })
+      })
+    } else {
+      return this.confirm('确定要继续吗？', false, false)
+    }
+  }
+
+  // 批量操作确认
+  async confirmBatch(operations, skipFlag = false) {
+    if (this.isAutoYes(skipFlag)) {
+      logger.info('跳过批量操作确认')
+      return true
+    }
+
+    logger.separator()
+    console.log('即将执行以下操作:')
+    operations.forEach((op, index) => {
+      console.log(`${index + 1}. ${op}`)
+    })
+    logger.separator()
+
+    return this.confirm('确认执行所有操作？', false, false)
+  }
+
+  // 端口冲突确认
+  async confirmPortCleanup(port, processes, skipFlag = false) {
+    if (this.isAutoYes(skipFlag)) {
+      logger.info(`跳过端口清理确认: 端口 ${port}`)
+      return true
+    }
+
+    logger.warn(`端口 ${port} 被以下进程占用:`)
+    processes.forEach(pid => {
+      console.log(`  进程 ID: ${pid}`)
+    })
+
+    return this.confirm(`是否杀死这些进程以释放端口 ${port}？`, true, false)
+  }
+
+  // 环境切换确认
+  async confirmEnvironmentSwitch(from, to, skipFlag = false) {
+    if (this.isAutoYes(skipFlag)) {
+      logger.info(`跳过环境切换确认: ${from} -> ${to}`)
+      return true
+    }
+
+    if (to === 'production' || to === '生产环境') {
+      logger.warn(`即将从 ${from} 切换到 ${to}`)
+      logger.warn('生产环境操作需要额外谨慎')
+      return this.confirm('确定要切换到生产环境吗？', false, false)
+    }
+
+    return this.confirm(`确定要从 ${from} 切换到 ${to} 吗？`, true, false)
+  }
+
+  // 文件覆盖确认
+  async confirmOverwrite(filePath, skipFlag = false) {
+    if (this.isAutoYes(skipFlag)) {
+      logger.info(`跳过文件覆盖确认: ${filePath}`)
+      return true
+    }
+
+    logger.warn(`文件已存在: ${filePath}`)
+    return this.confirm('是否覆盖现有文件？', false, false)
+  }
+
+  // 清理操作确认
+  async confirmCleanup(targets, skipFlag = false) {
+    if (this.isAutoYes(skipFlag)) {
+      logger.info('跳过清理操作确认')
+      return true
+    }
+
+    logger.warn('即将清理以下内容:')
+    targets.forEach(target => {
+      console.log(`  - ${target}`)
+    })
+
+    return this.confirm('确定要执行清理操作吗？', false, false)
+  }
+
+  // 服务启动确认（用于可能有端口冲突的情况）
+  async confirmServiceStart(service, port, skipFlag = false) {
+    if (this.isAutoYes(skipFlag)) {
+      return true
+    }
+
+    return this.confirm(`确定要启动 ${service} 服务 (端口 ${port}) 吗？`, true, false)
+  }
+
+  // 版本发布确认
+  async confirmRelease(version, isProduction = false, skipFlag = false) {
+    if (this.isAutoYes(skipFlag)) {
+      logger.info(`跳过版本发布确认: ${version}`)
+      return true
+    }
+
+    if (isProduction) {
+      logger.warn(`即将发布生产版本: ${version}`)
+      logger.warn('此操作将创建正式发布标签')
+      return this.confirmDangerous(`发布版本 ${version}`, '生产环境', false)
+    } else {
+      return this.confirm(`确定要发布开发版本 ${version} 吗？`, true, false)
+    }
+  }
+
+  // 数据库操作确认
+  async confirmDatabaseOperation(operation, environment, skipFlag = false) {
+    const dangerousOps = ['reset', 'drop', 'migrate:reset', 'db:reset']
+    const isDangerous = dangerousOps.some(op => operation.includes(op))
+
+    if (isDangerous) {
+      return this.confirmDangerous(
+        `数据库操作: ${operation}`,
+        environment,
+        this.isAutoYes(skipFlag),
+      )
+    } else {
+      if (this.isAutoYes(skipFlag)) {
+        return true
+      }
+      return this.confirm(`确定要执行数据库操作: ${operation} (${environment}) 吗？`, true, false)
+    }
+  }
+}
+
+export const confirmManager = new ConfirmManager()

package/lib/env-policy.js

@@ -0,0 +1,134 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import stripJsonComments from 'strip-json-comments'
+
+const DEFAULT_POLICY_PATH = 'env-policy.jsonc'
+
+let cachedPolicy = null
+let cachedPolicyDir = null
+
+function assertStringArray(value, fieldPath) {
+  if (!Array.isArray(value)) {
+    throw new Error(`${fieldPath} 必须是数组`)
+  }
+  const invalid = value.filter(v => typeof v !== 'string' || v.trim().length === 0)
+  if (invalid.length > 0) {
+    throw new Error(`${fieldPath} 中存在非法值，请使用非空字符串`)
+  }
+}
+
+function assertRecord(value, fieldPath) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`${fieldPath} 必须是对象`)
+  }
+}
+
+export function loadEnvPolicy(configDir) {
+  if (cachedPolicy && cachedPolicyDir === configDir) return cachedPolicy
+
+  const policyPath = join(configDir, DEFAULT_POLICY_PATH)
+  if (!existsSync(policyPath)) {
+    throw new Error(
+      `缺少配置文件 ${DEFAULT_POLICY_PATH}。
+请在目标工程根目录创建 dx/config/${DEFAULT_POLICY_PATH}（或用 DX_CONFIG_DIR / --config-dir 指定配置目录）。
+当前配置目录: ${configDir}`,
+    )
+  }
+
+  let parsed
+  try {
+    const raw = readFileSync(policyPath, 'utf8')
+    parsed = JSON.parse(stripJsonComments(raw) || '{}')
+  } catch (error) {
+    throw new Error(`无法解析 ${DEFAULT_POLICY_PATH}: ${error.message}`)
+  }
+
+  validateEnvPolicy(parsed)
+  cachedPolicy = parsed
+  cachedPolicyDir = configDir
+  return cachedPolicy
+}
+
+export function validateEnvPolicy(policy) {
+  assertRecord(policy, 'env-policy')
+
+  if (policy.version !== 1) {
+    throw new Error('env-policy.jsonc.version 必须为 1')
+  }
+
+  assertStringArray(policy.environments, 'env-policy.jsonc.environments')
+
+  if (typeof policy.secretPlaceholder !== 'string' || policy.secretPlaceholder.trim().length === 0) {
+    throw new Error('env-policy.jsonc.secretPlaceholder 必须为非空字符串')
+  }
+
+  assertRecord(policy.keys, 'env-policy.jsonc.keys')
+  assertStringArray(policy.keys.secret || [], 'env-policy.jsonc.keys.secret')
+  assertStringArray(policy.keys.localOnly || [], 'env-policy.jsonc.keys.localOnly')
+  assertStringArray(policy.keys.localOverride || [], 'env-policy.jsonc.keys.localOverride')
+
+  assertRecord(policy.layout, 'env-policy.jsonc.layout')
+  assertStringArray(policy.layout.forbidExact || [], 'env-policy.jsonc.layout.forbidExact')
+  assertStringArray(policy.layout.allowRoot || [], 'env-policy.jsonc.layout.allowRoot')
+  assertStringArray(policy.layout.allowSubdirGlobs || [], 'env-policy.jsonc.layout.allowSubdirGlobs')
+
+  assertRecord(policy.appToTarget || {}, 'env-policy.jsonc.appToTarget')
+  for (const [app, target] of Object.entries(policy.appToTarget || {})) {
+    if (typeof app !== 'string' || app.trim().length === 0) {
+      throw new Error('env-policy.jsonc.appToTarget 中存在非法 app key')
+    }
+    if (typeof target !== 'string' || target.trim().length === 0) {
+      throw new Error('env-policy.jsonc.appToTarget 中存在非法 target value')
+    }
+  }
+
+  assertRecord(policy.targets, 'env-policy.jsonc.targets')
+  const targetIds = Object.keys(policy.targets)
+  if (targetIds.length === 0) {
+    throw new Error('env-policy.jsonc.targets 不能为空')
+  }
+
+  for (const [targetId, target] of Object.entries(policy.targets)) {
+    if (typeof targetId !== 'string' || targetId.trim().length === 0) {
+      throw new Error('env-policy.jsonc.targets 中存在非法 targetId')
+    }
+    assertRecord(target, `env-policy.jsonc.targets.${targetId}`)
+    assertRecord(target.files, `env-policy.jsonc.targets.${targetId}.files`)
+    if (typeof target.files.committed !== 'string' || target.files.committed.trim().length === 0) {
+      throw new Error(`env-policy.jsonc.targets.${targetId}.files.committed 必须为非空字符串`)
+    }
+    if (typeof target.files.local !== 'string' || target.files.local.trim().length === 0) {
+      throw new Error(`env-policy.jsonc.targets.${targetId}.files.local 必须为非空字符串`)
+    }
+    assertRecord(target.required || {}, `env-policy.jsonc.targets.${targetId}.required`)
+
+    for (const [group, keys] of Object.entries(target.required || {})) {
+      assertStringArray(keys, `env-policy.jsonc.targets.${targetId}.required.${group}`)
+    }
+  }
+
+  // Ensure appToTarget does not point to missing targets.
+  for (const [app, target] of Object.entries(policy.appToTarget || {})) {
+    if (!policy.targets[target]) {
+      throw new Error(
+        `env-policy.jsonc.appToTarget.${app} 指向不存在的 target: ${target}（请在 env-policy.jsonc.targets 中定义）`,
+      )
+    }
+  }
+}
+
+export function resolvePolicyTargetId(policy, app) {
+  if (!policy || !app) return null
+  const mapped = policy.appToTarget?.[app]
+  return mapped || null
+}
+
+export function resolveTargetRequiredVars(policy, targetId, environment) {
+  if (!policy || !targetId) return []
+  const target = policy.targets?.[targetId]
+  if (!target) return []
+  const required = target.required || {}
+  const common = Array.isArray(required._common) ? required._common : []
+  const envSpecific = Array.isArray(required[environment]) ? required[environment] : []
+  return Array.from(new Set([...common, ...envSpecific]))
+}