NapCatQQ is a headless QQ bot framework that integrates with the NTQQ (New Technology QQ) desktop client via native injection and reverse-engineered protocol internals. It implements the OneBot v11 standard protocol, providing HTTP, WebSocket, and SSE network adapters for external bot control, along with a comprehensive web-based management interface (WebUI) for configuration, monitoring, file management, terminal access, and plugin management. The system is organized as a monorepo with over 30 packages, including core QQ protocol interaction (napcat-core), OneBot adapter (napcat-onebot), WebUI backend (Express) and frontend (React), a plugin system, RPC library, protobuf runtime, image size detection, PTY terminal support, and database decryption tools. The architecture is modular but tightly coupled to the NTQQ native wrapper, which is loaded via platform-specific binaries. Key entry points include the shell loader (napcat-shell/napcat.ts) for process management, the framework bootstrap (napcat-framework/napcat.ts), the OneBot adapter initialization (napcat-onebot/index.ts), and the WebUI Express server (napcat-webui-backend/index.ts). Data flows involve receiving QQ events through native listeners, converting them to OneBot events, and dispatching to configured network adapters. Outgoing actions are translated to QQ internal API calls via packet transformers and highway file uploaders. External dependencies include the NTQQ desktop client (required runtime), FFmpeg for media processing, platform-specific native binaries for packet handling and PTY, and various Node.js packages (Express, React, TypeBox, etc.). The project is actively maintained but carries inherent fragility due to its reliance on reverse-engineered QQ internals that may change with QQ updates.
This is a large Vue 3 monorepo (pnpm workspaces + Turborepo) that provides 14 fully functional applications: 7 admin panels (web-*) and 7 public-facing marketing sites (site-*), each built with a different UI framework (Ant Design Vue, Arco Design, Element Plus, iDux, Naive UI, PrimeVue, TDesign). The project demonstrates how to build identical feature sets across multiple UI ecosystems while sharing common business logic, API clients, state management, and build tooling. It includes a Nitro-based mock backend server (apps/backend-mock) for development and a client-side static mock (packages/effects/api/src/static-mock.ts) for GitHub Pages previews. The architecture is modular: shared packages under packages/ (api, request, stores, preferences, styles, types, utils, locales, constants) are consumed by all apps, while internal packages (vite-config, lint-configs, node-utils) provide centralized tooling. Key entry points include each app's main.ts, layout component, and router. Data flows through an Axios-based HTTP client (packages/effects/request) with token injection, Pinia stores for user and app state, and a preferences composable for theme/locale management. External dependencies include Vue 3, Vite 8, TypeScript 6, Tailwind CSS v4, Pinia, Axios, ECharts, and the seven UI libraries. The monorepo is designed as a showcase and boilerplate for enterprise front-end architecture, not a specific product.
TraceAI is a multi-language (Python, TypeScript, Java, C#) OpenTelemetry-based instrumentation SDK for AI/LLM applications. It provides drop-in auto-instrumentation for 50+ LLM providers, agent frameworks (LangChain, LlamaIndex, CrewAI, AutoGen, etc.), and vector databases (Pinecone, ChromaDB, Qdrant, etc.). The core library wraps SDK calls to capture structured spans with semantic attributes (tokens, model, messages, tool calls) and exports them via OTLP to any OpenTelemetry-compatible backend, with a default hosted backend at Future AGI. The architecture is a monorepo with per-framework packages that follow a consistent instrumentor pattern: register a tracer provider, instrument the target library, then make API calls. Key entry points are `register()` (Python/TypeScript), `TraceAI.init()` (Java), and `TraceAI.Register()` (C#). The SDK also includes context attribute propagation, PII redaction, evaluation tags, and configurable masking. While the codebase is well-structured and actively maintained, there is significant duplication across framework instrumentors and some tests rely on heavy mocking, which limits reusability of individual components.
OpenCut is a free and open-source video editor being rewritten from scratch. The repository is a monorepo containing a web application (React with TanStack Router, shadcn/ui components, Cloudflare Workers deployment), a desktop application (Rust with GPUI framework), a minimal API (Elysia on Cloudflare Workers), and a media crate for FFmpeg dependency management. Currently in early development, the web app has placeholder routes for home and editor, the desktop app opens a window with empty panels (browser, preview, inspector, timeline), and the API provides health and echo endpoints. The media crate includes a sophisticated build script that downloads or compiles FFmpeg from source for multiple platforms. The codebase demonstrates clean architecture with well-separated concerns, but most features are not yet implemented. The high star count (91k) likely reflects the previous classic version, not the current rewrite.
Berty is a full-stack, privacy-focused, peer-to-peer messaging application. The system consists of a Go backend implementing the Wesh protocol (based on IPFS, libp2p, and OrbitDB) that provides core messaging, push notifications, authentication, replication, and directory services. The backend is exposed via gRPC and consumed by multiple clients: a React Native mobile app (with both a legacy JS variant and a newer Expo-based variant), a Go CLI with a terminal UI (mini) and a desktop GUI (Fyne), and native bridges for iOS and Android. The architecture is modular, with separate packages for error handling, authentication, push relay, and bot framework. Key entry points include the `berty daemon` CLI command, the mobile app entry points (`App.tsx` in both `js/packages` and `berty-bridge-expo/mobile`), and the bridge framework (`go/framework/bertybridge`). Data flows involve gRPC streams from the Go backend to the mobile clients, with event-driven state management and local encrypted storage via SQLCipher. External dependencies include libp2p, OrbitDB, gRPC, protobuf, and various platform-specific native modules for BLE, mDNS, and push notifications. The repository also contains auxiliary tools for infrastructure testing, rendezvous servers, and debugging (Tyber).
This repository is a monorepo implementing a Language Server Protocol (LSP) integration for JupyterLab, consisting of a Python backend (`jupyter-lsp`) and a TypeScript frontend (`jupyterlab-lsp`). The backend manages multiple language server processes (Python, R, Julia, bash, SQL, etc.) via WebSocket proxying, file system shadowing for disk-based servers, and configurable spec discovery. The frontend provides LSP features (autocompletion, diagnostics, hover, jump-to-definition, rename, signature help, syntax highlighting) as JupyterLab plugins, with custom CodeMirror 6 extensions, a diagnostics panel, and a status bar. The architecture includes virtual documents for notebook cells with IPython magic handling, foreign code extraction (e.g., `%%R`, `%%sql`), and a settings schema system that dynamically populates language server configuration UIs. The codebase is well-tested with Python unit tests, TypeScript unit tests, and Robot Framework acceptance tests running in CI. While the core functionality is robust, there is moderate technical drift due to reliance on undocumented JupyterLab internal APIs, fragile regex-based magic parsing, and some deprecated language server specifications.
Yoast SEO is a comprehensive WordPress SEO plugin providing on-page content analysis, XML sitemaps, schema markup generation, social media previews, and AI-assisted content optimization. The codebase is a monorepo containing PHP backend logic under a domain-driven architecture (Application, Domain, Infrastructure, User_Interface layers) and a modern JavaScript frontend using React, Redux, and Tailwind CSS. It integrates deeply with the WordPress ecosystem through hooks, REST API endpoints, and a robust conditional-based feature toggling system. Core capabilities include real-time readability and SEO assessments via a web worker-based analysis engine (packages/yoastseo), bulk editing of SEO metadata, AI content generation (titles, descriptions, outlines), schema aggregation for structured data, a dashboard with Google Site Kit integration, and extensive support for third-party plugins (WooCommerce, Elementor, WPML). The plugin employs a well-defined integration pattern (Integration_Interface with get_conditionals) for modular feature management. The repository exhibits professional engineering practices including comprehensive automated testing (PHPUnit, Jest, Mockery, Brain Monkey), dependency injection, and continuous integration. However, it shows signs of architectural drift with deprecated classes and legacy WPSEO_* namespaces coexisting with newer code, and a high open issue count reflecting its large user base. The AI features (consent management, content planner) are relatively recent additions with evolving requirements.
This is a production-oriented full-stack SaaS starter kit (not a data/research project). It is a monorepo template pairing a Next.js web app (landing page, auth flow, account dashboard, marketing sections) with a Flutter cross-platform app (iOS/Android/macOS/Windows/Linux/web) on top of a shared Supabase backend. The backend is a Postgres schema (users, customers, products, prices, subscriptions, invoices) protected by row-level security, plus Deno edge functions that orchestrate Stripe Checkout sessions and process Stripe webhooks. PostHog handles analytics on both frontends, Loops.so handles transactional email, and an optional Monero cryptocurrency payment variant can be toggled in via patch scripts, giving the template two billing backends.
CtxPort is a browser extension and companion documentation website that lets users copy AI conversations (from ChatGPT, Claude, Gemini, DeepSeek, Grok, Doubao, GitHub) as structured Markdown Context Bundles. It solves 'context rot' by enabling portable, lossless migration of conversations between AI tools without uploading data to third parties. The architecture is a modern monorepo using pnpm workspaces and Turborepo, with separate packages for schema validation (Zod), markdown serialization, plugin-based extraction, and shared UI components. The browser extension (Manifest V3, WXT, React 19, Tailwind CSS 4) injects copy buttons and sidebar list icons into supported platforms, while the documentation website (Next.js + Nextra) provides multilingual (en/zh) user guides and feature descriptions. All processing is client-side; no data is uploaded. The codebase demonstrates strong engineering practices including a plugin system for extensibility, a strategy pattern for content flatteners, clean separation of concerns, and comprehensive CI/CD pipelines. Some fragility exists in DOM selectors and platform APIs, but the architecture is well-structured for adaptation.
This repository is the full-stack implementation of Mega, a large-monorepo Git hosting and code collaboration platform with a Rust backend and a large React/Next.js frontend. The backend is split into several crates: mono provides the HTTP/SSH API server, ceres contains application services for Git operations, change lists (CLs), code review, build triggers, webhooks and notifications, jupiter handles persistence through SeaORM entities and storage services, jupiter-migrate manages a large sequence of database migrations, and orion/orion-server implement a Buck2-based distributed build orchestration system. The frontend in moon/apps/web is a feature-rich collaboration application with posts, notes, chat, notifications, project management, diff viewing, CL/merge-queue review, admin groups, OAuth integrations, and editor support. The core operational flow is: git push/import -> ceres transport and jupiter storage -> change list and merge-queue workflows -> build triggers sent to Orion -> build events/checks streamed back to the UI.
This is a monorepo for a web-based vector graphics editor (similar to Figma) built with React, Canvas2D, and TypeScript. It features a core editor with drawing tools, layers, path editing, undo/redo, SVG import/export, and real-time multiplayer collaboration (via Yjs/Hocuspocus). The architecture includes a standalone editor app, a deprecated multiplayer variant, a backend (NestJS + Prisma + PostgreSQL) for authentication and file storage, and a workbench for team management. Shared packages provide geometry utilities, UI components, icons, and Skia PathKit WASM bindings. The codebase demonstrates strong engineering patterns (command pattern, event emitter, strategy pattern) and provides several reusable components, especially the geometry library and UI components. However, there is significant code duplication between the standalone and multiplayer apps, and the multiplayer app is deprecated, indicating some drift risks. The backend is functional but has minimal stubs and a hardcoded JWT secret.
This is the Cisco Webex JavaScript SDK, a large monorepo providing client libraries for integrating with Webex collaboration services including messaging, meetings, calling, contact center, and device management. The SDK is organized into multiple packages under `packages/@webex/` and `packages/`, with a plugin-based architecture built on a core framework (`webex-core`) that provides HTTP interceptors, storage adapters, eventing, and batcher patterns. The codebase is predominantly JavaScript with increasing TypeScript adoption in newer packages. It includes extensive unit and integration tests, sample applications, and a browser extension bridge for secure cross-context messaging. While the SDK is actively maintained and used in production, it exhibits some technical drift due to legacy packages, mixed test runners (Mocha, Jest, Karma, Playwright), and outdated tooling references (e.g., Node 10 in CI scripts). The architecture is modular and many components (interceptors, batchers, rate limiters, state machines) are well-crafted and potentially reusable in other projects.
GraphQL Zeus is a TypeScript-first GraphQL client generator that produces a fully type-safe query builder from any GraphQL schema. It provides a CLI tool (`zeus`) that accepts a GraphQL schema file or introspection URL and generates a complete TypeScript client with zero runtime dependencies beyond `cross-fetch` and `ws` (for subscriptions). The generated client supports multiple transport modes: standard HTTP via `Chain` and `Thunder` (with custom fetch injection), WebSocket subscriptions (both legacy and `graphql-ws`), and Server-Sent Events (SSE). It also offers integration helpers for Apollo Client (`typedDocumentNode`) and exports reusable selection set composition via `Selector`. The monorepo is structured into three packages: `graphql-zeus` (CLI orchestration), `graphql-zeus-core` (code generation engine and runtime functions), and `graphql-zeus-jsonschema` (JSON Schema generation from input types). The code generation pipeline parses the schema into a tree structure, then templates it into TypeScript types and runtime functions. The project is moderately well-maintained with active issues and a test suite focused on the core code generator, though the CLI lacks automated tests and the build tooling relies on the deprecated `ttypescript` package, indicating some technical drift.
This is a monorepo for an AI coding assistant called T1 Code (a fork of T3 Code). It provides a unified chat-based interface that integrates multiple AI providers (Codex, Claude, Cursor, OpenCode) via a server-side orchestration engine. The server uses Effect-TS for functional effects, SQLite for persistence, and WebSocket for real-time communication. Clients include a web app (React with TanStack Router), a terminal UI (Ink/React), and a desktop app (Electron). The system supports git operations, terminal integration, source control providers (GitHub, GitLab, Bitbucket, Azure DevOps), checkpointing/diff tracking, and text generation for commit messages, PRs, and branch names. The architecture follows an event-sourcing/CQRS pattern with a projection pipeline for read models. The codebase is well-structured with extensive test coverage and reusable Effect-based service layers, but relies on beta versions of Effect-TS and other libraries, which introduces some technical drift risk.
Tape is a decentralized video-sharing platform built on Lens Protocol. The monorepo contains multiple frontends: a legacy Next.js app (apps/web), a newer Vite + TanStack Router rewrite (apps/web-vite), an Expo/React Native mobile app, an embeddable video player, and an Open Graph image generator. The backend consists of a Hono API (apps/api) for oEmbed, DID resolution, metadata, and event ingestion, plus a cron service (apps/cron) for cleanup, analytics flushing, and S3 backups. Smart contracts for permissionless signup live in apps/contracts. The platform supports video upload, short-form bytes, comments, mirrors, collects, tips, follows, notifications, search, and profile management, all interacting with Lens Protocol's GraphQL APIs and on-chain contracts. Data flows through several layers: media is uploaded to IPFS/S3/Arweave, metadata is stored on Arweave or IPFS, and social actions are executed via Lens Protocol typed-data signing and broadcasting. The platform also runs an in-house analytics pipeline: browser events are queued through a service worker to Redis, flushed to ClickHouse by cron jobs, and backed up to S3. Postgres (via Prisma) stores platform-level data such as allowed tokens, profile toggles, curated profiles, and platform stats. Redis is used for caching and queueing throughout. Although primarily an application, the repository has a meaningful data/analytics component (ClickHouse schema, event/trail tracking, Redis-backed queues, S3 backup jobs) that could be reused independently. The codebase is actively maintained but carries migration debt: two web frontends, two UI kits (packages/ui and packages/winder), two Lens GraphQL clients (v1 and v2), and commented-out cron services indicate an in-progress transition. No meaningful test suite is present; CI focuses on Biome checks and builds.
httpc is a TypeScript framework for building function-based APIs with end-to-end type safety. It abstracts HTTP into typed function calls, providing a server with a middleware pipeline (parsers, rewriters, renderers), a typed client generator that produces proxy-based clients with full autocompletion, a CLI for scaffolding projects and generating clients, and a comprehensive kit (authentication, caching, validation, dependency injection, event bus, permissions, logging, email, geo). The architecture is a monorepo with packages: server, client, kit, cli, and adapters for Vercel, Netlify, and Cloudflare. Key entry points include `createHttpCServer` (server), `createClient` (client), and CLI commands (`create`, `client`, `call`). Data flows: HTTP request → parser → middleware pipeline → call execution → renderer → response. External dependencies include tsyringe, zod, valibot, winston, lru-cache, redis, maxmind, and jws. The framework is experimental (v0.1.0) but demonstrates strong engineering practices with clean abstractions and reusable patterns.
Pomatez is a cross-platform Pomodoro timer desktop application built with a monorepo architecture managed by Lerna and Yarn workspaces. It provides a customizable timer with focus/break sessions, task management, system tray integration, desktop notifications, full-screen break enforcement, Discord Rich Presence, and auto-update capabilities. The application is implemented with two backend options: a primary Electron backend and an experimental Tauri (Rust) backend, both sharing a common React frontend (renderer) and a shared constants package. The frontend uses Redux Toolkit for state management, styled-components for theming (light/dark), react-i18next for internationalization (English, Spanish, Chinese, Japanese), and react-beautiful-dnd for task list drag-and-drop. The repository also includes a Gatsby-based marketing website for downloads and feature showcases. The core timer logic is driven by a React context (CounterContext) that manages countdown, session transitions, and full-screen break states. User settings and tasks are persisted to localStorage (and electron-store for the Electron backend) with debounced Redux store persistence. The application exposes a connector abstraction (ConnnectorContext) that decouples the frontend from the backend platform, allowing the same UI code to work with both Electron and Tauri via platform-specific connectors. The Electron main process handles window management, system tray, global shortcuts, and auto-updates, while the Tauri backend provides similar functionality through Rust commands. External dependencies include node-notifier for notifications, discord-rpc for Rich Presence, and electron-updater/tauri-plugin-updater for auto-updates. The codebase demonstrates solid engineering practices with reusable UI components, custom hooks, and a well-organized store structure. However, it shows signs of technical drift with outdated dependencies (React 16, TypeScript 4.9.4, deprecated husky v4) and the dual-backend approach introduces code duplication and maintenance overhead. Test coverage is minimal, with only one unit test file found. The Tauri backend is marked as experimental and has some incomplete features (e.g., set_ui_theme is a no-op). Overall, Pomatez is a functional and feature-rich desktop application with a clean frontend architecture, but its backend complexity and dependency age suggest moderate refactoring needs.
A well-structured monorepo for building cross-platform Expo (React Native) applications using pnpm and Turborepo. The repository demonstrates a scalable architecture with three shared packages (eslint configuration, reusable UI components, and a home feature) and a single example Expo app that leverages Expo Router for navigation, react-native-reanimated for animations (parallax scroll, wave animation), expo-haptics for haptic feedback, and expo-symbols/expo-image for platform-adaptive icons and images. The code is organized following modern React Native best practices: typed routes, strict TypeScript, automatic dark/light mode, absolute imports, and Jest + testing-library/react-native tests for components. CI/CD is fully implemented via GitHub Actions with workflows for linting, building, testing, EAS deployments, and preview builds. While the application itself is a simple template (home screen with steps, an explore screen with informational collapsibles, and a modal), the architecture showcases a effective monorepo workflow with Turborepo caching and pnpm workspace protocols. The most notable technical components are a cross-platform icon abstraction (SF Symbols to Material Icons), a standalone parallax scroll view with Reanimated, and an in-app browser link adapter—all of which are modular and easily extracted for other projects.
threeify is a TypeScript monorepo providing a WebGL2-based 3D rendering library with a focus on physically-based rendering (PBR), glTF support, and modular architecture. It is loosely derived from three.js but aims for a more modern, tree-shakeable design with native WebGL2 abstractions. The library includes a comprehensive math package (vectors, matrices, quaternions, colors, bounding volumes), a scene graph with cameras, lights, and materials (including clearcoat, sheen, transmission, and anisotropic extensions), a renderer with post-processing effects (tone mapping, Gaussian blur, bloom, cubemap background), a 2D layer compositor with blend modes and panorama support, and a custom GLSL-to-TypeScript transpiler for shader management. The codebase is organized into packages (core, math, scene, layer-compositor) and tools, with over 50 interactive examples demonstrating various rendering techniques. External dependencies include WebGL2 and browser APIs; the library is still in development and not yet recommended for production use.
This is a monorepo containing starter templates and final code for the official Next.js Learn courses. It includes multiple independent Next.js applications demonstrating the Pages Router, App Router, data fetching, authentication, SEO optimization, and more. The code is educational, well-structured, and follows modern Next.js patterns (server actions, streaming, suspense, etc.). It is not a production application but serves as a reference implementation for learning. The dashboard example includes a full CRUD invoice management system with PostgreSQL, NextAuth authentication, and Tailwind CSS styling. The basics examples cover static generation, dynamic routes, API routes, and TypeScript. The SEO example demonstrates performance optimization techniques like dynamic imports and lazy loading.