engineering-package-evaluator
Reusable evaluation framework for assessing Python engineering packages for adoption — license compatibility, maintenance health, integration risk, and dependency strategy.
Best use case
engineering-package-evaluator is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Reusable evaluation framework for assessing Python engineering packages for adoption — license compatibility, maintenance health, integration risk, and dependency strategy.
Teams using engineering-package-evaluator should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/engineering-package-evaluator/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How engineering-package-evaluator Compares
| Feature / Agent | engineering-package-evaluator | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Reusable evaluation framework for assessing Python engineering packages for adoption — license compatibility, maintenance health, integration risk, and dependency strategy.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Engineering Package Evaluator Skill
Structured evaluation framework for Python engineering packages being
considered for adoption into digitalmodel or other MIT-licensed projects.
## When to Use This Skill
- Evaluating a new Python package for integration
- Assessing license compatibility for a dependency
- Reviewing maintenance health of an existing dependency
- Deciding between direct dependency vs optional extra vs wrapper
## Evaluation Checklist
### 1. License Compatibility
```
Package License?
├── MIT / BSD / Apache-2.0 → Direct dependency (safe)
├── LGPL-2.1 / LGPL-3.0 → Direct dependency (dynamic linking OK)
├── GPL-2.0 / GPL-3.0 → Optional extra ONLY (cannot bundle)
├── AGPL → Do not use (viral, affects SaaS)
└── Proprietary / Unknown → Do not use without legal review
```
### 2. Maintenance Health
| Metric | Green | Yellow | Red |
|--------|-------|--------|-----|
| Last commit | < 6 months | 6–18 months | > 18 months |
| Last release | < 12 months | 12–24 months | > 24 months |
| Open issues | < 50 | 50–200 | > 200 |
| Response time | < 1 week | 1–4 weeks | > 1 month |
| CI status | Passing | Flaky | Failing/none |
| Python 3.10+ | Supported | Untested | Incompatible |
### 3. Community & Quality
| Metric | Strong | Moderate | Weak |
|--------|--------|----------|------|
| GitHub stars | > 500 | 100–500 | < 100 |
| Contributors | > 10 | 3–10 | 1–2 |
| Documentation | Comprehensive | Basic | None/stale |
| Test suite | > 80% coverage | Some tests | No tests |
| JOSS/academic paper | Published | Preprint | None |
### 4. Dependency Risk
| Risk Factor | Mitigation |
|-------------|-----------|
| Single maintainer | Thin wrapper, plan for replacement |
| Breaking API changes | Pin version, adapter pattern |
| Large dependency tree | Evaluate transitive deps too |
| C/Fortran extensions | May not build on all platforms |
| Python version lag | Test in CI with target versions |
## Integration Patterns
### Direct Dependency
```toml
# pyproject.toml
[project]
dependencies = ["pygef>=0.12"]
```
Use when: MIT/BSD/Apache/LGPL, well-maintained, stable API.
### Optional Extra
```toml
[project.optional-dependencies]
geotechnical-gpl = ["groundhog>=0.12", "openpile>=1.0"]
```
Use when: GPL license, or large/heavy package not needed by all users.
### GPL Guard Pattern
```python
try:
import groundhog
HAS_GROUNDHOG = True
except ImportError:
HAS_GROUNDHOG = False
def compute_with_groundhog(soil_profile):
if not HAS_GROUNDHOG:
raise ImportError(
"groundhog required: pip install digitalmodel[geotechnical-gpl]"
)
return groundhog.some_function(soil_profile)
```
### Thin Wrapper (Isolation)
```python
# parsers/gef_reader.py — thin wrapper around pygef
"""Isolates pygef dependency. If pygef is abandoned, only this file changes."""
from pygef import read_gef
def parse_gef_file(path):
gef = read_gef(path)
return CPTData(
depth_m=gef.df["depth"].values,
qc_MPa=gef.df["qc"].values,
fs_kPa=gef.df["fs"].values,
)
```
## Evaluation Report Template
```yaml
package:
name: groundhog
version: "0.12.0"
pypi: https://pypi.org/project/groundhog/
repo: https://github.com/snakesonabrain/groundhog
license: GPL-3.0
assessment:
license_compatible: false # GPL vs MIT host
maintenance: green # active development
community: moderate # ~200 stars, 3 contributors, JOSS paper
test_coverage: moderate # some tests, no coverage badge
python_support: ">=3.8"
api_stability: moderate # breaking changes between 0.x versions
decision: optional_extra
strategy: |
Add as optional dependency under [geotechnical-gpl] extra.
Use GPL guard pattern. Core calculations independent.
Thin adapter in _groundhog_adapter.py for cross-validation.
risks:
- Single primary maintainer
- GPL-3.0 prevents bundling in MIT distribution
- 0.x version implies API not yet stable
```
## Related Skills
- `plugin-management` — managing plugin and extension systems
## Version History
| Version | Date | Changes |
|---------|------|---------|
| 1.0.0 | 2026-02-26 | Initial skill — license tree, health metrics, integration patterns |Related Skills
geotechnical-engineering
Domain expertise for offshore geotechnical analysis planning — soil classification, foundation design method selection, pile/anchor capacity, on-bottom stability, and scour prediction.
baoyu-article-illustrator
Article illustrations: type × style × palette consistency.
vscode-extensions
VS Code productivity optimization with essential extensions, settings sync, profiles, keybindings, snippets, and workspace configuration
git-advanced
Advanced git workflows including rebase, worktrees, bisect, hooks, and monorepo patterns
docker
Complete Docker containerization patterns with multi-stage builds for development and production workflows
elite-frontend-ux
Create distinctive, production-grade frontend interfaces with expert-level UX design. Use when building SaaS dashboards, landing pages, marketing sites, React/Vue components, HTML/CSS layouts, or any web UI. Combines bold aesthetic direction with systematic design tokens, WCAG accessibility, conversion optimization, and Tailwind/React best practices. Produces polished, memorable interfaces that avoid generic AI aesthetics while meeting professional standards. type: reference
sphinx
Generate comprehensive Python documentation with Sphinx. Covers autodoc for API extraction, Napoleon for Google/NumPy docstrings, intersphinx for cross-references, and multiple output formats including HTML, PDF, and ePub.
pandoc
Universal document converter for transforming Markdown to PDF, DOCX, HTML, LaTeX, and 40+ other formats. Covers templates, filters, citations with BibTeX/CSL, and batch conversion automation scripts.
marp
Create professional Markdown-based slide presentations with Marp. Covers themes, directives, speaker notes, presenter view, and export to PDF, HTML, and PPTX formats. Includes VS Code integration, CLI usage, and CI/CD automation.
docusaurus
Build modern documentation websites with Docusaurus. Covers docs, blog, pages, versioning, i18n, search integration, and deployment patterns. React-based with MDX support for interactive documentation.
slack-api
Slack bot development and workspace automation using Web API, Events API, Socket Mode, and Block Kit for building interactive messaging applications
miro-api
Miro whiteboard automation using REST API v2 and Python SDK for creating boards, frames, shapes, connectors, and collaborative visual workflows