nb is a command-line note-taking, bookmarking, and archiving tool with Git-backed versioning, encryption, full-text search, tagging, pinning, and a built-in web server for browsing. It is implemented primarily as a single portable Bash script, with optional Go, Ksh, and Zsh wrappers. The architecture is a monolith CLI with a plugin system for extending subcommands and themes. Key entry points are the `nb` script and its aliases `bin/notes` and `bin/bookmark`. Data flows involve creating/editing notes in `NB_DIR`, where each notebook is a Git repository; operations create automatic commits, and an `.index` file per folder maintains ordering. The tool supports multiple notebooks, nested folders, encryption (OpenSSL/GPG), bookmark import from browsers, and remote sync via Git. The extensive test suite (2200+ BATS tests) covers all major features and edge cases.
RustNet is a cross-platform, real-time network monitoring terminal UI application. It captures packets via libpcap (or platform-specific backends like PKTAP on macOS, ETW on Windows), performs deep packet inspection (DPI) for protocols including HTTP, HTTPS, DNS, SSH, QUIC, BitTorrent, and many others, and attributes each connection to the owning OS process using eBPF (Linux), lsof (macOS), IP Helper (Windows), or sockstat (FreeBSD). The architecture is a multi-crate Rust workspace: `rustnet-core` provides connection tracking, DPI analyzers, GeoIP/OUI lookup, and rate/RTT tracking; `rustnet-capture` wraps libpcap; `rustnet-host` implements process lookup via a unified `ProcessLookup` trait; `rustnet-sandbox` handles privilege dropping and sandboxing (Landlock, Seatbelt, Windows job objects). The main binary (`rustnet-monitor`) orchestrates capture, enrichment, and a ratatui-based TUI with tabs for Overview, Details, Activity, Graph, and Host. It supports PCAP/PCAPNG export with process metadata, JSONL event logging, Kubernetes pod attribution, and a rich theme system with multiple presets. The codebase is well-structured, extensively tested, and actively maintained with CI/CD for multiple platforms and packaging (DEB, RPM, DMG, MSI, Homebrew, Chocolatey).
fselect is a Rust command-line tool that enables searching the filesystem using SQL-like queries. It parses a SELECT-FROM-WHERE-GROUP BY-HAVING-ORDER BY-LIMIT syntax, traverses directories, and extracts rich metadata from files including size, timestamps, permissions, media information (EXIF, audio/video dimensions, duration), cryptographic hashes, MIME types, extended attributes, ACLs, git status, and more. The tool supports aggregation functions, subqueries (both FROM-subselects and correlated IN/EXISTS), and multiple output formats (tabular, CSV, JSON, HTML). It can accelerate searches via external indexes (Everything on Windows, plocate on Linux) and includes an interactive REPL mode. The architecture is a single binary with clean separation of concerns: lexer/parser for query processing, a searcher module for filesystem traversal and expression evaluation, utilities for metadata extraction, and pluggable output formatters.
ascii-chat is a production-grade terminal-based video conferencing application that converts live video and audio streams into real-time ASCII art rendered in the terminal. It operates in multiple modes: server (multi-client host), client (connect to server), mirror (local preview), discovery (peer-to-peer session participant), and discovery-service (session registry and NAT traversal relay). The system uses a custom binary protocol (ACIP) over TCP/WebSocket/WebRTC, with end-to-end encryption (Ed25519 + X25519 + XSalsa20-Poly1305) and support for SSH/GPG key authentication. A companion web client compiled via WebAssembly mirrors functionality in the browser. The codebase includes a standalone reusable C library (libasciichat) with a comprehensive platform abstraction layer (POSIX/Windows/WASM), a declarative options registry that auto-generates man pages and shell completions, SIMD-accelerated ASCII rendering (AVX2, NEON, SVE, SSE2), lock-free data structures, and a sophisticated logging system with crash-safe mmap output. The architecture is modular and cross-platform, with extensive unit, integration, and E2E test coverage across Linux, macOS, Windows, and WebAssembly targets.
Mole is a macOS system maintenance CLI tool that provides a unified interface for cleaning caches, uninstalling applications, analyzing disk usage, monitoring system health, and optimizing performance. It combines two Go binaries (cmd/analyze for disk exploration with a Bubble Tea TUI, cmd/status for real-time system metrics) with an extensive shell script library for orchestration and system-level operations. The `mo` command dispatches to subcommands like `clean`, `uninstall`, `analyze`, `status`, `optimize`, `purge`, and `installer`. The architecture is hybrid: Go handles performance-critical tasks (concurrent directory scanning with semaphore-based concurrency, hardlink deduplication, gob-based caching, and interactive TUI rendering) while Bash scripts manage cleanup logic, safety guards (path identity snapshots, whitelists, process guards), Homebrew integration, and sudo session management. Key data flows include disk scanning with progress events and cache invalidation, system metrics collection via gopsutil and macOS commands (system_profiler, ioreg, pmset), and cleanup operations with dry-run previews and bounded timeouts. External dependencies include Homebrew (for cask detection and uninstall), macOS system commands (tmutil, plutil, diskutil, osascript), and Go modules (charmbracelet/bubbletea, lipgloss, gopsutil). The codebase emphasizes safety with fail-closed policies, identity re-verification before deletion, and extensive timeout handling. It supports both interactive TUI and non-interactive JSON output for scripting.
Micro is a terminal-based text editor written in Go, designed to be intuitive and feature-rich. It provides a full editing experience with multiple cursors, tabs, splits, syntax highlighting, undo/redo, search/replace, autocomplete, and a built-in command bar. The architecture follows a modular design with clear separation of concerns: the `internal/action` package handles keybindings and event dispatching via a trie-based key tree; `internal/buffer` manages text buffers using an efficient line array and an event-driven undo stack; `internal/display` renders the editor UI through a window abstraction that supports soft wrapping and status lines; and `internal/screen` wraps the tcell library for terminal I/O. The editor supports Lua-based plugins that hook into lifecycle events and expose Go standard library packages, enabling extensibility without recompilation. External dependencies include tcell (terminal control), gopher-lua (scripting), go-diff (diff computation), and several forked libraries for JSON5 parsing and shell quoting. The main entry point is `cmd/micro/micro.go`, which parses CLI flags, initializes configuration, loads plugins, and runs the event loop. Data flows primarily involve file I/O (reading/writing buffers), terminal input events (keyboard/mouse), and plugin callbacks. The codebase is well-tested with unit tests, generated buffer tests from VSCode model tests, and CI pipelines across platforms.
Xcodes is a command-line tool for installing, managing, and switching between multiple versions of Apple's Xcode IDE. It provides subcommands for downloading, listing, selecting, uninstalling, and updating Xcode releases, as well as managing simulator runtimes. The tool supports two data sources: scraping Apple's Developer downloads page (the 'apple' source) and consuming the unofficial Xcode Releases JSON feed ('xcodeReleases'). Authentication is handled through Apple ID with two-factor or SMS fallback, or via fastlane session cookies. The architecture is a modular Swift Package Manager project with a thin CLI entry point (using Apple's ArgumentParser) and a core library (XcodesKit) that encapsulates all business logic. The core library uses a lightweight dependency injection pattern via an Environment struct, a strategy pattern for downloads (URLSession or aria2), and a service-oriented design for runtime installation, list management, and system configuration. The codebase exhibits strong Swift concurrency adoption and includes test fixtures for parsing Apple HTML and property-list data. While the Apple scraping approach is inherently fragile, the overall architecture is well-structured, testable, and follows modern Swift best practices.
remindctl is a macOS command-line interface for Apple Reminders, built with Swift and Apple's EventKit framework. It provides a comprehensive set of commands to create, edit, complete, delete, and search reminders, manage lists, set due dates, alarms, recurrence, location triggers, and URLs. The application is structured as a modular library (RemindCore) containing the core EventKit interaction and business logic, and a CLI executable (remindctl) that uses the Commander library for command routing and argument parsing. The CLI supports multiple output formats (JSON, plain, table, quiet) and includes advanced features like fuzzy list name resolution, stable numeric indexing across reordered fetches, and a custom async timeout pattern for system operations. The codebase demonstrates strong Swift concurrency practices (async/await, actors), comprehensive unit tests, and a well-documented release pipeline with signed notarized binaries and Homebrew distribution.
This is a well-crafted Go library providing a thread-safe, highly customizable progress bar for terminal applications. It supports both determinate (known maximum) and indeterminate (spinner) modes, with features like elapsed time, predicted time remaining, byte throughput, iterations per second, and configurable themes (including ASCII, Unicode, and custom). The library is designed for ease of use with convenient constructors (Default, DefaultBytes) and a fully functional options pattern for deep customization. It is used as an io.Writer in download scenarios and includes a built-in HTTP server for external monitoring of progress state. The codebase is clean, well-tested, and follows Go best practices.
Astroterm is a terminal-based star map application written in C. It renders the real-time positions of stars, planets, the Moon, and constellation figures using ASCII or Unicode characters. The system computes celestial positions from the Yale Bright Star Catalog, Keplerian orbital elements, and user-specified date/time and location (latitude/longitude or city name). It projects the visible sky onto the terminal via a stereographic projection and uses ncurses for display and input. The build system is Meson with Ninja, supporting Linux, macOS, and Windows. The codebase is well-structured into separate modules for astronomy calculations (astro.c), coordinate transforms (coord.c), terminal rendering (drawing.c, term.c), and data parsing (parse_BSC5.c, city.c). It includes comprehensive unit tests using Unity and CI via GitHub Actions. The application is highly configurable through command-line arguments and demonstrates strong craftsmanship in astronomical computations and terminal graphics.
PM2 is a production process manager for Node.js applications with built-in load balancing, monitoring, and deployment capabilities. It keeps applications alive forever, enables zero-downtime reloads, and provides comprehensive system administration features. The architecture features a daemon-based design with CLI and programmatic APIs communicating via IPC (pm2-axon). Key capabilities include process clustering, log management, metrics collection, Docker integration, startup script generation, and a plugin system for extensibility. The codebase demonstrates strong engineering practices with internalized dependencies to reduce supply chain risk, comprehensive test coverage, and active maintenance with regular updates supporting Node.js >=18 and Bun.
ipatool is a cross-platform command-line tool that acts as an unofficial Apple App Store client. It enables searching, purchasing, and downloading iOS/iPadOS/tvOS/watchOS/visionOS/macOS applications and packages directly from Apple's servers. The tool implements Apple's private SAP authentication and signing protocol by emulating Apple's StoreAgent binary in-process using the Unicorn CPU emulator, allowing it to generate kbsync blobs and decrypt macOS packages. It also includes low-level parsers for Apple's proprietary formats (AEA encrypted archives, APFS filesystems, dyld shared caches) to extract assets from macOS restore images. The architecture is modular: a CLI layer (using cobra) dispatches to domain logic in pkg/appstore, which relies on a generic HTTP client (pkg/http), keychain storage (pkg/keychain), and platform abstractions (pkg/util). An MCP (Model Context Protocol) server subcommand exposes the same functionality over stdio. The codebase is heavily tested with unit and integration tests, and CI builds for macOS, Linux, Windows, and iOS. While primarily an application, it contains significant reverse-engineering and protocol-analysis components, giving it a hybrid character.
jc (JSON Convert) is a mature Python library and CLI tool that converts the output of over 150 command-line tools, system files, and common data formats into structured JSON. It operates both as a piped command-line utility (`jc <command>`) and as a programmable Python module (`jc.parse('parser_name', data)`), enabling seamless integration with jq, scripting, and automation pipelines. The architecture follows a consistent parser pattern: each parser module defines an `info` metadata class and a `parse(data, raw, quiet)` function, with optional `_process()` for type coercion. Streaming parsers (suffixed `_s`) use generator-based patterns for real-time output. The library includes vendored dependencies for ASN.1, plist, EDID, and TOML parsing, and supports cross-platform execution across Linux, macOS, FreeBSD, and Windows. The primary data flow is stdin or file input → parser module → structured dict/list output (JSON or YAML). Key entry points include the CLI (`jc/cli.py`), the library API (`jc/lib.py`), and individual parser modules under `jc/parsers/`. The project maintains an extensive test suite with fixtures captured from multiple OS versions, ensuring robustness against command output variations. It also provides shell completions, a plugin system for custom parsers, and documentation generation scripts. While the codebase is well-engineered with clean abstractions, the sheer number of parsers and reliance on vendored libraries introduce moderate maintenance surface area.
Argh is an opinionated derive-based argument parsing library for Rust, optimized for code size and conformance to Fuchsia CLI specifications. The repository is a multi-crate workspace: `argh` (public API, re-exports derive macros and provides runtime functions like `from_env`), `argh_derive` (proc-macro implementation of `FromArgs`, `FromArgValue`, and `ArgsInfo`), `argh_shared` (shared data structures for command metadata, used by both derive and completion crates), and `argh_complete` (generators for bash, zsh, fish, and nushell shell completions). The core architecture uses a derive macro to generate parsing code at compile time, producing minimal binary size. It supports switches, options (required, optional, repeating), positional arguments (including greedy/remainder), subcommands (static and dynamic), custom parsers via `FromArgValue`, default values, and extensive help/usage formatting with notes, examples, and error codes. The library is well-tested with unit tests, compile-fail UI tests, and integration tests. It is designed as a lightweight alternative to clap, prioritizing code size and compile-time speed.
Arduino CLI is a command-line tool and gRPC daemon for Arduino embedded development. It manages board platforms (cores), libraries, sketches, compilation, upload, monitoring, and debugging. The architecture is dual: a CLI frontend using the Cobra framework and a gRPC server (daemon mode) that exposes the same operations via protobuf-defined services. The core domain logic is organized under `internal/arduino/` with subsystems for building (preprocessor, compiler, linker, diagnostics), package management (index loading, install/uninstall, dependency resolution), sketch handling (profiles, YAML config), and hardware discovery/monitoring. External dependencies include gRPC, protobuf, Cobra/Viper for CLI, and Arduino-specific libraries for path handling, properties, serial communication, and pluggable discovery protocols. The system supports cross-platform operation (Linux, macOS, Windows) and includes extensive integration tests that exercise real CLI commands against isolated environments.
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.
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.
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).
dep is a Node.js dependency installer that provides npm-compatible install, lock, and run commands with zero runtime dependencies. It resolves dependency trees, downloads packages, verifies integrity, and links them into node_modules. The architecture is modular with separate concerns for installation, lockfile generation, and script execution. Key features include workspace support, bounded concurrency, platform/engine constraint handling, optionalDependencies, peerDependencies, bundledDependencies, overrides, and aliased specifiers. The tool is designed for end-users rather than package authors, focusing on installing, locking, and running scripts.
This repository contains a tool named `xcdiff` for comparing two Xcode project files (.xcodeproj) and outputting their differences in multiple formats. It is designed as both a command-line utility and a reusable Swift library (XCDiffCore). The tool analyzes structural and configuration differences between projects, including targets, sources, headers, resources, build settings, and dependencies. The architecture follows a modular, plugin-like design where each aspect of the project comparison is handled by a separate comparator implementing a common protocol. This allows for easy extension with new comparison types. Results are rendered through a similarly abstracted renderer system, supporting output formats such as plain text, JSON, markdown, and HTML. The tool is actively maintained and keeps pace with evolving Xcode project formats, as evidenced by fixtures for recent Xcode features like synchronized groups.