opencode-skills-collection 3.0.46 → 3.0.47

package/bundled-skills/ecl-harness-engineer/references/adapters/go.md

@@ -0,0 +1,212 @@
+---
+adapter:
+  language: go
+  display_name: "Go"
+  version: "1.0"
+
+  detection:
+    files: [go.mod, go.sum]
+    confidence: 0.95
+
+  commands:
+    build: "go build ./..."
+    test: "go test ./..."
+    lint: "golangci-lint run"
+    lint_arch: "make lint-arch"
+    format: "gofmt -w ."
+    start: null   # Inferred from cmd/ structure or main.go
+    dev: null      # Often uses "air" but not assumed
+
+  package_manager:
+    detection: []  # Go modules are built-in
+    default: "go"
+    install_command: "go mod download"
+
+  route_detection:
+    server_indicators:
+      - pattern: 'http\.ListenAndServe|http\.Server\{|\.Listen\('
+        description: "Standard library HTTP server"
+        frameworks: ["net/http"]
+      - pattern: 'gin\.Default|gin\.New'
+        description: "Gin web framework"
+        frameworks: ["gin"]
+      - pattern: 'chi\.NewRouter|chi\.NewMux'
+        description: "Chi router"
+        frameworks: ["chi"]
+      - pattern: 'echo\.New\(\)'
+        description: "Echo web framework"
+        frameworks: ["echo"]
+      - pattern: 'mux\.NewRouter'
+        description: "Gorilla Mux router"
+        frameworks: ["gorilla/mux"]
+      - pattern: 'fiber\.New\(\)'
+        description: "Fiber web framework"
+        frameworks: ["fiber"]
+
+    cli_indicators:
+      - pattern: 'github\.com/spf13/cobra'
+        description: "Cobra CLI framework"
+        frameworks: ["cobra"]
+      - pattern: 'github\.com/urfave/cli'
+        description: "urfave/cli framework"
+        frameworks: ["urfave/cli"]
+      - pattern: 'flag\.Parse\(\)|flag\.String\('
+        description: "Standard library flags"
+        frameworks: ["flag"]
+
+    frontend_indicators: []  # Go is not typically used for frontend
+
+    patterns:
+      # Chi router
+      - type: route
+        regex: 'r\.(Get|Post|Put|Delete|Patch|Head|Options)\s*\(\s*["\x27]([^"\x27]+)["\x27]'
+        groups: [method, path]
+        frameworks: ["chi"]
+      # Gin
+      - type: route
+        regex: '\.(GET|POST|PUT|DELETE|PATCH)\s*\(\s*["\x27]([^"\x27]+)["\x27]'
+        groups: [method, path]
+        frameworks: ["gin"]
+      # Echo
+      - type: route
+        regex: 'e\.(GET|POST|PUT|DELETE|PATCH)\s*\(\s*["\x27]([^"\x27]+)["\x27]'
+        groups: [method, path]
+        frameworks: ["echo"]
+      # Gorilla Mux
+      - type: route
+        regex: '\.HandleFunc\s*\(\s*["\x27]([^"\x27]+)["\x27].*\)\.(Methods)\s*\(\s*["\x27]([^"\x27]+)["\x27]\)'
+        groups: [path, _, method]
+        frameworks: ["gorilla/mux"]
+      # net/http
+      - type: route
+        regex: 'http\.HandleFunc\s*\(\s*["\x27]([^"\x27]+)["\x27]'
+        groups: [path]
+        frameworks: ["net/http"]
+      # Cobra CLI
+      - type: command
+        regex: '&cobra\.Command\s*\{\s*Use:\s*["\x27]([^"\x27\s]+)'
+        groups: [command_name]
+        frameworks: ["cobra"]
+
+  import_analysis:
+    list_packages: "go list -json ./..."
+    import_pattern: '"([^"]+)"'
+    source_extensions: [".go"]
+    module_root_file: "go.mod"
+
+  layer_conventions:
+    patterns:
+      - layer: 0
+        paths: ["internal/types", "types", "domain", "model", "entity"]
+        description: "Pure types, zero internal imports"
+      - layer: 1
+        paths: ["internal/utils", "utils", "pkg/utils", "lib"]
+        description: "Utilities, depend only on types"
+      - layer: 2
+        paths: ["internal/core", "core", "internal/service", "service"]
+        description: "Business logic, depend on types + utils"
+      - layer: 3
+        paths: ["internal/handler", "handler", "api", "internal/api"]
+        description: "HTTP/gRPC handlers, depend on core"
+      - layer: 4
+        paths: ["cmd"]
+        description: "Entry points, depend on everything"
+
+  dependency_detection:
+    manifest_file: "go.mod"
+    databases:
+      - pattern: "github.com/jackc/pgx|github.com/lib/pq"
+        type: "postgres"
+        default_port: 5432
+      - pattern: "github.com/go-sql-driver/mysql"
+        type: "mysql"
+        default_port: 3306
+      - pattern: "go.mongodb.org/mongo-driver"
+        type: "mongodb"
+        default_port: 27017
+      - pattern: "github.com/go-redis/redis|github.com/redis/go-redis"
+        type: "redis"
+        default_port: 6379
+      - pattern: "github.com/mattn/go-sqlite3|modernc.org/sqlite"
+        type: "sqlite"
+        default_port: 0
+    services:
+      - pattern: "github.com/segmentio/kafka-go|github.com/IBM/sarama"
+        type: "kafka"
+        default_port: 9092
+      - pattern: "github.com/rabbitmq/amqp091-go|github.com/streadway/amqp"
+        type: "rabbitmq"
+        default_port: 5672
+      - pattern: "github.com/nats-io/nats.go"
+        type: "nats"
+        default_port: 4222
+      - pattern: "github.com/elastic/go-elasticsearch"
+        type: "elasticsearch"
+        default_port: 9200
+    env_var_patterns:
+      - pattern: 'os\.Getenv\("([^"]+)"\)'
+      - pattern: 'os\.LookupEnv\("([^"]+)"\)'
+      - pattern: 'viper\.\w+\("([^"]+)"\)'
+
+  linter:
+    template_section: "go-linter"
+    script_extension: ".go"
+    run_command: "go run scripts/lint-deps.go"
+
+  naming:
+    file_pattern: "^[a-z][a-z0-9_]*\\.go$"
+    test_pattern: "^[a-z][a-z0-9_]*_test\\.go$"
+    directory_style: "snake_case"
+
+  ci:
+    github_actions:
+      image: "golang:1.22"
+      setup_steps:
+        - "uses: actions/setup-go@v5\n  with:\n    go-version: '1.22'"
+      cache_paths: ["~/go/pkg/mod", "~/.cache/go-build"]
+---
+
+# Go Adapter
+
+## Server Start Command Inference
+
+Priority order for detecting the server start command:
+
+1. Existing `harness/config/environment.json` startup command, if present
+2. `cmd/server/main.go` exists → `go run cmd/server/main.go`
+3. `cmd/api/main.go` exists → `go run cmd/api/main.go`
+4. `main.go` at root with `http` import → `go run main.go`
+5. Fail with actionable error
+
+## CLI Binary Inference
+
+1. `cmd/cli/main.go` exists → `go build -o bin/cli cmd/cli/main.go`
+2. `cmd/<name>/main.go` exists → `go build -o bin/<name> cmd/<name>/main.go`
+3. `main.go` at root with `cobra`/`flag` import → `go build -o bin/app .`
+
+## Testing Patterns
+
+- Unit tests: `*_test.go` files alongside source
+- Integration tests: `//go:build integration` build tag → `go test -tags=integration ./...`
+- Table-driven tests are idiomatic
+
+## Common Frameworks
+
+| Framework | Detection Pattern | Route Style |
+|-----------|------------------|-------------|
+| chi | `github.com/go-chi/chi` | `r.Get("/path", handler)` |
+| gin | `github.com/gin-gonic/gin` | `r.GET("/path", handler)` |
+| echo | `github.com/labstack/echo` | `e.GET("/path", handler)` |
+| fiber | `github.com/gofiber/fiber` | `app.Get("/path", handler)` |
+| gorilla/mux | `github.com/gorilla/mux` | `r.HandleFunc("/path", handler).Methods("GET")` |
+| net/http | stdlib | `http.HandleFunc("/path", handler)` |
+
+## Structured Logging
+
+Go projects should use structured loggers. Common patterns to detect:
+- `go.uber.org/zap` → `zap.String()`, `zap.Int()`
+- `log/slog` (stdlib) → `slog.Info()`, `slog.With()`
+- `github.com/rs/zerolog` → `log.Info().Str().Msg()`
+- `github.com/sirupsen/logrus` → `logrus.WithFields()`
+
+Unstructured patterns to flag: `log.Printf`, `log.Println`, `log.Fatalf`, `fmt.Printf` (in non-CLI code)

package/bundled-skills/ecl-harness-engineer/references/adapters/java.md

@@ -0,0 +1,205 @@
+---
+adapter:
+  language: java
+  display_name: "Java / Kotlin"
+  version: "1.0"
+
+  detection:
+    files: [pom.xml, build.gradle, build.gradle.kts, settings.gradle, settings.gradle.kts]
+    content_patterns:
+      - file: "pom.xml"
+        pattern: "<groupId>"
+      - file: "build.gradle.kts"
+        pattern: "plugins|dependencies"
+    confidence: 0.90
+
+  commands:
+    build: null   # Detected from build tool
+    test: null    # Detected from build tool
+    lint: null    # Often spotbugs, checkstyle, or ktlint
+    lint_arch: null
+    format: null
+    start: null
+    dev: null
+
+  package_manager:
+    detection:
+      - lockfile: "pom.xml"
+        manager: "maven"
+      - lockfile: "build.gradle"
+        manager: "gradle"
+      - lockfile: "build.gradle.kts"
+        manager: "gradle"
+    default: "maven"
+    install_command: null  # Dependencies resolved during build
+
+  route_detection:
+    server_indicators:
+      - pattern: '@RestController|@Controller|@RequestMapping'
+        description: "Spring MVC/Boot controller"
+        frameworks: ["spring"]
+      - pattern: 'import io\.micronaut'
+        description: "Micronaut framework"
+        frameworks: ["micronaut"]
+      - pattern: 'import io\.quarkus'
+        description: "Quarkus framework"
+        frameworks: ["quarkus"]
+      - pattern: 'import io\.vertx'
+        description: "Vert.x framework"
+        frameworks: ["vertx"]
+      - pattern: 'import io\.ktor'
+        description: "Ktor framework (Kotlin)"
+        frameworks: ["ktor"]
+      - pattern: 'import io\.javalin'
+        description: "Javalin web framework"
+        frameworks: ["javalin"]
+
+    cli_indicators:
+      - pattern: 'import picocli|@CommandLine'
+        description: "picocli CLI framework"
+        frameworks: ["picocli"]
+      - pattern: 'public static void main\(String'
+        description: "Java main method (potential CLI)"
+        frameworks: ["stdlib"]
+
+    frontend_indicators: []
+
+    patterns:
+      # Spring MVC annotations
+      - type: route
+        regex: '@(GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping)\s*\(\s*(?:value\s*=\s*)?["\x27]([^"\x27]*)["\x27]'
+        groups: [method, path]
+        frameworks: ["spring"]
+      # Spring RequestMapping
+      - type: route
+        regex: '@RequestMapping\s*\(.*(?:value|path)\s*=\s*["\x27]([^"\x27]+)["\x27].*method\s*=\s*RequestMethod\.(\w+)'
+        groups: [path, method]
+        frameworks: ["spring"]
+      # Ktor (Kotlin)
+      - type: route
+        regex: '(get|post|put|delete|patch)\s*\(\s*["\x27]([^"\x27]+)["\x27]'
+        groups: [method, path]
+        frameworks: ["ktor"]
+      # Javalin
+      - type: route
+        regex: 'app\.(get|post|put|delete|patch)\s*\(\s*["\x27]([^"\x27]+)["\x27]'
+        groups: [method, path]
+        frameworks: ["javalin"]
+
+  import_analysis:
+    list_packages: null
+    import_pattern: "^import\\s+([\\w.]+)"
+    source_extensions: [".java", ".kt"]
+    module_root_file: "pom.xml"
+
+  layer_conventions:
+    patterns:
+      - layer: 0
+        paths: ["src/main/java/**/model", "src/main/java/**/entity", "src/main/java/**/dto"]
+        description: "Domain models, entities, DTOs"
+      - layer: 1
+        paths: ["src/main/java/**/util", "src/main/java/**/common", "src/main/java/**/config"]
+        description: "Utilities and configuration"
+      - layer: 2
+        paths: ["src/main/java/**/service", "src/main/java/**/repository", "src/main/java/**/dao"]
+        description: "Service and data access layer"
+      - layer: 3
+        paths: ["src/main/java/**/controller", "src/main/java/**/api", "src/main/java/**/resource"]
+        description: "REST controllers, API endpoints"
+      - layer: 4
+        paths: ["src/main/java/**/Application.java", "src/main/java/**/Main.java"]
+        description: "Application entry point"
+
+  dependency_detection:
+    manifest_file: "pom.xml"
+    databases:
+      - pattern: "postgresql|postgres"
+        type: "postgres"
+        default_port: 5432
+      - pattern: "mysql-connector"
+        type: "mysql"
+        default_port: 3306
+      - pattern: "mongodb-driver|mongo-java-driver"
+        type: "mongodb"
+        default_port: 27017
+      - pattern: "jedis|lettuce-core|spring-data-redis"
+        type: "redis"
+        default_port: 6379
+      - pattern: "h2|sqlite-jdbc"
+        type: "sqlite"
+        default_port: 0
+    services:
+      - pattern: "kafka-clients|spring-kafka"
+        type: "kafka"
+        default_port: 9092
+      - pattern: "amqp-client|spring-amqp|spring-rabbit"
+        type: "rabbitmq"
+        default_port: 5672
+      - pattern: "elasticsearch-rest-client|spring-data-elasticsearch"
+        type: "elasticsearch"
+        default_port: 9200
+    env_var_patterns:
+      - pattern: 'System\.getenv\(\s*["\x27]([^"\x27]+)["\x27]\)'
+      - pattern: '\\$\\{([A-Z_][A-Z0-9_]*)\\}'
+
+  linter:
+    template_section: "java-linter"
+    script_extension: ".java"
+    run_command: null  # Typically integrated into build tool (spotbugs, checkstyle)
+
+  naming:
+    file_pattern: "^[A-Z][a-zA-Z0-9]*\\.java$"
+    test_pattern: "^[A-Z][a-zA-Z0-9]*Test\\.java$"
+    directory_style: "lowercase"
+
+  ci:
+    github_actions:
+      image: null  # Uses setup-java action
+      setup_steps:
+        - "uses: actions/setup-java@v4\n  with:\n    distribution: 'temurin'\n    java-version: '21'"
+      cache_paths: ["~/.m2/repository", "~/.gradle/caches"]
+---
+
+# Java / Kotlin Adapter
+
+## Build Tool Detection
+
+| File | Build Tool | Build Command | Test Command |
+|------|-----------|---------------|--------------|
+| `pom.xml` | Maven | `mvn package -DskipTests` | `mvn test` |
+| `build.gradle` | Gradle (Groovy) | `./gradlew build -x test` | `./gradlew test` |
+| `build.gradle.kts` | Gradle (Kotlin DSL) | `./gradlew build -x test` | `./gradlew test` |
+
+If `mvnw` or `gradlew` wrapper exists, prefer the wrapper over system-installed tool.
+
+## Server Start Command Inference
+
+1. Existing `harness/config/environment.json` startup command, if present
+2. Spring Boot → `./gradlew bootRun` or `mvn spring-boot:run`
+3. Fat JAR exists → `java -jar target/*.jar` or `java -jar build/libs/*.jar`
+4. Main class annotated with `@SpringBootApplication` → infer from pom.xml/build.gradle
+
+## Framework-Specific Notes
+
+### Spring Boot
+- Routes via annotations: `@GetMapping("/path")`, `@PostMapping("/path")`
+- Controller prefix: `@RequestMapping("/api/v1")` on class
+- Auto-configuration: `application.properties` or `application.yml`
+- Default port: 8080 (configurable via `server.port`)
+- Actuator health: `/actuator/health`
+
+### Micronaut
+- Similar annotation style to Spring: `@Get("/path")`, `@Post("/path")`
+- Compile-time DI (no reflection)
+- Default port: 8080
+
+### Ktor (Kotlin)
+- DSL-based routing: `routing { get("/path") { ... } }`
+- Configuration via `application.conf` (HOCON) or `application.yaml`
+
+## Testing Patterns
+
+- JUnit 5 is standard: `@Test`, `@ParameterizedTest`
+- Kotlin: same JUnit 5 + kotest as alternative
+- Integration tests often use `@SpringBootTest` + Testcontainers
+- Test directory: `src/test/java/` or `src/test/kotlin/`

package/bundled-skills/ecl-harness-engineer/references/adapters/python.md

@@ -0,0 +1,225 @@
+---
+adapter:
+  language: python
+  display_name: "Python"
+  version: "1.0"
+
+  detection:
+    files: [pyproject.toml, setup.py, requirements.txt, Pipfile]
+    content_patterns:
+      - file: "pyproject.toml"
+        pattern: '\\[project\\]|\\[tool\\.poetry\\]'
+    confidence: 0.90
+
+  commands:
+    build: null  # Python typically doesn't need a build step
+    test: "pytest"
+    lint: "ruff check ."
+    lint_arch: "python scripts/lint_deps.py src/"
+    format: "ruff format ."
+    start: null   # Inferred from framework
+    dev: null
+
+  package_manager:
+    detection:
+      - lockfile: "poetry.lock"
+        manager: "poetry"
+      - lockfile: "uv.lock"
+        manager: "uv"
+      - lockfile: "Pipfile.lock"
+        manager: "pipenv"
+      - lockfile: "pdm.lock"
+        manager: "pdm"
+    default: "pip"
+    install_command: "{manager} install"
+
+  route_detection:
+    server_indicators:
+      - pattern: 'from fastapi|import fastapi|FastAPI\(\)'
+        description: "FastAPI ASGI framework"
+        frameworks: ["fastapi"]
+      - pattern: 'from flask|import flask|Flask\(__name__\)'
+        description: "Flask WSGI framework"
+        frameworks: ["flask"]
+      - pattern: 'from django|import django'
+        description: "Django web framework"
+        frameworks: ["django"]
+      - pattern: 'from aiohttp|import aiohttp\.web'
+        description: "aiohttp async web framework"
+        frameworks: ["aiohttp"]
+      - pattern: 'from starlette|import starlette'
+        description: "Starlette ASGI framework"
+        frameworks: ["starlette"]
+      - pattern: 'from litestar|import litestar'
+        description: "Litestar ASGI framework"
+        frameworks: ["litestar"]
+
+    cli_indicators:
+      - pattern: 'import click|from click'
+        description: "Click CLI framework"
+        frameworks: ["click"]
+      - pattern: 'import typer|from typer'
+        description: "Typer CLI framework"
+        frameworks: ["typer"]
+      - pattern: 'import argparse|from argparse'
+        description: "Standard library argparse"
+        frameworks: ["argparse"]
+      - pattern: 'import fire|from fire'
+        description: "Google Python Fire"
+        frameworks: ["fire"]
+
+    frontend_indicators: []  # Python is not typically used for frontend
+
+    patterns:
+      # FastAPI
+      - type: route
+        regex: '@(?:app|router)\.(get|post|put|delete|patch)\s*\(\s*["\x27]([^"\x27]+)["\x27]'
+        groups: [method, path]
+        frameworks: ["fastapi", "starlette", "litestar"]
+      # Flask
+      - type: route
+        regex: '@(?:app|bp|blueprint)\.(route)\s*\(\s*["\x27]([^"\x27]+)["\x27](?:.*methods\s*=\s*\[([^\]]+)\])?'
+        groups: [_, path, method]
+        frameworks: ["flask"]
+      # Django URLs
+      - type: route
+        regex: 'path\s*\(\s*["\x27]([^"\x27]+)["\x27]'
+        groups: [path]
+        frameworks: ["django"]
+      # Click
+      - type: command
+        regex: '@\w+\.command\s*\(\s*(?:name\s*=\s*)?["\x27]?([^"\x27\)]+)'
+        groups: [command_name]
+        frameworks: ["click"]
+      # Typer
+      - type: command
+        regex: '@app\.command\s*\(\s*(?:name\s*=\s*)?["\x27]?([^"\x27\)]*)'
+        groups: [command_name]
+        frameworks: ["typer"]
+
+  import_analysis:
+    list_packages: null
+    import_pattern: "^(?:from|import)\\s+([\\w.]+)"
+    source_extensions: [".py"]
+    module_root_file: "pyproject.toml"
+
+  layer_conventions:
+    patterns:
+      - layer: 0
+        paths: ["src/models", "src/schemas", "src/types", "models", "schemas"]
+        description: "Data models, Pydantic schemas, type definitions"
+      - layer: 1
+        paths: ["src/utils", "src/lib", "src/common", "utils", "lib"]
+        description: "Shared utilities"
+      - layer: 2
+        paths: ["src/services", "src/core", "src/domain", "services", "core"]
+        description: "Business logic, service layer"
+      - layer: 3
+        paths: ["src/api", "src/routes", "src/views", "src/handlers", "api", "routes"]
+        description: "API endpoints, request handlers"
+      - layer: 4
+        paths: ["src/main.py", "src/app.py", "src/cli.py", "main.py", "app.py"]
+        description: "Application entry points"
+
+  dependency_detection:
+    manifest_file: "pyproject.toml"
+    databases:
+      - pattern: "psycopg|asyncpg|sqlalchemy.*postgres|databases.*postgres"
+        type: "postgres"
+        default_port: 5432
+      - pattern: "pymysql|aiomysql|mysqlclient"
+        type: "mysql"
+        default_port: 3306
+      - pattern: "pymongo|motor"
+        type: "mongodb"
+        default_port: 27017
+      - pattern: "redis|aioredis"
+        type: "redis"
+        default_port: 6379
+      - pattern: "aiosqlite|sqlite3"
+        type: "sqlite"
+        default_port: 0
+    services:
+      - pattern: "confluent-kafka|aiokafka"
+        type: "kafka"
+        default_port: 9092
+      - pattern: "pika|aio-pika"
+        type: "rabbitmq"
+        default_port: 5672
+      - pattern: "elasticsearch|elastic-transport"
+        type: "elasticsearch"
+        default_port: 9200
+    env_var_patterns:
+      - pattern: 'os\.environ\.get\(\s*["\x27]([^"\x27]+)["\x27]'
+      - pattern: 'os\.environ\[["\x27]([^"\x27]+)["\x27]\]'
+      - pattern: 'os\.getenv\(\s*["\x27]([^"\x27]+)["\x27]'
+
+  linter:
+    template_section: "python-linter"
+    script_extension: ".py"
+    run_command: "python scripts/lint_deps.py src/"
+
+  naming:
+    file_pattern: "^[a-z][a-z0-9_]*\\.py$"
+    test_pattern: "^test_[a-z][a-z0-9_]*\\.py$"
+    directory_style: "snake_case"
+
+  ci:
+    github_actions:
+      image: "python:3.12"
+      setup_steps:
+        - "uses: actions/setup-python@v5\n  with:\n    python-version: '3.12'"
+      cache_paths: ["~/.cache/pip", ".venv"]
+---
+
+# Python Adapter
+
+## Server Start Command Inference
+
+1. Existing `harness/config/environment.json` startup command, if present
+2. FastAPI detected → `python -m uvicorn {module}:app --port 8080`
+   - Module inferred from main app file location
+3. Flask detected → `python -m flask run --port 8080`
+4. Django detected → `python manage.py runserver 8080`
+5. `main.py` exists → `python main.py`
+
+## Virtual Environment Detection
+
+The adapter checks for virtual environments in this order:
+1. `.venv/` directory → `source .venv/bin/activate`
+2. `venv/` directory → `source venv/bin/activate`
+3. `poetry.lock` → `poetry shell` or prefix with `poetry run`
+4. `uv.lock` → prefix with `uv run`
+5. `Pipfile.lock` → prefix with `pipenv run`
+
+## Framework-Specific Notes
+
+### FastAPI
+- Routes via decorators: `@app.get("/path")`, `@router.post("/path")`
+- Dependency injection via `Depends()`
+- Auto-generated OpenAPI docs at `/docs` and `/redoc`
+- Start with uvicorn: `uvicorn app.main:app --reload`
+
+### Flask
+- Routes via decorators: `@app.route("/path", methods=["GET"])`
+- Blueprints for modular routing
+- Start with: `flask run` or `python -m flask run`
+
+### Django
+- URL configuration in `urls.py`: `path("api/", include("app.urls"))`
+- Class-based views and function-based views
+- Start with: `python manage.py runserver`
+- Migrations: `python manage.py migrate`
+
+### Click / Typer (CLI)
+- Click: `@cli.command()` decorator pattern
+- Typer: `@app.command()` decorator pattern, with auto-generated help
+
+## Type Checking
+
+Python projects may use type checkers:
+- `mypy` — most common, configured in `pyproject.toml` or `mypy.ini`
+- `pyright` — Microsoft's type checker, often via Pylance
+- `pytype` — Google's type checker
+
+Detection: check `pyproject.toml` `[tool.mypy]` or `mypy.ini` existence.