hatch3r 1.8.0 → 2.0.0

package/skills/hatch3r-cli-difftastic/SKILL.md

@@ -1,84 +0,0 @@
----
-id: hatch3r-cli-difftastic
-description: "Structural diff that understands syntax. Use when syntax-aware diffing that reports semantic edits instead of textual lines; invoke `difft`. Skips whitespace and reordering noise by computing edits over parsed syntax trees."
-tags: ["cli-tools", "git"]
-quality_charter: agents/shared/quality-charter.md
-efficiency_patterns: agents/shared/efficiency-patterns.md
-cache_friendly: true
-cli_tool:
-  id: difftastic
-  bin: difft
-  tier: 2
-  category: git
-  homepage: https://difftastic.wilfred.me.uk/
----
-<!-- HATCH3R-CLI-SKILL-GENERATED v1 -->
-# difftastic
-
-Structural diff that understands syntax
-
-## When to Use
-
-Reach for `difft` when the task is in the **git** category and the agent would otherwise call an MCP tool or read large outputs into context.
-
-## Token Cost
-
-CLI tools return structured stdout that fits in <1KB for typical queries; equivalent MCP calls regularly exceed 10KB.
-Reference: Anthropic engineering (Nov 4 2025) — code-execution-over-MCP yields 98.7% token reduction.
-
-## Recipes
-
-```bash
-difft a.ts b.ts
-```
-Compare two files using a syntax-aware tree diff; rename-of-block does not show as wholesale rewrite.
-
-```bash
-git -c diff.external=difft diff HEAD~1 HEAD
-```
-One-shot syntactic git diff for the last commit without mutating global config.
-
-```bash
-git config --global diff.external difft
-```
-Wire `difft` as the default git external diff (human setup; agents should prefer the `-c` form above for transparency).
-
-```bash
-difft --background light a.ts b.ts
-```
-Render with a light-background palette — pick to match the terminal theme.
-
-```bash
-difft --display side-by-side a.py b.py
-```
-Side-by-side layout for review; fall back to the default inline mode for narrow terminals.
-
-## Wrong Choice When
-
-- A script needs stable, parseable diff output — `diff -u` or `git diff --no-color` produce deterministic POSIX output; `difft` is for human reading.
-- You only need a prettier pager for unified diffs — `delta` (Tier 1) renders standard git output with syntax highlighting and is faster.
-- The languages involved are unsupported by tree-sitter parsers `difft` ships — fall back to `diff -u`.
-
-## Alternatives
-
-| Tool | When to prefer |
-|------|----------------|
-| `delta` | Want syntax-highlighted unified diff for git output. |
-| `diff -u` | Script consumes the output; need POSIX stability. |
-| `git diff --word-diff` | Care about prose changes; line-noise from refactors is acceptable. |
-
-## Detection / Install
-
-Verify with:
-```bash
-command -v difft
-```
-
-Install (mac):
-
-```bash
-# brew
-brew install difftastic
-```
-
-Homepage: https://difftastic.wilfred.me.uk/

package/skills/hatch3r-cli-docker/SKILL.md

@@ -1,89 +0,0 @@
----
-id: hatch3r-cli-docker
-description: "Container runtime and CLI. Use when image build, container run, exec inspection, or registry push commands; invoke `docker`. Talks to a running Docker Engine daemon over a Unix socket; perfect for x86 build hosts."
-tags: ["cli-tools", "container"]
-quality_charter: agents/shared/quality-charter.md
-efficiency_patterns: agents/shared/efficiency-patterns.md
-cache_friendly: true
-cli_tool:
-  id: docker
-  bin: docker
-  tier: 2
-  category: container
-  homepage: https://docs.docker.com/get-docker/
----
-<!-- HATCH3R-CLI-SKILL-GENERATED v1 -->
-# docker
-
-Container runtime and CLI
-
-## When to Use
-
-Reach for `docker` when the task is in the **container** category and the agent would otherwise call an MCP tool or read large outputs into context.
-
-## Token Cost
-
-CLI tools return structured stdout that fits in <1KB for typical queries; equivalent MCP calls regularly exceed 10KB.
-Reference: Anthropic engineering (Nov 4 2025) — code-execution-over-MCP yields 98.7% token reduction.
-
-## Recipes
-
-```bash
-docker build -t myapp:dev .
-```
-Build a local tag from the cwd Dockerfile; layer cache hits keep rebuilds under a second.
-
-```bash
-docker run --rm -v "$PWD":/app -w /app node:22 npm test
-```
-Run a one-shot test container with the host repo mounted — no image rebuild, no leftover container.
-
-```bash
-docker compose up -d --build
-```
-Bring up the multi-service stack from `docker-compose.yml` in the background, rebuilding stale images.
-
-```bash
-docker run --rm -e DEBUG=1 myapp:dev sh -c 'env | sort'
-```
-Inspect the runtime environment a container actually sees; useful for diagnosing missing env vars.
-
-```bash
-docker inspect myapp:dev --format '{{.Config.Cmd}} {{.Config.Entrypoint}}'
-```
-Extract a single image setting via Go template — avoids piping 10KB of JSON to `jq`.
-
-```bash
-docker ps --format '{{.ID}} {{.Names}} {{.Status}}' --filter status=running
-```
-Compact running-container summary; one line per container, easy to grep.
-
-## Wrong Choice When
-
-- The goal is per-agent isolation only (file scoping, no service runtime) — `container-use` provides that without a long-running daemon.
-- You are deploying to a Kubernetes cluster — go through `kubectl`/`helm`; `docker run` does not understand cluster semantics.
-- The host already has `podman` and rootless containers — prefer it for security; the CLI surface is nearly identical.
-
-## Alternatives
-
-| Tool | When to prefer |
-|------|----------------|
-| `podman` | Want rootless containers and a daemonless model. |
-| `container-use` | Need lightweight per-agent isolation; no service orchestration. |
-| `nerdctl` | Existing containerd installation; do not need Docker Desktop. |
-
-## Detection / Install
-
-Verify with:
-```bash
-command -v docker
-```
-
-Install (mac):
-
-```bash
-# brew
-brew install --cask docker
-```
-
-Homepage: https://docs.docker.com/get-docker/

package/skills/hatch3r-cli-duckdb/SKILL.md

@@ -1,84 +0,0 @@
----
-id: hatch3r-cli-duckdb
-description: "Embedded analytical database with first-class CSV/Parquet support. Use when ad-hoc analytical SQL over local Parquet, CSV, and JSON files; invoke `duckdb`. Streams records lazily; works on datasets that exceed available RAM."
-tags: ["cli-tools", "data"]
-quality_charter: agents/shared/quality-charter.md
-efficiency_patterns: agents/shared/efficiency-patterns.md
-cache_friendly: true
-cli_tool:
-  id: duckdb
-  bin: duckdb
-  tier: 2
-  category: data
-  homepage: https://duckdb.org/
----
-<!-- HATCH3R-CLI-SKILL-GENERATED v1 -->
-# duckdb
-
-Embedded analytical database with first-class CSV/Parquet support
-
-## When to Use
-
-Reach for `duckdb` when the task is in the **data** category and the agent would otherwise call an MCP tool or read large outputs into context.
-
-## Token Cost
-
-CLI tools return structured stdout that fits in <1KB for typical queries; equivalent MCP calls regularly exceed 10KB.
-Reference: Anthropic engineering (Nov 4 2025) — code-execution-over-MCP yields 98.7% token reduction.
-
-## Recipes
-
-```bash
-duckdb -c "SELECT count(*) FROM 'data/*.parquet'"
-```
-Count rows across a Parquet glob — no schema declaration, no import step.
-
-```bash
-duckdb -c "COPY (SELECT * FROM 'in.csv' WHERE active) TO 'out.parquet' (FORMAT PARQUET)"
-```
-Filter a CSV and emit columnar Parquet in one pass; ideal for downstream `qsv`/`jq` chains.
-
-```bash
-duckdb -c "ATTACH 'app.sqlite' AS sqlite; SELECT * FROM sqlite.users LIMIT 10"
-```
-Query a SQLite file without conversion — useful for app debugging from the terminal.
-
-```bash
-duckdb -json -c "DESCRIBE 'data.parquet'"
-```
-Emit JSON schema rows for column inspection; pipe to `jq` to extract specific column types.
-
-```bash
-duckdb -c "SELECT date_trunc('day', ts) AS d, count(*) FROM 'events/*.csv' GROUP BY 1 ORDER BY 1"
-```
-Aggregate over a CSV directory; DuckDB streams the read so memory stays bounded.
-
-## Wrong Choice When
-
-- The CSV has <10k rows and you only need to slice/select columns — `qsv` (Tier 2 sibling) starts faster and has no install dependency in many environments.
-- The workload is transactional (writes from multiple clients, ACID across rows) — use SQLite or Postgres; DuckDB is read-optimized OLAP.
-- A single `jq` filter would do the job (the data is already JSON, the operation is field extraction) — skip the SQL detour.
-
-## Alternatives
-
-| Tool | When to prefer |
-|------|----------------|
-| `qsv` | Single CSV file, <100MB, just need slice/select/sort. |
-| `sqlite3` | Need OLTP writes or row-level updates rather than analytics. |
-| `python -m pandas` | Already in a Python script and the data fits in memory. |
-
-## Detection / Install
-
-Verify with:
-```bash
-command -v duckdb
-```
-
-Install (mac):
-
-```bash
-# brew
-brew install duckdb
-```
-
-Homepage: https://duckdb.org/

package/skills/hatch3r-cli-gh/SKILL.md

@@ -1,90 +0,0 @@
----
-id: hatch3r-cli-gh
-description: "GitHub CLI — repos, issues, PRs, releases, gists. Use when drafting GitHub pull requests, issues, releases, gists, or workflow dispatches; invoke `gh`. Authenticates via the platform's native token mechanism (OAuth / PAT)."
-tags: ["cli-tools", "forge", "core"]
-quality_charter: agents/shared/quality-charter.md
-efficiency_patterns: agents/shared/efficiency-patterns.md
-cache_friendly: true
-cli_tool:
-  id: gh
-  bin: gh
-  tier: 1
-  category: forge
-  homepage: https://cli.github.com/
----
-<!-- HATCH3R-CLI-SKILL-GENERATED v1 -->
-# gh
-
-GitHub CLI — repos, issues, PRs, releases, gists
-
-## When to Use
-
-Reach for `gh` when the task is in the **forge** category and the agent would otherwise call an MCP tool or read large outputs into context.
-
-## Token Cost
-
-CLI tools return structured stdout that fits in <1KB for typical queries; equivalent MCP calls regularly exceed 10KB.
-Reference: Anthropic engineering (Nov 4 2025) — code-execution-over-MCP yields 98.7% token reduction.
-
-## Recipes
-
-```bash
-gh pr view 123 --json title,state,body,reviewDecision
-```
-Targeted JSON projection — pulls just the fields the agent needs, not the whole PR payload.
-
-```bash
-gh issue list --label bug --json number,title,author --limit 50
-```
-Label-filtered list with capped page size — avoids paginating the entire issue corpus into context.
-
-```bash
-gh api repos/:owner/:repo/contents/path/to/file.ts --jq '.sha'
-```
-Direct REST passthrough with built-in `--jq` filter — single round-trip, no jq install required at call site.
-
-```bash
-gh run watch
-```
-Blocks until the most recent CI run finishes — pairs with PR creation flows so the agent doesn't poll.
-
-```bash
-gh release create v1.7.5 --notes-from-tag --target release/1.7.5
-```
-Cuts a release using annotated-tag notes; deterministic input avoids hand-edited release bodies.
-
-```bash
-gh pr checks 78 --watch
-```
-Live-tail status checks for a PR — return value reflects the worst check state, scripts can branch on it.
-
-## Wrong Choice When
-
-- Don't reach for `gh` against a GitLab or Azure DevOps remote. Reach for `glab` (`hatch3r-cli-glab`) or `az repos`/`az devops` (`hatch3r-cli-az-devops`).
-- Don't use `gh auth login` flows when an audit trail of who authorized what is required; OAuth scopes granted to the CLI are user-bound. Reach for the GitHub web UI plus org-level SSO logs.
-- Don't use `gh api` for high-volume bulk fetches (>10k records) — rate limits bite. Reach for the GraphQL endpoint via `gh api graphql -F query=@file.gql` with pagination, or a GitHub App token.
-
-## Alternatives
-
-| Tool | When to prefer |
-|------|----------------|
-| `glab` (`hatch3r-cli-glab`) | GitLab forges — same operations, different vendor. |
-| `az-devops` (`hatch3r-cli-az-devops`) | Azure DevOps forges. |
-| `git` + `curl` against REST | Minimal environment (CI runner) where installing `gh` is blocked; trade convenience for raw HTTP. |
-| GitHub web UI | Operations needing org-level approval flows or SAML re-auth that the CLI cannot proxy. |
-
-## Detection / Install
-
-Verify with:
-```bash
-command -v gh
-```
-
-Install (mac):
-
-```bash
-# brew
-brew install gh
-```
-
-Homepage: https://cli.github.com/

package/skills/hatch3r-cli-glab/SKILL.md

@@ -1,89 +0,0 @@
----
-id: hatch3r-cli-glab
-description: "GitLab CLI — merge requests, issues, pipelines. Use when GitLab merge-request review, pipeline retries, and issue triage; invoke `glab`. Authenticates via the platform's native token mechanism (OAuth / PAT)."
-tags: ["cli-tools", "forge"]
-quality_charter: agents/shared/quality-charter.md
-efficiency_patterns: agents/shared/efficiency-patterns.md
-cache_friendly: true
-cli_tool:
-  id: glab
-  bin: glab
-  tier: 2
-  category: forge
-  homepage: https://gitlab.com/gitlab-org/cli
----
-<!-- HATCH3R-CLI-SKILL-GENERATED v1 -->
-# glab
-
-GitLab CLI — merge requests, issues, pipelines
-
-## When to Use
-
-Reach for `glab` when the task is in the **forge** category and the agent would otherwise call an MCP tool or read large outputs into context.
-
-## Token Cost
-
-CLI tools return structured stdout that fits in <1KB for typical queries; equivalent MCP calls regularly exceed 10KB.
-Reference: Anthropic engineering (Nov 4 2025) — code-execution-over-MCP yields 98.7% token reduction.
-
-## Recipes
-
-```bash
-glab mr list --assignee=@me --output json | jq '.[] | {iid, title, web_url}'
-```
-List merge requests assigned to the authenticated user; `--output json` keeps stdout structured.
-
-```bash
-glab mr view 42 --output json
-```
-Fetch a single MR's metadata as JSON — avoids the HTML-decorated default view.
-
-```bash
-glab mr diff 42
-```
-Print the unified diff for an MR to stdout; pipe to `delta` for review or `diff -u` parsing.
-
-```bash
-glab issue create --title 'tracking-id mismatch on import' --label bug --label backend
-```
-Open an issue from a script; the URL is printed on stdout for the agent to capture.
-
-```bash
-glab ci view --branch main
-```
-Show the pipeline status for `main`; agents should re-run with `--output json` for parseable output.
-
-```bash
-glab api projects/:fullpath/jobs --paginate
-```
-Raw API call with auto-pagination for endpoints the high-level commands do not cover.
-
-## Wrong Choice When
-
-- The repo lives on GitHub, not GitLab — use `gh` (Tier 1) which has parity for issues/PRs/checks.
-- The repo lives in Azure Repos — use `az devops` (Tier 2 sibling) with the same credential model.
-- You only need to read a public file at a known URL — `curl` is one HTTP round-trip versus `glab`'s auth dance.
-
-## Alternatives
-
-| Tool | When to prefer |
-|------|----------------|
-| `gh` | GitHub-hosted repository. |
-| `az devops` | Azure DevOps / Azure Repos. |
-| `curl` + `GITLAB_TOKEN` | Endpoint not exposed by `glab api`; need explicit retry/timeout control. |
-
-## Detection / Install
-
-Verify with:
-```bash
-command -v glab
-```
-
-Install (mac):
-
-```bash
-# brew
-brew install glab
-```
-
-Homepage: https://gitlab.com/gitlab-org/cli

package/skills/hatch3r-cli-lazygit/SKILL.md

@@ -1,78 +0,0 @@
----
-id: hatch3r-cli-lazygit
-description: "Terminal UI for git with keyboard-driven workflows. Use when keyboard-driven terminal UI for staging, rebasing, branch switching; invoke `lazygit`. Reads `.git/objects` directly without invoking external services or remotes."
-tags: ["cli-tools", "git"]
-quality_charter: agents/shared/quality-charter.md
-efficiency_patterns: agents/shared/efficiency-patterns.md
-cache_friendly: true
-cli_tool:
-  id: lazygit
-  bin: lazygit
-  tier: 2
-  category: git
-  homepage: https://github.com/jesseduffield/lazygit
----
-<!-- HATCH3R-CLI-SKILL-GENERATED v1 -->
-# lazygit
-
-Terminal UI for git with keyboard-driven workflows
-
-## When to Use
-
-Reach for `lazygit` when the task is in the **git** category and the agent would otherwise call an MCP tool or read large outputs into context.
-
-## Token Cost
-
-CLI tools return structured stdout that fits in <1KB for typical queries; equivalent MCP calls regularly exceed 10KB.
-Reference: Anthropic engineering (Nov 4 2025) — code-execution-over-MCP yields 98.7% token reduction.
-
-## Recipes
-
-`lazygit` is a TUI for humans; agents should call plain `git` instead. The recipes below are key bindings inside the running TUI, not shell commands.
-
-```bash
-lazygit
-```
-Launch the TUI in the cwd repo — requires an interactive terminal; will hang in a non-TTY context.
-
-```bash
-lazygit -p path/to/repo
-```
-Open the TUI on a specific repo without changing directory first.
-
-Key bindings inside the TUI (human reference):
-- `a` — stage all changes in the focused file
-- `c` — open the commit message editor
-- `P` — push current branch
-- `p` — pull current branch
-- `?` — show the full keymap
-
-## Wrong Choice When
-
-- The caller is an autonomous agent (no human at the terminal) — use plain `git status` / `git add` / `git commit` instead; they emit parseable stdout.
-- The task is part of a CI script — `lazygit` cannot run headless; rely on `git` plumbing commands.
-- You need a scriptable diff view — pair `git diff` with `delta` or `difftastic` rather than launching a TUI.
-
-## Alternatives
-
-| Tool | When to prefer |
-|------|----------------|
-| `git` (plain) | Anything an agent or CI script runs. |
-| `tig` | Prefer a different TUI keymap; broadly similar capability. |
-| `gh` / `glab` | The operation is forge-side (PRs, issues), not local repo state. |
-
-## Detection / Install
-
-Verify with:
-```bash
-command -v lazygit
-```
-
-Install (mac):
-
-```bash
-# brew
-brew install lazygit
-```
-
-Homepage: https://github.com/jesseduffield/lazygit

package/skills/hatch3r-cli-llm/SKILL.md

@@ -1,84 +0,0 @@
----
-id: hatch3r-cli-llm
-description: "simonw/llm — invoke LLMs from the command line with prompt templates. Use when model-agnostic shell prompting with template files and conversation memory; invoke `llm`. Streams tokens to stdout so downstream `grep`/`tee` consumers see partial results."
-tags: ["cli-tools", "ai"]
-quality_charter: agents/shared/quality-charter.md
-efficiency_patterns: agents/shared/efficiency-patterns.md
-cache_friendly: true
-cli_tool:
-  id: llm
-  bin: llm
-  tier: 2
-  category: ai
-  homepage: https://llm.datasette.io/
----
-<!-- HATCH3R-CLI-SKILL-GENERATED v1 -->
-# llm
-
-simonw/llm — invoke LLMs from the command line with prompt templates
-
-## When to Use
-
-Reach for `llm` when the task is in the **ai** category and the agent would otherwise call an MCP tool or read large outputs into context.
-
-## Token Cost
-
-CLI tools return structured stdout that fits in <1KB for typical queries; equivalent MCP calls regularly exceed 10KB.
-Reference: Anthropic engineering (Nov 4 2025) — code-execution-over-MCP yields 98.7% token reduction.
-
-## Recipes
-
-```bash
-llm 'summarize this' < file.txt
-```
-Pipe a file into the default model; output is plain text on stdout.
-
-```bash
-llm -m claude-3-5-sonnet 'rewrite as bullet points' < draft.md > bullets.md
-```
-Pick a model explicitly and redirect output — useful in batch scripts.
-
-```bash
-llm -t code-review -m claude-3-5-sonnet < patch.diff
-```
-Use a saved prompt template (`-t code-review`); template files live under `~/.config/io.datasette.llm/templates/`.
-
-```bash
-llm logs --last 5 --json | jq '.[] | {model, prompt, response}'
-```
-Inspect recent prompt/response pairs; the local SQLite log is queryable with standard SQL via `llm logs sql`.
-
-```bash
-llm templates list
-```
-List installed templates so the agent picks an existing one instead of writing a new prompt from scratch.
-
-## Wrong Choice When
-
-- You are already running inside an agent driven by an LLM (this assistant) — nesting another LLM call adds latency and cost without new capability.
-- The task is deterministic text transformation (e.g., rename a variable across files) — use `sd`/`comby`/`ast-grep`, not an LLM.
-- Working offline without a configured local backend — set up Ollama or `llm-local` first; `llm` with no provider errors out.
-
-## Alternatives
-
-| Tool | When to prefer |
-|------|----------------|
-| `aichat` | Want a richer multi-turn TTY chat experience. |
-| `mods` | Bias toward shell-friendly piping, prompt-as-flag UX. |
-| `curl` to provider API | Need explicit request shape, streaming, or headers `llm` does not expose. |
-
-## Detection / Install
-
-Verify with:
-```bash
-command -v llm
-```
-
-Install (mac):
-
-```bash
-# brew
-brew install llm
-```
-
-Homepage: https://llm.datasette.io/

package/skills/hatch3r-cli-miller/SKILL.md

@@ -1,84 +0,0 @@
----
-id: hatch3r-cli-miller
-description: "awk/sed/cut/join for CSV/TSV/JSON/Parquet streams. Use when awk-like record processing across CSV, TSV, JSON line streams; invoke `mlr`. Streams records lazily; works on datasets that exceed available RAM."
-tags: ["cli-tools", "data", "opt-in"]
-quality_charter: agents/shared/quality-charter.md
-efficiency_patterns: agents/shared/efficiency-patterns.md
-cache_friendly: true
-cli_tool:
-  id: miller
-  bin: mlr
-  tier: 3
-  category: data
-  homepage: https://miller.readthedocs.io/
----
-<!-- HATCH3R-CLI-SKILL-GENERATED v1 -->
-# miller
-
-awk/sed/cut/join for CSV/TSV/JSON/Parquet streams
-
-## When to Use
-
-Reach for `mlr` when the task is in the **data** category and the agent would otherwise call an MCP tool or read large outputs into context.
-
-## Token Cost
-
-CLI tools return structured stdout that fits in <1KB for typical queries; equivalent MCP calls regularly exceed 10KB.
-Reference: Anthropic engineering (Nov 4 2025) — code-execution-over-MCP yields 98.7% token reduction.
-
-## Recipes
-
-```bash
-mlr --c2t cat data.csv
-```
-Convert CSV to TSV on stdout — handy for piping into shell tools that prefer tab delimiters.
-
-```bash
-mlr --csv stats1 -a mean,stddev -f price products.csv
-```
-Compute mean and stddev of the `price` column.
-
-```bash
-mlr --icsv --ojson put '$tax = $amount * 0.07' transactions.csv
-```
-Read CSV, add a computed column, emit JSON — chained format conversion plus DSL transform.
-
-```bash
-mlr --csv filter '$status == "active"' users.csv
-```
-Row filter using the put/filter DSL — operates on streams of arbitrary size.
-
-```bash
-mlr --csv join -j id -f orders.csv customers.csv
-```
-SQL-style join on `id` between two CSVs, streamed.
-
-## Wrong Choice When
-
-- **Multi-gigabyte analytical queries with joins:** `hatch3r-cli-duckdb` (tier 2) has a query planner and parallel scan; mlr is streaming-single-thread.
-- **One-column slice or count:** `hatch3r-cli-qsv` (tier 2) is faster for trivial slicing.
-- **Production ETL with schema enforcement:** use a real database or dbt — mlr is a CLI-scratchpad tool.
-
-## Alternatives
-
-| Tool | When to prefer |
-|------|----------------|
-| `hatch3r-cli-duckdb` (tier 2) | Multi-GB data, joins, analytical SQL, Parquet |
-| `hatch3r-cli-qsv` (tier 2) | Single-column slice, count, sample on plain CSV |
-| `hatch3r-cli-csvkit` (tier 3) | SQL-over-CSV with `csvsql`, Python integration |
-
-## Detection / Install
-
-Verify with:
-```bash
-command -v mlr
-```
-
-Install (mac):
-
-```bash
-# brew
-brew install miller
-```
-
-Homepage: https://miller.readthedocs.io/