Learning_Git/Git_Workflow_Guide.md

Git Workflow Guide for Life Planner

Table of Contents

1. Quick Reference Guides

• Life Planner Git Workflow Cheat Sheet
  • Start Day Process
  • Start Task Process
  • Save Work Process
  • Complete Task Process
  • End Day Process

2. Error Resolution Guides

• Start of Day Errors
  • Branch Already Exists
  • Uncommitted Changes
  • Local Changes Overwrite
  • Branch Name Mismatch
  • End of Day Errors
  • Push Rejection Handling
  • Merge Conflict Resolution

3. Detailed Workflow Processes

• Starting Work for the Day
• Branch and Directory Navigation
• Working on Tasks
• Handling Remote Changes
• End of Day Procedures

4. File Management

• Local vs Remote Changes
  • Viewing Differences
  • Keeping Remote Changes
  • Keeping Local Changes
  • Comparing Files

5. Scripts and Automation

• Project Status Scripts
  • Check Project Status
  • Start Working on Project
  • Update Task Status
  • End of Day Commit
• Task Management Commands
• Report Generation

6. Reference

• Common Commit Messages
• Status Check Commands
• Installation Instructions
• Usage Examples

---

1. Quick Reference Guides

Life Planner Git Workflow Cheat Sheet

Start Day Process

START DAY:
1. git checkout main
2. git branch                                              # See which branch to checkout or create a new one
3. git pull origin main
4. git checkout -b working_projectname_YYYYMMDD

Start Task Process

START TASK:
1. git status
2. Show counts of Tasks by Status:

• echo "WORKING tasks: $(grep -r "tags: .*WORKING" . | wc -l)"
  echo "OPEN tasks: $(grep -r "tags: .*OPEN" . | wc -l)"
  echo "CLOSED tasks: $(grep -r "tags: .*CLOSED" . | wc -l)"
  

3. Identify Task to work on:
   - grep -r "tags: .*WORKING" .                                  # View WORKING tasks
   - grep -r "tags: .*OPEN" .                                     # View OPEN tasks
   - grep -r "tags: .*CLOSED" .                                   # View CLOSED tasks
4. nano filename.md
5. Update task status to WORKING if starting a new task

Save Work Process

SAVE WORK:
1. git add filename.md (or git add .)
2. git commit -m "message"

Complete Task Process

COMPLETE TASK:
1. Update task status to CLOSED
2. git add filename.md
3. git commit -m "Completed task message"

End Day Process

END DAY:
1. Review Changes:
   - git status                                      # Check current status
   - git diff --name-only                            # List changed files
   - git log --oneline                               # View recent commits
2. Check Branch Status:
   - git branch --merged                             # List merged branches
   - git branch --no-merged                          # List unmerged branches
   - git branch -vv                                  # View branch details
3. Merge and Push:
    - git checkout main
    - git merge working_projectname_YYYYMMDD
    - git push
4. Clean Up:
   - git branch -d working_projectname_YYYYMMDD      # Delete merged branch
   - git branch                                      # Verify cleanup
   - git status

Common Task Status Commands

# Quick status checks
git status                                            # Current repository status
git branch                                            # List all branches
git diff --name-only                                  # List modified files

# Task status queries
grep -r "tags: .*WORKING" .                           # Find all WORKING tasks
grep -r "tags: .*OPEN" .                              # Find all OPEN tasks
grep -r "tags: .*CLOSED" .                            # Find all CLOSED tasks

# Branch management
git branch --merged                                   # Show merged branches
git branch --no-merged                                # Show unmerged branches
git branch -vv                                        # Detailed branch information

Back to Top

---

2. Error Resolution Guides

Start of Day Errors

Branch Already Exists

1. git checkout main                              # Return to main branch
2. git branch -D working_projectname_YYYYMMDD     # Delete existing branch
3. git checkout -b working_projectname_YYYYMMDD   # Create new branch

Uncommitted Changes

1. git stash                                      # Save current changes
2. git checkout main                              # Switch to main
3. git pull origin main                           # Get updates
4. git checkout -b working_projectname_YYYYMMDD   # Create new branch
5. git stash pop                                  # Restore your changes

Local Changes Overwrite

1. git add .                                      # Stage current changes
2. git commit -m "WIP - Saving current progress"  # Save changes
3. git checkout main                              # Then proceed with normal process

Branch Name Mismatch

1. git branch                                     # Check existing branches
2. git checkout main                              # Ensure on main
3. git pull origin main                           # Get latest changes
4. git checkout -b working_projectname_YYYYMMDD   # Create new branch (check spelling)

End of Day Errors

Push Rejection Handling

# When you see the error in your image:
1. git pull origin main     # Get remote changes
2. git merge main          # Merge them into your branch
3. git push origin main    # Try pushing again

Merge Conflict Resolution

If you get conflicts during the merge:

1. Open the conflicted files
2. Look for conflict markers (<<<<<<, =======, >>>>>>>)
3. Edit the files to resolve conflicts
4. Save the files
5. git add . to mark conflicts as resolved
6. git commit -m "Resolved merge conflicts"

Back to Top

---

3. Detailed Workflow Processes

Starting Work for the Day

1. git checkout main

   • Switch to main branch to ensure you're starting from the latest version

2. git pull

   • Get any updates that might have been made elsewhere

3. git checkout -b working_projectname_YYYYMMDD

   • Create and switch to a new branch for today's work
   • Example: git checkout -b working_financial_20231031

Branch and Directory Navigation

Best Practices

Always work from the life_planner root directory when creating and managing branches. This ensures proper version control and file tracking.

# Correct approach (from life_planner root directory):
/mnt/d/OneDrive/GH_Repositories/life_planner$ git checkout main
/mnt/d/OneDrive/GH_Repositories/life_planner$ git pull origin main
/mnt/d/OneDrive/GH_Repositories/life_planner$ git checkout -b working_projectname_YYYYMMDD

Benefits of Working from Root Directory

1. Git tracks all project files from the root directory
2. Ensures consistent branch management
3. Prevents potential branch/tracking issues
4. Maintains clear project history

Why Not CD Into Project Directory

• Git branches affect the entire repository
• Working from a subdirectory might:
  • Cause confusion about which files are being tracked
  • Lead to incomplete commits
  • Make it harder to manage multiple task files

Example Workflow

# 1. Start in life_planner root
/mnt/d/OneDrive/GH_Repositories/life_planner$

# 2. Create/checkout branch
git checkout -b working_financial_20231101

# 3. Then you can edit files in any project subdirectory
vim ONG_Assessing_Financial_Situation/01_T_MS1_Connect_all_financial_accounts_in_Tiller.md

# 4. Git commands will work for all modified files
git status    # Shows changes across all directories
git add .     # Stages changes from all directories

Working on Tasks

Before Starting a Task

1. git status

   • Check which files have been modified
   • Verify you're on the correct branch

2. Update task status in markdown file

   • Change task status tag from OPEN to WORKING
   • Example: tags: [WORKING, MS1_Tiller_Account_Setup]

While Working

1. git add filename.md

   • Stage specific files you've modified
   • Or use git add . to stage all changes

2. git commit -m "Meaningful commit message"

   • Save your changes with a clear message
   • Example: "Updated Task 1.1 status to WORKING"

Handling Remote Changes

Process for Remote Updates

1. First, stage your local changes:

git add .
git commit -m "End of day changes - YYYY-MM-DD"

2. Switch to main branch:

git checkout main

3. Get remote changes BEFORE merging your work:

git pull origin main

4. Switch back to your working branch:

git checkout working_projectname_YYYYMMDD

5. Integrate main's changes into your working branch:

git merge main

• Resolve any conflicts if they occur

End of Day Procedures

Finishing a Task

1. Update task status to CLOSED

   • Change task status tag to CLOSED
   • Example: tags: [CLOSED, MS1_Tiller_Account_Setup]

2. Stage and commit the status change:

git add filename.md
git commit -m "Completed Task 1.1 - [Brief description]"

Final Steps

1. Switch to main branch:

git checkout main

2. Merge your work:

git merge working_projectname_YYYYMMDD

3. Push changes:

git push origin main

4. Clean up:

git branch -d working_projectname_YYYYMMDD

Back to Top

---

4. File Management

Local vs Remote Changes

Viewing Differences

# See what's different between your local file and remote
git diff workflow_overview.md

# For a more detailed view
git diff origin/main workflow_overview.md

# View file content differences
git diff --word-diff workflow_overview.md

Keeping Remote Changes

# Option 1: Discard local changes for specific file
git checkout origin/main workflow_overview.md

# Option 2: Force overwrite local with remote
git fetch origin
git reset --hard origin/main

⚠️ WARNING: reset --hard will discard ALL local changes!

Keeping Local Changes

# Stash your local changes
git stash

# Pull remote changes
git pull

# Then decide:
git stash pop   # Apply your local changes back
# or
git stash drop  # Discard your local changes

Comparing Files

View Current Changes

# View local file content
cat workflow_overview.md

# View remote file content
git show origin/main:workflow_overview.md

# Compare specific versions
git diff HEAD~1 workflow_overview.md  # Compare with previous version

Quick Solutions for Common Scenarios

To Overwrite Local with Remote:

# For specific file
1. git checkout origin/main workflow_overview.md
2. git pull

# For all files
1. git fetch origin
2. git reset --hard origin/main

To Keep Both and Decide Later:

1. git stash
2. git pull
3. git stash pop
4. # Resolve any conflicts manually

To Compare and Decide:

# View differences
git diff workflow_overview.md

# Keep remote version
git checkout origin/main workflow_overview.md

# Or keep local and commit
git add workflow_overview.md
git commit -m "Keeping local changes to workflow_overview.md"
git pull

Best Practices for File Management

1. Always check status before making changes:

   git status
   

2. Review changes before committing:

   git diff --staged  # For staged changes
   git diff          # For unstaged changes
   

3. Use meaningful commit messages:

   git commit -m "Updated workflow documentation with new file management section"
   

4. Regularly sync with remote:

   git fetch origin
   git status  # Check if you're behind/ahead
   

Back to Top

---

5. Scripts and Automation

Project Status Scripts

Check Project Status

#!/bin/bash

echo "=== Current Project Statuses ==="
echo "-------------------------------"

# Find all README.md files and check their status tags
find . -name "README.md" -type f -exec sh -c '
    echo "Project: $(dirname {})"
    grep -H "STATUS:" {} 2>/dev/null
    echo
' \;

echo "=== Active (WORKING) Tasks ==="
echo "-----------------------------"
find . -name "*.md" -type f -exec sh -c '
    if grep -l "tags: .*WORKING" "$0" >/dev/null; then
        echo "File: $0"
        head -n 3 "$0"
        echo "---"
    fi
' {} \;

Start Working on Project

#!/bin/bash

start_project() {
    local project_name=$1
    
    # Create and checkout new branch
    git checkout -b "working_${project_name}_$(date +%Y%m%d)"
    
    # Show current tasks in project
    echo "Current tasks in $project_name:"
    find "$project_name" -name "*.md" -type f -exec sh -c '
        echo "=== $(basename $1) ==="
        grep "tags:" "$1" 2>/dev/null
        echo
    ' sh {} \;
}

# Usage: ./start_project.sh project_name
start_project "$1"

Update Task Status

#!/bin/bash

update_task_status() {
    local task_file=$1
    local new_status=$2
    
    # Update status in task file
    sed -i "s/tags: \[.*\]/tags: [$new_status/" "$task_file"
    
    # Add to git
    git add "$task_file"
    
    echo "Updated status of $task_file to $new_status"
}

# Usage: ./update_task.sh task_file.md WORKING
update_task_status "$1" "$2"

End of Day Commit

#!/bin/bash

end_day_commit() {
    # Get current branch
    current_branch=$(git branch --show-current)
    
    # Generate work summary
    echo "=== Work Summary $(date +%Y-%m-%d) ===" > work_summary.tmp
    echo "Branch: $current_branch" >> work_summary.tmp
    echo "" >> work_summary.tmp
    
    # Find all modified files
    echo "Modified Tasks:" >> work_summary.tmp
    git diff --name-only | while read -r file; do
        if [[ $file == *.md ]]; then
            echo "- $file" >> work_summary.tmp
            grep "tags:" "$file" >> work_summary.tmp
        fi
    done
    
    # Create commit message
    commit_msg=$(cat work_summary.tmp)
    
    # Commit changes
    git add .
    git commit -m "$commit_msg"
    
    # Merge back to main
    git checkout main
    git merge "$current_branch"
    
    # Clean up
    rm work_summary.tmp
    
    echo "Day's work committed and merged"
}

end_day_commit

Task Management Commands

# Show all WORKING tasks
find . -type f -name "*.md" -exec sh -c '
    if grep -l "tags: .*WORKING" "$0" >/dev/null; then
        echo "=== $0 ==="
        head -n 5 "$0"
        echo
    fi
' {} \;

# Show tasks by milestone
find . -type f -name "*.md" -exec sh -c '
    if grep -l "tags: .*MS1" "$0" >/dev/null; then
        echo "=== $0 ==="
        grep "tags:" "$0"
        echo
    fi
' {} \;

Report Generation

#!/bin/bash

generate_report() {
    local report_file="progress_report_$(date +%Y%m%d).md"
    
    echo "# Progress Report $(date +%Y-%m-%d)" > "$report_file"
    echo "" >> "$report_file"
    
    # Project Status Summary
    echo "## Project Status" >> "$report_file"
    find . -name "README.md" -type f -exec sh -c '
        echo "### $(dirname {})"
        grep "STATUS:" {} 2>/dev/null
        echo
    ' >> "$report_file" \;
    
    # Task Status by Milestone
    echo "## Task Status by Milestone" >> "$report_file"
    for milestone in MS{1..7}; do
        echo "### $milestone" >> "$report_file"
        echo "#### WORKING:" >> "$report_file"
        find . -type f -name "*.md" -exec grep -l "tags: .*WORKING.*$milestone" {} \; >> "$report_file"
        echo "#### CLOSED:" >> "$report_file"
        find . -type f -name "*.md" -exec grep -l "tags: .*CLOSED.*$milestone" {} \; >> "$report_file"
        echo "" >> "$report_file"
    done
    
    echo "Report generated: $report_file"
}

generate_report

Back to Top

---

6. Reference

Common Commit Messages

# Starting Task
"Started work on Task X.X - Brief description"
"Initialized Task X.X - Setting up environment"

# Status Updates
"Updated Task X.X status to WORKING"
"Updated Task X.X status to CLOSED"
"In progress: Task X.X - Current status update"

# Task Completion
"Completed Task X.X - Brief description of accomplishment"
"Finished Task X.X - Added all requested features"

# End of Day
"End of day commit - Tasks X.X, X.X completed"
"Daily progress - Multiple task updates"

# WIP (Work in Progress)
"WIP: Task X.X - Saving current progress"
"WIP: Intermediate save for Task X.X"

Status Check Commands

# Basic Status Checks
git status                      # Current working state
git log --oneline              # Commit history in compact form
git branch                     # List all branches
git remote -v                  # Show remote repositories

# Detailed Checks
git log --graph --decorate     # Visual commit history
git diff --name-status         # List of changed files
git show HEAD                  # Latest commit details
git remote show origin         # Remote branch details

# Branch Information
git branch -vv                 # Verbose branch info
git branch --merged            # Show merged branches
git branch --no-merged        # Show unmerged branches

# File History
git log --follow filename     # File history including renames
git blame filename           # Line-by-line change history

Installation Instructions

1. Initial Setup

# Make scripts directory
mkdir -p ~/life_planner/scripts

# Copy all scripts
cp *.sh ~/life_planner/scripts/

# Make scripts executable
chmod +x ~/life_planner/scripts/*.sh

2. Configure Git

# Set up user information
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

# Set default branch name
git config --global init.defaultBranch main

# Set up aliases for common commands
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit

3. Script Installation

# Add to PATH (add to .bashrc or .zshrc)
export PATH="$PATH:$HOME/life_planner/scripts"

# Verify installation
which start_project.sh
which update_task.sh
which end_day_commit.sh

Usage Examples

Daily Workflow Example

# Morning Start
git checkout main
git pull
git checkout -b working_financial_20231101

# Start New Task
vim task1.md                    # Edit task status to WORKING
git add task1.md
git commit -m "Started Task 1.1 - Setting up Tiller"

# Complete Task
vim task1.md                    # Edit task status to CLOSED
git add task1.md
git commit -m "Completed Task 1.1 - Tiller setup complete"

# End of Day
git checkout main
git pull
git merge working_financial_20231101
git push
git branch -d working_financial_20231101

Using Automation Scripts

# Start new project work
./start_project.sh financial_planning

# Update task status
./update_task.sh task1.md WORKING
./update_task.sh task1.md CLOSED

# Generate daily report
./generate_report.sh

# End of day commit
./end_day_commit.sh

Common Scenarios

Handling Interruptions

# Save current work
git add .
git commit -m "WIP: Saving progress on Task 1.1"

# Switch to urgent task
git checkout -b urgent_fix
# ... work on urgent task ...

# Return to previous work
git checkout working_financial_20231101

Managing Multiple Tasks

# List all active tasks
find . -name "*.md" -exec grep -l "tags: .*WORKING" {} \;

# Check task status
git status
git diff --name-only

# Review day's changes
git log --since="6am" --oneline

Back to Top

---