@localtech/claude-code-toolkit 1.0.3 → 1.0.4

package/templates/.claude/memory/patterns.md

@@ -0,0 +1,72 @@
+# Common Patterns and Solutions
+
+## Error Handling Pattern
+```
+try {
+  // Operation that might fail
+  const result = await riskyOperation();
+  return result;
+} catch (error) {
+  // Log error with context
+  console.error(`Operation failed: ${error.message}`, { context: additionalData });
+  // Return safe default or re-throw
+  throw new Error(`Operation failed: ${error.message}`);
+}
+```
+
+## API Response Pattern
+```
+interface ApiResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  timestamp: string;
+}
+
+function createResponse<T>(data: T): ApiResponse<T> {
+  return {
+    success: true,
+    data,
+    timestamp: new Date().toISOString()
+  };
+}
+```
+
+## Component Structure Pattern
+```
+interface ComponentProps {
+  // Define props interface
+}
+
+export function ComponentName({ prop1, prop2 }: ComponentProps) {
+  // Early returns for edge cases
+  if (!prop1) return null;
+
+  // Main component logic
+  return (
+    <div>
+      {/* Component JSX */}
+    </div>
+  );
+}
+```
+
+## Testing Pattern
+```
+describe('ComponentName', () => {
+  it('should render correctly with valid props', () => {
+    // Arrange
+    const props = { /* test props */ };
+
+    // Act
+    render(<ComponentName {...props} />);
+
+    // Assert
+    expect(screen.getByText('expected text')).toBeInTheDocument();
+  });
+
+  it('should handle error states gracefully', () => {
+    // Test error scenarios
+  });
+});
+```

package/templates/.claude/memory/preferences.md

@@ -0,0 +1,23 @@
+# User Preferences and Working Styles
+
+## Development Environment
+**IDE**: Cursor IDE with Claude Code extension
+**Theme**: Dark mode preferred
+**Font**: Monospace, 14pt for code readability
+
+## Code Style Preferences
+**Language**: TypeScript preferred over JavaScript for new projects
+**Architecture**: Functional programming principles where appropriate
+**Naming**: camelCase for variables/functions, PascalCase for classes/types
+**Documentation**: JSDoc/TSDoc for public APIs, inline comments for complex logic
+
+## Communication Style
+**Feedback**: Prefer specific, actionable feedback with examples
+**Documentation**: Professional yet approachable tone
+**Decision Making**: Prefer data-driven decisions with clear rationale
+
+## Tool Preferences
+**Version Control**: Git with conventional commits
+**Testing**: Jest/Vitest with >80% coverage target
+**Linting**: ESLint with TypeScript rules
+**Package Management**: Prefer npm for stability, yarn/pnpm for performance

package/templates/.claude/skills/claude-code-hooks-master/SKILL.md

@@ -0,0 +1,358 @@
+# Claude Code Skill: Claude Code Hooks Master
+
+## Metadata
+name: claude-code-hooks-master
+description: Master the power of Claude Code hooks for automated development workflows, continuous integration, and seamless productivity enhancement
+author: Carlos Fadhel
+version: 1.0.0
+tags: automation, hooks, workflow, efficiency, ci, productivity, integration
+
+## When to Use This Skill
+Use this skill when you need to:
+- Automate repetitive development tasks
+- Implement continuous integration workflows
+- Enhance development efficiency with smart automation
+- Integrate Claude Code with external tools and services
+- Create custom development workflows
+- Ensure code quality through automated checks
+
+## Core Concepts: Hooks Architecture
+
+### What Are Claude Code Hooks?
+Hooks are automated scripts that trigger at specific points in your development workflow:
+- **Pre-commit**: Run before code is committed (linting, testing, formatting)
+- **Post-commit**: Run after commits (documentation, notifications, deployment prep)
+- **Pre-push**: Run before pushing to remote (integration tests, security checks)
+- **Post-merge**: Run after merging branches (cleanup, notifications, deployments)
+- **File-change**: Trigger on specific file modifications
+- **Custom events**: User-defined triggers for specific workflows
+
+### Hook Directory Structure
+```
+.claude/hooks/
+├── pre-commit/
+│   ├── lint-and-format.sh
+│   ├── run-tests.sh
+│   └── security-check.py
+├── post-commit/
+│   ├── update-docs.sh
+│   ├── notify-team.py
+│   └── backup-code.sh
+├── pre-push/
+│   ├── integration-tests.sh
+│   ├── performance-check.py
+│   └── deployment-prep.sh
+└── custom/
+    ├── on-api-change/
+    │   └── regenerate-clients.sh
+    ├── on-db-migration/
+    │   └── run-migrations.sh
+    └── on-release/
+        └── publish-package.sh
+```
+
+## Hook Implementation Best Practices
+
+### 1. Hook Script Standards
+```bash
+#!/bin/bash
+# HOOK: pre-commit-lint-format
+# DESCRIPTION: Lint and format code before commits
+# AUTHOR: Claude Code Hooks Master
+# VERSION: 1.0.0
+
+set -e  # Exit on any error
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+log_info() {
+    echo -e "${GREEN}[INFO]${NC} $1"
+}
+
+log_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Main execution
+main() {
+    log_info "Running pre-commit lint and format checks..."
+
+    # Your automation logic here
+    if ! run_linter; then
+        log_error "Linting failed. Please fix issues before committing."
+        exit 1
+    fi
+
+    if ! run_formatter; then
+        log_error "Formatting failed."
+        exit 1
+    fi
+
+    log_info "All pre-commit checks passed!"
+}
+
+# Helper functions
+run_linter() {
+    # Implement your linting logic
+    echo "Running linter..."
+    # Return 0 for success, 1 for failure
+}
+
+run_formatter() {
+    # Implement your formatting logic
+    echo "Running formatter..."
+    # Return 0 for success, 1 for failure
+}
+
+# Run main function
+main "$@"
+```
+
+### 2. Error Handling & Logging
+- Always use `set -e` to fail fast on errors
+- Provide clear, actionable error messages
+- Log both successes and failures
+- Use exit codes appropriately (0 = success, 1 = failure)
+
+### 3. Performance Considerations
+- Keep hooks fast (< 30 seconds for pre-commit)
+- Cache results when possible
+- Run expensive operations in background for post-commit hooks
+- Use parallel execution for independent checks
+
+### 4. Integration with Claude Code Skills
+Hooks can trigger Claude Code skills automatically:
+```bash
+# In a post-commit hook
+claude_code_run_skill "professional-documentation-writer" "update-api-docs"
+claude_code_run_skill "test-generator" "run-regression-tests"
+```
+
+## Essential Hook Categories
+
+### 🔍 **Quality Assurance Hooks**
+- **Pre-commit**: Linting, formatting, type checking
+- **Pre-push**: Full test suite, integration tests
+- **Post-merge**: Cross-browser testing, accessibility audits
+
+### 🚀 **Deployment Hooks**
+- **Pre-push**: Build verification, environment checks
+- **Post-commit**: Automatic staging deployments
+- **Post-merge**: Production deployments (with approval gates)
+
+### 📚 **Documentation Hooks**
+- **Post-commit**: Auto-generate API docs, update README
+- **On-api-change**: Regenerate client SDKs
+- **Pre-release**: Generate changelog, update version numbers
+
+### 🔒 **Security Hooks**
+- **Pre-commit**: Secret scanning, dependency vulnerability checks
+- **Pre-push**: Security testing, penetration testing triggers
+- **Post-merge**: Security audit notifications
+
+### 🤝 **Collaboration Hooks**
+- **Post-commit**: Team notifications, Slack updates
+- **Post-merge**: Code review assignments, QA notifications
+- **On-conflict**: Conflict resolution guides, merge conflict notifications
+
+## Advanced Automation Examples
+
+### 1. Smart Commit Messages
+```bash
+# pre-commit-smart-commit.sh
+# Analyzes changes and suggests commit message format
+
+CHANGED_FILES=$(git diff --cached --name-only)
+if echo "$CHANGED_FILES" | grep -q "test"; then
+    SUGGEST_TYPE="test"
+elif echo "$CHANGED_FILES" | grep -q "docs"; then
+    SUGGEST_TYPE="docs"
+elif echo "$CHANGED_FILES" | grep -q "\.md$"; then
+    SUGGEST_TYPE="docs"
+else
+    SUGGEST_TYPE="feat"
+fi
+
+echo "Suggested commit type: $SUGGEST_TYPE"
+echo "Example: $SUGGEST_TYPE: add user authentication"
+```
+
+### 2. Intelligent Testing
+```bash
+# pre-push-smart-testing.sh
+# Runs only relevant tests based on changed files
+
+CHANGED_FILES=$(git diff --name-only HEAD~1)
+TEST_COMMAND="npm test"
+
+# Run full suite for core changes
+if echo "$CHANGED_FILES" | grep -E "(core|config|package\.json)"; then
+    echo "Core changes detected - running full test suite"
+    TEST_COMMAND="$TEST_COMMAND -- --coverage"
+# Run specific tests for feature changes
+elif echo "$CHANGED_FILES" | grep -E "src/components"; then
+    echo "Component changes detected - running component tests"
+    TEST_COMMAND="$TEST_COMMAND -- --testPathPattern=components"
+fi
+
+eval $TEST_COMMAND
+```
+
+### 3. Automated Documentation
+```bash
+# post-commit-docs-update.sh
+# Auto-updates documentation based on code changes
+
+if git diff --name-only HEAD~1 | grep -E "\.(js|ts|py)$"; then
+    echo "Code changes detected - updating documentation"
+
+    # Use Claude Code skills for documentation
+    claude_code_run_skill "professional-documentation-writer" "update-api-docs"
+
+    # Update README if necessary
+    if git diff --name-only HEAD~1 | grep -E "(README|readme)"; then
+        claude_code_run_skill "professional-documentation-writer" "update-readme"
+    fi
+fi
+```
+
+### 4. Deployment Automation
+```bash
+# post-merge-deployment.sh
+# Automates deployment after successful merges
+
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+if [ "$BRANCH" = "main" ] || [ "$BRANCH" = "master" ]; then
+    echo "Merge to main branch detected - starting deployment"
+
+    # Run final checks
+    npm run test:ci
+    npm run build
+
+    # Deploy to staging
+    deploy_to_staging
+
+    # Notify team
+    notify_deployment "staging"
+
+    # Optional: auto-deploy to production after manual approval
+    if [ "$AUTO_DEPLOY_PROD" = "true" ]; then
+        deploy_to_production
+        notify_deployment "production"
+    fi
+fi
+```
+
+## Integration with Claude Code Agents
+
+### Memory System Integration
+```bash
+# post-commit-memory-update.sh
+# Updates the persistent memory system with project changes
+
+COMMIT_MSG=$(git log -1 --pretty=%B)
+CHANGED_FILES=$(git diff --name-only HEAD~1)
+
+# Add to decisions memory
+if echo "$COMMIT_MSG" | grep -i "decision\|choice\|architect"; then
+    echo "## $(date) - Architecture Decision" >> .claude/memory/decisions.md
+    echo "**Decision**: $COMMIT_MSG" >> .claude/memory/decisions.md
+fi
+
+# Add to learnings memory
+if echo "$COMMIT_MSG" | grep -i "learn\|discover\|find"; then
+    echo "## $(date) - Development Learning" >> .claude/memory/learnings.md
+    echo "**Insight**: $COMMIT_MSG" >> .claude/memory/learnings.md
+fi
+```
+
+### Agent Triggering
+```bash
+# on-file-change-trigger-agents.sh
+# Triggers specific agents based on file changes
+
+CHANGED_FILES=$(git diff --name-only)
+
+# Trigger mobile UI specialist for UI changes
+if echo "$CHANGED_FILES" | grep -E "mobile|ui|component"; then
+    claude_code_run_agent "mobile-ui-specialist" "review-ui-changes"
+fi
+
+# Trigger code reviewer for critical files
+if echo "$CHANGED_FILES" | grep -E "(security|auth|payment)"; then
+    claude_code_run_agent "code-reviewer" "security-review"
+fi
+```
+
+## Performance & Reliability
+
+### Hook Performance Guidelines
+- **Pre-commit**: < 10 seconds (blocking operations)
+- **Pre-push**: < 30 seconds (can be interrupted)
+- **Post-commit**: < 60 seconds (background operations)
+- **Post-merge**: < 5 minutes (deployment operations)
+
+### Reliability Features
+- **Timeout handling**: Prevent hanging hooks
+- **Retry logic**: For network-dependent operations
+- **Fallback behavior**: Graceful degradation on failures
+- **Logging**: Comprehensive logging for debugging
+
+### Monitoring & Maintenance
+```bash
+# hook-monitor.sh
+# Monitors hook performance and health
+
+HOOK_LOGS_DIR=".claude/hooks/logs"
+mkdir -p "$HOOK_LOGS_DIR"
+
+# Log hook execution time
+start_time=$(date +%s)
+# ... hook logic ...
+end_time=$(date +%s)
+duration=$((end_time - start_time))
+
+echo "$(date): $HOOK_NAME took ${duration}s" >> "$HOOK_LOGS_DIR/performance.log"
+
+# Alert on slow hooks
+if [ $duration -gt 30 ]; then
+    notify_team "Slow hook detected: $HOOK_NAME (${duration}s)"
+fi
+```
+
+## Security Considerations
+
+### Safe Hook Practices
+- **Validate inputs**: Never trust user-provided data
+- **Limit permissions**: Run hooks with minimal required permissions
+- **Audit logging**: Log all hook executions for security review
+- **Secret management**: Use secure credential storage (not plain text)
+
+### Network Security
+- **HTTPS only**: All external API calls must use HTTPS
+- **Certificate validation**: Verify SSL certificates
+- **API authentication**: Use proper authentication tokens
+- **Rate limiting**: Respect API rate limits to avoid blocks
+
+## Input Requirements
+- Project type (web app, mobile app, API, library)
+- Development workflow preferences (Git flow, trunk-based, etc.)
+- External integrations needed (CI/CD, monitoring, notifications)
+- Performance requirements and constraints
+
+## Output Format
+Return production-ready hook implementations with:
+- Proper error handling and logging
+- Performance optimizations
+- Security best practices
+- Integration with existing Claude Code skills
+- Documentation and maintenance guides
+- Monitoring and alerting capabilities