# Set your name and email — use the same email as your GitHub account
$ git config --global user.name "Alex Johnson"
$ git config --global user.email "alex@example.com"

# Set VS Code (or any editor) as Git's default editor
$ git config --global core.editor "code --wait"

# Make 'main' the default branch name (modern standard)
$ git config --global init.defaultBranch main

# Verify your settings
$ git config --list
user.name=Alex Johnson
user.email=alex@example.com
core.editor=code --wait
init.defaultBranch=main

# Create a new folder and navigate into it
$ mkdir my-java-project
$ cd my-java-project

# Initialize Git — this creates a hidden .git folder
$ git init
Initialized empty Git repository in /Users/alex/my-java-project/.git/

# Check the current state of your repo
$ git status
On branch main
No commits yet
nothing to commit (create/copy files and use "git add" to track)

# Create a file
$ echo "public class Main {}" > Main.java

# Check status again — Git sees the new file
$ git status
On branch main
No commits yet

Untracked files:
  (use "git add <file>" to include in what will be committed)
        Main.java

nothing added to commit but untracked files present

# See what changed
$ git status
Untracked files: Main.java, Task.java

# Stage a specific file
$ git add Main.java

# Stage all changes in the current folder
$ git add .

# See what's staged (green = staged, red = unstaged)
$ git status
Changes to be committed:
        new file:   Main.java
        new file:   Task.java

# Commit with a message describing WHAT and WHY
$ git commit -m "Add initial Task Manager files"
[main (root-commit) a3f2c91] Add initial Task Manager files
 2 files changed, 47 insertions(+)
 create mode 100644 Main.java
 create mode 100644 Task.java

# Unstage a file before committing (doesn't delete the change)
$ git restore --staged Task.java

# See WHAT changed in a file (diff of working dir vs staged)
$ git diff
# See diff of staged vs last commit
$ git diff --staged

❌  git commit -m "fix"
❌  git commit -m "changes"
❌  git commit -m "asdfgh"
❌  git commit -m "WIP dont push"

✓  git commit -m "Add input validation to TaskManager.addTask()"
✓  git commit -m "Fix NPE when task file doesn't exist on first run"
✓  git commit -m "Rename completeTask() to markComplete() for clarity"
✓  git commit -m "Remove debug print statements before release"

# Full log — each commit on multiple lines
$ git log
commit a3f2c91b7e4d8f3a2c1b9e7f5d4a3b2c1d9e7f5
Author: Alex Johnson <alex@example.com>
Date:   Mon Jan 15 14:32:00 2024

    Add input validation to TaskManager.addTask()

commit b2e1d9f8c7a6b5e4d3c2b1a9f8e7d6c5b4a3f2
Author: Alex Johnson <alex@example.com>
Date:   Mon Jan 15 11:15:00 2024

    Add TaskManager with file persistence

# Compact one-line log
$ git log --oneline
a3f2c91 Add input validation to TaskManager.addTask()
b2e1d9f Add TaskManager with file persistence
c1d9e7f Add Task model class
d4a3b2c Initial commit — add README

# Visual branch graph (very useful with branches!)
$ git log --oneline --graph --all
* a3f2c91 Add input validation
* b2e1d9f Add TaskManager
* c1d9e7f Add Task model
* d4a3b2c Initial commit

# See exactly what changed in a specific commit
$ git show a3f2c91
diff --git a/TaskManager.java b/TaskManager.java
--- a/TaskManager.java
+++ b/TaskManager.java
-    public void addTask(String title) {
-        tasks.add(new Task(title, "MEDIUM"));
+    public void addTask(String title, String priority) {
+        if (title.isBlank()) { System.out.println("Empty title."); return; }
+        tasks.add(new Task(title.trim(), priority));

# See who changed which line in a file (blame!)
$ git blame TaskManager.java
a3f2c91 (Alex  Jan 15) public void addTask(String title, String priority) {
b2e1d9f (Alex  Jan 15) private ArrayList<Task> tasks = new ArrayList<>();

# See all branches (* marks your current branch)
$ git branch
* main

# Create a new branch
$ git branch feature/due-dates

# Switch to it
$ git checkout feature/due-dates
Switched to branch 'feature/due-dates'

# Better: create AND switch in one command (modern syntax)
$ git switch -c feature/search
Switched to a new branch 'feature/search'

# Now make changes and commit — only on this branch
$ git add .
$ git commit -m "Add searchTasks() method with case-insensitive matching"
[feature/search 7f3a1b2] Add searchTasks() method

# Switch back to main — your changes are NOT here
$ git switch main
Switched to branch 'main'

# See all branches including remote
$ git branch -a
* main
  feature/due-dates
  feature/search

# Delete a branch (after merging)
$ git branch -d feature/search
Deleted branch feature/search (was 7f3a1b2).

# You're on main. You want to bring in feature/search.
$ git switch main

$ git merge feature/search
Updating b2e1d9f..7f3a1b2
Fast-forward
 TaskManager.java | 12 ++++++++++++
 1 file changed, 12 insertions(+)

# After a clean merge, delete the branch
$ git branch -d feature/search
Deleted branch feature/search.

# A merge commit (when both branches have diverged)
$ git merge feature/due-dates
Merge made by the 'ort' strategy.
 Task.java        |  8 ++++++++
 TaskManager.java |  6 ++++++
 2 files changed, 14 insertions(+)

# See the merge commit in log
$ git log --oneline --graph
*   c9f1a2b Merge branch 'feature/due-dates' into main
|\ 
| * 8e4d3c2 Add overdue task filtering
| * 7a1b9f8 Add dueDate field to Task class
* | 6b2c4d1 Fix file loading on empty repo
|/
*  a3f2c91 Add input validation

# On your feature branch, rebase onto latest main
$ git switch feature/stats
$ git rebase main
Successfully rebased and updated refs/heads/feature/stats.

# Now merge — it'll be a clean fast-forward
$ git switch main
$ git merge feature/stats
Fast-forward

$ git merge feature/autosave
CONFLICT (content): Merge conflict in TaskManager.java
Automatic merge failed; fix conflicts and then commit the result.

# See which files have conflicts
$ git status
both modified:   TaskManager.java

# ... edit the file, resolve the conflict ...

$ git add TaskManager.java
$ git commit -m "Merge feature/autosave — combine save and print"
[main d3a2b1c] Merge feature/autosave

# Abort a merge if things go wrong (returns to pre-merge state)
$ git merge --abort

# Add GitHub as the "origin" remote
$ git remote add origin https://github.com/alexj/task-manager.git

# First push: -u sets upstream tracking
$ git push -u origin main
Enumerating objects: 9, done.
To https://github.com/alexj/task-manager.git
 * [new branch]      main -> main
Branch 'main' set up to track remote branch 'main' from 'origin'.

# After that, just:
$ git push

# Push a feature branch to GitHub
$ git push -u origin feature/due-dates

# Pull = fetch + merge. Gets latest changes from GitHub.
$ git pull
remote: Enumerating objects: 3, done.
Updating a3f2c91..9d1e4b7
Fast-forward
 README.md | 5 +++++

# Clone an existing repo to your machine
$ git clone https://github.com/alexj/task-manager.git
Cloning into 'task-manager'...
done.

# See your remotes
$ git remote -v
origin  https://github.com/alexj/task-manager.git (fetch)
origin  https://github.com/alexj/task-manager.git (push)

# Fetch updates from the original repo
$ git fetch upstream
From https://github.com/original/repo
 * [new branch]      main -> upstream/main

# Merge upstream changes into your local main
$ git switch main
$ git merge upstream/main
Fast-forward

# Push the updated main to your fork
$ git push

main  ──●──────────────────────────────────●──
          \                            /
feature   ──●──●──●  (PR review)  merge

# 1. Branch off main
$ git switch -c feature/sort-tasks

# 2. Work and commit
$ git commit -m "Add sort by priority"
$ git commit -m "Add sort by due date"

# 3. Push and open PR
$ git push -u origin feature/sort-tasks

# 4. PR reviewed, approved, merged → delete branch
$ git switch main && git pull && git branch -d feature/sort-tasks

── BEFORE STAGING ─────────────────────────────
# Discard changes to a file (back to last commit)
$ git restore Main.java

# Discard ALL unstaged changes
$ git restore .

── AFTER STAGING ──────────────────────────────
# Unstage a file (keeps your edits)
$ git restore --staged Main.java

── AFTER COMMITTING (local only) ──────────────
# Undo last commit — keep changes staged
$ git reset --soft HEAD~1

# Undo last commit — keep changes unstaged
$ git reset HEAD~1

# Fix a typo in the last commit message (before push)
$ git commit --amend -m "Correct message here"

# Add a forgotten file to the last commit
$ git add ForgottenFile.java
$ git commit --amend --no-edit

── AFTER PUSHING (safest undo) ────────────────
# Revert creates a NEW commit that undoes a bad one
# (safe because it doesn't rewrite history)
$ git revert a3f2c91
[main 8b1d4e2] Revert "Add broken feature"

# Temporarily stash work-in-progress
$ git stash
Saved working directory and index state WIP on main
# ... do something else ... then restore:
$ git stash pop

# Last resort: restore a specific file from a commit
$ git checkout a3f2c91 -- Task.java

# .gitignore file — place in your project root

# Compiled Java bytecode — never commit .class files
*.class
*.jar
target/
build/
out/

# IDE files — other developers use their own settings
.idea/
*.iml
.vscode/
*.eclipse

# Operating system files
.DS_Store
Thumbs.db

# NEVER commit secrets or credentials
*.env
config/secrets.properties
application-prod.properties

$ git log --oneline
f1a2b3c Merge pull request #3: Add task search
e9d8c7b Add case-insensitive keyword matching to searchTasks()
d6e5f4a Add searchTasks() method stub with tests
c3b2a1f Merge pull request #2: Add task sorting
b9a8f7e Sort by due date using Comparator.comparing()
a7b6c5d Add sort by priority — HIGH first
9e8d7c6 Merge pull request #1: Add file persistence
8f7e6d5 Add loadFromFile() with CSV parsing
7a6b5c4 Add saveToFile() using PrintWriter
6c5b4a3 Add TaskManager class with in-memory operations
5b4a3f2 Add Task model with CSV serialization
4a3b2c1 Add .gitignore for Java and IntelliJ
3f2e1d0 Add README with build instructions and feature list