packwise-skills 1.0.0

package/sub-skills/backend/python-server.md

@@ -0,0 +1,164 @@
+# Python Backend Build Sub-Skill
+
+Build Python backend services (FastAPI/Django/Flask/Litestar).
+
+**Current version**: Python 3.12+ / 3.13 (2025-2026)
+
+## When to Use
+
+- REST API / GraphQL API
+- Web application backend
+- AI/ML model serving
+- Data processing service
+- Research/academic projects
+- Admin panels / internal tools
+
+## Framework Quick Start
+
+### FastAPI (Recommended for new projects)
+
+```python
+from fastapi import FastAPI
+app = FastAPI()
+
+@app.get("/health")
+async def health():
+    return {"status": "ok"}
+
+@app.get("/api/users/{user_id}")
+async def get_user(user_id: int):
+    return {"user_id": user_id}
+```
+
+```bash
+uvicorn app:app --host 0.0.0.0 --port 8000 --workers 4
+```
+
+### Django (Full-featured, batteries-included)
+
+```bash
+django-admin startproject myproject
+cd myproject
+python manage.py migrate
+python manage.py collectstatic
+python manage.py runserver
+```
+
+### Flask (Lightweight, minimal)
+
+```python
+from flask import Flask
+app = Flask(__name__)
+
+@app.route("/health")
+def health():
+    return {"status": "ok"}
+```
+
+### Framework Comparison
+
+| Framework | Performance | Async | ORM | Admin | Best For |
+|-----------|------------|-------|-----|-------|---------|
+| FastAPI | Highest | Native | SQLAlchemy | Via admin | APIs, microservices, ML serving |
+| Django | Good | ASGI (since 4.1) | Built-in | Built-in | Full-stack web apps, CMS |
+| Flask | Moderate | Via extensions | SQLAlchemy | Via extensions | Simple APIs, microservices |
+| Litestar | High | Native | SQLAlchemy | Built-in | FastAPI alternative |
+
+## Build & Package
+
+```bash
+# FastAPI/Flask: run directly, no compilation needed
+# Django:
+python manage.py collectstatic       # Collect static files
+python manage.py migrate              # Database migration
+
+# Production WSGI/ASGI server
+# FastAPI/ASGI:
+pip install uvicorn[standard]
+uvicorn app:app --host 0.0.0.0 --port 8000 --workers 4
+
+# Django/Flask/WSGI:
+pip install gunicorn
+gunicorn -w 4 -b 0.0.0.0:8000 myapp.wsgi:application
+
+# Gunicorn + Uvicorn workers (async WSGI)
+gunicorn app:app -w 4 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000
+```
+
+## Docker
+
+```dockerfile
+FROM python:3.13-slim AS builder
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir --prefix=/install -r requirements.txt
+
+FROM python:3.13-slim
+WORKDIR /app
+COPY --from=builder /install /usr/local
+COPY . .
+RUN groupadd -r appuser && useradd -r -g appuser appuser && \
+    chown -R appuser:appuser /app
+USER appuser
+EXPOSE 8000
+HEALTHCHECK --interval=30s --timeout=3s CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || exit 1
+CMD ["gunicorn", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "-b", "0.0.0.0:8000", "app:app"]
+```
+
+## Dependency Management
+
+```bash
+# pip + requirements.txt (traditional)
+pip freeze > requirements.txt
+pip install -r requirements.txt
+
+# Poetry (recommended for new projects)
+poetry init
+poetry add fastapi uvicorn sqlalchemy
+poetry export -f requirements.txt --output requirements.txt
+
+# uv (fastest, Rust-based, pip-compatible)
+pip install uv
+uv pip install fastapi uvicorn
+uv pip compile requirements.in -o requirements.txt
+```
+
+## Gunicorn + Nginx
+
+```bash
+# Gunicorn (production WSGI server)
+gunicorn -w 4 -b 127.0.0.1:8000 myapp.wsgi:application
+
+# Nginx reverse proxy
+# upstream backend { server 127.0.0.1:8000; }
+# server {
+#     listen 80;
+#     server_name example.com;
+#     location / { proxy_pass http://backend; proxy_set_header Host $host; }
+# }
+```
+
+## Cloud Platforms
+
+| Platform | Method | Best For |
+|----------|--------|---------|
+| Railway | Git push | Quick deploy |
+| Render | Git push | Quick deploy |
+| Fly.io | Docker | Global deploy |
+| AWS Lambda | Mangum (ASGI adapter) | Serverless |
+| Vercel | Serverless Functions | FastAPI (limited) |
+| Aliyun FC | Serverless | China market |
+
+## Common Pitfalls
+
+| Issue | Fix |
+|-------|-----|
+| Dependency install failure | Pin exact versions; use `pip-compile` for locked deps |
+| Database migration | Run `alembic upgrade head` or `python manage.py migrate` in production |
+| Static files 404 | Nginx serves static files directly; Django: `collectstatic` |
+| Async not working | FastAPI: use `async def`; Django: enable ASGI; Flask: use Quart for async |
+| Python version mismatch | Specify `python:3.13-slim` in Dockerfile; match local and production |
+| `ModuleNotFoundError` | Ensure virtualenv activated; check `sys.path` |
+| WSGI vs ASGI confusion | FastAPI = ASGI (uvicorn); Django = WSGI (gunicorn) or ASGI (uvicorn) |
+| CORS error | FastAPI: `CORSMiddleware`; Django: `django-cors-headers`; Flask: `flask-cors` |
+| Memory leak in workers | Gunicorn: `--max-requests 1000` to restart workers periodically |

package/sub-skills/backend/rust-backend.md

@@ -0,0 +1,118 @@
+# Rust Backend Build Sub-Skill
+
+Build and package Rust backend services (Axum/Actix-Web/Rocket/Warp).
+
+**Current version**: Rust 1.82+ / Axum 0.7 / Actix-Web 4.x (2025-2026)
+
+## When to Use
+
+- High-performance API services
+- Microservices requiring low latency and minimal memory
+- WebSocket servers
+- System-level services (CLI backends, daemons)
+- Security-sensitive backends (memory safety guaranteed by compiler)
+
+## Build
+
+```bash
+# Standard build
+cargo build --release
+# Output: target/release/myapp
+
+# With version embedding
+cargo build --release
+# In build.rs:
+# println!("cargo:rustc-env=APP_VERSION={}", env!("CARGO_PKG_VERSION"));
+
+# Static binary (no system dependencies)
+RUSTFLAGS='-C target-feature=+crt-static' cargo build --release --target x86_64-unknown-linux-gnu
+
+# Cross-compile
+cargo install cross
+cross build --release --target x86_64-unknown-linux-gnu
+cross build --release --target aarch64-unknown-linux-gnu
+cross build --release --target x86_64-pc-windows-gnu
+cross build --release --target x86_64-apple-darwin
+```
+
+## Framework Quick Start
+
+### Axum (Recommended — Tokio team)
+
+```rust
+use axum::{routing::get, Router};
+use std::net::SocketAddr;
+
+#[tokio::main]
+async fn main() {
+    let app = Router::new()
+        .route("/", get(|| async { "Hello, World!" }))
+        .route("/health", get(|| async { "OK" }));
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], 8080));
+    axum::serve(tokio::net::TcpListener::bind(addr).await.unwrap(), app)
+        .await
+        .unwrap();
+}
+```
+
+### Actix-Web (Highest raw performance)
+
+```rust
+use actix_web::{web, App, HttpServer, HttpResponse};
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    HttpServer::new(|| {
+        App::new()
+            .route("/", web::get().to(|| async { HttpResponse::Ok().body("Hello!") }))
+            .route("/health", web::get().to(|| async { HttpResponse::Ok().body("OK") }))
+    })
+    .bind("0.0.0.0:8080")?
+    .run()
+    .await
+}
+```
+
+## Docker
+
+```dockerfile
+FROM rust:1.82-slim AS builder
+WORKDIR /app
+COPY Cargo.toml Cargo.lock ./
+# Cache dependencies (create dummy src)
+RUN mkdir src && echo 'fn main(){}' > src/main.rs && cargo build --release && rm -rf src
+COPY src/ src/
+RUN touch src/main.rs && cargo build --release
+
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates && \
+    rm -rf /var/lib/apt/lists/* && \
+    groupadd -r appuser && useradd -r -g appuser appuser
+COPY --from=builder /app/target/release/myapp /myapp
+USER appuser
+EXPOSE 8080
+HEALTHCHECK --interval=30s --timeout=3s CMD curl -f http://localhost:8080/health || exit 1
+CMD ["/myapp"]
+```
+
+## Selection Guide
+
+| Framework | Async Runtime | Performance | Ecosystem | Best For |
+|-----------|--------------|-------------|-----------|----------|
+| Axum | Tokio | High | Growing fast | New projects, middleware-heavy |
+| Actix-Web | Tokio | Highest | Mature | Maximum throughput |
+| Rocket | Tokio | High | Good | Rapid prototyping, ergonomic API |
+| Warp | Tokio | High | Smaller | Filter-based routing |
+| Poem | Tokio | High | Growing | OpenAPI integration |
+
+## Common Pitfalls
+
+| Issue | Fix |
+|-------|-----|
+| Binary too large | Use `strip = true` in Cargo.toml `[profile.release]`; use `upx --best` |
+| Slow compile | Use `sccache`; enable incremental compilation; reduce dependencies |
+| Cross-compile fails | Use `cross` tool; or Docker-based cross-compilation |
+| `openssl` build fails | Use `rustls` (pure Rust TLS) instead of native OpenSSL |
+| Missing system libs in Docker | Use `debian:bookworm-slim` (not `alpine`) for glibc compatibility |
+| Static linking issues | Use `x86_64-unknown-linux-musl` target for fully static binary |

package/sub-skills/cli/python-cli.md

@@ -0,0 +1,236 @@
+# Python CLI Tool Packaging Sub-Skill
+
+Package and distribute Python command-line tools as standalone executables or pip packages.
+
+**Current version**: Python 3.12+ / PyInstaller 6.x / Nuitka 2.x / uv (2025-2026)
+
+## When to Use
+
+- Automation scripts for distribution to non-Python users
+- DevOps/infrastructure tools
+- Data processing pipelines
+- Security tools, scanners
+- Research tools for academic distribution
+
+## Packaging Options Comparison
+
+| Method | Size | Startup | Cross-compile | Best For |
+|--------|------|---------|--------------|----------|
+| PyInstaller | 15–80MB | 1–3s | No (build per platform) | Universal distribution |
+| Nuitka | 10–50MB | < 1s | No | Performance, AV false positive avoidance |
+| pip/PyPI | 0 (source) | Instant | N/A | Developer tools |
+| pipx | 0 (isolated) | Instant | N/A | CLI tools for developers |
+| Docker | 50–200MB | 1–2s | Yes | Server/container environments |
+| uv | 0 (source) | Instant | N/A | Fast Python package management |
+
+---
+
+## PyInstaller (Most Universal)
+
+```bash
+pip install pyinstaller
+
+# Single file mode (self-extracting)
+pyinstaller --onefile --name mytool mytool.py
+
+# Directory mode (faster startup, recommended for production)
+pyinstaller --name mytool mytool.py
+
+# With hidden imports (common for dynamic imports)
+pyinstaller --onefile \
+  --hidden-import=cryptography \
+  --hidden-import=paramiko \
+  --hidden-import=click \
+  --name mytool mytool.py
+
+# Console app (default) vs GUI app
+pyinstaller --onefile --console mytool.py    # Console
+pyinstaller --onefile --windowed mytool.py   # GUI (no console window)
+
+# Output: dist/mytool (Linux/macOS) or dist/mytool.exe (Windows)
+```
+
+### Cross-Platform Build (GitHub Actions)
+
+```yaml
+name: Build CLI
+on:
+  push:
+    tags: ['v*']
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+      - run: pip install pyinstaller
+      - run: pyinstaller --onefile --name mytool mytool.py
+      - uses: actions/upload-artifact@v4
+        with:
+          name: mytool-${{ matrix.os }}
+          path: dist/
+```
+
+---
+
+## Nuitka (Better Performance)
+
+```bash
+pip install nuitka
+
+# Standalone binary
+python -m nuitka \
+  --standalone \
+  --onefile \
+  --output-filename=mytool \
+  --enable-plugin=anti-bloat \
+  mytool.py
+
+# With module support
+python -m nuitka \
+  --standalone \
+  --onefile \
+  --include-module=cryptography \
+  --include-package=click \
+  mytool.py
+```
+
+---
+
+## pip Distribution (PyPI)
+
+```toml
+# pyproject.toml
+[build-system]
+requires = ["setuptools>=75.0", "wheel"]
+build-backend = "setuptools.backends._legacy:_Backend"
+
+[project]
+name = "mytool"
+version = "1.0.0"
+description = "My awesome CLI tool"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+    "click>=8.0",
+    "requests>=2.28",
+    "rich>=13.0",
+]
+
+[project.scripts]
+mytool = "mytool.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/user/mytool"
+```
+
+```bash
+# Build
+python -m build
+# Output: dist/mytool-1.0.0-py3-none-any.whl + dist/mytool-1.0.0.tar.gz
+
+# Publish to PyPI
+pip install twine
+twine upload dist/*
+
+# Or: use trusted publishing (recommended)
+# Configure on pypi.org → Your project → Publishing → Add GitHub Actions
+```
+
+---
+
+## pipx (Isolated Installation)
+
+```bash
+# Install pipx
+pip install pipx
+pipx ensurepath
+
+# Install CLI tool in isolated environment
+pipx install mytool
+
+# Install from local wheel
+pipx install dist/mytool-1.0.0-py3-none-any.whl
+
+# Install from Git
+pipx install git+https://github.com/user/mytool.git
+```
+
+---
+
+## Docker Distribution
+
+```dockerfile
+FROM python:3.13-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+RUN pip install .
+RUN groupadd -r tooluser && useradd -r -g tooluser tooluser
+USER tooluser
+ENTRYPOINT ["mytool"]
+```
+
+---
+
+## Rich CLI Framework (Recommended for Beautiful CLIs)
+
+```python
+# mytool/cli.py
+import click
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+@click.group()
+@click.version_option(version="1.0.0")
+def cli():
+    """My awesome CLI tool."""
+    pass
+
+@cli.command()
+@click.argument("name")
+@click.option("--verbose", "-v", is_flag=True, help="Verbose output")
+def greet(name: str, verbose: bool):
+    """Greet someone."""
+    if verbose:
+        console.print(f"[dim]Processing request...[/dim]")
+    console.print(f"[bold green]Hello, {name}![/bold green]")
+
+@cli.command()
+def table():
+    """Show a beautiful table."""
+    t = Table(title="Data")
+    t.add_column("Name", style="cyan")
+    t.add_column("Value", style="green")
+    t.add_row("Python", "3.13")
+    t.add_row("CLI", "mytool 1.0.0")
+    console.print(t)
+
+if __name__ == "__main__":
+    cli()
+```
+
+---
+
+## Common Pitfalls
+
+| Issue | Fix |
+|-------|-----|
+| PyInstaller missing hidden imports | Use `--hidden-import`; check with `pyi-archive_viewer` |
+| Antivirus false positive (PyInstaller) | Switch to Nuitka; sign binaries; submit to AV vendors |
+| Cross-platform build fails | Build on each platform separately; use CI matrix builds |
+| Large binary size | Use Nuitka (smaller); exclude unused packages; use `--exclude-module` |
+| Slow startup (PyInstaller) | Use directory mode instead of `--onefile` |
+| `pkg_resources` deprecation | Migrate to `importlib.metadata`; use `setuptools>=70` |
+| pip install fails on Windows | Use `python -m pip install`; check PATH |
+| Permission denied on Linux/macOS | `chmod +x dist/mytool` |
+| Entry point not found | Check `[project.scripts]` in `pyproject.toml`; verify module path |