Open-source alternatives to Github Script

The GitHub ToolKit for developing GitHub Actions.

The Kubernetes Python Client is a programmatic interface for cluster automation and resource management. It provides a REST-based API client that maps method calls to HTTP verbs and JSON payloads to create, update, delete, and monitor workloads and infrastructure components. The client features dynamic schema mapping and resource mapping, allowing it to control custom objects and unique resource definitions without requiring pre-defined classes or static schemas. It supports YAML manifest parsing to convert structured files into compatible objects for bulk resource deployment. The toolset co

Thunder Client is a REST API client extension for VS Code that functions as an HTTP request manager, testing tool, and mocking workspace. It allows users to send requests, organize them into collections, and manage API configurations directly within the editor. The project distinguishes itself through a command-line interface for executing automated test suites in CI/CD pipelines and a Git-based synchronization system for sharing request collections and environment configurations across teams. It also incorporates artificial intelligence to automate the conversion of API scripts during migrat

This project is a GitHub API client and resource manager designed for interacting with GitHub REST and GraphQL APIs. It serves as a programmatic interface for automating the management of repositories, issues, and pull requests. The library functions as a workflow automation tool, providing a simplified interface to handle repository data and account settings. It enables the creation of custom scripts to streamline repetitive tasks and data retrieval from the GitHub platform. The implementation provides a wrapper for external API calls that operates across both browser and server environment

This project is an Android security analysis toolkit and mobile app runtime manipulator designed for reverse engineering and auditing mobile applications. It provides a system for modifying Java classes and method behavior in active mobile processes to bypass security controls. The toolkit includes a web-based interface for controlling the instrumentation engine and a specialized utility for disabling certificate validation to intercept and inspect encrypted network traffic via SSL pinning bypass. It also features an Android file explorer for browsing and managing files within private data di

This project is an open-source Flutter GitHub client and cross-platform mobile application. It serves as a GitHub GraphQL client and OAuth mobile app, providing a mobile interface for browsing repositories, issues, and user profiles. It is also designed as an open-source architecture reference to demonstrate Flutter best practices, state management, and multi-language localization. The application distinguishes itself by using GraphQL queries to retrieve nested repository and user information, reducing network requests and over-fetching. It utilizes a shared Dart codebase to provide a consist

PyGithub is a Python library that serves as an object-oriented wrapper for the GitHub REST API. It functions as a specialized client that translates API endpoints into a hierarchy of Python classes, allowing for the programmatic management of GitHub repositories, user profiles, and organizations. The library manages the serialization of requests and responses, converting JSON data into structured object attributes. It utilizes lazy-loading for property retrieval and employs generators to handle pagination when iterating over large remote datasets. This toolkit enables the automation of GitHu

The Azure Cloud Command-Line Interface is a terminal-based utility used for creating, managing, and automating infrastructure and services within the Azure cloud ecosystem. It serves as a programmatic interface for handling cloud environment setup and resource lifecycles by interacting with Azure APIs. The tool facilitates cloud infrastructure automation through the use of scripts and standardized exit codes. It provides a command-line workflow that includes tab-completion for commands and parameters and a flexible query syntax for filtering results and extracting specific data fields from cl

Oils is a Unix shell interpreter and scripting language runtime that combines a modern shell language with POSIX and Bash compatibility. It functions as a structured data shell, integrating JSON and J8 formats to manage complex data without relying on string parsing. The system is distinguished by a C++ transpiled interpreter that converts a subset of Python source code into strongly typed C++ for high-performance execution. It features a garbage-collected typed runtime that supports prototype-based polymorphism, lexical closures, and reference-based variable mutation. To decouple shell logic

Amber is a transpiler that translates high-level source code into executable shell scripts for Bash, Zsh, and Ksh. It provides a type-safe environment for shell script generation, allowing for static type validation and the creation of standalone executable scripts. The project distinguishes itself through a compilation process that includes tree-shaking import optimization to reduce output size and template-based script wrapping for custom headers and footers. It utilizes a module-based dependency resolution system with visibility controls to manage code reuse across multiple files. The lan

This is a GitHub Actions tool used to clone Git repositories into a workspace to provide source code for automated workflow steps. It functions as a repository manager that handles the orchestration of source code checkouts, including a dedicated authentication handler for persisting security tokens and credentials. The project distinguishes itself through capabilities for managing complex repository structures, such as recursive submodule initialization and the retrieval of large binary assets via Git Large File Storage. It also supports multi-repository workspace management, allowing severa

pyinfra is a Python-based infrastructure automation framework that turns Python code into shell commands for managing servers, Docker containers, and local machines. It operates as a declarative, idempotent deployment tool, applying desired system states by comparing target configurations against current states and making only the necessary changes. The framework provides a connector-based transport abstraction that unifies SSH, Docker, and local execution behind a common interface, with a parallel execution engine that manages concurrent operations across hosts. The tool distinguishes itself

Codeception is a full-stack testing framework for PHP applications that provides a unified interface for unit, functional, and acceptance testing. It serves as a tool for automating real desktop and mobile browsers via the WebDriver protocol and acts as a client for testing REST and SOAP APIs. The framework is distinguished by its support for Behavior-Driven Development, allowing users to write human-readable test specifications in Gherkin language to align technical tests with business requirements. It implements actor-based action mapping to connect these natural language steps to executabl

This project is a command-line utility that executes processes by injecting environment variables from local configuration files. It functions as a runtime wrapper, allowing developers to manage application settings and process execution contexts without modifying global system variables. The tool distinguishes itself by supporting dynamic configuration loading, which allows for the use of files that export objects or promises to compute values at runtime. It provides granular control over environment management, including the ability to group variables into named collections, protect existin

pyinfra is an agentless infrastructure automation framework that turns declarative Python code into idempotent shell commands to manage servers, containers, and local machines over SSH without requiring any pre-installed software on target hosts. It operates by comparing the desired state of a system against its current state, using a dry-run simulation mode to preview changes and a fact-based conditional execution engine to gather host attributes at runtime and control which operations run. The tool compiles Python operations into optimized shell commands and executes them in parallel across

MVVMReactiveCocoa is an iOS application that functions as a Git repository browser and GitBucket client. It is structured as an MVVM application, utilizing the Model-View-ViewModel architectural pattern to separate business logic from the user interface. The project is powered by ReactiveCocoa, employing functional reactive programming to manage asynchronous data streams and bind data models directly to the user interface. This approach uses observer-based state management to synchronize UI components. The application provides capabilities for Git repository management, including searching f

This project is a Rust-based AI agent framework and tool orchestrator that provides a command-line interface for interacting with large language models. It functions as an AI tool orchestrator that routes client requests to language servers and manages the planning and handoffs between specialized agents to solve complex tasks. The system distinguishes itself as a language porting validator, using deterministic mocks and specifications to verify feature parity between different language implementations of a codebase. It further extends agent capabilities by acting as a Model Context Protocol

stack-overflow-import is a Python dynamic module loader and web-based code fetcher. It functions as a tool that retrieves code blocks from community answers on Stack Overflow and loads them as executable Python modules within a local environment. The project enables automated code snippet integration by fetching high-rated community solutions and importing them directly into the runtime. This allows for a workflow where external code is loaded as executable modules to facilitate the testing of snippets without manual copying and pasting.

ptpython is a programmable Python interactive shell and development console. It functions as an enhanced REPL for executing Python code and managing runtime state, featuring support for an asynchronous event loop that allows for top-level await statements. The environment is highly customizable, offering pluggable keybinding schemes and adjustable interface appearances. It provides a programmable interface that can be embedded into other applications to facilitate runtime debugging and live state inspection. The shell includes a suite of developer tools for interactive coding, such as automa

graphql-request is a lightweight, type-safe GraphQL client library for JavaScript that runs across browsers, Node.js, and other JavaScript environments. It provides a minimal HTTP client for sending queries and mutations, with a promise-based execution model that uses the native fetch API for cross-runtime compatibility without additional dependencies. The client supports reusable selection set composition at runtime, allowing fragments to be shared across multiple requests to reduce duplication. It includes a plugin-based extension system for adding custom middleware, tracing, or file upload

This project is an orchestration tool for establishing interactive debug sessions within automation pipelines. It functions as a GitHub Action that opens an interactive SSH or web-based shell session, providing a remote access utility for real-time system interaction and troubleshooting during continuous integration execution. The tool supports conditional debugging workflows, allowing interactive shells to be triggered only upon manual request or the failure of previous automation steps. It also enables detached debugging modes to start background sessions that provide connection details wit

This project provides a containerized execution agent designed to host automated workflows for version control platforms. It functions as a self-hosted runner that automatically registers with a central service upon startup and terminates after completing a single job, ensuring that every task runs in a clean, isolated environment. The system distinguishes itself through its focus on ephemeral lifecycle management and security. By utilizing a non-root execution model, it enforces least-privilege principles during job processing. The runner supports dynamic configuration through environment va

This is a Go client library for interacting with the Slack API, providing a programmatic interface to manage channels, users, and workspace settings. It functions as a bot framework and event handler, allowing for the development of automated assistants that respond to workspace activities. The library includes a dedicated Block Kit builder for constructing complex UI layouts, such as interactive elements, data tables, and visualizations, for rich messaging. It also provides a full implementation for managing user authentication and identity verification through OAuth2 and OpenID Connect. Br

This is a GitHub Action that executes shell commands on remote servers over SSH as part of a CI/CD pipeline. It supports authentication using passwords, private keys, or private keys with passphrases, and can verify the SHA256 fingerprint of the remote host's public key before connecting to prevent man-in-the-middle attacks. The action can connect to multiple remote hosts in a single workflow step, optionally executing commands synchronously across all of them. It also supports routing SSH connections through an intermediate jump host to reach target servers in restricted networks. Environmen

Vouch is a GitHub Actions automation that enforces community trust by requiring new contributors to be vouched by existing members before they can interact with a project's issues and pull requests. It maintains a vouched user list in a tracked file, and automatically closes or locks interactions from unvouched or denounced users to reduce spam and abuse. The system lets collaborators manage trust through issue and discussion comments using specific keywords to vouch, denounce, or unvouch users, with automatic updates to the vouched list and optional pull request merges. It also provides a CL

This project is a REST API client library and Google Cloud SDK component that integrates Python applications with Google services. It functions as a discovery-based API client, utilizing an OAuth 2.0 integration library to secure requests and verify identity through access tokens and service accounts. The library is distinguished by its use of discovery documents to dynamically generate clients at runtime. By parsing JSON metadata, it maps Python method calls to HTTP requests and builds interface-based resource models that mirror the hierarchical structure of the remote service. Its broader