NetCoreKevin is an enterprise-level AI middleware platform built on .NET 9 with a Vue 3 frontend. It provides a multi-tenant SaaS backend with AI agent capabilities, RAG knowledge base, permission management, file storage, messaging, and code generation. The architecture follows Domain-Driven Design with modular plug-ins, featuring a generic repository pattern, base service classes, and extensive cross-cutting concerns (caching, logging, transaction management, distributed locks). The AI agent framework supports tool calling, skill management, memory, safety layers, and streaming responses. The frontend uses Ant Design Vue with multi-theme support. While the codebase is well-structured and feature-rich, it exhibits some technical debt such as static service locators, large helper classes, and raw SQL usage in places. Overall, it is a solid, production-ready application with reusable components.
This is a Nuxt module that integrates Swiper.js into Nuxt 3 applications using Web Components. It provides automatic registration of `<swiper-container>` and `<swiper-slide>` custom elements, a Vue composable (`useSwiper`) for reactive Swiper instance control, and support for both bundled and individual Swiper module imports. The module is minimal, well-typed, and leverages Nuxt's module system for configuration. It includes a playground and test fixture but no complex business logic. The codebase is clean and modern, with proper TypeScript types and a structured setup, though the test suite is practically empty. The composable is well-crafted and could be extracted as a standalone utility.
This repository serves as the landing page for the Nuxt web framework, providing a minimal but polished interface to kickstart Nuxt projects. The core functionality is a gallery of starter templates—each pointing to a GitHub repository branch—with one-click redirections to CodeSandbox, StackBlitz, or a local `npm create nuxt@latest` command. The application is built with Nuxt 4 and leverages server routes for API lookups (slug-based) and redirects, client-side data fetching via `useFetch`, and a performant static generation pipeline. It also includes a custom `style-inlining` module that purges unused CSS and inlines critical styles during prerendering, and a `purge-comments` Vite plugin that strips HTML comments from Vue templates at build time. The UI is styled with Tailwind CSS and Nuxt UI components, and the entire site is designed to be lightweight (budgeted at 270 KB total). It is a genuinely useful tool for the Nuxt community, acting as both a promotional site and a practical starter launcher.
This is a Vue 3 Single-Page Application (SPA) that provides an interactive form-based interface for generating Markdown badges using the shields.io service. The application allows users to generate repo metadata badges, generic static badges, package version badges, dynamic data badges, image markdown/HTML, and a catalogue of pre-made badges. The code is written in TypeScript with a clean separation of concerns: core logic modules handle badge generation and URL construction, Vue components manage UI, and a simple store persists user preferences via localStorage. The architecture is monolithic with client-side routing via Vue Router. The project demonstrates solid software engineering practices with comprehensive unit tests, a Makefile for common tasks, and GitHub Actions CI/CD for linting, testing, and deployment. While the codebase is well-structured and maintainable, it relies on the deprecated Vue CLI and some packages are several major versions behind (e.g., TypeScript 4.6, ESLint 8), indicating moderate technical drift. The application is actively maintained with recent commits and a clear release process.
lx-music-desktop is a cross-platform Electron-based music player (Vue 3 + TypeScript) that aggregates multiple Chinese streaming services (NetEase, Tencent, Kugou, Kuwo, Migu, Baidu, Xiami). It provides music search, playback, playlist management, lyrics (including desktop lyric windows and karaoke-style font rendering), downloads with quality tiers, audio effects (EQ, convolution reverb, pitch shifting), cross-device synchronization over a custom WebSocket protocol, and an HTTP Open API for third-party control. The architecture spans three processes: main (Electron window/tray/IPC, SQLite persistence via better-sqlite3), renderer (Vue app with custom reactive stores and a plugin-based audio engine), and renderer-lyric (dedicated always-on-top lyric window). All built-in music sources were removed in v2.6.0 following a Tencent legal complaint; the app now relies entirely on user-supplied Music API scripts, introducing a sandboxed script runtime with security warnings. The repository is actively maintained (last commit 2026-09-19) but the project is in a transition phase—the maintainer has announced a successor project ('Any Listen'), and the codebase shows signs of legacy accumulation: extensive commented-out code, duplicated components (e.g., MusicSortModal), hardcoded API endpoints/signatures that break frequently, and a custom store implementation diverging from Vuex/Pinia. Despite this, the code is well-organized around provider SDK adapters, composable logic hooks, and a clear main/renderer IPC boundary, with several genuinely reusable patterns.
This is a self-hosted, free image hosting service (Telegraph-Image) built as a serverless application on Cloudflare Pages. It provides image upload, storage (Telegram Bot API or Cloudflare R2), serving with optional moderation (Workers AI or moderatecontent.com), and an admin dashboard (Vue-based) for managing images (list, block, delete, whitelist, edit names, toggle likes). The architecture follows a clean provider pattern for storage and moderation modules, uses middleware chaining via Cloudflare Pages Functions, and includes features like short links (KV-backed), anti-hotlinking, and deployment self-checks. The frontend is hybrid: a dependency-free modern homepage and an older Nuxt.js SPA for the admin panel. The codebase is well-tested with unit and e2e tests, but has technical debt from a legacy Nuxt frontend, deprecated `document.execCommand` usage, and reliance on external CDN resources for admin UI.
Diffgram is a full-stack data annotation platform designed for creating, managing, and reviewing annotations on images, video, audio, text, 3D point clouds, and geospatial data. The system is composed of multiple microservices: a Flask-based REST API (`default`), a background processing service (`walrus`) for media ingestion, export generation, and project migration, an event-driven action runner service (`eventhandlers`) that executes automated workflows (e.g., ML model inference, webhooks, exports), and a Vue 2 + Vuetify single-page application frontend. The backend uses PostgreSQL with SQLAlchemy ORM, RabbitMQ for async messaging, and supports multiple cloud storage backends (AWS S3, GCP, Azure, MinIO). Authentication supports OAuth2/Keycloak, API keys, and session cookies with fine-grained role-based permissions. The platform's core domain includes label schemas, attribute groups, instance templates, task/job management with review workflows, discussions/issues, and a custom query engine for filtering files by labels and attributes. It integrates with external AI services (HuggingFace, Vertex AI, Azure Text Analytics) and labeling vendors (Labelbox, Scale AI). The frontend provides rich annotation tools including 2D canvas (boxes, polygons, keypoints), 3D point cloud annotation with Three.js, audio waveform annotation, text token annotation, and geospatial tile annotation. A command pattern enables undo/redo for annotation actions. The codebase demonstrates solid engineering practices with clear separation of concerns, reusable patterns (strategy, observer, command, policy enforcer), and extensive test coverage (Cypress E2E, Jest unit tests, Python unittest). However, there are signs of technical drift: some outdated dependencies, mixed JavaScript/TypeScript in the frontend, and a few legacy modules marked as deprecated. The open-core model is evident from `OPENCORE - ADD` markers, suggesting proprietary extensions. Overall, Diffgram is a mature, actively maintained annotation platform suitable for teams building training data pipelines.
modV is a desktop application for real-time audio-visual synthesis and effects processing. Built with Electron, Vue.js, and WebGL, it provides a modular environment where users can create chains of visual modules (2D, 3D, shader-based) that react to audio, MIDI, or user-defined parameters. The application features a dual-store Vuex architecture (main and worker processes) to keep the UI responsive while handling intensive graphics and audio processing in a background thread. Key capabilities include audio feature extraction via Meyda, MIDI input mapping, a plugin system for extensibility, and a preset system with seamless state switching. The project emphasizes real-time performance and flexibility for VJs, artists, and live visual performers.
Formvuelar is a Vue 3 form component library designed for backend-driven form workflows, with first-class support for Laravel-style validation responses. The source defines 19+ Fvl* components (input, textarea, select, search select, tag select, checkboxes, radio, switches, sliders, color/date pickers, file uploads, dropzone) and a root FvlForm component that coordinates submission, error display, dirty-state tracking, and upload progress. The core architecture uses provide/inject plus mixins: FvlForm creates a form context object and child controls inject it via formControl.js to read backend errors, clear errors on input, and expose loading and upload state. Submission is handled by Axios with per-form instances and interceptors; the library expects Laravel's 422 { message, errors } payload by default but can be adapted through global $formvuelar configuration.
This repository provides a Vue 3 plugin for printing HTML elements. The plugin allows developers to specify an element to print, apply custom styles, and control print window behavior. The core logic is implemented in src/index.js, which creates a new window, injects the element's HTML and styles, and triggers the print dialog. The plugin handles options merging, browser compatibility (including IE conditional comments), and provides callbacks for post-print actions. While the core functionality is sound and demonstrates skill in handling browser printing quirks, the build dependencies are outdated, indicating some technical drift in the development toolchain.
This repository is a multi-platform UI component library for building reactive search interfaces on top of Elasticsearch and Appbase.io. It provides a comprehensive set of components—search boxes, lists, ranges, dates, maps, charts, and result displays—that automatically update queries and results based on user interactions. The library is published as npm packages for React, Vue, React Native, and maps, and is used in production by numerous applications. Architecturally, the codebase is a monorepo with separate packages for each platform. Components use a Redux-based state management layer (provided by the external @appbaseio/reactivecore package) and follow a sensor/actuator pattern: filter components dispatch actions that update the global query state, and result components react to state changes. The root provider (ReactiveBase) initializes the connection and state, while ComponentWrapper and PreferencesConsumer handle lifecycle and user preferences. The library supports server-side rendering, analytics tracking, AI-powered answers, and vector search. Key entry points are the package index files (e.g., packages/web/src/index.js) that export all components. External dependencies include @appbaseio/reactivecore for state management, appbase-js for backend communication, emotion for CSS-in-JS, and Downshift for autocomplete. While the library is functional and widely adopted, the codebase exhibits significant duplication across platform packages, large monolithic component files (e.g., SearchBox.js ~2000 lines), snapshot-only tests, and some deprecated patterns (eval in chart rendering, hoistNonReactStatics). These factors contribute to a moderate quality score.
This repository is a Nuxt.js 2 module that integrates Sentry error tracking into Nuxt applications. It provides client-side and server-side Sentry initialization, lazy loading, performance tracing, release management, and extensive integration configuration. The module hooks into Nuxt's build process via a custom shim for @nuxt/kit, generating plugin templates and configuring webpack. It supports both JavaScript and TypeScript projects, with options for custom integrations and runtime configuration. The codebase is well-structured with clear separation of concerns (module entry, hooks, options resolution, utilities, templates) and includes a comprehensive test suite using vitest and playwright. However, it is specifically designed for Nuxt 2, which is now deprecated, and the official Sentry Nuxt module is recommended for Nuxt 3+. The repository appears to be in maintenance mode with the last release in September 2024 and no recent commits.
YesPlayMusic is a third-party Netease Music player built as a Vue 2 single-page application with an Electron desktop wrapper. It provides a full-featured music playback experience including personal FM, daily recommendations, playlists, albums, artists, MVs, and synchronized lyrics. The application integrates with the Netease Music API for all content, supports UnblockNeteaseMusic for alternative audio sources, and offers Last.fm scrobbling, Discord Rich Presence, MPRIS (Linux), Touch Bar (macOS), and global shortcuts. The architecture follows a Vuex store pattern with a singleton Player class proxied into the state, and uses IndexedDB (Dexie) for caching track sources, lyrics, and album data. The Electron main process handles IPC for tray, menu, touchbar, and system integration, while the renderer process runs the Vue app with lazy-loaded routes and i18n support for multiple languages. The codebase is well-structured with reusable UI components (Cover, TrackList, ContextMenu, Modal, SvgIcon) and utility modules (lyrics parser, auth helpers, request interceptor). However, it relies on aging dependencies (Vue 2, Electron 13, Node 14/16) and is in maintenance mode per the README, with a new 2.0 alpha in development. Security concerns include disabled TLS verification in Docker and Electron webSecurity disabled. Despite these issues, the project demonstrates solid engineering practices for a feature-rich music player and offers several components that could be extracted for other Vue projects.
CRMEB is a full-featured open-source e-commerce platform built on ThinkPHP 6 (PHP backend) with separate admin, API, customer service, and external API endpoints. The backend serves a Vue 2 + Element UI admin SPA and a uni-app mobile client for WeChat Mini Programs, H5, and apps. It provides standard e-commerce operations (product, order, user, finance management) along with extensive marketing modules (group buying, flash sales, bargaining, coupons, points, live streaming, lottery, agent/distribution), a DIY page builder, and deep WeChat ecosystem integration (official accounts, mini programs, payment, templates, live). The architecture follows a layered pattern: controllers delegate to services, which use DAOs for data access, with models as ActiveRecord classes. The system includes an event system, asynchronous queue jobs, and WebSocket support via Workerman for real-time notifications. It also features a code generation tool (CRUD) to rapidly scaffold admin modules. While the codebase is large and functional, it contains significant boilerplate, duplicated patterns, and some messy code (e.g., repeated conditions in DAO methods). Reusable components include payment, upload, and SMS abstraction layers following a driver/manager pattern, as well as a queue utility and JWT authentication trait.
This repository is a fully functional, offline single-player space strategy game (OGame clone) built with Vue 3, TypeScript, Pinia, and shadcn-vue. It implements the complete OGame feature set: resource management, building, research, fleet combat, defense, diplomacy, NPC AI, achievements, campaigns, and a battle simulator. The architecture is a modern SPA with client-side persistence (localStorage encrypted via AES), optional WebDAV cloud sync, and multi-platform builds (web, desktop via Electron, Android via Capacitor, Docker). The game logic is organized into modular TypeScript files under `src/logic/`, with a centralized game loop in `App.vue` that processes resource production, construction queues, fleet missions, NPC behavior, and achievement checks every second. The UI uses a custom component library built on shadcn-vue and Reka UI, with full internationalization (8 languages). The repository also includes a Go-based static server for production deployment and a battle simulation Web Worker for offloading heavy computation. While the codebase is well-structured and demonstrates good use of modern frontend patterns, it is heavily coupled to game state and lacks automated tests, which limits reusability of most modules outside this project.
AgentHub (also known as Maestro) is an Electron desktop application that orchestrates a virtual software development team of 46 AI agents powered by Claude Code CLI. The system enforces a 'Harness Engineering' methodology: Skills (standardized slash commands), Hooks (pre/post tool interceptors), Gates (quality checkpoints G0–G6), and FileWatchers (auto-sync markdown files to database). The GUI is intentionally limited to monitoring and three core operations—most workflow is driven by slash commands within Claude Code sessions. Architecture follows a three-layer pattern: Vue 3 + TypeScript renderer communicates via Electron IPC (contextBridge) to a main process with ~16 singleton services (session-manager, task-manager, gate-keeper, hook-manager, etc.). Persistence uses sql.js (SQLite in-memory) with a debounced disk save and 13 migrations. The source of truth is markdown files in `.knowledge/` and `.tasks/` directories, which are watched by chokidar and synced to the database. The app supports bilingual UI (zh-TW/en) and runs on Windows, macOS, and Linux. Key features include: sprint-based project management with task dependency tracking, interactive terminal sessions (xterm.js + node-pty), cost tracking per session, Git integration, a gate pipeline with review workflows, and a skill/hook management system with hash-based idempotent deployment. The codebase is well-structured with reusable components and services, though it shows some technical drift (alpha dependencies, brand name mismatch, Windows-specific paths) and high complexity from the extensive agent definitions and knowledge base.
nuxt-purgecss is a Nuxt 3 module that integrates PurgeCSS to remove unused CSS from the final build. It hooks into Nuxt's PostCSS configuration to add the `@fullhuman/postcss-purgecss` plugin with sensible defaults tailored for Vue and Nuxt projects. The module automatically scans common Nuxt directories (components, layouts, pages, composables, app files, plugins, and nuxt.config) for used CSS classes, and includes a safelist of typical Nuxt classes (e.g., transition classes, nuxt-link classes, scoped style attributes) to prevent accidental removal. It also provides a custom default extractor that strips inline `<style>` blocks from Vue Single File Components before extraction, ensuring that only classes used in templates are considered. The module is disabled by default in development mode and can be configured via the `purgecss` key in `nuxt.config`. The codebase is small, well-structured, and includes integration tests using `@nuxt/test-utils` that verify correct purging behavior on a playground Nuxt project. However, the project has seen no releases since September 2022 and relies on outdated dependencies (e.g., Nuxt 3 RC, Node 16 in CI), indicating it is no longer actively maintained.
This repository is a Vue.js 3 component library for building interactive node-based diagrams, inspired by react-diagrams. It provides a `Diagram` component that renders an SVG canvas with draggable nodes, ports, and links, supporting pan/zoom, grid snapping, resizable nodes, custom node types, context menus, serialization, and edit modes. The architecture is a classic Vue component library: a main `Diagram.vue` orchestrates SVG rendering via `vue-svg-pan-zoom`, while `DiagramModel` and `DiagramNode` classes manage the data model. The codebase includes extensive Storybook stories and a documentation site built with Nuxt. While functional and well-documented, the main diagram component is monolithic and mixes concerns, and some features (like port deletion) are incomplete. The library is actively maintained and uses modern tooling (Vite, TypeScript, Vitest).
This repository is a full-stack, multi-client rental property management platform called 'rightHouse' (房适). It consists of three frontends: a Vue 3 + Arco Design admin panel (RH-admin), a uni-app landlord mobile app (RH-landlord), and a uni-app tenant mobile app (RH-tenant), all backed by an Egg.js Node.js REST API (RH-server) with MySQL, Redis, MinIO, and OSS storage. The system enables landlords to publish houses, tenants to search and apply for rentals, and administrators to manage users, houses, and lease applications. Key workflows include lease application with approval flow, maintenance requests, rental market listings with location-based search, and tenant reviews. The architecture is monolithic on the server side but with separate client applications sharing some UI components (uView UI) and a custom HTTP client (luch-request). The codebase is functional and covers the full rental lifecycle, but suffers from duplicated UI component libraries across mobile apps, mixed Vue 2/Vue 3 frameworks, hardcoded configuration values, and lack of automated tests. The admin panel uses modern Vue 3 tooling, while the mobile apps rely on the older uView 2.0 library. The server side includes JWT authentication, SMS notifications, and file upload capabilities. Overall, it is a solid but not exceptional implementation of a rental management system, useful as a reference for similar multi-tenant applications but with several areas of technical debt.
Yi.Abp.Admin is a full-stack enterprise administration framework built on ASP.NET Core (ABP vNext framework) with multiple Vue 3 frontends (Pure Admin, Vben5, RuoYi, and a BBS variant). It provides RBAC, multi-tenancy, audit logging, setting management, code generation, and OAuth support (QQ, Gitee). The backend follows Domain-Driven Design with modules like Yi.Framework.Rbac and Yi.Framework.TenantManagement, using SqlSugar ORM as a replacement for ABP's default EF Core. The frontends feature dynamic route generation from backend permissions, reusable UI components (dialog, cropper, table bar, form API), and state management with Pinia. The monorepo also includes a CLI tool for scaffolding new modules. Despite some duplication across frontends and ABP customizations that may cause upgrade friction, the codebase demonstrates solid engineering with well-separated concerns and several independently usable components.