RedBot (node-red-contrib-chatbot) is a Node-RED plugin that provides a visual palette of ~109 nodes for building multi-platform chatbots. It supports Telegram, Facebook Messenger, Slack, WhatsApp, Viber, Sinch, DeepChat, and Discord through a common ChatExpress middleware engine. The package also includes Mission Control, a React-based admin panel for managing chatbots, users, content, devices, and plugins, served alongside the Node-RED editor. Architecturally, the system uses a monolithic Node-RED plugin pattern with a separate React frontend. Inbound messages arrive via platform webhooks, pass through ChatExpress middleware chains, and are routed into Node-RED flows. Outbound messages are sent through platform-specific sender nodes. Mission Control provides a GraphQL API (Apollo Server, Sequelize, SQLite) for data access and WebSocket endpoints for real-time message streaming and simulator feedback. A custom plugin system (code-plug) allows extending the admin UI with pages, widgets, and permissions. Key features include flow control nodes (Rules, Conversation), context management, message templates with variable substitution, OpenAI Responses API integration, queue management, and a wide array of media and interactive nodes (images, buttons, invoices, etc.). The project is mature (version 2.0.5) with extensive documentation and a large user base, but carries technical debt from aged dependencies (GraphQL v14, React 16, Apollo Boost 0.4), mixed coding patterns, and platform-specific workarounds.
This is an educational repository of Python scripts, mini-projects, and markdown guides for building LLM-based AI agents applied to cybersecurity. The code is organized into five progressive parts: foundational LLM/embeddings usage, prompt templates, prompt chaining, RAG over security data, and agentic workflows. It demonstrates multiple agent frameworks (LangChain, LangGraph, CrewAI, DeepAgents) and MCP server integrations for tools like nmap and Shodan. The dominant character is application/tutorial code rather than data research, although it bundles small datasets (CVE embeddings, sample RAG corpora) and commits Chroma vector stores for offline exercises. The repo is not a single deployable service; it is a collection of entry-point scripts and small frameworks. Architecture is a set of standalone examples with shared patterns: state graphs for orchestration, YAML-configured crews, MCP adapters, and RAG ingestion/query pipelines. Most scripts require OpenAI-compatible API keys and/or local tools such as nmap/Ollama. Simulated data and placeholder responses in some examples make it a learning environment rather than production security tooling. Maintenance is current but drift is moderate: some examples use deprecated langchain vectorstore imports, documentation is duplicated across subdirectories, several referenced files are missing, and hardcoded model strings like gpt-5.4-mini appear dated or fictional. There is no root-level automated test suite; only the Shodan MCP subproject contains tests. The strongest reusable patterns are the MCP server wrapping, LangGraph conditional-state orchestration, CrewAI declarative crew configuration, and the hierarchical SOC agent supervisor.
This repository provides a set of custom memory allocator implementations in C++ (Linear, Stack, Pool, FreeList, and a wrapper for malloc). The allocators are designed for educational purposes, demonstrating how to replace general-purpose malloc with more efficient, specialized allocators. The code is structured around a common base class (`Allocator`) and uses generic linked list data structures (singly and doubly linked, plus a stack-based linked list) to manage free memory blocks. A benchmarking framework (`Benchmark`) measures allocation/free throughput and memory usage. The project is a library/example, not a production service, and is intended to illustrate trade-offs between allocator types. The implementation is clean and well-organized, but lacks tests and modern C++ features, and has not been actively maintained.
This is an Arduino library for parsing serial data packets from NeuroSky-based EEG headsets (Star Wars Force Trainer, Mattel MindFlex). The Brain class implements a complete packet protocol parser with sync byte detection (0xAA, 0xAA), length validation, checksum verification, and data extraction. It exposes signal quality, attention, meditation values, and 8 EEG power bands through getter methods and CSV output. The library is designed for embedded systems with limited memory, using fixed-size buffers and Stream-based interfaces compatible with both HardwareSerial and SoftwareSerial. The architecture is a single monolithic class with no external dependencies beyond the Arduino framework. Data flows from serial input through packet parsing to either CSV string output or individual getter methods. The code demonstrates solid embedded engineering practices for its domain, including proper state management, error handling, and protocol compliance. However, it uses dated C++ patterns (char* instead of std::string, boolean instead of bool) and fixed buffers that could overflow with malformed input. This library is well-suited for hobbyist brain-computer interface projects using legacy NeuroSky hardware. It's not suitable for modern Arduino versions without modification, and the hardware it targets is aging. The code is clean and reusable but lacks tests and modern safety features.
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.
MRH-G2Ray is a containerized application that sets up a VLESS proxy server (Xray) on GitHub Codespaces, providing a free, ephemeral proxy service. The system automatically generates a unique UUID per Codespace, configures Xray with VLESS over XHTTP, and exposes an admin web panel (port 8080) with HTTP Basic Auth for easy retrieval of the VLESS connection link. The architecture is a single Docker container running both Xray and a Python-based admin server, orchestrated via devcontainer configuration. It is designed for users in restricted regions to bypass internet censorship using GitHub's free cloud infrastructure. The codebase is modular with separate startup scripts, but tightly coupled to the specific Xray configuration and Codespaces environment.
Chardin.js is a jQuery plugin that creates an instructional overlay on web pages, highlighting elements and displaying tooltips based on `data-intro` and `data-position` attributes. It supports both a simultaneous display of all hints and a sequential step-by-step tour mode with automatic or click-based advancement. The plugin dynamically positions helper layers and tooltips relative to target elements, handling scroll and resize events. The architecture is a single-file, self-contained jQuery plugin pattern with an accompanying CSS file. It relies on jQuery 3.5+ and a simple API for starting, stopping, and toggling the overlay. The codebase is functional and well-structured but uses an outdated build chain (CoffeeScript, Rake, node-sass) and lacks modern module bundling or ES6 syntax. The repository appears to have been inactive for several years, with no recent commits or active maintenance.
Scrawl is a 2D game engine that fuses a Python-facing API with a high-performance Rust runtime built on Bevy and PyO3. It targets developers who want Scratch-like simplicity (sprites, scenes, broadcasts, event decorators) and Godot-like depth (node tree, signals, physics bodies, animation). The Python package (`scrawl`) provides classes for Game, Scene, Sprite2D, RigidBody2D, Camera2D, Timer, Tween, and more, all of which transparently synchronize with a Bevy ECS backend via a shared command queue and dirty-flag system. A visual IDE (`scrawl_ide`) built with PySide6 offers scene editing, code editing, asset management, property inspection, an AI chat panel, and a game runner that launches the engine as a subprocess. The Rust side comprises 13+ crates (core, render, physics, audio, particles, navigation, animation, tilemap, UI, scripting, bridge, editor protocol), though several remain disconnected from the main binary (e.g., audio, particles, navigation). The overall architecture is dual-process: the IDE writes generated Python scripts to disk and spawns the engine binary, which uses named pipes for editor-server protocol. This is purely an application; there is no data analysis or machine learning component.
SVGKit is a mature Objective-C library for rendering SVG files natively on Apple platforms (iOS, macOS, tvOS, watchOS, visionOS). It provides a full SVG 1.1 parser built on libxml2 SAX, an extensive DOM implementation (Core DOM + SVG-DOM) with CSS style support, and a CALayer-based rendering pipeline that converts SVG elements into Core Animation layers. The library offers two rendering modes: a fast bitmap-based view (SVGKFastImageView) and an interactive layered view (SVGKLayeredImageView). It also includes export utilities for rasterizing SVGs to NSData, UIImage, and NSImage. While functionally solid and widely used (over 4,500 stars), the codebase shows signs of age: many SVG features are stubbed with 'not implemented' assertions, the bundled CocoaLumberjack 2.2.0 is outdated, and there are code duplication and workarounds for Apple private class collisions. The architecture is modular with a plugin-based parser extension system, making specific components (like the path data parser, CSS value parser, and DOM node classes) potentially reusable in other contexts.
PAML is a suite of command-line C programs for phylogenetic analysis by maximum likelihood, the de facto standard in molecular evolution for estimating substitution parameters, detecting positive selection (codeml NSsites, branch-site, and clade models), computing dN/dS distances (yn00), simulating sequences (evolver), and estimating divergence times with fossil calibrations (mcmctree). Programs are driven by control files using key = value options, consume sequence alignments and Newick trees, and write detailed text outputs (rst, mlc, mcmc.txt, rates). The primary entry points are standalone executables: codeml, baseml, mcmctree, evolver, yn00, pamp, chi2, and ds. This is research software serving empirical evolutionary biology, not a data pipeline or library. Architecturally, the codebase is monolithic legacy C: a central shared header (src/paml.h) plus large shared implementation files (src/tools.c, src/treesub.c, src/treespace.c) are compiled into each program via #define program macros and direct #include of .c files, with heavy #ifdef conditional compilation. The numerical core is sophisticated and battle-tested — eigen-decomposition of rate matrices, matrix exponentials, Newton/BFGS/Levenberg-Marquardt optimizers, discrete-gamma heterogeneity, Bactrian MCMC proposal kernels, and ESS/HPD diagnostics — but is embedded in global state, fixed-size arrays (requiring recompilation for large datasets), hardcoded limits, and extensive #if 0 dead code. The changelog (doc/pamlHistory.txt) candidly documents known regressions and broken features across its 30-year history, a genuine risk for trust-critical reuse. The repository is actively maintained (version 4.10.10, last commit 2026-01-29) with rigorous versioned releases and an exceptionally detailed changelog. Technical drift is medium: the code style is decades-old C with acknowledged weaknesses (unsafe allocations, platform-dependent system() calls, interactive prompts), but the science remains current and the package is still the reference implementation against which newer phylogenetic methods are validated. The most reusable assets are the self-contained numerical routines in tools.c, the tree parsing and site-pattern compression in treesub.c, and the standalone distribution functions in chi2.c; extracting them into a new project is feasible, whereas the monolithic driver programs are too coupled to be worth reusing directly.
soynlp is a pure-Python library for unsupervised Korean natural language processing, providing statistical methods for tokenization, noun extraction, POS tagging, lemmatization, and text normalization. The architecture is modular, with subpackages for hangle (Hangul decomposition/composition), lemmatizer, normalizer, noun extraction (v1, v2, news), POS tagging (dictionary-based and LR-template-based), tokenization (LTokenizer, MaxScoreTokenizer, RegexTokenizer), vectorization (TF-IDF-like), word extraction (cohesion, branching entropy), and utility data structures (LRGraph, EojeolCounter). Key entry points include WordExtractor, LRNounExtractor_v2, LTokenizer, MaxScoreTokenizer, BaseVectorizer, and DoublespaceLineCorpus. Data flows typically involve reading a corpus of double-space-separated sentences, building LR substring frequency graphs, extracting word/noun scores, and then using those scores for tokenization or tagging. External dependencies are limited to numpy and scikit-learn (older versions). The repository also includes research-oriented tutorials (Jupyter notebooks) and pre-built linguistic resources (frequency dictionaries, trained noun predictors), making it a hybrid of a production library and a research codebase. The unsupervised approach is well-suited for homogeneous document collections where domain-specific adaptation is needed.
This repository provides a functional system for motion retargeting from human video to robot models. It detects arm and hand poses from monocular video using MediaPipe, fuses the detections, applies multi-stage coordinate transformations (world → first-person → URDF standard), and retargets the motion to robot URDF models using numerical optimization. The system includes visualization tools for debugging coordinate transformations and verifying retargeting results. The architecture is modular with separate components for detection (`src/whobody_dect/`), retargeting (`src/dex_retargeting/`), and example workflows (`example/`). Key entry points include `example/vector_retargeting/retarget_from_wholebody_video.py` for the main retargeting pipeline and `src/whobody_dect/simple_visualize.py` for coordinate system validation.
PersistentWindows is a Windows system tray utility that automatically saves and restores window positions, sizes, and Z-order across display changes such as monitor connection/disconnection, resolution changes, wake from sleep, and RDP reconnections. It captures window layouts either automatically on display events or manually via hotkeys or tray menu, stores them in memory and a local LiteDB database, and performs multi-pass restoration to handle unresponsive or slow windows. The application also includes a webpage commander feature (Alt+W) that translates single-key shortcuts into browser actions for efficient web navigation. The architecture is a monolithic C# desktop application targeting .NET Framework 4.5, with a system tray interface built using Windows Forms. The core logic resides in PersistentWindowProcessor.cs (~3000 lines), which handles event hooks, timers, capture/restore algorithms, and database persistence. The WinApiBridge module encapsulates all Windows API interactions (User32, Kernel32, Shell32) via DllImport declarations, while separate modules provide internationalization (Lang.cs), minimize-to-tray functionality, and virtual desktop support. The application runs as a background process with optional GUI elements for configuration and manual snapshots. External dependencies include the Windows operating system (Vista through 11+), .NET Framework 4.5, and a custom LiteDB implementation for persistent storage. The application also supports auto-upgrade by checking GitHub releases and downloading updates. It is licensed under GPL v3 and has a strong focus on edge-case handling for fractional scaling, taskbar restoration, and unresponsive windows. While the codebase is functional and feature-rich, it exhibits high coupling in the main processor class and relies on platform-specific APIs that may require updates for future Windows versions.
This repository is a Visual Studio Code extension for developing, debugging, and simulating Apache Cordova and Ionic mobile applications. It provides a comprehensive debug adapter that supports launching and attaching to Android, iOS, browser, and simulated targets. The extension integrates with the Chrome DevTools Protocol (CDP) via a custom proxy to enable sourcemap rewriting and cross-platform debugging, and it offers IntelliSense for Cordova plugin APIs and Ionic framework components. It also includes commands for building, running, preparing, and cleaning Cordova/Ionic projects, as well as telemetry and localization support across 14 languages. The architecture is modular: the core debug session (`CordovaDebugSession`) delegates to platform-specific implementations (`AndroidPlatform`, `IosPlatform`, `BrowserPlatform`) that inherit from abstract base classes (`AbstractPlatform`, `AbstractMobilePlatform`). A CDP proxy layer (`CordovaCDPProxy`) intercepts and transforms messages between the debugger and the target runtime, with specialized message handlers for Chrome and Safari runtimes. Target management is handled by `MobileTargetManager` subclasses (`AndroidTargetManager`, `IOSTargetManager`) that enumerate devices and emulators. The extension also includes a plugin simulator (`PluginSimulator`) that serves the app via `cordova-simulate` and a Socket.IO connection. Key entry points include the extension activation (`src/extension/cordova-extension.ts`), the debug configuration provider (`src/extension/debugConfigurationProvider.ts`), and the debug session class (`src/debugger/cordovaDebugSession.ts`). External dependencies include the Cordova CLI, Ionic CLI, Android SDK, iOS toolchain (Xcode, ios-webkit-debug-proxy), and npm packages like `cordova-simulate`, `socket.io-client`, and `vscode-js-debug-browsers`. The codebase is written in TypeScript and uses Gulp and Webpack for building. While the extension is functionally complete and well-structured, it shows signs of technical drift: many dependencies are outdated (e.g., `applicationinsights` 0.15.6, `socket.io-client` 2.4.0), the Cordova ecosystem has declined in favor of Capacitor, and the large i18n file set (200+ files) adds maintenance overhead. The code contains some legacy patterns (e.g., `eval` for custom require, extensive use of `any` types) and hardcoded timeouts. Despite this, the core abstractions for platform handling and CDP message processing are well-designed and potentially reusable.
This repository contains an Android application that uses the Shizuku framework to gain privileged access to system services for modifying carrier configuration. The app enables VoLTE and other IMS-related settings by overriding carrier config parameters for all active subscriptions. It consists of two main components: a ShizukuProvider that handles binder communication with the Shizuku service, and a PrivilegedProcess (Instrumentation subclass) that runs in a privileged context to grant permissions and apply carrier config overrides. The application targets Android SDK 34-37 and relies on the Shizuku and HiddenApiBypass libraries for system access and hidden API bypass.
GrasscutterCommandGenerator is a Windows Forms (.NET Framework 4.8) desktop application that serves as a comprehensive administration and command-generation tool for Grasscutter, a Genshin Impact private server emulator. It provides a GUI to generate and execute server commands (e.g., give items, teleport, spawn entities, set weather), edit server configuration files (gacha banners, drops, shops, activities), manage player accounts and permissions, and run a MITM proxy to intercept game traffic. The application is heavily data-driven, relying on embedded localized text files for game entity IDs and names, and uses Newtonsoft.Json for serialization. It supports multi-language UI (Chinese, English, Russian, Traditional Chinese) and integrates with a remote command plugin (gc-opencommand-plugin) for direct server interaction. The architecture is a monolith WinForms application with a tabbed page interface. The main entry point is Program.cs, which initializes the main form (FormMain) that hosts multiple pages (e.g., PageGiveItem, PageAvatar, PageQuest, PageProxy) and modal editors (FormGachaBannerEditor, FormShopEditor). A base class (BasePage) provides common lifecycle and command execution methods. The application communicates with the Grasscutter server via HTTP (OpenCommandAPI) and can also modify system proxy settings to redirect game traffic. External dependencies include the .NET Framework, Newtonsoft.Json (embedded), and Windows API calls for proxy and hotkey management. Key data flows involve loading game data from embedded resource files at startup, constructing command strings from user input, and optionally sending them to the server. The proxy module (Eavesdrop) captures and forwards HTTP/HTTPS traffic between the game client and server. The tool also supports importing/exporting player data in the GOOD (Genshin Open Object Description) format. While the codebase is functional and well-organized for its domain, it is tightly coupled to the Grasscutter server API and game data, requiring manual updates with each game patch. No automated tests are present, and the reliance on hardcoded data and Windows-specific features limits portability.
Totum is a self-hosted, low-code/no-code application framework built on PHP 8.3 and PostgreSQL. It functions as a dynamic database and spreadsheet hybrid, allowing users to define data structures (tables, fields) via JSON configuration and implement business logic using a proprietary DSL ('Totum-code'). The system features a modular architecture with a CLI management tool (`bin/totum`), a web-based UI (`http/index.php`), and extensive role-based access control (RBAC). It supports multi-tenancy via schema mapping, external service integration (PDF, Excel, AI), and automated installation via Ansible playbooks for Ubuntu environments. The core logic relies heavily on traits for shared functionality and abstract base classes for table and field handling, creating a flexible but complex codebase. The application is designed for rapid business application construction (CRM, ERP, custom tools) without requiring traditional coding. It stores schema definitions and field configurations in PostgreSQL JSONB columns, enabling runtime structure modification. The calculation engine (`Calculate.php`) parses and executes custom code strings for data validation, formatting, and cross-table logic. While the architecture is robust for its intended purpose, it exhibits signs of technical debt including monolithic frontend JavaScript (`main.js`), hardcoded paths in installation scripts, and reliance on legacy libraries (Chart.js v2, jQuery). The codebase demonstrates significant craftsmanship in its dynamic table engine and calculation DSL, but maintenance requires careful handling of the custom parsing logic and schema migrations.
This repository provides a comprehensive CLI toolkit and programmatic interface (Python SDK and notebook clients) for creating, deploying, managing, monitoring, and evaluating AI agents on Amazon Bedrock AgentCore. The system supports multiple agent frameworks (Strands, LangChain/LangGraph, CrewAI, AutoGen, OpenAI Agents, Google ADK) and infrastructure-as-code options (CDK, Terraform). Key capabilities include project scaffolding via Jinja2 templates, runtime lifecycle management (configure, launch, destroy, invoke), memory management (short-term/long-term, semantic, user preference), observability (CloudWatch-based trace and log querying with OpenTelemetry span parsing), evaluation (LLM-as-a-judge with built-in and custom evaluators), policy engine CRUD, gateway management (MCP, API key, Cognito OAuth), and identity federation setup. The codebase is well-structured with a clear three-layer architecture (CLI -> operations -> services), extensive test coverage, and consistent error handling. However, the project is explicitly deprecated in favor of the @aws/agentcore NPM CLI, meaning future development is minimal and users are encouraged to migrate. Despite the deprecation, the reusable abstractions (e.g., CloudWatch query builder, trace processor, strategy models, configuration schemas) demonstrate solid software craftsmanship.
This repository defines a schema for describing custom elements manifest files. It provides a TypeScript definition file (schema.d.ts) that serves as the single source of truth for the schema, and a generated JSON Schema file (schema.json) for validation. The schema captures metadata about custom elements including their attributes, events, methods, and CSS properties. The repository includes build scripts to generate the JSON Schema from TypeScript definitions, tests to validate the schema against an example manifest, and CI/CD workflows. While the schema itself is well-designed and reusable, the project shows signs of technical drift due to outdated dependencies.
Tilt is a Ruby library that provides a generic interface to a multitude of template engines. It abstracts away the differences between engines like ERB, Haml, Markdown variants, and many others, offering a unified API for template loading, compilation, and rendering. The architecture is built around a central Tilt module, a Mapping class that associates file extensions with template implementations, and a base Template class that individual engines subclass. The library supports lazy loading of template engines, template caching, and pipeline composition. It is widely used in the Ruby ecosystem, particularly in web frameworks like Sinatra and Rack. The repository under rtomayko/tilt is no longer maintained, as the project has moved to jeremyevans/tilt, but this version represents the stable 2.x series. The code is well-structured and demonstrates good software engineering practices, though some template implementations are deprecated or rely on older gems.