ccjk 16.0.6 → 16.3.0

package/templates/common/output-styles/en/agents-md-baseline.md

@@ -0,0 +1,28 @@
+---
+name: agents-md-baseline
+description: OpenAI Codex AGENTS.md engineering baseline - verify loops, minimal diffs, risky-op confirmation
+---
+
+# AGENTS.md Engineering Baseline
+
+> Based on the [OpenAI Codex AGENTS.md guide](https://developers.openai.com/codex/guides/agents-md) and community best practices.
+
+## Working agreements
+
+- **Read before edit**: Review relevant code, tests, and project docs (e.g. `ARCHITECTURE.md`, `docs/`) before changing anything.
+- **Minimal diffs**: Change only what the task requires; no drive-by refactors or unrelated cleanup.
+- **Verify loop**: After edits, run the project's smallest relevant checks (`pnpm test`, `pnpm lint`, `npm test`, etc.); fix failures before moving on.
+- **Confirm risky ops**: Get explicit approval before deleting files, force git operations, production config changes, or bulk dependency updates.
+- **Paths and commands**: Quote file paths; prefer the package manager and scripts documented in the repo.
+
+## Output style
+
+- Lead with conclusions; keep steps clear; avoid filler.
+- Reference code with `path:line` when possible.
+- Investigate or ask when unsure — do not guess APIs or layout.
+
+## Collaboration
+
+- Match existing naming, structure, and test patterns.
+- Explain rationale before new dependencies or large-scope changes.
+- End tasks with a short summary of what changed and how it was verified.

package/templates/common/output-styles/en/plan-first.md

@@ -0,0 +1,30 @@
+---
+name: plan-first
+description: OpenAI Codex recommended - plan before coding; clarify Goal/Context/Constraints/Done-when
+---
+
+# Plan-First Engineering Style
+
+> From [Codex Best Practices](https://developers.openai.com/codex/learn/best-practices) — plan before implementing complex, ambiguous, or multi-step work.
+
+## Four task anchors
+
+Align on these before acting:
+
+1. **Goal** — What outcome is required?
+2. **Context** — Which files, dirs, docs, or errors matter?
+3. **Constraints** — Architecture, safety, style, and boundaries?
+4. **Done when** — What must be true to finish? (tests pass, behavior changes, bug gone)
+
+## Planning discipline
+
+- Multi-file changes, architecture decisions, unclear requirements: **plan first, code second**.
+- Plans cover scope, step order, verification, and risks.
+- Implement only after the plan is sound; explain deviations before continuing.
+- Split large work into verifiable steps with clear done criteria.
+
+## Coding
+
+- Execute the smallest planned step; no unplanned refactors.
+- Revise the plan when reality changes — do not brute-force around it.
+- Cite code as `path:line` for reviewability.

package/templates/common/output-styles/en/surgical-diff.md

@@ -0,0 +1,27 @@
+---
+name: surgical-diff
+description: Community consensus (Karpathy/senior maintainers) - surgical minimal diffs, understand before editing
+---
+
+# Surgical-Diff Engineering Style
+
+> Shared discipline for effective agents: smaller, well-scoped diffs win. Aligns with OpenAI Codex repo maintenance practice and community “surgical edit” norms.
+
+## Core rules
+
+- **Read before edit** — No changes without reading relevant code, tests, and callers.
+- **Minimal diff** — Only lines the task requires; no drive-by refactors, unrelated formatting, or comment deletes.
+- **Single intent** — One PR-sized purpose per task; no unrelated fixes bundled in.
+- **Reuse first** — Extend existing functions and patterns; do not parallel-reimplement.
+
+## Avoid
+
+- Broad renames “for cleanliness”
+- Dependency/CI/config churn without request
+- try-catch that hides failures to green tests
+- Guessing APIs — read code or docs when unsure
+
+## Before done
+
+- Diff size matches task scope; huge changes need a plan first.
+- Every hunk has a one-line “why necessary” rationale.

package/templates/common/output-styles/en/verify-and-ship.md

@@ -0,0 +1,31 @@
+---
+name: verify-and-ship
+description: OpenAI Codex recommended - test/lint/self-review loop before shipping
+---
+
+# Verify-and-Ship Engineering Style
+
+> From [Codex Best Practices](https://developers.openai.com/codex/learn/best-practices) — Codex should test, check, and confirm results, not only generate code.
+
+## Verification loop (required)
+
+After changes, run in order:
+
+1. **Tests** — Run the smallest relevant suite; add tests for new logic.
+2. **Static checks** — Lint, format, typecheck per repo scripts (`pnpm test`, `pnpm lint`, etc.).
+3. **Behavior** — Confirm against the task, not just “it compiles”.
+4. **Diff self-review** — Regressions, edge cases, risky patterns (swallowed errors, secrets).
+
+Fix and repeat until green; only then report done.
+
+## Shipping bar
+
+- Summarize what changed, why, and how it was verified.
+- List commands run and outcomes.
+- If full suite was skipped, say why and what was covered.
+- Do not claim completion until Done-when is met.
+
+## Collaboration
+
+- Use documented package manager and scripts; do not invent commands.
+- Confirm destructive ops; never skip verification.

package/templates/common/output-styles/zh-CN/agents-md-baseline.md

@@ -0,0 +1,28 @@
+---
+name: agents-md-baseline
+description: OpenAI Codex 官方 AGENTS.md 工程基线 - 验证循环、最小改动、危险操作确认
+---
+
+# AGENTS.md 工程基线
+
+> 基于 [OpenAI Codex AGENTS.md 指南](https://developers.openai.com/codex/guides/agents-md) 与社区最佳实践。
+
+## 工作约定
+
+- **先读后改**：动手前阅读相关代码、测试与项目文档（如 `ARCHITECTURE.md`、`docs/`）。
+- **最小改动**：只改完成任务所需的代码，不做无关重构或顺手清理。
+- **验证循环**：改动后运行项目已有的最小验证命令（如 `pnpm test`、`pnpm lint`、`npm test`）；失败则修复后再继续。
+- **危险操作确认**：删除文件、强制 git 操作、改生产配置、批量依赖变更前必须说明影响并征得确认。
+- **路径与命令**：文件路径用引号包裹；优先使用项目文档中记录的包管理器与脚本。
+
+## 输出风格
+
+- 结论先行，步骤清晰，避免空话。
+- 引用代码时用 `文件路径:行号` 格式，便于定位。
+- 不确定时先调查或提问，不猜测 API 或文件结构。
+
+## 协作原则
+
+- 遵循仓库既有命名、目录结构与测试风格。
+- 新依赖或大范围改动前先说明理由。
+- 任务完成时简要说明改了什么、如何验证。

package/templates/common/output-styles/zh-CN/plan-first.md

@@ -0,0 +1,30 @@
+---
+name: plan-first
+description: OpenAI Codex 推荐 - 复杂任务先规划再编码，明确 Goal/Context/Constraints/Done-when
+---
+
+# Plan-First 工程风格
+
+> 来源：[Codex Best Practices](https://developers.openai.com/codex/learn/best-practices) — 复杂、模糊或多步骤任务先规划再动手。
+
+## 任务启动四要素
+
+每次接到任务，先在心里（或输出中）对齐：
+
+1. **Goal**：要达成什么结果？
+2. **Context**：哪些文件、目录、文档、错误信息相关？
+3. **Constraints**：架构、安全、风格、不可触碰的边界是什么？
+4. **Done when**：怎样算完成？（测试通过、行为改变、bug 不再复现）
+
+## 规划纪律
+
+- 多文件改动、架构决策、需求不清时：**先出计划，不写代码**。
+- 计划包含：影响范围、步骤顺序、验证方式、风险点。
+- 计划经确认或自洽后再实施；实施中偏离计划时先说明原因。
+- 大任务可拆为可独立验证的小步，每步有明确完成标准。
+
+## 编码原则
+
+- 按计划的最小步骤推进，不做计划外重构。
+- 发现计划有误时，更新计划再继续，不硬改。
+- 引用代码用 `路径:行号`，便于审查。

package/templates/common/output-styles/zh-CN/surgical-diff.md

@@ -0,0 +1,27 @@
+---
+name: surgical-diff
+description: 社区共识（Karpathy/资深维护者）- 外科手术式最小改动，先理解再动刀
+---
+
+# Surgical-Diff 工程风格
+
+> 高效 agent 的共同纪律：改动越小、上下文越准，结果越稳。参考 OpenAI Codex 官方仓库维护实践与社区「surgical edit」共识。
+
+## 核心纪律
+
+- **先读后改**：不读相关代码、测试、调用方就不改。
+- **最小 diff**：只改完成任务必需的行；禁止顺手重构、格式化无关文件、删无关注释。
+- **单一意图**：一个任务一个 PR 级意图，不混入无关修复。
+- **复用优先**：扩展现有函数/模式，不平行造轮子。
+
+## 禁止
+
+- 大范围重命名「为了好看」
+- 未要求时升级依赖、改 CI、动配置
+- 用 try-catch 吞掉错误来「让测试过」
+- 猜测 API：不确定就查代码或文档
+
+## 完成前
+
+- Diff 行数与任务规模匹配；超大改动需先拆计划。
+- 每条改动能一句话说明「为何必要」。

package/templates/common/output-styles/zh-CN/verify-and-ship.md

@@ -0,0 +1,31 @@
+---
+name: verify-and-ship
+description: OpenAI Codex 推荐 - 测试/静态检查/自审闭环，确认行为后再交付
+---
+
+# Verify-and-Ship 工程风格
+
+> 来源：[Codex Best Practices](https://developers.openai.com/codex/learn/best-practices) — Codex 应测试、检查、确认结果，而非只生成代码。
+
+## 验证闭环（必须）
+
+完成改动后按顺序执行：
+
+1. **测试**：运行与变更相关的最小测试集（单元/集成）；新增逻辑需补测试。
+2. **静态检查**：运行项目已有的 lint、format、typecheck（如 `pnpm test`、`pnpm lint`）。
+3. **行为确认**：对照任务要求验证实际行为，不只「编译通过」。
+4. **Diff 自审**：检查回归、边界条件、危险模式（未处理错误、硬编码密钥等）。
+
+失败则修复并重复闭环，通过后再报告完成。
+
+## 交付标准
+
+- 说明改了什么、为什么、如何验证。
+- 列出已运行的命令及结果。
+- 未跑全量测试时说明原因与已覆盖范围。
+- 不声称「完成」除非 Done-when 条件已满足。
+
+## 协作
+
+- 使用仓库文档中的包管理器与脚本，不臆造命令。
+- 破坏性操作前确认；不跳过验证步骤。

package/templates/common/workflow/bmad/en/bmad-init.md

@@ -0,0 +1,275 @@
+# /bmad-init Command
+
+This command initializes or updates BMad-Method (V6) in your project.
+
+## When this command is invoked:
+
+1. Check if `_bmad/` directory exists to determine if BMad V6 is already installed
+2. Check for legacy V4 installations (`.bmad-core` or `.bmad-method` directories)
+3. Fresh install executes: `npx bmad-method install --directory . --modules bmm --tools claude-code --communication-language English --document-output-language English --yes`
+4. Existing install executes: `npx bmad-method install --directory . --action quick-update --yes`
+5. Fix installer bug: rename `{output_folder}` to `_bmad-output` (Beta known issue)
+6. Automatically update `.gitignore` (remove V4 entries, add V6 entries)
+7. Display installation results and prompt user for next steps
+
+## Implementation
+
+```javascript
+const { execSync } = require('node:child_process')
+const fs = require('node:fs')
+const path = require('node:path')
+
+// Legacy entries to clean from .gitignore
+const LEGACY_GITIGNORE_ENTRIES = [
+  '.bmad-core',
+  '.bmad-method',
+  '.claude/commands/BMad',
+  '{output_folder}',  // v6.0.0-Beta.8 bug artifact
+]
+
+// V6 .gitignore entries
+const V6_GITIGNORE_ENTRIES = [
+  '_bmad/',
+  '_bmad-output/',
+]
+
+// Fix installer bug: {output_folder} not resolved to _bmad-output (v6.0.0-Beta.8)
+function fixOutputFolderBug(cwd) {
+  const buggyPath = path.join(cwd, '{output_folder}')
+  const correctPath = path.join(cwd, '_bmad-output')
+
+  if (!fs.existsSync(buggyPath)) return false
+
+  if (!fs.existsSync(correctPath)) {
+    // _bmad-output doesn't exist, simply rename
+    fs.renameSync(buggyPath, correctPath)
+    console.log('   ✅ {output_folder} → _bmad-output/ (renamed)')
+  } else {
+    // _bmad-output already exists, merge subdirectories then delete
+    const entries = fs.readdirSync(buggyPath, { withFileTypes: true })
+    for (const entry of entries) {
+      const src = path.join(buggyPath, entry.name)
+      const dest = path.join(correctPath, entry.name)
+      if (!fs.existsSync(dest)) {
+        fs.renameSync(src, dest)
+        console.log(`   ✅ Moved ${entry.name} → _bmad-output/`)
+      }
+    }
+    fs.rmSync(buggyPath, { recursive: true, force: true })
+    console.log('   ✅ Removed redundant {output_folder}/')
+  }
+  return true
+}
+
+function updateGitignore(cwd) {
+  const gitignorePath = path.join(cwd, '.gitignore')
+  let content = ''
+  let exists = false
+
+  if (fs.existsSync(gitignorePath)) {
+    content = fs.readFileSync(gitignorePath, 'utf8')
+    exists = true
+  }
+
+  const lines = content.split('\n')
+  let changed = false
+
+  // Remove V4 legacy entries
+  const filtered = lines.filter(line => {
+    const trimmed = line.trim()
+    const isLegacy = LEGACY_GITIGNORE_ENTRIES.some(entry =>
+      trimmed === entry || trimmed === entry + '/' || trimmed === '/' + entry
+    )
+    if (isLegacy) {
+      console.log(`   🗑️  Removing legacy entry: ${trimmed}`)
+      changed = true
+    }
+    return !isLegacy
+  })
+
+  // Add V6 entries
+  const newEntries = []
+  for (const entry of V6_GITIGNORE_ENTRIES) {
+    const entryBase = entry.replace(/\/$/, '')
+    const alreadyExists = filtered.some(line => {
+      const trimmed = line.trim()
+      return trimmed === entry || trimmed === entryBase || trimmed === '/' + entryBase
+    })
+    if (!alreadyExists) {
+      newEntries.push(entry)
+      console.log(`   ✅ Adding new entry: ${entry}`)
+      changed = true
+    }
+  }
+
+  if (!changed) {
+    console.log('   ℹ️  .gitignore is up to date, no changes needed')
+    return
+  }
+
+  // Build new content
+  let result = filtered.join('\n')
+
+  if (newEntries.length > 0) {
+    // Ensure trailing newline, then add BMad section
+    if (result.length > 0 && !result.endsWith('\n')) {
+      result += '\n'
+    }
+    result += '\n# BMad Method V6\n'
+    result += newEntries.join('\n') + '\n'
+  }
+
+  fs.writeFileSync(gitignorePath, result, 'utf8')
+  console.log(`   📝 .gitignore ${exists ? 'updated' : 'created'}`)
+}
+
+async function initBmad() {
+  const cwd = process.cwd()
+  const bmadV6Path = path.join(cwd, '_bmad')
+  const legacyCorePath = path.join(cwd, '.bmad-core')
+  const legacyMethodPath = path.join(cwd, '.bmad-method')
+
+  // Check for legacy V4 installation
+  const hasLegacyCore = fs.existsSync(legacyCorePath)
+  const hasLegacyMethod = fs.existsSync(legacyMethodPath)
+
+  if (hasLegacyCore || hasLegacyMethod) {
+    console.log('⚠️  Legacy BMad V4 installation detected:')
+    if (hasLegacyCore) console.log('   • .bmad-core/ (V4 core directory)')
+    if (hasLegacyMethod) console.log('   • .bmad-method/ (V4 method directory)')
+    console.log('')
+    console.log('📌 The V6 installer will handle legacy migration automatically. Follow the prompts during installation.')
+    console.log('   Details: https://bmad-code-org.github.io/BMAD-METHOD/docs/how-to/upgrade-to-v6')
+    console.log('')
+  }
+
+  // Check if V6 is already installed
+  const hasV6 = fs.existsSync(bmadV6Path)
+
+  // Build non-interactive install command
+  let installCmd
+  if (hasV6) {
+    console.log('🔄 Existing BMad V6 installation detected, performing quick update...')
+    console.log('')
+    installCmd = [
+      'npx bmad-method install',
+      '--directory .',
+      '--action quick-update',
+      '--yes',
+    ].join(' ')
+  } else {
+    console.log('🚀 Initializing BMad-Method V6...')
+    console.log('')
+    installCmd = [
+      'npx bmad-method install',
+      '--directory .',
+      '--modules bmm',
+      '--tools claude-code',
+      '--communication-language English',
+      '--document-output-language English',
+      '--yes',
+    ].join(' ')
+  }
+
+  // Execute installation
+  try {
+    console.log(`📋 Executing: ${installCmd}`)
+    console.log('')
+    execSync(installCmd, {
+      stdio: 'inherit',
+      cwd: cwd,
+      shell: true
+    })
+
+    console.log('')
+    console.log('✅ BMad-Method V6 installation/update complete!')
+    console.log('')
+    console.log('═══════════════════════════════════════════════════════════════')
+    console.log('📌 IMPORTANT: Please restart your AI IDE to load BMad extensions')
+    console.log('═══════════════════════════════════════════════════════════════')
+    console.log('')
+    // Fix {output_folder} bug (v6.0.0-Beta.8)
+    console.log('🔧 Checking for known installer issues...')
+    try {
+      const fixed = fixOutputFolderBug(cwd)
+      if (!fixed) console.log('   ℹ️  No fixes needed')
+    } catch (err) {
+      console.log(`   ⚠️  Failed to fix {output_folder}: ${err.message}`)
+      console.log('   Please manually rename {output_folder}/ to _bmad-output/')
+    }
+    console.log('')
+
+    console.log('📂 V6 Directory Structure:')
+    console.log('   • _bmad/          — agents, workflows, tasks, and configuration')
+    console.log('   • _bmad-output/   — generated artifact output directory')
+    console.log('')
+
+    // Automatically update .gitignore
+    console.log('🔧 Updating .gitignore...')
+    try {
+      updateGitignore(cwd)
+    } catch (err) {
+      console.log('   ⚠️  Failed to automatically update .gitignore, please manually add _bmad/ and _bmad-output/')
+    }
+    console.log('')
+    console.log('🚀 Quick Start:')
+    console.log('   1. Restart your AI IDE')
+    console.log('   2. Run /bmad-help for guidance and next step suggestions')
+    console.log('   3. Type /bmad and use autocomplete to browse available commands')
+    console.log('')
+    console.log('💡 Common Workflows:')
+    console.log('   • /bmad-help                      — Interactive help')
+    console.log('   • /bmad-bmm-create-prd             — Create Product Requirements Document')
+    console.log('   • /bmad-bmm-create-architecture     — Create Architecture Document')
+    console.log('   • /bmad-bmm-create-epics-and-stories — Create Epics and User Stories')
+    console.log('   • /bmad-bmm-sprint-planning         — Initialize Sprint Planning')
+    console.log('   • /bmad-bmm-dev-story               — Implement User Story')
+
+    // Legacy V4 IDE command cleanup reminder
+    const legacyClaudeAgents = path.join(cwd, '.claude', 'commands', 'BMad', 'agents')
+    const legacyClaudeTasks = path.join(cwd, '.claude', 'commands', 'BMad', 'tasks')
+    if (fs.existsSync(legacyClaudeAgents) || fs.existsSync(legacyClaudeTasks)) {
+      console.log('')
+      console.log('⚠️  Legacy V4 IDE commands detected, consider removing manually:')
+      if (fs.existsSync(legacyClaudeAgents)) console.log('   • .claude/commands/BMad/agents/')
+      if (fs.existsSync(legacyClaudeTasks)) console.log('   • .claude/commands/BMad/tasks/')
+      console.log('   New V6 commands are installed under .claude/commands/bmad/')
+    }
+  }
+  catch (error) {
+    console.error('❌ Installation failed:', error.message)
+    console.log('')
+    console.log('🛠️  Manual Installation Guide:')
+    console.log('   1. Ensure Node.js 20+ is installed')
+    console.log('   2. Non-interactive install:')
+    console.log('      npx bmad-method install --directory . --modules bmm --tools claude-code --communication-language English --document-output-language English --yes')
+    console.log('   3. Quick update existing installation:')
+    console.log('      npx bmad-method install --directory . --action quick-update --yes')
+    console.log('   4. Or interactive install:')
+    console.log('      npx bmad-method install')
+    console.log('')
+    console.log('📖 Documentation:')
+    console.log('   https://bmad-code-org.github.io/BMAD-METHOD/docs/how-to/install-bmad')
+  }
+}
+
+// Execute initialization
+initBmad()
+```
+
+## Usage
+
+Simply type in Claude Code:
+
+```
+/bmad-init
+```
+
+This command will:
+
+1. Detect current installation status (V6 / V4 legacy / not installed)
+2. Fresh install: non-interactively execute `npx bmad-method install --directory . --modules bmm --tools claude-code --communication-language English --document-output-language English --yes`
+3. Existing install: execute `npx bmad-method install --directory . --action quick-update --yes`
+4. Fix `{output_folder}` → `_bmad-output` installer bug
+5. Automatically update `.gitignore` (clean up legacy entries, add V6 entries)
+6. Provide next step suggestions