@goplausible/algorand-mcp 3.0.7

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

@@ -0,0 +1,122 @@
+# AlgoKit Init
+
+The `algokit init` [command](../cli/index.md#init) is used to quickly initialize new projects using official Algorand Templates or community provided templates. It supports a fully guided command line wizard experience, as well as fully scriptable / non-interactive functionality via command options.
+
+## Quick start
+
+For a quick start template with all of the defaults you can run: `algokit init` which will interactively guide you through picking the right stack to build your AlgoKit project. Afterwards, you should immediately be able to hit F5 to compile the hello world smart contract to the `smart_contracts/artifacts` folder (with breakpoint debugging - try setting a breakpoint in `smart_contracts/helloworld.py`) and open the `smart_contracts/helloworld.py` file and get linting, automatic formatting and syntax highlighting.
+
+## Prerequisites
+
+Git is a prerequisite for the init command as it is used to clone templates and initialize git repos. Please consult the [README](../../README.md#prerequisites) for installation instructions.
+
+## Functionality
+
+As outlined in [quick start](#quick-start), the simplest use of the command is to just run `algokit init` and you will then be guided through selecting a template and configuring options for that template. e.g.
+
+```
+$ ~ algokit init
+? Which of these options best describes the project you want to start? `Smart Contract` | `Dapp Frontend` | `Smart Contract & Dapp Frontend` | `Custom`
+? Name of project / directory to create the project in:  my-cool-app
+```
+
+Once above 2 questions are answered, the `cli` will start instantiating the project and will start asking questions specific to the template you are instantiating. By default official templates such as `python`, `fullstack`, `react`, `python` include a notion of a `preset`. If you want to skip all questions and let the tool preset the answers tailored for a starter project you can pick `Starter`, for a more advanced project that includes unit tests, CI automation and other advanced features, pick `Production`. Lastly, if you prefer to modify the experience and tailor the template to your needs, pick the `Custom` preset.
+
+If you want to accept the default for each option simply hit [enter] or alternatively to speed things up you can run `algokit init --defaults` and they will be auto-accepted.
+
+### Workspaces vs Standalone Projects
+
+AlgoKit supports two distinct project structures: Workspaces and Standalone Projects. This flexibility allows developers to choose the most suitable approach for their project's needs.
+
+To initialize a project within a workspace, use the `--workspace` flag. If a workspace does not already exist, AlgoKit will create one for you by default (unless you disable it via `--no-workspace` flag). Once established, new projects can be added to this workspace, allowing for centralized management.
+
+To create a standalone project, use the `--no-workspace` flag during initialization. This instructs AlgoKit to bypass the workspace structure and set up the project as an isolated entity.
+
+For more details on workspaces and standalone projects, refer to the [AlgoKit Project documentation](./project.md#workspaces-vs-standalone-projects).
+
+## Bootstrapping
+
+You will also be prompted if you wish to run the [bootstrap](../cli/index.md#bootstrap) command, this is useful if you plan to immediately begin developing in the new project. If you passed in `--defaults` or `--bootstrap` then it will automatically run bootstrapping unless you passed in `--no-bootstrap`.
+
+```
+
+? Do you want to run `algokit bootstrap` to bootstrap dependencies for this new project so it can be run immediately? Yes
+Installing Python dependencies and setting up Python virtual environment via Poetry
+poetry: Creating virtualenv my-smart-contract in /Users/algokit/algokit-init/my-smart-contract/.venv
+poetry: Updating dependencies
+poetry: Resolving dependencies...
+poetry:
+poetry: Writing lock file
+poetry:
+poetry: Package operations: 53 installs, 0 updates, 0 removals
+poetry:
+poetry: • Installing pycparser (2.21)
+
+---- other output omitted for brevity ----
+
+poetry: • Installing ruff (0.0.171)
+Copying /Users/algokit/algokit-init/my-smart-contract/smart_contracts/.env.template to /Users/algokit/algokit-init/my-smart-contract/smart_contracts/.env and prompting for empty values
+? Would you like to initialise a git repository and perform an initial commit? Yes
+🎉 Performed initial git commit successfully! 🎉
+🙌 Project initialized at `my-smart-contract`! For template specific next steps, consult the documentation of your selected template 🧐
+Your selected template comes from:
+➡️ https://github.com/algorandfoundation/algokit-python-template
+As a suggestion, if you wanted to open the project in VS Code you could execute:
+
+> cd my-smart-contract && code .
+
+```
+
+After bootstrapping you are also given the opportunity to initialize a git repo, upon successful completion of the init command the project is ready to be used. If you pass in `--git` it will automatically initialise the git repository and if you pass in `--no-git` it won't.
+
+> Please note, when using `--no-workspaces`, algokit init will assume a max lookup depth of 1 for a fresh template based project. Otherwise it will assume a max depth of 2, since default algokit workspace structure is at most 2 levels deep.
+
+## Options
+
+There are a number of options that can be used to provide answers to the template prompts. Some of the options requiring further explanation are detailed below, but consult the CLI reference for all available [options](../cli/index.md#init).
+
+## Community Templates
+
+As well as the official Algorand templates shown when running the init command, community templates can also be provided by providing a URL via the prompt or the `--template-url` option.
+
+e.g. `algokit init --template-url https://github.com/algorandfoundation/algokit-python-template` (that being the url of the official python template, the same as `algokit init -t python`).
+
+The `--template-url` option can be combined with `--template-url-ref` to specify a specific commit, branch or tag
+
+e.g. `algokit init --template-url https://github.com/algorandfoundation/algokit-python-template --template-url-ref 0232bb68a2f5628e910ee52f62bf13ded93fe672`
+
+If the URL is not an official template there is a potential security risk and so to continue you must either acknowledge this prompt, or if you are in a non-interactive environment you can pass the `--UNSAFE-SECURITY-accept-template-url` option (but we generally don't recommend this option so users can review the warning message first) e.g.
+
+```
+
+Community templates have not been reviewed, and can execute arbitrary code.
+Please inspect the template repository, and pay particular attention to the values of \_tasks, \_migrations and \_jinja_extensions in copier.yml
+? Continue anyway? Yes
+
+```
+
+If you want to create a community template, you can use the [AlgoKit guidelines on template building](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/tutorials/algokit-template.md#creating-algokit-templates) and [Copier documentation](https://copier.readthedocs.io/en/stable/) as a starting point.
+
+## Template Answers
+
+Answers to specific template prompts can be provided with the `--answer {key} {value}` option, which can be used multiple times for each prompt. Quotes can be used for values with spaces e.g. `--answer author_name "Algorand Foundation"`.
+
+To find out the key for a specific answer you can either look at `.algokit/.copier-answers.yml` in the root folder of a project created via `algokit init` or in the `copier.yaml` file of a template repo e.g. for the [python template](https://github.com/algorandfoundation/algokit-python-template/blob/main/copier.yaml).
+
+## Non-interactive project initialization
+
+By combining a number of options, it is possible to initialize a new project without any interaction. For example, to create a project named `my-smart-contract` using the `python` template with no git, no bootstrapping, the author name of `Algorand Foundation`, and defaults for all other values, you could execute the following:
+
+```
+
+$ ~ algokit init -n my-smart-contract -t python --no-git --no-bootstrap --answer author_name "Algorand Foundation" --defaults
+🙌 Project initialized at `my-smart-contract`! For template specific next steps, consult the documentation of your selected template 🧐
+Your selected template comes from:
+➡️ https://github.com/algorandfoundation/algokit-python-template
+As a suggestion, if you wanted to open the project in VS Code you could execute:
+
+> cd my-smart-contract && code .
+
+```
+
+For more details about the `AlgoKit init` command, please refer to the [AlgoKit CLI reference documentation](../cli/index.md#init).

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

@@ -0,0 +1,191 @@
+# AlgoKit LocalNet
+
+The AlgoKit LocalNet feature allows you to manage (start, stop, reset, manage) a locally sandboxed private Algorand network. This allows you to interact and deploy changes against your own Algorand network without needing to worry about funding TestNet accounts, information you submit being publicly visible or being connected to an active Internet connection (once the network has been started).
+
+AlgoKit LocalNet uses Docker images that are optimised for a great dev experience. This means the Docker images are small and start fast. It also means that features suited to developers are enabled such as KMD (so you can programmatically get faucet private keys).
+
+The philosophy we take with AlgoKit LocalNet is that you should treat it as an ephemeral network. This means assume it could be reset at any time - don't store data on there that you can't recover / recreate. We have optimised the AlgoKit LocalNet experience to minimise situations where the network will get reset to improve the experience, but it can and will still happen in a number of situations.
+
+> For details on executing `algokit localnet` without `docker` or `podman` refer to the [codespaces](#codespaces) section.
+
+## Prerequisites
+
+AlgoKit LocalNet relies on Docker and Docker Compose being present and running on your system. Alternatively, you can use Podman as a replacement for Docker see [Podman support](#podman-support).
+
+You can install Docker by following the [official installation instructions](https://docs.docker.com/get-docker/). Most of the time this will also install Docker Compose, but if not you can [follow the instructions](https://docs.docker.com/compose/install/) for that too.
+
+If you are on Windows then you will need WSL 2 installed first, for which you can find the [official installation instructions](https://learn.microsoft.com/en-us/windows/wsl/install). If you are using Windows 10 then ensure you are on the latest version to reduce likelihood of installation problems.
+
+Alternatively, the Windows 10/11 Pro+ supported [Hyper-V backend](https://docs.docker.com/desktop/install/windows-install/) for Docker can be used instead of the WSL 2 backend.
+
+### Podman support
+
+If you prefer to use [Podman](https://podman.io/) as your container engine, make sure to install and configure Podman first. Then you can set the default container engine that AlgoKit will use, by running: `algokit config container-engine podman`. See [Container-based LocalNet](#container-based-localnet) for more details.
+
+## Known issues
+
+The AlgoKit LocalNet is built with 30,000 participation keys generated and after 30,000 rounds is reached it will no longer be able to add rounds. At this point you can simply reset the LocalNet to continue development. Participation keys are slow to generate hence why they are pre-generated to improve experience.
+
+## Supported operating environments
+
+We rely on the official Algorand docker images for Indexer, Conduit and Algod, which means that AlgoKit LocalNet is supported on Windows, Linux and Mac on Intel and AMD chipsets (including Apple Silicon).
+
+## Container-based LocalNet
+
+AlgoKit cli supports both [Docker](https://www.docker.com/) and [Podman](https://podman.io/) as container engines. While `docker` is used by default, executing the below:
+
+```
+algokit config container-engine
+# or
+algokit config container-engine podman|docker
+```
+
+Will set the default container engine to use when executing `localnet` related commands via `subprocess`.
+
+### Creating / Starting the LocalNet
+
+To create / start your AlgoKit LocalNet instance you can run `algokit localnet start`. This will:
+
+- Detect if you have Docker and Docker Compose installed
+- Detect if you have the Docker engine running
+- Create a new Docker Compose deployment for AlgoKit LocalNet if it doesn't already exist
+- (Re-)Start the containers
+
+You can also specify additional options:
+
+- `--name`: Specify a name for a custom LocalNet instance. This allows you to have multiple LocalNet configurations. Refer to [Named LocalNet Configuration Directory](#named-localnet-configuration-directory) for more details.
+- `--config-dir`: Specify a custom configuration directory for the LocalNet.
+- `--dev/--no-dev`: Control whether to launch 'algod' in developer mode or not. Defaults to 'yes' (developer mode enabled).
+
+If it's the first time running it on your machine then it will download the following images from DockerHub:
+
+- [`algorand/algod`](https://hub.docker.com/r/algorand/algod) (~500 MB)
+- [`algorand/indexer`](https://hub.docker.com/r/algorand/indexer) (~96 MB)
+- [`algorand/conduit`](https://hub.docker.com/r/algorand/conduit) (~98 MB)
+- [`postgres:13-alpine`](https://hub.docker.com/_/postgres) (~80 MB)
+
+Once they have downloaded, it won't try and re-download images unless you perform a `algokit localnet reset`.
+
+Once the LocalNet has started, the following endpoints will be available:
+
+- [algod](https://developer.algorand.org/docs/rest-apis/algod/v2/):
+  - address: <http://localhost:4001>
+  - token: `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`
+- [kmd](https://developer.algorand.org/docs/rest-apis/kmd/):
+  - address: <http://localhost:4002>
+  - token: `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`
+- [indexer](https://developer.algorand.org/docs/rest-apis/indexer/):
+  - address: <http://localhost:8980>
+- tealdbg port:
+  - address: <http://localhost:9392>
+
+### Creating / Starting a Named LocalNet
+
+AlgoKit manages the default LocalNet environment and automatically keeps the configuration updated with any upstream changes. As a result, configuration changes are reset automatically by AlgoKit, so that developers always have access to a known good LocalNet configuration. This works well for the majority of scenarios, however sometimes developers need the control to make specific configuration changes for specific scenarios.
+
+When you want more control, named LocalNet instances can be used by running `algokit localnet start --name {name}`. This command will set up and run a named LocalNet environment (based off the default), however AlgoKit will not update the environment or configuration automatically. From here developers are able to modify their named environment in any way they like, for example setting `DevMode: false` in `algod_network_template.json`.
+
+Once you have a named LocalNet running, the AlgoKit LocalNet commands will target this instance.
+If at any point you'd like to switch back to the default LocalNet, simply run `algokit localnet start`.
+
+### Specifying a custom LocalNet configuration directory
+
+You can specify a custom LocalNet configuration directory by using the `--config-dir` option or by setting the `ALGOKIT_LOCALNET_CONFIG_DIR` environment variable. This allows you to have multiple LocalNet instances with different configurations in different directories, which is useful in 'CI/CD' scenarios where you can save your custom localnet in your version control and then run `algokit localnet start --config-dir /path/to/custom/config` to use it within your pipeline.
+
+For example, to create a LocalNet instance with a custom configuration directory, you can run:
+
+```
+algokit localnet start --config-dir /path/to/custom/config
+```
+
+### Named LocalNet Configuration Directory
+
+When running `algokit localnet start --name {name}`, AlgoKit stores configuration files in a specific directory on your system. The location of this directory depends on your operating system:
+
+- **Windows**: We use the value of the `APPDATA` environment variable to determine the directory to store the configuration files. This is usually `C:\Users\USERNAME\AppData\Roaming`.
+- **Linux or Mac**: We use the value of the `XDG_CONFIG_HOME` environment variable to determine the directory to store the configuration files. If `XDG_CONFIG_HOME` is not set, the default location is `~/.config`.
+
+Assuming you have previously used a default LocalNet, the path `./algokit/sandbox/` will exist inside the configuration directory, containing the configuration settings for the default LocalNet instance. Additionally, for each named LocalNet instance you have created, the path `./algokit/sandbox_{name}/` will exist, containing the configuration settings for the respective named LocalNet instances.
+
+It is important to note that only the configuration files for a named LocalNet instance should be changed. Any changes made to the default LocalNet instance will be reverted by AlgoKit.
+
+You can use `--name` flag along with `--config-dir` option to specify a custom path for the LocalNet configuration directory. This allows you to manage multiple LocalNet instances with different configurations in different directories on your system.
+
+### Controlling Algod Developer Mode
+
+By default, AlgoKit LocalNet starts algod in developer mode. This mode enables certain features that are useful for development but may not reflect the behavior of a production network. You can control this setting using the `--dev/--no-dev` flag when starting the LocalNet:
+
+```bash
+algokit localnet start --no-dev  # Starts algod without developer mode
+algokit localnet start --dev     # Starts algod with developer mode (default)
+```
+
+If you change this setting for an existing LocalNet instance, AlgoKit will prompt you to restart the LocalNet to apply the changes.
+
+### Stopping and Resetting the LocalNet
+
+To stop the LocalNet you can execute `algokit localnet stop`. This will turn off the containers, but keep them ready to be started again in the same state by executing `algokit localnet start`.
+
+To reset the LocalNet you can execute `algokit localnet reset`, which will tear down the existing containers, refresh the container definition from the latest stored within AlgoKit and update to the latest Docker images. If you want to keep the same container spec and versions as you currently have, but quickly tear down and start a new instance then run `algokit localnet reset --no-update`.
+
+### Viewing transactions in the LocalNet
+
+You can see a web-based user interface of the current state of your LocalNet including all transactions by using the [AlgoKit Explore](./explore.md) feature, e.g. by executing `algokit localnet explore`.
+
+### Executing goal commands against AlgoKit LocalNet
+
+See the [AlgoKit Goal](./goal.md) feature. You can also execute `algokit localnet console` to open a [Bash shell which allows you to run the goal commandline](./goal.md#running-multiple-commands).
+
+Note: if you want to copy files into the container so you can access them via goal then you can use the following:
+
+```
+docker cp foo.txt algokit_algod:/root
+```
+
+### Getting access to the private key of the faucet account
+
+If you want to use the LocalNet then you need to get the private key of the initial wallet so you can transfer ALGOs out of it to other accounts you create.
+
+There are two ways to do this:
+
+**Option 1: Manually via goal**
+
+```
+algokit goal account list
+algokit goal account export -a {address_from_an_online_account_from_above_command_output}
+```
+
+**Option 2: Automatically via kmd API**
+
+Needing to do this manual step every time you spin up a new development environment or reset your LocalNet is frustrating. Instead, it's useful to have code that uses the Sandbox APIs to automatically retrieve the private key of the default account.
+
+AlgoKit Utils provides methods to help you do this:
+
+- TypeScript - [`ensureFunded`](https://github.com/algorandfoundation/algokit-utils-ts/blob/main/docs/capabilities/transfer.md#ensurefunded) and [`getDispenserAccount`](https://github.com/algorandfoundation/algokit-utils-ts/blob/main/docs/capabilities/transfer.md#dispenser)
+- Python - [`ensure_funded`](https://algorandfoundation.github.io/algokit-utils-py/html/apidocs/algokit_utils/algokit_utils.html#algokit_utils.ensure_funded) and [`get_dispenser_account`](https://algorandfoundation.github.io/algokit-utils-py/html/apidocs/algokit_utils/algokit_utils.html#algokit_utils.get_dispenser_account)
+
+For more details about the `AlgoKit localnet` command, please refer to the [AlgoKit CLI reference documentation](../cli/index.md#localnet).
+
+## GitHub Codespaces-based LocalNet
+
+The AlgoKit LocalNet feature also supports running the LocalNet in a GitHub Codespace with port forwarding by utilizing the [GitHub CLI](https://github.com/cli/gh). This allows you to run the LocalNet without the need to use Docker. This is especially useful for scenarios where certain hardware or software limitations may prevent you from being able to run Docker.
+
+To run the LocalNet in a GitHub Codespace, you can use the `algokit localnet codespace` command.
+By default without `--force` flag it will prompt you to delete stale codespaces created earlier (if any). Upon termination it will also prompt to delete the codespace that was used prior to termination.
+
+Running an interactive session ensures that you have control over the lifecycle of your Codespace, preventing unnecessary usage and potential costs. GitHub Codespaces offers a free tier with certain limits, which you can review in the [GitHub Codespaces documentation](https://docs.github.com/en/codespaces/overview#pricing).
+
+### Options
+
+- `-m`, `--machine`: Specifies the GitHub Codespace machine type to use. Defaults to `basicLinux32gb`. Available options are `basicLinux32gb`, `standardLinux32gb`, `premiumLinux`, and `largePremiumLinux`. Refer to [GitHub Codespaces documentation](https://docs.github.com/en/codespaces/overview/machine-types) for more details.
+- `-a`, `--algod-port`: Sets the port for the Algorand daemon. Defaults to `4001`.
+- `-i`, `--indexer-port`: Sets the port for the Algorand indexer. Defaults to `8980`.
+- `-k`, `--kmd-port`: Sets the port for the Algorand kmd. Defaults to `4002`.
+- `-n`, `--codespace-name`: Specifies the name of the codespace. Defaults to a random name with a timestamp.
+- `-t`, `--timeout`: Max duration for running the port forwarding process. Defaults to 1 hour. This timeout ensures the codespace **will automatically shut down** after the specified duration to prevent accidental overspending of free quota on GitHub Codespaces. [More details](https://docs.github.com/en/codespaces/setting-your-user-preferences/setting-your-timeout-period-for-github-codespaces).
+- `-r`, `--repo-url`: The URL of the repository to use. Defaults to the AlgoKit base template repository (`algorandfoundation/algokit-base-template`). The reason why algokit-base-template is used by default is due to [.devcontainer.json](https://github.com/algorandfoundation/algokit-base-template/blob/main/template_content/.devcontainer.json) which defines the scripts that take care of setting up AlgoKit CLI during container start. You can use any custom repo as a base, however it's important to ensure the reference [.devcontainer.json](https://github.com/algorandfoundation/algokit-base-template/blob/main/template_content/.devcontainer.json) file exists in your repository **otherwise there will be no ports to forward from the codespace**.
+- `--force`, `-f`: Force deletes stale codespaces and skips confirmation prompts. Defaults to explicitly prompting for confirmation.
+
+For more details about managing LocalNet in GitHub Codespaces, please refer to the [AlgoKit CLI reference documentation](../cli/index.md#codespace).
+
+> Tip: By specifying alternative port values it is possible to have several LocalNet instances running where one is using default ports via `algokit localnet start` with Docker | Podman and the other relies on port forwarding via `algokit localnet codespace`.

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

@@ -0,0 +1,95 @@
+# AlgoKit Project
+
+`algokit project` is a collection of commands and command groups useful for managing algokit compliant [project workspaces](./init.md#workspaces).
+
+## Overview
+
+The `algokit project` command group is designed to simplify the management of AlgoKit projects. It provides a suite of tools to initialize, deploy, link, list, and run various components within a project workspace. This command group ensures that developers can efficiently handle the lifecycle of their projects, from bootstrapping to deployment and beyond.
+
+### What is a Project?
+
+In the context of AlgoKit, a "project" refers to a structured standalone or monorepo workspace that includes all the necessary components for developing, testing, and deploying Algorand applications. This may include smart contracts, frontend applications, and any associated configurations. In the context of the CLI, the `algokit project` commands help manage these components cohesively.
+
+The orchestration between workspaces, standalone projects, and custom commands is designed to provide a seamless development experience. Below is a high-level overview of how these components interact within the AlgoKit ecosystem.
+
+```mermaid
+graph TD;
+A[`algokit project` command group] --> B["Workspace (.algokit.toml)"];
+A --> C["Standalone Project (.algokit.toml)"];
+B --> D["Sub-Project 1 (.algokit.toml)"];
+B --> E["Sub-Project 2 (.algokit.toml)"];
+C --> F["Custom Commands defined in .algokit.toml"];
+D --> F;
+E --> F;
+```
+
+- **AlgoKit Project**: The root command that encompasses all project-related functionalities.
+- **Workspace**: A root folder that is managing multiple related sub-projects.
+- **Standalone Project**: An isolated project structure for simpler applications.
+- **Custom Commands**: Commands defined by the user in the `.algokit.toml` and automatically injected into the `algokit project run` command group.
+
+### Workspaces vs Standalone Projects
+
+As mentioned, AlgoKit supports two distinct project structures: Workspaces and Standalone Projects. This flexibility allows developers to choose the most suitable approach for their project's needs.
+
+### Workspaces
+
+Workspaces are designed for managing multiple related projects under a single root directory. This approach is beneficial for complex applications that consist of multiple sub-projects, such as a smart contract and a corresponding frontend application. Workspaces help in organizing these sub-projects in a structured manner, making it easier to manage dependencies and shared configurations.
+
+To initialize a project within a workspace, use the `--workspace` flag. If a workspace does not already exist, AlgoKit will create one for you by default (unless you disable it via `--no-workspace` flag). Once established, new projects can be added to this workspace, allowing for centralized management.
+
+To mark your project as `workspace` fill in the following in your `.algokit.toml` file:
+
+```toml
+[project]
+type = 'workspace' # type specifying if the project is a workspace or standalone
+projects_root_path = 'projects' # path to the root folder containing all sub-projects in the workspace
+```
+
+#### VSCode optimizations
+
+AlgoKit has a set of minor optimizations for VSCode users that are useful to be aware of:
+
+- Templates created with the `--workspace` flag automatically include a VSCode code-workspace file. New projects added to an AlgoKit workspace are also integrated into an existing VSCode workspace.
+- Using the `--ide` flag with `init` triggers automatic prompts to open the project and, if available, the code workspace in VSCode.
+
+#### Handling of the `.github` Folder
+
+A key aspect of using the `--workspace` flag is how the `.github` folder is managed. This folder, which contains GitHub-specific configurations such as workflows and issue templates, is moved from the project directory to the root of the workspace. This move is necessary because GitHub does not recognize workflows located in subdirectories.
+
+Here's a simplified overview of what happens:
+
+1. If a `.github` folder is found in your project, its contents are transferred to the workspace's root `.github` folder.
+2. Files with matching names in the destination are not overwritten; they're skipped.
+3. The original `.github` folder is removed if it's left empty after the move.
+4. A notification is displayed, advising you to review the moved `.github` contents to ensure everything is in order.
+
+This process ensures that your GitHub configurations are properly recognized at the workspace level, allowing you to utilize GitHub Actions and other features seamlessly across your projects.
+
+### Standalone Projects
+
+Standalone projects are suitable for simpler applications or when working on a single component. This structure is straightforward, with each project residing in its own directory, independent of others. Standalone projects are ideal for developers who prefer simplicity or are focusing on a single aspect of their application and are sure that they will not need to add more sub-projects in the future.
+
+To create a standalone project, use the `--no-workspace` flag during initialization. This instructs AlgoKit to bypass the workspace structure and set up the project as an isolated entity.
+
+Both workspaces and standalone projects are fully supported by AlgoKit's suite of tools, ensuring developers can choose the structure that best fits their workflow without compromising on functionality.
+
+To mark your project as a standalone project fill in the following in your `.algokit.toml` file:
+
+```toml
+[project]
+type = {'backend' | 'contract' | 'frontend'} # currently support 3 generic categories for standalone projects
+name = 'my-project' # unique name for the project inside workspace
+```
+
+> We recommend using workspaces for most projects (hence enabled by default), as it provides a more organized and scalable approach to managing multiple sub-projects. However, standalone projects are a great choice for simple applications or when you are certain that you will not need to add more sub-projects in the future, for such cases simply append `--no-workspace` when using `algokit init` command. For more details on init command please refer to [init](./init.md) command docs.
+
+## Features
+
+Dive into the features of the `algokit project` command group:
+
+- [bootstrap](./project/bootstrap.md) - Bootstrap your project with AlgoKit.
+- [deploy](./project/deploy.md) - Deploy your smart contracts effortlessly to various networks.
+- [link](./project/link.md) - Powerful feature designed to streamline the integration between `frontend` and `contract` projects
+- [list](./project/list.md) - Enumerate all projects within an AlgoKit workspace.
+- [run](./project/run.md) - Define custom commands and manage their execution via `algokit` cli.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:project:bootstrap.md

@@ -0,0 +1,128 @@
+# AlgoKit Project Bootstrap
+
+The AlgoKit Project Bootstrap feature allows you to bootstrap different project dependencies by looking up specific files in your current directory and immediate sub directories by convention.
+
+This is useful to allow for expedited initial setup for each developer e.g. when they clone a repository for the first time. It's also useful to provide a quick getting started experience when initialising a new project via [AlgoKit Init](./init.md) and meeting our goal of "nothing to debugging code in 5 minutes".
+
+It can bootstrap one or all of the following (with other options potentially being added in the future):
+
+- Python Poetry projects - Installs Poetry via pipx if its not present and then runs `poetry install`
+- Node.js project - Checks if npm is installed and runs `npm install`
+- dotenv (.env) file - Checks for `.env.template` files, copies them to `.env` (which should be in `.gitignore` so developers can safely make local specific changes) and prompts for any blank values (so the developer has an easy chance to fill in their initial values where there isn't a clear default).
+
+> **Note**: Invoking bootstrap from `algokit bootstrap` is not recommended. Please prefer using `algokit project bootstrap` instead.
+
+## Usage
+
+Available commands and possible usage as follows:
+
+```
+$ ~ algokit project bootstrap
+Usage: algokit project bootstrap [OPTIONS] COMMAND [ARGS]...
+
+Options:
+  -h, --help  Show this message and exit.
+
+Commands:
+  all     Bootstrap all aspects of the current directory and immediate sub directories by convention.
+  env     Bootstrap .env file in the current working directory.
+  npm     Bootstrap Node.js project in the current working directory.
+  poetry  Bootstrap Python Poetry and install in the current working directory.
+```
+
+## Functionality
+
+### Bootstrap .env file
+
+The command `algokit project bootstrap env` runs two main tasks in the current directory:
+
+- Searching for `.env.template` file in the current directory and use it as template to create a new `.env` file in the same directory.
+- Prompting the user to enter a value for any empty token values in the `env.` including printing the comments above that empty token
+
+For instance, a sample `.env.template` file as follows:
+
+```
+SERVER_URL=https://myserver.com
+# This is a mandatory field to run the server, please enter a value
+# For example: 5000
+SERVER_PORT=
+```
+
+Running the `algokit project bootstrap env` command while the above `.env.template` file in the current directory will result in the following:
+
+```
+$ ~ algokit project bootstrap env
+Copying /Users/me/my-project/.env.template to /Users/me/my-project/.env and prompting for empty values
+# This is a mandatory field to run the server, please enter a value value
+# For example: 5000
+
+? Please provide a value for SERVER_PORT:
+```
+
+And when the user enters a value for `SERVER_PORT`, a new `.env` file will be created as follows (e.g. if they entered `4000` as the value):
+
+```
+SERVER_URL=https://myserver.com
+# This is a mandatory field to run the server, please enter a value
+# For example: 5000
+SERVER_PORT=4000
+```
+
+### Bootstrap Node.js project
+
+The command `algokit project bootstrap npm` installs Node.js project dependencies if there is a `package.json` file in the current directory by running `npm install` command to install all node modules specified in that file. If you don't have npm available it will show a clear error message and resolution instructions.
+
+Here is an example outcome of running `algokit project bootstrap npm` command:
+
+```
+$ ~ algokit project bootstrap npm
+Installing npm dependencies
+npm:
+npm: added 17 packages, and audited 18 packages in 3s
+npm:
+npm: 2 packages are looking for funding
+npm: run `npm fund` for details
+npm:
+npm: found 0 vulnerabilities
+```
+
+### Bootstrap Python poetry project
+
+The command `algokit project bootstrap poetry` does two main actions:
+
+- Checking for Poetry version by running `poetry --version` and upgrades it if required
+- Installing Python dependencies and setting up Python virtual environment via Poetry in the current directory by running `poetry install`.
+
+Here is an example of running `algokit project bootstrap poetry` command:
+
+```
+$ ~ algokit project bootstrap poetry
+Installing Python dependencies and setting up Python virtual environment via Poetry
+poetry:
+poetry: Installing dependencies from lock file
+poetry:
+poetry: Package operations: 1 installs, 1 update, 0 removals
+poetry:
+poetry: • Installing pytz (2022.7)
+poetry: • Updating copier (7.0.1 -> 7.1.0a0)
+poetry:
+poetry: Installing the current project: algokit (0.1.0)
+```
+
+### Bootstrap all
+
+Execute `algokit project bootstrap all` to initiate `algokit project bootstrap env`, `algokit project bootstrap npm`, and `algokit project bootstrap poetry` commands within the current directory and all its immediate sub-directories. This comprehensive command is automatically triggered following the initialization of a new project through the [AlgoKit Init](./init.md) command.
+
+#### Filtering Options
+
+The `algokit project bootstrap all` command includes flags for more granular control over the bootstrapping process within [AlgoKit workspaces](../init.md#workspaces):
+
+- `--project-name`: This flag allows you to specify one or more project names to bootstrap. Only projects matching the provided names will be bootstrapped. This is particularly useful in monorepos or when working with multiple projects in the same directory structure.
+
+- `--type`: Use this flag to limit the bootstrapping process to projects of a specific type (e.g., `frontend`, `backend`, `contract`). This option streamlines the setup process by focusing on relevant project types, reducing the overall bootstrapping time.
+
+These new flags enhance the flexibility and efficiency of the bootstrapping process, enabling developers to tailor the setup according to project-specific needs.
+
+## Further Reading
+
+To learn more about the `algokit project bootstrap` command, please refer to [bootstrap](../../cli/index.md#bootstrap) in the AlgoKit CLI reference documentation.