feat: initial Claude Skills marketplace

Includes three production-ready skills for software engineering workflows:
- git-pushing: Automated git workflows with conventional commits
- test-fixing: Smart test failure resolution with error grouping
- review-implementing: Systematic code review feedback implementation

Features:
- Comprehensive documentation and contributing guidelines
- Apache 2.0 license for open source distribution
- Installation instructions for Claude Code
- Best practices guide for skill authoring

Skills use natural language activation instead of slash commands,
making them more intuitive and context-aware.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
mhattingpete
2025-10-17 13:59:18 +02:00
co-authored by Claude
commit 9245763ed6
8 changed files with 1055 additions and 0 deletions
+38
View File
@@ -0,0 +1,38 @@
# macOS
.DS_Store
.AppleDouble
.LSOverride
# Thumbnails
._*
# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
.com.apple.timemachine.donotpresent
# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk
# Backup files
*.bak
*~
# IDE
.idea/
.vscode/
*.swp
*.swo
*.swn
# Testing
test_outputs/
*.log
+194
View File
@@ -0,0 +1,194 @@
# Contributing to Claude Skills Marketplace
Thank you for your interest in contributing! This guide will help you create high-quality Skills that work reliably across different Claude models.
## Skill Structure
A basic Skill consists of:
```
skill-name/
├── SKILL.md # Required: Main skill file
├── reference.md # Optional: Detailed reference material
├── examples/ # Optional: Example files or templates
└── scripts/ # Optional: Executable scripts
```
## SKILL.md Format
```yaml
---
name: skill-name
description: What it does and when to use it. Include activation triggers.
model: sonnet # Optional: Preferred model (sonnet, opus, haiku)
---
# Skill Title
Brief overview (1-2 sentences).
## When to Use
Specific activation scenarios:
- User says "X"
- Context includes Y
- Task involves Z
## Instructions
Step-by-step instructions for Claude...
```
## Best Practices
### 1. Write Clear Descriptions
**Good:**
```yaml
description: Analyze vendorlist extraction performance and F1-scores. Use when user mentions vendorlist evaluation, low F1-scores, extraction accuracy issues, or asks to analyze vendorlist performance.
```
**Bad:**
```yaml
description: Helps with vendorlists
```
The description should answer:
- **What** does this skill do?
- **When** should it activate?
- **Why** would someone use it?
### 2. Use Gerund Names
**Good:** `git-pushing`, `test-fixing`, `review-implementing`
**Bad:** `git-push`, `fix-test`, `implement-review`
Gerund forms (-ing) indicate ongoing processes and match natural language patterns.
### 3. Keep Skills Focused
Each Skill should do ONE thing well. If you find yourself writing "and also" in the description, consider splitting into separate Skills.
### 4. Structure for Progressive Disclosure
**Keep SKILL.md under 500 lines:**
- Core instructions in SKILL.md
- Detailed reference material in reference.md
- Examples in separate files
This allows Claude to load only what's needed.
### 5. Assume Claude's Knowledge
Don't explain basic concepts. Claude already knows Python, git, testing frameworks, etc.
**Good:**
```markdown
Run `pytest -k "pattern"` to test specific cases.
```
**Bad:**
```markdown
Pytest is a testing framework for Python. The -k flag filters tests by pattern. You should use this command: `pytest -k "pattern"` to run tests that match the pattern.
```
### 6. Match Specificity to Risk
**High-risk operations** (database migrations, deployments):
- Provide step-by-step instructions
- Include validation checks
- Require confirmation
**Low-risk operations** (code formatting, documentation):
- Give general guidance
- Allow flexibility
### 7. Use Platform-Agnostic Paths
**Good:** `backend/src/utils/helper.py`
**Bad:** `backend\src\utils\helper.py`
Always use forward slashes for file paths.
### 8. Test Across Models
Test your Skill with:
- Claude Sonnet (balanced)
- Claude Opus (most capable)
- Claude Haiku (fastest)
Some models may need more detail than others.
## Submission Process
1. **Fork this repository**
2. **Create your skill:**
```bash
mkdir my-skill
cd my-skill
# Create SKILL.md following the template
```
3. **Test thoroughly:**
- Test with different phrasings
- Verify activation triggers work
- Check across multiple models if possible
4. **Update README.md:**
- Add your skill to the "Available Skills" section
- Include activation examples
- Describe what it does
5. **Submit Pull Request:**
- Title: "Add [skill-name] skill"
- Description: Explain what the skill does and why it's useful
- Include example usage
## Skill Categories
Organize your skill into one of these categories:
- **Git & Version Control**: Git workflows, commits, branches
- **Testing & Quality**: Test running, fixing, coverage
- **Code Review**: Review feedback, PR management
- **Documentation**: Docs generation, README updates
- **DevOps**: CI/CD, deployment, infrastructure
- **Data Processing**: ETL, analysis, transformation
- **Development Tools**: Linting, formatting, refactoring
## Examples of Good Skills
Look at existing skills in this repository for inspiration:
- **git-pushing**: Clear activation triggers, conventional commits
- **test-fixing**: Smart grouping strategy, systematic approach
- **review-implementing**: Todo tracking, systematic workflow
## Quality Checklist
Before submitting, verify:
- [ ] YAML frontmatter is valid
- [ ] Description includes activation triggers
- [ ] Instructions are concise (no unnecessary explanations)
- [ ] File paths use forward slashes
- [ ] Skill is under 500 lines (or uses reference files)
- [ ] Examples demonstrate activation
- [ ] README.md updated with new skill
- [ ] Tested with actual use cases
- [ ] No hard-coded paths or environment-specific details
## Getting Help
Questions or need guidance?
- Open an issue with your question
- Check [official documentation](https://docs.claude.com/en/docs/claude-code/skills)
- Look at [Anthropic's skills](https://github.com/anthropics/skills) for examples
## License
By contributing, you agree that your contributions will be licensed under the Apache 2.0 License.
+69
View File
@@ -0,0 +1,69 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work.
"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or countermlaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
(a) You must give any other recipients of the Work or Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
Copyright 2025 mhattingpete
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
+158
View File
@@ -0,0 +1,158 @@
# Claude Skills Marketplace
A curated collection of Claude Code Skills for software engineering workflows, focusing on data processing, testing, and DevOps automation.
## What are Skills?
Skills are model-invoked capabilities that extend Claude Code's functionality. Unlike slash commands that require explicit user activation, Skills are automatically triggered by Claude based on context and the Skill's description.
Each Skill consists of a `SKILL.md` file with:
- YAML frontmatter (name, description, metadata)
- Detailed instructions for Claude
- Optional supporting files (scripts, templates, references)
## Installation
### Install All Skills
```bash
# In Claude Code
/plugin marketplace add mhattingpete/claude-skills-marketplace
```
### Install Individual Skills
```bash
# Clone this repository
git clone https://github.com/mhattingpete/claude-skills-marketplace.git
# Copy specific skill to your project
cp -r claude-skills-marketplace/git-pushing .claude/skills/
# Or copy to personal skills directory (available across all projects)
cp -r claude-skills-marketplace/git-pushing ~/.claude/skills/
```
## Available Skills
### Git & Version Control
#### `git-pushing`
Automatically stage, commit with conventional commit messages, and push changes to remote.
**Activates when:** User mentions pushing changes, committing work, or saving to remote.
**Example usage:**
- "Push these changes"
- "Commit and push to github"
- "Let's save this work"
---
### Testing & Quality
#### `test-fixing`
Systematically identify and fix failing tests using smart error grouping strategies.
**Activates when:** User reports test failures, asks to fix tests, or wants test suite passing.
**Example usage:**
- "Fix the failing tests"
- "Make the test suite green"
- "Tests are broken after my refactor"
---
### Code Review
#### `review-implementing`
Process and implement code review feedback systematically with todo tracking.
**Activates when:** User provides reviewer comments, PR feedback, or asks to address review notes.
**Example usage:**
- "Implement this review feedback: [paste comments]"
- "Address these PR comments"
- "The reviewer suggested these changes"
---
## Skill Locations
Skills can be installed in three locations:
- **Project Skills**: `.claude/skills/` (team-shared, version-controlled)
- **Personal Skills**: `~/.claude/skills/` (available across all your projects)
- **Plugin Skills**: Installed via plugin marketplace
## Creating Custom Skills
Want to create your own Skills? Follow this structure:
```
my-skill/
├── SKILL.md # Main skill file with frontmatter and instructions
└── reference.md # Optional: Additional context loaded on-demand
```
### SKILL.md Template
```yaml
---
name: my-skill-name
description: What it does and when to use it. Be specific about activation triggers.
---
# Skill Title
Brief overview of what this skill does.
## When to Use
List specific scenarios when Claude should activate this skill:
- User says X
- User mentions Y
- Context includes Z
## Instructions
Step-by-step instructions for Claude to follow...
```
### Best Practices
1. **Description is key**: Include both what the skill does AND when to use it
2. **Use gerund forms**: Name skills with "-ing" (e.g., "git-pushing", not "git-push")
3. **Keep concise**: Skills under 500 lines load faster
4. **Progressive disclosure**: Move detailed content to separate reference files
5. **Test across models**: Verify skills work with Sonnet, Opus, and Haiku
## Contributing
Contributions are welcome! To add a new skill:
1. Fork this repository
2. Create your skill in a new directory
3. Follow the SKILL.md template and best practices
4. Add your skill to this README
5. Submit a pull request
## License
Apache 2.0 - See LICENSE file for details.
## Resources
- [Claude Code Documentation](https://docs.claude.com/en/docs/claude-code/skills)
- [Official Anthropic Skills](https://github.com/anthropics/skills)
- [Agent Skills Best Practices](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/best-practices.md)
## Support
Issues and questions:
- Open an issue on this repository
- Check [Claude Code discussions](https://github.com/anthropics/claude-code/discussions)
---
**Note**: These skills are designed for the 25L Taxonomy Assistant project but are generalized for broader use. Adapt descriptions and instructions to fit your specific workflows.
+248
View File
@@ -0,0 +1,248 @@
# Setting Up Your Claude Skills Marketplace
This guide walks through publishing your Skills marketplace on GitHub.
## Prerequisites
- GitHub account
- Git installed locally
- Skills repository created at `~/Documents/Repos/claude-skills-marketplace`
## Step 1: Initialize Git Repository
```bash
cd ~/Documents/Repos/claude-skills-marketplace
# Initialize git
git init
# Add all files
git add .
# Create initial commit
git commit -m "feat: initial Skills marketplace with git-pushing, test-fixing, and review-implementing
Includes:
- Three production-ready Skills
- Documentation and contributing guidelines
- Apache 2.0 license
- Installation instructions
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>"
```
## Step 2: Create GitHub Repository
### Option A: Using GitHub CLI
```bash
# Install gh if not already installed
# macOS: brew install gh
# Authenticate
gh auth login
# Create public repository
gh repo create claude-skills-marketplace --public --source=. --remote=origin
# Push to GitHub
git push -u origin main
```
### Option B: Using GitHub Web Interface
1. Go to https://github.com/new
2. Repository name: `claude-skills-marketplace`
3. Description: "Claude Code Skills for software engineering workflows"
4. Visibility: **Public**
5. Do NOT initialize with README (we already have one)
6. Click "Create repository"
Then push:
```bash
git remote add origin git@github.com:mhattingpete/claude-skills-marketplace.git
git branch -M main
git push -u origin main
```
## Step 3: Configure Repository
### Add Topics
Add GitHub topics for discoverability:
1. Go to repository settings
2. Under "About", click ⚙️
3. Add topics:
- `claude-code`
- `claude-skills`
- `ai-agents`
- `anthropic`
- `developer-tools`
- `automation`
### Update Repository Description
```
Claude Code Skills for software engineering workflows - Git automation, testing, and code review
```
### Add Website Link
```
https://docs.claude.com/en/docs/claude-code/skills
```
## Step 4: Enable GitHub Pages (Optional)
If you want a website for your Skills:
1. Settings → Pages
2. Source: Deploy from branch
3. Branch: `main` / `root`
4. Save
GitHub will generate a site at: `https://mhattingpete.github.io/claude-skills-marketplace`
## Step 5: Test Installation
### Via Plugin Marketplace (Once Registered)
```bash
# In Claude Code
/plugin marketplace add mhattingpete/claude-skills-marketplace
```
Note: This requires registering with Claude Code plugin system (contact Anthropic or check docs).
### Manual Installation
```bash
# Clone to test
git clone https://github.com/mhattingpete/claude-skills-marketplace.git /tmp/test-skills
# Copy a skill
cp -r /tmp/test-skills/git-pushing ~/.claude/skills/
# Test in Claude Code
# Say: "Push these changes"
# The git-pushing skill should activate
```
## Step 6: Promote Your Marketplace
### Add to README Badges
```markdown
![Skills](https://img.shields.io/badge/Skills-3-blue)
![License](https://img.shields.io/badge/license-Apache%202.0-green)
![Claude Code](https://img.shields.io/badge/Claude%20Code-Compatible-purple)
```
### Share Links
- Anthropic Claude community
- Reddit: r/ClaudeAI
- Twitter/X with #ClaudeCode hashtag
- Discord communities
### Create Announcement
Example post:
```
🚀 Just published claude-skills-marketplace - a collection of Claude Code
Skills for common dev workflows!
Includes:
✅ Git automation with conventional commits
✅ Smart test fixing with error grouping
✅ Code review feedback implementation
All skills use natural language - no need to memorize commands!
Check it out: https://github.com/mhattingpete/claude-skills-marketplace
```
## Maintenance
### Adding New Skills
```bash
# Create new skill directory
mkdir my-new-skill
# Create SKILL.md
# ... (following guidelines in CONTRIBUTING.md)
# Test locally
cp -r my-new-skill ~/.claude/skills/
# Commit and push
git add my-new-skill
git commit -m "feat(skills): add my-new-skill for X functionality"
git push
```
### Accepting Contributions
1. Review PRs for:
- Valid SKILL.md format
- Clear description with triggers
- Follows best practices
- Updated README
2. Test the skill locally
3. Merge if quality standards met
### Versioning
Consider semantic versioning for major updates:
```bash
# Tag releases
git tag -a v1.0.0 -m "Release v1.0.0: Initial three skills"
git push --tags
```
## Troubleshooting
### Skills Don't Load
- Verify YAML frontmatter is valid
- Check file is named `SKILL.md` (case-sensitive)
- Ensure description field exists
### Installation Issues
- Confirm repository is public
- Check file permissions (should be readable)
- Verify directory structure matches examples
### Activation Problems
- Review description for clear triggers
- Test with exact phrases from description
- Add more activation examples
## Next Steps
1. **Create more Skills**: Identify common workflows in your projects
2. **Gather feedback**: Ask users what they'd like automated
3. **Contribute upstream**: Share generalized Skills with Anthropic
4. **Build community**: Encourage contributions
## Resources
- [Claude Code Documentation](https://docs.claude.com/en/docs/claude-code/skills)
- [Anthropic Skills Repo](https://github.com/anthropics/skills)
- [Skills Best Practices](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/best-practices.md)
## Support
Questions or issues?
- Open an issue on GitHub
- Check Claude Code discussions
- Contact via repository discussions
+83
View File
@@ -0,0 +1,83 @@
---
name: git-pushing
description: Stage, commit, and push git changes with conventional commit messages. Use when user wants to commit and push changes, mentions pushing to remote, or asks to save and push their work. Also activates when user says "push changes", "commit and push", or similar git workflow requests.
---
# Git Push Workflow
Stage all changes, create a conventional commit, and push to the remote branch.
## When to Use
Automatically activate when the user:
- Explicitly asks to push changes ("push this", "commit and push")
- Mentions saving work to remote ("save to github", "push to remote")
- Completes a feature and wants to share it
- Says phrases like "let's push this up" or "commit these changes"
## Workflow
### 1. Check Git Status
Run `git status` to understand:
- Which files have changed
- What will be committed
- Current branch name
### 2. Stage Changes
- Run `git add .` to stage all changes
- Alternatively, stage specific files if partial commit is needed
### 3. Create Commit Message
**If user provided a message:**
- Use it directly
**If no message provided:**
- Analyze changes using `git diff`
- Generate a conventional commit message:
- Format: `type(scope): description`
- Types: `feat`, `fix`, `refactor`, `docs`, `test`, `chore`
- Keep description concise (50-90 characters)
- Use imperative mood: "Add" not "Added"
- Always append Claude Code footer:
```
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
```
**Use heredoc format:**
```bash
git commit -m "$(cat <<'EOF'
commit message here
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
EOF
)"
```
### 4. Push to Remote
- Run `git push` to push commits
- If push fails due to diverged branches, inform user and ask how to proceed
### 5. Confirm Success
- Report commit hash
- Summarize what was committed
- Confirm push succeeded
## Examples
User: "Push these changes"
→ Check status, stage all, generate commit message, push
User: "Commit with message 'fix: resolve table extraction issue'"
→ Use provided message, push
User: "Let's save this to github"
→ Activate workflow, generate appropriate commit message
+155
View File
@@ -0,0 +1,155 @@
---
name: review-implementing
description: Process and implement code review feedback systematically. Use when user provides reviewer comments, PR feedback, code review notes, or asks to implement suggestions from reviews. Activates on phrases like "implement this feedback", "address review comments", or when user pastes reviewer notes.
---
# Review Feedback Implementation
Systematically process and implement changes based on code review feedback.
## When to Use
Automatically activate when the user:
- Provides reviewer comments or feedback
- Pastes PR review notes
- Mentions implementing review suggestions
- Says "address these comments" or "implement feedback"
- Shares a list of changes requested by reviewers
## Systematic Workflow
### 1. Parse Reviewer Notes
Identify individual feedback items:
- Split numbered lists (1., 2., etc.)
- Handle bullet points or unnumbered feedback
- Extract distinct change requests
- Clarify any ambiguous items before starting
### 2. Create Todo List
Use TodoWrite tool to create actionable tasks:
- Each feedback item becomes one or more todos
- Break down complex feedback into smaller tasks
- Make tasks specific and measurable
- Mark first task as `in_progress` before starting
Example:
```
- Add type hints to extract function
- Fix duplicate tag detection logic
- Update docstring in chain.py
- Add unit test for edge case
```
### 3. Implement Changes Systematically
For each todo item:
**Locate relevant code:**
- Use Grep to search for functions/classes
- Use Glob to find files by pattern
- Read current implementation
**Make changes:**
- Use Edit tool for modifications
- Follow project conventions (CLAUDE.md)
- Preserve existing functionality unless changing behavior
**Verify changes:**
- Check syntax correctness
- Run relevant tests if applicable
- Ensure changes address reviewer's intent
**Update status:**
- Mark todo as `completed` immediately after finishing
- Move to next todo (only one `in_progress` at a time)
### 4. Handle Different Feedback Types
**Code changes:**
- Use Edit tool for existing code
- Follow type hint conventions (PEP 604/585)
- Maintain consistent style
**New features:**
- Create new files with Write tool if needed
- Add corresponding tests
- Update documentation
**Documentation:**
- Update docstrings following project style
- Modify markdown files as needed
- Keep explanations concise
**Tests:**
- Write tests as functions, not classes
- Use descriptive names
- Follow pytest conventions
**Refactoring:**
- Preserve functionality
- Improve code structure
- Run tests to verify no regressions
### 5. Validation
After implementing changes:
- Run affected tests
- Check for linting errors: `uv run ruff check`
- Verify changes don't break existing functionality
### 6. Communication
Keep user informed:
- Update todo list in real-time
- Ask for clarification on ambiguous feedback
- Report blockers or challenges
- Summarize changes at completion
## Edge Cases
**Conflicting feedback:**
- Ask user for guidance
- Explain the conflict clearly
**Breaking changes required:**
- Notify user before implementing
- Discuss impact and alternatives
**Tests fail after changes:**
- Fix tests before marking todo complete
- Ensure all related tests pass
**Referenced code doesn't exist:**
- Ask user for clarification
- Verify understanding before proceeding
## Important Guidelines
- **Always use TodoWrite** for tracking progress
- **Mark todos completed immediately** after each item
- **Only one todo in_progress** at any time
- **Don't batch completions** - update status in real-time
- **Ask questions** for unclear feedback
- **Run tests** if changes affect tested code
- **Follow CLAUDE.md conventions** for all code changes
- **Use conventional commits** if creating commits afterward
## Example
User: "Implement these review comments:
1. Add type hints to the extract function
2. Fix the duplicate tag detection logic
3. Update the docstring in chain.py"
**Actions:**
1. Create TodoWrite with 3 items
2. Mark item 1 as in_progress
3. Grep for extract function
4. Read file containing function
5. Edit to add type hints
6. Mark item 1 completed
7. Mark item 2 in_progress
8. Repeat process for remaining items
9. Summarize all changes made
+110
View File
@@ -0,0 +1,110 @@
---
name: test-fixing
description: Run tests and systematically fix all failing tests using smart error grouping. Use when user asks to fix failing tests, mentions test failures, runs test suite and failures occur, or requests to make tests pass. Activates on phrases like "fix the tests", "tests are failing", or "make the test suite green".
---
# Test Fixing Workflow
Systematically identify and fix all failing tests using smart grouping strategies.
## When to Use
Automatically activate when the user:
- Explicitly asks to fix tests ("fix these tests", "make tests pass")
- Reports test failures ("tests are failing", "test suite is broken")
- Completes implementation and wants tests passing
- Mentions CI/CD failures due to tests
## Systematic Approach
### 1. Initial Test Run
Run `make test` to identify all failing tests.
Analyze output for:
- Total number of failures
- Error types and patterns
- Affected modules/files
### 2. Smart Error Grouping
Group similar failures by:
- **Error type**: ImportError, AttributeError, AssertionError, etc.
- **Module/file**: Same file causing multiple test failures
- **Root cause**: Missing dependencies, API changes, refactoring impacts
Prioritize groups by:
- Number of affected tests (highest impact first)
- Dependency order (fix infrastructure before functionality)
### 3. Systematic Fixing Process
For each group (starting with highest impact):
1. **Identify root cause**
- Read relevant code
- Check recent changes with `git diff`
- Understand the error pattern
2. **Implement fix**
- Use Edit tool for code changes
- Follow project conventions (see CLAUDE.md)
- Make minimal, focused changes
3. **Verify fix**
- Run subset of tests for this group
- Use pytest markers or file patterns:
```bash
uv run pytest tests/path/to/test_file.py -v
uv run pytest -k "pattern" -v
```
- Ensure group passes before moving on
4. **Move to next group**
### 4. Fix Order Strategy
**Infrastructure first:**
- Import errors
- Missing dependencies
- Configuration issues
**Then API changes:**
- Function signature changes
- Module reorganization
- Renamed variables/functions
**Finally, logic issues:**
- Assertion failures
- Business logic bugs
- Edge case handling
### 5. Final Verification
After all groups fixed:
- Run complete test suite: `make test`
- Verify no regressions
- Check test coverage remains intact
## Best Practices
- Fix one group at a time
- Run focused tests after each fix
- Use `git diff` to understand recent changes
- Look for patterns in failures
- Don't move to next group until current passes
- Keep changes minimal and focused
## Example Workflow
User: "The tests are failing after my refactor"
1. Run `make test` → 15 failures identified
2. Group errors:
- 8 ImportErrors (module renamed)
- 5 AttributeErrors (function signature changed)
- 2 AssertionErrors (logic bugs)
3. Fix ImportErrors first → Run subset → Verify
4. Fix AttributeErrors → Run subset → Verify
5. Fix AssertionErrors → Run subset → Verify
6. Run full suite → All pass ✓