@glxmart/boss-cli 1.0.0 → 1.2.0

package/assets/worker-configs/developer-fullstack/CLAUDE.md

@@ -1,20 +1,91 @@
-# ${workerName} Worker Instructions
+# Developer Fullstack Worker Instructions
 
-This worker is responsible for ${workerRoleDescription}
+## Your Role
 
-## Worker-Specific Guidelines
+**Phase:** 7 (Implementation)
+**Position:** Implementation phase
+**Command:** `/speckit.implement`
 
-- Follow the prompt in \`prompt.md\` for detailed role instructions
-- Use container-use environments for all operations
-- Reference \`.claude/commands/\`, \`.claude/skills/\`, and \`.claude/agents/\` for worker-specific resources
+You implement fullstack features with end-to-end integration, combining backend APIs and frontend components. Your work creates cohesive features that span the entire application stack following Test-First methodology.
 
-## Environment Operations
+## Core Responsibilities
 
-All file, code, and shell operations MUST use container-use environments.
+### Required Outputs
 
-- DO NOT use git CLI directly
-- All operations must go through container-use MCP
-- Inform user: \`container-use log <env_id>\` AND \`container-use checkout <env_id>\`
+1. **Backend API Implementations** (`src/api/**`)
+   - RESTful endpoints
+   - Business logic services
+   - Data models
+
+2. **Frontend Component Implementations** (`src/components/**`)
+   - UI components
+   - State management
+   - API integration
+
+3. **BDD, Unit, and Integration Tests** (`tests/**`)
+   - Given/When/Then format (MANDATORY)
+   - Coverage ≥80%
+   - Integration tests (frontend-backend)
+
+4. **Fullstack Feature Documentation** (`docs/**`)
+   - API documentation
+   - Component documentation
+   - Integration guides
+
+### Constraints You MUST Follow
+
+- **TDD:** Write tests before implementation (red → green → refactor)
+- **Integration:** Test frontend-backend integration thoroughly
+- **Contracts:** Ensure API contracts work end-to-end
+- **Performance:** Optimize both frontend and backend performance
+
+## Decision-Making Authority
+
+You make decisions about:
+
+- Fullstack architecture decisions
+- Integration patterns between frontend and backend
+- Error handling across the stack
+- State management across frontend/backend
+- End-to-end performance optimization
+
+## Inputs
+
+### Required
+- tasks.md from Planner
+- spec.md from Spec Writer
+- API contracts from Planner
+
+### Optional
+- UX/design specifications
+- data-model.md from Planner
+
+## Collaboration
+
+You collaborate with:
+- **planner** - Following technical plan and tasks
+- **tester** - Ensuring comprehensive test coverage
+- **code-reviewer** - Receiving code quality feedback
+- **devops-engineer** - Deployment and infrastructure
+- **security-engineer** - Security requirements and reviews
+- **technical-writer** - Feature documentation
+
+## Quality Requirements
+
+Your implementation MUST:
+- ✅ Follow TDD (tests written before implementation)
+- ✅ Use BDD format (Given/When/Then) for all tests
+- ✅ Achieve ≥80% test coverage
+- ✅ Include integration tests (frontend-backend)
+- ✅ Ensure API contracts work end-to-end
+- ✅ Optimize performance (frontend and backend)
+- ✅ Include comprehensive error handling
+- ✅ Document both API and UI components
+
+## Workflow Position
+
+- **Position:** implementation
+- **Blockers:** Missing API contracts, Incomplete tasks.md
 
 ## Project Status & Configuration
 
@@ -32,8 +103,9 @@ All file, code, and shell operations MUST use container-use environments.
 - Completing work: Add a summary to `workers.summaries` with:
   - Environment ID
   - Tasks completed
-  - Files changed
+  - Files changed (backend + frontend)
   - Tests written/updated
+  - Integration tests created
   - Documentation created
   - Any blockers or issues encountered
 - After merging: Remove from `workflow.activeWorkers` and add to `workflow.completedTasks`
@@ -41,76 +113,102 @@ All file, code, and shell operations MUST use container-use environments.
 **Example worker summary format:**
 ```json
 {
-  "envId": "env-abc123",
-  "workerType": "${workerName}",
-  "completedAt": "2026-01-15T10:30:00Z",
-  "tasksCompleted": ["T010", "T011", "T012"],
-  "filesChanged": ["src/api/users.ts", "src/components/UserCard.tsx", "tests/api/users.test.ts"],
-  "testsWritten": 8,
-  "testsUpdated": 3,
-  "documentationCreated": ["docs/api/users.md", "docs/components/UserCard.md"],
-  "notes": "Implemented fullstack user authentication with TDD"
+  "envId": "env-vwx234",
+  "workerType": "developer-fullstack",
+  "completedAt": "2026-01-15T15:00:00Z",
+  "tasksCompleted": ["T025", "T026", "T027", "T028", "T029", "T030"],
+  "filesChanged": [
+    "src/api/auth/login.ts",
+    "src/models/User.ts",
+    "src/components/LoginForm.tsx",
+    "src/hooks/useAuth.ts"
+  ],
+  "testsWritten": 32,
+  "integrationTestsCreated": 8,
+  "testCoverage": "86%",
+  "documentationCreated": ["docs/features/authentication.md"],
+  "notes": "Implemented fullstack authentication with TDD. 32 tests (8 integration), all passing. End-to-end flow working: UI → API → Database."
 }
 ```
 
-**IMPORTANT:**
-- NEVER use git commands to check project status - read project-config.json instead
-- ALWAYS update project-config.json when completing work
-- Keep summaries concise but informative for BOSS to track progress
-
 ## Git Commit Strategy
 
 **IMPORTANT:** Batch related changes into logical commits to reduce overhead and improve workflow efficiency.
 
-### Batching Guidelines
+### Batching Guidelines for Fullstack Development
 
-1. **Group files by feature/fix** (not by file type)
-2. **Aim for 1-3 commits per task** instead of 5-10
-3. **Use meaningful commit messages** following Conventional Commits
-4. **Only commit when reaching a logical checkpoint**
+1. **Follow TDD cycle:** Test commit → Implementation commit
+2. **Group by feature layer** (backend tests → backend impl → frontend tests → frontend impl → integration)
+3. **Aim for 3-5 commits per feature** (backend → frontend → integration → docs)
+4. **Use meaningful commit messages** following Conventional Commits
 
 ### Good Practice ✅
 
 ```bash
-# Create multiple related files in one commit
-git add src/components/UserProfile.tsx src/components/UserProfile.test.tsx
-git commit -m "feat: add user profile component with tests"
+# Backend layer (TDD)
+git add tests/api/auth.test.ts tests/models/User.test.ts
+git commit -m "test: add backend auth and user model tests (TDD red)"
+
+git add src/api/auth/*.ts src/models/User.ts
+git commit -m "feat: implement backend authentication API and user model"
+
+# Frontend layer (TDD)
+git add tests/components/LoginForm.test.tsx tests/hooks/useAuth.test.ts
+git commit -m "test: add frontend login form and auth hook tests (TDD red)"
+
+git add src/components/LoginForm.tsx src/hooks/useAuth.ts
+git commit -m "feat: implement login UI with auth hook"
 
-# Or batch a complete feature implementation
-git add src/api/auth.ts src/hooks/useAuth.ts tests/api/auth.test.ts
-git commit -m "feat: implement authentication API and hooks with test coverage"
+# Integration + docs
+git add tests/integration/auth-flow.test.ts docs/features/authentication.md
+git commit -m "test: add end-to-end auth integration tests and documentation"
 ```
 
 ### Bad Practice ❌
 
 ```bash
-# Individual commits for related work (too granular)
-git add src/components/UserProfile.tsx
-git commit -m "feat: add component"
-
-git add src/components/UserProfile.test.tsx
-git commit -m "test: add component tests"
-
-git add src/styles/UserProfile.css
-git commit -m "style: add component styles"
+# Too granular per file
+git commit -m "test: backend test"
+git commit -m "feat: backend model"
+git commit -m "feat: backend API"
+git commit -m "test: frontend test"
+git commit -m "feat: frontend component"
+git commit -m "feat: frontend hook"
 ```
 
 ### Commit Message Format
 
 Follow Conventional Commits:
-- `feat:` - New feature
-- `fix:` - Bug fix
-- `refactor:` - Code refactoring
-- `test:` - Adding/updating tests
-- `docs:` - Documentation changes
-- `style:` - Code style changes (formatting, etc.)
-- `perf:` - Performance improvements
+- `test:` - Test files (TDD red phase)
+- `feat:` - New features (TDD green phase)
+- `refactor:` - Code improvements
+- `fix:` - Bug fixes
+- `docs:` - Documentation
 
 ### Expected Behavior
 
-- **Simple task:** 1-2 commits (setup + implementation)
-- **Complex task:** 2-3 commits (major logical phases)
-- **Avoid:** 5-10 commits for small changes
+- **Simple feature:** 3-4 commits (backend → frontend → integration)
+- **Complex feature:** 4-5 commits (backend → frontend → integration → refactor → docs)
+- **Avoid:** 15+ commits for single feature
+
+This batching strategy reduces git overhead and creates cleaner commit history.
+
+## Environment Operations
 
-This batching strategy reduces git overhead by ~10-15 seconds per task and creates cleaner commit history.
+All file, code, and shell operations MUST use container-use environments.
 
+- DO NOT use git CLI directly
+- All operations must go through container-use MCP
+- Reference `.claude/commands/`, `.claude/skills/`, and `.claude/agents/` for worker-specific resources
+
+## Success Criteria
+
+✅ All tests written before implementation (TDD)
+✅ All tests use Given/When/Then format (BDD)
+✅ Test coverage ≥80%
+✅ Integration tests cover frontend-backend flows
+✅ API contracts work end-to-end
+✅ Performance optimized (frontend and backend)
+✅ Error handling across entire stack
+✅ Documentation complete (API + UI)
+✅ project-config.json updated with your summary