Tooling for Multi-platform

Vs Husky: polyglot hooks; not a CI product. Local only. Teams still need a shared install path.

Modern Makefile replacement; not Taskfile. No implicit build DAG like Make. You still pick how CI invokes recipes. Distinct from package.json scripts if the repo is polyglot.

Moonbase Cloud remote cache is sunset - use bazel-remote or Bazel RE API (or Depot). Not a Turborepo drop-in.

Vs yq (YAML/JSON/XML), fx (interactive), and jless (TUI viewer): jq is the *filter language*, not a viewer and not YAML-native. Syntax is its own DSL — steep initial learning curve for complex transforms. Error messages can be cryptic. No schema validation or type safety.

mikefarah/yq ≠ kislyuk/yq — this entry is the Go binary (`mikefarah/yq`), not the Python wrapper around jq. Vs jq (JSON-only filter language): yq is multi-format structured data, not a jq dialect clone of every filter. Feature parity with jq is incomplete on purpose; learn the Go yq docs.

Vs jq (JSON filter) and DuckDB (SQL over files): Miller is the *named-field CLI verb chain*, not a full SQL engine and not jq’s JSON DSL. Great for tabular streams; heavy analytics and joins may outgrow mlr into DuckDB/Polars. Distinct from yq’s document-shaped transforms.

Vs yq (jq-shaped multi-format Go CLI) and jq (JSON filter language): dasel is *one selector* across formats, not a jq dialect clone and not YAML-only muscle memory. Learn dasel’s selector docs; do not assume every jq filter ports. Distinct from Miller (tabular verbs).

SOFT: last commit ~May 2025 — quiet but not abandoned folklore. Vs jq (filter language): gron is *flatten-for-grep*, not a transform DSL. Huge blobs become huge line piles; know when jq select() is the shorter path.

Vs jq (JSON filter), jless (JSON pager), gron (flatten-for-grep), and jc (CLI stdout→JSON): fq is the *binary-format* cousin, not a JSON-only pipe and not a packet capture GUI. Decoder coverage is wide but not every vendor blob; unknown formats still need a spec.

GPL-3.0 copyleft — fine as a laptop/CI CLI; read the license before you embed the analyzer into a proprietary product. Vs Hadolint (Dockerfile AST + ShellCheck on RUN): ShellCheck is *shell scripts*, not Dockerfiles. It is static analysis, not a runtime or a shell.

Vs watchexec (file→command *watcher*) and Zellij (Rust terminal *workspace/layouts*): Overmind is the *Procfile supervisor on tmux*, not a file watcher and not a layout multiplexer. Needs tmux installed. Not a production process supervisor — Overmind is a dev-loop tool, not systemd.

Vs Ollama / llama.cpp / vLLM (runtimes): llmfit is the hardware fit finder, not the model runtime. Catalogs and VRAM heuristics drift; always verify against your real device and quantization. Does not download or serve models for you.

First-party googleworkspace org surface — but the README states it is not an officially supported Google product. Vs raw Workspace REST / Apps Script: this is the CLI/agent skill layer, not a new API. Needs a GCP project + OAuth; unverified apps hit scope limits; Workspace/Admin API quotas still apply.

Vs Ollama/vLLM (local serve / high-throughput GPU serving): colibrì is research-grade MoE disk-streaming for models that do not fit, not the everyday pull-and-chat DX of Ollama or the production serving stack of vLLM. research/HW-heavy — expect fast NVMe, large model containers (hundreds of GB), and tokens/sec that track your disk hierarchy.

Vs Mise (cross-runtime version manager CLI): BrewUI is a macOS GUI for Homebrew packages, not a multi-language runtime pin tool. AGPL-3.0 is network copyleft — modifications you ship over a network must share source. macOS-only; cask currently targets newer macOS floors.

Plugins are free; primary intent is Claude Cowork (paid host). Vs generic Claude Code skills packs: this tree is aimed at knowledge-work / Cowork surfaces, not a drop-in replacement for every coding-agent skill. You still need a compatible Anthropic host product and whatever model plan that host requires.

Hermes-specific — not a generic Claude Code / Codex skill pack. Young surface; expect Hermes Agent as the host and follow upstream Hermes breaking changes. Vs ECC (multi-host ecosystem) and security-audit-skill (Cloudflare audit skill): oh-my-hermes is niche Hermes tooling, not a cross-harness coordination layer or a security scanner.

Vs GitDiagram: Archify is an agent skill that renders requested architecture/workflow/sequence views as self-contained HTML, while GitDiagram is a repo-to-interactive-diagram product. Diagram output is an orientation aid, not proof that every dependency or runtime relationship is correct; verify it against the source before using it as an architecture contract.

Vs generic agent-skills packs: this library is Stitch-specific — useful when you are on Google Stitch, not a universal design system. Stitch product access and quotas remain Google-side constraints; the skills repo does not replace that.

Elastic License 2.0 is source-available, not OSI open-source — you may not offer Weave Router as a hosted/managed service under ELv2 without permission. Vs LiteLLM: LiteLLM is the broader multi-provider gateway/SDK; Weave Router's wedge is per-prompt model selection via on-box embeddings. Routing quality still depends on your traffic mix and evaluation.

Caveat: the repository has no root LICENSE file; the MIT claim is stated in the README and npm package, so confirm the artifact and version you ship. Vs CopilotKit, Mastra, and Rivet: Agent Native's wedge is the shared action contract across surfaces, not a complete agent runtime or orchestration platform. Distinct from Panel: this is a framework for exposing actions, not the youth workbench/product surface Panel would have been.

Vs Superpowers and agent-skills packs: Impeccable is a design-language/skills layer for UI quality, not a coding agent and not a general agent-skills monorepo. Node ≥22.18 for the npx installer path; star count is extreme (~70k) — treat momentum as discovery noise until the skill actually changes your harness output.

Vs agent-browser and aclif: this is a CLI-surface generator/hub for arbitrary apps, not a browser automation agent and not a generic CLI framework alone. Many hub CLIs assume heavy upstream installs (GIMP, Blender, GIS, DAWs); star velocity is extreme (~50k) — budget the host apps, not only the thin CLI wrapper.

Not an agent product — offline-first bugs in git. Vs GitHub/GitLab/Linear: hosted trackers win on UI and notifications; git-bug wins when the issue database must survive without a network and stay colocated with history. Overnight HN heat is discovery, not a new category.

Vs Bun: Bun is a runtime+pkg toolkit; scriptc is AOT compile-out. Vs Deno: Deno is a runtime; scriptc is a compiler. Vs Oxc: Oxc is parser/lint tooling substrate; scriptc emits native/Wasm. Labs experiment; requires Node ≥24; young (~2 months) — expect sharp edges and fast churn.

Vs LlamaIndex (framework) and cloud LlamaParse: LiteParse is the local OSS parser binary/bindings; LlamaParse cloud is the upsell for dense tables/scans/handwriting. Hard docs still want LlamaParse or another heavy parser — do not pretend local PDFium equals production OCR SaaS.

The project calls itself experimental and recommends running it alongside Homebrew, not replacing it — do not purge brew. It depends on Homebrew’s formulas, bottles, and infrastructure; it is a faster client, not a new package ecosystem. Cold-install gains shrink on slow links (downloads dominate big bottles), and the “100x” headline is the warm-cache case. Vs mise (runtime version manager): zerobrew installs Homebrew packages, it does not pin language toolchains per project.