* fix(workspace): align resolved workspace messaging and config lookup intent(workspace): pure worktrees and external BEADS_DIR setups should work without implying a local .beads directory is required decision(config): derive config repo roots from FindBeadsDir-backed workspace resolution instead of a local-only .beads walk constraint(workspace-detection): keep FindBeadsDir ordering and storage behavior unchanged while making bd where the primary diagnostic hint learned(testing): shared-server env and global .beads ignore rules can distort CGO suites, so regression coverage now normalizes those test paths * fix(bootstrap): align no-workspace JSON wording intent(bootstrap): machine-readable no-workspace output should match the resolved-workspace guidance used elsewhere on this branch decision(bootstrap-json): reuse the shared workspace error helpers through a dedicated payload builder so tests can lock the JSON contract constraint(review-loop): keep the bootstrap CLI flow unchanged outside the no-workspace JSON branch while adding a focused regression test * fix(where): allow no-workspace diagnostics without db (beads-9f74-5l1) intent(where): no-workspace guidance should point to a command that actually runs when workspace resolution fails decision(startup): treat top-level where as a no-db command so it reaches its own handler before database preflight constraint(where-tests): subprocess mode can change the exact hint text, so the regression test locks the JSON contract and stable guidance fragments instead * fix(bootstrap): restore bd where guidance for no-workspace output (beads-9f74-3c3) intent(bootstrap): no-workspace bootstrap guidance should match the resolved-workspace diagnostics introduced on this branch decision(no-workspace-hints): reuse the shared hint that mentions bd where instead of the bootstrap-specific fallback text constraint(bootstrap-tests): cover both the payload helper and subprocess CLI path so wording regressions are caught before release * fix(workspace): remove no-workspace .beads fallbacks (beads-9f74-gr1) intent(workspace-resolution): finish the GH#3124 follow-up for runtime paths that still fabricated local .beads state rejected(no-workspace-fallback): inventing ./ .beads paths outside an active workspace hid shared-worktree resolution and created stray files decision(setup-recipes): keep built-in bd setup recipes usable without a workspace but require an active workspace for custom recipe state constraint(worktree-support): completion and backup helpers still need to resolve shared main-repo workspaces from a git worktree * fix(config): skip no-workspace store init for store-free commands intent(config): review-fix-loop found no-workspace config commands should reach their own graceful paths instead of failing in PersistentPreRun decision(config-preflight): detect store-free config subcommands before DB synthesis so config.yaml, git-backed, and diagnostic flows can run without an opened store constraint(json-contract): keep bd config validate --json machine-readable on stdout once pre-run stops short-circuiting into low-level DB errors learned(config-preflight): the parent config command not being in noDbCommands leaked store init into show, validate, drift, apply, and yaml-only config helpers * fix(ci): restore init prefix normalization and formatting intent(ci): clear the current PR failures instead of leaving the branch blocked behind known red checks decision(init-prefix): normalize dotted prefixes before persisting issue_prefix so config, metadata.json, and Dolt database naming stay aligned for Julia-style repos constraint(fmt-check): CI runs gofmt over the whole repo, so the existing spacing drift in internal/jira/tracker_test.go had to be cleaned up on this branch to get a green run learned(ci): the latest main CI was already red on the same formatting file and the same embedded shard, so rebasing surfaced pre-existing blockers rather than introducing a new shard-only regression
688 lines
19 KiB
Go
688 lines
19 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
|
|
"github.com/spf13/cobra"
|
|
"github.com/steveyegge/beads/internal/beads"
|
|
"github.com/steveyegge/beads/internal/configfile"
|
|
"github.com/steveyegge/beads/internal/storage/dolt"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
"github.com/steveyegge/beads/internal/ui"
|
|
"github.com/steveyegge/beads/internal/utils"
|
|
)
|
|
|
|
var migrateCmd = &cobra.Command{
|
|
Use: "migrate",
|
|
GroupID: "maint",
|
|
Short: "Database migration commands",
|
|
Long: `Database migration and data transformation commands.
|
|
|
|
Without subcommand, checks and updates database metadata to current version.
|
|
|
|
Subcommands:
|
|
hooks Plan git hook migration to marker-managed format
|
|
issues Move issues between repositories
|
|
sync Set up sync.branch workflow for multi-clone setups
|
|
`,
|
|
Run: func(cmd *cobra.Command, _ []string) {
|
|
autoYes, _ := cmd.Flags().GetBool("yes")
|
|
dryRun, _ := cmd.Flags().GetBool("dry-run")
|
|
updateRepoID, _ := cmd.Flags().GetBool("update-repo-id")
|
|
inspect, _ := cmd.Flags().GetBool("inspect")
|
|
|
|
// Block writes in readonly mode (migration modifies data, --inspect is read-only)
|
|
if !dryRun && !inspect {
|
|
CheckReadonly("migrate")
|
|
}
|
|
|
|
// Handle --update-repo-id first
|
|
if updateRepoID {
|
|
handleUpdateRepoID(dryRun, autoYes)
|
|
return
|
|
}
|
|
|
|
// Handle --inspect flag (show migration plan for AI agents)
|
|
if inspect {
|
|
handleInspect()
|
|
return
|
|
}
|
|
|
|
// Find .beads directory
|
|
beadsDir := beads.FindBeadsDir()
|
|
if beadsDir == "" {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "no_beads_directory",
|
|
"message": activeWorkspaceNotFoundMessage() + " " + diagHint() + ".",
|
|
})
|
|
os.Exit(1)
|
|
} else {
|
|
FatalErrorWithHint(activeWorkspaceNotFoundError(), diagHint())
|
|
}
|
|
}
|
|
|
|
// Load config
|
|
cfg, err := loadOrCreateConfig(beadsDir)
|
|
if err != nil {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "config_load_failed",
|
|
"message": err.Error(),
|
|
})
|
|
os.Exit(1)
|
|
}
|
|
FatalError("failed to load config: %v", err)
|
|
}
|
|
|
|
// Handle Dolt metadata update
|
|
handleDoltMetadataUpdate(cfg, dryRun)
|
|
},
|
|
}
|
|
|
|
// handleDoltMetadataUpdate handles version metadata updates for Dolt backends.
|
|
func handleDoltMetadataUpdate(cfg *configfile.Config, dryRun bool) {
|
|
ctx := rootCtx
|
|
store := getStore()
|
|
if store == nil {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"status": "no_databases",
|
|
"message": "No Dolt database found in .beads/",
|
|
})
|
|
} else {
|
|
fmt.Fprintf(os.Stderr, "No Dolt database found. Run 'bd init' to create a new database.\n")
|
|
}
|
|
return
|
|
}
|
|
|
|
// Check current state of all metadata fields
|
|
currentVersion, _ := store.GetMetadata(ctx, "bd_version")
|
|
currentRepoID, _ := store.GetMetadata(ctx, "repo_id")
|
|
currentCloneID, _ := store.GetMetadata(ctx, "clone_id")
|
|
|
|
needsVersionUpdate := currentVersion != Version
|
|
needsRepoID := currentRepoID == ""
|
|
needsCloneID := currentCloneID == ""
|
|
|
|
// If everything is already current, return early
|
|
if !needsVersionUpdate && !needsRepoID && !needsCloneID {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"status": "current",
|
|
"message": fmt.Sprintf("Dolt database already at version %s", Version),
|
|
})
|
|
} else {
|
|
fmt.Printf("Dolt database version: %s\n", currentVersion)
|
|
fmt.Printf("%s\n", ui.RenderPass("✓ Version matches"))
|
|
fmt.Printf("%s\n", ui.RenderPass("✓ All metadata fields present"))
|
|
}
|
|
return
|
|
}
|
|
|
|
if dryRun {
|
|
dryRunResult := map[string]interface{}{
|
|
"dry_run": true,
|
|
"needs_version_update": needsVersionUpdate,
|
|
"needs_repo_id": needsRepoID,
|
|
"needs_clone_id": needsCloneID,
|
|
}
|
|
if needsVersionUpdate {
|
|
dryRunResult["current_version"] = currentVersion
|
|
dryRunResult["target_version"] = Version
|
|
}
|
|
if jsonOutput {
|
|
outputJSON(dryRunResult)
|
|
} else {
|
|
fmt.Println("Dry run mode - no changes will be made")
|
|
if needsVersionUpdate {
|
|
fmt.Printf("Would update Dolt version: %s → %s\n", currentVersion, Version)
|
|
}
|
|
if needsRepoID {
|
|
fmt.Println("Would set repo_id")
|
|
}
|
|
if needsCloneID {
|
|
fmt.Println("Would set clone_id")
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
versionUpdated := false
|
|
repoIDSet := false
|
|
cloneIDSet := false
|
|
|
|
// Update bd_version if needed
|
|
if needsVersionUpdate {
|
|
if !jsonOutput {
|
|
fmt.Printf("Updating Dolt schema version: %s → %s\n", currentVersion, Version)
|
|
}
|
|
|
|
// Detect and set issue_prefix if missing
|
|
prefix, err := store.GetConfig(ctx, "issue_prefix")
|
|
if err != nil || prefix == "" {
|
|
issues, err := store.SearchIssues(ctx, "", types.IssueFilter{})
|
|
if err == nil && len(issues) > 0 {
|
|
detectedPrefix := utils.ExtractIssuePrefix(issues[0].ID)
|
|
if detectedPrefix != "" {
|
|
if err := store.SetConfig(ctx, "issue_prefix", detectedPrefix); err != nil {
|
|
if !jsonOutput {
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to set issue prefix: %v\n", err)
|
|
}
|
|
} else if !jsonOutput {
|
|
fmt.Printf("%s\n", ui.RenderPass(fmt.Sprintf("✓ Detected and set issue prefix: %s", detectedPrefix)))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Update version metadata (fatal on failure — version is critical)
|
|
if err := store.SetMetadata(ctx, "bd_version", Version); err != nil {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "version_update_failed",
|
|
"message": err.Error(),
|
|
})
|
|
os.Exit(1)
|
|
}
|
|
FatalError("failed to update version: %v", err)
|
|
}
|
|
versionUpdated = true
|
|
|
|
if !jsonOutput {
|
|
fmt.Printf("%s\n", ui.RenderPass("✓ Version updated"))
|
|
}
|
|
}
|
|
|
|
// Set repo_id if missing (non-fatal — may fail in non-git environments)
|
|
if needsRepoID {
|
|
computed, err := beads.ComputeRepoID()
|
|
if err != nil {
|
|
if !jsonOutput {
|
|
fmt.Fprintf(os.Stderr, "Warning: could not compute repo_id: %v\n", err)
|
|
}
|
|
} else {
|
|
if err := store.SetMetadata(ctx, "repo_id", computed); err != nil {
|
|
if !jsonOutput {
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to set repo_id: %v\n", err)
|
|
}
|
|
} else {
|
|
repoIDSet = true
|
|
if !jsonOutput {
|
|
fmt.Printf("%s\n", ui.RenderPass(fmt.Sprintf("✓ Set repo_id: %s", truncateID(computed, 8))))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set clone_id if missing (non-fatal — may fail in non-git environments)
|
|
if needsCloneID {
|
|
computed, err := beads.GetCloneID()
|
|
if err != nil {
|
|
if !jsonOutput {
|
|
fmt.Fprintf(os.Stderr, "Warning: could not compute clone_id: %v\n", err)
|
|
}
|
|
} else {
|
|
if err := store.SetMetadata(ctx, "clone_id", computed); err != nil {
|
|
if !jsonOutput {
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to set clone_id: %v\n", err)
|
|
}
|
|
} else {
|
|
cloneIDSet = true
|
|
if !jsonOutput {
|
|
fmt.Printf("%s\n", ui.RenderPass(fmt.Sprintf("✓ Set clone_id: %s", truncateID(computed, 8))))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"status": "success",
|
|
"current_database": cfg.Database,
|
|
"backend": "dolt",
|
|
"version": Version,
|
|
"version_updated": versionUpdated,
|
|
"repo_id_set": repoIDSet,
|
|
"clone_id_set": cloneIDSet,
|
|
})
|
|
} else {
|
|
fmt.Printf("\nDolt database: %s (version %s)\n", cfg.Database, Version)
|
|
}
|
|
|
|
// Embedded mode: flush Dolt commit after metadata writes.
|
|
if isEmbeddedMode() && (versionUpdated || repoIDSet || cloneIDSet) && store != nil {
|
|
if _, err := store.CommitPending(ctx, "migrate"); err != nil {
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to commit: %v\n", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// truncateID safely truncates an ID string to maxLen characters.
|
|
func truncateID(id string, maxLen int) string {
|
|
if len(id) <= maxLen {
|
|
return id
|
|
}
|
|
return id[:maxLen]
|
|
}
|
|
|
|
// loadOrCreateConfig loads metadata.json or creates default if not found
|
|
func loadOrCreateConfig(beadsDir string) (*configfile.Config, error) {
|
|
cfg, err := configfile.Load(beadsDir)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Create default if no config exists
|
|
if cfg == nil {
|
|
cfg = configfile.DefaultConfig()
|
|
}
|
|
|
|
return cfg, nil
|
|
}
|
|
|
|
func handleUpdateRepoID(dryRun bool, autoYes bool) {
|
|
// Find .beads directory
|
|
beadsDir := beads.FindBeadsDir()
|
|
if beadsDir == "" {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "no_database",
|
|
"message": "No beads database found. " + diagHint() + ".",
|
|
})
|
|
os.Exit(1)
|
|
}
|
|
FatalErrorWithHint("no beads database found", diagHint())
|
|
}
|
|
|
|
// Compute new repo ID
|
|
newRepoID, err := beads.ComputeRepoID()
|
|
if err != nil {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "compute_failed",
|
|
"message": err.Error(),
|
|
})
|
|
os.Exit(1)
|
|
}
|
|
FatalError("failed to compute repository ID: %v", err)
|
|
}
|
|
|
|
store := getStore()
|
|
if store == nil {
|
|
FatalError("no database — run 'bd init' first")
|
|
}
|
|
|
|
// Get old repo ID
|
|
ctx := rootCtx
|
|
oldRepoID, err := store.GetMetadata(ctx, "repo_id")
|
|
if err != nil && err.Error() != "metadata key not found: repo_id" {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "read_failed",
|
|
"message": err.Error(),
|
|
})
|
|
os.Exit(1)
|
|
}
|
|
FatalError("failed to read repo_id: %v", err)
|
|
}
|
|
|
|
oldDisplay := "none"
|
|
if len(oldRepoID) >= 8 {
|
|
oldDisplay = oldRepoID[:8]
|
|
}
|
|
|
|
if dryRun {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"dry_run": true,
|
|
"old_repo_id": oldDisplay,
|
|
"new_repo_id": truncateID(newRepoID, 8),
|
|
})
|
|
} else {
|
|
fmt.Println("Dry run mode - no changes will be made")
|
|
fmt.Printf("Would update repository ID:\n")
|
|
fmt.Printf(" Old: %s\n", oldDisplay)
|
|
fmt.Printf(" New: %s\n", truncateID(newRepoID, 8))
|
|
}
|
|
return
|
|
}
|
|
|
|
// Prompt for confirmation if repo_id exists and differs
|
|
if oldRepoID != "" && oldRepoID != newRepoID && !autoYes && !jsonOutput {
|
|
fmt.Printf("WARNING: Changing repository ID can break sync if other clones exist.\n\n")
|
|
fmt.Printf("Current repo ID: %s\n", oldDisplay)
|
|
fmt.Printf("New repo ID: %s\n\n", truncateID(newRepoID, 8))
|
|
fmt.Printf("Continue? [y/N] ")
|
|
var response string
|
|
_, _ = fmt.Scanln(&response)
|
|
if strings.ToLower(response) != "y" && strings.ToLower(response) != "yes" {
|
|
fmt.Println("Canceled")
|
|
return
|
|
}
|
|
}
|
|
|
|
// Update repo ID
|
|
if err := store.SetMetadata(ctx, "repo_id", newRepoID); err != nil {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "update_failed",
|
|
"message": err.Error(),
|
|
})
|
|
os.Exit(1)
|
|
}
|
|
FatalError("failed to update repo_id: %v", err)
|
|
}
|
|
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"status": "success",
|
|
"old_repo_id": oldDisplay,
|
|
"new_repo_id": truncateID(newRepoID, 8),
|
|
})
|
|
} else {
|
|
fmt.Printf("%s\n\n", ui.RenderPass("✓ Repository ID updated"))
|
|
fmt.Printf(" Old: %s\n", oldDisplay)
|
|
fmt.Printf(" New: %s\n", truncateID(newRepoID, 8))
|
|
}
|
|
|
|
// Embedded mode: flush Dolt commit.
|
|
if isEmbeddedMode() && store != nil {
|
|
if _, err := store.CommitPending(rootCtx, "migrate"); err != nil {
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to commit: %v\n", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// handleInspect shows migration plan and database state for AI agent analysis
|
|
func handleInspect() {
|
|
// Find .beads directory
|
|
beadsDir := beads.FindBeadsDir()
|
|
if beadsDir == "" {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "no_beads_directory",
|
|
"message": activeWorkspaceNotFoundMessage() + " " + diagHint() + ".",
|
|
})
|
|
os.Exit(1)
|
|
}
|
|
FatalErrorWithHint(activeWorkspaceNotFoundError(), diagHint())
|
|
}
|
|
|
|
// Check if database is available via the global store
|
|
dbExists := getStore() != nil
|
|
|
|
// If database doesn't exist, return inspection with defaults
|
|
if !dbExists {
|
|
result := map[string]interface{}{
|
|
"registered_migrations": listMigrations(),
|
|
"current_state": map[string]interface{}{
|
|
"schema_version": "missing",
|
|
"issue_count": 0,
|
|
"config": map[string]string{},
|
|
"missing_config": []string{},
|
|
"db_exists": false,
|
|
},
|
|
"warnings": []string{"Database does not exist - " + diagHint()},
|
|
"invariants_to_check": []string{},
|
|
}
|
|
|
|
if jsonOutput {
|
|
outputJSON(result)
|
|
} else {
|
|
fmt.Println("\nMigration Inspection")
|
|
fmt.Println("====================")
|
|
fmt.Println("Database: missing")
|
|
fmt.Println("\n⚠ Database does not exist - " + diagHint())
|
|
}
|
|
return
|
|
}
|
|
|
|
store := getStore()
|
|
if store == nil {
|
|
FatalError("no database — run 'bd init' first")
|
|
}
|
|
|
|
ctx := rootCtx
|
|
|
|
// Get current schema version
|
|
schemaVersion, err := store.GetMetadata(ctx, "bd_version")
|
|
if err != nil {
|
|
schemaVersion = "unknown"
|
|
}
|
|
|
|
// Get issue count
|
|
issueCount := 0
|
|
if stats, err := store.GetStatistics(ctx); err == nil {
|
|
issueCount = stats.TotalIssues
|
|
}
|
|
|
|
// Get config
|
|
configMap := make(map[string]string)
|
|
prefix, _ := store.GetConfig(ctx, "issue_prefix")
|
|
if prefix != "" {
|
|
configMap["issue_prefix"] = prefix
|
|
}
|
|
|
|
// Detect missing config
|
|
missingConfig := []string{}
|
|
if issueCount > 0 && prefix == "" {
|
|
missingConfig = append(missingConfig, "issue_prefix")
|
|
}
|
|
|
|
// Get registered migrations
|
|
registeredMigrations := listMigrations()
|
|
|
|
// Generate warnings
|
|
warnings := []string{}
|
|
if issueCount > 0 && prefix == "" {
|
|
detectedPrefix := ""
|
|
if issues, err := store.SearchIssues(ctx, "", types.IssueFilter{}); err == nil && len(issues) > 0 {
|
|
detectedPrefix = utils.ExtractIssuePrefix(issues[0].ID)
|
|
}
|
|
warnings = append(warnings, fmt.Sprintf("issue_prefix config not set - may break commands after migration (detected: %s)", detectedPrefix))
|
|
}
|
|
if schemaVersion != Version {
|
|
warnings = append(warnings, fmt.Sprintf("schema version mismatch (current: %s, expected: %s)", schemaVersion, Version))
|
|
}
|
|
|
|
// Output result
|
|
result := map[string]interface{}{
|
|
"registered_migrations": registeredMigrations,
|
|
"current_state": map[string]interface{}{
|
|
"schema_version": schemaVersion,
|
|
"issue_count": issueCount,
|
|
"config": configMap,
|
|
"missing_config": missingConfig,
|
|
"db_exists": true,
|
|
},
|
|
"warnings": warnings,
|
|
"invariants_to_check": []string{},
|
|
}
|
|
|
|
if jsonOutput {
|
|
outputJSON(result)
|
|
} else {
|
|
fmt.Println("\nMigration Inspection")
|
|
fmt.Println("====================")
|
|
fmt.Printf("Schema Version: %s\n", schemaVersion)
|
|
fmt.Printf("Issue Count: %d\n", issueCount)
|
|
fmt.Printf("Registered Migrations: %d\n", len(registeredMigrations))
|
|
|
|
if len(warnings) > 0 {
|
|
fmt.Println("\nWarnings:")
|
|
for _, w := range warnings {
|
|
fmt.Printf(" ⚠ %s\n", w)
|
|
}
|
|
}
|
|
|
|
if len(missingConfig) > 0 {
|
|
fmt.Println("\nMissing Config:")
|
|
for _, k := range missingConfig {
|
|
fmt.Printf(" - %s\n", k)
|
|
}
|
|
}
|
|
fmt.Println()
|
|
}
|
|
}
|
|
|
|
// handleToSeparateBranch configures separate branch workflow for existing repos
|
|
func handleToSeparateBranch(branch string, dryRun bool) {
|
|
// Validate branch name
|
|
b := strings.TrimSpace(branch)
|
|
if b == "" || strings.ContainsAny(b, " \t\n") {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "invalid_branch",
|
|
"message": "Branch name cannot be empty or contain whitespace",
|
|
})
|
|
os.Exit(1)
|
|
}
|
|
FatalErrorWithHint(fmt.Sprintf("invalid branch name '%s'", branch), "branch name cannot be empty or contain whitespace")
|
|
}
|
|
|
|
// Find .beads directory
|
|
beadsDir := beads.FindBeadsDir()
|
|
if beadsDir == "" {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "no_beads_directory",
|
|
"message": activeWorkspaceNotFoundMessage() + " " + diagHint() + ".",
|
|
})
|
|
os.Exit(1)
|
|
}
|
|
FatalErrorWithHint(activeWorkspaceNotFoundError(), diagHint())
|
|
}
|
|
|
|
store := getStore()
|
|
if store == nil {
|
|
FatalError("no database — run 'bd init' first")
|
|
}
|
|
|
|
// Get current sync.branch config
|
|
ctx := rootCtx
|
|
current, _ := store.GetConfig(ctx, "sync.branch")
|
|
|
|
// Dry-run mode
|
|
if dryRun {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"dry_run": true,
|
|
"previous": current,
|
|
"branch": b,
|
|
"changed": current != b,
|
|
})
|
|
} else {
|
|
fmt.Println("Dry run mode - no changes will be made")
|
|
if current == b {
|
|
fmt.Printf("sync.branch already set to '%s'\n", b)
|
|
} else {
|
|
fmt.Printf("Would set sync.branch: '%s' → '%s'\n", current, b)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Check if already set
|
|
if current == b {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"status": "noop",
|
|
"branch": b,
|
|
"message": "sync.branch already set to this value",
|
|
})
|
|
} else {
|
|
fmt.Printf("%s\n", ui.RenderPass(fmt.Sprintf("✓ sync.branch already set to '%s'", b)))
|
|
fmt.Println("No changes needed")
|
|
}
|
|
return
|
|
}
|
|
|
|
// Update sync.branch config
|
|
if err := store.SetConfig(ctx, "sync.branch", b); err != nil {
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"error": "config_update_failed",
|
|
"message": err.Error(),
|
|
})
|
|
os.Exit(1)
|
|
}
|
|
FatalError("failed to set sync.branch: %v", err)
|
|
}
|
|
|
|
// Success output
|
|
if jsonOutput {
|
|
outputJSON(map[string]interface{}{
|
|
"status": "success",
|
|
"previous": current,
|
|
"branch": b,
|
|
"message": "Enabled separate branch workflow",
|
|
})
|
|
} else {
|
|
fmt.Printf("%s\n\n", ui.RenderPass("✓ Enabled separate branch workflow"))
|
|
fmt.Printf("Set sync.branch to '%s'\n\n", b)
|
|
fmt.Println("Next steps:")
|
|
fmt.Println(" 1. No restart required. sync.branch is active immediately.")
|
|
fmt.Printf(" bd dolt push\n\n")
|
|
fmt.Println(" 2. Your existing data is preserved - no changes to git history")
|
|
fmt.Println(" 3. Future issue updates are stored in Dolt directly")
|
|
}
|
|
|
|
// Embedded mode: flush Dolt commit.
|
|
if isEmbeddedMode() && !dryRun && store != nil {
|
|
if _, commitErr := store.CommitPending(rootCtx, "migrate"); commitErr != nil {
|
|
fmt.Fprintf(os.Stderr, "Warning: failed to commit: %v\n", commitErr)
|
|
}
|
|
}
|
|
}
|
|
|
|
// listMigrations returns registered Dolt schema migrations.
|
|
func listMigrations() []string {
|
|
return dolt.ListCompatMigrations()
|
|
}
|
|
|
|
// migrateSyncCmd is the "bd migrate sync <branch>" subcommand that
|
|
// configures the separate-branch workflow for multi-clone setups.
|
|
// Previously this was documented but never wired as an actual subcommand,
|
|
// so bd doctor's recommendation to run "bd migrate sync beads-sync" would fail.
|
|
var migrateSyncCmd = &cobra.Command{
|
|
Use: "sync <branch>",
|
|
Short: "Set up sync.branch workflow for multi-clone setups",
|
|
Long: `Configure separate branch workflow for multi-clone setups.
|
|
|
|
This sets the sync.branch config value so that issue data is committed
|
|
to a dedicated branch, keeping your main branch clean.
|
|
|
|
Example:
|
|
bd migrate sync beads-sync`,
|
|
Args: cobra.ExactArgs(1),
|
|
Run: func(cmd *cobra.Command, args []string) {
|
|
dryRun, _ := cmd.Flags().GetBool("dry-run")
|
|
if !dryRun {
|
|
CheckReadonly("migrate sync")
|
|
}
|
|
handleToSeparateBranch(args[0], dryRun)
|
|
},
|
|
}
|
|
|
|
func init() {
|
|
migrateCmd.Flags().Bool("yes", false, "Auto-confirm prompts")
|
|
migrateCmd.Flags().Bool("dry-run", false, "Show what would be done without making changes")
|
|
migrateCmd.Flags().Bool("update-repo-id", false, "Update repository ID (use after changing git remote)")
|
|
migrateCmd.Flags().Bool("inspect", false, "Show migration plan and database state for AI agent analysis")
|
|
migrateCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output migration statistics in JSON format")
|
|
|
|
migrateSyncCmd.Flags().Bool("dry-run", false, "Show what would be done without making changes")
|
|
migrateSyncCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
|
|
migrateCmd.AddCommand(migrateSyncCmd)
|
|
|
|
migrateHooksCmd.Flags().Bool("dry-run", false, "Show what would be done without making changes")
|
|
migrateHooksCmd.Flags().Bool("apply", false, "Apply planned hook migration changes")
|
|
migrateHooksCmd.Flags().Bool("yes", false, "Skip confirmation prompt for --apply")
|
|
migrateHooksCmd.Flags().BoolVar(&jsonOutput, "json", false, "Output in JSON format")
|
|
migrateCmd.AddCommand(migrateHooksCmd)
|
|
|
|
rootCmd.AddCommand(migrateCmd)
|
|
}
|