ভুল শোধরানো — restore, reset, revert, amend আর reflog

১ · কী ফেরাতে চান, কোথায় আছে — undo-এর মানচিত্র

পরীক্ষার খাতার কথা ভাবুন। খসড়া পাতায় ভুল লিখলে কেটে দিলেই হয়। ফেয়ার কপিতে ভুল হলে কাটাকুটি চোখে পড়ে, তাই সাবধানে শোধরাতে হয়। আর খাতা জমা দিয়ে ফেললে আপনি আর সেটি টেনে আনতে পারেন না — বড়জোর একটি আলাদা সংশোধনী পাতা জুড়তে পারেন। Git-এ ভুল শোধরানোও ঠিক এমন: ভুলটি কোন জায়গায় আছে, তার ওপর নির্ভর করে কোন পদ্ধতি নিরাপদ।

পর্ব ৮-এ আপনি Git-এর তিনটি এলাকা দেখেছেন। এখানে শুধু মনে করিয়ে দিই। Working tree হলো আপনার ফোল্ডারের ফাইল, যেখানে আপনি লেখেন। Index (staging area) হলো পরের commit-এর খসড়া, যা git add দিয়ে ভরে। আর repository-তে থাকে সব commit; বর্তমান branch যে commit-এর দিকে নির্দেশ করে, সেটিই HEAD. Undo করার প্রতিটি command আসলে এই তিন জায়গার একটি বা একাধিক জায়গাকে অন্য একটি জায়গার মতো করে দেয়।

এই সারণিটিই নিচের flowchart-এ সিদ্ধান্তের ধাপ হিসেবে আঁকা। ওপর থেকে প্রশ্নগুলোর উত্তর দিতে দিতে নামুন; প্রথম “হ্যাঁ” যেখানে, সেখানেই আপনার command.

যে repository দিয়ে পুরো পর্বের উদাহরণ

এই পর্বের প্রতিটি “উদাহরণ” আউটপুট এই যন্ত্রে Git ২.৫৩ দিয়ে একটি আলাদা scratch ফোল্ডারে চালিয়ে হুবহু কপি করা। প্রজেক্টটি একটি কাল্পনিক অনলাইন বাজার অ্যাপের ছোট অংশ। লেখক, ইমেল আর সময় নির্দিষ্ট রাখা হয়েছে, তাই ফাইলের লেখা হুবহু এক হলে আপনার যন্ত্রেও একই commit ID আসবে:

$ git -c init.defaultBranch=main init -q bazar && cd bazar
$ git config user.name "Rahim"; git config user.email "rahim@example.com"
$ git config core.autocrlf false
$ export GIT_AUTHOR_DATE="2026-01-15T10:00:00+06:00" GIT_COMMITTER_DATE="2026-01-15T10:00:00+06:00"
$ printf '# Bazar app\n' > README.md
$ git add README.md; git commit -q -m "Add README"
$ export GIT_AUTHOR_DATE="2026-01-15T10:01:00+06:00" GIT_COMMITTER_DATE="2026-01-15T10:01:00+06:00"
$ printf 'function total(items) {\n  return items.reduce((s, it) => s + it.price * it.qty, 0);\n}\nmodule.exports = { total };\n' > cart.js
$ printf '# Bazar app\n- cart total\n' > README.md
$ git add cart.js README.md; git commit -q -m "Add cart total"
$ export GIT_AUTHOR_DATE="2026-01-15T10:02:00+06:00" GIT_COMMITTER_DATE="2026-01-15T10:02:00+06:00"
$ printf 'function discount(sum) {\n  return sum >= 1000 ? sum * 0.9 : sum;\n}\nmodule.exports = { discount };\n' > discount.js
$ git add discount.js; git commit -q -m "Add discount rule"
$ git log --oneline
f469880 Add discount rule
f8f0806 Add cart total
df9c5fe Add README

২ · Working tree আর index ফেরানো — git restore

ধরুন আপনি cart.js-এ কিছু পরীক্ষা করতে গিয়ে ফাইলটি এলোমেলো করে ফেলেছেন, আর বুঝছেন এই পরিবর্তন রাখার মতো নয়। git restore ফাইলটিকে index-এ যা আছে, সেই অবস্থায় ফিরিয়ে আনে। Index-এ সাধারণত শেষ commit-এর লেখাই থাকে, যদি না আপনি নতুন কিছু add করে থাকেন।

$ git status --short
 M cart.js
$ git restore cart.js
$ git status
On branch main
nothing to commit, working tree clean

ভুল ফাইল stage করেছেন — restore --staged

এবার উল্টো ঘটনা। আপনি একটি debug লাইন যোগ করে ভুলে git add করে ফেলেছেন। Commit করার আগে এটিকে index থেকে নামাতে চান, কিন্তু ফাইলের লেখা হারাতে চান না:

$ git add cart.js
$ git status
On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	modified:   cart.js

$ git restore --staged cart.js
$ git status --short
 M cart.js

খেয়াল করুন, git status নিজেই পরামর্শ দিচ্ছে কোন command দিয়ে unstage করবেন। আর শেষ লাইনে M-এর আগে একটি ফাঁকা ঘর: বাঁয়ের অক্ষর index-এর অবস্থা, ডানের অক্ষর working tree-র অবস্থা। পরিবর্তন এখন শুধু working tree-তে আছে, index আবার HEAD-এর মতো। --staged index-কে HEAD থেকে আবার লেখে, working tree ছোঁয় না — তাই এটি নিরাপদ।

পুরোনো কোনো commit থেকে একটি ফাইল আনা — --source

কখনো কখনো একটি ফাইলের দুই commit আগের রূপ দরকার হয়, কিন্তু পুরো project পেছনে নিতে চান না। --source=<commit> বলে দেয় কোন commit থেকে লেখা আনতে হবে। ডিফল্টভাবে এটি শুধু working tree-তে বসে; index আর branch যেমন ছিল তেমনই থাকে:

$ git restore --source=HEAD~2 README.md
$ cat README.md
# Bazar app
$ git status --short
 M README.md
$ git restore README.md
$ cat README.md
# Bazar app
- cart total

HEAD~2 মানে HEAD থেকে দুই ধাপ পেছনের commit, এখানে df9c5fe. আনা লেখা পছন্দ হলে add করে commit করবেন; না হলে শেষের মতো আবার git restore দিয়ে বাতিল। দুই জায়গাতেই একসাথে বসাতে চাইলে git restore --source=HEAD~2 --staged --worktree README.md.

পুরোনো command — checkout -- আর reset HEAD

git restore আর git switch এসেছে Git ২.২৩-এ, ২০১৯ সালে। তার আগে একই কাজ হতো git checkout আর git reset দিয়ে। পুরোনো বই, Stack Overflow-এর উত্তর আর অনেক AI এখনো এগুলোই দেখায়। এগুলো আজও কাজ করে:

$ git add cart.js
$ git reset HEAD cart.js
Unstaged changes after reset:
M	cart.js
$ git checkout -- cart.js
$ git status --short

কেন ভাঙা হলো? পুরোনো git checkout একই নামে দুটি একদম ভিন্ন কাজ করত — branch বদলানো (নিরাপদ) আর ফাইলের পরিবর্তন মুছে দেওয়া (বিপজ্জনক)। একটি অক্ষর এদিক-ওদিক হলেই একটির বদলে অন্যটি চলত। Branch বদলানো আর switch নিয়ে বিস্তারিত পর্ব ১২-এ।

৩ · শেষ commit ঠিক করা — git commit --amend

Commit করে ফেলার পরেই চোখে পড়ল দুটি ভুল: বার্তায় “delivery”-র বানান ভুল, আর নতুন fee.json ফাইলটি add করতে ভুলে গেছেন। git commit --amend শেষ commit-টিকে বাতিল করে তার জায়গায় একটি নতুন commit বানায় — আগের commit-এর বিষয়বস্তু, তার সাথে index-এ এখন যা আছে, আর নতুন বার্তা মিলিয়ে।

$ export GIT_AUTHOR_DATE="2026-01-15T10:03:00+06:00" GIT_COMMITTER_DATE="2026-01-15T10:03:00+06:00"
$ printf 'const { discount } = require("./discount");\nconst FEE = require("./fee.json").fee;\nfunction total(items) {\n  const sum = items.reduce((s, it) => s + it.price * it.qty, 0);\n  return discount(sum) + FEE;\n}\nmodule.exports = { total };\n' > cart.js
$ printf '{ "fee": 60 }\n' > fee.json
$ git add cart.js
$ git commit -m "Add delivry fee"
[main 97611f9] Add delivry fee
 1 file changed, 4 insertions(+), 1 deletion(-)
$ git status --short
?? fee.json
$ export GIT_AUTHOR_DATE="2026-01-15T10:04:00+06:00" GIT_COMMITTER_DATE="2026-01-15T10:04:00+06:00"
$ git add fee.json
$ git commit --amend -m "Add delivery fee"
[main d09aad4] Add delivery fee
 Date: Thu Jan 15 10:03:00 2026 +0600
 2 files changed, 5 insertions(+), 1 deletion(-)
 create mode 100644 fee.json
$ git log --oneline
d09aad4 Add delivery fee
f469880 Add discount rule
f8f0806 Add cart total
df9c5fe Add README

তিনটি জিনিস খেয়াল করুন। এক, commit ID বদলে গেছে: 97611f9 থেকে d09aad4. দুই, git log-এ 97611f9 আর নেই, যেন কখনো ছিলই না। তিন, Date: লাইনে ১০টা ৩ মিনিট — amend ডিফল্টভাবে লেখকের (author) মূল সময় রেখে দেয়, শুধু committer-এর সময় নতুন হয়। বার্তা না বদলে শুধু ফাইল যোগ করতে চাইলে git commit --amend --no-edit.

ID কেন বদলায়? একটি commit-এর ID তার পুরো বিষয়বস্তুর hash: snapshot, parent commit, লেখক, সময় আর বার্তা। এর যেকোনো একটি বদলালে hash বদলায় (ভেতরের খুঁটিনাটি পর্ব ৫২-এ)। তাই Git-এ কোনো commit “সম্পাদনা” করা যায় না — শুধু নতুন একটি বানিয়ে branch-কে সেদিকে সরানো যায়। নিচের ডায়াগ্রামে ধাপে ধাপে দেখুন:

৪ · git reset — branch-এর pointer সরানো, তিনটি mode

git reset <commit> সবচেয়ে শক্তিশালী আর সবচেয়ে ভুল বোঝা undo command. এর মূল কাজ একটাই: বর্তমান branch-কে অন্য একটি commit-এর দিকে সরানো। তারপর mode ঠিক করে আরও কতদূর যাবে:

নিচের ডায়াগ্রামে একই শুরুর অবস্থা থেকে তিনটি mode পাশাপাশি চলছে। শুরুতে main আছে C3-এ (যেখানে cart.js-এর রূপ v3); আপনি ফাইলটি বদলে v4 বানিয়ে stage করেছেন, তারপর আবার বদলে v5 করেছেন। Command: git reset --<mode> HEAD~2.

এবার আসল Git-এ d09aad4 থেকে এক commit পেছনে, প্রতিবার status দেখে। প্রতিটি পরীক্ষার পর git reset --hard ORIG_HEAD দিয়ে আবার d09aad4-এ ফিরেছি। ORIG_HEAD হলো reset, merge বা rebase-এর আগে HEAD যেখানে ছিল, সেই জায়গার একটি বিশেষ নাম।

$ git reset --soft HEAD~1
$ git log --oneline -1
f469880 Add discount rule
$ git status
On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	modified:   cart.js
	new file:   fee.json

$ git reset --hard ORIG_HEAD
HEAD is now at d09aad4 Add delivery fee

$ git reset HEAD~1
Unstaged changes after reset:
M	cart.js
$ git status
On branch main
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   cart.js

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	fee.json

no changes added to commit (use "git add" and/or "git commit -a")
$ git reset --hard ORIG_HEAD
HEAD is now at d09aad4 Add delivery fee

$ git reset --hard HEAD~1
HEAD is now at f469880 Add discount rule
$ git status
On branch main
nothing to commit, working tree clean
$ git log --oneline
f469880 Add discount rule
f8f0806 Add cart total
df9c5fe Add README
$ ls
README.md
cart.js
discount.js

তিন mode কোন এলাকা ছোঁয়, তা একটি ছোট মডেলে চালিয়ে দেখুন। প্রতিটি command একই শুরুর অবস্থার একটি নতুন কপিতে চলে, যাতে পাশাপাশি তুলনা করা যায়। শেষ দুই লাইন restore-এর দুই রূপ:

// Three areas + a branch pointer. One file, cart.js; "v1".."v5" are its versions.
const commits = { C1: { parent: null, cart: "v1" }, C2: { parent: "C1", cart: "v2" },
                  C3: { parent: "C2", cart: "v3" } };
function start() { // main at C3, v4 staged (index), then edited again to v5 (working tree)
  return { main: "C3", index: "v4", work: "v5" };
}
function back(id, n) { while (n-- > 0) id = commits[id].parent; return id; }
const ops = {
  "git reset --soft HEAD~2":    s => { s.main = back(s.main, 2); },           // branch only
  "git reset HEAD~2 (--mixed)": s => { s.main = back(s.main, 2);              // branch + index
                                       s.index = commits[s.main].cart; },
  "git reset --hard HEAD~2":    s => { s.main = back(s.main, 2);              // all three
                                       s.index = s.work = commits[s.main].cart; },
  "git restore --staged cart.js": s => { s.index = commits[s.main].cart; },   // index <- HEAD
  "git restore cart.js":        s => { s.work = s.index; },                   // work <- index
};
function row(label, s) {
  const head = commits[s.main].cart;
  const staged = s.index !== head ? "yes" : "no", unstaged = s.work !== s.index ? "yes" : "no";
  console.log(label.padEnd(31) + s.main.padEnd(6) + head.padEnd(6) + s.index.padEnd(7) +
              s.work.padEnd(6) + staged.padEnd(8) + unstaged);
}
console.log("command (each on a fresh copy)".padEnd(31) + "main  HEAD  index  work  staged  unstaged");
row("(start)", start());
for (const [cmd, f] of Object.entries(ops)) { const s = start(); f(s); row(cmd, s); }
// Commits are never deleted by reset: C3 still exists, only "main" stopped pointing at it.
console.log("C3 still in object store:", "C3" in commits);

command (each on a fresh copy) main  HEAD  index  work  staged  unstaged
(start)                        C3    v3    v4     v5    yes     yes
git reset --soft HEAD~2        C1    v1    v4     v5    yes     yes
git reset HEAD~2 (--mixed)     C1    v1    v1     v5    no      yes
git reset --hard HEAD~2        C1    v1    v1     v1    no      no
git restore --staged cart.js   C3    v3    v3     v5    no      yes
git restore cart.js            C3    v3    v4     v4    yes     no
C3 still in object store: true

৫ · git revert — শেয়ার করা history-তে নিরাপদ undo

ধরুন f469880 Add discount rule commit-টি ইতিমধ্যে দলের main-এ push হয়ে গেছে, আর এখন দেখা গেল ছাড়ের নিয়মটি ভুল। দলের অন্তত দুজন সেটি pull করেছেন। এখানে reset ভুল পথ, কারণ সেটি history-র একটি অংশ মুছে দিতে চায় — অথচ সেই অংশ অন্যদের clone-এ আছে। git revert <commit> উল্টো পথে হাঁটে: ভুল commit-এর ঠিক উল্টো পরিবর্তন দিয়ে একটি নতুন commit বানায়। ব্যাংকের হিসাবের খাতায় ভুল এন্ট্রি কেটে ফেলা হয় না; তার নিচে একটি উল্টো এন্ট্রি লেখা হয় — revert ঠিক সেই হিসাবরক্ষকের নিয়ম।

$ export GIT_AUTHOR_DATE="2026-01-15T10:05:00+06:00" GIT_COMMITTER_DATE="2026-01-15T10:05:00+06:00"
$ git revert --no-edit HEAD~1
[main 5fcff4a] Revert "Add discount rule"
 Date: Thu Jan 15 10:05:00 2026 +0600
 1 file changed, 4 deletions(-)
 delete mode 100644 discount.js
$ git log --oneline
5fcff4a Revert "Add discount rule"
d09aad4 Add delivery fee
f469880 Add discount rule
f8f0806 Add cart total
df9c5fe Add README
$ git show --stat --format="%h %s%n%n%b" HEAD
5fcff4a Revert "Add discount rule"

This reverts commit f469880657c8f5c5040e8ba79bec5a9bd6d72a98.


 discount.js | 4 ----
 1 file changed, 4 deletions(-)

History-তে কিছুই মোছেনি: f469880 যেমন ছিল, তেমনই আছে, আর ওপরে নতুন 5fcff4a. বার্তায় Git নিজেই লিখে দিয়েছে কোন commit উল্টানো হলো — পরে কেউ খুঁজলে পুরো গল্প পাবেন। --no-edit না দিলে Git বার্তা লেখার জন্য editor খোলে; ভালো চর্চা হলো সেখানে কেন উল্টানো হলো তা এক লাইনে লেখা।

খেয়াল করুন, আমরা HEAD~1 উল্টিয়েছি, অর্থাৎ শেষটির আগের commit. Revert যেকোনো পুরোনো commit-এ চলে, যদি পরের commit-গুলো একই লাইন না ছুঁয়ে থাকে। ছুঁয়ে থাকলে conflict হতে পারে, যা merge-এর conflict-এর মতো করেই মেটাতে হয় (পর্ব ১৩)। কয়েকটি commit একসাথে উল্টাতে git revert --no-commit A..B, তারপর একটি commit.

Merge commit উল্টানো — -m লাগে

একটি merge commit-এর দুটি parent থাকে। “উল্টো পরিবর্তন” মানে কোন parent-এর তুলনায়? Git নিজে ঠিক করে না, আপনাকে বলতে হয়। একটি আলাদা ছোট repository-তে:

$ git log --oneline --graph
*   075c171 Merge branch 'feature'
|\
| * e82c547 Add feature
* | 0f0d1e0 Main work
|/
* e3e3874 Base
$ git revert HEAD
error: commit 075c1716991ddc948cbac2499e86b0d425698972 is a merge but no -m option was given.
fatal: revert failed
$ git revert -m 1 --no-edit HEAD
[main 897a62d] Revert "Merge branch 'feature'"
 Date: Thu Jan 15 10:14:00 2026 +0600
 1 file changed, 1 deletion(-)
 delete mode 100644 f.txt

-m 1 মানে প্রথম parent (merge-এর সময় যে branch-এ ছিলেন, এখানে main) হলো মূল ধারা; feature থেকে যা এসেছিল, শুধু সেটুকু উল্টানো হবে। একটি সূক্ষ্ম ফাঁদ: এরপর একই feature branch আবার merge করলে Git মনে করে ওই commit-গুলো আগেই মেলানো হয়েছে, তাই পরিবর্তনগুলো আর ফেরে না। তখন revert-টিকেই revert করতে হয়। Git-এর নিজস্ব documentation-এ এ নিয়ে একটি পুরো লেখা আছে (“How to revert a faulty merge”); merge-এর ভেতরের যুক্তি পর্ব ৫৪-এ।

Reset + force push বনাম revert — দুই clone-এ কী ঘটে

এবার মডেলটি দুই মানুষের। Origin-এ A-B-C, আর C-তে একটি bug. করিম C pull করে তার ওপর D (search ফিচার) বানিয়েছেন, এখনো push করেননি। রহিম দুইভাবে bug সরাতে পারেন। প্রথম পথে তিনি reset --hard B করে একটি নতুন fix E বানিয়ে force push করেন। দ্বিতীয় পথে তিনি git revert C দিয়ে R বানিয়ে সাধারণ push করেন। তারপর করিম pull করেন (merge):

// Shared history: A-B-C is on origin; C added a bug. Karim already has C and adds D.
const C = {}; // id -> { parents, files: Set }
function commit(id, parents, files) { C[id] = { parents, files: new Set(files) }; return id; }
function ancestors(id, seen = new Set()) {
  if (!seen.has(id)) { seen.add(id); for (const p of C[id].parents) ancestors(p, seen); } return seen;
}
function mergeBase(a, b) { // nearest common ancestor (enough for this small graph)
  const A = ancestors(a); let best = null;
  for (const x of ancestors(b)) if (A.has(x) && (!best || ancestors(x).has(best))) best = x;
  return best;
}
function merge(id, ours, theirs) { // three-way merge, file by file
  const base = C[mergeBase(ours, theirs)].files, o = C[ours].files, t = C[theirs].files;
  const all = new Set([...base, ...o, ...t]), out = [];
  for (const f of all) { const keep = o.has(f) === base.has(f) ? t.has(f) : o.has(f); if (keep) out.push(f); }
  return commit(id, [ours, theirs], out.sort());
}
const log = (name, id) => console.log(name.padEnd(9), ("{" + [...ancestors(id)].sort().join(",") + "}").padEnd(16),
                                      "files:", [...C[id].files].join(", "));
commit("A", [], ["cart"]); commit("B", ["A"], ["cart", "fee"]); commit("C", ["B"], ["cart", "fee", "BUG"]);
commit("D", ["C"], ["cart", "fee", "BUG", "search"]);          // Karim's local work on top of C

console.log("--- way 1: Rahim runs reset --hard B, adds fix E, push --force");
commit("E", ["B"], ["cart", "fee", "coupon"]);                  // origin/main is now E
console.log("Karim ahead/behind:", [...ancestors("D")].filter(x => !ancestors("E").has(x)).length,
            "/", [...ancestors("E")].filter(x => !ancestors("D").has(x)).length);
log("pull->M1", merge("M1", "D", "E"));

console.log("--- way 2: Rahim runs git revert C (new commit R), normal push");
commit("R", ["C"], ["cart", "fee"]);                            // origin/main is now R
console.log("Karim ahead/behind:", [...ancestors("D")].filter(x => !ancestors("R").has(x)).length,
            "/", [...ancestors("R")].filter(x => !ancestors("D").has(x)).length);
log("pull->M2", merge("M2", "D", "R"));

--- way 1: Rahim runs reset --hard B, adds fix E, push --force
Karim ahead/behind: 2 / 1
pull->M1  {A,B,C,D,E,M1}   files: BUG, cart, coupon, fee, search
--- way 2: Rahim runs git revert C (new commit R), normal push
Karim ahead/behind: 1 / 1
pull->M2  {A,B,C,D,M2,R}   files: cart, fee, search

৬ · git clean — untracked ফাইল পরিষ্কার

restore আর reset শুধু tracked ফাইল নিয়ে কাজ করে। Build-এর পর জমে থাকা debug.log বা tmp/ ফোল্ডারের মতো যেসব ফাইল Git কখনো track করেনি (untracked), সেগুলো তারা ছোঁয় না। এগুলো সরাতে git clean. নিয়ম একটাই: আগে -n (dry run), তারপর -f.

$ git status --short
?? debug.log
?? tmp/
$ git clean -n
Would remove debug.log
$ git clean -nd
Would remove debug.log
Would remove tmp/
$ git clean -fd
Removing debug.log
Removing tmp/
$ git status --short

Untracked ফাইল Git-এর কাছে কখনো ছিল না, তাই git clean-এ মোছা ফাইল reflog বা অন্য কোনো Git command দিয়ে ফেরে না — সাধারণত recycle bin-এও যায় না। -x বিশেষ বিপজ্জনক: .env-এর মতো ignore করা ফাইলে প্রায়ই এমন গোপন তথ্য থাকে যা repository-তে কখনো রাখা হয়নি। কোন ফাইল ignore হবে, তা পর্ব ১০-এ দেখেছেন।

৭ · Reflog — Git-এর নিরাপত্তা জাল

অংশ ৪-এর শেষে আমরা git reset --hard HEAD~1 দিয়ে d09aad4-কে log থেকে “হারিয়ে” ফেলেছিলাম। এখন কি তাকে ফেরানো যায়? যায়। Git প্রতিবার HEAD বা কোনো branch সরালে একটি local খাতায় লিখে রাখে: আগে কোথায় ছিল, এখন কোথায়, কোন command-এর কারণে। এই খাতার নাম reflog. মুদি দোকানের হিসাবের খাতার মতো — দিনের প্রতিটি লেনদেন ক্রমানুসারে লেখা থাকে, ভুল লেনদেনও।

$ git reflog
f469880 HEAD@{0}: reset: moving to HEAD~1
d09aad4 HEAD@{1}: reset: moving to ORIG_HEAD
f469880 HEAD@{2}: reset: moving to HEAD~1
d09aad4 HEAD@{3}: reset: moving to ORIG_HEAD
f469880 HEAD@{4}: reset: moving to HEAD~1
d09aad4 HEAD@{5}: commit (amend): Add delivery fee
97611f9 HEAD@{6}: commit: Add delivry fee
f469880 HEAD@{7}: commit: Add discount rule
f8f0806 HEAD@{8}: commit: Add cart total
df9c5fe HEAD@{9}: commit (initial): Add README
$ git branch rescue d09aad4
$ git log --oneline -1 rescue
d09aad4 Add delivery fee
$ git reset --hard HEAD@{1}
HEAD is now at d09aad4 Add delivery fee
$ git log --oneline
d09aad4 Add delivery fee
f469880 Add discount rule
f8f0806 Add cart total
df9c5fe Add README
$ git branch -d rescue
Deleted branch rescue (was d09aad4).

ওপর থেকে নিচে নতুন থেকে পুরোনো। HEAD@{0} এখনকার অবস্থান, HEAD@{1} তার ঠিক আগে HEAD যেখানে ছিল, এভাবে। অংশ ৪-এর soft আর mixed পরীক্ষার পর ORIG_HEAD দিয়ে ফেরার চলাচলও লেখা আছে — reflog কিছুই বাদ দেয় না। নিচে 97611f9-ও আছে, amend-এর আগের সেই ভুল-বানানের commit. উদ্ধারের দুটি পথ দেখানো হয়েছে: git branch rescue d09aad4 একটি নতুন branch বসিয়ে commit-টিকে নিরাপদ করে, কিছুই না বদলে; তারপর git reset --hard HEAD@{1} main-কে সেখানে ফেরায়। Working tree-তে অসংরক্ষিত কাজ থাকলে --hard-এর বদলে আগে branch বসানোই নিরাপদ।

নিচের মডেলে একটি “ব্যস্ত, একটু অসাবধান দিন” তৈরি হয় seed-দেওয়া এলোমেলো সংখ্যা দিয়ে (PRNG mulberry32, তাই প্রতিবার একই ফল): প্রতি ধাপে হয় নতুন commit, নয়তো একটি reset --hard HEAD~1. তারপর প্রোগ্রাম খোঁজে কোন commit reflog-এ আছে কিন্তু main থেকে আর পৌঁছানো যায় না, আর সেগুলো ফেরায়। Hash এখানে FNV-1a, Git-এর SHA-1-এর বদলে একটি ছোট হিসাব:

// Reflog: every move of HEAD is written down, so a "lost" commit can be found again.
function mulberry32(a) { return () => { a = (a + 0x6D2B79F5) | 0; let t = Math.imul(a ^ (a >>> 15), 1 | a);
  t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; }
function fnv1a(s) { let h = 0x811c9dc5; for (const ch of s) { h ^= ch.charCodeAt(0); h = Math.imul(h, 0x01000193); }
  return (h >>> 0).toString(16).padStart(8, "0").slice(0, 7); }   // stands in for Git's SHA-1
const parentOf = {}, reflog = [];        // reflog[0] is the newest entry, like HEAD@{0}
let head = null, n = 0;
function move(to, why) { head = to; reflog.unshift({ id: to, why }); }
function commit(msg) { const id = fnv1a(msg + (head || "") + n++); parentOf[id] = head; move(id, "commit: " + msg); }
const rnd = mulberry32(15);
commit("Add README");
for (let i = 1; i <= 7; i++) {                            // a busy, slightly careless day
  if (rnd() < 0.6 || !parentOf[head]) commit("work " + i);
  else move(parentOf[head], "reset: moving to HEAD~1");     // like git reset --hard HEAD~1
}
reflog.forEach((e, i) => console.log(`${e.id} HEAD@{${i}}: ${e.why}`));
const reachable = new Set(); for (let c = head; c; c = parentOf[c]) reachable.add(c);
const lost = [...new Set(reflog.map(e => e.id))].filter(id => !reachable.has(id));
console.log("on main now :", [...reachable].reverse().join(" <- "));
console.log("only in reflog (lost):", lost.join(", ") || "none");
const tip = lost.find(id => !lost.some(x => parentOf[x] === id));   // lost commit with no lost child
const pick = reflog.findIndex(e => e.id === tip);
move(tip, `reset: moving to HEAD@{${pick}}`);              // git reset --hard HEAD@{n}
const back = []; for (let c = head; c; c = parentOf[c]) back.push(c);
console.log(`git reset --hard HEAD@{${pick}} -> HEAD = ${head}`);
console.log("still lost:", lost.filter(id => !back.includes(id)).join(", ") || "none");

345a3eb HEAD@{0}: reset: moving to HEAD~1
f0bbec3 HEAD@{1}: reset: moving to HEAD~1
68f8092 HEAD@{2}: commit: work 5
f0bbec3 HEAD@{3}: commit: work 4
345a3eb HEAD@{4}: commit: work 3
4286e30 HEAD@{5}: commit: work 2
04f1121 HEAD@{6}: commit: work 1
69c1b2e HEAD@{7}: commit: Add README
on main now : 69c1b2e <- 04f1121 <- 4286e30 <- 345a3eb
only in reflog (lost): f0bbec3, 68f8092
git reset --hard HEAD@{2} -> HEAD = 68f8092
still lost: none

যা ফেরানো যায় না

৮ · শেয়ার করা branch-এর সোনালি নিয়ম

পুরো পর্বকে একটি সারণিতে আনা যায়: কোন command কোন এলাকা বদলায়, আর কোনটি history নতুন করে লেখে।

1. Push-করা commit-এ --amend, reset বা rebase নয়। উল্টাতে হলে git revert.
2. Shared branch-এ force push নয়। নিজের feature branch-এ একান্ত দরকারে git push --force-with-lease — এটি শেষ fetch-এর পর অন্য কেউ push করে থাকলে থেমে যায়, সাধারণ --force থামে না (remote-এর বিস্তারিত পর্ব ১৪-এ)।
3. বিপজ্জনক command-এর আগে git status আর git stash বা একটি backup branch. git branch backup-before-reset লিখতে দুই সেকেন্ড লাগে।
4. git clean-এ সবসময় আগে -n.
5. কিছু হারালে থামুন। আর command না চালিয়ে git reflog পড়ুন, hash লিখে রাখুন, branch বসান।
6. Secret ভুলে push হয়ে গেলে revert যথেষ্ট নয়। সেটি history-তে থেকে যায়; আগে secret বাতিল করে নতুন বানান, তারপর history পরিষ্কারের কথা ভাবুন (পর্ব ৫৭)।

পুরোনো local commit গুছিয়ে নেওয়ার আরও সূক্ষ্ম হাতিয়ার আছে — কয়েকটি commit মেলানো, ক্রম বদলানো, মাঝের একটির বার্তা বদলানো। সেটি interactive rebase, পর্ব ১৫-এ। আর push হওয়ার আগে কাজ গুছিয়ে pull request খোলার ধারা পর্ব ১৬-এ।

৯ · AI-এর যুগে — undo-র পরামর্শ যাচাই

“Git-এ গোলমাল করে ফেলেছি, কীভাবে ঠিক করব?” — এই প্রশ্নে AI প্রায়ই সবচেয়ে ছোট উত্তরটি দেয়: git reset --hard origin/main বা git push --force. দুটিই কাজ করে, আর দুটিই বিনা সতর্কতায় কাজ মুছে দিতে পারে। AI আপনার working tree দেখতে পায় না, জানে না কোন branch শেয়ার করা, কে কী pull করেছেন। Undo-র ক্ষেত্রে AI-এর সাধারণ ভুলগুলো:

AI-এর দেওয়া undo command চালানোর আগে — চেকলিস্ট

• git status দেখেছি — কোনো অসংরক্ষিত কাজ নেই, বা stash/backup branch নিয়েছি
• জানি commit-টি push হয়েছে কি না, আর branch-টি শেয়ার করা কি না
• প্রতিটি flag git help <command>-এ মিলিয়েছি — বানানো flag নয়
• --hard, --force বা clean -f থাকলে আগে dry run বা throwaway clone-এ চালিয়েছি
• চালানোর পর git log --oneline আর git diff দেখে মিলিয়েছি যে ঠিক যা চেয়েছি তাই হয়েছে
• ভুল হলে reflog-এ কোন লাইনে ফিরব, তা জানি