gitmoji-cli is an interactive command-line tool that injects gitmoji emojis into git commit messages. It operates in two modes: a client mode (`gitmoji -c`) that runs interactive inquirer prompts to assemble a commit message before shelling out to `git commit`, and a hook mode (`gitmoji -i`) that installs a `prepare-commit-msg` git hook which intercepts every `git commit` and prompts the user before writing the commit message file. Additional subcommands list, fuzzy-search, update, and configure the emoji dataset and CLI preferences. It depends on the gitmoji.dev public API as the source of emoji data, git itself, and the npm ecosystem. Architecturally it is a Node.js ESM CLI built with a Babel compilation pipeline and a deliberate mix of Flow-typed JavaScript and newer TypeScript modules. The command layer is cleanly separated from utilities: meow parses flags and subcommands, a small dispatcher routes to lazily-imported command modules, inquirer drives prompts with a registered autocomplete plugin, and execa shells out to git. The emoji dataset is fetched via node-fetch, cached in `~/.gitmoji/gitmojis.json` for offline use, and searched using fuse.js with weighted scoring. Configuration resolves through a precedence hierarchy of `.gitmojirc.json`, a `gitmoji` key in package.json, parent-directory lookups, and a schema-validated global conf store. Notable engineering exists in the git hook integration, which correctly detects in-progress rebases and amends, handles SIGINT so an interrupted prompt does not abort the user's commit, and skips prompting when the commit title already contains a Unicode or shortcode emoji. The codebase has comprehensive Jest unit and snapshot tests, GitHub Actions CI covering lint/flow/test/coverage, a release pipeline, and a current dependency set. Main quirks are the transitional dual type system (Flow + TypeScript) and a few cosmetic copy-paste issues, but overall this is a polished, well-maintained developer tool.
Pa11y is a mature, widely-used automated accessibility testing tool that runs via command-line interface or Node.js API. It drives a headless Chrome browser (via Puppeteer) to load web pages, execute optional user interactions (actions), and then run one or more accessibility test runners (HTML_CodeSniffer and axe-core) against the page. Results are reported in multiple formats (CLI, CSV, JSON, HTML, TSV) and can be filtered by severity, ignored rules, or threshold. The architecture is a monolith library with a thin CLI wrapper, but the runner and reporter systems are modular and extensible via npm packages or local files. Key entry points are `bin/pa11y.js` for CLI and `lib/pa11y.js` for programmatic use. The data flow: launch Chrome, navigate to URL, run actions, inject runner scripts into the page, evaluate accessibility, collect and process issues, output via selected reporter. External dependencies include Puppeteer, axe-core, @pa11y/html_codesniffer, commander, and several utility libraries. The codebase is well-structured, thoroughly tested (unit and integration), and follows modern Node.js practices with async/await and ES6+ features.
PMXT is a unified prediction market SDK that aggregates data and trading across 15+ venues (Polymarket, Kalshi, Limitless, etc.) into a single, consistent interface. The system provides a core TypeScript library with a local sidecar server (Express), plus TypeScript, Python, and CLI SDKs that support both self-hosted and hosted (trade.pmxt.dev) modes. It offers market data (events, order books, trades, OHLCV), WebSocket streaming, order management (create, cancel, fetch), account balance and positions, cross-venue router for event matching and arbitrage, and data feeds (Binance, Chainlink). The architecture is a monorepo with workspaces core, sdks/typescript, sdks/python, sdks/cli, and tools. Each exchange follows a clean fetcher → normalizer → error mapper pattern, and the SDK surfaces are partially generated from the core's method signatures. While primarily an application SDK, the project includes significant data normalization, cross-venue data aggregation, and a router for analytical queries, giving it a hybrid character.
This repository provides `mmx-cli`, a TypeScript-based command-line interface for the MiniMax AI platform. It allows users to authenticate, generate text, images, video, speech, perform web search, and manage configuration entirely from the terminal. The codebase is modular with a command registry pattern, supports both OAuth and API key authentication, handles streaming responses (SSE), and includes a programmatic SDK for Node.js/TypeScript consumers. Key architectural patterns include a hierarchical command resolution system, a generic HTTP client with retry and timeout logic, file download utilities with atomic writes, and a polling utility for async task monitoring. The CLI also automates setup for third-party AI coding agents (Claude Code, Codex, Grok, etc.) by writing configuration files. Testing is extensive with a mock server pattern. The tool is dual-region (global and China) with automatic endpoint detection. While early in development (version 0.0.0-dev), the engineering quality is solid with clear separation of concerns, typed error handling, and thoughtful output formatting (text, JSON). Some components like the agent configurator and video generation validation are tightly coupled to MiniMax-specific APIs, but many utility and client modules exhibit patterns reusable in other CLI tools or API wrappers.
This is a Linux-only CLI benchmarking tool written in Zig that uses the `perf_event_open` syscall to measure hardware performance counters (CPU cycles, instructions, cache references/misses, branch misses) alongside wall time and peak RSS. It repeatedly executes user-specified commands, collects samples, and computes statistical summaries (mean, standard deviation, quartiles, outlier counts) with a colorful terminal UI. The tool compares multiple commands, treating the first as a reference, and displays deltas with statistical significance testing using Student's t-distribution. The codebase is small but well-crafted, demonstrating advanced use of Linux perf events, statistical analysis, and terminal rendering. It is actively maintained by Andrew Kelley (author of Zig) and serves as a practical alternative to Hyperfine for hardware-aware benchmarking.
ov is a feature-rich terminal pager written in Go, designed as a modern replacement for less/more. It supports large files via chunked reading with memory limits, ANSI escape sequence rendering, column alignment, word wrapping, search (case-insensitive, regex), follow/watch modes, multiple documents, sidebar panels (help, marks, doc list, sections, styles), mouse support, and extensive keybinding customization. The architecture is a single binary with a core `oviewer` package handling document management, screen drawing, event processing, and input modes. It uses `tcell` for terminal UI, `cobra` for CLI, `viper` for configuration, and supports compressed files (gzip, bzip2, zstd, lz4, xz). The codebase is well-tested with over 100 test files and demonstrates solid engineering practices including reusable patterns for bidirectional maps, ordered maps, converters, and input handling.
Inlang is a localization platform that treats translation as code, storing messages in a versioned Lix database managed through Git. The monorepo includes a TypeScript SDK for loading, querying, and exporting translation projects; a CLI for running checks and machine translation; a plugin system for integrating with multiple message formats (JSON, ICU, i18next, Android XML, Apple xcstrings, and more); and Lit-based web components for editing translations in-browser. The SDK provides a rich data model (bundles, messages, variants with selectors) and a checks engine for detecting missing translations, unused messages, and plural errors. Architecturally, the repo is organized as a pnpm/Nx monorepo. The core `@inlang/sdk` package manages project lifecycle and database operations via Kysely. Plugins conform to a uniform `importFiles/exportFiles` interface and are loaded dynamically. The CLI uses Commander and Consola, while the UI components use Lit with Shoelace design tokens. The companion website (TanStack Start) serves documentation, a marketplace registry, and SEO-optimized pages. The system is designed to run in Node.js (CLI) and browsers (editor), with a focus on preserving file formatting through careful diffing and merging during export. Notable craftsmanship includes the `keepUnchangedJsonEntries` utility for byte-identical file preservation, the `EchoTracker` for optimistic UI state, the `pluralExamples` helper for locale-aware examples, and the `human-id` word lists for generating readable identifiers. These components are self-contained, well-tested, and reusable outside the localization domain. The codebase demonstrates strong engineering practices with extensive test coverage (vitest, Storybook, fuzzing) and compatibility tests ensuring backward compatibility across SDK versions.
JPlag is a mature source-code plagiarism detection engine delivered as a Java library, a picocli-based CLI, and an embedded Vue.js report viewer. In production it parses submissions into language-specific token streams (via ANTLR, JavaCC, or custom parsers), compares token sequences pairwise using greedy string tiling with rolling hashes, merges fragmented matches, applies frequency-based weighting, optionally clusters submissions, and writes a .jplag ZIP report containing JSON models consumed by the viewer. The CLI can also start a local HTTP server to browse results. Architecturally it is a multi-module Maven project: core contains the comparison pipeline and reporting; language-api and language-antlr-utils define a plugin SPI for adding languages; languages/* provides 20+ modules; cli assembles the executable; report-viewer is an npm workspace with model/parser/ui-components packages. Key entry points are de.jplag.cli.CLI and de.jplag.JPlag.run(). External dependencies include ANTLR, picocli, Jackson, JGraphT, Apache Commons Math, and the Vue/TypeScript ecosystem. Although primarily an application, it embeds research-grade components such as spectral and agglomerative clustering with Bayesian optimization, token-sequence normalization, and match-frequency weighting, and it is backed by academic publications. It is not a data pipeline; the inputs are source-code submissions and the output is a similarity report. The repository is actively maintained with extensive CI, end-to-end gold-standard tests, and dependabot, though some language grammars lag language evolution and a few deprecated APIs remain.
Aura is a command-line package manager for Arch Linux and the Arch User Repository (AUR). It acts as a drop-in replacement for pacman, passing all pacman operations through unchanged while adding AUR-specific workflows: searching and building packages from the AUR, maintaining a local package cache for downgrades, taking JSON snapshots of installed package state for rollback, viewing and searching ALPM logs, identifying orphaned packages, analyzing licenses, and generating dependency graphs. The system integrates directly with pacman, makepkg, git, sudo/doas, shellcheck, and Graphviz, and uses a custom FAUR metadata server to query AUR package data efficiently. The primary implementation is a modern Rust workspace (aura-pm binary, aura-core library, and r2d2-alpm connection pool), with extensive localization via Project Fluent covering more than 20 languages. A legacy Haskell implementation remains in the repository but is superseded by the Rust rewrite, which is the actively maintained codebase.
SimUtil is a Dart-based terminal UI/CLI for managing iOS simulators and Xcode Derived Data. It wraps `xcrun simctl` to list, boot, shut down, install, launch, and interact with simulator devices, and adds conveniences like showing/cleaning Derived Data. The app is operated entirely from the terminal and stores user preferences in `~/.simutil/settings.yaml`, including a `plugins:` section for custom commands. Architecturally it separates terminal UI components (`lib/components`) from services (`lib/services`) such as `CommandExec` (a shell-command abstraction), `UserConfig` (YAML settings with first-run defaults and scalar merge), and Derived Data helpers. A `tool/generate_changelog.dart` code generator parses `CHANGELOG.md` and emits typed Dart data so the app can show post-update changelog dialogs. Tests cover the changelog generator and config file behavior, and CI runs build/install verification across platforms.
Matcha is a full-featured terminal email client (TUI) written in Go, using the Bubble Tea framework. It supports multiple email protocols (IMAP, JMAP, POP3, Maildir) and provides a rich set of features including PGP/SMIME encryption, OAuth2 authentication, a Lua plugin system with 35+ community plugins, background daemon for push notifications and sync, spellcheck, i18n with 11 languages, and a configurable theme system. The architecture is modular: a backend provider interface abstracts protocol implementations, a daemon runs as a background process communicating via JSON-RPC over Unix sockets, and the TUI is built with composable Bubble Tea models. The codebase demonstrates strong engineering practices with extensive test coverage, CI/CD pipelines, cross-platform packaging (Homebrew, Snap, Flatpak, Nix, WinGet), and a well-designed plugin API. It is not a data research project; it is a production-grade application.
SALib is a Python library for global sensitivity analysis (GSA) of computational models. It implements a comprehensive suite of variance-based and moment-independent methods including Sobol', Morris, FAST, DGSM, PAWN, HDMR, RBD-FAST, and fractional factorial designs. The library follows a decoupled workflow: sample parameter space, evaluate the model, then analyze results. It provides both a programmatic API (import SALib) and a command-line interface (salib sample/analyze). The architecture is modular: sampling modules in SALib.sample, analysis modules in SALib.analyze, with shared utilities in SALib.util. A high-level ProblemSpec class enables fluent method chaining (sample → evaluate → analyze → plot). Results are returned as ResultDict objects with to_df() and plot() methods for integration with pandas and matplotlib. External dependencies are numpy, scipy, matplotlib, pandas, and optionally multiprocess/pathos for parallel execution. The library is used in environmental modeling, energy systems, and uncertainty quantification research, with over 1000 GitHub stars and a JOSS paper.
Onedump is a Go-based CLI tool for database administration, specializing in backup, restore, and migration workflows. It supports MySQL (with a zero-dependency native dumper and mysqldump) and PostgreSQL (via pg_dump), and can persist backups to local files, AWS S3, Google Drive, Dropbox, or SFTP endpoints. The architecture follows a clean pipeline pattern: YAML configuration drives concurrent job execution, each job uses a dumper interface to stream database content through gzip compression and fan-out to multiple storage backends. Beyond core backup, it includes advanced features: MySQL binlog streaming to S3 with checksum-based deduplication, point-in-time restore via binlog replay, a MySQL slow query log parser with query masking and deduplication, and a resumable/concurrent SFTP file transfer utility with exponential backoff. The codebase is well-structured, heavily tested, and uses modern Go idioms, making it suitable as a reference for building database-adjacent infrastructure tooling.
decK is a CLI tool for declarative configuration management of Kong API Gateway and Konnect SaaS. It enables users to manage Kong entities (services, routes, plugins, consumers, certificates, etc.) via YAML/JSON state files, supporting sync, diff, dump, apply, reset, and validate operations. The architecture is a single binary with multiple subcommands organized under `gateway`, `file`, `ai`, and `konnect` namespaces, built on top of Kong's go-database-reconciler library for state reconciliation. Key entry points include `main.go` (signal handling), `cmd/root.go` (Cobra CLI), and command handlers in `cmd/gateway_*.go`, `cmd/file_*.go`, and `cmd/ai_*.go`. Data flows involve reading declarative state files, fetching current state from Kong Admin API or Konnect, computing diffs, and applying CRUD operations. External dependencies include Kong Gateway (>=1.x), Kong Enterprise, Konnect, and various Go libraries for Kubernetes, Terraform, and AI Gateway integrations. The repository also includes converters for generating Kubernetes Ingress Controller manifests (`kong2kic`), Terraform resources (`kong2tf`), and version migration rulesets (`convert/`).
Tax-Calculator is a mature, open-source microsimulation library for static (and simple behavioral) analysis of the US federal individual income and payroll tax system. It provides a Python API and a CLI tool (`tc`) that allow users to define policy reforms via JSON parameter files, apply them to microdata samples (CPS, PUF, or TMD), and produce distributional tables, revenue estimates, marginal tax rates, and welfare measures. The core architecture separates policy parameters (`Policy`), taxpayer records (`Records`), and economic adjustments (`GrowFactors`, `GrowDiff`, `Consumption`) from the calculation engine (`Calculator`), which uses Numba JIT compilation for performance. While primarily an application/library with formal releases and CI/CD, it also bundles research data (CPS microdata, grow factors) and includes extensive cross-validation against NBER's TAXSIM-35 model. The codebase is well-structured, heavily tested, and actively maintained, with a clear modular design that supports both CLI and programmatic use.
cli-chess is a terminal-based chess application that supports playing online via Lichess.org and offline against the Fairy-Stockfish engine. It features a modular MVP (Model-View-Presenter) architecture with clear separation of concerns across core game logic, reusable UI components (board, move list, chat, clock), menu systems, and API integration. The application supports all Lichess chess variants, includes features like premoves, takebacks, draw offers, chat, blindfold mode, unicode pieces, custom theming, and PGN export. Entry point is src/cli_chess/__main__.py, with gameplay driven by user input flowing through presenters to models, which update views via an event system. External dependencies include python-chess for board logic, berserk for Lichess API, and prompt-toolkit for the terminal UI.
htmlnano is a modular HTML minifier built on PostHTML, providing a library API, CLI, PostHTML plugin, and webpack integration. It processes HTML through a configurable pipeline of modules (e.g., whitespace collapse, comment removal, CSS/JS/SVG minification) organized into presets (safe, ampSafe, max). The core architecture uses PostHTML's tree walking and a plugin-like module interface where each module can transform attributes, content, or nodes. Optional peer dependencies (cssnano, terser, svgo, etc.) are loaded lazily, and configuration is handled via cosmiconfig. The codebase demonstrates strong engineering with comprehensive test coverage, property-based fuzz testing, and DOM equivalence validation. While primarily a library, it also includes a CLI and webpack adapter, making it a versatile tool for HTML optimization in build pipelines.
Mimeo is a Python CLI application that transforms a named expert's public body of work (essays, talks, interviews, podcasts, papers, etc.) into a structured, source-verified Agent Skill file (SKILL.md) and/or AGENTS.md, designed for AI coding agents to adopt the expert's reasoning style. The pipeline orchestrates identity resolution, source discovery via the Parallel API, content fetching (web, YouTube transcripts, optional audio transcription), LLM-based distillation and clustering (via OpenRouter), quote verification against source text, structured skill authoring, critique/refinement loops, and optional avatar generation. The output is a curated set of markdown files (principles, frameworks, mental models, anti-patterns, heuristics, quotes) organized per expert in the `output/` directory. The codebase is well-architected with async stages, a fingerprint-based caching layer, SSRF-safe HTTP helpers, prompt injection mitigations, and extensive offline tests using fake LLM/Parallel clients. While the primary purpose is the application tool, the generated output forms a reusable knowledge base of expert reasoning patterns, giving the repo a hybrid character.
kotofetch is a Rust-based CLI tool that displays Japanese quotes in the terminal with extensive customization options. It features built-in quote collections (anime, proverbs, haiku, lyrics, and yojijukugo) and supports importing Anki decks via AnkiConnect. The tool offers various display modes including furigana (ruby text) rendering, animations (typewriter, scramble, slide), and flexible text styling. The application architecture is modular, with separate modules for command-line parsing, configuration management, quote importing, and display rendering. The display module handles complex text layout, including inline furigana annotations, Unicode-aware wrapping, and terminal boxing with optional animations. Key reusable components include the furigana parsing and formatting logic (which handles conversion between Anki's [reading] syntax and kotofetch's (reading) syntax and renders ruby text with proper alignment) and the AnkiConnect client (which provides a robust interface for fetching and converting Anki notes into kotofetch-compatible quote files).
This is a Rust CLI tool called `facts` that implements a fact-driven development workflow. It manages a `.facts` file containing atomic, verifiable claims about a project, each with lifecycle tags (`@draft` → `@spec` → `@implemented`) and optional shell commands for automated verification. The tool provides a rich set of subcommands for listing, adding, editing, removing, linting, and checking facts, along with a terminal UI (TUI) built with Ratatui and Crossterm. It integrates with AI coding agents (Claude, Codex) to verify manual facts via an XML-based verdict protocol, and ships with bundled agent skills for discovery, refinement, and implementation. The project is self-hosting—it uses its own `.facts` file to describe itself—and is distributed via npm, PyPI, and direct install. The architecture is a monolith with clearly separated modules for parsing, writing, ID generation, tag filtering, file locking, and agent communication. The codebase demonstrates strong engineering practices: deterministic round-trip serialization, atomic file writes, advisory locking with stale detection, and a boolean expression evaluator for tag filters. It is actively maintained with a comprehensive test suite and CI/CD pipeline.