relay-flow 0.2.0-alpha → 0.2.2-alpha

package/internal/task/beads/bdcli/bdcli.go

@@ -0,0 +1,323 @@
+// Package bdcli is the narrow subprocess client for the Beads bd CLI.
+//
+// Beads owns its storage and workspace selection. This package only executes
+// bd commands with JSON output and translates the small portion of that JSON
+// contract needed by the task-system adapter.
+package bdcli
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"sync"
+)
+
+// CLI executes bd in one repository and one configured Beads workspace.
+// Commands for a workspace are serialized because a single bd workspace may
+// be backed by an embedded database.
+type CLI struct {
+	repoPath string
+	beadsDir string
+	mu       sync.Mutex
+}
+
+// New constructs a CLI client for the registered code repository and Beads
+// workspace. The paths are passed to every child process; this function does
+// not initialize or otherwise inspect the workspace.
+func New(repoPath, beadsDir string) *CLI {
+	return &CLI{repoPath: repoPath, beadsDir: beadsDir}
+}
+
+// Issue contains only the Beads issue fields relay-flow needs.
+type Issue struct {
+	ID          string   `json:"id"`
+	Title       string   `json:"title"`
+	Description string   `json:"description,omitempty"`
+	Status      string   `json:"status"`
+	IssueType   string   `json:"issue_type"`
+	Priority    int      `json:"priority"`
+	Assignee    string   `json:"assignee,omitempty"`
+	Labels      []string `json:"labels,omitempty"`
+	Parent      string   `json:"parent,omitempty"`
+}
+
+// Comment is a Beads issue comment.
+type Comment struct {
+	ID   string `json:"id"`
+	Text string `json:"text"`
+}
+
+// Client is the narrow command seam consumed by the Beads task adapter.
+type Client interface {
+	Probe(ctx context.Context) error
+
+	ListReady(ctx context.Context) ([]Issue, error)
+	ListClaimed(ctx context.Context) ([]Issue, error)
+
+	ListChildren(ctx context.Context, parentID string) ([]Issue, error)
+	Show(ctx context.Context, issueID string) (Issue, error)
+
+	ListComments(ctx context.Context, issueID string) ([]Comment, error)
+
+	CreateChild(
+		ctx context.Context,
+		parentID string,
+		title string,
+		description string,
+		label string,
+	) (Issue, error)
+
+	Update(ctx context.Context, issueID string, input UpdateInput) error
+	AddComment(ctx context.Context, issueID, body string) error
+}
+
+// UpdateInput describes the supported bd update flags. Description is sent
+// through stdin when non-nil so multiline mailbox descriptions are preserved.
+type UpdateInput struct {
+	Description *string
+	Status      string
+	Assignee    string
+	AddLabels   []string
+	ClearDefer  bool
+}
+
+// CommandError reports a bd process that exited unsuccessfully. Stdout and
+// stderr are kept separate because bd may emit useful diagnostics on either
+// stream.
+type CommandError struct {
+	Args     []string
+	ExitCode int
+	Stderr   string
+	Stdout   string
+
+	cause error
+}
+
+func (e *CommandError) Error() string {
+	if e == nil {
+		return "bd command failed"
+	}
+	message := fmt.Sprintf("bd %v: exit status %d", e.Args, e.ExitCode)
+	if stderr := strings.TrimSpace(e.Stderr); stderr != "" {
+		message += ": " + stderr
+	}
+	return message
+}
+
+func (e *CommandError) Unwrap() error {
+	if e == nil {
+		return nil
+	}
+	return e.cause
+}
+
+// Probe performs a harmless bounded read to ensure that the selected bd
+// binary can use the configured workspace.
+func (c *CLI) Probe(ctx context.Context) error {
+	var issues []Issue
+	return c.runJSON(ctx, []string{"list", "--ready", "--limit", "1", "--no-parent", "--json"}, nil, &issues)
+}
+
+// ListReady lists ready top-level issues.
+func (c *CLI) ListReady(ctx context.Context) ([]Issue, error) {
+	var issues []Issue
+	if err := c.runJSON(ctx, []string{"list", "--ready", "--no-parent", "--limit", "0", "--json"}, nil, &issues); err != nil {
+		return nil, err
+	}
+	return issues, nil
+}
+
+// ListClaimed lists active top-level issues carrying a relay-flow workflow
+// claim. The deferred status is intentional: it is part of the selected bd
+// command contract for this adapter.
+func (c *CLI) ListClaimed(ctx context.Context) ([]Issue, error) {
+	var issues []Issue
+	if err := c.runJSON(ctx, []string{
+		"list", "--no-parent", "--status", "open,in_progress,blocked,deferred",
+		"--label-pattern", "wf:*", "--limit", "0", "--json",
+	}, nil, &issues); err != nil {
+		return nil, err
+	}
+	return issues, nil
+}
+
+// ListChildren lists every child issue of parentID, including closed issues.
+func (c *CLI) ListChildren(ctx context.Context, parentID string) ([]Issue, error) {
+	var issues []Issue
+	if err := c.runJSON(ctx, []string{
+		"list", "--parent", parentID, "--all", "--limit", "0", "--json",
+	}, nil, &issues); err != nil {
+		return nil, err
+	}
+	return issues, nil
+}
+
+// Show reads one issue. The selected bd CLI returns a one-element JSON array
+// for show, so an empty result is treated as an unusable response.
+func (c *CLI) Show(ctx context.Context, issueID string) (Issue, error) {
+	var issues []Issue
+	if err := c.runJSON(ctx, []string{"show", issueID, "--json"}, nil, &issues); err != nil {
+		return Issue{}, err
+	}
+	if len(issues) == 0 {
+		return Issue{}, fmt.Errorf("bd show %q returned no issues", issueID)
+	}
+	return issues[0], nil
+}
+
+// ListComments lists comments for one issue.
+func (c *CLI) ListComments(ctx context.Context, issueID string) ([]Comment, error) {
+	var comments []Comment
+	if err := c.runJSON(ctx, []string{"comments", issueID, "--json"}, nil, &comments); err != nil {
+		return nil, err
+	}
+	return comments, nil
+}
+
+// CreateChild creates a task child under parentID. The description is sent on
+// stdin to preserve multiline text exactly.
+func (c *CLI) CreateChild(ctx context.Context, parentID, title, description, label string) (Issue, error) {
+	var issue Issue
+	if err := c.runJSON(ctx, []string{
+		"create", title,
+		"--type", "task",
+		"--parent", parentID,
+		"--no-inherit-labels",
+		"--labels", label,
+		"--stdin", "--json",
+	}, strings.NewReader(description), &issue); err != nil {
+		return Issue{}, err
+	}
+	return issue, nil
+}
+
+// Update applies the requested bd update flags. The method intentionally does
+// not add conditional status flags; status reconciliation belongs to the
+// Beads adapter, which reads the issue before calling Update.
+func (c *CLI) Update(ctx context.Context, issueID string, input UpdateInput) error {
+	args := []string{"update", issueID}
+	var stdin io.Reader
+	if input.Description != nil {
+		args = append(args, "--description=-")
+		stdin = strings.NewReader(*input.Description)
+	}
+	if input.Status != "" {
+		args = append(args, "--status", input.Status)
+	}
+	if input.Assignee != "" {
+		args = append(args, "--assignee", input.Assignee)
+	}
+	for _, label := range input.AddLabels {
+		args = append(args, "--add-label", label)
+	}
+	if input.ClearDefer {
+		args = append(args, "--defer", "")
+	}
+	if len(args) == 2 {
+		return errors.New("bd update requires at least one update field")
+	}
+	args = append(args, "--json")
+	var response any
+	return c.runJSON(ctx, args, stdin, &response)
+}
+
+// AddComment writes a comment through stdin so multiline content is not
+// interpreted as shell or command-line text.
+func (c *CLI) AddComment(ctx context.Context, issueID, body string) error {
+	var response any
+	return c.runJSON(ctx, []string{"comment", issueID, "--stdin", "--json"}, strings.NewReader(body), &response)
+}
+
+// run executes one serialized bd command and captures stdout and stderr
+// independently.
+func (c *CLI) run(ctx context.Context, args []string, stdin io.Reader) ([]byte, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	cmd := exec.CommandContext(ctx, "bd", args...)
+	cmd.Dir = c.repoPath
+	cmd.Env = commandEnvironment(c.repoPath, c.beadsDir)
+	cmd.Stdin = stdin
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		exitCode := -1
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) && exitErr.ProcessState != nil {
+			exitCode = exitErr.ExitCode()
+		}
+		return stdout.Bytes(), &CommandError{
+			Args:     append([]string(nil), args...),
+			ExitCode: exitCode,
+			Stderr:   stderr.String(),
+			Stdout:   stdout.String(),
+			cause:    err,
+		}
+	}
+	return stdout.Bytes(), nil
+}
+
+// runJSON runs bd and decodes its stdout. Informational text printed before
+// the JSON value is tolerated; stderr remains available only on CommandError
+// and is never treated as JSON input.
+func (c *CLI) runJSON(ctx context.Context, args []string, stdin io.Reader, destination any) error {
+	data, err := c.run(ctx, args, stdin)
+	if err != nil {
+		return err
+	}
+	return parseJSON(data, destination)
+}
+
+// commandEnvironment preserves unrelated process environment while removing
+// ambient Beads selectors that could redirect a child command. The configured
+// workspace is always the sole BEADS_DIR entry.
+func commandEnvironment(_ string, beadsDir string) []string {
+	ambient := os.Environ()
+	env := make([]string, 0, len(ambient)+1)
+	for _, entry := range ambient {
+		key, _, ok := strings.Cut(entry, "=")
+		if ok && (key == "BEADS_DIR" || key == "BEADS_DB" || key == "BD_DB") {
+			continue
+		}
+		env = append(env, entry)
+	}
+	env = append(env, "BEADS_DIR="+beadsDir)
+	return env
+}
+
+// parseJSON decodes the first valid JSON value in data, allowing informational
+// lines before it. This keeps the parser tolerant of bd's human-facing notices
+// without combining stderr with stdout.
+func parseJSON(data []byte, destination any) error {
+	var lastErr error
+	for offset, value := range data {
+		if value != '{' && value != '[' {
+			continue
+		}
+		decoder := json.NewDecoder(bytes.NewReader(data[offset:]))
+		var raw json.RawMessage
+		if err := decoder.Decode(&raw); err != nil {
+			lastErr = err
+			continue
+		}
+		if err := json.Unmarshal(raw, destination); err != nil {
+			lastErr = err
+			continue
+		}
+		return nil
+	}
+	if lastErr == nil {
+		lastErr = errors.New("no JSON value found")
+	}
+	return fmt.Errorf("parse bd JSON: %w", lastErr)
+}
+
+var _ Client = (*CLI)(nil)

package/internal/task/beads/bdcli/bdcli_test.go

@@ -0,0 +1,297 @@
+package bdcli
+
+import (
+	"context"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestRunJSONUsesRepoDirectoryAndConfiguredWorkspace(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	installStrictFakeBD(t, repoPath, beadsDir)
+
+	var got []map[string]any
+	cli := New(repoPath, beadsDir)
+	if err := cli.runJSON(context.Background(), []string{"array", "--json"}, nil, &got); err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 1 || got[0]["id"] != "demo-1" {
+		t.Fatalf("decoded array = %#v", got)
+	}
+}
+
+func TestCLIUsesExactReadCommands(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	installStrictFakeBD(t, repoPath, beadsDir)
+	cli := New(repoPath, beadsDir)
+	ctx := context.Background()
+
+	if err := cli.Probe(ctx); err != nil {
+		t.Fatalf("Probe: %v", err)
+	}
+	if issues, err := cli.ListReady(ctx); err != nil || len(issues) != 1 || issues[0].ID != "demo-1" {
+		t.Fatalf("ListReady = %#v, %v", issues, err)
+	}
+	if issues, err := cli.ListClaimed(ctx); err != nil || len(issues) != 1 || issues[0].ID != "demo-1" {
+		t.Fatalf("ListClaimed = %#v, %v", issues, err)
+	}
+	if issues, err := cli.ListChildren(ctx, "demo-parent"); err != nil || len(issues) != 1 || issues[0].Parent != "demo-parent" {
+		t.Fatalf("ListChildren = %#v, %v", issues, err)
+	}
+	if issue, err := cli.Show(ctx, "demo-parent"); err != nil || issue.ID != "demo-parent" {
+		t.Fatalf("Show = %#v, %v", issue, err)
+	}
+	if comments, err := cli.ListComments(ctx, "demo-parent"); err != nil || len(comments) != 1 || comments[0].Text != "existing comment" {
+		t.Fatalf("ListComments = %#v, %v", comments, err)
+	}
+}
+
+func TestCLIUsesExactWriteCommandsAndStdin(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	installStrictFakeBD(t, repoPath, beadsDir)
+	cli := New(repoPath, beadsDir)
+	ctx := context.Background()
+
+	if _, err := cli.CreateChild(ctx, "demo-parent", "demo-parent:implement", "mailbox description\nsecond line\n", "wf:implementation"); err != nil {
+		t.Fatalf("CreateChild: %v", err)
+	}
+	description := "reconciled description\nwith two lines\n"
+	if err := cli.Update(ctx, "demo-parent.1", UpdateInput{
+		Description: &description,
+		AddLabels:   []string{"wf:implementation"},
+	}); err != nil {
+		t.Fatalf("Update description/label: %v", err)
+	}
+	if err := cli.Update(ctx, "demo-parent", UpdateInput{AddLabels: []string{"wf:implementation"}}); err != nil {
+		t.Fatalf("Update claim label: %v", err)
+	}
+	if err := cli.Update(ctx, "demo-parent.1", UpdateInput{Status: "in_progress"}); err != nil {
+		t.Fatalf("Update status: %v", err)
+	}
+	if err := cli.Update(ctx, "demo-parent.1", UpdateInput{Status: "in_progress", Assignee: "dev@example.com"}); err != nil {
+		t.Fatalf("Update status and assignee: %v", err)
+	}
+	if err := cli.Update(ctx, "demo-parent.1", UpdateInput{Assignee: "dev@example.com"}); err != nil {
+		t.Fatalf("Update assignee only: %v", err)
+	}
+	if err := cli.AddComment(ctx, "demo-parent.1", "summary line\n\nsecond line\n"); err != nil {
+		t.Fatalf("AddComment: %v", err)
+	}
+	if err := cli.Update(ctx, "demo-parent", UpdateInput{Status: "open", ClearDefer: true}); err != nil {
+		t.Fatalf("Update recovery reset: %v", err)
+	}
+}
+
+func TestCLIUsesCloseAndReopenUpdateCommands(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	installStrictFakeBD(t, repoPath, beadsDir)
+	cli := New(repoPath, beadsDir)
+	ctx := context.Background()
+
+	if err := cli.Update(ctx, "demo-parent.1", UpdateInput{Status: "closed"}); err != nil {
+		t.Fatalf("Close update: %v", err)
+	}
+	if err := cli.Update(ctx, "demo-parent.1", UpdateInput{Status: "open", ClearDefer: true}); err != nil {
+		t.Fatalf("Reopen update: %v", err)
+	}
+}
+
+func TestStrictFakeBDRejectsUnexpectedArgv(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	fake := installStrictFakeBD(t, repoPath, beadsDir)
+
+	cmd := exec.Command(fake, "array", "--limit", "1", "--json")
+	cmd.Dir = repoPath
+	cmd.Env = []string{
+		"PATH=" + os.Getenv("PATH"),
+		"BD_EXPECT_CWD=" + repoPath,
+		"BD_EXPECT_BEADS_DIR=" + beadsDir,
+		"BEADS_DIR=" + beadsDir,
+		"BD_FIXTURE_DIR=" + os.Getenv("BD_FIXTURE_DIR"),
+	}
+	if err := cmd.Run(); err == nil {
+		t.Fatal("strict fake accepted an unsupported argv")
+	}
+}
+
+func TestRunJSONDecodesObjectAndAcceptsEmptyArray(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	installStrictFakeBD(t, repoPath, beadsDir)
+	cli := New(repoPath, beadsDir)
+
+	var object map[string]any
+	if err := cli.runJSON(context.Background(), []string{"object", "demo-1", "--json"}, nil, &object); err != nil {
+		t.Fatal(err)
+	}
+	if object["id"] != "demo-1" || object["title"] != "Shown issue" {
+		t.Fatalf("decoded object = %#v", object)
+	}
+
+	var empty []map[string]any
+	if err := cli.runJSON(context.Background(), []string{"empty", "--json"}, nil, &empty); err != nil {
+		t.Fatal(err)
+	}
+	if empty == nil || len(empty) != 0 {
+		t.Fatalf("decoded empty array = %#v", empty)
+	}
+}
+
+func TestRunJSONPreservesMultilineStdin(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	installStrictFakeBD(t, repoPath, beadsDir)
+
+	var got map[string]any
+	cli := New(repoPath, beadsDir)
+	stdin := strings.NewReader("first line\nsecond line\n\nfinal line\n")
+	if err := cli.runJSON(context.Background(), []string{"stdin", "--json"}, stdin, &got); err != nil {
+		t.Fatal(err)
+	}
+	if got["stdin"] != "accepted" {
+		t.Fatalf("decoded stdin response = %#v", got)
+	}
+}
+
+func TestCommandEnvironmentIsolatesBeadsSelectors(t *testing.T) {
+	t.Setenv("BEADS_DIR", "/ambient/workspace")
+	t.Setenv("BEADS_DB", "/ambient/beads.db")
+	t.Setenv("BD_DB", "/ambient/legacy.db")
+	t.Setenv("UNRELATED_ENV", "preserve-me")
+
+	env := commandEnvironment("/repo", "/configured/workspace")
+	values := make(map[string][]string)
+	for _, entry := range env {
+		key, value, ok := strings.Cut(entry, "=")
+		if !ok {
+			continue
+		}
+		values[key] = append(values[key], value)
+	}
+
+	if got := values["BEADS_DIR"]; len(got) != 1 || got[0] != "/configured/workspace" {
+		t.Fatalf("BEADS_DIR entries = %#v", got)
+	}
+	for _, key := range []string{"BEADS_DB", "BD_DB"} {
+		if got := values[key]; len(got) != 0 {
+			t.Fatalf("ambient %s leaked into command environment: %#v", key, got)
+		}
+	}
+	if got := values["UNRELATED_ENV"]; len(got) != 1 || got[0] != "preserve-me" {
+		t.Fatalf("unrelated environment = %#v", got)
+	}
+}
+
+func TestParseJSONSkipsInformationalOutputBeforeValue(t *testing.T) {
+	var got map[string]string
+	if err := parseJSON([]byte("bd: using workspace\n{\"id\":\"demo-1\"}\n"), &got); err != nil {
+		t.Fatal(err)
+	}
+	if got["id"] != "demo-1" {
+		t.Fatalf("parsed value = %#v", got)
+	}
+}
+
+func TestRunJSONRejectsMalformedOutput(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	installStrictFakeBD(t, repoPath, beadsDir)
+
+	var got map[string]any
+	err := New(repoPath, beadsDir).runJSON(context.Background(), []string{"malformed", "--json"}, nil, &got)
+	if err == nil {
+		t.Fatal("malformed JSON was accepted")
+	}
+	var commandErr *CommandError
+	if errors.As(err, &commandErr) {
+		t.Fatalf("malformed JSON reported as command failure: %#v", commandErr)
+	}
+}
+
+func TestRunReportsExitCodeStdoutAndStderrSeparately(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	installStrictFakeBD(t, repoPath, beadsDir)
+
+	_, err := New(repoPath, beadsDir).run(context.Background(), []string{"fail"}, nil)
+	if err == nil {
+		t.Fatal("ordinary non-zero bd exit was accepted")
+	}
+	var commandErr *CommandError
+	if !errors.As(err, &commandErr) {
+		t.Fatalf("error = %T %v, want CommandError", err, err)
+	}
+	if commandErr.ExitCode != 23 {
+		t.Fatalf("exit code = %d, want 23", commandErr.ExitCode)
+	}
+	if !strings.Contains(commandErr.Stdout, "partial stdout") {
+		t.Fatalf("stdout = %q", commandErr.Stdout)
+	}
+	if !strings.Contains(commandErr.Stderr, "failure detail") {
+		t.Fatalf("stderr = %q", commandErr.Stderr)
+	}
+	if len(commandErr.Args) != 1 || commandErr.Args[0] != "fail" {
+		t.Fatalf("command args = %#v", commandErr.Args)
+	}
+}
+
+func TestRunJSONDoesNotTreatStderrAsJSONInput(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	installStrictFakeBD(t, repoPath, beadsDir)
+
+	var got map[string]any
+	if err := New(repoPath, beadsDir).runJSON(context.Background(), []string{"stderr", "--json"}, nil, &got); err != nil {
+		t.Fatal(err)
+	}
+	if got["id"] != "demo-1" {
+		t.Fatalf("decoded stderr response = %#v", got)
+	}
+}
+
+func TestRunJSONToleratesInformationalStdout(t *testing.T) {
+	repoPath, beadsDir := newTestPaths(t)
+	installStrictFakeBD(t, repoPath, beadsDir)
+
+	var got map[string]any
+	if err := New(repoPath, beadsDir).runJSON(context.Background(), []string{"info", "--json"}, nil, &got); err != nil {
+		t.Fatal(err)
+	}
+	if got["id"] != "demo-1" {
+		t.Fatalf("decoded informational response = %#v", got)
+	}
+}
+
+func newTestPaths(t *testing.T) (repoPath, beadsDir string) {
+	t.Helper()
+	repoPath = t.TempDir()
+	beadsDir = filepath.Join(t.TempDir(), ".beads")
+	if err := os.Mkdir(beadsDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	return repoPath, beadsDir
+}
+
+func installStrictFakeBD(t *testing.T, repoPath, beadsDir string) string {
+	t.Helper()
+	binDir := t.TempDir()
+	fake := filepath.Join(binDir, "bd")
+	script, err := os.ReadFile(filepath.Join("testdata", "strict-bd.sh"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(fake, script, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("PATH", binDir+string(os.PathListSeparator)+os.Getenv("PATH"))
+	t.Setenv("BD_EXPECT_CWD", repoPath)
+	t.Setenv("BD_EXPECT_BEADS_DIR", beadsDir)
+	fixtureDir, err := filepath.Abs("testdata")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("BD_FIXTURE_DIR", fixtureDir)
+	t.Setenv("BEADS_DIR", "/ambient/workspace")
+	t.Setenv("BEADS_DB", "/ambient/beads.db")
+	t.Setenv("BD_DB", "/ambient/legacy.db")
+	return fake
+}

package/internal/task/beads/bdcli/testdata/array.json

@@ -0,0 +1 @@
+[{"id":"demo-1","title":"Ready issue"}]

package/internal/task/beads/bdcli/testdata/children.json

@@ -0,0 +1 @@
+[{"id":"demo-parent.1","title":"demo-parent:implement","description":"Existing mailbox","status":"open","issue_type":"task","priority":2,"labels":["wf:implementation"],"parent":"demo-parent"}]

package/internal/task/beads/bdcli/testdata/claimed.json

@@ -0,0 +1 @@
+[{"id":"demo-1","title":"Claimed issue","description":"Claimed description","status":"in_progress","issue_type":"epic","priority":1,"labels":["wf:implementation"]}]

package/internal/task/beads/bdcli/testdata/commented.json

@@ -0,0 +1 @@
+{"id":"comment-2","text":"summary line"}

package/internal/task/beads/bdcli/testdata/comments.json

@@ -0,0 +1 @@
+[{"id":"comment-1","text":"existing comment"}]

package/internal/task/beads/bdcli/testdata/created.json

@@ -0,0 +1 @@
+{"id":"demo-parent.1","title":"demo-parent:implement","description":"mailbox description\nsecond line\n","status":"open","issue_type":"task","priority":2,"labels":["wf:implementation"],"parent":"demo-parent"}

package/internal/task/beads/bdcli/testdata/object.json

@@ -0,0 +1 @@
+{"id":"demo-1","title":"Shown issue"}

package/internal/task/beads/bdcli/testdata/ready.json

@@ -0,0 +1 @@
+[{"id":"demo-1","title":"Ready issue","description":"Ready description","status":"open","issue_type":"epic","priority":1,"labels":[]}]

package/internal/task/beads/bdcli/testdata/show.json

@@ -0,0 +1 @@
+[{"id":"demo-parent","title":"Parent issue","description":"Parent description","status":"open","issue_type":"epic","priority":1,"labels":[]}]