JonKazama-Hellion/HellionChat
1
0
Fork 0
Code Issues 1 Pull Requests Actions Releases 28 Activity

docs: close active upstream cherry-pick pipeline

Browse Source 
Chat 2 has entered a major rework that Infi confirmed makes selective
patches no longer portable. The cherry-pick pipeline as a routine
workflow stops with the v1.4.x cycle. Documentation reflects the new
state across all touchpoints.

UPSTREAM_SYNC.md rewritten: replaces the "How I Cherry-Pick" /
"Reviewing What Is New Upstream" / "Conflict Handling" sections with
"Why Cherry-Picking Stopped", "What Closing the Pipeline Means in
Practice", "What Does Not Change", "What Could Re-Open Later".
Existing cherry-pick trails in the git history stay intact, EUPL-1.2
anchor lines and NOTICE.md remain canonical.

README.md, CONTRIBUTING.md, ROADMAP.md, THIRD_PARTY_NOTICES.md and
the PR template updated to match: cherry-pick references reframed as
historical or pointed at UPSTREAM_SYNC.md for the current state.
NOTICE.md keeps the BetterTTV cherry-pick example as a concrete past
case but adds a paragraph that the pipeline is closed and clarifies
the attribution standard is preserved unchanged.

PULL_REQUEST_TEMPLATE.md drops the "Upstream cherry-pick from Chat 2"
checkbox and the cherry-pick-path compatibility prompt. The upstream
git remote was already removed locally on 2026-05-08 (separate change,
not in this commit).

No source-file edits, no manifest version bump, no changelog entry —
this is documentation-only and ships with the next release.
This commit is contained in:
Jon Kazama
2026-05-08 15:00:30 +02:00
parent 9640d336a6
commit 9a8a014795
7 changed files with 117 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/UPSTREAM_SYNC.md
+69 -96
View File
@@ -2,12 +2,12 @@
HellionChat is a standalone EUPL-1.2 plugin that originated from
[Chat 2](https://github.com/Infiziert90/ChatTwo). Since v1.0.0 it
lives under its own namespace, IPC channels and source tree. I no
longer track upstream as a Git fork, but I do monitor Chat 2 commits
regularly and cherry-pick selectively where it makes sense.
lives under its own namespace, IPC channels and source tree. The
active cherry-pick pipeline from upstream Chat 2 is closed since
the v1.4.x cycle.
This document covers how that works so anyone (including future-me)
can do it cleanly.
This document covers what that means, why I closed it, and what
stays in place.
## A Word on Intent
@@ -28,99 +28,77 @@ new UI from scratch and making deliberate architectural decisions that
pull in a different direction. Some upstream patches will simply stop
applying cleanly and that is expected.
## One-Time Setup
## Why Cherry-Picking Stopped in v1.4.x
Add the upstream repo as a remote on a fresh clone:
Two things converged:
```bash
git remote add upstream https://github.com/Infiziert90/ChatTwo.git
git fetch upstream
```
1. **Chat 2 is in a rework cycle.** Infi mentioned directly that
parts of ChatTwo are being reworked and "stuff may not be able to
be cherry picked anymore." Once the upstream code paths I would
pull from no longer exist in the same shape, `git cherry-pick`
stops being a meaningful tool — what would land would not be the
change Infi wrote, it would be a hand-port of his concept.
2. **HellionChat has drifted enough that selective patches require
adaptation anyway.** The UI is being rebuilt, the theme engine
sits on top of HellionStyle which has no upstream equivalent, the
privacy filter changes how messages flow through MessageManager.
Even before the rework was announced, more and more upstream
patches needed adaptation rather than a clean apply.
Verify both remotes are wired up:
Together those two points mean continuing to call this an "active
cherry-pick pipeline" was no longer honest. So I closed it.
```bash
git remote -v
# origin https://github.com/JonKazama-Hellion/HellionChat.git (fetch)
# origin https://github.com/JonKazama-Hellion/HellionChat.git (push)
# upstream https://github.com/Infiziert90/ChatTwo.git (fetch)
# upstream https://github.com/Infiziert90/ChatTwo.git (push)
```
## What Closing the Pipeline Means in Practice
`upstream` is read-only. Never push to it.
- The `upstream` git remote was removed locally on 2026-05-08.
Anyone setting up a fresh clone does **not** add it back.
- New commits will not carry `(cherry picked from commit ...)`
trailers. Anything that originates from Chat 2 from this point
forward will be a hand-port at most, and it gets called out as
such in its own commit message and in the relevant source comments.
- The existing cherry-pick trail stays in the git history exactly as
it is. Every `(cherry picked from commit ...)` line that was added
with `-x` in earlier releases remains intact; that is the
attribution paper trail and removing it would be wrong.
## Reviewing What Is New Upstream
## What Does Not Change
Before any feature cycle I run a quick check:
- **EUPL-1.2 anchor lines in source files.** Files that originated
from Chat 2 keep their licence headers and any "based on
Infiziert90/ChatTwo" notice exactly as they are. The licence
obligations under EUPL-1.2 do not lapse because cherry-picking
stopped.
- **NOTICE.md** stays canonical. Attribution to Infi and Anna for the
message store, channel logic, hook system, ImGui chat window and
the localisation infrastructure remains the foundation statement of
this fork.
- **README acknowledgements.** The Acknowledgements section in
`README.md`, the maintainer thanks in the About tab, and the
`Language.*.resx` Crowdin translator credit list all stay as they
are.
- **The original `Language.*.resx` files** remain in the source tree
in their last upstream-sync state. They are the work of the Chat 2
Crowdin community and the existing translations stay valuable. They
will not receive automatic upstream updates anymore — see
CONTRIBUTING.md for what that means for translators.
```bash
git fetch upstream
git log --oneline main..upstream/main | head -30
```
## What Could Re-Open Later
That shows every commit Infi or contributors landed since the last
sync. I read the messages and decide which ones apply to HellionChat.
If Chat 2's rework lands and stabilises, and there is a piece of
upstream code that I genuinely want in HellionChat, the path forward
is **study and re-implement**, not cherry-pick. That means:
## What I Cherry-Pick
- Read the upstream change, understand the design, port the concept
to HellionChat's actual code paths.
- Credit the upstream author in the commit message and, if the
ported code is non-trivial, in a source-file comment.
- Pre-clear with Infi if the port is large enough to warrant a
conversation.
**Always:** security fixes, Dalamud API compatibility patches,
BetterTTV and emote-cache fixes, regression fixes for upstream
behaviour HellionChat still relies on.
**Sometimes:** small bug fixes in `MessageManager.cs`,
`MessageStore.cs`, `ChatLogWindow.cs`, the Tabs system. These come in
when they touch code I have not heavily modified.
**Never:** webinterface changes (the entire webinterface tree is gone
in HellionChat), changes that conflict with the privacy filter, changes
that re-add upstream defaults I deliberately reversed (full-history
logging, Tell Exclusive defaults, etc.).
As HellionChat's UI moves further from the Chat 2 baseline, upstream
patches will increasingly require adaptation rather than a clean
apply. If a patch cannot be ported without breaking HellionChat
behaviour or the privacy model, I skip it rather than force a
compromised version in.
## How I Cherry-Pick
Always with `-x` so authorship and the original commit hash stay
visible:
```bash
git checkout -b sync/upstream-<topic> main
git cherry-pick -x <upstream-commit-sha>
```
`-x` appends a `(cherry picked from commit <sha>)` line to the commit
message. That preserves upstream-author credit and lets anyone reading
`git log` trace the change back to Chat 2. Commit messages stay
identical to the upstream original; I do not rewrite them to match the
HellionChat format.
## Conflict Handling
When a cherry-pick conflicts:
1. Resolve by hand. Do not rewrite upstream code to match HellionChat
conventions; that is what the merge marker showed.
2. If the conflict is fundamental (touches code that no longer exists
in HellionChat), abort the cherry-pick and note why in the
relevant GitHub issue or backlog item. Some upstream patches are
simply not portable and that is fine.
3. After a clean resolve the commit message stays as-is, with the
`-x` footer Git appends automatically.
## Pushing the Sync
Cherry-picked commits go through the same review as any other change.
The sync branch lands in `main` via a no-fast-forward merge, then gets
a release tag if user-visible behaviour changed:
```bash
git checkout main
git merge --no-ff sync/upstream-<topic> -m "merge: upstream sync — <topic>"
```
This is heavier than `git cherry-pick -x` and that is the point.
Cherry-picking was light because both codebases shared structure;
once they do not, the proper attribution costs a real conversation
rather than a flag on a git command.
## Contributing Back
@@ -138,17 +116,12 @@ A few things to note about that process:
not push that decision onto his codebase.
- This is not guaranteed for every change, only where it makes sense
and where I am confident the fix is clean and self-contained.
## When Upstream Goes Silent
If Chat 2 stops receiving updates the remote stays configured and this
workflow stays documented. The moment maintenance picks back up I am
ready to pull again.
- Whether it gets accepted is Infi's call, and a "no" is fine.
## When Upstream Takes a Direction I Cannot Follow
If a future Chat 2 release breaks compatibility with the HellionChat
privacy philosophy in a way that cannot be resolved (mandatory cloud
sync, removal of the local message store, an incompatible license
change), HellionChat continues from the last compatible cherry-pick.
The inherited history stays under EUPL-1.2 and stays attributed.
sync, removal of the local message store, an incompatible licence
change), HellionChat continues from where it is. The inherited
history stays under EUPL-1.2 and stays attributed.