claude-code-toolkit 1.0.11 → 1.0.13

package/templates/.claude/agents/debugger.json

@@ -0,0 +1,41 @@
+{
+  "name": "debugger",
+  "description": "Systematic debugging and issue resolution agent",
+  "version": "1.0.0",
+  "triggers": [
+    "debug this",
+    "fix this bug",
+    "why is this failing",
+    "error",
+    "not working",
+    "investigate",
+    "troubleshoot",
+    "find the issue"
+  ],
+  "auto_triggers": {
+    "on_error": true,
+    "on_test_failure": true,
+    "on_build_failure": true
+  },
+  "instructions": [
+    "Use systematic debugging approaches",
+    "Reproduce the issue step by step",
+    "Check error messages and stack traces",
+    "Analyze recent code changes (git diff)",
+    "Examine logs and console output",
+    "Identify root cause, not just symptoms",
+    "Suggest fixes with clear explanations",
+    "Add preventive measures to avoid recurrence"
+  ],
+  "debugging_steps": [
+    "1. Understand the expected vs actual behavior",
+    "2. Reproduce the issue consistently",
+    "3. Isolate the problem area",
+    "4. Form hypothesis about the cause",
+    "5. Test the hypothesis",
+    "6. Implement and verify the fix",
+    "7. Add regression test"
+  ],
+  "tools": ["Read", "Grep", "Glob", "Bash", "LSP"],
+  "permissions": "read-only"
+}

package/templates/.claude/agents/doc-writer.json

@@ -0,0 +1,37 @@
+{
+  "name": "doc-writer",
+  "description": "Professional documentation generation agent",
+  "version": "1.0.0",
+  "triggers": [
+    "write documentation",
+    "create docs",
+    "document this",
+    "generate readme",
+    "write readme",
+    "api documentation",
+    "update documentation"
+  ],
+  "auto_triggers": {
+    "on_file_change": ["*.ts", "*.tsx", "*.js", "*.py"],
+    "on_api_change": true,
+    "on_export_change": true
+  },
+  "instructions": [
+    "Use the professional-documentation-writer skill",
+    "Create clear, comprehensive documentation",
+    "Include practical code examples",
+    "Generate API references for public functions",
+    "Add installation and usage instructions",
+    "Include troubleshooting sections",
+    "Follow project documentation standards",
+    "Update table of contents automatically"
+  ],
+  "skills": ["documentation-writer"],
+  "output_format": {
+    "style": "markdown",
+    "include_toc": true,
+    "include_examples": true
+  },
+  "tools": ["Read", "Write", "Grep", "Glob"],
+  "permissions": "write"
+}

package/templates/.claude/agents/mobile-ui-specialist.json

@@ -0,0 +1,41 @@
+{
+  "name": "mobile-ui-specialist",
+  "description": "Professional mobile UI/UX optimization agent",
+  "version": "1.0.0",
+  "triggers": [
+    "mobile ui",
+    "responsive design",
+    "fix layout",
+    "card height",
+    "text overflow",
+    "mobile friendly",
+    "ui consistency",
+    "touch targets"
+  ],
+  "auto_triggers": {
+    "on_file_change": ["*.css", "*.scss", "*.tsx", "*.vue", "*.svelte"],
+    "on_component_change": true
+  },
+  "instructions": [
+    "Use the mobile-ui-ux-master skill for all UI work",
+    "Enforce equal card heights in horizontal grids",
+    "Prevent text overflow from breaking layouts",
+    "Ensure touch targets meet 44px minimum",
+    "Implement mobile-first responsive design",
+    "Use CSS Grid/Flexbox for consistent layouts",
+    "Apply proper text containment (line-clamp, ellipsis)",
+    "Test designs across screen sizes (320px to 4K)",
+    "Follow the mobile UX checklist"
+  ],
+  "skills": ["mobile-ui-ux-master"],
+  "quality_checks": [
+    "Card heights consistent in same row",
+    "No horizontal scrolling on mobile",
+    "Touch targets >= 44px",
+    "Text readable at 14px minimum",
+    "Images have proper aspect ratios",
+    "Forms work with mobile keyboards"
+  ],
+  "tools": ["Read", "Write", "Grep", "Glob"],
+  "permissions": "write"
+}

package/templates/.claude/agents/orchestrator.json

@@ -0,0 +1,42 @@
+{
+  "name": "agent-orchestrator",
+  "version": "1.0.0",
+  "description": "Central agent management and routing system",
+  "agents": [
+    "code-reviewer",
+    "doc-writer",
+    "test-generator",
+    "debugger",
+    "researcher",
+    "mobile-ui-specialist"
+  ],
+  "routing_rules": {
+    "priority_order": [
+      "debugger",
+      "code-reviewer",
+      "test-generator",
+      "mobile-ui-specialist",
+      "doc-writer",
+      "researcher"
+    ],
+    "multi_agent_allowed": true,
+    "fallback_agent": "researcher"
+  },
+  "auto_activation": {
+    "on_error": ["debugger"],
+    "on_commit": ["code-reviewer"],
+    "on_test_failure": ["debugger", "test-generator"],
+    "on_ui_change": ["mobile-ui-specialist"],
+    "on_api_change": ["doc-writer", "test-generator"]
+  },
+  "memory_integration": {
+    "enabled": true,
+    "log_agent_actions": true,
+    "learn_from_corrections": true
+  },
+  "hooks_integration": {
+    "pre_commit": ["code-reviewer"],
+    "post_commit": ["doc-writer"],
+    "pre_push": ["test-generator", "code-reviewer"]
+  }
+}

package/templates/.claude/agents/researcher.json

@@ -0,0 +1,48 @@
+{
+  "name": "researcher",
+  "description": "Technical research and best practices agent",
+  "version": "1.0.0",
+  "triggers": [
+    "research",
+    "find out",
+    "how to",
+    "best practice",
+    "compare",
+    "what is the best way",
+    "recommend",
+    "alternatives"
+  ],
+  "auto_triggers": {
+    "on_new_dependency": true,
+    "on_architecture_decision": true
+  },
+  "instructions": [
+    "Provide accurate, up-to-date technical information",
+    "Compare different approaches with pros/cons",
+    "Consider project context and constraints",
+    "Cite sources and provide documentation links",
+    "Suggest practical implementations",
+    "Evaluate security implications",
+    "Consider performance trade-offs",
+    "Log findings to memory system"
+  ],
+  "research_areas": [
+    "Libraries and frameworks",
+    "Design patterns",
+    "Best practices",
+    "Security considerations",
+    "Performance optimization",
+    "Architecture decisions"
+  ],
+  "output_format": {
+    "include_sources": true,
+    "include_comparison_table": true,
+    "include_recommendation": true
+  },
+  "tools": ["Read", "WebSearch", "WebFetch", "Grep"],
+  "permissions": "read-only",
+  "memory_integration": {
+    "log_decisions": true,
+    "log_learnings": true
+  }
+}

package/templates/.claude/agents/test-generator.json

@@ -0,0 +1,42 @@
+{
+  "name": "test-generator",
+  "description": "Comprehensive test suite creation agent",
+  "version": "1.0.0",
+  "triggers": [
+    "write tests",
+    "generate tests",
+    "create test",
+    "add tests",
+    "unit tests",
+    "integration tests",
+    "test this function",
+    "test coverage"
+  ],
+  "auto_triggers": {
+    "on_file_change": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.js"],
+    "on_new_function": true,
+    "on_api_change": true
+  },
+  "instructions": [
+    "Generate comprehensive unit tests for all public functions",
+    "Create integration tests for API endpoints",
+    "Include edge cases and error scenarios",
+    "Follow project's testing framework conventions",
+    "Aim for >80% code coverage",
+    "Mock external dependencies appropriately",
+    "Use descriptive test names that explain behavior",
+    "Add setup and teardown when needed"
+  ],
+  "test_frameworks": {
+    "javascript": ["jest", "vitest", "mocha"],
+    "typescript": ["jest", "vitest"],
+    "python": ["pytest", "unittest"],
+    "go": ["testing"]
+  },
+  "output_format": {
+    "file_naming": "{filename}.test.{ext}",
+    "structure": "describe/it"
+  },
+  "tools": ["Read", "Write", "Grep", "Glob", "Bash"],
+  "permissions": "write"
+}

package/templates/.claude/skills/persistent-memory-system/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: memory-system
+description: Intelligent project knowledge management with context tracking, decision logging, pattern recognition, and learning accumulation across development sessions.
+---
+
+# Claude Code Skill: Persistent Memory System
+
+## When to Use This Skill
+Use this skill when you need to:
+- Track project decisions and their rationale
+- Maintain context across development sessions
+- Log learnings and insights from development work
+- Record user preferences and working styles
+- Identify and document common patterns and solutions
+- Ensure continuity in long-term projects
+
+## Core Concepts: Memory Architecture
+
+### What Is the Persistent Memory System?
+The memory system is a structured knowledge base that maintains project context, tracks decisions, accumulates learnings, and preserves important information across development sessions. Unlike conversation history that gets lost, the memory system persists in files that are always available.
+
+### Memory Directory Structure
+```
+.claude/memory/
+├── context.md      # Current project state and active focus
+├── decisions.md    # Architectural decisions with rationale
+├── learnings.md    # Development insights and discoveries
+├── patterns.md     # Common solutions and code patterns
+└── preferences.md  # User preferences and working styles
+```
+
+## Memory File Specifications
+
+### 1. Context File (`context.md`)
+**Purpose**: Maintains current project state and active focus areas
+
+**Structure**:
+```markdown
+# Current Project Context
+
+## Project Overview
+**Name**: [Project name]
+**Type**: [Project type - web app, API, mobile, etc.]
+**Status**: [Current phase - setup, development, testing, production]
+
+## Active Components
+- [List of active features/skills/agents]
+
+## Current Focus
+- [What is currently being worked on]
+- [Immediate priorities]
+
+## Next Steps
+1. [Prioritized action items]
+2. [Upcoming tasks]
+
+## Recent Changes
+- [Date]: [Change description]
+```
+
+**When to Update**:
+- Project phase changes
+- New features or components added
+- Focus area shifts
+- After significant milestones
+
+### 2. Decisions File (`decisions.md`)
+**Purpose**: Logs architectural and technical decisions with full context
+
+**Structure**:
+```markdown
+# Major Project Decisions
+
+## [Date] - [Decision Title]
+**Context**: [What prompted this decision]
+**Decision**: [What was decided]
+**Rationale**: [Why this choice was made]
+**Alternatives Considered**: [Other options that were evaluated]
+**Expected Impact**: [Anticipated effects of this decision]
+**Status**: [Active/Superseded/Under Review]
+```
+
+**When to Update**:
+- Technology stack choices
+- Architecture patterns selected
+- Library/framework decisions
+- Breaking changes introduced
+- API design decisions
+- Database schema changes
+
+### 3. Learnings File (`learnings.md`)
+**Purpose**: Captures development insights and discoveries
+
+**Structure**:
+```markdown
+# Key Learnings and Insights
+
+## [Date] - [Learning Title]
+**Insight**: [What was learned]
+**Context**: [How this was discovered]
+**Application**: [How to apply this learning]
+**Evidence**: [Supporting information or references]
+```
+
+**When to Update**:
+- Bug root causes discovered
+- Performance optimizations found
+- Best practices identified
+- Gotchas and edge cases encountered
+- Successful patterns recognized
+
+### 4. Patterns File (`patterns.md`)
+**Purpose**: Documents reusable code patterns and solutions
+
+**Structure**:
+```markdown
+# Common Patterns and Solutions
+
+## [Pattern Name]
+**Use Case**: [When to use this pattern]
+**Implementation**:
+```[language]
+[Code example]
+```
+**Notes**: [Important considerations]
+**Related Patterns**: [Links to related patterns]
+```
+
+**When to Update**:
+- Reusable solution created
+- Error handling approach established
+- API response format defined
+- Component structure standardized
+- Testing approach documented
+
+### 5. Preferences File (`preferences.md`)
+**Purpose**: Records user preferences and working styles
+
+**Structure**:
+```markdown
+# User Preferences and Working Styles
+
+## Development Environment
+**IDE**: [Preferred IDE/editor]
+**Theme**: [UI preferences]
+**Tools**: [Preferred tools and utilities]
+
+## Code Style Preferences
+**Language**: [Preferred languages]
+**Architecture**: [Preferred patterns]
+**Naming**: [Naming conventions]
+**Documentation**: [Documentation style]
+
+## Communication Style
+**Feedback**: [How user prefers feedback]
+**Documentation**: [Preferred documentation tone]
+**Decision Making**: [How decisions should be presented]
+
+## Tool Preferences
+**Version Control**: [Git preferences]
+**Testing**: [Testing framework preferences]
+**Linting**: [Code quality tools]
+```
+
+**When to Update**:
+- User expresses preferences
+- Working patterns emerge
+- Tool choices made
+- Communication style preferences noted
+
+## Memory Operations
+
+### Reading Memory
+Before making decisions or providing recommendations:
+1. Check `context.md` for current project state
+2. Review `decisions.md` for relevant past decisions
+3. Consult `learnings.md` for applicable insights
+4. Reference `patterns.md` for established solutions
+5. Consider `preferences.md` for user preferences
+
+### Writing to Memory
+When updating memory files:
+1. Use consistent date format (YYYY-MM-DD)
+2. Provide complete context for each entry
+3. Link related entries across files
+4. Keep entries concise but comprehensive
+5. Include actionable information
+
+### Memory Integration with Hooks
+Post-commit hooks can automatically update memory:
+```bash
+# Example: Auto-log decisions from commit messages
+if echo "$COMMIT_MSG" | grep -i "decision\|architecture"; then
+    echo "## $(date) - $COMMIT_MSG" >> .claude/memory/decisions.md
+fi
+```
+
+## Best Practices
+
+### Memory Hygiene
+- Review memory files periodically for relevance
+- Archive outdated decisions (mark as superseded)
+- Keep context.md current with project state
+- Prune learnings that no longer apply
+
+### Cross-referencing
+- Reference decision IDs in code comments
+- Link patterns to decisions that created them
+- Connect learnings to specific implementations
+
+### Team Collaboration
+- Memory files should be committed to version control
+- Team members can add to shared learnings
+- Decisions provide onboarding context for new members
+
+## Input Requirements
+- Project context and current state
+- Decisions being made with rationale
+- Insights and learnings discovered
+- User preferences as they emerge
+- Patterns and solutions developed
+
+## Output Format
+Return memory updates in clean markdown format with:
+- Consistent date formatting
+- Clear section headers
+- Complete context for each entry
+- Links to related information
+- Actionable recommendations

package/templates/.claude/skills/persistent-memory-system/memory-templates.md

@@ -0,0 +1,152 @@
+# Memory File Templates
+
+## Quick Reference Templates for Memory System Files
+
+### Context Entry Template
+```markdown
+## Project Overview
+**Name**: [PROJECT_NAME]
+**Type**: [web app | API | mobile app | library | CLI tool]
+**Status**: [setup | development | testing | staging | production]
+**Started**: [YYYY-MM-DD]
+
+## Active Components
+- [ ] Component 1
+- [ ] Component 2
+
+## Current Focus
+- Primary: [Main focus area]
+- Secondary: [Supporting work]
+
+## Blockers
+- [Any current blockers]
+
+## Next Steps
+1. [Priority 1]
+2. [Priority 2]
+3. [Priority 3]
+```
+
+### Decision Entry Template
+```markdown
+## [YYYY-MM-DD] - [Decision Title]
+
+**Context**:
+[What situation prompted this decision? What problem are we solving?]
+
+**Decision**:
+[What was decided? Be specific and actionable.]
+
+**Rationale**:
+[Why this choice over alternatives? What factors influenced the decision?]
+
+**Alternatives Considered**:
+1. [Alternative 1] - [Why rejected]
+2. [Alternative 2] - [Why rejected]
+
+**Expected Impact**:
+- [Impact 1]
+- [Impact 2]
+
+**Review Date**: [When to revisit this decision]
+**Status**: [Active | Superseded | Under Review]
+```
+
+### Learning Entry Template
+```markdown
+## [YYYY-MM-DD] - [Learning Title]
+
+**Insight**:
+[One-sentence summary of what was learned]
+
+**Context**:
+[How was this discovered? What were you working on?]
+
+**Details**:
+[Deeper explanation of the learning]
+
+**Application**:
+[How should this be applied going forward?]
+
+**Evidence**:
+[Links, references, or examples that support this]
+
+**Tags**: [tag1, tag2, tag3]
+```
+
+### Pattern Entry Template
+```markdown
+## [Pattern Name]
+
+**Category**: [Error Handling | Data Fetching | State Management | Testing | etc.]
+
+**Use Case**:
+[When should this pattern be used?]
+
+**Problem**:
+[What problem does this solve?]
+
+**Solution**:
+```[language]
+// Code implementation
+```
+
+**Example Usage**:
+```[language]
+// Real-world example
+```
+
+**Pros**:
+- [Advantage 1]
+- [Advantage 2]
+
+**Cons**:
+- [Tradeoff 1]
+- [Tradeoff 2]
+
+**Related Patterns**:
+- [Link to related pattern 1]
+- [Link to related pattern 2]
+
+**References**:
+- [External resource or documentation]
+```
+
+### Preference Entry Template
+```markdown
+## [Category] Preferences
+
+### [Subcategory]
+**Preference**: [What is preferred]
+**Reason**: [Why this preference exists]
+**Exceptions**: [When to deviate from this preference]
+
+### Examples
+- Preferred: [Example of preferred approach]
+- Avoid: [Example of what to avoid]
+```
+
+## Memory Update Checklist
+
+### After Major Decisions
+- [ ] Add entry to decisions.md
+- [ ] Update context.md if project direction changed
+- [ ] Check if patterns.md needs new pattern
+- [ ] Note any learnings discovered
+
+### After Bug Fixes
+- [ ] Add root cause to learnings.md
+- [ ] Document fix pattern in patterns.md if reusable
+- [ ] Update context.md with current focus
+
+### After Feature Completion
+- [ ] Update context.md with new components
+- [ ] Document any new patterns discovered
+- [ ] Log architectural decisions made
+- [ ] Capture learnings from implementation
+
+### Weekly Review
+- [ ] Is context.md accurate?
+- [ ] Are there decisions that should be reviewed?
+- [ ] Any learnings to add from recent work?
+- [ ] New patterns worth documenting?