diff --git a/skills/java-concurrency/assets/.gitkeep b/skills/java-concurrency/assets/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-concurrency/assets/config.yaml b/skills/java-concurrency/assets/config.yaml new file mode 100644 index 0000000..3e90331 --- /dev/null +++ b/skills/java-concurrency/assets/config.yaml @@ -0,0 +1,41 @@ +# java-concurrency Configuration +# Category: general +# Generated: 2025-12-30 + +skill: + name: java-concurrency + version: "1.0.0" + category: general + +settings: + # Default settings for java-concurrency + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-concurrency/assets/schema.json b/skills/java-concurrency/assets/schema.json new file mode 100644 index 0000000..13a8ac3 --- /dev/null +++ b/skills/java-concurrency/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-concurrency Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-concurrency/references/.gitkeep b/skills/java-concurrency/references/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-concurrency/references/GUIDE.md b/skills/java-concurrency/references/GUIDE.md new file mode 100644 index 0000000..5a9951f --- /dev/null +++ b/skills/java-concurrency/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Concurrency Guide + +## Overview + +This guide provides comprehensive documentation for the **java-concurrency** skill in the custom-plugin-java plugin. + +## Category: General + +## Quick Start + +### Prerequisites + +- Familiarity with general concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-concurrency - [your task description]" + +# Example +claude "java-concurrency - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_concurrency(input_data): + """ + Implement java-concurrency functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-concurrency/references/PATTERNS.md b/skills/java-concurrency/references/PATTERNS.md new file mode 100644 index 0000000..ebe69be --- /dev/null +++ b/skills/java-concurrency/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Concurrency Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: General + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-concurrency skill* diff --git a/skills/java-concurrency/scripts/.gitkeep b/skills/java-concurrency/scripts/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-concurrency/scripts/validate.py b/skills/java-concurrency/scripts/validate.py new file mode 100755 index 0000000..4d85f6d --- /dev/null +++ b/skills/java-concurrency/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-concurrency skill. +Category: general +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-concurrency skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-docker/assets/config.yaml b/skills/java-docker/assets/config.yaml new file mode 100644 index 0000000..3ed77fc --- /dev/null +++ b/skills/java-docker/assets/config.yaml @@ -0,0 +1,41 @@ +# java-docker Configuration +# Category: containers +# Generated: 2025-12-30 + +skill: + name: java-docker + version: "1.0.0" + category: containers + +settings: + # Default settings for java-docker + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-docker/assets/schema.json b/skills/java-docker/assets/schema.json new file mode 100644 index 0000000..3b910a2 --- /dev/null +++ b/skills/java-docker/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-docker Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-docker/references/GUIDE.md b/skills/java-docker/references/GUIDE.md new file mode 100644 index 0000000..360eb58 --- /dev/null +++ b/skills/java-docker/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Docker Guide + +## Overview + +This guide provides comprehensive documentation for the **java-docker** skill in the custom-plugin-java plugin. + +## Category: Containers + +## Quick Start + +### Prerequisites + +- Familiarity with containers concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-docker - [your task description]" + +# Example +claude "java-docker - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_docker(input_data): + """ + Implement java-docker functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-docker/references/PATTERNS.md b/skills/java-docker/references/PATTERNS.md new file mode 100644 index 0000000..0803e26 --- /dev/null +++ b/skills/java-docker/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Docker Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: Containers + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-docker skill* diff --git a/skills/java-docker/scripts/validate.py b/skills/java-docker/scripts/validate.py new file mode 100755 index 0000000..d59d84d --- /dev/null +++ b/skills/java-docker/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-docker skill. +Category: containers +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-docker skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-fundamentals/assets/.gitkeep b/skills/java-fundamentals/assets/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-fundamentals/assets/config.yaml b/skills/java-fundamentals/assets/config.yaml new file mode 100644 index 0000000..eb33482 --- /dev/null +++ b/skills/java-fundamentals/assets/config.yaml @@ -0,0 +1,41 @@ +# java-fundamentals Configuration +# Category: general +# Generated: 2025-12-30 + +skill: + name: java-fundamentals + version: "1.0.0" + category: general + +settings: + # Default settings for java-fundamentals + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-fundamentals/assets/schema.json b/skills/java-fundamentals/assets/schema.json new file mode 100644 index 0000000..5c86567 --- /dev/null +++ b/skills/java-fundamentals/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-fundamentals Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-fundamentals/references/.gitkeep b/skills/java-fundamentals/references/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-fundamentals/references/GUIDE.md b/skills/java-fundamentals/references/GUIDE.md new file mode 100644 index 0000000..51b5c7c --- /dev/null +++ b/skills/java-fundamentals/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Fundamentals Guide + +## Overview + +This guide provides comprehensive documentation for the **java-fundamentals** skill in the custom-plugin-java plugin. + +## Category: General + +## Quick Start + +### Prerequisites + +- Familiarity with general concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-fundamentals - [your task description]" + +# Example +claude "java-fundamentals - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_fundamentals(input_data): + """ + Implement java-fundamentals functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-fundamentals/references/PATTERNS.md b/skills/java-fundamentals/references/PATTERNS.md new file mode 100644 index 0000000..256c5dd --- /dev/null +++ b/skills/java-fundamentals/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Fundamentals Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: General + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-fundamentals skill* diff --git a/skills/java-fundamentals/scripts/.gitkeep b/skills/java-fundamentals/scripts/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-fundamentals/scripts/validate.py b/skills/java-fundamentals/scripts/validate.py new file mode 100755 index 0000000..16ddbbb --- /dev/null +++ b/skills/java-fundamentals/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-fundamentals skill. +Category: general +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-fundamentals skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-gradle/assets/config.yaml b/skills/java-gradle/assets/config.yaml new file mode 100644 index 0000000..05f86f6 --- /dev/null +++ b/skills/java-gradle/assets/config.yaml @@ -0,0 +1,41 @@ +# java-gradle Configuration +# Category: general +# Generated: 2025-12-30 + +skill: + name: java-gradle + version: "1.0.0" + category: general + +settings: + # Default settings for java-gradle + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-gradle/assets/schema.json b/skills/java-gradle/assets/schema.json new file mode 100644 index 0000000..4cfb582 --- /dev/null +++ b/skills/java-gradle/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-gradle Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-gradle/references/GUIDE.md b/skills/java-gradle/references/GUIDE.md new file mode 100644 index 0000000..25b2bcc --- /dev/null +++ b/skills/java-gradle/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Gradle Guide + +## Overview + +This guide provides comprehensive documentation for the **java-gradle** skill in the custom-plugin-java plugin. + +## Category: General + +## Quick Start + +### Prerequisites + +- Familiarity with general concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-gradle - [your task description]" + +# Example +claude "java-gradle - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_gradle(input_data): + """ + Implement java-gradle functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-gradle/references/PATTERNS.md b/skills/java-gradle/references/PATTERNS.md new file mode 100644 index 0000000..2e8c118 --- /dev/null +++ b/skills/java-gradle/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Gradle Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: General + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-gradle skill* diff --git a/skills/java-gradle/scripts/validate.py b/skills/java-gradle/scripts/validate.py new file mode 100755 index 0000000..b491ea7 --- /dev/null +++ b/skills/java-gradle/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-gradle skill. +Category: general +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-gradle skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-jpa-hibernate/assets/.gitkeep b/skills/java-jpa-hibernate/assets/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-jpa-hibernate/assets/config.yaml b/skills/java-jpa-hibernate/assets/config.yaml new file mode 100644 index 0000000..336b61d --- /dev/null +++ b/skills/java-jpa-hibernate/assets/config.yaml @@ -0,0 +1,41 @@ +# java-jpa-hibernate Configuration +# Category: general +# Generated: 2025-12-30 + +skill: + name: java-jpa-hibernate + version: "1.0.0" + category: general + +settings: + # Default settings for java-jpa-hibernate + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-jpa-hibernate/assets/schema.json b/skills/java-jpa-hibernate/assets/schema.json new file mode 100644 index 0000000..461aed5 --- /dev/null +++ b/skills/java-jpa-hibernate/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-jpa-hibernate Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-jpa-hibernate/references/.gitkeep b/skills/java-jpa-hibernate/references/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-jpa-hibernate/references/GUIDE.md b/skills/java-jpa-hibernate/references/GUIDE.md new file mode 100644 index 0000000..beb895a --- /dev/null +++ b/skills/java-jpa-hibernate/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Jpa Hibernate Guide + +## Overview + +This guide provides comprehensive documentation for the **java-jpa-hibernate** skill in the custom-plugin-java plugin. + +## Category: General + +## Quick Start + +### Prerequisites + +- Familiarity with general concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-jpa-hibernate - [your task description]" + +# Example +claude "java-jpa-hibernate - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_jpa_hibernate(input_data): + """ + Implement java-jpa-hibernate functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-jpa-hibernate/references/PATTERNS.md b/skills/java-jpa-hibernate/references/PATTERNS.md new file mode 100644 index 0000000..a7af301 --- /dev/null +++ b/skills/java-jpa-hibernate/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Jpa Hibernate Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: General + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-jpa-hibernate skill* diff --git a/skills/java-jpa-hibernate/scripts/.gitkeep b/skills/java-jpa-hibernate/scripts/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-jpa-hibernate/scripts/validate.py b/skills/java-jpa-hibernate/scripts/validate.py new file mode 100755 index 0000000..4457756 --- /dev/null +++ b/skills/java-jpa-hibernate/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-jpa-hibernate skill. +Category: general +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-jpa-hibernate skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-maven-gradle/assets/.gitkeep b/skills/java-maven-gradle/assets/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-maven-gradle/assets/config.yaml b/skills/java-maven-gradle/assets/config.yaml new file mode 100644 index 0000000..ebfff4a --- /dev/null +++ b/skills/java-maven-gradle/assets/config.yaml @@ -0,0 +1,41 @@ +# java-maven-gradle Configuration +# Category: general +# Generated: 2025-12-30 + +skill: + name: java-maven-gradle + version: "1.0.0" + category: general + +settings: + # Default settings for java-maven-gradle + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-maven-gradle/assets/schema.json b/skills/java-maven-gradle/assets/schema.json new file mode 100644 index 0000000..723770a --- /dev/null +++ b/skills/java-maven-gradle/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-maven-gradle Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-maven-gradle/references/.gitkeep b/skills/java-maven-gradle/references/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-maven-gradle/references/GUIDE.md b/skills/java-maven-gradle/references/GUIDE.md new file mode 100644 index 0000000..50446ef --- /dev/null +++ b/skills/java-maven-gradle/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Maven Gradle Guide + +## Overview + +This guide provides comprehensive documentation for the **java-maven-gradle** skill in the custom-plugin-java plugin. + +## Category: General + +## Quick Start + +### Prerequisites + +- Familiarity with general concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-maven-gradle - [your task description]" + +# Example +claude "java-maven-gradle - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_maven_gradle(input_data): + """ + Implement java-maven-gradle functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-maven-gradle/references/PATTERNS.md b/skills/java-maven-gradle/references/PATTERNS.md new file mode 100644 index 0000000..0da89fd --- /dev/null +++ b/skills/java-maven-gradle/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Maven Gradle Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: General + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-maven-gradle skill* diff --git a/skills/java-maven-gradle/scripts/.gitkeep b/skills/java-maven-gradle/scripts/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-maven-gradle/scripts/validate.py b/skills/java-maven-gradle/scripts/validate.py new file mode 100755 index 0000000..2ebe89c --- /dev/null +++ b/skills/java-maven-gradle/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-maven-gradle skill. +Category: general +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-maven-gradle skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-maven/assets/config.yaml b/skills/java-maven/assets/config.yaml new file mode 100644 index 0000000..413a469 --- /dev/null +++ b/skills/java-maven/assets/config.yaml @@ -0,0 +1,41 @@ +# java-maven Configuration +# Category: general +# Generated: 2025-12-30 + +skill: + name: java-maven + version: "1.0.0" + category: general + +settings: + # Default settings for java-maven + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-maven/assets/schema.json b/skills/java-maven/assets/schema.json new file mode 100644 index 0000000..e2bf4a9 --- /dev/null +++ b/skills/java-maven/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-maven Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-maven/references/GUIDE.md b/skills/java-maven/references/GUIDE.md new file mode 100644 index 0000000..bb5458b --- /dev/null +++ b/skills/java-maven/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Maven Guide + +## Overview + +This guide provides comprehensive documentation for the **java-maven** skill in the custom-plugin-java plugin. + +## Category: General + +## Quick Start + +### Prerequisites + +- Familiarity with general concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-maven - [your task description]" + +# Example +claude "java-maven - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_maven(input_data): + """ + Implement java-maven functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-maven/references/PATTERNS.md b/skills/java-maven/references/PATTERNS.md new file mode 100644 index 0000000..82e9c1c --- /dev/null +++ b/skills/java-maven/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Maven Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: General + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-maven skill* diff --git a/skills/java-maven/scripts/validate.py b/skills/java-maven/scripts/validate.py new file mode 100755 index 0000000..8e830ff --- /dev/null +++ b/skills/java-maven/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-maven skill. +Category: general +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-maven skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-microservices/assets/.gitkeep b/skills/java-microservices/assets/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-microservices/assets/config.yaml b/skills/java-microservices/assets/config.yaml new file mode 100644 index 0000000..6f293c2 --- /dev/null +++ b/skills/java-microservices/assets/config.yaml @@ -0,0 +1,41 @@ +# java-microservices Configuration +# Category: general +# Generated: 2025-12-30 + +skill: + name: java-microservices + version: "1.0.0" + category: general + +settings: + # Default settings for java-microservices + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-microservices/assets/schema.json b/skills/java-microservices/assets/schema.json new file mode 100644 index 0000000..8dbc647 --- /dev/null +++ b/skills/java-microservices/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-microservices Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-microservices/references/.gitkeep b/skills/java-microservices/references/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-microservices/references/GUIDE.md b/skills/java-microservices/references/GUIDE.md new file mode 100644 index 0000000..179bc39 --- /dev/null +++ b/skills/java-microservices/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Microservices Guide + +## Overview + +This guide provides comprehensive documentation for the **java-microservices** skill in the custom-plugin-java plugin. + +## Category: General + +## Quick Start + +### Prerequisites + +- Familiarity with general concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-microservices - [your task description]" + +# Example +claude "java-microservices - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_microservices(input_data): + """ + Implement java-microservices functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-microservices/references/PATTERNS.md b/skills/java-microservices/references/PATTERNS.md new file mode 100644 index 0000000..9d5c557 --- /dev/null +++ b/skills/java-microservices/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Microservices Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: General + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-microservices skill* diff --git a/skills/java-microservices/scripts/.gitkeep b/skills/java-microservices/scripts/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-microservices/scripts/validate.py b/skills/java-microservices/scripts/validate.py new file mode 100755 index 0000000..1a7a078 --- /dev/null +++ b/skills/java-microservices/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-microservices skill. +Category: general +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-microservices skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-performance/assets/config.yaml b/skills/java-performance/assets/config.yaml new file mode 100644 index 0000000..4a06379 --- /dev/null +++ b/skills/java-performance/assets/config.yaml @@ -0,0 +1,41 @@ +# java-performance Configuration +# Category: database +# Generated: 2025-12-30 + +skill: + name: java-performance + version: "1.0.0" + category: database + +settings: + # Default settings for java-performance + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-performance/assets/schema.json b/skills/java-performance/assets/schema.json new file mode 100644 index 0000000..9c4c9bf --- /dev/null +++ b/skills/java-performance/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-performance Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-performance/references/GUIDE.md b/skills/java-performance/references/GUIDE.md new file mode 100644 index 0000000..e4dfba0 --- /dev/null +++ b/skills/java-performance/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Performance Guide + +## Overview + +This guide provides comprehensive documentation for the **java-performance** skill in the custom-plugin-java plugin. + +## Category: Database + +## Quick Start + +### Prerequisites + +- Familiarity with database concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-performance - [your task description]" + +# Example +claude "java-performance - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_performance(input_data): + """ + Implement java-performance functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-performance/references/PATTERNS.md b/skills/java-performance/references/PATTERNS.md new file mode 100644 index 0000000..3c2ce9a --- /dev/null +++ b/skills/java-performance/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Performance Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: Database + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-performance skill* diff --git a/skills/java-performance/scripts/validate.py b/skills/java-performance/scripts/validate.py new file mode 100755 index 0000000..1ba09e5 --- /dev/null +++ b/skills/java-performance/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-performance skill. +Category: database +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-performance skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-spring-boot/assets/.gitkeep b/skills/java-spring-boot/assets/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-spring-boot/assets/config.yaml b/skills/java-spring-boot/assets/config.yaml new file mode 100644 index 0000000..2df7520 --- /dev/null +++ b/skills/java-spring-boot/assets/config.yaml @@ -0,0 +1,41 @@ +# java-spring-boot Configuration +# Category: general +# Generated: 2025-12-30 + +skill: + name: java-spring-boot + version: "1.0.0" + category: general + +settings: + # Default settings for java-spring-boot + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-spring-boot/assets/schema.json b/skills/java-spring-boot/assets/schema.json new file mode 100644 index 0000000..d709a4d --- /dev/null +++ b/skills/java-spring-boot/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-spring-boot Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-spring-boot/references/.gitkeep b/skills/java-spring-boot/references/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-spring-boot/references/GUIDE.md b/skills/java-spring-boot/references/GUIDE.md new file mode 100644 index 0000000..590755c --- /dev/null +++ b/skills/java-spring-boot/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Spring Boot Guide + +## Overview + +This guide provides comprehensive documentation for the **java-spring-boot** skill in the custom-plugin-java plugin. + +## Category: General + +## Quick Start + +### Prerequisites + +- Familiarity with general concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-spring-boot - [your task description]" + +# Example +claude "java-spring-boot - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_spring_boot(input_data): + """ + Implement java-spring-boot functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-spring-boot/references/PATTERNS.md b/skills/java-spring-boot/references/PATTERNS.md new file mode 100644 index 0000000..431a1c1 --- /dev/null +++ b/skills/java-spring-boot/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Spring Boot Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: General + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-spring-boot skill* diff --git a/skills/java-spring-boot/scripts/.gitkeep b/skills/java-spring-boot/scripts/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-spring-boot/scripts/validate.py b/skills/java-spring-boot/scripts/validate.py new file mode 100755 index 0000000..bf5f065 --- /dev/null +++ b/skills/java-spring-boot/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-spring-boot skill. +Category: general +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-spring-boot skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-testing-advanced/assets/config.yaml b/skills/java-testing-advanced/assets/config.yaml new file mode 100644 index 0000000..979966d --- /dev/null +++ b/skills/java-testing-advanced/assets/config.yaml @@ -0,0 +1,41 @@ +# java-testing-advanced Configuration +# Category: testing +# Generated: 2025-12-30 + +skill: + name: java-testing-advanced + version: "1.0.0" + category: testing + +settings: + # Default settings for java-testing-advanced + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-testing-advanced/assets/schema.json b/skills/java-testing-advanced/assets/schema.json new file mode 100644 index 0000000..bb11e81 --- /dev/null +++ b/skills/java-testing-advanced/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-testing-advanced Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-testing-advanced/references/GUIDE.md b/skills/java-testing-advanced/references/GUIDE.md new file mode 100644 index 0000000..302999a --- /dev/null +++ b/skills/java-testing-advanced/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Testing Advanced Guide + +## Overview + +This guide provides comprehensive documentation for the **java-testing-advanced** skill in the custom-plugin-java plugin. + +## Category: Testing + +## Quick Start + +### Prerequisites + +- Familiarity with testing concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-testing-advanced - [your task description]" + +# Example +claude "java-testing-advanced - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_testing_advanced(input_data): + """ + Implement java-testing-advanced functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-testing-advanced/references/PATTERNS.md b/skills/java-testing-advanced/references/PATTERNS.md new file mode 100644 index 0000000..46a7f39 --- /dev/null +++ b/skills/java-testing-advanced/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Testing Advanced Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: Testing + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-testing-advanced skill* diff --git a/skills/java-testing-advanced/scripts/validate.py b/skills/java-testing-advanced/scripts/validate.py new file mode 100755 index 0000000..87eb21b --- /dev/null +++ b/skills/java-testing-advanced/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-testing-advanced skill. +Category: testing +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-testing-advanced skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/skills/java-testing/assets/.gitkeep b/skills/java-testing/assets/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-testing/assets/config.yaml b/skills/java-testing/assets/config.yaml new file mode 100644 index 0000000..8cc2a00 --- /dev/null +++ b/skills/java-testing/assets/config.yaml @@ -0,0 +1,41 @@ +# java-testing Configuration +# Category: testing +# Generated: 2025-12-30 + +skill: + name: java-testing + version: "1.0.0" + category: testing + +settings: + # Default settings for java-testing + enabled: true + log_level: info + + # Category-specific defaults + validation: + strict_mode: false + auto_fix: false + + output: + format: markdown + include_examples: true + +# Environment-specific overrides +environments: + development: + log_level: debug + validation: + strict_mode: false + + production: + log_level: warn + validation: + strict_mode: true + +# Integration settings +integrations: + # Enable/disable integrations + git: true + linter: true + formatter: true diff --git a/skills/java-testing/assets/schema.json b/skills/java-testing/assets/schema.json new file mode 100644 index 0000000..95c03da --- /dev/null +++ b/skills/java-testing/assets/schema.json @@ -0,0 +1,60 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "java-testing Configuration Schema", + "type": "object", + "properties": { + "skill": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string", + "pattern": "^\\d+\\.\\d+\\.\\d+$" + }, + "category": { + "type": "string", + "enum": [ + "api", + "testing", + "devops", + "security", + "database", + "frontend", + "algorithms", + "machine-learning", + "cloud", + "containers", + "general" + ] + } + }, + "required": [ + "name", + "version" + ] + }, + "settings": { + "type": "object", + "properties": { + "enabled": { + "type": "boolean", + "default": true + }, + "log_level": { + "type": "string", + "enum": [ + "debug", + "info", + "warn", + "error" + ] + } + } + } + }, + "required": [ + "skill" + ] +} \ No newline at end of file diff --git a/skills/java-testing/references/.gitkeep b/skills/java-testing/references/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-testing/references/GUIDE.md b/skills/java-testing/references/GUIDE.md new file mode 100644 index 0000000..703699d --- /dev/null +++ b/skills/java-testing/references/GUIDE.md @@ -0,0 +1,95 @@ +# Java Testing Guide + +## Overview + +This guide provides comprehensive documentation for the **java-testing** skill in the custom-plugin-java plugin. + +## Category: Testing + +## Quick Start + +### Prerequisites + +- Familiarity with testing concepts +- Development environment set up +- Plugin installed and configured + +### Basic Usage + +```bash +# Invoke the skill +claude "java-testing - [your task description]" + +# Example +claude "java-testing - analyze the current implementation" +``` + +## Core Concepts + +### Key Principles + +1. **Consistency** - Follow established patterns +2. **Clarity** - Write readable, maintainable code +3. **Quality** - Validate before deployment + +### Best Practices + +- Always validate input data +- Handle edge cases explicitly +- Document your decisions +- Write tests for critical paths + +## Common Tasks + +### Task 1: Basic Implementation + +```python +# Example implementation pattern +def implement_java_testing(input_data): + """ + Implement java-testing functionality. + + Args: + input_data: Input to process + + Returns: + Processed result + """ + # Validate input + if not input_data: + raise ValueError("Input required") + + # Process + result = process(input_data) + + # Return + return result +``` + +### Task 2: Advanced Usage + +For advanced scenarios, consider: + +- Configuration customization via `assets/config.yaml` +- Validation using `scripts/validate.py` +- Integration with other skills + +## Troubleshooting + +### Common Issues + +| Issue | Cause | Solution | +|-------|-------|----------| +| Skill not found | Not installed | Run plugin sync | +| Validation fails | Invalid config | Check config.yaml | +| Unexpected output | Missing context | Provide more details | + +## Related Resources + +- SKILL.md - Skill specification +- config.yaml - Configuration options +- validate.py - Validation script + +--- + +*Last updated: 2025-12-30* diff --git a/skills/java-testing/references/PATTERNS.md b/skills/java-testing/references/PATTERNS.md new file mode 100644 index 0000000..8b0b8af --- /dev/null +++ b/skills/java-testing/references/PATTERNS.md @@ -0,0 +1,87 @@ +# Java Testing Patterns + +## Design Patterns + +### Pattern 1: Input Validation + +Always validate input before processing: + +```python +def validate_input(data): + if data is None: + raise ValueError("Data cannot be None") + if not isinstance(data, dict): + raise TypeError("Data must be a dictionary") + return True +``` + +### Pattern 2: Error Handling + +Use consistent error handling: + +```python +try: + result = risky_operation() +except SpecificError as e: + logger.error(f"Operation failed: {e}") + handle_error(e) +except Exception as e: + logger.exception("Unexpected error") + raise +``` + +### Pattern 3: Configuration Loading + +Load and validate configuration: + +```python +import yaml + +def load_config(config_path): + with open(config_path) as f: + config = yaml.safe_load(f) + validate_config(config) + return config +``` + +## Anti-Patterns to Avoid + +### ❌ Don't: Swallow Exceptions + +```python +# BAD +try: + do_something() +except: + pass +``` + +### ✅ Do: Handle Explicitly + +```python +# GOOD +try: + do_something() +except SpecificError as e: + logger.warning(f"Expected error: {e}") + return default_value +``` + +## Category-Specific Patterns: Testing + +### Recommended Approach + +1. Start with the simplest implementation +2. Add complexity only when needed +3. Test each addition +4. Document decisions + +### Common Integration Points + +- Configuration: `assets/config.yaml` +- Validation: `scripts/validate.py` +- Documentation: `references/GUIDE.md` + +--- + +*Pattern library for java-testing skill* diff --git a/skills/java-testing/scripts/.gitkeep b/skills/java-testing/scripts/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/skills/java-testing/scripts/validate.py b/skills/java-testing/scripts/validate.py new file mode 100755 index 0000000..179e012 --- /dev/null +++ b/skills/java-testing/scripts/validate.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python3 +""" +Validation script for java-testing skill. +Category: testing +""" + +import os +import sys +import yaml +import json +from pathlib import Path + + +def validate_config(config_path: str) -> dict: + """ + Validate skill configuration file. + + Args: + config_path: Path to config.yaml + + Returns: + dict: Validation result with 'valid' and 'errors' keys + """ + errors = [] + + if not os.path.exists(config_path): + return {"valid": False, "errors": ["Config file not found"]} + + try: + with open(config_path, 'r') as f: + config = yaml.safe_load(f) + except yaml.YAMLError as e: + return {"valid": False, "errors": [f"YAML parse error: {e}"]} + + # Validate required fields + if 'skill' not in config: + errors.append("Missing 'skill' section") + else: + if 'name' not in config['skill']: + errors.append("Missing skill.name") + if 'version' not in config['skill']: + errors.append("Missing skill.version") + + # Validate settings + if 'settings' in config: + settings = config['settings'] + if 'log_level' in settings: + valid_levels = ['debug', 'info', 'warn', 'error'] + if settings['log_level'] not in valid_levels: + errors.append(f"Invalid log_level: {settings['log_level']}") + + return { + "valid": len(errors) == 0, + "errors": errors, + "config": config if not errors else None + } + + +def validate_skill_structure(skill_path: str) -> dict: + """ + Validate skill directory structure. + + Args: + skill_path: Path to skill directory + + Returns: + dict: Structure validation result + """ + required_dirs = ['assets', 'scripts', 'references'] + required_files = ['SKILL.md'] + + errors = [] + + # Check required files + for file in required_files: + if not os.path.exists(os.path.join(skill_path, file)): + errors.append(f"Missing required file: {file}") + + # Check required directories + for dir in required_dirs: + dir_path = os.path.join(skill_path, dir) + if not os.path.isdir(dir_path): + errors.append(f"Missing required directory: {dir}/") + else: + # Check for real content (not just .gitkeep) + files = [f for f in os.listdir(dir_path) if f != '.gitkeep'] + if not files: + errors.append(f"Directory {dir}/ has no real content") + + return { + "valid": len(errors) == 0, + "errors": errors, + "skill_name": os.path.basename(skill_path) + } + + +def main(): + """Main validation entry point.""" + skill_path = Path(__file__).parent.parent + + print(f"Validating java-testing skill...") + print(f"Path: {skill_path}") + + # Validate structure + structure_result = validate_skill_structure(str(skill_path)) + print(f"\nStructure validation: {'PASS' if structure_result['valid'] else 'FAIL'}") + if structure_result['errors']: + for error in structure_result['errors']: + print(f" - {error}") + + # Validate config + config_path = skill_path / 'assets' / 'config.yaml' + if config_path.exists(): + config_result = validate_config(str(config_path)) + print(f"\nConfig validation: {'PASS' if config_result['valid'] else 'FAIL'}") + if config_result['errors']: + for error in config_result['errors']: + print(f" - {error}") + else: + print("\nConfig validation: SKIPPED (no config.yaml)") + + # Summary + all_valid = structure_result['valid'] + print(f"\n==================================================") + print(f"Overall: {'VALID' if all_valid else 'INVALID'}") + + return 0 if all_valid else 1 + + +if __name__ == "__main__": + sys.exit(main())