CrewAI is a large, actively maintained Python framework for orchestrating autonomous AI agents and event-driven multi-agent workflows. The codebase is organized as a monorepo with six libraries under `lib/`: `crewai` (core framework), `crewai-cli` (CLI), `crewai-tools` (tool integrations), `crewai-files` (multimodal file handling), `crewai-core` (shared utilities), and `devtools` (release tooling). The core provides two complementary abstractions — Crews for autonomous role-based agent collaboration and Flows for precise, state-machine-driven orchestration — that can be combined in production applications. The framework supports numerous LLM providers (OpenAI, Anthropic, Gemini, Azure, Bedrock, and many more), a wide array of built-in and third-party tools, MCP/A2A protocol integrations, human-in-the-loop flows, and enterprise deployment via the AMP Suite. The repository has extensive test coverage (pytest with VCR cassettes), strong static analysis (ruff, mypy, bandit), and a well-defined release process. While the framework code is solid and well-structured, the repository is dominated by auto-generated documentation files (thousands of `.mdx` files across multiple versions and languages) and repetitive tool README templates, which inflate the file count but contribute little reusable engineering value.
presenterm is a Rust-based CLI application that renders Markdown presentations directly in the terminal. It parses Markdown into a structured intermediate representation via comrak, then builds slides as sequences of render operations. The rendering engine supports rich text, images, code highlighting through bat/syntect, column layouts, themes, slide transitions, footers, speaker notes, and interactive keyboard-driven navigation. It also includes PDF/HTML export backends and hot-reload for live presentation development.
ClickClack is a production-grade, self-hostable team chat platform built for people, bots, and agents. The backend is a single Go binary serving a REST API with WebSocket real-time events, supporting both SQLite and PostgreSQL as interchangeable storage backends. The frontend is a Svelte 5 single-page application embedded into the Go binary, with an optional Electron desktop client and a TypeScript SDK for bot development. The system provides workspaces, channels, threads, direct messages, file uploads, full-text search, reactions, pinned messages, slash commands, event subscriptions, and push notifications (Web Push and Pushover). Authentication supports magic links, passwords (Argon2id), GitHub OAuth, and Cloudflare Access JWT. The architecture emphasizes security with SSRF-safe callback dialers, strict cookie namespacing, rate limiting, and bot scope enforcement. The codebase is notable for its dual-database store pattern with shared contract tests, a real-time event hub with cursor-based recovery, and a comprehensive test suite including unit, integration, and Playwright end-to-end tests. It is not a data research project; it is a fully featured application designed for self-hosting or cloud deployment.
omni-article-markdown is a CLI tool and library that converts web articles from various sources into clean Markdown format. It employs a modular pipeline architecture: Reader fetches HTML (using requests or Playwright for JavaScript-heavy sites), Extractor isolates article content by removing boilerplate and ads, and Parser converts the cleaned HTML to Markdown with support for code blocks, tables, math equations, and GitHub Gists. The system uses a plugin-based architecture where site-specific readers and extractors are automatically discovered and loaded, allowing easy extension for new websites. Key features include SSL verification control, cookie persistence for sites requiring authentication (like Zhihu), and flexible output options (stdout or file saving).
Grid.js is a TypeScript table library that renders interactive HTML tables with features like sorting, searching, pagination, and row/cell selection. It follows a modular architecture with clear separation of concerns: core grid functionality, configuration system, data pipeline for processing data through stages (extraction, transformation, filtering, sorting, limiting), storage abstraction for client/server data sources, UI components built with Preact, and a plugin system for extensibility. Data flows from user-provided sources through storage adapters, then through pipeline processors that handle server initiation, data extraction, format transformation, filtering, sorting, and pagination before reaching the view layer for rendering. User interactions trigger pipeline reprocessing to update the display.
Cot is a batteries-included web framework for Rust, heavily inspired by Django. It provides a full-stack application architecture with an ORM (SQLite, PostgreSQL, MySQL), automatic migration generation, an admin panel, form handling with validation, session management (multiple backends including file, database, Redis), caching (in-memory, Redis), email sending (console, SMTP), OpenAPI/Swagger documentation generation, static file serving, and a CLI for project scaffolding and migration management. The framework is built on top of tokio, axum, sea-query, sqlx, and tower, using trait-based designs and an extensive set of procedural macros (e.g., `#[model]`, `#[Form]`, `#[AdminModel]`, `#[IntoResponse]`, `query!`, `#[cot::main]`) to reduce boilerplate. Architecturally, Cot uses a type-safe phased bootstrapper (the `Bootstrapper` with six states from `Uninitialized` to `Initialized`) to configure the project in a guaranteed order. The central `Project` and `App` traits define the application composition, while the `Router` (trie-based) supports nested routing and reverse URL generation. The ORM layer features a query expression builder, migration engine with dependency-aware rollback, and backend-specific implementations. The macro system (`cot-macros` + `cot-codegen`) performs compile-time code generation for models, forms, queries, and admin interfaces, with UI compile-fail tests to validate error messages. The codebase demonstrates high craftsmanship with well-separated concerns, extensive test coverage (unit, integration, snapshot, UI compile-fail, and end-to-end WebDriver tests), and reusable patterns such as composable response modifiers, builder-pattern configuration, and a custom serde deserializer for path parameters. While the framework is relatively new and some features like workspace migration generation are incomplete, it is actively maintained with frequent releases and a healthy CI/CD pipeline.
K8up is a production-grade Kubernetes/OpenShift operator that automates restic-based backup, restore, archive, check, and prune operations. It is implemented as a controller-runtime application with a single Go binary exposing `k8up operator` and `k8up restic` subcommands. The operator watches namespaced CRDs (`Schedule`, `Backup`, `Restore`, `Archive`, `Check`, `Prune`, `PreBackupPod`, `PodConfig`, `Snapshot`), reconciles them, and creates Kubernetes Jobs that mount PVCs and execute a bundled restic wrapper. Schedules are aggregated in a single `Schedule` CRD and support randomized cron entries; application-aware backups use pod annotations and PreBackupPods to run commands before/after snapshotting. Storage backends are configured through a unified `Backend` object for S3, GCS, Azure, B2, Swift, REST, and local repos, with credentials resolved from Kubernetes Secrets. Prometheus metrics, stats webhooks, TLS/mTLS support, and Helm-based deployment are first-class features.
GridStack.js is a production-grade TypeScript library for building responsive, drag-and-drop dashboard layouts. The core GridStack class manages widget lifecycle, DOM placement, responsive column switching, nested grids, serialization, and eventing, while GridStackEngine performs collision and positioning math without touching the DOM. The library ships its own drag-and-drop subsystem rather than depending on HTML5 drag-and-drop or jQuery, and it has zero runtime dependencies. Architecturally, the repository is a multi-package collection: a framework-agnostic core, a SCSS styling layer, and official Angular, React, and Vue wrappers. The wrappers integrate through callback hooks such as addRemoveCB, saveCB, and updateCB, plus DOM-stamped host APIs, allowing each framework to dynamically create and destroy widgets while keeping item content mounted during cross-grid drags. Demo applications under demo/, angular/projects/demo, react/src, and vue/src exercise the public API and serve as integration references. The project is actively maintained with a comprehensive Vitest and Playwright test suite, issue-numbered regression tests, and frequent releases. Its main technical debt is the large monolithic gridstack.ts (roughly 3100 lines) and the need to keep three framework wrappers synchronized with core API changes. The Angular wrapper is intentionally pinned to an older Angular major and some legacy build artifacts remain, but the core engine/UI separation, clean utility layer, and callback-based framework integration make many parts genuinely reusable.
diagram-js is a modular, extensible JavaScript library for building interactive web-based diagram editors. It provides the foundational infrastructure—an event-driven architecture via EventBus, a command pattern with full undo/redo support via CommandStack, and a DI container (didi) for composing features as independent modules. The codebase includes core services (Canvas, ElementRegistry, GraphicsFactory) for managing SVG rendering, hit testing, and element lifecycle, along with a rich set of interaction features: drag-and-drop creation/move/resize/connect, snapping, grid snapping, auto-resize, auto-place, bendpoint editing, lasso selection, space tool, popup menus, context pads, palettes, search, overlays, copy/paste, and keyboard bindings. It is designed for downstream domain-specific editors (e.g., bpmn-js, dmn-js) which extend it via provider interfaces and rule systems. The library is well-tested with an extensive suite using Mocha/Chai/Sinon and runs on modern browsers. Its architecture emphasizes decoupling, extensibility, and reusable patterns.
tsify is a Rust library that generates TypeScript type declarations from Rust types, primarily for the wasm-bindgen ecosystem. The core mechanism is a `#[derive(Tsify)]` proc macro that produces a `Tsify` trait impl whose `DECL` constant is emitted into the wasm-bindgen `typescript_custom_section`, so `wasm-pack` automatically appends the generated `.d.ts` alongside the JS output. It maps Rust structs, enums, and type aliases to TypeScript interfaces, type aliases, namespaces, and unions, respecting serde attributes (`rename`, `tag`, `untagged`, `flatten`, `skip`, `default`, `transparent`) and offering tsify-specific overrides (`type`, `type_params`, `type_prefix`/`type_suffix`, `rename`, `namespace`, and serializer options like `missing_as_null` / `hashmap_as_object` / `large_number_types_as_bigints`). A second runtime type, `Ts<T>`, provides a memory-safe alternative to the deprecated `into_wasm_abi`/`from_wasm_abi` attributes by deferring deserialization out of the infallible ABI boundary into the function body, avoiding the destructor-skipping `throw_str` leak path.
This repository is the frontend client suite for daily.dev, a developer-focused content and community platform. It is structured as a monorepo using pnpm workspaces, containing three primary packages: `packages/webapp` (Next.js application), `packages/extension` (browser extension), and `packages/shared` (shared UI components, hooks, and GraphQL logic). The system aggregates developer content, manages user profiles and communities (Squads), handles monetization (Plus subscriptions, Cores), and provides career opportunities. Key entry points include the Next.js pages router in `packages/webapp/pages` and the extension background/content scripts in `packages/extension/src`. Data flows primarily through GraphQL queries to an external `daily-api` service, with client-side state managed via TanStack Query and Jotai. External dependencies include Paddle for payments, GrowthBook for feature flags, and Cloudinary for media. The architecture emphasizes code sharing and consistency across platforms, with `packages/shared` serving as the core library for UI primitives, business logic, and API abstractions. The webapp utilizes Next.js for server-side rendering and static generation, while the extension leverages web extension APIs for browser integration. The codebase demonstrates strong engineering practices with strict TypeScript typing, comprehensive testing (Jest, Playwright), and a robust design system. However, the heavy reliance on feature flags and the use of a non-LTS Node version (v24.18) introduce some technical debt and potential compatibility risks. The platform supports multiple user journeys including content consumption, community engagement, and monetization. It features a sophisticated feed system with infinite scrolling, personalized recommendations, and content preferences. The extension provides companion features like new tab pages and frame embedding, requiring careful synchronization with the web app's authentication and permission models. The codebase is well-structured but complex, with deep nesting of contexts and modals that could impact maintainability if not carefully managed.
This repository is a production-grade application for building real-time voice agents, primarily designed as an educational course but structured for actual deployment. It implements a complete voice call center system capable of receiving and making phone calls via Twilio, transcribing speech using various STT models (Moonshine, Whisper, Faster Whisper), reasoning with LLMs (Groq), searching property data using Superlinked and Qdrant, and generating speech using TTS models (Kokoro, Orpheus). The architecture is a modular monolith built with FastAPI, utilizing Docker for containerization and RunPod for GPU-accelerated model inference. While the repository includes Jupyter notebooks for educational purposes (Lesson 1-4), the core value lies in the `src/realtime_phone_agents` package, which encapsulates the agent logic, avatar system, and infrastructure integrations. The code demonstrates high craftsmanship in handling async audio streaming, managing external API dependencies, and implementing a flexible avatar registry system. It is suitable for engineers looking to build voice AI applications or understand the integration of LLMs with real-time audio pipelines.
TTGTagCollectionView is a production-ready iOS UI library that renders collections of tags/chips in a flowing, wrap-aware layout. The two principal entry points are `TextTagCollectionView`, which displays styled text tags driven by a datasource of `TextTag` model objects, and `TagCollectionView`, a generic container for arbitrary `UIView` tags using a delegate/datasource pattern. Tags are plain in-memory model objects — there is no persistence, networking, or data pipeline. The library is Swift-first with an intentional `@objc` compatibility surface preserving the pre-3.0 Objective-C API, and it ships with CocoaPods and Swift Package Manager support plus a `TagCloudView` SwiftUI wrapper.
lua-resty-redis is a Lua Redis client driver for OpenResty/ngx_lua, leveraging the cosocket API for fully non-blocking I/O. It implements the Redis wire protocol (RESP) to support all standard Redis commands, including pipelining, transactions, pub/sub, and SSL connections. The library provides automatic method generation via Lua metatables, allowing any Redis command to be called as a method without explicit registration. It also offers connection pooling, Unix socket support, and configurable timeouts. The single source file (lib/resty/redis.lua) is self-contained and can be dropped into any OpenResty project. The codebase demonstrates strong engineering practices with efficient table reuse, proper error handling, and comprehensive test coverage.
pgflow is a PostgreSQL/Supabase-native workflow orchestration engine for defining and executing typed DAGs as background jobs. The system is split into six coordinated packages: a PL/pgSQL core (pkgs/core) that implements the complete workflow state machine in the database — flows, steps, runs, step states, tasks, retries with exponential backoff, map/reduce fan-out, conditional step execution, skip-cascade propagation, and realtime event broadcasting — plus a type-safe TypeScript DSL (pkgs/dsl) for declaring flows with compile-time-enforced inputs/outputs, a Deno/edge worker runtime (pkgs/edge-worker) that consumes PGMQ messages and executes step handlers via platform adapters (Supabase vs. plain process), a realtime-subscription client library (pkgs/client), and a CLI (pkgs/cli) for scaffolding new Supabase projects. Execution relies on pgmq for task queues, pg_cron for stalled-task recovery and worker health, pg_net for HTTP worker invocation, supabase_vault for credentials, and Supabase Realtime for atomic state-transition broadcasts.
Vue Select is a mature, zero-dependency Vue 2 component library that implements a feature-rich select/dropdown/typeahead UI element. It supports single and multiple selection, tagging, AJAX-powered search, keyboard navigation, RTL, and extensive customization via slots, props, CSS variables, and child component overrides. The library is distributed via npm and can be used as a Vue plugin or global component. The architecture is centered around a single large Vue component (Select.vue) that composes mixins for type-ahead pointer management, auto-scrolling, and AJAX loading, plus child components for the clear button and open indicator. It follows WAI-ARIA practices for accessibility and includes a complete set of unit tests. While the component is tightly coupled internally, it exposes a well-documented API for external configuration. The codebase is actively maintained with semantic release, bundle size monitoring, and a separate Vue 3 beta branch.
This is the official JavaScript/TypeScript SDK for the Algorand blockchain, version 3.7.0. It provides a comprehensive set of tools for constructing, signing, encoding, and submitting transactions to Algorand nodes, as well as querying blockchain state via the Algod v2, Indexer, and KMD APIs. The SDK supports all transaction types (payment, asset management, application calls, key registration, state proofs, heartbeats), atomic transaction groups, ABI encoding/decoding for smart contract interactions, logic signatures (escrow, delegation, multisig), and post-quantum Falcon-1024 signatures. It is designed for both Node.js and browser environments, with CommonJS, ESM, and webpack bundle outputs. The architecture is modular: a core encoding layer (schema-based msgpack/JSON serialization) underpins all data types; a client layer abstracts HTTP communication with token-based authentication; a transaction builder pattern provides ergonomic construction; and a signer abstraction decouples signing logic from transaction assembly. Key entry points include the `Algodv2`, `Indexer`, and `Kmd` client classes, the `Transaction` class, `AtomicTransactionComposer` for atomic groups, and the `LogicSig`/`LogicSigAccount` classes. Data flows involve constructing transactions, signing them (via raw keys, multisig, or external signers), encoding to msgpack, and submitting to the network. The SDK also handles decoding of responses, including complex structures like block headers, state deltas, and simulation results. External dependencies include the `algorand-msgpack` package for msgpack encoding, `@algorandfoundation/falcon-wasm` for post-quantum signatures, and `hi-base32` for address encoding. The SDK is extensively tested with unit tests (Mocha), integration tests (Cucumber with mock servers), and browser tests (Selenium). It is actively maintained with regular releases, automated code generation from Algorand API specifications, and CI/CD pipelines for linting, testing, and publishing.
hastscript is a utility for creating Hast (HTML Abstract Syntax Tree) trees using a hyperscript-like API. It provides two main functions, `h` for HTML and `s` for SVG, which accept CSS-like selectors, properties, and children to construct virtual DOM nodes. The library is designed to be used in build tools and frameworks that work with the Hast syntax tree, such as those in the Unified collective. The core of the library is the `createH` function in `lib/create-h.js`, which is a parameterized hyperscript function that can be adapted for different domains (like HTML or SVG) by providing a schema and default tag name. Additionally, the library supports JSX via automatic and classic runtimes, implemented in `lib/create-automatic-runtime.js` and wired up in `lib/index.js`. The project is well-maintained, with recent commits and active CI workflows, and shows low technical drift with up-to-date dependencies.
Newspipe is a self-hosted web news aggregator (RSS/Atom feed reader) built with Flask. It provides a full-featured reading experience with multi-user support, two-factor authentication, role-based access control, and a RESTful API. The system fetches feeds asynchronously using asyncio, sanitizes content against XSS, and guards against SSRF via IP pinning. It supports categories, bookmarks, tags, notes, search, infinite scroll, and a resizable reading pane. Data can be imported/exported in OPML and JSON formats, and it integrates with Pinboard for bookmark import. The frontend uses Bootstrap 5, Chart.js, and Luxon for relative dates, with i18n support for English, French, and German. The architecture follows a layered pattern: Flask blueprints for views, controllers for data access (with a generic AbstractController), SQLAlchemy models, and utility libraries for security and data handling. The crawler is a separate async module that can be invoked via CLI or cron. The codebase demonstrates strong security practices (CSP, CSRF, safe redirects, input sanitization) and includes unit tests for security-critical components. While the project is well-structured and actively maintained, there is a known bug where non-admin users with API access cause a 500 error on article updates due to a tag association proxy issue.
WinUtil is a comprehensive Windows system administration utility delivered as a single compiled PowerShell script (winutil.ps1). It provides a WPF graphical interface for installing applications via WinGet and Chocolatey, applying registry and service tweaks, managing Windows features and AppX packages, changing DNS settings, enabling SSH, creating custom Windows 11 ISOs with driver injection, and controlling Windows Update profiles. The architecture is monolithic but modular in source: a build script (Compile.ps1) assembles the final artifact from separate function files, JSON configuration catalogs, and XAML UI definitions. Background work is handled by a job layer built on a runspace pool, with centralized progress reporting, logging, and error handling. The tool supports both interactive GUI mode and headless automation via preset/config files, making it suitable for both manual system optimization and automated deployment scenarios. While primarily an application, it includes data-driven components such as curated application catalogs and registry research encoded in JSON configuration files.