feat: add repo setup and visibility recipes (#30)

Add just recipes for repo lifecycle management:
- repo-clone: clone a GitHub repo as bare .git with main worktree
- repo-init: initialize a fresh bare repo with main worktree
- repo-create: create a GitHub repo and push (respects gh git_protocol)
- repo-public/repo-private: change repo visibility (verifies repo exists)

Also rewrites README Usage to use recipe-based workflow, adds a
"Developing with worktrees" walkthrough, and removes the resolved
Starship known issue.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: davidpoblador

README.md

@@ -12,27 +12,32 @@ each worktree is a full working copy of a branch.
 ## Prerequisites
 
 - git
+- [gh](https://cli.github.com/) (GitHub CLI, for repo setup recipes)
 - [uv](https://docs.astral.sh/uv/) (Python package manager, used to run just and copier)
 
 ## Usage
 
-Set up the bare repo and main worktree yourself, then run copier to drop skeleton files:
+Clone an existing GitHub repo:
 
 ```bash
 mkdir ~/repos/my-project && cd ~/repos/my-project
-gh repo clone owner/my-project .git -- --bare
-git worktree add main main
 uvx copier copy gh:dpoblador/projectuner .
+just repo-clone owner/my-project
 ```
 
-For a brand-new repo with no remote:
+Or start a fresh repo with no remote:
 
 ```bash
 mkdir ~/repos/my-project && cd ~/repos/my-project
-git init --bare .git
-git -C .git commit --allow-empty -m "Initial commit"
-git worktree add main main
 uvx copier copy gh:dpoblador/projectuner .
+just repo-init
+```
+
+To publish a fresh repo to GitHub:
+
+```bash
+just repo-create owner/my-project         # private by default
+just repo-create owner/my-project public  # or public
 ```
 
 ## What you get
@@ -48,34 +53,45 @@ my-project/
 └── .copier-answers.yml
 ```
 
-## Worktree workflow
+## Developing with worktrees
+
+All recipes are run from the project root. If you have
+[just](https://github.com/casey/just) installed, you can use `just` directly
+instead of `uv run --from just-bin just`.
 
-All worktree operations are just recipes, run from the project root. If you have
-[just](https://github.com/casey/just) installed, you can use `just <recipe>` directly
-instead of the `uv run --from just-bin` prefix.
+Start a feature by creating a worktree:
 
 ```bash
-# Start a new feature
-uv run --from just-bin just wt-add my-feature
+just wt-add my-feature     # creates branch from main
+cd my-feature/             # full working copy, ready to go
+```
 
-# Work in it
-cd my-feature/
+Work normally (edit, commit, push) inside `my-feature/`. Meanwhile `main/` stays
+pristine, so you can diff against it anytime:
 
-# List all worktrees
-uv run --from just-bin just wt-ls
+```bash
+git diff main...my-feature
+```
 
-# Fetch latest and fast-forward main
-uv run --from just-bin just wt-update
+You can have multiple worktrees active at once (one per branch):
 
-# Clean up when done (keeps remote branch)
-uv run --from just-bin just wt-rm my-feature
+```bash
+just wt-add bugfix         # another branch, another directory
+just wt-ls                 # see all active worktrees
+```
 
-# Or nuke everything: worktree + local + remote branch
-uv run --from just-bin just wt-destroy my-feature
+When a branch is merged, clean up:
+
+```bash
+just wt-rm my-feature      # removes worktree + local branch
+just wt-destroy bugfix     # also deletes the remote branch
 ```
 
-The `main/` worktree stays pristine as a clean reference for diffing. Never edit files in it
-directly.
+To pull the latest changes into your local main:
+
+```bash
+just wt-update             # fetches all remotes, fast-forwards main
+```
 
 ## Updating a scaffolded project
 
@@ -122,6 +138,11 @@ outside version control.
 | `wt-destroy` | `just wt-destroy <branch>` | Remove a worktree and delete both local and remote branches. |
 | `wt-ls` | `just wt-ls` | List all active worktrees. |
 | `wt-update` | `just wt-update` | Fetch all remotes and fast-forward `main`. |
+| `repo-clone` | `just repo-clone <owner/repo>` | Clone a GitHub repo as a bare `.git/` and create the `main` worktree. |
+| `repo-init` | `just repo-init` | Initialize a bare `.git/` repo with an empty commit and `main` worktree. |
+| `repo-create` | `just repo-create <owner/repo> [visibility]` | Create a GitHub repo (default: private) and push `main`. |
+| `repo-public` | `just repo-public` | Change the GitHub repo's visibility to public. |
+| `repo-private` | `just repo-private` | Change the GitHub repo's visibility to private. |
 | `template-update` | `just template-update [args]` | Update template files via copier. |
 
 ## Local excludes
@@ -130,18 +151,6 @@ Files at the project root are outside version control. They're excluded via
 `.git/info/exclude` (not `.gitignore`). To add your own patterns, edit
 `.git/info/exclude` directly.
 
-## Known issues
-
-### Starship shows branch name at the project root
-
-[Starship](https://starship.rs/)'s `git_branch` module reads `.git/HEAD` and displays the
-branch name even at the bare repo root. The `ignore_bare_repo` option doesn't help because
-Starship uses [gitoxide](https://github.com/GitoxideLabs/gitoxide) which
-[has a bug detecting bare repos](https://github.com/GitoxideLabs/gitoxide/issues/2402).
-
-The fix has been merged in gitoxide and is expected in the gitoxide release on 2026-02-22,
-after which Starship needs to bump its gitoxide dependency.
-
 ## Credit
 
 Based on the workflow from Ahmed el Gabri:

template/justfile

@@ -1,4 +1,4 @@
-# ABOUTME: Recipes for managing git worktrees and updating template files.
+# ABOUTME: Recipes for managing git worktrees, GitHub repos, and template files.
 # ABOUTME: Invoked via: uv run --from just-bin just <recipe>
 
 # List available recipes
@@ -123,6 +123,109 @@ wt-update:
     exit 1
   fi
 
+# Clone an existing GitHub repo as a bare repo with a main worktree
+repo-clone repo:
+  #!/bin/bash
+  set -euo pipefail
+
+  if [ -d .git ] || [ -f .git ]; then
+    echo "Error: .git already exists." >&2
+    exit 1
+  fi
+
+  REPO="{{ repo }}"
+
+  gh repo clone "$REPO" .git -- --bare
+  git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
+  git fetch origin --quiet
+  git worktree add main main
+
+  echo "Cloned $REPO with main worktree."
+  echo "  cd main/"
+
+# Initialize a new bare repo with a main worktree
+repo-init:
+  #!/bin/bash
+  set -euo pipefail
+
+  if [ -d .git ] || [ -f .git ]; then
+    echo "Error: .git already exists." >&2
+    exit 1
+  fi
+
+  git init --bare .git
+  TREE=$(git hash-object -t tree /dev/null)
+  COMMIT=$(echo "Initial commit" | git commit-tree "$TREE")
+  git update-ref refs/heads/main "$COMMIT"
+  git worktree add main main
+
+  echo "Initialized bare repo with main worktree."
+  echo "  cd main/"
+
+# Create a GitHub repo and push main
+repo-create repo visibility='private':
+  #!/bin/bash
+  set -euo pipefail
+
+  REPO="{{ repo }}"
+  VISIBILITY="{{ visibility }}"
+
+  if git remote get-url origin &>/dev/null; then
+    echo "Error: origin remote already exists ($(git remote get-url origin))." >&2
+    exit 1
+  fi
+
+  gh repo create "$REPO" --"$VISIBILITY"
+
+  PROTOCOL=$(gh config get git_protocol 2>/dev/null || echo "https")
+  if [ "$PROTOCOL" = "ssh" ]; then
+    URL="git@github.com:${REPO}.git"
+  else
+    URL="https://github.com/${REPO}.git"
+  fi
+
+  git remote add origin "$URL"
+  git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
+  git -C main push -u origin main
+
+  echo ""
+  echo "Created $VISIBILITY repo and pushed main."
+  echo "  https://github.com/$REPO"
+
+# Change GitHub repo visibility to public
+repo-public:
+  @{{ just_executable() }} _repo-visibility public
+
+# Change GitHub repo visibility to private
+repo-private:
+  @{{ just_executable() }} _repo-visibility private
+
+[private]
+_repo-visibility visibility:
+  #!/bin/bash
+  set -euo pipefail
+
+  VISIBILITY="{{ visibility }}"
+
+  REMOTE_URL=$(git remote get-url origin 2>/dev/null) || {
+    echo "Error: no origin remote configured." >&2
+    exit 1
+  }
+
+  REPO=$(echo "$REMOTE_URL" | sed -E 's|.*github\.com[:/]||; s|\.git$||')
+  if [ -z "$REPO" ]; then
+    echo "Error: could not parse GitHub repo from $REMOTE_URL" >&2
+    exit 1
+  fi
+
+  gh repo view "$REPO" >/dev/null 2>&1 || {
+    echo "Error: GitHub repo $REPO not found." >&2
+    exit 1
+  }
+
+  gh repo edit "$REPO" --visibility "$VISIBILITY"
+  echo "$REPO is now $VISIBILITY."
+
 # Update template files via copier (works around bare repo limitation)
 template-update *args:
   #!/bin/bash