Robusta KRR is a CLI tool for optimizing Kubernetes resource allocation by recommending CPU and memory requests/limits based on Prometheus metrics. It features a modular architecture with pluggable strategies for recommendation algorithms, multiple output formats, and integrations with various Prometheus-compatible systems. The project includes an enforcer component (mutating webhook) for automatic application of recommendations. The codebase demonstrates good engineering practices with clear separation of concerns, proper error handling, and extensible design patterns.
JayeX (jx) is a modular command-line interface (CLI) tool for managing JayeX 3.x, a CI/CD platform for Kubernetes. The application is built with Go and uses the Cobra library for command parsing. It provides commands for managing namespaces, viewing dashboards, upgrading plugins, checking versions, and interacting with various JayeX components. The architecture follows a modular plugin system where core functionality is extended through installable plugins. The tool interacts with Kubernetes clusters via client-go and maintains version information through build-time injection. Entry points are in cmd/main.go which delegates to platform-specific app implementations.
KiKit is a Python CLI tool, library, and KiCAD plugin for automating PCB panelization and fabrication output. It takes KiCAD board files (S-expression format) and produces panelized PCBs with v-cuts, mouse bites, tooling holes, fiducials, and frames. It also exports manufacturing files (Gerbers, drill, assembly data) tailored to popular fab houses (JLCPCB, PCBWay, OSH Park), generates 3D-printable solder paste stencils, performs DRC checks, and creates presentation pages for boards. The architecture is modular: core geometric operations use Shapely, interval algebra, and a custom S-expression parser; an extensible plugin system allows custom layout, tab, and cut strategies. The tool integrates deeply with KiCAD’s pcbnew API and supports multiple KiCAD versions (6–9) through version-specific adapters. While primarily a production tool for hardware engineers, its clean separation of parsing, geometry, and CLI makes several components reusable in other PCB-adjacent projects.
Apio is a command-line interface (CLI) tool designed to streamline FPGA hardware development workflows. It acts as a wrapper and manager for open-source EDA toolchains (Yosys, Nextpnr, Verilator, GTKWave) and hardware drivers, supporting multiple FPGA architectures (ICE40, ECP5, GOWIN, XILINX) and over 80 development boards. The tool automates the full lifecycle of FPGA projects, including initialization, linting, synthesis, place-and-route, simulation, and bitstream upload to hardware. Architecturally, Apio follows a modular design with a Click-based CLI layer that delegates heavy build tasks to a SCons subprocess. Communication between the CLI and SCons is handled via Protocol Buffers to avoid global state sharing. The codebase includes robust package management for downloading and installing toolchains, cross-platform support for Linux, macOS, and Windows, and a comprehensive test suite using pytest. It is a professional-grade tool with strong engineering practices, including CI/CD pipelines and semantic versioning. Technical drift is moderate due to the volatile nature of SCons APIs and the reliance on external toolchain versions. There is also a noted inconsistency in Python version usage (mixing 3.9 compatibility checks with 3.10+ match statements). However, the repository is actively maintained with recent commits and a healthy issue resolution rate. The codebase is suitable for reuse in FPGA tooling projects, particularly the package management and IPC patterns.
HAITI (HAsh IdenTIfIer) is a Ruby library and CLI tool for identifying hash types from input strings. It matches against a comprehensive database of over 675 hash types (including modern algorithms like SHA3, Blake2, and VeraCrypt) using regex patterns. The library provides concise output with hashcat mode numbers, John the Ripper format names, and example hashes. Multiple CLI entry points exist: the main `haiti` command, `haiti-parsable` for script-friendly output, `haiti-fzf` for interactive selection, and `hashcat-haiti`/`john-haiti` for converting hashes into hashcat/JtR formats. The codebase is well-structured, with clean separation between the identification engine, data definitions, and CLI wrappers. It includes comprehensive documentation (man pages, YARD API docs, a docsify site) and is packaged for numerous Linux distributions and Homebrew. The identification logic is straightforward but effective: iterate over a JSON array of prototypes, apply each regex to the input, and return matching types. The data file (`prototypes.json`) is manually maintained and extended with each release.
Generic Mapping Tools (GMT) is a mature, open-source collection of approximately 100 command-line tools for processing geographic and Cartesian data and producing high-quality PostScript illustrations, maps, and animations. The system is architected as a modular C library with a central dispatcher executable (`gmt`) that loads and runs individual modules. It supports both a classic mode (direct module calls) and a modern mode (`gmt begin/end`, `gmt subplot`) that manages sessions, figures, and panels. Key entry points include the `gmt` command, the C API (`GMT_Create_Session`, `GMT_Call_Module`), and shell completion scripts. Data flows involve reading grid, table, image, and color palette table (CPT) data from local files or remote servers (via `@` prefix), processing through modules (e.g., `grdimage`, `psxy`, `grdmath`, `grdfilter`), and outputting PostScript, grids, or other formats. External dependencies include netCDF, GDAL, FFTW, PCRE/POSIX regex, PROJ, GSHHG coastlines, and DCW country polygons. The codebase exhibits high craftsmanship with systematic option parsing, a well-defined API, extensive test coverage, and reusable infrastructure components.
angular-cli-ghpages is an Angular CLI builder and schematic that deploys Angular applications to GitHub Pages, Cloudflare Pages, or any Git repository. It wraps the gh-pages npm package and integrates with Angular CLI's deployment infrastructure via `ng deploy`. The tool features a modular architecture with separate entry points for standalone CLI usage, Angular builder integration, and schematic-based setup. It handles complex deployment concerns including build process integration, authentication token injection, CI environment metadata appending, and creation of necessary deployment files (.nojekyll, 404.html for SPA routing, CNAME for custom domains).
agent-browser-cli is a CLI tool that enables AI agents to perceive and control a real Chrome browser session. It consists of a Rust CLI that communicates with a local daemon via HTTP API, which in turn communicates with a Chrome extension via WebSocket. The system preserves the user's login state and cookies while providing capabilities like tab management, page inspection, JavaScript execution, screenshots, and CDP access. The architecture cleanly separates concerns: the CLI handles user input, the daemon manages persistent connections, and the extension executes commands in the browser context.
Qiita CLI is a command-line tool and preview server for managing Qiita blog posts locally. It allows users to create, edit, preview (with hot-reload), and publish articles and slides (Marp-based) to the Qiita platform via its REST API. The architecture separates CLI commands (init, login, new, preview, publish, pull) from a file-system-backed repository layer that synchronizes local markdown files with Qiita's remote state using a `.remote` mirror directory. A React-based web frontend provides a sidebar for navigating articles/slides and an embedded preview of rendered Markdown (including MathJax and embedded scripts). The server also supports Marp slide preview with shadow DOM isolation for CSS scoping. The codebase is well-structured, uses TypeScript, has comprehensive unit tests, and follows modern Node.js patterns (async/await, error handling, dependency injection). It is actively maintained by Qiita Inc. and targets Node.js 22+.
search-engine-parser is a Python library and CLI tool designed to scrape search engines for structured results. It provides a base class for search engine implementations with specific parsers for engines like Google, Bing, Yahoo, DuckDuckGo, and others. The tool supports both synchronous and asynchronous HTTP requests, includes caching to avoid repeated requests, and uses user-agent rotation to prevent blocking. Key features include a command-line interface (pysearch) for terminal use and a programmatic API for integration into other projects, returning results as SearchItem objects with convenient access to titles, links, and descriptions.
Speclj is a TDD/BDD testing framework for Clojure and ClojureScript that provides a rich DSL for writing specifications. It features a hierarchical component system for organizing tests, cross-platform support via reader conditionals, multiple runners (standard and vigilant), various reporters, stubbing/mocking capabilities, and tag-based test filtering. The architecture is modular with clear separation between test definition (speclj.core), platform abstraction (speclj.platform), test execution (speclj.running), and reporting (speclj.reporting).
The clonezilla-util is a command-line utility for managing Clonezilla backup images. It enables users to list, mount, and extract files from Clonezilla images without requiring a full restoration. The application leverages a modular architecture with separate libraries for handling Clonezilla specifics, compression formats, partclone parsing, and virtual file system integration via Dokan for Windows. Key features include efficient random-access reading through caching and indexing mechanisms, support for multiple compression formats (gzip, bzip2, xz, zstd), and the ability to mount images as virtual drives for seamless file explorer access. The codebase demonstrates strong engineering practices with interface-based design, reusable stream utilities, and performance-oriented components like buffer pools and caching streams. While the Dokan dependency limits cross-platform functionality to Windows, the core libraries (libCommon, libClonezilla, etc.) are designed to be portable and could be adapted to other platforms with alternative filesystem abstractions. The project is actively maintained with ongoing performance optimizations and a comprehensive test suite.
This repository is a full-stack Next.js application that serves as the world's largest open-source prompt library for AI. It provides a platform for users to create, share, discover, and manage prompts for various AI models (ChatGPT, Claude, Gemini, etc.). The core functionality includes CRUD operations for prompts with types (text, image, video, audio, skill, taste), voting, commenting, versioning, change requests, collections, and moderation tools. It features AI-powered capabilities such as semantic search via OpenAI embeddings, prompt improvement, translation, quality checking, and media generation through plugin-based providers (Fal.ai, Wiro.ai). The application supports multi-tenancy for self-hosting with configurable branding, authentication plugins (OAuth, OIDC, GitHub, Apple, Google), and storage backends (S3, DO Spaces). Beyond the web app, it includes a CLI tool (packages/prompts.chat) for browsing and running prompts locally, a Raycast extension for quick access, and an MCP server for integration with AI coding assistants. Additionally, it bundles an interactive educational book on prompt engineering (28+ chapters) and a gamified kids learning section, both fully localized into 17 languages. The codebase is well-structured with a plugin registry pattern, configuration-driven design, and extensive use of modern Next.js patterns (App Router, server components, streaming).
Goose is an open-source AI agent platform that provides a desktop application (Electron/React), CLI (Rust), and SDK (Python, Kotlin) for interacting with large language models through a unified Agent Client Protocol (ACP). In production, it enables users to define sessions with multiple LLM providers (Anthropic, OpenAI, Google, Azure, Bedrock, local models via MLX/GGUF, and 40+ declarative providers), extend capabilities via MCP servers and built-in platform extensions (shell, image, file editing, code analysis, apps creation), and automate workflows through parameterized recipes. The architecture is a hybrid: a Rust backend handles agent state machine orchestration, tool execution, permission management, and provider abstraction, while an Electron frontend provides a rich chat interface with settings, extension management, scheduling, and MCP apps display. Key entry points include the CLI binary (crates/goose-cli/src/main.rs), the ACP server (crates/goose/src/acp/server/), and the desktop renderer (ui/desktop/src/renderer.tsx). Data flows involve user input → state machine processing → LLM provider calls → tool execution → response streaming back to the UI, with telemetry and cost tracking throughout. External dependencies include OpenAI/Anthropic/Google APIs, MCP servers, Whisper for dictation, and optional services like PostHog and Langfuse for observability.
Wails is a Go framework for building cross-platform desktop applications using web frontends (HTML/CSS/JS). It provides a CLI tool for project scaffolding, development server, and building. The architecture consists of a Go backend that communicates with an embedded WebView via a binding system that auto-generates TypeScript/JavaScript wrappers for Go services. It supports Windows (WebView2), macOS (WebKit), Linux (GTK/WebKit), and mobile (iOS/Android). Key entry points include `application.New()` in v3 and `wails.Run()` in v2. External dependencies include the WebView2 runtime on Windows, WebKitGTK on Linux, Cocoa on macOS, and various system libraries. The repository contains both v2 (legacy) and v3 (current) versions, with v3 introducing a new binding generator, built-in task runner (`wake`), improved service lifecycle, and cross-platform scaffolding.
Task Master is a monorepo providing an AI-driven task management system designed for integration with AI coding assistants (Claude Code, Cursor, Windsurf, etc.). It consists of a CLI tool (`task-master`), an MCP server, a VS Code extension, and core library packages. The system manages tasks with statuses, priorities, dependencies, tags, and subtasks, and offers AI-assisted operations like PRD parsing, task expansion, complexity analysis, and TDD workflow automation (autopilot). It supports multiple storage backends (local JSON files, remote Hamster API via Supabase) and 15+ AI providers. The architecture follows a clean layered pattern with domain modules in `@tm/core` consumed by CLI and MCP interfaces, though a legacy `scripts/` directory still contains overlapping logic being gradually migrated. The codebase demonstrates strong engineering practices including factory patterns, abstract base classes, dependency injection, atomic file operations, and extensive test coverage. Some technical drift is present due to the ongoing migration from JavaScript to TypeScript and duplicated MCP server implementations.
This repository is a CLI tool for translating books (EPUB, TXT, PDF, SRT, Markdown) into bilingual versions (original + translation side-by-side) using large language models (OpenAI, Anthropic, Gemini, etc.) and free machine translation engines. It supports multiple translation backends, a provider configuration system, and a PDF-to-EPUB pipeline using docling for PDF extraction and Pandoc for EPUB export. The architecture is modular: loaders parse input formats, translators handle API calls with session context and capability probing, and a pipeline orchestrates PDF-to-EPUB conversion with figure rendering and classification. Key entry points are `make_book.py` and the installed command `bbook_maker`. The tool includes features like plan mode for selective translation, glossary support, resume, progress bars, and Docker support. It has extensive tests covering CLI contract, loaders, translators, pipeline stages, and documentation. External dependencies include LLM APIs, docling, pypdfium2, Pandoc, and various SDKs. The codebase demonstrates careful engineering decisions around capability degradation, session compaction, glossary learning, and structured output ladder. It is a well-maintained application with active development and low technical drift.
ctf-tools is a Nix flake that packages and manages CTF/security research tools. It provides a CLI interface (manage-tools) for installing, upgrading, and removing tools from a user's Nix profile. The system isolates each tool in its own derivation, builds from source or fetches prebuilt binaries from a Cachix cache, and handles complex packaging requirements like tools needing writable directories at runtime (BeEF, libc-database) or proprietary software requiring user-provided binaries (IDA). The architecture is modular with separate derivations for each tool, CI/CD for automated building and caching, and thoughtful handling of runtime dependencies through wrapper scripts.
XcodeGen is a command-line tool written in Swift that generates Xcode project files (.xcodeproj) from a declarative YAML or JSON specification (typically project.yml). It eliminates the need to manually manage Xcode project files by deriving the project structure from the filesystem and a concise spec, supporting all major Apple platforms (iOS, macOS, tvOS, watchOS, visionOS) and a wide range of product types including applications, frameworks, libraries, extensions, App Clips, and more. The tool integrates with Swift Package Manager, Carthage, and CocoaPods, and can generate schemes, breakpoints, Info.plist files, and build settings from layered presets. The architecture is modular: the ProjectSpec module defines the domain models and parsing logic for the spec format; XcodeGenKit contains the core generation logic (PBXProj generation, scheme generation, source file organization, settings resolution); XcodeGenCLI provides the command-line interface using SwiftCLI; and XcodeGenCore offers utility components like globbing, atomic properties, and path extensions. The tool is designed for automation and CI workflows, with caching support and pre/post generation commands. The codebase is well-structured with clear separation of concerns, extensive test coverage (unit tests, fixture-based golden tests, performance tests), and active maintenance. It demonstrates strong Swift engineering practices including protocol-oriented design, value types, and functional patterns. While the project is mature and widely adopted (over 8,800 stars), some areas like test fixtures are large and tightly coupled to specific Xcode versions, requiring periodic updates.
curlconverter is a command-line tool and library that converts curl commands into equivalent code snippets in over 30 programming languages and HTTP libraries. It features a modular architecture with a tree-sitter based Bash parser for robust curl command parsing, language-specific generators for target code production, and extensive test coverage. The tool handles complex curl features including authentication, headers, data uploads, multipart forms, proxies, and SSL options, producing runnable code in languages ranging from Python and JavaScript to Rust, Go, and specialized tools like Ansible and HTTPie.