This repository is an AI skill/prompt library for coding assistants (Claude, Cursor, GitHub Copilot, etc.). It contains a comprehensive security-focused markdown guide (SKILL.md) that AI assistants reference when generating code to ensure secure coding practices. The skill covers 60+ security vulnerabilities including IDOR, XSS, CSRF, SSRF, SQL injection, JWT misconfigurations, and more. It's designed to be installed in AI assistant skill directories to provide real-time security guidance during code generation. The repository has minimal structure - just three files (LICENSE, README.md, SKILL.md) with no traditional software components like tests, CI/CD, or package management. This is appropriate for its purpose as a static documentation resource for AI assistants. The security guidance is comprehensive and well-organized, covering both prevention strategies and common bypass techniques attackers use. Note: The last commit date (2026-02-17) appears to be in the future, which is unusual. The repository has 0 open issues and 94 forks, suggesting active adoption despite the odd timestamp.
This is the official web-based developer UI for Google's Agent Development Kit (ADK), an Angular single-page application for building, testing, evaluating, and deploying AI agents. In production it acts as a full agent IDE: a chat surface with SSE and WebSocket streaming (including bidirectional audio and video), a visual node-graph builder that reads and writes agent YAML configurations, an OpenTelemetry trace inspector with span trees and waterfall charts, an evaluation runner with configurable metrics and pass/fail thresholds, artifact and session browsers, and deployment wizards for Cloud Run, GKE, and Agent Runtime. The repository is an application, not a data pipeline: trace spans and eval results are consumed for UI introspection and agent debugging, but no notebooks, training scripts, or ETL jobs exist.
This repository is a monorepo of self-contained demo applications showing how to build and deploy multi-agent AI systems using Docker Compose, Docker Model Runner, and the MCP Gateway. It contains 12+ independent examples spanning Google ADK, A2A, Agno, CrewAI, LangGraph, Langchaingo (Go), Spring AI, Akka, and a Next.js agent UI. Each subproject is a standalone composition with its own compose.yaml, Dockerfile, and README, designed to run with a single `docker compose up --build` after creating a `.mcp.env` file. The demos are reference architectures rather than a single product, emphasizing local LLM inference, MCP tool integration, and switching between local and cloud models via compose override files.
Strecs3D is a specialized desktop application designed to optimize 3D printing infill density through Finite Element Method (FEM) analysis. The software ingests CAD geometry (STEP/STL) and optional stress analysis results (VTU), segments the mesh based on stress thresholds, and exports variable-density 3MF files compatible with major slicers like Cura, Bambu Studio, and PrusaSlicer. It serves as a bridge between structural engineering simulation and additive manufacturing, allowing users to reduce material usage while maintaining structural integrity. The architecture is built on Qt 6 for the user interface and VTK for 3D visualization, compiled via CMake with vcpkg for dependency management. The application follows a modular design with a clear separation between the UI layer, core processing logic, and FEM pipeline integration. It supports a full simulation workflow, converting STEP files to CalculiX input (INP), running the solver, and converting the output (FRD) back to VTK format for visualization and processing. Data flows from geometry import through optional FEM simulation to mesh segmentation and 3MF export. The system relies heavily on external tools (CalculiX, Gmsh, OpenCASCADE) which are integrated via custom ports and wrappers. While the internal C++ code demonstrates professional engineering practices, the heavy coupling to external binary dependencies and platform-specific build configurations introduces maintenance complexity. The codebase is actively maintained with recent commits and a low issue count relative to its popularity. However, technical drift is present due to hardcoded paths for external solvers and custom patches for Gmsh, which require careful version management to prevent breakage in deployment environments.
StoryToolkitAI is a video editing toolkit that leverages AI to enhance post-production workflows. It operates in dual modes (GUI and CLI) with core functionality centered around transcription, semantic search, speaker diarization, and integration with DaVinci Resolve Studio. The application enables users to transcribe media files, search content using natural language, generate stories via LLM assistance, and export to professional editing formats (EDL, XML, Fountain). Key architectural elements include a plugin-based system for LLM providers, a persistent task queue with dependency tracking for CPU/GPU workloads, and project-based file linking for unified search across media assets. The tool emphasizes local processing with optional external API usage for advanced features.
FlowEdit is a PyTorch-based implementation of the FlowEdit algorithm for inversion-free text-guided image editing using pre-trained flow models (Stable Diffusion 3 and FLUX). The system takes an input image and source/target prompts, and edits the image by solving an ODE that combines the source and target trajectories in the latent space. The core algorithm is implemented in FlowEdit_utils.py, with run_script.py orchestrating the experiment execution based on YAML configurations. The repository includes a dataset of images and prompts for numerical evaluation.
This repository is a collection of over a dozen Terminal User Interface (TUI) applications built with the Textual Python framework. The apps serve educational and recreational purposes: interactive exercises for learning CLI tools (awk, sed, grep), Python regular expressions, Python programming fundamentals, and two original grid-based games (Connect Square, Square Tic Tac Toe). Each app is self-contained, with a similar architectural pattern: an App subclass defines widgets, binds keys, and handles user input. The exercise apps execute user commands via subprocess and compare output to expected results; the regex playground and Python exercises evaluate Python expressions in a sandbox; the games implement AI opponents using weight-based heuristics. The code is clean, well-structured, and consistently styled, though the exercise apps share a large amount of boilerplate. The repository is actively maintained (1015 stars, 0 open issues, recent commits) and demonstrates solid craftsmanship, particularly in the game AI algorithms and custom Textual widget subclasses.
RealtimeCSG is a real-time constructive solid geometry (CSG) level design tool for Unity. It operates exclusively as an Editor extension, providing non-destructive boolean operations on brushes (box, sphere, cylinder, stairs, free-draw) with immediate visual feedback in the Scene view. The architecture is manager-driven: `InternalCSGModelManager` orchestrates hierarchy updates, mesh generation, and caching, while a native C++ DLL handles performance-critical CSG calculations. The tool offers multiple edit modes (Generate, Edit, Clip, Place, Surface) each with custom scene tools, handles, and inspector GUIs. It supports material assignment, UV editing, export to FBX or Unity prefab, and includes a full half-edge mesh representation (`ControlMesh`) for local mesh editing (vertex/edge/polygon). The codebase heavily relies on Unity Editor APIs, reflection to access internal Unity systems, and conditionals for cross-version compatibility. It is a production-grade, feature-rich tool used in game development workflows, though the closed-source native core and editor-only architecture limit runtime usage and cross-platform deployment.
This repository is a community-curated directory of companies that use Haskell. It contains no application code, build system, or automation; the entire data asset is a single markdown table listing 100+ organizations with normalized fields for company name, location, sector, evidence source, and remote-work policy. Contributions are made manually via pull requests, with each entry typically linked to a supporting GitHub profile, Reddit thread, job posting, or company page. The repository essentially serves as a lightweight, human-maintained dataset for answering questions like 'Which companies use Haskell, where are they, and do they support remote work?' It is best understood as a data curation project rather than a software project, and its hybrid nature is that the data lives in prose/markdown rather than in a machine-readable format such as CSV or JSON.
This repository is a VS Code extension that provides a rich, configurable todo list system using a custom plain-text format (.todo, .todos, .task, etc.). It enables users to create, edit, toggle states (box, done, cancelled), archive tasks, track time with a timer, generate project statistics, and scan embedded todos within code files using external search tools (ag, rg). The extension contributes two custom activity bar views (Files and Embedded) and status bar items, all driven by a comprehensive configuration system for symbols, colors, tags, and formatting. The architecture follows a modular design with a clear separation of concerns: document parsing into typed items (Todo, Project, Comment, Tag, etc.), decorator classes for syntax highlighting, utility modules for file operations, time formatting, statistics computation, and embedded code scanning. The item classes form a clean class hierarchy with static `is()` methods for identification and state manipulation methods. The embedded providers abstract over multiple search backends (JavaScript, ag, rg) with a common interface, and the base TreeDataProvider uses an event emitter pattern to notify view updates. The extension is written in TypeScript, bundled with webpack, and relies on several utility libraries (lodash, moment, micromatch, etc.). While the codebase demonstrates solid engineering practices—reusable components, consistent naming, and a config-driven design—it has notable maintenance risks: heavy reliance on complex regexes for parsing, a moderately large dependency list, and no visible test infrastructure (no test files found in the file tree). The changelog mentions regressions and a fundraising prompt, indicating limited maintenance bandwidth. Overall, it is a functional and feature-rich extension that does its job well, but its internal complexity and lack of tests could hinder long-term reliability.
OpenHGNN is a comprehensive research framework for Heterogeneous Graph Neural Networks (HGNNs) built on PyTorch and DGL. The repository implements 83+ graph neural network models across 17+ tasks including node classification, link prediction, recommendation, knowledge graph completion, and temporal graph learning. It serves as a benchmarking platform for academic research, providing standardized implementations of state-of-the-art architectures like HGT, MAGNN, CompGCN, and HERO. The framework uses a registration pattern for dynamic model/trainer discovery and supports distributed training, hyperparameter optimization via Optuna, and GraphBolt integration for large-scale graphs. While it has CLI entry points and setup.py, its primary purpose is research reproducibility rather than production deployment. The codebase demonstrates strong architectural patterns with BaseDataset, BaseTask, and BaseFlow abstractions that enforce consistent interfaces across 50+ model implementations. However, significant technical debt exists including version mismatches (setup.py declares 0.7.0 while README claims 0.9.0), hardcoded dataset paths, mixed DGL/PyG usage, and monolithic configuration files. The repository contains extensive training artifacts in output/ directories and documentation drift between README, setup.py, and Sphinx docs. Despite these issues, it remains a valuable resource for graph learning researchers seeking reproducible implementations of heterogeneous GNN architectures.
coca is a static code analysis and refactoring CLI tool written in Go, designed to assess code quality, detect bad smells, analyze dependencies, and support migration tasks (specifically Spring MVC to Spring Boot). It operates as a monolithic command-line application using the Clean Architecture pattern, with distinct layers for domain models, application logic, and infrastructure. The tool supports multiple languages including Java, Go, Python, JavaScript, TypeScript, and Groovy, leveraging ANTLR for parsing and generating ASTs for analysis. The system's primary function is to scan codebases for technical debt, architectural issues, and API definitions, outputting results in various formats (JSON, CSV, Graphviz). It includes features for bad smell detection (e.g., Long Method, Large Class), test smell analysis, and dependency usage evaluation. The architecture is modular, allowing individual analysis features to be executed independently, though the tool itself is a single binary. While the codebase demonstrates solid engineering practices with a clean separation of concerns and reusable domain models, it exhibits technical drift in its dependency ecosystem. The Go version specified (1.23) is ahead of current stable releases, and several core dependencies (e.g., spf13/cobra, gomega) are significantly outdated, creating a mismatch between the code's stated requirements and the available ecosystem versions. This suggests the project is either in a transitional state or relies on specific, potentially unstable, dependency versions.
This repository is a comprehensive, opinionated collection of HashiCorp Packer templates and supporting infrastructure-as-code assets for automating the creation of virtual machine images on VMware vSphere. It is not a running application but a toolset—a library of HCL configurations, shell scripts, Ansible playbooks, and Terraform examples—that together enable a repeatable, CI/CD-driven pipeline for building golden VM templates across a wide range of operating systems including Red Hat Enterprise Linux, Debian, Ubuntu, Windows Server, and many others. The core architecture is centered around Packer's `vsphere-iso` builder. Each OS distribution and version has its own build definition (e.g., `linux-rhel.pkr.hcl`) with separate variable files for vSphere credentials, network, storage, and build metadata. Shared data templates (kickstart, preseed, autoinstall, network, storage) are parameterized via HCL templating and reused across multiple Linux distributions. Provisioning is handled by Ansible using shared playbooks and OS-family specific roles, while post-processing stages conditionally import images into vSphere content libraries, export as OVFs, or register with HCP Packer Registry. The repository provides a complete development workflow: shell-based launchers (`build.sh`, `config.sh`) for interactive use, a `.gitlab-ci.yml` template for GitLab CI, and Terraform examples for deploying VMs from the built templates. A test suite using Bats and golden files validates the generated unattended installation files. Despite the heavy duplication across near-identical OS build definitions (a maintenance trade-off for clarity), the codebase is well-documented, version-pinned, and actively updated, making it a solid reference for organizations standardizing on vSphere VM image automation.
Rocket Pool is a production-grade decentralized Ethereum liquid staking protocol. The codebase is a comprehensive suite of Solidity smart contracts (mixed versions 0.7.6 and 0.8.30) plus extensive JavaScript/TypeScript integration tests using Hardhat, Mocha, and ethers.js. The system manages user ETH deposits (minting rETH), node operator validator lifecycle (minipools and newer megapools), RPL token staking and auctions, DAO governance (protocol, trusted node, security councils), oracle networks for beacon chain data, and reward distribution via Merkle trees. The architecture follows a monolithic smart contract design with proxy/delegate upgrade patterns, namespaced storage (RocketStorage), and modular interface-based contract interactions. Notable reusable patterns include generic linked list and address set storage, SSZ merkleization library for beacon proofs, snapshot-based voting power tracking, and a Merkle tree reward distributor. The codebase is well-tested with hundreds of scenario-based integration tests, but exhibits technical drift due to mixed Solidity versions, legacy minipool system coexistence with megapools, and some deprecated contracts. Overall, it is a mature, actively maintained protocol with high craftsmanship in storage and upgrade patterns.
MiKTeX is a comprehensive, cross-platform TeX distribution that provides a complete typesetting system for Windows, macOS, and Linux. The repository contains the source code for TeX engines (pdfTeX, XeTeX, LuaTeX, e-upTeX, etc.), companion tools (dvipdfmx, dvisvgm, asymptote, metapost, tex4ht, etc.), the TeXworks editor, and the MiKTeX package manager (Console) and DVI viewer (Yap). It also bundles a large number of third-party libraries (FreeType, HarfBuzz, Poppler, LibreSSL, cURL, GMP, MPFR, etc.) as vendored dependencies. The architecture is monolithic: each executable compiles independently but shares a common core library (MiKTeX Core) that provides session management, file I/O, package management, and platform abstraction. The primary data flow is user-driven: packages are downloaded from remote repositories, TeX documents are compiled via one of the engines producing DVI or PDF output, and fonts are handled via system or bundled resources. The codebase is actively maintained with frequent releases, but the reliance on many vendored libraries and extensive platform-specific `#ifdef` blocks introduces moderate technical drift risk.
AzGovViz (Azure Governance Visualizer) is a PowerShell 7+ application that performs deep Azure governance reconnaissance: it traverses an Azure tenant's Management Group hierarchy and collects policy, RBAC, Blueprint, diagnostic, cost, network, storage, orphaned-resource, and model-deployment data via ARM REST APIs, Microsoft Graph, and Azure Resource Graph. It renders results as an interactive HTML report (built on AG Grid), plus CSV, Markdown, and full JSON exports for change tracking. Architecturally it is a single generated ~39k-line PowerShell script (pwsh/AzGovVizParallel.ps1) assembled by a build script from modular function files under pwsh/dev/functions/. It is designed for scheduled, unattended execution in Azure DevOps or GitHub Actions using OIDC or service principal authentication, and can also run from a console or an Azure Web App accelerator. Data collection is heavily parallelized with ForEach-Object -Parallel, synchronized hashtables, and batched API calls with caching. It is not a library or service; it is a batch CLI reporting application, though its output artifacts form a structured analysis dataset. Notable non-trivial engineering includes dictionary-based HTML compression to keep report sizes within GitHub file-size limits, streaming JSON generation to avoid out-of-memory failures on huge tenants, parallel cost and ARG query batching, and an ALZ policy version checker that walks git history of the Azure Enterprise-Scale repository to hash and track policy drift. The trade-off is significant monolith complexity, heavy reliance on global script state, hardcoded API versions, and dependencies on external CDNs for interactive table libraries.
Bash-my-AWS is a CLI toolset designed to manage AWS resources using Bash functions and aliases. It wraps the AWS CLI with convenience functions for listing, filtering, and manipulating resources like EC2, S3, and CloudFormation. The architecture is a monolithic Bash library sourced into the user's shell environment, with modularized logic in `lib/*-functions`. It relies heavily on `awscli`, `jq`, and standard Unix utilities. The tool implements a pipe-skimming pattern (`skim-stdin`) that allows chaining commands (e.g., `instances | instance-stop`), enhancing usability for shell scripting. It includes a Python-based caching proxy (`bin/cachews`) to reduce API latency. While well-structured for Bash, it carries inherent risks due to the language's limitations, including security vulnerabilities in SSH handling and reliance on `eval` for argument inference. The repository is actively maintained with recent commits and a comprehensive test suite using a custom BDD-style framework. However, technical drift is moderate due to the rapid evolution of AWS APIs and Bash-specific security concerns. The codebase is suitable for engineers comfortable with Bash scripting who need a robust set of AWS management utilities.
This is a Java application that scrapes AWS CloudWatch metrics and exposes them in Prometheus format via an HTTP endpoint. It acts as a bridge between CloudWatch's time-series API and Prometheus's pull model. The architecture follows a clean separation of concerns: configuration is defined in YAML, the CloudWatchCollector parses rules and orchestrates data fetching through an interface (DataGetter) with two implementations (GetMetricStatistics and GetMetricData). Dimension discovery is abstracted into a DimensionSource interface with a caching decorator (CachingDimensionSource) using Caffeine for configurable per-rule TTL. The web server is built on Jetty 12 with servlets for metrics, health checks, config reload, and a home page. The codebase demonstrates solid engineering practices: dependency injection via constructor, interface-based design, comprehensive unit testing with Mockito and JUnit 5, and a multi-stage Docker build. However, the project is explicitly unmaintained with no active maintainers, leading to potential drift in AWS SDK and dependency versions. It is well-suited for teams needing to monitor AWS services that support CloudWatch metrics without adopting alternative exporters like YACE.
This repository is a community-driven collection of Streamlit 'extras' — custom components and utilities that extend Streamlit's functionality. It is a Python library (package `streamlit-extras`) that provides over 40 self-contained subpackages, each implementing a specific UI widget, layout helper, or data exploration tool. The architecture is modular: each extra is a subpackage under `src/streamlit_extras/` with a standardized metadata convention (`__title__`, `__desc__`, etc.) and a central `@extra` decorator for registration. Some extras are pure Python wrappers around Streamlit's native APIs (e.g., `grid`, `stateful_button`, `stoggle`), while others are full Custom Components v2 (CCv2) with React/TypeScript frontends built with Vite (e.g., `three_viewer`, `json_editor`, `sigma_graph`). The build system uses Hatch with a custom build hook to compile React frontends during wheel packaging. The gallery app (`gallery/streamlit_app.py`) serves as a demo and documentation explorer. The codebase is well-organized but has several deprecated extras that rely on private Streamlit APIs, and test coverage is limited to metadata validation. Overall, it is a solid, actively maintained library with reusable patterns for Streamlit component development.
tsumiki is a Claude Code plugin and skill library that operationalizes AI Test-Driven Development (AITDD). It exposes slash commands (`/dev-impl`, `/dev-debug`, `/ipa-security-check`, `/orchestrate`) and Markdown-based skills that guide an AI coding agent through a Red-Green-Refactor-Validation cycle. The repository is not a standalone runtime; it is a development methodology toolkit whose primary artifacts are command definitions, skill instructions, and workflow orchestration logic consumed by Claude Code.