# Stage hunks interactively
git add -p app.js
# Git shows each hunk and asks: Stage this hunk? [y,n,q,a,d,s,e,?]
# y = stage this hunk
# n = skip this hunk
# s = split this hunk into smaller pieces
# e = manually edit the hunk

## Summary
Add user search with fuzzy matching and result pagination.
 
## Motivation
Users with large teams reported difficulty finding specific team members.
The existing dropdown was limited to 20 entries with exact-match filtering.
See #456 for the original request.
 
## Changes
- Add `/api/users/search` endpoint with fuzzy matching (Levenshtein distance)
- Add `SearchBar` component with debounced input (300ms)
- Add pagination to search results (20 per page)
- Add search index to `users.name` column
 
## Testing
1. Navigate to Team Settings → Members
2. Type a partial name in the search bar
3. Verify results appear after typing stops (300ms debounce)
4. Verify pagination controls appear for > 20 results
5. Verify misspelled names still return fuzzy matches
 
## Screenshots
[Before/after screenshots for UI changes]
 
## Notes
- The search index migration may take ~2 minutes on production
- Fuzzy matching threshold is configurable via `SEARCH_FUZZ_THRESHOLD` env var

# Create stacked branches
git checkout main
git checkout -b feature/search-schema
# ... add schema ...
git push -u origin feature/search-schema
 
git checkout -b feature/search-api
# ... add API ...
git push -u origin feature/search-api
 
git checkout -b feature/search-ui
# ... add UI ...
git push -u origin feature/search-ui

# Pull a PR for local testing
gh pr checkout 42
# or
git fetch origin pull/42/head:pr-42
git checkout pr-42

git checkout feature/long-running
git fetch origin
git rebase origin/main
 
# If conflicts arise, resolve them while they're small and fresh
# Then force push your rebased branch
git push --force-with-lease origin feature/long-running

git checkout feature/long-running
git fetch origin
git merge origin/main

# Instead of keeping everything on a branch for 4 weeks:
if feature_flags.enabled("new_dashboard", user):
    render_new_dashboard()
else:
    render_legacy_dashboard()

git shortlog -sn
#   42  Jane Smith
#   15  jane smith
#    8  Jane S.
#    3  jsmith
#    1  Jane Smith (work laptop)

# Commit .mailmap so the whole team benefits
git add .mailmap
git commit -m "chore: add mailmap for contributor identity mapping"
 
# Now shortlog shows unified identities
git shortlog -sn
#   69  Jane Smith
 
# git log also uses .mailmap
git log --format="%aN <%aE>" | sort -u
 
# Verify .mailmap is working
git check-mailmap "jane smith <jane.smith@gmail.com>"
# Jane Smith <jane@company.com>

# Enable mailmap globally for git log
git config --global log.mailmap true

# Add a note to a commit
git notes add -m "Deployed to production on 2024-03-15" HEAD
 
# Add a note to a specific commit
git notes add -m "This commit introduced the memory leak — see #789" abc1234
 
# View notes
git log --show-notes
# commit abc1234
# Author: Jane Smith
# Date: Mon Mar 15 10:30:00 2024
#
#     feat: add caching layer
#
# Notes:
#     This commit introduced the memory leak — see #789
 
# Edit a note
git notes edit abc1234
 
# Append to an existing note
git notes append -m "Fix deployed in commit def5678" abc1234
 
# Remove a note
git notes remove abc1234

# Add notes in different namespaces
git notes --ref=review add -m "Approved by @alice, 2 minor suggestions" HEAD
git notes --ref=deploy add -m "Deployed to staging 2024-03-15 14:30 UTC" HEAD
git notes --ref=ci add -m "Build #4567 passed. Coverage: 87%" HEAD
 
# View notes from a specific namespace
git log --show-notes=review
git log --show-notes=deploy
 
# View all notes
git log --show-notes="*"

# Push notes to the remote
git push origin refs/notes/commits
 
# Fetch notes from the remote
git fetch origin refs/notes/commits:refs/notes/commits
 
# Configure automatic fetch of notes
git config --add remote.origin.fetch "+refs/notes/*:refs/notes/*"

# .github/CODEOWNERS
 
# Default owners for everything not covered below
*                           @org/core-team
 
# Frontend team
/src/components/            @org/frontend-team
/src/styles/                @org/frontend-team
*.tsx                       @org/frontend-team @senior-frontend-dev
*.css                       @org/frontend-team
 
# Backend team
/src/api/                   @org/backend-team
/src/services/              @org/backend-team
/src/models/                @org/backend-team
 
# Database changes require DBA review
/migrations/                @dba-lead @org/backend-team
 
# DevOps/Infrastructure
Dockerfile                  @org/devops
docker-compose*.yml         @org/devops
/.github/workflows/         @org/devops
/terraform/                 @org/devops @infra-lead
 
# Documentation
/docs/                      @org/docs-team
*.md                        @org/docs-team
 
# Security-sensitive files require security team
/src/auth/                  @org/security-team @security-lead
/src/crypto/                @org/security-team
*.pem                       @org/security-team
*.key                       @org/security-team
 
# Package management changes
package.json                @org/core-team @dependency-bot
package-lock.json           @org/core-team

# Initialize Nx in an existing repo
npx nx init
 
# Run tests only for affected packages
npx nx affected --target=test
 
# Build a specific project and its dependencies
npx nx build my-app
 
# Visualize the dependency graph
npx nx graph

# Initialize Turborepo
npx create-turbo@latest
 
# Run all build tasks (respecting dependency order)
npx turbo build
 
# Run tests for changed packages
npx turbo test --filter="...[HEAD~1]"

// turbo.json
{
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**"]
    },
    "test": {
      "dependsOn": ["build"]
    },
    "lint": {}
  }
}

# BUILD file
java_library(
    name = "my-lib",
    srcs = glob(["src/**/*.java"]),
    deps = ["//common:utils"],
)
 
java_test(
    name = "my-lib-test",
    srcs = glob(["test/**/*.java"]),
    deps = [":my-lib"],
)

# Anyone can pretend to be Linus Torvalds
git commit --author="Linus Torvalds <torvalds@linux-foundation.org>" -m "totally legit"

# 1. Generate a GPG key (if you don't have one)
gpg --full-generate-key
# Choose: RSA and RSA, 4096 bits, your Git email
 
# 2. List your keys
gpg --list-secret-keys --keyid-format=long
# sec   rsa4096/ABC123DEF456 2024-01-01 [SC]
#       FINGERPRINT1234567890ABCDEF
# uid   Jane Smith <jane@company.com>
 
# 3. Configure Git to use your key
git config --global user.signingkey ABC123DEF456
git config --global commit.gpgsign true    # sign all commits automatically
git config --global tag.gpgsign true       # sign all tags automatically
 
# 4. Make a signed commit
git commit -S -m "feat: add verified feature"
 
# 5. Verify a signed commit
git log --show-signature -1
# gpg: Signature made ...
# gpg: Good signature from "Jane Smith <jane@company.com>"
 
# 6. Add your public key to GitHub
gpg --armor --export ABC123DEF456
# Copy the output and paste in GitHub → Settings → SSH and GPG keys → New GPG key

# 1. Configure SSH signing
git config --global gpg.format ssh
git config --global user.signingkey ~/.ssh/id_ed25519.pub
git config --global commit.gpgsign true
git config --global tag.gpgsign true
 
# 2. Make a signed commit
git commit -m "feat: add verified feature"
# Automatically signed with your SSH key
 
# 3. For local verification, create an allowed signers file
echo "jane@company.com $(cat ~/.ssh/id_ed25519.pub)" > ~/.config/git/allowed_signers
git config --global gpg.ssh.allowedSignersFile ~/.config/git/allowed_signers
 
# 4. Verify
git log --show-signature -1
# Good "git" signature for jane@company.com
 
# 5. Add your SSH signing key to GitHub
# Go to Settings → SSH and GPG keys → New SSH key
# Key type: "Signing Key"
# Paste your public key

# Using GitHub CLI to set up branch protection
gh api repos/{owner}/{repo}/branches/main/protection \
  --method PUT \
  --field required_status_checks='{"strict":true,"contexts":["ci/tests","ci/lint"]}' \
  --field enforce_admins=true \
  --field required_pull_request_reviews='{"required_approving_review_count":2}' \
  --field restrictions=null

## Summary
<!-- Brief description of what this PR does -->
 
## Motivation
<!-- Why is this change needed? Link to issue if applicable -->
 
## Changes
<!-- List of specific changes made -->
-
-
 
## Testing
<!-- How was this tested? Steps to reproduce/verify -->
1.
2.
 
## Checklist
- [ ] Tests added/updated
- [ ] Documentation updated (if applicable)
- [ ] No breaking changes (or documented in summary)
- [ ] Self-reviewed the diff

---
name: Bug Report
about: Report a bug to help us improve
labels: bug
---
 
## Description
<!-- Clear description of the bug -->
 
## Steps to Reproduce
1.
2.
3.
 
## Expected Behavior
<!-- What should happen -->
 
## Actual Behavior
<!-- What actually happens -->
 
## Environment
- OS:
- Browser/Runtime:
- Version:
 
## Screenshots
<!-- If applicable -->

mkdir collab-lab && cd collab-lab
git init
echo "# Team Project" > README.md
git add . && git commit -m "initial commit"

# 1. Create a file with multiple logical sections
cat > app.js << 'EOF'
// Authentication
function login(user, pass) {
    return authenticate(user, pass);
}
 
// Search
function search(query) {
    return database.find(query);
}
 
// Utilities
function formatDate(date) {
    return date.toISOString();
}
EOF
git add app.js && git commit -m "feat: add initial app structure"
 
# 2. Make multiple unrelated changes in the same file
cat > app.js << 'EOF'
// Authentication
function login(user, pass) {
    if (!user || !pass) throw new Error('Missing credentials');
    return authenticate(user, pass);
}
 
// Search
function search(query, options = {}) {
    const { limit = 20, offset = 0 } = options;
    return database.find(query).limit(limit).skip(offset);
}
 
// Utilities
function formatDate(date) {
    return date.toLocaleDateString('en-US');
}
EOF
 
# 3. Stage changes as separate atomic commits using git add -p
git add -p app.js
# When Git shows the first hunk (login validation):
#   → Press 'y' to stage it
# When Git shows the second hunk (search pagination):
#   → Press 'n' to skip it
# When Git shows the third hunk (date formatting):
#   → Press 'n' to skip it
 
git commit -m "fix: validate credentials before authentication"
 
# 4. Stage the next logical change
git add -p app.js
# Stage the search pagination hunk: 'y'
# Skip the date formatting hunk: 'n'
 
git commit -m "feat: add pagination to search results"
 
# 5. Stage the remaining change
git add app.js
git commit -m "fix: use localized date format"
 
# 6. Verify atomic commits
git log --oneline -3
# Three separate, focused commits

# 1. Create the GitHub directory structure
mkdir -p .github
 
# 2. Create a PR template
cat > .github/pull_request_template.md << 'EOF'
## Summary
<!-- Brief description of what this PR does -->
 
## Changes
<!-- List of specific changes made -->
-
 
## Testing
<!-- How was this tested? -->
1.
 
## Checklist
- [ ] Tests pass
- [ ] Self-reviewed
- [ ] Documentation updated (if applicable)
EOF
 
git add .github/ && git commit -m "chore: add PR template"
 
# 3. Create a feature branch with good commits
git checkout -b feature/add-validation
 
cat > validate.js << 'EOF'
function validateEmail(email) {
    const pattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return pattern.test(email);
}
 
function validatePassword(password) {
    return password.length >= 8
        && /[A-Z]/.test(password)
        && /[0-9]/.test(password);
}
 
module.exports = { validateEmail, validatePassword };
EOF
git add validate.js
git commit -m "feat: add email and password validation utilities"
 
cat > validate.test.js << 'EOF'
const { validateEmail, validatePassword } = require('./validate');
 
console.assert(validateEmail('user@example.com') === true);
console.assert(validateEmail('invalid') === false);
console.assert(validatePassword('Str0ngPass') === true);
console.assert(validatePassword('weak') === false);
console.log('All validation tests passed');
EOF
git add validate.test.js
git commit -m "test: add validation utility tests"
 
# 4. View the diff that would go into a PR
git log --oneline main..feature/add-validation
git diff --stat main..feature/add-validation

git checkout main
 
# 1. Simulate commits from different identities of the same person
git commit --allow-empty --author="Jane Smith <jane@company.com>" -m "feat: add user model"
git commit --allow-empty --author="jane smith <jane.smith@gmail.com>" -m "fix: user model validation"
git commit --allow-empty --author="J. Smith <jsmith@old-company.com>" -m "docs: add user model docs"
 
# 2. See the fragmented contributor list
git shortlog -sn --all
# Multiple entries for the same person
 
# 3. Create a .mailmap file
cat > .mailmap << 'EOF'
Jane Smith <jane@company.com> jane smith <jane.smith@gmail.com>
Jane Smith <jane@company.com> J. Smith <jsmith@old-company.com>
EOF
git add .mailmap && git commit -m "chore: add mailmap for contributor identity mapping"
 
# 4. Verify unified identities
git shortlog -sn --all
# Jane Smith should now have a single entry with all commits combined
 
# 5. Test the mapping
git check-mailmap "jane smith <jane.smith@gmail.com>"
# Should output: Jane Smith <jane@company.com>

# 1. Find a commit to annotate
git log --oneline -5
# Pick a commit hash from the output
 
# 2. Add a review note
git notes add -m "Reviewed by @alice — approved with minor suggestions" HEAD~2
 
# 3. Add a deployment note in a separate namespace
git notes --ref=deploy add -m "Deployed to staging: 2024-03-15 14:30 UTC" HEAD~2
 
# 4. Add a CI note
git notes --ref=ci add -m "Build #1234 passed. Coverage: 91.2%" HEAD~2
 
# 5. View notes in the log
git log --show-notes -3
# The annotated commit shows the default note
 
git log --show-notes=deploy -3
# Shows deployment notes
 
git log --show-notes="*" -3
# Shows all notes from all namespaces
 
# 6. Append to a note
git notes append -m "Follow-up: Alice's suggestions addressed in commit HEAD" HEAD~2
git log --show-notes -3

# 1. Generate a signing key (if you don't have one)
ssh-keygen -t ed25519 -f ~/.ssh/git_signing_key -N "" -C "lab signing key"
 
# 2. Configure Git to use SSH signing
git config gpg.format ssh
git config user.signingkey ~/.ssh/git_signing_key.pub
git config commit.gpgsign true
 
# 3. Create an allowed signers file for local verification
mkdir -p ~/.config/git
echo "$(git config user.email) $(cat ~/.ssh/git_signing_key.pub)" > ~/.config/git/allowed_signers
git config gpg.ssh.allowedSignersFile ~/.config/git/allowed_signers
 
# 4. Make a signed commit
echo "signed content" > signed.txt
git add signed.txt
git commit -m "feat: add signed content"
 
# 5. Verify the signature
git log --show-signature -1
# Should show: Good "git" signature for your-email
 
# 6. Make an unsigned commit for comparison
git config commit.gpgsign false
echo "unsigned content" > unsigned.txt
git add unsigned.txt
git commit -m "feat: add unsigned content"
 
# 7. Compare
git log --show-signature -2
# First commit: no signature
# Second commit: Good signature
 
# 8. Re-enable signing
git config commit.gpgsign true

# 1. Create a project structure
mkdir -p src/{api,frontend,auth} docs
 
echo "const express = require('express');" > src/api/server.js
echo "import React from 'react';" > src/frontend/App.tsx
echo "function authenticate() {}" > src/auth/auth.js
echo "# API Docs" > docs/api.md
git add . && git commit -m "chore: add project structure"
 
# 2. Create CODEOWNERS file
mkdir -p .github
cat > .github/CODEOWNERS << 'EOF'
# Default owners
*                    @org/core-team
 
# Frontend
/src/frontend/       @org/frontend-team
*.tsx                @org/frontend-team
 
# Backend API
/src/api/            @org/backend-team
 
# Security-sensitive
/src/auth/           @org/security-team @security-lead
 
# Documentation
/docs/               @org/docs-team
*.md                 @org/docs-team
EOF
 
git add .github/CODEOWNERS
git commit -m "chore: add CODEOWNERS for automated review routing"
 
# 3. Verify the file
cat .github/CODEOWNERS