Error Diagnose Fix

error-diagnose-fix

Purpose

An Agent Loop that takes ownership of build/compilation errors instead of waiting for the user to paste them one by one. The agent runs the build command itself, collects all errors at once, analyzes their dependency relationships, fixes root causes first, and loops until the build succeeds.

This eliminates the ping-pong pattern observed in sessions:

User: [pastes error]
Agent: [fixes one thing]
User: [pastes next error]
Agent: [fixes, breaks something else]
... 5-10 rounds later ...

Replaced by:

Agent: [runs build, sees 7 errors, identifies 2 root causes, fixes both, re-runs, 0 errors]

When to trigger

• $error-diagnose-fix or /edf — start the loop
• $error-diagnose-fix <command> — specify the build command explicitly
• User pastes a build error and says "fix this", "搞定这个报错", "编译不过"
• User says "build is broken", "构建失败", "编译错误"
• Framework upgrade just broke the build (expo upgrade, dependency bump, etc.)
• Multiple cascading errors after a refactor

When NOT to use

• Runtime bugs (wrong behavior, not build failure) → use systematic-debugging
• Cross-device sync issues → use dual-side-debug
• CI-specific failures (works locally) → use pr-greenlight or babysit-pr
• Single obvious typo the user already knows about → just fix it directly

State file

/tmp/codex-edf-state.json:

{
  "build_command": "cargo check --workspace",
  "build_system": "cargo",
  "round": 0,
  "max_rounds": 6,
  "started_at": "ISO timestamp",
  "error_snapshots": [
    {
      "round": 0,
      "error_count": 7,
      "error_signatures": ["E0308@uc-core/src/lib.rs:42", "E0599@..."],
      "root_causes_identified": ["type mismatch in ContentHash refactor"],
      "fixes_applied": [],
      "hypothesis": null
    }
  ],
  "reverted_hypotheses": [],
  "resolved_errors": []
}

Phase 1 — Perceive: Detect build system and run build

1a — Identify build system and command

If the user provided a command, use it. Otherwise, auto-detect:

For this repo specifically, common commands are:

• Rust: cargo check --workspace --locked
• Frontend: bun run build (tsc + vite)
• Full: both of the above
• Expo (android project): npx expo run:android / npx expo run:ios

If unclear, ask the user which build to fix.

1b — Run the build and capture ALL output

# Example for cargo
cargo check --workspace --locked 2>&1 | tee /tmp/codex-edf-build-output.txt
echo "EXIT_CODE=$?"

Critical: capture the FULL output, not just tail. Errors at the top of the output often contain the root cause, while the bottom has cascading failures.

1c — Parse errors into a structured list

For each build system, parse errors into a uniform structure:

Cargo errors:

{
  "code": "E0308",           // error code
  "message": "mismatched types",
  "file": "crates/uc-core/src/active_clipboard.rs",
  "line": 42,
  "span": "expected `String`, found `&str`",
  "suggestion": "try using `.to_string()`",   // if rustc suggests
  "note": "..."              // additional context from rustc
}

TypeScript errors:

{
  "code": "TS2322",
  "message": "Type 'X' is not assignable to type 'Y'",
  "file": "src/components/Foo.tsx",
  "line": 15
}

ESLint/Prettier:

{
  "rule": "no-unused-vars",
  "message": "'x' is defined but never used",
  "file": "src/utils.ts",
  "line": 8,
  "fixable": true
}

Store the error list and count as error_snapshots[round].

Phase 2 — Reason: Analyze error dependencies

2a — Group errors by file and crate/package

Errors in the same file are often related. Errors in downstream crates that depend on an upstream crate with errors are likely cascading.

2b — Identify root cause vs cascade

Root cause signals:

• Error in a type definition, trait impl, or function signature → changes cascade to all callers
• Error in a mod.rs or re-export → cascades to all importers
• "cannot find" / "not defined" errors pointing to something recently renamed/moved
• Version mismatch in Cargo.toml / package.json → cascading API breakage

Cascade signals:

• Errors that reference a type/function from another file that also has errors
• "method not found" when the trait/struct definition has a separate error
• Many errors in different files all pointing to the same root type/function
• "unused import" errors appearing alongside "not found" errors (import was for something removed)

2c — Build a fix order

Root causes (fix first):
  1. [E0308] crates/uc-core/src/types.rs:42 — ContentHash type changed
     Cascading errors: 5 errors in 3 files that use ContentHash

  2. [E0432] crates/uc-core/src/lib.rs:8 — module `old_name` not found
     Cascading errors: 2 errors in files that import from old_name

Independent errors (fix after):
  3. [E0599] crates/uc-daemon/src/api.rs:100 — method not found (unrelated)

2d — For framework/dependency errors: check docs

If errors are caused by a version upgrade or unfamiliar API:

Use context7 MCP:
1. mcp__context7__resolve-library-id("expo-router") → get library ID
2. mcp__context7__query-docs(libraryId, "migration guide from v3 to v4")

This replaces guessing at breaking changes from training data.

Phase 3 — Act: Fix root causes

3a — State the hypothesis

Before fixing, record in the state file:

{
  "hypothesis": "ContentHash changed from String to [u8; 32], need to update all call sites",
  "files_to_change": ["crates/uc-core/src/dispatch.rs", "crates/uc-daemon/src/sync.rs"],
  "expected_outcome": "7 errors → ~2 errors (cascade eliminated, independent errors remain)"
}

3b — Create a revert point

git stash push -m "edf-round-N-checkpoint" --include-untracked 2>/dev/null
# Or if working tree is clean, just note the current HEAD
git rev-parse HEAD > /tmp/codex-edf-revert-point.txt

3c — Apply fixes

Fix root causes first, in the order from Phase 2c. Guidelines:

• Type mismatch / API change: Read the new type definition, update all call sites consistently
• Missing module / function: Check if renamed (git log, grep old name) or removed
• Version breaking change: Check migration guide (context7), apply required changes
• Import errors: Update import paths, re-export if needed

After fixing each root cause, do NOT re-run the full build yet. Fix all identified root causes first, then re-run once.

3d — Handle auto-fixable errors

Some errors have automatic fixes:

# Rust: apply compiler suggestions
# (rustc often suggests exact fix, apply them)

# ESLint: auto-fix
bun run lint:fix -- <specific files>

# Prettier: auto-format
bun run format

Phase 4 — Observe: Re-run build and compare

4a — Re-run the same build command

cargo check --workspace --locked 2>&1 | tee /tmp/codex-edf-build-output.txt
echo "EXIT_CODE=$?"

4b — Compare error sets

Parse the new errors and compare with the previous round:

4c — On regression: revert

# If fix made things worse or didn't help
git checkout -- .
# Or restore from stash
git stash pop

Record the failed hypothesis:

{
  "hypothesis": "...",
  "result": "no improvement — same 7 errors",
  "reverted": true
}

Add to reverted_hypotheses in state. Never retry a reverted hypothesis.