relay-flow 0.2.1-alpha → 0.2.2-alpha

package/internal/harness/factory.go

@@ -9,8 +9,12 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/config"
 )
 
-// Factory constructs a Harness from root harness config.
-type Factory func(config.RawValues) (Harness, error)
+// Factory constructs a Harness from root harness config and supplies the
+// selected harness's init defaults without coupling core to an adapter.
+type Factory struct {
+	DefaultConfig func() config.RawValues
+	New           func(config.RawValues) (Harness, error)
+}
 
 var (
 	registryMu sync.RWMutex
@@ -35,7 +39,25 @@ func New(name string, cfg config.RawValues) (Harness, error) {
 	if !ok {
 		return nil, fmt.Errorf("harness: unknown plugin %q (registered: %s)", name, strings.Join(Names(), ", "))
 	}
-	return f(cfg)
+	return f.New(config.Merge(defaultConfig(f), cfg))
+}
+
+// Defaults returns a fresh copy of the named harness's root config defaults.
+func Defaults(name string) (config.RawValues, error) {
+	registryMu.RLock()
+	f, ok := registry[name]
+	registryMu.RUnlock()
+	if !ok {
+		return nil, fmt.Errorf("harness: unknown plugin %q (registered: %s)", name, strings.Join(Names(), ", "))
+	}
+	return config.Merge(defaultConfig(f)), nil
+}
+
+func defaultConfig(f Factory) config.RawValues {
+	if f.DefaultConfig == nil {
+		return nil
+	}
+	return f.DefaultConfig()
 }
 
 // ValidateName returns an error listing registered names when name is not

package/internal/harness/harness.go

@@ -1,7 +1,7 @@
-// Package harness defines the harness contract: agent validation, session
-// discovery, resume syntax, and launch command construction. The runner
-// executes the returned command; the harness never manipulates runner
-// state.
+// Package harness defines the harness contract: repository setup, prompt
+// rendering, agent validation, session discovery, resume syntax, and launch
+// command construction. The runner executes the returned command; the harness
+// never manipulates runner state.
 package harness
 
 import (
@@ -17,6 +17,29 @@ type Session struct {
 	Title string
 }
 
+type PromptKind string
+
+const (
+	PromptInitial  PromptKind = "initial"
+	PromptFeedback PromptKind = "feedback"
+)
+
+// PromptData is the task-system-neutral data core supplies to the selected
+// harness. Harness templates, including HITL instructions, are rendered only
+// by the harness.
+type PromptData struct {
+	TaskSystem      string
+	Ticket          string
+	Workflow        string
+	Repo            string
+	Node            string
+	NodeType        workflow.NodeType
+	Agent           string
+	NodeDescription string
+	NextSteps       string
+	Mailbox         string
+}
+
 type LaunchSpec struct {
 	RunID       identity.RunID
 	NodeVisitID identity.NodeVisitID
@@ -30,12 +53,15 @@ type LaunchSpec struct {
 	Title       string
 	Prompt      string
 	NudgePrompt string
+	PromptData  PromptData
 	NextSteps   []workflow.Route
 	ResumeID    string
 }
 
 type Harness interface {
+	SetupRepo(ctx context.Context, repoPath string) error
 	ValidateAgent(ctx context.Context, repoPath, agent string) error
 	FindSession(ctx context.Context, repoPath, title string) (Session, bool, error)
+	RenderPrompt(kind PromptKind, data PromptData, nudgeTemplate string) (string, error)
 	BuildCommand(spec LaunchSpec) (runner.Command, error)
 }

package/internal/harness/opencode/opencode.go

@@ -15,36 +15,94 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strings"
 
 	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/harness"
 	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
-// Config is the adapter-owned root harnessConfig. OpenCode takes no
-// configuration; any key is rejected.
-type Config struct{}
+const (
+	defaultInitialPrompt = `Task system: {{taskSystem}}
+Use the {{taskSystem}} tools to read the parent ticket {{ticket}}.
+
+Your mailbox is {{mailbox}}. Read its description and comments for node instructions and feedback.`
+	defaultFeedbackPrompt = `New feedback was added to the comments section of your mailbox subtask {{mailbox}}. Read it.`
+	defaultHITLPrompt     = `Before submitting your report, present the complete proposed report through OpenCode's built-in Question tool with exactly two options: Approve and Reject. Submit it only after an explicit Approve answer.`
+)
+
+var promptVarPattern = regexp.MustCompile(`\{\{([^{}]*)\}\}`)
+
+var knownPromptVars = map[string]bool{
+	"taskSystem": true, "ticket": true, "workflow": true, "repo": true,
+	"node": true, "nodeType": true, "agent": true, "nodeDescription": true,
+	"nextSteps": true, "mailbox": true,
+}
+
+// Config is the adapter-owned root harnessConfig.
+type Config struct {
+	Initial  string `yaml:"initial"`
+	Feedback string `yaml:"feedback"`
+	HITL     string `yaml:"hitl"`
+}
+
+// DefaultConfig is written by relay-flow init and also fills omitted values
+// when older or hand-written config is loaded.
+func DefaultConfig() config.RawValues {
+	return config.RawValues{
+		"initial":  defaultInitialPrompt,
+		"feedback": defaultFeedbackPrompt,
+		"hitl":     defaultHITLPrompt,
+	}
+}
 
 func init() {
-	harness.Register("opencode", func(raw config.RawValues) (harness.Harness, error) {
-		var cfg Config
-		if err := config.DecodeStrict(raw, &cfg); err != nil {
-			return nil, fmt.Errorf("opencode harnessConfig: %w", err)
-		}
-		return New(), nil
+	harness.Register("opencode", harness.Factory{
+		DefaultConfig: DefaultConfig,
+		New: func(raw config.RawValues) (harness.Harness, error) {
+			var cfg Config
+			if err := config.DecodeStrict(raw, &cfg); err != nil {
+				return nil, fmt.Errorf("opencode harnessConfig: %w", err)
+			}
+			for name, tmpl := range map[string]string{
+				"initial":  cfg.Initial,
+				"feedback": cfg.Feedback,
+				"hitl":     cfg.HITL,
+			} {
+				if err := validateTemplate(tmpl); err != nil {
+					return nil, fmt.Errorf("opencode harnessConfig templates.%s: %w", name, err)
+				}
+			}
+			return New(cfg), nil
+		},
 	})
 }
 
 // Harness implements harness.Harness for OpenCode. It is safe for
 // concurrent use; the seams below are only swapped by tests before use.
 type Harness struct {
+	templates Config
 	// listAgents is the test seam; nil → real `opencode agent list`.
 	listAgents func(ctx context.Context) ([]string, error)
 }
 
 // New returns the production Harness.
-func New() *Harness { return &Harness{} }
+func New(cfg ...Config) *Harness {
+	if len(cfg) > 0 {
+		return &Harness{templates: cfg[0]}
+	}
+	return &Harness{templates: Config{
+		Initial: defaultInitialPrompt, Feedback: defaultFeedbackPrompt, HITL: defaultHITLPrompt,
+	}}
+}
+
+// SetupRepo ensures the relay-flow runtime plugin is configured for OpenCode
+// in the registered repository.
+func (h *Harness) SetupRepo(_ context.Context, repoPath string) error {
+	return setupRepo(repoPath)
+}
 
 // ValidateAgent reports whether name is a known OpenCode agent for the
 // repo, per `opencode agent list` (agent names are the unindented first
@@ -75,6 +133,26 @@ func (h *Harness) FindSession(context.Context, string, string) (harness.Session,
 	return harness.Session{}, false, nil
 }
 
+// RenderPrompt renders the selected session prompt, appends HITL approval
+// instructions for HITL nodes, then renders and appends the node's nudge
+// template.
+func (h *Harness) RenderPrompt(kind harness.PromptKind, data harness.PromptData, nudgeTemplate string) (string, error) {
+	var tmpl string
+	switch kind {
+	case harness.PromptInitial:
+		tmpl = h.templates.Initial
+	case harness.PromptFeedback:
+		tmpl = h.templates.Feedback
+	default:
+		return "", fmt.Errorf("opencode: unknown prompt kind %q", kind)
+	}
+	prompt := renderTemplate(tmpl, data)
+	if data.NodeType == workflow.NodeHITL {
+		prompt = appendPrompt(prompt, renderTemplate(h.templates.HITL, data))
+	}
+	return appendPrompt(prompt, renderTemplate(nudgeTemplate, data)), nil
+}
+
 // BuildCommand returns the structured opencode invocation with the
 // required RELAY_FLOW_* env. spec.ResumeID non-empty resumes the prior
 // session (`opencode --session <id>`); empty is a fresh launch. The
@@ -164,3 +242,40 @@ func listAgents(ctx context.Context) ([]string, error) {
 	}
 	return names, nil
 }
+
+func validateTemplate(tmpl string) error {
+	for _, match := range promptVarPattern.FindAllStringSubmatch(tmpl, -1) {
+		if !knownPromptVars[match[1]] {
+			return fmt.Errorf("unknown template variable {{%s}}", match[1])
+		}
+	}
+	return nil
+}
+
+func renderTemplate(tmpl string, data harness.PromptData) string {
+	values := map[string]string{
+		"taskSystem":      data.TaskSystem,
+		"ticket":          data.Ticket,
+		"workflow":        data.Workflow,
+		"repo":            data.Repo,
+		"node":            data.Node,
+		"nodeType":        string(data.NodeType),
+		"agent":           data.Agent,
+		"nodeDescription": data.NodeDescription,
+		"nextSteps":       data.NextSteps,
+		"mailbox":         data.Mailbox,
+	}
+	return promptVarPattern.ReplaceAllStringFunc(tmpl, func(match string) string {
+		return values[promptVarPattern.FindStringSubmatch(match)[1]]
+	})
+}
+
+func appendPrompt(prompt, extra string) string {
+	if extra == "" {
+		return prompt
+	}
+	if prompt == "" {
+		return extra
+	}
+	return prompt + "\n\n" + extra
+}

package/internal/harness/opencode/opencode_test.go

@@ -1,13 +1,21 @@
 package opencode_test
 
 import (
+	"encoding/json"
+	"os"
+	"path/filepath"
 	"reflect"
+	"strings"
 	"testing"
 
+	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/harness"
 	"github.com/rajpopat27/relay-flow/internal/harness/opencode"
+	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
+const configuredPlugin = "relay-flow-plugin@0.2.2-alpha"
+
 func TestBuildCommandArgv(t *testing.T) {
 	t.Setenv("RELAY_FLOW_HOME", "/var/lib/relay-flow-test")
 	tests := []struct {
@@ -48,3 +56,178 @@ func TestBuildCommandArgv(t *testing.T) {
 		})
 	}
 }
+
+func TestRenderPromptTemplatesExposeAllValues(t *testing.T) {
+	raw := config.RawValues{
+		"initial":  "initial {{taskSystem}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{nodeType}}|{{agent}}|{{nodeDescription}}|{{nextSteps}}|{{mailbox}}",
+		"feedback": "feedback {{mailbox}}",
+		"hitl":     "hitl {{node}}",
+	}
+	h, err := harness.New("opencode", raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data := harness.PromptData{
+		TaskSystem: "linear", Ticket: "PAY-101", Workflow: "basicFlow", Repo: "payments",
+		Node: "review", NodeType: workflow.NodeHITL, Agent: "build", NodeDescription: "Review it.",
+		NextSteps: "end (when: approved)", Mailbox: "PAY-234",
+	}
+	nudge := "nudge {{taskSystem}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{nextSteps}}"
+	initial, err := h.RenderPrompt(harness.PromptInitial, data, nudge)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantInitial := "initial linear|PAY-101|basicFlow|payments|review|hitl|build|Review it.|end (when: approved)|PAY-234\n\nhitl review\n\nnudge linear|PAY-101|basicFlow|payments|review|end (when: approved)"
+	if initial != wantInitial {
+		t.Fatalf("initial prompt = %q, want %q", initial, wantInitial)
+	}
+	feedback, err := h.RenderPrompt(harness.PromptFeedback, data, nudge)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if want := "feedback PAY-234\n\nhitl review\n\nnudge linear|PAY-101|basicFlow|payments|review|end (when: approved)"; feedback != want {
+		t.Fatalf("feedback prompt = %q, want %q", feedback, want)
+	}
+}
+
+func TestHarnessConfigRejectsUnknownPromptVariable(t *testing.T) {
+	_, err := harness.New("opencode", config.RawValues{"initial": "{{unknown}}"})
+	if err == nil || !strings.Contains(err.Error(), "unknown template variable {{unknown}}") {
+		t.Fatalf("harness.New error = %v", err)
+	}
+}
+
+func TestSetupRepoCreatesOpenCodeJSON(t *testing.T) {
+	dir := t.TempDir()
+	setupTwice(t, dir)
+	path := filepath.Join(dir, "opencode.json")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cfg struct {
+		Plugin []string `json:"plugin"`
+	}
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatalf("created config is invalid JSON: %v\n%s", err, data)
+	}
+	if !reflect.DeepEqual(cfg.Plugin, []string{configuredPlugin}) {
+		t.Fatalf("plugin = %v", cfg.Plugin)
+	}
+}
+
+func TestSetupRepoUpdatesExistingJSONAndPreservesContent(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "opencode.json")
+	original := "{\n  \"theme\": \"catppuccin\",\n  \"plugin\": [\"keep-me\", \"relay-flow-plugin@0.1.0\"],\n  \"nested\": {\"enabled\": true}\n}\n"
+	if err := os.WriteFile(path, []byte(original), 0o640); err != nil {
+		t.Fatal(err)
+	}
+	setupTwice(t, dir)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cfg struct {
+		Theme  string          `json:"theme"`
+		Plugin []string        `json:"plugin"`
+		Nested map[string]bool `json:"nested"`
+	}
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatalf("updated config is invalid JSON: %v\n%s", err, data)
+	}
+	if cfg.Theme != "catppuccin" || !cfg.Nested["enabled"] {
+		t.Fatalf("existing config changed: %+v", cfg)
+	}
+	if !reflect.DeepEqual(cfg.Plugin, []string{"keep-me", configuredPlugin}) {
+		t.Fatalf("plugin = %v", cfg.Plugin)
+	}
+	info, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if info.Mode().Perm() != 0o640 {
+		t.Fatalf("mode = %o, want 640", info.Mode().Perm())
+	}
+}
+
+func TestSetupRepoUpdatesJSONCOnceAndPreservesComments(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "opencode.jsonc")
+	original := `{
+  // theme stays
+  "theme": "catppuccin",
+  "plugin": [
+    "keep-me", // existing plugin stays
+    "relay-flow-plugin",
+    /* duplicate old relay-flow entry */
+    "relay-flow-plugin@0.1.0",
+  ],
+  "nested": {"enabled": true}, // trailing comment stays
+}
+`
+	if err := os.WriteFile(path, []byte(original), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	setupTwice(t, dir)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	for _, preserved := range []string{"// theme stays", "// existing plugin stays", "/* duplicate old relay-flow entry */", "// trailing comment stays", "\"keep-me\"", "\"nested\": {\"enabled\": true}"} {
+		if !strings.Contains(text, preserved) {
+			t.Fatalf("config lost %q:\n%s", preserved, text)
+		}
+	}
+	if strings.Count(text, configuredPlugin) != 1 || strings.Contains(text, "relay-flow-plugin@0.1.0") {
+		t.Fatalf("relay-flow plugin not updated exactly once:\n%s", text)
+	}
+	if _, err := os.Stat(filepath.Join(dir, "opencode.json")); !os.IsNotExist(err) {
+		t.Fatalf("unexpected opencode.json created: %v", err)
+	}
+}
+
+func TestSetupRepoAddsPluginPropertyToJSONCWithComments(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "opencode.jsonc")
+	original := "{\n  \"theme\": \"catppuccin\" // keep at end\n}\n"
+	if err := os.WriteFile(path, []byte(original), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	setupTwice(t, dir)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	if !strings.Contains(text, "// keep at end") || strings.Count(text, configuredPlugin) != 1 {
+		t.Fatalf("config not preserved and updated:\n%s", text)
+	}
+}
+
+func setupTwice(t *testing.T, dir string) {
+	t.Helper()
+	h := opencode.New()
+	if err := h.SetupRepo(t.Context(), dir); err != nil {
+		t.Fatalf("first SetupRepo: %v", err)
+	}
+	path := filepath.Join(dir, "opencode.json")
+	if _, err := os.Stat(path); os.IsNotExist(err) {
+		path = filepath.Join(dir, "opencode.jsonc")
+	}
+	first, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := h.SetupRepo(t.Context(), dir); err != nil {
+		t.Fatalf("second SetupRepo: %v", err)
+	}
+	second, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(first, second) {
+		t.Fatalf("SetupRepo is not idempotent\nfirst:\n%s\nsecond:\n%s", first, second)
+	}
+}