This repository provides the Nerd Fonts project, a CLI tool and collection of scripts that patch popular developer fonts with a large set of icon glyphs (including Font Awesome, Devicons, Octicons, Material Design Icons, and many more). The core entry point is the `font-patcher` Python script, which uses FontForge to merge icon glyphs into existing monospace fonts. Supporting scripts handle font name parsing, CSS generation, fontconfig configuration, release automation, and testing. The repository also contains pre-patched fonts in `patched-fonts/` and the raw icon sources in `src/glyphs/`. It is a mature, widely-used tool with active maintenance and a large community.
CloudflareSpeedTest is a CLI tool written in Go that measures latency and download speed of Cloudflare CDN IP addresses to find the fastest ones for users in China, where many Cloudflare IPs are suboptimal. It reads IP ranges from files (ip.txt/ipv6.txt) or command-line arguments, performs concurrent TCP or HTTP ping tests, filters results by latency/loss rate, then conducts HTTP download speed tests on the lowest-latency IPs. The final output is a sorted list of the best IPs displayed in the console and saved to a CSV file. The tool supports extensive customization: thread count, ping count, port, download test duration, speed/latency thresholds, colocation filtering via HTTP headers, and debug logging. It also includes helper scripts for automatically updating system hosts files, 3proxy configurations, or Cloudflare DNS records with the optimal IP. The architecture is a single binary with modular task files (tcping, httping, download, ip parsing) and utility modules (color output, CSV export, progress bar). External dependencies are minimal: ewma for moving average, pb for progress bars, and color for terminal colors. The codebase is well-structured with clear separation of concerns, though it lacks automated tests and CI pipelines. It is a practical, community-driven tool with over 29k stars, actively maintained with recent commits and responsive issue triage.
Flyway is a database migration tool that applies version-controlled SQL scripts to manage schema changes across 50+ database engines (relational and NoSQL). It operates as a Java library, CLI, Maven/Gradle plugin, and Docker image. The core architecture centers on a plugin system where `DatabaseType`, `VerbExtension`, `ConfigurationExtension`, and `Callback` implementations are discovered via Java ServiceLoader. The migration lifecycle is orchestrated by `FlywayExectutor`: it resolves migration scripts (SQL or Java), validates them against a schema history table, applies pending migrations in transaction-aware batches, and registers the result. Telemetry and license enforcement are woven into execution. The codebase is large but well-organised into modules: `flyway-core` for the engine, `flyway-commandline` for the CLI, `flyway-database-*` for per-database parsers and connections, `flyway-nc` for a dual native-connector path, and `flyway-reports` for output generation. External dependencies include JDBC drivers, AWS SDK (S3), and third-party helpers like SQLFluff (via Docker). Key entry points are the `Flyway` API class, the `Main` CLI class, and the `VerbExtension` implementations.
NetEase-MusicBox is a Python 3.10+ terminal client for NetEase Cloud Music (music.163.com), sold as the `musicbox` command. It is a hybrid application: an interactive curses TUI, an agent-facing stateless CLI, and a resident background daemon (`musicboxd`) that owns playback state. The TUI and daemon are mutually exclusive via a flock single-owner lock; control commands reach the daemon over a 0600-permission Unix domain socket using newline-delimited JSON-RPC. Audio plays through subprocess backends (mpg123 for MP3, mpv for FLAC/hi-res with IPC seek/volume control), and all NetEase API access goes through reverse-engineered weapi/eapi encryption (RSA+AES and AES-ECB with PKCS7/gzip handling). Login is QR-code scan only; session cookies and player state persist to XDG-compliant JSON/text files.
objection is a runtime mobile exploration toolkit powered by Frida, designed for security testing of iOS and Android applications without requiring jailbreak or root access. It provides an interactive REPL (objection explore) that lets security researchers bypass SSL pinning, dump keychain/keystore data, monitor cryptographic operations, inspect heap memory, hook methods, and bypass jailbreak/root detection — all by injecting a Frida agent into the target process. Architecture: The Python backend handles CLI commands, device state management, and patching (injecting Frida gadget into IPA/APK files). The TypeScript agent running inside the mobile app exports RPC methods for platform-specific features (Android: hooking, keystore, intents; iOS: keychain, crypto, biometrics). Communication happens over Frida's bi-directional transport. A Flask API server exposes RPC and script endpoints for remote control. The system uses a centralized state layer (connection, device, jobs) and a plugin system for extensibility. Key entry points: 'objection explore' (REPL), 'objection patchapk'/'objection patchipa' (binary patching), 'objection api' (API server), and the agent entry point in 'agent/src/index.ts'. External dependencies include frida, frida-tools, frida-fs, frida-screenshot, Flask, apktool, and GitHub API for gadget downloads. The codebase is well-structured for mobile security automation but shows some drift with deprecated CLI flags, Python 2 compatibility checks, and TODOs for advanced hooking targets.
iperf3 is a mature, widely-deployed network bandwidth measurement tool developed by ESnet/LBNL. It measures maximum achievable throughput on IP networks using TCP, UDP, and SCTP, and provides detailed per-interval statistics including jitter, packet loss, retransmits, congestion window, and CPU utilization. The tool operates as a client-server application with a control channel for parameter exchange and data channels for bulk transfer, supporting parallel streams, reverse mode, bidirectional tests, and various pacing/affinity options. The codebase is written in C and built with GNU Autotools (autoconf, automake, libtool). It exposes a public library API (libiperf) that allows embedding iperf functionality into other programs, demonstrated by minimal examples in the examples/ directory. The architecture follows a protocol vtable pattern (struct protocol) for pluggable transport protocols, a callback system for test lifecycle events, and a timer subsystem for pacing and reporting intervals. JSON output is generated via a vendored cJSON library. Key strengths include its cross-platform support (Linux, FreeBSD, macOS, and others via #ifdef), extensive command-line options, and integration with perfSONAR for research and education networks. However, the codebase shows signs of organic growth: large monolithic files (iperf_api.c ~3000 lines), platform-specific #ifdef sprawl, manual release test scripts, and some unresolved TODOs. Security advisories have been issued for past vulnerabilities, and the authentication module uses OpenSSL RSA with multiple padding modes. Overall, iperf3 is a high-quality, production-grade tool with a few areas of technical debt.
Opensquad is a multi-agent orchestration framework that enables users to create, manage, and run teams of AI agents (squads) for automated content workflows. The system is primarily a CLI tool (`npx opensquad init`) that bootstraps projects with agent definitions, pipeline configurations, and IDE integrations. It includes a Phaser-based 2D dashboard that visualizes agents working in a virtual office, updated in real-time via WebSocket. The architecture is file-based: squads are defined as YAML/Markdown files in `squads/`, pipelines as step sequences with bash validation gates, and skills as self-contained directories with `SKILL.md` manifests. The framework supports multiple content formats (Instagram carousels, blog posts, email newsletters) through a best-practices catalog and platform-specific Sherlock investigators that extract real engagement data from social media profiles. Key entry points include `bin/opensquad.js` (CLI dispatcher), `src/init.js` (project initialization), `src/update.js` (core file updates), `src/skills.js` (skill registry management), and `src/agents.js` (agent management). The dashboard is a React + Vite app with a Phaser scene (`OfficeScene.ts`) that renders pixel-art sprites and desks. External dependencies include Node.js 20+, Playwright (for browser automation and image rendering), and various MCP services (Apify, Canva, Blotato, Resend). The system is designed for non-technical users and emphasizes zero-config setup, progressive disclosure of complexity, and token-efficient phased execution (discovery → investigation → design → build).
This repository is a production-grade CLI application (`mcp-cli`) for interacting with the Model Context Protocol (MCP). It serves as an orchestration layer over MCP servers and Large Language Models (LLMs), providing a unified interface across chat, interactive shell, and scriptable command modes. The architecture is a monolithic Python application built on the `chuk-*` ecosystem, featuring a sophisticated unified command system, a streaming display manager, a WebSocket-based dashboard, multi-agent orchestration, and a planning subsystem for autonomous tool execution. It manages the full lifecycle of MCP server connections, tool discovery/execution, LLM provider abstraction, and session persistence. The codebase demonstrates high craftsmanship through its extensive use of Pydantic models for type safety, a well-isolated command pattern, and security-conscious utilities for SSRF protection and secret redaction. Key reusable components include the unified command framework (`UnifiedCommand`, `CommandRegistry`), the streaming display manager with content-type detection, and the `McpToolBackend` adapter that bridges planning systems to tool execution with guard integration. The project is actively maintained with a large test suite, though its heavy coupling to the `chuk-*` library ecosystem and cutting-edge Python version (3.14) represent notable technical dependencies.
nbconvert is a mature, actively maintained CLI tool and Python library for converting Jupyter Notebooks (.ipynb) into a wide variety of static formats, including HTML, LaTeX, PDF, Markdown, reStructuredText, AsciiDoc, slides (Reveal.js), executable scripts, and even back to notebook format. The architecture is a pipeline: a notebook is first processed by a chain of configurable preprocessors (e.g., for executing code, removing tags, extracting attachments, converting SVG to PDF), then rendered through Jinja2 templates into the target format, and finally written to disk or stdout via a writer, with optional post-processing (e.g., serving slides). The system is highly extensible via Python entry points for custom exporters, preprocessors, and templates, and all components are configurable through traitlets, enabling both programmatic and command-line use. The codebase is well-structured with clear separation of concerns: exporters (base, template-based, and format-specific), preprocessors (over a dozen), filters (for Jinja2 templates), writers, and postprocessors. The template system supports inheritance and custom syntax for LaTeX. Notable implementation highlights include a custom Markdown parser with LaTeX math support (handling both Mistune v2 and v3), ANSI-to-HTML/LaTeX conversion, SVG-to-PDF conversion with security hardening, and a context manager for directory changes. The test suite is extensive, covering exporters, filters, preprocessors, and the CLI application, with CI testing across multiple Python versions and platforms. While the core functionality is robust, the codebase shows signs of technical drift: some modules are deprecated (e.g., lexers.py), external tool dependencies (pandoc, Inkscape, Playwright) introduce version-specific behavior, and the template system has accumulated complexity with multiple inheritance chains and legacy compatibility paths. The project is actively maintained with recent security fixes and releases, but the breadth of supported formats and external dependencies creates ongoing maintenance overhead.
fastmod is a high-performance CLI tool for large-scale codebase refactoring, designed as a faster replacement for the original codemod. It recursively searches files in a directory tree using the `ignore` and `grep` crates (the same underlying libraries as ripgrep), applies regex-based substitutions, and presents diffs for interactive review or accepts all changes automatically. The tool supports multiline regex, glob/extension filtering, case-insensitive matching, fixed-string mode, external diff tools, and hidden/ignored file traversal. The architecture is a single Rust binary with two source files: `main.rs` containing all core logic (argument parsing, file walking, patching, and interactive prompts) and `terminal.rs` wrapping `crossterm` for terminal color and clearing. Execution can be either interactive (user reviews each diff) or fast (batch apply with optional `--accept-all`). The code is well-structured, leverages parallelism via `ignore::WalkParallel`, and includes a suite of integration tests. It does not expose a library API; all functionality is encapsulated in the binary.
Pipelight is a Rust-based CLI tool for defining and running automation pipelines. It allows users to create pipelines using TOML, YAML, HCL, or TypeScript configurations, trigger them via git hooks or file system changes, and monitor their execution. The architecture follows a modular design with separate crates for CLI parsing, workflow execution, configuration casting, process management, and utilities. Key features include process detachment for background execution, output capture for post-execution inspection, git hook integration, and file watching capabilities. The project demonstrates strong engineering practices with comprehensive error handling, cross-platform considerations, and thoughtful UX design for terminal interactions.
This repository contains a comprehensive hardware diagnostic and benchmarking tool implemented as a single bash script (hardware.sh). The tool collects detailed system information including OS, virtualization, motherboard, CPU, GPU, memory, and storage devices. It runs performance benchmarks using sysbench, fio, and Geekbench5 to evaluate hardware quality, presenting results in a formatted terminal interface with optional JSON output for further analysis. The script features robust dependency handling, automatic installation of missing tools, and cross-platform support for numerous Linux distributions. It demonstrates strong bash scripting practices with sophisticated progress bars, intelligent fallback mechanisms for network services, and modular design for gathering diverse system metrics.
The `av` CLI tool manages stacked Git branches and their associated GitHub pull requests in an automated workflow. It allows developers to create dependent branches, automatically rebase child branches when parents change, synchronize local state with GitHub (fetches, pushes, prunes merged branches), and interactively reorder or squash commits across a stack. The system uses a local JSON file database (`av.db`) to persist branch metadata and PR associations, a GraphQL client to communicate with GitHub, and a Bubbletea-based terminal UI for interactive prompts and progress spinners. It consists of Cobra command definitions, a git operations wrapper (mix of `go-git` and direct exec), and a state-machine sequencer for multi-step rebase operations with conflict handling. The architecture is modular with clear separation between git operations, GitHub API, state management, and user interface, making it a solid example of a domain-specific developer tool.
BittyTax is a Python CLI application suite for computing UK cryptocurrency tax liabilities. It consists of three console tools: bittytax_conv normalizes raw CSV/XLSX exports from approximately 80 exchanges, wallets, block explorers and accounting platforms into standardized transaction records; bittytax applies HMRC rules such as same-day matching, bed-and-breakfast, Section 104 pooling, and ten-day matching for companies, then generates PDF/Excel/console reports for capital gains, income, margin trading, holdings, and audit; bittytax_price fetches historical and latest asset prices from CoinGecko, CoinPaprika, CoinStats, Frankfurter, and BittyTaxAPI with local JSON caching. The repository is fundamentally an application rather than a data-research project: it exposes CLI entry points, has a plugin-based parser architecture, config-driven behavior, test suites, and CI pipelines, while the data-heavy parser and price modules are application subsystems rather than analytical pipelines.
This repository provides a standalone shell script for backing up Jenkins home directories. The script archives critical Jenkins configuration including XML files, plugins, user data, secrets, nodes, and job definitions with special handling for CloudBees Folder plugin and jobs containing spaces in their names. It operates as a CLI tool with zero external dependencies beyond standard Unix utilities (bash, find, cp, tar). The implementation demonstrates robust filesystem traversal techniques, proper handling of edge cases (empty directories, special characters in filenames), and recursive backup of nested folder structures. The script is designed to be portable across Linux distributions and includes comprehensive test coverage using Docker and Serverspec to validate functionality across multiple environments.
Ruplacer is a command-line tool written in Rust for finding and replacing text in files. It supports literal string, regex, and case-preserving replacements, and provides a diff-like output of changes. The tool respects .gitignore, allows filtering by file type, and can operate in a dry-run mode. The architecture is modular, with separate modules for argument parsing, console output, directory traversal, file processing, and the core replacement logic. The replacement logic is particularly notable for its use of the strategy pattern to handle different matching algorithms in a uniform way.
This repository provides an agent skill for attaching before/after screenshots and screen recordings to GitHub pull request descriptions. The core product is `skill/SKILL.md`, which instructs AI agents (like Claude Code) on a workflow: capture media using `agent-browser`, format them with the bundled zero-dependency script `skill/scripts/format.mjs`, and publish via `gh --attach`. The formatter generates deterministic markdown tables with image or video comparisons, and performs idempotent replacement of a marked block (`<!-- before-and-after:start/end -->`) in PR bodies, preserving all unrelated prose. The repository also includes a comprehensive verification suite (unit tests, local browser smoke, live GitHub smoke, and an agent smoke test) and a Next.js landing page at `site/`. The architecture is minimal: one dependency-free script, one skill document, and verification infrastructure. It does not wrap browser automation, capture, or media hosting—those are delegated to `agent-browser` and GitHub CLI.
This repository is a toolkit for creating and publishing WeChat Official Account articles. It consists of four main tools: WeChat Article Formatter (converts Markdown to WeChat-compatible HTML with themes), WeChat Draft Publisher (publishes articles to WeChat draft accounts with token management and image upload), WeChat Tech Writer (AI-assisted technical writing), and WeChat Product Manager Writer (AI writing from a product perspective). The system takes Markdown content, formats it for WeChat's specific constraints, and publishes it to WeChat Official Accounts. The architecture is modular with each tool as a separate skill containing its own scripts, templates, and documentation.
This is a monorepo housing `create-uni`, a CLI scaffolding tool for quickly generating `uni-app` projects. `uni-app` is a cross-platform framework based on Vue, allowing development for iOS, Android, Web, and various mini-programs. The CLI supports interactive prompts (via `@clack/prompts`), command-line flags, a native desktop GUI (via a Rust `napi-rs` addon encapsulating `wry`), and an MCP (Model Context Protocol) server for AI-assisted project creation. The core package (`packages/core`) handles template rendering using EJS with a callback-driven data injection pattern, while `packages/config` provides the option catalogues. The GUI package combines a Rust webview with a Preact/TypeScript UI (built with shadcn/ui). The MCP package exposes two tools (`create-with-template`, `create-custom`) with Zod schemas auto-derived from config data. The project demonstrates strong architectural separation, modern tooling, and a novel integration of a native GUI into a Node.js CLI. Though tightly focused on the uni-app ecosystem, several internal patterns (template rendering, object merging, directory traversal, MCP server setup) are cleanly implemented and potentially reusable.
This repository is the central configuration and tooling hub for managing Kubernetes GitHub organizations (kubernetes, kubernetes-sigs, etcd-io, etc.). It contains YAML files defining org members, teams, and repository permissions, along with a suite of Go CLI tools (korg, merge, restrictions) that validate, merge, and apply these configurations to GitHub via the peribolos tool. The system also includes an audit command that cross-references org membership against contribution data from devstats to identify inactive members. While the code is functional and well-tested, it is tightly coupled to the Kubernetes community's specific organizational structure and toolchain, limiting direct reusability outside that context.