XState is a production-grade TypeScript library for creating, interpreting, and executing finite state machines and statecharts, based on the SCXML standard and the actor model. The repository is a monorepo (pnpm workspaces) containing the core `xstate` package, the lighter `@xstate/store` for event-sourced state management, and framework-specific bindings for React, Vue, Svelte, Solid, Preact, and Angular. It also includes `xstate-inspect` for debugging, `xstate-immer` for Immer integration, a graph analysis module for model-based testing, and many example applications and templates. The core engine provides `createMachine`, `createActor`, `setup()` for type-safe machine definitions, built-in actions (assign, sendTo, raise, etc.), guard combinators, and actor logic factories (`fromPromise`, `fromCallback`, `fromObservable`). The store sub-package offers atoms, source atoms, and composable extensions like persist and undo/redo. The codebase demonstrates high craftsmanship with extensive TypeScript type inference, well-encapsulated modules, and comprehensive test coverage. It is actively maintained with continuous CI/CD and version management via changesets.
Apache Airflow is a workflow orchestration platform for authoring, scheduling, and monitoring data pipelines. The system uses a modular architecture with core components, extensible providers, a React/TypeScript web UI, and a FastAPI-based REST API. Key entry points include the CLI (`airflow` command), web server, scheduler, and triggerer. Data flows involve DAG parsing, task scheduling via executors, and state persistence in a metadata database. External dependencies include PostgreSQL/MySQL, Redis/RabbitMQ for Celery, and various provider-specific integrations. The codebase demonstrates strong engineering practices with version compatibility patterns, plugin systems, and well-structured API layers.
Monorepo for node-based graph/flow editor libraries. Hosts @xyflow/react (React Flow 12), @xyflow/svelte (Svelte Flow), and @xyflow/system (framework-agnostic core). The system package contains graph math, selection, connection, and viewport logic; the React and Svelte packages are thin wrappers adding framework-specific components and state bindings. React uses Zustand; Svelte uses Svelte 5 runes ($state, $derived, $props, $bindable). Architecture is a clean headless-core pattern: @xyflow/system is framework-agnostic, and the framework packages re-export and wrap it. Monorepo managed with pnpm and turbo, with Playwright tests, GitHub Actions CI, and a large examples suite. Actively maintained with frequent releases. Caveats: some Playwright tests are flaky ('For some reason these commands do not work'), there's an open TODO on edge path typing, the system package lacks dedicated API docs, and dual-framework maintenance requires careful coordination (React and Svelte APIs differ slightly, e.g., multiSelectionKeyCode vs multiSelectionKey). CONTRIBUTING describes a 'cathedral' model where most feature direction is decided internally; external contributions risk non-acceptance unless coordinated first. Overall a high-quality, production-grade library. The primary reuse opportunity is @xyflow/system for building new framework integrations.
PDM is a modern Python package and dependency manager that implements the latest PEP standards (517, 518, 621, 582, 735, 751). It provides a comprehensive CLI tool for managing project dependencies, virtual environments, Python interpreters, and publishing packages. The architecture is modular: a core `Project` class orchestrates configuration, lockfile management, environment abstraction, and workspace (monorepo) support. Dependency resolution is handled by either a built-in resolvelib-based resolver or an optional uv backend, with a pluggable installer/synchronizer layer. The tool supports multiple lockfile formats (pdm.lock, pylock.toml), export/import to various formats (requirements.txt, Pipfile, Poetry, Flit, setup.py), and a rich plugin system via entry points and signals. It also includes build backend integration, PEP 582 local package directories, and shell completions. The codebase is well-structured with clear separation of concerns, extensive test coverage, and active maintenance.
Ergo Framework is a Go implementation of the Erlang/OTP actor model for building concurrent, distributed, and fault-tolerant systems. It provides a complete actor runtime with processes, supervision trees, message passing (local and remote), service discovery, and network transparency. The architecture is library-based: applications import the framework and define actors, supervisors, and applications. Key entry points include `ergo.StartNode()` and the `gen`, `act`, `meta`, and `net` packages. The framework has zero core dependencies and uses a custom binary serialization (EDF) for inter-node communication. It is production-grade, with extensive testing, documentation, and a growing ecosystem of extra libraries (registrars, loggers, meta-processes). The codebase demonstrates high craftsmanship with lock-free data structures, efficient buffer pooling, and well-abstracted patterns. The last commit date appears anomalous (2026-09-04), but the repository is actively maintained with many stars and forks.
Dify is an open-source LLM application development platform that serves as a visual workflow builder, agent orchestration engine, RAG pipeline, and LLMOps backend-as-a-service. In production, it enables users to create, deploy, and monitor AI-powered applications including chatbots, text generation, autonomous agents, and complex multi-step workflows. The architecture is a monorepo consisting of a Python/Flask API backend with SQLAlchemy and Alembic migrations, a Next.js web console, a TypeScript CLI (difyctl), a Go-based agent runtime sandbox, and shared packages for contracts and UI components. Key entry points include the console web app for building and managing apps, the service API for integrating external systems, and the OpenAPI surface for third-party clients. Primary data flows involve user authentication, workflow execution (triggered by APIs, schedules, or webhooks), knowledge ingestion and retrieval (document extraction, chunking, embedding, vector search), and agent invocation (tool calls, LLM interactions). External dependencies include multiple vector databases (pgvector, Qdrant, Weaviate, etc.), LLM providers (OpenAI, Anthropic, etc.), object storage (S3, Azure Blob, etc.), Redis, Celery, and various observability backends (OpenTelemetry, Langfuse, etc.). The platform supports multi-tenancy, RBAC, billing, and enterprise features, and is deployed via Docker Compose, Kubernetes, or cloud-specific distributions.
act is a CLI tool that runs GitHub Actions workflows locally by simulating the GitHub Actions execution environment. It reads workflow YAML files from .github/workflows/, constructs an execution plan, and uses Docker to run containerized actions while handling environment variables, secrets, artifacts, and caching. The application features a modular architecture separating workflow parsing, expression evaluation, planning, execution, and container management. Key strengths include its expressive expression interpreter, reusable executor pattern for step orchestration, and clean abstraction for Docker/host environment execution. The tool is actively maintained with frequent updates, low technical drift due to updated dependencies, and comprehensive test coverage validating core functionality against GitHub Actions behavior.
Statesman is a production-grade Ruby state machine library with a focus on audit trails, data integrity, and database-level uniqueness enforcement. The core is the `Statesman::Machine` module, which provides a declarative DSL (states, transitions, guards, before/after callbacks) and is mixed into a machine class per model. State transitions are persisted as separate transition records (via a pluggable storage adapter), enabling full history and metadata tracking. The library ships with two adapters: an in-memory adapter for testing and an ActiveRecord adapter that uses unique indexes on `sort_key` and `most_recent` columns to prevent duplicate transitions and provide efficient current-state queries. It includes query scopes (`in_state`, `not_in_state`) for ActiveRecord models, a denormalised cached-current-state feature via `ConfigureCachedCurrentState`, and a type-safe variant of the query module for Sorbet compatibility. The codebase is highly modular, well-tested (over 130 spec files across multiple database backends), and follows modern Ruby and Rails best practices. It is maintained by GoCardless and supports Ruby 3.3–4.0 and Rails 7.2–8.1.
Inngest JS is a TypeScript SDK for building reliable, event-driven applications with durable execution. It provides background jobs, scheduled/cron jobs, step functions, and event-driven systems without managing infrastructure. The SDK works across multiple runtimes (Node.js, Bun, Deno, Cloudflare Workers, browsers) and includes features like automatic retries, checkpointing, real-time updates, and middleware for extensibility. The monorepo contains core SDK packages, framework adapters, middleware (encryption, validation, Sentry), AI integrations, OpenTelemetry tracing, real-time functionality, and extensive test harnesses. Examples demonstrate integration with popular frameworks like Next.js, Express, SvelteKit, Remix, and NestJS.
FastGPT is a production-grade AI Agent building platform that enables users to create, deploy, and manage AI applications through a visual workflow editor. The system provides a full-stack solution including a Next.js frontend with Chakra UI, a comprehensive REST API layer, and a modular backend architecture. Core capabilities include a workflow engine with agent loops, tool calling, dataset (knowledge base) management with vector search, sandboxed code execution (JS/Python), multi-tenant team management with fine-grained permissions, billing and usage tracking, and integration with external platforms (WeChat, Feishu, Dingtalk, MCP). The platform is designed for both open-source community and commercial deployments, with feature gating via license activation. The codebase is organized as a monorepo with clear separation of concerns: shared types and constants in `packages/global`, business logic in `packages/service`, UI components in `packages/web`, data access layer in `packages/dal`, and separate services for sandbox execution and volume management. It relies on MongoDB, Redis, BullMQ, S3-compatible storage, and multiple vector database backends (PG, Milvus, OceanBase, SeekDB, OpenGauss). The architecture is predominantly monolithic with the main application as a Next.js app, but sandbox and volume manager run as independent services, indicating a hybrid monolith/microservices pattern.
ngx-graph is an Angular library for rendering directed acyclic graphs (DAG) and other graph structures using SVG. It provides a standalone GraphComponent with signal-based inputs and outputs, supporting multiple built-in layout engines (Dagre, DagreCluster, DagreNodesOnly, D3 force-directed, Cola force-directed) and custom layouts via a Layout interface. The component handles viewport transformations (pan, zoom), node dragging, minimap, and rich layout morph animations between graph updates. The architecture centers on a flexible layout service pattern where each layout is a class implementing run/updateEdge/hooks, and the GraphComponent orchestrates layout calculations, SVG rendering, and interaction. The codebase demonstrates modern Angular practices (signals, standalone components, OnPush change detection) and includes comprehensive test coverage. It is maintained by Swimlane with regular releases and extensive documentation via Storybook.
Foblex Flow is an Angular-native library for building visual node editors, workflow builders, diagram editors, and AI pipeline UIs. It provides a comprehensive set of components and directives (f-flow, f-canvas, f-node, f-connection, f-connector, f-draggable, f-minimap, f-selection-area, etc.) along with plugins for managed state (undo/redo), accessibility (keyboard navigation), layout engines (dagre, elk), reflow-on-resize, and control schemes. The repository is a monorepo (NX) containing the core library, layout packages, a markdown renderer, a documentation portal with SSR, and multiple example applications (call center, schema designer, tournament bracket, UML diagram, marketing automation). The library is production-ready, actively maintained, and demonstrates high craftsmanship with decoupled architecture (mediator pattern), signal-based state management, Web Worker offloading for connection rendering, and extensive E2E testing.
Flowable is a lightweight, embeddable Business Process Management (BPM) platform written in Java. It provides a suite of engines for BPMN 2.0 process execution, CMMN case management, DMN decision tables, form management, identity management, and event registry. The architecture is modular: core engines, service modules (job, batch, variable, task, identitylink, entitylink), REST APIs, Spring Boot auto-configuration, and integration modules (Camel, CDI, JMX, LDAP, HTTP, secure JavaScript). Key entry points include ProcessEngine, CmmnEngine, DmnEngine, IdmEngine, and EventRegistry. Data flows involve deploying XML definitions, starting process/case instances, executing tasks, handling events, and persisting state to relational databases (MySQL, PostgreSQL, Oracle, DB2, MSSQL, H2, HSQL). The codebase is production-grade with extensive testing, schema migration scripts, and support for GraalVM native images. It is actively maintained with a large community (9.5k stars). However, it carries legacy compatibility modules (flowable5-engine) and some technical debt from the Activiti migration, resulting in moderate technical drift.
n8n is a production-grade workflow automation and AI agent platform. In production, it runs as a Node.js Express server with a Vue 3 frontend, executing user-defined workflows composed of nodes (triggers, actions, LLM calls). Workflows can be triggered manually, via webhooks, schedules, or events, and the execution engine handles concurrency, retries, errors, and data passing between nodes. The platform supports AI agents through an SDK that manages LLM calls, tool execution, memory, conversation loops, and MCP (Model Context Protocol) integration, enabling autonomous multi-step agents. Architecturally, the monorepo is organized into backend (packages/cli, packages/core, @n8n/engine), frontend (packages/frontend/editor-ui), database layer (@n8n/db with TypeORM), AI/agent packages (@n8n/agents, @n8n/ai-utilities, @n8n/instance-ai), and a vast node/credential library (packages/nodes-base, @n8n/nodes-langchain). Dependency injection is handled by @n8n/di, controllers are decorated with @RestController, and database models use a forked TypeORM. The system supports multiple database backends (PostgreSQL, SQLite) and can scale with Redis and worker processes. Key data flows: Workflow definitions are persisted in the database with version history. Execution data (inputs, outputs, binary data) is stored for monitoring and replay. The AI agent runtime uses a persistent message store for conversation memory, supports checkpoint/restore for long-running agents, and integrates with external LLMs (OpenAI, Anthropic, etc.) via a unified model factory. The platform exposes REST APIs for CRUD operations on workflows, credentials, users, and executions, as well as WebSocket push for real-time UI updates. External dependencies include a database, optional Redis for scaling, and numerous third-party services via nodes and credentials.
This repository implements a GitHub Action that automates deployment of static content to GitHub Pages. It takes a folder from the workspace, optionally builds it, and pushes the contents to a specified branch (default `gh-pages`) using git worktrees and rsync. The action supports authentication via GitHub token, personal access token, or SSH deploy keys, and offers extensive configuration options including clean deployments, single-commit history, target subfolders, dry runs, tags, and Git LFS. The architecture is modular: `src/main.ts` is the entry point, `src/lib.ts` orchestrates the workflow, `src/git.ts` handles repository initialization and deployment, `src/worktree.ts` manages git worktree creation with retry logic, `src/ssh.ts` configures SSH clients, and `src/execute.ts` provides a reusable command execution wrapper. The action relies on external tools `git`, `rsync`, and `ssh-agent`, and uses the `@actions/*` toolkit for GitHub Actions integration. The codebase is well-structured TypeScript with comprehensive unit and integration tests, and follows modern JavaScript practices with ESLint, Prettier, and Jest.
ruoyi-vue-pro (芋道) is a large-scale, multi-module enterprise rapid development platform built on Spring Boot 2.7, MyBatis-Plus, and Vue 3. It provides a comprehensive backend infrastructure for building business applications such as ERP, CRM, HRM, MES, WMS, OA, BPM (Flowable), IoT, AI, IM, Pay, Mall, and more. The codebase is structured around a reusable framework layer (`yudao-framework`) with many Spring Boot starters for security, data permission, multi-tenancy, WebSocket, Excel, monitoring, and protection (rate limiting, idempotency). Business modules follow a consistent layered pattern (DO → Mapper → Service → Controller → VO) with MapStruct converters. The system supports MySQL, PostgreSQL, Oracle, SQL Server, and Dameng databases, and integrates with Redis, RabbitMQ, Kafka, RocketMQ for messaging. It includes a code generator, a workflow designer, and AI chat/image/mind-map capabilities. The architecture is modular and well-organized, though the sheer number of modules (20+) introduces some duplication and complexity. Overall, it is a mature, actively maintained project with strong adherence to common enterprise patterns.
CodeStable is a framework for AI coding assistants (Claude Code, Codex CLI) that provides a set of 'skills' — thin harnesses that guide AI agents through software development tasks such as feature implementation, bug fixing, refactoring, epic decomposition, code review, and lesson management. The system emphasizes risk-based assurance, evidence-driven decisions, and minimal project memory, with a core philosophy of 'thin harness, thick context'. It is distributed as plugins for both Claude Code and Codex CLI, and includes a meta-skill (eval-cs-skill) for authoring, evaluating, optimizing, and releasing skills. The repository contains extensive experiment infrastructure with 15+ structured experiments covering routing accuracy, end-to-end outcomes, planted-defect recall, and learning transfer across multiple models. It features a sophisticated evaluation pipeline with deterministic oracles, hidden tests, regression tests, and checkpointed resume. The codebase demonstrates high craftsmanship with clean abstractions, strict validation, and cognitive honesty tagging (measured/soft/underpowered). Key architectural patterns include the thin skill pattern (compact SKILL.md with progressive disclosure via references), adapter pattern for AI model execution (Claude Code, Codex CLI, API, mock), deterministic seed building for reproducible experiments, and a risk-to-assurance mapping used generically by all task skills. The project has 8 ADRs documenting design decisions and a v1-to-v2 migration path that reduced 32 skills to 8. While the codebase is well-maintained and actively developed, some experiments are marked underpowered and the learning transfer epic was cancelled without completing primary hypotheses. The evaluation system is complex and tightly coupled to specific model names and macOS sandbox profiles, which may limit portability.
Direktiv is a workflow automation and serverless orchestration platform that enables users to define, execute, and manage workflows and services through a web UI or API. The system features a Go-based backend with React/TypeScript frontend, providing namespace-based multi-tenancy, event-driven triggers via CloudEvents and NATS, a plugin-extensible API gateway, and Kubernetes-native service deployment. Key capabilities include workflow execution (YAML/TypeScript), service management, secret/variable storage, file handling, Git-based namespace mirroring, and comprehensive monitoring with OpenTelemetry integration. The architecture follows a microservices-inspired monolith pattern with clear separation between API handling, data storage, execution engine, and gateway plugin systems.
This is a GitHub Action that parses JaCoCo XML coverage reports and posts a formatted coverage summary as a comment on pull requests. It supports single and multi-module projects, aggregate reports, multiple counter types (INSTRUCTION, BRANCH, LINE, COMPLEXITY, METHOD), custom emojis, and comment update strategies. The action fetches the list of changed files from the PR via the GitHub API, computes overall and per-file coverage percentages, and renders a markdown table with pass/fail indicators based on configurable thresholds. The codebase is written in TypeScript, well-structured with clear separation of concerns (action orchestration, XML parsing, coverage computation, markdown rendering), and includes a comprehensive test suite with fixtures covering various report structures and edge cases.
This repository is a production-grade, full-stack enterprise AI agent platform developed by iFlytek (Astron Agent). The system allows organizations to create, configure, deploy, and manage conversational AI agents (bots) with advanced workflow automation, knowledge retrieval (multi-strategy RAG), a plugin ecosystem (including MCP and HTTP tools), and multi-tenant team collaboration. The architecture is polyglot and service-oriented: a Java Spring Boot console backend handles bot lifecycle management, publishing to channels (API, WeChat, Feishu, marketplace), RBAC permissions, enterprise spaces, and notification systems. Python FastAPI core services power the workflow engine (20+ node types including LLM, code, decision, memory, knowledge), agent runtime with skill sandbox execution, knowledge indexing and retrieval, and plugin integrations (link server, RPA, MCP). A Go service manages tenant authentication and app key verification. The React + TypeScript frontend provides an interactive console for workflow design, model management, resource management (databases, knowledge bases, skill files), trace logs, and chat interfaces. External dependencies include multiple LLM providers (iFlytek Spark, OpenAI, Anthropic, Google, DeepSeek), MySQL, Redis, Kafka, S3-compatible storage, and Casdoor for SSO. The codebase demonstrates professional engineering with test coverage (JUnit, pytest, Jest), Flyway and Alembic database migrations, CI/CD pipelines, and a modular design using strategy, factory, and AOP patterns. However, it shows signs of complexity from polyglot maintenance, some duplicated frontend components, and legacy credential handling that has been addressed through targeted migration fixes. Overall, it is a well-maintained, actively developed platform suitable for mid-to-large enterprise deployments.