git-loom 0.18.0

A Git CLI tool that weaves together multiple feature branches into integration branches
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

# absorb

Automatically distribute working tree changes into the commits that last touched the affected lines. Uses blame to determine the correct target for each hunk, then amends those commits — all in a single operation.

## Usage

```
git loom absorb [-n] [files...]
```

### Options

| Option | Description |
|--------|-------------|
| `-n, --dry-run` | Show what would be absorbed without making changes |

### Arguments

| Argument | Description |
|----------|-------------|
| `[files...]` | Files to restrict absorption to (default: all tracked changed files) |

## How It Works

For each file with uncommitted changes:

1. Parses the unified diff into individual hunks
2. For each hunk, blames the modified/deleted lines to find their originating commit
3. If all hunks trace to the **same in-scope commit**, the whole file is absorbed
4. If hunks trace to **different commits**, each hunk is independently absorbed into its target
5. Hunks that can't be attributed (pure additions, ambiguous) are **skipped** and left in the working tree

After analysis, all assigned hunks are folded into their target commits in a single rebase operation.

## Examples

### Absorb all changes

```bash
git loom absorb
#   src/auth.rs -> a1b2c3d "Add authentication"
#   src/utils.rs -> d4e5f6a "Add utility helpers"
# Absorbed 2 hunk(s) from 2 file(s) into 2 commit(s)
```

### Absorb hunks into different commits

```bash
# src/shared.rs has changes in two separate regions,
# each originating from a different commit
git loom absorb
#   src/shared.rs [hunk 1/2] -> a1b2c3d "Add login form"
#   src/shared.rs [hunk 2/2] -> d4e5f6a "Add dashboard"
# Absorbed 2 hunk(s) from 1 file(s) into 2 commit(s)
```

### Dry run

```bash
git loom absorb --dry-run
#   src/auth.rs -> a1b2c3d "Add authentication"
#   src/shared.rs [hunk 1/2] -> d4e5f6a "Add utility helpers"
#   src/shared.rs [hunk 2/2] -- skipped (pure addition)
# Dry run: would absorb 2 hunk(s) from 2 file(s) into 2 commit(s)
```

### Restrict to specific files

```bash
git loom absorb src/auth.rs src/utils.rs
#   src/auth.rs -> a1b2c3d "Add authentication"
#   src/utils.rs -> d4e5f6a "Add utility helpers"
# Absorbed 2 hunk(s) from 2 file(s) into 2 commit(s)
```

## Conflicts

If the rebase that folds the fixup commits hits a conflict, the operation is
**paused**. Pre-existing staged changes are saved aside automatically.

```bash
git loom absorb
#   src/auth.rs -> a1b2c3d "Add authentication"
# ! Conflicts detected — resolve them with git, then run:
#   loom continue   to complete the absorb
#   loom abort      to cancel and restore original state
```

```bash
git add <resolved-files> && git loom continue
# ✓ Absorbed 1 hunk(s) from 1 file(s) into 1 commit(s)
```

See [`continue`](continue.md) and [`abort`](abort.md) for details.

## Prerequisites

- Must be on an integration branch
- Working tree must have uncommitted changes
- Target commits must be in scope (between merge-base and HEAD)