Turbo Editors — configuration samples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# Turbo Editors — configuration samples

Ready-made project configurations for the [Turbo editors](https://rickub.com/turbo-editors): one directory per kind of project, each holding the editor's own directory — `.turbo-go`, `.turbo-rust` — with its settings, snippets, tools and, in the `-with-agents` variants, its coding agents.

You do not clone this repository to use it. Every Turbo editor can fetch a directory from it straight into your project.

## Load a configuration into a project

From the directory of your project, give the editor the URL of the sample as the browser shows it:

```bash
cd my-go-project
turbo-go -load-config https://rickub.com/turbo-editors/configs/tree/main/golang-init
```

The editor looks for the `.turbo-go` directory inside `golang-init`, copies it into the current directory, prints what arrived, and exits:

```
Copied /path/to/my-go-project/.turbo-go from https://git.rickub.com/turbo-editors/configs.git (main):
  settings.toml
  snippets.toml
  tools.toml
```

Then start the editor as usual — `turbo-go`, `turbo-go main.go` — and the settings, snippets and tools are in force.

Each editor looks for its own directory: `turbo-rust` copies the `.turbo-rust` of the sample you point it at, `turbo-python` a `.turbo-python`, and so on. Pointing turbo-rust at a Go sample ends in an error saying there is no `.turbo-rust` there.

```bash
cd my-rust-project
turbo-rust -load-config https://rickub.com/turbo-editors/configs/tree/main/rustlang-init-with-agents
```

### What to know

- **`git` must be installed.** The fetch is a shallow `git clone`; no token and no account are needed for this public repository.
- **A project that already has the directory is left alone.** The editor refuses rather than overwrite what the project decided. Move the existing `.turbo-<editor>` away first if you mean to replace it.
- **The URL may be any of these**: the sample's directory (`…/tree/main/golang-init`), the editor's directory inside it (`…/tree/main/golang-init/.turbo-go`), or a file in it. A branch or tag other than `main` works the same way, from the URL the browser shows for it.
- **The same works from other forges.** GitHub, GitLab and Codeberg URLs are understood too, so a team can keep its own samples wherever its code lives.
- **Nothing else is copied**: the sample's `README.md` and anything beside the editor's directory stay here.

## The samples

| Directory | Editor | Holds |
| --- | --- | --- |
| `golang-init` | turbo-go | `settings.toml` (theme `turbo-dark`, autosave on after 1 s), `snippets.toml`, `tools.toml` (format, lint, build, test, run) |
| `golang-init-with-agents` | turbo-go | The same, plus `acp.toml` naming two coding agents and the two agent settings files they read |
| `rustlang-init` | turbo-rust | `settings.toml`, `snippets.toml`, `tools.toml` for a Cargo project |
| `rustlang-init-with-agents` | turbo-rust | The same, plus the two agents |

### The agents in the `-with-agents` samples

`acp.toml` declares two agents, both run as `mm -acp` — a local agent speaking the Agent Client Protocol — each with its own settings file beside it (`agent.mm-dmr-gemma.yaml`, `agent.mm-dmr-mellum.yaml`), passed through the `AGENT_CONFIG` environment variable. Those files point at a **Docker Model Runner** serving models on `http://localhost:12434`, with `host.docker.internal` as the fallback. To use them you need `mm` on your `PATH` and Docker Model Runner running with the named models; otherwise the Agent menu lists the agents and opening one reports that it could not start.

Edit the two YAML files after loading — the model, the URL, which tools the agent may use — exactly as you would any project file. They are yours once copied.

## Add a sample

1. Create a directory named for the kind of project: `<language>-<flavour>`.
2. Put the editor's directory inside it — `.turbo-<editor>/` with at least `settings.toml`; add `snippets.toml`, `tools.toml`, and `acp.toml` with its agent files if the sample ships agents. The starter files an editor creates from its Options menu are a good beginning.
3. Add a `README.md` saying what the sample is for and what it assumes is installed.
4. Do not commit anything an agent writes while you test the sample: `.mm/` is ignored for that reason.

The editors only read `.turbo-<editor>/`, so a sample may hold the same configuration for several editors side by side — `.turbo-go` and `.turbo-rust` in one directory — and each editor takes its own.