@goplausible/algorand-mcp 3.0.7

package/dist/resources/knowledge/taxonomy/algokit-cli:README.md

@@ -0,0 +1,272 @@
+<div align="center">
+<a href="https://github.com/algorandfoundation/algokit-cli"><img src="https://ipfs.algonode.xyz/ipfs/QmZqt55wHXrZzhBihSVzXDvwp9rguvLAvFhUm1qJR6GYeQ" width=60%></a>
+</div>
+
+<p align="center">
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md"><img src="https://img.shields.io/badge/docs-repository-00dc94?logo=github&style=flat.svg" /></a>
+    <a target="_blank" href="https://developer.algorand.org/algokit/"><img src="https://img.shields.io/badge/learn-AlgoKit-00dc94?logo=algorand&mac=flat.svg" /></a>
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-cli"><img src="https://img.shields.io/github/stars/algorandfoundation/algokit-cli?color=00dc94&logo=star&style=flat" /></a>
+    <a target="_blank" href="https://developer.algorand.org/algokit/"><img  src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fgithub.com%2Falgorandfoundation%2Falgokit-cli&countColor=%2300dc94&style=flat" /></a>
+</p>
+
+---
+
+The Algorand AlgoKit CLI is the one-stop shop tool for developers building on the [Algorand network](https://www.algorand.com/).
+
+AlgoKit gets developers of all levels up and running with a familiar, fun and productive development environment in minutes. The goal of AlgoKit is to help developers build and launch secure, automated production-ready applications rapidly.
+
+[Install AlgoKit](#install) | [Quick Start Tutorial](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/tutorials/intro.md) | [Documentation](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md)
+
+## What is AlgoKit?
+
+AlgoKit compromises of a number of components that make it the one-stop shop tool for developers building on the [Algorand network](https://www.algorand.com/).
+
+![AlgoKit components](https://raw.githubusercontent.com/algorandfoundation/algokit-cli/main/docs/imgs/algokit-map.png)
+
+AlgoKit can help you [**learn**](#learn), [**develop**](#develop) and [**operate**](#operate) Algorand solutions. It consists of [a number of repositories](https://github.com/search?q=org%3Aalgorandfoundation+algokit-&type=repositories), including this one.
+
+### Learn
+
+There are many learning resources on the [Algorand Developer Portal](https://developer.algorand.org/) and the [AlgoKit landing page](https://developer.algorand.org/algokit) has a range of links to more learning materials. In particular, check out the [quick start tutorial](https://developer.algorand.org/docs/get-started/algokit/) and the [AlgoKit detailed docs page](https://developer.algorand.org/docs/get-details/algokit/).
+
+If you need help you can access both the [Algorand Discord](https://discord.gg/84AActu3at) (pro-tip: check out the algokit channel!) and the [Algorand Forum](https://forum.algorand.org/).
+
+We have also developed an [AlgoKit video series](https://www.youtube.com/@algodevs/playlists).
+
+### Develop
+
+AlgoKit helps you develop Algorand solutions:
+
+- **Interaction**: AlgoKit exposes a number of interaction methods, namely:
+  - [**AlgoKit CLI**](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md): A Command Line Interface (CLI) so you can quickly access AlgoKit capabilities
+  - [VS Code](https://code.visualstudio.com/): All AlgoKit project templates include VS Code configurations so you have a smooth out-of-the-box development experience using VS Code
+  - [lora](https://lora.algokit.io/): AlgoKit has integrations with lora; a web-based user interface that let's you visualise and interact with an Algorand network
+- **Getting Started**: AlgoKit helps you get started quickly when building new solutions:
+  - [**AlgoKit Templates**](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/init.md): Template libraries to get you started faster and quickly set up a productive dev experience
+- **Development**: AlgoKit provides SDKs, tools and libraries that help you quickly and effectively build high quality Algorand solutions:
+  - **AlgoKit Utils** ([Python](https://github.com/algorandfoundation/algokit-utils-py#readme) | [TypeScript](https://github.com/algorandfoundation/algokit-utils-ts#readme)): A set of utility libraries so you can develop, test, build and deploy Algorand solutions quickly and easily
+    - [algosdk](https://developer.algorand.org/docs/sdks/) ([Python](https://github.com/algorand/py-algorand-sdk#readme) | [TypeScript](https://github.com/algorand/js-algorand-sdk#readme)) - The core Algorand SDK providing Algorand protocol API calls, which AlgoKit Utils wraps, but still exposes for advanced scenarios
+  - [**Algorand Python**](https://github.com/algorandfoundation/puya): A semantically and syntactically compatible, typed Python language that works with standard Python tooling and allows you to express smart contracts (apps) and smart signatures (logic signatures) for deployment on the Algorand Virtual Machine (AVM).
+  - [**TEALScript**](https://github.com/algorandfoundation/TEALScript): A subset of TypeScript that can be used to express smart contracts (apps) and smart signatures (logic signatures) for deployment on the Algorand Virtual Machine (AVM).
+  - [**AlgoKit LocalNet**](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/localnet.md): A local isolated Algorand network so you can simulate real transactions and workloads on your computer
+
+### Operate
+
+AlgoKit can help you deploy and operate Algorand solutions.
+
+AlgoKit comes with out-of-the-box [Continuous Integration / Continuous Deployment (CI/CD) templates](https://github.com/algorandfoundation/algokit-python-template) that help you rapidly set up best-practice software delivery processes that ensure you build quality in and have a solution that can evolve
+
+## What can AlgoKit help me do?
+
+The set of capabilities supported by AlgoKit will evolve over time, but currently includes:
+
+- Quickly run, explore and interact with an isolated local Algorand network (LocalNet)
+- Building, testing, deploying and calling [Algorand Python](https://github.com/algorandfoundation/puya) / [TEALScript](https://github.com/algorandfoundation/TEALScript) smart contracts
+
+For a user guide and guidance on how to use AlgoKit, please refer to the [docs](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md).
+
+Future capabilities are likely to include:
+
+- Quickly deploy [standardised](https://github.com/algorandfoundation/ARCs/#arcs-algorand-requests-for-comments), audited smart contracts
+- Building and deploying Algorand dApps
+
+## Is this for me?
+
+The target audience for this tool is software developers building applications on the Algorand network. A working knowledge of using a command line interfaces and experience using the supported programming languages is assumed.
+
+## How can I contribute?
+
+This is an open source project managed by the Algorand Foundation. See the [contributing page](https://github.com/algorandfoundation/algokit-cli/blob/main/CONTRIBUTING.md) to learn about making improvements to the CLI tool itself, including developer setup instructions.
+
+# Install
+
+> **Note** Refer to [Troubleshooting](#troubleshooting) for more details on mitigation of known edge cases when installing AlgoKit.
+
+## Prerequisites
+
+The key required dependency is Python 3.10+, but some of the installation options below will install that for you. We recommend using Python 3.12+, as the `algokit compile python` command requires this version.
+
+> **Note**
+> You can still install and use AlgoKit without these dependencies, and AlgoKit will tell you if you are missing one for a given command.
+
+- **Git**: Essential for creating and updating projects from templates. Installation guide available at [Git Installation](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git).
+- **Docker**: Necessary for running the AlgoKit LocalNet environment. Docker Compose version 2.5.0 or higher is required. See [Docker Installation](https://docs.docker.com/get-docker/).
+- **Node.js**: For those working on frontend templates or building contracts using TEALScript. **Minimum required versions are Node.js `v18` and npm `v9`**. Instructions can be found at [Node.js Installation](https://nodejs.org/en/download/).
+
+> **Note**
+> If you have previously installed AlgoKit using `pipx` and would like to switch to a different installation method, please ensure that
+> you first uninstall the existing version by running `pipx uninstall algokit`. Once uninstalled, you can follow the installation instructions for your preferred platform.
+
+## Cross-platform installation
+
+AlgoKit can be installed using OS specific package managers, or using the python tool [pipx](https://pypa.github.io/pipx/).
+See below for specific installation instructions.
+
+### Installation Methods
+
+- [Windows](#install-algokit-on-windows)
+- [Mac](#install-algokit-on-mac)
+- [Linux](#install-algokit-on-linux)
+- [pipx](#install-algokit-with-pipx-on-any-os)
+
+## Install AlgoKit on Windows
+
+> **Note**
+> AlgoKit is supported on Windows 10 1709 (build 16299) and later.
+> We only publish an x64 binary, however it also runs on ARM devices by default using the built in x64 emulation feature.
+
+1. Ensure prerequisites are installed
+
+   - [WinGet](https://learn.microsoft.com/en-us/windows/package-manager/winget/) (should be installed by default on recent Windows 10 or later)
+   - [Git](https://github.com/git-guides/install-git#install-git-on-windows) (or `winget install git.git`)
+   - [Docker](https://docs.docker.com/desktop/install/windows-install/) (or `winget install docker.dockerdesktop`)
+     > **Note**
+     > See [our LocalNet documentation](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/localnet.md#prerequisites) for more tips on installing Docker on Windows
+   - [Microsoft C++ Build Tools](https://visualstudio.microsoft.com/visual-cpp-build-tools/)
+
+2. Install using winget
+
+   ```shell
+   winget install algokit
+   ```
+
+3. [Verify installation](#verify-installation)
+
+### Maintenance
+
+Some useful commands for updating or removing AlgoKit in the future.
+
+- To update AlgoKit: `winget upgrade algokit`
+- To remove AlgoKit: `winget uninstall algokit`
+
+## Install AlgoKit on Mac
+
+> **Note**
+> AlgoKit is supported on macOS Big Sur (11) and later for both x64 and ARM (Apple Silicon)
+
+1. Ensure prerequisites are installed
+
+   - [Homebrew](https://docs.brew.sh/Installation)
+   - [Git](https://github.com/git-guides/install-git#install-git-on-mac) (should already be available if `brew` is installed)
+   - [Docker](https://docs.docker.com/desktop/install/mac-install/), (or `brew install --cask docker`)
+     > **Note**
+     > Docker requires MacOS 11+
+
+2. Install using Homebrew
+
+   ```shell
+   brew install algorandfoundation/tap/algokit
+   ```
+
+3. Restart the terminal to ensure AlgoKit is available on the path
+4. [Verify installation](#verify-installation)
+
+### Maintenance
+
+Some useful commands for updating or removing AlgoKit in the future.
+
+- To update AlgoKit: `brew upgrade algokit`
+- To remove AlgoKit: `brew uninstall algokit`
+
+## Install AlgoKit on Linux
+
+> **Note**
+> AlgoKit is compatible with Ubuntu 16.04 and later, Debian, RedHat, and any distribution that supports [Snap](https://snapcraft.io/docs/installing-snapd), but it is only supported on x64 architecture; ARM is not supported.
+
+1. Ensure prerequisites are installed
+
+   - [Snap](https://snapcraft.io/docs/installing-snapd) (should be installed by default on Ubuntu 16.04.4 LTS (Xenial Xerus) or later)
+   - [Git](https://github.com/git-guides/install-git#install-git-on-linux)
+   - [Docker](https://docs.docker.com/desktop/install/linux-install/)
+
+2. Install using snap
+
+   ```shell
+   sudo snap install algokit --classic
+   ```
+
+   > For detailed guidelines per each supported linux distro, refer to [Snap Store](https://snapcraft.io/algokit).
+
+3. [Verify installation](#verify-installation)
+
+### Maintenance
+
+Some useful commands for updating or removing AlgoKit in the future.
+
+- To update AlgoKit: `snap refresh algokit`
+- To remove AlgoKit: `snap remove --purge algokit`
+
+## Install AlgoKit with pipx on any OS
+
+1. Ensure desired prerequisites are installed
+
+   - [Python 3.10+](https://www.python.org/downloads/)
+   - [pipx](https://pypa.github.io/pipx/installation/)
+   - [Git](https://github.com/git-guides/install-git)
+   - [Docker](https://docs.docker.com/get-docker/)
+
+2. Install using pipx
+
+   ```shell
+   pipx install algokit
+   ```
+
+3. Restart the terminal to ensure AlgoKit is available on the path
+4. [Verify installation](#verify-installation)
+
+### Maintenance
+
+Some useful commands for updating or removing AlgoKit in the future.
+
+- To update AlgoKit: `pipx upgrade algokit`
+- To remove AlgoKit: `pipx uninstall algokit`
+
+## Verify installation
+
+Verify AlgoKit is installed correctly by running `algokit --version` and you should see output similar to:
+
+```
+algokit, version 1.0.1
+```
+
+> **Note**
+> If you get receive one of the following errors:
+>
+> - `command not found: algokit` (bash/zsh)
+> - `The term 'algokit' is not recognized as the name of a cmdlet, function, script file, or operable program.` (PowerShell)
+>
+> Then ensure that `algokit` is available on the PATH by running `pipx ensurepath` and restarting the terminal.
+
+It is also recommended that you run `algokit doctor` to verify there are no issues in your local environment and to diagnose any problems if you do have difficulties running AlgoKit. The output of this command will look similar to:
+
+```
+timestamp: 2023-03-27T01:23:45+00:00
+AlgoKit: 1.0.1
+AlgoKit Python: 3.11.1 (main, Dec 23 2022, 09:28:24) [Clang 14.0.0 (clang-1400.0.29.202)] (location: /Users/algokit/.local/pipx/venvs/algokit)
+OS: macOS-13.1-arm64-arm-64bit
+docker: 20.10.21
+docker compose: 2.13.0
+git: 2.37.1
+python: 3.10.9 (location:  /opt/homebrew/bin/python)
+python3: 3.10.9 (location:  /opt/homebrew/bin/python3)
+pipx: 1.1.0
+poetry: 1.3.2
+node: 18.12.1
+npm: 8.19.2
+brew: 3.6.18
+
+If you are experiencing a problem with AlgoKit, feel free to submit an issue via:
+https://github.com/algorandfoundation/algokit-cli/issues/new
+Please include this output, if you want to populate this message in your clipboard, run `algokit doctor -c`
+```
+
+Per the above output, the doctor command output is a helpful tool if you need to ask for support or [raise an issue](https://github.com/algorandfoundation/algokit-cli/issues/new).
+
+## Troubleshooting
+
+This section addresses specific edge cases and issues that some users might encounter when interacting with the CLI. The following table provides solutions to known edge cases:
+
+| Issue Description                                                                                                                                   | OS(s) with observed behaviour                             | Steps to mitigate                                                                                                                                                                                                                                                                                                                      | References                                          |
+| --------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
+| This scenario may arise if installed `python` was build without `--with-ssl` flag enabled, causing pip to fail when trying to install dependencies. | Debian 12                                                 | Run `sudo apt-get install -y libssl-dev` to install the required openssl dependency. Afterwards, ensure to reinstall python with `--with-ssl` flag enabled. This includes options like [building python from source code](https://medium.com/@enahwe/how-to-06bc8a042345) or using tools like [pyenv](https://github.com/pyenv/pyenv). | <https://github.com/actions/setup-python/issues/93> |
+| `poetry install` invoked directly or via `algokit project bootstrap all` fails on `Could NOT find PkgConfig (missing: PKG_CONFIG_EXECUTABLE)`.      | `MacOS` >=14 using `python` 3.13 installed via `homebrew` | Install dependencies deprecated in `3.13` and latest MacOS versions via `brew install pkg-config`, delete the virtual environment folder and retry the `poetry install` command invocation.                                                                                                                                            | N/A                                                 |

package/dist/resources/knowledge/taxonomy/algokit:README.md

@@ -0,0 +1,70 @@
+<div align="center">
+<a href="https://github.com/algorandfoundation/algokit"><img src="https://bafybeickjkfl4mbrhmgr67kentvjr3meixppy2ziqyvpjpkvrlyjacjvua.ipfs.nftstorage.link/"></a>
+</div>
+
+<br/>
+<div align="center">
+Welcome to the AlgoKit Developer Universe repo, the one-stop shop for all <a href="https://github.com/algorandfoundation/algokit-cli#what-is-algokit"> AlgoKit</a> related repositories and information
+</div>
+<br/>
+<p align="center">
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-cli"><img src="https://img.shields.io/badge/algokit-cli-00dc94?logo=algorand&mac=flat.svg" /></a>
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-utils-py#readme"><img src="https://img.shields.io/badge/algokit-utils-00dc94?logo=python&mac=flat.svg" /></a>
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-utils-ts#algokit-typescript-utilities"><img src="https://img.shields.io/badge/algokit-utils-00dc94?logo=typescript&mac=flat.svg" /></a>
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-client-generator-py"><img src="https://img.shields.io/badge/algokit-client generator-00dc94?logo=python&mac=flat.svg" /></a>
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-client-generator-ts"><img src="https://img.shields.io/badge/algokit-client generator-00dc94?logo=typescript&mac=flat.svg" /></a>
+
+</p>
+
+### AlgoKit CLI  
+<img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/algokit?logo=pypi"> <img alt="GitHub Repo stars" src="https://img.shields.io/github/stars/algorandfoundation/algokit-cli?logo=github">
+
+AlgoKit CLI is the one-stop shop tool for developers building on the [Algorand network](https://www.algorand.com/).
+
+AlgoKit gets developers of all levels up and running with a familiar, fun and productive development environment in minutes. The goal of AlgoKit is to help developers build and launch secure, automated production-ready applications rapidly.
+
+[Repo](https://github.com/algorandfoundation/algokit-cli) | [Quick Start Tutorial](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/tutorials/intro.md) | [Documentation](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md)
+
+>[!NOTE] 
+> By using the AlgoKit cli you will use all the below listed packages, no need to install them separately
+
+### Algorand Python
+Algorand Python is a semantically and syntactically compatible, typed Python language that works with standard Python tooling and allows you to express smart contracts (apps) and smart signatures (logic signatures) for deployment on the Algorand Virtual Machine (AVM). [See how to get started](https://github.com/algorandfoundation/puya).
+
+### AlgoKit Utils 
+A set of core Algorand utilities available in both Python and TypeScript that make it easier to build solutions on Algorand.
+
+The goal of this library is to provide intuitive, productive utility functions that make it easier, quicker and safer to build applications on Algorand. Largely these functions wrap the underlying Algorand SDK, but provide a higher level interface with sensible defaults and capabilities for common tasks.
+
+##### Python 
+<img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/algokit-utils?logo=pypi">
+
+[Repo](https://github.com/algorandfoundation/algokit-utils-py#readme) | [Documentation](https://algorandfoundation.github.io/algokit-utils-py/html/index.html) 
+
+
+##### TypeScript 
+<img alt="npm" src="https://img.shields.io/npm/dm/%40algorandfoundation/algokit-utils?logo=npm">
+
+[Repo](https://github.com/algorandfoundation/algokit-utils-ts#algokit-typescript-utilities) | [Documentation](https://github.com/algorandfoundation/algokit-utils-ts/tree/main/docs)
+
+### Client Generators
+This project generates a type-safe smart contract client in both Python TypeScript for the Algorand Blockchain that wraps the [application client](https://github.com/algorandfoundation/algokit-utils-ts/blob/main/docs/capabilities/app-client.md) in AlgoKit Utils. It does this by reading an [ARC-0032](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application spec file.
+
+##### Python 
+<img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/algokit-client-generator?logo=pypi">
+
+[Repo](https://github.com/algorandfoundation/algokit-client-generator-py) | [Examples](https://github.com/algorandfoundation/algokit-client-generator-py/tree/main/examples) 
+
+
+##### TypeScript 
+<img alt="npm" src="https://img.shields.io/npm/dm/%40algorandfoundation/algokit-client-generator?logo=npm">
+
+[Repo](https://github.com/algorandfoundation/algokit-client-generator-ts) | [Examples](https://github.com/algorandfoundation/algokit-client-generator-ts/tree/main/examples)
+
+### AVM Debugger
+The AlgoKit AVM VS Code debugger extension provides a convenient way to debug any Algorand Smart Contracts written in TEAL
+[more info](https://marketplace.visualstudio.com/items?itemName=AlgorandFoundation.algokit-avm-vscode-debugger)
+
+### TestNet Dispenser
+The AlgoKit TestNet Dispenser API provides functionalities to interact with the Dispenser service. This service enables users to fund and refund assets, testnet Algos only for now.
+[Documentation](./docs/testnet_api.md) 

package/dist/resources/knowledge/taxonomy/algokit:cli:algokit.md

@@ -0,0 +1,52 @@
+# AlgoKit
+
+The Algorand AlgoKit CLI is the one-stop shop tool for developers building on the Algorand network. The goal of AlgoKit is to help developers build and launch secure, automated production-ready applications rapidly.
+
+## AlgoKit CLI commands
+
+For details on how to use individual features see the following
+
+- [Bootstrap](./features/project/bootstrap.md) - Bootstrap AlgoKit project dependencies
+- [Compile](./features/compile.md) - Compile Algorand Python code
+- [Completions](./features/completions.md) - Install shell completions for AlgoKit
+- [Deploy](./features/project/deploy.md) - Deploy your smart contracts effortlessly to various networks
+- [Dispenser](./features/dispenser.md) - Fund your TestNet account with ALGOs from the AlgoKit TestNet Dispenser
+- [Doctor](./features/doctor.md) - Check AlgoKit installation and dependencies
+- [Explore](./features/explore.md) - Explore Algorand Blockchains using lora
+- [Generate](./features/generate.md) - Generate code for an Algorand project
+- [Goal](./features/goal.md) - Run the Algorand goal CLI against the AlgoKit Sandbox
+- [Init](./features/init.md) - Quickly initialize new projects using official Algorand Templates or community provided templates
+- [LocalNet](./features/localnet.md) - Manage a locally sandboxed private Algorand network
+- [Project](./features/project.md) - Manage an AlgoKit project workspace on your file system
+- [Tasks](./features/tasks.md) - Perform a variety of useful operations on the Algorand blockchain
+
+## Common AlgoKit CLI options
+
+AlgoKit has a number of global options that can impact all commands. Note: these global options must be appended to `algokit` and appear before a command, e.g. `algokit -v localnet start`, but not `algokit localnet start -v`. The exception to this is `-h`, which can be appended to any command or sub-command to see contextual help information.
+
+- `-h, --help` The help option can be used on any command to get details on any command, its sub-commands and options.
+- `-v, --verbose` Enables DEBUG logging, useful when troubleshooting or if you want to peek under the covers and learn what AlgoKit CLI is doing.
+- `--color / --no-color` Enables or disables output of console styling, we also support the [NO_COLOR](https://no-color.org) environment variable.
+- `--skip-version-check` Skips updated AlgoKit version checking and prompting for that execution, this can also be disabled [permanently on a given machine](./cli/index.md#version-prompt) with `algokit config version-prompt disable`.
+
+See also the [AlgoKit CLI Reference](./cli/index.md), which details every command, sub-command and option.
+
+## AlgoKit Tutorials
+
+The following tutorials guide you through various scenarios:
+
+- [AlgoKit quick start](./tutorials/intro.md)
+- [Creating AlgoKit templates](./tutorials/algokit-template.md)
+
+## Guiding Principles
+
+AlgoKit is guided by the following solution principles which flow through to the applications created by developers.
+
+1. **Cohesive developer tool suite**: Using AlgoKit should feel professional and cohesive, like it was designed to work together, for the developer; not against them. Developers are guided towards delivering end-to-end, high quality outcomes on MainNet so they and Algorand are more likely to be successful.
+2. **Seamless onramp**: New developers have a seamless experience to get started and they are guided into a pit of success with best practices, supported by great training collateral; you should be able to go from nothing to debugging code in 5 minutes.
+3. **Leverage existing ecosystem**: AlgoKit functionality gets into the hands of Algorand developers quickly by building on top of the existing ecosystem wherever possible and aligned to these principles.
+4. **Sustainable**: AlgoKit should be built in a flexible fashion with long-term maintenance in mind. Updates to latest patches in dependencies, Algorand protocol development updates, and community contributions and feedback will all feed in to the evolution of the software.
+5. **Secure by default**: Include defaults, patterns and tooling that help developers write secure code and reduce the likelihood of security incidents in the Algorand ecosystem. This solution should help Algorand be the most secure Blockchain ecosystem.
+6. **Extensible**: Be extensible for community contribution rather than stifling innovation, bottle-necking all changes through the Algorand Foundation and preventing the opportunity for other ecosystems being represented (e.g. Go, Rust, etc.). This helps make developers feel welcome and is part of the developer experience, plus it makes it easier to add features sustainably.
+7. **Meet developers where they are**: Make Blockchain development mainstream by giving all developers an idiomatic development experience in the operating system, IDE and language they are comfortable with so they can dive in quickly and have less they need to learn before being productive.
+8. **Modular components**: Solution components should be modular and loosely coupled to facilitate efficient parallel development by small, effective teams, reduced architectural complexity and allowing developers to pick and choose the specific tools and capabilities they want to use based on their needs and what they are comfortable with.

package/dist/resources/knowledge/taxonomy/algokit:cli:architecture-decisions:2022-11-14_sandbox-approach.md

@@ -0,0 +1,94 @@
+# AlgoKit sandbox approach
+
+- **Status**: Approved
+- **Owner:** Rob Moore
+- **Deciders**: Anne Kenyon (Algorand Inc.), Alessandro Cappellato (Algorand Foundation), Will Winder (Algorand Inc.)
+- **Date created**: 2022-11-14
+- **Date decided:** 2022-11-14
+- **Date updated**: 2022-11-16
+
+## Context
+
+In order for AlgoKit to facilitate a productive development experience it needs to provide a managed Algorand sandbox experience. This allows developers to run an offline (local-only) private instance of Algorand that they can privately experiment with, run automated tests against and reset at will.
+
+## Requirements
+
+- The sandbox works cross-platform (i.e. runs natively on Windows, Mac and Linux)
+- You can spin up algod and indexer since both have useful use cases when developing
+- The sandbox is kept up to date with the latest version of algod / indexer
+- There is access to KMD so that you can programmatically fund accounts to improve the developer experience and reduce manual effort
+- There is access to the tealdbg port outside of algod so you can attach a debugger to it
+- The sandbox is isolated and (once running) works offline so the workload is private, allows development when there is no internet (e.g. when on a plane) and allows for multiple instances to be run in parallel (e.g. when developing multiple independent projects simultaneously)
+- Works in continuous integration and local development environments so you can facilitate automated testing
+
+## Principles
+
+- **[AlgoKit Guiding Principles](../../docs/algokit.md#Guiding-Principles)** - specifically Seamless onramp, Leverage existing ecosystem, Meet devs where they are
+- **Lightweight** - the solution should have as low an impact as possible on resources on the developers machine
+- **Fast** - the solution should start quickly, which makes for a nicer experience locally and also allows it to be used for continuous integration automation testing
+
+## Options
+
+### Option 1 - Pre-built DockerHub images
+
+Pre-built application developer-optimised DockerHub images that work cross-platform; aka an evolved AlgoKit version of <https://github.com/MakerXStudio/algorand-sandbox-dev>.
+
+**Pros**
+
+- It's quick to download the images and quick to start the container since you don't need to compile Algod / indexer and the images are optimised for small size
+- The only dependency needed is Docker, which is a fairly common dependency for most developers to use these days
+- The images are reasonably lightweight
+- The images provide an optimised application developer experience with: (devmode) algo, KMD, tealdbg, indexer
+- It natively works cross-platform
+
+**Cons**
+
+- Some people have reported problems running WSL 2 on a small proportion of Windows environments (to get the latest Docker experience)
+- Docker within Docker can be a problem in some CI environments that run agents on Docker in the first place
+- Work needs to be done to create an automated CI/CD that automatically releases new versions to keep it up to date with latest algod/indexer versions
+
+### Option 2 - Lightweight algod client implementation
+
+Work with the Algorand Inc. team to get a lightweight algod client that can run outside of a Docker container cross-platform.
+
+**Pros**
+
+- Likely to be the most lightweight and fastest option - opening up better/easier isolated/parallelised automated testing options
+- Wouldn't need Docker as a dependency
+
+**Cons**
+
+- Indexer wouldn't be supported (Postgres would require Docker anyway)
+- Algorand Inc. does not distribute Windows binaries.
+
+### Option 3 - Sandbox
+
+Use the existing [Algorand Sandbox](https://github.com/algorand/sandbox).
+
+**Pros**
+
+- Implicitly kept up to date with Algorand - no extra thing to maintain
+- Battle-tested by the core Algorand team day-in-day-out
+- Supports all environments including unreleased feature branches (because it can target a git repo / commit hash)
+
+**Cons**
+
+- Sandbox is designed for network testing, not application development - it's much more complex than the needs of application developers
+- Slow to start because it has to download and built algod and indexer (this is particularly problematic for ephemeral CI/CD build agents)
+- It's not cross-platform (it requires bash to run sandbox.sh, although a sandbox.ps1 version could be created)
+
+## Preferred option
+
+Option 1 and Option 2.
+
+Option 1 provides a fully-featured experience that will work great in most scenarios, having option 2 as a second option would open up more advanced parallel automated testing scenarios in addition to that.
+
+## Selected option
+
+Option 1
+
+We're aiming to release the first version of AlgoKit within a short timeframe, which won't give time for Option 2 to be developed. Sandbox itself has been ruled out since it's not cross-platform and is too slow for both development and continuous integration.
+
+Option 1 also results in a similar result to running Sandbox, so existing Algorand documentation, libraries and approaches should work well with this option making it a good slot-in replacement for Sandbox for application developers.
+
+AlgoKit is designed to be modular: we can add in other approaches over time such as Option 2 when/if it becomes available.

package/dist/resources/knowledge/taxonomy/algokit:cli:architecture-decisions:2022-11-22_beaker-testing-strategy.md

@@ -0,0 +1,95 @@
+# Beaker testing strategy
+
+- **Status**: Draft
+- **Owner:** Rob Moore
+- **Deciders**: Anne Kenyon (Algorand Inc.), Alessandro Cappellato (Algorand Foundation), Michael Diamant (Algorand Inc.), Benjamin Guidarelli (Algorand Foundation)
+- **Date created**: 2022-11-22
+- **Date decided:** TBD
+- **Date updated**: 2022-11-28
+
+## Context
+
+AlgoKit will be providing a smart contract development experience built on top of [PyTEAL](https://pyteal.readthedocs.io/en/stable/) and [Beaker](https://developer.algorand.org/articles/hello-beaker/). Beaker is currently in a pre-production state and needs to be productionised to provide confidence for use in generating production-ready smart contracts by AlgoKit users. One of the key things to resolve to productionisation of Beaker is to improve the automated test coverage.
+
+Beaker itself is currently split into the PyTEAL generation related code and the deployment and invocation related code (including interacting with Sandbox). This decision is solely focussed on the PyTEAL generation components of Beaker. The current automated test coverage of this part of the codebase is ~50% and is largely based on compiling and/or executing smart contracts against Algorand Sandbox. While it's generally not best practice to try and case a specific code coverage percentage, a coverage of ~80%+ is likely indicative of good coverage in a dynamic language such as Python.
+
+The Sandbox tests provide a great deal of confidence, but are also slow to execute, which can potentially impair Beaker development and maintenance experience, especially as the coverage % is grown and/or features are added over time.
+
+Beaker, like PyTEAL, can be considered to be a transpiler on top of TEAL. When generating smart contracts, the individual TEAL opcodes are significant, since security audits will often consider the impact at that level, and it can have impacts on (limited!) resource usage of the smart contract. As such, "output stability" is potentially an important characteristic to test for.
+
+## Requirements
+
+- We have a high degree of confidence that writing smart contracts in Beaker leads to expected results for production smart contracts
+- We have reasonable regression coverage so features are unlikely to break as new features and refactorings are added over time
+- We have a level of confidence in the "output stability" of the TEAL code generated from a Beaker smart contract
+
+## Principles
+
+- **Fast development feedback loops** - The feedback loop during normal development should be as fast as possible to improve the development experience of developing Beaker itself
+- **Low overhead** - The overhead of writing and maintaining tests is as low as possible; tests should be quick to read and write
+- **Implementation decoupled** - Tests aren't testing the implementation details of Beaker, but rather the user-facing experience and output of it; this reduces the likelihood of needing to rewrite tests when performing refactoring of the codebase
+
+## Options
+
+### Option 1: TEAL Approval tests
+
+Writing [approval tests](https://approvaltests.com/) of the TEAL output generated from a given Beaker smart contract.
+
+**Pros**
+
+- Ensures TEAL output stability and focussing on asserting the output of Beaker rather than testing whether Algorand Protocol is working
+- Runs in-memory/in-process so will execute in low 10s of milliseconds making it easy to provide high coverage with low developer feedback loop overhead
+- Tests are easy to write - the assertion is a single line of code (no tedious assertions)
+- The tests go from Beaker contract -> TEAL approval so don't bake implementation detail and thus allow full Beaker refactoring with regression confidence without needing to modify the tests
+- Excellent regression coverage characteristics - fast test run and quick to write allows for high coverage and anchoring assertions to TEAL output is a very clear regression marker
+
+**Cons**
+
+- The tests rely on the approver to understand the TEAL opcodes that are emitted and verify they match the intent of the Beaker contract - anecdotally this can be difficult at times even for experienced (Py)TEAL developers
+- Doesn't assert the correctness of the TEAL output, just that it matches the previously manually approved output
+
+### Option 2: Sandbox compile tests
+
+Writing Beaker smart contracts and checking that the TEAL output successfully compiles against algod.
+
+**Pros**
+
+- Ensures that the TEAL output compiles, giving some surety about the intactness of it and focussing on asserting the output of Beaker rather than testing whether Algorand Protocol is working
+- Faster than executing the contract
+- Tests are easy to write - the assertion is a single line of code (no tedious assertions)
+
+**Cons**
+
+- Order of magnitude slower than asserting TEAL output (out of process communication)
+- Doesn't assert the correctness of the TEAL output, just that it compiles
+
+### Option 3: Sandbox execution tests
+
+Execute the smart contracts and assert the output is as expected. This can be done using dry run and/or actual transactions.
+
+**Pros**
+
+- Asserts that the TEAL output _executes_ correctly giving the highest confidence
+- Doesn't require the test writer to understand the TEAL output
+- Tests don't bake implementation detail and do assert on output so give a reasonable degree of refactoring confidence without modifying tests
+
+**Cons**
+
+- Tests are more complex to write
+- Tests take an order of magnitude longer to run than just compilation (two orders of magnitude to run than checking TEAL output)
+- Harder to get high regression coverage since it's slower to write and run the tests making it impractical to get full coverage
+- Doesn't ensure output stability
+- Is testing that the Algorand Protocol itself works (TEAL `x` when executed does `y`) so the testing scope is broader than just Beaker itself
+
+## Preferred option
+
+Option 1 (combined with Option 2 to ensure the approved TEAL actually compiles, potentially only run on CI by default to ensure fast local dev loop) for the bulk of testing to provide a rapid feedback loop for developers as well as ensuring output stability and great regression coverage.
+
+## Selected option
+
+Combination of option 1, 2 and 3:
+
+- While Option 1 + 2 provides high confidence with fast feedback loop, it relies on the approver being able to determine the TEAL output does what they think it does, which isn't always the case
+- Option 3 will be used judiciously to provide that extra level of confidence that the fundamentals of the Beaker output are correct for each main feature; this will involve key scenarios being tested with execution based tests, the goal isn't to get combinatorial coverage, which would be slow and time-consuming, but to give a higher degree of confidence
+- The decision of when to use Option 3 as well as Option 1+2 will be made on a per-feature basis and reviewed via pull request, over time a set of principles may be able to be revised that outline a clear delineation
+- Use of PyTest markers to separate execution so by default the dev feedback loop is still fast, but the full suite is always run against pull requests and merges to main