GritQL is a declarative query language and CLI tool for searching, linting, and transforming source code across many programming languages (JS/TS, Python, Java, Go, Rust, Ruby, PHP, SQL, etc.). The repository implements a Rust workspace comprising a pattern-matching engine (grit-pattern-matcher) that compiles GritQL patterns into executable AST-based matchers, a CLI client (grit) with commands like `apply`, `check`, `list`, `patterns`, and `lsp`, an LSP server for IDE integration, WebAssembly bindings for browser use (playground), and Node.js NAPI bindings for programmatic access. Patterns are authored in `.grit` files or embedded in Markdown with sample-based testing. The system uses tree-sitter parsers (vendored grammars) to parse source files, supports pattern caching for performance, and includes authentication, analytics, and remote module resolution. The architecture is modular: core pattern matching is isolated in `crates/grit-pattern-matcher`, pattern compilation in `crates/core`, language support in `crates/language`, and UX in `crates/cli`. The documentation site (Next.js with Markdoc) provides an interactive playground. External dependencies include tree-sitter parsers, NAPI-RS, WebAssembly tooling, and optional LLM APIs for AI-assisted patterns.
CorsixTH is a comprehensive open-source reimplementation of the 1997 Bullfrog game Theme Hospital. It reconstructs the original game's mechanics faithfully using a C++ engine for performance-critical subsystems (rendering, audio, pathfinding, file I/O) and Lua scripting for game logic, UI, and data definitions. The architecture is a monolithic desktop application with separate utility tools (a Java level editor, a wxWidgets animation viewer, and a sprite encoder). The Lua codebase is extensive, featuring a custom class system, humanoid action queue pattern, room/object definitions, localization support, and a persistent save/load system. The game runs cross-platform on Windows, macOS, Linux, and BSD via SDL3. Notable reusable patterns include a lightweight OOP framework (class.lua), a generic pathfinder with multiple search strategies, a virtual filesystem abstraction, and an RNC decompression library. The project is actively maintained with CI, issue templates, and a large community, though some subsystems (e.g., movie player, MIDI) rely on optional dependencies.
This repository is a Python library and framework for building and deploying multi-agent AI systems. It provides a structured way to define agents with specific roles, instructions, tools, and communication flows, orchestrated by an Agency. The framework extends the OpenAI Agents SDK with production-grade features: FastAPI web serving with streaming SSE endpoints, realtime voice support via WebSocket and Twilio, MCP (Model Context Protocol) server integration with OAuth authentication, persistent conversation state with load/save callbacks, system reminders for prompt engineering, input/output guardrails, and observability hooks for Langfuse/AgentOps. It also includes CLI tools for scaffolding agents and migrating from OpenAI Assistant configurations. Architecturally, the system is a library that can be used programmatically (create Agent and Agency instances, call get_response) or deployed as a FastAPI application via run_fastapi(). The core data flow involves user messages flowing through an agent's execution pipeline, which may invoke tools (built-in, MCP, OpenAPI, LangChain), hand off to other agents via SendMessage/Handoff, and stream responses back. The ThreadManager provides flat message storage with agent/caller metadata, supporting thread isolation and persistence. The tool system uses Pydantic models for schema generation and supports concurrency control. Key entry points include the Agent and Agency classes for programmatic use, run_fastapi() for web deployment, run_realtime() for voice, run_mcp() for MCP server, and CLI commands (create-agent-template, migrate-agent, import-tool). External dependencies include the OpenAI Agents SDK (pinned), FastAPI, Pydantic, and optional integrations like LiteLLM, LangChain, and MCP SDK. The codebase demonstrates strong engineering practices with extensive test coverage (unit, integration, live API), modular design, and reusable patterns such as the BaseTool class, ToolFactory adapter, ThreadManager message store, and OAuth flow for MCP. However, it has tight coupling to the OpenAI Agents SDK internals, requiring careful maintenance as the SDK evolves.
Virtual Kubelet is an open-source Kubernetes kubelet implementation that acts as a proxy between Kubernetes and external container orchestration APIs. It exposes the standard kubelet HTTP endpoints (pods, logs, exec, attach, portforward, stats, metrics) but delegates pod lifecycle management to pluggable providers. The architecture centers on a provider interface (`PodLifecycleHandler`, `NodeProvider`, `PodNotifier`) that any backend can implement, enabling Kubernetes to schedule pods on services like AWS Fargate, Azure Container Instances, or custom infrastructure. The core logic resides in the `node` package, which contains controllers for pod reconciliation, node registration/heartbeat, and status synchronization. The project includes a mock provider for testing, comprehensive unit and e2e tests, and supports tracing (OpenTelemetry, OpenCensus) and structured logging (logrus, slog, klogv2). It is a CNCF sandbox project with production adopters including Microsoft, AWS, and Alibaba.
DistroAV is an OBS Studio plugin that integrates NDI (Network Device Interface) technology, enabling high-quality, low-latency video and audio streaming over a local network. It allows OBS to act as both an NDI source (receiving streams) and an NDI output (sending streams), with additional per-source NDI output via a filter. The plugin is built as a native OBS module, dynamically loading the NDI SDK at runtime. It features a Qt6-based settings dialog for configuring output names, tally indicators, and update checks. The architecture is modular: separate source, output, and filter implementations, a configuration singleton with command-line overrides, and a background NDI source finder. The codebase is cross-platform (Windows, macOS, Linux) with a robust CMake build system and CI/CD pipelines using GitHub Actions. It demonstrates solid engineering practices including thread-safe config management, async HTTP updates via libcurl, and comprehensive localization support.
This is a Vim plugin that visualizes the undo history of a buffer as a tree, allowing users to navigate between different undo branches. It parses Vim's internal `undotree()` data structure and renders an ASCII representation in a dedicated split window. The architecture follows an object-oriented pattern in Vim script, with classes for panels (undotree and diffpanel) encapsulating state and behavior. Key features include: window layout customization, diff panel with sign highlighting, relative timestamps, configurable tree shapes, and support for persistent undo. The plugin is purely Vim script and depends only on an external diff command for the diff panel. It is well-maintained, actively used, and avoids deprecated Vim APIs. The code demonstrates high craftsmanship in Vim scripting, particularly in the ASCII tree rendering algorithm and the diff caching mechanism.
Reddit Enhancement Suite (RES) is a browser extension that enhances the Reddit browsing experience. It injects a content script into Reddit pages and provides dozens of modular features such as inline media expansion, keyboard navigation, user tagging, account switching, night mode, content filtering, and comment tools. The architecture is modular: each feature is a self-contained Module with lifecycle hooks, and media support is extensible via a Host plugin system. The extension communicates between foreground (content script) and background (service worker) using a custom messaging abstraction built on browser runtime ports. Persistent configuration and user data are stored via a storage wrapper layer that supports key-value, prefix, and blob modes with atomic compare-and-set semantics. The build pipeline uses esbuild with Flow type stripping, and the project includes integration tests via Nightwatch and unit tests via ava. The codebase is mature and well-organized, though it relies on older patterns (Flow, jQuery, lodash) and is tightly coupled to Reddit's DOM and API, which introduces maintenance risk when Reddit changes. There are no data analysis or research components; it is purely a client-side enhancement application.
Emissary (formerly Ambassador) is a Kubernetes-native API gateway and ingress controller built on top of Envoy proxy. In production, it dynamically generates Envoy configuration from Kubernetes custom resource definitions (CRDs) such as Mappings, Hosts, Listeners, AuthServices, RateLimitServices, and TLSContexts. The architecture is split into a Go-based control plane that watches Kubernetes resources, Consul service discovery, and filesystem inputs, and a Python-based sidecar that compiles an intermediate representation (IR) into Envoy v3 configuration JSON. The control plane manages envoy processes, health monitoring, and configuration updates via a rate-limited xDS/ADS server (ambex). The system supports a wide range of features including TLS termination/origination, authentication (gRPC/HTTP), rate limiting, tracing (Zipkin, OpenTelemetry, Datadog), shadow traffic, canary releases, circuit breakers, CORS, gzip, and more. Key entry points include the Go entrypoint (cmd/entrypoint/entrypoint.go) which orchestrates envoy, diagd, ambex, and watcher processes; the Python compiler (python/ambassador/src/ambassador/compile.py) which processes configuration; and the API extension server (cmd/apiext/main.go) for CRD conversion webhooks. The primary data flow is: Kubernetes CRDs or Consul endpoints are watched and collected into snapshots, which are then compiled by the Python sidecar into Envoy configuration JSON, pushed to envoy via ADS. The system relies heavily on Kubernetes APIs, Envoy proxy, Consul (optional), and various observability backends. The codebase is polyglot (Go and Python) with a complex build system using Makefiles, Helm charts, and Docker images. It includes an extensive test suite with unit tests, integration tests (KAT), and end-to-end tests. The project is production-grade but shows signs of technical drift with deprecated features, dual-language synchronization challenges, and some workarounds.
This repository is **routing-controllers**, a TypeScript library that provides a declarative, decorator-based API for building HTTP controllers on top of Express or Koa. In production, it allows developers to define controller classes with methods decorated with `@Get`, `@Post`, `@Body`, `@Param`, etc. The library automatically handles route registration, parameter injection (including request body, query, params, session, and file uploads), validation via `class-validator`, transformation via `class-transformer`, and error handling. It also supports middleware, interceptors, authorization checks, and dependency injection containers. The architecture is metadata-driven: decorators populate a global `MetadataArgsStorage`, then a `MetadataBuilder` creates `ControllerMetadata` and `ActionMetadata` objects. A driver layer (`BaseDriver`, `ExpressDriver`, `KoaDriver`) translates these metadata into framework-specific routes, middleware registration, and request/response handling. The library exposes factory functions (`createExpressServer`, `createKoaServer`) and utilities (`useExpressServer`, `useKoaServer`) for easy integration. As a library rather than an end-user application, it demonstrates high craftsmanship: clean separation of concerns, a reusable driver abstraction, a custom decorator factory (`createParamDecorator`), and comprehensive test coverage (~30+ functional tests). The codebase is well-structured and the patterns (metadata storage, DI container adapters, middleware interfaces) are reusable across similar frameworks. Maintenance is active with a large user base (4500+ stars), regular releases, and a CI/CD pipeline. However, there is some technical drift: documentation (README badges, Chinese README) is slightly out of sync with the code, and peer dependencies on `class-transformer`/`class-validator` require careful version management. Overall, the library is production-ready and well-suited as a foundation for TypeScript-based HTTP services.
doctoc is a CLI tool that automatically generates and updates a table of contents (TOC) for Markdown files. It parses markdown and HTML headings, creates anchor links compatible with GitHub, GitLab, Bitbucket, and other platforms, and inserts the TOC into the file between special comment markers. The tool supports a wide range of configuration options including heading level limits, custom titles, ordered/unordered lists, indentation styles, and pragma comment styles (legacy or compact). It can operate on single files or recursively scan directories, and offers a dry-run mode for CI validation. The architecture is a straightforward Node.js CLI application. The entry point is `doctoc.js`, which parses command-line arguments via `minimist` and delegates to `lib/transform.js` for the core TOC generation logic. `lib/transform.js` uses `@textlint/markdown-to-ast` to parse Markdown into an AST, `htmlparser2` to extract HTML headings, and `anchor-markdown-header` to generate anchor links. `lib/content-generation.js` handles the creation of comment markers (pragmas) for different syntaxes (`.md`, `.mdx`) and styles. `lib/file.js` provides recursive file discovery. The tool is distributed as an npm package and can also be used as a pre-commit hook via the provided `.pre-commit-hooks.yaml`. External dependencies are minimal and well-chosen: `@textlint/markdown-to-ast` for parsing, `htmlparser2` for HTML parsing, `anchor-markdown-header` for anchor generation, `loglevel` for logging, and `minimist` for argument parsing. The codebase is written in CommonJS style with `'use strict'`, and tests use the `tap` framework with a comprehensive suite of fixtures covering edge cases like frontmatter, emoji headers, nested markdown, and various formatting options.
Docfx is a documentation site generator that builds static HTML/PDF sites from Markdown, .NET source code, and Swagger/OpenAPI specifications. It is a CLI application written in C# that orchestrates a multi-stage build pipeline: configuration loading, file collection, document processing (conceptual Markdown, .NET API reference, REST API, schema-driven documents), template rendering with Mustache-like templates and JavaScript preprocessors, cross-reference resolution, and post-processing (search index, sitemap, bookmark validation). The system supports multiple output formats including HTML (with several themes), PDF, YAML, and JSON, and provides a local preview server. The architecture is modular with a plugin system based on MEF exports for document processors, build steps, and post-processors. Key entry points include the CLI commands (build, serve, pdf, init, merge, download, metadata) defined in src/Docfx.App, and the core build orchestration in src/Docfx.Build. The codebase is extensive with over 1700 files, including a custom Markdig-based markdown engine with many extensions (tab groups, triple-colon blocks, code snippets, xref, plantuml), a custom YAML serialization layer, and a dual JSON serializer (Newtonsoft.Json and System.Text.Json) for configuration and data contracts. Data flows begin with a docfx.json configuration file that specifies content sources, metadata, templates, and output settings. The build engine collects files using glob patterns, processes them through document-specific processors (e.g., DotnetApiCatalog for .NET assemblies, SwaggerJsonParser for REST APIs), applies overwrite documents for user customizations, resolves cross-references via XRef maps, renders templates, and finally runs post-processors to generate the final site artifacts. External dependencies include Roslyn (for .NET source analysis), Markdig (markdown parsing), YamlDotNet, HtmlAgilityPack, Spectre.Console, and Playwright (for PDF generation).
53AIHub is an open-source enterprise AI knowledge management and agent orchestration platform. The codebase reveals a multi-tenant SaaS/self-hosted system that allows organizations to build, deploy, and operate AI agents across multiple backends (OpenAI, Coze, Dify, Gemini, etc.), manage knowledge bases with full RAG pipelines (document parsing, chunking, embedding, graph extraction, wiki generation), record and transcribe meetings with insight extraction, and provide a unified search and chat interface. The architecture is a Go monolith backend using Gin and GORM, with a monorepo frontend comprising three React apps (admin console, end-user portal, and embeddable agent plugin) sharing a common business logic and component library. Data flows center on document ingestion pipelines, real-time agent relay with tool execution, and recording/speech processing. The system integrates with vector stores (Qdrant), Elasticsearch, Redis, and various LLM providers. While primarily an application, it contains substantial data processing pipelines characteristic of a data_research project, particularly the RAG and recording insight modules.
This repository implements MiniMind-3o, a small-scale Omni model (text/audio/image input, text/streaming audio output) designed for educational and research purposes. The system uses a Thinker–Talker dual-path architecture: a language model (Thinker) processes multimodal input and produces text tokens, which are then fed to a Talker module that generates audio codes using the Mimi codec and decodes to PCM audio. It supports voice cloning via reference audio, scheduled sampling during training, and staged training (T2A → A2A → I2T). Multiple inference interfaces are provided: a CLI (`eval_omni.py`), a Gradio web demo, and a real-time WebSocket-based WebUI with VAD and barge-in capability. The codebase is well-structured with clear separation of concerns, and the Thinker–Talker decoupling pattern is a notable architectural contribution. While primarily an application, it includes research-oriented components such as ablation studies and a technical report, making it a hybrid project with a strong application focus.
The Social Media Hacker List repository primarily maintains a curated markdown list of tools and applications for enhancing social media experiences across various platforms (Facebook, Instagram, Twitter, etc.). The list is organized by platform and includes entries such as alternative clients, analytics tools, bots, and content creation utilities. Each entry is manually curated and must meet specific inclusion criteria, such as being created by unaffiliated developers and having recent activity. To ensure the list remains accurate and free of broken or inactive links, the repository includes a Rust-based URL checker application. This tool is executed weekly via a GitHub Actions workflow (check.yaml) to validate every URL in the README.md. For standard URLs, it performs HEAD and GET requests, treating certain HTTP status codes as success (200, 403, 406) with special handling for known edge cases (e.g., 502 for reddit.com, 429 for apps.apple.com). For GitHub repository URLs, it uses the GitHub API to check if the repository is archived or has not been pushed to in the last 365 days, flagging such entries as invalid. The checker application is designed as a standalone, concurrent command-line tool. It reads input from stdin, extracts URLs using a regular expression, and processes them asynchronously with the tokio runtime. The application is containerized via a multi-stage Dockerfile and published to GitHub Container Registry through another workflow (publish.yaml), allowing it to be reused in other contexts. The code demonstrates solid Rust practices, including proper error handling, asynchronous I/O, and modular function design, making its core URL and GitHub checking logic potentially reusable in other projects with minimal adaptation.
This repository provides a lightweight CLI tool (`vision.js`) that enables text-only AI models (like Claude Code without native vision) to 'see' images by converting them to text via an external vision API. The core script reads images from local files, URLs, or the system clipboard (via platform-specific helpers for macOS and Windows), encodes them as base64, and sends them to any OpenAI-compatible vision API (defaulting to Alibaba Cloud's DashScope). It features automatic clipboard fallback, configurable API credentials via environment variables, and clear error handling. The repo also includes documentation files (`AGENTS.md`, `CLAUDE.md`, `SKILL.md`) that instruct AI agents on when and how to invoke the script, plus integration instructions for the cyberboss chatbot framework. It is a practical, well-structured utility that solves a common limitation of text-only AI models.
This repository implements a Python library for performing technical analysis of stock price data based on 'Chan Theory' (缠论). It calculates core elements such as strokes (笔), segments (线段), central hubs (中枢), and buy/sell points (买卖点) from K-line (OHLC) data. The system supports multiple data sources (BaoStock, AKShare, CSV, CCXT) and multiple timeframes (day, week, month, minute). The architecture is modular: the central CChan class orchestrates the analysis, with submodules for strokes (Bi), segments (Seg), hubs (ZS), buy/sell points (BuySellPoint), mathematical indicators (Math), plotting (Plot), and data access (DataAPI). Key entry points include main.py for demonstration, App/ashare_bsp_scanner_gui.py for a GUI-based stock scanner, and the CChan class for programmatic use. Data flows from user-provided stock codes and time ranges through the data API, then through the analysis pipeline (K-line combination, stroke detection, segment calculation, hub identification, buy/sell point detection), and finally outputs results that can be plotted or accessed via object properties. External dependencies include baostock, akshare, ccxt, matplotlib, numpy, pandas, and requests.
WaterCrawl is a full-stack web crawling and data extraction platform, built as a SaaS-style multi-tenant application. The backend is implemented in Django 5.1 with Django REST Framework, providing REST APIs for crawl requests (single/batch URL), web search (Google Custom Search integration), sitemap generation, and proxy server management. Asynchronous task execution is handled by Celery workers that invoke Scrapy spiders (SiteScrapper, GoogleCustomSearchScrapper, SitemapScrapper) and optionally use Playwright for JavaScript rendering. Real-time status updates are pushed to the frontend via Redis Pub/Sub and Server-Sent Events (SSE). The frontend is a React SPA (with TypeScript, Tailwind CSS, react-hook-form) that provides dashboard pages for configuring and monitoring crawl/search/sitemap jobs, managing teams and API keys, viewing usage statistics, and handling subscription billing through Stripe. Authentication supports JWT (simplejwt) and OAuth (Google, GitHub), with email verification and team invitation flows. The application stores extracted content (markdown, HTML, attachments) in MinIO or S3-compatible storage, and metadata in PostgreSQL.
code996 is a Node.js/TypeScript CLI tool that analyzes Git commit timestamp distributions to quantify work intensity and overtime patterns, producing a '996 index' score (named after the Chinese 9am-9pm-6day work schedule). It runs entirely locally via `git log`, collecting commit times, contributors, and timezones, then applies percentile-based algorithms to detect work start/end hours, compute overtime ratios (weekday/weekend/late-night), classify projects as corporate vs. open-source, detect cross-timezone teams, and adjust for Chinese holidays/makeup workdays. Output is rendered as a terminal report, offline Vue 3 web report (chart.xkcd visualizations, file:// compatible), JSON, or Markdown, with full zh-CN/en i18n. The tool explicitly targets job seekers and new team members to verify work-life balance claims against real commit data, and includes a disclaimer about accuracy limits (meetings, debugging, and non-coding work are invisible to git).
Microcks is an open-source API mocking and testing platform that ingests API contracts (OpenAPI, AsyncAPI, gRPC, GraphQL, SOAP, Postman, etc.) and generates live mock endpoints, validates conformance, and supports event-driven messaging (Kafka, MQTT, AMQP, SNS, SQS, NATS, WebSocket). The backend is a Spring Boot application with MongoDB persistence, Keycloak-based security, and OpenTelemetry observability. An Angular frontend provides dashboards, service management, test execution, and live trace visualization. A separate Quarkus-based async minion handles message consumption and production for async protocols. The codebase is well-modularized with a commons layer (domain model, expression language, validation utilities) and a webapp layer with REST controllers, service classes, and sophisticated mock dispatch logic. Notable patterns include a template engine for dynamic mock responses, a JSON expression evaluator for dispatch criteria, and a SoapUI-compatible assertion framework. The project shows strong engineering practices with extensive test coverage (unit, integration, fuzz) and CI/CD pipelines, though there is some technical drift in legacy Angular components and deprecated OAuth2 grant support.
DeePMD-kit is a deep learning package for many-body potential energy representation and molecular dynamics. It provides a multi-backend framework (TensorFlow 1.x/2.x, PyTorch, JAX, PaddlePaddle) for training and deploying neural network interatomic potentials. The system supports a wide range of physical properties (energy, forces, virials, dipoles, polarizabilities, DOS, Hessians, spin forces) and integrates natively with LAMMPS, ASE, i-PI, and other MD engines. The architecture is centered around a backend-agnostic reference layer (`deepmd/dpmodel/`) that defines descriptors, fitting networks, models, and losses using a common array API, with each backend providing thin wrappers and custom CUDA/Triton kernels for performance. Key entry points include the `dp` CLI (train, freeze, compress, test, convert-backend), the LAMMPS pair styles (`pair_deepmd`, `pair_deepspin`, `pair_dpa4spin`), and the Python inference API (`DeepPot`, `DeepEval`). The codebase also includes a pretrained model registry, fine-tuning utilities, and an experimental export pipeline (`pt_expt`) for compiled model deployment. While primarily an application framework, it has strong research character with extensive model architectures, data pipelines, and cross-backend consistency tests.