This is a large, well-structured monorepo for the discord.js library, a comprehensive framework for interacting with the Discord API. It provides a full-featured client with managers, structures, builders, voice support, REST and WebSocket transport layers, and extensive documentation tooling. The architecture is modular, with over 15 packages (e.g., @discordjs/core, @discordjs/rest, @discordjs/ws, @discordjs/voice, @discordjs/builders, @discordjs/structures) each with clear responsibilities. The codebase demonstrates high craftsmanship with reusable patterns like fluent builders, mixins, bitfields, and a custom collection class. It includes a documentation website (Next.js), a guide, a proxy container, and CI/CD automation. The library is actively maintained, uses modern TypeScript and Node.js (>=24.17.0), and has extensive test coverage. While the monorepo complexity and a forked API Extractor introduce some maintenance overhead, the overall engineering quality is strong.
Nanobot is a self-hosted, open-source personal AI assistant framework that operates as a full-stack application. The Python backend provides an agent loop with tool execution, session management, multi-provider LLM orchestration (OpenAI, Anthropic, etc.), and a plugin system for 18+ messaging channels (Telegram, Discord, Slack, WeChat, Feishu, etc.). It exposes a WebSocket-based gateway, an OpenAI-compatible API, and a CLI. Two frontends exist: a rich WebUI built with React/TypeScript/Vite/Tailwind and a terminal TUI built with Bun/OpenTUI. The architecture is event-driven via a message bus, with decoupled channel adapters, provider abstraction, and a config system supporting hot-reload. It includes security features like workspace sandboxing, credential redaction, and SSRF protection. The codebase is extensively tested (hundreds of unit/integration tests) and demonstrates strong engineering practices with clean abstractions, though its large dependency surface and multiple frontends introduce some maintenance surface area.
Necord is a NestJS module for creating Discord bots that integrates Discord.js with the NestJS dependency injection system. It provides decorators for defining Discord interactions (slash commands, context menus, message components, modals, etc.) and handles event listening through a discovery mechanism. The architecture follows NestJS patterns with modules, providers, and decorators, using explorer services to scan for decorated methods at runtime. Key features include automatic command registration, custom parameter decorators for interaction data, and advanced context management for asynchronous event handlers using Node.js async_hooks.
Answer Overflow is a full-stack platform that indexes Discord community conversations and makes them publicly searchable via the web, Google, and AI assistants. It consists of a Discord bot (built with discord.js and Effect-TS) that syncs messages, threads, and channels into a Convex backend, and a Next.js web application that renders these conversations as rich, SEO-optimized pages with search, thread cards, user profiles, and an AI-powered chat assistant. The bot handles features like solution marking, auto-threading, forum guidelines consent, and sitemap generation. The web app supports multiple tenants (custom domains) and includes a dashboard for server management, analytics, and subscription billing via Stripe. The architecture is a monorepo with shared packages for the database layer (typed Convex operations via Effect Schema), a custom React reconciler for Discord messages (Reacord), an AI agent component for streaming chat threads with vector search, and observability integrations (OpenTelemetry, Sentry, PostHog, Axiom). Effect-TS is used pervasively for dependency injection, error handling, and structured concurrency across the bot and web backend. The system is highly modular, testable (dedicated convex-test package and Effect-based test layers), and demonstrates advanced patterns in type-safe database access, real-time streaming, and Discord bot engineering.
Discord4J is a reactive, modular Java library for building Discord bots. It provides a high-level abstraction over Discord's REST API, Gateway WebSocket, and Voice protocols, built on Project Reactor and Netty. The library is structured into separate modules: `common` (shared utilities, store abstraction, rate limiting), `rest` (HTTP client with rate limiting and retry), `gateway` (WebSocket client with state management), `core` (domain objects, event system, spec builders), `voice` (voice connection with encryption and DAVE protocol), and `oauth2` (OAuth2 authentication). The architecture follows a layered design with pluggable components for caching (StoreLayout), rate limiting (GlobalRateLimiter), serialization (ExchangeStrategies), and event dispatching. The codebase demonstrates strong software engineering practices: extensive use of immutable specs via the Immutables library, reactive streams for all I/O, and a comprehensive event hierarchy mirroring Discord's API. However, it contains a mix of deprecated legacy specs and newer immutable specs, some experimental features, and a few duplicated utilities. Overall, it is a well-crafted, production-ready library with active maintenance and good reusability in its core patterns.
This repository is a production-grade Discord bot for managing support tickets, built with TypeScript and the discord.js core library. It provides a complete ticket lifecycle: users open tickets via panels (select menus or buttons), staff can claim, close, reopen, rename, add/remove participants, and the bot generates transcripts via ticket.pm. The architecture follows a modular feature-based pattern with automatic discovery of commands, events, and feature modules from the filesystem. The bot uses SQLite (via drizzle-orm and libsql) for persistence, supports internationalization (English and French), and includes telemetry, update checking, and migration scripts from v3 to v4. Key entry points are the slash commands (/add, /claim, /close, /reopen, /remove, /rename, /unclaim, /cleardm, /mass_add) and interactive components (buttons, selects, modals). External dependencies include Discord API, libsql, drizzle-orm, ticket.pm SDK, and typesafe-i18n.
Milo is a self-hosted Discord bot designed for community operations, support, and lightweight moderation. It features a modular architecture using discord.py cogs to separate concerns like AI chat, economy, farming, games, moderation, and utility functions. The bot uses SQLite for persistent storage of per-guild data (economy balances, farming progress, reminders) and includes mechanisms to prevent race conditions in economy operations via per-guild locking. Configuration is managed through environment variables and a local config.json file, with support for guild-specific overrides for features like AI chat API keys. The bot includes AI-assisted chat with optional web search, a per-guild economy with jobs and gambling, a farming progression system, mini-games (Tic-Tac-Toe, guess the number), social interaction commands (hug, slap), media fetching (memes, cat/dog pictures), and moderation tools (warnings, automod for invites/links/bad words). Utility commands cover reminders (with recurring and snooze options), AFK status, server information, and more. Milo emphasizes privacy and control for community owners, with all data stored locally and no required external services beyond Discord for core functionality.
esmBot is a feature-rich Discord bot focused on image manipulation, music playback, and server management. It leverages Oceanic.js for Discord API interaction, native C++ addons built on libvips for high-performance image processing, and Lavalink for music streaming. The bot supports both classic prefix commands and Discord slash commands, with a modular command class hierarchy that simplifies adding new features. It includes a database abstraction layer (SQLite or PostgreSQL), a localization system supporting 20+ languages, and a pagination utility for interactive embeds. The bot can run in a clustered PM2 environment and optionally operate a separate media API server for distributed processing. While the codebase demonstrates good engineering practices with clean abstractions, it has some security concerns (an eval/exec command), incomplete translations, and a complex native build process that may introduce maintenance overhead.
This repository is a formal verification suite for Clawdbot, a Discord bot, using TLA+ and the TLC model checker. It provides machine-checkable security models that act as a regression suite: 'green' models should pass (no invariant violation) and 'red' models are deliberately buggy variants that should fail with a counterexample trace. The repo includes over 100 TLA+ specifications covering gateway exposure, node command policy, pairing store invariants, routing isolation, Discord-specific conformance (role gating, PluralKit, thread binding), and liveness properties. It also contains scripts to extract tool group definitions from the main Clawdbot codebase and generate TLA+ configuration constants, ensuring conformance between the formal models and the implementation. The architecture is a collection of TLA+ specs and model configs orchestrated by a Makefile, with a vendored TLC jar and a CI pipeline that runs selected models on each PR. While the models are domain-specific to Clawdbot, the patterns (e.g., policy precedence, pairing store with expiry and cap, tokenized approvals) are reusable templates for formal verification of similar systems.
Hermit is a feature-rich Discord moderation and community bot for the OpenClaw ecosystem, deployed to Cloudflare Workers with a Bun-based gateway forwarder relaying Discord gateway events. In production it runs as a single Worker isolate using Carbon (@buape/carbon) for Discord interactions and Drizzle ORM over Cloudflare D1 for persistence. It exposes 14+ slash commands (claim, nominate, slap, lobster, say, admin, role, maintainer, helper, github, beta-pings), context-menu commands, webhook APIs for ClawHub search intelligence and publisher abuse digests, scheduled cron tasks (nomination expiry, thread monitoring, card sync), and a React-SSR form system with OAuth flows for ban appeals, content rights cases, and moderated submissions. The bot is tightly coupled to one Discord guild, with guild/channel/role/user IDs hardcoded across config files, though the domain modules (moderation, nominations, forms, games) are cleanly separated and extensively unit-tested against a SQLite D1 shim. A substantial secondary character is deterministic content/data engineering: the repo bundles a frozen WoRMS taxonomy snapshot of 264 accepted lobster species across 6 families, plus meticulously provenance-tracked AI artwork pipelines (1056 lobster scenes, ~327 slap scenes) with SHA-256 checksums, batch manifests, QA gates (RIFF signature checks, dwebp decode, perceptual dHash near-duplicate detection), remediation loops, and byte-identical rebuild tests. These pipelines feed the in-bot lobster encounter and fish-slap games rather than serving external research, so the repository is best classified as an application with strong data-engineering DNA. The build scripts are genuinely reusable for any biodiversity-data or generative-asset workflow. Drift risks include hardcoded local generation paths (e.g. /Users/hrudolph/...), pinned dependency overrides (esbuild, postcss, ws), future-dated snapshot timestamps as data artifacts, and checksum locks that make data updates deliberately expensive.
Broadcastarr is a media broadcasting service that scrapes broadcast schedules from websites, processes and stores broadcast information, and publishes notifications to platforms like Discord and Gotify. It integrates with media servers (Jellyfin) to make content available as M3U8 streams. The architecture consists of a monolithic application with separate server (API), worker (background tasks), and bootstrap (initialization) components. It uses Agenda for job scheduling, Mongoose for MongoDB ODM, Puppeteer for web scraping, Express for API server, and Discord.js for bot functionality. The system provides a REST API for monitoring and control, along with Discord slash commands for management.
This repository contains shinpuru, a production-grade Discord bot written in Go with a React/TypeScript web dashboard. It serves as a comprehensive guild management and moderation platform, handling reports, kicks, bans, mutes, and community engagement features like karma, starboard, votes, and code execution. The backend is a monolith using the discordgo library for Discord interactions, Fiber for its REST API, and sarulabs/di for dependency injection, backed by MySQL, Redis, and MinIO. The architecture is well-structured with clear separation of concerns. The internal/ directory houses services (database, storage, permissions, karma, reports), event listeners, slash commands, and middleware. The pkg/ directory is a standout collection of over 30 reusable utility packages, covering areas like rate limiting (limiter), one-time authentication (onetimeauth), Discord embed building (embedbuilder), fuzzy object resolution (fetch), and permission management (permissions). These packages are largely self-contained and could be extracted for use in other Go projects. The frontend is a modern React SPA with i18n support (English and German), a typed API client (shinpuru-ts), and a comprehensive set of components for managing every aspect of the bot. The project demonstrates strong engineering practices with CI/CD pipelines, Docker support, and a clear contribution model. While the codebase is large and shows some signs of technical drift (legacy package versions, some raw SQL patterns, duplicated package versions), the core architecture and reusable packages make it a valuable reference for building complex Discord bots or Go web applications.
SquadJS is a Node.js scripting framework for Squad game servers. It acts as a server-side daemon that connects to a Squad server via RCON and live log files (local, FTP, or SFTP) to collect real-time events such as player connections, kills, wounds, chat messages, admin actions, and server tick rates. The framework provides a plugin system with base classes (BasePlugin, DiscordBasePlugin) that allow extensibility for Discord integration, database logging (via Sequelize with MySQL/SQLite), community ban list checks, and custom admin tools. It also includes a Socket.IO API for remote monitoring and a prebuilt Grafana dashboard for visualization. The architecture is a monorepo with Yarn workspaces (core, squad-server, assets), where core handles RCON communication and log parsing, and squad-server manages server lifecycle, log rules, and plugin loading. The system is designed to be deployed alongside a Squad game server and is actively maintained with a focus on community-driven plugins.
Botdarr is a Java-based chat bot application that integrates with Radarr, Sonarr, and Lidarr media management services, allowing users to search, add, and monitor movies, TV shows, and music via chat platforms (Discord, Slack, Telegram, Matrix). The system uses a monolithic architecture with modular packages: API clients for each media service, command processing, chat platform adapters, and a SQLite database for persistence (e.g., user request limits, callback data). The main entry point is `BotdarrApplication`, which initializes the configured chat client and starts listening for commands. Data flows: user messages are received by the chat client, parsed by `CommandProcessor`, which executes commands that call the media service APIs (via `RadarrApi`, `SonarrApi`, `LidarrApi`), and responses are formatted by platform-specific `ChatClientResponseBuilder` implementations before being sent back. External dependencies include Apache HttpClient, Jackson, JDA (Discord), Slack SDK, Telegram Bot API, Matrix client-server API, and Flyway for database migrations. The codebase demonstrates solid engineering with strategy patterns for lookup/add/downloads, a command pattern for user interactions, and a clean abstraction for chat client response formatting. However, it suffers from technical drift due to reliance on Java 8, outdated libraries (JMockit 1.40, Jackson 2.13.4.1), and manual versioning. The Matrix client support appears incomplete, and response formatting logic is duplicated across platforms, increasing maintenance burden.
This repository is a retired reference implementation for deploying AI coding agents (CLAWDINATORs) on AWS using NixOS. It provides a complete image-based provisioning pipeline: NixOS images are built with nixos-generators, uploaded to S3, imported as AMIs, and launched as EC2 instances via OpenTofu. The agents run the openclaw gateway, connecting to Discord and GitHub to monitor repositories and assist maintainers. The system includes shared memory via EFS, a control plane Lambda for fleet management, GitHub App token refresh, and scheduled GitHub state sync. The codebase is well-structured with a modular NixOS module, clean shell scripts, and proper infrastructure-as-code patterns. However, the project is explicitly retired (fleet decommissioned August 2026, workflows disabled), so it serves primarily as a historical reference and learning resource for NixOS-on-AWS deployment patterns.
This repository is the community governance and operations hub for the OpenClaw project. It contains no application code; instead, it provides markdown documentation for community team guides, moderation policies, incident playbooks, onboarding, and bot management. The only executable artifact is a GitHub Actions workflow (`clawsweeper-dispatch.yml`) that dispatches events to an external ClawSweeper bot for automated GitHub QA and merge assistance. The repo also includes well-structured issue templates for policy and rules changes. It is not a software application in the traditional sense, but rather a set of operational documents and GitHub configuration files that support the OpenClaw community. The quality score reflects the lack of reusable software components and the documentation-only nature, though the workflow demonstrates moderate engineering craftsmanship.