کتاب جامع Git و GitHub

# Download via winget (Windows Package Manager)
winget install --id Git.Git -e --source winget

# Verify installation
git --version
# Output: git version 2.45.0.windows.1

# Optional: install GitHub CLI
winget install --id GitHub.cli
gh auth login

# Option A: via Homebrew (recommended)
brew install git

# Option B: via Xcode Command Line Tools
xcode-select --install

# Verify
git --version
# Output: git version 2.45.0

# Debian / Ubuntu
sudo apt update && sudo apt install git -y

# Fedora / RHEL
sudo dnf install git -y

# Arch Linux
sudo pacman -S git

# Verify
git --version

# Set global identity (used for every commit)
git config --global user.name "Abbas Talebifard"
git config --global user.email "abbas@example.com"

# Set default branch name (modern convention)
git config --global init.defaultBranch main

# Set preferred editor
git config --global core.editor "code --wait"        # VS Code
# git config --global core.editor "vim"              # Vim
# git config --global core.editor "nano"             # Nano

# Enable colored output
git config --global color.ui auto

# Set default pull behavior (rebase instead of merge)
git config --global pull.rebase true

# Configure line endings (cross-platform)
# Windows:
git config --global core.autocrlf true
# macOS/Linux:
git config --global core.autocrlf input

# View all settings
git config --list
git config --global --list

# Edit global config file directly
git config --global --edit

# Step 1: Generate a new SSH key (Ed25519 - modern & secure)
ssh-keygen -t ed25519 -C "abbas@example.com"
# Press Enter to accept default path (~/.ssh/id_ed25519)
# Set a passphrase (optional but recommended)

# Step 2: Start ssh-agent in background
eval "$(ssh-agent -s)"

# Step 3: Add private key to ssh-agent
ssh-add ~/.ssh/id_ed25519

# Step 4: Copy public key to clipboard
cat ~/.ssh/id_ed25519.pub
# macOS: pbcopy < ~/.ssh/id_ed25519.pub
# Windows: clip < ~/.ssh/id_ed25519.pub
# Linux: xclip -sel clip < ~/.ssh/id_ed25519.pub

# Step 5: Add key to GitHub → Settings → SSH and GPG keys → New SSH key

# Step 6: Test connection
ssh -T git@github.com
# Output: Hi A-talebifard! You've successfully authenticated...

# Create a new directory and initialize git
mkdir my-first-repo
cd my-first-repo
git init

# Create a README file
echo "# My First Repo" > README.md

# Check status (file is untracked)
git status

# Stage the file
git add README.md

# Commit with a message
git commit -m "Initial commit: add README"

# View commit history
git log --oneline

# Connect to GitHub (create empty repo on GitHub first)
git remote add origin git@github.com:A-talebifard/my-first-repo.git
git branch -M main
git push -u origin main

# Initialize a new git repo in current directory
mkdir my-project && cd my-project
git init
# Output: Initialized empty Git repository in /path/.git/

# Initialize with a specific default branch
git init -b main

# Initialize a bare repo (for servers, no working dir)
git init --bare my-project.git

# Clone an existing remote repository
git clone https://github.com/A-talebifard/my-project.git
git clone git@github.com:A-talebifard/my-project.git   # via SSH

# Clone into a specific directory
git clone git@github.com:A-talebifard/my-project.git my-folder

# Clone only the latest commit (shallow, saves bandwidth)
git clone --depth 1 git@github.com:A-talebifard/my-project.git

# Stage a single file
git add README.md

# Stage multiple files
git add file1.txt file2.txt file3.txt

# Stage all changes in current directory (recursive)
git add .
git add --all          # stages deletions too
git add -A             # same as --all

# Stage all .js files
git add "*.js"

# Stage interactively (patch mode - choose hunks)
git add -p
# For each changed hunk, choose: y (yes), n (no), s (split), q (quit)

# Stage a specific directory
git add src/components/

# Stage based on modification type
git add -u             # only modified/deleted, not new files

# Basic commit with message
git commit -m "Add user authentication"

# Multi-line commit message (title + body)
git commit -m "Add user authentication

- Implement JWT-based login flow
- Add /api/auth/login and /api/auth/register
- Add password hashing with bcrypt
- Add tests for auth middleware"

# Stage all tracked modifications and commit in one step
git commit -am "Update README"

# Amend the last commit (add changes or fix message)
git commit --amend -m "New message"
git commit --amend --no-edit    # keep message, add changes

# Empty commit (useful for CI triggers)
git commit --allow-empty -m "Trigger CI"

# Sign commit with GPG key
git commit -S -m "Signed commit"

# Conventional Commits format
# <type>(<scope>): <description>
git commit -m "feat(auth): add OAuth2 login support"
git commit -m "fix(api): handle null user in /profile"
git commit -m "docs: update installation guide"
git commit -m "refactor: simplify token validation"
git commit -m "test: add unit tests for user model"
git commit -m "chore: bump dependencies"

# Show working tree status
git status

# Short format (compact)
git status -s
# Output:
#  M modified-file.txt       (modified, not staged)
# M  staged-file.txt         (staged)
# A  new-staged-file.txt     (added & staged)
# ?? untracked-file.txt      (untracked)

# Show branch info
git status -b

# Show ignored files too
git status --ignored

# Show commit history
git log

# One-line compact format
git log --oneline
# Output:
# a1b2c3d (HEAD -> main, origin/main) Add user auth
# d4e5f6g Update README
# 7h8i9j0 Initial commit

# Graph view with branches
git log --oneline --graph --all --decorate

# Show last N commits
git log -5

# Show commits by a specific author
git log --author="Abbas"

# Show commits since a date
git log --since="2 weeks ago"
git log --since="2024-01-01"

# Show commits for a specific file
git log -- path/to/file.txt

# Show diff for each commit
git log -p

# Show stats per commit
git log --stat

# Show commits in a date range
git log --after="2024-01-01" --before="2024-06-01"

# Search commits by message (regex)
git log --grep="auth"

# Custom format
git log --pretty=format:"%h - %an, %ar : %s"

# Diff working dir vs staging area (unstaged changes)
git diff

# Diff staging area vs last commit (staged changes)
git diff --staged
git diff --cached     # same as --staged

# Diff working dir vs last commit (all changes)
git diff HEAD

# Diff between two commits
git diff a1b2c3d d4e5f6g

# Diff between two branches
git diff main feature/login

# Diff for a specific file
git diff path/to/file.txt

# Show only file names that changed
git diff --name-only

# Show stats (insertions/deletions)
git diff --stat

# Word-level diff (better for prose)
git diff --word-diff

# List remote repositories
git remote -v
# origin  git@github.com:A-talebifard/repo.git (fetch)
# origin  git@github.com:A-talebifard/repo.git (push)

# Add a remote
git remote add origin git@github.com:A-talebifard/repo.git

# Add upstream (for forks)
git remote add upstream git@github.com:original-owner/repo.git

# Change remote URL (e.g., from HTTPS to SSH)
git remote set-url origin git@github.com:A-talebifard/repo.git

# Rename a remote
git remote rename origin github

# Remove a remote
git remote remove origin

# Show details of a remote
git remote show origin

# Push current branch to origin, set upstream tracking
git push -u origin main
# -u is shorthand for --set-upstream

# After first push, just:
git push
git push origin main

# Force push (DANGEROUS - rewrites remote history)
git push --force-with-lease     # safer than --force
git push -f                     # use only on personal branches!

# Push all branches
git push --all

# Push tags
git push --tags
git push origin v1.0.0

# Delete a remote branch
git push origin --delete feature/old-branch

# Pull = fetch + merge
git pull
git pull origin main

# Pull with rebase (cleaner history)
git pull --rebase origin main

# Fetch without merging (safer)
git fetch origin
git fetch --all --prune

# Look inside the .git directory
ls -la .git/
# HEAD  config  description  hooks/  info/  objects/  refs/

# View the HEAD pointer
cat .git/HEAD
# Output: ref: refs/heads/main

# View the type of any object by SHA
git cat-file -t a1b2c3d
# Output: commit

# View the content of an object (raw)
git cat-file -p a1b2c3d
# Output:
# tree e5f6g7h...
# parent y4z5a6b...
# author Abbas <abbas@example.com> 1700000000 +0330
# committer Abbas <abbas@example.com> 1700000000 +0330
#
# Add user authentication

# Hash a file without storing it (see what hash it WOULD get)
git hash-object README.md
# Output: i9j0k1l...

# Write a file to git object database
git hash-object -w README.md

# List all objects in the database
git rev-list --all --objects | head -20

# View tree contents
git ls-tree HEAD
git ls-tree HEAD src/

# Show commit details
git show a1b2c3d

# View all refs
git show-ref

# Local branches
ls .git/refs/heads/
cat .git/refs/heads/main
# Output: a1b2c3d... (SHA of latest commit on main)

# Remote branches
ls .git/refs/remotes/origin/

# Tags
ls .git/refs/tags/

# HEAD points to current branch
cat .git/HEAD
# ref: refs/heads/main

# Special refs
# ORIG_HEAD  - previous HEAD (after reset/merge)
# MERGE_HEAD - commit being merged in
# FETCH_HEAD - result of last fetch

# Symbolic ref (HEAD points to a branch)
git symbolic-ref HEAD
# refs/heads/main

# Detached HEAD (HEAD points to a commit directly)
git checkout a1b2c3d
git symbolic-ref HEAD
# fatal: ref HEAD is not a symbolic ref

# View reflog for HEAD
git reflog
# Output:
# a1b2c3d HEAD@{0}: commit: Add feature X
# y4z5a6b HEAD@{1}: checkout: moving from feature to main
# 7h8i9j0 HEAD@{2}: reset: moving to HEAD~1
# k1l2m3n HEAD@{3}: commit: Important work (was "lost")

# View reflog for a specific branch
git reflog show feature/login

# Recover a "lost" commit
git reset --hard k1l2m3n   # go back to that commit

# Expire old reflog entries (cleanup)
git reflog expire --expire=90.days --all

# Garbage collect (permanently remove unreachable objects)
git gc --prune=now

# List all local branches
git branch
# * main
#   feature/login
#   feature/signup

# List all branches (local + remote)
git branch -a

# List branches with last commit info
git branch -v

# List merged branches (into current)
git branch --merged

# List unmerged branches
git branch --no-merged

# Create a new branch (stay on current)
git branch feature/login

# Create and switch in one step
git switch -c feature/login
git checkout -b feature/login    # older syntax

# Switch to an existing branch
git switch main
git checkout main                # older syntax

# Switch to previous branch
git switch -
git checkout -                   # older syntax

# Rename current branch
git branch -m new-name

# Rename another branch
git branch -m old-name new-name

# Delete a fully-merged branch (safe)
git branch -d feature/login

# Force delete a branch (even if not merged)
git branch -D feature/login

# Delete a remote branch
git push origin --delete feature/login

# Track a remote branch
git switch -c feature/login --track origin/feature/login
git checkout -b feature/login origin/feature/login

# Push a new branch to remote and set upstream
git push -u origin feature/login

# Switch to target branch (e.g., main)
git switch main

# Merge feature branch into main
git merge feature/login

# Fast-forward merge (default when possible)
# If main hasn't changed since branch was created,
# Git just moves the main pointer forward

# Three-way merge (when both branches have new commits)
# Git creates a merge commit with two parents

# Disable fast-forward (always create merge commit)
git merge --no-ff feature/login

# Force fast-forward (fail if not possible)
git merge --ff-only feature/login

# Merge with a message
git merge -m "Merge feature/login into main" feature/login

# Squash merge (combine all commits into one)
git merge --squash feature/login
git commit -m "Add login feature (squashed)"

# Abort a merge in progress
git merge --abort

# Check if a branch is merged
git branch --merged | grep feature/login

# Show branches that contain a specific commit
git branch --contains a1b2c3d

# Show remote branches that contain a commit
git branch -r --contains a1b2c3d

# Compare branches
git log main..feature/login        # commits in feature, not in main
git log feature/login..main        # commits in main, not in feature
git log --left-right main...feature/login  # both, with markers

# Show diff between branch tips
git diff main feature/login

# Cherry-pick a single commit from another branch
git cherry-pick a1b2c3d

# Move a branch to a different commit
git branch -f feature/login a1b2c3d

# Create a branch from a specific commit
git branch hotfix a1b2c3d

# List branches sorted by last commit date
git for-each-ref --sort=-committerdate refs/heads/ \
  --format='%(committerdate:short) %(refname:short)'

# Basic rebase: replay feature commits on top of main
git switch feature/login
git rebase main

# Rebase and then fast-forward main (clean alternative to merge)
git switch feature/login
git rebase main
git switch main
git merge --ff-only feature/login   # safe now

# Interactive rebase (most powerful tool!)
git rebase -i HEAD~3
# Opens editor with last 3 commits:
# pick a1b2c3d Commit 1
# pick d4e5f6g Commit 2
# pick 7h8i9j0 Commit 3
#
# Commands you can use:
# pick   = use commit as-is
# reword = use commit, but edit message
# edit   = use commit, but pause to amend
# squash = combine with previous commit
# fixup  = like squash, but discard message
# drop   = remove commit entirely
# reorder = rearrange lines to reorder commits

# Abort a rebase
git rebase --abort

# Continue after fixing conflicts
git rebase --continue

# Skip a commit (if it's empty after rebase)
git rebase --skip

# Rebase onto a different base (advanced)
git rebase --onto main old-base feature/login

# Before: 5 messy commits on feature branch
git log --oneline
# f5g6h7i WIP: login form
# j8k9l0m fix typo
# n1p2q3r WIP: validation
# s4t5u6v cleanup
# w7x8y9z Add login feature

# Start interactive rebase for last 5 commits
git rebase -i HEAD~5

# In editor, change to:
# pick   w7x8y9z Add login feature
# squash s4t5u6v cleanup
# squash n1p2q3r WIP: validation
# squash j8k9l0m fix typo
# squash f5g6h7i WIP: login form

# After saving, edit combined message:
# Add login feature
#
# - Form with email/password
# - Client-side validation
# - API integration

# Result: 1 clean commit instead of 5
git log --oneline
# a1b2c3d Add login feature

// Original file (on main):
function greet(name) {
  return "Hello, " + name;
}

// During merge, Git shows conflict like this:
<<<<<<< HEAD
function greet(name) {
  return "Hi, " + name + "!";
}
=======
function greet(name) {
  return `Hello, ${name}!`;
}
>>>>>>> feature/login

// <<<<<<< HEAD : your current branch (HEAD)
// ======= : separator
// >>>>>>> feature/login : incoming branch

# Step 1: Identify conflicted files
git status
# Output:
# Unmerged paths:
#   both modified:   src/auth.js
#   both modified:   README.md

# Step 2: Open each conflicted file in your editor
# Look for <<<<<<<, =======, >>>>>>> markers
# Edit to keep the final desired code (remove all markers)

# Step 3: Stage the resolved files
git add src/auth.js README.md

# Step 4: Complete the merge
git commit
# (For rebase: git rebase --continue)

# ===== If you want to abort the merge entirely =====
git merge --abort
# (For rebase: git rebase --abort)

# ===== View conflicts in a visual mergetool =====
git mergetool
# Opens configured merge tool (VS Code, Meld, KDiff3, Beyond Compare)

# Configure default mergetool
git config --global merge.tool vscode
git config --global mergetool.vscode.cmd 'code --wait $MERGED'

# Default strategy: recursive (now called "ort" in modern Git)
git merge feature/login

# Prefer "ours" — keep our version on conflict
git merge -X ours feature/login

# Prefer "theirs" — keep their version on conflict
git merge -X theirs feature/login

# Show common ancestor in conflict markers (helpful!)
git merge -X diff-algorithm=histogram feature/login

# Use a specific strategy
git merge -s recursive feature/login
git merge -s octopus branch1 branch2 branch3  # for 3+ branches
git merge -s ours redundant-branch            # discard their changes, just record merge

# ===== Pull strategies for conflicts =====
# When pulling, prefer rebase to avoid extra merge commits
git config --global pull.rebase true

# Or set per-pull
git pull --rebase origin main

# Scenario: You're on feature/login, your colleague pushed to main

# 1. Try to merge latest main into your feature
git switch feature/login
git merge main
# CONFLICT (content): Merge conflict in src/auth.js

# 2. View the conflict
git diff
# Shows the <<<<<<< ======= >>>>>>> markers

# 3. Open in editor, manually resolve
# Before:
<<<<<<< HEAD
const API_URL = "https://api.staging.example.com";
=======
const API_URL = "https://api.example.com";
>>>>>>> main

# After resolution (you decide which, or combine):
const API_URL = process.env.API_URL || "https://api.example.com";

# 4. Stage and commit
git add src/auth.js
git commit -m "Merge main into feature/login, resolve API_URL conflict"

# ===== Scenario: Contributing to someone else's project =====

# Step 1: Fork on GitHub (via web UI: click "Fork" button)
# Now you have: github.com/A-talebifard/their-project

# Step 2: Clone YOUR fork (not the original)
git clone git@github.com:A-talebifard/their-project.git
cd their-project

# Step 3: Add upstream remote (original repo)
git remote add upstream git@github.com:original-owner/their-project.git

# Step 4: Create a feature branch
git switch -c feature/my-contribution

# Step 5: Make changes, commit, push to your fork
git push -u origin feature/my-contribution

# Step 6: Open Pull Request on GitHub (your-fork → upstream)

# Step 7: Keep your fork in sync with upstream
git fetch upstream
git switch main
git merge upstream/main
git push origin main

# ===== Using GitHub CLI (gh) =====
# Install: https://cli.github.com/

gh auth login                          # one-time setup
gh repo clone A-talebifard/their-project
gh repo fork original-owner/repo --clone
gh pr create --title "Add dark mode" --body "Resolves #42"
gh pr status
gh pr checkout 123                     # checkout PR #123 locally
gh pr merge 123 --squash --delete-branch

# Create PAT:
# GitHub → Settings → Developer settings → Personal access tokens → Generate new token

# Classic PAT scopes (for git operations):
# - repo (full control of private repos)
# - workflow (update GitHub Actions workflows)
# - read:org (read org and team membership)

# Use PAT in place of password (HTTPS)
git clone https://github.com/A-talebifard/repo.git
# Username: A-talebifard
# Password: <your-PAT>

# Cache credentials (avoid entering every time)
git config --global credential.helper store        # plain text (not secure)
git config --global credential.helper cache        # in-memory for 15 min
git config --global credential.helper 'cache --timeout=3600'  # 1 hour

# macOS: use Keychain
git config --global credential.helper osxkeychain

# Windows: use Git Credential Manager (default with Git for Windows)
git config --global credential.helper manager

# Embed PAT in URL (NOT recommended, but possible)
git remote set-url origin https://A-talebifard:<PAT>@github.com/A-talebifard/repo.git

# Project Name

> Short one-line description of what this project does.

![License](https://img.shields.io/badge/license-MIT-blue)
![Build](https://img.shields.io/github/workflow/status/A-talebifard/repo/CI)
![Stars](https://img.shields.io/github/stars/A-talebifard/repo)

## Features

- ✨ Feature one
- 🚀 Feature two
- 🔒 Feature three

## Installation

```bash
npm install project-name
```

## Quick Start

```javascript
import { doSomething } from 'project-name';

doSomething({ option: true });
```

## Documentation

Full docs at [https://docs.example.com](https://docs.example.com)

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md).

## License

MIT © [Abbas Talebifard](https://github.com/A-talebifard)

# ===== Step 1: Sync with main before starting =====
git switch main
git pull origin main

# ===== Step 2: Create a feature branch with descriptive name =====
git switch -c feature/add-jwt-auth
# Naming conventions:
# feature/xxx  - new features
# fix/xxx      - bug fixes
# docs/xxx     - documentation
# refactor/xxx - code refactoring
# chore/xxx    - maintenance tasks

# ===== Step 3: Make changes, commit in logical chunks =====
git add src/auth.js
git commit -m "feat(auth): implement JWT generation"
git add src/middleware.js
git commit -m "feat(auth): add auth middleware"
git add tests/auth.test.js
git commit -m "test(auth): cover token validation"

# ===== Step 4: Push to remote =====
git push -u origin feature/add-jwt-auth

# ===== Step 5: Open PR via GitHub CLI =====
gh pr create \
  --title "feat(auth): Add JWT authentication" \
  --body "## Description
Implements JWT-based authentication for the API.

## Type of Change
- [x] New feature
- [ ] Bug fix
- [ ] Breaking change

## Testing
- [x] Unit tests pass
- [x] Manual testing on staging

## Related Issue
Closes #42

## Checklist
- [x] Code follows style guide
- [x] Self-review completed
- [x] Documentation updated
- [x] No new warnings" \
  --base main \
  --head feature/add-jwt-auth

# ===== Step 6: After review feedback, make more commits =====
git add src/auth.js
git commit -m "fix(auth): handle expired tokens"
git push   # automatically updates the PR

# ===== Step 7: View PR status =====
gh pr view --web
gh pr checks

# ===== Step 8: After approval, merge (choose strategy) =====
gh pr merge 123 --squash --delete-branch   # recommended
gh pr merge 123 --merge --delete-branch    # preserves all commits
gh pr merge 123 --rebase --delete-branch   # linear history

# ===== Step 9: Sync local main =====
git switch main
git pull origin main
git branch -d feature/add-jwt-auth   # cleanup

## Description

<!-- Brief description of what this PR does -->

## Type of Change

- [ ] Bug fix (non-breaking change which fixes an issue)
- [ ] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would cause existing functionality to not work as expected)
- [ ] Documentation update
- [ ] Refactor (no functional changes)

## Related Issue

Closes #(issue-number)

## Testing

- [ ] Unit tests added/updated
- [ ] Integration tests pass
- [ ] Manual testing completed

## Screenshots (if applicable)

<!-- Drag and drop screenshots here -->

## Checklist

- [ ] My code follows the project's style guide
- [ ] I have performed a self-review
- [ ] I have commented my code, particularly in hard-to-understand areas
- [ ] I have updated documentation accordingly
- [ ] My changes generate no new warnings

# Create issue via CLI
gh issue create \
  --title "Bug: Login button not working on Safari" \
  --body "## Description
The login button does not respond on Safari 17.

## Steps to Reproduce
1. Go to /login
2. Enter credentials
3. Click 'Sign In'

## Expected
Redirect to dashboard

## Actual
Nothing happens, console shows TypeError

## Environment
- Safari 17.0
- macOS 14.0
- Production: https://app.example.com

## Screenshots
<!-- drag screenshot here -->

## Labels
bug, frontend, safari, P1" \
  --label "bug,P1" \
  --assignee "@me" \
  --project "Q4 Sprint"

# List open issues
gh issue list
gh issue list --state closed --limit 20
gh issue list --assignee "@me" --label "bug"

# View an issue
gh issue view 42
gh issue view 42 --web

# Close/reopen
gh issue close 42
gh issue close 42 --reason "completed"  # or "not planned"
gh issue reopen 42

# Comment on an issue
gh issue comment 42 --body "Fixed in PR #43"

# Add labels, assignees
gh issue edit 42 --add-label "high-priority"
gh issue edit 42 --add-assignee "A-talebifard"

# .github/ISSUE_TEMPLATE/bug_report.yml
name: Bug Report
description: Report a bug to help us improve
labels: ["bug", "triage"]
body:
  - type: markdown
    attributes:
      value: |
        Thanks for taking the time to fill out this bug report!
  - type: textarea
    id: description
    attributes:
      label: Description
      description: A clear description of the bug
    validations:
      required: true
  - type: textarea
    id: steps
    attributes:
      label: Steps to Reproduce
      placeholder: |
        1. Go to '...'
        2. Click on '....'
        3. See error
    validations:
      required: true
  - type: dropdown
    id: browser
    attributes:
      label: Browser
      options:
        - Chrome
        - Firefox
        - Safari
        - Edge
        - Other
  - type: input
    id: version
    attributes:
      label: App Version
      placeholder: "v1.2.3"

# .github/workflows/ci.yml
name: CI

# When should this workflow run?
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
  # Schedule: every day at 3 AM UTC
  schedule:
    - cron: "0 3 * * *"
  # Manual trigger
  workflow_dispatch:
    inputs:
      debug:
        description: 'Enable debug mode'
        type: boolean
        default: false

# Environment variables available to all jobs
env:
  NODE_VERSION: '20'
  CI: true

jobs:
  # ===== Job 1: Lint =====
  lint:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'

      - name: Install dependencies
        run: npm ci   # clean install (faster than npm install)

      - name: Run ESLint
        run: npm run lint

  # ===== Job 2: Test =====
  test:
    runs-on: ubuntu-latest
    needs: lint   # wait for lint job
    strategy:
      matrix:
        node-version: [18, 20, 22]
        os: [ubuntu-latest, macos-latest]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'npm'
      - run: npm ci
      - run: npm test
        env:
          COVERAGE: true

      - name: Upload coverage
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: coverage-${{ matrix.os }}-${{ matrix.node-version }}
          path: coverage/

  # ===== Job 3: Build & Deploy =====
  build:
    runs-on: ubuntu-latest
    needs: [lint, test]
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'
      - run: npm ci
      - run: npm run build
        env:
          API_KEY: ${{ secrets.API_KEY }}

      - name: Deploy to production
        run: |
          echo "Deploying..."
          ./scripts/deploy.sh

# Steps to add a secret:
# Repo → Settings → Secrets and variables → Actions → New repository secret

# Use in workflow:
steps:
  - name: Use secret
    run: |
      curl -X POST https://api.example.com \
        -H "Authorization: Bearer ${{ secrets.API_TOKEN }}"

  - name: Use variable (non-sensitive)
    run: echo "Environment is ${{ vars.ENVIRONMENT }}"

# Organization-level secrets (shared across repos):
# Org → Settings → Secrets → Actions

# Environment secrets (per-deployment):
# Repo → Settings → Environments → production → Add secret
jobs:
  deploy:
    environment: production   # requires approval
    steps:
      - run: ./deploy.sh
        env:
          PROD_KEY: ${{ secrets.PROD_KEY }}

# .github/workflows/release.yml
name: Release

on:
  push:
    tags:
      - 'v*'   # triggers on tags like v1.0.0, v2.1.3

jobs:
  release:
    runs-on: ubuntu-latest
    permissions:
      contents: write   # required to create release
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0   # full history for changelog

      - name: Setup Node
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install & build
        run: |
          npm ci
          npm run build

      - name: Generate changelog
        id: changelog
        uses: mikepenz/release-changelog-builder-action@v5
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Create GitHub Release
        uses: softprops/action-gh-release@v2
        with:
          body: ${{ steps.changelog.outputs.changelog }}
          files: |
            dist/*.zip
            dist/*.tar.gz
            CHANGELOG.md
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

# Step 1: Create a special repo named exactly: username.github.io
# For example: A-talebifard.github.io

# Step 2: Clone and add content
git clone git@github.com:A-talebifard/A-talebifard.github.io.git
cd A-talebifard.github.io
echo "<h1>Hello World</h1>" > index.html
git add .
git commit -m "Initial site"
git push

# Step 3: Visit https://A-talebifard.github.io (live in ~1 min)

# Any repo can have a Pages site

# Option A: From /docs folder on main branch
mkdir docs
echo "<h1>My Project</h1>" > docs/index.html
git add docs/
git commit -m "Add docs site"
git push

# Then: Repo → Settings → Pages → Source: main /docs folder

# Option B: From gh-pages branch
git switch --orphan gh-pages
git rm -rf .
echo "<h1>My Project</h1>" > index.html
git add .
git commit -m "Initial gh-pages"
git push origin gh-pages

# Site URL: https://username.github.io/repo-name/

# .github/workflows/deploy-pages.yml
name: Deploy to GitHub Pages

on:
  push:
    branches: [main]
  workflow_dispatch:

permissions:
  contents: read
  pages: write
  id-token: write

concurrency:
  group: pages
  cancel-in-progress: true

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - run: npm run build

      - name: Setup Pages
        uses: actions/configure-pages@v4

      - name: Upload artifact
        uses: actions/upload-pages-artifact@v3
        with:
          path: ./dist

  deploy:
    needs: build
    runs-on: ubuntu-latest
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    steps:
      - name: Deploy
        id: deployment
        uses: actions/deploy-pages@v4

# Step 1: Add CNAME file in repo root or /docs
echo "www.example.com" > CNAME
git add CNAME
git commit -m "Add custom domain"
git push

# Step 2: Configure DNS
# For subdomain (www.example.com):
#   CNAME www -> username.github.io
# For apex (example.com):
#   A @ -> 185.199.108.153
#   A @ -> 185.199.109.153
#   A @ -> 185.199.110.153
#   A @ -> 185.199.111.153

# Step 3: Enable HTTPS
# Repo → Settings → Pages → Custom domain → Enforce HTTPS ✓

# Step 4: Verify in 24-48 hours
curl -I https://www.example.com

# ===== git reset --soft =====
# Moves HEAD only; staging area and working dir unchanged
git reset --soft HEAD~1
# Use case: "I want to re-commit my last commit with a different message
# or split it into multiple commits"

# ===== git reset --mixed (default) =====
# Moves HEAD + unstages changes (but keeps them in working dir)
git reset HEAD~1
git reset --mixed HEAD~1
# Use case: "I committed too early, want to re-stage selectively"

# ===== git reset --hard =====
# Moves HEAD + discards all changes (DANGEROUS!)
git reset --hard HEAD~1
# Use case: "I want to completely discard my last commit and changes"

# ===== Reset to a specific commit =====
git reset --hard a1b2c3d

# ===== Reset a single file to HEAD =====
git checkout HEAD -- path/to/file.txt
git restore path/to/file.txt   # modern syntax (Git 2.23+)

# ===== Reset staging area (unstage everything) =====
git reset

# ===== Unstage a specific file =====
git reset path/to/file.txt
git restore --staged path/to/file.txt   # modern

# Revert a single commit (creates a new commit)
git revert a1b2c3d
# Opens editor with default message: "Revert: <original message>"

# Revert without auto-commit (combine multiple reverts)
git revert --no-commit a1b2c3d
git revert --no-commit d4e5f6g
git commit -m "Revert: remove broken auth changes"

# Revert a range of commits
git revert --no-commit HEAD~3..HEAD

# Revert a merge commit
git revert -m 1 a1b2c3d
# -m 1 means: keep parent 1 (the branch you merged INTO)

# Revert last commit but keep changes staged
git revert -n HEAD

# ===== Difference: reset vs revert =====
# reset: rewrites history (use on local/personal branches)
# revert: adds new commit that undoes (use on shared branches)

# ===== Scenario: Bad commit already pushed to main =====
# DON'T: git reset --hard HEAD~1 && git push -f
# DO:
git revert HEAD
git push

# Restore a file from latest commit (discard local changes)
git checkout -- path/to/file.txt
git restore path/to/file.txt          # modern (Git 2.23+)

# Restore a file from a specific commit
git checkout a1b2c3d -- path/to/file.txt
git restore --source=a1b2c3d path/to/file.txt

# Restore multiple files
git restore file1.txt file2.txt

# Restore all files in current directory
git restore .

# Restore staged changes (unstage)
git restore --staged path/to/file.txt
git restore --staged .

# Restore a deleted file (not yet committed deletion)
git restore path/to/deleted.txt

# Restore a deleted file (committed deletion)
git checkout HEAD~1 -- path/to/deleted.txt

# ===== View a file from a specific commit without restoring =====
git show a1b2c3d:path/to/file.txt

# Show what would be deleted (dry run)
git clean -n
git clean --dry-run

# Delete untracked files
git clean -f

# Delete untracked files and directories
git clean -fd

# Delete ignored files too (be careful!)
git clean -fdx

# Interactive clean
git clean -i

# Stash all tracked changes (modified + staged)
git stash
git stash push -m "WIP: working on login form"

# Stash including untracked files
git stash -u
git stash --include-untracked

# Stash only staged changes (keep unstaged in working dir)
git stash --keep-index

# Stash a specific file
git stash push -m "Just auth.js" -- path/to/auth.js

# List all stashes
git stash list
# Output:
# stash@{0}: On feature/login: WIP: working on login form
# stash@{1}: On main: quick fix
# stash@{2}: WIP on main: a1b2c3d Add README

# Show what's in a stash
git stash show stash@{0}
git stash show -p stash@{0}    # full diff

# Apply most recent stash (keeps it in stack)
git stash apply

# Apply a specific stash
git stash apply stash@{2}

# Apply and remove from stack (most common)
git stash pop

# Drop a stash
git stash drop stash@{0}

# Clear all stashes (DANGEROUS)
git stash clear

# Create a branch from a stash
git stash branch new-branch stash@{0}

# Cherry-pick a single commit
git cherry-pick a1b2c3d

# Cherry-pick multiple commits
git cherry-pick a1b2c3d d4e5f6g 7h8i9j0

# Cherry-pick a range (exclusive of start)
git cherry-pick a1b2c3d..d4e5f6g

# Cherry-pick without committing (stage changes only)
git cherry-pick --no-commit a1b2c3d
git cherry-pick -n a1b2c3d

# Cherry-pick and edit commit message
git cherry-pick --edit a1b2c3d

# Cherry-pick but keep original message format
git cherry-pick -x a1b2c3d
# Adds: (cherry picked from commit a1b2c3d...)

# ===== Common scenario: hotfix from main to develop =====
# A bug was fixed on main, need same fix on develop
git switch develop
git cherry-pick a1b2c3d   # the hotfix commit
git push

# ===== Resolve conflicts during cherry-pick =====
git cherry-pick a1b2c3d
# CONFLICT...
# Resolve, then:
git add .
git cherry-pick --continue

# Abort cherry-pick
git cherry-pick --abort

# Start bisect session
git bisect start

# Mark current commit as bad (has the bug)
git bisect bad

# Mark a known-good commit (e.g., from a month ago)
git bisect good v1.0.0
# or: git bisect good a1b2c3d

# Git checks out a middle commit.
# Test it, then mark as good or bad:
git bisect good   # or git bisect bad

# Continue until Git identifies the first bad commit
# Output: "a1b2c3d is the first bad commit"

# End bisect session (return to original branch)
git bisect reset

# ===== Automated bisect (with a test script) =====
git bisect start
git bisect bad HEAD
git bisect good v1.0.0
git bisect run npm test    # auto-runs tests until failure found
git bisect reset

# ===== Add a submodule =====
git submodule add git@github.com:shared/lib.git libs/shared-lib
git commit -m "Add shared-lib as submodule"

# This creates:
# 1. .gitmodules file (tracks submodule URL & path)
# 2. libs/shared-lib/ directory (the submodule content)
# 3. A gitlink entry (pointer to specific commit in submodule)

# ===== Clone a repo WITH its submodules =====
git clone --recurse-submodules git@github.com:A-talebifard/project.git

# If you forgot --recurse-submodules, initialize after clone:
git submodule update --init --recursive

# ===== Update all submodules to latest commit =====
git submodule update --remote
git add .
git commit -m "Update submodules to latest"

# ===== Update a specific submodule =====
cd libs/shared-lib
git switch main
git pull
cd ../..
git add libs/shared-lib
git commit -m "Update shared-lib to latest main"

# ===== View submodule status =====
git submodule status

# ===== Make changes INSIDE a submodule =====
cd libs/shared-lib
# Make changes, commit, push as normal
git add .
git commit -m "Fix bug in shared-lib"
git push origin main
cd ../..
git add libs/shared-lib
git commit -m "Bump shared-lib to latest with bug fix"

# ===== Remove a submodule =====
git submodule deinit -f libs/shared-lib
git rm -f libs/shared-lib
git commit -m "Remove shared-lib submodule"

# Create a new working tree for an existing branch
git worktree add ../project-feature feature/login
# Now you have:
# /path/to/project          -> main branch (original)
# /path/to/project-feature  -> feature/login (new worktree)

# Create worktree with a NEW branch
git worktree add -b feature/api ../project-api

# List all worktrees
git worktree list
# Output:
# /path/to/project          a1b2c3d [main]
# /path/to/project-feature  d4e5f6g [feature/login]
# /path/to/project-api      7h8i9j0 [feature/api]

# Remove a worktree (just delete the directory)
git worktree remove ../project-feature

# Prune stale worktree entries
git worktree prune

# ===== Common use cases =====
# 1. Working on a feature when a hotfix is needed:
#    - Open new worktree on main, fix, push, remove worktree
# 2. Running tests on one branch while coding on another
# 3. Comparing two versions side by side in two editors

# ===== Partial clone: only download commits, fetch blobs on demand =====
git clone --filter=blob:none git@github.com:large/repo.git
# Faster clone, downloads file contents only when you read them

# Even more aggressive: no blobs, no trees
git clone --filter=tree:0 git@github.com:large/repo.git

# ===== Sparse checkout: only check out specific directories =====
git clone --no-checkout git@github.com:large/repo.git
cd repo
git sparse-checkout init --cone
git sparse-checkout set src/components src/utils
git checkout main
# Now only src/components/ and src/utils/ are on disk

# Add more directories later
git sparse-checkout add docs

# Disable sparse checkout
git sparse-checkout disable

#!/bin/bash
# File: .git/hooks/pre-commit (make executable with: chmod +x)

# Exit on any error
set -e

echo "▶ Running pre-commit checks..."

# 1. Block commits with console.log in JS files
if git diff --cached --name-only | grep -E "\.(js|ts|jsx|tsx)$"; then
  FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E "\.(js|ts|jsx|tsx)$")
  for FILE in $FILES; do
    if grep -n "console\.log" "$FILE"; then
      echo "❌ Found console.log in $FILE. Remove before committing."
      exit 1
    fi
  done
fi

# 2. Block commits with TODO comments
if git diff --cached | grep -E "^\+.*TODO"; then
  echo "⚠️  Warning: commit contains TODO comments"
  # exit 1   # uncomment to make this blocking
fi

# 3. Check for secrets (basic patterns)
if git diff --cached | grep -iE "(api_key|password|secret)\s*=\s*['\"]"; then
  echo "❌ Possible secret detected! Please review."
  exit 1
fi

# 4. Run linter on staged files
if [ -f "package.json" ]; then
  npx lint-staged
fi

echo "✅ Pre-commit checks passed"
exit 0

#!/bin/bash
# File: .git/hooks/commit-msg
# Ensures commit messages follow Conventional Commits format

MSG_FILE="$1"
MSG=$(cat "$MSG_FILE")

# Regex: type(scope): description  or  type: description
PATTERN="^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([a-z0-9-]+\))?!?: .{1,80}$"

# Skip merge commits
if echo "$MSG" | grep -q "^Merge "; then
  exit 0
fi

# Skip revert commits
if echo "$MSG" | grep -q "^Revert "; then
  exit 0
fi

# Check first line
FIRST_LINE=$(echo "$MSG" | head -1)

if ! echo "$FIRST_LINE" | grep -qE "$PATTERN"; then
  echo "❌ Invalid commit message format!"
  echo ""
  echo "Expected: type(scope): description"
  echo "Examples:"
  echo "  feat(auth): add JWT login"
  echo "  fix: handle null user"
  echo "  docs: update README"
  echo ""
  echo "Got: $FIRST_LINE"
  exit 1
fi

exit 0

# Install Husky
npm install --save-dev husky lint-staged

# Initialize Husky (creates .husky/ directory)
npx husky init

# Add pre-commit hook
echo "npx lint-staged" > .husky/pre-commit

# Configure lint-staged in package.json
# This runs specific commands on staged files only

{
  "lint-staged": {
    "*.{js,ts,jsx,tsx}": [
      "eslint --fix",
      "prettier --write",
      "git add"
    ],
    "*.{css,scss}": [
      "stylelint --fix",
      "git add"
    ],
    "*.{md,json,yaml}": [
      "prettier --write",
      "git add"
    ]
  }
}

# ===== A comprehensive .gitignore =====

# Dependencies
node_modules/
.pnp/
.pnp.js

# Build output
dist/
build/
out/
.next/
.nuxt/
.cache/
.parcel-cache/

# Environment variables (NEVER commit!)
.env
.env.local
.env.*.local
*.env

# Secrets
secrets.json
*.pem
*.key
!public.key

# Logs
logs/
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*

# OS files
.DS_Store
Thumbs.db
desktop.ini

# IDE / Editor
.vscode/
!.vscode/settings.json
!.vscode/extensions.json
.idea/
*.swp
*.swo
*~
.project
.classpath
.settings/

# Test coverage
coverage/
.nyc_output/

# Misc
*.pid
*.seed
*.pid.lock
.tmp/
tmp/

# Negation: include a file that would be ignored
!tests/fixtures/.env

# Create a global gitignore for OS/IDE files
echo "# OS
.DS_Store
Thumbs.db

# IDE
.vscode/
.idea/
*.swp" > ~/.gitignore_global

# Tell Git to use it
git config --global core.excludesfile ~/.gitignore_global

# Now you don't need to add these to every project's .gitignore

# Step 1: Generate GPG key
gpg --full-generate-key
# Choose: (1) RSA and RSA
# Key size: 4096
# Validity: 1y (or 0 for no expiry)
# Real name: Abbas Talebifard
# Email: abbas@example.com (same as GitHub)

# Step 2: List GPG keys
gpg --list-secret-keys --keyid-format=long
# Output:
# sec   rsa4096/ABC123DEF456 2024-01-01 [SC]
# Copy the KEY_ID (after the /): ABC123DEF456

# Step 3: Export public key
gpg --armor --export ABC123DEF456
# Copy the entire output (-----BEGIN PGP PUBLIC KEY BLOCK----- ...)

# Step 4: Add to GitHub → Settings → SSH and GPG keys → New GPG key

# Step 5: Configure Git to use GPG
git config --global user.signingkey ABC123DEF456
git config --global commit.gpgsign true   # sign all commits by default

# Step 6: Sign a commit
git commit -S -m "Signed commit"

# Sign a tag
git tag -s v1.0.0 -m "Signed release v1.0.0"

# Verify a signature
git verify-commit HEAD
git tag -v v1.0.0

# .gitattributes - per-file settings

# Normalize line endings (auto-convert on checkout/commit)
* text=auto

# Specific file types
*.txt text
*.jpg binary
*.png binary
*.pdf binary

# Force LF for shell scripts
*.sh text eol=lf

# Force CRLF for Windows batch files
*.bat text eol=crlf

# Mark generated files as linguist-vendored (excluded from GitHub stats)
docs/*.md linguist-vendored
minified/*.js linguist-generated=true

# Diff settings
*.md diff=markdown
*.json diff=json

# Scenario: Did git reset --hard, lost my work!

# Step 1: Check reflog (record of every HEAD movement)
git reflog
# Output:
# a1b2c3d HEAD@{0}: reset: moving to HEAD~1
# d4e5f6g HEAD@{1}: commit: My important work  ← this is what you want!

# Step 2: Recover by resetting to that commit
git reset --hard d4e5f6g

# Or cherry-pick just that commit
git cherry-pick d4e5f6g

# Scenario: Checked out a commit (not a branch), now commits go nowhere

# Symptoms:
# "You are in 'detached HEAD' state..."

# Solution 1: Create a new branch from current position
git switch -c new-branch-name

# Solution 2: If you already made commits, save them first
git branch temp-branch        # mark current position
git switch main
git merge temp-branch         # bring commits to main
git branch -d temp-branch

# Solution 3: If you don't want those commits
git switch main               # return to main, commits are "lost" but in reflog

# Error: "Updates were rejected because the remote contains work
# that you do not have locally"

# Cause: Someone else pushed to the same branch

# Solution 1: Pull first, then push
git pull --rebase origin main    # rebase your commits on top of remote
git push

# Solution 2: If you want to merge instead of rebase
git pull origin main
# (this creates a merge commit)
git push

# Solution 3: Force push (ONLY for personal branches!)
git push --force-with-lease

# Cause: .gitignore only affects untracked files.
# If a file was already tracked, adding to .gitignore doesn't remove it.

# Solution: Remove from tracking but keep on disk
git rm --cached path/to/file    # for a single file
git rm -r --cached path/to/dir  # for a directory

# Then commit
git commit -m "Stop tracking file (now in .gitignore)"

# ===== Remove all files that should be ignored =====
git rm -r --cached .
git add .
git commit -m "Apply .gitignore to all files"

# Scenario: Committed .env with API keys!

# Step 1: If recent commit (not pushed yet)
git rm --cached .env
echo ".env" >> .gitignore
git add .gitignore
git commit --amend --no-edit

# Step 2: If already pushed (BAD! keys are exposed)
# - IMMEDIATELY rotate/revoke the exposed keys
# - Then clean history with BFG Repo-Cleaner or git-filter-repo

# Using git-filter-repo (modern, recommended):
pip install git-filter-repo
git filter-repo --path .env --invert-paths

# Force push rewritten history
git push --force --all
git push --force --tags

# Step 3: Notify collaborators - they need to re-clone

# Step 1: Check what's taking space
git count-objects -vH

# Step 2: See largest files in history
git rev-list --objects --all | \
  git cat-file --batch-check='%(objecttype) %(objectname) %(objectsize) %(rest)' | \
  awk '/^blob/ {print substr($0,6)}' | \
  sort -k2 -n -r | head -20

# Step 3: Run garbage collection
git gc --aggressive --prune=now

# Step 4: For large files in history, use BFG Repo-Cleaner
# Download from: https://rtyley.github.io/bfg-repo-cleaner/
java -jar bfg.jar --strip-blobs-bigger-than 50M my-repo.git
cd my-repo.git
git reflog expire --expire=now --all
git gc --prune=now --aggressive

# Step 5: Consider Git LFS for large binary files going forward
git lfs install
git lfs track "*.psd" "*.mp4" "*.zip"
git add .gitattributes

# Scenario: Started merge but conflicts are too complex

# Abort the merge (return to pre-merge state)
git merge --abort

# If you already committed the merge:
git reset --hard ORIG_HEAD
# ORIG_HEAD points to where you were before the merge

# For rebase:
git rebase --abort

# For future commits: update config
git config --global user.name "Correct Name"
git config --global user.email "correct@example.com"

# For past commits (last N commits), use interactive rebase:
git rebase -i HEAD~5
# Mark commits as "edit", then for each:
git commit --amend --author="Correct Name <correct@example.com>"
git rebase --continue

# For ALL commits in repo (DANGEROUS, rewrites entire history):
git filter-repo --commit-callback '
    commit.author_email = b"correct@example.com"
    commit.author_name = b"Correct Name"
    commit.committer_email = b"correct@example.com"
    commit.committer_name = b"Correct Name"
'

# Force push
git push --force --all

// ❌ Bad commit messages:
- "fix"
- "update"
- "wip"
- "fixed the bug"
- "asdf"
- "Changes from meeting"

// ✅ Good commit messages:
- "fix(auth): handle expired JWT tokens gracefully"
- "feat(api): add /users endpoint with pagination"
- "docs: add installation instructions for Windows"
- "refactor(auth): extract token validation to middleware"

// ✅ With body:
feat(auth): add OAuth2 login with Google

- Add /api/auth/google endpoint
- Implement OAuth2 callback handler
- Store refresh tokens in database
- Add middleware to validate OAuth sessions

Resolves: #42
Breaking change: removes old /api/login endpoint

# H1 Heading
## H2 Heading
### H3 Heading

**Bold text**
*Italic text*
~~Strikethrough~~
`inline code`

[Link text](https://example.com)
![Alt text](image.png)

- Unordered list item
- Another item
  - Nested item

1. Ordered list
2. Second item
3. Third item

> Blockquote
> More quote

```javascript
// Code block with syntax highlighting
function hello() {
  console.log("Hello");
}
```

| Column 1 | Column 2 |
|----------|----------|
| Cell 1   | Cell 2   |
| Cell 3   | Cell 4   |

---

Horizontal rule above

- [x] Task list (completed)
- [ ] Task list (pending)

<details>
<summary>Click to expand</summary>
Hidden content here
</details>

<!-- HTML comment -->

Footnote[^1]

[^1]: Footnote definition

## GitHub Flavored Markdown (GFM)
- @mentions (notify users)
- #123 (link to issue/PR)
- emoji :smile: :rocket: :+1:
- SHA references (a1b2c3d)