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

tapps_agents/resources/claude/commands/lint.md

@@ -0,0 +1,52 @@
+# Lint Command
+
+Run code linting with Ruff (10-100x faster than alternatives).
+
+## Usage
+
+```
+@lint <file-path>
+```
+
+Or with natural language:
+```
+Lint src/api/auth.py
+Check code style in src/utils/helpers.py
+Run linting on the authentication module
+```
+
+## What It Does
+
+1. **Runs Ruff**: Executes Ruff linting (Python's fastest linter)
+2. **Finds Issues**: Identifies code style and quality issues
+3. **Provides Fixes**: Suggests specific fixes for each issue
+4. **Scores Code**: Calculates linting score (0-10)
+
+## Examples
+
+```
+@lint src/api/auth.py
+@lint src/utils/helpers.py
+@lint src/ --fix
+```
+
+## Features
+
+- **Fast**: Ruff is 10-100x faster than alternatives
+- **Comprehensive**: Checks style, quality, and best practices
+- **Auto-Fix**: Can automatically fix many issues (with --fix flag)
+- **Scoring**: Provides linting score for quality gates
+
+## Output
+
+- Linting report with issues
+- Line numbers and error codes
+- Fix recommendations
+- Linting score
+
+## Integration
+
+- **Cursor**: Use `@reviewer *lint <file>` (Cursor Skill)
+- **Claude Desktop**: Use `@lint <file>` (this command)
+- **CLI**: Use `tapps-agents reviewer lint <file>`
+

tapps_agents/resources/claude/commands/plan.md

@@ -0,0 +1,65 @@
+# Plan Command
+
+Create development plan with user stories, acceptance criteria, and estimates.
+
+## Usage
+
+```
+@plan "<description>"
+```
+
+Or with natural language:
+```
+Plan a user authentication feature
+Create a plan for a REST API for products
+Plan the implementation of user registration
+```
+
+## What It Does
+
+1. **Analyzes Requirements**: Understands the feature description
+2. **Creates User Stories**: Breaks down into user stories
+3. **Defines Acceptance Criteria**: Adds acceptance criteria for each story
+4. **Estimates Effort**: Provides story point estimates
+5. **Identifies Dependencies**: Maps dependencies between stories
+
+## Examples
+
+```
+@plan "Create a user authentication API with JWT tokens"
+@plan "Add CRUD operations for products"
+@plan "Implement user registration with email verification"
+```
+
+## Output
+
+- User stories with IDs
+- Acceptance criteria for each story
+- Story point estimates
+- Dependency mapping
+- Priority recommendations
+
+## Format
+
+```
+## User Story 1: User Registration
+
+**Description**: As a user, I want to register with email and password
+
+**Acceptance Criteria**:
+- User can register with valid email and password
+- Email validation is performed
+- Password meets security requirements
+- User receives confirmation email
+
+**Story Points**: 5
+**Priority**: High
+**Dependencies**: None
+```
+
+## Integration
+
+- **Cursor**: Use `@planner *plan "<desc>"` (Cursor Skill)
+- **Claude Desktop**: Use `@plan "<desc>"` (this command)
+- **CLI**: Use `tapps-agents planner plan "<desc>"`
+

tapps_agents/resources/claude/commands/refactor-clean.md

@@ -0,0 +1,21 @@
+# Refactor Clean Command (Simple Mode)
+
+Mechanical cleanup: unused imports, dead code, duplication. Use *refactor for larger design changes.
+
+## Usage
+
+```
+@refactor-clean <file>
+```
+
+Or: `@simple-mode *refactor-clean {file}`
+
+## What It Does
+
+1. `@reviewer *duplication` and/or Ruff for unused-import/dead-code
+2. `@implementer *refactor` for mechanical cleanup
+3. Report changes
+
+## Integration
+
+- **Cursor**: `@simple-mode *refactor-clean {file}`

tapps_agents/resources/claude/commands/refactor.md

@@ -0,0 +1,55 @@
+# Refactor Command
+
+Refactor existing code to improve quality, maintainability, and performance.
+
+## Usage
+
+```
+@refactor <file-path> "<instructions>"
+```
+
+Or with natural language:
+```
+Refactor src/api/auth.py to improve error handling
+Refactor src/utils/helpers.py to reduce complexity
+Improve the code structure in src/models/user.py
+```
+
+## What It Does
+
+1. **Analyzes Code**: Examines current code structure and patterns
+2. **Applies Refactoring**: Implements improvements based on instructions
+3. **Maintains Functionality**: Ensures refactoring doesn't break existing behavior
+4. **Improves Quality**: Enhances code quality, readability, and maintainability
+5. **Updates Tests**: Updates tests if needed to match refactored code
+
+## Examples
+
+```
+@refactor src/api/auth.py "Extract helper functions, improve error handling"
+@refactor src/utils/helpers.py "Reduce cyclomatic complexity, add type hints"
+@refactor src/models/user.py "Improve data validation, add docstrings"
+```
+
+## Common Refactoring Patterns
+
+- **Extract Functions**: Break down complex functions
+- **Improve Naming**: Use clearer variable and function names
+- **Add Type Hints**: Improve type safety
+- **Reduce Complexity**: Simplify complex logic
+- **Improve Error Handling**: Add proper error handling
+- **Add Documentation**: Improve docstrings and comments
+
+## Output
+
+- Refactored code file
+- Quality improvement metrics
+- Test updates (if needed)
+- Refactoring summary
+
+## Integration
+
+- **Cursor**: Use `@implementer *refactor <file> "<instructions>"` (Cursor Skill)
+- **Claude Desktop**: Use `@refactor <file> "<instructions>"` (this command)
+- **CLI**: Use `tapps-agents implementer refactor <file> "<instructions>"`
+

tapps_agents/resources/claude/commands/review.md

@@ -0,0 +1,67 @@
+# Code Review Command
+
+Review code files with objective quality metrics, security analysis, and actionable feedback.
+
+## Usage
+
+```
+@review <file-path>
+```
+
+Or with natural language:
+```
+Review the code in src/api/auth.py
+Check the quality of src/utils/helpers.py
+```
+
+## What It Does
+
+1. **Calculates Objective Scores** (5 metrics):
+   - Complexity Score (0-10)
+   - Security Score (0-10)
+   - Maintainability Score (0-10)
+   - Test Coverage Score (0-100%)
+   - Performance Score (0-10)
+
+2. **Runs Quality Tools**:
+   - Ruff linting (Python)
+   - mypy type checking
+   - Bandit security scanning
+   - Code duplication detection
+   - Dependency vulnerability audit
+
+3. **Provides Actionable Feedback**:
+   - Specific line numbers for issues
+   - Code examples for fixes
+   - Security recommendations
+   - Best practice suggestions
+
+## Examples
+
+```
+@review src/api/auth.py
+@review src/utils/helpers.py
+@review tests/test_auth.py
+```
+
+## Output Format
+
+- Quality scores with pass/fail status
+- Detailed issue list with line numbers
+- Security vulnerabilities (if any)
+- Actionable recommendations
+- Code examples for fixes
+
+## Quality Gates
+
+- Overall score must be ≥ 70
+- Security score must be ≥ 7.0
+- Complexity should be ≤ 8.0
+
+## Integration
+
+This command works with:
+- **Cursor**: Use `@reviewer *review <file>` (Cursor Skill)
+- **Claude Desktop**: Use `@review <file>` (this command)
+- **CLI**: Use `tapps-agents reviewer review <file>`
+

tapps_agents/resources/claude/commands/score.md

@@ -0,0 +1,60 @@
+# Code Score Command
+
+Quick code quality scoring without detailed feedback. Faster than full review.
+
+## Usage
+
+```
+@score <file-path>
+```
+
+Or with natural language:
+```
+Score src/api/auth.py
+What's the quality score of src/utils/helpers.py?
+```
+
+## What It Does
+
+Calculates objective quality metrics only (no LLM feedback):
+- Complexity Score (0-10)
+- Security Score (0-10)
+- Maintainability Score (0-10)
+- Test Coverage Score (0-100%)
+- Performance Score (0-10)
+- Overall Score (0-100)
+
+## Examples
+
+```
+@score src/api/auth.py
+@score src/utils/helpers.py
+```
+
+## Output Format
+
+Quick score summary:
+```
+📊 Code Scores: src/api/auth.py
+
+- Complexity: 7.2/10 ✅
+- Security: 8.5/10 ✅
+- Maintainability: 7.8/10 ✅
+- Test Coverage: 85% ✅
+- Performance: 7.0/10 ✅
+- Overall: 76.5/100 ✅ PASS
+```
+
+## When to Use
+
+- Quick quality checks before committing
+- CI/CD quality gates
+- Comparing code quality across files
+- Fast feedback during development
+
+## Integration
+
+- **Cursor**: Use `@reviewer *score <file>` (Cursor Skill)
+- **Claude Desktop**: Use `@score <file>` (this command)
+- **CLI**: Use `tapps-agents reviewer score <file>`
+

tapps_agents/resources/claude/commands/security-review.md

@@ -0,0 +1,22 @@
+# Security Review Command (Simple Mode)
+
+Structured security check: reviewer + ops + OWASP-style checklist.
+
+## Usage
+
+```
+@security-review
+@security-review <path>
+```
+
+Or: `@simple-mode *security-review [path]`
+
+## What It Does
+
+1. `@reviewer *review` (security score, bandit)
+2. `@ops *audit-security`
+3. Apply OWASP-style checklist; summarize and give remediation hints
+
+## Integration
+
+- **Cursor**: `@simple-mode *security-review [path]` or `@security-review`

tapps_agents/resources/claude/commands/security-scan.md

@@ -0,0 +1,54 @@
+# Security Scan Command
+
+Scan code for security vulnerabilities and provide remediation recommendations.
+
+## Usage
+
+```
+@security-scan <file-path>
+```
+
+Or with natural language:
+```
+Scan src/api/auth.py for security issues
+Check for vulnerabilities in src/utils/helpers.py
+Audit the security of the authentication module
+```
+
+## What It Does
+
+1. **Scans Code**: Analyzes code for security vulnerabilities
+2. **Checks Dependencies**: Audits dependencies for known vulnerabilities
+3. **Identifies Issues**: Finds security issues and weaknesses
+4. **Provides Fixes**: Recommends specific security fixes
+5. **Prioritizes**: Ranks issues by severity
+
+## Examples
+
+```
+@security-scan src/api/auth.py
+@security-scan src/utils/helpers.py
+@security-scan . --dependencies
+```
+
+## Features
+
+- **Vulnerability Detection**: Finds common security issues
+- **Dependency Audit**: Checks for vulnerable dependencies
+- **Severity Ranking**: Prioritizes issues by severity
+- **Fix Recommendations**: Provides specific fixes
+- **Best Practices**: Suggests security best practices
+
+## Output
+
+- Security scan report
+- Vulnerability list with severity
+- Fix recommendations
+- Dependency audit results
+
+## Integration
+
+- **Cursor**: Use `@reviewer *security-scan <file>` (Cursor Skill)
+- **Claude Desktop**: Use `@security-scan <file>` (this command)
+- **CLI**: Use `tapps-agents reviewer security-scan <file>`
+

tapps_agents/resources/claude/commands/tdd.md

@@ -0,0 +1,24 @@
+# TDD Command (Simple Mode)
+
+TDD workflow: Red-Green-Refactor with coverage ≥80%.
+
+## Usage
+
+```
+@tdd "<description>"
+@tdd <file>
+```
+
+Or: `@simple-mode *tdd "<description>"` or `*tdd {file}`
+
+## What It Does
+
+1. Define interfaces/contracts
+2. Write failing tests (RED) via `@tester *generate-tests`
+3. Implement minimal code (GREEN) via `@implementer *implement`
+4. Refactor (IMPROVE) via `@implementer *refactor`
+5. `@tester *test` and ensure coverage ≥80%
+
+## Integration
+
+- **Cursor**: `@simple-mode *tdd "<desc>"` or `*tdd {file}`

tapps_agents/resources/claude/commands/test-coverage.md

@@ -0,0 +1,21 @@
+# Test Coverage Command (Simple Mode)
+
+Coverage-driven test generation. Find gaps and generate tests for uncovered paths.
+
+## Usage
+
+```
+@test-coverage <file> [--target 80]
+```
+
+Or: `@simple-mode *test-coverage <file> --target 80`
+
+## What It Does
+
+1. Use coverage.xml/coverage.json to find low/uncovered modules
+2. `@tester *test` for those paths to improve coverage
+3. Report coverage change
+
+## Integration
+
+- **Cursor**: `@simple-mode *test-coverage <file> --target 80`

tapps_agents/resources/claude/commands/test.md

@@ -0,0 +1,54 @@
+# Test Command
+
+Generate comprehensive tests for code files with coverage analysis.
+
+## Usage
+
+```
+@test <file-path>
+```
+
+Or with natural language:
+```
+Generate tests for src/api/auth.py
+Add test coverage for src/utils/helpers.py
+Create tests for the authentication module
+```
+
+## What It Does
+
+1. **Analyzes Code**: Understands the code structure and functionality
+2. **Generates Tests**: Creates unit tests and integration tests
+3. **Runs Tests**: Executes the test suite
+4. **Reports Coverage**: Shows test coverage metrics
+5. **Validates**: Ensures tests pass and cover critical paths
+
+## Examples
+
+```
+@test src/api/auth.py
+@test src/utils/helpers.py
+@test tests/test_auth.py --integration
+```
+
+## Features
+
+- **Unit Tests**: Tests individual functions and methods
+- **Integration Tests**: Tests component interactions (optional)
+- **Coverage Analysis**: Reports code coverage percentage
+- **Test Patterns**: Follows project testing patterns (pytest, unittest, etc.)
+- **Edge Cases**: Includes edge case and error handling tests
+
+## Output
+
+- Generated test files
+- Test execution results
+- Coverage report
+- Test pass/fail status
+
+## Integration
+
+- **Cursor**: Use `@tester *test <file>` (Cursor Skill)
+- **Claude Desktop**: Use `@test <file>` (this command)
+- **CLI**: Use `tapps-agents tester test <file>`
+

tapps_agents/resources/claude/commands/update-codemaps.md

@@ -0,0 +1,20 @@
+# Update Codemaps Command (Simple Mode)
+
+Refresh codemap/context index (e.g. Context7 cache).
+
+## Usage
+
+```
+@update-codemaps
+```
+
+Or: `@simple-mode *update-codemaps`
+
+## What It Does
+
+1. Refresh project codemap or context index
+2. If Context7: `@reviewer *docs-refresh` or project cache refresh flow
+
+## Integration
+
+- **Cursor**: `@simple-mode *update-codemaps`

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

@@ -0,0 +1,21 @@
+# Update Docs Command (Simple Mode)
+
+Sync documentation with code.
+
+## Usage
+
+```
+@update-docs
+@update-docs <path>
+```
+
+Or: `@simple-mode *update-docs [path]`
+
+## What It Does
+
+1. `@documenter *document` or `*document-api` for target
+2. Sync README or docs/ if project scripts exist
+
+## Integration
+
+- **Cursor**: `@simple-mode *update-docs [path]`

tapps_agents/resources/claude/skills/__init__.py

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