~/dotfiles
├── git
│   └── .gitconfig                 →  ~/.gitconfig
├── zsh
│   ├── .zshrc                     →  ~/.zshrc
│   ├── .zsh_aliases               →  ~/.zsh_aliases
│   └── .config
│       └── starship.toml          →  ~/.config/starship.toml
├── ghostty
│   └── .config
│       └── ghostty
│           └── config             →  ~/.config/ghostty/config
└── nvim
    └── .config
        └── nvim
            └── init.lua           →  ~/.config/nvim/init.lua

# 1. Generate a key (accept the default path, set a passphrase)
ssh-keygen -t ed25519 -C "you@example.com"

# 2. Start the agent and store the passphrase in the macOS keychain
eval "$(ssh-agent -s)"
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

# 3. Copy the public key
pbcopy < ~/.ssh/id_ed25519.pub

# Then go to GitHub → Settings → SSH and GPG keys → New SSH key, paste the key and save. 
# Add this to ~/.ssh/config so the key loads automatically:
Host github.com
  AddKeysToAgent yes
  UseKeychain yes
  IdentityFile ~/.ssh/id_ed25519

cd ~/dotfiles

git status                          # review what will be committed
# Add any changes in the working directory to the staging area
# Save changes to the local repository
git add .                           
git commit -m "Initial commit: git and zsh packages"
# It only stages already tracked files, so use git add . first for new files (as above).

# Upload the local repository content to our recently created github remote repository: 
git push                           
Username...: nmaximo7
Password...: YOUR PERSONAL TOKEN
# How to save the token so you don't have to paste it every time
# !!! DO NOT DO THIS
git config --global credential.helper store
# That saves your token in plain text in ~/.git-credentials, readable by any process running as you. 

# On macOS, keep the default helper instead, which uses the encrypted Keychain:
git config --global credential.helper osxkeychain

cd ~

# SSH (Option A)
git clone git@github.com:YOUR-USERNAME/macOS.git

# or HTTPS (Option B)
git clone https://github.com/YOUR-USERNAME/macOS.git

cd ~/macOS
# Open it in your editor (optional):
code ~/macOS     # Visual Studio Code

cd ~/macOS/

# Git package
mkdir git
cp ~/.gitconfig git

# Zsh package
mkdir zsh

# Install Oh My Zsh
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
# Install Starship using Homebrew
brew install starship
# Install a Nerd Font
brew install --cask font-meslo-lg-nerd-font

# Create the Stow package structure.
cd ~/macOS/
mkdir -p zsh/.config
# Move and generate the config files
# Instead of creating a blank .zshrc, move the one Oh My Zsh just generated into your zsh package. 
mv ~/.zshrc ~/macOS/zsh/
# Then, create your aliases file
touch ~/macOS/zsh/.zsh_aliases

# Generate the Starship Tokyo Night preset directly into the Stow directory.
starship preset tokyo-night -o ~/macOS/zsh/.config/starship.toml

# --- Oh My Zsh ---------------------------------------------------------
export ZSH="$HOME/.oh-my-zsh"

# Starship draws the prompt, so Oh My Zsh must not set a theme
ZSH_THEME=""

plugins=(git)

source "$ZSH/oh-my-zsh.sh"

# --- Personal config ---------------------------------------------------
# Aliases (only load if the file exists)
[ -f "$HOME/.zsh_aliases" ] && source "$HOME/.zsh_aliases"

# Machine-specific or secret settings (NOT tracked by Git, see section 11)
[ -f "$HOME/.zshrc.local" ] && source "$HOME/.zshrc.local"

# Useful plugins
# brew install zsh-autosuggestions zsh-syntax-highlighting
source "$(brew --prefix)/share/zsh-autosuggestions/zsh-autosuggestions.zsh"
source "$(brew --prefix)/share/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh"

# --- Starship prompt (keep this at the very bottom) --------------------
eval "$(starship init zsh)"

# Navigation
alias ..='cd ..'
alias ...='cd ../..'

# Listing
alias ll='ls -lah'

# Editor
alias v='nvim'
alias vim='nvim'

# Git shortcuts
alias gs='git status -sb'
alias gl='git log --oneline --graph --decorate -15'

# Dotfiles
alias dots='cd ~/dotfiles'

cd ~/macOS
stow -nv zsh      # dry run first
stow -v zsh       # create the links
source ~/.zshrc   # reload the shell

cd ~/macOS/
# Keep Passwords.kdbx in a synced folder (e.g. ~/Documents/Passwords/) and
mkdir KeePassXC
cp [...]/passwords.kdbx keePassXC
# Add at the end .gitignore

cat >> .gitignore <<'EOF'

# --- Secrets: never commit ---
*.kdbx
*.kdb
*.key
*.pem
.env
.env.*
.zshrc.local
.git-credentials
id_rsa*
id_ed25519*
EOF

cd ~/macOS
brew bundle dump --force    # writes ./Brewfile

# Review it, delete what you no longer need, then commit it:
git add Brewfile
git commit -m "Add Brewfile"
git push
# Restore later with:
brew bundle --file=~/nixOS/Brewfile

# 1. Command Line Tools
xcode-select --install

# 2. Homebrew 
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 3. Git and Stow
brew install git stow

# 4. Clone your dotfiles (set up GitHub authentication first)
git clone git@github.com:YOUR-USERNAME/dotfiles.git ~/dotfiles
cd ~/dotfiles

# 5. Install apps and tools
brew bundle --file=~/nixOS/Brewfile

# 6. Back up any default files that would conflict, then stow
mv ~/.zshrc ~/.zshrc.bak 2>/dev/null
mv ~/.gitconfig ~/.gitconfig.bak 2>/dev/null
stow -v git zsh ghostty nvim

#!/usr/bin/env bash
set -euo pipefail

DOTFILES="$HOME/nixOS"
PACKAGES=(git zsh ghostty nvim)

# Homebrew
if ! command -v brew >/dev/null 2>&1; then
  echo "Homebrew is not installed. Install it from https://brew.sh and re-run." >&2
  exit 1
fi

# Tools and apps
brew bundle --file="$DOTFILES/Brewfile"

# Make sure ~/.config exists so Stow does not fold it into the repo
mkdir -p "$HOME/.config"

# Link every package (dry run first: abort on conflicts)
cd "$DOTFILES"
stow -nv "${PACKAGES[@]}"
stow -v  "${PACKAGES[@]}"

echo "Done. Open a new terminal session."

cd ~/dotfiles

# Edit any linked file as usual, e.g. nvim ~/.zshrc (it edits the repo copy)

git status                       # what changed?
git diff                         # review the changes
git add -p                       # stage interactively, hunk by hunk
git commit -m "zsh: add git aliases"
git push

# On another machine:
cd ~/dotfiles
git pull
stow -R zsh        # re-link if files were added or removed

git checkout --orphan abranchnane # Start a new branch from scratch without any previous commit history.
git add -A # Stage all changes in the working directory for the next commit.
git commit -am "Fresh start"
git branch -D main # The `git branch -D main` command is used to forcefully delete the specified branch named "main" in Git.
git branch -m main # Rename the current branch to "main" in Git. 
git push -f origin main # It pushes the renamed branch ("main") to the remote repository and sets it as the upstream branch.
git gc --aggressive --prune all # It performs garbage collection, which cleans up unnecessary files and optimizes the repository for better performance. --aggressive runs a more aggressive garbage collection