build

name	build
description	Build the project (auto-detects build system)
argument-hint	[target]

Build Project

Build the project using the detected build system.

Arguments

• $ARGUMENTS - Optional build target or arguments to pass to the build command

Build System Detection (Parallel)

Launch parallel agents to check for multiple build system files simultaneously:

Agent 1 — JVM Build Systems: Check for: build.gradle.kts, build.gradle, pom.xml

Agent 2 — Native/Systems Build Systems: Check for: Cargo.toml, go.mod, Makefile, CMakeLists.txt, build.zig

Agent 3 — Web/Scripting Build Systems: Check for: package.json, deno.json, bun.lockb, composer.json, Gemfile, mix.exs, setup.py, pyproject.toml

Agent 4 — Container Build Systems: Check for: compose.yaml, compose.yml, docker-compose.yaml, docker-compose.yml, Dockerfile

Use the first match from the combined results, prioritized in the order below.

Detection Priority Table

File	Build System	Build Command	Test Command
build.gradle.kts	Gradle (Kotlin DSL)	./gradlew build	./gradlew test
build.gradle	Gradle (Groovy)	./gradlew build	./gradlew test
pom.xml	Maven	mvn package	mvn test
Cargo.toml	Cargo (Rust)	cargo build	cargo test
package.json	Node.js	<pm> run build	<pm> test
go.mod	Go	go build ./...	go test ./...
Makefile	Make	make	make test
CMakeLists.txt	CMake	cmake --build .	ctest
setup.py / pyproject.toml	Python	pip install -e .	pytest
Gemfile	Ruby	bundle install	bundle exec rake test
mix.exs	Elixir	mix compile	mix test
build.zig	Zig	zig build	zig build test
deno.json	Deno	deno task build	deno test
bun.lockb	Bun	bun run build	bun test
composer.json	PHP (Composer)	composer install	composer test or ./vendor/bin/phpunit
compose.yaml / docker-compose.yml	Docker Compose	docker compose build	docker compose run --rm test
Dockerfile	Docker	docker build -t <image> .	N/A

Execution

1. Detect: Run parallel detection agents above
2. Report: Tell user which build system was detected
3. Build: Run the appropriate build command
   • If $ARGUMENTS provided, append to build command or use as target
4. Verify (Parallel): After successful build, launch TWO parallel agents:
   • Agent 1 — Run Tests: Execute the test command for the detected build system
   • Agent 2 — Run Lint: Execute the lint/format-check command if one exists for the detected build system (e.g., ./gradlew ktlintCheck, <pm> run lint, cargo clippy, go vet ./...)
5. Report: Show build status, test results, lint results, and summary

Node.js Specifics (Parallel Detection)

For Node.js projects, launch TWO parallel agents to determine configuration:

Agent 1 — Detect Package Manager (check for lock files in priority order):

• bun.lockb -> use bun
• pnpm-lock.yaml -> use pnpm
• yarn.lock -> use yarn
• Otherwise -> use npm

Agent 2 — Check package.json Scripts:

• Read package.json and determine available scripts
• If build script exists: <pm> run build
• If build script doesn't exist but it's a TypeScript project: <pm> exec tsc or npx tsc
• Note available test and lint scripts for verification phase

Gradle Specifics

• Use ./gradlew wrapper if present, otherwise gradle
• For multi-module projects, ./gradlew build builds all modules

Rust Specifics

• Use --release flag for production builds: cargo build --release
• If $ARGUMENTS is "release", build in release mode

PHP Specifics

For PHP projects with composer.json:

1. Install dependencies: composer install
2. Run tests:
   • If test script exists in composer.json scripts: composer test
   • Otherwise, check for PHPUnit: ./vendor/bin/phpunit
   • Or PHPStan for static analysis: ./vendor/bin/phpstan analyse
3. Build (if applicable):
   • If build script exists: composer run build
   • Laravel: php artisan optimize
   • Symfony: php bin/console cache:clear

Docker Specifics

Docker Compose (preferred when present):

1. Check for compose files (in order):

   • compose.yaml (modern standard)
   • compose.yml
   • docker-compose.yaml
   • docker-compose.yml

2. Build: docker compose build $ARGUMENTS

   • Arguments passed directly (e.g., /build --no-cache, /build api)

3. Run tests (if test service exists): docker compose run --rm test

Dockerfile only (no compose file):

1. Determine image name: Use directory name as default tag

2. Build: docker build -t <dirname> . $ARGUMENTS

   • Arguments passed directly (e.g., /build --no-cache, /build -f Dockerfile.dev)
   • If multiple Dockerfiles exist, ask user which to build (unless -f specified)

Test Failures

IMPORTANT: If any tests fail during or after the build, fix them. There is no such thing as a "pre-existing" test failure - all test failures must be resolved before the task is considered complete. The task always completes with completely passing tests.

Error Handling (Parallel Diagnosis)

If the build fails, launch TWO parallel agents to diagnose:

Agent 1 — Analyze Error Output:

• Parse the build error output
• Identify the root cause (missing dependency, syntax error, type error, etc.)
• Propose a specific fix

Agent 2 — Search for Similar Patterns:

• Grep the codebase for similar patterns that compile successfully
• Check recent git history for changes that may have introduced the breakage
• Look for related configuration or dependency changes

Once both agents complete, synthesize their findings to apply the fix, then re-run the build. Repeat until the build succeeds.

If no build system detected:

• Report to user that no recognized build system was found
• List the files checked
• Ask user how to build the project