History আর পার্থক্য দেখা — status, diff, log আর show

১ · তিনটি এলাকা, চারটি প্রশ্ন

একটি পরিচিত দৃশ্য দিয়ে শুরু করি। রহিম একটি কাল্পনিক মুদি দোকানের হিসাবের ছোট program বানাচ্ছেন — bill.py ফাইলে দামের যোগফল, prices.txt ফাইলে দামের তালিকা। সকালে কয়েকটি জিনিস বদলালেন, দুপুরে আরও কিছু। বিকেলে commit করতে বসে তাঁর মাথায় চারটি প্রশ্ন: কোন কোন ফাইল বদলেছি? প্রতিটিতে ঠিক কী বদলেছে? এর মধ্যে কতটা পরের commit-এ যাবে? আর গত সপ্তাহে Nasrin যে discount-এর কাজ করেছিলেন, সেটা কোন commit-এ?

Git-এ এই চারটি প্রশ্নের জন্য চারটি command আছে, আর চারটিই শুধু পড়ে — কোনো ফাইল, index বা history বদলায় না। তাই এগুলো ভয় ছাড়াই যতবার খুশি চালানো যায়। কিন্তু উত্তর ঠিকভাবে পড়তে হলে আগে মনে রাখতে হবে, পর্ব ৮-এ (প্রথম Git repository) দেখা তিনটি এলাকা কী কী।

তিনটি এলাকায় একই ফাইলের তিনটি ভিন্ন রূপ থাকতে পারে। আর HEAD হলো “আপনি এখন কোথায়” তার চিহ্ন — সাধারণত একটি branch-এর নাম, আর সেই branch-এর সর্বশেষ commit. Branch আর HEAD-এর ভেতরের কাজ পর্ব ১২-এ (Branch — pointer, HEAD, switch) আসবে; আজ শুধু জানলেই চলবে যে HEAD মানে “শেষ commit”.

এই পর্বের সব আউটপুট আসল: Git ২.৫৩ দিয়ে একটি খালি folder-এ bazar নামের একটি ছোট repository বানিয়ে চালানো। লেখক Rahim (rahim@example.com) আর Nasrin (nasrin@example.com), দুজনই কাল্পনিক। Commit-এর সময় ইচ্ছে করে নির্দিষ্ট করা — ১৫ থেকে ২২ জানুয়ারি ২০২৬, প্রতিদিন সকাল ১০টা (+06:00). একই ফাইল, একই নাম আর একই সময় দিয়ে আপনি নিজে বানালে commit-এর hash-ও হুবহু একই আসবে, কারণ hash হিসাব হয় এই তথ্যগুলো থেকেই। History-টির commit graph এরকম — আট দিনে আটটি commit, মাঝে একটি ছোট branch আর একটি merge:

$ git log --oneline --graph --all --decorate
*   8ef86df (HEAD -> main) Merge branch 'discount'
|\  
| * 4663630 (discount) Apply eid discount to the total
| * 7830cb6 Add eid discount function
* | dbc8f82 Update onion price
* | 50032f9 Move notes into docs folder
|/  
* 058bc63 Fix price names and round the total
* daa3560 Add bill calculator
* 38690bb Add price list and README

এখনই সব চিহ্ন বোঝার দরকার নেই। অংশ ৬-এ এই ছবি লাইন ধরে পড়ব, আর অংশ ৭-এ এর ওপর হাঁটব।

২ · git status — এখন কোন ফাইল কোন অবস্থায়

ধরুন উপরের history-র পরে রহিম আরও কিছু কাজ করলেন, এখনো commit করেননি: prices.txt-এ চিনির দাম যোগ করে git add করলেন; bill.py-তে discount-এর হার বদলে git add করলেন, তারপর ফাইলের প্রথম লাইনের মন্তব্যও বদলালেন (সেটি add করেননি); README.md-তে একটি লাইন যোগ করলেন; নতুন test_bill.py বানিয়ে add করলেন; git mv দিয়ে docs/notes.txt-এর নাম বদলালেন; আর todo.txt নামে একটি নতুন ফাইল খুললেন, add করেননি। এবার git status:

$ git status
On branch main
Changes to be committed:
  (use "git restore --staged <file>..." to unstage)
	modified:   bill.py
	renamed:    docs/notes.txt -> docs/meeting-notes.txt
	modified:   prices.txt
	new file:   test_bill.py

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:   README.md
	modified:   bill.py

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

আউটপুটের তিনটি অংশ তিনটি আলাদা তুলনা:

• Changes to be committed — index আর শেষ commit-এর পার্থক্য। এখন git commit চালালে ঠিক এগুলোই যাবে। ফাইলের নাম বদল (renamed) আর নতুন ফাইল (new file)-ও এখানে।
• Changes not staged for commit — working tree আর index-এর পার্থক্য। বদলেছেন, কিন্তু add করেননি; commit চালালে এগুলো যাবে না.
• Untracked files — Git এই ফাইলগুলোকে এখনো চেনে না: এগুলো শেষ commit-এও নেই, index-এও নেই। এমন ফাইলকে বলে untracked file; বাকিগুলো tracked.

খেয়াল করুন, bill.py দুটি অংশেই আছে! কারণ এর তিনটি রূপ তিন রকম: শেষ commit-এ পুরোনো হার, index-এ নতুন হার, আর working tree-তে নতুন হার আর নতুন মন্তব্য। Git ফাইল নয়, ফাইলের অবস্থা stage করে — git add চালানোর মুহূর্তে যা ছিল, তা-ই। পরে বদলালে সেটা আবার আলাদা পরিবর্তন।

ছোট রূপ: git status -s আর দুই কলামের কোড

লম্বা আউটপুট নতুনদের জন্য ভালো, কিন্তু অনেক ফাইলে দ্রুত চোখ বোলাতে ছোট রূপ (-s বা --short) সুবিধার। -b যোগ করলে প্রথম লাইনে branch-এর নামও দেখায়:

$ git status -s
 M README.md
MM bill.py
R  docs/notes.txt -> docs/meeting-notes.txt
M  prices.txt
A  test_bill.py
?? todo.txt
$ git status -sb
## main
 M README.md
MM bill.py
R  docs/notes.txt -> docs/meeting-notes.txt
M  prices.txt
A  test_bill.py
?? todo.txt

প্রতিটি লাইনের শুরুতে ঠিক দুটি অক্ষর, তারপর একটি ফাঁকা ঘর, তারপর path. প্রথম অক্ষর X = index বনাম শেষ commit (staged অংশ); দ্বিতীয় অক্ষর Y = working tree বনাম index (unstaged অংশ)। ফাঁকা ঘর মানে “এই তুলনায় পার্থক্য নেই”। তাই M␣ আর ␣M দেখতে প্রায় এক, অর্থ সম্পূর্ণ আলাদা — ফাঁকা ঘরটি কোন পাশে, সেটাই আসল খবর।

টেবিলে “␣” চিহ্ন একটি ফাঁকা ঘর বোঝাতে; আসল আউটপুটে সেখানে সাধারণ space থাকে।

নিচের ছোট program-টি ঠিক এই নিয়মে প্রতিটি লাইন ভেঙে ব্যাখ্যা করে, আর বলে কোন diff command দিয়ে পরিবর্তনটি দেখা যাবে। উপরের আসল আউটপুটের ছয়টি লাইনের সাথে আরও তিনটি সাধারণ অবস্থা যোগ করা হয়েছে:

// Explain "git status --short" lines. X = index vs HEAD, Y = working tree vs index.
const CODE = { " ": "unchanged", M: "modified", T: "type changed", A: "added", D: "deleted",
               R: "renamed", C: "copied", U: "unmerged" };
const lines = [" M README.md", "MM bill.py", "R  docs/notes.txt -> docs/meeting-notes.txt",
  "M  prices.txt", "A  test_bill.py", "?? todo.txt", "AM app.js", " D old.txt", "UU shop.py"];
function explain(line) {
  const X = line[0], Y = line[1], path = line.slice(3);
  if (X === "?" && Y === "?") return [path, "untracked: Git does not follow it yet", "-"];
  if (X === "!" && Y === "!") return [path, "ignored (shown only with --ignored)", "-"];
  if (X === "U" || Y === "U" || (X === "A" && Y === "A") || (X === "D" && Y === "D"))
    return [path, "merge conflict: fix the file, then git add", "git diff"];
  const cmds = [];
  if (X !== " ") cmds.push("git diff --staged");   // index differs from HEAD
  if (Y !== " ") cmds.push("git diff");            // working tree differs from index
  return [path, "index: " + CODE[X] + " | worktree: " + CODE[Y], cmds.join(" + ")];
}
const rows = lines.map((l) => [l.slice(0, 2).replace(/ /g, "_"), ...explain(l)]);
console.log("XY  " + "path".padEnd(24) + "meaning".padEnd(44) + "see it with");
for (const [xy, p, m, c] of rows)
  console.log(xy.padEnd(4) + (p.length > 23 ? p.slice(0, 20) + "..." : p).padEnd(24) + m.padEnd(44) + c);
const staged = lines.filter((l) => !"?! U".includes(l[0])).length;
const unstaged = lines.filter((l) => !"?! U".includes(l[1])).length;
console.log(`\n${staged} entries have something staged, ${unstaged} have unstaged changes.`);

XY  path                    meaning                                     see it with
_M  README.md               index: unchanged | worktree: modified       git diff
MM  bill.py                 index: modified | worktree: modified        git diff --staged + git diff
R_  docs/notes.txt -> do... index: renamed | worktree: unchanged        git diff --staged
M_  prices.txt              index: modified | worktree: unchanged       git diff --staged
A_  test_bill.py            index: added | worktree: unchanged          git diff --staged
??  todo.txt                untracked: Git does not follow it yet       -
AM  app.js                  index: added | worktree: modified           git diff --staged + git diff
_D  old.txt                 index: unchanged | worktree: deleted        git diff
UU  shop.py                 merge conflict: fix the file, then git add  git diff

5 entries have something staged, 4 have unstaged changes.

৩ · git diff — কোন দুটি জিনিসের তুলনা

git status বলে কোন ফাইল বদলেছে; diff বলে কোন লাইন. সবচেয়ে বড় ভুল বোঝাবুঝি হলো ভাবা যে git diff মানে “শেষ commit-এর পর যা বদলেছে”। না — শুধু git diff মেলায় working tree আর index. তাই যা add করে ফেলেছেন, তা git diff-এ আর দেখায় না। অনেকে git add . করে git diff চালিয়ে কিছু না দেখে ভাবেন “কিছুই বদলায়নি” — অথচ সব পরিবর্তন index-এ বসে আছে।

নিচের stepper-এ bill.py-এর তিনটি রূপের ওপর চারটি diff চালানো হয়েছে। প্রতিটি ধাপে দেখুন বাঁ দিক (−, a/) আর ডান দিক (+, b/) কোন এলাকা, আর index লাইনের দুটি hash কোথা থেকে আসছে:

HEAD     f5d75db  # bill.py - grocery bill for a corner shop
                  return amount * 0.9 if amount >= 1000 ...
Index    b9360c2  # bill.py - grocery bill for a corner shop
                  return amount * 0.95 if amount >= 1000 ...
Worktree b7a6d96  # bill.py - ... corner shop (prices in taka)
                  return amount * 0.95 if amount >= 1000 ...

$ git diff -- bill.py
diff --git a/bill.py b/bill.py
index b9360c2..b7a6d96 100644
--- a/bill.py
+++ b/bill.py
@@ -1,4 +1,4 @@
-# bill.py - grocery bill for a corner shop
+# bill.py - grocery bill for a corner shop (prices in taka)
 PRICES = {}
 
 def load_prices(path):

$ git diff --staged -- bill.py
diff --git a/bill.py b/bill.py
index f5d75db..b9360c2 100644
--- a/bill.py
+++ b/bill.py
@@ -22,4 +22,4 @@ def show(cart):
     print("Total:", eid_discount(bill_total(cart)))
 
 def eid_discount(amount):
-    return amount * 0.9 if amount >= 1000 else amount
+    return amount * 0.95 if amount >= 1000 else amount

$ git diff HEAD -- bill.py
diff --git a/bill.py b/bill.py
index f5d75db..b7a6d96 100644
--- a/bill.py
+++ b/bill.py
@@ -1,4 +1,4 @@
-# bill.py - grocery bill for a corner shop
+# bill.py - grocery bill for a corner shop (prices in taka)
 PRICES = {}
 
 def load_prices(path):
@@ -22,4 +22,4 @@ def show(cart):
     print("Total:", eid_discount(bill_total(cart)))
 
 def eid_discount(amount):
-    return amount * 0.9 if amount >= 1000 else amount
+    return amount * 0.95 if amount >= 1000 else amount

$ git diff HEAD~2 HEAD~1
diff --git a/prices.txt b/prices.txt
index f676f31..8fbde9b 100644
--- a/prices.txt
+++ b/prices.txt
@@ -1,5 +1,5 @@
 rice,72
 lentil,110
-onion,60
+onion,80
 potato,35
 oil,175

সংক্ষেপে দেখা: --stat আর --name-only

বড় পরিবর্তনে প্রথমে পুরো diff নয়, একটি সারাংশ দেখা ভালো। --stat প্রতিটি ফাইলে কত লাইন যোগ (+) আর কত লাইন বাদ (-) হয়েছে তার একটি ছোট দণ্ড দেখায়; --name-only শুধু ফাইলের নাম:

$ git diff --stat
 README.md | 2 ++
 bill.py   | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)
$ git diff --cached --stat
 bill.py                               | 2 +-
 docs/{notes.txt => meeting-notes.txt} | 0
 prices.txt                            | 1 +
 test_bill.py                          | 3 +++
 4 files changed, 5 insertions(+), 1 deletion(-)
$ git diff HEAD --stat
 README.md                             | 2 ++
 bill.py                               | 4 ++--
 docs/{notes.txt => meeting-notes.txt} | 0
 prices.txt                            | 1 +
 test_bill.py                          | 3 +++
 5 files changed, 8 insertions(+), 2 deletions(-)
$ git diff --name-only
README.md
bill.py

যোগফল মিলিয়ে দেখুন: unstaged ৩টি যোগ আর ১টি বাদ, staged ৫টি যোগ আর ১টি বাদ, আর git diff HEAD-এ দুটো মিলে ৮ আর ২. bill.py-এর 2 +- (১টি বদল = ১ বাদ + ১ যোগ) দুই জায়গায়, আর HEAD-এর সাথে 4 ++--. খেয়াল করুন, Git একটি লাইন “বদলানো” বলে আলাদা কিছু জানে না — একটি বদল মানে একটি লাইন বাদ আর একটি নতুন লাইন যোগ। নাম বদলের লাইনে {notes.txt => meeting-notes.txt} আর 0: বিষয়বস্তু একটুও বদলায়নি।

Commit বনাম commit, আর দুই বিন্দু বনাম তিন বিন্দু

$ git diff --stat HEAD~3 HEAD
 bill.py                     | 5 ++++-
 notes.txt => docs/notes.txt | 1 +
 prices.txt                  | 2 +-
 3 files changed, 6 insertions(+), 2 deletions(-)
$ git diff --name-only HEAD~3 HEAD
bill.py
docs/notes.txt
prices.txt
$ git diff --stat main~1..discount
 bill.py                     | 5 ++++-
 docs/notes.txt => notes.txt | 1 -
 prices.txt                  | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)
$ git diff --stat main~1...discount
 bill.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

প্রথম দুটি সোজা: 058bc63 (HEAD~3) থেকে শেষ commit পর্যন্ত তিনটি ফাইল বদলেছে। মাঝের লাইনে notes.txt => docs/notes.txt — Git নিজে নাম বদল লিখে রাখে না; একটি ফাইল উধাও আর প্রায় একই বিষয়বস্তুর নতুন ফাইল দেখে অনুমান করে যে এটি নাম বদল। একে বলে rename detection.

শেষ দুটি ফাঁদের মতো। git diff A..B আসলে git diff A B-এর আরেক লেখা — দুই প্রান্তের সরাসরি তুলনা। main~1-এ notes ফাইলটি docs/-এ সরানো হয়েছিল, কিন্তু discount branch-এ তা হয়নি; তাই সরাসরি তুলনায় দেখায় যেন discount ফাইলটিকে ফেরত এনেছে (docs/notes.txt => notes.txt). অথচ discount branch-এ কেউ notes ছুঁয়েও দেখেননি! তিন বিন্দু A...B মেলায় দুই branch-এর শেষ সাধারণ পূর্বপুরুষ — merge base — থেকে B পর্যন্ত, অর্থাৎ “B-র দিকে কী কী করা হয়েছে”। তাই শুধু bill.py. Pull request-এর পাতায় দেখা diff সাধারণত এই তিন-বিন্দুর ধারণার কাছাকাছি (platform-ভেদে খুঁটিনাটি আলাদা), আর merge base-এর হিসাব পর্ব ৫৪-এ।

শব্দ ধরে দেখা: --word-diff

$ git diff HEAD~2 HEAD~1
diff --git a/prices.txt b/prices.txt
index f676f31..8fbde9b 100644
--- a/prices.txt
+++ b/prices.txt
@@ -1,5 +1,5 @@
 rice,72
 lentil,110
-onion,60
+onion,80
 potato,35
 oil,175
$ git diff --word-diff HEAD~2 HEAD~1
diff --git a/prices.txt b/prices.txt
index f676f31..8fbde9b 100644
--- a/prices.txt
+++ b/prices.txt
@@ -1,5 +1,5 @@
rice,72
lentil,110
[-onion,60-]{+onion,80+}
potato,35
oil,175

সাধারণ diff পুরো লাইন বাদ আর পুরো লাইন যোগ দেখায়। --word-diff একই পরিবর্তন এক লাইনে দেখায়: [-…-] বাদ, {+…+} যোগ। লম্বা অনুচ্ছেদ বা documentation-এ একটি শব্দ বদলালে এটি খুব কাজের। কিন্তু খেয়াল করুন, পুরো onion,60 একটি “শব্দ” ধরা হয়েছে — Git ডিফল্টভাবে শব্দ আলাদা করে শুধু ফাঁকা জায়গা দিয়ে, কমা দিয়ে নয়। চাইলে --word-diff-regex দিয়ে শব্দের নিয়ম বদলানো যায়। আর শুধু space বা tab-এর পরিবর্তন উপেক্ষা করতে -w (--ignore-all-space) — formatting বদলানো কোড review-এ খুব কাজের।

৪ · Unified diff লাইন ধরে পড়া

Code review, pull request, AI-এর দেওয়া patch — সবখানেই আপনি একই বিন্যাস দেখবেন: unified diff. এটি পড়তে পারা আজকের developer-এর মৌলিক সাক্ষরতা। নিচে 058bc63 commit-টি — রহিম একসাথে দুটি ছোট ভুল ঠিক করেছিলেন: দামের তালিকার নামের আশপাশের ফাঁকা জায়গা ছাঁটা, আর মোট টাকা দুই দশমিক ঘরে গোল করা। দুটি পরিবর্তন ফাইলের দুই জায়গায়, তাই দুটি hunk:

$ git show HEAD~3
commit 058bc631869c00d5d9573647e4c74a49bde9446b
Author: Rahim <rahim@example.com>
Date:   Sat Jan 17 10:00:00 2026 +0600

    Fix price names and round the total

diff --git a/bill.py b/bill.py
index 187744d..22b830e 100644
--- a/bill.py
+++ b/bill.py
@@ -5,7 +5,7 @@ def load_prices(path):
     with open(path) as f:
         for line in f:
             name, price = line.split(",")
-            PRICES[name] = float(price)
+            PRICES[name.strip()] = float(price)
 
 def line_total(item, qty):
     return PRICES[item] * qty
@@ -14,7 +14,7 @@ def bill_total(cart):
     total = 0
     for item, qty in cart:
         total += line_total(item, qty)
-    return total
+    return round(total, 2)
 
 def show(cart):
     for item, qty in cart:

প্রথম hunk-টি লাইন ধরে পড়ি। “পরে” চাপুন আর ডানের হিসাবটি খেয়াল করুন — পুরোনো ফাইলের কোন লাইন, নতুন ফাইলের কোন লাইন, আর @@-এর সংখ্যাগুলো কীভাবে মেলে:

1diff --git a/bill.py b/bill.py2index 187744d..22b830e 1006443--- a/bill.py4+++ b/bill.py5@@ -5,7 +5,7 @@ def load_prices(path):6     with open(path) as f:7         for line in f:8             name, price = line.split(",")9-            PRICES[name] = float(price)10+            PRICES[name.strip()] = float(price)11 12 def line_total(item, qty):13     return PRICES[item] * qty

দ্বিতীয় hunk @@ -14,7 +14,7 @@ def bill_total(cart): একইভাবে পড়ুন: পুরোনো লাইন ১৪ থেকে ২০, পরিবর্তনটি লাইন ১৭-এ। প্রথম hunk-এ লাইন সংখ্যা বাড়েনি-কমেনি, তাই দুই দিকের শুরু একই (১৪)। যদি প্রথম hunk-এ দুটি লাইন যোগ হতো, তাহলে দ্বিতীয়টি হতো -14,7 +16,7 — পরের প্রতিটি hunk-এর নতুন-দিকের শুরু আগের সব যোগ-বিয়োগের হিসাব বহন করে।

দুটি পরিবর্তন কখন একটি hunk-এ মিশে যায়? যখন তাদের মাঝে অপরিবর্তিত লাইন context-এর দ্বিগুণ বা তার কম — ডিফল্টে ৬ বা কম। কারণ দুই hunk-এর context তখন একে অপরকে ছুঁয়ে ফেলত। উপরের commit-এ দুই পরিবর্তনের মাঝে (লাইন ৮ আর ১৭) ৮টি লাইন, তাই আলাদা hunk. অনুশীলন ১-এ এটি নিজে যাচাই করবেন।

৫ · Diff কীভাবে হিসাব হয় — LCS থেকে Myers

Git কীভাবে ঠিক করে কোন লাইন “মিলেছে” আর কোনটি যোগ-বিয়োগ? মূল চিন্তা: দুই ফাইলের লাইনের তালিকায় একই ক্রমে থাকা সবচেয়ে বড় লাইন-সমষ্টি খুঁজুন — এগুলো অপরিবর্তিত; বাকি পুরোনো লাইন বাদ, বাকি নতুন লাইন যোগ। এই সমষ্টির নাম longest common subsequence (LCS). LCS যত বড়, যোগ-বিয়োগ তত কম: যোগ-বিয়োগের মোট = (পুরোনো লাইন − LCS) + (নতুন লাইন − LCS).

নিচের program-টি dynamic programming দিয়ে LCS বের করে (DSA কোর্সে LCS আর edit distance দেখুন), তারপর Git-এর নিয়মে ৩টি context লাইন রেখে hunk বানায় আর সঠিক @@ header ছাপে। ইনপুট ঈদের বাজারের দুটি ফর্দ, ১৪ আর ১৫ লাইনের:

// Line diff via LCS (dynamic programming) printed as unified-diff hunks (3 context lines).
// Git's default is Myers' O(ND) algorithm (1986); both find a shortest edit script.
const a = "rice 5kg|lentil 2kg|onion 3kg|garlic 500g|ginger 250g|potato 4kg|oil 2L|salt 1kg|sugar 2kg|milk 3L|semai 4pack|dates 1kg|chicken 3kg|beef 5kg".split("|");
const b = "rice 5kg|lentil 2kg|onion 4kg|garlic 500g|ginger 250g|potato 4kg|oil 2L|salt 1kg|sugar 2kg|milk 3L|semai 4pack|dates 1kg|cardamom 50g|chicken 3kg|beef 6kg".split("|");
function diffOps(a, b) {               // ops: [kind, text, oldIndex, newIndex]
  const n = a.length, m = b.length, L = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
  for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--)
    L[i][j] = a[i] === b[j] ? L[i + 1][j + 1] + 1 : Math.max(L[i + 1][j], L[i][j + 1]);
  const ops = []; let i = 0, j = 0;
  while (i < n || j < m) {
    if (i < n && j < m && a[i] === b[j]) { ops.push([" ", a[i], i, j]); i++; j++; }
    else if (i < n && (j === m || L[i + 1][j] >= L[i][j + 1])) { ops.push(["-", a[i], i, j]); i++; }
    else { ops.push(["+", b[j], i, j]); j++; }
  }
  console.log("LCS length:", L[0][0], "of", n, "old /", m, "new lines");
  return ops;
}
function unified(ops, C = 3) {
  const ch = ops.map((o, k) => (o[0] !== " " ? k : -1)).filter((k) => k >= 0);
  let k = 0;
  while (k < ch.length) {
    let last = k;                         // join changes whose gap is at most 2*C lines
    while (last + 1 < ch.length && ch[last + 1] - ch[last] - 1 <= 2 * C) last++;
    const from = Math.max(0, ch[k] - C), to = Math.min(ops.length - 1, ch[last] + C);
    const part = ops.slice(from, to + 1);
    const oc = part.filter((o) => o[0] !== "+").length, nc = part.filter((o) => o[0] !== "-").length;
    const os = oc ? part[0][2] + 1 : part[0][2], ns = nc ? part[0][3] + 1 : part[0][3];
    console.log(`@@ -${os},${oc} +${ns},${nc} @@`);
    for (const o of part) console.log(o[0] + o[1]);
    k = last + 1;
  }
}
const ops = diffOps(a, b);
console.log("--- a/eid-list.txt\n+++ b/eid-list.txt");
unified(ops);

LCS length: 12 of 14 old / 15 new lines
--- a/eid-list.txt
+++ b/eid-list.txt
@@ -1,6 +1,6 @@
 rice 5kg
 lentil 2kg
-onion 3kg
+onion 4kg
 garlic 500g
 ginger 250g
 potato 4kg
@@ -10,5 +10,6 @@
 milk 3L
 semai 4pack
 dates 1kg
+cardamom 50g
 chicken 3kg
-beef 5kg
+beef 6kg

এই DP পদ্ধতিতে সময় আর memory লাগে পুরোনো লাইন × নতুন লাইনের সমানুপাতিক — ১০ হাজার লাইনের দুই ফাইলে ১০ কোটি ঘর! Git তাই ডিফল্টভাবে ব্যবহার করে Myers-এর algorithm: Eugene W. Myers-এর ১৯৮৬ সালের প্রবন্ধ “An O(ND) Difference Algorithm and Its Variations” (Algorithmica পত্রিকায়)। এখানে N মোট লাইন আর D যোগ-বিয়োগের সংখ্যা; ফাইল দুটি প্রায় একই হলে (D ছোট, যা বাস্তবে প্রায় সবসময়) এটি খুব দ্রুত। উভয় পদ্ধতিই সবচেয়ে কম যোগ-বিয়োগের একটি diff খোঁজে, কিন্তু সমান-ছোট একাধিক diff থাকলে কোনটি বেছে নেবে, তা আলাদা হতে পারে। তার আগে Unix-এর মূল diff program-এর পেছনে ছিল James W. Hunt আর M. Douglas McIlroy-র ১৯৭৬ সালের Bell Labs-এর প্রতিবেদন “An Algorithm for Differential File Comparison”.

Git-এ --diff-algorithm দিয়ে চারটি diff algorithm বেছে নেওয়া যায়: myers (ডিফল্ট), minimal (আরও সময় নিয়ে নিশ্চিতভাবে সবচেয়ে ছোট), patience আর histogram. Patience diff-এর ধারণা সাধারণত Bram Cohen-এর বলে ধরা হয়: আগে দুই ফাইলে একবারই আসে এমন লাইন (যেমন একটি function-এর নাম) জোড়া দেওয়া, তারপর মাঝের অংশ। Histogram তার একটি দ্রুত রূপ, JGit প্রকল্প থেকে Git-এ এসেছে বলে জানা যায়। কোড সরানো বা নতুন function ঢোকানোর ক্ষেত্রে এ দুটি অনেক সময় মানুষের কাছে বেশি স্বাভাবিক diff দেয় — যেমন } বা ফাঁকা লাইনের মতো সাধারণ লাইন ভুল জায়গায় জোড়া না লাগানো — তবে সবসময় নয়, আর কোনটি “ভালো” তা অনেকটা রুচি। এই পর্বের দুটি উদাহরণে চারটিই একই ফল দেয়। স্থায়ীভাবে বদলাতে git config diff.algorithm histogram; config-এর বিস্তারিত পর্ব ১০-এ।

৬ · git log — history-তে খোঁজা

মুদি দোকানের হিসাবের খাতার কথা ভাবুন: প্রতিদিনের entry-তে তারিখ, কে লিখেছেন, কী লেনদেন। মাস শেষে হয়তো জানতে চান, “কোন দিন পেঁয়াজের দাম বদলেছিল?” বা “Nasrin আপা কোন কোন entry করেছেন?” git log হলো এই খাতা পড়ার যন্ত্র — আর তার অসংখ্য option হলো খাতায় দ্রুত খোঁজার কৌশল। কিছু না দিলে এটি HEAD থেকে পেছনে হেঁটে প্রতিটি commit-এর পূর্ণ hash, লেখক, তারিখ আর বার্তা দেখায় (-n 2 বা -2 = শুধু প্রথম দুটি):

$ git log -n 2
commit 8ef86df964edcab96ca448ed6627d790f6b901d6
Merge: dbc8f82 4663630
Author: Rahim <rahim@example.com>
Date:   Thu Jan 22 10:00:00 2026 +0600

    Merge branch 'discount'

commit dbc8f8272bfed101c82d5364113b6cbadb8912e3
Author: rahim <rahim@home.example.com>
Date:   Wed Jan 21 10:00:00 2026 +0600

    Update onion price

প্রথম commit-টি একটি merge commit — তাই একটি বাড়তি লাইন Merge: dbc8f82 4663630, অর্থাৎ এর দুটি parent. লম্বা আউটপুট টার্মিনালে সাধারণত একটি pager-এ (প্রায়ই less) খোলে: স্পেস চাপলে পরের পাতা, /শব্দ দিয়ে খোঁজা, q চাপলে বেরিয়ে আসা। অনেক নতুন ব্যবহারকারী এখানে আটকে যান — শুধু q.

$ git log --oneline
8ef86df Merge branch 'discount'
dbc8f82 Update onion price
50032f9 Move notes into docs folder
4663630 Apply eid discount to the total
7830cb6 Add eid discount function
058bc63 Fix price names and round the total
daa3560 Add bill calculator
38690bb Add price list and README

--oneline প্রতিটি commit এক লাইনে: ছোট hash আর বার্তার প্রথম লাইন। ক্রমটি খেয়াল করুন: 50032f9 (২০ জানুয়ারি) এর পরে 4663630 (১৯ জানুয়ারি) — ডিফল্টে git log commit-গুলো তারিখের উল্টো ক্রমে সাজায়, ফলে দুই branch-এর commit মিশে যায়। তাই অংশ ১-এর --graph ছবিটি অনেক বেশি তথ্য দেয়: * একটি commit, | একটি ধারা, |\ যেখানে merge commit-এর দ্বিতীয় parent-এর দিকে ধারা ভাগ হয়েছে, |/ যেখানে ধারাটি branch তৈরির জায়গায় মিলেছে। --all সব branch থেকে history দেখায় (শুধু HEAD থেকে নয়), আর --decorate বন্ধনীতে branch-এর নাম দেখায় — (HEAD -> main) মানে HEAD এখন main branch-এ। নতুন Git-এ টার্মিনালে --decorate সাধারণত নিজেই চালু থাকে। --graph চালু থাকলে Git সাজানোর ক্রমও বদলায়, যাতে একটি ধারার commit পাশাপাশি থাকে।

খোঁজার filter

$ git log --oneline --author=Nasrin
4663630 Apply eid discount to the total
7830cb6 Add eid discount function
$ git log --oneline --author=Rahim
8ef86df Merge branch 'discount'
50032f9 Move notes into docs folder
058bc63 Fix price names and round the total
daa3560 Add bill calculator
38690bb Add price list and README
$ git log --oneline -i --author=rahim
8ef86df Merge branch 'discount'
dbc8f82 Update onion price
50032f9 Move notes into docs folder
058bc63 Fix price names and round the total
daa3560 Add bill calculator
38690bb Add price list and README
$ git log --oneline --since="2026-01-18T00:00+06:00" --until="2026-01-20T23:59+06:00"
50032f9 Move notes into docs folder
4663630 Apply eid discount to the total
7830cb6 Add eid discount function
$ git log --oneline --grep=discount
8ef86df Merge branch 'discount'
4663630 Apply eid discount to the total
7830cb6 Add eid discount function

• --author=Nasrin — লেখকের নাম বা email-এ লেখাটি আছে এমন commit (আসলে একটি regular expression). খেয়াল করুন, --author=Rahim dbc8f82 দেখায়নি, কারণ সেই commit-এ নাম ছোট হাতের rahim. -i দিলে বড়-ছোট হাতের পার্থক্য উপেক্ষা হয়। একই মানুষের দুই রকম নাম — অংশ ৮-এ এর সমাধান।
• --since / --until — সময়ের সীমা; "2 weeks ago" বা "yesterday"-এর মতো লেখাও চলে। সীমা মাপা হয় committer-এর তারিখে (লেখকের তারিখে নয়, যদিও এখানে দুটো একই)। সময় অঞ্চল (time zone) না লিখলে আপনার কম্পিউটারের অঞ্চল ধরা হয় — তাই এখানে +06:00 লিখে দেওয়া, যাতে যেকোনো দেশে একই ফল আসে।
• --grep=discount — commit-বার্তায় খোঁজা। Merge commit-এর বার্তাতেও শব্দটি আছে, তাই সেটিও এসেছে। কোডের ভেতরে কোনো লেখা কখন ঢুকল বা বেরোল, তা খুঁজতে git log -S — সেটি পর্ব ৫৫-এ, git blame আর git bisect-এর সাথে।

একটি ফাইলের history: -- path আর --follow

$ git log --oneline -- prices.txt
dbc8f82 Update onion price
38690bb Add price list and README
$ git log --oneline -- docs/notes.txt
50032f9 Move notes into docs folder
$ git log --oneline --follow -- docs/notes.txt
50032f9 Move notes into docs folder
38690bb Add price list and README

---এর পরে path দিলে শুধু সেই ফাইল বা folder ছুঁয়েছে এমন commit. -- চিহ্নটি Git-কে বলে “এর পরে সব path, revision নয়” — ফাইলের নাম কোনো branch-এর নামের মতো হলে এটি বিভ্রান্তি এড়ায়। docs/notes.txt-এর history মাত্র একটি commit দেখাচ্ছে, কারণ এই path-এ ফাইলটি এসেছে 50032f9-এ। --follow দিলে Git নাম বদল পেরিয়ে পেছনে যায় আর পুরোনো নাম notes.txt-এর সময়কার 38690bb-ও খুঁজে পায়। --follow শুধু একটিমাত্র ফাইলের সাথে কাজ করে, আর নাম বদল চেনে অংশ ৩-এর মতো মিল দেখে অনুমানে — তাই নাম বদলের সাথে বিষয়বস্তু অনেক বদলালে ধারাটি হারাতে পারে। পরামর্শ: নাম বদল আর বড় সম্পাদনা আলাদা commit-এ করুন।

প্রতিটি commit-এর পরিবর্তনসহ: --stat আর -p

$ git log --stat -n 1 HEAD~3
commit 058bc631869c00d5d9573647e4c74a49bde9446b
Author: Rahim <rahim@example.com>
Date:   Sat Jan 17 10:00:00 2026 +0600

    Fix price names and round the total

 bill.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

--stat প্রতিটি commit-এর নিচে সারাংশ জুড়ে দেয়; -p (patch) জুড়ে দেয় পুরো diff — অংশ ৪-এর মতো। git log -p -- bill.py হলো একটি ফাইলের পুরো বিবর্তনের গল্প, commit ধরে ধরে।

নিজের মতো format

$ git log -3 --format='%h %an %ar %s'
8ef86df Rahim 9 months ago Merge branch 'discount'
dbc8f82 rahim 9 months ago Update onion price
50032f9 Rahim 9 months ago Move notes into docs folder
$ git log -3 --format='%h %an %ad %s' --date=short
8ef86df Rahim 2026-01-22 Merge branch 'discount'
dbc8f82 rahim 2026-01-21 Update onion price
50032f9 Rahim 2026-01-20 Move notes into docs folder

--format (বা --pretty=format:)-এ % দিয়ে শুরু চিহ্নগুলো তথ্যের জায়গা: %h ছোট hash, %H পূর্ণ hash, %an লেখকের নাম, %ae email, %ad লেখার তারিখ, %ar আপেক্ষিক তারিখ, %s বার্তার প্রথম লাইন, %p parent-দের ছোট hash. সাবধান: %ar-এর “9 months ago” নির্ভর করে আপনি কবে চালাচ্ছেন তার ওপর — এই আউটপুট নেওয়া হয়েছিল ২০২৬ সালের অক্টোবরের শেষে। আপনার স্ক্রিনে অন্য কিছু আসবে, কিন্তু --date=short-এর 2026-01-22 সবখানে একই। Script-এ তাই সবসময় নির্দিষ্ট তারিখের format.

শেষ সারিটি অংশ ৩-এর সতর্কতার সাথে মিলিয়ে নিন। এই repository-তে git log --oneline discount..main দেখায় তিনটি commit — 8ef86df, dbc8f82, 50032f9 — যেগুলো main-এ আছে কিন্তু discount-এ নেই; আর main..discount কিছুই দেখায় না, কারণ discount-এর সব commit ইতিমধ্যে merge হয়ে main-এর অংশ।

৭ · git show আর revision-এর নাম — HEAD~ বনাম HEAD^

git show <commit> একটি commit-এর তথ্য আর তার আগের অবস্থার সাথে diff দেখায় — অংশ ৪-এ git show HEAD~3 ঠিক এটাই ছিল। আর git show <commit>:<path> দেখায় সেই commit-এর সময় ফাইলটি হুবহু কেমন ছিল, working tree না ছুঁয়ে:

$ git show HEAD~2:prices.txt
rice,72
lentil,110
onion,60
potato,35
oil,175
$ git show HEAD:prices.txt
rice,72
lentil,110
onion,80
potato,35
oil,175

পুরোনো দাম দেখতে ফাইল বদলাতে হলো না, কোনো branch-ও বদলাতে হলো না। কোলনের পরের path সবসময় repository-র মূল folder থেকে গোনা। পুরোনো ফাইলটি আলাদা নামে রাখতে চাইলে: git show HEAD~2:prices.txt > old-prices.txt.

Merge commit-এ git show একটি চমক দেয়:

$ git show HEAD
commit 8ef86df964edcab96ca448ed6627d790f6b901d6
Merge: dbc8f82 4663630
Author: Rahim <rahim@example.com>
Date:   Thu Jan 22 10:00:00 2026 +0600

    Merge branch 'discount'
$ git show --stat --format=%h HEAD
8ef86df

 bill.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

কোনো diff নেই! Merge commit-এ ডিফল্টভাবে Git একটি “মিশ্র diff” (combined diff) দেখায়, যেখানে শুধু সেই লাইনগুলো আসে যা কোনো parent-এর সাথেই মেলে না — অর্থাৎ conflict মেটাতে গিয়ে হাতে লেখা অংশ। এই merge-এ conflict ছিল না, তাই কিছুই নেই। কিন্তু --stat দিলে Git ২.৫৩ প্রথম parent-এর সাথে তুলনার সারাংশ দেখায়: merge-এর ফলে main-এ bill.py-তে ৪টি লাইন যোগ, ১টি বাদ। দুই parent-এর সাথে আলাদা আলাদা তুলনা চাইলে git show -m. Merge-এর খুঁটিনাটি পর্ব ১৩-এ (Merge আর conflict).

Commit-কে নাম দেওয়ার ভাষা

উপরে বারবার HEAD~3, HEAD~2 লিখেছি। এগুলোকে বলে revision-এর নাম: commit-কে চেনানোর লেখা, যা Git একটি hash-এ রূপান্তর করে। কয়েকটি মৌলিক রূপ:

• পূর্ণ বা ছোট hash — 8ef86df, এমনকি 8ef8; শর্ত: অন্তত ৪টি অক্ষর আর repository-তে একটিমাত্র object-এর সাথে মেলা। বড় project-এ ৭ অক্ষরও কখনো দ্ব্যর্থক হয়, তাই Git প্রয়োজনে নিজেই লম্বা ছোট-hash দেখায়।
• Branch-এর নাম আর HEAD — main, discount, HEAD.
• X~n — X থেকে প্রথম parent ধরে n ধাপ পেছনে। X~ = X~1.
• X^n — X-এর n-তম parent, এক ধাপেই। X^ = X^1 = X~1. সাধারণ commit-এর parent একটি, তাই সেখানে ^2-এর অর্থ নেই।

এবার আসল Git দিয়ে যাচাই। git rev-parse একটি revision-এর নামকে hash-এ রূপান্তর করে; --short দিলে ছোট hash:

$ git rev-parse --short HEAD
8ef86df
$ git rev-parse --short HEAD~1
dbc8f82
$ git rev-parse --short HEAD^
dbc8f82
$ git rev-parse --short HEAD~2
50032f9
$ git rev-parse --short HEAD^2
4663630
$ git rev-parse --short HEAD^2~1
7830cb6
$ git rev-parse --short HEAD~3
058bc63
$ git rev-parse --short HEAD^2~2
058bc63
$ git log -1 --format='%h parents: %p' HEAD
8ef86df parents: dbc8f82 4663630
$ git rev-parse --short 8ef8
8ef86df
$ git log --oneline -1 HEAD~1^2
fatal: ambiguous argument 'HEAD~1^2': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

শেষ লাইনটি ইচ্ছে করে ভুল: HEAD~1 (dbc8f82) সাধারণ commit, তার দ্বিতীয় parent নেই, তাই Git “unknown revision” বলে থামে। নিচের program-টি এই নিয়মগুলো নিজে প্রয়োগ করে — একই আটটি commit, একই parent-এর তালিকা, প্রথম parent আগে:

// Resolve revision names like HEAD~2, HEAD^2, main^2~1 on a tiny commit DAG.
// parents[0] is the FIRST parent (the branch you were on when you merged).
const commits = {
  "8ef86df": { msg: "Merge branch 'discount'", parents: ["dbc8f82", "4663630"] },
  "dbc8f82": { msg: "Update onion price", parents: ["50032f9"] },
  "50032f9": { msg: "Move notes into docs folder", parents: ["058bc63"] },
  "4663630": { msg: "Apply eid discount to the total", parents: ["7830cb6"] },
  "7830cb6": { msg: "Add eid discount function", parents: ["058bc63"] },
  "058bc63": { msg: "Fix price names and round the total", parents: ["daa3560"] },
  "daa3560": { msg: "Add bill calculator", parents: ["38690bb"] },
  "38690bb": { msg: "Add price list and README", parents: [] },
};
const refs = { main: "8ef86df", discount: "4663630", HEAD: "main" };   // HEAD -> main
function base(name) {
  if (refs[name]) return refs[refs[name]] || refs[name];             // follow HEAD -> main
  const hits = Object.keys(commits).filter((h) => h.startsWith(name));
  if (name.length < 4 || hits.length !== 1) throw new Error(`'${name}': unknown or ambiguous`);
  return hits[0];
}
function resolve(rev) {
  const m = rev.match(/^([^~^]+)((?:[~^]\d*)*)$/);
  let c = base(m[1]); const path = [c];
  for (const [, op, num] of m[2].matchAll(/([~^])(\d*)/g)) {
    const k = num === "" ? 1 : Number(num);
    if (op === "^") {                                 // ^k = k-th parent (^0 = itself)
      if (k > 0) { c = commits[c].parents[k - 1]; if (!c) throw new Error(`${rev}: no parent ${k}`); }
    } else for (let s = 0; s < k; s++) {              // ~k = follow FIRST parent k times
      c = commits[c].parents[0]; if (!c) throw new Error(`${rev}: history too short`);
    }
    path.push(op + k + " " + c);
  }
  return path.join("  ");
}
for (const r of ["HEAD~1", "HEAD^", "HEAD~2", "HEAD^2", "HEAD^2~1", "HEAD~3", "HEAD^^2", "discount~2", "7830"])
  try { console.log(r.padEnd(11), resolve(r)); } catch (e) { console.log(r.padEnd(11), "fatal:", e.message); }

HEAD~1      8ef86df  ~1 dbc8f82
HEAD^       8ef86df  ^1 dbc8f82
HEAD~2      8ef86df  ~2 50032f9
HEAD^2      8ef86df  ^2 4663630
HEAD^2~1    8ef86df  ^2 4663630  ~1 7830cb6
HEAD~3      8ef86df  ~3 058bc63
HEAD^^2     fatal: HEAD^^2: no parent 2
discount~2  4663630  ~2 058bc63
7830        7830cb6

--first-parent option ঠিক “বাবার ধারা” ধরে হাঁটে: git log --oneline --first-parent এই repository-তে দেখায় 8ef86df, dbc8f82, 50032f9, 058bc63, daa3560, 38690bb — main-এর নিজের গল্প, যেখানে পুরো discount-এর কাজ একটি merge commit হিসেবে আসে। দল যদি নিয়ম মেনে প্রতিটি feature merge করে, তাহলে এই দৃশ্য release-এর সারাংশের মতো পড়া যায়। Rebase দিয়ে history সোজা রাখার বিকল্প পথ পর্ব ১৫-এ।

৮ · দলের হিসাব — git shortlog আর .mailmap

git shortlog commit-গুলোকে লেখক অনুযায়ী ভাগ করে। -s শুধু সংখ্যা, -n বেশি থেকে কম ক্রমে, -e email-ও দেখায়:

$ git shortlog -sn HEAD
     5	Rahim
     2	Nasrin
     1	rahim
$ git shortlog -sne HEAD
     5	Rahim <rahim@example.com>
     2	Nasrin <nasrin@example.com>
     1	rahim <rahim@home.example.com>

রহিম দুবার এসেছেন! একটি commit তিনি বাড়ির ল্যাপটপ থেকে করেছিলেন, যেখানে Git-এ নাম ছোট হাতের rahim আর অন্য email দেওয়া ছিল। Git-এর কাছে এরা দুজন আলাদা মানুষ। (টার্মিনালে শুধু git shortlog -sn লিখলেই HEAD থেকে হিসাব হয়; কিন্তু script বা pipe-এর ভেতরে Git তখন commit-এর তালিকা ইনপুট থেকে পড়ার অপেক্ষা করে, তাই সেখানে HEAD লিখে দেওয়া নিরাপদ।)

পুরোনো commit বদলানো যায় না — বদলালে hash বদলে যায় (পর্ব ৫২)। সমাধান হলো repository-র মূল folder-এ একটি .mailmap ফাইল, যা বলে “এই নাম/email আসলে ওই মানুষ”:

$ cat .mailmap
Rahim <rahim@example.com> rahim <rahim@home.example.com>
$ git shortlog -sn HEAD
     6	Rahim
     2	Nasrin
$ git log -1 --format='%h %an / %aN' HEAD~1
dbc8f82 rahim / Rahim

প্রতিটি লাইনের গঠন: আসল-নাম <আসল-email> commit-এ-লেখা-নাম <commit-এ-লেখা-email>. এখন shortlog-এ রহিম ৬. Commit নিজে বদলায়নি — %an এখনো rahim দেখায়, কিন্তু %aN (বড় হাতের N) mailmap মেনে Rahim. Git ২.৫৩-এ সাধারণ git log-এর “Author:” লাইনও ডিফল্টভাবে mailmap মানে। .mailmap সাধারণত commit করে রাখা হয়, যাতে দলের সবাই একই হিসাব পান। আর ভবিষ্যতে এমন ভাঙা নাম এড়াতে প্রতিটি কম্পিউটারে user.name আর user.email একই রাখুন — পর্ব ১০-এর বিষয়।

৯ · AI-এর যুগে — diff পড়তে পারাই আপনার রক্ষাকবচ

AI এখন কোড লেখে, commit-বার্তা লেখে, এমনকি পুরো patch বানিয়ে দেয়। এর মানে আপনার কাজ বদলে যাচ্ছে: লেখার চেয়ে বেশি যাচাই — আর যাচাইয়ের প্রধান যন্ত্র diff. AI-এর দেওয়া পরিবর্তন commit করার আগে git diff আর git diff --staged লাইন ধরে পড়া, --stat দিয়ে দেখা যে AI এমন কোনো ফাইল ছোঁয়নি যা ছোঁয়ার কথা ছিল না — এটুকু অভ্যাস অনেক বড় ভুল আটকায়। এই বিষয়ে AI-এর কিছু পরিচিত ভুল:

AI-এর পরিবর্তন commit করার আগে — চেকলিস্ট

• git status দেখে নিশ্চিত হয়েছি কোন ফাইল staged, কোনটি নয়, আর কোনো অচেনা নতুন ফাইল আছে কি না
• git diff --staged --stat দেখেছি — শুধু প্রত্যাশিত ফাইলই আছে
• git diff --staged লাইন ধরে পড়েছি; প্রতিটি - লাইন কেন বাদ গেল, তা বুঝেছি
• AI-এর সুপারিশ করা প্রতিটি অচেনা flag git help <command>-এ মিলিয়েছি
• যে command কিছু বদলায় (reset, clean, push --force), তা আগে একটি পরীক্ষার clone-এ চালিয়েছি
• Prompt-এ পাঠানো diff থেকে পাসওয়ার্ড, token আর ব্যক্তিগত তথ্য মুছেছি; test চালিয়ে দেখেছি