Git and GitHub Cheatsheet

#!/bin/bash
# Git Repository Setup Script

# Initialize repository
git init

# Set up global configuration (run once per machine)
git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"
git config --global init.defaultBranch main
git config --global core.editor "code --wait"
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'
git config --global diff.tool vscode
git config --global difftool.vscode.cmd 'code --wait --diff $LOCAL $REMOTE'

# Set up useful aliases
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'
git config --global alias.visual '!gitk'
git config --global alias.graph 'log --graph --oneline --decorate --all'
git config --global alias.amend 'commit --amend --no-edit'
git config --global alias.pushf 'push --force-with-lease'
git config --global alias.pom 'push origin main'
git config --global alias.pod 'push origin develop'
git config --global alias.cleanup 'branch --merged | grep -v "\*\|main\|develop" | xargs -n 1 git branch -d'

# Create .gitignore file
cat > .gitignore << EOF
# Dependencies
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*

# Production builds
/dist
/build
*.tgz
*.tar.gz

# Runtime data
pids
*.pid
*.seed
*.pid.lock

# Coverage directory used by tools like istanbul
coverage/
*.lcov

# IDE files
.vscode/
.idea/
*.swp
*.swo
*~

# OS generated files
.DS_Store
.DS_Store?
._*
.Spotlight-V100
.Trashes
ehthumbs.db
Thumbs.db

# Environment variables
.env
.env.local
.env.development.local
.env.test.local
.env.production.local

# Logs
logs
*.log

# Temporary files
*.tmp
*.temp
EOF

# Create initial README.md
cat > README.md << EOF
# Project Name

Brief description of your project.

## Installation

```bash
npm install
```

## Usage

```bash
npm start
```

## Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Submit a pull request

## License

MIT License
EOF

# Add files and make initial commit
git add .
git commit -m "Initial commit: Setup project structure"

echo "Git repository initialized with best practices!"
echo "Next steps:"
echo "1. Add remote: git remote add origin <repository-url>"
echo "2. Push to remote: git push -u origin main"

#!/bin/bash
# Advanced Git Workflow Scripts

# Function to create and switch to a new feature branch
new_feature() {
    if [ -z "$1" ]; then
        echo "Usage: new_feature <feature-name>"
        return 1
    fi
    
    # Ensure we're on main/master
    git checkout main 2>/dev/null || git checkout master
    git pull origin main 2>/dev/null || git pull origin master
    
    # Create and switch to new branch
    git checkout -b "feature/$1"
    echo "Created and switched to feature/$1"
}

# Function to finish a feature branch
finish_feature() {
    current_branch=$(git branch --show-current)
    
    if [[ $current_branch != feature/* ]]; then
        echo "Error: Not on a feature branch"
        return 1
    fi
    
    # Push feature branch
    git push origin "$current_branch"
    
    # Switch back to main
    git checkout main
    git pull origin main
    
    echo "Feature branch $current_branch pushed to origin"
    echo "Create a pull request to merge into main"
}

# Function to clean up merged branches
cleanup_branches() {
    echo "Cleaning up merged branches..."
    
    # Delete local branches that have been merged
    git branch --merged main | grep -v "\*\|main\|master\|develop" | xargs -n 1 git branch -d
    
    # Clean up remote tracking branches
    git remote prune origin
    
    echo "Branch cleanup complete!"
}

# Function to sync with upstream (for forks)
sync_fork() {
    if [ -z "$1" ]; then
        echo "Usage: sync_fork <upstream-remote-name>"
        return 1
    fi
    
    # Fetch upstream changes
    git fetch "$1"
    
    # Switch to main branch
    git checkout main
    
    # Merge upstream changes
    git merge "$1/main"
    
    # Push updated main to origin
    git push origin main
    
    echo "Fork synced with upstream!"
}

# Function to create a hotfix branch
hotfix() {
    if [ -z "$1" ]; then
        echo "Usage: hotfix <hotfix-name>"
        return 1
    fi
    
    # Create hotfix branch from main
    git checkout main
    git pull origin main
    git checkout -b "hotfix/$1"
    
    echo "Created hotfix branch: hotfix/$1"
    echo "Make your fixes and run 'finish_hotfix $1'"
}

# Function to finish a hotfix
finish_hotfix() {
    if [ -z "$1" ]; then
        echo "Usage: finish_hotfix <hotfix-name>"
        return 1
    fi
    
    hotfix_branch="hotfix/$1"
    
    # Ensure we're on the hotfix branch
    git checkout "$hotfix_branch"
    
    # Push hotfix branch
    git push origin "$hotfix_branch"
    
    # Merge to main
    git checkout main
    git merge "$hotfix_branch"
    git push origin main
    
    # Merge to develop if it exists
    if git show-ref --verify --quiet refs/heads/develop; then
        git checkout develop
        git merge "$hotfix_branch"
        git push origin develop
    fi
    
    # Delete hotfix branch
    git branch -d "$hotfix_branch"
    git push origin --delete "$hotfix_branch"
    
    echo "Hotfix $1 completed and merged!"
}

# Function to squash commits in current branch
squash_commits() {
    if [ -z "$1" ]; then
        echo "Usage: squash_commits <number-of-commits>"
        return 1
    fi
    
    git rebase -i "HEAD~$1"
    echo "Interactive rebase started. Squash commits as needed."
}

# Function to generate a changelog
generate_changelog() {
    echo "# Changelog" > CHANGELOG.md
    echo "" >> CHANGELOG.md
    
    # Get all tags
    tags=$(git tag -l --sort=-version:refname)
    
    for tag in $tags; do
        echo "## $tag" >> CHANGELOG.md
        echo "" >> CHANGELOG.md
        
        # Get commits since previous tag
        if [ "$tag" = "$(echo "$tags" | tail -n 1)" ]; then
            # First tag, get all commits
            git log --pretty=format:"- %s (%h)" "$tag" >> CHANGELOG.md
        else
            # Get commits between tags
            prev_tag=$(echo "$tags" | grep -A 1 "$tag" | tail -n 1)
            git log --pretty=format:"- %s (%h)" "$prev_tag..$tag" >> CHANGELOG.md
        fi
        
        echo "" >> CHANGELOG.md
        echo "" >> CHANGELOG.md
    done
    
    echo "Changelog generated in CHANGELOG.md"
}

# Export functions for use
export -f new_feature finish_feature cleanup_branches sync_fork
export -f hotfix finish_hotfix squash_commits generate_changelog

echo "Advanced Git workflow functions loaded!"
echo "Available commands:"
echo "  new_feature <name>     - Create new feature branch"
echo "  finish_feature         - Finish current feature branch"
echo "  cleanup_branches       - Clean up merged branches"
echo "  sync_fork <upstream>   - Sync fork with upstream"
echo "  hotfix <name>          - Create hotfix branch"
echo "  finish_hotfix <name>   - Finish hotfix branch"
echo "  squash_commits <n>     - Squash last n commits"
echo "  generate_changelog     - Generate changelog from git tags"

#!/bin/bash
# GitHub CLI Automation Scripts
# Requires: gh cli tool (https://cli.github.com/)

# Function to create a new repository
create_repo() {
    if [ -z "$1" ]; then
        echo "Usage: create_repo <repo-name>"
        return 1
    fi
    
    repo_name="$1"
    
    # Create repository
    gh repo create "$repo_name" --public
    
    # Clone the repository
    gh repo clone "$repo_name"
    cd "$repo_name" || return 1
    
    echo "Repository $repo_name created and cloned!"
}

# Function to create a pull request
create_pr() {
    if [ -z "$1" ]; then
        echo "Usage: create_pr <title>"
        return 1
    fi
    
    title="$1"
    
    # Create PR with default template
    gh pr create --title "$title" --body "## Changes
- List your changes here

## Testing
- [ ] Tests pass locally
- [ ] Code follows style guidelines
- [ ] Self-review completed"
    
    echo "Pull request created: $title"
}

# Function to review and merge PR
review_pr() {
    if [ -z "$1" ]; then
        echo "Usage: review_pr <pr-number>"
        return 1
    fi
    
    pr_number="$1"
    
    # Approve and merge PR
    gh pr review "$pr_number" --approve
    gh pr merge "$pr_number" --squash
    
    echo "PR #$pr_number approved and merged"
}

# Function to create an issue
create_issue() {
    if [ -z "$1" ]; then
        echo "Usage: create_issue <title>"
        return 1
    fi
    
    title="$1"
    
    # Create issue with template
    gh issue create --title "$title" --body "## Description
Please describe the issue

## Steps to Reproduce
1. Step one
2. Step two
3. Step three

## Expected Behavior
What should happen

## Actual Behavior
What actually happens"
    
    echo "Issue created: $title"
}

# Function to create a release
create_release() {
    if [ -z "$1" ]; then
        echo "Usage: create_release <version>"
        return 1
    fi
    
    version="$1"
    
    # Create release with auto-generated notes
    gh release create "$version" --title "Release $version" --generate-notes
    
    echo "Release $version created!"
}

# Common GitHub CLI commands
echo "GitHub CLI Quick Commands:"
echo "  gh repo list                     - List your repositories"
echo "  gh repo view                     - View current repository"
echo "  gh pr list                       - List pull requests"
echo "  gh pr status                     - Show PR status"
echo "  gh issue list                    - List issues"
echo "  gh workflow list                 - List GitHub Actions workflows"
echo "  gh workflow run <workflow>       - Run a workflow"
echo "  gh auth status                   - Check authentication status"
echo "  gh auth login                    - Login to GitHub"