Twenty is a production-grade, open-source CRM delivered as a large Nx monorepo. The system is a full-stack TypeScript application: a NestJS backend (twenty-server) exposing GraphQL/REST APIs, a React frontend (twenty-front) with Jotai-based state management, a shared UI component library (twenty-ui), and shared TypeScript packages (twenty-shared). It provides multi-tenant workspaces, object-record CRUD with custom data models, role-based permissions, AI chat/agent capabilities (model tiers, tool calls, streaming), analytics via ClickHouse, and a CLI scaffolding tool (create-twenty-app) for bootstrapping custom apps. The architecture is modular with NestJS ConfigurableModuleBuilder patterns, event-driven design using Zod-validated schemas, and component-scoped state via atom families and component instance contexts.
JSON Crack is an open-source, browser-based tool for visualizing, formatting, converting, and exploring JSON, YAML, CSV, and XML data as interactive graphs. The monorepo (Turborepo) contains four workspaces: a Next.js web app (apps/www) that provides the full editor experience with a Monaco-based text editor, split-view layout, graph canvas, and various utility modals (jq, JSONPath, schema validation, code generation); a VS Code extension (apps/vscode) that embeds the same graph view as a webview panel; a Chrome extension (apps/chrome-extension) that injects a 'Raw'/'Graph' toggle on any JSON page; and a reusable React component package (packages/jsoncrack-react) that exposes `JSONCrack` as a standalone component along with a `parseGraph` utility and TypeScript types. All data processing happens client-side — the app is a fully static Next.js export served behind NGINX. The architecture is frontend-only, relying on Zustand for state, reaflow for graph layout, react-zoomable-ui for pannable/zoomable canvas, and jsonc-parser for AST-driven parsing. The codebase is well-organized, with clear separation of concerns, good TypeScript coverage, and unit tests in the core package.
This is a monorepo for Auth.js (formerly NextAuth.js), a framework-agnostic authentication library for web applications. The core engine (`@auth/core`) handles OAuth/OIDC, email/passwordless, credentials, and WebAuthn/Passkey authentication flows. It provides a unified API for session management (JWT or database-backed), CSRF protection, and cookie handling. The library is designed to be integrated into multiple frameworks via separate packages: `@auth/nextjs`, `@auth/sveltekit`, `@auth/express`, `@auth/qwik`, and `@auth/solid-start`. Each framework package adapts the core `Auth` function to the framework's request/response model, offering server-side handlers, middleware, and client-side hooks. The repository also includes over 80 built-in OAuth/OIDC provider definitions (e.g., Google, GitHub, Discord, Auth0) and 20+ database adapters (e.g., Prisma, Drizzle, MongoDB, PostgreSQL, DynamoDB) that implement a standard `Adapter` interface for user persistence. The project is now part of Better Auth, and the README recommends new projects use Better Auth unless specific feature gaps exist. The monorepo contains development apps, example applications, and a comprehensive documentation site built with Nextra.
RocketRide is an open-source AI pipeline orchestration platform that enables building, running, and deploying complex multi-step AI workflows. The system is built as a multi-language monorepo with a high-performance C++ engine core (apLib/engLib) that executes declarative JSON pipelines (.pipe files) composed of 100+ modular Python nodes covering LLM providers (OpenAI, Anthropic, Gemini, Mistral, DeepSeek, Ollama, etc.), vector databases (Pinecone, Qdrant, Milvus, Chroma, Weaviate, Elasticsearch), document processing (OCR, parsing, chunking, embedding), agent frameworks (CrewAI, LangChain, LlamaIndex, DeepAgent), and external tool integrations (Slack, Gmail, Google Drive, Microsoft 365, GitHub, Notion, etc.). The engine supports local, on-premise, Docker, and cloud deployment modes with GPU acceleration and real-time observability (token usage, latency, memory, call-tree tracing via WebSocket DAP channel). The architecture follows a modular plugin pattern: each pipeline node implements a consistent IGlobal/IInstance lifecycle with beginGlobal/endGlobal hooks, dynamic dependency loading via a depends() mechanism, and declarative configuration via services.json files. The platform includes multiple front-end applications: a VS Code extension (visual pipeline builder with engine management), a web shell (Module Federation host for cloud/on-prem UIs), and specialized apps (SQL explorer, file dropper, event monitor, chat widget, chaos testing tool). Client SDKs in Python and TypeScript allow embedding pipelines into external applications, and an MCP server exposes pipelines as tools for AI assistants. The system also provides an n8n integration, an embeddable chat widget, and a Helm chart for Kubernetes deployment. Key data flows begin with pipeline definition (JSON or visual canvas), which is parsed and validated by the engine. The engine resolves node configurations, installs required dependencies, and executes nodes in topological order, passing typed data (text, documents, images, audio, tables, embeddings) through the pipeline graph. Nodes communicate via a shared context and can branch, merge, loop, and invoke sub-pipelines. Results are streamed back through WebSocket connections for real-time UI updates, and full execution traces are stored for debugging and observability. The platform also includes a model server for GPU-accelerated inference (OCR, embeddings, vision, TTS) with device locking and proxy mode. External dependencies are extensive: the C++ engine relies on OpenSSL, libcurl, libxml2, and platform-specific system calls; Python nodes depend on dozens of AI/ML libraries (transformers, sentence-transformers, openai, anthropic, langchain, llama-index, crewai, etc.); TypeScript/React frontends use MUI, ReactFlow, and RJSF. The build system uses pnpm workspaces, vcpkg for C++ dependencies, and a custom builder script. The project is MIT-licensed with an active community (17.7k stars, 7.5k forks) and regular releases with semantic versioning.
Agenda is a light-weight job scheduling library for Node.js with a pluggable backend architecture. The core library provides scheduling (cron, human-readable intervals, debounce), concurrency control, distributed locking, retries with composable backoff strategies, unique job constraints, and persistent job logging. It supports three official backends (MongoDB, PostgreSQL, Redis) via clean abstractions (JobRepository, NotificationChannel, JobLogger) that can be mixed and matched. The monorepo also includes two companion applications: agendash (a Vue 3 web dashboard for monitoring and managing jobs with real-time SSE updates) and agenda-rest (a Koa-based REST API server with CLI entry point). The codebase is fully TypeScript, ESM-only (v6), uses pnpm workspaces, changesets for versioning, Vitest for testing, and has extensive shared test suites that ensure backend interoperability. The architecture demonstrates strong separation of concerns, but there is some code duplication across backends and legacy v4 documentation that could cause confusion.
This repository is the AWS Amplify JavaScript library, a production-grade client SDK for building cloud-connected web and React Native applications. In production, it runs inside end-user apps and mediates access to AWS services: Cognito authentication flows (SRP, OAuth/PKCE, WebAuthn passkeys, token refresh, MFA), S3 storage (multipart uploads, presigned URLs, path-based operations, resumable uploads), AppSync GraphQL/REST APIs, real-time WebSocket subscriptions and events, Pinpoint/Kinesis/Firehose/Personalize analytics, push notifications and in-app messaging, DataStore offline synchronization, Geo, Predictions, Lex, and IoT PubSub. It also ships a Next.js adapter that provides server-side rendering support with per-request cookie-based token storage and auth route handlers for both App Router and Pages Router. Architecturally this is a TypeScript monorepo: a `core` package provides foundational primitives (branded `AmplifyContext`, storage abstractions, HTTP middleware composition, SigV4 signing, retry logic, Hub event bus, cache), while category packages (`auth`, `storage`, `api-graphql`, `api-rest`, `analytics`, `notifications`, `datastore`, `geo`, `pubsub`) implement provider-specific logic behind a common context-first API pattern. The public `aws-amplify` umbrella package re-exports these through subpath exports, with `server` and `internals` entry points for SSR and advanced use. React Native support is provided through native modules for passkeys, push notifications, and web browser sessions. Data flows are typically: configure the Amplify singleton, resolve a context (global or per-request), call a category API, which uses composed HTTP middleware and generated service clients to talk to AWS endpoints, with analytics events buffered and flushed asynchronously. The codebase is actively maintained, with recent commits, extensive CI/CD workflows, changesets, and a large test suite. However, it carries notable transitional debt: Amazon Pinpoint APIs are deprecated with an October 2026 end-of-support, legacy v5 compatibility shims and deprecated key-based storage APIs remain, and some logic is deliberately duplicated across packages (e.g., connection state monitors and event buffers). Despite this, the architecture is coherent, the middleware and context patterns are well-designed, and the SDK is heavily tested across browser, React Native, and server environments.
Cherry Markdown is a rich, extensible WYSIWYG Markdown editor library and ecosystem, developed primarily in JavaScript. The core library (packages/cherry-markdown) provides a full-featured editor with real-time preview, syntax highlighting, math rendering (KaTeX/MathJax), diagram support (Mermaid, PlantUML, ECharts), table editing, AI streaming rendering, and a comprehensive toolbar system. It is built on a modular hook architecture where every syntax feature and toolbar button is a pluggable component, allowing deep customization without modifying core code. The editor supports multiple rendering modes (full, core-only, engine-only, streaming) and can be embedded in web applications, desktop apps, and IDEs. The repository is structured as a monorepo containing several first-class integrations: a Tauri-based desktop client (packages/client) with file management, local versioning, and dual-editor support (Cherry + Milkdown); a VS Code extension (packages/vscodePlugin) providing an in-editor preview with MathJax and image upload; a WeChat Mini Program renderer (packages/miniProgram) that converts Markdown to WXML; and numerous examples including a React demo, AI chat demos, and a configuration helper. The architecture emphasizes separation of concerns through composable utilities, a pipeline-based rendering engine (Engine.js), and an event system for decoupled communication. Key entry points include Cherry.js (main editor class), CherryStream.js (streaming-only variant), Engine.js (rendering pipeline), and the various index files (index.js, index.core.js, index.engine.js, index.stream.js) that expose different build artifacts. External dependencies include CodeMirror 6 for editing, Mermaid/PlantUML for diagrams, KaTeX/MathJax for math, ECharts for charts, and Tauri for the desktop client. The codebase is well-tested with over 100 test files covering hooks, toolbars, utilities, and integrations, and enforces coverage thresholds. While the monorepo adds maintenance complexity, the core library is mature, actively developed, and demonstrates strong engineering practices with clean abstractions and reusable patterns.
FormKit is a form-building framework for Vue and React, organized as a monorepo of 15+ packages. The architecture is a core (framework-agnostic) node tree that manages form state, validation, schema rendering, and plugins, with separate packages for framework bindings (Vue, React, Nuxt), inputs, validation rules, internationalization (30+ locales), icons, themes (CSS, Tailwind, UnoCSS), addons (multi-step, floating labels, localStorage), a CLI for scaffolding and theme generation, and Zod integration. It uses a schema system (JSON-serializable) to define form layouts and conditional rendering, and a plugin/feature pattern for extensibility. The repository demonstrates high engineering quality: extensive test coverage (unit, type, e2e memory leak tests), well-structured abstractions (observers, message stores, composables), and cross-framework consistency. However, there are minor inconsistencies (license declared as UNLICENSED despite README claiming MIT, incomplete translations in some locales, deprecated packages like @formkit/tailwindcss, and potential brittleness in remote API dependencies in the CLI). Overall, it's a production-grade form solution with solid reusability of its core patterns.
Lifo is a browser-based virtual machine and sandbox environment that emulates a Linux-like OS entirely in JavaScript. It provides a virtual filesystem (VFS), network stack, process management, shell, and an extensive Node.js compatibility layer that allows running real npm packages, dev servers (Vite, Expo, Express), and CLI tools inside the sandbox. The repository is a pnpm monorepo containing multiple packages: `@lifo-sh/core` (kernel, VFS, shell, node-compat), `@lifo-sh/ui` (React components for terminal, file explorer, preview), `lifo-sh` (CLI for daemon/session management), `apps/playground` (interactive web demo), `apps/desktop` (macOS-style web desktop), and many `lifo-pkg-*` command packages (git, ffmpeg, vi, etc.). The architecture is modular: the core kernel is framework-agnostic and can be embedded in Node.js or browser environments, while the UI and CLI are separate consumers. Key data flows involve user input through the shell, command execution against the VFS and network stack, and Node API calls intercepted by the compatibility layer. External dependencies include `acorn`, `browser-metro`, `ws`, and optional `esbuild`. The project is actively maintained with frequent releases, extensive tests, and a clear roadmap for expanding the sandbox capabilities.
Joplin is a mature, cross-platform note-taking and synchronization application built on a monorepo architecture using Yarn Workspaces. It comprises four primary application layers: a desktop client (Electron/React), a mobile client (React Native), a CLI tool (Node.js), and a self-hosted server (Node.js/Koa). The core business logic resides in `packages/lib`, which handles data models (Notes, Folders, Tags), encryption (E2EE), and synchronization protocols (WebDAV, Joplin Server, Dropbox, etc.). The codebase demonstrates strong engineering practices with TypeScript, Redux state management, and a robust plugin system that allows third-party extensibility via a defined API. It supports multiple editor backends (CodeMirror, ProseMirror, TinyMCE) and integrates native modules for performance-critical tasks like OneNote parsing (Rust) and voice transcription (Whisper).
Cal.diy is a fully open-source, MIT-licensed fork of Cal.com, providing a self-hostable scheduling platform. It is a large monorepo containing a Next.js web application (apps/web) for booking pages, settings, and admin, a NestJS API (apps/api/v2) for platform REST endpoints, and extensive packages for business logic (packages/features), integrations (packages/app-store with 50+ apps), embeddable booking widgets (packages/embeds), and reusable React atoms (packages/platform/atoms). The architecture uses tRPC for client-server communication, Prisma ORM with PostgreSQL, Redis caching, and a custom dependency injection system (ioctopus) alongside NestJS DI. Key patterns include a tasker abstraction for async/sync background jobs (webhooks, emails, calendar sync), a versioned webhook payload builder factory, repository pattern over Prisma, and a consistent app-store integration structure. The platform exposes a public API with OAuth2, webhooks, and embeddable components for third-party developers. The codebase is actively maintained with frequent schema migrations and CI/CD pipelines, but exhibits some technical drift due to dual API surfaces (tRPC vs REST), stub implementations for enterprise features, and generated files that require regeneration.
Novu is a comprehensive notification infrastructure platform designed for multi-channel delivery (Email, SMS, Push, Chat, In-App) and workflow orchestration. It functions as both a SaaS product and a self-hosted solution, providing a unified API to manage subscribers, triggers, and notification templates. The system integrates deeply with AI agents, supporting Model Context Protocol (MCP) and managed runtimes (e.g., Anthropic) for conversational notifications. The architecture is a TypeScript monorepo managed by Nx and pnpm, featuring a NestJS backend (API, Worker, WebSocket), React/Next.js frontend (Dashboard, Playground), and MongoDB/Redis/ClickHouse data stores. It emphasizes extensibility through a provider factory pattern and a programmatic workflow DSL.
MindsHub Cowork is a platform superproject that orchestrates four independent submodules into a unified AI workspace for knowledge workers. The repository itself contains no application logic — it's a pure orchestration layer using git submodules (frontend: Electron/Vite app, backend/core_api: FastAPI server, backend/core_agent: Anton autonomous agent, backend/data-vault: data engine). The superproject provides a sophisticated developer workflow via its Makefile: per-developer branch selection through a gitignored dev.env, dual run paths (local source with hot-reload vs uv-tool-installed desktop server) that follow the same refs, deliberate pin management via 'make pin'/'make baseline', and a nuclear 'make flush' for complete environment reset. Submodules are configured with 'ignore = all' so branch work never pollutes the parent git status. The Docker setup uses multi-stage builds with uv for Python and nginx for the web SPA. The REST API (documented in docs/api.html) exposes conversations, projects, artifacts, schedules, files, connectors, memories, skills, scratchpads, and search — all backed by a local SQLite database. This is hybrid in that it manages both a desktop (Electron) and web (SPA) frontend against the same API, but the dominant character is application orchestration.
TriliumNext/Trilium is a full-stack, cross-platform hierarchical note-taking application with rich text editing, LLM integration, sync, encryption, and a plugin-based architecture. The monorepo contains a Node.js Express server (SQLite backend), a Preact/React SPA client, an Electron desktop wrapper, a standalone browser-SQLite-WASM build, and a Capacitor mobile app. The system manages notes as a tree with cloning, attributes, relations, and multiple content types (text, code, mind maps, canvases, spreadsheets, calendars, etc.). It provides custom CKEditor5 plugins for math, footnotes, mermaid diagrams, and AI assistance, as well as a full-featured LLM chat with tool execution and skill sheets. The codebase is well-tested with over 2000 spec files, uses modern TypeScript and pnpm workspaces, and includes comprehensive import/export (Evernote, OneNote, Obsidian, Notion, Google Keep, OPML, Markdown, HTML) and sync capabilities. Key architectural patterns include a provider abstraction for platform-specific services (crypto, zip, messaging, clipboard), a component-based widget system on the client, and a centralized entity cache (becca/froca) that is synchronized via WebSocket.
Task Master is a monorepo providing an AI-driven task management system designed for integration with AI coding assistants (Claude Code, Cursor, Windsurf, etc.). It consists of a CLI tool (`task-master`), an MCP server, a VS Code extension, and core library packages. The system manages tasks with statuses, priorities, dependencies, tags, and subtasks, and offers AI-assisted operations like PRD parsing, task expansion, complexity analysis, and TDD workflow automation (autopilot). It supports multiple storage backends (local JSON files, remote Hamster API via Supabase) and 15+ AI providers. The architecture follows a clean layered pattern with domain modules in `@tm/core` consumed by CLI and MCP interfaces, though a legacy `scripts/` directory still contains overlapping logic being gradually migrated. The codebase demonstrates strong engineering practices including factory patterns, abstract base classes, dependency injection, atomic file operations, and extensive test coverage. Some technical drift is present due to the ongoing migration from JavaScript to TypeScript and duplicated MCP server implementations.
FirebaseUI Web is a multi-package library that provides pre-built authentication UI components for web applications using Firebase Auth. It supports multiple frameworks (React, Angular, shadcn) with a shared core package that handles auth logic, state management, error handling, and internationalization. The library includes ready-to-use sign-in, sign-up, phone, email link, OAuth, and multi-factor authentication (SMS/TOTP) flows, all customizable via a composable behavior system. It is published as npm packages (@firebase-oss/ui-*) and includes extensive examples and end-to-end tests with Playwright against the Firebase Auth Emulator.
Vexip UI is a large, TypeScript-first Vue 3 component library with over 78 high-quality components, built as a monorepo with multiple internal packages (`@vexip-ui/utils`, `@vexip-ui/hooks`, `@vexip-ui/config`, `@vexip-ui/icons`, `@vexip-ui/bem-helper`, etc.). It provides a consistent prop system via `useProps`, BEM-based theming, extensive composable hooks, custom directives, and a global configuration provider. The codebase is actively maintained, with comprehensive unit and SSR tests, bilingual documentation (VitePress), and a playground. It follows modern Vue 3 patterns (Composition API, JSX/TSX, TypeScript generics) and demonstrates strong engineering practices in component architecture, state injection, and performance (virtual scroll, lazy rendering, resize observers). While heavily coupled internally, many of its building blocks (e.g., BEM helper, PostCSS plugin, utility functions) are published as standalone packages and are reusable in other Vue projects.
Optio is a self-hosted, Kubernetes-native orchestration platform for AI coding agents (Claude Code, OpenAI Codex, GitHub Copilot, Gemini, Cursor, OpenCode). In production it runs three task tiers — repo tasks (issue/request → agent pod → PR), standalone jobs (parameterized agent runs without repo checkout), and persistent agents (long-lived, message-driven agents with turn-based execution) — plus an autonomous PR review loop. The core loop is driven by ~15 BullMQ workers (task, PR watcher, review, webhook, ticket sync, reconcile, workflow trigger) against a Postgres database, with Redis pub/sub powering a real-time event bus and WebSocket log/terminal/chat streaming to the Next.js dashboard and CLI. Agents execute in ephemeral pods built from per-language Docker images; a K8s-style reconciliation control plane (world snapshot + pure decision functions + CAS-gated executor) converges four run kinds and catches drift. The architecture is a pnpm/turbo monorepo: a Fastify 5 API with Drizzle ORM and Zod-validated OpenAPI schemas; a Next.js 15 admin dashboard (tasks, jobs, reviews, sessions, agents, cluster, analytics); a Commander-based CLI (login, task/repo/session/secret commands over REST + WebSocket); and a static docs site. Shared packages provide a clean AgentAdapter interface (`validateSecrets` → `buildContainerConfig` → `parseResult`), a Docker/Kubernetes container runtime abstraction, ticket provider adapters (GitHub, GitLab, Jira, Linear, Notion), and shared types/utilities (task state machines, repo URL parsing, SSRF guards, cost arithmetic). Workspace-scoped multi-tenancy with admin/member/viewer RBAC, AES-256-GCM secret encryption with AAD binding, WebSocket upgrade tokens, HMAC-signed internal calls, and a security-focused audit trail (optio_actions) are enforced throughout. Engineering strengths: the test suite is unusually thorough for a project this size — nearly every route, service, worker, and shared utility has a unit test, with per-file Postgres/Redis isolation for integration tests, real-server E2E tests using a deterministic fake container runtime (with mock directives like [[mock:pr]]), and Playwright smoke tests. The reconcile pattern, generic state machine utilities, and pure decision functions in `packages/shared/src/reconcile/` are the highest-craftsmanship code. Known debt: five near-duplicate NDJSON event parsers (one per agent, with drift risk), hardcoded model pricing tables in the Codex/Gemini adapters, scattered duplicated workspace-scoping checks, a 60+ file migration history with historical prefix collisions (now script-enforced), and raw SQL in the analytics service. The project moves fast (v0.1 → v0.4.1 within months, last commit 2026-08) and some surface area (OpenCode/OpenClaw adapters, skills marketplace) is explicitly experimental, but the core architecture is coherent and production-oriented.
This repository is a full-stack video course management system (CVM) designed for creating, editing, and publishing technical video lessons. It consists of a web application (React Router v7 with SSR), a CLI tool (`cvm`), a remote RPC API (Hono, deployed on Vercel), and several internal packages including a core domain library with Drizzle ORM schema, a standalone Remotion overlay renderer, and a vendored Lucide icon set. The system orchestrates complex workflows such as video capture (OBS integration), timeline editing with clip trimming and overlay compositing, AI-assisted content generation (chapter autofill, SEO descriptions, newsletters using Anthropic Claude), and publishing to YouTube, Dropbox, and Buffer. A teleprompter popup syncs via BroadcastChannel, and a diagram editor built on tldraw supports snapshot-based revision history. The architecture is heavily driven by Effect-ts for backend services, with a clear separation between read-only CLI operations (via HTTP RPC) and write operations (via web app routes). The frontend uses optimistic updates for a fluid user experience, while the backend enforces draft-gate policies to prevent writes to published course versions. The codebase is thoroughly tested with Vitest and PGlite in-memory PostgreSQL, using fake service layers for external dependencies (Dropbox, AI generation, video processing). Despite its healthy test coverage and well-structured service pattern, the repository shows signs of organic growth: multiple modals with duplicated state logic, large reducer files, and some drift between duplicated prompt definitions. The dependency on the Effect-ts ecosystem and a large number of third-party APIs (Dropbox, YouTube, Buffer, OBS, Cloudinary) creates a maintenance surface that requires careful version alignment. The overlay renderer is isolated as a separate package with its own build process, reducing coupling but adding deployment complexity.
This is a standalone Rust web server that implements Turborepo's remote caching API. It acts as a sidecar process, typically started inside CI pipelines (GitHub Actions, GitLab, Kubernetes), that forwards artifact storage and retrieval requests to any S3-compatible object store (AWS S3, Cloudflare R2, RustFS). The server exposes a small set of REST endpoints: health check, artifact upload/download/head, event logging, and a team artifact listing stub. Artifacts are streamed directly from the HTTP body to S3 (and vice versa) without buffering into memory. Optional Bearer-token authentication uses constant-time comparison, and the server is instrumented with OpenTelemetry for distributed traces and system-level metrics (CPU, memory) that are exportable via OTLP. The repository also includes a GitHub Action wrapper (Node.js) that manages the binary lifecycle—startup health polling, graceful shutdown, and log collection—and a multi-stage Docker build that produces statically linked Linux binaries and a universal macOS binary. The architecture is a monolith (single binary) built with actix-web, with clear separation into modules for settings, storage, authentication, routes, and telemetry. All artifacts are scoped under a team prefix derived from the Turborepo client's query parameters.