This is the official Sentry JavaScript SDK monorepo, providing error monitoring, performance tracing, session replay, user feedback, and profiling for a wide range of JavaScript runtimes and frameworks. The architecture is a large monorepo with ~50 packages, each targeting specific platforms (browser, Node.js, Cloudflare Workers, Deno, Bun) and frameworks (Next.js, Angular, React, SvelteKit, Nuxt, etc.). The core SDK logic lives in `packages/core`, with platform-specific packages that integrate via a consistent `Sentry.init()` entry point. Data flows from the user's application through instrumented APIs (error handlers, fetch, timers, etc.) to produce events (errors, spans, breadcrumbs, replay recordings) that are serialized into envelopes and sent to Sentry's ingest endpoint via configurable transports. The monorepo also includes bundler plugins for build-time instrumentation (source map upload, debug ID injection, component annotation) and extensive integration tests covering multiple bundler versions and framework releases. The codebase exhibits high craftsmanship with well-defined integration patterns (`defineIntegration`), modular utilities, and comprehensive test infrastructure. It is actively maintained with frequent commits and a broad compatibility surface, though the sheer number of framework-specific packages introduces some maintenance complexity.
This monorepo provides a suite of libraries and CLI tools for generating changelogs from git metadata according to the Conventional Commits specification. The core pipeline consists of: a git client to fetch commits, a parser to extract structured data from commit messages, a filter to remove reverted commits, and a writer to render the changelog in Markdown. Additional packages handle version bump recommendations, preset loading (Angular, Conventional Commits), and template rendering. The system is designed for both programmatic use via builder-style APIs (e.g., `ConventionalChangelog`, `Bumper`) and direct CLI invocation. It supports multiple git hosting platforms (GitHub, GitLab, Bitbucket) and is configured through presets that define commit type effects, reference formatting, and section ordering. The architecture is a monorepo with 11+ independently published packages, each with its own tests, TypeScript definitions, and CLI entry points. The codebase is actively maintained, with frequent releases, breaking changes managed through major version bumps, and a migration from Handlebars to render functions. It requires Node.js >= 22 and is fully ESM. The project also includes a documentation website (Astro/Starlight), CI/CD via GitHub Actions, and an AI agent skill for commit message guidance. While primarily a developer tool, the repository demonstrates strong software engineering practices: clean separation of concerns, stream-based processing for large commit histories, a preset plugin pattern, and comprehensive test coverage including real git repository interactions. The lower-level packages (parser, filter, writer, git client) are designed to be reusable in other contexts, and the template utilities provide a foundation for custom changelog formatting.
Mockoon is a multi-platform API mocking tool that runs mock servers locally or remotely. It is built as a monorepo with six npm packages: @mockoon/commons (shared models, migrations, OpenAPI converter), @mockoon/commons-server (core Express-based mock server engine with templating and response rules), @mockoon/app (Electron desktop application with an Angular renderer), @mockoon/cli (oclif-based command-line interface), @mockoon/cloud (cloud sync library), and the deprecated @mockoon/serverless wrapper. The architecture cleanly separates the core server logic from the delivery mechanisms. The MockoonServer class provides an HTTP/HTTPS server with a sophisticated response rule engine, a Handlebars templating system with over 100 custom helpers (including deep Faker.js integration), CRUD operations on data buckets, WebSocket support, proxy mode, and a full admin API. The desktop app uses a Redux-like state management pattern with RxJS, ensuring predictable and testable UI state transitions. The codebase demonstrates high craftsmanship in several areas. The ResponseRulesInterpreter is a self-contained DSL for matching HTTP requests to mock responses. The TemplateParser provides an extensible helper registration system. The data migration system in commons is a textbook example of handling schema evolution for JSON-based data models. The project is actively maintained with a robust CI/CD pipeline, though it carries some technical debt such as a deprecated serverless package and disabled strict TypeScript mode in the desktop app.
Genql is a type-safe GraphQL query builder that generates TypeScript clients from GraphQL schemas. The core functionality resides in the CLI (@genql/cli) which introspects a GraphQL schema and emits a client enabling compile-time query validation and autocompletion. The repository also includes a Next.js website for documentation and a converter tool, plus a scraper subsystem that automatically discovers public GraphQL APIs via Sourcegraph, generates clients, and publishes them to npm. The architecture is a monorepo managed by pnpm with three main components: cli (code generation and runtime), website (documentation and converter), and scraper (automated discovery and publishing). Key features include batching queries, subscriptions, framework-agnostic design, and support for Node.js, browser, Deno, and Cloudflare environments.
This repository provides a collection of shared configurations and tools for web development at Shopify. It is structured as a monorepo containing multiple npm packages, including ESLint and Stylelint plugins with custom rules, Babel presets, TypeScript configurations, Prettier settings, and utilities for image optimization. The project enforces consistent coding standards across Shopify's web applications and is used in their build and development pipelines. The architecture is modular, with each package providing a specific tool or configuration that can be extended by consumers.
This repository is a TypeScript monorepo of 40+ markdown-it plugins, published as individual @mdit/plugin-* npm packages plus the @mdit/helper utility package. It is a developer-facing library ecosystem, not an application: each plugin extends markdown-it with additional Markdown syntax and rendering behavior, including alerts, containers, tabs, footnotes, task lists, definition lists, abbreviations, emoji, math (KaTeX and MathJax with full and slim variants), diagrams (PlantUML/UML), image controls (size, lazyload, mark), advanced links, attribute syntax, icons, layout directives (flex/grid/columns), file include/snippet (Node-only, file-system based), and text semantics (sub, sup, mark, ins, ruby, spoiler). The plugins are consumed primarily by static-site generators such as VuePress/VitePress and by any Node or browser pipeline that renders Markdown via markdown-it.
This is a multi-platform TypeScript library for programmatically controlling Elgato Stream Deck devices and the Corsair Galleon K100 keyboard. It provides a unified API over three distinct transport layers: USB HID via `node-hid` (Node.js), WebHID (browser), and TCP/IP (network-connected devices like the Stream Deck Studio and Network Dock). The architecture decouples hardware-specific details behind a service-oriented core: `PropertiesService`, `InputService`, `ButtonsLcdDisplayService`, `LcdSegmentDisplayService`, and `EncoderLedService` are injected into a `StreamDeckBase` class, allowing support for 15+ models (Original, Mini, XL, Plus, Plus XL, Neo, Pedal, Studio, etc.) with minimal duplication. Image processing is modular, with pluggable encoders (JPEG, bitmap) and header generators for different firmware generations. The `PreparedBuffer` pattern enables pre-computing and caching of image writes. The codebase is well-structured as a monorepo with separate packages for core logic, Node.js transport, WebHID transport, TCP transport, and a browser demo. Unit tests use Jest with snapshot testing for HID report payloads. The library is actively maintained, with recent commits, CI pipelines, and automated release-please workflows.
This is the official Gemini CLI by Google, a terminal-based AI assistant that brings Gemini models to the command line. It is a large TypeScript monorepo with packages for the CLI (interactive UI built on Ink/React), core agent logic (context management, tool execution, routing, policy enforcement), SDK for programmatic agent sessions, A2A server for agent-to-agent communication, and supporting tooling (devtools, test utilities, caretaker agent for automated issue triage). The CLI supports slash commands, extensions (hooks, MCP servers, themes), skills, sandboxed execution, multiple authentication methods (OAuth, API key, Vertex AI), and rich terminal features like themes, keybindings, and mouse support. It includes an extensive evaluation framework for behavioral testing of agent capabilities. The architecture is modular with clear separation between UI, core agent loop, and extensibility layers, though the monorepo size introduces some coupling and test fragility.
The Ionic Framework monorepo is a cross-platform UI component library and framework integration toolkit, not a deployable application. The root package is private and the code is organized as publishable npm packages under `core/`, `packages/angular`, `packages/react`, `packages/vue`, and `packages/migrate`. Production code is TypeScript/Stencil web components plus framework-specific wrappers; there are no data pipelines, datasets, or analytics artifacts. Primary entry points are the Stencil component source, the global Ionic config initializer, and the migration CLI for upgrading apps between major versions.
DefinitelyTyped is the centralized repository for TypeScript type definitions, serving as critical infrastructure for the TypeScript ecosystem. This monorepo manages thousands of @types packages that provide static type checking and IntelliSense support for JavaScript libraries. The repository uses dtslint for validation, pnpm for package management, and follows a major.minor.9999 versioning scheme aligned with upstream library versions. Each type definition package contains index.d.ts declaration files, test files with $ExpectType assertions, and package.json metadata. The codebase is purely declarative - it contains no runtime logic, only type signatures, interfaces, and function signatures for external libraries. This makes it a foundational dependency for TypeScript projects rather than a consumable application.
Logseq is a privacy-first, open-source knowledge management platform built as a monorepo containing an Electron desktop app, Capacitor-based mobile apps (iOS/Android), a web app, and a Node.js db-sync server. The codebase is predominantly ClojureScript (CLJS) with React/Rum for the UI, DataScript for the in-memory graph database, and SQLite (via better-sqlite3 and sqlite-wasm) for persistence. It uses shadow-cljs for CLJS compilation, webpack for JS bundling, and Tailwind CSS for styling. A separate OCaml-based CLI (logseq-cli) built with Melange provides graph inspection, sync, and CRUD operations against the same db-worker-node backend. The architecture separates concerns into deps/ subprojects (db, outliner, graph-parser, db-sync, common, publishing, shui) that are compiled as separate shadow-cljs targets and shared across Electron, browser, mobile, and CLI runtimes. The system has two graph types: file-based graphs (Markdown/Org) and DB graphs (SQLite-backed with DataScript in-memory querying). DB graphs enable real-time collaboration (RTC) via a Cloudflare Worker-based sync server (deps/db-sync) using WebSockets and D1 SQLite. The db-worker-node is a long-lived Node.js process that manages SQLite connections and sync state, communicating with the UI via a thread-api IPC mechanism. The outliner module handles block tree operations with structural invariants, while the graph-parser handles Markdown/Org parsing via mldoc. The publishing module generates static HTML sites from graphs. Key architectural patterns include: missionary for reactive async flows, promesa for promise composition, malli for schema validation, datascript for Datalog queries, and a component-based UI with Rum/React. The codebase has extensive test coverage via cljs.test, Playwright E2E tests (clj-e2e), and Python-based CLI E2E tests (cli-e2e). The repository is actively maintained with recent commits, 43k+ stars, and active issue triage, though the large monorepo complexity and multi-language surface (CLJS, OCaml, Swift, Kotlin, Python, JS) create maintenance challenges.
This repository is the official TypeScript SDK for the Fuel Network blockchain, structured as a monorepo using pnpm and Turbo. It provides a comprehensive suite of libraries for wallet management, transaction construction, smart contract interaction (contracts, predicates, scripts), and code generation from Sway ABIs. The codebase includes a CLI tool (`fuels`) for project scaffolding, building, deploying, and running local test nodes. It supports both Node.js and browser environments, evidenced by dual build configurations and React-based dApp templates. The architecture relies heavily on generated GraphQL operations and external binary dependencies (`forc`, `fuel-core`) which are managed internally via installation scripts.
This repository is a reference architecture for building production-ready React applications, implemented as a monorepo containing three distinct application templates: Next.js App Router, Next.js Pages Router, and Vite. It serves as a comprehensive guide for scalable project structure, demonstrating best practices in state management (Zustand for client state, TanStack Query for server state), testing (Vitest, Playwright, MSW), and security (JWT, RBAC). The codebase prioritizes strict TypeScript usage, unidirectional data flow, and feature-based colocation. The system functions as a boilerplate and educational tool rather than a standalone product. It provides a complete development environment including UI component libraries (Radix UI + Tailwind), form handling (React Hook Form + Zod), and API abstraction layers. The architecture is designed to be copy-pasted into new projects, with the three app implementations serving as comparative examples for different React rendering strategies. Key operational patterns include a centralized API client with Axios interceptors for authentication and error handling, a mock backend service using MSW and @mswjs/data for local development and testing, and a robust authorization system that enforces role-based access control at the component and route levels. The codebase is heavily instrumented with tests and documentation to ensure maintainability and adherence to the defined architectural standards.
Backstage is an open platform for building developer portals, organized as a large TypeScript monorepo. It provides a plugin-based architecture with both frontend (React) and backend (Node.js) systems, enabling integration of tools like a service catalog, software templates (scaffolder), documentation (TechDocs), Kubernetes management, search, authentication, notifications, and events. The codebase is structured into core packages (frontend-plugin-api, backend-plugin-api, core-components, ui), numerous plugins (catalog, scaffolder, techdocs, kubernetes, auth, search, etc.), CLI tooling, and a design system (Backstage UI). Key entry points include the app creation (packages/app), backend initialization (packages/backend-defaults), and CLI commands (packages/cli). Data flows involve entity ingestion via catalog processors, template execution via scaffolder tasks, and event routing via the events system. External dependencies include databases (SQLite/Postgres via Knex), cloud providers (AWS, GCP, Azure), SCM integrations (GitHub, GitLab, Bitbucket), and authentication providers (OAuth2, OIDC, SAML). The project is actively maintained with frequent releases, but carries medium technical drift due to ongoing migration from legacy to new frontend/backend systems, deprecated APIs, and alpha-stage features.
Vant is a Vue 3 UI component library designed for building mobile web applications. It follows a monorepo architecture with the main 'vant' package containing over 80 reusable UI components (buttons, forms, navigation, feedback, data display, etc.), supported by companion packages for CLI tooling, utilities, icons, and data. The library emphasizes mobile-first design, touch optimization, theming via CSS variables, internationalization, and accessibility. Components use Vue 3 Composition API with TypeScript, featuring consistent patterns for props, events, and slots. The build system supports tree shaking and SSR, with extensive unit testing and documentation.
VidBee is a multi-platform media downloader and transcript workspace. The primary product is an Electron desktop app that downloads video/audio from 1000+ sites via yt-dlp, runs local speech-to-text transcription (sherpa-onnx Whisper/SenseVoice/Qwen3/Parakeet families) with speaker diarization in an isolated worker process, and provides an AI agent chat, summarization, translation, and FAQ layer over the resulting transcripts. It also ships a self-hosted Fastify API with a TanStack Start web client, a CLI wrapper around yt-dlp that can run fully in-process or connect to the desktop/API, and a browser extension (WXT) that hands video URLs to the desktop app via a token-authenticated loopback HTTP bridge. An RSS subscription engine with SQLite CAS leader election supports feed auto-download. Architecturally this is a pnpm monorepo built around host-neutral packages: packages/task-queue (FSM-driven job queue with priority scheduler, retry backoff, watchdog, and SQLite/memory persistence adapters), packages/transcription (ASR pipeline, caption parsing, speaker clustering, chunk manifests), packages/downloader-core (yt-dlp args, format selection, cookie handling, oRPC contracts), packages/subscriptions-core (feed parsing, scheduler, leader election), plus packages/ui, packages/i18n, packages/db, and packages/logger. The desktop, API, CLI, and web hosts share these packages, and oRPC contract schemas are explicitly kept byte-equal across hosts. The desktop renderer uses React 19, TanStack Router, Jotai, and Tailwind 4; the main process uses an IPC-decorator pattern with roughly fifteen typed services. Engineering quality is consistently above average: shared contracts with zod validation, swappable persistence adapters, a pure-function task FSM, security-conscious extension token auth, and an SSRF-guarded remote image proxy. The main weaknesses are duplication and sync fragility: near-identical download UI components exist in both desktop and web apps, several overlapping error classifiers must be kept manually in sync, the API hardcodes APP_VERSION separately from package versions, and legacy migration/back-compat paths (task-queue projection to legacy DownloadItem shapes, migrate-history scripts) accumulate complexity. This is an application repository, not data research: the ASR and speaker-clustering code is product engineering rather than a research artifact, though the transcription package is a genuinely reusable pipeline.
TMagic Editor is a low-code visual page builder framework developed by Tencent. It provides a WYSIWYG drag-and-drop editor for assembling pages from a library of components (Vue and React), configuring properties via schema-driven forms, binding data sources (HTTP, static, mock), attaching JavaScript code blocks for custom logic, and defining event/action flows. The editor outputs a structured DSL (JSON) that can be rendered by separate runtime packages for Vue 2/3 and React, making it suitable for building internal tools, marketing pages, or any form-based application. Architecturally, the project is a monorepo with over 20 packages. The core editor (`packages/editor`) is built with Vue 3 and Element Plus (with an adapter for TDesign), and relies on a canvas stage (`packages/stage`) using the Moveable library for element selection, resizing, and dragging. Property forms are rendered by a headless-capable form engine (`packages/form`) that supports validation, dynamic fields, and complex containers (tabs, tables, group lists). Data sources are managed through an observable pattern (`packages/data-source`) with dependency tracking (`packages/dep`) that can be offloaded to a Web Worker. The system includes a CLI tool (`packages/cli`) for generating runtime entry files and a comprehensive SDK (`packages/editor/src/sdk`) for programmatic DSL manipulation without a browser DOM. Key features include multi-page and page-fragment support, undo/redo with IndexedDB persistence, dependency analysis for incremental updates, a plugin system for extending editor services, and a design abstraction layer that allows switching between UI frameworks. The codebase is well-tested with Vitest, follows modern TypeScript practices, and includes extensive documentation via VitePress. While primarily a developer tool for creating custom editors, it also ships with a playground for demonstration and testing.
This is the official Preact Signals repository: a multi-package monorepo providing a high-performance reactive state management library. The core package (`@preact/signals-core`) implements fine-grained dependency tracking using a linked-list-based reactive graph, with primitives like `signal()`, `computed()`, `effect()`, `batch()`, `untracked()`, `createModel()`, and `action()`. Framework-specific integrations exist for Preact (`@preact/signals`) and React (`@preact/signals-react`), including hooks (`useSignal`, `useComputed`, `useSignalEffect`, `useModel`), utility components (`Show`, `For`), and automatic Babel transforms that inject `useSignals` for seamless reactive re-rendering. In addition to the core and framework libraries, the repository includes a comprehensive developer tooling ecosystem: an ESLint plugin with six rules to prevent common signal anti-patterns, a debug package (`@preact/signals-debug`) that instruments signal internals for logging and DevTools integration, a Vite plugin (`@preact/signals-agent-vite`) that wires up debug clients and Babel transforms, and a full-featured DevTools UI (`@preact/signals-devtools-ui`) with a timeline, performance insights, and an interactive dependency graph. A browser extension embeds this UI into Chrome DevTools, communicating via adapters that support direct, postMessage, and extension messaging patterns. The codebase is well-structured with clear separation of concerns, extensive test coverage (unit, integration, and cross-framework), and active maintenance. While certain components are tightly coupled to the signals ecosystem, several patterns (adapter-based communication, graph layout algorithm, batch reconciliation logic) are isolated enough for extraction into other projects. The repository uses modern tooling (pnpm workspaces, Vitest, Babel, ESLint/Oxlint) and keeps up with framework versions, indicating low technical drift.
This repository is a pnpm monorepo for @stylistic/eslint-plugin, a community-maintained ESLint plugin that provides formatting and stylistic rules for JavaScript, TypeScript, JSX, and related syntaxes. It ports formatting rules that were deprecated or removed from ESLint core and typescript-eslint, giving users a drop-in path to continue enforcing style conventions. The main deliverable is an npm library consumed through ESLint flat config; there is no server, database, or runtime application. The plugin exposes roughly a hundred rules, each with typed options, autofix support, parser-specific test coverage, and generated metadata and type declarations.
This monorepo provides two packages for font optimization in web applications. `fontaine` is a library that automatically generates metric-adjusted CSS `@font-face` fallback rules to reduce Cumulative Layout Shift (CLS). It parses CSS, reads font metrics from files or URLs, and injects override rules with proper `size-adjust`, `ascent-override`, etc. `fontless` is a Vite plugin that builds on top of fontaine and integrates with multiple font providers (Google Fonts, Bunny, FontSource, npm, etc.) to automatically download, subset, and serve optimized fonts with zero runtime JavaScript. It scans CSS for `font-family` declarations, resolves fonts through a provider chain, downloads the actual font files, emits them as build assets, and injects both the primary `@font-face` rules and metric-override fallback families. The codebase is well-structured, has comprehensive test coverage, and follows modern JavaScript/TypeScript practices. It is a hybrid of a library (fontaine) and an application plugin (fontless) but primarily serves as a developer tool for building optimized web fonts.