feat: Add bd init --contributor and --team wizards

- Implement OSS contributor workflow wizard
  - Auto-detects fork relationships (upstream remote)
  - Checks push access (SSH vs HTTPS)
  - Creates separate planning repository
  - Configures auto-routing to keep planning out of PRs

- Implement team workflow wizard
  - Detects protected main branches
  - Creates sync branch if needed
  - Configures auto-commit/auto-push
  - Supports both direct and PR-based workflows

- Add comprehensive documentation
  - examples/contributor-workflow/README.md
  - examples/team-workflow/README.md
  - Updated AGENTS.md, README.md, QUICKSTART.md
  - Updated docs/MULTI_REPO_MIGRATION.md

Closes: bd-kla1, bd-twlr, bd-6z7l
Amp-Thread-ID: https://ampcode.com/threads/T-b4d124a2-447e-47d1-8124-d7c5dab9a97b
Co-authored-by: Amp <amp@ampcode.com>
This commit is contained in:
Steve Yegge
2025-11-05 19:03:57 -08:00
parent c20aabe263
commit b230a2270d
10 changed files with 1140 additions and 2 deletions

View File

@@ -12,6 +12,8 @@ This directory contains examples of how to integrate bd with AI agents and workf
<!-- REMOVED (bd-4c74): branch-merge example - collision resolution no longer needed with hash IDs -->
- **[claude-desktop-mcp/](claude-desktop-mcp/)** - MCP server for Claude Desktop integration
- **[claude-code-skill/](claude-code-skill/)** - Claude Code skill for effective beads usage patterns
- **[contributor-workflow/](contributor-workflow/)** - OSS contributor setup with separate planning repo
- **[protected-branch/](protected-branch/)** - Protected branch workflow for team collaboration
## Quick Start

View File

@@ -0,0 +1,211 @@
# OSS Contributor Workflow Example
This example demonstrates how to use beads' contributor workflow to keep your planning issues separate from upstream PRs when contributing to open-source projects.
## Problem
When contributing to OSS projects, you want to:
- Track your planning, todos, and design notes
- Keep experimental work organized
- **NOT** pollute upstream PRs with your personal planning issues
## Solution
Use `bd init --contributor` to set up a separate planning repository that never gets committed to the upstream project.
## Setup
### Step 1: Fork and Clone
```bash
# Fork the project on GitHub, then clone your fork
git clone https://github.com/YOUR_USERNAME/project.git
cd project
# Add upstream remote (important for fork detection!)
git remote add upstream https://github.com/ORIGINAL_OWNER/project.git
```
### Step 2: Initialize Beads with Contributor Wizard
```bash
# Run the contributor setup wizard
bd init --contributor
```
The wizard will:
1. ✅ Detect that you're in a fork (checks for 'upstream' remote)
2. ✅ Prompt you to create a planning repo (`~/.beads-planning` by default)
3. ✅ Configure auto-routing so your planning stays separate
4. ✅ Initialize the planning repo with git
### Step 3: Start Working
```bash
# Create a planning issue
bd create "Plan how to fix bug X" -p 2
# This issue goes to ~/.beads-planning automatically!
```
## How It Works
### Auto-Routing
When you create issues as a contributor:
```bash
bd create "Fix authentication bug" -p 1
```
Beads automatically routes this to your planning repo (`~/.beads-planning/.beads/beads.jsonl`), not the current repo.
### Viewing Issues
```bash
# See all issues (from both repos)
bd list
# See only current repo issues
bd list --source-repo .
# See only planning issues
bd list --source-repo ~/.beads-planning
```
### Discovered Work
When you discover work while implementing:
```bash
# The new issue inherits source_repo from parent
bd create "Found edge case in auth" -p 1 --deps discovered-from:bd-42
```
### Committing Code (Not Planning)
Your code changes get committed to the fork, but planning issues stay separate:
```bash
# Only commits to fork (not planning repo)
git add src/auth.go
git commit -m "Fix: authentication bug"
git push origin my-feature-branch
```
Your planning issues in `~/.beads-planning` **never appear in PRs**.
## Example Workflow
```bash
# 1. Create fork and clone
git clone https://github.com/you/upstream-project.git
cd upstream-project
git remote add upstream https://github.com/upstream/upstream-project.git
# 2. Run contributor setup
bd init --contributor
# Wizard detects fork ✓
# Creates ~/.beads-planning ✓
# Configures auto-routing ✓
# 3. Plan your work (routes to planning repo)
bd create "Research how auth module works" -p 2
bd create "Design fix for bug #123" -p 1
bd ready # Shows planning issues
# 4. Implement (commit code only)
git checkout -b fix-auth-bug
# ... make changes ...
git add . && git commit -m "Fix: auth bug"
# 5. Track discovered work (stays in planning repo)
bd create "Found related issue in logout" -p 2 --deps discovered-from:bd-abc
# 6. Push code (planning never included)
git push origin fix-auth-bug
# Create PR on GitHub - zero planning pollution!
# 7. Clean up after PR merges
bd close bd-abc --reason "PR merged"
```
## Configuration
The wizard configures these settings in `.beads/beads.db`:
```yaml
contributor:
planning_repo: ~/.beads-planning
auto_route: true
```
### Manual Configuration
If you prefer manual setup:
```bash
# Initialize beads normally
bd init
# Configure planning repo
bd config set contributor.planning_repo ~/.beads-planning
bd config set contributor.auto_route true
```
## Multi-Repository View
Beads aggregates issues from multiple repos:
```bash
# List issues from all configured repos
bd list
# Filter by source repository
bd list --source-repo . # Current repo only
bd list --source-repo ~/.beads-planning # Planning repo only
```
## Benefits
**Clean PRs** - No personal todos in upstream contributions
**Private planning** - Experimental work stays local
**Git ledger** - Everything is version controlled
**Unified view** - See all issues with `bd list`
**Auto-routing** - No manual sorting needed
## Common Questions
### Q: What if I want some issues in the upstream repo?
A: Override auto-routing with `--source-repo` flag:
```bash
bd create "Document new API" -p 2 --source-repo .
```
### Q: Can I change the planning repo location?
A: Yes, configure it:
```bash
bd config set contributor.planning_repo /path/to/my-planning
```
### Q: What if I have push access to upstream?
A: The wizard will ask if you want a planning repo anyway. You can say "no" to store everything in the current repo.
### Q: How do I disable auto-routing?
A: Turn it off:
```bash
bd config set contributor.auto_route false
```
## See Also
- [Multi-Repo Migration Guide](../../docs/MULTI_REPO_MIGRATION.md)
- [Team Workflow Example](../team-workflow/)
- [Protected Branch Setup](../protected-branch/)

View File

@@ -0,0 +1,402 @@
# Team Workflow Example
This example demonstrates how to use beads for team collaboration with shared repositories.
## Problem
When working as a team on a shared repository, you want to:
- Track issues collaboratively
- Keep everyone in sync via git
- Handle protected main branches
- Maintain clean git history
## Solution
Use `bd init --team` to set up team collaboration with automatic sync and optional protected branch support.
## Setup
### Step 1: Initialize Team Workflow
```bash
# In your shared repository
cd my-project
# Run the team setup wizard
bd init --team
```
The wizard will:
1. ✅ Detect your git configuration
2. ✅ Ask if main branch is protected
3. ✅ Configure sync branch (if needed)
4. ✅ Set up automatic sync
5. ✅ Enable team mode
### Step 2: Protected Branch Configuration
If your main branch is protected (GitHub/GitLab), the wizard will:
- Create a separate `beads-metadata` branch for issue updates
- Configure beads to commit to this branch automatically
- Set up periodic PR workflow for merging to main
### Step 3: Team Members Join
Other team members just need to:
```bash
# Clone the repository
git clone https://github.com/org/project.git
cd project
# Initialize beads (auto-imports existing issues)
bd init
# Start working!
bd ready
```
## How It Works
### Direct Commits (No Protected Branch)
If main isn't protected:
```bash
# Create issue
bd create "Implement feature X" -p 1
# Daemon auto-commits to main
# (or run 'bd sync' manually)
# Pull to see team's issues
git pull
bd list
```
### Protected Branch Workflow
If main is protected:
```bash
# Create issue
bd create "Implement feature X" -p 1
# Daemon commits to beads-metadata branch
# (or run 'bd sync' manually)
# Push beads-metadata
git push origin beads-metadata
# Periodically: merge beads-metadata to main via PR
```
## Configuration
The wizard configures:
```yaml
team:
enabled: true
sync_branch: beads-metadata # or main if not protected
daemon:
auto_commit: true
auto_push: true
```
### Manual Configuration
```bash
# Enable team mode
bd config set team.enabled true
# Set sync branch
bd config set team.sync_branch beads-metadata
# Enable auto-sync
bd config set daemon.auto_commit true
bd config set daemon.auto_push true
```
## Example Workflows
### Scenario 1: Unprotected Main
```bash
# Alice creates an issue
bd create "Fix authentication bug" -p 1
# Daemon commits and pushes to main
# (auto-sync enabled)
# Bob pulls changes
git pull
bd list # Sees Alice's issue
# Bob claims it
bd update bd-abc --status in_progress
# Daemon commits Bob's update
# Alice pulls and sees Bob is working on it
```
### Scenario 2: Protected Main
```bash
# Alice creates an issue
bd create "Add new API endpoint" -p 1
# Daemon commits to beads-metadata
git push origin beads-metadata
# Bob pulls beads-metadata
git pull origin beads-metadata
bd list # Sees Alice's issue
# Later: merge beads-metadata to main via PR
git checkout main
git pull origin main
git merge beads-metadata
# Create PR, get approval, merge
```
## Team Workflows
### Daily Standup
```bash
# See what everyone's working on
bd list --status in_progress
# See what's ready for work
bd ready
# See recently closed issues
bd list --status closed --limit 10
```
### Sprint Planning
```bash
# Create sprint issues
bd create "Implement user auth" -p 1
bd create "Add profile page" -p 1
bd create "Fix responsive layout" -p 2
# Assign to team members
bd update bd-abc --assignee alice
bd update bd-def --assignee bob
# Track dependencies
bd dep add bd-def bd-abc --type blocks
```
### PR Integration
```bash
# Create issue for PR work
bd create "Refactor auth module" -p 1
# Work on it
bd update bd-abc --status in_progress
# Open PR with issue reference
git push origin feature-branch
# PR title: "feat: refactor auth module (bd-abc)"
# Close when PR merges
bd close bd-abc --reason "PR #123 merged"
```
## Sync Strategies
### Auto-Sync (Recommended)
Daemon commits and pushes automatically:
```bash
bd daemon start --auto-commit --auto-push
```
Benefits:
- ✅ Always in sync
- ✅ No manual intervention
- ✅ Real-time collaboration
### Manual Sync
Sync when you want:
```bash
bd sync # Export, commit, pull, import, push
```
Benefits:
- ✅ Full control
- ✅ Batch updates
- ✅ Review before push
## Conflict Resolution
Hash-based IDs prevent most conflicts. If conflicts occur:
```bash
# During git pull/merge
git pull origin beads-metadata
# CONFLICT in .beads/beads.jsonl
# Option 1: Accept remote
git checkout --theirs .beads/beads.jsonl
bd import -i .beads/beads.jsonl
# Option 2: Accept local
git checkout --ours .beads/beads.jsonl
bd import -i .beads/beads.jsonl
# Option 3: Use beads-merge tool (recommended)
# See AGENTS.md for beads-merge integration
git add .beads/beads.jsonl
git commit
```
## Protected Branch Best Practices
### For Protected Main:
1. **Create beads-metadata branch**
```bash
git checkout -b beads-metadata
git push origin beads-metadata
```
2. **Configure protection rules**
- Allow direct pushes to beads-metadata
- Require PR for main
3. **Periodic PR workflow**
```bash
# Once per day/sprint
git checkout main
git pull origin main
git checkout beads-metadata
git pull origin beads-metadata
git checkout main
git merge beads-metadata
# Create PR, get approval, merge
```
4. **Keep beads-metadata clean**
```bash
# After PR merges
git checkout beads-metadata
git rebase main
git push origin beads-metadata --force-with-lease
```
## Common Questions
### Q: How do team members see each other's issues?
A: Issues are stored in `.beads/beads.jsonl` which is version-controlled. Pull from git to sync.
```bash
git pull
bd list # See everyone's issues
```
### Q: What if two people create issues at the same time?
A: Hash-based IDs prevent collisions. Even if created simultaneously, they get different IDs.
### Q: How do I disable auto-sync?
A: Turn it off:
```bash
bd config set daemon.auto_commit false
bd config set daemon.auto_push false
# Sync manually
bd sync
```
### Q: Can we use different sync branches per person?
A: Not recommended. Use a single shared branch for consistency. If needed:
```bash
bd config set sync.branch my-custom-branch
```
### Q: What about CI/CD integration?
A: Add to your CI pipeline:
```bash
# In .github/workflows/main.yml
- name: Sync beads issues
run: |
bd sync
git push origin beads-metadata
```
## Troubleshooting
### Issue: Daemon not committing
Check daemon status:
```bash
bd daemon status
bd daemons list
```
Verify config:
```bash
bd config get daemon.auto_commit
bd config get daemon.auto_push
```
Restart daemon:
```bash
bd daemon stop
bd daemon start --auto-commit --auto-push
```
### Issue: Merge conflicts in JSONL
Use beads-merge (see [AGENTS.md](../../AGENTS.md#advanced-intelligent-merge-tools)) or resolve manually:
```bash
git checkout --theirs .beads/beads.jsonl
bd import -i .beads/beads.jsonl
git add .beads/beads.jsonl
git commit
```
### Issue: Issues not syncing
Manually sync:
```bash
bd sync
git push
```
Check for conflicts:
```bash
git status
bd validate --checks=conflicts
```
## See Also
- [Protected Branch Setup](../protected-branch/)
- [Contributor Workflow](../contributor-workflow/)
- [Multi-Repo Migration Guide](../../docs/MULTI_REPO_MIGRATION.md)
- [Advanced Merge Tools](../../AGENTS.md#advanced-intelligent-merge-tools)