tapps-agents 3.5.41__py3-none-any.whl → 3.6.1__py3-none-any.whl

tapps_agents/resources/claude/commands/README.md

@@ -0,0 +1,156 @@
+# Claude Desktop Commands
+
+This directory contains Claude Desktop commands that work alongside Cursor Skills. These commands provide the same functionality in both Claude Desktop and Cursor IDE.
+
+## Quick Start
+
+Use commands in Claude Desktop by typing `@command-name`:
+
+```
+@review src/api/auth.py
+@build "Create a user authentication feature"
+@test src/api/auth.py
+```
+
+## Available Commands
+
+### Core Development Commands
+
+| Command | Description | Cursor Equivalent |
+|---------|-------------|-------------------|
+| `@review` | Full code review with scoring | `@reviewer *review` |
+| `@score` | Quick quality scoring | `@reviewer *score` |
+| `@implement` | Generate code from description | `@implementer *implement` |
+| `@test` | Generate and run tests | `@tester *test` |
+| `@debug` | Debug errors and find root cause | `@debugger *debug` |
+| `@refactor` | Refactor code with instructions | `@implementer *refactor` |
+| `@improve` | Improve code quality | `@improver *improve` |
+| `@lint` | Run code linting | `@reviewer *lint` |
+
+### Planning & Design Commands
+
+| Command | Description | Cursor Equivalent |
+|---------|-------------|-------------------|
+| `@plan` | Create development plan | `@planner *plan` |
+| `@design` | Design system architecture | `@architect *design` |
+| `@docs` | Generate documentation | `@documenter *document` |
+
+### Quality & Security Commands
+
+| Command | Description | Cursor Equivalent |
+|---------|-------------|-------------------|
+| `@security-scan` | Scan for vulnerabilities | `@reviewer *security-scan` |
+| `@library-docs` | Get library documentation | `@reviewer *docs` |
+
+### Workflow Commands (Simple Mode)
+
+| Command | Description | Cursor Equivalent |
+|---------|-------------|-------------------|
+| `@build` | Complete feature workflow | `@simple-mode *build` |
+| `@fix` | Fix bugs with debugging | `@simple-mode *fix` |
+
+## Usage Examples
+
+### Code Review
+```
+@review src/api/auth.py
+@score src/utils/helpers.py
+@lint src/ --fix
+```
+
+### Code Generation
+```
+@implement "Create a user authentication API" src/api/auth.py
+@refactor src/api/auth.py "Improve error handling"
+@improve src/utils/helpers.py "Add type hints"
+```
+
+### Testing
+```
+@test src/api/auth.py
+@test src/utils/helpers.py --integration
+```
+
+### Debugging
+```
+@debug "Null pointer error on line 42" --file src/api/auth.py
+@fix src/api/auth.py "Fix authentication token validation"
+```
+
+### Planning & Design
+```
+@plan "Create a user authentication feature"
+@design "REST API for product management"
+@docs src/api/auth.py
+```
+
+### Complete Workflows
+```
+@build "Create a user authentication API with JWT tokens"
+@fix src/api/auth.py "Fix the null pointer error"
+```
+
+### Library Documentation
+```
+@library-docs fastapi
+@library-docs fastapi routing
+@library-docs pytest fixtures
+```
+
+## Integration with Cursor Skills
+
+These commands are designed to work alongside Cursor Skills:
+
+- **Claude Desktop**: Use `@command-name` (these commands)
+- **Cursor IDE**: Use `@agent-name *command` (Cursor Skills)
+- **CLI**: Use `tapps-agents <agent> <command>` (terminal)
+
+All three interfaces provide the same functionality, so you can use whichever is most convenient for your workflow.
+
+## Command Details
+
+See individual command files for detailed usage:
+- `review.md` - Code review with scoring
+- `score.md` - Quick quality scoring
+- `implement.md` - Code generation
+- `test.md` - Test generation
+- `debug.md` - Error debugging
+- `build.md` - Complete feature workflow
+- `fix.md` - Bug fixing workflow
+- `refactor.md` - Code refactoring
+- `improve.md` - Code improvement
+- `lint.md` - Code linting
+- `plan.md` - Development planning
+- `design.md` - System design
+- `docs.md` - Documentation generation
+- `security-scan.md` - Security scanning
+- `library-docs.md` - Library documentation
+
+## Best Practices
+
+1. **Use `@build` for new features** - Complete workflow with all quality gates
+2. **Use `@review` before committing** - Ensure code quality
+3. **Use `@test` after implementation** - Verify functionality
+4. **Use `@fix` for bugs** - Systematic debugging workflow
+5. **Use `@library-docs` for API reference** - Get up-to-date library docs
+
+## Configuration
+
+Commands use the same configuration as Cursor Skills:
+- `.tapps-agents/config.yaml` - Project configuration
+- `.tapps-agents/kb/context7-cache` - Library documentation cache
+
+## Troubleshooting
+
+If a command doesn't work:
+1. Check that TappsCodingAgents is installed: `pip list | grep tapps-agents`
+2. Verify configuration: Check `.tapps-agents/config.yaml`
+3. Check command syntax: See individual command files
+4. Try CLI equivalent: `tapps-agents <agent> <command>`
+
+## Related Documentation
+
+- **Cursor Skills**: See `.claude/skills/` for Cursor Skills
+- **CLI Reference**: See `docs/TAPPS_AGENTS_COMMAND_REFERENCE.md`
+- **Quick Reference**: See `.cursor/rules/quick-reference.mdc`
+

tapps_agents/resources/claude/commands/__init__.py

@@ -0,0 +1 @@
+"""Claude Desktop command definitions."""

tapps_agents/resources/claude/commands/build-fix.md

@@ -0,0 +1,22 @@
+# Build Fix Command (Simple Mode)
+
+Fix build/compile errors (Python, npm, tsc, cargo). Distinct from *fix (runtime) and *fix-tests.
+
+## Usage
+
+```
+@build-fix "<build-output or description>"
+```
+
+Or: `@simple-mode *build-fix "<description>"`
+
+## What It Does
+
+1. Parse build/compile errors
+2. `@debugger *debug` with error and file/line
+3. `@implementer *refactor` to apply fix
+4. Re-run build to verify
+
+## Integration
+
+- **Cursor**: `@simple-mode *build-fix "<description or build output>"`

tapps_agents/resources/claude/commands/build.md

@@ -0,0 +1,77 @@
+# Build Command (Simple Mode)
+
+Complete feature development workflow with all quality gates. This is the most powerful command for building new features.
+
+## Usage
+
+```
+@build "<description>"
+```
+
+Or with natural language:
+```
+Build a user authentication feature with JWT tokens
+Create a REST API for managing products
+Add user registration with email verification
+```
+
+## What It Does
+
+Executes a complete 7-step workflow:
+
+1. **Enhance Prompt** - Analyzes requirements and creates comprehensive specification
+2. **Create User Stories** - Breaks down into user stories with acceptance criteria
+3. **Design Architecture** - Creates system architecture and component design
+4. **Design API/Models** - Designs API endpoints and data models
+5. **Implement Code** - Generates code following all specifications
+6. **Review Code** - Reviews code quality with scoring (loops if score < 70)
+7. **Generate Tests** - Creates comprehensive test suite
+
+## Examples
+
+```
+@build "Create a user authentication API with JWT tokens"
+@build "Add CRUD operations for products with validation"
+@build "Implement user registration with email verification"
+```
+
+## Features
+
+- **Complete Workflow**: All steps from requirements to tests
+- **Quality Gates**: Automatic quality checks with loopback
+- **Documentation**: Creates workflow documentation at each step
+- **Best Practices**: Follows SDLC best practices
+- **Comprehensive**: Includes architecture, design, implementation, testing
+
+## Output
+
+- Enhanced requirements document
+- User stories with acceptance criteria
+- Architecture design document
+- API/data model specifications
+- Implemented code files
+- Code review report
+- Test suite with coverage
+
+## Quality Gates
+
+- Overall score must be ≥ 70 (loops back if below)
+- Security score must be ≥ 7.0
+- All tests must pass
+
+## Integration
+
+- **Cursor**: Use `@simple-mode *build "<desc>"` (Cursor Skill)
+- **Claude Desktop**: Use `@build "<desc>"` (this command)
+- **CLI**: Use `tapps-agents simple-mode full --prompt "<desc>" --auto`
+
+## Documentation Created
+
+All workflow documentation is saved to:
+- `docs/workflows/simple-mode/step1-enhanced-prompt.md`
+- `docs/workflows/simple-mode/step2-user-stories.md`
+- `docs/workflows/simple-mode/step3-architecture.md`
+- `docs/workflows/simple-mode/step4-design.md`
+- `docs/workflows/simple-mode/step6-review.md`
+- `docs/workflows/simple-mode/step7-testing.md`
+

tapps_agents/resources/claude/commands/debug.md

@@ -0,0 +1,53 @@
+# Debug Command
+
+Analyze errors and find root causes with systematic debugging.
+
+## Usage
+
+```
+@debug "<error-description>" --file <file-path>
+```
+
+Or with natural language:
+```
+Debug the null pointer error in src/api/auth.py
+Fix the authentication error in login.py
+Analyze why the API is returning 500 errors
+```
+
+## What It Does
+
+1. **Analyzes Error**: Examines error messages, stack traces, and code
+2. **Identifies Root Cause**: Finds the underlying issue
+3. **Suggests Fix**: Provides specific fix recommendations
+4. **Validates Solution**: Ensures fix resolves the issue
+
+## Examples
+
+```
+@debug "Null pointer exception on line 42" --file src/api/auth.py
+@debug "Authentication failed with invalid token" --file src/api/auth.py
+@debug "TypeError: 'NoneType' object has no attribute 'name'" --file src/models/user.py
+```
+
+## Features
+
+- **Error Analysis**: Parses error messages and stack traces
+- **Code Tracing**: Traces execution flow to find issue
+- **Root Cause**: Identifies underlying problem, not just symptoms
+- **Fix Suggestions**: Provides specific code fixes
+- **Validation**: Verifies fix resolves the issue
+
+## Output
+
+- Root cause analysis
+- Specific fix recommendations
+- Code examples for fixes
+- Validation of solution
+
+## Integration
+
+- **Cursor**: Use `@debugger *debug "<error>" --file <file>` (Cursor Skill)
+- **Claude Desktop**: Use `@debug "<error>" --file <file>` (this command)
+- **CLI**: Use `tapps-agents debugger debug "<error>" --file <file>`
+

tapps_agents/resources/claude/commands/design.md

@@ -0,0 +1,68 @@
+# Design Command
+
+Create system architecture and component design for a feature or system.
+
+## Usage
+
+```
+@design "<description>"
+```
+
+Or with natural language:
+```
+Design the architecture for a user authentication system
+Create a system design for a REST API
+Design the component structure for user management
+```
+
+## What It Does
+
+1. **Analyzes Requirements**: Understands system requirements
+2. **Designs Architecture**: Creates high-level system architecture
+3. **Defines Components**: Identifies and designs components
+4. **Maps Data Flow**: Shows how data flows through the system
+5. **Considers Performance**: Includes performance considerations
+
+## Examples
+
+```
+@design "User authentication system with JWT tokens"
+@design "REST API for product management"
+@design "Microservice architecture for user management"
+```
+
+## Output
+
+- System architecture diagram (text/ASCII)
+- Component descriptions
+- Data flow diagrams
+- Technology stack recommendations
+- Performance considerations
+- Scalability recommendations
+
+## Format
+
+```
+## System Architecture
+
+### Components
+- Authentication Service
+- User Management Service
+- Token Service
+
+### Data Flow
+1. User → Authentication Service → Token Service
+2. Token Service → User Management Service
+
+### Technology Stack
+- FastAPI for API
+- PostgreSQL for database
+- Redis for caching
+```
+
+## Integration
+
+- **Cursor**: Use `@architect *design "<desc>"` (Cursor Skill)
+- **Claude Desktop**: Use `@design "<desc>"` (this command)
+- **CLI**: Use `tapps-agents architect design "<desc>"`
+

tapps_agents/resources/claude/commands/docs.md

@@ -0,0 +1,53 @@
+# Documentation Command
+
+Generate documentation for code files, APIs, or entire projects.
+
+## Usage
+
+```
+@docs <file-path>
+```
+
+Or with natural language:
+```
+Document the API in src/api/auth.py
+Generate documentation for src/utils/helpers.py
+Create API documentation for the authentication module
+```
+
+## What It Does
+
+1. **Analyzes Code**: Examines code structure and functionality
+2. **Generates Documentation**: Creates comprehensive documentation
+3. **Includes Examples**: Adds code examples and usage patterns
+4. **Formats Properly**: Uses appropriate documentation format (Markdown, etc.)
+
+## Examples
+
+```
+@docs src/api/auth.py
+@docs src/utils/helpers.py
+@docs README.md --update
+```
+
+## Features
+
+- **API Documentation**: Documents API endpoints and parameters
+- **Function Documentation**: Documents functions and methods
+- **Usage Examples**: Includes code examples
+- **Type Information**: Documents types and parameters
+- **Error Handling**: Documents error cases
+
+## Output
+
+- Documentation file (Markdown, etc.)
+- API reference documentation
+- Usage examples
+- Type information
+
+## Integration
+
+- **Cursor**: Use `@documenter *document <file>` (Cursor Skill)
+- **Claude Desktop**: Use `@docs <file>` (this command)
+- **CLI**: Use `tapps-agents documenter document <file>`
+

tapps_agents/resources/claude/commands/e2e.md

@@ -0,0 +1,22 @@
+# E2E Command (Simple Mode)
+
+Generate and run E2E tests. Playwright MCP recommended for execution.
+
+## Usage
+
+```
+@e2e
+@e2e <path>
+```
+
+Or: `@simple-mode *e2e` or `@tester *generate-e2e-tests`
+
+## What It Does
+
+1. `@tester *generate-e2e-tests` for the project or path
+2. If Playwright MCP is available, use it to run and validate
+3. Report results
+
+## Integration
+
+- **Cursor**: `@simple-mode *e2e` or `@tester *generate-e2e-tests`

tapps_agents/resources/claude/commands/fix.md

@@ -0,0 +1,54 @@
+# Fix Command (Simple Mode)
+
+Fix bugs and errors with systematic debugging workflow.
+
+## Usage
+
+```
+@fix <file-path> "<description>"
+```
+
+Or with natural language:
+```
+Fix the null pointer error in src/api/auth.py
+Debug and fix the authentication issue
+Resolve the bug in login.py
+```
+
+## What It Does
+
+Executes a complete fix workflow:
+
+1. **Debug Error** - Analyzes error and finds root cause
+2. **Implement Fix** - Applies the fix to resolve the issue
+3. **Test Fix** - Generates/updates tests to verify the fix
+4. **Validate** - Ensures fix doesn't break existing functionality
+
+## Examples
+
+```
+@fix src/api/auth.py "Fix the null pointer error on line 42"
+@fix src/api/auth.py "Resolve the authentication token validation issue"
+@fix src/models/user.py "Fix the email validation bug"
+```
+
+## Features
+
+- **Systematic Debugging**: Finds root cause, not just symptoms
+- **Automatic Fix**: Implements the fix based on analysis
+- **Test Verification**: Ensures fix works correctly
+- **Quality Check**: Verifies fix doesn't introduce new issues
+
+## Output
+
+- Root cause analysis
+- Fixed code file
+- Test updates
+- Validation results
+
+## Integration
+
+- **Cursor**: Use `@simple-mode *fix <file> "<desc>"` (Cursor Skill)
+- **Claude Desktop**: Use `@fix <file> "<desc>"` (this command)
+- **CLI**: Use `tapps-agents simple-mode fix --file <file> --prompt "<desc>"`
+

tapps_agents/resources/claude/commands/implement.md

@@ -0,0 +1,53 @@
+# Implement Command
+
+Generate code from natural language description following project patterns and best practices.
+
+## Usage
+
+```
+@implement "<description>" <file-path>
+```
+
+Or with natural language:
+```
+Implement a user authentication API with JWT tokens in src/api/auth.py
+Create a REST endpoint for products in src/api/products.py
+```
+
+## What It Does
+
+1. **Analyzes Requirements**: Understands the description and requirements
+2. **Follows Project Patterns**: Uses existing code patterns and conventions
+3. **Generates Code**: Creates implementation following best practices
+4. **Includes Documentation**: Adds docstrings and comments
+5. **Auto-Review**: Optionally reviews generated code for quality
+
+## Examples
+
+```
+@implement "Create a user authentication API with JWT tokens" src/api/auth.py
+@implement "Add CRUD operations for products" src/api/products.py
+@implement "Create a utility function to validate email addresses" src/utils/validation.py
+```
+
+## Features
+
+- **Context-Aware**: Understands project structure and dependencies
+- **Pattern Matching**: Follows existing code patterns
+- **Type Hints**: Includes proper type annotations
+- **Error Handling**: Includes appropriate error handling
+- **Documentation**: Adds docstrings and comments
+
+## Output
+
+- Generated code file
+- Quality score (if auto-review enabled)
+- Documentation and comments
+- Integration with existing codebase
+
+## Integration
+
+- **Cursor**: Use `@implementer *implement "<desc>" <file>` (Cursor Skill)
+- **Claude Desktop**: Use `@implement "<desc>" <file>` (this command)
+- **CLI**: Use `tapps-agents implementer implement "<desc>" <file>`
+

tapps_agents/resources/claude/commands/improve.md

@@ -0,0 +1,53 @@
+# Improve Command
+
+Improve code quality, maintainability, and performance based on specific instructions.
+
+## Usage
+
+```
+@improve <file-path> "<instructions>"
+```
+
+Or with natural language:
+```
+Improve error handling in src/api/auth.py
+Optimize performance in src/utils/helpers.py
+Enhance code quality in src/models/user.py
+```
+
+## What It Does
+
+1. **Analyzes Code**: Examines current code quality
+2. **Applies Improvements**: Implements improvements based on instructions
+3. **Enhances Quality**: Improves maintainability, performance, readability
+4. **Maintains Functionality**: Ensures improvements don't break existing behavior
+
+## Examples
+
+```
+@improve src/api/auth.py "Add input validation, improve error handling"
+@improve src/utils/helpers.py "Optimize performance, reduce memory usage"
+@improve src/models/user.py "Add type hints, improve documentation"
+```
+
+## Common Improvements
+
+- **Error Handling**: Add proper error handling and validation
+- **Performance**: Optimize algorithms and reduce complexity
+- **Readability**: Improve code structure and naming
+- **Type Safety**: Add type hints and validation
+- **Documentation**: Improve docstrings and comments
+- **Testing**: Add missing test coverage
+
+## Output
+
+- Improved code file
+- Quality improvement metrics
+- Summary of changes
+
+## Integration
+
+- **Cursor**: Use `@improver *improve <file> "<instructions>"` (Cursor Skill)
+- **Claude Desktop**: Use `@improve <file> "<instructions>"` (this command)
+- **CLI**: Use `tapps-agents improver improve <file> "<instructions>"`
+

tapps_agents/resources/claude/commands/library-docs.md

@@ -0,0 +1,64 @@
+# Library Documentation Command
+
+Get up-to-date library documentation from Context7 knowledge base.
+
+## Usage
+
+```
+@library-docs <library-name> [topic]
+```
+
+Or with natural language:
+```
+Show me FastAPI routing documentation
+Get pytest fixtures documentation
+Look up SQLAlchemy query documentation
+```
+
+## What It Does
+
+1. **Searches Cache**: Checks Context7 KB cache first (fast, <0.15s)
+2. **Fetches Documentation**: Gets library documentation from Context7 API
+3. **Filters by Topic**: Optionally filters by specific topic
+4. **Provides Examples**: Includes code examples and usage patterns
+
+## Examples
+
+```
+@library-docs fastapi
+@library-docs fastapi routing
+@library-docs pytest fixtures
+@library-docs sqlalchemy queries
+```
+
+## Features
+
+- **KB-First Caching**: Uses cached documentation when available (90%+ hit rate)
+- **Up-to-Date**: Fetches latest documentation from Context7
+- **Topic Filtering**: Can filter by specific topics
+- **Code Examples**: Includes practical code examples
+- **Cross-References**: Links to related libraries
+
+## Output
+
+- Library documentation
+- Code examples
+- API reference
+- Best practices
+- Related libraries
+
+## Integration
+
+- **Cursor**: Use `@reviewer *docs <library> [topic]` (Cursor Skill)
+- **Claude Desktop**: Use `@library-docs <library> [topic]` (this command)
+- **CLI**: Use `tapps-agents reviewer docs <library> [topic]`
+
+## Context7 Setup
+
+Requires Context7 API key in `.tapps-agents/config.yaml`:
+```yaml
+context7:
+  enabled: true
+  api_key: "your-api-key"
+```
+