io.github.CloudCorpRecords/conflictfix

conflictfix

A merge conflict already exists, and the question for each hunk in it is narrow: can this one be resolved mechanically, or does a human need to look at it? conflictfix answers hunk by hunk. You supply the file path and, for every hunk, the three line lists a three-way merge works from — the common ancestor's lines (base), your side's lines (ours), and their side's lines (theirs) — and it classifies each hunk, returning the resolved lines for the ones that are safe and leaving the risky ones alone.

Four classes are safe. When ours and theirs are exactly the same, the hunk is identical and resolves to those lines, however they differ from base. When only one side moved — ours still equals base, so the hunk is theirs_only and resolves to theirs, or theirs still equals base, so the hunk is ours_only and resolves to ours — the side that changed wins outright, including when it deleted every line. When the two sides differ only in whitespace, the hunk is whitespace_only and resolves to ours echoed verbatim, spacing and all: normalization decides the class, it never rewrites the lines. Everything else is conflict: not safe, resolution null, and never auto-merged by this tool.

The checks run in that fixed order and the first match wins, so a hunk where all three lists agree is identical, not ours_only, and a one-sided change that also happens to be whitespace-equal is reported as the one-sided change it is. Whitespace normalization trims each line, drops leading and trailing entries that are empty after trimming, and joins what remains with newlines. Interior blank lines are preserved by that process, so a blank line appearing in the middle of one side only is a real difference and the hunk is a conflict, not a whitespace difference.

The result echoes the path, carries one entry per input hunk with its 0-based index, class, safe flag, and resolution, and totals the outcome: safe_count, risky_count, and fully_resolvable, which is true exactly when no hunk is risky. Malformed input — a missing, empty, or non-string path, a missing, non-array, or empty hunks list, a hunk that is not an object, a missing or non-array base, ours, or theirs, or any line that is not a string — is a validation error naming the offending path, such as hunks[2].ours[0] must be a string, with no partial result. Unknown extra fields are ignored, including inside hunk items. The computation is pure and local: no repository is read, no merge is performed, and no files are touched.

CLI

npx @reneturcios/conflictfix triage --input args.json
npx @reneturcios/conflictfix --version

args.json contains the full arguments object:

{
  "path": "src/app.ts",
  "hunks": [
    {
      "base": ["const x = 1;"],
      "ours": ["const x = 1;"],
      "theirs": ["const x = 2;"]
    },
    {
      "base": ["return a;"],
      "ours": ["return b;"],
      "theirs": ["return c;"]
    }
  ]
}

The result is printed as JSON:

{
  "path": "src/app.ts",
  "hunks": [
    {
      "index": 0,
      "class": "theirs_only",
      "safe": true,
      "resolution": ["const x = 2;"]
    },
    {
      "index": 1,
      "class": "conflict",
      "safe": false,
      "resolution": null
    }
  ],
  "safe_count": 1,
  "risky_count": 1,
  "fully_resolvable": false
}

Exit codes: 0 on success, 1 on a runtime error (including an unreadable or invalid input file, or invalid input), 2 on a usage error.

MCP server

npx -y @reneturcios/conflictfix mcp

MCP client config:

{
  "mcpServers": {
    "conflictfix": {
      "command": "npx",
      "args": ["-y", "@reneturcios/conflictfix", "mcp"]
    }
  }
}

Tools

• triage_conflicts — Triage a three-way merge conflict: classify each hunk as a safe mechanical resolution or risky from caller-supplied base, ours, and theirs lines. Safe hunks return their resolved lines; risky hunks are never auto-merged.

  • path (string, required, non-empty) — file path the conflict hunks belong to
  • hunks (array, required, at least 1 item) — conflict hunks to triage; each item carries:
    • base (array of strings, required, may be empty) — lines from the common ancestor
    • ours (array of strings, required, may be empty) — lines from our side
    • theirs (array of strings, required, may be empty) — lines from their side

  Returns {path, hunks, safe_count, risky_count, fully_resolvable}, where each entry in hunks is {index, class, safe, resolution} with class one of identical, theirs_only, ours_only, whitespace_only, or conflict.

Docker

docker run -i ghcr.io/cloudcorprecords/conflictfix
docker run --rm -v "$PWD:/w" ghcr.io/cloudcorprecords/conflictfix triage --input /w/args.json

Development

npm install
npm run build   # tsc -> dist/
npm test        # tsx --test test/*.test.ts (pure local, no network)
npm run dev     # run the CLI from source

License

MIT — Copyright (c) 2026 Rene Turcios