Git-এর ভেতরে — blob, tree, commit আর content-addressed storage

$ git -c init.defaultBranch=main init -q
$ ls -F .git
HEAD
config
description
hooks/
info/
objects/
refs/
$ cat .git/HEAD
ref: refs/heads/main
$ find .git/objects -type f
$ ls .git/hooks
applypatch-msg.sample
commit-msg.sample
…
pre-commit.sample
pre-push.sample
…
update.sample

$ ls -F .git
COMMIT_EDITMSG
HEAD
config
description
hooks/
index
info/
logs/
objects/
refs/
$ ls -F .git/refs .git/refs/heads .git/logs
.git/logs:
HEAD
refs/

.git/refs:
heads/
tags/

.git/refs/heads:
main

$ echo hello | git hash-object --stdin
ce013625030ba8dba906f756967f9e9ca394464a
$ printf hello | git hash-object --stdin
b6fc4c620b67d95f953a5c1c1230aaab5db5a1b0
$ git add greeting.txt src/cart.js
$ find .git/objects -type f
.git/objects/65/70f20184cd4454ec84681d7683dc1fc5ddce35
.git/objects/ce/013625030ba8dba906f756967f9e9ca394464a
$ git cat-file -t ce01362
blob
$ git cat-file -s ce01362
6
$ git cat-file -p ce01362
hello

// SHA-1 (FIPS 180-4) written out in full, so we can compute Git's object IDs by hand.
function sha1(bytes) {                       // bytes: array of numbers 0..255
  const m = [...bytes, 0x80], bits = bytes.length * 8;
  while (m.length % 64 !== 56) m.push(0);     // pad to 56 bytes mod 64
  for (let i = 7; i >= 0; i--) m.push(Math.floor(bits / 2 ** (8 * i)) & 255);
  const rol = (x, n) => (x << n) | (x >>> (32 - n));
  let h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
  for (let o = 0; o < m.length; o += 64) {    // one 64-byte block at a time
    const w = [];
    for (let i = 0; i < 16; i++) w[i] = (m[o+4*i] << 24) | (m[o+4*i+1] << 16) | (m[o+4*i+2] << 8) | m[o+4*i+3];
    for (let i = 16; i < 80; i++) w[i] = rol(w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16], 1);
    let [a, b, c, d, e] = h;
    for (let i = 0; i < 80; i++) {
      const f = i < 20 ? (b & c) | (~b & d) : i < 40 || i >= 60 ? b ^ c ^ d : (b & c) | (b & d) | (c & d);
      const k = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6][Math.floor(i / 20)];
      const t = (rol(a, 5) + f + e + k + w[i]) | 0;
      e = d; d = c; c = rol(b, 30); b = a; a = t;
    }
    h = h.map((x, i) => (x + [a, b, c, d, e][i]) | 0);
  }
  return h.map(x => (x >>> 0).toString(16).padStart(8, "0")).join("");
}
const utf8 = s => [...new TextEncoder().encode(s)];
// Git's rule: id = SHA-1( "blob " + <size in BYTES> + "\0" + <content> )
function blobId(text) {
  const body = utf8(text);
  return sha1([...utf8("blob " + body.length + "\0"), ...body]);
}
console.log("sha1('abc')     =", sha1(utf8("abc")));   // standard test vector
for (const s of ["hello\n", "hello", "", "সালাম\n"])
  console.log(JSON.stringify(s).padEnd(10), utf8(s).length + " bytes ->", blobId(s));

# How Git stores one loose object: header + content -> SHA-1 name -> zlib bytes on disk
import hashlib
import zlib

content = b"hello\n"
store = b"blob %d\x00" % len(content) + content      # "<type> <size>\0<content>"
oid = hashlib.sha1(store).hexdigest()

print("bytes hashed :", store)
print("object id    :", oid)
print("loose path   : .git/objects/%s/%s" % (oid[:2], oid[2:]))

# Git compresses loose objects with zlib; default level (core.looseCompression) is 1
packed = zlib.compress(store, 1)
print("on-disk size :", len(packed), "bytes")
print("on-disk hex  :", packed.hex())
print("round trip ok:", zlib.decompress(packed) == store)

# The same object in a SHA-256 repository gets a longer, different name
print("sha256 id    :", hashlib.sha256(store).hexdigest())

# Changing one byte changes the whole name (avalanche effect)
other = b"blob 6\x00hellO\n"
print("hellO id     :", hashlib.sha1(other).hexdigest())

$ git cat-file -p 'HEAD^{tree}'
040000 tree 9999772157e6638b8b328b65ddf169040665ef85	docs
100644 blob ce013625030ba8dba906f756967f9e9ca394464a	greeting.txt
100755 blob 5bd7bd58778e6f16e1d1c147693b9abb354ecf34	run.sh
040000 tree be0cf5e51603159fd0863b82dca114773e4c29d4	src
$ git cat-file -p 9999772
100644 blob ce013625030ba8dba906f756967f9e9ca394464a	hello-copy.txt
$ git ls-tree HEAD~1 src
040000 tree be0cf5e51603159fd0863b82dca114773e4c29d4	src
$ git cat-file tree 7d0e48c | xxd
00000000: 3130 3036 3434 2067 7265 6574 696e 672e  100644 greeting.
00000010: 7478 7400 ce01 3625 030b a8db a906 f756  txt...6%.......V
00000020: 967f 9e9c a394 464a 3430 3030 3020 7372  ......FJ40000 sr
00000030: 6300 be0c f5e5 1603 159f d086 3b82 dca1  c...........;...
00000040: 1477 3e4c 29d4                           .w>L).

$ git cat-file -p HEAD
tree f32d1ce7e4f75215b9768171448a5c8ecfd38b0d
parent 17f23e62f1fb909f900e5bd02d6e717a5e6a4569
author Rahim <rahim@example.com> 1768449660 +0600
committer Rahim <rahim@example.com> 1768449660 +0600

Add copy and run script
$ git tag -a v1.0 -m "First release"
$ git cat-file -t v1.0
tag
$ git cat-file -p v1.0
object bd9d66df7d58229921e670ab68ac9471f51750cb
type commit
tag v1.0
tagger Rahim <rahim@example.com> 1768449720 +0600

First release
$ git rev-parse v1.0 'v1.0^{commit}'
0b5a053c1addf8d449d3b9232eeda4ecac173c31
bd9d66df7d58229921e670ab68ac9471f51750cb

$ xxd -l 12 .git/index
00000000: 4449 5243 0000 0002 0000 0002            DIRC........
$ git ls-files --stage
100644 ce013625030ba8dba906f756967f9e9ca394464a 0	docs/hello-copy.txt
100644 ce013625030ba8dba906f756967f9e9ca394464a 0	greeting.txt
100755 5bd7bd58778e6f16e1d1c147693b9abb354ecf34 0	run.sh
100644 6570f20184cd4454ec84681d7683dc1fc5ddce35 0	src/cart.js

// Same full SHA-1 as before (compacted); now rebuild tree and commit objects byte by byte.
function sha1(bytes) {
  const m = [...bytes, 0x80], bits = bytes.length * 8;
  while (m.length % 64 !== 56) m.push(0);
  for (let i = 7; i >= 0; i--) m.push(Math.floor(bits / 2 ** (8 * i)) & 255);
  const rol = (x, n) => (x << n) | (x >>> (32 - n));
  let h = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
  for (let o = 0; o < m.length; o += 64) {
    const w = [];
    for (let i = 0; i < 16; i++) w[i] = (m[o+4*i] << 24) | (m[o+4*i+1] << 16) | (m[o+4*i+2] << 8) | m[o+4*i+3];
    for (let i = 16; i < 80; i++) w[i] = rol(w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16], 1);
    let [a, b, c, d, e] = h;
    for (let i = 0; i < 80; i++) {
      const f = i < 20 ? (b & c) | (~b & d) : i < 40 || i >= 60 ? b ^ c ^ d : (b & c) | (b & d) | (c & d);
      const t = (rol(a, 5) + f + e + [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6][i / 20 | 0] + w[i]) | 0;
      e = d; d = c; c = rol(b, 30); b = a; a = t;
    }
    h = h.map((x, i) => (x + [a, b, c, d, e][i]) | 0);
  }
  return h.map(x => (x >>> 0).toString(16).padStart(8, "0")).join("");
}
const utf8 = s => [...new TextEncoder().encode(s)];
const raw = hex => hex.match(/../g).map(x => parseInt(x, 16));      // 40 hex -> 20 bytes
const obj = (type, body) => sha1([...utf8(type + " " + body.length + "\0"), ...body]);
const entry = (mode, name, id) => [...utf8(mode + " " + name + "\0"), ...raw(id)];
const greeting = obj("blob", utf8("hello\n")), cart = obj("blob", utf8("let total = 0;\n"));
const src = obj("tree", entry("100644", "cart.js", cart));          // the folder src/
const root = obj("tree", [...entry("100644", "greeting.txt", greeting), ...entry("40000", "src", src)]);
const who = "Rahim <rahim@example.com> 1768449600 +0600";            // 2026-01-15 10:00 +06:00
const text = `tree ${root}\nauthor ${who}\ncommitter ${who}\n\nAdd greeting and cart\n`;
console.log("blob greeting.txt :", greeting);
console.log("blob src/cart.js  :", cart);
console.log("tree src/         :", src);
console.log("tree (root)       :", root);
console.log("commit            :", obj("commit", utf8(text)));

$ git rev-parse HEAD
bd9d66df7d58229921e670ab68ac9471f51750cb
$ git rev-parse 'HEAD^{tree}'
f32d1ce7e4f75215b9768171448a5c8ecfd38b0d
$ git rev-parse HEAD:src
be0cf5e51603159fd0863b82dca114773e4c29d4
$ git rev-parse HEAD:src/cart.js
6570f20184cd4454ec84681d7683dc1fc5ddce35
$ git hash-object src/cart.js
6570f20184cd4454ec84681d7683dc1fc5ddce35

$ echo "milk 60" | git hash-object -w --stdin
91bd68f5aaf6a47f67d780330dfe074748fcad75
$ git update-index --add --cacheinfo 100644,91bd68f5aaf6a47f67d780330dfe074748fcad75,notes.txt
$ git write-tree
68bac8fb55ee7f99890cd580c17baea3273d2293
$ echo "Add notes via plumbing" | git commit-tree 68bac8f -p HEAD
80794bae52ca2d7c9c3cf5ade267e84a75f1c6e0
$ git update-ref refs/heads/main 80794bae52ca2d7c9c3cf5ade267e84a75f1c6e0
$ git log --oneline
80794ba Add notes via plumbing
bd9d66d Add copy and run script
17f23e6 Add greeting and cart
$ git status --short
 D notes.txt
$ git restore notes.txt
$ cat notes.txt
milk 60
$ git reflog -1
80794ba HEAD@{0}: 

// Storage model: 3 commits of a small site, each a FULL snapshot of 4 files.
// Content-addressed store: the key is "blob <size>\0<content>" (real Git hashes this key).
const fill = (ch, n) => ch.repeat(n);             // fake file contents of n bytes
const v1 = { "logo.png": fill("L", 40000), "index.html": fill("a", 6000),
             "style.css": fill("s", 3000), "README.md": fill("r", 1000) };
const v2 = { ...v1, "index.html": fill("b", 6100) };          // only index.html edited
const v3 = { ...v2, "style.css": fill("t", 3200),             // style.css edited and
             "about.html": fill("a", 6000) };                 // about.html = old index.html
const store = new Map();                                       // key -> size in bytes
let naiveBytes = 0, copies = 0;
for (const [name, snap] of [["C1", v1], ["C2", v2], ["C3", v3]]) {
  let added = 0, reused = 0;
  for (const content of Object.values(snap)) {
    const key = "blob " + content.length + "\0" + content;
    naiveBytes += content.length; copies++;                    // copy-every-file approach
    if (store.has(key)) reused++;
    else { store.set(key, content.length); added++; }
  }
  console.log(`${name}: ${Object.keys(snap).length} files, new blobs ${added}, reused ${reused}`);
}
const stored = [...store.values()].reduce((a, b) => a + b, 0);
console.log("unique blobs:", store.size, " naive file copies:", copies);
console.log("naive bytes :", naiveBytes);
console.log("blob bytes  :", stored, `(${(100 * (1 - stored / naiveBytes)).toFixed(1)}% saved)`);

$ git count-objects -v
count: 13
size: 1
in-pack: 0
packs: 0
size-pack: 0
prune-packable: 0
garbage: 0
size-garbage: 0
$ git gc -q
$ git count-objects -v
count: 0
size: 0
in-pack: 13
packs: 1
size-pack: 2
…
$ ls .git/objects/pack
pack-bb1a7494860ee2a214cb8c116e4a22f38b7eec99.idx
pack-bb1a7494860ee2a214cb8c116e4a22f38b7eec99.pack
pack-bb1a7494860ee2a214cb8c116e4a22f38b7eec99.rev
$ cat .git/packed-refs
# pack-refs with: peeled fully-peeled sorted
80794bae52ca2d7c9c3cf5ade267e84a75f1c6e0 refs/heads/main
0b5a053c1addf8d449d3b9232eeda4ecac173c31 refs/tags/v1.0
^bd9d66df7d58229921e670ab68ac9471f51750cb

$ git log --oneline
314cfec Price list v4
d839fdc Price list v3
0fb8885 Price list v2
ca45023 Price list v1
$ git gc -q
$ git verify-pack -v .git/objects/pack/pack-*.idx
314cfec9f9513c8d08765f1ebe0b8fb9510f6108 commit 212 151 12
…
5b0a2471a7904f6f54277a9bdee494b4d6bf973d blob   4354 1056 585
907485f20862f8b3d6ee18b116fbddd326c06360 tree   38 49 1641
…
2f2f909ca588bab7bd850c54f091923e16d2d592 blob   14 25 1739 1 5b0a2471a7904f6f54277a9bdee494b4d6bf973d
…
5229ab56116c4145f6c0f5eec825858722cb9a1c blob   21 33 1813 1 5b0a2471a7904f6f54277a9bdee494b4d6bf973d
…
975d72fec0e39a6bb5087d9ccdc188df951a0f29 blob   28 41 1895 1 5b0a2471a7904f6f54277a9bdee494b4d6bf973d
non delta: 9 objects
chain length = 1: 3 objects
.git/objects/pack/pack-9fa97ccabd6c7c53ca1b028d8e6544a0a4c8aad5.pack: ok

$ git -c init.defaultBranch=main init -q --object-format=sha256
$ git rev-parse --show-object-format
sha256
$ echo hello | git hash-object --stdin
2cf8d83d9ee29543b34a87727421fdecb7e3f3a183d337639025de576db9ebb4
$ git log --oneline
4339515 Add greeting
$ git rev-parse HEAD
433951541da79b2a4b92d69a709eb825bc5b3171cf2c55660f9423ef2791938c
$ cat .git/config
[extensions]
	objectformat = sha256
[core]
	repositoryformatversion = 1
…