@cregis-dev/cckit 0.4.0 → 0.5.0

package/templates/ecc/skills/skill-stocktake/scripts/quick-diff.sh

@@ -1,87 +0,0 @@
-#!/usr/bin/env bash
-# quick-diff.sh — compare skill file mtimes against results.json evaluated_at
-# Usage: quick-diff.sh RESULTS_JSON [CWD_SKILLS_DIR]
-# Output: JSON array of changed/new files to stdout (empty [] if no changes)
-#
-# When CWD_SKILLS_DIR is omitted, defaults to $PWD/.claude/skills so the
-# script always picks up project-level skills without relying on the caller.
-#
-# Environment:
-#   SKILL_STOCKTAKE_GLOBAL_DIR   Override ~/.claude/skills (for testing only;
-#                                do not set in production — intended for bats tests)
-#   SKILL_STOCKTAKE_PROJECT_DIR  Override project dir detection (for testing only)
-
-set -euo pipefail
-
-RESULTS_JSON="${1:-}"
-CWD_SKILLS_DIR="${SKILL_STOCKTAKE_PROJECT_DIR:-${2:-$PWD/.claude/skills}}"
-GLOBAL_DIR="${SKILL_STOCKTAKE_GLOBAL_DIR:-$HOME/.claude/skills}"
-
-if [[ -z "$RESULTS_JSON" || ! -f "$RESULTS_JSON" ]]; then
-  echo "Error: RESULTS_JSON not found: ${RESULTS_JSON:-<empty>}" >&2
-  exit 1
-fi
-
-# Validate CWD_SKILLS_DIR looks like a .claude/skills path (defense-in-depth).
-# Only warn when the path exists — a nonexistent path poses no traversal risk.
-if [[ -n "$CWD_SKILLS_DIR" && -d "$CWD_SKILLS_DIR" && "$CWD_SKILLS_DIR" != */.claude/skills* ]]; then
-  echo "Warning: CWD_SKILLS_DIR does not look like a .claude/skills path: $CWD_SKILLS_DIR" >&2
-fi
-
-evaluated_at=$(jq -r '.evaluated_at' "$RESULTS_JSON")
-
-# Fail fast on a missing or malformed evaluated_at rather than producing
-# unpredictable results from ISO 8601 string comparison against "null".
-if [[ ! "$evaluated_at" =~ ^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$ ]]; then
-  echo "Error: invalid or missing evaluated_at in $RESULTS_JSON: $evaluated_at" >&2
-  exit 1
-fi
-
-# Pre-extract known paths from results.json once (O(1) lookup per file instead of O(n*m))
-known_paths=$(jq -r '.skills[].path' "$RESULTS_JSON" 2>/dev/null)
-
-tmpdir=$(mktemp -d)
-# Use a function to avoid embedding $tmpdir in a quoted string (prevents injection
-# if TMPDIR were crafted to contain shell metacharacters).
-_cleanup() { rm -rf "$tmpdir"; }
-trap _cleanup EXIT
-
-# Shared counter across process_dir calls — intentionally NOT local
-i=0
-
-process_dir() {
-  local dir="$1"
-  while IFS= read -r file; do
-    local mtime dp is_new
-    mtime=$(date -u -r "$file" +%Y-%m-%dT%H:%M:%SZ)
-    dp="${file/#$HOME/~}"
-
-    # Check if this file is known to results.json (exact whole-line match to
-    # avoid substring false-positives, e.g. "python-patterns" matching "python-patterns-v2").
-    if echo "$known_paths" | grep -qxF "$dp"; then
-      is_new="false"
-      # Known file: only emit if mtime changed (ISO 8601 string comparison is safe)
-      [[ "$mtime" > "$evaluated_at" ]] || continue
-    else
-      is_new="true"
-      # New file: always emit regardless of mtime
-    fi
-
-    jq -n \
-      --arg path "$dp" \
-      --arg mtime "$mtime" \
-      --argjson is_new "$is_new" \
-      '{path:$path,mtime:$mtime,is_new:$is_new}' \
-      > "$tmpdir/$i.json"
-    i=$((i+1))
-  done < <(find "$dir" -name "*.md" -type f 2>/dev/null | sort)
-}
-
-[[ -d "$GLOBAL_DIR" ]] && process_dir "$GLOBAL_DIR"
-[[ -n "$CWD_SKILLS_DIR" && -d "$CWD_SKILLS_DIR" ]] && process_dir "$CWD_SKILLS_DIR"
-
-if [[ $i -eq 0 ]]; then
-  echo "[]"
-else
-  jq -s '.' "$tmpdir"/*.json
-fi

package/templates/ecc/skills/skill-stocktake/scripts/save-results.sh

@@ -1,56 +0,0 @@
-#!/usr/bin/env bash
-# save-results.sh — merge evaluated skills into results.json with correct UTC timestamp
-# Usage: save-results.sh RESULTS_JSON <<< "$EVAL_JSON"
-#
-# stdin format:
-#   { "skills": {...}, "mode"?: "full"|"quick", "batch_progress"?: {...} }
-#
-# Always sets evaluated_at to current UTC time via `date -u`.
-# Merges stdin .skills into existing results.json (new entries override old).
-# Optionally updates .mode and .batch_progress if present in stdin.
-
-set -euo pipefail
-
-RESULTS_JSON="${1:-}"
-
-if [[ -z "$RESULTS_JSON" ]]; then
-  echo "Error: RESULTS_JSON argument required" >&2
-  echo "Usage: save-results.sh RESULTS_JSON <<< \"\$EVAL_JSON\"" >&2
-  exit 1
-fi
-
-EVALUATED_AT=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-
-# Read eval results from stdin and validate JSON before touching the results file
-input_json=$(cat)
-if ! echo "$input_json" | jq empty 2>/dev/null; then
-  echo "Error: stdin is not valid JSON" >&2
-  exit 1
-fi
-
-if [[ ! -f "$RESULTS_JSON" ]]; then
-  # Bootstrap: create new results.json from stdin JSON + current UTC timestamp
-  echo "$input_json" | jq --arg ea "$EVALUATED_AT" \
-    '. + { evaluated_at: $ea }' > "$RESULTS_JSON"
-  exit 0
-fi
-
-# Merge: new .skills override existing ones; old skills not in input_json are kept.
-# Optionally update .mode and .batch_progress if provided.
-#
-# Use mktemp for a collision-safe temp file (concurrent runs on the same RESULTS_JSON
-# would race on a predictable ".tmp" suffix; random suffix prevents silent overwrites).
-tmp=$(mktemp "${RESULTS_JSON}.XXXXXX")
-trap 'rm -f "$tmp"' EXIT
-
-jq -s \
-  --arg ea "$EVALUATED_AT" \
-  '.[0] as $existing | .[1] as $new |
-   $existing |
-   .evaluated_at = $ea |
-   .skills = ($existing.skills + ($new.skills // {})) |
-   if ($new | has("mode")) then .mode = $new.mode else . end |
-   if ($new | has("batch_progress")) then .batch_progress = $new.batch_progress else . end' \
-  "$RESULTS_JSON" <(echo "$input_json") > "$tmp"
-
-mv "$tmp" "$RESULTS_JSON"

package/templates/ecc/skills/skill-stocktake/scripts/scan.sh

@@ -1,170 +0,0 @@
-#!/usr/bin/env bash
-# scan.sh — enumerate skill files, extract frontmatter and UTC mtime
-# Usage: scan.sh [CWD_SKILLS_DIR]
-# Output: JSON to stdout
-#
-# When CWD_SKILLS_DIR is omitted, defaults to $PWD/.claude/skills so the
-# script always picks up project-level skills without relying on the caller.
-#
-# Environment:
-#   SKILL_STOCKTAKE_GLOBAL_DIR   Override ~/.claude/skills (for testing only;
-#                                do not set in production — intended for bats tests)
-#   SKILL_STOCKTAKE_PROJECT_DIR  Override project dir detection (for testing only)
-
-set -euo pipefail
-
-GLOBAL_DIR="${SKILL_STOCKTAKE_GLOBAL_DIR:-$HOME/.claude/skills}"
-CWD_SKILLS_DIR="${SKILL_STOCKTAKE_PROJECT_DIR:-${1:-$PWD/.claude/skills}}"
-# Path to JSONL file containing tool-use observations (optional; used for usage frequency counts).
-# Override via SKILL_STOCKTAKE_OBSERVATIONS env var if your setup uses a different path.
-OBSERVATIONS="${SKILL_STOCKTAKE_OBSERVATIONS:-$HOME/.claude/observations.jsonl}"
-
-# Validate CWD_SKILLS_DIR looks like a .claude/skills path (defense-in-depth).
-# Only warn when the path exists — a nonexistent path poses no traversal risk.
-if [[ -n "$CWD_SKILLS_DIR" && -d "$CWD_SKILLS_DIR" && "$CWD_SKILLS_DIR" != */.claude/skills* ]]; then
-  echo "Warning: CWD_SKILLS_DIR does not look like a .claude/skills path: $CWD_SKILLS_DIR" >&2
-fi
-
-# Extract a frontmatter field (handles both quoted and unquoted single-line values).
-# Does NOT support multi-line YAML blocks (| or >) or nested YAML keys.
-extract_field() {
-  local file="$1" field="$2"
-  awk -v f="$field" '
-    BEGIN { fm=0 }
-    /^---$/ { fm++; next }
-    fm==1 {
-      n = length(f) + 2
-      if (substr($0, 1, n) == f ": ") {
-        val = substr($0, n+1)
-        gsub(/^"/, "", val)
-        gsub(/"$/, "", val)
-        print val
-        exit
-      }
-    }
-    fm>=2 { exit }
-  ' "$file"
-}
-
-# Get UTC timestamp N days ago (supports both macOS and GNU date)
-date_ago() {
-  local n="$1"
-  date -u -v-"${n}d" +%Y-%m-%dT%H:%M:%SZ 2>/dev/null ||
-  date -u -d "${n} days ago" +%Y-%m-%dT%H:%M:%SZ
-}
-
-# Count observations matching a file path since a cutoff timestamp
-count_obs() {
-  local file="$1" cutoff="$2"
-  if [[ ! -f "$OBSERVATIONS" ]]; then
-    echo 0
-    return
-  fi
-  jq -r --arg p "$file" --arg c "$cutoff" \
-    'select(.tool=="Read" and .path==$p and .timestamp>=$c) | 1' \
-    "$OBSERVATIONS" 2>/dev/null | wc -l | tr -d ' '
-}
-
-# Scan a directory and produce a JSON array of skill objects
-scan_dir_to_json() {
-  local dir="$1"
-  local c7 c30
-  c7=$(date_ago 7)
-  c30=$(date_ago 30)
-
-  local tmpdir
-  tmpdir=$(mktemp -d)
-  # Use a function to avoid embedding $tmpdir in a quoted string (prevents injection
-  # if TMPDIR were crafted to contain shell metacharacters).
-  local _scan_tmpdir="$tmpdir"
-  _scan_cleanup() { rm -rf "$_scan_tmpdir"; }
-  trap _scan_cleanup RETURN
-
-  # Pre-aggregate observation counts in two passes (one per window) instead of
-  # calling jq per-file — reduces from O(n*m) to O(n+m) jq invocations.
-  local obs_7d_counts obs_30d_counts
-  obs_7d_counts=""
-  obs_30d_counts=""
-  if [[ -f "$OBSERVATIONS" ]]; then
-    obs_7d_counts=$(jq -r --arg c "$c7" \
-      'select(.tool=="Read" and .timestamp>=$c) | .path' \
-      "$OBSERVATIONS" 2>/dev/null | sort | uniq -c)
-    obs_30d_counts=$(jq -r --arg c "$c30" \
-      'select(.tool=="Read" and .timestamp>=$c) | .path' \
-      "$OBSERVATIONS" 2>/dev/null | sort | uniq -c)
-  fi
-
-  local i=0
-  while IFS= read -r file; do
-    local name desc mtime u7 u30 dp
-    name=$(extract_field "$file" "name")
-    desc=$(extract_field "$file" "description")
-    mtime=$(date -u -r "$file" +%Y-%m-%dT%H:%M:%SZ)
-    # Use awk exact field match to avoid substring false-positives from grep -F.
-    # uniq -c output format: "   N /path/to/file" — path is always field 2.
-    u7=$(echo "$obs_7d_counts" | awk -v f="$file" '$2 == f {print $1}' | head -1)
-    u7="${u7:-0}"
-    u30=$(echo "$obs_30d_counts" | awk -v f="$file" '$2 == f {print $1}' | head -1)
-    u30="${u30:-0}"
-    dp="${file/#$HOME/~}"
-
-    jq -n \
-      --arg path "$dp" \
-      --arg name "$name" \
-      --arg description "$desc" \
-      --arg mtime "$mtime" \
-      --argjson use_7d "$u7" \
-      --argjson use_30d "$u30" \
-      '{path:$path,name:$name,description:$description,use_7d:$use_7d,use_30d:$use_30d,mtime:$mtime}' \
-      > "$tmpdir/$i.json"
-    i=$((i+1))
-  done < <(find "$dir" -name "*.md" -type f 2>/dev/null | sort)
-
-  if [[ $i -eq 0 ]]; then
-    echo "[]"
-  else
-    jq -s '.' "$tmpdir"/*.json
-  fi
-}
-
-# --- Main ---
-
-global_found="false"
-global_count=0
-global_skills="[]"
-
-if [[ -d "$GLOBAL_DIR" ]]; then
-  global_found="true"
-  global_skills=$(scan_dir_to_json "$GLOBAL_DIR")
-  global_count=$(echo "$global_skills" | jq 'length')
-fi
-
-project_found="false"
-project_path=""
-project_count=0
-project_skills="[]"
-
-if [[ -n "$CWD_SKILLS_DIR" && -d "$CWD_SKILLS_DIR" ]]; then
-  project_found="true"
-  project_path="$CWD_SKILLS_DIR"
-  project_skills=$(scan_dir_to_json "$CWD_SKILLS_DIR")
-  project_count=$(echo "$project_skills" | jq 'length')
-fi
-
-# Merge global + project skills into one array
-all_skills=$(jq -s 'add' <(echo "$global_skills") <(echo "$project_skills"))
-
-jq -n \
-  --arg global_found "$global_found" \
-  --argjson global_count "$global_count" \
-  --arg project_found "$project_found" \
-  --arg project_path "$project_path" \
-  --argjson project_count "$project_count" \
-  --argjson skills "$all_skills" \
-  '{
-    scan_summary: {
-      global: { found: ($global_found == "true"), count: $global_count },
-      project: { found: ($project_found == "true"), path: $project_path, count: $project_count }
-    },
-    skills: $skills
-  }'

package/templates/ecc/skills/springboot-patterns/SKILL.md

@@ -1,314 +0,0 @@
----
-name: springboot-patterns
-description: Spring Boot architecture patterns, REST API design, layered services, data access, caching, async processing, and logging. Use for Java Spring Boot backend work.
-origin: ECC
----
-
-# Spring Boot Development Patterns
-
-Spring Boot architecture and API patterns for scalable, production-grade services.
-
-## When to Activate
-
-- Building REST APIs with Spring MVC or WebFlux
-- Structuring controller → service → repository layers
-- Configuring Spring Data JPA, caching, or async processing
-- Adding validation, exception handling, or pagination
-- Setting up profiles for dev/staging/production environments
-- Implementing event-driven patterns with Spring Events or Kafka
-
-## REST API Structure
-
-```java
-@RestController
-@RequestMapping("/api/markets")
-@Validated
-class MarketController {
-  private final MarketService marketService;
-
-  MarketController(MarketService marketService) {
-    this.marketService = marketService;
-  }
-
-  @GetMapping
-  ResponseEntity<Page<MarketResponse>> list(
-      @RequestParam(defaultValue = "0") int page,
-      @RequestParam(defaultValue = "20") int size) {
-    Page<Market> markets = marketService.list(PageRequest.of(page, size));
-    return ResponseEntity.ok(markets.map(MarketResponse::from));
-  }
-
-  @PostMapping
-  ResponseEntity<MarketResponse> create(@Valid @RequestBody CreateMarketRequest request) {
-    Market market = marketService.create(request);
-    return ResponseEntity.status(HttpStatus.CREATED).body(MarketResponse.from(market));
-  }
-}
-```
-
-## Repository Pattern (Spring Data JPA)
-
-```java
-public interface MarketRepository extends JpaRepository<MarketEntity, Long> {
-  @Query("select m from MarketEntity m where m.status = :status order by m.volume desc")
-  List<MarketEntity> findActive(@Param("status") MarketStatus status, Pageable pageable);
-}
-```
-
-## Service Layer with Transactions
-
-```java
-@Service
-public class MarketService {
-  private final MarketRepository repo;
-
-  public MarketService(MarketRepository repo) {
-    this.repo = repo;
-  }
-
-  @Transactional
-  public Market create(CreateMarketRequest request) {
-    MarketEntity entity = MarketEntity.from(request);
-    MarketEntity saved = repo.save(entity);
-    return Market.from(saved);
-  }
-}
-```
-
-## DTOs and Validation
-
-```java
-public record CreateMarketRequest(
-    @NotBlank @Size(max = 200) String name,
-    @NotBlank @Size(max = 2000) String description,
-    @NotNull @FutureOrPresent Instant endDate,
-    @NotEmpty List<@NotBlank String> categories) {}
-
-public record MarketResponse(Long id, String name, MarketStatus status) {
-  static MarketResponse from(Market market) {
-    return new MarketResponse(market.id(), market.name(), market.status());
-  }
-}
-```
-
-## Exception Handling
-
-```java
-@ControllerAdvice
-class GlobalExceptionHandler {
-  @ExceptionHandler(MethodArgumentNotValidException.class)
-  ResponseEntity<ApiError> handleValidation(MethodArgumentNotValidException ex) {
-    String message = ex.getBindingResult().getFieldErrors().stream()
-        .map(e -> e.getField() + ": " + e.getDefaultMessage())
-        .collect(Collectors.joining(", "));
-    return ResponseEntity.badRequest().body(ApiError.validation(message));
-  }
-
-  @ExceptionHandler(AccessDeniedException.class)
-  ResponseEntity<ApiError> handleAccessDenied() {
-    return ResponseEntity.status(HttpStatus.FORBIDDEN).body(ApiError.of("Forbidden"));
-  }
-
-  @ExceptionHandler(Exception.class)
-  ResponseEntity<ApiError> handleGeneric(Exception ex) {
-    // Log unexpected errors with stack traces
-    return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
-        .body(ApiError.of("Internal server error"));
-  }
-}
-```
-
-## Caching
-
-Requires `@EnableCaching` on a configuration class.
-
-```java
-@Service
-public class MarketCacheService {
-  private final MarketRepository repo;
-
-  public MarketCacheService(MarketRepository repo) {
-    this.repo = repo;
-  }
-
-  @Cacheable(value = "market", key = "#id")
-  public Market getById(Long id) {
-    return repo.findById(id)
-        .map(Market::from)
-        .orElseThrow(() -> new EntityNotFoundException("Market not found"));
-  }
-
-  @CacheEvict(value = "market", key = "#id")
-  public void evict(Long id) {}
-}
-```
-
-## Async Processing
-
-Requires `@EnableAsync` on a configuration class.
-
-```java
-@Service
-public class NotificationService {
-  @Async
-  public CompletableFuture<Void> sendAsync(Notification notification) {
-    // send email/SMS
-    return CompletableFuture.completedFuture(null);
-  }
-}
-```
-
-## Logging (SLF4J)
-
-```java
-@Service
-public class ReportService {
-  private static final Logger log = LoggerFactory.getLogger(ReportService.class);
-
-  public Report generate(Long marketId) {
-    log.info("generate_report marketId={}", marketId);
-    try {
-      // logic
-    } catch (Exception ex) {
-      log.error("generate_report_failed marketId={}", marketId, ex);
-      throw ex;
-    }
-    return new Report();
-  }
-}
-```
-
-## Middleware / Filters
-
-```java
-@Component
-public class RequestLoggingFilter extends OncePerRequestFilter {
-  private static final Logger log = LoggerFactory.getLogger(RequestLoggingFilter.class);
-
-  @Override
-  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
-      FilterChain filterChain) throws ServletException, IOException {
-    long start = System.currentTimeMillis();
-    try {
-      filterChain.doFilter(request, response);
-    } finally {
-      long duration = System.currentTimeMillis() - start;
-      log.info("req method={} uri={} status={} durationMs={}",
-          request.getMethod(), request.getRequestURI(), response.getStatus(), duration);
-    }
-  }
-}
-```
-
-## Pagination and Sorting
-
-```java
-PageRequest page = PageRequest.of(pageNumber, pageSize, Sort.by("createdAt").descending());
-Page<Market> results = marketService.list(page);
-```
-
-## Error-Resilient External Calls
-
-```java
-public <T> T withRetry(Supplier<T> supplier, int maxRetries) {
-  int attempts = 0;
-  while (true) {
-    try {
-      return supplier.get();
-    } catch (Exception ex) {
-      attempts++;
-      if (attempts >= maxRetries) {
-        throw ex;
-      }
-      try {
-        Thread.sleep((long) Math.pow(2, attempts) * 100L);
-      } catch (InterruptedException ie) {
-        Thread.currentThread().interrupt();
-        throw ex;
-      }
-    }
-  }
-}
-```
-
-## Rate Limiting (Filter + Bucket4j)
-
-**Security Note**: The `X-Forwarded-For` header is untrusted by default because clients can spoof it.
-Only use forwarded headers when:
-1. Your app is behind a trusted reverse proxy (nginx, AWS ALB, etc.)
-2. You have registered `ForwardedHeaderFilter` as a bean
-3. You have configured `server.forward-headers-strategy=NATIVE` or `FRAMEWORK` in application properties
-4. Your proxy is configured to overwrite (not append to) the `X-Forwarded-For` header
-
-When `ForwardedHeaderFilter` is properly configured, `request.getRemoteAddr()` will automatically
-return the correct client IP from the forwarded headers. Without this configuration, use
-`request.getRemoteAddr()` directly—it returns the immediate connection IP, which is the only
-trustworthy value.
-
-```java
-@Component
-public class RateLimitFilter extends OncePerRequestFilter {
-  private final Map<String, Bucket> buckets = new ConcurrentHashMap<>();
-
-  /*
-   * SECURITY: This filter uses request.getRemoteAddr() to identify clients for rate limiting.
-   *
-   * If your application is behind a reverse proxy (nginx, AWS ALB, etc.), you MUST configure
-   * Spring to handle forwarded headers properly for accurate client IP detection:
-   *
-   * 1. Set server.forward-headers-strategy=NATIVE (for cloud platforms) or FRAMEWORK in
-   *    application.properties/yaml
-   * 2. If using FRAMEWORK strategy, register ForwardedHeaderFilter:
-   *
-   *    @Bean
-   *    ForwardedHeaderFilter forwardedHeaderFilter() {
-   *        return new ForwardedHeaderFilter();
-   *    }
-   *
-   * 3. Ensure your proxy overwrites (not appends) the X-Forwarded-For header to prevent spoofing
-   * 4. Configure server.tomcat.remoteip.trusted-proxies or equivalent for your container
-   *
-   * Without this configuration, request.getRemoteAddr() returns the proxy IP, not the client IP.
-   * Do NOT read X-Forwarded-For directly—it is trivially spoofable without trusted proxy handling.
-   */
-  @Override
-  protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response,
-      FilterChain filterChain) throws ServletException, IOException {
-    // Use getRemoteAddr() which returns the correct client IP when ForwardedHeaderFilter
-    // is configured, or the direct connection IP otherwise. Never trust X-Forwarded-For
-    // headers directly without proper proxy configuration.
-    String clientIp = request.getRemoteAddr();
-
-    Bucket bucket = buckets.computeIfAbsent(clientIp,
-        k -> Bucket.builder()
-            .addLimit(Bandwidth.classic(100, Refill.greedy(100, Duration.ofMinutes(1))))
-            .build());
-
-    if (bucket.tryConsume(1)) {
-      filterChain.doFilter(request, response);
-    } else {
-      response.setStatus(HttpStatus.TOO_MANY_REQUESTS.value());
-    }
-  }
-}
-```
-
-## Background Jobs
-
-Use Spring’s `@Scheduled` or integrate with queues (e.g., Kafka, SQS, RabbitMQ). Keep handlers idempotent and observable.
-
-## Observability
-
-- Structured logging (JSON) via Logback encoder
-- Metrics: Micrometer + Prometheus/OTel
-- Tracing: Micrometer Tracing with OpenTelemetry or Brave backend
-
-## Production Defaults
-
-- Prefer constructor injection, avoid field injection
-- Enable `spring.mvc.problemdetails.enabled=true` for RFC 7807 errors (Spring Boot 3+)
-- Configure HikariCP pool sizes for workload, set timeouts
-- Use `@Transactional(readOnly = true)` for queries
-- Enforce null-safety via `@NonNull` and `Optional` where appropriate
-
-**Remember**: Keep controllers thin, services focused, repositories simple, and errors handled centrally. Optimize for maintainability and testability.