x-cmd is a modular POSIX shell command framework providing 300+ modules and 600+ curated CLI tools behind a unified `x` dispatcher. In production it functions as a cross-platform developer toolkit: it wraps package managers (apt, brew, scoop, winget, pixi, asdf), provides AI/LLM client integrations (OpenAI, Gemini, Claude, DeepSeek, Ollama, Kimi), wraps git-forge APIs (GitHub, GitLab, Gitea, Gitee, Codeberg), and offers system utilities (process/disk/network/GPU monitoring, DNS, routing, file operations). The core is a shell bootstrap (`X`) that sources module entry points (`mod/<name>/latest`), with lazy-loading via the `xrc:mod:lib` DSL and a metadata layer (`adv/*.jso`) driving shell completions, help text, and TLDR examples. The framework explicitly targets bash, zsh, dash, fish, nushell, xonsh, and PowerShell with per-shell code paths, and supports Linux, macOS, Windows (Git Bash/WSL), and Termux. Architecturally this is a monolith of loosely-coupled shell modules rather than a single binary. Each module follows a consistent pattern: a `latest` manifest declaring the main function, subcommand dispatch via `case` statements, and AWK scripts for data transformation. Configuration flows through a YAML profile system (`cfgy`), command output caching via `ccmd`, and on-demand binary provisioning through `pkg`/`pixi`/`snap` fallbacks. The most impressive craftsmanship lives in the AWK libraries: a pure-AWK JSON parser, a QR encoder with GF(256) Reed-Solomon error correction, a Chinese lunar calendar converter, and a TSV-based ontology engine. These are genuinely reusable, self-contained data-processing components. However, the codebase also contains many stub modules, duplicated AI-provider wrappers, hardcoded version pins, and heavy `eval` usage — the breadth of scope (300+ modules) trades completeness for coverage. The repo has a hybrid character: while dominantly an application, it embeds data-oriented subsystems (ondb ontology database, CVE/OSV/KEV vulnerability data, agent token-cost analytics) that could be extracted independently.
This is the official Netlify CLI (netlify/cli), a comprehensive Node.js command-line tool for managing the Netlify platform. It provides commands for local development (`netlify dev`), deployment (`netlify deploy`), serverless and edge functions, environment variables, blobs (key-value store), database migrations (local Postgres via PGlite), log streaming, AI agents, and site configuration. The architecture follows a modular command pattern using Commander.js, with each major feature (deploy, dev, functions, etc.) in its own subdirectory. The codebase is well-structured with clear separation of commands, utilities, and libraries. It integrates deeply with Netlify's API and SDKs, and includes extensive integration tests with mock APIs and site builders. While the CLI is production-grade and actively maintained, it carries significant TypeScript type safety debt (hundreds of ESLint suppressions and `@ts-expect-error` comments), and some modules exhibit high complexity (e.g., the deploy command is a ~900-line file). Overall, it is a reliable tool with a strong feature set, but refactoring and type tightening would improve maintainability.
Kalker is a multi-platform mathematical calculator implemented primarily in Rust. It provides a CLI with a REPL, a web component compiled to WebAssembly, and an Android mobile app via Capacitor. The core library (`kalk`) supports user-defined variables and functions, units, differentiation, integration, root finding, equation systems, matrices/vectors, complex numbers, and multiple number bases. The codebase is well-structured with a clear separation between parsing (lexer/parser), evaluation (interpreter), and a custom value system. It features extensive test files and integration tests for numerical methods. While the core numerical routines (tanh-sinh quadrature, Newton's method, Gaussian elimination) are tightly coupled to the interpreter, they are implemented with care and demonstrate non-trivial numerical analysis. The repository also includes build scripts for multiple targets and CI/CD pipelines.
ghstack is a Python CLI tool that enables developers to work with stacked pull requests on GitHub. It manages a stack of diffs as separate PRs using a specific branch naming convention (gh/username/N/{base,head,orig}). The tool provides subcommands for submitting, landing, checking out, pulling, cherry-picking, logging, syncing, unlinking, and managing stacked PRs. It interacts with GitHub via both GraphQL and REST APIs asynchronously (aiohttp) and relies heavily on git operations for branch and commit management. The codebase is modular with abstract endpoint classes for testability, a fake GitHub endpoint for offline testing, and a comprehensive test suite using custom pytest collection of .py.test files. Its primary value is enabling the 'stacked diff' workflow on GitHub, which is common in large engineering organizations but poorly supported natively.
MCPM (Model Context Protocol Manager) is a production-grade CLI tool for managing Model Context Protocol (MCP) servers. It provides a centralized server registry, global configuration, virtual profile system (tags), multi-client integration (Claude Desktop, Cursor, Windsurf, VSCode, Cline, Goose, and 10+ more), direct server execution via stdio/HTTP/SSE, secure public sharing via tunnels, and usage monitoring/analytics. The tool is designed for both interactive use and AI-agent automation (non-interactive mode with environment variables). The repository also contains a curated registry of 400+ MCP server definitions (JSON manifests) with metadata and installation instructions. While primarily a Python CLI application, the registry component adds a hybrid data/configuration dimension. The architecture follows a monolith command pattern with modular command implementations, client adapters using base class inheritance, and optional FastMCP proxy for server aggregation.
This repository provides a Python CLI tool and Makefile pipeline to scrape all essays from Paul Graham's website (paulgraham.com), convert them to Markdown, and produce an EPUB ebook. The core logic resides in a single script (`graham.py`) that uses `requests`, `BeautifulSoup`, `html2text`, and `htmldate` to download, parse, and date-stamp each essay. A `Makefile` orchestrates the full build: creating a virtual environment, fetching essays, merging them with `pandoc`, and generating the final EPUB with a custom CSS and an iBooks dark-mode patch. The CI workflow (GitHub Actions) runs daily, detects new essays by comparing article counts, and automatically creates a release with the updated EPUB and metadata CSV. The architecture is straightforward—no web server, database, or tests—but the pipeline is robust and well-documented for its single purpose. While the scraper is tightly coupled to Paul Graham's site structure, several components (the iBooks patcher, the footnote conversion function, and the EPUB stylesheet) are cleanly isolated and reusable in other EPUB generation projects.
This repository implements a comprehensive CLI tool and library for downloading content from Patreon. It supports posts, products, media (images, videos, audio, attachments), and metadata like campaign info, comments, and collections. The downloader uses cookie-based authentication to access patron-only content and handles various embedded media providers (YouTube, Vimeo, SproutVideo) via internal tasks or external downloader hooks. The architecture is event-driven and modular: a base Downloader class orchestrates fetchers, parsers, and download task batches, with typed entities and extensive configuration options (proxy, concurrency, file existence actions, naming formats). A built-in web server with a React frontend allows browsing downloaded content via a local SQLite database with full-text search. The code demonstrates strong engineering practices: class mixins for database and API layers, a task hierarchy with retry and abort support, a chainable logger abstraction, and a utility-heavy core that is largely decoupled from the Patreon-specific logic. However, the tight coupling to Patreon's undocumented API structure, lack of automated tests, and some deprecated options are notable weaknesses.
msldap is a Python library and CLI tool for interacting with Microsoft Active Directory via LDAP. It provides both a low-level async connection (MSLDAPClientConnection) and a high-level client (MSLDAPClient) with convenience methods for enumerating users, computers, groups, GPOs, trusts, and more. The library supports multiple authentication methods (NTLM, Kerberos, simple, SSPI), LDAPS, SOCKS proxy, and includes an interactive console client (msldap) and a BloodHound collector (msldap-bloodhound). It also features ADCS vulnerability scanning, shadow credentials, LAPS extraction, DNS record manipulation, and an LDAP relay server. The codebase is well-organized with a modular architecture, extensive test suite (offline and live interop tests), and several reusable components such as a custom ASN.1 packetizer, LDAP filter parser, and binary structure parser. However, it has some known bugs (7 registered in known_failures.yml), vendored dependencies (asciitree, aiocmd) that may drift from upstream, and a few code quality issues (typos, dead code). Overall, it is a solid, feature-rich tool for AD security assessments.
kubectl-foreach is a Go-based CLI tool designed to run kubectl commands against multiple Kubernetes contexts in parallel. It retrieves context lists from kubeconfig, applies user-defined filters (exact match, regex, exclusion) to select target contexts, executes the provided kubectl command concurrently for each context, and prefixes output lines with context names for clarity. The architecture is monolithic with clear separation of concerns: argument parsing, filtering, context matching, and parallel execution are isolated into distinct modules. Key dependencies include kubectl (for context retrieval and command execution) and third-party libraries for colored output (gchalk), testing (testify), and concurrency management (golang.org/x/sync).
ghtkn is a Go CLI and local agent daemon that obtains short-lived GitHub App User Access Tokens via the OAuth device flow, replacing long-lived PATs and CLI OAuth tokens. The Cobra-based CLI exposes commands such as init, auth, get, exec, git-credential, revoke, agent start/stop/lock/unlock/status/reset, info, docs, json-schema, and completion. The agent runs as a background daemon and speaks a JSON-lines protocol over a local socket with GET, SET, UNLOCK, STATUS, and STOP commands. Tokens are stored encrypted at rest using AES-256-GCM with an Argon2id-derived key-encryption key, one file per client ID with 0600 permissions and atomic writes.
openupm-cli is a command-line interface for managing Unity Package Manager (UPM) dependencies. It allows users to add, remove, search, view, and list Unity packages from various registries (primarily OpenUPM and Unity's official registry). The tool modifies the Unity project's manifest.json file to add/remove dependencies and handles scoped registries for package resolution. It features a modular architecture with clear separation between CLI interface, application logic, domain models, and I/O operations. The codebase is written in TypeScript with comprehensive test coverage and follows semantic versioning for releases.
This is a large TypeScript monorepo for Sourceloop, a LoopBack 4-based microservices platform for building multi-tenant enterprise SaaS applications. It contains 14+ pre-built microservices covering authentication, audit, notification, chat, scheduler, payment, survey, search, video-conferencing, BPMN/workflow, task management, reporting, feature toggles, OIDC, and user-tenant management. Each service is packaged as a pluggable LoopBack component with controllers, models, repositories, providers, and database migrations for both PostgreSQL and MySQL. The repo also includes reusable cross-cutting packages for caching, observability, file uploads, feature flags, and a CLI for scaffolding new microservices and UI projects, plus many sandbox example applications demonstrating real-world integrations.
Spawn is a multi-cloud VM provisioning CLI that deploys AI coding agents (Claude Code, Codex, OpenClaw, etc.) onto cloud VMs (Hetzner, DigitalOcean, AWS Lightsail, GCP, Daytona, Sprite) with a single command. It handles the full lifecycle: interactive agent/cloud selection via fuzzy matching, VM provisioning, SSH key injection, agent installation (npm binaries, pre-built tarballs, or Docker sidecars), environment configuration (OpenRouter API key, MCP servers via skill files), and interactive session handoff. The system supports headless mode, recursive spawning (agent launching sub-agents), auto-update systemd services, and a security scan cron. It is distributed as per-cloud JS bundles (Bun.build, minified) with curl|bash wrappers that download from GitHub Releases, and a Windows PowerShell installer. Architecturally, Spawn is a modular monolith: a shared orchestration pipeline (`shared/orchestrate.ts`) drives cloud-specific providers implementing a common `CloudRunner`/`CloudOrchestrator` interface (authenticate → promptSize → createServer → waitForReady → install → configure → launch → interactiveSession). Agents and clouds are defined in a `manifest.json` that validates compatibility via runtime type contracts. A shared `Result` monad (`@openrouter/spawn-shared`) enables functional error handling with retry semantics across SSH calls and cloud API interactions. The codebase is well-tested (~100+ test files) with fs-isolated sandboxes, mocked cloud prompts, and integration tests against real cloud providers via an E2E harness. The codebase demonstrates strong engineering practices: schema-validated input parsing (valibot), security-first validation (allowlists for every user-controlled input: instance names, IPs, SSH usernames, shell commands, remote paths), and atomic file operations with corruption recovery for history persistence. However, there is significant duplication across cloud providers (near-identical SSH execution patterns in each cloud module), large monolithic files (orchestrate.ts ~1000+ lines, agent-setup.ts ~2000 lines), and manual drift risk from hardcoded API slugs (DigitalOcean marketplace images, Hetzner server types, GCP machine types) and embedded OAuth client secrets (documented as acceptable public-client pattern).
datafusion-dft (dft) is a batteries-included Rust application that wraps Apache DataFusion into a multi-front-end SQL query and analysis tool. It provides four interfaces sharing one execution core: a scriptable CLI (file/command queries, benchmarking, FlightSQL client mode, CSV/JSON/Parquet/Vortex output), a ratatui terminal UI with SQL editor, paginated results, and history tabs, an Arrow FlightSQL gRPC server with full metadata and prepared-statement support, and an HTTP REST server. The core library (crates/datafusion-app) constructs a DataFusion SessionContext with a trait-based extension plugin system, dedicated CPU/IO executors, statistics collection, and observability hooks.
Mevlog-rs is a Rust-based, open-source alternative to commercial blockchain explorers like Dune Analytics, providing a comprehensive toolchain for indexing, storing, and querying EVM-compatible blockchain data. The core system downloads raw chain data from RPC endpoints, stores it in per-chain SQLite databases, and allows read-only SQL queries enriched with custom U256 arithmetic, formatting, and ENS resolution. It includes a CLI with 20+ subcommands, a web backend (Axum + React) for hosted exploration, a TUI (ratatui) for interactive browsing, and an MCP server for AI agent integration. The system is heavily oriented toward MEV (maximal extractable value) analysis, with coinbase transfer detection, state diffs, and call tracing via local revm replay or RPC. Key architectural patterns include a shared dependency initializer, a secure read-only SQL sandbox with progress limits, a config-driven custom table engine, and a reorg-aware indexing pipeline that handles chain reorganizations. While the codebase demonstrates strong craftsmanship and modularity, its large dependency surface, reliance on external services (ChainList, Pinata, cryo), and some commented-out tests indicate ongoing evolution and moderate maintenance risk.
This repository is a cookbook of runnable examples for the OpenClaw SDK. It contains two layers: small one-concept recipes (e.g., run-an-agent, stream-events, cancel-a-run) and standalone starter apps (quickstart Node app, coding-agent CLI, agent-workbench React app, run-board React dashboard). The code demonstrates SDK workflows such as starting runs, streaming normalized events, cancelling work, reusing sessions, checking model status, and testing with an in-memory transport. The architecture is modular: recipes are self-contained TypeScript files with shared configuration helpers, and SDK examples are independent packages that can be copied out and adapted. The repository includes comprehensive tests, CI checks, and a workspace SDK shim for local validation without a live Gateway. It is actively maintained with modern dependencies (TypeScript 7, Node 22, pnpm 10.34.5) and follows strict formatting and linting rules.
nodemon is a CLI tool and library that monitors a directory for file changes and automatically restarts a specified command (typically a Node.js application). It parses command-line arguments and configuration files (nodemon.json, package.json) to determine watch paths, ignore patterns, file extensions, and the command to execute. It uses chokidar for file system watching and manages child processes via fork or spawn. When changes are detected, it matches the changed files against configured rules and restarts the child process if appropriate. It supports custom signals, delay, legacy polling, and event hooks. The architecture is monolithic with a library API, key modules include CLI parser, config loader, rule engine, file watcher, and process manager. The codebase relies on non-standard Node.js APIs (e.g., process.stdin.setEncoding, child_process.fork, process.versions.node), indicating significant technical drift from standard Node.js, though the tool remains widely used and actively maintained.
npkill is a TypeScript CLI/TUI application that scans filesystems to find node_modules (and other ecosystem build/dependency directories) consuming disk space, then interactively or programmatically deletes them. The core engine (Npkill class) exposes RxJS observable streams for scanning, size calculation, newest-file detection, deletion, and logging, with a worker_threads-based parallel directory traversal. The CLI layer adds a raw-mode interactive terminal UI with cursor navigation, multi-select deletion, search filtering, JSON/NDJSON output modes, --dry-run, .npkillrc config file support, and user-defined profiles. It ships both as a bin executable and as a programmatic Node library per API.md.
Fisher is a pure-Fish plugin manager for the Fish shell. It provides a CLI with commands to install, update, remove, and list plugins, which can be sourced from local directories or remote tarballs (GitHub or GitLab). The entire implementation resides in a single `fisher.fish` function (~250 lines) that handles argument parsing, concurrent downloads, file placement, event emission, and state persistence via a `fish_plugins` file. The architecture is monolithic but well-structured, using Fish-specific features like universal variables and event hooks. No external dependencies beyond curl and tar are required, and the tool is designed to be zero-configuration and snappy. The test suite uses the Fishtape framework with a sample plugin (ponyo) to validate install/update/remove flows and event handling.
This is a Python application for migrating playlists and liked songs from Spotify to YouTube Music. It provides both a command-line interface (CLI) and a graphical user interface (GUI) built with Tkinter. The tool first backs up Spotify data (playlists, liked songs, liked albums) into a local JSON file using a modified version of the spotify-backup script. Then it reads that JSON and uses ytmusicapi to add or like songs on YouTube Music, employing a multi-algorithm search strategy to match tracks. The architecture is monolithic: a single package with CLI entry points defined in pyproject.toml and a GUI module. Key external dependencies are ytmusicapi, tkinter, and the Spotify Web API. The code is well-structured with clear separation of concerns (backend logic, CLI, GUI, backup) and includes retry logic for API rate limits. The search algorithm supports exact matching, extended matching, and fuzzy matching with video fallback, demonstrating thoughtful design for cross-platform music identification.