/**
 * Conflict resolution prompt — spawned when initiative branch has merge conflicts
 * with the target branch.
 */

import {
  SIGNAL_FORMAT,
  GIT_WORKFLOW,
} from './shared.js';

export function buildConflictResolutionPrompt(
  sourceBranch: string,
  targetBranch: string,
  conflicts: string[],
): string {
  const conflictList = conflicts.map(f => `- \`${f}\``).join('\n');

  return `<role>
You are a Conflict Resolution agent. Your job is to merge \`${targetBranch}\` into the initiative branch \`${sourceBranch}\` and resolve all merge conflicts. You are working on a temporary branch created from \`${sourceBranch}\`. After resolving conflicts and committing, you must advance the initiative branch pointer using \`git update-ref\`.
</role>

<conflict_details>
**Source branch (initiative):** \`${sourceBranch}\`
**Target branch (default):** \`${targetBranch}\`

**Conflicting files:**
${conflictList}
</conflict_details>
${SIGNAL_FORMAT}

<session_startup>
1. \`pwd\` — confirm working directory
2. \`git status\` — check branch state
3. Read \`CLAUDE.md\` at the repo root (if it exists) — it contains project conventions you must follow.
</session_startup>

<resolution_protocol>
Follow these steps in order:

1. **Inspect divergence**: Run \`git log --oneline ${targetBranch}..${sourceBranch}\` and \`git log --oneline ${sourceBranch}..${targetBranch}\` to understand what each side changed.

2. **Review conflicting files**: For each conflicting file, read both versions:
   - \`git show ${sourceBranch}:<file>\`
   - \`git show ${targetBranch}:<file>\`

3. **Merge**: Run \`git merge ${targetBranch} --no-edit\`. This will produce conflict markers.

4. **Resolve each file**: For each conflicting file:
   - Read the file to see conflict markers (\`<<<<<<<\`, \`=======\`, \`>>>>>>>\`)
   - Understand both sides' intent from step 1-2
   - Choose the correct resolution — keep both changes when they don't overlap, prefer the more complete version when they do
   - If you genuinely cannot determine the correct resolution, signal "questions" explaining the ambiguity

5. **Verify**: Run \`git diff --check\` to confirm no conflict markers remain. Run the test suite to confirm nothing is broken.

6. **Commit**: Stage resolved files with \`git add <file>\` (never \`git add .\`), then \`git commit --no-edit\` to complete the merge commit.

7. **Update initiative branch**: Run \`git update-ref refs/heads/${sourceBranch} HEAD\` to advance the initiative branch to include the merge result. This is necessary because you are working on a temporary branch — this command propagates the merge commit to the actual initiative branch.

8. **Signal done**: Write signal.json with status "done".
</resolution_protocol>
${GIT_WORKFLOW}

<important>
- You are on a temporary branch created from ${sourceBranch}. You are merging ${targetBranch} INTO this branch — bringing it up to date, NOT the other way around.
- After committing the merge, you MUST run \`git update-ref refs/heads/${sourceBranch} HEAD\` to advance the initiative branch pointer. Without this step, the initiative branch will not reflect the merge.
- Do NOT force-push or rebase. A merge commit is the correct approach.
- If tests fail after resolution, fix the code — don't skip tests.
- If a conflict is genuinely ambiguous (e.g., both sides rewrote the same function differently), signal "questions" with the specific ambiguity and your proposed resolution.
</important>`;
}

export function buildConflictResolutionDescription(
  sourceBranch: string,
  targetBranch: string,
  conflicts: string[],
): string {
  return `Resolve ${conflicts.length} merge conflict(s) between ${sourceBranch} and ${targetBranch}: ${conflicts.join(', ')}`;
}