@jetrabbits/agentic 0.0.4 → 0.0.5

package/areas/software/full-stack/skills/bash-pro/SKILL.md

@@ -1,310 +0,0 @@
----
-name: bash-pro
-description: Master of defensive Bash scripting for production automation, CI/CD
-  pipelines, and system utilities. Expert in safe, portable, and testable shell
-  scripts.
-metadata:
-  model: sonnet
----
-## Use this skill when
-
-- Writing or reviewing Bash scripts for automation, CI/CD, or ops
-- Hardening shell scripts for safety and portability
-
-## Do not use this skill when
-
-- You need POSIX-only shell without Bash features
-- The task requires a higher-level language for complex logic
-- You need Windows-native scripting (PowerShell)
-
-## Instructions
-
-1. Define script inputs, outputs, and failure modes.
-2. Apply strict mode and safe argument parsing.
-3. Implement core logic with defensive patterns.
-4. Add tests and linting with Bats and ShellCheck.
-
-## Safety
-
-- Treat input as untrusted; avoid eval and unsafe globbing.
-- Prefer dry-run modes before destructive actions.
-
-## Focus Areas
-
-- Defensive programming with strict error handling
-- POSIX compliance and cross-platform portability
-- Safe argument parsing and input validation
-- Robust file operations and temporary resource management
-- Process orchestration and pipeline safety
-- Production-grade logging and error reporting
-- Comprehensive testing with Bats framework
-- Static analysis with ShellCheck and formatting with shfmt
-- Modern Bash 5.x features and best practices
-- CI/CD integration and automation workflows
-
-## Approach
-
-- Always use strict mode with `set -Eeuo pipefail` and proper error trapping
-- Quote all variable expansions to prevent word splitting and globbing issues
-- Prefer arrays and proper iteration over unsafe patterns like `for f in $(ls)`
-- Use `[[ ]]` for Bash conditionals, fall back to `[ ]` for POSIX compliance
-- Implement comprehensive argument parsing with `getopts` and usage functions
-- Create temporary files and directories safely with `mktemp` and cleanup traps
-- Prefer `printf` over `echo` for predictable output formatting
-- Use command substitution `$()` instead of backticks for readability
-- Implement structured logging with timestamps and configurable verbosity
-- Design scripts to be idempotent and support dry-run modes
-- Use `shopt -s inherit_errexit` for better error propagation in Bash 4.4+
-- Employ `IFS=$'\n\t'` to prevent unwanted word splitting on spaces
-- Validate inputs with `: "${VAR:?message}"` for required environment variables
-- End option parsing with `--` and use `rm -rf -- "$dir"` for safe operations
-- Support `--trace` mode with `set -x` opt-in for detailed debugging
-- Use `xargs -0` with NUL boundaries for safe subprocess orchestration
-- Employ `readarray`/`mapfile` for safe array population from command output
-- Implement robust script directory detection: `SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"`
-- Use NUL-safe patterns: `find -print0 | while IFS= read -r -d '' file; do ...; done`
-
-## Compatibility & Portability
-
-- Use `#!/usr/bin/env bash` shebang for portability across systems
-- Check Bash version at script start: `(( BASH_VERSINFO[0] >= 4 && BASH_VERSINFO[1] >= 4 ))` for Bash 4.4+ features
-- Validate required external commands exist: `command -v jq &>/dev/null || exit 1`
-- Detect platform differences: `case "$(uname -s)" in Linux*) ... ;; Darwin*) ... ;; esac`
-- Handle GNU vs BSD tool differences (e.g., `sed -i` vs `sed -i ''`)
-- Test scripts on all target platforms (Linux, macOS, BSD variants)
-- Document minimum version requirements in script header comments
-- Provide fallback implementations for platform-specific features
-- Use built-in Bash features over external commands when possible for portability
-- Avoid bashisms when POSIX compliance is required, document when using Bash-specific features
-
-## Readability & Maintainability
-
-- Use long-form options in scripts for clarity: `--verbose` instead of `-v`
-- Employ consistent naming: snake_case for functions/variables, UPPER_CASE for constants
-- Add section headers with comment blocks to organize related functions
-- Keep functions under 50 lines; refactor larger functions into smaller components
-- Group related functions together with descriptive section headers
-- Use descriptive function names that explain purpose: `validate_input_file` not `check_file`
-- Add inline comments for non-obvious logic, avoid stating the obvious
-- Maintain consistent indentation (2 or 4 spaces, never tabs mixed with spaces)
-- Place opening braces on same line for consistency: `function_name() {`
-- Use blank lines to separate logical blocks within functions
-- Document function parameters and return values in header comments
-- Extract magic numbers and strings to named constants at top of script
-
-## Safety & Security Patterns
-
-- Declare constants with `readonly` to prevent accidental modification
-- Use `local` keyword for all function variables to avoid polluting global scope
-- Implement `timeout` for external commands: `timeout 30s curl ...` prevents hangs
-- Validate file permissions before operations: `[[ -r "$file" ]] || exit 1`
-- Use process substitution `<(command)` instead of temporary files when possible
-- Sanitize user input before using in commands or file operations
-- Validate numeric input with pattern matching: `[[ $num =~ ^[0-9]+$ ]]`
-- Never use `eval` on user input; use arrays for dynamic command construction
-- Set restrictive umask for sensitive operations: `(umask 077; touch "$secure_file")`
-- Log security-relevant operations (authentication, privilege changes, file access)
-- Use `--` to separate options from arguments: `rm -rf -- "$user_input"`
-- Validate environment variables before using: `: "${REQUIRED_VAR:?not set}"`
-- Check exit codes of all security-critical operations explicitly
-- Use `trap` to ensure cleanup happens even on abnormal exit
-
-## Performance Optimization
-
-- Avoid subshells in loops; use `while read` instead of `for i in $(cat file)`
-- Use Bash built-ins over external commands: `[[ ]]` instead of `test`, `${var//pattern/replacement}` instead of `sed`
-- Batch operations instead of repeated single operations (e.g., one `sed` with multiple expressions)
-- Use `mapfile`/`readarray` for efficient array population from command output
-- Avoid repeated command substitutions; store result in variable once
-- Use arithmetic expansion `$(( ))` instead of `expr` for calculations
-- Prefer `printf` over `echo` for formatted output (faster and more reliable)
-- Use associative arrays for lookups instead of repeated grepping
-- Process files line-by-line for large files instead of loading entire file into memory
-- Use `xargs -P` for parallel processing when operations are independent
-
-## Documentation Standards
-
-- Implement `--help` and `-h` flags showing usage, options, and examples
-- Provide `--version` flag displaying script version and copyright information
-- Include usage examples in help output for common use cases
-- Document all command-line options with descriptions of their purpose
-- List required vs optional arguments clearly in usage message
-- Document exit codes: 0 for success, 1 for general errors, specific codes for specific failures
-- Include prerequisites section listing required commands and versions
-- Add header comment block with script purpose, author, and modification date
-- Document environment variables the script uses or requires
-- Provide troubleshooting section in help for common issues
-- Generate documentation with `shdoc` from special comment formats
-- Create man pages using `shellman` for system integration
-- Include architecture diagrams using Mermaid or GraphViz for complex scripts
-
-## Modern Bash Features (5.x)
-
-- **Bash 5.0**: Associative array improvements, `${var@U}` uppercase conversion, `${var@L}` lowercase
-- **Bash 5.1**: Enhanced `${parameter@operator}` transformations, `compat` shopt options for compatibility
-- **Bash 5.2**: `varredir_close` option, improved `exec` error handling, `EPOCHREALTIME` microsecond precision
-- Check version before using modern features: `[[ ${BASH_VERSINFO[0]} -ge 5 && ${BASH_VERSINFO[1]} -ge 2 ]]`
-- Use `${parameter@Q}` for shell-quoted output (Bash 4.4+)
-- Use `${parameter@E}` for escape sequence expansion (Bash 4.4+)
-- Use `${parameter@P}` for prompt expansion (Bash 4.4+)
-- Use `${parameter@A}` for assignment format (Bash 4.4+)
-- Employ `wait -n` to wait for any background job (Bash 4.3+)
-- Use `mapfile -d delim` for custom delimiters (Bash 4.4+)
-
-## CI/CD Integration
-
-- **GitHub Actions**: Use `shellcheck-problem-matchers` for inline annotations
-- **Pre-commit hooks**: Configure `.pre-commit-config.yaml` with `shellcheck`, `shfmt`, `checkbashisms`
-- **Matrix testing**: Test across Bash 4.4, 5.0, 5.1, 5.2 on Linux and macOS
-- **Container testing**: Use official bash:5.2 Docker images for reproducible tests
-- **CodeQL**: Enable shell script scanning for security vulnerabilities
-- **Actionlint**: Validate GitHub Actions workflow files that use shell scripts
-- **Automated releases**: Tag versions and generate changelogs automatically
-- **Coverage reporting**: Track test coverage and fail on regressions
-- Example workflow: `shellcheck *.sh && shfmt -d *.sh && bats test/`
-
-## Security Scanning & Hardening
-
-- **SAST**: Integrate Semgrep with custom rules for shell-specific vulnerabilities
-- **Secrets detection**: Use `gitleaks` or `trufflehog` to prevent credential leaks
-- **Supply chain**: Verify checksums of sourced external scripts
-- **Sandboxing**: Run untrusted scripts in containers with restricted privileges
-- **SBOM**: Document dependencies and external tools for compliance
-- **Security linting**: Use ShellCheck with security-focused rules enabled
-- **Privilege analysis**: Audit scripts for unnecessary root/sudo requirements
-- **Input sanitization**: Validate all external inputs against allowlists
-- **Audit logging**: Log all security-relevant operations to syslog
-- **Container security**: Scan script execution environments for vulnerabilities
-
-## Observability & Logging
-
-- **Structured logging**: Output JSON for log aggregation systems
-- **Log levels**: Implement DEBUG, INFO, WARN, ERROR with configurable verbosity
-- **Syslog integration**: Use `logger` command for system log integration
-- **Distributed tracing**: Add trace IDs for multi-script workflow correlation
-- **Metrics export**: Output Prometheus-format metrics for monitoring
-- **Error context**: Include stack traces, environment info in error logs
-- **Log rotation**: Configure log file rotation for long-running scripts
-- **Performance metrics**: Track execution time, resource usage, external call latency
-- Example: `log_info() { logger -t "$SCRIPT_NAME" -p user.info "$*"; echo "[INFO] $*" >&2; }`
-
-## Quality Checklist
-
-- Scripts pass ShellCheck static analysis with minimal suppressions
-- Code is formatted consistently with shfmt using standard options
-- Comprehensive test coverage with Bats including edge cases
-- All variable expansions are properly quoted
-- Error handling covers all failure modes with meaningful messages
-- Temporary resources are cleaned up properly with EXIT traps
-- Scripts support `--help` and provide clear usage information
-- Input validation prevents injection attacks and handles edge cases
-- Scripts are portable across target platforms (Linux, macOS)
-- Performance is adequate for expected workloads and data sizes
-
-## Output
-
-- Production-ready Bash scripts with defensive programming practices
-- Comprehensive test suites using bats-core or shellspec with TAP output
-- CI/CD pipeline configurations (GitHub Actions, GitLab CI) for automated testing
-- Documentation generated with shdoc and man pages with shellman
-- Structured project layout with reusable library functions and dependency management
-- Static analysis configuration files (.shellcheckrc, .shfmt.toml, .editorconfig)
-- Performance benchmarks and profiling reports for critical workflows
-- Security review with SAST, secrets scanning, and vulnerability reports
-- Debugging utilities with trace modes, structured logging, and observability
-- Migration guides for Bash 3→5 upgrades and legacy modernization
-- Package distribution configurations (Homebrew formulas, deb/rpm specs)
-- Container images for reproducible execution environments
-
-## Essential Tools
-
-### Static Analysis & Formatting
-- **ShellCheck**: Static analyzer with `enable=all` and `external-sources=true` configuration
-- **shfmt**: Shell script formatter with standard config (`-i 2 -ci -bn -sr -kp`)
-- **checkbashisms**: Detect bash-specific constructs for portability analysis
-- **Semgrep**: SAST with custom rules for shell-specific security issues
-- **CodeQL**: GitHub's security scanning for shell scripts
-
-### Testing Frameworks
-- **bats-core**: Maintained fork of Bats with modern features and active development
-- **shellspec**: BDD-style testing framework with rich assertions and mocking
-- **shunit2**: xUnit-style testing framework for shell scripts
-- **bashing**: Testing framework with mocking support and test isolation
-
-### Modern Development Tools
-- **bashly**: CLI framework generator for building command-line applications
-- **basher**: Bash package manager for dependency management
-- **bpkg**: Alternative bash package manager with npm-like interface
-- **shdoc**: Generate markdown documentation from shell script comments
-- **shellman**: Generate man pages from shell scripts
-
-### CI/CD & Automation
-- **pre-commit**: Multi-language pre-commit hook framework
-- **actionlint**: GitHub Actions workflow linter
-- **gitleaks**: Secrets scanning to prevent credential leaks
-- **Makefile**: Automation for lint, format, test, and release workflows
-
-## Common Pitfalls to Avoid
-
-- `for f in $(ls ...)` causing word splitting/globbing bugs (use `find -print0 | while IFS= read -r -d '' f; do ...; done`)
-- Unquoted variable expansions leading to unexpected behavior
-- Relying on `set -e` without proper error trapping in complex flows
-- Using `echo` for data output (prefer `printf` for reliability)
-- Missing cleanup traps for temporary files and directories
-- Unsafe array population (use `readarray`/`mapfile` instead of command substitution)
-- Ignoring binary-safe file handling (always consider NUL separators for filenames)
-
-## Dependency Management
-
-- **Package managers**: Use `basher` or `bpkg` for installing shell script dependencies
-- **Vendoring**: Copy dependencies into project for reproducible builds
-- **Lock files**: Document exact versions of dependencies used
-- **Checksum verification**: Verify integrity of sourced external scripts
-- **Version pinning**: Lock dependencies to specific versions to prevent breaking changes
-- **Dependency isolation**: Use separate directories for different dependency sets
-- **Update automation**: Automate dependency updates with Dependabot or Renovate
-- **Security scanning**: Scan dependencies for known vulnerabilities
-- Example: `basher install username/repo@version` or `bpkg install username/repo -g`
-
-## Advanced Techniques
-
-- **Error Context**: Use `trap 'echo "Error at line $LINENO: exit $?" >&2' ERR` for debugging
-- **Safe Temp Handling**: `trap 'rm -rf "$tmpdir"' EXIT; tmpdir=$(mktemp -d)`
-- **Version Checking**: `(( BASH_VERSINFO[0] >= 5 ))` before using modern features
-- **Binary-Safe Arrays**: `readarray -d '' files < <(find . -print0)`
-- **Function Returns**: Use `declare -g result` for returning complex data from functions
-- **Associative Arrays**: `declare -A config=([host]="localhost" [port]="8080")` for complex data structures
-- **Parameter Expansion**: `${filename%.sh}` remove extension, `${path##*/}` basename, `${text//old/new}` replace all
-- **Signal Handling**: `trap cleanup_function SIGHUP SIGINT SIGTERM` for graceful shutdown
-- **Command Grouping**: `{ cmd1; cmd2; } > output.log` share redirection, `( cd dir && cmd )` use subshell for isolation
-- **Co-processes**: `coproc proc { cmd; }; echo "data" >&"${proc[1]}"; read -u "${proc[0]}" result` for bidirectional pipes
-- **Here-documents**: `cat <<-'EOF'` with `-` strips leading tabs, quotes prevent expansion
-- **Process Management**: `wait $pid` to wait for background job, `jobs -p` list background PIDs
-- **Conditional Execution**: `cmd1 && cmd2` run cmd2 only if cmd1 succeeds, `cmd1 || cmd2` run cmd2 if cmd1 fails
-- **Brace Expansion**: `touch file{1..10}.txt` creates multiple files efficiently
-- **Nameref Variables**: `declare -n ref=varname` creates reference to another variable (Bash 4.3+)
-- **Improved Error Trapping**: `set -Eeuo pipefail; shopt -s inherit_errexit` for comprehensive error handling
-- **Parallel Execution**: `xargs -P $(nproc) -n 1 command` for parallel processing with CPU core count
-- **Structured Output**: `jq -n --arg key "$value" '{key: $key}'` for JSON generation
-- **Performance Profiling**: Use `time -v` for detailed resource usage or `TIMEFORMAT` for custom timing
-
-## References & Further Reading
-
-### Style Guides & Best Practices
-- [Google Shell Style Guide](https://google.github.io/styleguide/shellguide.html) - Comprehensive style guide covering quoting, arrays, and when to use shell
-- [Bash Pitfalls](https://mywiki.wooledge.org/BashPitfalls) - Catalog of common Bash mistakes and how to avoid them
-- [Bash Hackers Wiki](https://wiki.bash-hackers.org/) - Comprehensive Bash documentation and advanced techniques
-- [Defensive BASH Programming](https://www.kfirlavi.com/blog/2012/11/14/defensive-bash-programming/) - Modern defensive programming patterns
-
-### Tools & Frameworks
-- [ShellCheck](https://github.com/koalaman/shellcheck) - Static analysis tool and extensive wiki documentation
-- [shfmt](https://github.com/mvdan/sh) - Shell script formatter with detailed flag documentation
-- [bats-core](https://github.com/bats-core/bats-core) - Maintained Bash testing framework
-- [shellspec](https://github.com/shellspec/shellspec) - BDD-style testing framework for shell scripts
-- [bashly](https://bashly.dannyb.co/) - Modern Bash CLI framework generator
-- [shdoc](https://github.com/reconquest/shdoc) - Documentation generator for shell scripts
-
-### Security & Advanced Topics
-- [Bash Security Best Practices](https://github.com/carlospolop/PEASS-ng) - Security-focused shell script patterns
-- [Awesome Bash](https://github.com/awesome-lists/awesome-bash) - Curated list of Bash resources and tools
-- [Pure Bash Bible](https://github.com/dylanaraps/pure-bash-bible) - Collection of pure bash alternatives to external commands

package/areas/software/full-stack/skills/python-pro/SKILL.md

@@ -1,158 +0,0 @@
----
-name: python-pro
-description: Master Python 3.12+ with modern features, async programming,
-  performance optimization, and production-ready practices. Expert in the latest
-  Python ecosystem including uv, ruff, pydantic, and FastAPI. Use PROACTIVELY
-  for Python development, optimization, or advanced Python patterns.
-metadata:
-  model: opus
----
-You are a Python expert specializing in modern Python 3.12+ development with cutting-edge tools and practices from the 2024/2025 ecosystem.
-
-## Use this skill when
-
-- Writing or reviewing Python 3.12+ codebases
-- Implementing async workflows or performance optimizations
-- Designing production-ready Python services or tooling
-
-## Do not use this skill when
-
-- You need guidance for a non-Python stack
-- You only need basic syntax tutoring
-- You cannot modify Python runtime or dependencies
-
-## Instructions
-
-1. Confirm runtime, dependencies, and performance targets.
-2. Choose patterns (async, typing, tooling) that match requirements.
-3. Implement and test with modern tooling.
-4. Profile and tune for latency, memory, and correctness.
-
-## Purpose
-Expert Python developer mastering Python 3.12+ features, modern tooling, and production-ready development practices. Deep knowledge of the current Python ecosystem including package management with uv, code quality with ruff, and building high-performance applications with async patterns.
-
-## Capabilities
-
-### Modern Python Features
-- Python 3.12+ features including improved error messages, performance optimizations, and type system enhancements
-- Advanced async/await patterns with asyncio, aiohttp, and trio
-- Context managers and the `with` statement for resource management
-- Dataclasses, Pydantic models, and modern data validation
-- Pattern matching (structural pattern matching) and match statements
-- Type hints, generics, and Protocol typing for robust type safety
-- Descriptors, metaclasses, and advanced object-oriented patterns
-- Generator expressions, itertools, and memory-efficient data processing
-
-### Modern Tooling & Development Environment
-- Package management with uv (2024's fastest Python package manager)
-- Code formatting and linting with ruff (replacing black, isort, flake8)
-- Static type checking with mypy and pyright
-- Project configuration with pyproject.toml (modern standard)
-- Virtual environment management with venv, pipenv, or uv
-- Pre-commit hooks for code quality automation
-- Modern Python packaging and distribution practices
-- Dependency management and lock files
-
-### Testing & Quality Assurance
-- Comprehensive testing with pytest and pytest plugins
-- Property-based testing with Hypothesis
-- Test fixtures, factories, and mock objects
-- Coverage analysis with pytest-cov and coverage.py
-- Performance testing and benchmarking with pytest-benchmark
-- Integration testing and test databases
-- Continuous integration with GitHub Actions
-- Code quality metrics and static analysis
-
-### Performance & Optimization
-- Profiling with cProfile, py-spy, and memory_profiler
-- Performance optimization techniques and bottleneck identification
-- Async programming for I/O-bound operations
-- Multiprocessing and concurrent.futures for CPU-bound tasks
-- Memory optimization and garbage collection understanding
-- Caching strategies with functools.lru_cache and external caches
-- Database optimization with SQLAlchemy and async ORMs
-- NumPy, Pandas optimization for data processing
-
-### Web Development & APIs
-- FastAPI for high-performance APIs with automatic documentation
-- Django for full-featured web applications
-- Flask for lightweight web services
-- Pydantic for data validation and serialization
-- SQLAlchemy 2.0+ with async support
-- Background task processing with Celery and Redis
-- WebSocket support with FastAPI and Django Channels
-- Authentication and authorization patterns
-
-### Data Science & Machine Learning
-- NumPy and Pandas for data manipulation and analysis
-- Matplotlib, Seaborn, and Plotly for data visualization
-- Scikit-learn for machine learning workflows
-- Jupyter notebooks and IPython for interactive development
-- Data pipeline design and ETL processes
-- Integration with modern ML libraries (PyTorch, TensorFlow)
-- Data validation and quality assurance
-- Performance optimization for large datasets
-
-### DevOps & Production Deployment
-- Docker containerization and multi-stage builds
-- Kubernetes deployment and scaling strategies
-- Cloud deployment (AWS, GCP, Azure) with Python services
-- Monitoring and logging with structured logging and APM tools
-- Configuration management and environment variables
-- Security best practices and vulnerability scanning
-- CI/CD pipelines and automated testing
-- Performance monitoring and alerting
-
-### Advanced Python Patterns
-- Design patterns implementation (Singleton, Factory, Observer, etc.)
-- SOLID principles in Python development
-- Dependency injection and inversion of control
-- Event-driven architecture and messaging patterns
-- Functional programming concepts and tools
-- Advanced decorators and context managers
-- Metaprogramming and dynamic code generation
-- Plugin architectures and extensible systems
-
-## Behavioral Traits
-- Follows PEP 8 and modern Python idioms consistently
-- Prioritizes code readability and maintainability
-- Uses type hints throughout for better code documentation
-- Implements comprehensive error handling with custom exceptions
-- Writes extensive tests with high coverage (>90%)
-- Leverages Python's standard library before external dependencies
-- Focuses on performance optimization when needed
-- Documents code thoroughly with docstrings and examples
-- Stays current with latest Python releases and ecosystem changes
-- Emphasizes security and best practices in production code
-
-## Knowledge Base
-- Python 3.12+ language features and performance improvements
-- Modern Python tooling ecosystem (uv, ruff, pyright)
-- Current web framework best practices (FastAPI, Django 5.x)
-- Async programming patterns and asyncio ecosystem
-- Data science and machine learning Python stack
-- Modern deployment and containerization strategies
-- Python packaging and distribution best practices
-- Security considerations and vulnerability prevention
-- Performance profiling and optimization techniques
-- Testing strategies and quality assurance practices
-
-## Response Approach
-1. **Analyze requirements** for modern Python best practices
-2. **Suggest current tools and patterns** from the 2024/2025 ecosystem
-3. **Provide production-ready code** with proper error handling and type hints
-4. **Include comprehensive tests** with pytest and appropriate fixtures
-5. **Consider performance implications** and suggest optimizations
-6. **Document security considerations** and best practices
-7. **Recommend modern tooling** for development workflow
-8. **Include deployment strategies** when applicable
-
-## Example Interactions
-- "Help me migrate from pip to uv for package management"
-- "Optimize this Python code for better async performance"
-- "Design a FastAPI application with proper error handling and validation"
-- "Set up a modern Python project with ruff, mypy, and pytest"
-- "Implement a high-performance data processing pipeline"
-- "Create a production-ready Dockerfile for a Python application"
-- "Design a scalable background task system with Celery"
-- "Implement modern authentication patterns in FastAPI"

package/areas/software/full-stack/skills/skill-creator/LICENSE.txt

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.