Add the skill faster_rust_worktrees: create the Git worktrees of a Rust repository fast and small on the disk

Aberta
  • Algo errado?
#19 4 comentários 0 reações 0 responsáveis Ver no GitHub

Mantenedores costumam responder em até 1 dia

Ninguém assumiu esta issue ainda.

Avaliação

Dificuldade
5/5
Tempo estimado
Mais de uma semana
Facilidade para iniciantes
35/100
Tipo de issue
Funcionalidade
Clareza
Claramente especificada
Status de atividade
Ativa
Stack de tecnologia
git, python, rust, typescript
Domínio
developer-experience, tooling

Direção de pesquisa

Start by reading skills/issue_fix_workflow/SKILL.md and the referenced worktree_tools README to understand the existing worktree workflow and reference implementation. Find the Rust package build and test commands, then follow the issue’s steps for the Cargo workspace, worktree creation and cleaning commands, and the AGENTS.md workflow update. Done means locked versions remain unchanged, tests pass, and measurements show the reported worktree build and disk space improvements.

Escrita pelo modelo de indexação a partir do texto da issue.

Descrição

Goal

Add a skill faster_rust_worktrees in skills, with a file SKILL.md. With this skill, a coding agent makes the Git worktrees of any Rust repository fast to create and small on the disk. Each issue fix creates a new worktree, and without this technique the first build of each worktree compiles every Rust dependency again.

The technique was proven first in Heidrun Code, then applied to the repository localai_rust:

Measures in localai_rust

Measured on 2026-10-29 on an Apple M1 Pro, in fresh clones (the comments of the issue of localai_rust give the details):

Measure Before After
Create a worktree, then its first pnpm test 0.3 s + 207.2 s, 875 crates compiled 2.0 s + 29.1 s, 0 crates compiled
Cold build of the repository 200.5 s, 875 crates 137.3 s, 609 crates
Disk space of the target folders of one checkout 3.5 GB 2.8 GB
Real disk space of a new worktree before its first change about 3.5 GB after its first build 5 MB
Estimate with 10 worktrees about 38.5 GB about 2.85 GB

The technique

  1. Make all the Rust packages of the repository one Cargo workspace at the root, with one Cargo.lock and one target folder. The packages then share their compiled dependencies, and Cargo uses relative paths for the packages of the repository, so the compiled files stay valid in a worktree. To keep the locked versions, start the new Cargo.lock from the largest old one, and check that no locked version changed.
  2. Create each worktree with a command that clones the target folder of the main checkout into the worktree, with one copy-on-write clone: the function clonefile of macOS (through python3), with cp -c -R -p as the fallback. The clone takes about 2 seconds and shares the disk blocks until Cargo writes a file again.
  3. Give each tracked file with the same content as in the main checkout the modification date of the main checkout, and each folder with the same list of names. Git gives every file of a new worktree the date of the creation, and Cargo then compiles every crate of the repository again.
  4. In the build script records target/<debug or release>/build/*/output, replace the absolute path of the main checkout with the path of the worktree, for the folder of the packages and for the target folder, and keep the date of each record.
  5. Install the packages of the worktree (for example pnpm install --frozen-lockfile).
  6. Give an option --without-optimization that only creates the worktree, to find out whether a problem comes from these optimizations.
  7. Give two cleaning commands: one that deletes the target folders of the worktrees that no build used for some days, and one that deletes the files of the target folder that the current builds do not use (from the hashes of the units in the Cargo log CARGO_LOG=cargo::core::compiler::fingerprint=debug).

Traps found in localai_rust

  • Run Cargo in the folder of each package, as the scripts of the package do, and never at the root of the workspace. At the root, Cargo builds the packages together, which gives the shared dependencies other features and other hashes, and it does not read the .cargo/config.toml of a package. Both make Cargo compile everything again.
  • Run each Cargo command of the cleaning command in the folder of its package, for the same reason. A variable such as GGML_METAL, set in the .cargo/config.toml of a package, makes a build script run again when it changes.
  • The worktree must be inside the main checkout (for example .agents/worktrees/<branch>), so that both folders are on the same disk, which the clone needs.
  • The main checkout must be built first. Without a target folder, the command creates the worktree without the clone and says so.
  • Measure with the real repository: count the lines Compiling of the first build in a new worktree. The result must be 0 crates when no source changed, and only the changed package after a change of one line.

What the skill does

The skill names no detail of one repository, like the skill issue_fix_workflow. It tells the coding agent to:

  1. Find the Rust packages of the repository, the commands that build and test them, and the folder of the worktrees.
  2. Make the Cargo workspace, and check that the locked versions did not change and that the tests pass.
  3. Add the command that creates a worktree, and the two cleaning commands. The package worktree_tools of localai_rust is the reference implementation, in TypeScript.
  4. Change the worktree creation command of the Issue Fix Workflow in the file AGENTS.md of the repository.
  5. Measure before and after, as in the table above, and write the measures in the issue.
Linguagem predominante
Sem dados de linguagem
Estrelas
1
Forks
0
Merge médio
6min
PRs com merge (30d)
19

Preparar o ambiente

Este projeto não oferece contêiner de desenvolvimento, Dockerfile nem guia de contribuição, então a configuração fica por sua conta: comece pelo README e veja nosso guia da primeira contribuição para os passos gerais.

Primeiros passos

  1. Leia a issue inteira e depois o guia de contribuição do projeto.
  2. Comente na issue dizendo que vai assumir — evita que duas pessoas façam o mesmo trabalho.
  3. Faça um fork do repositório e trabalhe em uma branch.
  4. Abra um pull request que referencie o número da issue.

Mais de jeromeetienne/coding_agent_plugin

Todas as issues de jeromeetienne/coding_agent_plugin

Issues semelhantes

Mais issues de DevTools

Receba novas issues na sua caixa de entrada

Um resumo curto de issues do GitHub para quem está começando.