added docs for github actions doc

Author: ajay-dhangar

absolute-beginners/git-github-beginner/_category_.json

@@ -0,0 +1,13 @@
+{
+  "label": "Git & GitHub",
+  "position": 5,
+  "link": {
+    "type": "generated-index",
+    "title": "Git & GitHub For Absolute Beginners",
+    "description": "The foundation of every developer's career. Learn to track changes, collaborate with teams, and contribute to open-source at CodeHarborHub. Master Git and GitHub to navigate the world of software development with confidence. Whether you're a beginner or looking to deepen your understanding, our comprehensive resources will guide you through the essentials of version control, branching strategies, and collaborative workflows. Start your journey to becoming a proficient developer today!"
+  },
+  "customProps": {
+    "icon": "🐙",
+    "status": "Foundational"
+  }
+}

absolute-beginners/git-github-beginner/basic-git-usage/index.mdx

@@ -0,0 +1,9 @@
+{
+  "label": "Basic Git",
+  "position": 4,
+  "link": {
+    "type": "generated-index",
+    "title": "Basic Git Commands for Absolute Beginners",
+    "description": "Learn the essential commands you will use 90% of the time as a developer. From creating your first repository to pushing code to GitHub. Master the basics of Git to track changes, collaborate with others, and manage your code effectively. Whether you're new to version control or looking to solidify your understanding, this guide will walk you through the fundamental Git commands every developer should know. Start your journey to becoming a proficient developer today!"
+  }
+}

absolute-beginners/git-github-beginner/basic-git/_category_.json

@@ -0,0 +1,71 @@
+---
+title: "Initializing a Repository (git init)"
+sidebar_label: "1. git init"
+sidebar_position: 1
+description: "Learn how to start version control in your project using the git init command. This guide will walk you through the process of creating a new Git repository, understanding what git init does, and best practices for beginners. Whether you're starting a new project or adding Git to an existing one, this tutorial will help you get set up and ready to track your code changes effectively."
+tags: ["git", "git init", "version control", "repository", "beginner guide"]
+keywords: ["git", "git init", "version control", "repository", "beginner guide"]
+---
+
+Every great project at **CodeHarborHub** starts with a single step: telling Git to start watching your files. This process is called **Initialization**.
+
+The `git init` command transforms an ordinary directory (folder) into a GitHub-ready **Git Repository**.
+
+:::info
+Think of `git init` as the "Start Engine" button for your project. It revs up Git's engine and gets it ready to track every change you make to your code.
+:::
+
+## What does `git init` actually do?
+
+When you run this command, Git creates a hidden folder named `.git` inside your project. This folder is the "Brain" of your project—it stores every version, every branch, and every configuration for that specific repository.
+
+### The "Before and After"
+* **Before `git init`:** Your folder is just a collection of files. If you delete a line of code, it’s gone forever.
+* **After `git init`:** Your folder is a **Repository**. Git is now "listening" for changes, ready to save snapshots of your work.
+
+## How to Use It
+
+Follow these steps to start your first repository:
+
+1.  **Open your Terminal** (or Git Bash on Windows).
+2.  **Navigate** to your project folder:
+    ```bash
+    cd Desktop/my-web-project
+    ```
+3.  **Run the Initialization:**
+    ```bash
+    git init
+    ```
+
+**Expected Output:**
+
+> `Initialized empty Git repository in C:/Users/Ajay/Desktop/my-web-project/.git/`
+
+## The Repository Lifecycle
+
+```mermaid
+graph TD
+    A[Create Folder] --> B[git init]
+    B --> C{Is it a Repo?}
+    C -- Yes --> D[Hidden .git folder created]
+    D --> E[Ready for 'git add']
+    C -- No --> F[Standard Folder]
+```
+
+## Common Use Cases
+
+| Scenario | What to do? |
+| :--- | :--- |
+| **New Project** | Create a folder → `git init`. |
+| **Existing Code** | Go to the existing folder → `git init`. |
+| **Mistake?** | If you initialized the wrong folder, simply delete the hidden `.git` folder to stop tracking. |
+
+## Important Rules for Beginners
+
+1.  **Don't Touch the `.git` Folder:** You will see this folder if you have "Hidden Items" turned on. **Never** delete or modify files inside it manually, or you might lose your entire project history!
+2.  **Don't Nest Repositories:** Avoid running `git init` inside a folder that is *already* inside another Git repository. One project = One `.git` folder.
+3.  **The "Main" Branch:** By default, Git creates a starting branch. In modern development, this is usually called `main` (though older versions might call it `master`). You can rename it later, but for now, just know that this is your "Main" branch where your stable code will live.
+
+:::tip Did you know?
+You only need to run `git init` **once** per project. Once the `.git` folder exists, Git will continue to track that folder forever until you delete it.
+:::

absolute-beginners/git-github-beginner/basic-git/git-init.mdx

@@ -0,0 +1,112 @@
+---
+title: "Installation and Initial Setup"
+sidebar_label: "3. Setup & Configuration"
+sidebar_position: 3
+description: "Step-by-step guide to installing Git on Windows, Mac, and Linux, and configuring your global developer identity. Learn how to verify your setup and connect Git to GitHub for seamless version control and collaboration."
+tags: ["git", "installation", "setup", "configuration", "version control"]
+keywords: ["git", "installation", "setup", "configuration", "version control"]
+---
+
+Before you can start contributing to **CodeHarborHub** projects, you need to turn your computer into a "Git-aware" machine. Follow the guide below for your specific Operating System.
+
+:::important
+Before we dive in, make sure you have a GitHub account set up. If you haven't done that, follow the instructions in **[Create a GitHub Account](/tutorial/github/create-a-github-account)** first, and then come back here to set up Git on your machine.
+:::
+
+## Step 1: Installing Git
+
+<Tabs>
+<TabItem value="windows" label="Windows" default>
+
+1.  **Download:** Visit [git-scm.com/download/win](https://git-scm.com/download/win) and the download will start automatically.
+2.  **Run the Installer:** Open the `.exe` file.
+3.  **The "CodeHarborHub" Recommended Settings:**
+    * **Editor:** Choose "Visual Studio Code" as Git's default editor.
+    * **Path:** Select "Git from the command line and also from 3rd-party software."
+    * **Line Endings:** Select "Checkout Windows-style, commit Unix-style."
+4.  **Finish:** Click Install.
+
+</TabItem>
+<TabItem value="mac" label="macOS">
+
+1.  **Check if installed:** Open Terminal and type `git --version`. macOS often comes with a version of Git pre-installed.
+2.  **Install via Homebrew (Recommended):**
+    ```bash
+    brew install git
+    ```
+3.  **Alternative:** Download the installer from [git-scm.com/download/mac](https://git-scm.com/download/mac).
+
+</TabItem>
+<TabItem value="linux" label="Linux">
+
+Use your distribution's package manager. For **Ubuntu/Debian** (the most common for CodeHarborHub learners):
+
+```bash
+sudo apt update
+sudo apt install git-all -y
+```
+
+For **Fedora**:
+
+```bash
+sudo dnf install git
+```
+
+</TabItem>
+</Tabs>
+
+## Step 2: Configuring Your Identity
+
+This is the most important step! Git needs to know who you are so it can attach your name to your "Commits" (Save Points).
+
+:::important
+Use the **same email address** you used for your GitHub account. This ensures your contributions are linked to your profile!
+:::
+
+Open your terminal (or Git Bash on Windows) and run these two commands:
+
+```bash
+# Set your professional name
+git config --global user.name "ajay-dhangar"
+
+# Set your GitHub email
+git config --global user.email "ajay...@gmail.com"
+```
+
+:::note 
+Replace `"ajay-dhangar"` and `"ajay...@gmail.com"` with your actual name and email. This information will be visible in your commit history and on GitHub.
+:::
+
+## Step 3: Verifying the Setup
+
+Let's make sure everything is working perfectly. Run the following command to see your configuration:
+
+```bash
+git config --list
+```
+
+**What you should see:**
+
+Look for the `user.name` and `user.email` lines in the output. If they match what you typed, your "Developer Identity" is now live!
+
+## How the Setup Connects
+
+```mermaid
+graph LR
+    A[Your PC] -- "Name & Email" --> B[Git Config File]
+    B -- "Identifies" --> C[Your Commits]
+    C -- "Pushed to" --> D[GitHub Profile]
+    D -- "Lights up" --> E[Contribution Green Squares]
+```
+
+## Extra Credit: Essential "Helper" Tools
+
+While you can do everything in the terminal, these tools make the **CodeHarborHub** experience much smoother:
+
+1.  **Visual Studio Code (VS Code):** The \#1 editor for developers. It has Git built right in!
+2.  **Git Lens (Extension):** An extension for VS Code that shows you exactly who wrote every line of code as you click on it.
+3.  **GitHub Desktop:** A simple visual interface if you aren't comfortable with the terminal yet.
+
+:::tip Did you know?
+If you are on Windows, always use **Git Bash** (which was installed with Git) instead of the standard Command Prompt. It gives you a Linux-like experience that matches all professional tutorials!
+:::

absolute-beginners/git-github-beginner/installation-and-setup.mdx

@@ -0,0 +1,81 @@
+---
+title: "What is Git and Why Use It?"
+sidebar_label: "2. What is Git?"
+sidebar_position: 2
+description: "Learn the fundamentals of Git, the world's most popular version control system, and why it is essential for modern developers."
+tags: ["git", "version control", "software development", "collaboration", "branches"]
+keywords: ["git", "version control", "software development", "collaboration", "branches"]
+---
+
+At **CodeHarborHub**, we define **Git** as the "Time Machine" for your code. 
+
+Technically, Git is a **Distributed Version Control System (DVCS)**. It tracks every change you make to your files, allowing you to go back to a previous version if something breaks. Unlike a simple "Undo" button, Git keeps a permanent history of every line of code ever written in your project.
+
+:::info Fun Fact
+The name "Git" was chosen by its creator, Linus Torvalds, as a self-deprecating joke. In British slang, "git" means a foolish or unpleasant person. Linus said, "I'm an egotistical bastard, and I name all my projects after myself. First 'Linux', now 'Git'." Despite the name, Git has become the most widely used version control system in the world.
+:::
+
+## Why Should We Use Git?
+
+If you are working on a solo project or a massive team at **CodeHarborHub**, Git provides three "Industrial-Level" pillars that make development possible:
+
+### 1. The "Safety Net" (Version History)
+Imagine you are building a React app. You add a new feature, and suddenly the whole site crashes. Without Git, you might spend hours trying to remember what you changed. 
+* **With Git:** You simply "Roll Back" to the last working version in one command.
+
+### 2. Parallel Universes (Branching)
+Want to try a crazy new UI design without breaking the live website?
+* Git allows you to create a **Branch**. This is a separate workspace where you can experiment freely. Once the feature is perfect, you "Merge" it back into the main project.
+
+### 3. Collaboration (Teamwork)
+How do 1,000 developers work on the same Linux Kernel or a MERN stack project simultaneously?
+* Git manages the "Conflicts." It knows if Developer A changed line 10 and Developer B changed line 50, and it combines them automatically. If both developers change the same line, Git will ask you to resolve the conflict manually.
+
+## Git vs. Traditional Saving
+
+| Traditional Saving (The "Bad" Way) | Git Saving (The "Pro" Way) |
+| :--- | :--- |
+| `final_v1.zip`, `final_v2.zip` | One folder, infinite history. |
+| Overwriting a friend's work. | Automatic merging of changes. |
+| Hard to see "who changed what." | Detailed logs for every single line. |
+| No way to "test" safely. | Branches for every new feature. |
+
+## How Git Works: The 3 Stages
+
+Git doesn't just save files immediately. It uses a professional 3-step process to ensure your "Snapshots" are clean and intentional.
+
+1.  **Working Directory:** Your actual folder where you are typing code.
+2.  **Staging Area (Index):** A "Pre-save" area. You pick which files are ready to be snapshotted.
+3.  **Repository (HEAD):** The permanent database where Git stores the versions.
+
+```mermaid
+graph LR
+    A[Working Directory] -- "git add" --> B[Staging Area]
+    B -- "git commit" --> C[Local Repository]
+    C -- "git push" --> D[Remote - GitHub]
+```
+
+## Git vs. GitHub: Don't Get Confused!
+
+At **CodeHarborHub**, we use both, but they are different tools:
+
+  * **Git:** The **Tool**. It's the software installed on your computer that manages the history.
+  * **GitHub:** The **Host**. It's a website (the cloud) where you upload your Git repositories so others can see them and collaborate.
+
+:::info Think of it like this
+Git is the camera that takes the photos (commits), and GitHub is the Instagram where you share them. You can use Git without GitHub, but you can't use GitHub without Git!
+:::
+
+## Getting Started at CodeHarborHub
+
+To see if Git is already on your system, open your terminal and type:
+
+```bash
+git --version
+```
+
+If you see a version number (e.g., `git version 2.34.1`), you are ready to move to the next step! If not, head over to **[Installation and Setup](./installation-and-setup)** to get Git on your machine.
+
+:::info
+Git is "Distributed." This means every developer on your team has a **full copy** of the project history on their own hard drive. If the central server (GitHub) ever goes down, the project can be restored from any developer's laptop!
+:::

absolute-beginners/git-github-beginner/intro-to-git.mdx

@@ -0,0 +1,87 @@
+---
+title: What is Version Control Systems?
+sidebar_label: "1. What is VCS?"
+sidebar_position: 1
+description: "Understand the Time Machine of software development—Version Control Systems (VCS). Learn how VCS helps developers track changes, collaborate, and manage code history effectively. Discover the difference between centralized and distributed systems, and why Git is the industry standard for version control."
+tags: ["version control", "git", "vcs", "software development", "collaboration"]
+keywords: ["version control", "git", "vcs", "software development", "collaboration"]
+---
+
+Imagine you are writing a 50-page research paper. You save it as `paper.docx`. Then you make changes and save it as `paper_final.docx`. Then your teacher gives feedback, and you save it as `paper_final_v2_ACTUAL_FINAL.docx`. 
+
+Soon, your folder looks like a mess, and you can't remember what you changed in which version. 
+
+In the software world, we use **Version Control Systems (VCS)** to solve this forever. At **CodeHarborHub**, we call it the **Developer's Time Machine**.
+
+:::info Fun Fact
+The first version control system was created in the 1970s, long before the internet as we know it today. It was called **SCCS (Source Code Control System)** and was used to manage changes to software code on mainframe computers.
+:::
+
+## The Core Purpose
+
+A VCS is a software tool that helps software teams manage changes to source code over time. It keeps track of every single modification to the code in a special kind of database. If a mistake is made, developers can turn back the clock and compare earlier versions of the code to help fix the mistake while minimizing disruption to all team members.
+
+### Why do we use it?
+
+* **History:** You can see exactly who changed what line of code and why.
+* **Undo Button:** If you introduce a bug, you can "roll back" to a version that worked in seconds.
+* **Collaboration:** Multiple developers can work on the same file at the same time without overwriting each other's work.
+
+## Centralized vs. Distributed VCS
+
+Not all Version Control Systems work the same way. In the industry, we have moved from "Centralized" to "Distributed" systems.
+
+<Tabs>
+<TabItem value="cvcs" label="Centralized (The Old Way)" default>
+
+There is one single server that contains all the versioned files. You "check out" a file, edit it, and send it back.
+* **Risk:** If the server goes down, nobody can work or save their history.
+* *Example:* SVN (Subversion).
+
+</TabItem>
+<TabItem value="dvcs" label="Distributed (The Modern Way)">
+
+Every developer has a **full copy** of the entire project history on their own computer.
+* **Benefit:** You can work offline. If the main server crashes, any developer's copy can be used to restore it.
+* *Example:* **Git** (What we use at CodeHarborHub).
+
+</TabItem>
+</Tabs>
+
+## The Git "Snapshots" Concept
+
+Most systems think of changes as "List of file changes." **Git** (the most popular VCS) thinks of information more like a series of **Snapshots**.
+
+Every time you "Commit" (save) your work, Git takes a picture of what all your files look like at that moment and stores a reference to that snapshot.
+
+```mermaid
+graph LR
+    A[Version 1] --> B[Version 2]
+    B --> C[Version 3]
+    C --> D[Version 4]
+    
+    subgraph "Snapshots"
+    A
+    B
+    C
+    D
+    end
+```
+
+## Key Terms Every Beginner Must Know
+
+| Term | Meaning in "Human" Language |
+| :--- | :--- |
+| **Repository (Repo)** | The project folder containing all your code and its history. |
+| **Commit** | A "Save Point" in your timeline with a descriptive message. |
+| **Branch** | A "Parallel Universe" where you can test new ideas safely. |
+| **Merge** | Combining two parallel universes into one. |
+| **Clone** | Downloading a project from the internet to your local PC. |
+
+## Why CodeHarborHub Uses Git
+
+We use Git because it is the **Industrial Standard**. Whether you want to work at Google, a small startup, or contribute to Open Source, Git is the language you will speak. It ensures that our community projects stay organized and that every contributor's work is protected.
+
+:::tip Did you know?
+Git was created by **Linus Torvalds** in 2005—the same genius who created the **Linux Kernel**. He needed a better way to manage thousands of developers working on Linux, so he built Git in just a few weeks\!
+:::