relay-flow 0.0.1 → 0.2.0-alpha

package/internal/config/schema.go

@@ -1,193 +0,0 @@
-// Package config loads and validates relay-flow workflow YAML files.
-package config
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"regexp"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-)
-
-// StringList accepts either a scalar or a list of strings in YAML and
-// normalizes both forms to []string, so a single value can be written as
-// `closeOn: done` instead of `closeOn: [done]`.
-type StringList []string
-
-func (s *StringList) UnmarshalYAML(value *yaml.Node) error {
-	if value.Kind == yaml.ScalarNode {
-		if value.Tag != "!!str" {
-			return fmt.Errorf("expected string or list of strings")
-		}
-		*s = []string{value.Value}
-		return nil
-	}
-	var values []string
-	if err := value.Decode(&values); err != nil {
-		return err
-	}
-	*s = values
-	return nil
-}
-
-// Has reports membership (case-insensitive).
-func (s StringList) Has(name string) bool {
-	for _, value := range s {
-		if strings.EqualFold(value, name) {
-			return true
-		}
-	}
-	return false
-}
-
-// AdapterSpec selects a pluggable adapter (tasks or runner) by type name.
-// Config is opaque to core: the adapter's factory unmarshals it strictly.
-type AdapterSpec struct {
-	Type   string         `yaml:"type"`
-	Config map[string]any `yaml:"config"`
-}
-
-// Node is one square on the board: a tracker state (When), the agent that
-// works tickets in that state, and the outcome edges to other nodes.
-type Node struct {
-	// Agent is the OpenCode agent serving this node. Empty = terminal node
-	// (no agent runs; must be listed in closeOn).
-	Agent string `yaml:"agent"`
-	// When is the tracker state string that routes tickets to this node
-	// (poll-time condition). Unique across the file, case-insensitive.
-	When string `yaml:"when"`
-	// OnSuccess / OnFailure are the outcome edges: node names the ticket
-	// moves to when its agent reports success/failure. Self-loops allowed.
-	OnSuccess string `yaml:"onSuccess"`
-	OnFailure string `yaml:"onFailure"`
-	// NudgePrompt is sent into the ticket's existing terminal when it
-	// lands back on this node (bounce). Supports {{ticket}} and {{node}}
-	// placeholders; defaults to DefaultNudgePrompt.
-	NudgePrompt string `yaml:"nudgePrompt"`
-}
-
-// DefaultNudgePrompt is used when a node declares no nudgePrompt.
-const DefaultNudgePrompt = "Ticket {{ticket}} is at node '{{node}}' again. Read the tracker's latest feedback, continue your work, and end your reply with the STATUS/SUMMARY block as before."
-
-// Config is one workflow file: name, adapters, nodes, closeOn.
-type Config struct {
-	// Name is the workflow's identity: server registry key, claim-label
-	// component (`wf:<name>`), CLI argument. CamelCase, unique per server.
-	Name                string `yaml:"name"`
-	PollIntervalSeconds int    `yaml:"pollIntervalSeconds"`
-	// Tasks selects the ticket-system adapter (jira, beads, ...).
-	Tasks AdapterSpec `yaml:"tasks"`
-	// Runner selects the execution backend (orca, tmux, ...).
-	Runner AdapterSpec `yaml:"runner"`
-	// CloseOn lists terminal nodes: tickets reaching them get their
-	// terminals closed. Nodes here must have no agent.
-	CloseOn StringList `yaml:"closeOn"`
-	// Nodes maps node names to their definitions. The graph: each agent
-	// node's edges point at other nodes; terminal nodes have no agent.
-	Nodes map[string]Node `yaml:"nodes"`
-}
-
-var namePattern = regexp.MustCompile(`^[a-z][A-Za-z0-9]*$`)
-
-// NodeForState returns the node whose When matches tracker state
-// (case-insensitive), or "" if none.
-func (c *Config) NodeForState(state string) string {
-	for name, n := range c.Nodes {
-		if strings.EqualFold(n.When, state) {
-			return name
-		}
-	}
-	return ""
-}
-
-// Validate cross-checks the graph so broken configs fail at submit, before
-// any goroutine starts.
-func (c *Config) Validate() error {
-	if !namePattern.MatchString(c.Name) {
-		return fmt.Errorf("name %q must be camelCase with no spaces", c.Name)
-	}
-	if strings.TrimSpace(c.Tasks.Type) == "" {
-		return fmt.Errorf("tasks.type must not be empty")
-	}
-	if strings.TrimSpace(c.Runner.Type) == "" {
-		return fmt.Errorf("runner.type must not be empty")
-	}
-	if len(c.Nodes) == 0 {
-		return fmt.Errorf("nodes must not be empty")
-	}
-	if len(c.CloseOn) == 0 {
-		return fmt.Errorf("closeOn must not be empty (terminal nodes that close ticket terminals)")
-	}
-	for _, co := range c.CloseOn {
-		n, ok := c.Nodes[co]
-		if !ok {
-			return fmt.Errorf("closeOn: unknown node %q", co)
-		}
-		if n.Agent != "" {
-			return fmt.Errorf("closeOn: node %q has an agent; closeOn nodes must be terminal (no agent)", co)
-		}
-	}
-	seenWhen := map[string]string{}
-	for name, n := range c.Nodes {
-		if strings.TrimSpace(n.When) == "" {
-			return fmt.Errorf("nodes[%s].when must not be empty", name)
-		}
-		key := strings.ToLower(strings.TrimSpace(n.When))
-		if other, dup := seenWhen[key]; dup {
-			return fmt.Errorf("nodes[%s].when %q duplicates nodes[%s].when", name, n.When, other)
-		}
-		seenWhen[key] = name
-		if n.Agent == "" {
-			// Agentless = human gate / pause node: no automation, no
-			// edges required. Whether it also closes terminals is
-			// controlled solely by closeOn.
-			continue
-		}
-		if n.OnSuccess == "" {
-			return fmt.Errorf("nodes[%s].onSuccess must not be empty (agent nodes need both outcome edges)", name)
-		}
-		if n.OnFailure == "" {
-			return fmt.Errorf("nodes[%s].onFailure must not be empty (agent nodes need both outcome edges)", name)
-		}
-		if _, ok := c.Nodes[n.OnSuccess]; !ok {
-			return fmt.Errorf("nodes[%s].onSuccess: unknown node %q", name, n.OnSuccess)
-		}
-		if _, ok := c.Nodes[n.OnFailure]; !ok {
-			return fmt.Errorf("nodes[%s].onFailure: unknown node %q", name, n.OnFailure)
-		}
-		if n.NudgePrompt == "" {
-			n.NudgePrompt = DefaultNudgePrompt
-			c.Nodes[name] = n
-		}
-	}
-	return nil
-}
-
-// Parse decodes and validates workflow YAML bytes. name is only used in
-// error messages.
-func Parse(name string, b []byte) (*Config, error) {
-	var c Config
-	dec := yaml.NewDecoder(bytes.NewReader(b))
-	dec.KnownFields(true)
-	if err := dec.Decode(&c); err != nil {
-		return nil, fmt.Errorf("parse config %s: %w", name, err)
-	}
-	if c.PollIntervalSeconds <= 0 {
-		c.PollIntervalSeconds = 15
-	}
-	if err := c.Validate(); err != nil {
-		return nil, fmt.Errorf("config %s: %w", name, err)
-	}
-	return &c, nil
-}
-
-// Load reads and parses a workflow YAML file.
-func Load(path string) (*Config, error) {
-	b, err := os.ReadFile(path)
-	if err != nil {
-		return nil, fmt.Errorf("read config %s: %w", path, err)
-	}
-	return Parse(path, b)
-}

package/internal/config/schema_test.go

@@ -1,162 +0,0 @@
-package config
-
-import (
-	"strings"
-	"testing"
-)
-
-const validYAML = `
-name: xyzTaskFlow
-pollIntervalSeconds: 15
-tasks:
-  type: jira
-  config:
-    query: project = xyz
-    issueTypes: [Task]
-runner:
-  type: orca
-closeOn: [done]
-nodes:
-  coding:
-    agent: build
-    when: "In Progress"
-    onSuccess: reviewing
-    onFailure: coding
-  reviewing:
-    agent: build
-    when: "In Review"
-    onSuccess: done
-    onFailure: coding
-  done:
-    when: "Done"
-`
-
-func TestParseValid(t *testing.T) {
-	cfg, err := Parse("test", []byte(validYAML))
-	if err != nil {
-		t.Fatalf("valid config rejected: %v", err)
-	}
-	if cfg.Name != "xyzTaskFlow" {
-		t.Errorf("name = %q", cfg.Name)
-	}
-	if cfg.PollIntervalSeconds != 15 {
-		t.Errorf("pollIntervalSeconds = %d", cfg.PollIntervalSeconds)
-	}
-	if cfg.Tasks.Type != "jira" || cfg.Runner.Type != "orca" {
-		t.Errorf("tasks=%q runner=%q", cfg.Tasks.Type, cfg.Runner.Type)
-	}
-	if cfg.Tasks.Config["query"] != "project = xyz" {
-		t.Errorf("opaque tasks config not preserved: %v", cfg.Tasks.Config)
-	}
-	if len(cfg.Nodes) != 3 {
-		t.Fatalf("nodes = %v", cfg.Nodes)
-	}
-	n := cfg.Nodes["coding"]
-	if n.Agent != "build" || n.When != "In Progress" || n.OnSuccess != "reviewing" || n.OnFailure != "coding" {
-		t.Errorf("coding node = %+v", n)
-	}
-	if cfg.Nodes["done"].Agent != "" {
-		t.Errorf("done should have no agent")
-	}
-	if len(cfg.CloseOn) != 1 || cfg.CloseOn[0] != "done" {
-		t.Errorf("closeOn = %v", cfg.CloseOn)
-	}
-}
-
-func TestParseDefaultPollInterval(t *testing.T) {
-	yaml := strings.Replace(validYAML, "pollIntervalSeconds: 15\n", "", 1)
-	cfg, err := Parse("test", []byte(yaml))
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if cfg.PollIntervalSeconds != 15 {
-		t.Errorf("default pollIntervalSeconds = %d, want 15", cfg.PollIntervalSeconds)
-	}
-}
-
-func TestCloseOnScalar(t *testing.T) {
-	yaml := strings.Replace(validYAML, "closeOn: [done]", "closeOn: done", 1)
-	cfg, err := Parse("test", []byte(yaml))
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if len(cfg.CloseOn) != 1 || cfg.CloseOn[0] != "done" {
-		t.Errorf("closeOn = %v", cfg.CloseOn)
-	}
-}
-
-func TestParseErrors(t *testing.T) {
-	rep := func(old, new string) string { return strings.Replace(validYAML, old, new, 1) }
-	cases := []struct {
-		name string
-		yaml string
-		want string
-	}{
-		{"empty name", rep("name: xyzTaskFlow", "name: \"\""), "name"},
-		{"bad name", rep("name: xyzTaskFlow", "name: My Flow"), "camelCase"},
-		{"unknown top field", validYAML + "bogus: 1\n", "field bogus"},
-		{"unknown node field", rep("onFailure: coding\n  reviewing:", "onFailure: coding\n    bogus: 1\n  reviewing:"), "field bogus"},
-		{"no tasks type", rep("type: jira", "type: \"\""), "tasks.type"},
-		{"no runner type", rep("type: orca", "type: \"\""), "runner.type"},
-		{"empty closeOn", rep("closeOn: [done]", "closeOn: []"), "closeOn"},
-		{"closeOn unknown node", rep("closeOn: [done]", "closeOn: [nope]"), "closeOn"},
-		{"closeOn node has agent", rep("closeOn: [done]", "closeOn: [coding]"), "closeOn"},
-
-		{"edge target missing", rep("onSuccess: reviewing", "onSuccess: nowhere"), "onSuccess"},
-		{"agent node missing onSuccess", rep("    onSuccess: reviewing\n", ""), "onSuccess"},
-		{"agent node missing onFailure", rep("    onFailure: coding\n  reviewing", "  reviewing"), "onFailure"},
-		{"dup when", rep("when: \"In Review\"", "when: \"In Progress\""), "duplicat"},
-		{"empty when", rep("when: \"In Progress\"", "when: \"\""), "when"},
-		{"no nodes", rep("nodes:\n", "nodes: {}\n#") + "", "nodes"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			yaml := tc.yaml
-			if tc.name == "no nodes" {
-				// strip the entire nodes block
-				yaml = validYAML[:strings.Index(validYAML, "nodes:")]
-			}
-			_, err := Parse("test", []byte(yaml))
-			if err == nil {
-				t.Fatalf("expected error containing %q, got nil", tc.want)
-			}
-			if !strings.Contains(strings.ToLower(err.Error()), strings.ToLower(tc.want)) {
-				t.Fatalf("error %q missing %q", err, tc.want)
-			}
-		})
-	}
-}
-
-func TestSelfLoopEdgeAllowed(t *testing.T) {
-	// coding.onFailure == coding: already in validYAML, must parse.
-	if _, err := Parse("test", []byte(validYAML)); err != nil {
-		t.Fatalf("%v", err)
-	}
-}
-
-func TestNodeForState(t *testing.T) {
-	cfg, err := Parse("test", []byte(validYAML))
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if got := cfg.NodeForState("in progress"); got != "coding" {
-		t.Errorf("NodeForState(in progress) = %q, want coding", got)
-	}
-	if got := cfg.NodeForState("Done"); got != "done" {
-		t.Errorf("NodeForState(Done) = %q, want done", got)
-	}
-	if got := cfg.NodeForState("Backlog"); got != "" {
-		t.Errorf("NodeForState(Backlog) = %q, want empty", got)
-	}
-}
-
-func TestDefaultNudgePrompt(t *testing.T) {
-	cfg, err := Parse("test", []byte(validYAML))
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	p := cfg.Nodes["coding"].NudgePrompt
-	if !strings.Contains(p, "{{ticket}}") || !strings.Contains(p, "{{node}}") {
-		t.Errorf("default nudgePrompt missing templates: %q", p)
-	}
-}

package/internal/daemon/daemon.go

@@ -1,218 +0,0 @@
-// Package daemon runs one workflow's poll loop: list tickets from the
-// tasks adapter, route each through the 3-way claim switch, and dispatch
-// agent sessions through the runner adapter. It contains no tracker- or
-// runner-specific logic — both arrive as interfaces.
-package daemon
-
-import (
-	"context"
-	"fmt"
-	"log"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/rajpopat27/relay-flow/internal/config"
-	"github.com/rajpopat27/relay-flow/internal/runner"
-	"github.com/rajpopat27/relay-flow/internal/tasks"
-)
-
-// Daemon polls one workflow and dispatches tickets. Long-lived: one poll
-// goroutine per submitted workflow; dispatch/bounce run as short-lived
-// goroutines per ticket.
-type Daemon struct {
-	cfg      *config.Config
-	tasks    tasks.Tasks
-	runner   runner.Runner
-	repoID   string
-	repoName string
-	dryRun   bool
-
-	// nudged marks key → node for which a prompt/nudge was already
-	// delivered, so each node visit prompts exactly once. Cleared when a
-	// report moves the ticket (re-arming the next visit).
-	nudgedMu sync.Mutex
-	nudged   map[string]string
-
-	wg sync.WaitGroup // tracks dispatch/bounce goroutines; Wait blocks tests
-}
-
-// New builds a daemon for one validated workflow config.
-func New(cfg *config.Config, tk tasks.Tasks, rn runner.Runner, repoID, repoName string, dryRun bool) *Daemon {
-	return &Daemon{
-		cfg: cfg, tasks: tk, runner: rn,
-		repoID: repoID, repoName: repoName, dryRun: dryRun,
-		nudged: map[string]string{},
-	}
-}
-
-// PollLoop ticks until ctx is cancelled (server shutdown/remove).
-func (d *Daemon) PollLoop(ctx context.Context) {
-	interval := time.Duration(d.cfg.PollIntervalSeconds) * time.Second
-	ticker := time.NewTicker(interval)
-	defer ticker.Stop()
-	d.PollOnce()
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case <-ticker.C:
-			d.PollOnce()
-		}
-	}
-}
-
-// Wait blocks until in-flight dispatch/bounce goroutines finish. Tests
-// call it after PollOnce; production never needs it.
-func (d *Daemon) Wait() { d.wg.Wait() }
-
-// PollOnce lists tickets once and routes each:
-//
-//	claimed by another workflow → skip (cross-workflow mutex)
-//	unmapped tracker state        → log + skip
-//	node in closeOn               → runner.Close (terminal teardown)
-//	claimed by me, not prompted   → bounce: Find → Nudge (or respawn)
-//	unclaimed                     → dispatch: Claim → Spawn
-func (d *Daemon) PollOnce() {
-	found, err := d.tasks.List()
-	if err != nil {
-		log.Printf("poll %s: %v", d.cfg.Name, err)
-		return
-	}
-	for _, t := range found {
-		switch {
-		case t.ClaimedBy != "" && t.ClaimedBy != d.cfg.Name:
-			// Foreign workflow owns it — never touch.
-		case t.Node == "":
-			log.Printf("poll %s: %s at unmapped state, skipping", d.cfg.Name, t.Key)
-		case d.cfg.CloseOn.Has(t.Node):
-			log.Printf("poll %s: %s at terminal node %q, closing terminals", d.cfg.Name, t.Key, t.Node)
-			if err := d.runner.Close(t); err != nil {
-				log.Printf("poll %s: close %s: %v", d.cfg.Name, t.Key, err)
-			}
-			d.ClearNudged(t.Key)
-		case d.cfg.Nodes[t.Node].Agent == "":
-			// Human gate: no automation. Claim it so foreign workflows
-			// leave it alone, then leave the ticket for the human.
-			if t.ClaimedBy == "" {
-				if err := d.tasks.Claim(t); err != nil {
-					log.Printf("poll %s: claim %s (gate node): %v", d.cfg.Name, t.Key, err)
-				}
-			}
-		case t.ClaimedBy == d.cfg.Name:
-			d.wg.Add(1)
-			go d.bounce(t)
-		default:
-			d.wg.Add(1)
-			go d.dispatch(t)
-		}
-	}
-}
-
-// dispatch claims an unclaimed ticket and spawns its agent session.
-func (d *Daemon) dispatch(t tasks.Ticket) {
-	defer d.wg.Done()
-	node := d.cfg.Nodes[t.Node]
-	if err := d.tasks.Claim(t); err != nil {
-		log.Printf("dispatch %s: claim: %v", t.Key, err)
-		return
-	}
-	prompt := initialPrompt(d.cfg, t.Node, t)
-	env := map[string]string{
-		"RELAY_FLOW_WORKFLOW": d.cfg.Name,
-		"RELAY_FLOW_TICKET":   t.Key,
-		"RELAY_FLOW_NODE":     t.Node,
-		"RELAY_FLOW_AGENT":    node.Agent,
-	}
-	if err := d.runner.Spawn(t, t.Node, node.Agent, prompt, env); err != nil {
-		log.Printf("dispatch %s: spawn: %v", t.Key, err)
-		return
-	}
-	d.markNudged(t.Key, t.Node)
-	log.Printf("dispatch %s: spawned %q for node %q", t.Key, node.Agent, t.Node)
-}
-
-// bounce handles a ticket this workflow claimed but has no in-memory
-// record of (server restart): find the live terminal and nudge it, once
-// per node visit. No terminal → spawn fresh (claim already held).
-func (d *Daemon) bounce(t tasks.Ticket) {
-	defer d.wg.Done()
-	node := d.cfg.Nodes[t.Node]
-	sess, ok, err := d.runner.Find(t, t.Node)
-	if err != nil {
-		log.Printf("bounce %s: find: %v", t.Key, err)
-		return
-	}
-	if !ok {
-		// No live session: marker is irrelevant — always respawn (a
-		// terminal may have died after we marked it prompted).
-		d.ClearNudged(t.Key)
-		// Crash took the terminal with it: spawn a fresh session.
-		prompt := initialPrompt(d.cfg, t.Node, t)
-		env := map[string]string{
-			"RELAY_FLOW_WORKFLOW": d.cfg.Name,
-			"RELAY_FLOW_TICKET":   t.Key,
-			"RELAY_FLOW_NODE":     t.Node,
-			"RELAY_FLOW_AGENT":    node.Agent,
-		}
-		if err := d.runner.Spawn(t, t.Node, node.Agent, prompt, env); err != nil {
-			log.Printf("bounce %s: spawn: %v", t.Key, err)
-			return
-		}
-		d.markNudged(t.Key, t.Node)
-		log.Printf("bounce %s: no live session, spawned fresh for node %q", t.Key, t.Node)
-		return
-	}
-	if d.nudgedNode(t.Key) == t.Node {
-		return // session alive and already prompted for this visit
-	}
-	prompt := renderNudge(node.NudgePrompt, t.Key, t.Node)
-	if err := d.runner.Nudge(sess, prompt); err != nil {
-		log.Printf("bounce %s: nudge: %v (retry next poll)", t.Key, err)
-		return
-	}
-	d.markNudged(t.Key, t.Node)
-	log.Printf("bounce %s: nudged %q for node %q", t.Key, sess.Title, t.Node)
-}
-
-// ClearNudged drops the prompted marker for a ticket — called when a
-// report moves it to a new node, re-arming the next visit's nudge.
-func (d *Daemon) ClearNudged(key string) {
-	d.nudgedMu.Lock()
-	delete(d.nudged, key)
-	d.nudgedMu.Unlock()
-}
-
-func (d *Daemon) markNudged(key, node string) {
-	d.nudgedMu.Lock()
-	d.nudged[key] = node
-	d.nudgedMu.Unlock()
-}
-
-func (d *Daemon) nudgedNode(key string) string {
-	d.nudgedMu.Lock()
-	defer d.nudgedMu.Unlock()
-	return d.nudged[key]
-}
-
-// initialPrompt tells the agent which ticket it owns and the STATUS/
-// SUMMARY handoff contract (statuses success|failure). The agent fetches
-// ticket details itself via acli — nothing is injected here so feedback
-// is always picked up fresh. Flattened to one line: the command is typed
-// into a pty via keystroke simulation.
-func initialPrompt(cfg *config.Config, nodeName string, t tasks.Ticket) string {
-	prompt := fmt.Sprintf(
-		"You have been assigned ticket %s. Run `acli jira workitem view %s --fields summary,description,comment --json` "+
-			"to fetch its details and full comment history. When you are done, end your final message with exactly: "+
-			"STATUS: <success or failure> SUMMARY: <one-line summary of what you did>",
-		t.Key, t.Key)
-	return strings.Join(strings.Fields(prompt), " ")
-}
-
-// renderNudge applies {{ticket}}/{{node}} templating and flattens to one
-// line (keystroke simulation submits on newline).
-func renderNudge(tmpl, ticket, node string) string {
-	s := strings.ReplaceAll(tmpl, "{{ticket}}", ticket)
-	s = strings.ReplaceAll(s, "{{node}}", node)
-	return strings.Join(strings.Fields(s), " ")
-}