package main import ( "context" "encoding/json" "errors" "fmt" "os" "path/filepath" "sort" "strings" "time" "github.com/spf13/cobra" "github.com/steveyegge/beads/internal/config" "github.com/steveyegge/beads/internal/configfile" "github.com/steveyegge/beads/internal/debug" "github.com/steveyegge/beads/internal/remotecache" "github.com/steveyegge/beads/internal/routing" "github.com/steveyegge/beads/internal/storage" "github.com/steveyegge/beads/internal/storage/dolt" "github.com/steveyegge/beads/internal/timeparsing" "github.com/steveyegge/beads/internal/types" "github.com/steveyegge/beads/internal/ui" "github.com/steveyegge/beads/internal/validation" ) var createCmd = &cobra.Command{ Use: "create [title]", GroupID: "issues", Aliases: []string{"new"}, Short: "Create a new issue (or batch from markdown/graph JSON)", Args: cobra.MinimumNArgs(0), // Changed to allow no args when using -f Run: func(cmd *cobra.Command, args []string) { CheckReadonly("create") file, _ := cmd.Flags().GetString("file") graphFile, _ := cmd.Flags().GetString("graph") // If file flag is provided, parse markdown and create multiple issues if file != "" { if graphFile != "" { FatalError("cannot specify both --file and --graph") } if len(args) > 0 { FatalError("cannot specify both title and --file flag") } // --dry-run not supported with --file (would need to parse and preview multiple issues) dryRun, _ := cmd.Flags().GetBool("dry-run") if dryRun { FatalError("--dry-run is not supported with --file flag") } createIssuesFromMarkdown(cmd, file) return } // If graph flag is provided, batch-create a graph of issues atomically if graphFile != "" { if len(args) > 0 { FatalError("cannot specify both title and --graph flag") } createIssuesFromGraph(graphFile) return } // Original single-issue creation logic // Get title from flag or positional argument titleFlag, _ := cmd.Flags().GetString("title") var title string if len(args) > 0 && titleFlag != "" { // Both provided - check if they match if args[0] != titleFlag { FatalError("cannot specify different titles as both positional argument and --title flag\n Positional: %q\n --title: %q", args[0], titleFlag) } title = args[0] // They're the same, use either } else if len(args) > 0 { // Guard: reject positional args that look like flags (bd-2c0). // When --help or other flags bypass Cobra's flag parsing (e.g., // programmatic invocation), they end up here as positional args. if strings.HasPrefix(args[0], "-") { FatalError("title %q looks like a flag (starts with '-').\n Run 'bd create --help' for available options.\n To use this title anyway, pass it explicitly: bd create --title=%q", args[0], args[0]) } title = args[0] } else if titleFlag != "" { title = titleFlag } else { FatalError("title required (or use --file to create from markdown)") } // Get silent flag silent, _ := cmd.Flags().GetBool("silent") // Warn if creating a test issue in a database with existing issues. // A brand-new repo with zero issues is not a "production database" (#2898). if isTestIssue(title) && !silent && !debug.IsQuiet() { if stats, err := store.GetStatistics(context.Background()); err == nil && stats != nil && stats.TotalIssues >= 5 { fmt.Fprintf(os.Stderr, "%s Creating test issue in production database\n", ui.RenderWarn("⚠")) fmt.Fprintf(os.Stderr, " Title: %q appears to be test data\n", title) fmt.Fprintf(os.Stderr, " Recommendation: Use isolated test database with --db\n") fmt.Fprintf(os.Stderr, " bd --db /tmp/test-beads create %q\n", title) } } // Get field values description, _ := getDescriptionFlag(cmd) skills, _ := cmd.Flags().GetString("skills") if skills != "" { if description != "" { description += "\n\n" } description += "## Required Skills\n" + skills } ctxStr, _ := cmd.Flags().GetString("context") if ctxStr != "" { if description != "" { description += "\n\n" } description += "## Context\n" + ctxStr } // Check if description is required by config if description == "" && !isTestIssue(title) { if config.GetBool("create.require-description") { FatalError("description is required (set create.require-description: false in config.yaml to disable)") } } design, _ := getDesignFlag(cmd) acceptance, _ := cmd.Flags().GetString("acceptance") notes, _ := cmd.Flags().GetString("notes") specID, _ := cmd.Flags().GetString("spec-id") // Parse priority (supports both "1" and "P1" formats) priorityStr, _ := cmd.Flags().GetString("priority") priority, err := validation.ValidatePriority(priorityStr) if err != nil { FatalError("%v", err) } issueType, _ := cmd.Flags().GetString("type") assignee, _ := cmd.Flags().GetString("assignee") labels, _ := cmd.Flags().GetStringSlice("labels") labelAlias, _ := cmd.Flags().GetStringSlice("label") if len(labelAlias) > 0 { labels = append(labels, labelAlias...) } explicitID, _ := cmd.Flags().GetString("id") parentID, _ := cmd.Flags().GetString("parent") externalRef, _ := cmd.Flags().GetString("external-ref") deps, _ := cmd.Flags().GetStringSlice("deps") waitsFor, _ := cmd.Flags().GetString("waits-for") waitsForGate, _ := cmd.Flags().GetString("waits-for-gate") forceCreate, _ := cmd.Flags().GetBool("force") repoOverride, _ := cmd.Flags().GetString("repo") wisp, _ := cmd.Flags().GetBool("ephemeral") noHistory, _ := cmd.Flags().GetBool("no-history") if wisp && noHistory { FatalError("--ephemeral and --no-history are mutually exclusive") } molTypeStr, _ := cmd.Flags().GetString("mol-type") var molType types.MolType if molTypeStr != "" { molType = types.MolType(molTypeStr) if !molType.IsValid() { FatalError("invalid mol-type %q (must be swarm, patrol, or work)", molTypeStr) } } // Parse wisp type (TTL classification for ephemeral wisps) wispTypeStr, _ := cmd.Flags().GetString("wisp-type") var wispType types.WispType if wispTypeStr != "" { wispType = types.WispType(wispTypeStr) if !wispType.IsValid() { FatalError("invalid wisp-type %q (must be heartbeat, ping, patrol, gc_report, recovery, error, or escalation)", wispTypeStr) } } // Event-specific flags eventCategory, _ := cmd.Flags().GetString("event-category") eventActor, _ := cmd.Flags().GetString("event-actor") eventTarget, _ := cmd.Flags().GetString("event-target") eventPayload, _ := cmd.Flags().GetString("event-payload") // Validate event-specific flags require --type=event if (eventCategory != "" || eventActor != "" || eventTarget != "" || eventPayload != "") && issueType != "event" { FatalError("--event-category, --event-actor, --event-target, and --event-payload flags require --type=event") } // Parse --due flag (GH#820) // Uses layered parsing: compact duration → NLP → date-only → RFC3339 var dueAt *time.Time dueStr, _ := cmd.Flags().GetString("due") if dueStr != "" { t, err := timeparsing.ParseRelativeTime(dueStr, time.Now()) if err != nil { FatalError("invalid --due format %q. Examples: +6h, tomorrow, next monday, 2025-01-15", dueStr) } dueAt = &t } // Parse --defer flag (GH#820) var deferUntil *time.Time deferStr, _ := cmd.Flags().GetString("defer") if deferStr != "" { t, err := timeparsing.ParseRelativeTime(deferStr, time.Now()) if err != nil { FatalError("invalid --defer format %q. Examples: +1h, tomorrow, next monday, 2025-01-15", deferStr) } // Warn if defer date is in the past (user probably meant future) if t.Before(time.Now()) && !silent && !debug.IsQuiet() { fmt.Fprintf(os.Stderr, "%s Defer date %q is in the past. Issue will appear in bd ready immediately.\n", ui.RenderWarn("!"), t.Format("2006-01-02 15:04")) fmt.Fprintf(os.Stderr, " Did you mean a future date? Use --defer=+1h or --defer=tomorrow\n") } deferUntil = &t } // Parse --metadata flag (GH#1406) var metadata json.RawMessage if cmd.Flags().Changed("metadata") { metadataValue, _ := cmd.Flags().GetString("metadata") var metadataJSON string if strings.HasPrefix(metadataValue, "@") { filePath := metadataValue[1:] // #nosec G304 -- user explicitly provides file path via @file.json syntax data, err := os.ReadFile(filePath) if err != nil { FatalError("failed to read metadata file %s: %v", filePath, err) } metadataJSON = string(data) } else { metadataJSON = metadataValue } if !json.Valid([]byte(metadataJSON)) { FatalError("invalid JSON in --metadata: must be valid JSON") } metadata = json.RawMessage(metadataJSON) } // Validate template based on --validate flag or config // Uses LintIssue for field-aware validation: checks --acceptance field too (GH#2468 parity) validateTemplate, _ := cmd.Flags().GetBool("validate") validationMode := config.GetString("validation.on-create") if validateTemplate || validationMode == "error" || validationMode == "warn" { lintIssue := &types.Issue{ IssueType: types.IssueType(issueType).Normalize(), Description: description, AcceptanceCriteria: acceptance, } if err := validation.LintIssue(lintIssue); err != nil { if validateTemplate || validationMode == "error" { FatalError("%v", err) } // warn mode: print warning but proceed fmt.Fprintf(os.Stderr, "%s %v\n", ui.RenderWarn("⚠"), err) } } // Handle --dry-run flag (before --rig to ensure it works with cross-rig creation) dryRun, _ := cmd.Flags().GetBool("dry-run") if dryRun { previewIssue := buildCreateIssue(createIssueParams{ ID: explicitID, Title: title, Description: description, Design: design, AcceptanceCriteria: acceptance, Notes: notes, SpecID: specID, Priority: priority, IssueType: types.IssueType(issueType).Normalize(), Assignee: assignee, ExternalRef: externalRef, Ephemeral: wisp, NoHistory: noHistory, CreatedBy: getActorWithGit(), Owner: getOwner(), MolType: molType, WispType: wispType, DueAt: dueAt, DeferUntil: deferUntil, Metadata: metadata, EventKind: eventCategory, Actor: eventActor, Target: eventTarget, Payload: eventPayload, }) if jsonOutput { outputJSON(previewIssue) } else { renderCreateDryRunPreview(previewIssue, labels, deps) } return } // Get estimate if provided var estimatedMinutes *int if cmd.Flags().Changed("estimate") { est, _ := cmd.Flags().GetInt("estimate") if est < 0 { FatalError("estimate must be a non-negative number of minutes") } estimatedMinutes = &est } // Use global jsonOutput set by PersistentPreRun // Determine target repository using routing logic repoPath := "." // default to current directory if cmd.Flags().Changed("repo") { // Explicit --repo flag overrides auto-routing repoPath = repoOverride } else { // Auto-routing based on user role userRole, err := routing.DetectUserRole(".") if err != nil { debug.Logf("Warning: failed to detect user role: %v\n", err) } // Build routing config with backward compatibility for legacy contributor.* keys. // Prefer config.yaml values, but fall back to DB config values set by bd init --contributor. routingMode := getRoutingConfigValue(rootCtx, store, "routing.mode") contributorRepo := getRoutingConfigValue(rootCtx, store, "routing.contributor") // NFR-001: Backward compatibility - fall back to legacy contributor.* keys if routingMode == "" { if getRoutingConfigValue(rootCtx, store, "contributor.auto_route") == "true" { routingMode = "auto" } } if contributorRepo == "" { contributorRepo = getRoutingConfigValue(rootCtx, store, "contributor.planning_repo") } routingConfig := &routing.RoutingConfig{ Mode: routingMode, DefaultRepo: getRoutingConfigValue(rootCtx, store, "routing.default"), MaintainerRepo: getRoutingConfigValue(rootCtx, store, "routing.maintainer"), ContributorRepo: contributorRepo, ExplicitOverride: repoOverride, } repoPath = routing.DetermineTargetRepo(routingConfig, userRole, ".") } // Switch to target repo for multi-repo support (bd-6x6g) // When routing to a different repo, we use direct storage access var targetStore storage.DoltStorage var remoteCache *remotecache.Cache // non-nil when routing to a remote URL if repoPath != "." { if remotecache.IsRemoteURL(repoPath) { // Remote URL: pull into cache, open store, push explicitly after create var err error remoteCache, err = remotecache.DefaultCache() if err != nil { FatalError("failed to initialize remote cache: %v", err) } if _, err := remoteCache.Ensure(rootCtx, repoPath); err != nil { FatalError("failed to sync remote %s: %v", repoPath, err) } targetStore, err = remoteCache.OpenStore(rootCtx, repoPath, newDoltStoreFromConfig) if err != nil { FatalError("failed to open remote store: %v", err) } } else { targetBeadsDir := routing.ExpandPath(repoPath) debug.Logf("DEBUG: Routing to target repo: %s\n", targetBeadsDir) // Ensure target beads directory exists with prefix inheritance if err := ensureBeadsDirForPath(rootCtx, targetBeadsDir, store); err != nil { FatalError("failed to initialize target repo: %v", err) } // Open new store for target repo using factory to respect backend config targetBeadsDirPath := filepath.Join(targetBeadsDir, ".beads") var err error targetStore, err = newDoltStoreFromConfig(rootCtx, targetBeadsDirPath) if err != nil { FatalError("failed to open target store: %v", err) } } // Close the original store before replacing it (it won't be used anymore) // Note: We don't defer-close targetStore here because PersistentPostRun // will close whatever store is assigned to the global `store` variable. // This fixes the "database is closed" error during auto-flush (GH#routing-close-bug). if store != nil { _ = store.Close() // Best effort cleanup on error path } // Replace store for remainder of create operation. // Must use setStore to sync cmdCtx.Store — a bare `store = targetStore` // leaves cmdCtx.Store pointing at the closed original, which causes // "store is closed" in PostRun tip auto-commit (GH#tip-closed-bug). setStore(targetStore) } // Check for conflicting flags if explicitID != "" && parentID != "" { FatalError("cannot specify both --id and --parent flags") } // If parent is specified, generate child ID and optionally inherit labels var inheritedLabels []string if parentID != "" { ctx := rootCtx // Validate parent exists before generating child ID _, err := store.GetIssue(ctx, parentID) if err != nil { if errors.Is(err, storage.ErrNotFound) { FatalError("parent issue %s not found", parentID) } FatalError("failed to check parent issue: %v", err) } childID, err := store.GetNextChildID(ctx, parentID) if err != nil { FatalError("%v", err) } explicitID = childID // Set as explicit ID for the rest of the flow // Inherit parent labels unless --no-inherit-labels is set (GH#2100) noInheritLabels, _ := cmd.Flags().GetBool("no-inherit-labels") if !noInheritLabels { inheritedLabels, _ = store.GetLabels(ctx, parentID) } } // Validate explicit ID format if provided if explicitID != "" { // Basic format validation for all issue types. // Note: Orchestrator-specific agent ID validation (mayor, polecat, witness, etc.) // is handled by the orchestrator, not beads core. _, err := validation.ValidateIDFormat(explicitID) if err != nil { FatalError("%v", err) } // Validate prefix matches database prefix ctx := rootCtx // Get database prefix and allowed prefixes from config. // YAML config takes precedence over DB — in shared-server mode the DB // may belong to a different project (GH#2469). var dbPrefix, allowedPrefixes string if yamlPrefix := config.GetString("issue-prefix"); yamlPrefix != "" { dbPrefix = yamlPrefix } else { dbPrefix, _ = store.GetConfig(ctx, "issue_prefix") // Best effort: empty prefix is a valid fallback } allowedPrefixes, _ = store.GetConfig(ctx, "allowed_prefixes") // Best effort: empty means no prefix restriction // Use ValidateIDPrefixAllowed which handles multi-hyphen prefixes correctly (GH#1135) // This checks if the ID starts with an allowed prefix, rather than extracting // the prefix first (which can fail for IDs like "hq-cv-test" where "test" looks like a word) if err := validation.ValidateIDPrefixAllowed(explicitID, dbPrefix, allowedPrefixes, forceCreate); err != nil { FatalError("%v", err) } } issue := buildCreateIssue(createIssueParams{ ID: explicitID, Title: title, Description: description, Design: design, AcceptanceCriteria: acceptance, Notes: notes, SpecID: specID, Priority: priority, IssueType: types.IssueType(issueType).Normalize(), Assignee: assignee, ExternalRef: externalRef, EstimatedMinutes: estimatedMinutes, Ephemeral: wisp, NoHistory: noHistory, CreatedBy: getActorWithGit(), Owner: getOwner(), MolType: molType, WispType: wispType, EventKind: eventCategory, Actor: eventActor, Target: eventTarget, Payload: eventPayload, DueAt: dueAt, DeferUntil: deferUntil, Metadata: metadata, }) ctx := rootCtx // Check if any dependencies are discovered-from type // If so, inherit source_repo from the parent issue var discoveredFromParentID string for _, depSpec := range deps { depSpec = strings.TrimSpace(depSpec) if depSpec == "" { continue } var depType types.DependencyType var dependsOnID string if strings.Contains(depSpec, ":") { parts := strings.SplitN(depSpec, ":", 2) if len(parts) == 2 { depType = types.DependencyType(strings.TrimSpace(parts[0])) dependsOnID = strings.TrimSpace(parts[1]) if depType == types.DepDiscoveredFrom && dependsOnID != "" { discoveredFromParentID = dependsOnID break } } } } // If we found a discovered-from dependency, inherit source_repo from parent if discoveredFromParentID != "" { parentIssue, err := store.GetIssue(ctx, discoveredFromParentID) if err == nil && parentIssue.SourceRepo != "" { issue.SourceRepo = parentIssue.SourceRepo } // If error getting parent or parent has no source_repo, continue with default } if err := store.CreateIssue(ctx, issue, actor); err != nil { FatalError("%v", err) } // Track whether any post-create writes occurred. CreateIssue commits // the issue to Dolt internally, but subsequent AddDependency/AddLabel // calls only write to the working set. A follow-up Dolt commit is // needed to persist them (GH#2009). postCreateWrites := false // If parent was specified, add parent-child dependency if parentID != "" { dep := &types.Dependency{ IssueID: issue.ID, DependsOnID: parentID, Type: types.DepParentChild, } if err := store.AddDependency(ctx, dep, actor); err != nil { WarnError("failed to add parent-child dependency %s -> %s: %v", issue.ID, parentID, err) } else { postCreateWrites = true } } // Merge inherited parent labels with user-specified labels (GH#2100) if len(inheritedLabels) > 0 { seen := make(map[string]bool) for _, l := range labels { seen[l] = true } for _, l := range inheritedLabels { if !seen[l] { labels = append(labels, l) } } } // Add labels if specified for _, label := range labels { if err := store.AddLabel(ctx, issue.ID, label, actor); err != nil { WarnError("failed to add label %s: %v", label, err) } else { postCreateWrites = true } } // Add dependencies if specified (format: type:id or just id for default "blocks" type) for _, depSpec := range deps { depSpec = strings.TrimSpace(depSpec) if depSpec == "" { continue } var depType types.DependencyType var dependsOnID string swapDirection := false if strings.Contains(depSpec, ":") { parts := strings.SplitN(depSpec, ":", 2) if len(parts) != 2 { WarnError("invalid dependency format '%s', expected 'type:id' or 'id'", depSpec) continue } rawType := types.DependencyType(strings.TrimSpace(parts[0])) dependsOnID = strings.TrimSpace(parts[1]) switch rawType { case "depends-on", "blocked-by": // Alias: the new issue depends on the target. Store as a blocks edge. depType = types.DepBlocks case types.DepBlocks: // Explicit "blocks:X" means the new issue blocks X, so store X -> new issue. depType = types.DepBlocks swapDirection = true default: depType = rawType } } else { depType = types.DepBlocks dependsOnID = depSpec } if !depType.IsValid() { FatalErrorRespectJSON("invalid dependency type %q (must be non-empty, max 50 chars); valid types: %s", depType, createDepsAcceptedTypeList()) } if !depType.IsWellKnown() { FatalErrorRespectJSON("unknown dependency type %q; valid types: %s", depType, createDepsAcceptedTypeList()) } dep := &types.Dependency{ IssueID: issue.ID, DependsOnID: dependsOnID, Type: depType, } if swapDirection { dep.IssueID = dependsOnID dep.DependsOnID = issue.ID } if err := store.AddDependency(ctx, dep, actor); err != nil { WarnError("failed to add dependency %s -> %s: %v", issue.ID, dependsOnID, err) } else { postCreateWrites = true } } // Add waits-for dependency if specified if waitsFor != "" { // Validate gate type gate := waitsForGate if gate == "" { gate = types.WaitsForAllChildren } if gate != types.WaitsForAllChildren && gate != types.WaitsForAnyChildren { FatalError("invalid --waits-for-gate value '%s' (valid: all-children, any-children)", gate) } // Create metadata JSON meta := types.WaitsForMeta{ Gate: gate, } metaJSON, err := json.Marshal(meta) if err != nil { FatalError("failed to serialize waits-for metadata: %v", err) } dep := &types.Dependency{ IssueID: issue.ID, DependsOnID: waitsFor, Type: types.DepWaitsFor, Metadata: string(metaJSON), } if err := store.AddDependency(ctx, dep, actor); err != nil { WarnError("failed to add waits-for dependency %s -> %s: %v", issue.ID, waitsFor, err) } else { postCreateWrites = true } } // Commit to Dolt. In DoltStore mode, CreateIssue commits the issue // row internally, so only post-create metadata (deps, labels) needs // a separate commit. In EmbeddedDoltStore mode, CreateIssue writes // to the working set without a Dolt commit, so we always commit // everything together at the end. if isEmbeddedMode() || postCreateWrites { commitMsg := fmt.Sprintf("bd: create %s", issue.ID) if err := store.Commit(ctx, commitMsg); err != nil && !isDoltNothingToCommit(err) { WarnError("failed to commit: %v", err) } } // If issue was routed to a different repo, commit pending changes. // Push is NOT done here — periodic sync handles pushes to // DoltHub remotes. Per-create pushes caused 22GB of git-remote-cache // bloat with dozens of agents creating wisps constantly (hq-glw). if repoPath != "." && targetStore != nil { if err := targetStore.Commit(ctx, fmt.Sprintf("bd: create (auto-commit) by %s", actor)); err != nil && !isDoltNothingToCommit(err) { debug.Logf("warning: failed to commit routed repo: %v", err) } } // Push to remote if this was a remote-routed create. // Done explicitly (not via defer) because FatalError calls os.Exit, // which skips deferred functions. if remoteCache != nil { if pushErr := remoteCache.Push(rootCtx, repoPath); pushErr != nil { FatalError("failed to push to %s: %v\nThe issue was created locally but not synced to the remote.", repoPath, pushErr) } } if jsonOutput { outputJSON(issue) } else if silent { fmt.Println(issue.ID) } else { fmt.Printf("%s Created issue: %s\n", ui.RenderPass("✓"), formatFeedbackID(issue.ID, issue.Title)) fmt.Printf(" Priority: P%d\n", issue.Priority) fmt.Printf(" Status: %s\n", issue.Status) // Show tip after successful create (direct mode only) maybeShowTip(store) } // Track as last touched issue SetLastTouchedID(issue.ID) }, } type createIssueParams struct { ID string Title string Description string Design string AcceptanceCriteria string Notes string SpecID string Priority int IssueType types.IssueType Assignee string ExternalRef string EstimatedMinutes *int Ephemeral bool NoHistory bool CreatedBy string Owner string MolType types.MolType WispType types.WispType EventKind string Actor string Target string Payload string DueAt *time.Time DeferUntil *time.Time Metadata json.RawMessage } func buildCreateIssue(params createIssueParams) *types.Issue { var externalRefPtr *string if params.ExternalRef != "" { externalRefPtr = ¶ms.ExternalRef } return &types.Issue{ ID: params.ID, Title: params.Title, Description: params.Description, Design: params.Design, AcceptanceCriteria: params.AcceptanceCriteria, Notes: params.Notes, SpecID: params.SpecID, Status: types.StatusOpen, Priority: params.Priority, IssueType: params.IssueType, Assignee: params.Assignee, ExternalRef: externalRefPtr, EstimatedMinutes: params.EstimatedMinutes, Ephemeral: params.Ephemeral, NoHistory: params.NoHistory, CreatedBy: params.CreatedBy, Owner: params.Owner, MolType: params.MolType, WispType: params.WispType, EventKind: params.EventKind, Actor: params.Actor, Target: params.Target, Payload: params.Payload, DueAt: params.DueAt, DeferUntil: params.DeferUntil, Metadata: params.Metadata, } } func renderCreateDryRunPreview(issue *types.Issue, labels, deps []string) { idDisplay := issue.ID if idDisplay == "" { idDisplay = "(will be generated)" } fmt.Printf("%s [DRY RUN] Would create issue:\n", ui.RenderWarn("⚠")) fmt.Printf(" ID: %s\n", idDisplay) fmt.Printf(" Title: %s\n", issue.Title) fmt.Printf(" Type: %s\n", issue.IssueType) fmt.Printf(" Priority: P%d\n", issue.Priority) fmt.Printf(" Status: %s\n", issue.Status) if issue.Assignee != "" { fmt.Printf(" Assignee: %s\n", issue.Assignee) } if issue.Description != "" { fmt.Printf(" Description: %s\n", issue.Description) } if len(labels) > 0 { fmt.Printf(" Labels: %s\n", strings.Join(labels, ", ")) } if len(deps) > 0 { fmt.Printf(" Dependencies: %s\n", strings.Join(deps, ", ")) } if issue.EventKind != "" { fmt.Printf(" Event category: %s\n", issue.EventKind) } } func createDepsAcceptedTypeList() string { names := []string{"blocked-by", "depends-on"} for _, depType := range types.WellKnownDependencyTypes() { names = append(names, string(depType)) } sort.Strings(names) return strings.Join(names, ", ") } func init() { createCmd.Flags().StringP("file", "f", "", "Create multiple issues from markdown file") createCmd.Flags().String("graph", "", "Create a graph of issues with dependencies from JSON plan file") createCmd.Flags().String("title", "", "Issue title (alternative to positional argument)") createCmd.Flags().Bool("silent", false, "Output only the issue ID (for scripting)") createCmd.Flags().Bool("dry-run", false, "Preview what would be created without actually creating") registerPriorityFlag(createCmd, "2") createCmd.Flags().StringP("type", "t", "task", "Issue type (bug|feature|task|epic|chore|decision); custom types require types.custom config; aliases: enhancement/feat→feature, dec/adr→decision") registerCommonIssueFlags(createCmd) createCmd.Flags().String("spec-id", "", "Link to specification document") createCmd.Flags().StringSliceP("labels", "l", []string{}, "Labels (comma-separated)") createCmd.Flags().String("skills", "", "Required skills for this issue") createCmd.Flags().String("context", "", "Additional context for the issue") createCmd.Flags().StringSlice("label", []string{}, "Alias for --labels") _ = createCmd.Flags().MarkHidden("label") // Only fails if flag missing (caught in tests) createCmd.Flags().String("id", "", "Explicit issue ID (e.g., 'bd-42' for partitioning)") createCmd.Flags().String("parent", "", "Parent issue ID for hierarchical child (e.g., 'bd-a3f8e9')") createCmd.Flags().Bool("no-inherit-labels", false, "Don't inherit labels from parent issue") createCmd.Flags().StringSlice("deps", []string{}, "Dependencies in format 'type:id' or 'id' (e.g., 'discovered-from:bd-20,blocks:bd-15' or 'bd-20')") createCmd.Flags().String("waits-for", "", "Spawner issue ID to wait for (creates waits-for dependency for fanout gate)") createCmd.Flags().String("waits-for-gate", "all-children", "Gate type: all-children (wait for all) or any-children (wait for first)") createCmd.Flags().Bool("force", false, "Force creation even if prefix doesn't match database prefix") createCmd.Flags().String("repo", "", "Target repository for issue (overrides auto-routing)") createCmd.Flags().IntP("estimate", "e", 0, "Time estimate in minutes (e.g., 60 for 1 hour)") createCmd.Flags().Bool("ephemeral", false, "Create as ephemeral (short-lived, subject to TTL compaction)") createCmd.Flags().Bool("no-history", false, "Skip Dolt commit history without making GC-eligible (for permanent agent beads)") createCmd.Flags().String("mol-type", "", "Molecule type: swarm (multi-agent), patrol (recurring ops), work (default)") createCmd.Flags().String("wisp-type", "", "Wisp type for TTL-based compaction: heartbeat, ping, patrol, gc_report, recovery, error, escalation") createCmd.Flags().Bool("validate", false, "Validate description contains required sections for issue type") // Event-specific flags (only valid when --type=event) createCmd.Flags().String("event-category", "", "Event category (e.g., patrol.muted, agent.started) (requires --type=event)") createCmd.Flags().String("event-actor", "", "Entity URI who caused this event (requires --type=event)") createCmd.Flags().String("event-target", "", "Entity URI or bead ID affected (requires --type=event)") createCmd.Flags().String("event-payload", "", "Event-specific JSON data (requires --type=event)") // Time-based scheduling flags (GH#820) // Examples: // --due=+6h Due in 6 hours // --due=tomorrow Due tomorrow // --due="next monday" Due next Monday // --due=2025-01-15 Due on specific date // --defer=+1h Hidden from bd ready for 1 hour // --defer=tomorrow Hidden until tomorrow createCmd.Flags().String("due", "", "Due date/time. Formats: +6h, +1d, +2w, tomorrow, next monday, 2025-01-15") createCmd.Flags().String("defer", "", "Defer until date (issue hidden from bd ready until then). Same formats as --due") createCmd.Flags().String("metadata", "", "Set custom metadata (JSON string or @file.json to read from file)") // Note: --json flag is defined as a persistent flag in main.go, not here rootCmd.AddCommand(createCmd) } // formatTimeForRPC converts a *time.Time to RFC3339 string for RPC calls. // Returns empty string if t is nil, to distinguish "not set" from "set to zero". func formatTimeForRPC(t *time.Time) string { if t == nil { return "" } return t.Format(time.RFC3339) } // ensureBeadsDirForPath ensures a beads directory exists at the target path. // If the .beads directory doesn't exist, it creates it and initializes with // the same prefix as the source store (T010, T012: prefix inheritance). func ensureBeadsDirForPath(ctx context.Context, targetPath string, sourceStore storage.DoltStorage) error { beadsDir := filepath.Join(targetPath, ".beads") metadataPath := filepath.Join(beadsDir, "metadata.json") // Check if beads directory already exists with a Dolt database. // metadata.json is the canonical marker for an initialized beads dir. if _, err := os.Stat(metadataPath); err == nil { return nil } // Create .beads directory if err := os.MkdirAll(beadsDir, 0750); err != nil { return fmt.Errorf("cannot create .beads directory: %w", err) } // Initialize database via NewFromConfigWithOptions to respect Dolt config. // Set the prefix if source store has one (T012: prefix inheritance). if sourceStore != nil { sourcePrefix, err := sourceStore.GetConfig(ctx, "issue_prefix") if err == nil && sourcePrefix != "" { // Sanitize prefix for SQL database name (same as bd init). dbName := strings.ReplaceAll(sourcePrefix, "-", "_") // Open target store temporarily to set prefix. // Use newDoltStore with explicit config since the target .beads // directory was just created and has no metadata.json yet. tempStore, err := newDoltStore(ctx, &dolt.Config{ BeadsDir: beadsDir, Database: dbName, CreateIfMissing: true, }) if err != nil { return fmt.Errorf("failed to initialize target database: %w", err) } if err := tempStore.SetConfig(ctx, "issue_prefix", sourcePrefix); err != nil { _ = tempStore.Close() // Best effort cleanup on error path return fmt.Errorf("failed to set prefix in target store: %w", err) } if err := tempStore.Close(); err != nil { return fmt.Errorf("failed to close target store: %w", err) } // Write metadata.json so newDoltStoreFromConfig can find the // correct database name on subsequent opens (GH#2988). cfg := configfile.DefaultConfig() cfg.Backend = configfile.BackendDolt cfg.DoltDatabase = dbName cfg.DoltMode = configfile.DoltModeEmbedded cfg.ProjectID = configfile.GenerateProjectID() if err := cfg.Save(beadsDir); err != nil { return fmt.Errorf("failed to write metadata.json: %w", err) } } } return nil }