Repository management in Linux CLI - Step-by-Step Execution

Concept Flow - Repository management

Initialize repository

↓

Add files to staging

↓

Commit changes

↓

Push to remote repository

↓

Pull updates from remote

↓

Manage branches

↓

Merge branches or resolve conflicts

↓

Repeat as needed

This flow shows the basic steps to manage a code repository using commands: initialize, add, commit, push, pull, branch, and merge.

Execution Sample

Linux CLI

git init

git add file.txt

git commit -m "Add file"

git push origin main

This script initializes a repository, stages a file, commits it with a message, and pushes changes to the main branch.

Execution Table

Step	Command	Action	Result	Output
1	git init	Initialize repository	Creates .git folder	Initialized empty Git repository in /path/.git/
2	git add file.txt	Stage file.txt	file.txt added to staging area
3	git commit -m "Add file"	Commit staged files	Creates commit with message	[main (root-commit) abc1234] Add file 1 file changed, 1 insertion(+)
4	git push origin main	Push commits to remote	Uploads commits to remote main branch	Enumerating objects: 3, done. Counting objects: 100% (3/3), done. Writing objects: 100% (3/3), 250 bytes | 250.00 KiB/s, done. Total 3 (delta 0), reused 0 (delta 0) To https://repo.url.git * [new branch] main -> main
5	git pull origin main	Pull latest changes	Updates local repo with remote changes	Already up to date.
6	git branch feature	Create new branch	New branch 'feature' created
7	git checkout feature	Switch to feature branch	HEAD now at feature branch	Switched to branch 'feature'
8	git merge main	Merge main into feature	Combines changes	Already up to date.
9	git status	Check repo status	Shows current branch and changes	On branch feature nothing to commit, working tree clean
10	exit	End of demo	No further commands

💡 Demo ends after showing basic repository management commands.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	After 6	After 7	After 8	After 9	Final
Repository state	No repo	Initialized .git	file.txt staged	Commit created	Commit pushed	Up to date	Branch 'feature' created	Switched to 'feature'	Merged main	Clean working tree	Clean working tree on 'feature'

Key Moments - 3 Insights

Why do we need to 'git add' before 'git commit'?

Because 'git add' stages changes to be included in the next commit. Without adding, 'git commit' has nothing to save. See execution_table step 2 and 3.

What happens if you try to push without committing?

Nothing new is sent because commits represent saved changes. Pushing without commits means no updates to send. See execution_table step 4 after step 3.

Why switch branches before merging?

You merge changes into the branch you are currently on. So you switch to the target branch first, then merge. See execution_table steps 7 and 8.

Visual Quiz - 3 Questions

Look at the execution table, what is the output of 'git commit -m "Add file"' at step 3?

A Switched to branch 'feature'

B Initialized empty Git repository in /path/.git/

C [main (root-commit) abc1234] Add file\n 1 file changed, 1 insertion(+)

D Already up to date.

💡 Hint

Check the Output column at step 3 in the execution_table.

At which step does the repository get initialized?

A Step 1

B Step 2

C Step 4

D Step 6

💡 Hint

Look at the Command and Action columns for repository creation.

If you skip 'git add' and run 'git commit', what would happen?

A Commit will include all changes automatically

B Commit will fail with an error

C Commit will create an empty commit if no staged changes

D Push will automatically stage files

💡 Hint

Refer to key_moments about staging before commit and typical git behavior.

Concept Snapshot

Repository management with Git:
- git init: start repo
- git add: stage files
- git commit -m "msg": save changes
- git push: upload to remote
- git pull: update local
- git branch: manage branches
- git merge: combine branches

Full Transcript

This visual execution shows how to manage a code repository using Git commands. First, 'git init' creates a new repository. Then, 'git add' stages files to prepare them for saving. 'git commit' saves these staged changes with a message. 'git push' uploads commits to a remote server. 'git pull' updates your local copy with remote changes. Branches are created with 'git branch' and switched with 'git checkout'. Merging combines changes from one branch into another. The execution table traces each command's effect and output, while variable tracking shows repository state changes. Key moments clarify why staging is needed before committing and why branch switching is important before merging. Quizzes test understanding of outputs and command order. This guide helps beginners see step-by-step how repository management works in practice.

Practice

1. What is the purpose of the git init command in repository management?

easy

A. To add files to the staging area

B. To check the status of the repository

C. To upload changes to a remote repository

D. To create a new Git repository in the current directory

Solution

1. Step 1: Understand the role of git init

   This command sets up a new Git repository by creating necessary files and folders in the current directory.

2. Step 2: Differentiate from other commands

   git add stages files, git push uploads changes, and git status shows repository state, so they do not create a repository.

3. Final Answer:

   To create a new Git repository in the current directory -> Option D

4. Quick Check:

   git init creates repo [OK]

Hint: Remember: init means start a new repo [OK]

Common Mistakes:

• Confusing git init with git add
• Thinking git init uploads files
• Using git init to check status

2. Which of the following is the correct syntax to add all changed files to the staging area in Git?

easy

A. git add .

B. git add *

C. git add -all

D. git add --commit

Solution

1. Step 1: Identify the command to stage all changes

   git add . stages all changes in the current directory and subdirectories.

2. Step 2: Check other options for correctness

   git add * may not include hidden files, git add -all is invalid, and git add --commit is not a valid option.

3. Final Answer:

   git add . -> Option A

4. Quick Check:

   git add . stages all files [OK]

Hint: Use dot (.) to add all files in current folder [OK]

Common Mistakes:

• Using git add * which misses hidden files
• Typing invalid options like -all
• Confusing git add with commit commands

3. What will be the output of the command git status immediately after running git init in a new directory?

medium

A. fatal: not a git repository (or any of the parent directories): .git

B. On branch main
nothing to commit, working tree clean

C. On branch main
No commits yet
nothing to commit (create/copy files and use "git add" to track)

D. On branch master
nothing to commit, working tree clean

Solution

1. Step 1: Understand initial state after git init

   After initializing, the repository has no commits yet, so git status shows "No commits yet" and instructions to add files.

2. Step 2: Check branch name and messages

   Modern Git uses "main" as default branch, and the message includes "nothing to commit (create/copy files and use \"git add\" to track)".

3. Final Answer:

   On branch main No commits yet nothing to commit (create/copy files and use "git add" to track) -> Option C

4. Quick Check:

   New repo status shows no commits yet [OK]

Hint: New repo shows 'No commits yet' on main branch [OK]

Common Mistakes:

• Expecting 'master' branch instead of 'main'
• Thinking working tree is clean immediately
• Confusing error message with valid status

4. You ran git commit -m "Initial commit" but got the error: nothing to commit, working tree clean. What is the most likely cause?

medium

A. The repository is not initialized

B. You forgot to run git add to stage files before committing

C. The commit message is missing quotes

D. You need to run git push first

Solution

1. Step 1: Analyze the error message meaning

   The message means there are no staged changes to commit, so Git has nothing to save.

2. Step 2: Identify missing step before commit

   Files must be staged using git add before committing; skipping this causes the error.

3. Final Answer:

   You forgot to run git add to stage files before committing -> Option B

4. Quick Check:

   Stage files before commit [OK]

Hint: Always add files before commit [OK]

Common Mistakes:

• Trying to push before committing
• Ignoring the need to stage files
• Assuming commit message syntax error

5. You cloned a repository and want to update your local copy with the latest changes from the remote. Which sequence of commands correctly achieves this?

hard

A. git fetch origin; git merge origin/main

B. git pull origin main; git add .

C. git push origin main; git commit -m "update"

D. git clone origin; git commit -m "update"

Solution

1. Step 1: Understand how to update local repo from remote

   git fetch origin downloads changes from remote without merging, then git merge origin/main applies those changes to your current branch.

2. Step 2: Check other options for correctness

   git pull origin main combines fetch and merge but git add . after pull is unnecessary; git push uploads changes, not updates; git clone is for initial copy, not update.

3. Final Answer:

   git fetch origin; git merge origin/main -> Option A

4. Quick Check:

   Fetch then merge updates local repo [OK]

Hint: Fetch then merge to update local repo safely [OK]

Common Mistakes:

• Using push instead of pull to update
• Running add after pull unnecessarily
• Trying to clone again to update