StewBeet

Editor support for the beet ecosystem: beet, bolt, mecha and StewBeet. .bolt files get their own language, and the mcfunction strings inside your Python get highlighting, completion, errors and links to the built datapack.

Watch this as a video, in better quality

Completion and navigation inside a block

You write	You get
`.bolt` modules	The Bolt language: advanced highlighting, completion and ctrl+click on the commands, and a lens per function the module writes
bolt inside a `.mcfunction`	The same, and Spyglass taken off a file it cannot parse
plain beet, `ctx.data.functions[p] = Function(...)`	The commands inside are commands: coloured, completed, checked, and linked to what the build wrote
mecha	Navigation from every generated line back to the source line it came from
StewBeet `write_*` helpers	All of the above, plus every `{...}` path resolved to what it really is

Every example below comes from demo/, a pack you can build and open yourself.

Quick start

Install Spyglass. It provides completion, hover and errors.
For navigation to the build, add the sniffer plugin to your beet config (beet.yml):

require:
    - "stewbeet.plugins.sniffer"  # <- this one (requires "stewbeet" to be pip-installed or in your venv)

Or leave beet.yml alone and ask for it on the command line: beet -s "require[]=stewbeet.plugins.sniffer" build.

Bolt

Watch this as a video, in better quality

The Bolt language, with completion and ctrl+click on its commands

.bolt files open as Bolt, with a grammar generated from every command tree mecha ships, whatever version your pack targets: item = 3 is Python, item modify entity @s ... is a command.

Completion, errors and ctrl+click on commands, through Spyglass. Python expressions are masked.
Spyglass's colours on the commands, as in a .mcfunction it reads. The Python around them, and a value bolt computes inside one, keep the grammar's.
A lens per function the module writes, leading to the generated file(s).
Computed paths stay clickable: function gui.open resolves to what the last build wrote.
Commands mecha reads and vanilla does not: ~/child paths, a command over several lines, and the commands a plugin adds to mecha, such as bolt_compute's compute bolt. The build says where each one is.

Bolt inside a `.mcfunction`

These files get the bolt language id too: every file the last build compiled as bolt, with mecha's nesting, a command over several lines or a command a plugin added, and before any build, the files whose text gives it away. Spyglass still indexes them, so the functions they define are known to the files that call them, and the errors it reports on their bolt lines are dropped.

beet

Plugins using beet's own API need nothing else than stewbeet.plugins.sniffer:

Beet code highlighting

Watch this as a video, in better quality

Errors and navigation in a plain beet plugin

Errors as you type, no build needed. Build errors are relayed onto the Python that wrote the command.
Navigation both ways: go to definition lands on the call that wrote a function, find references lists every writer, and a lens above each block opens what it generated.

StewBeet

write_function(f"{ns}:machines/tick", f"""
execute unless score @s energy.storage >= @s {ns}.energy_rate run return fail
execute if entity @s[tag={ns}.turbine] run function {ns}:turbine/tick
""")

Each {...} is filled with what the last build resolved it to, so ctrl+click and completion work on computed paths. A {name} in a plain string is read the same way, since .format fills it in later. A name resolved on one line is reused where the build covers nothing, such as commands assembled in a variable. Nothing evaluates your Python, and what stays unknown keeps a _ mask.

What counts as a block

Written as	Example
`write_*` helpers	`write_function`, `write_versioned_function`, `write_load_file`, ...
A variable	`content = f"""..."""` and every `+=` up to the call that consumes it
A list	`.append`, `+= [...]`, literals, comprehensions, `"\n".join(lines)`
Your own function	Any parameter annotated `McFunction`, by position or by keyword
Your own class	A field annotated `McFunction`, ex: `Bonus(name="speed", commands="""...""")`
An expression	Both branches of `"..." if cond else "..."`, and `"..." + "\n".join(lines)`
beet's own API	`Function(...)` from a string or a `list[str]`, plus `.append`, `.prepend` and `.lines`

Every block is coloured. The grammar colours what it sees from the line a block opens on, such as a write_* call or a variable annotated McFunction (a plain str alias from stewbeet), and a block only the whole file reveals, such as a dataclass field or a variable with no annotation, is painted in the same colours, read from your theme and your editor.tokenColorCustomizations:

MCFunction type highlighting

Coming from Aegis

Compared to Aegis, StewBeet is lighter and easier to install, but it does not provide Python symbols in completion (yet).

	Aegis	StewBeet
`.bolt` highlighting	None, read as `mcfunction`	Bolt grammar
Commands in Python strings	No	Yes
Source to build navigation	No	Both directions
Needs	`ms-python.python` and your environment	Nothing
`.bolt` completion	Full compiler, Python symbols included	Commands only, through Spyglass

Keep Aegis if you need that last row.

Does it need my venv?

No. The extension only reads your sources and the .mcfunction.map files your build writes thanks to the stewbeet.plugins.sniffer plugin.

Settings

All under StewBeet.*:

Setting	Default
`languageFeatures`	`true`	Completion, hover, signature help and go to definition inside the blocks
`suggestSpyglass`	`true`	Offer the Spyglass install once, when it is missing
`buildOutput`	`""`	Where the generated pack is, absolute or relative to the workspace. Empty searches the workspace
`sourceMapDiagnostics`	`true`	Relay build errors onto the Python that wrote the command
`resolveInterpolations`	`true`	Fill each `{...}` with what the last build resolved it to
`diagnosticRuleDenylist`	`["undeclaredSymbol"]`	Rules never relayed onto Python
`codeLens`	`true`	The link above a block that produced a function
`headerLinks`	`true`	Resource locations in a generated file's `#>` header
`boltInMcfunction`	`true`	Give a `.mcfunction` holding bolt the `bolt` language id
`enableBlockDecorations`	`true`	The coloured box around a block
`backgroundColor`	`rgba(80,40,0,0.15)`	Any CSS colour
`borderColor`	`rgba(200,120,30,0.30)`	Any CSS colour
`borderWidth`	`"2px"`

Commands, from the palette: Go to Generated Function, Go to Python Source, Reload Source Maps, Refresh Build Diagnostics, Show Diagnostics Status, Install Spyglass Language Server.

Palette commands

Installation

From the marketplace: search StewBeet in the Extensions panel. From a .vsix: code --install-extension StewBeet.vsix, or Extensions -> ... -> Install from VSIX...

mcfunction grammar taken from MinecraftCommands/syntax-mcfunction and adapted to our needs.

StewBeet

Alexandre COLLIGNON

StewBeet

Quick start

Bolt

Bolt inside a .mcfunction

beet

StewBeet

What counts as a block

Coming from Aegis

Does it need my venv?

Settings

Installation

Bolt inside a `.mcfunction`