DEV Community: K-kibet

Terminal commands to check Git remote configurations

K-kibet — Thu, 27 Nov 2025 17:06:07 +0000

Here are the commands to check Git remote configurations:

Check Remote URLs

git remote -v

This shows all remote repositories with their fetch and push URLs.

List Remote Names

git remote

Shows just the names of your remotes (usually "origin").

Get Detailed Remote Info

git remote show origin

Shows detailed information about a specific remote including fetch/push URLs and branch tracking.

Check Remote URL for Specific Remote

git config --get remote.origin.url

Directly gets the URL for the "origin" remote.

Common Output Examples

$ git remote -v
origin  https://github.com/user/repo.git (fetch)
origin  https://github.com/user/repo.git (push)

If you don't see any output, it means no remote repositories are configured. You can add one with:

git remote add origin <repository-url>

How to Remove All Git Commits Locally Without Losing Your Code

K-kibet — Mon, 17 Nov 2025 07:08:40 +0000

When working on a project, there are times you may want to completely remove your Git history — maybe your commit log is messy, you accidentally pushed sensitive details, or you simply want to start fresh. The good news is that you can wipe out every Git commit in a local repository without losing a single line of your code.

In this guide, we’ll walk through a simple and safe way to remove all Git commits locally and start over with clean version control.

## Why Remove Git History?

There are several good reasons developers reset their Git history:

To clean up messy commits and start fresh.
To remove accidentally committed files, like environment variables or API keys.
To prepare a project for open-source release without exposing past work.
To reduce repository size.
To disconnect the project from a previous remote repository.

Whatever your reason is, the process is straightforward.

Method 1: Remove Git Completely (Keep Only Your Code)

If you want to detach the project from Git entirely, use this method. It deletes all Git tracking and history but keeps all your project files safe.

Step 1: Delete the `.git` directory

On macOS/Linux:

rm -rf .git

On Windows (PowerShell):

Remove-Item -Recurse -Force .git

Once the .git folder is gone, the project is no longer a Git repository. None of your files are deleted.

Method 2: Reset Git and Start a Fresh Repo

If you still want the project under Git but with a completely clean commit history, follow these steps:

Step 1: Delete the Git history

rm -rf .git

Step 2: Reinitialize a new Git repository

git init

Step 3: Add all your existing files

git add .

Step 4: Create the first clean commit

git commit -m "Initial commit"

This gives you a brand-new repository with your full project files but zero previous commits.

Optional: Reconnect to a Remote Repository

If you want to push the fresh repo to GitHub, GitLab, or Bitbucket, add your remote:

git remote add origin your-repo-url.git
git push -u --force origin main

⚠️ Warning: Using --force will overwrite the remote history.

Final Thoughts

Clearing your Git history is a powerful way to clean up your project, enhance privacy, or prepare your code for a new workflow. The best part? You don’t lose any of your files — only the commit history is wiped.

Whether you’re cleaning up a personal project or preparing for a professional deployment, starting fresh with a clean Git history can make your repository easier to understand and maintain.

🧹 How to Clear Cache in Windows Using PowerShell (Complete Guide)

K-kibet — Mon, 17 Nov 2025 07:04:44 +0000

Keeping your Windows PC clean and responsive is important—especially if you use it daily for development, gaming, work, or general browsing. Over time, Windows stores piles of temporary files, thumbnails, DNS entries, and other cached data that can slow down your system, eat up disk space, and sometimes cause weird system glitches.

The good news? You can delete all these caches easily using PowerShell, Windows’ powerful command-line tool. This guide walks you through the exact commands you need and explains what each one does.

🔴 Why Clear Cache in Windows?

Windows creates cache files to improve performance, but they can become harmful when:

Apps start running slowly
The system becomes sluggish
Files refuse to open or load
Disk space gets low
Old thumbnails or corrupted temp files cause bugs
DNS cache causes browsing issues

Clearing cache is safe and often fixes these problems.

🟦 PowerShell vs CMD — What’s the Difference?

Many online guides use CMD (Command Prompt) commands like:

del /q/f/s %TEMP%\*

But these do NOT work in PowerShell, because PowerShell uses different syntax and more powerful commands.

So here are the correct and safe PowerShell commands.

🧹 1. Clear User Temporary Files

Your user TEMP folder fills up with leftover files from installers, browsers, and apps.

Run:

Remove-Item "$env:TEMP\*" -Recurse -Force -ErrorAction SilentlyContinue

This wipes all temporary files for the current user account.

🧹 2. Clear Windows Temp Folder

This folder stores system-wide temp files.

Remove-Item "C:\Windows\Temp\*" -Recurse -Force -ErrorAction SilentlyContinue

Make sure you open PowerShell as Administrator for this step.

🧼 3. Flush DNS Cache

If websites fail to load or you get unusual network errors, your DNS cache may be corrupt.

Clear-DnsClientCache

This resets your DNS entries and can instantly fix browsing issues.

🧹 4. Clear Windows Prefetch Cache

The Prefetch folder helps Windows launch programs faster, but it can get bloated.

Remove-Item "C:\Windows\Prefetch\*" -Recurse -Force -ErrorAction SilentlyContinue

Windows rebuilds this folder automatically.

🧹 5. Clear Thumbnail Cache

If File Explorer shows wrong or broken thumbnails, clear them using:

Remove-Item "$env:LocalAppData\Microsoft\Windows\Explorer\thumbcache_*.db" -Force -ErrorAction SilentlyContinue
Stop-Process -Name explorer -Force
Start-Process explorer

Restarting Explorer refreshes your system thumbnail cache immediately.

🧼 6. Reset Microsoft Store Cache

If the Microsoft Store won’t load or shows errors:

Start-Process "wsreset.exe"

This resets all Store-related cache data.

🟩 Combined PowerShell Script (Run All at Once)

If you want a single command set that clears everything, paste this in PowerShell:

Remove-Item "$env:TEMP\*" -Recurse -Force -ErrorAction SilentlyContinue
Remove-Item "C:\Windows\Temp\*" -Recurse -Force -ErrorAction SilentlyContinue
Clear-DnsClientCache
Remove-Item "C:\Windows\Prefetch\*" -Recurse -Force -ErrorAction SilentlyContinue
Remove-Item "$env:LocalAppData\Microsoft\Windows\Explorer\thumbcache_*.db" -Force -ErrorAction SilentlyContinue
Stop-Process -Name explorer -Force
Start-Process explorer
Start-Process "wsreset.exe"
Write-Host "✅ Cache cleanup complete!"

This gives your system a fresh start in under a minute.

🎯 Final Thoughts

Manually cleaning up cache can dramatically improve system responsiveness, free up disk space, and solve minor Windows problems. PowerShell is the most reliable tool for this because it gives full control and avoids errors that CMD-based methods often cause.

Run this cleanup once a month—or any time your PC starts feeling slow—and enjoy a cleaner, faster Windows experience.

How to Connect Your Namecheap Domain to a Render App (Step-by-Step Guide)

K-kibet — Mon, 17 Nov 2025 06:58:03 +0000

If you're hosting your web app on Render and want to use a custom domain from Namecheap, the setup is easier than it looks. In this guide, I’ll walk you through the complete process—from adding your domain on Render to configuring DNS records on Namecheap and enabling HTTPS.

Whether you're deploying a full-stack app, API, or static website, the steps are the same. Let’s get started!

🔧 Step 1: Add Your Custom Domain in Render

Log in to your Render Dashboard.
Open the app you want to connect (Static Site or Web Service).
Navigate to the Settings tab.
Scroll down to Custom Domains.
Click Add Custom Domain.
Enter the domain you purchased from Namecheap (e.g., example.com or www.example.com).
Click Continue.

Render will now generate DNS records that you need to add in your Namecheap dashboard. Keep this page open—you’ll need the values.

🌐 Step 2: Configure DNS Records in Namecheap

Log in to your Namecheap account.
Go to Domain List → click Manage next to your domain.
Switch to the Advanced DNS tab.

Before adding new records:

Remove any old or conflicting DNS records (A, CNAME, URL redirect records).

Now add the records Render provided. Usually, the setup looks like this:

For your main/root domain (`example.com`):

Type	Host	Value (Target)	TTL
A	@	Render IP address (shown in Render)	Auto

For the `www` subdomain (`www.example.com`):

Type	Host	Value (Target)	TTL
CNAME	www	your-app-name.onrender.com (or equivalent)	Auto

If Render gave you unique DNS targets or a different setup, be sure to use the exact values shown on your dashboard.

Once you save your changes, DNS propagation begins. This usually completes within a few minutes but can take up to a few hours.

🔒 Step 3: Enable HTTPS on Render

After your DNS records propagate:

Return to the Custom Domains section in Render.
Wait for Render to verify your domain.
Once verified, click Enable Automatic HTTPS.

Render will automatically issue an SSL certificate via Let’s Encrypt. When completed, your website will be accessible securely via HTTPS.

🧪 Step 4: Test Your Domain

After everything is set up:

Visit https://yourdomain.com
Or https://www.yourdomain.com

You should now see your Render-hosted application running under your custom domain.

If the site doesn’t load immediately, don’t worry—DNS propagation may still be in progress.

🔍 Bonus Tips

Check DNS Propagation

Use tools like:

whatsmydns.net
dnschecker.org

Enter your domain and check if the A and CNAME records have updated globally.

Choose between root or www

You can choose whichever will serve as your primary address:

Primary: example.com ➝ redirect www.example.com
Primary: www.example.com ➝ redirect example.com

Render lets you configure domain redirects easily in the Custom Domains section.

🎉 Final Thoughts

Connecting a custom domain from Namecheap to Render is straightforward once you understand the DNS steps. With your custom domain in place, your project looks more professional, builds trust, and becomes easier for users to access.

🔥 How to Generate a JKS Keystore Without Android Studio (Complete Guide)

K-kibet — Mon, 17 Nov 2025 06:52:14 +0000

A simple tutorial for creating a `.jks` file using Keytool — with fixed passwords, alias, and automated command

Android developers often rely on Android Studio to generate a signing keystore for their apps. But what if you want to create a .jks file without opening Android Studio?
Maybe you're working on a server, CI/CD pipeline, or a lightweight development environment where Android Studio isn't installed.

This guide walks you through:

Installing the JDK (if missing)
Enabling the keytool command
Generating a .jks keystore non-interactively
Using fixed credentials (storePassword, keyPassword, alias)
Creating a matching key.properties file

Let’s get started.

1. The Goal (What We Want to Generate)

We want a .jks file named:

goalkings.jks

With these credentials:

storePassword = goalkings
keyPassword   = goalkings
keyAlias      = goalkings
storeFile     = goalkings.jks

And we want to generate it using a single command, without Android Studio, without answering prompts.

2. Checking If `keytool` Works

Before generating the keystore, we must ensure that Java’s keytool utility is available.

Open PowerShell or CMD and run:

keytool -help

If you get:

The term 'keytool' is not recognized...

…it means the JDK isn't installed or not added to PATH.

Let's fix that.

3. Install the Java Development Kit (JDK)

If Java isn’t installed, download and install a JDK:

Adoptium (recommended): https://adoptium.net
Oracle JDK: https://www.oracle.com/java/technologies/javase-downloads.html

During installation, note where the JDK is installed. Usually:

C:\Program Files\Java\jdk-17\

or:

C:\Program Files\Java\jdk-21\

4. Add JDK to PATH (Windows)

If you installed Java but keytool still doesn’t work, you need to add it to your PATH.

Steps:

Press Win + S → search Environment Variables
Open Edit the system environment variables
Click Environment Variables
Under System Variables, find Path → click Edit
Add the JDK’s bin directory:

C:\Program Files\Java\jdk-17\bin

Click OK
Restart CMD/PowerShell

Now run:

keytool -help

If it outputs help text — you're ready!

5. Generate the JKS File (Non-Interactive Command)

Navigate to your project directory. Example:

cd D:\vscodeProjects\goalkings

Now run this command exactly:

keytool -genkeypair -v -keystore goalkings.jks -storepass goalkings -keypass goalkings -keyalg RSA -keysize 2048 -validity 10000 -alias goalkings -dname "CN=Goalkings, OU=IT, O=Goalkings Ltd, L=Nairobi, S=Nairobi, C=KE"

✔ No prompts
✔ No questions
✔ Generates goalkings.jks instantly

Your keystore will now appear inside the current directory:

D:\vscodeProjects\goalkings\goalkings.jks

6. Verify the Keystore

Check that everything was created correctly:

keytool -list -v -keystore goalkings.jks -storepass goalkings

This displays:

alias name
fingerprints
key algorithm
creation date

7. Create a key.properties File (Android)

Inside your Android project root, create:

`key.properties`

storePassword=goalkings
keyPassword=goalkings
keyAlias=goalkings
storeFile=goalkings.jks

This file is used by your build.gradle for signing.

8. Example `build.gradle` Signing Setup

Inside:

android {
    ...
}

Add:

def keystoreProps = new Properties()
def keystorePropsFile = rootProject.file("key.properties")

if (keystorePropsFile.exists()) {
    keystoreProps.load(new FileInputStream(keystorePropsFile))
}

android {
    signingConfigs {
        release {
            storeFile file(keystoreProps['storeFile'])
            storePassword keystoreProps['storePassword']
            keyAlias keystoreProps['keyAlias']
            keyPassword keystoreProps['keyPassword']
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release
            minifyEnabled false
            shrinkResources false
        }
    }
}

Final Thoughts

You have now:

✔ Installed Java
✔ Enabled keytool
✔ Generated a .jks keystore without Android Studio
✔ Used predefined passwords & alias
✔ Created a key.properties file
✔ Configured signing in Gradle

This method works perfectly for:

CI/CD pipelines
Server builds
Flutter projects
React Native Android builds
Lightweight development setups

How to fix: “less than 1MB free space" Warning

K-kibet — Mon, 17 Nov 2025 06:45:32 +0000

If your Windows laptop is showing “less than 1MB free space” even though you’re sure there’s plenty of storage, here are possible causes and how to fix them:

🔍 1. Wrong Drive is Being Reported

Check which drive is showing that warning:

It could be a recovery partition, system reserved partition, or external drive with very little space.

Fix:

Open File Explorer → This PC and look at each drive’s actual free space.
Don’t worry if small system partitions are nearly full — that’s normal.

⚙️ 2. File Explorer or Storage Info Glitch

Sometimes Windows misreports space due to a glitch or outdated cache.

Fix:

Restart your laptop.
Then go to Settings → System → Storage to see the real breakdown.
Or run:

  wmic logicaldisk get name,freespace,size

in Command Prompt to view free space per drive.

🛠️ 3. Hidden Files or System Files Taking Up Space

Space may be used by:

Pagefile, hiberfil.sys, System Restore points, Windows Update Cache, or Temporary files.

Fix:

Open Disk Cleanup:
- Search for Disk Cleanup in Start.
- Select your drive and clean up System files.
Or use:

  cleanmgr /sageset:1
  cleanmgr /sagerun:1

🐛 4. Corrupted Disk or File System

Corruption can make Windows think the drive is full.

Fix:
Run CHKDSK:

chkdsk C: /f

It may ask to restart — allow it.

🧪 5. Malware or Disk-Filling Bugs

Some malware or faulty apps fill your drive with logs or junk files.

Fix:

Run a scan with Windows Defender or Malwarebytes.
Check %TEMP% folder and delete everything in it.

🧰 Useful Tools

Use WinDirStat or TreeSize Free to see where your storage is going visually.

How to Safely Roll Back to a Specific Git Commit in Your Local Project

K-kibet — Mon, 17 Nov 2025 06:42:06 +0000

Mistakes happen — maybe you pushed the wrong changes, introduced a bug, or simply want to go back to a cleaner point in your project. The good news? Git makes it easy to roll back to a previous commit without panic. In this guide, I'll walk you through exactly how to return your local Git project to an earlier commit safely, depending on whether you want to keep or discard your recent changes.

🔍 Understanding Git Reset Options

Before rolling back, it’s important to understand the three main types of Git resets. Each determines what happens to your working directory and staged files.

1. Soft Reset — Undo a Commit but Keep All Your Changes

If you only want to move the commit pointer backwards but keep your files staged for re-commit:

git reset --soft <commit-hash>

When to Use:

You mistakenly made a commit too early.
You want to combine commits or tidy your history.

Your files remain intact — only the commit is undone.

2. Mixed Reset — Keep Changes but Unstage Them

This is the default reset mode and the most commonly used:

git reset --mixed <commit-hash>

When to Use:

You want to undo commits but still keep the changes in your files.
You prefer to re-stage the changes manually.

Your working directory stays the same; your staging area is cleared.

3. Hard Reset — Completely Discard All Changes

If you want to fully roll back and wipe out all changes made after a certain commit:

git reset --hard <commit-hash>

When to Use:

You want a clean reset.
You’re sure you don’t need any recent changes.
Your local branch is a mess and you want to start fresh from a known good state.

⚠️ Warning: This permanently deletes all uncommitted changes. Use this only if you're absolutely sure.

🔎 How to Get the Commit Hash

Before using any reset command, find the commit you want to roll back to:

git log --oneline

You’ll see output like:

abc1234 Fix login bug
def5678 Add new payment system
...

Copy the hash (e.g., abc1234) and use it with your reset command.

🚀 Rolling Back After You’ve Already Pushed

If the commit is already pushed to a remote branch and you're sure you want to rewrite history:

git push origin <branch-name> --force

⚠️ Use with caution. Force-pushing can overwrite others’ work.

🎯 Final Thoughts

Rolling back to a specific commit doesn’t have to be scary. Git gives you powerful tools to safely undo mistakes — as long as you pick the right type of reset for your situation. Whether you want to keep your changes, clean your entire working directory, or just tidy up your history, these commands give you full control.

How to Safely Clear System Cache Using the Terminal: A Simple Guide

K-kibet — Mon, 17 Nov 2025 06:36:54 +0000

What Is System Cache?

System cache consists of temporary files created by your operating system and apps. These files improve performance, but over time they accumulate and can:

Take up storage,
Slow down the system,
Cause outdated or corrupted cache-related issues.

Clearing cache doesn’t delete personal files; it only removes temporary system files.

Clearing System Cache: Conversation Breakdown

1. Alex’s First Question: “How do I clear cache from the terminal?”

Sam explains that cache clearing depends on your operating system. Below are the correct terminal commands per OS.

Linux: Clear System File Cache

Linux makes it easy to clear memory cache using the terminal without deleting actual files.

To clear pagecache, dentries, and inode caches:

sudo sync
echo 3 | sudo tee /proc/sys/vm/drop_caches

This frees RAM by clearing cached filesystem data. It is safe and widely used by system administrators.

One-line command:

sudo sh -c 'sync; echo 3 > /proc/sys/vm/drop_caches'

macOS: Clear System Cache

macOS stores various system, application, and user caches. You can safely remove them using:

Clear user-level cache:

sudo rm -rf ~/Library/Caches/*

Clear system-level cache:

sudo rm -rf /Library/Caches/*

Restart after clearing cache:

sudo shutdown -r now

A reboot ensures macOS rebuilds fresh cache files.

Windows: Clearing System Cache via Command Line

Windows uses multiple cache locations. Here’s how to clear the most important ones:

Clear Temp folder:

del /q /f /s %TEMP%\*

Clear Prefetch cache:

del /q /f /s C:\Windows\Prefetch\*

Clear Windows Update cache:

net stop wuauserv
del /q /f /s C:\Windows\SoftwareDistribution\Download\*
net start wuauserv

Or use built-in Disk Cleanup:

cleanmgr

Alex’s Final Question: “Does Disk Cleanup (cleanmgr) delete actual files?”

Sam clarifies:

**Yes, Disk Cleanup can delete files — but only safe temporary files.**

It removes things like:

Temporary system files
Recycle Bin contents
Thumbnail cache
Windows Update leftovers
System error logs

You manually check what you want to delete. Nothing is deleted unless you confirm it.

Important Warning:

Avoid deleting Previous Windows installation, unless you’re sure you don’t need to roll back a system update.

Final Thoughts

Clearing system cache is a safe and effective way to:

Free disk space
Fix software glitches
Speed up your machine

Just make sure you use the correct commands for your operating system, and always double-check before deleting anything.

Whether you're like Alex, curious about how things work, or like Sam, someone who assists others through technical issues, clearing cache via the terminal is a powerful skill every computer user should know.

📦 Managing Multiple Projects in One Repository: Submodules, Subtrees, Monorepos & Partial Cloning Explained

K-kibet — Mon, 17 Nov 2025 06:27:57 +0000

Modern software development often involves several related projects that need to live together—perhaps a shared library, a mobile app, an admin dashboard, and a backend API. Managing these independently while keeping them organized in a single place requires the right Git strategy.

In this guide, we’ll explore four powerful approaches to organizing multiple projects under one repository:

Git Submodules
Git Subtrees
Monorepo structure
Partial cloning using sparse-checkout

Each technique has its strengths and ideal use cases. Let’s break them down with clear examples.

🔧 1. Git Submodules — Independent Projects Inside a Parent Repository

Git submodules let you embed separate Git repositories inside a parent repository. Each submodule maintains its own commit history and remote origin.

✔ When to Use Submodules

When projects must remain completely independent
When you want separate version control per project
When reused modules belong in multiple repositories

📌 Example Use Case

Main project: mega-suite
Submodules:

ui-engine
data-analyzer

📥 Adding a Submodule

git submodule add https://github.com/example/ui-engine.git modules/ui-engine
git commit -m "Added ui-engine as submodule"

This creates a .gitmodules file that tracks submodule entries.

▶ Initialize & Update Submodules

git submodule update --init --recursive

🔄 Working Inside a Submodule

cd modules/ui-engine
git checkout main

💡 Pros

Clean separation
Reusable modules
Independent version history

⚠ Limitations

Can confuse beginners
Requires extra commands to sync
Submodules can break if misconfigured

🌳 2. Git Subtrees — Embed Projects Without Complexity

Git subtrees merge another repository into a folder inside your repo—without the extra complexity of submodules.

✔ When to Use Subtrees

When you want all code in one repo
But still want to pull updates from external repos
And you don’t want the overhead of submodules

📌 Example Use Case

Main repository: mega-suite
Subtree projects:

ui-engine
data-analyzer

➕ Add a Subtree

git remote add ui-engine https://github.com/example/ui-engine.git
git subtree add --prefix=modules/ui-engine ui-engine main --squash

🔄 Updating the Subtree

git subtree pull --prefix=modules/ui-engine ui-engine main --squash

💡 Pros

Everything stored inside one repo
No special clone commands
Easier than submodules
No detached HEAD issues

⚠ Limitations

Repo size grows faster
No true isolation between projects

🏢 3. Monorepos — A Single Repo for Multiple Projects

A monorepo is a repository where all projects live together—even if they are unrelated. Big companies like Google, Meta, and Microsoft use monorepos to streamline development.

✔ When to Use a Monorepo

When projects depend on each other
When you want shared tooling and libraries
When you want centralized versioning

📁 Example Monorepo Structure:

mega-suite/
├── apps/
│   ├── dashboard/
│   └── mobile/
├── services/
│   ├── auth-service/
│   └── billing-service/
└── shared/
    ├── ui-kit/
    └── utils/

💡 Pros

Easy refactoring across multiple projects
Shared code lives in one place
One repository to maintain
Unified versioning

⚠ Limitations

Repo can grow very large
Requires tooling (NX, Lerna, Turborepo)
Requires discipline to maintain structure

📥 4. Partial Cloning — Clone Only the Project You Need

Partial cloning (via sparse-checkout) allows users to clone only specific folders instead of the entire repository. This is perfect for monorepos.

✔ When to Use Sparse-Checkout / Partial Cloning

Repo is too large
Developers work on only one project
You want to save disk space and bandwidth

📌 Example Setup

Monorepo: mega-suite
Folders:

apps/dashboard
apps/mobile

🧩 Clone Repo Without Checkout

git clone --no-checkout https://github.com/example/mega-suite.git
cd mega-suite

🔧 Initialize Sparse Checkout

git sparse-checkout init
git sparse-checkout set apps/dashboard

▶ Checkout Files

git checkout main

Now only the dashboard project is downloaded!

💡 Pros

Works perfectly with monorepos
Saves disk space
Developers download only what they need

⚠ Limitations

Requires Git 2.25+
Adds a bit of setup complexity

🎯 Which Approach Should You Choose?

Use Case	Best Method
Projects must remain fully independent	Submodules
Want all code in one repo but keep external sources	Subtrees
Multiple related apps/libraries in one place	Monorepo
Only need to clone specific folders	Partial cloning

🚀 Final Thoughts

Organizing multiple projects under one Git repository isn’t one-size-fits-all. Each method—submodules, subtrees, monorepos, and partial cloning—serves a different purpose.

For strict independence → Submodules
For simpler integration → Subtrees
For large ecosystems → Monorepos
For large repos requiring selective cloning → Partial cloning

Pick the strategy that fits your workflow and scale your projects with confidence.

How to Wipe Your Git History: A Complete Guide to Removing All Previous Commits

K-kibet — Mon, 17 Nov 2025 06:20:38 +0000

Have you ever found yourself in a situation where your Git repository's history has become messy, cluttered, or contains sensitive information that needs to be completely removed? Whether you're starting fresh, cleaning up a project, or need to remove committed secrets, there are times when you need to nuclear option: removing all previous commits entirely.

In this comprehensive guide, we'll explore several methods to wipe your Git history while preserving your current files.

Why Would You Want to Remove All Commits?

Before we dive into the methods, let's understand common scenarios where this might be necessary:

Accidental commits of sensitive data (API keys, passwords, credentials)
Starting a fresh history for a new project phase
Cleaning up a messy commit history beyond repair
Removing large files that are bloating your repository size
Preparing a template repository for public release

⚠️ Important Warning

These operations are destructive and cannot be undone! Always:

Backup your repository before proceeding
Communicate with your team if this is a shared repository
Understand that you'll lose all commit history, tags, and branches

Method 1: The Orphan Branch Approach (Recommended)

This is the safest method that keeps all your current files intact while creating a completely fresh history.

# Step 1: Create a new orphan branch (no parent, no history)
git checkout --orphan new-branch

# Step 2: Add all current files to staging
git add -A

# Step 3: Create your new initial commit
git commit -m "Initial commit - fresh start"

# Step 4: Delete the old main branch
git branch -D main

# Step 5: Rename current branch to main
git branch -m main

# Step 6: Force push to update remote repository
git push -f origin main

When to use this method: This is your go-to approach for most situations. It's clean, straightforward, and preserves all your current work.

Method 2: Nuclear Option - Complete Reinitialization

This method completely wipes everything and starts from scratch. Use this when you want the absolute cleanest slate.

# Step 1: Remove the entire .git directory
rm -rf .git

# Step 2: Reinitialize git
git init

# Step 3: Set up your user configuration
git config user.name "Your Name"
git config user.email "your@email.com"

# Step 4: Add files and create initial commit
git add .
git commit -m "Initial commit"

# Step 5: Reconnect to remote repository
git remote add origin <your-remote-url>
git push -u origin main

When to use this method: When you want to completely reset everything, including git configuration, or when dealing with repository corruption.

Method 3: Git Reset Approach

This method uses Git's internal commands to reset the repository to before the first commit.

# Step 1: Remove HEAD reference
git update-ref -d HEAD

# Step 2: Add and commit files
git add .
git commit -m "Initial commit"

# Step 3: Force push to remote
git push -f origin main

When to use this method: When you prefer using core Git commands and want to keep the existing repository configuration.

Handling Remote Repositories

If you're working with a remote repository (GitHub, GitLab, etc.), you'll need to force push after cleaning your local history:

git push -f origin main

The -f (force) flag is necessary because your local history no longer matches the remote history.

Best Practices and Considerations

1. Check for Sensitive Data First

Before proceeding, ensure you're not just removing history but actually eliminating sensitive information:

# Search for potential secrets in your history
git log -p | grep -i "password\|key\|secret"

2. Update All Branches

If you have multiple branches, you'll need to clean them up too or delete them:

# List all branches
git branch -a

# Delete old branches
git branch -D branch-name

3. Clean Up Tags

Tags will also be removed with your history. If you need to preserve them, consider:

# List all tags
git tag

# Re-tag after cleanup if necessary

4. Notify Your Team

If this is a shared repository:

Coordinate with your team
Have everyone clone the fresh repository
Ensure no one has local changes that haven't been pushed

Alternative: Rebasing Instead of Nuclear Option

Before taking the drastic step of removing all history, consider if interactive rebase might solve your problem:

git rebase -i --root

This allows you to squash, edit, or drop commits while preserving some history.

Conclusion

Removing all Git commits is a powerful but dangerous operation. The orphan branch method (Method 1) is generally recommended for most use cases as it preserves your current working files while giving you a clean history slate.

Remember: with great power comes great responsibility. Use these commands carefully, always maintain backups, and communicate changes with your team when working on shared repositories.

Have you ever needed to wipe your Git history? Share your experiences or questions in the comments below!

Solving Git Authentication Failures: "Password authentication is not supported" Error

K-kibet — Mon, 17 Nov 2025 05:50:22 +0000

If you've recently encountered the frustrating error message "Password authentication is not supported for Git operations" when trying to clone a repository, you're not alone. This common issue stems from GitHub's decision to deprecate password-based authentication for Git operations. But don't worry – I'll walk you through several effective solutions to get you back to coding in no time.

Understanding the Error

Here's what you might be seeing:

Failed to clone source: Clone error: 
Cloning into bare repository './git-data/source.git'...
remote: Invalid username or token. 
Password authentication is not supported for Git operations.
fatal: Authentication failed for 'https://github.com/username/repo.git/'

This error occurs because GitHub no longer accepts account passwords when authenticating Git operations. The platform made this change to enhance security, pushing users toward more secure authentication methods.

Solutions: From Quick Fixes to Best Practices

1. Use Personal Access Tokens (PAT) - Quick HTTPS Solution

Personal Access Tokens are the modern replacement for passwords in HTTPS cloning:

Step-by-step:

Go to GitHub → Settings → Developer settings → Personal access tokens → Tokens (classic)
Click "Generate new token" and select "Generate new token (classic)"
Give it a descriptive name and set an expiration date
Select the appropriate scopes (typically repo for full repository access)
Generate the token and copy it immediately (you won't see it again!)

Usage:

git clone https://username:TOKEN@github.com/kkibetkkorir/goal-genius-newUI-updated.git

Or configure Git to use your token:

git config --global credential.helper cache
# Then on your next operation, use the token as your password

2. Switch to SSH Authentication (Recommended Long-term Solution)

SSH keys provide a more secure and convenient authentication method:

Setting up SSH:

# Generate a new SSH key
ssh-keygen -t ed25519 -C "your_email@example.com"

# Start the SSH agent
eval "$(ssh-agent -s)"

# Add your SSH key to the agent
ssh-add ~/.ssh/id_ed25519

Add the public key to GitHub:

Copy your public key: cat ~/.ssh/id_ed25519.pub
Go to GitHub Settings → SSH and GPG keys → New SSH key
Paste your public key and give it a descriptive title

Clone using SSH:

git clone git@github.com:kkibetkkorir/goal-genius-newUI-updated.git

3. Git Credential Manager - Set It and Forget It

If you're tired of constantly entering credentials:

# Cache credentials for 15 minutes
git config --global credential.helper cache

# Or store them indefinitely (use with caution)
git config --global credential.helper 'store --file ~/.my-credentials'

# On Windows, use the Credential Manager
git config --global credential.helper manager

4. Check for IP Allowlisting Issues

The error message might mention IP allowlisting if you're working within an organization:

Verify your organization's IP restrictions
Check if your current IP address is whitelisted
Use a VPN to connect from an approved network if necessary
Contact your IT department for the allowed IP ranges

5. CI/CD and Automated Environments

For automated scripts and CI/CD pipelines:

# Use environment variables
git clone https://$GITHUB_TOKEN@github.com/username/repo.git

# Or use the built-in GITHUB_TOKEN in GitHub Actions
- uses: actions/checkout@v3
  with:
    token: ${{ secrets.GITHUB_TOKEN }}

Best Practices for Different Scenarios

For personal projects: SSH keys offer the best balance of security and convenience.

For shared computers: Use Personal Access Tokens with limited scopes and reasonable expiration dates.

For CI/CD systems: Use fine-grained tokens with minimal required permissions.

For organizations: Implement SSH keys with mandatory passphrases for additional security.

Troubleshooting Common Issues

"Permission denied" with SSH? Ensure your SSH key is added to the ssh-agent and GitHub
Token not working? Check if the token has expired or has insufficient permissions
Still having issues? Verify repository existence and your access permissions

Why This Change Matters

GitHub's move away from password authentication is part of a broader industry shift toward more secure authentication methods. Passwords are vulnerable to brute-force attacks and phishing, while tokens and SSH keys provide:

Better security through scoped permissions
The ability to revoke access without changing your password
More granular control over what each token can access
Reduced risk in case of credential leaks

Final Thoughts

While the transition away from password authentication might cause temporary frustration, the security benefits are well worth it. Setting up proper authentication now will save you from future headaches and keep your code more secure.

Have you encountered this error? Which solution worked best for you? Share your experiences in the comments below!

Pro tip: Once you've set up SSH authentication or Personal Access Tokens, you'll likely find them more convenient than passwords in the long run. Happy coding! 🚀

The Complete Guide to Working with Single Folders in Multi-Project GitHub Repositories

K-kibet — Mon, 17 Nov 2025 05:46:44 +0000

A practical guide to cloning, modifying, and pushing changes to specific folders in monorepos without dealing with unrelated projects

Have you ever encountered a GitHub repository that contains multiple projects, but you only need to work on one specific folder? Maybe it's a company monorepo with dozens of projects, or an open-source repository with various examples and tools. Downloading the entire repository when you only care about one project feels inefficient and cumbersome.

In this comprehensive guide, I'll show you exactly how to work with single folders in multi-project repositories—from initial clone to final push—without the overhead of dealing with unrelated projects.

Understanding the Challenge

Many organizations use monorepos (single repositories containing multiple projects) for better code sharing, dependency management, and collaboration. However, as a developer, you might only need to work on one specific project within that repository.

The challenge is threefold:

Cloning only the folder you need
Making changes in isolation
Pushing back changes without affecting other projects

Method 1: Sparse Checkout (Recommended Approach)

This is the most reliable method for working with single folders while maintaining full git functionality.

Step 1: Clone Only Your Target Folder

# Create a new directory for your work
mkdir my-project && cd my-project

# Initialize git repository
git init

# Add the remote repository
git remote add origin https://github.com/username/multi-project-repo.git

# Enable sparse checkout
git config core.sparseCheckout true

# Specify EXACTLY which folder you want
echo "project-a/*" > .git/info/sparse-checkout

# Fetch and checkout only your specified folder
git fetch --depth=1 origin main
git checkout origin/main
git switch -c main

Step 2: Verify Your Setup

Check that you only have the files you need:

# List all tracked files - should only show your project folder
git ls-files

# Check current status
git status

You should only see files from your target folder (e.g., project-a/).

Method 2: Quick Sparse Clone with Filter

For a more streamlined approach:

git clone --filter=blob:none --no-checkout https://github.com/username/multi-project-repo.git
cd multi-project-repo
git sparse-checkout init --cone
git sparse-checkout set project-a
git checkout main

Making Changes in Isolation

Now you can work on your project without worrying about other folders:

# Navigate to your project
cd project-a

# Make your changes - edit files, add new ones, etc.
# The rest of the repository doesn't exist in your workspace

# Create new files
touch new-feature.js

# Edit existing files
echo "// New functionality" >> existing-file.js

Pushing Changes Back to the Specific Folder

This is where many developers get nervous—but the process is straightforward.

Step 1: Stage Your Changes Carefully

# Check what will be committed
git status

# Add all changes in your project folder
git add .

# Verify only your project files are staged
git diff --staged --name-only
# Should only show files in project-a/

Step 2: Commit with a Descriptive Message

git commit -m "project-a: Added new authentication features

- Implemented OAuth2 integration
- Added user session management
- Updated documentation"

Using project-a: prefix in your commit message helps maintain clarity in the repository history.

Step 3: Pull Latest Changes and Handle Conflicts

Always pull before pushing to avoid conflicts:

git pull origin main

If there are conflicts, they'll only occur in files within your project folder, since those are the only files you have.

Step 4: Push Your Changes

git push origin main

Safety Checks and Best Practices

Pre-Push Verification Script

Create a script to ensure you're only modifying your intended folder:

#!/bin/bash
# safe-push.sh

PROJECT_DIR="project-a"  # Change this to your folder

echo "Running safety checks..."

# Check for files outside target directory
stray_files=$(git ls-files --cached | grep -v "^$PROJECT_DIR/" | grep -v "\.git")
if [ ! -z "$stray_files" ]; then
    echo "ERROR: Found files outside $PROJECT_DIR:"
    echo "$stray_files"
    echo "Aborting push."
    exit 1
fi

# Check for unstaged changes
if ! git diff --quiet; then
    echo "Warning: You have unstaged changes."
    read -p "Continue anyway? (y/N): " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        exit 1
    fi
fi

echo "Safety checks passed. Proceeding with push..."
git pull origin main
git push origin main

Handling Common Issues

Problem: "Updates were rejected because the remote contains work you do not have locally"

# This happens when others modified files in your project folder
git pull origin main --allow-unrelated-histories
# Resolve any conflicts, then push
git push origin main

Problem: Accidentally staged files outside your project

# Unstage all files
git reset

# Only stage files in your project folder
git add project-a/

Advanced Techniques

Working with Multiple Related Folders

If your project depends on shared utilities:

# Add additional folders to sparse checkout
echo "shared-libraries/" >> .git/info/sparse-checkout
echo "common-config/" >> .git/info/sparse-checkout
git checkout main

Creating Feature Branches

# Create a feature branch
git checkout -b feature/new-authentication

# Make changes, commit, and push
git push origin feature/new-authentication

# Create PR on GitHub, then merge to main

Why This Approach Works

Sparse Checkout: Git only checks out the files you specify, but maintains awareness of the entire repository structure
Smart Pushing: Git tracks what actually changed and only transmits those deltas
Path-Based Operations: Most git operations are path-aware, so pushing only affects the files you modified

Real-World Example: Company Monorepo

Let's walk through a realistic scenario:

# Clone only the frontend project from company monorepo
mkdir company-frontend && cd company-frontend
git init
git remote add origin https://github.com/company/monorepo.git
git config core.sparseCheckout true
echo "apps/web-frontend/*" > .git/info/sparse-checkout
git fetch --depth=1 origin main
git checkout origin/main
git switch -c main

# Work on frontend changes
cd apps/web-frontend
# ... make changes ...

# Safely push back
git add .
git commit -m "apps/web-frontend: Updated responsive design"
git pull origin main
git push origin main

Benefits of This Workflow

Reduced Download Size: Only get what you need
Faster Operations: No unnecessary file processing
Focused Development: No distractions from unrelated projects
Maintained Collaboration: Full compatibility with team workflows
Safety: Little risk of accidentally modifying other projects

Conclusion

Working with single folders in multi-project repositories doesn't require complex tools or risky procedures. With sparse checkout, you can efficiently collaborate on large monorepos while maintaining the focus and simplicity of working with a single project.

The key takeaways:

Use sparse checkout to clone only what you need
Always verify your changes before committing
Pull before pushing to avoid conflicts
Use descriptive commit messages

This approach gives you the best of both worlds: the collaboration benefits of monorepos with the focused workflow of single-project repositories.

Next time you face a massive repository, remember—you don't need to clone it all. Just take what you need and leave the rest.

DEV Community: K-kibet

Terminal commands to check Git remote configurations

Check Remote URLs

List Remote Names

Get Detailed Remote Info

Check Remote URL for Specific Remote

Common Output Examples

How to Remove All Git Commits Locally Without Losing Your Code

## Why Remove Git History?

Method 1: Remove Git Completely (Keep Only Your Code)

Step 1: Delete the .git directory

Method 2: Reset Git and Start a Fresh Repo

Step 1: Delete the Git history

Step 2: Reinitialize a new Git repository

Step 3: Add all your existing files

Step 4: Create the first clean commit

Optional: Reconnect to a Remote Repository

Final Thoughts

🧹 How to Clear Cache in Windows Using PowerShell (Complete Guide)

🔴 Why Clear Cache in Windows?

🟦 PowerShell vs CMD — What’s the Difference?

🧹 1. Clear User Temporary Files

🧹 2. Clear Windows Temp Folder

🧼 3. Flush DNS Cache

🧹 4. Clear Windows Prefetch Cache

🧹 5. Clear Thumbnail Cache

🧼 6. Reset Microsoft Store Cache

🟩 Combined PowerShell Script (Run All at Once)

🎯 Final Thoughts

How to Connect Your Namecheap Domain to a Render App (Step-by-Step Guide)

🔧 Step 1: Add Your Custom Domain in Render

🌐 Step 2: Configure DNS Records in Namecheap

For your main/root domain (example.com):

For the www subdomain (www.example.com):

🔒 Step 3: Enable HTTPS on Render

🧪 Step 4: Test Your Domain

🔍 Bonus Tips

Check DNS Propagation

Choose between root or www

🎉 Final Thoughts

🔥 How to Generate a JKS Keystore Without Android Studio (Complete Guide)

A simple tutorial for creating a .jks file using Keytool — with fixed passwords, alias, and automated command

1. The Goal (What We Want to Generate)

2. Checking If keytool Works

3. Install the Java Development Kit (JDK)

4. Add JDK to PATH (Windows)

Steps:

5. Generate the JKS File (Non-Interactive Command)

6. Verify the Keystore

7. Create a key.properties File (Android)

key.properties

8. Example build.gradle Signing Setup

Final Thoughts

How to fix: “less than 1MB free space" Warning

🔍 1. Wrong Drive is Being Reported

⚙️ 2. File Explorer or Storage Info Glitch

🛠️ 3. Hidden Files or System Files Taking Up Space

🐛 4. Corrupted Disk or File System

🧪 5. Malware or Disk-Filling Bugs

🧰 Useful Tools

How to Safely Roll Back to a Specific Git Commit in Your Local Project

🔍 Understanding Git Reset Options

1. Soft Reset — Undo a Commit but Keep All Your Changes

When to Use:

2. Mixed Reset — Keep Changes but Unstage Them

When to Use:

3. Hard Reset — Completely Discard All Changes

When to Use:

🔎 How to Get the Commit Hash

🚀 Rolling Back After You’ve Already Pushed

🎯 Final Thoughts

How to Safely Clear System Cache Using the Terminal: A Simple Guide

What Is System Cache?

Clearing System Cache: Conversation Breakdown

1. Alex’s First Question: “How do I clear cache from the terminal?”

Linux: Clear System File Cache

To clear pagecache, dentries, and inode caches:

One-line command:

macOS: Clear System Cache

Clear user-level cache:

Step 1: Delete the `.git` directory

For your main/root domain (`example.com`):

For the `www` subdomain (`www.example.com`):

A simple tutorial for creating a `.jks` file using Keytool — with fixed passwords, alias, and automated command

2. Checking If `keytool` Works

`key.properties`

8. Example `build.gradle` Signing Setup

**Yes, Disk Cleanup can delete files — but only safe temporary files.**