Is there a way to split a commit into fixups for the different commits it affects?

Suppose my repository has two files, f1 and f2, lines of each of which have been changed by multiple different commits. Now suppose my head commit, c3, changes line L_1_1 through L_1_2 of f1 and L_2_1 through L_2_2 of f2, which were last altered in commits c1 and c2 respectively. For simplicity, let's assume each complete range of lines was altered in its entirety by its corresponding commit.

Now, I want to break this commit up into two separate changes, and apply each of them as a fixup to c1 and c2, so that they each get the changes I made to the relevant files in c3, at the point where the relevant lines were last changed rather than in a separate commit.

Naturally, I can do this manually: A soft reset to c3~, committing each of the files separately, and rebasing with editing the todo-list to correspond to the fixups I want. But this is a bit cumbersome, especially if it's not just the case of 2 files, but a lot more.

How can I affect this change more conveniently? (If it's at all possible.)

Notes:

• Naturally, I want to be able to do this not just for 2 files, but for many files.
• c3, c2 and c1 are not consecutive commits, nor the only commits. c3 is the head, that's all you can assume.

I believe the answer is yes, this can be automated. The following algorithm should do what you're asking:

0. Start with a clean git status. (No pending files.)
1. Reset mixed, back one commit. Now all of the changes in that commit (c3) will be pending.
2. Loop through each of the pending files presented by git diff --name-only.
3. For each file: stage it, and commit it, using the --fixup option, and specify the commit ID you wish to squash this new commit into. You can use a function to determine that commit ID. The first sensible function that comes to mind is the last commit ID that modified the file before c3, for example:

git log --format="%H" -n1 <file-name> # last commit ID to modify <file-name>

4. Now do an interactive rebase using autosquash, and set the editor to null so you aren't prompted to save and continue. This will automatically squash the new commits into their respective prior commits using fixup.

Here's an MRE in a Bash script that demonstrates with 5 files (though any number should work):

#!/bin/bash
git init
git config core.safecrlf false # don't display line ending warnings

# create some files, each in their own commit
for i in {1..5}
do
   echo "Creating file$i.txt..."
   echo "This is file $i" > file$i.txt
   git add .
   git commit -m "Add file$i.txt"
done

# modify each file
for i in {1..5}
do
   echo "Modifying file$i.txt..."
   echo "Another line to file $i" >> file$i.txt
done

# create a single commit with all of the file modifications
git add .
git commit -m "Modify all files"

echo ""
echo "Show current log:"
git --no-pager log --oneline # show current history
echo ""

# reset mixed back 1 commit
git reset @~1

# loop through pending files and create a fixup commit to the last commit modifying the file
git diff --name-only | \
	while read file;
	do
		# stage only this file
		git add $file
		# commit the add with fixup to the most recent commit modifying this file
		git commit --fixup $(git log --format="%H" -n1 $file) # this could be a function
		echo ""
	done
	
echo ""
echo "Show current log:"
git --no-pager log --oneline # show current history
echo ""

# interactive rebase with autosquash, without prompting for an editor
GIT_SEQUENCE_EDITOR=: git rebase -i --root --autosquash

echo ""
echo "Show current log:"
git --no-pager log --oneline # show current history
echo ""