git-backup is a CLI tool written in Go that backs up all Git repositories from GitHub and GitHub Enterprise (including GitLab) to local storage. It uses the go-git library to perform bare or non-bare clones without requiring the git CLI. The configuration is driven by a YAML file that supports Go templating for environment variable injection. The tool discovers repositories via the provider APIs using configurable filters (owned, starred, collaborator, org member) and excludes specific repos or namespaces. Pagination is handled automatically. It supports Docker deployment with UID/GID mapping. The code is well-structured with clear separation of providers (GitHub, GitLab) behind a common RepositorySource interface. It is a focused, standalone backup solution that does not require external dependencies beyond the binary itself.
gd-plug is a plugin manager for Godot 4.x, inspired by vim-plug. It provides a command-line interface to install, update, and uninstall Godot plugins (Git repositories) based on declarations in a `plug.gd` configuration file. The tool supports parallel operations, version freezing (by branch, tag, or commit), development vs. production modes, and clean uninstallation. The architecture centers around a single script (`plug.gd`) that extends Godot's SceneTree, processing command-line arguments and managing plugin lifecycle through Git operations and file system manipulations. Key features include dependency tracking via a local configuration file, threaded parallelism for efficient operations, and robust file handling with safety checks to prevent overwriting user files.
psc is a CLI tool that uses eBPF iterators to scan processes and file descriptors with Google CEL for filtering. It provides container context for processes by integrating with Docker, containerd, CRI-O, and Podman runtimes. The architecture is modular with separate packages for BPF data unmarshaling, container management, CEL filtering, and output formatting (table/tree). Key strengths include its efficient kernel-level access via eBPF, expressive CEL-based filtering, and intelligent container context propagation to child processes.
Plater is a 3D printer parts placer and optimizer that takes STL files and configuration parameters to generate optimized print plates. It uses a heuristic based on greedy algorithm with brute force to arrange parts on print plates, minimizing the number of plates needed. The system features both a Qt-based GUI for interactive use and a command-line interface for automation. The architecture cleanly separates the core placement algorithm (in the plater/ library) from the user interface (in gui/), with the core library handling STL parsing, bitmap-based part representation, and the optimization algorithm. The placement algorithm pixelizes parts into bitmaps, applies spacing through dilation, and uses a gravity-inspired scoring system to position parts, running multiple iterations with different parameters to find the optimal solution.
spogo is a terminal-based Spotify client written in Go that provides full control over playback, library management, search, and user listening data. It authenticates via browser cookies (sp_dc/sp_t) instead of the official OAuth flow, allowing it to bypass rate limits by using Spotify's internal web API endpoints (Connect/GraphQL) alongside the public Web API. The architecture is modular with multiple engine backends (connect, web, auto, applescript) and a clean CLI interface built with Kong. It features robust output formatting (human, JSON, plain), comprehensive error handling with documented exit codes, and extensive test coverage. While the tool is highly functional and well-crafted, its reliance on undocumented internal Spotify APIs and webpack hash resolution introduces fragility that may require maintenance as Spotify's frontend evolves.
top4grep is a command-line tool for searching academic papers from four top security conferences (NDSS, IEEE S&P, USENIX, CCS). It builds a local SQLite database by querying DBLP via SPARQL and optionally scraping abstracts from publisher websites. The tool supports keyword-based querying with stemming for fuzzy matching and sorts results by year and conference precedence. The architecture separates concerns into distinct modules: database operations (__main__.py, db.py, build_db.py), abstract extraction (abstract.py), and utilities (utils.py). The code demonstrates good practices like SQLAlchemy ORM usage, context managers for resource handling, and the Template Method pattern for conference-specific abstract extraction.
O! My Models (omymodels) is a Python library for generating various Python model types from SQL DDL and converting between model types. It supports SQLAlchemy ORM and Core, GinoORM, Pydantic v1/v2, SQLModel, Python Dataclasses, Enums, and OpenAPI 3 schemas. The architecture follows a pipeline: SQL DDL parsing → normalization → type conversion → model generation → Jinja2 template rendering. Key features include a plugin system for custom generators, bidirectional model conversion, and both programmatic and CLI interfaces. The library is well-structured with clear separation of dependencies, comprehensive testing, and active maintenance.
svg-sprite is a mature Node.js library and CLI tool for generating SVG sprites from individual SVG files. It supports five output modes (css, view, defs, symbol, stack) and produces accompanying stylesheets (CSS, SCSS, LESS, Stylus) via Mustache templates. The system processes SVGs through a queue-based pipeline that includes SVGO optimization, dimension calculation, namespace handling, and layout algorithms (including a bin-packing algorithm for compact sprites). It is configuration-driven with YAML/JSON support for meta data, alignment, and shape transformations. The codebase is modular with clear separation of concerns: shape processing, sprite layout, mode-specific rendering, and utility functions. It includes a comprehensive test suite with snapshot tests and visual regression testing using Playwright. While the library is actively maintained and well-structured, it carries some technical debt from older JavaScript patterns and a large dependency footprint. The packer algorithm and queue-based processing are standout reusable components.
This is a CLI tool for installing multiple Ruby implementations (CRuby, JRuby, TruffleRuby, mruby) from source. It auto-detects the operating system, package manager, and downloader, then downloads, verifies checksums, applies patches, compiles, and installs the Ruby. The architecture is a collection of sourced bash scripts organized into a plugin system: each Ruby implementation has its own `functions.sh` and `dependencies.sh` that override generic steps. The main entry point is `bin/ruby-install`, which orchestrates the process using utility functions from `share/ruby-install/`. The codebase is well-structured with extensive test coverage using shunit2, and follows a strict coding style. It does not handle data pipelines or analytics; it is purely a system administration tool.
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.
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.
Cali is a TypeScript-based CLI application designed for React Native and Expo development teams. It functions as an AI-powered orchestration layer that automates mobile quality assurance, code review, and performance analysis. The system operates by ingesting repository context (PR data, mobile artifacts) and executing structured agent loops that interact with platform-specific tools (Android/iOS SDKs) via the Vercel AI SDK. It supports both local execution and CI environments (GitHub Actions, EAS), generating structured reports in JSON and Markdown formats. Architecturally, it follows a monorepo pattern with distinct packages for the core CLI (packages/cali) and platform-specific tool wrappers (packages/tools). The core logic relies on a role-based command structure where specific tasks (QA, Review, Dev) are delegated to specialized agent roles. Data flow is deterministic, moving from context resolution through tool execution to report publishing, ensuring consistent behavior across different environments. The tool distinguishes itself by managing complex mobile development contexts, such as artifact parsing (APK/IPA) and device management, which are typically brittle in automated workflows. It integrates skill discovery for AI agents and supports multiple output publishers (local file, Vercel Blob). While it solves a specific niche problem effectively, it introduces dependencies on external binaries and rapid-versioning AI SDKs that require careful maintenance.
ClusterSSH is a Perl-based cluster administration tool that provides a graphical console (using Tk) to manage multiple SSH (or other protocol) sessions simultaneously. It allows users to define clusters via configuration files, expand hostnames using shell-style ranges, and replicate keystrokes from a master console to all connected terminal windows. The architecture is monolithic, centered around the App::ClusterSSH module, with distinct sub-modules handling configuration, cluster resolution, host parsing, and window management via X11::Protocol. It relies heavily on the X11 protocol for event injection into child xterm processes, making it tightly coupled to X11 environments but highly effective for its specific use case of synchronized cluster management.
CF-Clearance-Scraper is a Python CLI tool designed to solve Cloudflare challenges (JavaScript, managed, and interactive) and extract the cf_clearance cookie for bypassing anti-bot protections. The application uses Zendriver for headless browser automation, dynamically generates realistic Chrome user agents, handles proxy authentication via CDP events, and provides output formats including raw cookies, cURL/Wget/aria2 commands, or JSON storage. The architecture is monolithic with a single entry point (main.py) featuring clean separation of concerns: argument parsing, browser orchestration, challenge detection/solving, and output formatting. Key strengths include robust user agent fallback mechanics and proxy handling, though the Cloudflare-solving logic is tightly coupled to Zendriver and challenge-specific heuristics.
Flent is a mature, actively maintained network testing tool designed primarily for bufferbloat detection. It wraps multiple simultaneous network performance tools (netperf, iperf, ping, fping, irtt) into a single coordinated test, aggregates time-series data, and produces publication-quality plots via matplotlib. The architecture is a Python CLI application with an optional Qt GUI, built around a modular system of test definitions (Python .conf files), pluggable runners, aggregators, combiners, and formatters. It supports batch execution for reproducible experiments, extensive metadata collection (kernel parameters, qdisc stats, WiFi stats), and multiple output formats (CSV, JSON, plots). While primarily an application, it has strong data collection and analysis characteristics, making it a hybrid tool for network performance research. The codebase is well-structured with clear separation of concerns, though it carries some legacy Python 2 compatibility shims and platform-specific Linux dependencies.
Promptimize is a prompt engineering evaluation and testing toolkit implemented as a Python library with CLI interface. It enables users to define prompt cases (test cases for LLM prompts) as code, associate evaluation functions that score responses on a 0-1 scale, execute test suites across different models and configurations, and generate performance reports. The architecture centers around BasePromptCase and its derivatives (PromptCase, TemplatedPromptCase, LangchainPromptCase) which encapsulate prompt logic and evaluation, Suite classes that manage collections of prompt cases and handle execution/reporting, and utility modules for templating, caching, and result serialization. The toolkit minimizes redundant API calls by caching prompt executions and only re-running when prompts change, supports human review for edge cases, and integrates with Langchain/OpenAI for LLM interactions.
callx is a Node.js CLI tool that serves as a unified runtime switcher and configuration manager for AI coding assistants like Claude Code and OpenCode. It allows users to define multiple AI 'sprites' (agent configurations) with different providers, models, skills, and MCP servers, all managed through a single `~/.config/callx` directory. The system provides two entry points: the `call` command for quick invocation of sprites, and `callcli`, a full-featured TUI built with Ink and React for managing providers, sprites, skills, MCP servers, and git worktrees. The architecture is a monolith CLI application with a clear separation between runtime utilities (`lib/runtime.js`), git worktree helpers (`lib/worktree.js`), and the TUI frontend (`lib/callcli/app.mjs`). The runtime module handles all configuration file I/O, provider normalization, skill syncing via symlinks, and MCP server configuration generation for both Claude Code and OpenCode formats. The TUI provides a Monokai-themed interface with list-based navigation, field-level editing, and multi-select for skills and MCP servers. Key data flows include: reading `providers.json` for API keys and endpoints, reading sprite `config.json` for CLI type and model selection, syncing skill packs from `skillpacks/` to sprite-specific `skills/` directories via symlinks, and generating MCP configuration files from `mcpservers/` definitions. The tool also integrates with git worktrees, providing an interactive flow to create new branches and worktrees with suggested naming conventions. External dependencies are minimal: Node.js 18+, Ink and React for the TUI, and the target AI CLI tools (opencode-ai, @anthropic-ai/claude-code).
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.
The solo-cli is a command-line tool designed to deploy and manage Physical AI systems on local hardware. It integrates functionalities for serving large language models (via Ollama, vLLM, or llama.cpp), controlling robotic arms (through the LeRobot framework), authenticating with a custom model hub (Solo Hub), and fine-tuning models using external datasets. The application features a modular command structure with lazy-loaded dependencies to optimize startup time, cross-platform hardware detection for automated backend selection, and a layered configuration system. Additional utilities include Docker management, system information gathering, and filesystem-safe string handling for robotics data operations. The project also includes example implementations of Model Context Protocol (MCP) servers for various domains, demonstrating how to extend the CLI's capabilities for specialized AI workflows.
Stoobly Agent is a CLI-driven HTTP proxy tool for recording, mocking, replaying, and testing API traffic. Built on mitmproxy, it intercepts HTTP/HTTPS requests and applies configurable policies across four modes: record, mock, develop, and test. The tool stores intercepted requests and responses in a local SQLite database via a custom ORM, and can also synchronize with the Stoobly cloud service for remote project management. It supports lifecycle hooks (user-defined Python callables), OpenAPI endpoint import, snapshot/rollback of request state, and a scaffold system that generates Docker Compose or local development environments for services and workflows. The architecture is modular, with clear separation between the CLI layer (Click-based), proxy interception handlers, data models and adapters (converting between mitmproxy, raw HTTP, ORM, and Stoobly API representations), and a settings system with YAML persistence and environment variable overrides. Key entry points include the main CLI group (stoobly_agent/cli.py), the proxy intercept handler (stoobly_agent/app/proxy/intercept_handler.py), and the scaffold commands (stoobly_agent/app/cli/scaffold/). External dependencies include mitmproxy for traffic interception, a custom ORM (stoobly_orator) for local storage, and the Stoobly cloud API for remote features. The codebase demonstrates strong software engineering practices with extensive use of design patterns (adapter, facade, builder, singleton, strategy) and a comprehensive test suite covering unit, integration, and end-to-end scenarios. While the scaffold system and snapshot management add complexity, the overall architecture is well-organized and the tool delivers a polished developer experience for API mocking and contract testing.