* fix(issueops): enforce the template read-only update guard on every leg
The refusal of an update to a template (validateIssueUpdatable) lived only
in cmd/bd as a pre-read, so PATCH /v0/beads/issues/{id}, batch:apply update
items and library callers of Lifecycle.Update / BatchApplier edited
templates that `bd update` refused.
It is now one role rule, storage issueops.AuthorizeTemplateUpdate, returning
*issueops.TemplateReadOnlyError (matches ErrTemplateReadOnly; the message is
the sentence bd always printed). It runs in the update's own transaction,
after the compare-and-set preconditions (a stale guard still reports the
mismatch), and no force flag waives it:
- ExecuteUpdate (dolt, embedded) and the uow Update and batch update legs;
- the batch apply metadata splice that finishes a create item stays
unguarded on both bodies (a template the request creates is not modified);
- httpapi maps it to 409 template_read_only on updateIssue and applyBatch
(spec x-bd-codes and descriptions updated, apigen regenerated) and the
client rebuilds the typed error.
UpdateRequest.AllowTemplate stands the guard down for one request: the
caller edits a template deliberately. bd label (add, remove, remove-prefix)
and bd set-state set it, so they keep editing templates on every route, as
on origin/main. Over HTTP it is the optional `allow_template` member of the
PATCH body, advertised by the issues.update.allowTemplate behavior token,
which also says the server enforces the guard. httpclient Lifecycle.Update
decides from the cached handshake before the dial: against a server without
the token (no guard, no member) it runs the same rule
(AuthorizeTemplateUpdate) on a pre-read and never sends allow_template, so a
new bd against an older bd serve still refuses template updates.
cmd/bd: bd update, bd assign and the proxied assign/tag drop their pre-read
and print the role's refusal with the same line and exit code.
Conformance: RunLifecycleUpdateRefusesATemplate,
RunLifecycleUpdateAllowTemplateEditsATemplate,
RunBatchApplyUpdateItemsRefuseATemplate and
RunBatchApplySplicesTheMetadataOfATemplateItCreates on dolt, embedded, uow
and http (the http splice case is parked: the v0 create item has no
is_template member), plus handler and CLI rendering tests, and
TestUpdateTemplateGuardAgainstAServerThatPredatesIt (new client, handshake
without the token: refused before the dial, allow_template not sent).
Skew note (CHANGELOG): an older bd label / bd set-state against a new server
cannot send allow_template and now gets 409 template_read_only on a template.
bd comment, note, priority and tag keep their CLI-only pre-read guard.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
* fix(issueops): scope template read-only docs to updates, test label stand-down
Review fixups for PR 7427 (adopt-pr review loop, iteration 1):
- Contract: the role guard covers updates, not every mutation. The
CHANGELOG headline, ErrTemplateReadOnly and CodeTemplateReadOnly now
say so, and "Not yet moved" names claim, reopen, :casMetadata and the
served addComment, which have no template check yet (a PATCH with
claim: true refuses a template that POST :claim still claims). Close
is #7425's. Follow-up: bd-jkp9v3.
- Skew: the CapIssuesUpdateAllowTemplate client fallback covers
updateIssue only. A batch update item gets no client-side check, so
through an older bd serve it still edits a template; the CHANGELOG
and both capability docs say so.
- Tests: a template row now goes through the CLI on both tiers
(TestEmbeddedLabelEditReports, TestProxiedServerLabelC). bd label add,
bd label remove --prefix and bd set-state edit it (AllowTemplate);
bd update --title and bd assign exit 1 with the template sentence and
leave it unchanged. Mutants: dropping AllowTemplate from label.go and
state.go reds the three edits on both tiers; disabling
AuthorizeTemplateUpdate reds update and assign on both tiers.
- Stale comments: runTagProxiedServer, applyUpdateProxiedOne,
proxiedUpdateTarget, UpdateFlags (five booleans, not four) and the
ItemUpdate notes in applyLabelEdit and bd label propagate's proxied
route (UpdateItem has no AllowTemplate).
Agent-Signature: claude-code-claude-opus-5-5-max on behalf of Julian Knutsen
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
1090 lines
42 KiB
Go
1090 lines
42 KiB
Go
// Package main implements the bd CLI label management commands.
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
|
|
"github.com/spf13/cobra"
|
|
"github.com/steveyegge/beads/internal/metrics"
|
|
"github.com/steveyegge/beads/internal/storage"
|
|
"github.com/steveyegge/beads/internal/types"
|
|
"github.com/steveyegge/beads/internal/ui"
|
|
"github.com/steveyegge/beads/internal/utils"
|
|
"github.com/steveyegge/beads/issueops"
|
|
)
|
|
|
|
var labelCmd = &cobra.Command{
|
|
Use: "label",
|
|
GroupID: "issues",
|
|
Short: "Manage issue labels",
|
|
}
|
|
|
|
// openIssueLifecycle hands back the guarded write role for whichever route this
|
|
// invocation is on, each through its own capability accessor. Neither branch
|
|
// opens a unit of work, names a use case or composes a transaction: the label
|
|
// edit is a patch, and the role is what applies it.
|
|
func openIssueLifecycle() (issueops.Lifecycle, error) {
|
|
if usesProxiedServer() {
|
|
return proxiedIssueLifecycle()
|
|
}
|
|
return store.IssueLifecycle()
|
|
}
|
|
|
|
// openIssueReader hands back the read role the same way. `bd label list` is a
|
|
// detail read whose answer is already hydrated — issueops.Reader.Get returns
|
|
// IssueDetails with Labels on it — so there is nothing here for a label-shaped
|
|
// read surface to add.
|
|
func openIssueReader() (issueops.Reader, error) {
|
|
if usesProxiedServer() {
|
|
return proxiedIssueReader()
|
|
}
|
|
return store.IssueReader()
|
|
}
|
|
|
|
// resolveLabelTarget turns one positional argument into the EXACT id the roles
|
|
// take, on whichever route this invocation is on.
|
|
//
|
|
// This is the ONE fork left in this command, and it is a fork over how a route
|
|
// REACHES the store rather than over what it does once it has an answer. The
|
|
// proxied arm is not a second policy: it is the same exact-then-wisp lookup
|
|
// internal/workapi already defines for every proxied front door, and its
|
|
// not-found is normalized to the same message shape.
|
|
func resolveLabelTarget(ctx context.Context, id string) (string, error) {
|
|
if usesProxiedServer() {
|
|
return resolveLabelTargetProxied(ctx, id)
|
|
}
|
|
return utils.ResolvePartialID(ctx, store, id)
|
|
}
|
|
|
|
// applyLabelEdit applies ONE label patch to each named issue through
|
|
// issueops.Lifecycle, and is the whole of what `bd label add` and
|
|
// `bd label remove` do differently.
|
|
//
|
|
// ONE CALL PER ISSUE, AND ONE PATCH PER CALL. Every label of the request goes
|
|
// into a single LabelPatch, so an N-issue, M-label edit is N calls rather than
|
|
// the N*M raw writes both routes used to make. The role is what makes that
|
|
// safe to say: LabelPatch applies Replace, then Add, then Remove, de-duplicates
|
|
// within an edit, drops an empty entry rather than storing it, and refuses an
|
|
// over-length label with ErrFieldTooLong before anything is written.
|
|
//
|
|
// The wisp plane needs no branch here. UpdateRequest.IssuePlaneOnly stays
|
|
// false, so the role resolves the plane INSIDE its own transaction and an
|
|
// ephemeral row's labels land in the ephemeral table — which is the four-way
|
|
// switch the proxied route used to hand-roll, and the one place a front door
|
|
// could put a wisp's label in the durable table by getting a boolean backwards.
|
|
//
|
|
// WHAT THE LOOP COSTS, stated in full because it is the one place this
|
|
// migration is not free. Both routes used to put the whole edit in ONE
|
|
// transaction — the direct one through transactHonoringAutoCommit, the proxied
|
|
// one through uow.RunTx — and a per-issue role call cannot. So for N issues:
|
|
//
|
|
// - N history entries where there was one, each naming its own issue;
|
|
// - under `--dolt-auto-commit on`, which is the DEFAULT, N Dolt version
|
|
// commits where the old transaction made one. Batch mode still makes zero,
|
|
// via issueOpsContext above, so the multiplication is only on the mode
|
|
// that was already committing per command;
|
|
// - a failure on the third id leaves the first two written, where the old
|
|
// shape rolled the good ones back with the bad one.
|
|
//
|
|
// PARTIAL APPLICATION IS ACCEPTABLE HERE, and that is an argument rather than
|
|
// a shrug. issueops.ApplyLabelPatch computes the TARGET SET and returns
|
|
// Changed false without writing when it equals the existing one, so an add and
|
|
// a remove are both idempotent: re-running the same command over the same ids
|
|
// is a no-op on the ids that already landed and does the remaining work on the
|
|
// ids that did not. A partial batch therefore CONVERGES on retry, which is the
|
|
// property that makes "landed some" a recoverable state rather than a
|
|
// corrupted one. It would not be acceptable for an edit whose replay is not
|
|
// the identity — which is exactly why this is stated here and not generalized.
|
|
//
|
|
// THE ATOMIC SHAPE IS EXPRESSIBLE ON THE FACADE ALREADY and is the named
|
|
// follow-up, not a vague later: issueops.BatchApplier.ApplyBatch takes one
|
|
// ItemUpdate per issue carrying this same IssuePatch, applies them in order and
|
|
// commits them together, so the N calls collapse back to one transaction and
|
|
// one history entry with no new role and no new request type. It is not in this
|
|
// slice because it needs a cmd/bd accessor of its own and because its end gate
|
|
// runs a hierarchy and cycle walk a label-only request has no use for. It also
|
|
// needs a template stand-down first: UpdateItem has no AllowTemplate, so an
|
|
// ItemUpdate refuses the templates this function edits today (bd-jkp9v3).
|
|
func applyLabelEdit(ctx context.Context, issueIDs []string, labels []string, operation string) error {
|
|
lifecycle, err := openIssueLifecycle()
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
// The role creates its Dolt version commit inside the storage layer, so
|
|
// `--dolt-auto-commit batch` cannot be honored by blanking a commit message
|
|
// the way transactHonoringAutoCommit did on the old direct route: it has to
|
|
// be said on the CONTEXT. This is the one thing a command loses by moving
|
|
// off the raw transaction, and issueOpsContext is where every other
|
|
// role-routed write says it.
|
|
ctx, err = issueOpsContext(ctx)
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
patch := issueops.IssuePatch{}
|
|
if operation == labelOperationRemoved {
|
|
patch.Labels.Remove = labels
|
|
} else {
|
|
patch.Labels.Add = labels
|
|
}
|
|
// WHICH LABELS ACTUALLY MOVED is what the report has to say (GH#5988).
|
|
// UpdateResult.Changed is one flag per issue, which answers it exactly
|
|
// for a single label; a multi-label edit that changed something also
|
|
// needs the pre-edit set to tell its moved labels from its no-ops, so
|
|
// only that case pays for a read.
|
|
//
|
|
// THAT PRE-EDIT SET IS READ OUTSIDE THE WRITE TRANSACTION, so per-label
|
|
// attribution on the multi-label path is best-effort: a concurrent edit
|
|
// landing between the read and the Update can misattribute one label's
|
|
// line. What it cannot do is write the wrong thing — the target set is
|
|
// recomputed from current.Labels inside the write transaction
|
|
// (issueops.ApplyLabelPatch), so the stored labels, the JSON shape and
|
|
// the exit code stay correct and the state converges. A single-label
|
|
// edit is immune by construction, deriving its outcome from the write's
|
|
// own transaction. The batch shape named above closes the window
|
|
// structurally by collapsing the read and the write into one
|
|
// transaction; it is not worth a second read protocol before then.
|
|
var reader issueops.Reader
|
|
if len(labels) > 1 {
|
|
if reader, err = openIssueReader(); err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
}
|
|
outcomes := make([]labelEditOutcome, 0, len(issueIDs))
|
|
for _, issueID := range issueIDs {
|
|
var before map[string]bool
|
|
if reader != nil {
|
|
details, gerr := reader.Get(ctx, issueops.GetRequest{ID: issueID})
|
|
if gerr != nil {
|
|
return HandleErrorRespectJSON("label %s: reading labels on %s: %v",
|
|
labelOperationGerund(operation), issueID, gerr)
|
|
}
|
|
before = make(map[string]bool, len(details.Labels))
|
|
for _, label := range details.Labels {
|
|
before[label] = true
|
|
}
|
|
}
|
|
result, uerr := lifecycle.Update(ctx, issueops.UpdateRequest{
|
|
Actor: currentActor(),
|
|
IssueID: issueID,
|
|
Patch: patch,
|
|
// bd label has always edited templates; the role's template
|
|
// guard stands down for it (issueops.UpdateRequest.AllowTemplate).
|
|
AllowTemplate: true,
|
|
})
|
|
if uerr != nil {
|
|
gerund := labelOperationGerund(operation)
|
|
return HandleErrorRespectJSON("label %s: %s label '%s' on %s: %v",
|
|
gerund, gerund, strings.Join(labels, "', '"), issueID, uerr)
|
|
}
|
|
// Marked per issue rather than once after the loop: the edits land one
|
|
// call at a time, so a request that failed on its third id has still
|
|
// written its first two and the deferred commit has to know about them.
|
|
commandDidWrite.Store(true)
|
|
outcome := labelEditOutcome{issueID: issueID, labels: labels, changed: make([]bool, len(labels))}
|
|
for i, label := range labels {
|
|
switch {
|
|
case !result.Changed:
|
|
// The role wrote nothing, so no label of this edit moved.
|
|
case before == nil:
|
|
outcome.changed[i] = true
|
|
case operation == labelOperationRemoved:
|
|
outcome.changed[i] = before[label]
|
|
default:
|
|
outcome.changed[i] = !before[label]
|
|
}
|
|
}
|
|
outcomes = append(outcomes, outcome)
|
|
}
|
|
return reportLabelEdit(outcomes, operation, jsonOutput)
|
|
}
|
|
|
|
// The two label edits this command performs, spelled once. They are the words
|
|
// the JSON "status" member and the human line both carry, so they are constants
|
|
// rather than two string literals that have to agree. labelStatusUnchanged is
|
|
// the status of a label the edit left as it was: an add of a label the issue
|
|
// already had, or a remove of one it never had.
|
|
const (
|
|
labelOperationAdded = "added"
|
|
labelOperationRemoved = "removed"
|
|
labelStatusUnchanged = "unchanged"
|
|
)
|
|
|
|
// labelEditOutcome is what one issue's edit did: labels is the set the edit
|
|
// named for THAT issue and changed[i] reports whether labels[i] actually
|
|
// moved. The label set is per issue rather than one shared slice because
|
|
// --prefix resolves a different set for each issue from its own current
|
|
// labels; applyLabelEdit's fixed caller-supplied set is the degenerate case
|
|
// where every outcome repeats it.
|
|
type labelEditOutcome struct {
|
|
issueID string
|
|
labels []string
|
|
changed []bool
|
|
}
|
|
|
|
// labelOperationGerund returns the present-participle form of a
|
|
// labelOperation* constant, for error messages on a failure path. The past
|
|
// tense constants above are correct on success (that's what happened) but
|
|
// read as a false success report when the same word appears next to a
|
|
// non-nil error — "label removed: ...: connection refused" claims the removal
|
|
// that in fact just failed.
|
|
func labelOperationGerund(operation string) string {
|
|
switch operation {
|
|
case labelOperationAdded:
|
|
return "adding"
|
|
case labelOperationRemoved:
|
|
return "removing"
|
|
default:
|
|
return operation
|
|
}
|
|
}
|
|
|
|
// reportLabelEdit prints what landed, in the shape both routes have always
|
|
// printed it: one JSON row per (issue, label) pair, or one human line per issue
|
|
// naming every label that moved. A label the edit left as it was is reported
|
|
// as such — status "unchanged", and a line of its own — rather than as the
|
|
// operation, so a no-op cannot be read as a confirmation (GH#5988). It is
|
|
// still not an error: the exit code stays 0 so idempotent callers keep working.
|
|
func reportLabelEdit(outcomes []labelEditOutcome, operation string, jsonOut bool) error {
|
|
if jsonOut {
|
|
// One row per (issue, label) pair; the hint is the one-label-per-issue
|
|
// floor rather than an exact count, since each outcome carries its own
|
|
// label set and append grows from there.
|
|
results := make([]map[string]interface{}, 0, len(outcomes))
|
|
for _, outcome := range outcomes {
|
|
for i, label := range outcome.labels {
|
|
status := operation
|
|
if !outcome.changed[i] {
|
|
status = labelStatusUnchanged
|
|
}
|
|
results = append(results, map[string]interface{}{
|
|
"status": status,
|
|
"issue_id": outcome.issueID,
|
|
"label": label,
|
|
})
|
|
}
|
|
}
|
|
return outputJSON(results)
|
|
}
|
|
verb, prep := "Added", "to"
|
|
if operation == labelOperationRemoved {
|
|
verb, prep = "Removed", "from"
|
|
}
|
|
for _, outcome := range outcomes {
|
|
var moved, unmoved []string
|
|
for i, label := range outcome.labels {
|
|
if outcome.changed[i] {
|
|
moved = append(moved, label)
|
|
} else {
|
|
unmoved = append(unmoved, label)
|
|
}
|
|
}
|
|
if len(moved) > 0 {
|
|
fmt.Printf("%s %s %s '%s' %s %s\n", ui.RenderPass("✓"), verb,
|
|
labelNoun(moved, "label", "labels"), strings.Join(moved, "', '"), prep, outcome.issueID)
|
|
}
|
|
if len(unmoved) == 0 {
|
|
continue
|
|
}
|
|
unmovedDesc := strings.Join(unmoved, "', '")
|
|
if operation == labelOperationRemoved {
|
|
fmt.Printf("%s %s '%s' %s not on %s\n", ui.RenderAccent("•"),
|
|
labelNoun(unmoved, "Label", "Labels"), unmovedDesc, labelNoun(unmoved, "was", "were"), outcome.issueID)
|
|
} else {
|
|
fmt.Printf("%s %s already has %s '%s'\n", ui.RenderAccent("•"),
|
|
outcome.issueID, labelNoun(unmoved, "label", "labels"), unmovedDesc)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// labelNoun picks the singular or plural word for a list of labels.
|
|
func labelNoun(labels []string, singular, plural string) string {
|
|
if len(labels) > 1 {
|
|
return plural
|
|
}
|
|
return singular
|
|
}
|
|
|
|
// removeLabelsByPrefix removes every label starting with prefix from each
|
|
// issue in issueIDs, through issueops.Lifecycle — the same role
|
|
// applyLabelEdit uses, so the events journal and both storage routes see this
|
|
// edit the same way they see a plain `label remove`. Unlike applyLabelEdit
|
|
// (which applies one fixed, caller-supplied label set to every issue), the
|
|
// label set here is resolved per-issue from that issue's current labels via
|
|
// issueops.Reader, since different issues may carry different prefix-matching
|
|
// labels — so the loop is one Get plus one Update per issue rather than one
|
|
// shared patch for all of them.
|
|
//
|
|
// The report goes through reportLabelEdit, the same handler the plain path
|
|
// uses, so a removal this call did not actually make is reported as
|
|
// "unchanged" rather than as a removal (GH#5988). Reimplementing the report
|
|
// here is what let the pre-review version of this function claim removals off
|
|
// its pre-read snapshot.
|
|
func removeLabelsByPrefix(ctx context.Context, issueIDs []string, prefix string, jsonOut bool) error {
|
|
reader, err := openIssueReader()
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
// Grouped per issue from the start: one LabelPatch.Remove applies every
|
|
// matching label for that issue in one Update, which is applyLabelEdit's
|
|
// "one call per issue, one patch per call" contract. issueIDs carries no
|
|
// duplicates (resolveIssueIDsForPrefix collapses them), so this is one Get
|
|
// and one Update per distinct issue named on the command line.
|
|
type prefixTarget struct {
|
|
issueID string
|
|
labels []string
|
|
}
|
|
var targets []prefixTarget
|
|
for _, issueID := range issueIDs {
|
|
details, gerr := reader.Get(ctx, issueops.GetRequest{ID: issueID})
|
|
if gerr != nil {
|
|
return HandleErrorRespectJSON("getting labels for %s: %v", issueID, gerr)
|
|
}
|
|
if matched := labelsWithPrefix(details.Labels, prefix); len(matched) > 0 {
|
|
targets = append(targets, prefixTarget{issueID: issueID, labels: matched})
|
|
}
|
|
}
|
|
if len(targets) == 0 {
|
|
if jsonOut {
|
|
return outputJSON([]map[string]interface{}{})
|
|
}
|
|
fmt.Printf("No labels matching prefix '%s' found\n", prefix)
|
|
return nil
|
|
}
|
|
|
|
lifecycle, err := openIssueLifecycle()
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
ctx, err = issueOpsContext(ctx)
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
outcomes := make([]labelEditOutcome, 0, len(targets))
|
|
for _, target := range targets {
|
|
result, uerr := lifecycle.Update(ctx, issueops.UpdateRequest{
|
|
Actor: currentActor(),
|
|
IssueID: target.issueID,
|
|
Patch: issueops.IssuePatch{Labels: issueops.LabelPatch{Remove: target.labels}},
|
|
// As above: bd label edits templates by design.
|
|
AllowTemplate: true,
|
|
})
|
|
if uerr != nil {
|
|
return HandleErrorRespectJSON("label removing (prefix): %s: %v", target.issueID, uerr)
|
|
}
|
|
commandDidWrite.Store(true)
|
|
// WHICH LABELS ACTUALLY MOVED, derived from the write rather than from
|
|
// the Get that chose them. Every label in target.labels was on the
|
|
// issue when it was read, so UpdateResult.Changed answers for the
|
|
// whole set at once: false means the role wrote nothing and none of
|
|
// them moved. Per-label attribution is best-effort for the reason
|
|
// applyLabelEdit states at length — the read is outside the write
|
|
// transaction — but the claim that cannot be made any more is
|
|
// "removed" for an edit that wrote nothing at all.
|
|
changed := make([]bool, len(target.labels))
|
|
for i := range changed {
|
|
changed[i] = result.Changed
|
|
}
|
|
outcomes = append(outcomes, labelEditOutcome{
|
|
issueID: target.issueID,
|
|
labels: target.labels,
|
|
changed: changed,
|
|
})
|
|
}
|
|
return reportLabelEdit(outcomes, labelOperationRemoved, jsonOut)
|
|
}
|
|
|
|
// parseLabelArgs splits positional args into issue IDs and labels. The final
|
|
// arg is the label spec; commas separate multiple labels ("label1,label2").
|
|
func parseLabelArgs(args []string) (issueIDs []string, labels []string) {
|
|
labels = splitLabelArg(args[len(args)-1])
|
|
issueIDs = args[:len(args)-1]
|
|
return
|
|
}
|
|
|
|
// splitLabelArg splits a comma-separated label argument into individual
|
|
// labels, trimming whitespace and dropping empty entries. Matches the
|
|
// comma-separated convention of bd create --labels.
|
|
func splitLabelArg(arg string) []string {
|
|
parts := strings.Split(arg, ",")
|
|
labels := make([]string, 0, len(parts))
|
|
for _, part := range parts {
|
|
if part = strings.TrimSpace(part); part != "" {
|
|
labels = append(labels, part)
|
|
}
|
|
}
|
|
return labels
|
|
}
|
|
|
|
// labelsWithPrefix returns the subset of labels whose name starts with
|
|
// prefix, preserving input order.
|
|
func labelsWithPrefix(labels []string, prefix string) []string {
|
|
var matched []string
|
|
for _, label := range labels {
|
|
if strings.HasPrefix(label, prefix) {
|
|
matched = append(matched, label)
|
|
}
|
|
}
|
|
return matched
|
|
}
|
|
|
|
// resolveLabelIssueIDs resolves every issue-ID positional arg to the EXACT id
|
|
// the role takes, failing hard on the first arg that doesn't resolve.
|
|
//
|
|
// Resolution stays a front-door job and does not move behind the role:
|
|
// GetRequest.ID and UpdateRequest.IssueID are both exact by contract, for the
|
|
// reason those docs give — an affordance that can resolve to a different issue
|
|
// than the caller named has no place on a contract two front doors share. This
|
|
// is therefore the ONE thing that still forks by route, and it forks on how a
|
|
// route reaches the store rather than on what it then does with the answer.
|
|
//
|
|
// Labels come last on the command line, so when several ID-position args fail
|
|
// the caller almost certainly passed labels space-separated ("bd label add
|
|
// bd-123 a b c"); the error hints at the comma-separated form instead of
|
|
// silently skipping the bad args (bd-vu5kv).
|
|
func resolveLabelIssueIDs(ctx context.Context, subcommand string, issueIDs []string) ([]string, error) {
|
|
resolved := make([]string, 0, len(issueIDs))
|
|
for _, id := range issueIDs {
|
|
fullID, err := resolveLabelTarget(ctx, id)
|
|
if err != nil {
|
|
if len(issueIDs) > 1 {
|
|
return nil, fmt.Errorf("resolving issue ID %q: %w (to %s multiple labels, pass one comma-separated argument: bd label %s <issue-id> label1,label2)",
|
|
id, err, subcommand, subcommand)
|
|
}
|
|
return nil, fmt.Errorf("resolving issue ID %q: %w", id, err)
|
|
}
|
|
resolved = append(resolved, fullID)
|
|
}
|
|
return resolved, nil
|
|
}
|
|
|
|
// resolveIssueIDsForPrefix resolves every positional arg to an issue ID for
|
|
// the --prefix form of `bd label remove`. Unlike the plain add/remove path,
|
|
// --prefix takes no trailing label argument — every positional is an issue
|
|
// ID — so a positional that fails to resolve is reported as a likely
|
|
// mixed-up label argument (e.g. a caller who reflexively kept the old
|
|
// trailing-label habit: `bd label remove bd-1 stale-label --prefix x`)
|
|
// rather than with resolveLabelIssueIDs' "pass one comma-separated argument"
|
|
// hint, which recommends exactly the label-argument syntax --prefix does not
|
|
// take and would only compound the confusion.
|
|
//
|
|
// That hint is SPECULATIVE, so it is gated on the same condition as the twin's:
|
|
// only a line carrying more than one positional can plausibly have ended with
|
|
// a stray label. A single positional that does not resolve is just a bad issue
|
|
// ID — usually a typo or a deleted issue — and blaming an argument mistake the
|
|
// caller did not make sends them looking for the wrong thing.
|
|
//
|
|
// Duplicate ids collapse. Two positionals naming the same issue (directly or
|
|
// through different resolvable forms) are one issue to remove labels from, and
|
|
// leaving the repeat in would make the caller pay a second Get and read a
|
|
// second report line for one edit.
|
|
func resolveIssueIDsForPrefix(ctx context.Context, issueIDs []string) ([]string, error) {
|
|
resolved := make([]string, 0, len(issueIDs))
|
|
seen := make(map[string]bool, len(issueIDs))
|
|
for _, id := range issueIDs {
|
|
fullID, err := resolveLabelTarget(ctx, id)
|
|
if err != nil {
|
|
if len(issueIDs) > 1 {
|
|
return nil, fmt.Errorf("cannot combine --prefix with label arguments: %q is not an issue ID: %w", id, err)
|
|
}
|
|
return nil, fmt.Errorf("resolving issue ID %q: %w", id, err)
|
|
}
|
|
if seen[fullID] {
|
|
continue
|
|
}
|
|
seen[fullID] = true
|
|
resolved = append(resolved, fullID)
|
|
}
|
|
return resolved, nil
|
|
}
|
|
|
|
//nolint:dupl // labelAddCmd and labelRemoveCmd are similar but serve different operations
|
|
var labelAddCmd = &cobra.Command{
|
|
Use: "add [issue-id...] [label[,label...]]",
|
|
Short: "Add one or more labels to one or more issues",
|
|
Long: "Add labels to issues. Issue IDs come first; the final argument is the label. Pass multiple labels comma-separated: bd label add bd-123 label1,label2",
|
|
Args: cobra.MinimumNArgs(2),
|
|
SilenceUsage: true,
|
|
SilenceErrors: true,
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
CheckReadonly("label add")
|
|
|
|
evt := metrics.NewCommandEvent("label-add")
|
|
defer func() {
|
|
if c := metrics.Global(); c != nil {
|
|
c.CloseEventAndAdd(evt)
|
|
}
|
|
}()
|
|
|
|
return runLabelAdd(rootCtx, args)
|
|
},
|
|
}
|
|
|
|
//nolint:dupl // labelRemoveCmd and labelAddCmd are similar but serve different operations
|
|
var labelRemoveCmd = &cobra.Command{
|
|
Use: "remove [issue-id...] [label[,label...]]",
|
|
Short: "Remove one or more labels from one or more issues",
|
|
Long: "Remove labels from issues. Issue IDs come first; the final argument is the label. Pass multiple labels comma-separated: bd label remove bd-123 label1,label2\n\n" +
|
|
"With --prefix, no label argument is needed: every label on the given issue(s) starting with the prefix is removed, e.g. bd label remove bd-123 --prefix pool:refused:",
|
|
Args: func(cmd *cobra.Command, args []string) error {
|
|
prefix, _ := cmd.Flags().GetString("prefix")
|
|
if prefix != "" {
|
|
return cobra.MinimumNArgs(1)(cmd, args)
|
|
}
|
|
return cobra.MinimumNArgs(2)(cmd, args)
|
|
},
|
|
SilenceUsage: true,
|
|
SilenceErrors: true,
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
CheckReadonly("label remove")
|
|
|
|
evt := metrics.NewCommandEvent("label-remove")
|
|
defer func() {
|
|
if c := metrics.Global(); c != nil {
|
|
c.CloseEventAndAdd(evt)
|
|
}
|
|
}()
|
|
|
|
prefix, _ := cmd.Flags().GetString("prefix")
|
|
if prefix != "" {
|
|
issueIDs, err := resolveIssueIDsForPrefix(rootCtx, args)
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
return removeLabelsByPrefix(rootCtx, issueIDs, prefix, jsonOutput)
|
|
}
|
|
return runLabelRemove(rootCtx, args)
|
|
},
|
|
}
|
|
var labelListCmd = &cobra.Command{
|
|
Use: "list [issue-id]",
|
|
Short: "List labels for an issue",
|
|
Args: cobra.ExactArgs(1),
|
|
SilenceUsage: true,
|
|
SilenceErrors: true,
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
evt := metrics.NewCommandEvent("label-list")
|
|
defer func() {
|
|
if c := metrics.Global(); c != nil {
|
|
c.CloseEventAndAdd(evt)
|
|
}
|
|
}()
|
|
|
|
return runLabelList(rootCtx, args)
|
|
},
|
|
}
|
|
|
|
// labelListAllSearcher is the whole storage surface `bd label list-all`
|
|
// needs. SearchIssues already hydrates Issue.Labels in bulk; omitting
|
|
// GetLabels here keeps the per-issue lookup — one extra connection and
|
|
// transaction per issue in embedded mode — unreachable (GH#5325).
|
|
type labelListAllSearcher interface {
|
|
SearchIssues(ctx context.Context, query string, filter types.IssueFilter) ([]*types.Issue, error)
|
|
}
|
|
|
|
func countLabelsAcrossIssues(ctx context.Context, s labelListAllSearcher) (map[string]int, error) {
|
|
issues, err := s.SearchIssues(ctx, "", types.IssueFilter{})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
labelCounts := make(map[string]int)
|
|
for _, issue := range issues {
|
|
for _, label := range issue.Labels {
|
|
labelCounts[label]++
|
|
}
|
|
}
|
|
return labelCounts, nil
|
|
}
|
|
|
|
var labelListAllCmd = &cobra.Command{
|
|
Use: "list-all",
|
|
Short: "List all unique labels in the database",
|
|
SilenceUsage: true,
|
|
SilenceErrors: true,
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
evt := metrics.NewCommandEvent("label-list-all")
|
|
defer func() {
|
|
if c := metrics.Global(); c != nil {
|
|
c.CloseEventAndAdd(evt)
|
|
}
|
|
}()
|
|
|
|
if usesProxiedServer() {
|
|
return runLabelListAllProxiedServer(rootCtx)
|
|
}
|
|
|
|
labelCounts, err := countLabelsAcrossIssues(rootCtx, store)
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
type labelInfo struct {
|
|
Label string `json:"label"`
|
|
Count int `json:"count"`
|
|
}
|
|
if len(labelCounts) == 0 {
|
|
if jsonOutput {
|
|
return outputJSON([]labelInfo{})
|
|
}
|
|
fmt.Println("\nNo labels found in database")
|
|
return nil
|
|
}
|
|
labels := make([]string, 0, len(labelCounts))
|
|
for label := range labelCounts {
|
|
labels = append(labels, label)
|
|
}
|
|
sort.Strings(labels)
|
|
if jsonOutput {
|
|
result := make([]labelInfo, 0, len(labels))
|
|
for _, label := range labels {
|
|
result = append(result, labelInfo{
|
|
Label: label,
|
|
Count: labelCounts[label],
|
|
})
|
|
}
|
|
return outputJSON(result)
|
|
}
|
|
fmt.Printf("\n%s All labels (%d unique):\n", ui.RenderAccent("🏷"), len(labels))
|
|
maxLen := 0
|
|
for _, label := range labels {
|
|
if len(label) > maxLen {
|
|
maxLen = len(label)
|
|
}
|
|
}
|
|
for _, label := range labels {
|
|
padding := strings.Repeat(" ", maxLen-len(label))
|
|
fmt.Printf(" %s%s (%d issues)\n", label, padding, labelCounts[label])
|
|
}
|
|
fmt.Println()
|
|
return nil
|
|
},
|
|
}
|
|
|
|
var labelPropagateCmd = &cobra.Command{
|
|
Use: "propagate [parent-id] [label]",
|
|
Short: "Propagate a label from a parent issue to all its children",
|
|
Long: "Push a label from a parent down to all direct children that don't already have it. Useful for applying branch: labels across an epic's subtasks.",
|
|
Args: cobra.ExactArgs(2),
|
|
SilenceUsage: true,
|
|
SilenceErrors: true,
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
CheckReadonly("label propagate")
|
|
|
|
evt := metrics.NewCommandEvent("label-propagate")
|
|
defer func() {
|
|
if c := metrics.Global(); c != nil {
|
|
c.CloseEventAndAdd(evt)
|
|
}
|
|
}()
|
|
|
|
if usesProxiedServer() {
|
|
return runLabelPropagateProxiedServer(rootCtx, args)
|
|
}
|
|
|
|
ctx := rootCtx
|
|
|
|
parentID, err := utils.ResolvePartialID(ctx, store, args[0])
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("resolving parent %s: %v", args[0], err)
|
|
}
|
|
label := strings.TrimSpace(args[1])
|
|
if label == "" {
|
|
return HandleErrorRespectJSON("label cannot be empty")
|
|
}
|
|
|
|
if strings.HasPrefix(label, "provides:") {
|
|
return HandleErrorRespectJSON("'provides:' labels are reserved for cross-project capabilities. Hint: use 'bd ship %s' instead", strings.TrimPrefix(label, "provides:"))
|
|
}
|
|
|
|
children, err := store.SearchIssues(ctx, "", types.IssueFilter{ParentID: &parentID})
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("searching children of %s: %v", parentID, err)
|
|
}
|
|
|
|
if len(children) == 0 {
|
|
if jsonOutput {
|
|
return outputJSON([]map[string]interface{}{})
|
|
}
|
|
fmt.Printf("No children found for %s\n", parentID)
|
|
return nil
|
|
}
|
|
|
|
commitMsg := fmt.Sprintf("bd: propagate label '%s' from %s to %d children", label, parentID, len(children))
|
|
err = transactHonoringAutoCommit(ctx, store, commitMsg, func(tx storage.Transaction) error {
|
|
for _, child := range children {
|
|
if err := tx.AddLabel(ctx, child.ID, label, currentActor()); err != nil {
|
|
return fmt.Errorf("add label '%s' on %s: %w", label, child.ID, err)
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("label propagate: %v", err)
|
|
}
|
|
|
|
if jsonOutput {
|
|
results := make([]map[string]interface{}, 0, len(children))
|
|
for _, child := range children {
|
|
results = append(results, map[string]interface{}{
|
|
"status": "propagated",
|
|
"issue_id": child.ID,
|
|
"label": label,
|
|
})
|
|
}
|
|
return outputJSON(results)
|
|
}
|
|
for _, child := range children {
|
|
fmt.Printf("%s Propagated label '%s' to %s\n", ui.RenderPass("✓"), label, child.ID)
|
|
}
|
|
return nil
|
|
},
|
|
}
|
|
|
|
// labelRenamePreviewLimit caps how many issues a `--dry-run` blast-radius
|
|
// preview names before collapsing the rest into a count.
|
|
const labelRenamePreviewLimit = 10
|
|
|
|
var labelRenameCmd = &cobra.Command{
|
|
Use: "rename <old-label> <new-label>",
|
|
Short: "Rename a label across every issue and wisp that carries it",
|
|
Long: "Rename a label everywhere it appears. An issue that already carries " +
|
|
"the new label keeps it and drops the old one instead of erroring - a " +
|
|
"merge, reported honestly (the write path measures merged from what " +
|
|
"the insert actually affected, never from a snapshot check, so its " +
|
|
"count is correct under concurrent writes). Pass --dry-run to preview " +
|
|
"the blast radius (a count and the first issues) without writing " +
|
|
"anything; the preview's merged count is a plain snapshot intersection " +
|
|
"of two separate reads, so treat it as an estimate, not the number the " +
|
|
"rename itself will report.",
|
|
Args: cobra.ExactArgs(2),
|
|
SilenceUsage: true,
|
|
SilenceErrors: true,
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
dryRun, _ := cmd.Flags().GetBool("dry-run")
|
|
if !dryRun {
|
|
CheckReadonly("label rename")
|
|
}
|
|
|
|
evt := metrics.NewCommandEvent("label-rename")
|
|
defer func() {
|
|
if c := metrics.Global(); c != nil {
|
|
c.CloseEventAndAdd(evt)
|
|
}
|
|
}()
|
|
|
|
return runLabelRename(rootCtx, args, dryRun)
|
|
},
|
|
}
|
|
|
|
// validateLabelRename trims and checks the two rename arguments, returning
|
|
// the trimmed labels or the refusal a caller should surface. It is a pure
|
|
// function so the refusal rules are testable without a store.
|
|
func validateLabelRename(rawOld, rawNew string) (oldLabel, newLabel string, err error) {
|
|
oldLabel = strings.TrimSpace(rawOld)
|
|
newLabel = strings.TrimSpace(rawNew)
|
|
if oldLabel == "" || newLabel == "" {
|
|
return "", "", fmt.Errorf("label cannot be empty")
|
|
}
|
|
if oldLabel == newLabel {
|
|
return "", "", fmt.Errorf("cannot rename label '%s' to itself", oldLabel)
|
|
}
|
|
// Same reserved-prefix refusal runLabelAdd and label propagate apply: a
|
|
// rename is effectively an add of newLabel, and touching oldLabel would
|
|
// let a caller strip a 'provides:' capability outside 'bd ship'.
|
|
for _, label := range [2]string{oldLabel, newLabel} {
|
|
if strings.HasPrefix(label, "provides:") {
|
|
return "", "", fmt.Errorf("'provides:' labels are reserved for cross-project capabilities. Hint: use 'bd ship' instead")
|
|
}
|
|
}
|
|
return oldLabel, newLabel, nil
|
|
}
|
|
|
|
func runLabelRename(ctx context.Context, args []string, dryRun bool) error {
|
|
oldLabel, newLabel, err := validateLabelRename(args[0], args[1])
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
warnLabelsContainingWhitespace([]string{oldLabel, newLabel})
|
|
|
|
if dryRun {
|
|
return runLabelRenameDryRun(ctx, oldLabel, newLabel)
|
|
}
|
|
|
|
var renamed, merged int
|
|
if usesProxiedServer() {
|
|
renamed, merged, err = runLabelRenameProxiedServer(ctx, oldLabel, newLabel)
|
|
} else {
|
|
renamed, merged, _, err = store.RenameLabel(ctx, oldLabel, newLabel, currentActor())
|
|
}
|
|
// Recorded from renamed>0 BEFORE the error check: a rename can commit its
|
|
// SQL side and still return a non-nil err (e.g. the Dolt publication step
|
|
// failing after the working-set write landed), and the caller's deferred
|
|
// commit needs to know a write happened either way.
|
|
if renamed > 0 {
|
|
commandDidWrite.Store(true)
|
|
}
|
|
if err != nil {
|
|
// The counts are assigned INSIDE the transaction closure on both
|
|
// routes (label_proxied_server.go RunTx, dolt/labels.go
|
|
// withRetryTx), so a Commit failure or retry exhaustion returns
|
|
// them still holding the rolled-back attempt's numbers - nothing
|
|
// landed. Only doltAddAndCommit failing after the SQL tx committed
|
|
// is a genuine partial, and renamed>0 cannot discriminate the two.
|
|
// Report an UPPER BOUND rather than assert a write that may not
|
|
// have happened; commandDidWrite above shares the premise but is
|
|
// fail-safe in the other direction, this message is not.
|
|
if renamed > 0 {
|
|
return HandleErrorRespectJSON("%s", labelRenamePartialFailureMessage(renamed, merged, err))
|
|
}
|
|
return HandleErrorRespectJSON("label rename: %v", err)
|
|
}
|
|
return reportLabelRename(oldLabel, newLabel, renamed, merged, jsonOutput)
|
|
}
|
|
|
|
// labelRenameCandidatesProxied is the read-only counterpart of
|
|
// runLabelRenameProxiedServer, used only by --dry-run: two label searches, no
|
|
// write. Kept separate from the write path so a dry-run can never reach a
|
|
// uow.RunTx call.
|
|
func labelRenameCandidatesProxied(ctx context.Context, oldLabel, newLabel string) (oldIssues, newIssues []*types.Issue, err error) {
|
|
uw, err := proxiedOpenReadUOW(ctx)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
defer uw.Close(ctx)
|
|
|
|
oldPage, err := uw.IssueUseCase().SearchIssues(ctx, "", types.IssueFilter{Labels: []string{oldLabel}})
|
|
if err != nil {
|
|
return nil, nil, fmt.Errorf("searching issues with label %q: %w", oldLabel, err)
|
|
}
|
|
if len(oldPage.Items) == 0 {
|
|
return nil, nil, nil
|
|
}
|
|
newPage, err := uw.IssueUseCase().SearchIssues(ctx, "", types.IssueFilter{Labels: []string{newLabel}})
|
|
if err != nil {
|
|
return nil, nil, fmt.Errorf("searching issues with label %q: %w", newLabel, err)
|
|
}
|
|
return oldPage.Items, newPage.Items, nil
|
|
}
|
|
|
|
func runLabelRenameDryRun(ctx context.Context, oldLabel, newLabel string) error {
|
|
var (
|
|
oldIssues, newIssues []*types.Issue
|
|
err error
|
|
)
|
|
if usesProxiedServer() {
|
|
oldIssues, newIssues, err = labelRenameCandidatesProxied(ctx, oldLabel, newLabel)
|
|
} else {
|
|
oldIssues, err = store.GetIssuesByLabel(ctx, oldLabel)
|
|
if err == nil {
|
|
newIssues, err = store.GetIssuesByLabel(ctx, newLabel)
|
|
}
|
|
}
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("label rename --dry-run: %v", err)
|
|
}
|
|
|
|
// A preview-only snapshot intersection of two independent reads, NOT the
|
|
// write path's measured count: renameLabelInPlane derives merged from
|
|
// what its INSERT IGNORE actually affected, specifically to avoid the
|
|
// schedule-dependent count a check-then-insert shape used to produce
|
|
// under a concurrent AddLabel/RemoveLabel between the two reads (see the
|
|
// comment on that function). This dry-run has no insert to measure
|
|
// against, so it falls back to exactly that check-then-count shape - an
|
|
// acceptable estimate for a preview, but callers must not treat it as
|
|
// authoritative. The flag help and command Long text say so too.
|
|
alreadyNew := make(map[string]struct{}, len(newIssues))
|
|
for _, issue := range newIssues {
|
|
alreadyNew[issue.ID] = struct{}{}
|
|
}
|
|
merged := 0
|
|
for _, issue := range oldIssues {
|
|
if _, ok := alreadyNew[issue.ID]; ok {
|
|
merged++
|
|
}
|
|
}
|
|
|
|
if jsonOutput {
|
|
preview := make([]map[string]interface{}, 0, len(oldIssues))
|
|
for _, issue := range oldIssues {
|
|
preview = append(preview, map[string]interface{}{
|
|
"issue_id": issue.ID,
|
|
"title": issue.Title,
|
|
})
|
|
}
|
|
return outputJSON(map[string]interface{}{
|
|
"dry_run": true,
|
|
"old_label": oldLabel,
|
|
"new_label": newLabel,
|
|
"count": len(oldIssues),
|
|
"merged": merged,
|
|
"issues": preview,
|
|
})
|
|
}
|
|
|
|
if len(oldIssues) == 0 {
|
|
fmt.Printf("No issues found with label '%s'\n", oldLabel)
|
|
return nil
|
|
}
|
|
fmt.Printf("Would rename label '%s' to '%s': %d issues", oldLabel, newLabel, len(oldIssues))
|
|
if merged > 0 {
|
|
fmt.Printf(" (%d already have '%s')", merged, newLabel)
|
|
}
|
|
fmt.Println()
|
|
limit := len(oldIssues)
|
|
if limit > labelRenamePreviewLimit {
|
|
limit = labelRenamePreviewLimit
|
|
}
|
|
for _, issue := range oldIssues[:limit] {
|
|
fmt.Printf(" %s %s\n", issue.ID, issue.Title)
|
|
}
|
|
if len(oldIssues) > limit {
|
|
fmt.Printf(" ... and %d more\n", len(oldIssues)-limit)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// labelRenamePartialFailureMessage phrases a failed rename as an UPPER BOUND.
|
|
// Both routes assign the counts inside the transaction closure, so on a Commit
|
|
// failure or retry exhaustion they still hold the rolled-back attempt's numbers
|
|
// and nothing landed; only doltAddAndCommit failing after the SQL transaction
|
|
// committed is a genuine partial, and renamed > 0 cannot tell the two apart.
|
|
// Every number in the sentence is therefore hedged - a definite count here would
|
|
// assert a write that may never have happened.
|
|
func labelRenamePartialFailureMessage(renamed, merged int, err error) string {
|
|
return fmt.Sprintf("label rename: up to %d issue(s) (of which up to %d merged) may have been renamed before failing: %v",
|
|
renamed, merged, err)
|
|
}
|
|
|
|
// reportLabelRename prints what a (non-dry-run) rename landed: an honest
|
|
// zero-issues no-op, or the count plus how many of those were merges.
|
|
func reportLabelRename(oldLabel, newLabel string, renamed, merged int, jsonOut bool) error {
|
|
if jsonOut {
|
|
return outputJSON(map[string]interface{}{
|
|
"status": "renamed",
|
|
"old_label": oldLabel,
|
|
"new_label": newLabel,
|
|
"renamed": renamed,
|
|
"merged": merged,
|
|
})
|
|
}
|
|
if renamed == 0 {
|
|
fmt.Printf("No issues found with label '%s'\n", oldLabel)
|
|
return nil
|
|
}
|
|
noun := "issue"
|
|
if renamed != 1 {
|
|
noun = "issues"
|
|
}
|
|
fmt.Printf("Renamed label '%s' to '%s': %d %s", oldLabel, newLabel, renamed, noun)
|
|
if merged > 0 {
|
|
fmt.Printf(" (%d already had '%s')", merged, newLabel)
|
|
}
|
|
fmt.Println()
|
|
return nil
|
|
}
|
|
|
|
func init() {
|
|
// Issue ID completions
|
|
labelAddCmd.ValidArgsFunction = issueIDCompletion
|
|
labelRemoveCmd.ValidArgsFunction = issueIDCompletion
|
|
labelListCmd.ValidArgsFunction = issueIDCompletion
|
|
labelPropagateCmd.ValidArgsFunction = issueIDCompletion
|
|
|
|
labelRemoveCmd.Flags().String("prefix", "", "Remove every label matching this prefix instead of an exact label (e.g., 'pool:refused:' removes all pool:refused:* labels). No label positional argument is needed when set. CAUTION: a short prefix removes every match on an issue in a single edit, including labels you may not have meant to touch (e.g. --prefix t removes both 'tier:opus' and 'test-needed') — check `bd label list <issue-id>` first if unsure. State-dimension labels (e.g. 'launch:', 'scalegate:') should move via `bd set-state` instead, which this flag bypasses without its event-bead audit trail.")
|
|
|
|
labelRenameCmd.Flags().Bool("dry-run", false, "Preview the blast radius without renaming anything (merged count is a snapshot intersection, not authoritative - see --help)")
|
|
|
|
labelCmd.AddCommand(labelAddCmd)
|
|
labelCmd.AddCommand(labelRemoveCmd)
|
|
labelCmd.AddCommand(labelListCmd)
|
|
labelCmd.AddCommand(labelListAllCmd)
|
|
labelCmd.AddCommand(labelPropagateCmd)
|
|
labelCmd.AddCommand(labelRenameCmd)
|
|
rootCmd.AddCommand(labelCmd)
|
|
}
|
|
|
|
// runLabelAdd, runLabelRemove and runLabelList are ONE body each, for both
|
|
// routes. The route fork is gone from these three commands: what used to be an
|
|
// `if usesProxiedServer() { return run…ProxiedServer(...) }` in the middle of a
|
|
// RunE — with a second, separately-maintained implementation on the other side
|
|
// of it — is now a fork inside resolveLabelTarget and inside the accessor, and
|
|
// both arms end at the same role.
|
|
func runLabelAdd(ctx context.Context, args []string) error {
|
|
issueIDs, labels := parseLabelArgs(args)
|
|
if len(labels) == 0 {
|
|
return HandleErrorRespectJSON("label cannot be empty")
|
|
}
|
|
// The reserved-prefix refusal is checked BEFORE anything is resolved, and
|
|
// that ORDER CHANGED: the direct route used to resolve every id first and
|
|
// refuse the label afterwards. A caller that both typo'd an id and reached
|
|
// for a reserved label is now told about the label — the one of the two
|
|
// this command will never accept, at any id — rather than being sent to fix
|
|
// an id that was never going to be labeled. The proxied route already
|
|
// checked in this order, so this is the two routes agreeing on the earlier
|
|
// of the two answers rather than a new rule.
|
|
for _, label := range labels {
|
|
if strings.HasPrefix(label, "provides:") {
|
|
return HandleErrorRespectJSON("'provides:' labels are reserved for cross-project capabilities. Hint: use 'bd ship %s' instead", strings.TrimPrefix(label, "provides:"))
|
|
}
|
|
}
|
|
// splitLabelArg already trims and drops empties, so this route never stored
|
|
// the untrimmed class. What it could not tell a caller is that
|
|
// `bd label add bd-1 'theme:a theme:b'` is ONE label — the same silent
|
|
// miscount #5812 is about, reached by a different command. Warning here
|
|
// keeps the whole CLI saying the same thing about the same input.
|
|
warnLabelsContainingWhitespace(labels)
|
|
issueIDs, err := resolveLabelIssueIDs(ctx, "add", issueIDs)
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
return applyLabelEdit(ctx, issueIDs, labels, labelOperationAdded)
|
|
}
|
|
|
|
func runLabelRemove(ctx context.Context, args []string) error {
|
|
issueIDs, labels := parseLabelArgs(args)
|
|
if len(labels) == 0 {
|
|
return HandleErrorRespectJSON("label cannot be empty")
|
|
}
|
|
issueIDs, err := resolveLabelIssueIDs(ctx, "remove", issueIDs)
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
return applyLabelEdit(ctx, issueIDs, labels, labelOperationRemoved)
|
|
}
|
|
|
|
func runLabelList(ctx context.Context, args []string) error {
|
|
issueID, err := resolveLabelTarget(ctx, args[0])
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("resolving %s: %v", args[0], err)
|
|
}
|
|
reader, err := openIssueReader()
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
// The detail read already carries the labels, sorted, for whichever
|
|
// plane holds the row — so there is no label-shaped read here, and no
|
|
// wisp branch either.
|
|
details, err := reader.Get(ctx, issueops.GetRequest{ID: issueID})
|
|
if err != nil {
|
|
return HandleErrorRespectJSON("%v", err)
|
|
}
|
|
labels := details.Labels
|
|
if jsonOutput {
|
|
if labels == nil {
|
|
labels = []string{}
|
|
}
|
|
return outputJSON(labels)
|
|
}
|
|
if len(labels) == 0 {
|
|
fmt.Printf("\n%s has no labels\n", issueID)
|
|
return nil
|
|
}
|
|
fmt.Printf("\n%s Labels for %s:\n", ui.RenderAccent("🏷"), issueID)
|
|
for _, label := range labels {
|
|
fmt.Printf(" - %s\n", label)
|
|
}
|
|
fmt.Println()
|
|
return nil
|
|
}
|