beads/cmd/bd/init_contributor.go
Jim Wordelman c4e51986b0
feat(prune): reference-aware bd prune skips closed beads cited by open beads (be-jewoem, be-u2mw2x) (#4023)
* pm: decompose be-zej8mz → 3 builder beads for reference-aware prune

Child beads:
- be-jewoem: core implementation in cmd/bd/purge.go
- be-u2mw2x: --help and README docs update
- be-0wt833: bench asserting <5s on 10K-open-bead fixture (blocked on core)

Plan at docs/plans/reference-aware-prune.md.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(prune): reference-aware bd prune skips closed beads cited by open beads (be-jewoem, be-u2mw2x)

Implements be-5sn FR-01 through FR-06:

- buildReferencedSet scans description/notes/comments of every non-closed
  bead for literal candidate IDs using word-boundary regexp alternation.
  Uses Statuses filter (not ExcludeStatus) to avoid the PG coverage gap
  (be-jdeief guardrail per be-5sn §15).

- runPurgeOrPrune filters referenced beads after pinned-filtering when
  scope.cmdName == "prune" && !scope.ignoreReferences.

- All 4 human output paths updated: preview, dry-run, force, nothing-to-do.
  referenced_skipped/referenced_count always in prune JSON; absent in purge.
  referenced_ids_sample omitted when 0 (per be-zej8mz §5).

- --ignore-references flag registered in pruneCmd.Flags() only; purge
  init() unchanged so bd purge --ignore-references gives "unknown flag".

- pruneCmd.Long gains reference-protection paragraph per be-zej8mz §3.

- README.md adds Maintenance section documenting prune, purge, and the
  reference-aware skip with --ignore-references escape hatch.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* test(prune): NFR-02 bench test for buildReferencedSet on 10K-bead fixture (be-0wt833)

TestPruneLargeFixture generates 10K open beads × ~5KB bodies + 100 closed
candidates with 20 seeded references; asserts buildReferencedSet completes
<5s and returns exactly the seeded IDs.

Passes in ~1.2s on a standard dev machine. Skips under -short.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* docs(prune): regen CLI reference + release gate PASS (be-jewoem)

Regenerate CLI docs with CGO_ENABLED=0 -tags gms_pure_go binary built
from PR HEAD. Adds --ignore-references flag to prune command docs in
CLI_REFERENCE.md and three website prune.md pages.

Gate evaluation: all 6 criteria PASS (AC-6 integration tests deferred
to be-zkzw per reviewer).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* feat(contributor): bd-umbf contributor namespace isolation (Children 1-3)

Child 1 (be-c7696f): Auto-configure contributor routing in bd init
when upstream remote is detected. Non-interactive, idempotent — skips if
routing.contributor is already set. Creates ~/.beads-planning, sets
routing.mode=auto, routing.contributor, sync.remote=upstream, and pins
git beads.role=contributor.

Child 2 (be-9d2b67): bd export --exclude-owner flag and config-driven
export.exclude_owners / export.exclude_owner config. Filters issues by
created_by before writing JSONL. --verbose emits filtered count.

Child 3 (be-3c5a0f): New bd migrate-personal command. Finds project DB
issues whose created_by matches the current git identity, prompts for
confirmation, then moves them to the planning repo (routing.contributor),
copying labels, dependencies, and comments atomically.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(init): match autoConfigureForkContributor output to be-0ccf34 design spec

Three variants were missing; the one present used wrong symbol (✓ instead of ▶).

Happy path: ▶ header, upstream URL echoed, three ✓ action lines, opt-out hint last.
Opt-out path (--role=maintainer on a fork): ⚠ with explanation and recovery hint.
Re-init path (routing already configured): ⚠ with existing path and reconfigure hint.
Non-interactive/quiet: silent (unchanged).

Pass roleFlag through to autoConfigureForkContributor so the opt-out variant fires
when --role=maintainer is given explicitly on a fork.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(contributor): separate insert/delete phases in migrate-personal; suppress nonInteractive output

migrate-personal now copies all issues to planning DB first, then
deletes them from project DB in a single transaction via DeleteIssues.
A mid-loop failure before the delete phase leaves no issues deleted,
making re-runs safe.

Also pass quiet || nonInteractive to autoConfigureForkContributor so
bd init --non-interactive does not emit fork-detection output.

Fixes B4 and the nonInteractive gap from be-72b53f review.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* docs(prune): regen CLI reference — add bd migrate-personal, update bd export flags

Regenerated from bd 1.0.4 dev (9ed33b68d) with CGO_ENABLED=0 -tags gms_pure_go.
Fixes B1: bd migrate-personal was missing from docs/CLI_REFERENCE.md and
all website cli-reference pages.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* docs(gate): update be-jewoem release gate to cover bd-umbf scope

Expands gate scope from be-jewoem/be-u2mw2x only to include bd-umbf
Children 1-3 commits added to the branch. Documents blocker resolution
status (B1/B2/B4 resolved, B3 pending validator), updates CI results to
latest all-green run 26009209774, and marks overall gate ON HOLD pending
validator tests.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* docs(gate): update be-jewoem gate — PR description refreshed, B3 dependency chain clarified (2026-05-19)

* test(contributor): be-f9a104 — bd-umbf export+migrate-personal tests

6 tests for bd-umbf Children 2-3 per be-f9a104 scope:

cmd/bd/export_exclude_owner_test.go (be-9d2b67):
- TestExportExcludeOwner_flag: --exclude-owner=alice filters alice's issues
- TestExportExcludeOwner_config: export.exclude_owners config drives filter
- TestExportExcludeOwner_verbose: --verbose reports filtered count

cmd/bd/migrate_personal_test.go (be-3c5a0f):
- TestMigratePersonal_noopWhenEmpty: no matching issues → 0/success
- TestMigratePersonal_movesIssues: personal issues moved to planning repo
- TestMigratePersonal_abortOnNoConfirm: EOF stdin → abort, issues stay

All gate on BEADS_TEST_EMBEDDED_DOLT=1. Fork-detection init tests
covered by be-de99a6 (tests/be-de99a6-fork-detect) per PM scope.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(test): be-36oa — skip TestMigratePersonal_movesIssues on Dolt unavailable

Broaden the skip condition in TestMigratePersonal_movesIssues to also skip
when the planning dir's Dolt server is unavailable (BEADS_DOLT_AUTO_START=0
leaves port=0, causing dolt.New() to fail). Adds "dolt", "cannot connect",
and "server" to the skip-trigger strings alongside the existing routing
and actor-mismatch conditions.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* test(init): be-de99a6 — fork-detection UX output format tests

4 embedded tests for autoConfigureForkContributor output per be-de99a6:

- TestBdInit_ForkAutoContributor: upstream remote → 'Fork detected' in output,
  routing.mode=auto set
- TestBdInit_ForkAutoContributor_Idempotent: second init run → routing.mode
  still 'auto' (no double-write)
- TestBdInit_ForkAutoContributor_MaintainerFlag: --role=maintainer → routing.mode
  NOT set to auto
- TestBdInit_ForkAutoContributor_NonInteractive: --quiet → no '▶' block, but
  routing still configured

All gate on BEADS_TEST_EMBEDDED_DOLT=1. Uses initForkRepo helper to
add upstream remote for fork detection.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(bd-umbf): be-jewoem B3 — fix yaml/DB store mismatch in export owner-filter and fork routing

Two real bugs found while landing the B3 validator tests:

1. buildOwnerExcludeSet (export.go) was only reading export.exclude_owners
   from the database. The export.* prefix is yaml-only (config.yaml), so
   config set via 'bd config set export.exclude_owners' was invisible to the
   filter. Now reads yaml first, falls back to database.

2. autoConfigureForkContributor (init_contributor.go) was writing
   routing.mode, routing.contributor, and sync.remote via store.SetConfig
   (database). Those keys carry the routing.*/sync.* prefixes which are
   yaml-only. Reading back via 'bd config get routing.mode' always returned
   empty. Now uses config.SetYamlConfig for these keys; idempotency check
   updated to read from yaml too.

Also: update TestBdInit_ForkAutoContributor to verify routing config state
rather than output text (suppressed in non-TTY test environments); remove
temporary debug_fork_test.go; mark B3 RESOLVED in release gate.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(lint): drop unused ctx+store params from autoConfigureForkContributor

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* chore: release gate PASS for bd-3852 (orphaned children doctor check)

* fix(rebase): update second autoConfigureForkContributor call to 2-arg signature

Later commits in this branch dropped ctx and store params from
autoConfigureForkContributor. The second call site added by be787e4b5
still used the old 4-arg form; update to match the final 2-arg form.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(rebase): drop #4028-superseded fork-detect; take main init.go/init_contributor.go (be-15y28)

PR #4028 landed autoConfigureForkContributor on main. PR #4023 had its own
version of init.go and init_contributor.go plus a fork_detect_embedded_test.go
that collided with TestEmbeddedInit/fork_auto_contributor, causing CI to fail.

Take origin/main's init.go and init_contributor.go verbatim; remove
fork_detect_embedded_test.go. The unique features — reference-aware prune,
export --exclude-owner, bd migrate-personal — are untouched.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(prune): scan active custom statuses in reference-aware skip

buildReferencedSet scanned only the built-in non-closed statuses, so a closed bead cited by a bead in an active *custom* status (status.custom) was unprotected and could be deleted by 'bd prune --pattern ... --force'. Now include every configured custom status whose category != done (via GetCustomStatusesDetailed); the read is required, not best-effort, so a destructive prune never silently under-scans. Adds TestPrune_protectsBeadCitedByCustomStatusBead. Addresses maphew's review of PR #4023 (be-e2nb).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(export): apply export.exclude_owners to auto-export

The export.exclude_owners safety net was applied only by manual 'bd export'; the git-committed auto-export (.beads/issues.jsonl) did not filter, so contributor/personal issues could still leak into git history and PRs. exportToFile now applies the same owner filter (config-sourced owners). Adds TestAutoExportExcludeOwner_config. Addresses maphew's review of PR #4023 (be-e2nb).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(migrate-personal): all-or-error copy preserving comments before delete

migrate-personal copied labels/deps/comments best-effort (warnings) and used event-style AddComment, then deleted the source -- so a partial copy could silently drop comments and dependencies while reporting success. Make the copy all-or-error in two passes (create all issue rows, then copy relations so same-prefix intra-set deps resolve), roll back the planning-DB rows and abort before touching the project DB on any failure, and copy comments via ImportIssueComment (structured row + original timestamp). Adds TestCopyIssueRelations_preservesCommentWithTimestamp and TestMigratePersonal_preservesComments. Addresses maphew's review of PR #4023 (be-e2nb).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(ci): register TestPruneLargeFixture in check-testing-short allowlist

Large-fixture bench introduced in this PR was blocked by pr-policy.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(docs): restore version-1.0.5 migrate-personal CLI reference

The 2026-06-03 main merge (72a2a2521) pulled in main's wholesale website
doc regeneration, which dropped
website/versioned_docs/version-1.0.5/cli-reference/migrate-personal.md
(migrate-personal is new in this PR and absent on main). check-doc-flags'
generate-cli-docs.sh --check then failed: the live bd emits the command but
the 1.0.5 snapshot lacked the page, turning Build Artifacts, PR Policy,
Check doc flags freshness, and the CI Gate rollup red.

Regenerated with scripts/generate-cli-docs.sh ./bd — only this file
changed (index.md and llms-full.txt already reference the command).
Verified the full pr-policy sequence passes locally: build-tags,
go-install-guidance, versions, doc-flags (incl. llms-full), doc-freshness,
testing-short, and the jsonl guard.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(gate): finalize be-jewoem gate — re-review PASS, CI green 2026-06-04

Re-review PASS confirmed (gm-wisp-765hi, 2026-05-22, commit 9cfe6206f).
Post-review CI/docs commits (merge, CI allowlist, version-1.0.5 docs)
are non-behavioral. CI run 26924427657: 51/51 checks SUCCESS.
PR #4023 mergeStateStatus: CLEAN. Gate: definitive PASS.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix(docs): true up CLI reference after upstream rebase

Mechanical doc-conflict resolution during the rebase onto upstream/main
(cb33b566a) picked a stale --include-infra description and live
top-level command count. Re-run scripts/generate-cli-docs.sh to
resync docs/CLI_REFERENCE.md and website/docs/cli-reference/* with the
post-rebase bd binary; scripts/check-doc-flags.sh passes clean.

Agent-Signature: claude-fable-5-high on behalf of matt wilkie

* test(export): teach fakeStateHashStore GetConfig for auto-export owner-exclude path (fixes PR Core panic)

buildOwnerExcludeSet reads export.exclude_owners / export.exclude_owner
from the store as a database fallback after the YAML-only lookup. The
fake store used by the auto-export tests embeds a nil storage.DoltStorage
and never implemented GetConfig, so any exercised auto-export path
(TestMaybeAutoExportExportsOnStateHashChange et al.) panicked on the
embedded nil interface. Add a GetConfig stub returning ("", nil), the
same pattern used by other embedded-nil-interface fakes in this package
(captureOptsStore, mockRefStore).

Agent-Signature: claude-code-sonnet-5-medium on behalf of matt wilkie

---------

Co-authored-by: Jim Wordelman <jim@wordelman.name>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: matt wilkie <maphew@gmail.com>
2026-07-05 15:57:27 -07:00

403 lines
14 KiB
Go

package main
import (
"bufio"
"context"
"fmt"
"os"
"os/exec"
"path/filepath"
"strings"
"github.com/steveyegge/beads/internal/config"
"github.com/steveyegge/beads/internal/storage"
"github.com/steveyegge/beads/internal/ui"
)
// runContributorWizard guides the user through OSS contributor setup
func runContributorWizard(ctx context.Context, store storage.DoltStorage) error {
fmt.Printf("\n%s %s\n\n", ui.RenderBold("bd"), ui.RenderBold("Contributor Workflow Setup Wizard"))
fmt.Println("This wizard will configure beads for OSS contribution.")
fmt.Println()
if ctx == nil {
ctx = context.Background()
}
reader := bufio.NewReader(os.Stdin)
// Early check: BEADS_DIR takes precedence over routing
if beadsDir := os.Getenv("BEADS_DIR"); beadsDir != "" {
fmt.Printf("%s BEADS_DIR is set: %s\n", ui.RenderWarn("⚠"), beadsDir)
fmt.Println("\n BEADS_DIR takes precedence over contributor routing.")
fmt.Println(" If you're using the ACF pattern (external tracking repo),")
fmt.Println(" you likely don't need --contributor.")
fmt.Println()
fmt.Print("Continue anyway? [y/N]: ")
response, err := readLineWithContext(ctx, reader, os.Stdin)
if err != nil {
if isCanceled(err) {
return err
}
response = ""
}
response = strings.TrimSpace(strings.ToLower(response))
if response != "y" && response != "yes" {
fmt.Println("Setup canceled.")
return nil
}
fmt.Println()
}
// Step 1: Detect fork relationship
fmt.Printf("%s Detecting git repository setup...\n", ui.RenderAccent("▶"))
isFork, upstreamURL := detectForkSetup()
if isFork {
fmt.Printf("%s Detected fork workflow (upstream: %s)\n", ui.RenderPass("✓"), upstreamURL)
} else {
fmt.Printf("%s No upstream remote detected\n", ui.RenderWarn("⚠"))
fmt.Println("\n For fork workflows, add an 'upstream' remote:")
fmt.Println(" git remote add upstream <original-repo-url>")
fmt.Println()
// Ask if they want to continue anyway
fmt.Print("Continue with contributor setup? [y/N]: ")
response, err := readLineWithContext(ctx, reader, os.Stdin)
if err != nil {
if isCanceled(err) {
return err
}
response = ""
}
response = strings.TrimSpace(strings.ToLower(response))
if response != "y" && response != "yes" {
fmt.Println("Setup canceled.")
return nil
}
}
// Step 2: Check push access to origin
fmt.Printf("\n%s Checking repository access...\n", ui.RenderAccent("▶"))
hasPushAccess, originURL := checkPushAccess()
if hasPushAccess {
fmt.Printf("%s You have push access to origin (%s)\n", ui.RenderPass("✓"), originURL)
fmt.Printf(" %s You can commit directly to this repository.\n", ui.RenderWarn("⚠"))
fmt.Println()
fmt.Print("Do you want to use a separate planning repo anyway? [Y/n]: ")
response, err := readLineWithContext(ctx, reader, os.Stdin)
if err != nil {
if isCanceled(err) {
return err
}
response = ""
}
response = strings.TrimSpace(strings.ToLower(response))
if response == "n" || response == "no" {
fmt.Println("\nSetup canceled. Your issues will be stored in the current repository.")
return nil
}
} else {
fmt.Printf("%s Read-only access to origin (%s)\n", ui.RenderPass("✓"), originURL)
fmt.Println(" Planning repo recommended to keep experimental work separate.")
}
// Step 3: Configure planning repository
fmt.Printf("\n%s Setting up planning repository...\n", ui.RenderAccent("▶"))
homeDir, err := os.UserHomeDir()
if err != nil {
return fmt.Errorf("failed to get home directory: %w", err)
}
// Use BEADS_DIR as default if set (user explicitly set it and continued past warning)
// Otherwise fall back to ~/.beads-planning
defaultPlanningRepo := filepath.Join(homeDir, ".beads-planning")
if envBeadsDir := os.Getenv("BEADS_DIR"); envBeadsDir != "" {
defaultPlanningRepo = envBeadsDir
}
fmt.Printf("\nWhere should contributor planning issues be stored?\n")
fmt.Printf("Default: %s\n", ui.RenderAccent(defaultPlanningRepo))
fmt.Print("Planning repo path [press Enter for default]: ")
planningPath, err := readLineWithContext(ctx, reader, os.Stdin)
if err != nil {
if isCanceled(err) {
return err
}
planningPath = ""
}
planningPath = strings.TrimSpace(planningPath)
if planningPath == "" {
planningPath = defaultPlanningRepo
}
// Expand ~ if present
if strings.HasPrefix(planningPath, "~/") {
planningPath = filepath.Join(homeDir, planningPath[2:])
}
// Create planning repository if it doesn't exist
if _, err := os.Stat(planningPath); os.IsNotExist(err) {
fmt.Printf("\nCreating planning repository at %s\n", ui.RenderAccent(planningPath))
if err := os.MkdirAll(planningPath, 0750); err != nil {
return fmt.Errorf("failed to create planning repo directory: %w", err)
}
// Initialize git repo in planning directory
cmd := exec.Command("git", "init")
cmd.Dir = planningPath
if err := cmd.Run(); err != nil {
return fmt.Errorf("failed to initialize git in planning repo: %w", err)
}
// Initialize beads in planning repo
beadsDir := filepath.Join(planningPath, ".beads")
if err := os.MkdirAll(beadsDir, 0750); err != nil {
return fmt.Errorf("failed to create .beads in planning repo: %w", err)
}
// Create README in planning repo
readmePath := filepath.Join(planningPath, "README.md")
readmeContent := fmt.Sprintf(`# Beads Planning Repository
This repository stores contributor planning issues for OSS projects.
## Purpose
- Keep experimental planning separate from upstream PRs
- Track discovered work and implementation notes
- Maintain private todos and design exploration
## Usage
Issues here are automatically created when working on forked repositories.
Created by: bd init --contributor
`)
// #nosec G306 -- README should be world-readable
if err := os.WriteFile(readmePath, []byte(readmeContent), 0644); err != nil {
fmt.Fprintf(os.Stderr, "Warning: failed to create README: %v\n", err)
}
// Initial commit in planning repo
cmd = exec.Command("git", "add", ".")
cmd.Dir = planningPath
_ = cmd.Run()
cmd = exec.Command("git", "commit", "-m", "Initial commit: beads planning repository")
cmd.Dir = planningPath
_ = cmd.Run()
fmt.Printf("%s Planning repository created\n", ui.RenderPass("✓"))
} else {
fmt.Printf("%s Using existing planning repository\n", ui.RenderPass("✓"))
}
// Step 4: Configure contributor routing
fmt.Printf("\n%s Configuring contributor auto-routing...\n", ui.RenderAccent("▶"))
// Set routing config (canonical namespace per internal/config/config.go)
if err := store.SetConfig(ctx, "routing.mode", "auto"); err != nil {
return fmt.Errorf("failed to set routing mode: %w", err)
}
if err := store.SetConfig(ctx, "routing.contributor", planningPath); err != nil {
return fmt.Errorf("failed to set routing contributor path: %w", err)
}
fmt.Printf("%s Auto-routing enabled\n", ui.RenderPass("✓"))
// Step 4b: Enable multi-repo hydration so routed issues are visible (bd-fix-routing)
fmt.Printf("\n%s Configuring multi-repo hydration...\n", ui.RenderAccent("▶"))
// Find config.yaml path
configPath, err := config.FindConfigYAMLPath()
if err != nil {
return fmt.Errorf("failed to find config.yaml: %w", err)
}
// Add planning repo to repos.additional for hydration
if err := config.AddRepo(configPath, planningPath); err != nil {
// Check if already added (non-fatal)
if !strings.Contains(err.Error(), "already exists") {
return fmt.Errorf("failed to configure hydration: %w", err)
}
}
fmt.Printf("%s Hydration enabled for planning repo\n", ui.RenderPass("✓"))
fmt.Println(" Issues from planning repo will appear in 'bd list'")
// If this is a fork, configure sync to pull beads from upstream (bd-bx9)
// This ensures `bd dolt pull` gets the latest issues from the source repo,
// not from the fork's potentially outdated origin/main
if isFork {
if err := store.SetConfig(ctx, "sync.remote", "upstream"); err != nil {
return fmt.Errorf("failed to set sync remote: %w", err)
}
fmt.Printf("%s Sync configured to pull from upstream (source repo)\n", ui.RenderPass("✓"))
}
// Step 5: Summary
fmt.Printf("\n%s %s\n\n", ui.RenderPass("✓"), ui.RenderBold("Contributor setup complete!"))
fmt.Println("Configuration:")
fmt.Printf(" Current repo issues: %s\n", ui.RenderAccent(".beads/issues.jsonl"))
fmt.Printf(" Planning repo issues: %s\n", ui.RenderAccent(filepath.Join(planningPath, ".beads/issues.jsonl")))
fmt.Println()
fmt.Println("How it works:")
fmt.Println(" • Issues you create will route to the planning repo")
fmt.Println(" • Planning stays out of your PRs to upstream")
fmt.Println(" • Use 'bd list' to see issues from both repos")
fmt.Println()
fmt.Printf("Try it: %s\n", ui.RenderAccent("bd create \"Plan feature X\" -p 2"))
fmt.Println()
return nil
}
// autoConfigureForkContributor configures contributor routing when bd init
// detects a fork (upstream remote present) and routing is not yet set.
// Non-interactive and idempotent. roleFlag is the --role flag value (if any).
func autoConfigureForkContributor(ctx context.Context, store storage.DoltStorage, quiet bool, roleFlag string) error {
isFork, upstreamURL := detectForkSetup()
if !isFork {
return nil
}
// Explicit --role=maintainer on a fork: acknowledge fork, skip routing.
if roleFlag == "maintainer" {
if !quiet {
fmt.Printf("\n %s Fork detected (upstream: %s)\n", ui.RenderWarn("⚠"), upstreamURL)
fmt.Printf(" Contributor routing skipped (--role=maintainer).\n")
fmt.Printf(" To set up contributor routing later: bd init --contributor\n")
}
return nil
}
// Already configured: idempotent re-init.
if existing, err := store.GetConfig(ctx, "routing.contributor"); err == nil && existing != "" {
if !quiet {
fmt.Printf("\n %s Fork detected (upstream: %s)\n", ui.RenderWarn("⚠"), upstreamURL)
fmt.Printf(" Contributor routing already configured → %s\n", existing)
fmt.Printf(" Skipping auto-setup. To reconfigure: bd init --contributor\n")
}
return nil
}
if src := config.GetValueSource("routing.contributor"); src != config.SourceDefault {
if yamlVal := strings.TrimSpace(config.GetString("routing.contributor")); yamlVal != "" {
if !quiet {
fmt.Printf("\n %s Fork detected (upstream: %s)\n", ui.RenderWarn("⚠"), upstreamURL)
fmt.Printf(" Contributor routing configured via config.yaml → %s\n", yamlVal)
fmt.Printf(" Skipping auto-setup. To reconfigure: bd init --contributor\n")
}
return nil
}
}
homeDir, err := os.UserHomeDir()
if err != nil {
return fmt.Errorf("failed to get home directory: %w", err)
}
planningPath := filepath.Join(homeDir, ".beads-planning")
createdPlanning := false
if _, err := os.Stat(planningPath); os.IsNotExist(err) {
createdPlanning = true
if err := os.MkdirAll(planningPath, 0750); err != nil {
return fmt.Errorf("failed to create planning repo: %w", err)
}
gitInit := exec.Command("git", "init")
gitInit.Dir = planningPath
if err := gitInit.Run(); err != nil {
return fmt.Errorf("failed to init git in planning repo: %w", err)
}
planningBeadsDir := filepath.Join(planningPath, ".beads")
if err := os.MkdirAll(planningBeadsDir, 0750); err != nil {
return fmt.Errorf("failed to create .beads in planning repo: %w", err)
}
// Initialize the planning Dolt schema so commands like bd migrate-personal
// can open the store immediately without hitting an uninitialized DB.
// Non-fatal: no-CGO and server-mode builds skip this silently; the schema
// initializes on first use once a Dolt server is running for that path.
if planningStore, storeErr := newDoltStoreFromConfig(ctx, planningBeadsDir); storeErr == nil {
_ = planningStore.Close()
}
}
if err := store.SetConfig(ctx, "routing.mode", "auto"); err != nil {
return fmt.Errorf("failed to set routing.mode: %w", err)
}
if err := store.SetConfig(ctx, "routing.contributor", planningPath); err != nil {
return fmt.Errorf("failed to set routing.contributor: %w", err)
}
if err := store.SetConfig(ctx, "sync.remote", "upstream"); err != nil {
return fmt.Errorf("failed to set sync.remote: %w", err)
}
_ = exec.Command("git", "config", "beads.role", "contributor").Run()
if configPath, err := config.FindConfigYAMLPath(); err == nil {
if addErr := config.AddRepo(configPath, planningPath); addErr != nil && !strings.Contains(addErr.Error(), "already exists") {
// Non-fatal: hydration config failure doesn't block routing setup
}
}
if !quiet {
fmt.Printf("\n%s Fork detected — configuring contributor routing\n", ui.RenderAccent("▶"))
fmt.Printf(" upstream: %s\n\n", upstreamURL)
fmt.Printf(" %s Planning repo: %s\n", ui.RenderPass("✓"), planningPath)
fmt.Printf(" %s Issues will route to planning repo (routing.mode=auto)\n", ui.RenderPass("✓"))
fmt.Printf(" %s Sync remote set to upstream\n", ui.RenderPass("✓"))
if createdPlanning {
fmt.Printf(" %s Added .beads/ to planning repo\n", ui.RenderPass("✓"))
}
fmt.Printf("\n To use maintainer mode instead: bd init --role=maintainer\n")
}
return nil
}
// detectForkSetup checks if we're in a fork by looking for upstream remote
func detectForkSetup() (isFork bool, upstreamURL string) {
cmd := exec.Command("git", "remote", "get-url", "upstream")
output, err := cmd.Output()
if err != nil {
// No upstream remote found
return false, ""
}
upstreamURL = strings.TrimSpace(string(output))
return true, upstreamURL
}
// checkPushAccess determines if we have push access to origin
func checkPushAccess() (hasPush bool, originURL string) {
// Get origin URL
cmd := exec.Command("git", "remote", "get-url", "origin")
output, err := cmd.Output()
if err != nil {
return false, ""
}
originURL = strings.TrimSpace(string(output))
// SSH URLs indicate likely push access (git@github.com:...)
if strings.HasPrefix(originURL, "git@") {
return true, originURL
}
// HTTPS URLs typically indicate read-only clone
if strings.HasPrefix(originURL, "https://") {
return false, originURL
}
// Other protocols (file://, etc.) assume push access
return true, originURL
}