backend-claude-code 1.0.0

package/commands/dev-run.md

@@ -0,0 +1,385 @@
+---
+description: Execute an implementation plan with rigorous validation loops
+argument-hint: <path/to/plan.md>
+---
+
+> Adapted from PRPs-agentic-eng by Wirasm. Part of the PRP workflow series.
+
+# PRP Implement
+
+Execute a plan file step-by-step with continuous validation. Every change is verified immediately — never accumulate broken state.
+
+**Core Philosophy**: Validation loops catch mistakes early. Run checks after every change. Fix issues immediately.
+
+**Golden Rule**: If a validation fails, fix it before moving on. Never accumulate broken state.
+
+---
+
+## Phase 0 — DETECT
+
+### Package Manager Detection
+
+| File Exists | Package Manager | Runner |
+|---|---|---|
+| `bun.lockb` | bun | `bun run` |
+| `pnpm-lock.yaml` | pnpm | `pnpm run` |
+| `yarn.lock` | yarn | `yarn` |
+| `package-lock.json` | npm | `npm run` |
+| `pyproject.toml` or `requirements.txt` | uv / pip | `uv run` or `python -m` |
+| `Cargo.toml` | cargo | `cargo` |
+| `go.mod` | go | `go` |
+
+### Validation Scripts
+
+Check `package.json` (or equivalent) for available scripts:
+
+```bash
+# For Node.js projects
+cat package.json | grep -A 20 '"scripts"'
+```
+
+Note available commands for: type-check, lint, test, build.
+
+---
+
+## Phase 1 — LOAD
+
+Read the plan file:
+
+```bash
+cat "$ARGUMENTS"
+```
+
+Extract these sections from the plan:
+- **Summary** — What is being built
+- **Patterns to Mirror** — Code conventions to follow
+- **Files to Change** — What to create or modify
+- **Step-by-Step Tasks** — Implementation sequence
+- **Validation Commands** — How to verify correctness
+- **Acceptance Criteria** — Definition of done
+
+If the file doesn't exist or isn't a valid plan:
+```
+Error: Plan file not found or invalid.
+Run /dev plan <feature-description> to create a plan first.
+```
+
+**CHECKPOINT**: Plan loaded. All sections identified. Tasks extracted.
+
+---
+
+## Phase 2 — PREPARE
+
+### Git State
+
+```bash
+git branch --show-current
+git status --porcelain
+```
+
+### Branch Decision
+
+| Current State | Action |
+|---|---|
+| On feature branch | Use current branch |
+| On main, clean working tree | Create feature branch: `git checkout -b feat/{plan-name}` |
+| On main, dirty working tree | **STOP** — Ask user to stash or commit first |
+| In a git worktree for this feature | Use the worktree |
+
+### Sync Remote
+
+```bash
+git pull --rebase origin $(git branch --show-current) 2>/dev/null || true
+```
+
+**CHECKPOINT**: On correct branch. Working tree ready. Remote synced.
+
+---
+
+## Phase 3 — EXECUTE
+
+Process each task from the plan sequentially.
+
+### Per-Task Loop
+
+For each task in **Step-by-Step Tasks**:
+
+1. **Read MIRROR reference** — Open the pattern file referenced in the task's MIRROR field. Understand the convention before writing code.
+
+2. **Implement** — Write the code following the pattern exactly. Apply GOTCHA warnings. Use specified IMPORTS.
+
+3. **Validate immediately** — After EVERY file change:
+   ```bash
+   # Run type-check (adjust command per project)
+   [type-check command from Phase 0]
+   ```
+   If type-check fails → fix the error before moving to the next file.
+
+4. **Track progress** — Log: `[done] Task N: [task name] — complete`
+
+### Handling Deviations
+
+If implementation must deviate from the plan:
+- Note **WHAT** changed
+- Note **WHY** it changed
+- Continue with the corrected approach
+- These deviations will be captured in the report
+
+**CHECKPOINT**: All tasks executed. Deviations logged.
+
+---
+
+## Phase 4 — VALIDATE
+
+Run all validation levels from the plan. Fix issues at each level before proceeding.
+
+### Level 1: Static Analysis
+
+```bash
+# Type checking — zero errors required
+[project type-check command]
+
+# Linting — fix automatically where possible
+[project lint command]
+[project lint-fix command]
+```
+
+If lint errors remain after auto-fix, fix manually.
+
+### Level 2: Unit Tests
+
+Write tests for every new function (as specified in the plan's Testing Strategy).
+
+```bash
+[project test command for affected area]
+```
+
+- Every function needs at least one test
+- Cover edge cases listed in the plan
+- If a test fails → fix the implementation (not the test, unless the test is wrong)
+
+### Level 3: Build Check
+
+```bash
+[project build command]
+```
+
+Build must succeed with zero errors.
+
+### Level 4: Integration Testing (if applicable)
+
+```bash
+# Start server, run tests, stop server
+[project dev server command] &
+SERVER_PID=$!
+
+# Wait for server to be ready (adjust port as needed)
+SERVER_READY=0
+for i in $(seq 1 30); do
+  if curl -sf http://localhost:PORT/health >/dev/null 2>&1; then
+    SERVER_READY=1
+    break
+  fi
+  sleep 1
+done
+
+if [ "$SERVER_READY" -ne 1 ]; then
+  kill "$SERVER_PID" 2>/dev/null || true
+  echo "ERROR: Server failed to start within 30s" >&2
+  exit 1
+fi
+
+[integration test command]
+TEST_EXIT=$?
+
+kill "$SERVER_PID" 2>/dev/null || true
+wait "$SERVER_PID" 2>/dev/null || true
+
+exit "$TEST_EXIT"
+```
+
+### Level 5: Edge Case Testing
+
+Run through edge cases from the plan's Testing Strategy checklist.
+
+**CHECKPOINT**: All 5 validation levels pass. Zero errors.
+
+---
+
+## Phase 5 — REPORT
+
+### Create Implementation Report
+
+```bash
+mkdir -p .claude/PRPs/reports
+```
+
+Write report to `.claude/PRPs/reports/{plan-name}-report.md`:
+
+```markdown
+# Implementation Report: [Feature Name]
+
+## Summary
+[What was implemented]
+
+## Assessment vs Reality
+
+| Metric | Predicted (Plan) | Actual |
+|---|---|---|
+| Complexity | [from plan] | [actual] |
+| Confidence | [from plan] | [actual] |
+| Files Changed | [from plan] | [actual count] |
+
+## Tasks Completed
+
+| # | Task | Status | Notes |
+|---|---|---|---|
+| 1 | [task name] | [done] Complete | |
+| 2 | [task name] | [done] Complete | Deviated — [reason] |
+
+## Validation Results
+
+| Level | Status | Notes |
+|---|---|---|
+| Static Analysis | [done] Pass | |
+| Unit Tests | [done] Pass | N tests written |
+| Build | [done] Pass | |
+| Integration | [done] Pass | or N/A |
+| Edge Cases | [done] Pass | |
+
+## Files Changed
+
+| File | Action | Lines |
+|---|---|---|
+| `path/to/file` | CREATED | +N |
+| `path/to/file` | UPDATED | +N / -M |
+
+## Deviations from Plan
+[List any deviations with WHAT and WHY, or "None"]
+
+## Issues Encountered
+[List any problems and how they were resolved, or "None"]
+
+## Tests Written
+
+| Test File | Tests | Coverage |
+|---|---|---|
+| `path/to/test` | N tests | [area covered] |
+
+## Next Steps
+- [ ] Code review via `/code-review`
+- [ ] Create PR via `/git pr`
+```
+
+### Update PRD (if applicable)
+
+If this implementation was for a PRD phase:
+1. Update the phase status from `in-progress` to `complete`
+2. Add report path as reference
+
+### Archive Plan
+
+```bash
+mkdir -p .claude/PRPs/plans/completed
+mv "$ARGUMENTS" .claude/PRPs/plans/completed/
+```
+
+**CHECKPOINT**: Report created. PRD updated. Plan archived.
+
+---
+
+## Phase 6 — OUTPUT
+
+Report to user:
+
+```
+## Implementation Complete
+
+- **Plan**: [plan file path] → archived to completed/
+- **Branch**: [current branch name]
+- **Status**: [done] All tasks complete
+
+### Validation Summary
+
+| Check | Status |
+|---|---|
+| Type Check | [done] |
+| Lint | [done] |
+| Tests | [done] (N written) |
+| Build | [done] |
+| Integration | [done] or N/A |
+
+### Files Changed
+- [N] files created, [M] files updated
+
+### Deviations
+[Summary or "None — implemented exactly as planned"]
+
+### Artifacts
+- Report: `.claude/PRPs/reports/{name}-report.md`
+- Archived Plan: `.claude/PRPs/plans/completed/{name}.plan.md`
+
+### PRD Progress (if applicable)
+| Phase | Status |
+|---|---|
+| Phase 1 | [done] Complete |
+| Phase 2 | [next] |
+| ... | ... |
+
+> Next step: Run `/git pr` to create a pull request, or `/code-review` to review changes first.
+```
+
+---
+
+## Handling Failures
+
+### Type Check Fails
+1. Read the error message carefully
+2. Fix the type error in the source file
+3. Re-run type-check
+4. Continue only when clean
+
+### Tests Fail
+1. Identify whether the bug is in the implementation or the test
+2. Fix the root cause (usually the implementation)
+3. Re-run tests
+4. Continue only when green
+
+### Lint Fails
+1. Run auto-fix first
+2. If errors remain, fix manually
+3. Re-run lint
+4. Continue only when clean
+
+### Build Fails
+1. Usually a type or import issue — check error message
+2. Fix the offending file
+3. Re-run build
+4. Continue only when successful
+
+### Integration Test Fails
+1. Check server started correctly
+2. Verify endpoint/route exists
+3. Check request format matches expected
+4. Fix and re-run
+
+---
+
+## Success Criteria
+
+- **TASKS_COMPLETE**: All tasks from the plan executed
+- **TYPES_PASS**: Zero type errors
+- **LINT_PASS**: Zero lint errors
+- **TESTS_PASS**: All tests green, new tests written
+- **BUILD_PASS**: Build succeeds
+- **REPORT_CREATED**: Implementation report saved
+- **PLAN_ARCHIVED**: Plan moved to `completed/`
+
+---
+
+## Next Steps
+
+- Run `/code-review` to review changes before committing
+- Run `/git commit` to commit with a descriptive message
+- Run `/git pr` to create a pull request
+- Run `/dev plan <next-phase>` if the PRD has more phases

package/commands/dev-test.md

@@ -0,0 +1,89 @@
+---
+description: Java TDD 워크플로우 — 테스트 먼저 작성하고 Spring Boot 기능을 구현합니다
+argument-hint: <feature, class, or method to test>
+---
+
+# Java TDD
+
+**Feature**: $ARGUMENTS
+
+---
+
+## 개요
+
+Spring Boot TDD 워크플로우: RED → GREEN → REFACTOR → COVERAGE
+
+---
+
+## Phase 1 — PLAN
+
+`$ARGUMENTS`를 분석:
+1. 어떤 계층을 테스트하는가? (서비스/컨트롤러/레포지토리)
+2. 정상 경로 (happy path)는?
+3. 실패 케이스 (에러/엣지케이스)는?
+4. 필요한 모의 객체 (Mock)는?
+
+**복잡한 기능**이면 먼저 `planner` 에이전트로 구현 계획 수립.
+
+## Phase 2 — RED (테스트 작성)
+
+`tdd-guide` 에이전트로 테스트 작성:
+
+### 테스트 슬라이스 선택
+- 서비스 로직 → `@ExtendWith(MockitoExtension.class)`
+- 컨트롤러/API → `@WebMvcTest`
+- JPA 레포지토리 → `@DataJpaTest`
+- 통합 → `@SpringBootTest`
+
+### 테스트 실행 (실패 확인)
+```bash
+./mvnw test -Dtest=<TestClassName> -q 2>&1 | tail -20 || \
+./gradlew test --tests "<full.package.TestClassName>" 2>&1 | tail -20
+```
+
+실패 확인 — 테스트가 통과하면 이미 구현이 있거나 테스트가 잘못됨.
+
+## Phase 3 — GREEN (최소 구현)
+
+테스트를 통과하는 최소한의 코드 작성:
+- 과도한 구현 금지
+- 리팩토링 금지 (이 단계에서)
+
+```bash
+# 테스트 재실행
+./mvnw test -Dtest=<TestClassName> -q 2>&1 | tail -10
+```
+
+모든 테스트 통과 확인.
+
+## Phase 4 — REFACTOR
+
+테스트 통과 상태에서:
+1. 중복 제거
+2. 명명 개선
+3. 메서드 분리
+4. 매 변경 후 테스트 재실행
+
+```bash
+./mvnw test -q 2>&1 | tail -5
+```
+
+## Phase 5 — COVERAGE
+
+```bash
+./mvnw test jacoco:report -q 2>&1 | tail -5
+./gradlew test jacocoTestReport 2>&1 | tail -5
+```
+
+80% 미만이면 누락된 경로 테스트 추가.
+
+## Output
+
+```
+TDD Cycle — <기능명>
+Tests Written: N
+RED: FAIL (확인됨)
+GREEN: PASS
+Coverage: XX%
+Status: COMPLETE | NEEDS_MORE_TESTS
+```

package/commands/dev-verify.md

@@ -0,0 +1,95 @@
+---
+description: Spring Boot 전체 검증 파이프라인 — 빌드·정적 분석·테스트·커버리지·보안 스캔 순차 실행
+argument-hint: [--fast | --full | blank for standard]
+---
+
+# Verify
+
+Spring Boot 프로젝트의 전체 품질 게이트를 순차적으로 실행합니다.
+
+**Mode**: $ARGUMENTS
+- 빈 값 / `--standard`: 빌드 + 테스트 + 커버리지
+- `--fast`: 빌드 + 테스트만 (커버리지·보안 스킵)
+- `--full`: 빌드 + 테스트 + 커버리지 + 보안 스캔 + 정적 분석
+
+---
+
+## Phase 1 — BUILD
+
+```bash
+./mvnw compile -q --no-transfer-progress 2>&1 | tail -5 || \
+./gradlew compileJava -q 2>&1 | tail -5
+```
+
+실패 시 즉시 중단 → `/dev build` 실행 권장.
+
+## Phase 2 — STATIC ANALYSIS
+
+`--fast` 모드는 건너뜀.
+
+```bash
+# Checkstyle
+./mvnw checkstyle:check -q 2>&1 | tail -5 || \
+./gradlew checkstyleMain -q 2>&1 | tail -5
+
+# SpotBugs
+./mvnw spotbugs:check -q 2>&1 | tail -5 || \
+./gradlew spotbugsMain -q 2>&1 | tail -5
+```
+
+오류 있으면 파일·라인·규칙 보고. 계속 진행 (차단하지 않음).
+
+## Phase 3 — TEST + COVERAGE
+
+```bash
+./mvnw test -q --no-transfer-progress 2>&1 | tail -10 || \
+./gradlew test -q 2>&1 | tail -10
+```
+
+테스트 실패 시 실패한 테스트 목록 보고 후 중단.
+
+커버리지 리포트 생성:
+```bash
+./mvnw jacoco:report -q 2>&1 || \
+./gradlew jacocoTestReport -q 2>&1
+
+# 커버리지 수치 확인
+grep -A3 "LINE" target/site/jacoco/index.html 2>/dev/null | \
+  grep -oP '\d+%' | head -1 || echo "커버리지 리포트를 찾을 수 없습니다"
+```
+
+80% 미만이면 경고.
+
+## Phase 4 — SECURITY SCAN
+
+`--full` 모드에서만 실행.
+
+```bash
+# OWASP Dependency Check
+./mvnw dependency-check:check -q 2>&1 | grep -E "CRITICAL|HIGH|One or more" | head -10 || \
+./gradlew dependencyCheckAnalyze -q 2>&1 | grep -E "CRITICAL|HIGH" | head -10
+```
+
+CRITICAL 취약점 발견 시 → `security-reviewer` 에이전트 실행 권장.
+
+## Phase 5 — SUMMARY REPORT
+
+```
+Verify — <날짜>  Mode: standard | fast | full
+────────────────────────────────────────────
+Phase 1  Build              PASS | FAIL
+Phase 2  Static Analysis    PASS | FAIL | SKIP   (N issues)
+Phase 3  Tests              PASS | FAIL           (N/N passed)
+         Coverage           XX%  (≥80% required)
+Phase 4  Security Scan      PASS | FAIL | SKIP   (N CVEs)
+────────────────────────────────────────────
+Overall: PASS | FAIL
+
+Next steps:
+  - FAIL Build    → /dev build
+  - FAIL Tests    → /java-test
+  - Low Coverage  → /test-coverage
+  - CVEs found    → security-reviewer 에이전트
+```
+
+> 상세 검증 패턴은 `skill: springboot-verification` 참조.

package/commands/dev.md

@@ -0,0 +1,45 @@
+---
+description: 기능 개발 전체 워크플로우 — 계획 → 구현 → 테스트 순서로 실행
+argument-hint: <기능 설명>
+---
+
+# Dev
+
+**Input**: $ARGUMENTS — 구현할 기능 설명
+
+`/dev plan` → `/dev run` → `/dev test` 를 순서대로 실행합니다.
+
+---
+
+## Step 1 — PLAN
+
+`/dev plan $ARGUMENTS` 실행.
+
+구현 계획서가 완성되면 사용자에게 확인을 받는다.
+계획이 승인되면 Step 2로 진행한다.
+
+## Step 2 — RUN
+
+`/dev run <계획서 경로>` 실행.
+
+구현이 완료되고 빌드가 통과되면 Step 3으로 진행한다.
+
+## Step 3 — TEST
+
+`/dev test` 실행.
+
+테스트가 통과되고 커버리지 80%+ 확인되면 완료를 보고한다.
+
+---
+
+## 완료 리포트
+
+```
+Dev — <기능명>
+─────────────────────────
+Plan    DONE  <계획서 경로>
+Run     DONE  <변경 파일 수>개 파일
+Test    DONE  <테스트 수>개 통과 / 커버리지 XX%
+─────────────────────────
+Next: /git commit → /git pr
+```