MonkeyType is a Python library and CLI tool that collects runtime types of function arguments and return values using Python's sys.setprofile hook. It stores these call traces (default SQLite) and can generate PEP 484 stub files or directly apply type annotations to source code via libcst. The architecture separates tracing (CallTracer), storage (CallTraceStore interface with SQLite implementation), stub generation (FunctionDefinition, ModuleStub), and application (libcst-based code transformation). It provides a configurable plugin system (Config/DefaultConfig) for customizing trace storage, code filtering, sampling, and type rewriting. The type rewriting subsystem includes a GenericTypeRewriter visitor pattern and several built-in rewriters (RemoveEmptyContainers, RewriteConfigDict, RewriteLargeUnion, RewriteMostSpecificCommonBase, RewriteGenerator) that refine raw union types into more idiomatic annotations. The project is well-tested with a comprehensive test suite and has been used in production at Instagram.
OpenAgents Control (OAC) is a framework for managing, testing, and orchestrating AI coding agents. It provides a CLI tool (`oac`) to install, update, and manage agents, context files, and skills from a registry. The system includes a plugin architecture for OpenCode and a compatibility layer that converts agent definitions between OAC, Claude Code, Cursor, and Windsurf formats. A comprehensive evaluation framework tests agent behavior against critical rules (approval gates, context loading, stop-on-failure, delegation, tool usage) using YAML-defined test suites and timeline-based analysis. The repository is primarily a software development toolchain for AI-assisted coding workflows, with strong emphasis on deterministic safety rules and multi-agent coordination.
Field Theory CLI is a local-first TypeScript application for managing X/Twitter bookmarks and building personal knowledge bases. It provides a comprehensive CLI interface for syncing bookmarks from Twitter/X (via OAuth API or browser session extraction), classifying content, exporting to markdown with wikilinks, generating interconnected wikis, and enabling agent workflows through skill installation for AI coding agents like Claude Code and Codex. The application features a 'Possible' idea generation pipeline that applies bookmark collections to repositories for innovation planning, with local data storage in ~/.fieldtheory/ using SQLite FTS5 for full-text search. Built with modular architecture separating concerns into bookmarks, ideas, agent context, and document operations modules.
WAT is a zero-dependency Python library for deep runtime inspection of objects. It provides a single `wat` object that can be used via `wat / obj`, `wat(obj)`, or `obj | wat` to display the object's type, value, attributes, methods, signatures, docstrings, source code, and more. The library supports a rich set of modifiers (short, long, dunder, code, caller, public, all) that can be chained fluently. It also offers `wat.locals` and `wat.globals` to inspect variable scopes. A notable feature is the ability to load the entire inspector without installation via a base64-compressed snippet or even a single Unicode glyph, making it extremely portable for debugging in any Python environment. The codebase is a single well-structured module with comprehensive test coverage, demonstrating solid Python engineering practices including operator overloading, AST manipulation for minification, and careful handling of edge cases in object introspection.
Goose is a high-performance, Rust-based load testing framework designed to simulate realistic HTTP/HTTPS user traffic. It functions as both a reusable library and a CLI tool, allowing developers to write load tests in Rust that are compiled into standalone binaries. The architecture relies on the Tokio async runtime for efficient concurrency, utilizing flume channels to decouple virtual user threads from the main metrics aggregation process. It supports complex test scenarios including weighted transactions, session data management, and custom protocol simulation (TCP, WebSocket, gRPC). The framework distinguishes itself through rigorous metric accuracy, specifically implementing mitigation strategies for Coordinated Omission (CO) to prevent misleading latency data during server stalls. It provides extensive reporting capabilities, generating HTML reports with ECharts visualizations, JSON metrics for CI/CD integration, and PDF reports via headless Chrome. Runtime control is available through Telnet and WebSocket interfaces, allowing test parameters to be adjusted dynamically without stopping the load generation. While the core library is stable and well-architected, the project exhibits signs of active but evolving development. The distributed testing feature (Gaggle) was removed and is currently being re-implemented, indicating ongoing architectural shifts. The project maintains a comprehensive documentation suite via mdBook but faces challenges in synchronizing documentation across multiple locations (README, CHANGELOG, mdBook, inline code). The AI-assisted development workflow relies on external APIs that may introduce dependency risks if those services change. For engineers evaluating reuse, Goose offers a robust foundation for performance testing with strong type safety guarantees in its client builder. The Coordinated Omission mitigation logic is a unique, high-value component for teams concerned with metric accuracy. However, users should be aware of the optional PDF dependency (Chrome) and the current instability of the distributed testing mode. The codebase is suitable for integration into CI/CD pipelines or as a library for custom performance validation tools.
elfcat is a zero-dependency Rust CLI tool that transforms ELF binary files into interactive, self-contained HTML visualizations. It parses the full ELF structure—file header, program headers, section headers, segments, sections, notes, and string tables—and generates an HTML page with a hex dump where bytes are color-coded by their structural role (e.g., ident, header fields, segments, sections). The output includes interactive features: hovering highlights the corresponding bytes in the hex dump, clicking fields with cross-references (like e_phoff or sh_offset) jumps to the referenced area and draws SVG arrows, and detailed info tables appear on hover for headers, segments, and sections. The tool is purely client-side; no server is involved, and the HTML report works offline in any modern browser. The codebase is well-structured, using Rust's trait system to abstract over 32-bit and 64-bit ELF formats without duplication, and it depends only on the Rust standard library.
This monorepo provides a Flutter plugin ecosystem for creating native home screen widgets on iOS (WidgetKit) and Android (Jetpack Glance). It consists of three core packages: `home_widget` (Dart API for data persistence, updates, scheduling, and background interactions), `home_widget_generator` (annotation-based code generation emitting SwiftUI and Kotlin code from `@HomeWidget` annotations), and `home_widget_cli` (command-line tool for scaffolding and patching native projects). The plugin handles cross-platform widget lifecycle, configuration, localized text, timed data, interactive clicks, image assets, and widget previews. Multiple example apps demonstrate features like configurable widgets, file sharing, lock screen widgets, and generator-based layouts. The architecture is a developer toolchain with a monorepo structure using Melos, extensive CI/CD workflows, and comprehensive unit and integration tests.
ghqr is a Go-based CLI tool for scanning GitHub enterprises, organizations, and repositories against a comprehensive set of best-practice rules. It produces actionable reports in Markdown, Excel, and JSON formats, with prioritized findings, remediation plans, and manual checklists. The tool also includes an MCP (Model Context Protocol) server for AI assistant integration, enabling interactive scanning and recommendations via stdio or HTTP/SSE. A deterministic mock generator allows demos and testing without live API calls. The architecture follows a composable pipeline pattern: initialization, data loading (from live API or JSON replay), enterprise/GHES/organization/repository discovery and scanning, evaluation against YAML-defined rules, and report rendering. Scanners use both REST and GraphQL APIs with batch queries, rate-limit handling, and tri-state boolean support for GHES on-prem instances. The rule registry is embedded as YAML files, loaded at startup into a typed registry that evaluators reference by stable rule IDs. Key entry points are the `ghqr scan`, `ghqr mcp`, `ghqr mock`, and `ghqr list-recommendations` commands. External dependencies include the GitHub API (REST and GraphQL), the `excelize` library for Excel output, and the `mcp-go` library for MCP protocol support. The tool is containerized via Docker and published to GHCR, with install scripts for Linux, macOS, and Windows.
Decman is a declarative package and configuration manager for Arch Linux that ensures system state matches user-defined specifications. It uses a modular architecture with a core application and plugins for managing different subsystems (pacman, AUR, systemd, flatpak). Users define their desired system state in Python files, and Decman executes these specifications to install/remove packages, manage files and directories, enable/disable services, and apply other system configurations. The system tracks its state in a JSON store to determine what changes are needed between runs, and provides hook functions for custom logic at various points in the execution lifecycle.
sbomqs is a command-line tool and Go library for evaluating the quality and compliance of Software Bill of Materials (SBOM) documents. It parses SBOMs in CycloneDX, SPDX 2.x, and SPDX 3.0 formats and scores them against multiple industry standards: NTIA Minimum Elements (2021/2025/2026), BSI TR-03183-2 (v1.1, v2.0, v2.1), FSCT v3, OpenChain Telco v1.1, and an Interlynk comprehensive profile. The tool outputs scores, detailed compliance reports, and feature lists, and can be integrated with Dependency-Track and policy engines. It is used in production by several platforms and has been cited in academic research evaluating over 78,000 SBOMs. The codebase is well-structured with clean interfaces, extensive test coverage, and a modular architecture that separates parsing, scoring, compliance checking, and reporting. A notable architectural trade-off is the coexistence of two scoring engines (legacy v1 and v2), which adds complexity but allows incremental migration. The library is embeddable as a Go module, and the CLI supports multiple output formats (basic, detailed, JSON).
go-instrument is a CLI tool that automatically instruments Go source files with OpenTelemetry trace spans. It parses Go AST, identifies functions that accept a `context.Context` parameter, and inserts span creation, defer, and optional error recording statements. It handles various edge cases: anonymous functions, build constraints (ignore/exclude), generated files, custom context/error parameter names, already-instrumented functions, and preserves original line numbers for panic stack traces via compiler directives. The tool is implemented as a reusable library with a clear separation between the generic AST processing engine (`processor` package) and the specific instrumentation strategy (`instrument` package), allowing custom instrumenters. The CLI frontend is minimal; the core logic is in the `processor` and `instrument` packages and is cleanly abstracted via an `Instrumenter` interface. The codebase is well-tested, includes fuzz testing, and uses current Go tooling.
PeakRDL is a CLI toolchain for control/status register (CSR) generation centered around the SystemRDL 2.0 language. It compiles register descriptions from SystemRDL or imported formats (e.g., IP-XACT) and exports synthesizable SystemVerilog RTL, C headers, UVM register models, HTML documentation, and more. The architecture is a pluggable CLI: a core dispatcher loads subcommands (built-in: dump, globals, preprocess) and external exporter/importer plugins via setuptools entry points or TOML config. Input processing handles SystemRDL compilation, parameterized components, and element arrays. The codebase demonstrates strong Python engineering with modular configuration schema validation, argument file expansion with environment variable support, and a clean plugin discovery mechanism.
Birdie is a snapshot testing library for the Gleam programming language. It provides a `snap` function to capture and compare test outputs against stored snapshots, and a CLI interface to review, accept, reject, and manage snapshots. The architecture separates concerns into modules for snapshot handling, CLI parsing, diagnostic formatting, diff computation, and project metadata. Key entry points are the `snap` function for writing tests and the `main` function for the CLI tool. The system relies on Gleam standard library and several community packages for argument parsing, file operations, ANSI styling, and source code analysis via the `glance` library. Data flows involve test execution creating `.new` snapshot files, CLI review moving them to `.accepted` or deleting them, and stale snapshot detection via a reference file tracking which snapshots were used during test runs.
free-claude-code is a local proxy and developer tool that connects coding agents (Claude Code and similar harnesses) to OpenAI-compatible AI providers. It is a Python package (`free_claude_code`) with a CLI, a local API server, an admin web UI, and a substantial configuration subsystem. The system abstracts over a dozen AI providers (including NVIDIA NIM, Cloudflare, HuggingFace, and others) with provider-specific workarounds for tool parameter aliasing, thinking templates, and reasoning replay. It persists sessions, messages, and model metadata in SQLite, manages a tree-based conversation model with Telegram platform support, and renders transcripts with segment-based truncation and subagent state management. The repo is a shipped developer tool with installer/update scripts, GitHub issue templates, dependabot config, and a diagnostic `fcc-doctor` command; it is not a research or data project.
Mobilerun is a comprehensive CLI and Python SDK framework for controlling Android and iOS devices through natural language commands powered by LLM agents. It orchestrates multi-agent workflows (Manager, Executor, FastAgent) built on llama-index Workflows, with device interaction via ADB (Android) and a separate iOS binary (WebDriverAgent). The system supports multiple LLM providers (OpenAI, Anthropic, Gemini, xAI, DeepSeek, Ollama, etc.), including custom OAuth flows for subscription-based access (Anthropic Claude, Google Code Assist, xAI Grok). It features a configurable agent architecture with Jinja2 prompt templates, macro recording/replay, MCP-based custom tool integration, telemetry (PostHog), tracing (Phoenix, Langfuse), and a rich set of developer tools (device selection, configuration wizard, doctor, credential management). The codebase is well-tested with over 50 test files covering XML parsing, coordinate coordinate contracts, OAuth flows, and agent workflows. While there is some code duplication in OAuth implementations and tight coupling to llama-index internals, the overall architecture is modular and extensible. The project is in active development (version 0.7.0, Beta) with commercial ties to Mobilerun Cloud.
This repository provides a cross-platform desktop application (GUI and CLI) for debloating Android devices by uninstalling or disabling unwanted system packages. It is built in Rust using the Iced GUI framework for the interface and a shared core library (`uad-core`) that abstracts ADB communication, package list management, backup/restore, and self-update logic. The tool leverages a community-maintained package classification database (embedded JSON) that categorizes packages by vendor (AOSP, Google, OEM, etc.) and removal safety (Recommended, Advanced, Expert, Unsafe). The architecture is modular: `uad-core` handles all ADB operations and data logic, `uad-cli` provides a command-line interface with subcommands for device management, package list filtering, and actions, and `uad-gui` offers a modern graphical interface with search, filter, bulk selection, and settings for cross-user and fallback modes. The codebase is well-organized with clear separation of concerns, custom theming, and a generic modal overlay widget. It demonstrates solid engineering practices for a desktop tool, though some components (like the embedded large JSON and complex fallback logic) introduce maintenance complexity.
The system is a comprehensive toolkit for AI-driven image and video generation, primarily leveraging diffusion models such as Stable Diffusion, Stable Diffusion XL, and Stable Video Diffusion. It provides both a command-line interface (CLI) and an HTTP API server for generating images from text prompts, performing image-to-image translation, inpainting, ControlNet-guided generation, upscaling, face restoration, and video frame interpolation. The architecture is modular, separating core model implementations, enhancements, processors, and utilities, with a strong emphasis on extensibility through configurable backends and pluggable components. Key features include support for multiple sampling algorithms (DDIM, PLMS, K-diffusion solvers), integration with ControlNet for conditional generation via edge, depth, pose, and other maps, and post-processing pipelines for upscaling (using RealESRGAN or similar) and face enhancement (using CodeFormer). The system also incorporates multimodal capabilities through integrated models like BLIP for image captioning and visual question answering, and segment anything model (SAM) for segmentation tasks. Model weight management is handled through a centralized system that resolves and converts weights from various sources (Hugging Face Hub, local cache) and formats (CompVis, Diffusers, Refiners). The CLI offers commands like `imagine` for text-to-image generation, `aimg` as a multi-command interface for imagine, upscale, edit, server, and videogen operations, and `run-server` to launch the HTTP API with a web interface (StableStudio). The HTTP API provides REST endpoints for programmatic access, complete with OpenAPI documentation and GPU-aware concurrency control to handle multiple requests safely. Overall, the system is designed to be user-friendly yet powerful, automating complex workflows like model downloads and caching while providing low-level control for advanced users.
Peekaboo is a mature macOS desktop automation toolkit that provides a CLI, Mac app, and MCP server for screen capture, UI element detection, input synthesis, window management, and AI agent integration. The architecture is modular: a Swift CLI (peekaboo) exposes ~33 commands for interaction, system control, and AI agent orchestration; a Mac app provides a menu bar interface, session management, and visualizer overlays; a bridge daemon (PeekabooBridge) enables secure remote automation via a versioned socket protocol with operation allowlisting. The MCP server exposes native automation tools to AI clients (Claude, Cursor, etc.) via stdio transport. The agent runtime (PeekabooAgentService) supports multiple AI providers (OpenAI, Anthropic, Ollama, etc.) with streaming, tool calling, and session persistence. The codebase is written in Swift 6.2 with strict concurrency, extensive unit/integration tests, and a focus on safety (fail-closed target validation, honest effect reporting). It is not a data research project; it is a production-grade application for macOS automation.
Sitespeed.io is a mature, open-source web performance testing and monitoring tool that drives real browsers (Chrome, Firefox, Edge, Safari, including mobile) to collect a comprehensive set of performance metrics. It measures Core Web Vitals (LCP, INP, CLS, TTFB, FCP), visual metrics (Speed Index, filmstrip), HAR waterfalls, CPU long tasks, third-party requests, accessibility violations (via axe-core), and sustainability metrics (CO₂ estimates). The tool is used for one-off audits, CI/CD performance budgets, and continuous production monitoring, with results output as rich HTML reports, JSON, JUnit/TAP, and time-series data sent to Graphite/InfluxDB/Grafana. The architecture is plugin-based: a core message queue orchestrates a pipeline of plugins (setup → url → summarize → render). Built-in plugins handle browser testing (via Browsertime), HAR analysis (PageXray), best-practice advice (Coach), accessibility, sustainability, statistical comparison (Mann-Whitney U), performance budgets, and result storage (S3, GCS, SCP, Rsync). The CLI is built with yargs and supports ~600 options organized into topical modules. The tool is primarily delivered as a Docker image (multi-arch amd64/arm64) and an npm package. Key entry points are `bin/sitespeed.js` (CLI), `lib/sitespeed.js` (programmatic API), and `docker/scripts/start.sh` (Docker entrypoint). External dependencies include Browsertime, Coach Core, PageXray, axe-core, and the third-party-web dataset. The project has extensive CI/CD (GitHub Actions), a documentation site built with Eleventy, and a release workflow that publishes npm packages and Docker images with Sigstore signatures and SBOMs.
Harp is a zero-configuration static web server and static site generator. It serves Jade, Markdown, EJS, Less, Stylus, Sass, and CoffeeScript files as HTML, CSS, and JavaScript without any build step. The architecture is a Connect-based middleware stack with a CLI wrapper. Key entry points are the `harp` CLI (bin/harp) and the library API (lib/index.js) which exposes `server()`, `compile()`, `mount()`, and `pipeline()`. The system reads project configuration from `harp.json` or `_harp.json`, supports layouts and partials via `_layout.jade` and `_data.json` files, and provides fallback 200/404 handling. It can compile projects to static assets for deployment. The codebase is well-structured with comprehensive tests and a smoke test for release validation. Dependencies are pinned, and the code uses modern JavaScript. It is a mature, stable project suitable for rapid prototyping and static site hosting.