Framefox is a full-stack Python web framework built on FastAPI and SQLModel, designed for building modern web applications with a focus on developer productivity. It follows an MVC architecture with clean separation of concerns, featuring a robust dependency injection container, comprehensive security system (including JWT, OAuth, CSRF protection, and brute force prevention), form handling and validation, session management, and a powerful CLI for code generation. The framework includes built-in profiling and debugging tools, task queuing capabilities, and email services. Its architecture emphasizes SOLID principles, with well-defined layers for controllers, services, repositories, and entities, making it suitable for both traditional web applications and API-driven projects.
Flameshot is a powerful cross-platform screenshot application written in C++ with Qt. It provides a GUI for capturing screen regions, annotating with various tools (arrows, circles, text, pixelation, etc.), and saving or uploading images to Imgur or other services. The architecture includes a command-line interface for scripting, a background daemon for system tray and global shortcuts, and a DBus interface for desktop integration. Internally, it is a monolithic desktop app with a modular tool system (each annotation tool is a separate class) and a config system with validation. The codebase is well-structured but carries platform-specific workarounds (Wayland, Windows registry hacks) and some legacy code, leading to medium technical drift. It is actively maintained with recent commits, though translations show signs of staleness.
Paru is an AUR (Arch User Repository) helper and pacman wrapper written in Rust. It provides a command-line interface for searching, building, installing, and managing packages from both official Arch repositories and the AUR. The application features a modular architecture with distinct modules for configuration, dependency resolution, installation, and package operations. Key functionalities include interactive package selection, chroot builds, dependency handling, PGP signing, and configurable build options. Paru maintains pacman compatibility while extending it with AUR-specific features like development version tracking and local repository management.
This repository provides `claude-monitor`, a privacy-first CLI application for real-time monitoring of Claude Code usage. It reads local JSONL session logs, computes token consumption, costs, and burn rates, and displays them via a Rich-based terminal UI. The tool supports multiple subscription plans (Pro, Max5, Max20, Custom), integrates with Claude Code's official rate limits via statusline capture, and offers an opt-in persistent usage warehouse for historical analysis. It is distributed as a PyPI package with command aliases `cmonitor` and `ccm`. The architecture is modular, with separate packages for CLI, core logic, data ingestion/analysis, monitoring, output formatting, terminal management, UI components, and utilities. Key entry points include the CLI main module (`cli/main.py`), snapshot builder (`output/snapshots.py`), and monitoring orchestrator (`monitoring/orchestrator.py`). The application is well-tested with over 700 tests covering snapshot, trust-layer, warehouse, UI, timezone, and CLI paths. While primarily an application, it incorporates data engineering patterns such as sessionization, percentile-based limit estimation, and a versioned JSON warehouse. The codebase demonstrates strong craftsmanship with reusable components like the P90Calculator, PricingCalculator, TimezoneHandler, and UsageWarehouse. However, it has some technical drift risks due to hardcoded pricing rates, dependency on Claude Code's internal log format, and experimental API features that may change.
Mistral Vibe is a production-grade terminal-based AI coding agent by Mistral AI. It provides an interactive CLI powered by Textual for multi-turn LLM conversations, file editing, shell execution, and subagent delegation. The system is architected around a core agent loop that orchestrates tool calls with a permission system, session management (resume, rewind, fork), and an event-driven checkpointing mechanism for file state snapshots. It integrates with multiple LLM providers (Mistral, Anthropic, OpenAI, Vertex) via a backend adapter pattern, and supports external integrations through MCP (Model Context Protocol) servers, custom hooks, and a skill system. The codebase heavily employs layered configuration, ports/adapters for audio, notifications, and update checking, and includes an app server for IDE integration via the ACP (Agent Communication Protocol). It also features telemetry via OpenTelemetry and GrowthBook-based experiments. The repository is actively maintained with recent commits, a comprehensive test suite (>1400 tests), and CI/CD pipelines for PyPI releases and PyInstaller binaries.
Auto-Redbook-Skills is a CLI tool for creating and publishing Xiaohongshu (Little Red Book) social media notes. It takes Markdown content with YAML front matter, renders it into a cover image and multiple card images using Playwright (headless browser), and optionally publishes the note to Xiaohongshu via a built-in, reverse-engineered HTTP signature client. The tool supports 8 visual themes (e.g., sketch, neo-brutalism, botanical) and 4 pagination modes (manual separator, auto-fit, auto-split, dynamic height). The publishing pipeline is entirely self-contained within the repository, using a vendor module that implements the Xiaohongshu creator platform's authentication, signing, and upload protocols without external API services. The project is primarily a content creation automation tool, not a data research project, though it does involve some data transformation (Markdown to images).
Av1an is a hyper-scalable video encoding framework written in Rust, designed to parallelize encoding of AV1 (and other codecs) by splitting videos into scenes, encoding each scene independently, and concatenating the results. It supports multiple encoders (aomenc, SVT-AV1, rav1e, x264, x265, vpx) and provides advanced features like target quality (iterative probing to achieve a desired VMAF/SSIMULACRA2/Butteraugli score), VapourSynth integration for frame-accurate input and metric calculations, and scene detection via av-scenechange. The architecture is a classic library+binary workspace: `av1an-core` contains all encoding logic, chunk management, metrics, interpolation, and concatenation, while the `av1an` binary provides a CLI interface with extensive options for chunking methods, encoder parameters, zones, and resume capabilities. The system relies heavily on external tools (ffmpeg, mkvmerge, vspipe, encoder binaries) and uses a broker-based worker pool for parallel encoding with progress bars and Ctrl+C handling. The codebase is well-tested with integration tests that run actual encodes, and includes a dedicated interpolation module with eight methods (linear, natural cubic spline, Fritsch-Carlson, PCHIP, quadratic, cubic polynomial, Catmull-Rom, Akima) that is self-contained and reusable. While the project demonstrates strong engineering practices (modular design, extensive tests, CI/CD), it carries some technical debt: heavy use of nightly Rust features, global state via OnceCell, many unwrap/expect calls, and tight coupling to external tool versions. The repository is actively maintained with recent commits and a responsive issue tracker.
ReNative (rnv) is a cross-platform development CLI tool and framework that enables building applications for mobile (iOS, Android), web, TV (Tizen, webOS, Fire TV, Android TV, tvOS), desktop (macOS, Windows, Linux, Electron), wearables, and consoles from a single codebase. The system uses a monorepo architecture with modular packages: a core library (`@rnv/core`) providing configuration merging, plugin management, template injection, and task orchestration; platform-specific engines (`@rnv/engine-rn`, `@rnv/engine-rn-electron`, `@rnv/engine-rn-next`, etc.) that define build logic and native project templates; SDK packages (`@rnv/sdk-android`, `@rnv/sdk-apple`, `@rnv/sdk-tizen`, etc.) for platform-specific tooling like device management and code generation; and a CLI entry point (`rnv`) that dispatches commands to registered tasks. The primary data flow involves reading hierarchical configuration files (`renative.json`, `appConfigs/`), merging them with plugin definitions and engine defaults, injecting placeholders into platform templates (e.g., AndroidManifest.xml, Xcode project files, Webpack configs), and then invoking native build tools (Gradle, Xcode, Webpack, etc.) to produce deployable artifacts. External dependencies include React Native, Electron, Next.js, Webpack, and platform SDKs (Android SDK, Xcode, Tizen SDK, webOS SDK). The framework also includes a telemetry module, Docker integration, and a build hooks system for custom pre/post-publish scripts.
EvoSkill is a CLI tool and Python library for automatically discovering and improving skills for coding agents. It implements a self-improvement loop: a base agent is evaluated on a task, failures are analyzed by a proposer agent which suggests skill/prompt mutations, a generator creates new skills/prompts, and the evolved agent is re-evaluated. The best programs are tracked via git branches, enabling frontier management and rollback. The system supports multiple agent SDKs (Claude Code, Codex CLI, OpenCode, OpenHands, Goose, Harbor) through a unified harness abstraction, allowing the same evolution loop to work across different agent platforms. The architecture is modular: CLI commands (init, run, eval, skills, diff, logs, reset, remote) provide the user interface; an API layer (EvoSkill, EvalRunner) offers programmatic access; the loop engine (SelfImprovingLoop) orchestrates the evolution; the registry (ProgramManager) handles git-based program versioning; the harness layer abstracts SDK-specific execution with retry, timeout, and structured output parsing; agent profiles define role-specific configurations (base agent, proposer, generator, evaluator); and evaluation modules support multiple scoring methods (exact match, tolerance, LLM-as-judge, script-based, Harbor). External dependencies include various agent SDKs (claude-agent-sdk, opencode-ai, openhands-ai, etc.), LLM providers (OpenRouter, Fireworks), and infrastructure tools (Docker, Daytona for remote execution). The repository also includes example benchmarks (OfficeQA, SEAL-QA, Dabstep, LiveCodeBench) with datasets and evaluation scripts, demonstrating the system's application to real-world tasks. The codebase exhibits strong engineering practices with clean abstractions, reusable components, and comprehensive testing, though there are some areas of duplication (e.g., skill-creator scripts) and global mutable state in the SDK configuration.
OpenDoor is an advanced CLI security reconnaissance platform for directory discovery, subdomain enumeration, WAF detection, and content fingerprinting. It employs a modular architecture with a plugin-based analysis pipeline (sniffers), network transport abstraction (direct, proxy, VPN), and extensive output formatting (JSON, CSV, SQLite, SARIF). Its core scanning engine, state machine, and plugin systems demonstrate sophisticated engineering, featuring auto-calibration, semantic soft-404 diffing, and a clean exception hierarchy.
rclip is a command-line semantic photo search tool that indexes local image collections using a CLIP model (OpenCLIP ViT-B/32-256) and supports natural-language, image-to-image, and combined queries with boolean operations. The core architecture is monolithic: a Python package with modules for model inference (ONNX/CoreML), SQLite-based feature caching, image preprocessing, and a Textual terminal user interface for interactive browsing. It is fully offline and privacy-preserving, supporting a wide range of image formats including HEIC, raw (CR2, DNG, ARW), and standard web formats. The tool is distributed via PyPI, Snap, AppImage, Homebrew, and Windows MSI, with careful compliance management for third-party licenses, codecs, and model artifacts. It includes an extensive test suite (unit and end-to-end), CI/CD via GitHub Actions, and a compliance toolkit that enforces license policies during builds. The codebase is well-structured and demonstrates good engineering practices, though it relies on a pinned version of textual-image that uses a private API, introducing some technical drift risk.
Paperclip is a Rust toolkit for working with OpenAPI specifications. It provides code generation for type-safe HTTP clients and servers from OpenAPI v2/v3 specs, procedural macros to derive OpenAPI annotations from Rust code, and an Actix-web plugin for serving generated specs and integrating with handlers. The architecture is modular with separate crates for core types, macros, Actix integration, and CLI tools. Key features include reference resolution with cycle detection, emitter-based code generation strategy, builder patterns with compile-time field validation, and macro-driven spec generation. The project is actively maintained with recent commits, CI workflows, and frequent version updates.
llama-benchy is a CLI tool for benchmarking OpenAI-compatible LLM endpoints, providing detailed performance metrics similar to llama-bench. It measures prompt processing and token generation speeds at various context depths, supports concurrent requests, prefix caching analysis, and multiple output formats. The tool features a modular architecture with separate modules for HTTP client logic, result processing, and progress reporting. It uses asynchronous HTTP requests to efficiently handle concurrent benchmarking and includes sophisticated logic for handling streaming responses, token timing reconstruction, and latency measurement. The tool is actively maintained with recent commits and up-to-date dependencies.
feedgrab is a universal content aggregation tool that fetches, normalizes, and saves content from 18+ platforms (Twitter/X, Xiaohongshu, WeChat, YouTube, Bilibili, GitHub, HackerNews, Medium, Reddit, Weibo, Douyin, Telegram, RSS, Feishu, Kdocs, Zsxq, FlowUs, and more) into Obsidian-compatible Markdown files with YAML frontmatter. It operates as a CLI tool, a Python library, and an MCP server, featuring a modular architecture with per-platform fetchers that implement a multi-tier fallback strategy (direct API → CDP browser reuse → Playwright launch → Jina Reader) to maximize resilience against anti-scraping measures. The system includes robust utilities for deduplication, media download, Groq Whisper transcription, paywall bypass, and cookie rotation for authenticated platforms. Originally developed as a 'vibe coding' personal project, it has evolved into a well-structured application with a service layer, typed configuration, and comprehensive CLI commands (login, doctor, batch search, setup wizard). It is actively maintained, with frequent commits addressing platform API changes and adding new features.
git-credential-keepassxc is a Rust-based Git credential helper that enables Git and shell scripts to store and retrieve credentials from KeePassXC. It implements the KeePassXC browser protocol to communicate with the password manager via socket/named pipe interfaces. The application provides subcommands for getting credentials (get), generating TOTP codes (totp), storing credentials (store), managing configuration (configure), verifying caller identity (caller), and other auxiliary functions. It features optional security enhancements including strict caller verification, YubiKey-based encryption of configuration files, and desktop notifications. The architecture follows a modular Rust CLI pattern with clear separation between argument parsing, configuration management, core protocol implementation, and utility functions.
Centerline is a Python library for computing the medial axis (centerline) of polygon geometries using Voronoi diagrams. It provides both a programmatic API via the Centerline class and a command-line interface (create_centerlines) for processing vector files. The library takes polygon/multipolygon inputs, generates a Voronoi diagram from densified boundaries, filters ridges contained within the input geometry, and unions them to produce a multilinestring output while preserving attribute data. The architecture separates core algorithmic logic (geometry.py) from I/O and CLI concerns (converters.py), with proper error handling via custom exceptions.
Lorem Ipsum.js is a JavaScript library that generates placeholder lorem ipsum text for use in web development, design mockups, and other applications requiring dummy text. It provides both a programmatic API and a command-line interface, supporting output in plain text or HTML formats with configurable parameters for word, sentence, and paragraph counts. The library is designed to work across multiple JavaScript environments including Node.js, web browsers, and React Native. The architecture follows a modular structure with clear separation of concerns: core text generation logic resides in lib/, utility functions in util/, constants in constants/, and the CLI interface in bin/. The main entry point exports a loremIpsum() function that accepts configuration options and delegates to specialized classes for generation and formatting. The system handles platform-specific details like line endings and clipboard operations through environment detection utilities. Key features include robust input validation, cross-platform compatibility, customizable word lists and length bounds, and proper error handling. The library implements defensive programming practices with comprehensive type safety via TypeScript, extensive unit testing, and attention to edge cases such as unsupported platforms or invalid parameters. The CLI tool offers additional functionality like copying generated text to the system clipboard.
Syntheseus is a Python package for retrosynthetic planning that provides a unified framework for integrating various single-step reaction models with search algorithms to find synthetic routes from target molecules to available starting materials. The package features a plugin architecture that allows users to plug in different reaction models (such as Chemformer, GLN, LocalRetro, etc.) and search algorithms (like MCTS, Retro*, Breadth-First, etc.) through well-defined abstract base classes. It includes command-line interfaces for running end-to-end searches and evaluating single-step model performance, along with tools for route analysis and visualization. The architecture emphasizes separation of concerns: the interface module defines core abstractions (molecule, reaction, bag, and models), the reaction_prediction module handles model loading and inference, and the search module implements the search algorithms and graph representations. This design enables easy extension and experimentation with new models and algorithms. The package is actively used in academic research and has been applied in recent publications for benchmarking retrosynthesis approaches.
xword-dl is a command-line tool that downloads crossword puzzles from over 30 online outlets and saves them in the standard .puz format. The codebase implements a plugin-based architecture where each outlet (e.g., New York Times, Guardian, Los Angeles Times) has its own downloader subclassing a base class. The main entry point (xword_dl.py) discovers plugins via package walking, parses command-line arguments, and dispatches to the appropriate downloader. The download flow consists of locating the puzzle URL (by latest or by date), fetching solver data, parsing the outlet-specific format (JSON, XML, or obfuscated payload) into a unified Puzzle object, sanitizing content for the .puz format, and saving the file. Notable technical challenges handled include deobfuscating AmuseLabs' proprietary encoding using a brute-force BFS key search, authenticating with NYT's subscription API, and translating diverse grid/clue representations into a standardized binary format. The project is actively maintained with pinned dependencies, GitHub Actions CI, and a well-documented plugin pattern. While it lacks unit tests and some downloaders are disabled due to anti-scraping measures, the core architecture is clean and the deobfuscation module is a standout reusable asset.
Sherlock is a monolithic Python CLI for username enumeration across social networks. For a given username it fans out concurrent HTTP probes to roughly 400 external sites (defined declaratively in sherlock_project/resources/data.json), then classifies each response as Claimed / Available / Unknown / Illegal / WAF using three detection modes: HTTP status code, presence/absence of a site-specific error message in the response body, or redirect behavior (redirects disabled, 2xx/3xx means claimed). Requests run in parallel via a requests-futures session capped at 20 workers; an optional per-site regex short-circuits illegal usernames without sending a request, and hardcoded fingerprint strings detect Cloudflare / PerimeterX / AWS WAF blocks. The CLI accepts one or more usernames, supports {?} wildcard expansion into `_`, `-`, `.` variants, and reports results to the terminal via a QueryNotify observer, with optional .txt, .csv, and .xlsx export. The system is fully data-driven: no per-site code exists. Each manifest entry declares the probe URL, error detection method, error signatures, optional headers/request method/JSON payload, and NSFW flag; a JSON Schema (data.schema.json) enforces conditional consistency (e.g., errorMsg required when errorType includes 'message'). By default the manifest is fetched live from https://data.sherlockproject.xyz, with an ephemeral false-positive exclusion list pulled from a dedicated GitHub branch; --local, --json, and --site flags override this behavior. Entry points are the `sherlock` console script, `python -m sherlock_project`, a Docker image entrypoint, and an Apify Actor (.actor/) that wraps the Docker image and pushes JSON results into an Apify dataset. Engineering strengths include the declarative manifest/schema design, a genuinely useful test suite (schema validation, live-target probe tests, randomized false-positive fuzzing, a Unicode regression test for issue #2730), and CI that runs a tox matrix across Python 3.10-3.14t on three OSes, validates only manifest entries modified by a PR, comments the validation summary back on the PR, and updates the exclusions list daily. Weaknesses: nearly all orchestration and output-format logic lives in a ~1,200-line sherlock.py; notify.py uses a module-global result counter; sites.py has mutable default arguments and a dead username_unclaimed parameter; the --print-found flag is always True (store_true combined with default=True); stem is an unused declared dependency; and the request layer relies on requests-futures, an effectively unmaintained library. The project is actively maintained and extremely popular (93k+ stars), and its health depends on hundreds of external sites remaining stable, hence the extensive removed-sites documentation and dedicated false-positive/false-negative issue templates. Technical drift is moderate rather than severe: the Python ^3.9 floor is now EOL, requests-futures is unmaintained, the WAF fingerprint catalog has not been extended since late 2024, and the PyPI readme still documents removed --tor flags.