relay-flow 0.2.0-alpha → 0.2.2-alpha

package/internal/task/jira/lifecycle_inheritance_test.go

@@ -0,0 +1,172 @@
+package jira
+
+import (
+	"context"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+// Inherited root/repository taskConfig must have the same effect at runtime
+// that validation implies. ApplyTaskConfig receives only the configuration the
+// caller assembles (lifecycle defaults merged under workflow/node values), so
+// an adapter that keeps inherited values to itself accepts configuration,
+// validates it against the live task system, and then silently discards it.
+//
+// The adapter therefore returns its inherited transitionTo/assignee values as
+// part of its lifecycle defaults, producing the effective precedence
+// built-in default < root < repo < workflow < node.
+//
+// internal/task/beads/lifecycle_inheritance_test.go is the sibling of this
+// file and asserts the same invariants against the Beads adapter. Keep the two
+// in sync: a change that breaks inheritance in one adapter must fail here too.
+
+// repoScopedSystem builds the adapter with root/repository-scoped values, the
+// scopes that never appear in an ApplyTaskConfig argument.
+func repoScopedSystem(t *testing.T, fake *fakeJira, repoValues config.RawValues) task.System {
+	t.Helper()
+	repoConfig := config.Merge(config.RawValues{"project": "PAY", "component": "api"}, repoValues)
+	sys, err := newSystem(context.Background(), &fakeClient{fake: fake}, task.RepoSpec{
+		Name:       "payments",
+		RepoConfig: repoConfig,
+	})
+	if err != nil {
+		t.Fatalf("adapter construction failed: %v", err)
+	}
+	return sys
+}
+
+// operationConfig reproduces what the caller assembles before ApplyTaskConfig.
+func operationConfig(defaults, workflow, node config.RawValues) config.RawValues {
+	return config.Merge(defaults, config.Merge(workflow, node))
+}
+
+func lifecycleDefaultsOf(t *testing.T, sys task.System) task.LifecycleDefaults {
+	t.Helper()
+	d, ok := sys.(task.LifecycleDefaults)
+	if !ok {
+		t.Fatal("adapter does not expose task.LifecycleDefaults; inherited values cannot reach runtime")
+	}
+	return d
+}
+
+func TestLifecycleDefaultsCarryInheritedTransitionTo(t *testing.T) {
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailbox := &task.Mailbox{ID: "2", Key: "PAY-102", Node: "implement"}
+
+	t.Run("repo parentStatus reaches start", func(t *testing.T) {
+		fake := &fakeJira{}
+		sys := repoScopedSystem(t, fake, config.RawValues{
+			"transitionTo": map[string]any{"parentStatus": "In Review"},
+		})
+		cfg := operationConfig(lifecycleDefaultsOf(t, sys).StartDefaults(), nil, nil)
+
+		if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, cfg); err != nil {
+			t.Fatal(err)
+		}
+		if len(fake.parentTransitions) != 1 || fake.parentTransitions[0] != "In Review" {
+			t.Fatalf("parent transitions = %v, want the inherited repo value to beat the built-in default",
+				fake.parentTransitions)
+		}
+	})
+
+	t.Run("repo taskStatus reaches a work node", func(t *testing.T) {
+		fake := &fakeJira{}
+		sys := repoScopedSystem(t, fake, config.RawValues{
+			"transitionTo": map[string]any{"taskStatus": "In Review"},
+		})
+		cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(), nil, nil)
+
+		if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: mailbox}, cfg); err != nil {
+			t.Fatal(err)
+		}
+		if len(fake.taskTransitions) != 1 || fake.taskTransitions[0] != "In Review" {
+			t.Fatalf("mailbox transitions = %v, want the inherited repo value to beat the built-in default",
+				fake.taskTransitions)
+		}
+	})
+}
+
+func TestLifecycleDefaultsCarryInheritedAssignee(t *testing.T) {
+	fake := &fakeJira{}
+	sys := repoScopedSystem(t, fake, config.RawValues{"assignee": "repo-bot@example.com"})
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailbox := &task.Mailbox{ID: "2", Key: "PAY-102", Node: "implement"}
+	cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(), nil, nil)
+
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: mailbox}, cfg); err != nil {
+		t.Fatal(err)
+	}
+	if len(fake.assignments) != 1 || fake.assignments[0] != "PAY-102:repo-bot@example.com" {
+		t.Fatalf("assignments = %v, want the inherited repo assignee applied to the mailbox", fake.assignments)
+	}
+}
+
+func TestLifecycleDefaultsPrecedenceDefaultRepoWorkflowNode(t *testing.T) {
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailbox := &task.Mailbox{ID: "2", Key: "PAY-102", Node: "implement"}
+
+	for _, tc := range []struct {
+		name     string
+		workflow config.RawValues
+		node     config.RawValues
+		want     string
+	}{
+		{name: "repo beats built-in default", want: "Repo Status"},
+		{
+			name:     "workflow beats repo",
+			workflow: config.RawValues{"transitionTo": map[string]any{"taskStatus": "Workflow Status"}},
+			want:     "Workflow Status",
+		},
+		{
+			name:     "node beats workflow",
+			workflow: config.RawValues{"transitionTo": map[string]any{"taskStatus": "Workflow Status"}},
+			node:     config.RawValues{"transitionTo": map[string]any{"taskStatus": "Node Status"}},
+			want:     "Node Status",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			fake := &fakeJira{}
+			sys := repoScopedSystem(t, fake, config.RawValues{
+				"transitionTo": map[string]any{"taskStatus": "Repo Status"},
+			})
+			cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(), tc.workflow, tc.node)
+
+			if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: mailbox}, cfg); err != nil {
+				t.Fatal(err)
+			}
+			if len(fake.taskTransitions) != 1 || fake.taskTransitions[0] != tc.want {
+				t.Fatalf("mailbox transitions = %v, want [%s]", fake.taskTransitions, tc.want)
+			}
+		})
+	}
+}
+
+// With nothing inherited, the built-in lifecycle values still apply.
+func TestLifecycleDefaultsWithoutInheritedValues(t *testing.T) {
+	fake := &fakeJira{}
+	sys := repoScopedSystem(t, fake, nil)
+	d := lifecycleDefaultsOf(t, sys)
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailbox := &task.Mailbox{ID: "2", Key: "PAY-102", Node: "implement"}
+
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, operationConfig(d.StartDefaults(), nil, nil)); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: mailbox}, operationConfig(d.WorkDefaults(), nil, nil)); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, operationConfig(d.EndDefaults(), nil, nil)); err != nil {
+		t.Fatal(err)
+	}
+	if len(fake.parentTransitions) != 2 || fake.parentTransitions[0] != defaultStartParentStatus || fake.parentTransitions[1] != defaultEndParentStatus {
+		t.Fatalf("parent transitions = %v, want [%s %s]", fake.parentTransitions, defaultStartParentStatus, defaultEndParentStatus)
+	}
+	if len(fake.taskTransitions) != 1 || fake.taskTransitions[0] != defaultWorkTaskStatus {
+		t.Fatalf("mailbox transitions = %v, want [%s]", fake.taskTransitions, defaultWorkTaskStatus)
+	}
+	if len(fake.assignments) != 0 {
+		t.Fatalf("assignments = %v, want none when no assignee is configured", fake.assignments)
+	}
+}

package/internal/task/jira/normalize.go

@@ -3,13 +3,12 @@ package jira
 import (
 	"encoding/json"
 	"fmt"
+	"strings"
 
 	"github.com/rajpopat27/relay-flow/internal/task"
 )
 
-// rawIssue matches one entry in acli's search output. acli emits a BARE
-// ARRAY of these (no {"issues":[...]} REST envelope) — the adapter owns
-// the acli wire contract, not the REST API's.
+// rawIssue is the subset of Jira REST issue fields normalized by the adapter.
 type rawIssue struct {
 	ID     string `json:"id"`
 	Key    string `json:"key"`
@@ -33,11 +32,26 @@ type rawIssue struct {
 				Summary string `json:"summary"`
 			} `json:"fields"`
 		} `json:"subtasks"`
+		IssueLinks []struct {
+			Type struct {
+				Name string `json:"name"`
+			} `json:"type"`
+			InwardIssue *struct {
+				Key    string `json:"key"`
+				Fields struct {
+					Status struct {
+						StatusCategory struct {
+							Key string `json:"key"`
+						} `json:"statusCategory"`
+					} `json:"status"`
+				} `json:"fields"`
+			} `json:"inwardIssue"`
+		} `json:"issuelinks"`
 	} `json:"fields"`
 }
 
-// normalizeSearchResponse converts raw acli search JSON (a bare array of
-// issue objects) into normalized parent tickets: status, issueType, labels,
+// normalizeSearchResponse converts REST issue objects into normalized parent
+// tickets: status, issueType, labels,
 // and assignee become plain Fields entries. Assignee is normalized to the
 // user's email address — the stable, machine-comparable identity workflow
 // filters match against (displayName is human-readable, not an identifier).
@@ -49,6 +63,9 @@ func normalizeSearchResponse(raw []byte) ([]task.Ticket, error) {
 	}
 	out := make([]task.Ticket, 0, len(issues))
 	for _, issue := range issues {
+		if hasOpenBlocker(issue) {
+			continue
+		}
 		fields := map[string]any{
 			"status":    issue.Fields.Status.Name,
 			"issueType": issue.Fields.IssueType.Name,
@@ -68,6 +85,16 @@ func normalizeSearchResponse(raw []byte) ([]task.Ticket, error) {
 	return out, nil
 }
 
+func hasOpenBlocker(issue rawIssue) bool {
+	for _, link := range issue.Fields.IssueLinks {
+		if link.Type.Name == "Blocks" && link.InwardIssue != nil &&
+			!strings.EqualFold(link.InwardIssue.Fields.Status.StatusCategory.Key, "done") {
+			return true
+		}
+	}
+	return false
+}
+
 func claimLabels(labels []string) []string {
 	var out []string
 	for _, l := range labels {
@@ -78,15 +105,6 @@ func claimLabels(labels []string) []string {
 	return out
 }
 
-// labelsOf extracts label strings from a raw Jira issue view.
-func labelsOf(raw []byte) ([]string, error) {
-	var issue rawIssue
-	if err := json.Unmarshal(raw, &issue); err != nil {
-		return nil, fmt.Errorf("jira view: parse json: %w", err)
-	}
-	return issue.Fields.Labels, nil
-}
-
 // subtasksOf maps existing subtask titles (<ticket>:<node>) to mailboxes.
 func subtasksOf(raw []byte) (map[string]task.Mailbox, error) {
 	var issue rawIssue

package/internal/task/jira/rest/adf.go

@@ -0,0 +1,165 @@
+package rest
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/ast"
+	"github.com/yuin/goldmark/text"
+)
+
+var markdown = goldmark.New()
+
+// ADF converts explicit Markdown syntax to Atlassian Document Format.
+func ADF(value string) map[string]any {
+	source := []byte(strings.ReplaceAll(value, "\r\n", "\n"))
+	document := markdown.Parser().Parse(text.NewReader(source))
+	content := blockContent(document, source)
+	if len(content) == 0 {
+		content = []any{paragraph(nil)}
+	}
+	return map[string]any{"type": "doc", "version": 1, "content": content}
+}
+
+func blockContent(parent ast.Node, source []byte) []any {
+	content := make([]any, 0, parent.ChildCount())
+	for node := parent.FirstChild(); node != nil; node = node.NextSibling() {
+		switch node := node.(type) {
+		case *ast.Heading:
+			content = append(content, map[string]any{
+				"type":    "heading",
+				"attrs":   map[string]any{"level": node.Level},
+				"content": inlineContent(node, source, nil),
+			})
+		case *ast.Paragraph, *ast.TextBlock:
+			content = append(content, paragraph(inlineContent(node, source, nil)))
+		case *ast.List:
+			content = append(content, list(node, source))
+		case *ast.FencedCodeBlock:
+			content = append(content, codeBlock(node.Text(source), node.Language(source)))
+		case *ast.CodeBlock:
+			content = append(content, codeBlock(node.Text(source), nil))
+		case *ast.HTMLBlock:
+			content = append(content, paragraph([]any{textNode(string(node.Text(source)), nil)}))
+		default:
+			content = append(content, blockContent(node, source)...)
+		}
+	}
+	return content
+}
+
+func list(value *ast.List, source []byte) map[string]any {
+	items := make([]any, 0, value.ChildCount())
+	for child := value.FirstChild(); child != nil; child = child.NextSibling() {
+		itemContent := blockContent(child, source)
+		if len(itemContent) == 0 {
+			itemContent = []any{paragraph(nil)}
+		}
+		items = append(items, map[string]any{"type": "listItem", "content": itemContent})
+	}
+
+	kind := "bulletList"
+	result := map[string]any{"type": kind, "content": items}
+	if value.IsOrdered() {
+		result["type"] = "orderedList"
+		if value.Start != 1 {
+			result["attrs"] = map[string]any{"order": value.Start}
+		}
+	}
+	return result
+}
+
+func codeBlock(value, language []byte) map[string]any {
+	result := map[string]any{
+		"type":    "codeBlock",
+		"content": []any{textNode(strings.TrimSuffix(string(value), "\n"), nil)},
+	}
+	if len(language) != 0 {
+		result["attrs"] = map[string]any{"language": string(language)}
+	}
+	return result
+}
+
+func paragraph(content []any) map[string]any {
+	result := map[string]any{"type": "paragraph"}
+	if len(content) != 0 {
+		result["content"] = content
+	}
+	return result
+}
+
+func inlineContent(parent ast.Node, source []byte, marks []any) []any {
+	content := make([]any, 0, parent.ChildCount())
+	for node := parent.FirstChild(); node != nil; node = node.NextSibling() {
+		switch node := node.(type) {
+		case *ast.Text:
+			if value := string(node.Text(source)); value != "" {
+				content = append(content, textNode(value, marks))
+			}
+			if node.HardLineBreak() {
+				content = append(content, map[string]any{"type": "hardBreak"})
+			} else if node.SoftLineBreak() {
+				content = append(content, textNode(" ", marks))
+			}
+		case *ast.String:
+			if value := string(node.Value); value != "" {
+				content = append(content, textNode(value, marks))
+			}
+		case *ast.Emphasis:
+			kind := "em"
+			if node.Level == 2 {
+				kind = "strong"
+			}
+			content = append(content, inlineContent(node, source, withMark(marks, map[string]any{"type": kind}))...)
+		case *ast.Link:
+			mark := map[string]any{"type": "link", "attrs": map[string]any{"href": string(node.Destination)}}
+			content = append(content, inlineContent(node, source, withMark(marks, mark))...)
+		case *ast.AutoLink:
+			content = append(content, textNode(string(node.Label(source)), withMark(marks, map[string]any{
+				"type": "link", "attrs": map[string]any{"href": string(node.URL(source))},
+			})))
+		case *ast.CodeSpan:
+			content = append(content, inlineContent(node, source, withMark(marks, map[string]any{"type": "code"}))...)
+		case *ast.RawHTML:
+			content = append(content, textNode(string(node.Text(source)), marks))
+		default:
+			content = append(content, inlineContent(node, source, marks)...)
+		}
+	}
+	return content
+}
+
+func withMark(marks []any, mark map[string]any) []any {
+	result := make([]any, len(marks), len(marks)+1)
+	copy(result, marks)
+	return append(result, mark)
+}
+
+func textNode(value string, marks []any) map[string]any {
+	result := map[string]any{"type": "text", "text": value}
+	if len(marks) != 0 {
+		result["marks"] = marks
+	}
+	return result
+}
+
+func ADFText(raw json.RawMessage) string {
+	var node struct {
+		Text    string            `json:"text"`
+		Content []json.RawMessage `json:"content"`
+	}
+	if json.Unmarshal(raw, &node) != nil {
+		return ""
+	}
+	parts := make([]string, 0, len(node.Content)+1)
+	if node.Text != "" {
+		parts = append(parts, node.Text)
+	}
+	for _, child := range node.Content {
+		if text := ADFText(child); text != "" {
+			parts = append(parts, text)
+		}
+	}
+	return strings.Join(parts, "\n")
+}

package/internal/task/jira/rest/adf_test.go

@@ -0,0 +1,60 @@
+package rest
+
+import (
+	"encoding/json"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestADFConvertsExplicitMarkdown(t *testing.T) {
+	doc := ADF("# Heading\n\nWords with **strong**, *emphasis*, [a link](https://example.com), and `code`.\n\n1. first\n2. second\n\n```go\nfmt.Println(\"ok\")\n```")
+	content := doc["content"].([]any)
+
+	if got := content[0].(map[string]any); got["type"] != "heading" || !reflect.DeepEqual(got["attrs"], map[string]any{"level": 1}) {
+		t.Fatalf("heading = %#v", got)
+	}
+
+	raw, err := json.Marshal(doc)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		`"type":"strong"`,
+		`"type":"em"`,
+		`"attrs":{"href":"https://example.com"},"type":"link"`,
+		`"type":"code"`,
+		`"type":"orderedList"`,
+		`"attrs":{"language":"go"}`,
+		`"type":"codeBlock"`,
+	} {
+		if !strings.Contains(string(raw), want) {
+			t.Errorf("ADF missing %s: %s", want, raw)
+		}
+	}
+}
+
+func TestADFDoesNotInferFormatting(t *testing.T) {
+	doc := ADF("SUMMARY\n\nNode: implement\n\nHTTPS://EXAMPLE.COM")
+	raw, err := json.Marshal(doc)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(raw), `"type":"heading"`) || strings.Contains(string(raw), `"type":"strong"`) {
+		t.Fatalf("plain text was inferred as formatting: %s", raw)
+	}
+	if got := len(doc["content"].([]any)); got != 3 {
+		t.Fatalf("paragraph count = %d, want 3", got)
+	}
+}
+
+func TestADFMarkerRoundTrip(t *testing.T) {
+	const marker = "<!-- run-1:summary -->"
+	raw, err := json.Marshal(ADF("Done.\n\n" + marker))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := ADFText(raw); !strings.Contains(got, marker) {
+		t.Fatalf("ADFText() = %q, want marker %q", got, marker)
+	}
+}