@codihaus/claude-skills 1.0.0

package/skills/_registry.md

@@ -0,0 +1,189 @@
+# Skill Registry
+
+Central registry of all available skills. Reference this to suggest relevant skills during work.
+
+## Available Skills
+
+| Skill | Purpose | When to Suggest |
+|-------|---------|-----------------|
+| `/debrief` | Create BRD and use cases | Starting new project/feature, unclear requirements |
+| `/dev-arch` | Architecture decisions | New features, major changes, technical design |
+| `/dev-scout` | Explore codebase, detect patterns | Before implementation, understanding existing code |
+| `/dev-specs` | Create implementation plans | After debrief, before coding |
+| `/dev-coding` | Implement features | When specs are ready |
+| `/dev-coding-backend` | Backend patterns | API, schema, database work |
+| `/dev-coding-frontend` | Frontend patterns | UI, components, pages |
+| `/dev-test` | Automated testing | After implementation, before review |
+| `/dev-review` | Code review | After testing passes, before merge |
+| `/dev-changelog` | Implementation summary | After review passes |
+
+### Utility Skills (called by other skills)
+
+| Skill | Purpose | Called By |
+|-------|---------|-----------|
+| `/utils/diagram` | Create/validate Mermaid diagrams | `/dev-scout`, `/dev-specs`, `/dev-arch` |
+| `/utils/docs-graph` | View documentation relationships | `/debrief`, `/dev-specs`, `/dev-arch` |
+| `/utils/gemini` | Large context scanning (1M tokens) | `/dev-scout` for large codebases |
+
+## Skill Flow
+
+```
+Requirements unclear?
+    → /debrief
+        ↓
+    Calls /dev-arch → "Can architecture support this?"
+
+Need architecture decisions?
+    → /dev-arch
+        ↓
+    Creates architecture.md, ADRs
+
+Need to understand codebase?
+    → /dev-scout
+
+Ready to plan implementation?
+    → /dev-specs
+        ↓
+    Calls /dev-arch → "What patterns to use?"
+
+Ready to code?
+    → /dev-coding
+        ├── Backend work → loads /dev-coding-backend
+        └── Frontend work → loads /dev-coding-frontend
+
+Code done, need testing?
+    → /dev-test (auto-triggered by /dev-coding)
+
+Tests pass, need review?
+    → /dev-review
+        ↓
+    Issues? → /dev-coding (fix loop)
+        ↓
+    Pass? → /dev-changelog
+
+Need to document what was built?
+    → /dev-changelog
+
+Need to visualize something?
+    → /utils/diagram (usually called by other skills)
+
+Need to see doc relationships?
+    → /utils/docs-graph (usually called by other skills)
+```
+
+## Trigger Phrases
+
+When user says... → Suggest skill
+
+| User Says | Suggest |
+|-----------|---------|
+| "new feature", "requirements", "customer wants" | `/debrief` |
+| "architecture", "how should we design", "technical approach" | `/dev-arch` |
+| "what does this code do", "explore", "understand codebase" | `/dev-scout` |
+| "how should I implement", "implementation plan" | `/dev-specs` |
+| "build this", "implement", "code this" | `/dev-coding` |
+| "test this", "verify it works", "run tests" | `/dev-test` |
+| "review my code", "check this PR" | `/dev-review` |
+| "what was built", "summarize changes", "document implementation" | `/dev-changelog` |
+| "create diagram", "architecture diagram", "flow chart" | `/utils/diagram` |
+| "what links to this", "doc relationships" | `/utils/docs-graph` |
+
+## Cross-Skill Suggestions
+
+During each skill, consider suggesting:
+
+### /debrief
+- During: Calls `/dev-arch` to validate architecture feasibility
+- After: "Use `/dev-specs` to create implementation plans"
+- If codebase exists: "Consider `/dev-scout` first to understand existing code"
+
+### /dev-arch
+- Called by: `/debrief` (feasibility) and `/dev-specs` (patterns)
+- Reads: `_quality-attributes.md` for architecture-level checklists
+- Outputs: `architecture.md`, ADRs in feature folder
+- After: Informs `/dev-specs` with decisions
+
+### /dev-scout
+- After: "Ready for implementation? Use `/dev-specs` to plan"
+- If patterns unclear: "Use `/utils/diagram` to visualize architecture"
+
+### /dev-specs
+- Before: Ensure `/debrief` completed (BRD exists)
+- During: Calls `/dev-arch` for patterns and decisions
+- Reads: `_quality-attributes.md` for spec-level checklists
+- After: "Use `/dev-coding` to implement"
+
+### /dev-coding
+- Before: Ensure `/dev-specs` completed
+- During: Auto-loads `/dev-coding-backend` or `/dev-coding-frontend`
+- Reads: `_quality-attributes.md` for implementation-level checklists
+- After: Auto-triggers `/dev-test` to verify implementation
+- After test: "Use `/dev-review` to review changes"
+
+### /dev-test
+- Before: Implementation via `/dev-coding` completed
+- During: Captures console errors, network failures, UI state
+- If fails: Fix issues, then re-test
+- After pass: "Use `/dev-review` to review changes"
+
+### /dev-review
+- Reads: `_quality-attributes.md` for ALL level checklists (verification)
+- If issues found: Offers to call `/dev-coding` for automatic fix
+- After fix: Re-runs review automatically
+- If pass: Suggests `/dev-changelog` to document implementation
+- If major changes needed: "Consider creating a CR via `/debrief`"
+
+### /dev-changelog
+- Before: `/dev-review` must pass
+- Reads: Git changes, specs, use cases
+- Outputs: summary.md, implementation.md, tech-debt.md, docs-updates.md
+- Purpose: Document what was built, track progress, identify doc updates
+
+### /utils/diagram
+- Utility skill for diagram validation
+- Called by other skills, not typically invoked directly
+- Used for: architecture diagrams, flow charts, ERD
+
+### /utils/docs-graph
+- Utility skill for documentation relationships
+- Called by other skills to understand dependencies
+- Auto-updated by Claude Code hooks
+
+## Quality Attributes
+
+All skills reference `skills/_quality-attributes.md` for their respective level:
+
+| Skill | Quality Level |
+|-------|---------------|
+| `/dev-arch` | Architecture Level |
+| `/dev-specs` | Specification Level |
+| `/dev-coding` | Implementation Level |
+| `/dev-review` | All Levels (verification) |
+
+Quality attributes covered:
+- **Scalability** - handles growth
+- **Maintainability** - easy to change
+- **Performance** - fast enough
+- **Security** - protected
+- **Reliability** - doesn't break
+- **Testability** - can verify
+
+## Skill Awareness Protocol
+
+Every skill should:
+
+1. **Read this registry** at start (or have it embedded)
+2. **Suggest relevant skills** at natural points:
+   - Before: What should have been done first
+   - During: What could help right now
+   - After: What should come next
+3. **Not force** - Suggestions only, user decides
+
+## Example Skill Awareness Output
+
+```markdown
+💡 **Skill Suggestions:**
+- Before proceeding: Consider `/dev-scout` to understand existing patterns
+- After completion: Use `/dev-review` to review your changes
+- Related: `/utils/diagram` can help visualize the architecture
+```