This repository is a community patch overlay for Nous Research's Hermes Agent, adding a durable 'Memory OS': a PostgreSQL-backed URI-addressed memory graph (core://, writer://, system:// domains) with row-level security multi-tenancy, vector semantic recall via a hindsight embeddings service, and a fail-closed write pipeline that classifies candidate memories, verifies them by readback before promotion, routes uncertain writes to human review, and tracks corrections in a regression-replay ledger. It ships a standalone FastAPI + React memory review WebUI, watchdog/scorecard/canary scripts, systemd units, and CI gates including patch verification and a secret-scraping privacy guard. The dominant character is application: an agent-runtime extension integrated with the Hermes CLI, Telegram gateway, and cron scheduler, with tools registered through a central tool registry and policy modules (confidence calibration, privacy inference, relationship boundaries, completion fidelity) returning frozen dataclass verdicts that gate tool execution. Security discipline is unusually strong — writes are readback-verified, secrets are redacted/hashed before persistence, LLM failures block writes rather than proceeding, memory deletion uses HMAC-signed short-TTL grants with nonce replay protection, and roughly 100 test files exercise gates, CLI behavior, gateway gating, plugins, and operational scripts. The main structural weaknesses are two parallel memory-graph backend implementations (embedded agent/memory_graph vs standalone-memory-graph-webui/backend) with duplicate ORM models that may diverge, many hardcoded ~/.hermes profile paths and deployment-specific service names in scripts/tests, and an explicit patch-overlay design that must be re-applied as upstream Hermes evolves. Some data-research flavored utilities exist (trajectory_compressor.py for fine-tuning corpus compression, precision/recall eval harnesses, CJK-aware search tokenization), but they serve the application rather than defining it. For an AI agent looking for memory infrastructure patterns — readback-verified writes, fail-closed policy verdicts, RLS namespace isolation, HMAC-granted deletes — this repo is a strong reference; for direct reuse, treat the standalone WebUI and embedded backend as candidates for consolidation, and expect to parameterize path assumptions.
BetterModel is a server-side Minecraft model rendering engine for Java Edition, distributed as a Bukkit/Paper/Spigot plugin, a Fabric mod, and Maven-published API artifacts. In production it loads Blockbench .bbmodel files at runtime, converts geometry, UVs, and animations into Minecraft item-model JSON and textures, generates or merges resource packs, and streams display-entity packets to clients so animated models can be attached to entities, players, dummies, and mounts. Beyond rendering, it provides public APIs for trackers, hitboxes, nametags, player-skin models, custom armor, event dispatch, scheduling, and third-party integrations with MythicMobs, Citizens, SkinsRestorer, and Nexo. The architecture is a multi-module Gradle build: a platform-independent API module, shared core implementation, Bukkit/Paper/Spigot and Fabric platform bindings, and eight NMS version adapters covering Minecraft 1.21.4 through 26.3. The core data flow is `.bbmodel` JSON -> raw model records -> blueprints -> renderer/rendered bones -> item-display transformations -> packet bundling and resource-pack output. The code is modern, actively maintained, and deliberately designed for high-traffic Paper servers, using Kotlin/Java interop, Adventure, cloud commands, Caffeine, fastutil, JOML, and Paperweight/Fabric Loom tooling. Main strengths are the clean platform abstraction, the public API surface, the packet-bundling and resource-pack generation machinery, and the broad feature set. Main weaknesses are the heavy copy-paste across NMS version modules, a visible lack of automated tests, incomplete Fabric features in places, and heavy reliance on reflection and version-specific internals. Overall this is a solid, professional Minecraft engine implementation with some reusable API-level utilities, but the NMS layer would benefit from generated or shared code to reduce drift risk.
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.
This repository contains a build toolchain for compiling tree-sitter grammar dynamic libraries (.so/.dylib/.dll) for use with Emacs 29+. The core is a Python CLI (`langman.py`) that wraps shell scripts (`build.sh` and `batch.sh`) to clone, compile, and install tree-sitter grammars from GitHub. It supports versioned builds (via git tags) with caching, cross-platform extended attribute versioning, and parallel builds. The architecture is a simple CLI application with separate commands for building, installing, and querying versions. The codebase is well-structured, includes unit and end-to-end tests, and demonstrates clean separation of concerns between the Python frontend and the shell-based build logic. The tool is practical for Emacs users who need a streamlined way to manage tree-sitter language grammars.
This repository is a comprehensive React component library that implements the Salesforce Lightning Design System (SLDS). It provides a broad set of accessible, thematic enterprise UI components such as buttons, modals, data tables, comboboxes, carousels, date pickers, progress indicators, and many more. The library is published as an npm package (`@salesforce/design-system-react`) and is consumed by Salesforce applications and third-party projects. It is not a standalone application; rather, it exports reusable React components with SLDS CSS styling, ARIA support, internationalization hooks (LTR/RTL), and a rich icon system with thousands of inline SVG modules. The architecture follows a consistent per-component folder structure: each component has a main `index.tsx` (or `.jsx`), a development-only `check-props.js` for runtime validation, private sub-components under `private/`, and Storybook documentation under `__docs__` and `__examples__`. Shared utilities live in `utilities/` (e.g., `useClickOutside`, `keyboard-navigate`, `generateId`) and a central constants file defines display names for child filtering. The build system uses Vite to produce both ES and CommonJS bundles, with deep import support. The library relies on external dependencies such as React, `@salesforce-ux/design-system-2` (SLDS CSS), `@floating-ui/dom` for positioning, and lodash per-function packages. Data flows are unidirectional: components receive configuration via props and emit events via callbacks. No backend or state management library is included; integration logic is delegated to the consumer. The library emphasizes accessibility with ARIA attributes and assistive text props throughout. It supports dark/light/system color schemes and includes a custom ESLint plugin to enforce SLDS BEM class conventions. The codebase is in active development with a CI pipeline (lint, typecheck, unit tests, snapshot tests, accessibility tests). However, it exhibits signs of technical debt: a mix of class and functional components, incomplete TypeScript migration, a large deprecation API surface with many sunset warnings, and some example code with minor bugs. The library is evolving toward React 19 compatibility, replacing older patterns (e.g., `react-onclickoutside` with `useClickOutside`). While the components are well-structured and professionally tested, the codebase is not exceptional—it is a solid, production-grade component library with some accumulated drift.
This repository is an educational resource focused on teaching the Gang of Four (GoF) design patterns through comprehensive explanations, code examples, and diagrams. It covers creational, structural, and behavioral patterns, with each pattern accompanied by detailed markdown documentation, visual diagrams, and runnable code samples in both Java and Kotlin. The project structure organizes content by pattern type, making it easy to locate and study specific patterns. The code examples demonstrate practical implementations of each pattern in context-specific scenarios, such as a banking system for the Command pattern, a notification system for the Decorator pattern, and a file system for the Composite pattern. While the build configuration defaults to running a Singleton demo, each pattern includes independent main functions or demo classes that can be executed separately. The repository also features automated workflows for building and deploying the documentation via GitHub Pages. Despite some maintenance challenges like duplicate documentation files (marked for removal in a future version) and the coexistence of Java and Kotlin examples, the project shows active maintenance through contribution guidelines, regular updates, and a clear migration path toward consolidating documentation. The examples are well-crafted, self-contained, and illustrate core object-oriented design principles effectively, making them valuable for both learning and reference purposes.
This repository implements 'Kara', a KDE Plasma 6 applet that functions as a desktop/workspace pager. It allows users to switch between virtual desktops or activities via a configurable widget that can display pills, text labels, or icons. The applet supports multiple highlight styles (line, square, full, full with line), scrolling and click interactions, and custom labeling with templates. The architecture consists of a C++ plugin providing the PagerModel and WindowModel (using KWin and TaskManager APIs) and QML files defining the user interface, representation components, and highlight overlays. The project is actively developed with 37 open issues and 327 stars, and is built for modern KDE Frameworks 6 and Qt6.
ProxMorph is a comprehensive theming system for the Proxmox VE, PBS, and Proxmox Datacenter Manager web interfaces. It provides 23+ dark and light themes derived from popular color palettes (Catppuccin, Dracula, Nord, Gruvbox, Solarized, Tokyo Night, UniFi, GitHub Dark, Blue Slate). The project's primary artifact is a bash installer (`install.sh`) that detects the Proxmox product, deploys CSS files into Proxmox's widget-toolkit directory, patches `proxmoxlib.js` to register themes in the native Color Theme selector, and optionally installs APT hooks for re-patching after system updates. It also includes hardware sensor monitoring (CPU/NVMe/HDD temps, fan speeds, UPS) via a Perl patch to `Nodes.pm` and a client-side JavaScript widget. Architecture is a hybrid of shell scripting (installer, theme generation), static CSS (themes), and JavaScript patches (theme selector, chart colors, sensor display). Each theme is a standalone CSS file (~2000-3000 lines) that overrides ExtJS component classes with heavy use of `!important`. The installer supports cluster-wide deployment via SSH, checksum verification for supply-chain security, and rollback via backup files. The project also includes a component inventory document and a generator for OLED variants using awk-based palette substitution. While the theming itself is tightly coupled to Proxmox's ExtJS DOM structure, the installer and generation scripts exhibit non-trivial shell scripting patterns. The project is actively maintained (v2.8.4), with detailed changelogs and versioned releases. It is not a data research project; all content is UI theming and deployment tooling.
The Graphillion repository is a Python library for efficient graphset operations. It provides classes and functions for generating, manipulating, and analyzing sets of graphs and vertex sets. The library is designed for handling large sets of graphs efficiently and can process trillions of graphs on a single computer. It has been used in various applications, including power network evaluation and railway analysis.
PowerView.py is a Python reimplementation of the classic PowerShell Active Directory reconnaissance and attack tool, PowerView.ps1. It functions as a comprehensive AD security assessment suite, providing an interactive shell, a Flask-based web UI, and a Model Context Protocol (MCP) server for AI agent integration. The codebase is structured as a monolith around a central PowerView class that dispatches commands to specialized modules covering enumeration, privilege escalation, and attack execution. The tool supports multiple AD protocols (LDAP, LDAPS, ADWS, SMB, RPC, Kerberos) for both enumeration and exploitation. It includes modules for Kerberoasting, AS-REP Roasting, Shadow Credentials, ACL abuse, GPO manipulation, ADCS abuse, and trust mapping. A standout feature is its custom implementation of the ADWS (Active Directory Web Services) protocol, including a full MC-NBFX binary XML encoder/decoder and NNS framing, enabling direct SOAP-based interaction with AD. It also features a plugin system, a vulnerability detection engine, and a connection pooling layer. While functionally rich and actively maintained, the codebase exhibits significant structural debt. The command dispatch is a monolithic if/elif chain, and there is considerable code duplication across the CLI, Web, and MCP interfaces. Despite this, several components are genuinely reusable, including the ADWS protocol stack, the plugin framework, the AccessControl (SD/ACE) parser, and the connection pooling utilities. The reliance on forked versions of ldap3 and impacket introduces a maintenance risk. Although classified as an application, the repository has a strong data/research character. It contains extensive, researcher-curated reference data (SIDs, OIDs, extended rights, schema objects) and implements protocol-level research (ADWS binary XML, Kerberos structures, trust key parsing). This makes it a valuable resource for understanding AD internals, even if the primary deliverable is a security tool.
SpyGuard is a network traffic analysis tool designed for detecting signs of compromise, particularly stalkerware and spyware, by monitoring WiFi traffic from connected devices. It consists of a frontend Vue.js 3 application for user interaction and capture initiation, and a backend Flask API for managing configuration, threat intelligence, and analysis. The core analysis engine processes PCAP files using Suricata, checks traffic against IOC databases and whitelists, performs heuristic and active checks (passive DNS, WHOIS, SSL validation), and generates JSON/PDF reports. External watchers periodically update threat intelligence feeds from sources like Cisco Umbrella and IP-to-ASN mappings. The architecture separates concerns: frontend handles capture UI and device management, backend provides authenticated APIs for system administration, and the analysis engine performs the detection logic. Key entry points include server/frontend/main.py (frontend service), server/backend/main.py (backend API), server/backend/watchers.py (threat intelligence updater), and analysis/analysis.py (analysis trigger).
PiLiDAR is a DIY 360° 3D panorama scanner application for Raspberry Pi. It integrates a LiDAR (LD06/STL27L), stepper motor, IMU, and Raspberry Pi camera to capture 2D scans and photos, then processes them into colored 3D point clouds and 360° panoramas. The system is orchestrated by a main Python script (PiLiDAR.py) that controls hardware, captures data, and runs post-processing pipelines. The codebase is modular with a library of device drivers, calibration utilities, and 3D processing functions. It supports hardware PWM via curve-fitted speed control, automatic exposure and white balance calibration, Hugin-based panorama stitching, and Open3D-based point cloud registration, meshing, and visualization. The architecture is monolithic but well-organized, with clear separation of concerns. Key strengths include robust LiDAR protocol handling, reusable stepper motor control, and a comprehensive point cloud processing pipeline. The project is actively maintained with recent commits and low technical drift, though it requires specific hardware and external tools (Hugin, rpicam-still) to function.
OpenAgentsControl (OAC) is a comprehensive multi-agent orchestration and evaluation framework for AI coding assistants. It provides a CLI tool (`oac`) for managing agent configurations across platforms (Cursor, Claude Code, Windsurf) via a compatibility layer with adapters and feature matrices. The system includes an extensive evaluation framework with YAML-defined test suites, modular evaluators (approval gates, context loading, delegation, tool usage, stop-on-failure), and a plugin system for skills, abilities, and hooks. The repository also contains a context management system with MVI (Minimal Viable Information) principles, profile-based installation, and structured documentation. While primarily an application framework for developers and AI agent builders, it integrates evaluation capabilities that resemble data pipeline patterns for agent behavior testing.
This repository is a collection of standalone examples demonstrating the MLX framework (Apple's machine learning framework for Apple Silicon). It covers a wide range of deep learning models including LLMs (Mistral, Mixtral, Llama, T5), image generation (Stable Diffusion, FLUX, CLIP), video generation (Wan2.1), audio (Whisper, MusicGen, EnCodec), segmentation (SAM), and more. Each example is self-contained with its own entry point (CLI or Python script), model conversion utilities, and often a training/fine-tuning script. The repository is primarily an application-focused showcase with some research elements (e.g., normalizing flows, GCN). Production entry points include `whisper/mlx_whisper/cli.py` for transcription, `flux/txt2image.py` for image generation, `video/wan2.1/txt2video.py` for video generation, and `lora/lora.py` for fine-tuning. All examples depend on the MLX library and often bundle conversion from PyTorch weights. The architecture is a flat collection of independent projects, not a unified framework, leading to some code duplication (e.g., T5 and EnCodec are copied into multiple directories). However, several components are well-crafted and reusable, notably the Whisper decoding pipeline, the LoRA adapter module, and the flow-matching samplers for diffusion models.
DSMR-reader is a self-hosted Django web application that reads Dutch smart meter (DSMR protocol) telegrams via serial or network connections, stores electricity and gas consumption data, and provides real-time and historical visualization, statistical analysis, and export. It is a monolith composed of 14+ Django apps (datalogger, consumption, statistics, API, frontend, MQTT, InfluxDB, backup, notifications, etc.) communicating via Django signals and a scheduled process loop. Key entry points include the backend management command (`dsmr_backend`) for infinite background processing, the datalogger command (`dsmr_datalogger`) for telegram ingestion, and REST API v1/v2 endpoints. Primary data flows: telegrams → raw reading models → consumption compaction → hourly/daily statistics, with sidecar integrations publishing to MQTT, InfluxDB, Dropbox, and notification services. External dependencies: Django 5.2, PostgreSQL, MQTT broker, InfluxDB, Dropbox API, Buienradar weather, and third-party notification services. The project demonstrates solid Django architecture with mixins, signals, fixture-based testing, and containerized deployment, though it carries technical debt in outdated frontend libraries (Bootstrap 3, iCheck) and a high number of migrations.
This repository is a companion to the CKS (Certified Kubernetes Security) course, providing shell scripts and Kubernetes manifests to set up a learning environment and demonstrate security hardening techniques. It is not a running application but a collection of infrastructure-as-code resources that users execute on cloud VMs to create a Kubernetes cluster and apply security configurations. The core functionality includes automated installation scripts for Kubernetes master and worker nodes on Ubuntu 24.04 using kubeadm and containerd, along with a Weave CNI plugin for networking. The course-content directory contains dozens of YAML files that illustrate network policies, Open Policy Agent (OPA) gatekeeper policies, secure ingress, node metadata protection, runtime auditing, supply chain security (image footprint, static analysis, vulnerability scanning, image policy webhooks), and system hardening (AppArmor, seccomp). Architecturally, the repo is a set of entry points: the install scripts (cluster-setup/latest/install_master.sh, install_worker.sh) and the Kubernetes manifests applied via kubectl. External dependencies include Ubuntu 24.04, Kubernetes packages, containerd, Podman, and various security tools (Falco, Trivy, Clair, conftest). The code is well-organized and current, with several reusable security profiles (seccomp, AppArmor, OPA policies) that demonstrate non-obvious skill and can be extracted for other projects.
colorful-menu.nvim is a Neovim plugin that enhances completion menus by providing Tree-sitter based syntax highlighting for completion items. It reconstructs context-aware code snippets from LSP completion data (e.g., turning a variable completion into 'var name Type') and applies semantic highlighting. The plugin integrates with nvim-cmp, blink.cmp, and Neovim's native LSP completion through well-defined entry points. Its architecture separates concerns: utility functions handle Tree-sitter parsing and text manipulation, language-specific modules implement reconstruction logic for various LSPs (gopls, rust-analyzer, etc.), and the core module coordinates these components. The plugin demonstrates strong text processing capabilities, particularly in its highlight range adjustment and truncation logic that preserves semantic highlighting during text modifications.
This repository is a production-grade Next.js application (v14 with App Router) that serves as the official web eco-design best practices reference (Référentiel d'écoconception web) by GreenIT.fr. It provides a multi-language (French, English, Spanish) content site with a headless CMS (TinaCMS) for editing, a REST API for programmatic access, and a client-side search (Pagefind). The core content is a structured collection of 115+ best practice sheets (fiches) with frontmatter metadata including lifecycle stages, environmental impact, validation rules, and version tracking. The site is deployed on Vercel and uses MongoDB for TinaCMS indexing. While the primary purpose is an application, the underlying content is a well-structured, versioned dataset that could be used independently for compliance checking or analytical purposes, giving the repo a hybrid character. The application code is well-organized with reusable patterns for MDX rendering, glossary tooltips, content validation, and multi-referential configuration.
The ReVanced Documentation repository serves as a central hub for documentation related to the ReVanced suite of tools (Manager, CLI, and Patcher). It does not contain application code but instead aggregates Markdown documentation and uses Git submodules to link to the respective tool repositories. The repository features a GitHub Actions workflow that automates the process of updating these submodules and committing the changes, ensuring the documentation stays in sync with the source code. Architecturally, the repository is straightforward: it consists of documentation files organized by topic, configuration files for submodules, and a workflow for maintenance. The key entry point is the GitHub Actions workflow triggered by repository_dispatch events, which updates a specified submodule and records the change. This design allows for efficient maintenance of the documentation without manual intervention. While the repository lacks complex application logic, it demonstrates good practices in documentation management and automation. The update workflow is a reusable component that could be adapted to other projects using submodules. The documentation itself is well-organized and accessible, providing users with clear guidance on using and contributing to the ReVanced ecosystem.
HPWater is a water rendering system for Unity HDRP that implements advanced graphical techniques including ray-traced refraction, volumetric lighting, interactive caustics, and fluid dynamics simulation. The architecture follows Unity's Render Graph API with modular components for different water effects. Key entry points include the main HPWater.shader orchestrator and various C# integration files that hook into HDRP's rendering pipeline. The system processes water rendering through multiple passes: GBuffer encoding for water-specific data, caustic simulation via compute shaders, volumetric light scattering with temporal filtering, refraction calculations, and fluid dynamics for wave propagation. While the core implementation is tightly coupled to Unity's HDRP, it demonstrates solid graphics programming practices.