This repository is a comprehensive Rust reimplementation of the GNU coreutils, providing approximately 100 standard Unix command-line utilities (cat, cp, cut, df, du, echo, false, fmt, head, id, kill, ln, ls, mv, nl, od, ptx, pwd, rm, seq, tac, tee, tr, tty, wc, who, yes, arch, base32, base64, basenc, chmod, chroot, comm, csplit, date, dirname, dircolors, expand, expr, factor, fold, groups, hostid, hostname, install, join, link, logname, md5sum, mkdir, mkfifo, mknod, mktemp, more, nice, nohup, nproc, numfmt, paste, pathchk, pinky, pr, printenv, printf, readlink, realpath, rmdir, sha*sum, shred, shuf, sleep, sort, split, stat, stdbuf, stty, sum, sync, tail, test, timeout, touch, tr, truncate, tsort, tty, uname, unexpand, uniq, unlink, uptime, users, vdir, wc, who, whoami, yes, and more). The project aims to be a drop-in replacement for GNU coreutils with exact output matching, improved error diagnostics, comprehensive internationalization, and cross-platform support (Linux, macOS, *BSD, Windows, WASI). It has been adopted by Ubuntu starting from version 25.10. Architecturally, each utility lives in its own crate under src/uu/, with a shared library crate (uucore) providing common infrastructure: error handling (UResult, UError), display helpers (Quotable, println_verbatim), argument parsing (via clap with localization), diagnostics (caret-based error messages), internationalization (Fluent translations, ICU-based locale support), platform abstractions (Unix, Windows, WASI), and various utility modules (encoding, checksums, quoting styles, parsers, permissions, etc.). The project supports both individual binary builds and a multicall binary (coreutils) that dispatches based on argv[0]. A separate binary (uudoc) generates manpages and shell completions. Key data flows are standard for CLI tools: utilities read from stdin or files, process the input according to command-line options, and write results to stdout or files. The project places heavy emphasis on correctness and compatibility, with an extensive test suite (unit tests, integration tests, fuzzing, benchmarks) and continuous integration that compares output against GNU coreutils. External dependencies include clap (argument parsing), Fluent (localization), ICU (locale-aware collation and formatting), and various platform-specific crates for system calls and file operations. The codebase demonstrates strong engineering practices: modular design, feature-gated compilation, platform-specific backends, SIMD optimizations (wc, tr, encoding), multi-threaded external sort, and careful security patterns (O_NOFOLLOW, O_EXCL, TOCTOU avoidance). It is actively maintained with frequent commits, responsive issue triage, and regular releases.
This repository provides a Go library (`github.com/pelletier/go-toml/v2`) for reading and writing TOML documents, conforming to TOML v1.1.0. It offers a two-phase architecture: a low-level iterative AST parser in the `unstable` package, and higher-level `Marshal`/`Unmarshal` functions with configurable streaming `Encoder`/`Decoder` that support strict mode, custom marshalers, and struct tags. The library is dependency-free (only standard library) and includes three CLI tools: `tomll` (formatter), `tomljson` (TOML to JSON), and `jsontoml` (JSON to TOML). The codebase demonstrates strong engineering practices: pooled encoder/decoder states, cached struct plans via `sync.Map`, word-at-a-time scanning for performance, a fused generic decode path, and comprehensive test coverage including auto-generated conformance tests from the upstream toml-test suite. It also includes an experimental document-editing package (`unstable/edit`) that preserves comments and layout via byte-range indexing and splice-based mutations.
Mutagen is a mature, comprehensive Python library for reading and writing audio metadata across virtually all common formats, including MP3 (ID3v1/v2, APEv2), FLAC, Ogg Vorbis/Opus/Speex/Theora, MP4/M4A, ASF/WMA, WavPack, AIFF, DSF, DSDIFF, True Audio, Musepack, Monkey's Audio, OptimFROG, AAC, AC3, and more. It provides a consistent dictionary-like API for tag manipulation, format-specific stream info (bitrate, sample rate, channels, length), and low-level access to container structures (Ogg pages, ID3 frames, IFF chunks, MP4 atoms). The library is designed for embedding in larger applications (e.g., Quod Libet, Beets, MusicBrainz Picard) and also ships several command-line tools: mid3v2 (ID3 tag editor), mid3iconv (ID3 encoding converter), mid3cp (ID3 tag copier), moggsplit (Ogg stream splitter), mutagen-inspect (format inspector), and mutagen-pony (ID3 health checker). Architecturally, Mutagen follows a layered design: a base `FileType` class with format detection via static `score()` methods, per-format modules that parse container headers and metadata, and a shared utility layer (`_util.py`) providing file I/O decorators, binary packing/unpacking (`cdata`), bit-level readers, dictionary mixins, and padding management. The ID3 subsystem is particularly sophisticated, with a declarative frame specification system (`_specs.py`) that handles encoding, version conversion, and unsynchronization. The Ogg subsystem provides a clean `OggPage` abstraction reused by all Ogg-based formats. The IFF subsystem (`_iff.py`) generalizes chunk-based containers for AIFF, RIFF/WAVE, and DSDIFF. Data flows are straightforward: the user opens a file via `mutagen.File()` or a format-specific constructor, which triggers header parsing and tag loading. Tags are exposed as mutable dictionaries; saving writes updated metadata back to the file with configurable padding. The library supports file-like objects and pathlib paths throughout. External dependencies are minimal (pure Python, no runtime dependencies beyond the standard library), making it highly portable. The test suite includes over 3000 tests, fuzzing infrastructure, and a large corpus of synthetic audio fixtures covering edge cases and malformed inputs.
CodExt is a Python library and command-line tool that extends the standard library's codecs with over 120 custom encodings for data transformation. It provides encoding/decoding functionalities across domains including base encodings (baseN, base45, base85, etc.), cryptography (Vigenère, RSA, XOR), compression (gzip, LZ77/LZ78), steganography, and language-based transformations (Leetspeak, Morse, Braille). The system features a heuristic-based guess mode for automated multi-layered decoding and a macro system for chaining codecs. Architected as a plugin-based library, it allows dynamic registration of new codecs and is designed for CTF, security, and data obfuscation tasks. The codebase demonstrates strong modularity with clear separation of concerns between core functionality, codec implementations, and utility modules.
This repository is a Homebrew tap for distributing OpenClaw's CLI tools (19 formulae and one migrated cask). It provides automated formula update and reconciliation workflows triggered by GitHub releases or periodic schedules. The core automation is implemented in Python scripts under `.github/scripts/`: `formula_text.py` is a pure parser/renderer for Homebrew formula Ruby text, `update_formula.py` handles downloading release assets, verifying checksums, and writing updated formulae, and `reconcile_formulae.py` periodically checks for newer stable releases and updates formulae accordingly. The tap includes comprehensive CI workflows that validate formula syntax, run Homebrew style checks, and perform platform-specific install tests on macOS ARM64/x86_64 and Linux x86_64. The codebase is well-structured, with clear separation between text manipulation, network operations, and orchestration. The automation scripts are robust, with input validation, timeout handling, and secure dispatch constraints. The formulae themselves are standard Homebrew formulae with architecture-specific URLs and checksums. The repository demonstrates high craftsmanship in its automation layer, particularly the `formula_text.py` module which could be extracted and reused in other projects needing to programmatically manipulate Homebrew formula files.
Rainbow is a zero-runtime-dependency Swift library that applies ANSI escape sequences to strings for colored terminal output. It supports the named 16-color palette plus light variants, 8-bit 256-color mode (38;5;N), 24-bit true color (38;2;R;G;B), hex colors approximated to the nearest 256-color cube, HSL colors converted to RGB, and styles (bold, dim, italic, underline, blink, swap, strikethrough). Output is gated by OutputTarget detection that checks isatty() on POSIX/Windows plus NO_COLOR/FORCE_COLOR environment variables, so redirected output degrades to plain text automatically.
This repository provides reproducible Nix packaging for a collection of CLI tools (summarize, discrawl, wacrawl, gogcli, goplaces, camsnap, sonoscli, peekaboo, poltergeist, sag, imsg, qmd) used in the OpenClaw ecosystem. It includes per-tool OpenClaw plugin metadata (skills) that teach AI agents how to use each tool. The repo features automated update workflows: a Go-based tool updater (`cmd/update-tools`) that fetches latest GitHub releases and updates Nix expressions with new versions and hashes, and a skill syncer (`cmd/sync-skills`) that pulls the latest skill definitions from upstream OpenClaw repositories. The Go code demonstrates solid engineering with proper timeout handling, process group management, atomic file updates, and comprehensive tests. The Nix expressions are well-structured, supporting multiple platforms (aarch64-darwin, x86_64-linux, aarch64-linux) and using pinned nixpkgs inputs for reproducibility. CI runs formatting checks, vetting, tests with race detector, and builds all packages on supported systems. The repository is actively maintained with frequent commits and automated CI runs.
MacosUseSDK is a Swift library and collection of command-line tools for macOS accessibility automation. It enables traversing application accessibility trees to inspect UI elements, simulating user input (mouse/keyboard), opening applications, and providing visual feedback for debugging. The architecture centers around a core library with specialized modules for traversal, input simulation, visual feedback, and action orchestration, with six CLI tools exposing different subsets of functionality. Primary use cases include UI testing, accessibility verification, and automated interaction with macOS applications.
This repository is a curated collection of 177+ domain-specific scientific 'skills' for AI agents, following the Agent Skills standard. Each skill is a self-contained module providing a CLI tool, documentation, and tests for a specific scientific or technical task—ranging from single-cell RNA-seq analysis (scanpy) and molecular docking (diffdock) to clinical report validation and ISO standards readiness. The architecture is a monorepo of independent skills, each with its own scripts/, references/, assets/, and tests/. Skills are designed to be safe, bounded, and reproducible: they validate inputs before execution, enforce resource limits, avoid network access unless explicitly required, and produce structured JSON reports. The repository also includes a shared test infrastructure (skill_contract) and a meta-skill (autoskill) that can automatically propose new skills from screen activity. While primarily an application library for AI agents, it has strong data/research characteristics due to its heavy use of scientific data formats and validation of research artifacts.
This repository is a monorepo of 'skills' for the Minis AI assistant platform, designed to extend the assistant's capabilities with domain-specific workflows, API integrations, and automation scripts. Each skill is a self-contained directory with a SKILL.md (instruction set for the AI), executable scripts (Python/shell), reference documentation, and evaluation test cases. The skills cover a wide range of tasks: social media management (Weibo, Twitter/X, Xiaohongshu, Telegram, Bilibili), media processing (YouTube downloader, PDF conversion, TTS, image generation), financial data retrieval (US/Korea/China stocks, fund flows), productivity (Notion API, todoocard e-paper, whenpeak energy prediction), video composition (HyperFrames framework), and system utilities (Android dev environment, Cloudflare DNS, qBittorrent). The architecture is modular and agent-driven: the AI selects a skill based on user intent, reads its SKILL.md, and invokes the provided scripts via shell_execute. Output is typically JSON for machine consumption. The codebase demonstrates strong engineering practices with structured skill definitions, evaluation frameworks, and reusable patterns like cookie-based auth, SQLite message stores, and deterministic animation analysis. However, many skills depend on reverse-engineered or unofficial APIs, hardcoded paths tied to the Minis iOS environment, and external tools (ffmpeg, pandoc, typst), introducing maintenance and portability risks.
FreeMote is a Windows-oriented .NET Framework 4.8 toolchain for reverse-engineering, decompiling, converting, rendering, and rebuilding E-mote (EMT) PSB game asset packages. It is primarily an application suite rather than a data/research project: five CLI tools (EmtConvert, PsbDecompile, PsBuild, EmtMake, FontBuilder-related commands) plus a WPF viewer provide user-facing workflows, while the core libraries FreeMote, FreeMote.Psb, and FreeMote.PsBuild implement binary parsing, encryption, plugin dispatch, compilation/decompilation, and platform conversion. The architecture is modular: FreeMote handles low-level container and crypto primitives, FreeMote.Psb provides the PSB object model and plugin interfaces, FreeMote.PsBuild handles JSON/PSB conversion and E-mote project generation, and FreeMote.Plugins supplies compressors, image/audio codecs, and shell handlers through MEF composition. The primary data flow is file-in/file-out: encrypted or shell-wrapped PSB containers are opened through FreeMount plugin composition, decrypted or unpacked into an in-memory PSB object graph, decompiled to JSON plus extracted resources, then optionally recompiled, re-encrypted, and packed back into shells. The reverse pipeline also supports building PSB from JSON, generating bitmap fonts, porting between Kirikiri/Windows/common/console specifications, converting motion PSB into MMO editor projects, and extracting textures/audio from archives. The code embodies deep reverse-engineering knowledge: PSB versions 1-4, trie-compressed name tables, XorShift128/MT19937 cipher handling, MDF/LZ4/Zlib shells, ASTC/BC7/DXT/TLG pixel formats, and console-specific texture swizzling. Although the repo contains research-grade format analysis, its dominant character is an application toolkit for game modding. It is actively maintained with CI packaging, tests, and a plugin ecosystem, but carries medium technical drift: legacy .NET Framework and System.Drawing dependencies, Direct3D9 interop in the viewer, reliance on external executables for some audio/image encoders, hard-coded platform heuristics, and a large monolithic Psb.cs with TODO debt. The most reusable assets are self-contained texture utilities and the generic plugin/composition pattern, not the tightly coupled PSB-specific pipeline components.
mpiFileUtils is a suite of MPI-based command-line tools for managing large datasets on parallel file systems (Lustre, DAOS, GPFS, NFS). It provides parallel equivalents of common file operations: dcp (copy), dsync (sync), drm (remove), dcmp (compare), dtar (archive), dfind (find), dchmod (chmod), dbcast (broadcast), ddup (dedup), and others. The tools are built atop a common library (libmfu) that implements a distributed file list (mfu_flist) with collective operations, path manipulation, I/O wrappers with retry logic, progress reporting, and work distribution via libcircle. The architecture follows a walk->filter->act pattern where the file system is traversed in parallel, metadata is aggregated into a distributed list, and work is distributed across MPI ranks. The tools are designed for high-throughput operations on millions of files and are used in HPC environments. While the codebase shows signs of legacy (dcp1, Python 2 tests), it is actively maintained and includes advanced features like DAOS object-level copy and tar indexing for parallel extraction. The repository is primarily an application (CLI tool suite) with a strong library component (libmfu) that could be reused in other HPC data-movement projects.
MQTT-SN Tools is a suite of four command-line applications for working with the MQTT-SN (MQTT for Sensor Networks) protocol. The system provides mqtt-sn-pub for publishing messages, mqtt-sn-sub for subscribing to topics, mqtt-sn-dump for monitoring packets, and mqtt-sn-serial-bridge for serial-to-UDP bridging. All tools share a common C library (mqtt-sn.c/h) that implements the MQTT-SN protocol handling, including socket management, packet encoding/decoding, keep-alive mechanics, and topic mapping. The architecture is modular with clear separation between the protocol library and application-specific logic. Each tool follows a standard pattern: parse command-line arguments, establish UDP connection to an MQTT-SN broker, perform protocol operations (connect, publish/subscribe, etc.), handle incoming/outgoing packets, and clean up resources. The project has active maintenance with recent commits and a test suite.
This repository is a comprehensive, structured library of over 50 marketing 'skills' designed for AI coding agents (Claude Code, Codex, Cursor, etc.). Each skill is a self-contained directory with a SKILL.md (frontmatter + workflow), a references/ folder with deep-dive documentation and benchmarks, and evals/evals.json for behavioral testing. The skills cover the full marketing lifecycle: copywriting, SEO, paid ads (Meta, Google, LinkedIn), email, social, CRO, pricing, offers, attribution, market research, and more. Additionally, the repository includes 40+ zero-dependency Node.js CLI scripts that act as API clients for marketing tools like Ahrefs, Semrush, GA4, Meta Ads, Mailchimp, etc., each following a consistent pattern with dry-run support and environment variable authentication. Several integration guides and a central tool registry (REGISTRY.md) complete the ecosystem. While primarily a content library, the CLI scripts and validation/sync tooling demonstrate strong engineering patterns. The skills are designed to be consumed by AI agents to execute complex, multi-step marketing tasks, with cross-skill references and a shared context document (product-marketing.md) enabling orchestration.
SWFTools is a collection of command-line utilities and libraries for creating, converting, and manipulating Adobe Flash (SWF) files. The core functionality includes converting PDF, images (JPEG, PNG, GIF), audio (WAV, MP3), and video (AVI) into SWF format, as well as extracting and analyzing SWF content. The architecture is modular, built around an abstract graphics device interface (gfxdevice_t) that allows rendering to multiple backends (SWF, PDF, OpenGL, text, bitmap), and a corresponding source interface (gfxsource_t) for reading different input formats. The codebase is predominantly C with some C++ and Python components, and includes a full ActionScript 3 compiler, MP3 encoders (LAME and BladeEnc), a polygon boolean operations library, and a 2D antialiased rendering engine (Libart). A wxPython GUI provides a graphical frontend for PDF-to-SWF conversion. While the project is functionally complete and demonstrates strong engineering in areas like device abstraction and computational geometry, it is heavily tied to the now-deprecated Flash platform and bundles several outdated third-party libraries, resulting in high technical drift.
This repository is a curated list of command-line tools, designed to help users discover and evaluate CLI utilities for various tasks. It does not contain any executable code or application logic; instead, it serves as a static reference document hosted on GitHub. The main content resides in `readme.md`, which organizes tools into categories such as CSV, File System, Git, Networking, and Programming Languages, each with links to the tools' source repositories and concise descriptions. Contribution guidelines are provided in `contributing.md` to maintain the list's quality and consistency. The repository uses shields.io badges to display metadata like the license and links to related curated lists. Although the repository lacks reusable software components or architectural patterns due to its static nature, it is well-maintained with recent commits and active issue tracking. It exhibits low technical drift as it has no code dependencies to become outdated. As a reference resource, it effectively fulfills its goal of aggregating CLI tools, though it does not demonstrate notable software engineering craftsmanship.