This is a VS Code extension that provides a unified interface for discovering, installing, and managing MCP (Model Context Protocol) servers and AI agent skills. It integrates with multiple sources: the Official MCP Registry, skills.sh, GitHub repositories, and CloudMCP (a hosted alternative). The extension offers a chat participant (`@mcp`) for natural-language search and install, and a sidebar webview with search and management tabs. It supports 30+ AI coding agents including GitHub Copilot, Claude Code, and Codex CLI. The architecture consists of a TypeScript extension backend (using esbuild for bundling) and a React 19 + Vite + Tailwind CSS + shadcn/ui frontend, communicating via typed RPC messages. Telemetry is collected anonymously with standardized error classification. The codebase is well-structured with clear separation of concerns, CI/CD pipelines, and unit tests.
Tunet is a modern, responsive React dashboard for Home Assistant that provides a customizable interface for monitoring and controlling smart home entities. The application features a React/Vite frontend with an Express/Node.js backend, using SQLite for persistent storage of user configurations. It implements a modular card-based UI system with 20+ specialized card types (lights, climate, media, etc.), real-time WebSocket synchronization with Home Assistant, and extensive customization options including theming, layout configuration, and plugin-like extensibility. The application follows React best practices with custom hooks, context API for state management, and a well-organized component architecture.
This repository powers the tina.io website: a marketing, blog, changelog, and documentation hub for TinaCMS (an open-source Git-backed headless CMS). Built with Next.js 14 (App Router), TypeScript, Tailwind CSS, and TinaCMS itself as the content management system, it dogfoods the product. Content is stored as JSON (structured pages with block-based templates) and MDX (blog posts with rich components). The site features internationalization (English/Chinese with automated translation workflows), Algolia search indexing, API routes for Mailchimp, SendGrid, GitHub, and YouTube integrations, OG image generation via Satori/resvg, visual regression testing with Playwright, and a comprehensive UI component library. The architecture is a standard Next.js monolith with a block-based page builder and a custom TinaCMS schema defining 12 content collections. While the codebase is well-organized and actively maintained, it exhibits some technical debt: mixed styling systems (styled-components and Tailwind), TypeScript strict mode disabled, and a large block template set that may become unwieldy. The i18n implementation relies on duplicated route trees, which a design document aims to refactor.
React Code View is a React component library for rendering code with live preview and syntax highlighting. It provides a CodeView component that combines an editable code editor, live preview, and syntax highlighting, allowing developers to create interactive code examples. The library includes build tool plugins (unplugin) for Vite, Webpack, Rollup, esbuild, and Rspack that enable importing markdown files as React components with automatic code block processing. At its core, it uses Sucrase for JSX/TS transformation, Shiki for syntax highlighting, and CodeMirror 6 for the editing experience, with code execution happening in a sandboxed environment.
Gogs is a self-hosted Git service written in Go, providing a full-featured platform for hosting Git repositories with issue tracking, pull requests, wiki, webhooks, and Git LFS support. The backend is a monolithic Go application using a dual web framework (Macaron and Flamego) and dual ORM (XORM and GORM) during an ongoing migration. The frontend is a hybrid of legacy server-rendered templates and a modern React SPA built with TanStack Router, Radix UI, and Tailwind CSS. The system supports multiple authentication backends (LDAP, SMTP, PAM, GitHub OAuth), SSH and HTTP Git protocols, and extensive REST API. It is deployed via Docker with s6 supervisor and backup rotation scripts. The codebase demonstrates strong engineering practices with well-structured utility packages, security-conscious input validation, and comprehensive test coverage using golden files and mock stores. However, it carries technical debt from the framework migration, vendored outdated frontend plugins (CodeMirror 5.17.0), and a monolithic legacy JavaScript file.
This repository is a React TypeScript cheatsheet that serves as a reference guide for developers. It consists of markdown documentation files in /docs that are processed to generate a README.md and a Docusaurus website. The site covers React and TypeScript topics including hooks, components, context, refs, and concurrent rendering features. The architecture uses Docusaurus for static site generation with custom styling and redirects. Key operational aspects include automated README generation via genReadme.mjs, CI validation of formatting, and deployment to Netlify.
Nginx Proxy Manager is a full-stack web application that provides a graphical user interface and REST API for managing Nginx reverse proxy configurations, SSL/TLS certificates (via Let's Encrypt or custom uploads), TCP/UDP streams, access control lists, and user permissions. The system is designed to run as a Docker container and is primarily used by self-hosting enthusiasts and small-to-medium deployments to simplify the otherwise complex task of configuring Nginx and maintaining certificates. The architecture is a classic three-tier web application: a Node.js/Express backend (ES modules) with Objection.js/Knex ORM supporting SQLite, MySQL, and PostgreSQL; a React 18/19 frontend built with TypeScript, Vite, TanStack Query, and Tabler UI; and a set of s6-overlay managed services (backend, frontend, Nginx) inside a single Docker image. The backend generates Nginx configuration files from Liquid templates and reloads Nginx on any change. External dependencies include Nginx, Certbot (for Let's Encrypt), OpenSSL, and optionally a database server. Key entry points are `backend/index.js` (server startup, migration, setup, Express app) and `frontend/src/main.tsx` (React bootstrap). The primary data flow is: user creates or modifies a proxy host, redirection, stream, or certificate via the UI → API call → backend validates permissions and data → persists to database → regenerates relevant Nginx config files → tests configuration → reloads Nginx. The system also periodically checks for certificate expiration and renews via Certbot, and fetches IP ranges from Cloudflare/Cloudfront for access control. The codebase demonstrates solid engineering practices: a consistent internal service layer with access control and audit logging, a well-typed API client with automatic camelCase/decamelize conversion, a reusable table framework built on TanStack Table, and a comprehensive i18n system supporting 24+ locales. While some modules (e.g., certificate management) are large and could benefit from refactoring, the overall structure is clean and maintainable.
SigNoz is a full-stack open-source observability platform that ingests OpenTelemetry data (traces, metrics, logs), stores it in ClickHouse, and provides a rich web UI for querying, dashboards, alerts, and infrastructure monitoring. The backend is written in Go with a modular architecture using factory/provider patterns, SQL migrations, and OpenFGA-based authorization. The frontend is a React/TypeScript SPA with Zustand state management, react-query, uPlot charts, and a comprehensive query builder supporting PromQL, ClickHouse SQL, and builder queries. The enterprise edition adds anomaly detection, RBAC, licensing, and usage metering. The codebase is actively maintained with extensive testing (unit, integration, e2e) and CI/CD, though some legacy API versions and deprecated clients indicate ongoing migration.
mapcn is a React map component library and documentation site, not a data project. The product is a single-file MapLibre GL JS wrapper (`src/registry/map.tsx`) that exposes composable components such as Map, MapMarker, MapPopup, MapRoute, MapArc, MapGeoJSON, MapClusterLayer, and MapControls. It is distributed as a shadcn/ui registry: users run `npx shadcn add @mapcn/...` and receive copy-paste source code. The accompanying Next.js 16 app is a showcase and docs portal, rendering live examples, code samples, installation commands, and generated LLM-oriented content via routes under `/llm` and `/llms.txt`. Architecturally, the repo combines a library (registry JSON + map.tsx) with an application shell (Next.js App Router, Tailwind CSS v4, shadcn UI components). The map components use React contexts, portals, forwardRef/useImperativeHandle, and MapLibre style expressions to manage markers, popups, routes, arcs, GeoJSON layers, clustering, and hover states. Blocks under `src/registry/blocks/` demonstrate realistic use cases (analytics maps, store locators, logistics networks, uptime monitoring) with hardcoded sample data and external data sources like OSRM routing and Natural Earth GeoJSON. These demo blocks are primarily illustrations, not data pipelines. Maintenance is active, but the codebase has risks: the core map library is a ~3000-line monolith, the distributable JSON registry duplicates source files, and the stack is heavily bleeding-edge (Next.js 16, React 19.2.3, Tailwind v4). No automated tests appear in the repository. Overall it is a polished, effectively structured component library with a strong distribution model, but its craftsmanship is constrained by the single-file monolith and build fragility.
This repository is a minimalist CV (resume) web application built with Next.js 16, React 19, TypeScript, and Tailwind CSS. It serves as a personal portfolio site that renders resume data from a single TypeScript file into a print-friendly layout. The architecture follows Next.js App Router conventions with server-side rendering and static generation. Key features include a command menu for quick navigation, responsive design, dark mode support, SEO-optimized structured data (JSON-LD), and a production-ready Docker setup. The codebase demonstrates strong engineering practices with clear separation of concerns, reusable UI components, and attention to accessibility and performance.
MediaCMS is a production-grade, self-hosted video and media content management platform built as a Django monolith with a React frontend. In production it ingests video, audio, image, and PDF uploads via a chunked Fine Uploader flow, transcodes video through FFmpeg into multiple MP4/HLS renditions matched by configurable encoding profiles, streams them through a customized video.js player, and supports subtitles (manual upload and Whisper transcription), chapter markers, video trimming/editing, playlists, comments with mention notifications, likes, reports, and PostgreSQL full-text search. It ships a REST API under /api/v1/, an editor/manager admin UI, RSS feeds with Yahoo Media RSS extensions, and a small Click-based CLI. The backend is organized into Django apps (files, users, actions, rbac, lti, saml_auth, identity_providers, migrationservice, uploader) with DRF serializers/views, Celery workers for encoding and notifications, Redis as broker, and Nginx serving protected media through an auth_request subrequest. A significant portion is education/LMS-focused: an LTI 1.3 tool provider with deep linking, SAML authentication, RBAC groups mapped to categories, Moodle filter and TinyMCE plugins, and a migration service that imports media, captions, and users from Kaltura, Panopto, and YouTube with quiet-hours scheduling and encrypted credentials. This gives the repository a mild data-pipeline flavor through the migration service, but its dominant character is a full web application. Engineering quality is strong for an open-source Django project: extensive pytest coverage across API, permissions, LTI, SAML, RBAC, migration providers, and pipeline tasks; a large Jest suite for frontend components, hooks, and stores; semantic-release and pre-commit CI; and a clean provider abstraction for migration sources. Weaknesses include legacy webpack-built minified bundles checked into static/, a mix of JSX and TSX across the frontend, duplicated iOS player code between the video-editor and chapters-editor tools, several TODO/FIXME markers, and version-sensitive external dependencies (yt-dlp, Moodle, LTI). Overall it is an actively maintained codebase with several genuinely reusable components, though it carries moderate legacy debt in its frontend tooling.
Iconoir is an open-source icon library (MIT) providing over 1600 SVG icons in 24×24 grid, distributed as framework-specific packages for React, React Native, Vue, SolidJS, Flutter, and CSS. The repository is a monorepo containing the raw SVG icons, a build pipeline that generates typed component libraries from those SVGs, and a Next.js website for browsing and downloading icons with search, filtering, and customization. The build system (bin/build/index.js) uses a plugin architecture to produce components for each target framework, while the website includes virtualized rendering for performance. Despite the large surface area, the codebase is well-organized with clear separation between icon sources, build tooling, and distribution packages. The primary architectural pattern is code generation: SVGs are transformed into framework-specific components via templates, enabling consistent cross-platform delivery. Notable components include the build pipeline's template system (e.g., icon-template.js), the website's virtualized icon list with React Window, and a Python script for enriching icon metadata from naming conventions.
ReadAny is a full-featured, cross-platform e-book reader application with deep AI integration. It supports reading EPUB, PDF, MOBI, FB2, and other formats via the modified foliate-js engine, and provides text-to-speech, annotations, reading statistics, and cross-device sync (WebDAV, S3, LAN). The AI subsystem offers chat with RAG (semantic search over book content), context-aware tools, and execution of user-defined skills. The application follows a local-first architecture with robust offline capabilities and optional cloud sync. The codebase is structured as a pnpm monorepo with four main packages: 'core' (shared business logic, types, stores, AI, RAG, sync, stats, TTS), 'app' (Tauri desktop client with React+shadcn UI), 'app-expo' (Expo/React Native mobile client), and 'cli' (agent integration via MCP and managed shims). The application exhibits high craftsmanship in its platform abstraction layer, persistent store pattern, and hybrid search engine. However, there is significant platform-driven code duplication (desktop vs. mobile UI components) and a complex dependency graph with multiple patched packages, indicating some architectural debt.
This repository implements a multi-agent AI system for generating comprehensive company research reports. The backend is a FastAPI application that orchestrates a LangGraph-based pipeline of specialized research agents: a grounding node that optionally crawls the company's website, parallel research nodes (company, industry, financial, news) that use Tavily search and LLM-generated queries to gather data, a curator that filters documents by relevance score, an enricher that fetches raw content, a briefing node that generates category-specific summaries using Gemini, and an editor that compiles the final report using GPT-4o. The frontend is a React application with TypeScript and Tailwind CSS that communicates via SSE streaming. The system is primarily a web application with a modular agent pipeline, not a data analysis project.
This is a monorepo housing two terminal-based Instagram clients: a modern TypeScript client using React Ink for a rich Terminal User Interface (TUI) and a legacy Python client using curses. The system provides a full-featured Instagram experience entirely within the terminal, including real-time messaging via MQTT, feed and story browsing, profile viewing, multi-account management, authentication (with 2FA/challenge support), and one-turn CLI commands for AI agent integration. It also incorporates LLM-based chat summarization (OpenAI compatible) and basic analytics in the Python client. Architecture is straightforward: a CLI entry point (Pastel for TS, Typer for Python) dispatches commands, with the TUI built from reusable Ink components (ScrollView, MessageList, InputBox, etc.) that manage state via React hooks and contexts. A mock system enables offline UI development. External dependencies include reverse-engineered Instagram APIs (instagram-private-api, instagram_mqtt) and multiple utility libraries. The dual-client structure and reliance on patched, unofficial APIs introduce maintenance risks, but the TypeScript client is well-crafted with clear separation of concerns, thorough component reuse, and thoughtful UX design for keyboard-driven terminal use.
TidGi-Desktop is a cross-platform Electron application that integrates TiddlyWiki (a personal wiki) with AI agent capabilities, Git synchronization, and modern desktop features. It allows users to manage multiple workspaces (folder-based or single-file HTML wikis), sync with Git remotes, and interact with AI agents for chat, tool execution, and knowledge management. The architecture is Electron multi-process with main process, renderer processes (multiple windows), and a utility process for wiki worker. Services are wired via Inversify DI container and communicate via typed IPC (electron-ipc-cat). Key entry points include src/main.ts (Electron main), src/renderer.tsx (React renderer), src/services/agentInstance/ (AI agent lifecycle), src/services/wiki/ (wiki management), and src/services/git/ (Git operations). External dependencies include TiddlyWiki, Git (via dugite), SQLite (TypeORM), various AI SDKs (OpenAI, Anthropic, etc.), OAuth providers, and system-level integrations. The codebase is well-structured with a service-oriented architecture, extensive test coverage (unit, E2E, BDD), and a rich preference system driven by Zod schemas. It demonstrates high craftsmanship in areas like AI prompt concatenation, tool registration, and file system watching, though some modules are tightly coupled to the application's domain.
ReNative (rnv) is a cross-platform development CLI tool and framework that enables building applications for mobile (iOS, Android), web, TV (Tizen, webOS, Fire TV, Android TV, tvOS), desktop (macOS, Windows, Linux, Electron), wearables, and consoles from a single codebase. The system uses a monorepo architecture with modular packages: a core library (`@rnv/core`) providing configuration merging, plugin management, template injection, and task orchestration; platform-specific engines (`@rnv/engine-rn`, `@rnv/engine-rn-electron`, `@rnv/engine-rn-next`, etc.) that define build logic and native project templates; SDK packages (`@rnv/sdk-android`, `@rnv/sdk-apple`, `@rnv/sdk-tizen`, etc.) for platform-specific tooling like device management and code generation; and a CLI entry point (`rnv`) that dispatches commands to registered tasks. The primary data flow involves reading hierarchical configuration files (`renative.json`, `appConfigs/`), merging them with plugin definitions and engine defaults, injecting placeholders into platform templates (e.g., AndroidManifest.xml, Xcode project files, Webpack configs), and then invoking native build tools (Gradle, Xcode, Webpack, etc.) to produce deployable artifacts. External dependencies include React Native, Electron, Next.js, Webpack, and platform SDKs (Android SDK, Xcode, Tizen SDK, webOS SDK). The framework also includes a telemetry module, Docker integration, and a build hooks system for custom pre/post-publish scripts.
svg2jsx is a web application that converts SVG markup into valid JSX code for React components. It provides a real-time editor with a split pane: left for SVG input (with drag-and-drop support) and right for the generated JSX output. The conversion pipeline runs server-side via a Next.js API route, applying SVGO optimization, attribute normalization (camelCase, className, style objects), and optional formatting as a React component (with memo, TypeScript, and quote configuration). The frontend is built with React 18, Next.js 15, TanStack Query, Tailwind CSS, and react-ace for the editor. The codebase is well-structured, with clean separation of concerns between UI components, state management (React Context), and pure conversion logic. Tests cover the core conversion function. The app is designed for single-user, client-side usage with a simple API endpoint.
This repository implements a comprehensive Traefik configuration management system, providing a unified UI and REST API to manage middlewares, routers, services, mTLS, security settings, and plugins. The backend is built in Go using the Gin framework with SQLite for persistence, and it supports both Pangolin and direct Traefik API as data sources. The frontend is a React/TypeScript SPA built with Vite, using Zustand for state management and Shadcn UI for components. Key architectural patterns include background watchers that sync Traefik state into the database, a config proxy that merges and serves dynamic Traefik configuration, and a plugin manager that edits static YAML files. The system acts as an HTTP provider for Traefik, generating dynamic configuration on the fly. It is not a data research project; it is a full-stack operational tool for managing Traefik reverse proxy configurations.
This repository is a React component library (`@codegouvfr/react-dsfr`) that provides a complete implementation of the French government's Design System (DSFR) for modern web applications. It covers nearly all DSFR UI components (buttons, forms, navigation, modals, tables, etc.) and adds framework-specific integrations for Next.js (both Pages Router and App Router), Vite, and Create React App, including SSR support without flash. The library also ships a CLI tool (`npx react-dsfr`) that performs static analysis of a project's source code to generate an optimized CSS bundle containing only the DSFR components actually used, solving a common bloat problem in design-system integrations. Additionally, it provides a GDPR consent management system, i18n per component, MUI theming compatibility, dark mode, and a large set of SVG pictograms. The architecture is a typical React library: each component is a memoized, forwardRef-wrapped functional component using DSFR CSS classes via a `cx` helper. Build-time scripts parse the DSFR CSS into TypeScript constants (spacing, colors, breakpoints, class names) to ensure type safety and ease of use. The library avoids bundling all DSFR CSS in JavaScript; instead, it relies on the CSS being loaded from `node_modules` and optionally trimmed by the CLI. Notable internal patterns include a lightweight `StatefulObservable` for reactive state, a set of stable-callback hooks (`useConst`, `useConstCallback`) to avoid unnecessary re-renders, and a factory pattern for pictograms. While not a hybrid repo, its build pipeline demonstrates a unique approach to CSS-to-TypeScript code generation. The codebase is actively maintained with a comprehensive test suite covering both runtime behavior and build-script correctness. However, it carries some technical drift: it relies on a patched version of `@gouvfr/dsfr` (1.14.2), the pictograms are large inline SVGs that must be manually updated, and the CSS optimization script uses hardcoded component mappings that could diverge from future DSFR releases. Overall, it is a high-quality, production-grade library suitable for any French public service website built with React.