@cloudstreamsoftware/claude-tools 1.0.0 → 1.1.0

package/skills/tutorial/lessons/02-training.md

@@ -0,0 +1,86 @@
+# Lesson 2: Training Mode
+
+Training mode helps you learn optimal workflows by suggesting the best command sequence for any task.
+
+## Concept
+
+Training mode is like having an expert pair programmer who:
+1. Analyzes what you're trying to do
+2. Suggests the optimal workflow
+3. Explains WHY that order matters
+4. Lets you proceed, modify, or skip
+
+It works through **intent detection** - scanning your prompt for keywords that map to workflow patterns.
+
+Example:
+- "Add a login feature" → Detects "add" + "feature" → Suggests: plan → tdd → code-review → verify
+- "Fix the broken API" → Detects "fix" + "broken" → Suggests: tdd → verify
+- "Refactor the utils" → Detects "refactor" → Suggests: refactor-clean → code-review
+
+## Why This Matters
+
+Without training mode, you might:
+- Start coding without a plan (scope creep)
+- Skip tests (bugs in production)
+- Forget code review (quality issues)
+- Miss the verify step (broken builds)
+
+Training mode ensures you follow best practices until they become habit.
+
+## Exercise
+
+Let's enable training mode and see it in action.
+
+**Step 1**: Create or open a project's CLAUDE.md file
+
+**Step 2**: Add these lines:
+```markdown
+## Training Mode: enabled
+## Training Verbosity: standard
+```
+
+**Step 3**: Ask Claude to do something:
+```
+Add a user profile feature
+```
+
+**Step 4**: Observe the training prompt:
+- See the suggested workflow
+- Note the explanation of WHY this order
+- Choose: Proceed / Modify / Skip
+
+## Verification
+
+You've completed this exercise successfully if:
+- [ ] You saw a workflow suggestion (not just code immediately)
+- [ ] The suggestion included multiple steps
+- [ ] You understood WHY each step was suggested
+- [ ] You were given choice to proceed/modify/skip
+
+## Key Takeaway
+
+Training mode teaches you optimal workflows. Keep it enabled until the patterns become automatic.
+
+## Verbosity Options
+
+You can adjust how much training mode explains:
+
+| Setting | What You See |
+|---------|--------------|
+| minimal | Just the command sequence |
+| standard | Commands + brief rationale |
+| detailed | Commands + rationale + skill references |
+
+Update your CLAUDE.md:
+```markdown
+## Training Verbosity: minimal
+```
+
+## Next Steps
+
+In Lesson 3, you'll learn the 6 most essential commands every user should memorize.
+
+---
+
+**Feature learned**: Training Mode - automatic workflow suggestions based on intent
+**Progress**: 3 of 15 lessons complete

package/skills/tutorial/lessons/03-commands.md

@@ -0,0 +1,109 @@
+# Lesson 3: Essential Commands
+
+These 5 commands form the core of your daily workflow. Master these first.
+
+## Concept
+
+You don't need to memorize all 22 commands. These 6 cover 90% of daily work:
+
+| # | Command | Purpose | When to Use |
+|---|---------|---------|-------------|
+| 1 | `/verify` | Validate project | Before every commit |
+| 2 | `/plan` | Design implementation | Complex features |
+| 3 | `/tdd` | Test-driven development | New code |
+| 4 | `/code-review` | Quality check | Before PR |
+| 5 | `/checkpoint` | Recovery point | Before risky changes |
+| 6 | `/audit` | System health check | Start of session, debugging |
+
+Think of them as a safety workflow:
+```
+audit → checkpoint → plan → tdd → code-review → verify → commit
+```
+
+## Why This Matters
+
+Each command prevents specific problems:
+- `/audit` ensures system is healthy and properly configured
+- `/verify` catches broken builds before CI
+- `/plan` prevents scope creep and rework
+- `/tdd` ensures testable, quality code
+- `/code-review` catches bugs and security issues
+- `/checkpoint` enables safe rollback
+
+## Exercise
+
+Let's practice each command on a test file.
+
+**Step 1**: Run `/audit` to check system health:
+```
+/audit
+```
+This verifies Memory MCP, features, and configuration are working.
+
+**Step 2**: Create a simple test file:
+```javascript
+// test-file.js
+function add(a, b) {
+  return a + b;
+}
+```
+
+**Step 3**: Run `/checkpoint`:
+```
+/checkpoint
+```
+This creates a save point you can return to.
+
+**Step 4**: Run `/plan "add multiplication function"`:
+```
+/plan "add a multiply function with tests"
+```
+Observe the implementation plan.
+
+**Step 5**: Run `/tdd multiply`:
+```
+/tdd multiply
+```
+Watch the RED → GREEN → REFACTOR flow.
+
+**Step 6**: Run `/code-review`:
+```
+/code-review
+```
+See quality feedback on your changes.
+
+**Step 7**: Run `/verify`:
+```
+/verify
+```
+Final validation before commit.
+
+## Verification
+
+You've completed this exercise successfully if:
+- [ ] `/audit` showed system health status
+- [ ] `/checkpoint` created a recovery point
+- [ ] `/plan` showed implementation steps
+- [ ] `/tdd` wrote tests before implementation
+- [ ] `/code-review` provided quality feedback
+- [ ] `/verify` ran all validations
+
+## Key Takeaway
+
+These 6 commands are your daily toolkit. Use them in sequence: audit → checkpoint → plan → tdd → code-review → verify.
+
+## Pro Tips
+
+1. **Always `/verify` before commit** - catches 80% of issues
+2. **Use `/plan` for anything taking >30 min** - prevents rework
+3. **`/checkpoint` before refactors** - enables safe experimentation
+4. **`/code-review` with security flag** - `/code-review --security` for auth code
+
+## Next Steps
+
+In Lesson 4, you'll learn complete workflow patterns for different task types.
+
+---
+
+**Commands learned**: `/verify`, `/plan`, `/tdd`, `/code-review`, `/checkpoint`, `/audit`
+**Progress**: 4 of 15 lessons complete

package/skills/tutorial/lessons/04-workflows.md

@@ -0,0 +1,115 @@
+# Lesson 4: Workflow Patterns
+
+Different tasks need different workflows. Learn when to use each pattern.
+
+## Concept
+
+The system recognizes 16 different intent types, each with an optimal workflow:
+
+### Common Workflows
+
+**New Feature**
+```
+/plan → /tdd → /code-review → /verify
+```
+Plan first, test-drive the implementation, review quality, validate.
+
+**Bug Fix**
+```
+/tdd → /verify
+```
+Write a failing test that reproduces the bug, fix it, verify.
+
+**Refactoring**
+```
+/checkpoint → /refactor-clean → /code-review → /verify
+```
+Safety checkpoint, clean up, review changes, validate nothing broke.
+
+**Security Work**
+```
+/code-review --security → /verify
+```
+Security-focused review, then validation.
+
+## Why This Matters
+
+Using the right workflow:
+- **Prevents rework** - plan before coding
+- **Catches bugs early** - test before implementation
+- **Ensures quality** - review before commit
+- **Enables rollback** - checkpoint before risky changes
+
+## Exercise
+
+Let's execute a complete feature workflow.
+
+**Step 1**: Start with a plan:
+```
+/plan "add a greeting function that returns 'Hello, {name}!'"
+```
+
+**Step 2**: Approve the plan, then use TDD:
+```
+/tdd greeting
+```
+Observe:
+1. Test file created first (RED)
+2. Implementation to pass tests (GREEN)
+3. Cleanup if needed (REFACTOR)
+
+**Step 3**: Review the code:
+```
+/code-review
+```
+Check for:
+- Code quality feedback
+- Potential improvements
+- Security considerations
+
+**Step 4**: Final verification:
+```
+/verify
+```
+Ensure everything passes.
+
+## Verification
+
+You've completed this exercise successfully if:
+- [ ] You followed the plan → tdd → review → verify sequence
+- [ ] Tests were written BEFORE implementation
+- [ ] Code review provided actionable feedback
+- [ ] Final verify showed all green
+
+## Key Takeaway
+
+Match your workflow to your task. The system suggests the right pattern via training mode.
+
+## Workflow Quick Reference
+
+| Task Type | Workflow |
+|-----------|----------|
+| New feature | plan → tdd → review → verify |
+| Bug fix | tdd → verify |
+| Refactor | checkpoint → refactor-clean → review → verify |
+| Security | review (security) → verify |
+| Deployment | checkpoint → verify → deploy |
+| Documentation | update-docs → update-codemaps |
+
+## The Orchestrate Shortcut
+
+For complex tasks, use `/orchestrate` to chain agents automatically:
+```
+/orchestrate feature "user authentication"
+```
+
+This triggers: planner → architect → tdd-guide → code-reviewer
+
+## Next Steps
+
+In Lesson 5, you'll learn about compliance modes for regulated industries.
+
+---
+
+**Pattern learned**: Task-specific workflows - match the workflow to the task type
+**Progress**: 5 of 15 lessons complete

package/skills/tutorial/lessons/05-compliance.md

@@ -0,0 +1,116 @@
+# Lesson 5: Compliance Modes
+
+For regulated industries (healthcare, finance, etc.), compliance modes ensure code meets standards.
+
+## Concept
+
+The system supports three compliance frameworks:
+
+| Mode | Industry | Key Requirements |
+|------|----------|------------------|
+| HIPAA | Healthcare | PHI protection, encryption, audit logs |
+| SOC2 | SaaS/Cloud | Data security, availability, processing integrity |
+| PCI-DSS | Payments | Cardholder data protection, access control |
+
+When compliance mode is active:
+1. `/code-review` checks for compliance violations
+2. `/compliance-check` runs a full audit
+3. Agents add compliance-specific validations
+4. Generated code includes required safeguards
+
+## Why This Matters
+
+Compliance violations can result in:
+- **HIPAA**: Fines up to $1.5M per incident
+- **SOC2**: Failed audits, lost enterprise customers
+- **PCI-DSS**: Inability to process payments
+
+The system catches violations during development, not after deployment.
+
+## Exercise
+
+Let's set up compliance mode and run an audit.
+
+**Step 1**: Add compliance mode to your CLAUDE.md:
+```markdown
+## Compliance Mode: hipaa
+```
+
+**Step 2**: Run a compliance check:
+```
+/compliance-check
+```
+
+**Step 3**: Observe the audit output:
+- PHI exposure risks
+- Encryption requirements
+- Audit logging gaps
+- Access control issues
+
+**Step 4**: Review compliance-aware code review:
+```
+/code-review
+```
+Notice the additional compliance checks in the output.
+
+## Verification
+
+You've completed this exercise successfully if:
+- [ ] You set compliance mode in CLAUDE.md
+- [ ] `/compliance-check` ran an audit
+- [ ] You saw compliance-specific findings
+- [ ] `/code-review` included compliance checks
+
+## Key Takeaway
+
+Set compliance mode once per project, and the system handles the rest.
+
+## Compliance Quick Reference
+
+### HIPAA Mode
+```markdown
+## Compliance Mode: hipaa
+```
+Checks for:
+- PHI in logs/errors
+- Encryption at rest/transit
+- Audit trail for data access
+- Minimum necessary access
+
+### SOC2 Mode
+```markdown
+## Compliance Mode: soc2
+```
+Checks for:
+- Data retention policies
+- Change management
+- Incident response
+- Vendor management
+
+### PCI-DSS Mode
+```markdown
+## Compliance Mode: pci-dss
+```
+Checks for:
+- Card data exposure
+- Encryption standards
+- Access logging
+- Network segmentation
+
+## Combining Modes
+
+For projects requiring multiple frameworks:
+```markdown
+## Compliance Mode: hipaa, soc2
+```
+
+The system applies all relevant checks.
+
+## Next Steps
+
+In Lesson 6, you'll learn Zoho-specific development workflows.
+
+---
+
+**Feature learned**: Compliance modes - automatic regulatory compliance checks
+**Progress**: 6 of 15 lessons complete

package/skills/tutorial/lessons/06-zoho.md

@@ -0,0 +1,121 @@
+# Lesson 6: Zoho Development
+
+Specialized workflows for Zoho Creator, Catalyst, and Deluge development.
+
+## Concept
+
+Zoho development has unique constraints:
+- **Deluge** has a 5,000-statement limit per function
+- **Catalyst** functions have 40-second timeout
+- **Creator** forms have specific relationship patterns
+
+The system includes agents specialized for Zoho:
+- `creator-architect` - Creator app design
+- `catalyst-deployer` - Catalyst function deployment
+- `deluge-reviewer` - Deluge script validation
+
+## Why This Matters
+
+Without these constraints in mind:
+- Scripts hit statement limits and fail
+- Functions timeout in production
+- Creator relationships break data integrity
+
+The system catches these issues before deployment.
+
+## Exercise
+
+Let's scaffold a Catalyst function and write Deluge code.
+
+**Step 1**: Scaffold a Catalyst function:
+```
+/zoho-scaffold catalyst-function "process-webhook"
+```
+Observe the generated structure:
+- Function boilerplate
+- Error handling
+- Timeout management
+- Logging setup
+
+**Step 2**: Generate Deluge code:
+```
+/deluge "fetch contacts from CRM and update Creator form"
+```
+Notice:
+- Null checks on every variable
+- Try-catch error handling
+- Statement count awareness
+- API call batching
+
+**Step 3**: Review the generated code:
+```
+/code-review
+```
+See Zoho-specific checks:
+- Statement count estimation
+- API quota usage
+- Timeout risks
+
+## Verification
+
+You've completed this exercise successfully if:
+- [ ] `/zoho-scaffold` created a function structure
+- [ ] `/deluge` generated code with proper safeguards
+- [ ] Code review included Zoho-specific checks
+- [ ] You understand the platform constraints
+
+## Key Takeaway
+
+Use the Zoho commands to generate code that respects platform limits.
+
+## Zoho Quick Reference
+
+### Creator Development
+```
+/zoho-scaffold creator-app "inventory-tracker"
+```
+Generates:
+- Form hierarchy design
+- Workflow templates
+- Widget placeholders
+- Connection setup
+
+### Catalyst Functions
+```
+/zoho-scaffold catalyst-function "data-sync"
+```
+Generates:
+- Function entry point
+- Error handling
+- Environment config
+- Logging setup
+
+### Deluge Scripts
+```
+/deluge "calculate invoice totals with tax"
+```
+Generates:
+- Null-safe code
+- Error handling
+- Optimized queries
+- Comment documentation
+
+## Platform Constraints Reference
+
+| Platform | Constraint | Limit |
+|----------|------------|-------|
+| Deluge | Statements per function | 5,000 |
+| Catalyst | Function timeout | 40 seconds |
+| Creator | Subforms per form | 10 |
+| Catalyst | Memory per function | 512 MB |
+| Deluge | API calls per function | 25,000/day |
+
+## Next Steps
+
+In Lesson 7, you'll learn about the Hooks System - how to automate quality checks before and after Claude Code actions.
+
+---
+
+**Commands learned**: `/zoho-scaffold`, `/deluge`
+**Agents introduced**: creator-architect, catalyst-deployer, deluge-reviewer
+**Progress**: 7 of 15 lessons complete