Build

---
name: build
description: Smart .NET build with fuzzy project matching and optional --fix for MCP-driven error resolution
argument-hint: "[--project <name>] [--solution <name>] [--fix] [--configuration <config>]"
allowed-tools: Bash, Read, Glob, Grep, Task, AskUserQuestion
---

# /dotnet:build

Smart build command with fuzzy project/solution matching and optional automatic error fixing via MCP research.

## Arguments

Parse arguments from `$ARGUMENTS`:

| Flag | Description | Default |
|------|-------------|---------|
| `--solution <path>` | Target solution (supports fuzzy/partial matching) | Auto-detect |
| `--project <path>` | Target project (supports fuzzy/partial matching) | None |
| `--configuration <config>` | Build configuration | Debug |
| `--fix` | Automatically fix errors using build-fixer agent | false |
| `--verbosity <level>` | MSBuild verbosity (q, m, n, d, diag) | minimal |
| `--no-restore` | Skip restore step | false |

## Workflow

### Step 1: Locate Target

If `--project` specified:

1. Use Glob to find matching `.csproj` files
2. If partial name (e.g., "Api"), match against `*Api*.csproj`
3. If multiple matches, use AskUserQuestion to clarify
4. If natural language (e.g., "the API project"), use Grep to search project files for context

If `--solution` specified:

1. Use Glob to find matching `.sln` files
2. Same fuzzy matching logic as projects

If neither specified:

1. Look for `.sln` file in current directory or parent directories
2. If multiple solutions found, use AskUserQuestion to select
3. If no solution, look for single `.csproj`

### Step 2: Run Build

Construct and execute build command:

```bash
dotnet build "<target>" --configuration <config> --verbosity <verbosity> [--no-restore]
```

Capture both stdout and stderr for error analysis.

### Step 3: Analyze Results

If build succeeds:

- Report success with build time and output location
- List any warnings (grouped by category if many)

If build fails and `--fix` NOT specified:

- Report errors clearly
- Group errors by type (CS*, MSB*, NU*)
- Suggest running with `--fix` flag

If build fails and `--fix` IS specified:

- Parse error codes from output
- Extract relevant context (file, line, error message)
- Spawn `build-fixer` agent with error context:

```text
Task(dotnet:build-fixer, "Fix the following build errors:

Errors:
<paste parsed errors with file paths and line numbers>

Project/Solution: <target>
Configuration: <config>

Research each error via MCP, apply fixes, and report what was changed.")
```

### Step 4: Retry After Fix (if --fix)

After build-fixer agent completes:

1. Run build again
2. If still errors, retry up to 3 times total
3. Report final status with list of fixes applied

## Output Format

**Success:**

```text
Build succeeded for <target>
  Configuration: <config>
  Time: <duration>
  Output: <path>
  Warnings: <count> (use --verbosity detailed to see)
```

**Failure (no --fix):**

```text
Build failed for <target>

Errors (grouped by type):
  CS1061: 3 errors - Member does not exist
  CS0103: 2 errors - Name does not exist in context

Run with --fix to attempt automatic resolution.
```

**Failure (with --fix):**

```text
Build failed for <target>

Attempting automatic fix...
  - Fixed CS1061 in Foo.cs:42 (added missing using)
  - Fixed CS0103 in Bar.cs:15 (corrected typo)

Retrying build...
Build succeeded after 2 fix iterations.
```

## Examples

```bash
# Build solution in current directory
/dotnet:build

# Build specific project with fuzzy matching
/dotnet:build --project Api

# Build with automatic error fixing
/dotnet:build --fix

# Build Release configuration with detailed output
/dotnet:build --configuration Release --verbosity detailed

# Build specific solution
/dotnet:build --solution MyApp.sln
```