This monorepo (Nx) implements a complete ecosystem for managing and distributing 'skills'βcurated, structured instructions for AI coding agents. The codebase reveals a production CLI (`agent-skills`) built with Ink/React for interactive terminal UI, an MCP server (`agent-skills-mcp`) for agent-in-context skill lookup via FastMCP, a Next.js marketplace website for browsing, and a skills catalog with over 150 skill definitions across architecture, cloud, development, quality, security, and other domains. The core library (`@tech-leads-club/core`) uses a clean hexagonal architecture with port/adapter separation for file system, HTTP, environment, logging, and shell operations, enabling testability and future portability. The CLI supports interactive and non-interactive install/remove/update workflows with atomic lockfile writes, append-only audit logging, and content-hash integrity verification. The MCP server implements a progressive disclosure pattern (search β read β fetch/prepare) to minimize token usage, with registry caching and ETag revalidation. The marketplace is highly SEO-optimized with JSON-LD structured data, breadcrumbs, and static generation. Property-based tests (fast-check) for UI components and cache boundaries demonstrate strong engineering discipline. The skills catalog itself is the core productβeach skill is a markdown file with YAML frontmatter, optional scripts/references, and trigger phrases, all validated by a custom validation tool and security-scanned in CI. While the architecture is solid and the codebase is actively maintained with frequent releases, some areas show drift risk: duplicate validation scripts across skills, hardcoded benchmark data in the marketplace, and tight coupling to external CDN availability for registry downloads. The cloud-deploy skill references an enormous set of Cloudflare product docs that will inevitably become outdated. Overall, this is a well-crafted, modern TypeScript monorepo that effectively solves the problem of giving AI agents reusable, safe, and discoverable instructions.
torlink is a terminal-based torrent client that combines a rich Text User Interface (TUI) with headless daemon modes for torrent search, download, seeding, and file serving. Built with TypeScript, Node.js, and React (via Ink for TUI rendering), it provides zero-configuration access to curated torrent sources across categories like games, movies, TV, and anime. The application features parallel source querying, result deduplication, automatic seeding with optional file deletion, and persistent state management for queues, history, and seeds. The architecture follows a modular design: the TUI layer (src/ui) handles interactive modes, daemon services (src/daemon) manage headless operations (serve, files, watch, seed, attach), core download logic (src/download) manages the torrent queue and engine integration, and source plugins (src/sources) fetch torrents via RSS, APIs, or web scraping. Key utilities include atomic file writes, resilient HTTP fetching, caching, and format helpers. The CLI entry point (scripts/cli-entry.cjs) handles Node version checks and WebRTC fallbacks before launching the appropriate mode. External dependencies include Ink for TUI rendering, webtorrent for torrent handling, node-datachannel for WebRTC fallbacks, and various HTTP clients. The project maintains active development with recent commits, comprehensive test coverage, and CI workflows. While dependency pinning indicates managed compatibility risks, the codebase demonstrates strong engineering practices through isolated utilities, reactive patterns for concurrent searches, and cross-platform path handling.
gitmoji-cli is an interactive command-line tool that injects gitmoji emojis into git commit messages. It operates in two modes: a client mode (`gitmoji -c`) that runs interactive inquirer prompts to assemble a commit message before shelling out to `git commit`, and a hook mode (`gitmoji -i`) that installs a `prepare-commit-msg` git hook which intercepts every `git commit` and prompts the user before writing the commit message file. Additional subcommands list, fuzzy-search, update, and configure the emoji dataset and CLI preferences. It depends on the gitmoji.dev public API as the source of emoji data, git itself, and the npm ecosystem. Architecturally it is a Node.js ESM CLI built with a Babel compilation pipeline and a deliberate mix of Flow-typed JavaScript and newer TypeScript modules. The command layer is cleanly separated from utilities: meow parses flags and subcommands, a small dispatcher routes to lazily-imported command modules, inquirer drives prompts with a registered autocomplete plugin, and execa shells out to git. The emoji dataset is fetched via node-fetch, cached in `~/.gitmoji/gitmojis.json` for offline use, and searched using fuse.js with weighted scoring. Configuration resolves through a precedence hierarchy of `.gitmojirc.json`, a `gitmoji` key in package.json, parent-directory lookups, and a schema-validated global conf store. Notable engineering exists in the git hook integration, which correctly detects in-progress rebases and amends, handles SIGINT so an interrupted prompt does not abort the user's commit, and skips prompting when the commit title already contains a Unicode or shortcode emoji. The codebase has comprehensive Jest unit and snapshot tests, GitHub Actions CI covering lint/flow/test/coverage, a release pipeline, and a current dependency set. Main quirks are the transitional dual type system (Flow + TypeScript) and a few cosmetic copy-paste issues, but overall this is a polished, well-maintained developer tool.
Iris is a high-performance C inference engine for diffusion image generation models, specifically designed for FLUX.2 Klein (4B/9B) and Z-Image-Turbo (6B) architectures. It provides a complete pipeline from text encoding (Qwen3-4B/8B) through transformer denoising to VAE decoding, outputting PNG or PPM images. The system operates as both a standalone CLI tool with an interactive REPL and a C library (libiris.a), featuring memory-mapped weight loading for efficiency (~4-5GB peak for 4B model) and optional Metal GPU acceleration on Apple Silicon for significant speedups. The architecture is modular: separate components handle safetensors weight loading, BPE tokenization, transformer blocks (double/single stream for Flux, main/refiner for Z-Image), VAE decoding, and image I/O (PNG/JPEG/PPM). The CLI supports text-to-image, image-to-image, multi-reference generation, and various scheduling strategies (shifted sigmoid, linear, power). Memory optimization techniques include releasing the text encoder after embedding extraction, embedding caching with 4-bit quantization, and dynamic attention memory budgeting for reference images. The codebase demonstrates deep systems engineering and ML inference expertise, with hand-optimized kernels, custom Metal shaders, and detailed performance instrumentation. It is self-contained with no external dependencies beyond standard C libraries and optional BLAS/Metal, making it portable across Linux and macOS. The project includes regression test vectors and a JPEG decoder fuzzer, indicating a focus on correctness and reliability.
JVMS (JDK Version Manager) is a Windows-specific CLI tool for managing multiple JDK installations. It allows users to install, switch between, and manage different JDK versions from various distributions (Oracle, Amazon Corretto, Adoptium, Azul Zulu). The application features both command-line and text-based user interfaces, modifies system environment variables (JAVA_HOME, PATH) to make JDKs available, and uses a symlink mechanism for persistent JDK switching across console sessions and reboots. Built in Go with a modular architecture, it separates concerns into command handling, data models, UI components, and utility packages for file operations, web downloads, and JDK provider management.
Trice is an embedded logging and tracing toolchain consisting of a lightweight C instrumentation library for microcontrollers and a Go-based host CLI tool. The C library provides variadic macros that emit compact binary records (ID + values) instead of format strings, drastically reducing flash and bandwidth usage. The Go tool manages Trice IDs (insert, clean, bind), decodes incoming binary streams from targets over UART, RTT, TCP/UDP, or file, and displays formatted logs with timestamps, colors, and filtering. It supports multiple buffer strategies (stack, static, double, ring), framing protocols (COBS, TCOBS), optional XTEA encryption, and local logging on the target itself. The architecture is a classic host-target split: the target runs the C library, the host runs the Go CLI. The codebase is well-tested with a large matrix of CGO test configurations and CI pipelines for multiple STM32 example projects. It is actively maintained with frequent releases and a responsive issue tracker.
Liffy is a comprehensive Local File Inclusion (LFI) exploitation tool designed for security testing and penetration testing. It provides a modular command-line interface that supports multiple LFI techniques including data://, expect://, input://, filter:// wrappers, log poisoning, null byte attacks, ZIP wrapper exploitation, and blind LFI detection. The tool features advanced capabilities such as WAF bypass techniques, encoding layers, multi-threading with rate limiting, custom headers, POST request support, and rich terminal output. Architecture follows a modular design with core techniques isolated in separate modules, coordinated by a main orchestrator (liffy.py) that handles argument parsing, configuration loading, and execution management.
InvoicePrinter is a Ruby library for generating PDF invoices, with additional CLI and HTTP server interfaces. It takes structured invoice data (as Ruby objects or JSON) and generates formatted PDF documents using the Prawn library. The system consists of three main components: the core library for PDF generation, a command-line executable for direct use, and a server executable providing a HTTP API. The architecture shows good separation of concerns with distinct modules for data models, PDF rendering, font handling, and server interface.
Standardese is a documentation generator for C++ that parses source code (particularly header files) using libclang or cppast to extract code structure and documentation comments. It combines this information to produce documentation in multiple formats, including HTML, Markdown, XML, and plain text. The tool is designed to be extensible, with a modular architecture separating comment parsing, entity modeling, synopsis generation, and output generation. The project employs several software engineering patterns, such as the visitor pattern for traversing the markup DOM, a builder pattern for constructing documentation entities, and a thread pool for parallel processing. Configuration is handled via command-line options and configuration files using Boost.Program_options. The output generation system uses a generator interface that allows adding new formats without modifying the core logic. Standardese is actively maintained, with recent commits indicating ongoing development. It relies on well-established dependencies like Boost, cmark-gfm, and cppast/libclang, and its build system is based on CMake. The codebase demonstrates good craftsmanship in its separation of concerns and reusable components, such as escaping utilities and enum reflection helpers, which could be extracted for use in other projects.
Vibe Check MCP is a production-ready MCP (Model Context Protocol) server that provides metacognitive oversight for AI agents. It implements the research-backed Chain-Pattern Interrupt (CPI) methodology to prevent reasoning lock-in by injecting reflective pauses during agent workflows. The server exposes six tools: `vibe_check` for generating clarifying questions via a secondary LLM, `vibe_learn` for logging patterns of mistakes and successes, and three constitution management tools (`update_constitution`, `reset_constitution`, `check_constitution`) for per-session behavioral rules. It supports multiple LLM providers (Gemini, OpenAI, Anthropic, OpenRouter) with automatic fallback to static questions when the LLM is unavailable, and maintains session history for context-aware feedback. The architecture is a monolithic MCP server with dual transport modes: stdio for local agent clients (Claude Desktop, Cursor, Windsurf, VS Code) and streamable HTTP for remote access. A CLI tool (`vibe-check-mcp`) automates installation into all major MCP client configurations with atomic writes and backup creation, handles secret management via interactive prompts or env files, and provides diagnostic commands. The server includes robust HTTP security hardening: DNS-rebinding protection via Host header validation, loopback-only CORS by default with a configurable allowlist, explicit JSON body size limits, and proper JSON-RPC error responses instead of HTML pages. The codebase is well-organized with separation of concerns, extensive unit and integration tests (over 30 test files), CI/CD with security scanning, and clean abstraction layers such as a central model registry and request-scoped transport wrappers.
pcb2gcode is a mature, actively maintained C++17 command-line tool that converts PCB design files (Gerber RS-274X, Excellon drill) into CNC G-code for isolation routing, drilling, and outline cutting. It supports multiple CNC controllers (LinuxCNC, Mach3, Mach4) and advanced features like auto-levelling via probe-based Z correction, tiling, mirroring, Voronoi-based isolation, and path optimization (TSP, Eulerian paths, backtracking). The architecture is modular: input parsing (libgerbv), geometric processing (Boost.Geometry, Boost.Polygon), path computation (segment trees, A* search, Eulerian decomposition), and G-code generation. The project includes an optional MCP server for AI integration and a comprehensive test suite with golden file comparisons. Dependencies are well-managed via CMake and pinned in CI.
The mviewer repository is a Rust-based application for viewing and exporting Marmoset .mview scene files. It features a dual-mode interface: launching a GUI (using tao/wry embedded webview) for interactive preview when no arguments are provided, or running in CLI mode for batch conversion when arguments are given. The GUI loads a local HTTP server to serve an embedded, forked Marmoset JavaScript viewer that renders scenes with visual parity to Marmoset Toolbag. The core Rust logic handles loading the proprietary .mview archive format, extracting scene data (meshes, materials, animations, cameras, lights, textures), and exporting to glTF/GLB/OBJ formats. The application demonstrates strong modularity with clear separation between archive parsing, data processing, export pipelines, and GUI integration. While the embedded JavaScript viewer introduces some maintenance considerations due to its forked nature, the Rust components exhibit high reusability and craftsmanship, particularly in handling complex binary formats and data transformations.
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.
Agentic Metric is a local-only monitoring tool for AI coding agents that tracks token usage and costs across Claude Code, Codex, OpenCode, Qwen Code, and VS Code (Copilot Chat). It features a TUI dashboard and CLI for real-time monitoring, historical trends, and cost estimation. The architecture uses a plugin-based collector system for each agent type, incremental file parsing for efficient live updates, and a SQLite database for data aggregation. Key design strengths include smart session upsert logic to prevent metric regression, cross-platform process detection, and a flexible pricing system with family-based fallbacks.
Plugin Inspector is a CLI tool and library for offline static and runtime analysis of OpenClaw plugins. It validates plugin structure, SDK imports, hook registrations, and manifest contracts without requiring a live OpenClaw host. The tool generates rich compatibility reports in JSON, Markdown, SARIF, and JUnit formats, integrates with CI pipelines (GitHub Actions, GitLab, CircleCI), and supports batch analysis across plugin corpora. Its architecture is modular: a core inspection engine (src/inspector.js) performs static analysis using AST parsing (acorn, eslint-scope) and regex-based detection; an optional runtime capture subsystem (src/capture-api.js, src/synthetic-probes.js) executes plugin entrypoints with a dynamically generated mock SDK (src/sdk-mock.js) to verify registration behavior and hook handling. The tool also includes a CI policy engine, workspace planning, platform probes, and profiling/diffing utilities. While tightly coupled to OpenClaw internals, the codebase demonstrates strong engineering practices with extensive test coverage, reusable components, and a well-defined public API surface.
JSON Server v1 (beta) is a CLI tool and library that spins up a fully functional REST API from a JSON or JSON5 file. It is built on top of lowdb for data persistence and @tinyhttp/app for HTTP handling. The architecture is a clean three-layer design: a CLI entry point (bin.ts) that wires file watching and server startup, an Express-like app layer (app.ts) that defines routes and parses query parameters, and a service layer (service.ts) that encapsulates all data access, filtering, pagination, and relationship embedding. The system supports advanced query capabilities including field operators (gt, lt, in, contains, etc.), JSON-based _where queries, sorting, pagination with navigation metadata, and resource embedding via _embed. It also handles referential integrity on deletes by nullifying foreign keys or cascading dependent deletions. The codebase demonstrates solid TypeScript craftsmanship with strict mode enabled, modern ESM modules, and a clear separation of concerns. Notable engineering patterns include the NormalizedAdapter wrapper that enforces string IDs and strips $schema on read while re-injecting it on write, and the Observer adapter that intercepts lowdb read/write lifecycle events to enable file-watch reloading without feedback loops. The query parsing layer cleanly separates URLSearchParams-based operator syntax from raw JSON _where objects, with proper type coercion for booleans, null, and numbers. The project is in active beta (v1.0.0-beta.15) with recent commits, CI via GitHub Actions, and a pre-commit hook running tests. It targets Node.js >=22.12 and leverages experimental TypeScript stripping for development. Dependencies are current and well-chosen (lowdb v7, @tinyhttp v3, eta v4). The test suite uses Node's built-in test runner and covers the service layer, query parsing, pagination, and full HTTP integration tests.
Lux is a fast and simple video downloader CLI tool written in Go. It supports downloading videos, images, and audio from over 40 websites including YouTube, Bilibili, TikTok, Instagram, Twitter, and many Chinese streaming platforms. The tool operates as a single binary with a rich set of command-line options for selecting quality, downloading playlists, resuming interrupted downloads, multi-threaded downloading, and integration with aria2 for RPC-based downloads. Architecturally, Lux follows a plugin-based extractor pattern. Each supported website has its own extractor module under `extractors/`, registered via `init()` functions into a global map keyed by domain. The main entry point is `main.go`, which parses CLI flags via `urfave/cli` and dispatches to the appropriate extractor. Extracted video metadata (streams, quality, size) is passed to the downloader, which handles HTTP requests, progress bars, file merging via ffmpeg, and optional subtitle embedding. Key data flows: URL input β domain detection β extractor selection β HTML/API scraping β stream metadata extraction β downloader (single or multi-threaded) β file output. External dependencies include ffmpeg for merging and subtitle embedding, and various third-party Go libraries for HTTP requests, HTML parsing, JavaScript execution (for TikTok signing), and progress bars. The codebase is well-organized with clear separation of concerns, extensive test coverage for individual extractors, and CI workflows that run weekly to verify extractor functionality. While many extractors rely on fragile regex-based scraping of HTML pages, the overall architecture is solid and the downloader implements robust features like resume support and configurable retry logic.
This repository is a comprehensive Chinese-language Rust tutorial titled 'Rust Course' (Rust θ―θ¨ε£η»). It is primarily an educational documentation project built with mdBook, producing a static website and a PDF. The content covers Rust from basic syntax to advanced topics like async, unsafe, concurrency, and performance optimization, with over 170 chapters and 1.1 million characters. It also includes a forked and translated version of the rustlings interactive exercise system (rustlings-zh), which provides a CLI tool for hands-on practice. The repository is not a production application but a learning resource; however, the rustlings-zh component is a functional CLI application. The architecture is a static site generator (mdBook) plus a standalone Rust CLI tool. Key entry points are the mdBook configuration (book.toml) and the rustlings-zh main.rs. The project is well-maintained, tracks Rust versions up to 1.89, and has active community contributions.
mitmproxy2swagger is a CLI tool that automatically converts HTTP traffic captures from mitmproxy or browser HAR exports into OpenAPI 3.0 specifications. It enables reverse-engineering REST APIs by analyzing recorded traffic without manual inspection. The tool uses a two-pass workflow: the first pass identifies API paths and generates a template file with parameter placeholders; after the user edits the template to select endpoints, the second pass produces full endpoint descriptions with inferred request/response schemas. Architecturally, the tool is a single-purpose Python application organized into modular components: input readers (mitmproxy_capture_reader.py for binary flow files, har_capture_reader.py for HAR JSON), a core orchestration module (mitmproxy2swagger.py) that handles argument parsing, format auto-detection, and schema merging, and utility modules (swagger_util.py for OpenAPI schema generation, console_util.py for progress display). The tool supports multiple content types (JSON, msgpack, form-urlencoded) and can optionally include example data and headers in the output. Key entry points are the `mitmproxy2swagger` command with arguments for input file, output path, API prefix, and optional flags. External dependencies include mitmproxy for reading flow files, ruamel.yaml for YAML output, json-stream for streaming HAR parsing, and msgpack for msgpack support. The codebase is well-maintained with CI/CD, tests, Docker support, and pre-commit hooks.