@codihaus/claude-skills 1.6.15 → 1.6.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codihaus/claude-skills",
-  "version": "1.6.15",
+  "version": "1.6.16",
   "description": "Claude Code skills for software development workflow",
   "main": "src/index.js",
   "bin": {

package/skills/dev-coding/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: dev-coding
 description: Implement features as a Principal Engineering Developer
-version: 2.1.0
+version: 2.1.1
 ---
 
 # /dev-coding - Implementation Skill
@@ -58,6 +58,21 @@ You have three layers of knowledge to apply:
 2. `plans/brd/tech-context.md` exists → patterns known
 3. `plans/features/{feature}/codebase-context.md` exists (optional, helpful)
 
+## CRITICAL: Always Load Stack Knowledge
+
+**BEFORE implementing any feature:**
+
+1. **Read `plans/brd/tech-context.md`** → Identify stack(s)
+2. **Read `knowledge/stacks/{stack}/_index.md`** → Load framework patterns
+3. **Focus on "For /dev-coding" section** → Note best practices
+
+**Stack file mapping:**
+- "Next.js" → `knowledge/stacks/nextjs/_index.md`
+- "Nuxt" → `knowledge/stacks/nuxt/_index.md`
+- "Directus" → `knowledge/stacks/directus/_index.md`
+
+**If you skip this step**, you'll implement using generic patterns instead of framework-specific best practices (e.g., using fetch instead of Server Actions in Next.js).
+
 ## Expected Outcome
 
 Implemented feature that meets all acceptance criteria from spec.
@@ -75,12 +90,24 @@ Implemented feature that meets all acceptance criteria from spec.
 ## Implementation Approach
 
 **1. Load Context (once):**
-- Read spec → Get requirements, acceptance criteria, work area
-- Read tech-context.md → Get project patterns + identify stack(s)
-- Load stack knowledge → Read `knowledge/stacks/{stack}/_index.md` (detected from tech-context.md)
-- Read codebase-context.md → Get feature-specific implementation
-- Read architecture.md (if exists) → Get architecture decisions
-- Load universal principles (references/) as needed
+
+**Step 1: Read spec**
+- Get requirements, acceptance criteria, work area
+
+**Step 2: Detect and load stack knowledge**
+- Read `plans/brd/tech-context.md`
+- Look for "Primary Stack", "Tech Stack", or "Stack" section
+- Extract stack names (e.g., "Next.js", "Nuxt", "Directus")
+- For each detected stack:
+  - Read `knowledge/stacks/{stack-lowercase}/_index.md` (e.g., `nextjs`, `nuxt`, `directus`)
+  - Focus on "For /dev-coding" section
+  - Note best practices, patterns, anti-patterns
+- If stack knowledge file doesn't exist, note it and continue
+
+**Step 3: Load universal and project specifics**
+- Read `plans/features/{feature}/codebase-context.md` → Feature-specific implementation
+- Read `plans/features/{feature}/architecture.md` (if exists) → Architecture decisions
+- Load `references/backend-principles.md` and/or `frontend-principles.md` as needed
 
 **2. Plan Work:**
 - If feature name given (not specific UC): Ask implementation mode
@@ -135,14 +162,34 @@ Layer 3: Project Specifics (tech-context.md)
 Implementation
 ```
 
-**How to detect stack:**
-- Read tech-context.md → Look for "Tech Stack" or "Primary Stack" section
-- Common stacks: Next.js, Nuxt, Directus, Prisma, Supabase
-
-**Apply what the requirement needs:**
-- API endpoint? → Universal API principles + Framework API patterns (Server Actions vs API routes) + Project's API pattern
-- UI component? → Universal component principles + Framework component patterns (Server vs Client Components) + Project's UI pattern
-- Data access? → Universal data principles + Framework data patterns (ORM usage) + Project's data pattern
+**How to detect and load stack knowledge:**
+
+1. **Read tech-context.md** and look for stack indicators:
+   ```markdown
+   **Primary Stack**: Next.js + Directus
+   ```
+   or
+   ```markdown
+   ## Tech Stack
+   - Frontend: Nuxt.js 3
+   - Backend: Directus
+   ```
+
+2. **Load stack knowledge files:**
+   - If "Next.js" detected → Read `knowledge/stacks/nextjs/_index.md`
+   - If "Nuxt" detected → Read `knowledge/stacks/nuxt/_index.md`
+   - If "Directus" detected → Read `knowledge/stacks/directus/_index.md`
+
+3. **Focus on "For /dev-coding" section** in each stack file for:
+   - Framework-specific patterns
+   - Best practices
+   - Anti-patterns to avoid
+   - Common gotchas
+
+**Apply all three layers based on requirement:**
+- API endpoint? → Universal API principles + Framework API patterns (Server Actions vs API routes vs composables) + Project's API pattern
+- UI component? → Universal component principles + Framework UI patterns (Server vs Client Components, SFC, etc.) + Project's UI pattern
+- Data access? → Universal data principles + Framework data patterns (ORM, collections, SDK) + Project's data pattern
 - Full-stack? → Apply all three layers across concerns
 
 ## After Implementation
@@ -161,21 +208,64 @@ Implementation
 
 **Requirement:** "Add password reset endpoint" (Next.js project)
 
-1. **Load Knowledge:**
-   - Universal: `references/backend-principles.md` (validation, security)
-   - Framework: `knowledge/stacks/nextjs/_index.md` (Server Actions vs Route Handlers)
-   - Project: `tech-context.md` (how THIS project does APIs)
+**1. Load Knowledge:**
+
+```
+Step 1: Read plans/brd/tech-context.md
+→ Found: "Primary Stack: Next.js 14 (App Router)"
+
+Step 2: Read knowledge/stacks/nextjs/_index.md
+→ Section "For /dev-coding":
+  - Use Server Actions for mutations (not Route Handlers)
+  - Server Actions = "use server" directive
+  - Place in lib/actions/
+  - Return structured response {success, error, data}
+
+Step 3: Read references/backend-principles.md
+→ API security: validate input, rate limit, secure tokens
+
+Step 4: Read tech-context.md patterns
+→ Project uses Zod for validation
+→ Project uses nodemailer for emails
+→ Auth actions in lib/actions/auth.ts
+```
+
+**2. Discover:**
+```
+Glob: lib/actions/*.ts
+Read: lib/actions/auth.ts (see existing login pattern)
+```
 
-2. **Discover:** Where are endpoints? → Glob for similar patterns, Read example
+**3. Apply Three Layers:**
+- **Universal**: Input validation, secure token (crypto.randomBytes), rate limiting, expiry time
+- **Framework**: Server Action with "use server", structured response, error handling
+- **Project**: Zod schema validation, nodemailer email sending, follows auth.ts pattern
 
-3. **Apply Three Layers:**
-   - Universal: Input validation, secure token handling, rate limiting
-   - Framework: Use Server Action (Next.js pattern) with `"use server"`
-   - Project: Follow existing auth pattern in `lib/actions/`
+**4. Implement:**
+```typescript
+// lib/actions/auth.ts
+"use server"
 
-4. **Implement:** Create/modify files following all three layers
+export async function resetPassword(email: string) {
+  // Universal: Validation
+  const schema = z.string().email()
+  const validated = schema.parse(email)
+
+  // Universal: Generate secure token
+  const token = crypto.randomBytes(32).toString('hex')
+
+  // Project: Store token in DB (project pattern)
+  await db.passwordReset.create({...})
+
+  // Project: Send email (project uses nodemailer)
+  await sendEmail({...})
+
+  // Framework: Server Action response pattern
+  return { success: true, data: { sent: true } }
+}
+```
 
-5. **Validate:** Check acceptance criteria
+**5. Validate:** Check acceptance criteria
 
 ## Quality