Unfortunately my development, thinking, testing time for today has well surpassed it's time.
(Also this is a re-post of this message, the original one was not sent in plain-text mode, (html) probably leading to a mailing-list rejection, so I re-send it in plain-text mode to make sure it gets through, sorry in advance for any potential duplicates but if all is well it shouldn't be a duplicate ;))
But I would be unsatisfactory if no scripts were provided to at least have some starting point.
So I present to you scripts developed by Gemini Flash 2.5 for git bash.
These scripts are untested, but perhaps I will test them tomorrow further, or perhaps others can test these and refine these.
Below is also an explanation of how to store and use these scripts.
(I am quite busy, so I make no promises on any follows ups, or additional refinements, but I do my best to provide at least something to go on and for inspiration/ideas)
(Also I feel somewhat out of place in the linux/unix/bash world so perhaps better if somebody else carries over the stick so to speak ;))
(Another idea is to re-fine/bug fix them via gemini 2.5 pro, which is a stronger AI).
Here are the Bash scripts for your custom Git commands, ready for developers to use.
These scripts are designed to be standalone executables. Save each block of code into a file with the specified name (e.g., `git-new-contribution`), then make them executable (`chmod +x <filename>`). Place these files in a directory that is part of your system's `PATH` environment variable (e.g., `~/bin/` on Linux, or a custom directory you add to PATH for Git Bash on Windows).
Git will automatically recognize these as subcommands (e.g., `git new-contribution`).
-----
### 1\. `git-new-contribution`
This script fetches the latest `master`, determines the next sequential contribution number for your user prefix, creates the new branch, pushes it, and marks it as active.
```bash
#!/bin/bash
# Script: git-new-contribution
# Purpose: To initiate a brand new development effort from the latest master.
# Usage: git new-contribution <UserPrefix> <Description/Goal...>
# --- Input Validation ---
if [ -z "$1" ] || [ -z "$2" ]; then
echo "Usage: git new-contribution <UserPrefix> \"<Description/Goal...>\"" >&2
echo "Example: git new-contribution Skybuck \"Implement user authentication\"" >&2
exit 1
fi
USER_PREFIX="$1"
DESCRIPTION_RAW="$2"
# Slugify description: lowercase, replace spaces with hyphens, remove non-alphanumeric except hyphens
DESCRIPTION_SLUGIFIED=$(echo "$DESCRIPTION_RAW" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g' | sed -E 's/^-+|-+$//g' | head -c 50) # Truncate to avoid very long names
if [ -z "$DESCRIPTION_SLUGIFIED" ]; then
echo "Error: Description cannot be empty or result in an empty slug." >&2
exit 1
fi
# --- Core Logic ---
# 1. Fetch latest master and checkout
echo "Fetching latest master and switching to it..."
git checkout master || { echo "Error: Failed to checkout master." >&2; exit 1; }
git pull origin master || { echo "Error: Failed to pull latest master." >&2; exit 1; }
# 2. Determine next contribution number
# Look at all branches, local and remote, that match the pattern for this user prefix.
# Sort numerically and take the last one, then increment.
LAST_NUM=$(git for-each-ref --format='%(refname:short)' refs/{heads,remotes/origin}/"${USER_PREFIX}Contribution"* 2>/dev/null | \
grep -E "^${USER_PREFIX}Contribution[0-9]{3}-" | \
sed -E "s/^${USER_PREFIX}Contribution([0-9]{3})-.*$/\\1/" | \
sort -n | tail -1)
NEXT_NUM=1
if [ -n "$LAST_NUM" ]; then
NEXT_NUM=$((10#$LAST_NUM + 1)) # Use 10# to force base 10 for safety
fi
# Format to three digits (e.g., 001, 010, 100)
FORMATTED_NEXT_NUM=$(printf "%03d" "$NEXT_NUM")
NEW_BRANCH_NAME="${USER_PREFIX}Contribution${FORMATTED_NEXT_NUM}-${DESCRIPTION_SLUGIFIED}"
# Check if branch already exists locally or remotely (highly unlikely given numbering, but for safety)
if git show-ref --quiet --verify "refs/heads/$NEW_BRANCH_NAME" || git show-ref --quiet --verify "refs/remotes/origin/$NEW_BRANCH_NAME"; then
echo "Error: Branch '$NEW_BRANCH_NAME' already exists. This should not happen with sequential numbering." >&2
exit 1
fi
echo "Creating new branch: '$NEW_BRANCH_NAME' from master..."
git checkout -b "$NEW_BRANCH_NAME" master || { echo "Error: Failed to create local branch." >&2; exit 1; }
git push -u origin "$NEW_BRANCH_NAME" || { echo "Error: Failed to push new branch to origin." >&2; exit 1; }
echo "---"
echo "Calling git set-active to mark as active..."
# Call git-set-active directly. Ensure git-set-active is in PATH or alias setup.
"$(dirname "$0")/git-set-active" "$NEW_BRANCH_NAME" || { echo "Warning: Failed to set branch as active. Please run 'git set-active $NEW_BRANCH_NAME' manually." >&2; }
echo ""
echo "Successfully created and activated new contribution branch:"
echo "-> **$NEW_BRANCH_NAME**"
echo "You are now on this branch. Start coding!"
exit 0
```
-----
### 2\. `git-set-active`
This script explicitly marks an existing contribution branch as currently active or in progress by creating an `active/<branchname>` tag and removing any `merged/` or `rejected/` tags.
```bash
#!/bin/bash
# Script: git-set-active
# Purpose: To explicitly mark an existing contribution branch as currently active.
# Usage: git set-active <branchname>
# --- Input Validation ---
if [ -z "$1" ]; then
echo "Usage: git set-active <branchname>" >&2
echo "Example: git set-active SkybuckContribution001-ImplementLogin" >&2
exit 1
fi
BRANCH_NAME="$1"
ACTIVE_TAG="active/$BRANCH_NAME"
# Check if the branch exists locally or remotely
if ! git show-ref --quiet --verify "refs/heads/$BRANCH_NAME" && ! git show-ref --quiet --verify "refs/remotes/origin/$BRANCH_NAME"; then
echo "Error: Branch '$BRANCH_NAME' does not exist locally or remotely." >&2
exit 1
fi
# Get the latest commit hash of the branch. Prioritize remote if local isn't up to date.
BRANCH_HASH=$(git rev-parse "refs/remotes/origin/$BRANCH_NAME^{commit}" 2>/dev/null || git rev-parse "refs/heads/$BRANCH_NAME^{commit}" 2>/dev/null)
if [ -z "$BRANCH_HASH" ]; then
echo "Error: Could not determine commit hash for branch '$BRANCH_NAME'." >&2
exit 1
fi
# Delete existing merged/rejected tags (if any) to ensure only 'active' is present for status
for STATUS_TAG_PREFIX in "merged" "rejected"; do
if git show-ref --quiet --verify "refs/tags/${STATUS_TAG_PREFIX}/$BRANCH_NAME"; then
echo "Removing existing remote tag: ${STATUS_TAG_PREFIX}/$BRANCH_NAME..."
git push origin --delete "${STATUS_TAG_PREFIX}/$BRANCH_NAME" || { echo "Warning: Failed to delete old remote tag ${STATUS_TAG_PREFIX}/$BRANCH_NAME." >&2; }
fi
done
# Create and push the active tag
echo "Creating and pushing active tag: '$ACTIVE_TAG' for branch '$BRANCH_NAME'..."
git tag -f "$ACTIVE_TAG" "$BRANCH_HASH" || { echo "Error: Failed to create local tag '$ACTIVE_TAG'." >&2; exit 1; }
git push -f origin "$ACTIVE_TAG" || { echo "Error: Failed to push tag '$ACTIVE_TAG' to origin." >&2; exit 1; }
echo ""
echo "Branch **$BRANCH_NAME** successfully marked as **ACTIVE**."
echo "You can view active branches with: **git tag --list 'active/*'**"
exit 0
```
-----
### 3\. `git-set-merged`
This script marks a contribution branch as successfully merged into `master` by creating a `merged/<branchname>` tag and removing any `active/` or `rejected/` tags.
```bash
#!/bin/bash
# Script: git-set-merged
# Purpose: To mark a contribution branch as successfully merged into master.
# Usage: git set-merged <branchname>
# --- Input Validation ---
if [ -z "$1" ]; then
echo "Usage: git set-merged <branchname>" >&2
echo "Example: git set-merged SkybuckContribution001-MyFeature" >&2
exit 1
fi
BRANCH_NAME="$1"
MERGED_TAG="merged/$BRANCH_NAME"
# Check if the branch exists locally or remotely
if ! git show-ref --quiet --verify "refs/heads/$BRANCH_NAME" && ! git show-ref --quiet --verify "refs/remotes/origin/$BRANCH_NAME"; then
echo "Error: Branch '$BRANCH_NAME' does not exist locally or remotely." >&2
exit 1
fi
# Get the latest commit hash of the branch. Prioritize remote.
BRANCH_HASH=$(git rev-parse "refs/remotes/origin/$BRANCH_NAME^{commit}" 2>/dev/null || git rev-parse "refs/heads/$BRANCH_NAME^{commit}" 2>/dev/null)
if [ -z "$BRANCH_HASH" ]; then
echo "Error: Could not determine commit hash for branch '$BRANCH_NAME'." >&2
exit 1
fi
# Remove active/rejected tags if they exist
for STATUS_TAG_PREFIX in "active" "rejected"; do
if git show-ref --quiet --verify "refs/tags/${STATUS_TAG_PREFIX}/$BRANCH_NAME"; then
echo "Removing existing remote tag: ${STATUS_TAG_PREFIX}/$BRANCH_NAME..."
git push origin --delete "${STATUS_TAG_PREFIX}/$BRANCH_NAME" || { echo "Warning: Failed to delete old remote tag ${STATUS_TAG_PREFIX}/$BRANCH_NAME." >&2; }
fi
done
# Create and push the merged tag
echo "Creating and pushing merged tag: '$MERGED_TAG' for branch '$BRANCH_NAME'..."
git tag -f "$MERGED_TAG" "$BRANCH_HASH" || { echo "Error: Failed to create local tag '$MERGED_TAG'." >&2; exit 1; }
git push -f origin "$MERGED_TAG" || { echo "Error: Failed to push tag '$MERGED_TAG' to origin." >&2; exit 1; }
echo ""
echo "Branch **$BRANCH_NAME** successfully marked as **MERGED**."
echo "It remains in your repository history."
exit 0
```
-----
### 4\. `git-set-rejected`
This script marks a contribution branch as not being integrated into `master` by creating a `rejected/<branchname>` tag and removing any `active/` or `merged/` tags.
```bash
#!/bin/bash
# Script: git-set-rejected
# Purpose: To mark a contribution branch as not being integrated into master.
# Usage: git set-rejected <branchname>
# --- Input Validation ---
if [ -z "$1" ]; then
echo "Usage: git set-rejected <branchname>" >&2
echo "Example: git set-rejected AI0001Contribution002-ExperimentalAlgorithm" >&2
exit 1
fi
BRANCH_NAME="$1"
REJECTED_TAG="rejected/$BRANCH_NAME"
# Check if the branch exists locally or remotely
if ! git show-ref --quiet --verify "refs/heads/$BRANCH_NAME" && ! git show-ref --quiet --verify "refs/remotes/origin/$BRANCH_NAME"; then
echo "Error: Branch '$BRANCH_NAME' does not exist locally or remotely." >&2
exit 1
fi
# Get the latest commit hash of the branch. Prioritize remote.
BRANCH_HASH=$(git rev-parse "refs/remotes/origin/$BRANCH_NAME^{commit}" 2>/dev/null || git rev-parse "refs/heads/$BRANCH_NAME^{commit}" 2>/dev/null)
if [ -z "$BRANCH_HASH" ]; then
echo "Error: Could not determine commit hash for branch '$BRANCH_NAME'." >&2
exit 1
fi
# Remove active/merged tags if they exist
for STATUS_TAG_PREFIX in "active" "merged"; do
if git show-ref --quiet --verify "refs/tags/${STATUS_TAG_PREFIX}/$BRANCH_NAME"; then
echo "Removing existing remote tag: ${STATUS_TAG_PREFIX}/$BRANCH_NAME..."
git push origin --delete "${STATUS_TAG_PREFIX}/$BRANCH_NAME" || { echo "Warning: Failed to delete old remote tag ${STATUS_TAG_PREFIX}/$BRANCH_NAME." >&2; }
fi
done
# Create and push the rejected tag
echo "Creating and pushing rejected tag: '$REJECTED_TAG' for branch '$BRANCH_NAME'..."
git tag -f "$REJECTED_TAG" "$BRANCH_HASH" || { echo "Error: Failed to create local tag '$REJECTED_TAG'." >&2; exit 1; }
git push -f origin "$REJECTED_TAG" || { echo "Error: Failed to push tag '$REJECTED_TAG' to origin." >&2; exit 1; }
echo ""
echo "Branch **$BRANCH_NAME** successfully marked as **REJECTED**."
echo "It remains in your repository history for reference."
exit 0
```
-----
### 5\. `git-set-revive`
This script "re-activates" an *existing* contribution branch that was previously marked as `merged` or `rejected`. It removes the old status tag and re-applies the `active/` tag.
```bash
#!/bin/bash
# Script: git-set-revive
# Purpose: To re-activate an EXISTING contribution branch that was previously merged or rejected.
# Usage: git set-revive <branchname>
# --- Input Validation ---
if [ -z "$1" ]; then
echo "Usage: git set-revive <branchname>" >&2
echo "Example: git set-revive SkybuckContribution005-BugfixRethink" >&2
exit 1
fi
BRANCH_NAME="$1"
# Check if the branch exists locally or remotely
if ! git show-ref --quiet --verify "refs/heads/$BRANCH_NAME" && ! git show-ref --quiet --verify "refs/remotes/origin/$BRANCH_NAME"; then
echo "Error: Branch '$BRANCH_NAME' does not exist locally or remotely." >&2
exit 1
fi
# Check if it currently has a merged or rejected tag
HAS_MERGED_TAG=$(git ls-remote --tags origin "merged/$BRANCH_NAME")
HAS_REJECTED_TAG=$(git ls-remote --tags origin "rejected/$BRANCH_NAME")
if [ -z "$HAS_MERGED_TAG" ] && [ -z "$HAS_REJECTED_TAG" ]; then
echo "Error: Branch '$BRANCH_NAME' is not currently marked as 'merged/' or 'rejected/'. Cannot revive." >&2
echo "If it's active, use 'git set-active' to refresh its tag." >&2
exit 1
fi
echo "Attempting to revive branch '$BRANCH_NAME'..."
# Remove old status tags
for STATUS_TAG_PREFIX in "merged" "rejected"; do
if git show-ref --quiet --verify "refs/tags/${STATUS_TAG_PREFIX}/$BRANCH_NAME"; then
echo "Removing existing remote tag: ${STATUS_TAG_PREFIX}/$BRANCH_NAME..."
git push origin --delete "${STATUS_TAG_PREFIX}/$BRANCH_NAME" || { echo "Warning: Failed to delete old remote tag ${STATUS_TAG_PREFIX}/$BRANCH_NAME." >&2; }
fi
done
# Call git-set-active to apply the active tag
echo "---"
echo "Calling git set-active to mark as active..."
"$(dirname "$0")/git-set-active" "$BRANCH_NAME" || { echo "Error: Failed to set branch as active during revival. Please run 'git set-active $BRANCH_NAME' manually." >&2; exit 1; }
echo ""
echo "Branch **$BRANCH_NAME** successfully **REVIVED** and marked as **ACTIVE**."
echo "Remember, this branch's history has NOT been rebased onto master."
echo "You are now on this branch if you were already there. To switch: **git checkout $BRANCH_NAME**"
exit 0
```
-----
### 6\. `git-back-to`
This script creates a *new* development branch starting at a specified historical tag/commit.
```bash
#!/bin/bash
# Script: git-back-to
# Purpose: To create a NEW development branch from any specific historical point (a tag).
# Usage: git back-to <tagname_of_old_commit> "<new_branch_description>"
# --- Input Validation ---
if [ -z "$1" ] || [ -z "$2" ]; then
echo "Usage: git back-to <tagname_of_old_commit> \"<new_branch_description>\"" >&2
echo "Example: git back-to merged/AI0001Contribution007-OldAPIDesign \"Re-evaluate V1 API for performance\"" >&2
exit 1
fi
OLD_TAG_NAME="$1"
NEW_BRANCH_DESCRIPTION_RAW="$2"
# --- Configuration ---
# Get UserPrefix from git config, default to sanitized user.name
USER_PREFIX=$(git config user.contributionPrefix)
if [ -z "$USER_PREFIX" ]; then
USER_PREFIX=$(git config user.name | tr -cd '[:alnum:]' | head -c 10) # Sanitize and truncate
if [ -z "$USER_PREFIX" ]; then
echo "Error: Git user.name or user.contributionPrefix not set." >&2
echo "Please configure them: git config --global user.name \"Your Name\"" >&2
echo "Or: git config --global user.contributionPrefix \"YourPrefix\"" >&2
exit 1
fi
fi
# Slugify description
NEW_BRANCH_DESCRIPTION_SLUGIFIED=$(echo "$NEW_BRANCH_DESCRIPTION_RAW" | tr '[:upper:]' '[:lower:]' | sed -E 's/[^a-z0-9]+/-/g' | sed -E 's/^-+|-+$//g' | head -c 50)
if [ -z "$NEW_BRANCH_DESCRIPTION_SLUGIFIED" ]; then
echo "Error: New branch description cannot be empty or result in an empty slug." >&2
exit 1
fi
# Check if tag exists
if ! git show-ref --quiet --verify "refs/tags/$OLD_TAG_NAME" && ! git ls-remote --tags origin "refs/tags/$OLD_TAG_NAME"; then
echo "Error: Tag '$OLD_TAG_NAME' does not exist locally or remotely. Please ensure it's fetched." >&2
exit 1
fi
# 2. Determine next contribution number for the new branch
LAST_NUM=$(git for-each-ref --format='%(refname:short)' refs/{heads,remotes/origin}/"${USER_PREFIX}Contribution"* 2>/dev/null | \
grep -E "^${USER_PREFIX}Contribution[0-9]{3}-" | \
sed -E "s/^${USER_PREFIX}Contribution([0-9]{3})-.*$/\\1/" | \
sort -n | tail -1)
NEXT_NUM=1
if [ -n "$LAST_NUM" ]; then
NEXT_NUM=$((10#$LAST_NUM + 1))
fi
FORMATTED_NEXT_NUM=$(printf "%03d" "$NEXT_NUM")
NEW_BRANCH_NAME="${USER_PREFIX}Contribution${FORMATTED_NEXT_NUM}-${NEW_BRANCH_DESCRIPTION_SLUGIFIED}"
# Check if branch already exists locally or remotely
if git show-ref --quiet --verify "refs/heads/$NEW_BRANCH_NAME" || git show-ref --quiet --verify "refs/remotes/origin/$NEW_BRANCH_NAME"; then
echo "Error: New branch name '$NEW_BRANCH_NAME' already exists. This should not happen with sequential numbering." >&2
exit 1
fi
# 3. Create new local branch from tag
echo "Creating new branch '**$NEW_BRANCH_NAME**' from historical tag '**$OLD_TAG_NAME**'..."
git checkout -b "$NEW_BRANCH_NAME" "$OLD_TAG_NAME" || { echo "Error: Failed to create local branch '$NEW_BRANCH_NAME' from tag '$OLD_TAG_NAME'." >&2; exit 1; }
# 4. Push new branch to remote
echo "Pushing new branch '**$NEW_BRANCH_NAME**' to remote origin..."
git push -u origin "$NEW_BRANCH_NAME" || { echo "Error: Failed to push new branch to origin." >&2; exit 1; }
echo "---"
# 5. Call git-set-active
echo "Calling git set-active to mark as active..."
"$(dirname "$0")/git-set-active" "$NEW_BRANCH_NAME" || { echo "Warning: Failed to set branch as active. Please run 'git set-active $NEW_BRANCH_NAME' manually." >&2; }
echo ""
echo "Successfully created and activated new branch from historical tag:"
echo "-> Branch **$NEW_BRANCH_NAME** is based on **$OLD_TAG_NAME**."
echo "You are now on this branch. If you wish to bring it up to master, use **git the-future**."
exit 0
```
-----
### 7\. `git-the-future`
This script rebases the current branch onto the latest `master`, guiding the user through conflict resolution.
```bash
#!/bin/bash
# Script: git-the-future
# Purpose: To initiate the rebasing of the current active branch onto the latest master branch.
# Usage: git the-future
# --- Core Logic ---
CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD)
# Validate user is on a branch and not master
if [ "$CURRENT_BRANCH" = "HEAD" ] || [ "$CURRENT_BRANCH" = "" ]; then
echo "Error: You are not on a branch (detached HEAD). Please checkout a branch first." >&2
exit 1
fi
if [ "$CURRENT_BRANCH" = "master" ]; then
echo "Error: Cannot run 'git the-future' on the master branch." >&2
echo "This command is designed to rebase a feature branch onto master." >&2
exit 1
fi
echo "Preparing to rebase current branch '**${CURRENT_BRANCH}**' onto the latest **master**."
# Update local master
echo "Updating local master branch..."
git checkout master || { echo "Error: Could not checkout master." >&2; exit 1; }
git pull origin master || { echo "Error: Could not pull origin master. Please resolve manually or try again." >&2; exit 1; }
# Checkout original branch
git checkout "$CURRENT_BRANCH" || { echo "Error: Could not checkout original branch ${CURRENT_BRANCH}." >&2; exit 1; }
echo ""
echo "Starting rebase of **${CURRENT_BRANCH}** onto **master**..."
echo "---"
git rebase master
REBASE_STATUS=$? # Capture the exit status of the rebase command
if [ $REBASE_STATUS -eq 0 ]; then
echo "---"
echo "Rebase completed successfully!"
echo "Your branch **${CURRENT_BRANCH}** is now rebased on top of the latest **master**."
echo "To update the remote branch, you will likely need to force push (use --force-with-lease for safety):"
echo " **git push --force-with-lease origin ${CURRENT_BRANCH}**"
elif [ $REBASE_STATUS -eq 1 ]; then
echo "---"
echo "Rebase paused due to conflicts!" >&2
echo "Please resolve the conflicts manually in your files." >&2
echo "After resolving, use these commands:" >&2
echo " **git add .**" >&2
echo " **git rebase --continue**" >&2
echo "If you wish to abort the rebase:" >&2
echo " **git rebase --abort**" >&2
exit 1 # Indicate failure due to conflicts
else
echo "---"
echo "Rebase failed for an unexpected reason (exit code $REBASE_STATUS)." >&2
echo "Please investigate the git output above." >&2
exit 1
fi
exit 0
```
How do I store and use/test these scripts ?
That's an excellent and crucial question\! Having the scripts is one thing, but knowing how to set them up and test them is key to making your workflow a reality.
Here's a step-by-step guide on how to store, use, and test these scripts on both Linux and Windows (using Git Bash).
-----
## Storing, Using, and Testing Your Git Workflow Scripts
These scripts are written in Bash, so they will work natively on Linux and within the Git Bash environment on Windows. They will **not** work directly in Windows Command Prompt (CMD) or PowerShell.
### Step 1: Create a Dedicated Directory for Your Scripts
It's best practice to keep your custom scripts organized in a dedicated directory.
* **Choose a location:** A common choice is `~/bin` (a `bin` folder in your home directory) or you can create a new one like `~/git-commands`. Let's use `~/git-commands` for this guide.
* **Create the directory:**
```bash
mkdir -p ~/git-commands
```
(The `-p` flag ensures that if `~` doesn't have a directory named `git-commands`, it will create it.)
### Step 2: Save Each Script to Its Own File
For each of the 7 scripts I provided (e.g., `git-new-contribution`, `git-set-active`, etc.):
1. **Open a text editor:** Use a plain text editor (like VS Code, Notepad++, Sublime Text, Vim, Nano, Gedit, etc.).
2. **Copy the entire script content:** Copy the full Bash script code for one command.
3. **Paste into the editor.**
4. **Save the file:** Save the file into your `~/git-commands` directory.
* **Crucially, name the file exactly as specified:**
* `git-new-contribution`
* `git-set-active`
* `git-set-merged`
* `git-set-rejected`
* `git-set-revive`
* `git-back-to`
* `git-the-future`
* **Do NOT add a `.sh` extension** (e.g., don't save as `git-new-contribution.sh`). Git expects the executable to be named `git-yourcommand`.
Repeat this for all 7 scripts.
### Step 3: Make the Scripts Executable
For your operating system to run these files as programs, you need to set their executable permission.
* **Open your terminal (Bash on Linux, Git Bash on Windows).**
* **Navigate to your scripts directory:**
```bash
cd ~/git-commands
```
* **Make all scripts executable:**
```bash
chmod +x git-*
```
(This command makes all files starting with `git-` in the current directory executable.)
### Step 4: Add the Scripts Directory to Your System's PATH
Your shell needs to know where to find these custom `git-` commands. You do this by adding your `~/git-commands` directory to your `PATH` environment variable.
* **Open your terminal (Bash on Linux, Git Bash on Windows).**
* **Edit your shell's configuration file:**
* **Linux (Bash):** `nano ~/.bashrc` or `vim ~/.bashrc`
* **Linux (Zsh):** `nano ~/.zshrc` or `vim ~/.zshrc`
* **Windows (Git Bash):** `nano ~/.bashrc` or `nano ~/.profile` (either works, `.bashrc` is common)
* **Add the following line to the end of the file:**
```bash
export PATH="$PATH:$HOME/git-commands"
```
* **Save and close the file.**
* **Apply the changes:**
* **For the current session:** Run `source ~/.bashrc` (or `source ~/.zshrc` / `source ~/.profile`).
* **For future sessions:** Close and reopen your terminal.
### Step 5: Configure Git User Details (If Not Already Done)
Your scripts rely on your Git user name and email, and specifically a `user.contributionPrefix`.
* **Set your global Git user name and email:**
```bash
git config --global user.name "Your Name"
git config --global user.email "your.email@xxxxxxxxxxx"
```
* **Set your custom contribution prefix:**
```bash
git config --global user.contributionPrefix "Skybuck" # Or "AI0001", "JohnDoe", etc.
```
(The scripts will fall back to a sanitized version of `user.name` if `user.contributionPrefix` isn't set, but setting it explicitly is cleaner.)
### Step 6: Test Your Commands\!
Now you can test your custom workflow commands.
* **Navigate to an existing Git repository** where you want to test, or create a new one:
```bash
mkdir my-test-repo
cd my-test-repo
git init
touch README.md
git add README.md
git commit -m "Initial commit"
# Create a remote for testing (e.g., on GitHub, GitLab, or a local bare repo)
# git remote add origin <your_remote_repo_url>
# git push -u origin master
```
* **Test `git new-contribution`:**
```bash
git new-contribution Skybuck "My first test feature"
```
You should see output indicating branch creation, pushing, and activation.
* Verify: `git branch -a` (you should see your new branch) and `git tag --list 'active/*'` (you should see `active/SkybuckContribution001-My-first-test-feature`).
* **Test `git set-merged` (after some commits on the new branch, and ideally merging into master):**
```bash
# (Make some commits on SkybuckContribution001-My-first-test-feature)
# (Simulate merging into master - e.g., git checkout master && git merge SkybuckContribution001-My-first-test-feature)
git set-merged SkybuckContribution001-My-first-test-feature
```
* Verify: `git tag --list 'active/*'` (should no longer show it) and `git tag --list 'merged/*'` (should now show `merged/SkybuckContribution001-My-first-test-feature`).
* **Test `git back-to` and `git the-future`:**
```bash
# Assuming SkybuckContribution001-My-first-test-feature was merged and tagged
git back-to merged/SkybuckContribution001-My-first-test-feature "Testing revival and rebase"
# This creates a new branch (e.g., SkybuckContribution002-Testing-revival-and-rebase)
# You will be on this new branch.
# Make a small change on this new branch
echo "New line for revival" >> test.txt
git add test.txt
git commit -m "Added line to revived branch"
# Now, try to bring it up to master
git the-future
# Follow any instructions if conflicts occur.
# After successful rebase, push: git push --force-with-lease origin SkybuckContribution002-Testing-revival-and-rebase
```
By following these steps, you'll have your custom Git workflow up and running, ready for your extensive testing\!
Bye,
Skybuck Flying
skybuck2000@xxxxxxxxxxx
