Pydoc-Markdown is a Python library and CLI tool for generating API documentation in Markdown format from Python source code. Unlike many documentation tools, it does not execute the code but instead parses it using the docspec library, making it safe for use with untrusted code. The system features a plugin architecture with loaders (currently only Python), processors (for converting docstrings from Google, Sphinx, Pydoc-Markdown formats to Markdown), renderers (for outputting to Markdown files, MkDocs, Hugo, Docusaurus, or Jinja2 templates), and source linkers (for generating links to source code on GitHub, GitLab, etc.). It can be configured via YAML, TOML, or used programmatically. The project also integrates with Novella for Markdown preprocessing, allowing inline @pydoc tags in documentation files. The codebase is well-structured with clean interfaces, comprehensive test coverage, and a well-defined plugin system. It demonstrates solid software engineering practices including dependency injection, configuration via dataclasses, and entry-point-based plugin discovery. The project has been actively maintained with regular releases and community contributions, though the maintainer has noted limited time for development. The architecture supports extensibility, making it suitable for integration into documentation pipelines for Python projects.
jest-junit is a Jest reporter that transforms test results into JUnit-compatible XML files, commonly used in CI/CD pipelines for integration with tools like Jenkins, CircleCI, and GitLab CI. The codebase is a small, focused Node.js library with a clear architecture: an entry point that supports both the modern reporter API and the deprecated testResultsProcessor, a configuration resolver that merges settings from environment variables, package.json, and reporter options, and a core transformation module (`buildJsonResults`) that converts Jest's aggregated result objects into a structured JSON representation directly mappable to JUnit XML via the `xml` package. It handles template variables for test suite names, class names, and test titles, supports custom properties via external JS files, and manages edge cases like test compilation errors, empty suites, console output inclusion, and retried tests. The code is well-tested with Jest and includes XML schema validation. While the library is not architecturally groundbreaking, it is cleanly modular, follows Node.js best practices, and its configuration and transformation patterns could be reused in other test report generators.
This is a Filament PHP plugin that integrates ApexCharts into Filament's widget system. It provides a base `ApexChartWidget` class with traits for features such as defer loading, filtering (simple select and custom form schema via Filament Schemas), dark mode, header/subheading, footer, content height, loading indicator, and polling. An Artisan command (`make:filament-apex-charts`) generates widget stubs for 20+ chart types (area, bar, boxplot, bubble, candlestick, column, donut, heatmap, line, mixed, pie, polarArea, radar, radialbar, rangeArea, scatter, sunburst, timelineRangeBars, treemap, funnel). The frontend is powered by an Alpine.js component that initializes ApexCharts and listens for Livewire events to update options reactively. The package includes a build step for its JavaScript asset (compiled via esbuild) and a test suite using Pest. The architecture follows Laravel package development best practices with separation of concerns via traits and a service provider. The code is well-maintained, supports modern PHP 8.2, Laravel 11-13, Filament 4/5, and Livewire 3/4.
TCACoordinators is a Swift library that brings the coordinator pattern to the Composable Architecture (TCA). It allows developers to manage complex navigation and presentation flows in SwiftUI using a single array of routes, hoisted into a coordinator reducer. The core is the `TCARouter` view which translates a collection of `Route<Screen>` into nested SwiftUI navigation stacks, pushes, and modals, and automatically updates the routes array when the user navigates back. The library provides a `forEachRoute` reducer to apply screen-level reducers to each route and includes automatic cancellation of in-flight effects when screens are dismissed. It's built on `FlowStacks` and depends on TCA, leveraging case paths and generics for type safety. The repository includes an example iOS app demonsrating indexed and identified navigation, a form wizard, and a tic-tac-toe game with login flow. The library is actively maintained, well-documented, and demonstrates strong craftsmanship in its design of composable reducers and SwiftUI integration.
This is an R package (`parameters`) from the easystats ecosystem that provides a unified interface for extracting, formatting, and comparing parameters from a vast array of statistical models (lm, glmmTMB, brms, lme4, lavaan, fixest, etc.). The package functions as a model-parameter reporting engine: it takes a fitted model object and returns a tidy data frame with coefficients, standard errors, confidence intervals, p-values, and effect sizes, supporting various inference methods (Wald, profile, bootstrap, Kenward-Roger, Satterthwaite). Beyond basic extraction, it offers standardization, bootstrapping, equivalence testing, p-value functions, dominance analysis, and data reduction (PCA, EFA, clustering). The architecture relies heavily on S3 generic dispatch (e.g., `model_parameters.lm`, `model_parameters.glmmTMB`) and integrates with the easystats stack (`insight` for model introspection, `bayestestR` for Bayesian indices, `datawizard` for data manipulation). Output can be formatted as plain text, markdown, or HTML, making it suitable for both interactive use and automated reporting. The package is actively maintained with extensive test coverage and continuous integration.
This Terraform module provisions an AWS SNS topic and a Lambda function (Python 3.13) that forwards SNS notifications to a Slack channel via webhook. The Lambda function parses and formats various AWS event types—CloudWatch alarms, GuardDuty findings, Security Hub findings, AWS Health events, AWS Backup notifications, and generic messages—into structured Slack attachments. It supports encrypted webhook URLs via KMS, custom Lambda functions, VPC configuration, and SNS subscription filtering. The module is part of the terraform-aws-modules ecosystem and follows standard Terraform module conventions with comprehensive CI/CD, pre-commit hooks, and semantic release. The Python code includes unit tests with snapshot testing, linting, and type checking, demonstrating solid engineering practices.
This Laravel package provides an Eloquent-like interface for AWS DynamoDB, allowing developers to use familiar ORM methods with DynamoDB while maintaining compatibility with Laravel's ecosystem. The package implements a sophisticated query builder that translates Eloquent-style conditions into efficient DynamoDB operations, intelligently choosing between Query and Scan operations and selecting optimal indexes when available. Key features include support for simple and composite keys, global/secondary indexes, asynchronous operations via AWS SDK promises, query scopes, and automatic attribute marshaling/unmarshaling. The architecture follows Laravel conventions with service providers, facades, and a base DynamoDbModel class. Notable components include a condition analyzer that optimizes query operations and a parser subsystem that correctly builds DynamoDB expression syntax with proper attribute name/value handling.
This repository is the official Ghost Starter Theme, a foundation for building custom Ghost CMS themes. It provides a complete set of Handlebars templates (default.hbs, index.hbs, post.hbs, etc.), modular CSS components (buttons, forms, global reset), and JavaScript modules (mobile menu toggle, infinite scroll) that are compiled and optimized via Rollup and PostCSS. The theme is designed to be extended and includes CI/CD workflows for testing and deployment. It is not a standalone application but a theme package that runs within the Ghost CMS environment (>=5.0.0). The codebase demonstrates modern front-end tooling with ESM, CSS custom properties, and responsive image handling. While the theme itself is tightly coupled to Ghost's template engine, several components (CSS patterns, infinite scroll, menu toggle) are self-contained and could be extracted for use in other projects.
This repository is a React component library (`@codegouvfr/react-dsfr`) that provides a complete implementation of the French government's Design System (DSFR) for modern web applications. It covers nearly all DSFR UI components (buttons, forms, navigation, modals, tables, etc.) and adds framework-specific integrations for Next.js (both Pages Router and App Router), Vite, and Create React App, including SSR support without flash. The library also ships a CLI tool (`npx react-dsfr`) that performs static analysis of a project's source code to generate an optimized CSS bundle containing only the DSFR components actually used, solving a common bloat problem in design-system integrations. Additionally, it provides a GDPR consent management system, i18n per component, MUI theming compatibility, dark mode, and a large set of SVG pictograms. The architecture is a typical React library: each component is a memoized, forwardRef-wrapped functional component using DSFR CSS classes via a `cx` helper. Build-time scripts parse the DSFR CSS into TypeScript constants (spacing, colors, breakpoints, class names) to ensure type safety and ease of use. The library avoids bundling all DSFR CSS in JavaScript; instead, it relies on the CSS being loaded from `node_modules` and optionally trimmed by the CLI. Notable internal patterns include a lightweight `StatefulObservable` for reactive state, a set of stable-callback hooks (`useConst`, `useConstCallback`) to avoid unnecessary re-renders, and a factory pattern for pictograms. While not a hybrid repo, its build pipeline demonstrates a unique approach to CSS-to-TypeScript code generation. The codebase is actively maintained with a comprehensive test suite covering both runtime behavior and build-script correctness. However, it carries some technical drift: it relies on a patched version of `@gouvfr/dsfr` (1.14.2), the pictograms are large inline SVGs that must be manually updated, and the CSS optimization script uses hardcoded component mappings that could diverge from future DSFR releases. Overall, it is a high-quality, production-grade library suitable for any French public service website built with React.
Fetch is a Scala library for simple and efficient data access, built on cats-effect. It provides a monadic abstraction (`Fetch[F, A]`) that automatically optimizes data fetching through batching, caching, deduplication, and parallel execution. Users define data sources by implementing the `DataSource` trait, specifying how to fetch individual identities or batches. The library then composes fetches using standard monadic and applicative combinators, transparently batching requests to the same source and running independent fetches concurrently. It supports custom caches, optional fetches, error handling, and debugging via a separate `fetch-debug` module. The architecture is a pure library with no runtime dependencies beyond cats-effect, making it suitable for both JVM and Scala.js. Key entry points include `Fetch.apply`, `Fetch.run`, `Fetch.runLog`, and `Fetch.runCache`. External dependencies are minimal: cats-effect, cats-core, and scalatest for testing.
mruby/c is a lightweight implementation of the mruby bytecode interpreter optimized for microcontrollers with minimal RAM (<40KB). It executes Ruby bytecode generated by the mrbc compiler, supports cooperative multitasking via a built-in scheduler (rrt0), and provides a C API for embedding. The architecture splits into a core VM engine, a configurable memory allocator, a hardware abstraction layer (HAL) for portability across MCU architectures, and built-in class implementations for common Ruby types. The codebase is well-structured and demonstrates strong embedded software engineering practices, with reusable patterns for memory management, value boxing, and platform abstraction. It is not a data/research project; it is a production-quality embedded runtime.
Alimer is a modern cross-platform .NET 10 game engine featuring a modular architecture with Entity-Component-System (ECS) design, multi-backend graphics rendering (Vulkan, Direct3D 12, Metal), physics integration, audio subsystem, and asset pipeline. The engine provides a complete framework for game development with systems for rendering, physics, audio, input, and scene management. It follows a layered architecture where platform-specific implementations are abstracted behind clean interfaces, allowing developers to build games that run on Windows, Linux, and macOS. The codebase demonstrates strong engineering practices with well-defined boundaries between systems, extensible asset importing, and backend-agnostic graphics abstractions.
This repository provides a custom HTML element, `<clipboard-copy>`, that copies text or element content to the clipboard when clicked. Implemented as a web component extending `HTMLElement`, it supports multiple data sources: the `value` attribute, a `for` attribute that references another element by ID (including inputs, textareas, and anchor hrefs), or element text content. The element ensures accessibility by automatically adding `role="button"` and `tabindex="0"` if not present, and handles keyboard events (Enter/Space) for activation. Internally, it uses the modern `navigator.clipboard.writeText()` API when available, falling back to `document.execCommand('copy')` via a temporary hidden node. It also normalizes Unicode whitespace characters (e.g., non-breaking spaces, zero-width joiners) to plain spaces or strips them, ensuring the copied text matches visual expectations. A `clipboard-copy` custom event is dispatched on success, allowing external handlers to provide feedback. The source code is written in TypeScript, is well-structured with clear separation of concerns (clipboard logic in `clipboard.ts`, element definition in `clipboard-copy-element.ts`, and a side-effect module for registration), and includes a comprehensive test suite covering element creation, clipboard operations, shadow DOM contexts, and edge cases like disabled state and Unicode normalization. The project follows GitHub's engineering standards (eslint, prettier, CI via GitHub Actions) and is published as an npm package under `@github/clipboard-copy-element`.
Dekorate is a Java annotation-processing framework that generates Kubernetes, OpenShift, Knative, and other container orchestration manifests at compile time. It is primarily a library consumed by Java applications, especially those built with Spring Boot, Quarkus, Thorntail, or plain Java. The architecture centers around a `Session` that coordinates `ConfigurationGenerator`s, `ManifestGenerator`s, and a graph of `Decorator`s to produce deployment descriptors. It supports multiple platforms via separate annotation modules (e.g., kubernetes-annotations, openshift-annotations, knative-annotations) and integrates with build tools like Docker, Jib, S2I, and Tekton for CI/CD pipelines. The codebase is well-structured with clean abstractions (Decorator, Configurator, SPI factories) and extensive testing, though it suffers from a high module count and some outdated dependencies (e.g., Java 1.8 baseline, old Spring Boot versions in examples). Overall, it is a mature and capable tool for generating Kubernetes manifests from Java annotations.
This repository implements a complete quantitative trading framework for A-shares, known as 'zettaranc-skill'. It is a dual-track project: (1) a Python/Rust software application providing CLI tools, a FastAPI REST API, and a React frontend for stock analysis, backtesting, simulation, screening, and strategy optimization; (2) an AI character-play skill pack that encodes a specific trading methodology (Zettaranc/Shaofu strategies) into a SKILL.md for LLM role-play. The application side dominates: it has 15+ CLI subcommands, a modular architecture with 30+ technical indicators, 20+ strategy detectors, a multi-source data layer (Tushare, Indevs, A-Stock-Data, Hithink, SQLite), a Rust-accelerated backtesting engine (via PyO3), a walk-forward simulation framework, and a self-optimization pipeline. The codebase is well-structured with clean abstractions (DataSource protocol, unified error codes, parameter registration), extensive test coverage, and CI/CD. However, it suffers from some technical drift: dual Python/Rust implementations must stay synchronized, Chinese vernacular naming reduces readability, hardcoded constants persist, and the self-optimizer's LLM judge is a stub. Overall, it is a production-grade personal quant framework with high craftsmanship in its core components.
This repository implements a complete reinforcement learning pipeline for whole-body motion tracking on humanoid robots, specifically Unitree G1 and XBot L7. The system uses a teacher-student architecture with Proximal Policy Optimization (PPO) to train policies that track reference motions from retargeted motion capture datasets. It features three training phases: a base training phase, an adaptation phase with domain randomization, and a finetuning phase. The environment is built on MJLab (a MuJoCo wrapper) and includes extensive domain randomization (e.g., motor parameters, body mass, center of mass, joint offsets, external forces, and a window load capacity curriculum for payload-aware training). The codebase is highly modular, with registered MDP components (observations, rewards, terminations, randomizations) and a flexible configuration system using Hydra. It also includes advanced features such as symmetry augmentation, differentiable forward kinematics, and a custom motion dataset pipeline with memory-mapped storage. While primarily a reinforcement learning training framework, it has strong data engineering aspects for processing motion datasets and generating training data for the student encoder. The repository is well-structured for research and sim-to-real transfer, but it is tightly coupled to specific robot assets and dependencies (torch, torchrl, mjlab) with pinned versions that may require adaptation for other environments.
MultiGen is an AI agent platform designed for private, on-premise deployment. It features a planner-react architecture where a planner agent creates task plans and a react agent executes them using various tools (web browsing, shell commands, file operations, multimodal generation). The system maintains persistent session history via PostgreSQL, enabling conversation continuity and agent memory retention. Extensibility is supported through Model Context Protocol (MCP) and Agent-to-Agent (A2A) integrations. The backend is built with FastAPI using a layered architecture (Interface/Application/Domain/Infrastructure), the frontend with Next.js 14 App Router, and execution occurs in a sandboxed Docker container with Ubuntu, Chrome, and VNC. Real-time updates are delivered via Server-Sent Events (SSE) powered by Redis streams.
PostgresGUI is a native macOS PostgreSQL client application built with SwiftUI and SwiftData. It provides a desktop interface for managing PostgreSQL database connections, executing queries, browsing schemas, and manipulating data. The application features SSH tunneling support for secure connections, credential storage via macOS Keychain, query result editing capabilities, and export functionality. Built with a protocol-oriented MVVM-like architecture, it emphasizes separation of concerns through distinct layers for networking, data persistence, UI presentation, and state management. The app handles complex concerns like connection lifecycle management, result set normalization, and concurrent operations using modern Swift concurrency patterns.
Fluorine-Manager is a Linux-native mod manager derived from Mod Organizer 2, designed to manage game modifications without altering the original game files. It employs a virtual file system (VFS) using FUSE to overlay mod files, enabling safe mod installation and conflict resolution. The application features a Qt-based GUI with extensive plugin architecture supporting Bethesda games (Skyrim, Fallout series) and non-Bethesda titles through Python and C++ plugins. Core functionality includes mod organization, load order management, BSA/BA2 archive handling, INI file manipulation, and integration with Nexus Mods and Steam/Proton for Windows game compatibility on Linux. The system follows a modular design with clear separation between core logic, game-specific implementations, and utility libraries.
The academic-skills repository is a collection of prompt engineering assets designed to assist with academic research workflows when used with large language models like ChatGPT. It provides eight distinct skills, each encapsulated in a self-contained directory containing a skill description (SKILL.md), platform-specific metadata (agents/openai.yaml), and optional reference templates or scripts. The skills cover tasks such as reading and noting papers, writing literature surveys, monitoring arXiv for new publications, analyzing reviewer comments, summarizing experiment logs, extracting benchmark information, identifying research gaps, and generating weekly lab updates. The repository emphasizes reliability and reproducibility by constraining LLM outputs to avoid hallucination, providing clear input processing rules, and offering structured templates for consistent results. One skill (paper-feishu-digest) includes a deterministic Python script for fetching and filtering arXiv papers, demonstrating a hybrid approach that combines LLM assistance with traditional data processing. Additional tools for validating the repository structure and packaging skills for distribution are included, all written using only the Python standard library to minimize dependencies. The codebase exhibits strong modularity, with each skill following a uniform structure that facilitates maintenance and extension. The arxiv_digest.py script stands out as a reusable component for arXiv data processing, featuring robust error handling, keyword-based ranking, and conservative inference of paper contributions and limitations from abstracts. Overall, the repository represents a well-crafted toolkit for enhancing academic productivity through LLM augmentation, balancing prompt engineering with selective use of deterministic scripts where appropriate.