[ טוען... ]

git history drop ב-Git 2.56: מחיקת קומיט בלי rebase אינטראקטיבי

תאריך: 14.11.2026
זמן קריאה: 17 דקות
לידור כהן
מייסד, לידור דיגיטל

שיתוף:

הירשמו לניוזלטר - תובנות על אוטומציה ו-AI, בלי ספאם

איור של שרשרת קומיטים שבה קומיט אחד מוסר והקומיטים שאחריו מוחלים מחדש ומתחברים לקומיט ההורה

git history drop היא תת-פקודה חדשה ב-Git 2.56 שמסירה קומיט אחד מאמצע ההיסטוריה, בלי rebase אינטראקטיבי. הפקודה מוחקת את הקומיט ומחילה מחדש את כל הצאצאים שלו על ההורה של הקומיט שהוסר. החלה מחדש (replay) פירושה ש-Git יוצר כל קומיט מחדש, עם אותם שינויים ואותה הודעה, על בסיס אחר.

התרחישים מוכרים לכל מפתח: קומיט דיבאג שנשכח, תיקיית build שנכנסה בטעות, או שינוי שהוחלט לוותר עליו לפני פתיחת ה-PR. לפי סקירת החידושים של GitLab, עד הגרסה הזו מחיקת קומיט קיים חייבה שימוש ב-git rebase -i.

ההבדל אינו רק תחבירי. rebase אינטראקטיבי הוא תהליך עם מצב (stateful) שנוגע ב-index וב-worktree, דורש רשימת todo ויכול לעצור באמצע במצב קונפליקט. git history drop בנויה אחרת: היא נכשלת עם שגיאה במקום להשאיר את המאגר במצב ביניים, וברוב המקרים היא לא צריכה working tree כלל.

המאמר מסביר מה git history drop עושה, איך משתמשים בה בבטחה, במה היא שונה מ-rebase ומגישות מבוססות worktree, מה אפשר ומה אי אפשר לטעון לגבי ביצועים, ואיך משלבים אותה בעבודת צוות שמתחזק מאגר Next.js או עשרות מאגרים של לקוחות בסוכנות.

מה זה git history drop ומה השתנה ב-Git 2.56

הרקע: פקודת git history הניסיונית

git history היא פקודה חדשה יחסית. היא הופיעה לראשונה כניסיונית ב-Git 2.54 עם תת-הפקודות reword ו-split, ב-2.55 נוספה fixup וב-2.56 נוספה drop. הפקודה כולה בנויה על המנגנון של git replay.

התיעוד הרשמי מגדיר אותה כחלופה דעתנית ופשוטה יותר ל-rebase. היא לא נועדה להחליף את rebase בכל תרחיש, אלא לכסות בצורה נקייה פעולות ממוקדות ונפוצות: שינוי הודעת קומיט, פיצול קומיט, הכנסת תיקון לקומיט קודם, ועכשיו גם מחיקת קומיט.

מאפיין מרכזי נוסף: לפי דף ה-man, רוב תת-הפקודות לא נוגעות ב-index או ב-worktree, ולכן הן עובדות גם במאגר bare. החריגה המתועדת היא fixup, שקוראת שינויים מה-staging.

מה הפקודה עושה בפועל

לפי 9to5Linux, drop מסירה קומיט ומחילה מחדש את הצאצאים שלו על ההורה של הקומיט שהוסר. באופן ויזואלי:

לפני:   A --- B --- C --- D    (feature/cart)

git history drop B

אחרי:   A --- C' --- D'        (feature/cart)

הקומיטים C ו-D לא זזים במובן המילולי. Git יוצר קומיטים חדשים, C' ו-D', עם אותם שינויים ואותן הודעות, אבל עם הורה שונה ולכן עם SHA שונה. זו הסיבה שכל מחיקת קומיט היא שכתוב היסטוריה לכל דבר, עם כל ההשלכות לגבי ענפים שכבר נדחפו לשרת.

שתי התנהגויות חשובות שכדאי להכיר מההתחלה:

עוד חידושים ב-Git 2.56 שקשורים לניקוי היסטוריה

drop לא הגיעה לבד. הגרסה כוללת כמה תוספות משלימות:

הערה לגבי דיוק: התיעוד ב-kernel.org מציג גם תת-פקודה בשם squash, שלא מופיעה בדף ה-man של man7. ייתכן שמדובר בתיעוד של ענף הפיתוח ולא של הגרסה היציבה, ולכן לא ברור אילו תת-פקודות בדיוק כלולות ב-2.56.0. הדרך הבטוחה לבדוק היא להריץ git history -h על הגרסה המותקנת.

הגרסה בהקשר: מספרים ולוח זמנים לקראת Git 3.0

Git 2.56.0 הוכרזה על ידי Junio C Hamano ב-28 בספטמבר 2026, וכוללת 748 קומיטים שאינם merge מאז 2.55, מ-104 תורמים, מתוכם 39 לראשונה. הגרסה הקודמת, 2.55.0, שוחררה ב-29 ביוני 2026.

לפי GitLab, לוח הזמנים המתוכנן לקראת Git 3.0 כולל את 2.56 בספטמבר 2026, את 2.98 בדצמבר 2026, ואת 2.99 ו-3.0 באביב 2027. המקורות לא מתחייבים למועד שבו git history תצא מהסטטוס הניסיוני, אבל קצב השחרורים מזכיר שמדובר בפקודה שמתפתחת מגרסה לגרסה, וכדאי לבדוק את ההתנהגות מחדש אחרי כל שדרוג.

מדריך מעשי: הסרת קומיט מההיסטוריה עם git history drop

המדריך הבא מניח ענף פיצ'ר מקומי בשם feature/cart במאגר Next.js, שבו נכנס בטעות קומיט שמוסיף את תיקיית .next/ או קובץ דיבאג. אותם צעדים רלוונטיים לכל מאגר.

שלב 0: לוודא שהגרסה מתאימה

git --version
# נדרש git version 2.56.0 ומעלה

git history -h
# מציג את תת-הפקודות הזמינות בגרסה המותקנת

כדאי לבדוק את הגרסה גם בסביבות CI ובשרתים, שבהן גרסת Git עשויה להיות שונה מזו שבמחשב הפיתוח.

שלב 1: גיבוי באמצעות tags ולא ענפים

זו נקודה שקל לפספס. מכיוון שברירת המחדל מעדכנת את כל הענפים שיורדים מהקומיט, ענף גיבוי שנוצר על אותו קצה מכיל גם הוא את הקומיט שנמחק, ועלול לזוז יחד עם כל השאר. במקרה כזה הגיבוי משוכתב בדיוק כמו המקור ומאבד את ערכו.

התיעוד מדבר על ענפים, ולכן tag הוא דרך גיבוי שלא אמורה להיות מושפעת. הקוד הבא יוצר tag לכל ענף שמכיל את הקומיט:

# גיבוי של כל ענף שמכיל את הקומיט שעומד להימחק
for b in $(git branch --format='%(refname:short)' --contains 3f2a9c1); do
  git tag "pre-drop/$b" "$b"
done

git tag --list 'pre-drop/*'

אחרי ההרצה, כדאי לוודא שה-tags עדיין מצביעים על ההיסטוריה הישנה (ראו שלב 5). ה-reflog הוא רשת ביטחון נוספת, אבל tag עם שם ברור נוח בהרבה לשחזור ולהשוואה.

שלב 2: לאתר את הקומיט, לבדוק merges ולמפות ענפים מושפעים

# היסטוריה אחרונה בתצוגת גרף
git log --oneline --graph -n 15

# האם יש קומיטי merge בין הקומיט לקצה הענף? פלט ריק = אין
git log --merges --oneline 3f2a9c1..HEAD

# אילו ענפים מכילים את הקומיט ולכן עשויים לזוז
git branch --contains 3f2a9c1

אם הפקודה השנייה מחזירה תוצאות, drop לא תעבוד על היסטוריה כזו, ויהיה צורך בכלי אחר. הפקודה השלישית נותנת רשימה אמינה של הענפים שברירת המחדל עשויה להזיז.

שלב 3: הרצה יבשה

git history drop 3f2a9c1 --dry-run

הדגל --dry-run מופיע בתקציר הפקודה, אבל המקורות שנבדקו לא מתארים מה בדיוק הוא מדפיס. לכן כל הנחה לגבי הפלט, למשל שהוא מציג את רשימת הענפים שיתעדכנו, אינה מאומתת. מומלץ להריץ אותו פעם אחת על ענף ניסיוני כדי לראות מה הוא מציג בגרסה המותקנת, ולהסתמך על git branch --contains למיפוי הענפים.

שלב 4: הרצה אמיתית

git history drop 3f2a9c1

אם אחד הצאצאים מתנגש עם ההסרה, הפקודה נעצרת עם שגיאה ולא נכנסת למצב של פתרון קונפליקטים. אין שלב ביניים שצריך להמשיך או לבטל, כי שום ref לא עודכן.

שלב 5: לאמת את התוצאה

# ההיסטוריה החדשה
git log --oneline -n 10

# ה-tag עדיין מצביע על ההיסטוריה הישנה, כולל הקומיט שנמחק
git log --oneline -n 5 pre-drop/feature/cart

# ההפרש בין המצב הישן לחדש אמור להיות בדיוק ההיפוך של הקומיט שהוסר
git diff pre-drop/feature/cart HEAD --stat

# בדיקות ידניות, כי hooks לא רצים (ראו בהמשך)
npm run lint && npm run build

הבדיקה עם git diff מול ה-tag היא דרך פשוטה לוודא שלא נעלם שום שינוי אחר מלבד מה שהתכוונתם להסיר. כשהכול תקין, אפשר למחוק את ה-tags:

git tag -d $(git tag --list 'pre-drop/*')

האפשרויות החשובות: --dry-run, --update-refs ו---empty

התקציר המתועד של git history drop הוא:

git history drop <commit> [--dry-run] [--update-refs=(branches|head)] [--empty=(drop|keep|abort)]

התיעוד ב-kernel.org מציין בנוסף את --[no-]gpg-sign.

--update-refs: אילו ענפים יזוזו

לאפשרות שני ערכים, ו-branches הוא ברירת המחדל:

  • branches: כל ענף שיורד מהקומיט שהוסר יעודכן להצביע על ההיסטוריה החדשה.
  • head: רק הענף הנוכחי (HEAD) מתעדכן.

תרחיש נפוץ בסוכנויות: ענף feature/cart ומעליו ענף feature/checkout שנפתח ממנו (stacked branches). מחיקת קומיט ב-feature/cart עם ברירת המחדל תזיז גם את feature/checkout. ברוב המקרים זו התוצאה הרצויה, כי כך הקומיט שהוסר לא נשאר בענף העליון. מצד שני, אם מישהו בצוות עובד על ענף שיורד מאותו קומיט ולא מצפה לשינוי, --update-refs=head מגביל את השכתוב לענף הנוכחי בלבד.

--empty: מה קורה לקומיטים שמתרוקנים

לפעמים, אחרי הסרת קומיט, אחד הצאצאים כבר לא מכיל שום שינוי, למשל קומיט שכל מטרתו הייתה לתקן משהו בקומיט שהוסר. האפשרות --empty מקבלת שלושה ערכים: drop, keep ו-abort. המשמעות הבאה נגזרת משמות הערכים:

  • drop: להסיר גם קומיטים שהתרוקנו.
  • keep: להשאיר אותם כקומיטים ריקים.
  • abort: לעצור את הפעולה.

בצוותים שמקפידים על היסטוריה מסודרת, abort הוא בחירה שמרנית: הוא מכריח לעצור ולהבין למה קומיט התרוקן לפני שמחליטים מה לעשות.

--gpg-sign: חתימה על הקומיטים החדשים

אם המאגר דורש קומיטים חתומים, חשוב לזכור שהקומיטים שמוחלים מחדש הם קומיטים חדשים. האפשרות --[no-]gpg-sign מופיעה בתיעוד ב-kernel.org אך לא בגרסת man7, ולכן כדאי לוודא עם git history -h שהיא זמינה בגרסה המותקנת לפני שמסתמכים עליה.

git history drop מול git rebase אינטראקטיבי ו-worktree

הדרך הישנה: git rebase -i

השיטה המוכרת להסרת קומיט ספציפי היא להריץ rebase אינטראקטיבי, לסמן את הקומיט כ-drop ולסיים את ה-rebase:

git rebase -i 3f2a9c1^
# בעורך: לשנות את pick ל-drop בשורה של הקומיט 3f2a9c1
# לשמור ולצאת

זה עובד, אבל יש כמה נקודות חיכוך: צריך להבין את התחביר של ^, צריך לערוך רשימת todo, ה-rebase נוגע ב-worktree וב-index לאורך התהליך, ואם יש קונפליקט המאגר נשאר באמצע rebase עד שמסיימים או מבטלים.

טבלת השוואה

קריטריון

git history drop

git rebase -i (drop)

מצב ביניים

אין; נכשל לפני עדכון refs

עם מצב; יכול לעצור במצב קונפליקט

נגיעה ב-worktree וב-index

רק אם HEAD שוכתב, בסיום

לאורך כל התהליך

רשימת todo

לא נדרשת

נדרשת

טווח פעולה

קומיט אחד

טווח, עריכות מרובות

קומיטי merge

לא נתמך

נתמך עם --rebase-merges

פתרון קונפליקטים

לא; מבטל

עוצר לפתרון ידני

מקורות הטבלה: עמודת git history drop מבוססת על התיעוד ב-kernel.org ועל דף ה-man ב-man7. עמודת rebase מבוססת על ההשוואה בבלוג של GitHub לגרסה 2.54, על ההמלצה בתיעוד git-history להשתמש ב-rebase לטווחים ולעריכות מרובות, ועל ההפניה ל---rebase-merges בתיעוד ב-kernel.org.

תכונות של git history drop ללא השוואה מתועדת

כמה מאפיינים של הפקודה מתועדים היטב, אבל המקורות שנבדקו לא מתארים את ההתנהגות המקבילה של rebase בנקודות האלה, ולכן הם לא מופיעים בטבלה:

מתי git rebase אינטראקטיבי עדיין הכלי הנכון

התיעוד עצמו ממליץ להשתמש ב-rebase כדי להחיל טווח קומיטים על בסיס אחר, וב-rebase אינטראקטיבי כדי לערוך קומיטים רבים בבת אחת. בנוסף:

  • היסטוריה עם merges: כאן נדרש git rebase --rebase-merges.
  • הסרה שצפויה ליצור קונפליקט: rebase מאפשר לעצור, לפתור ולהמשיך. drop פשוט תסרב.
  • ניקוי רחב לפני PR: כשצריך לאחד, לסדר מחדש ולמחוק כמה קומיטים, רשימת todo אחת יעילה יותר מסדרת פקודות נפרדות.

במילים אחרות, git history drop אינה חלופה מלאה ל-git rebase. היא כלי חד למקרה אחד נפוץ מאוד.

גישות מבוססות worktree ולמה replay שונה

פרקטיקה כללית שמוכרת בקרב מפתחים, ולא נתון מתועד במקורות, היא לשכתב היסטוריה בתיקייה נפרדת כדי לא לשבש את סביבת העבודה הפעילה: לפתוח worktree זמני עם git worktree add, להריץ בו את ה-rebase, ואז לחזור לתיקייה הראשית. כך, למשל, שרת הפיתוח של Next.js בתיקייה הראשית לא מגיב לשינויי הקבצים שה-rebase מייצר.

ההבדל העקרוני ב-git history הוא שהיא בכלל לא צריכה worktree לרוב הפעולות. לפי דף ה-man, תת-הפקודות לא נוגעות ב-index או ב-working tree, למעט fixup. ההשלכה המעשית: אין צורך בתיקייה נוספת, וה-worktree הפעיל מתעדכן רק בסוף, ורק אם HEAD שוכתב. אין כרגע מקור רשמי שמשווה מספרית בין הגישות, אבל מבחינה ארכיטקטונית סביר להניח שמדובר בפחות עבודה על מערכת הקבצים.

ביצועים: הטענה על שיפור של פי 40 עד 77

נתון של שיפור פי 40 עד 77 בהחלה מחדש לעומת שיטות מסורתיות לא מופיע באף אחד מהמקורות הרשמיים שנבדקו: לא בתיעוד, לא בהודעת השחרור ב-LWN ולא בבלוגים של GitHub ו-GitLab. אין כרגע מקור רשמי שתומך במספרים כאלה, ולכן אין לראות בהם עובדה עד שיתפרסם בנצ'מרק עם מתודולוגיה גלויה.

מה שאפשר להסיק בזהירות: מכיוון שהפקודה לא נוגעת ב-worktree במהלך ההחלה מחדש, סביר שבמאגר גדול עם הרבה קבצים ההבדל יורגש. הדרך הנכונה לדעת היא למדוד על המאגר עצמו, בשני שכפולים נפרדים:

# שני שכפולים נפרדים לניסוי, כדי לא לגעת במאגר העבודה
git clone ./my-next-app /tmp/bench-a
git clone ./my-next-app /tmp/bench-b

# ה-SHA המקוצר באורך ש-Git משתמש בו ברשימת ה-todo
SHORT=$(git -C /tmp/bench-b rev-parse --short 3f2a9c1)

cd /tmp/bench-a && git switch feature/cart && time git history drop 3f2a9c1

# Linux (GNU sed)
cd /tmp/bench-b && git switch feature/cart && time GIT_SEQUENCE_EDITOR="sed -i 's/^pick $SHORT/drop $SHORT/'" git rebase -i 3f2a9c1^

# macOS (BSD sed) דורש ארגומנט ריק אחרי -i:
# GIT_SEQUENCE_EDITOR="sed -i '' 's/^pick $SHORT/drop $SHORT/'"

שתי הערות לגבי הקטע:

  • sed ב-macOS: הגרסה של BSD דורשת sed -i '' עם ארגומנט ריק. בלי זה הפקודה תיכשל או תתנהג אחרת מהצפוי.
  • אורך ה-SHA: ה-SHA המקוצר בביטוי של sed חייב להתאים בדיוק לאורך הקיצור שמופיע ברשימת ה-todo. במאגרים גדולים Git עשוי לקצר ליותר משבעה תווים, ואז ביטוי עם שבעה תווים לא יתאים וה-rebase יעבור בלי למחוק דבר. לכן הקטע משתמש ב-git rev-parse --short, וכדאי לוודא אחרי הריצה עם git log שהקומיט אכן נעלם.

מדידה כזו, על כמה קומיטים במרחקים שונים מקצה הענף, תיתן תמונה אמינה יותר מכל מספר כללי.

מגבלות של git history drop שחשוב להכיר

אין merges ואין קומיט שורש

drop לא יכולה להסיר את קומיט השורש או קומיט merge, והיא גם לא עובדת על היסטוריה שמכילה merges. במאגר שבו נהוג למזג את main לתוך ענפי פיצ'ר במקום לבצע rebase, המגבלה הזו תופיע הרבה. במקרים כאלה, git rebase --rebase-merges נשאר הכלי המתאים.

קונפליקט פירושו עצירה

אם החלה מחדש של צאצא כלשהו הייתה יוצרת קונפליקט, הפקודה מבטלת עם שגיאה. זו בחירה מכוונת: לפי התיעוד, שכתובי היסטוריה ב-git history אינם פעולות עם מצב. בפועל, אם קומיט מאוחר יותר שינה את אותן שורות בדיוק, יש לחזור ל-rebase אינטראקטיבי.

hooks לא רצים

git history לא מריץ כרגע אף githook, והתיעוד מציין שזה עשוי להשתנות. בפרויקטי Next.js שמשתמשים ב-Husky וב-lint-staged, המשמעות היא שהקומיטים החדשים נוצרים בלי שום בדיקה מקומית. תוכן השינויים בקומיטים עצמם לא משתנה, אבל hook שמוסיף מידע להודעות קומיט או אוכף מדיניות כלשהי לא יופעל.

סטטוס ניסיוני

התיעוד מסמן את הפקודה EXPERIMENTAL ומציין שההתנהגות עשויה להשתנות. לא כדאי לבנות סקריפטים אוטומטיים שמסתמכים על פורמט הפלט או על ברירות המחדל הנוכחיות בלי לנעול גרסת Git.

שכתוב מקומי לא מוחק כלום מהשרת

זו לא מגבלה של הפקודה אלא של Git עצמו, אבל היא קריטית: הסרת קומיט מההיסטוריה המקומית לא מוחקת אותו מהשרת, מ-forks, מקאשים של CI או מהמחשבים של חברי צוות שכבר משכו אותו. אם הקומיט הכיל סוד, התיקון האמיתי הוא רוטציה, לא שכתוב היסטוריה.

עבודה בצוות ושחזור: טיפים למאגרי Next.js וסוכנויות

המקורות הרשמיים לא כוללים הנחיות לעבודה בצוות או ל-force push. הטיפים הבאים הם המלצות מעשיות שנגזרות מאופן הפעולה של הפקודה ומפרקטיקות Git מקובלות.

לפני push: מרחב חופשי לניקוי

כל עוד הענף לא נדחף, אפשר להשתמש ב-git history drop בלי לתאם עם אף אחד. מקרים טיפוסיים בפרויקטי Next.js:

  • קומיט שהוסיף את .next/ או out/ לפני שעודכן .gitignore.
  • קומיט עם console.log או קבצי בדיקה זמניים.
  • קומיט של package-lock.json שנוצר מגרסת npm שגויה.
  • ניסוי בקונפיגורציה של next.config.js שהוחלט לוותר עליו.

בכל המקרים האלה, הסרת הקומיט עדיפה על פני קומיט revert שמשאיר רעש בהיסטוריה של ה-PR.

אחרי push: force-with-lease וסנכרון נכון של חברי הצוות

ברגע שהענף נמצא בשרת, מחיקת קומיט מחייבת force push. מומלץ להשתמש תמיד ב---force-with-lease, שמסרב לדרוס אם מישהו אחר דחף לענף בינתיים:

git push --force-with-lease origin feature/cart

חברי צוות שעובדים על אותו ענף צריכים לסנכרן את עצמם, והדרך תלויה בשאלה אם יש להם קומיטים מקומיים:

git fetch origin

# אפשרות 1: אין קומיטים מקומיים שצריך לשמור
git reset --hard origin/feature/cart

# אפשרות 2: יש קומיטים מקומיים - pull --rebase משתמש ב-fork-point
# (בענף שמוגדר לו upstream)
git pull --rebase

# אפשרות 3: לציין במפורש את הבסיס הישן שעליו נבנו הקומיטים המקומיים
# origin/feature/cart@{1} הוא בדרך כלל הערך שלפני ה-fetch האחרון
git reflog show origin/feature/cart -n 5
git rebase --onto origin/feature/cart origin/feature/cart@{1}

אזהרה: הקומיט שנמחק יכול לחזור בשקט. הפקודה git rebase origin/feature/cart, עם upstream מפורש, מבטלת את מנגנון ה-fork-point. הקומיט B, שעדיין קיים בהיסטוריה המקומית של חבר הצוות, לא מופיע ב-upstream החדש, ולכן rebase יחיל אותו מחדש מעל הגרסה החדשה. התוצאה: B חוזר עם SHA חדש, וה-push הבא יחזיר אותו לשרת בלי שאיש ישים לב.

לכן, אחרי כל סנכרון, כדאי לבדוק שרק הקומיטים של חבר הצוות עצמו נמצאים מעל הענף המרוחק:

git log --oneline origin/feature/cart..HEAD

אם מופיע ברשימה קומיט עם ההודעה של B, הוא חזר. על ענפים מוגנים כמו main או production, מומלץ להשאיר את force push חסום ברמת הפלטפורמה ולבצע תיקונים דרך revert.

סוד שדלף: drop הוא לא הפתרון

זה התרחיש שבו הכי מפתה להשתמש בפקודה, ובו היא הכי פחות מספיקה. אם .env.local עם מפתחות API נכנס לקומיט שכבר נדחף, צריך קודם כול להחליף את המפתחות, ורק אחר כך לנקות היסטוריה. ניתוח מעשי של תרחיש כזה מופיע במאמר על דליפת סודות דרך Claude Code ל-GitHub, ותהליך מסודר להחלפת מפתחות מתואר במדריך לרוטציה אחרי דליפת משתני סביבה.

CI כשער במקום hooks

מכיוון ש-git history לא מריצה hooks, הבדיקות המחייבות צריכות לרוץ בצד השרת. Pipeline שמריץ lint, בדיקות טיפוסים ו-build על כל push תופס בעיות שנוצרו בשכתוב, בלי תלות במה שקרה במחשב המקומי. כדאי לוודא שגם ה-workflows עצמם מוקשחים, כפי שמוסבר במדריך לאבטחת GitHub Actions והצמדה ל-SHA.

מונורפו וענפים מוערמים

במונורפו עם כמה אפליקציות Next.js וחבילות משותפות, ענפים רבים יכולים לרדת מאותו קומיט. ברירת המחדל של --update-refs=branches תזיז את כולם. לפני הרצה כזו:

  1. הריצו git branch --contains <sha> כדי לראות אילו ענפים מכילים את הקומיט.
  2. הריצו --dry-run ובדקו מה הפלט מציג בגרסה המותקנת.
  3. בדקו אם אחד הענפים שייך לחבר צוות אחר.
  4. אם כן, השתמשו ב---update-refs=head או תאמו מראש.

צ'קליסט לצוות

לסוכנויות שמתחזקות עשרות מאגרים של לקוחות, כדאי לקבע מדיניות קצרה וברורה:

  • ענפים פרטיים: חופש מלא לשכתב, כולל git history drop.
  • ענפים משותפים: שכתוב רק בתיאום, תמיד עם --force-with-lease, וסנכרון עם git pull --rebase ולא עם rebase על upstream מפורש.
  • ענפים מוגנים: אין שכתוב, רק revert.
  • גרסת Git: לנעול גרסה מינימלית בתיעוד הצוות, כי הפקודה ניסיונית.
  • גיבוי: tags לפני כל שכתוב, לא ענפי גיבוי שעלולים לזוז.
  • סודות: רוטציה קודמת לכל ניקוי היסטוריה.
  • מסירה ללקוח: לפני העברת מאגר ללקוח, לנקות קומיטים זמניים בענפים שעדיין לא מוזגו, ולא לגעת בהיסטוריה של main.
  • הודעות קומיט בעברית: הפקודה אדישה לכיווניות טקסט, ו-RTL אינו שיקול באופן פעולתה.

שחזור כשמשהו השתבש

גם אחרי שכתוב, הקומיטים הישנים לא נמחקים מיד מהמאגר המקומי. הנקודה החשובה: עם ברירת המחדל --update-refs=branches, ייתכן שכמה ענפים זזו. git reset --hard HEAD@{1} משחזר רק את הענף הנוכחי, וכל שאר הענפים יישארו על ההיסטוריה החדשה.

הדרך הפשוטה ביותר היא לשחזר מה-tags שנוצרו בשלב 1:

git status   # לוודא שאין שינויים מקומיים שיידרסו

# הענף הנוכחי
git reset --hard pre-drop/feature/cart

# כל ענף אחר שזז, בלי לעבור אליו
git branch -f feature/checkout pre-drop/feature/checkout

בלי tags, אפשר להיעזר ב-reflog של כל ענף בנפרד, בתחביר <branch>@{1}:

# לבדוק מה היה הערך הקודם של כל ענף שזז
git reflog show feature/cart -n 5
git reflog show feature/checkout -n 5

# הענף הנוכחי
git reset --hard feature/cart@{1}

# שאר הענפים
git branch -f feature/checkout feature/checkout@{1}

התחביר <branch>@{1} מצביע על הערך הקודם של הענף רק אם השכתוב היה העדכון האחרון שלו, ולכן חשוב לבדוק ב-reflog שהרשומה הקודמת היא אכן המצב שלפני השכתוב. reset --hard דורס שינויים מקומיים שלא נשמרו, ולכן git status לפני כל שחזור הוא הרגל טוב.

שאלות נפוצות

האם אפשר למחוק קומיט merge עם git history drop?

לא. הפקודה דוחה קומיטי merge ואת קומיט השורש, וגם לא עובדת על היסטוריה שמכילה merges. במקרים האלה יש להשתמש ב-git rebase --rebase-merges.

מה קורה אם ההסרה יוצרת קונפליקט?

הפקודה נעצרת עם שגיאה לפני שהיא מעדכנת refs, ולא נכנסת למצב של פתרון קונפליקטים. המאגר נשאר בדיוק כפי שהיה, ואפשר לעבור ל-rebase אינטראקטיבי כדי לפתור את הקונפליקט ידנית.

האם git history drop עובדת במאגר bare?

לפי התיעוד, רוב תת-הפקודות של git history עובדות במאגר bare כי הן לא צריכות index או working tree. החריגה המתועדת היא fixup, שקוראת שינויים מה-staging, ולכן drop אמורה לעבוד גם במאגר bare.

האם ה-Git hooks ירוצו?

לא, נכון לעכשיו. התיעוד מציין ש-git history לא מריצה hooks ושזה עשוי להשתנות בעתיד. לכן כדאי להריץ בדיקות ידנית ולהסתמך על CI.

האם הפקודה יציבה מספיק לשימוש יומיומי?

התיעוד מסמן אותה EXPERIMENTAL ומציין שההתנהגות עשויה להשתנות. לשימוש ידני בענפים מקומיים, עם גיבוי ב-tags ו---dry-run, הסיכון נמוך. לסקריפטים אוטומטיים כדאי להמתין להתייצבות.

מה הייתה הדרך הקודמת להסיר קומיט?

להריץ git rebase -i, לסמן את הקומיט כ-drop ולסיים את ה-rebase. הדרך הזו עדיין עובדת ועדיין עדיפה כשיש merges, קונפליקטים או צורך בעריכות מרובות.

סיכום

git history drop היא תוספת קטנה עם השפעה מורגשת על עבודה יומיומית. במקום לפתוח rebase אינטראקטיבי, לערוך רשימת todo ולקוות שלא ייווצר קונפליקט באמצע, מספיקה פקודה אחת שמסירה קומיט ומחילה מחדש את הצאצאים שלו. היא לא נוגעת ב-worktree עד הסוף, נכשלת בצורה נקייה, ומציעה --dry-run, גם אם הפלט שלו עדיין לא מתועד במלואו.

לצד זאת, חשוב להכיר את הגבולות: הפקודה ניסיונית, לא תומכת ב-merges או בקומיט השורש, לא פותרת קונפליקטים ולא מריצה hooks. אין כרגע מקור רשמי שתומך בטענות על שיפור ביצועים של פי 40 עד 77, ומי שהביצועים חשובים לו צריך למדוד על המאגר שלו.

בעבודת צוות, הכללים הישנים עדיין חלים, עם כמה דגשים חדשים: גיבוי ב-tags ולא בענפים שעלולים לזוז, שחזור של כל ענף שזז ולא רק של HEAD, סנכרון עם fork-point כדי שהקומיט שנמחק לא יחזור בשקט, ורוטציה לפני כל ניסיון למחוק סוד מההיסטוריה.

מקורות

וואטסאפ