Public Repo Setup

Public Repo Setup

Purpose

Automates the full setup and ongoing management of selective public publishing for private git repos. Uses the orphan branch + worktree pattern so published content shares zero history with the private repo.

Trigger Phrases

• "set up public publishing for {repo}"
• "create a public repo for {repo}"
• "add a safety hook"
• "show my public repos"
• "check public repo status"
• "remove public publishing"

Concepts

• Private repo: The user's existing private git repo with all their content.
• Public repo: A separate public GitHub repo that receives cherry-picked files.
• Orphan branch: A branch with no shared history — the bridge between private and public.
• Worktree: A second checkout directory linked to the same .git database, checked out on the orphan branch.
• Pre-push hook: A safety script that prevents accidentally pushing private branches to the public remote.

Commands

setup {repo-path}

Full end-to-end setup of public publishing for a private repo.

Steps:

1. Validate the repo — confirm {repo-path} is a git repo with at least one commit. If not, stop and explain.

2. Gather configuration — ask the user for:

   • Public repo name on GitHub (e.g., public-notes). Default: public-{private-repo-name}.
   • Public repo description (optional).
   • Worktree location — where to place the public worktree. Default: {repo-parent-dir}/{public-repo-name}.
   • Remote name for the public repo. Default: public.
   • Orphan branch name. Default: public-branch.

3. Create the public GitHub repo:

   gh repo create {username}/{public-repo-name} --public --description "{description}"
   

   If gh is not available or not authenticated, provide the manual GitHub steps instead.

4. Create the orphan branch in the private repo:

   cd {repo-path}
   git switch --orphan {orphan-branch}
   git commit --allow-empty -m "Init public branch"
   git switch {original-branch}
   

5. Add the public remote:

   git remote add {remote-name} https://github.com/{username}/{public-repo-name}.git
   

6. Create the worktree:

   git worktree add {worktree-path} {orphan-branch}
   

7. Install the pre-push safety hook — see the add-hook command below. Always install the hook during setup.

8. Push the initial empty commit:

   cd {worktree-path}
   git push {remote-name} {orphan-branch}:main
   cd {repo-path}
   

9. Confirm success — summarize what was created:

   • Public repo URL
   • Worktree path
   • Remote name
   • How to publish files: cd {worktree-path} && git checkout {main-branch} -- path/to/file

10. Offer to save config — ask if the user wants the configuration saved to their global copilot instructions (~/.copilot/copilot-instructions.md).

add-hook {repo-path}

Install or update the pre-push safety hook on a repo.

Steps:

1. Locate the git dir — resolve {repo-path}/.git (or the linked gitdir if it's a worktree).

2. Check for existing hook — if .git/hooks/pre-push exists, show it and ask whether to replace or append.

3. Write the hook:

   #!/bin/bash
   remote="$1"
   
   if [[ "$remote" != "{remote-name}" ]]; then
     exit 0
   fi
   
   echo "⚠️  Pushing to PUBLIC remote"
   echo "Files in this push:"
   echo "---"
   git diff --name-only HEAD~1 HEAD
   echo "---"
   read -p "Are you sure? (y/n) " -n 1 -r
   echo
   if [[ ! $REPLY =~ ^[Yy]$ ]]; then
     echo "Push aborted."
     exit 1
   fi
   
   PRIVATE_PATTERNS=("secret" "private" "draft" "journal" "internal")
   FILES=$(git diff --name-only HEAD~1 HEAD)
   
   for pattern in "${PRIVATE_PATTERNS[@]}"; do
     if echo "$FILES" | grep -qi "$pattern"; then
       echo "🚫 Blocked: found file matching '$pattern'"
       exit 1
     fi
   done
   

4. Ask if the user wants to customize the blocked patterns list.

5. Confirm the hook is installed.

status {repo-path?}

Show the current state of public publishing for a repo (or all configured repos).

Steps:

1. If {repo-path} is provided, inspect that repo. Otherwise, check all repos listed in the user's global copilot instructions under any "Public Publishing" config sections.

2. For each repo, report:

   • Private repo path and branch
   • Public remote URL
   • Worktree path and whether it exists
   • Orphan branch name
   • Whether the pre-push hook is installed
   • Number of files on the public branch vs. private branch
   • Last push date to the public remote (from git log {orphan-branch} -1 --format=%ci)

3. Flag any issues:

   • Worktree missing or corrupt
   • Public remote unreachable
   • Pre-push hook missing
   • Unpushed commits on the orphan branch

teardown {repo-path}

Remove public publishing setup from a repo.

Steps:

1. Confirm with the user — this is destructive. List what will be removed.

2. Remove the worktree:

   git worktree remove {worktree-path}
   

3. Delete the orphan branch:

   git branch -D {orphan-branch}
   

4. Remove the public remote:

   git remote remove {remote-name}
   

5. Optionally delete the hook — ask if the user wants to remove the pre-push hook (they may have other hooks in the same file).

6. Optionally delete the public GitHub repo — ask, and if yes:

   gh repo delete {username}/{public-repo-name} --yes
   

7. Remove config from global copilot instructions if it was saved there.

8. Confirm what was cleaned up.

Constraints

• Never push a non-orphan branch to the public remote. This is the cardinal rule.
• Always install the pre-push hook during setup. It's not optional.
• Never delete or modify the private repo's main branch — only create/manage the orphan branch.
• Always ask for confirmation before destructive operations (teardown, deleting repos).
• Use git switch --orphan not git checkout --orphan — it starts with a clean working tree automatically.