Add Daily prompt input preflight

internal/adapters/scriptorium/runner.go

@@ -0,0 +1,154 @@
+// Package scriptorium adapts the external scriptorium CLI.
+package scriptorium
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"time"
+)
+
+type CommandRunner interface {
+	Run(ctx context.Context, name string, args []string, timeout time.Duration) (CommandResult, error)
+}
+
+type CommandResult struct {
+	Stdout   []byte
+	Stderr   []byte
+	ExitCode int
+}
+
+type ExecRunner struct{}
+
+func (ExecRunner) Run(ctx context.Context, name string, args []string, timeout time.Duration) (CommandResult, error) {
+	runCtx := ctx
+	cancel := func() {}
+	if timeout > 0 {
+		runCtx, cancel = context.WithTimeout(ctx, timeout)
+	}
+	defer cancel()
+
+	cmd := exec.CommandContext(runCtx, name, args...)
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+	result := CommandResult{Stdout: stdout.Bytes(), Stderr: stderr.Bytes(), ExitCode: 0}
+	if err == nil {
+		return result, nil
+	}
+	if exitErr, ok := err.(*exec.ExitError); ok {
+		result.ExitCode = exitErr.ExitCode()
+		return result, nil
+	}
+	if runCtx.Err() != nil {
+		return result, runCtx.Err()
+	}
+	return result, err
+}
+
+type Runner struct {
+	Binary     string
+	ConfigPath string
+	Profile    string
+	Timeout    time.Duration
+	ExtraArgs  []string
+	Commands   CommandRunner
+}
+
+type RenderRequest struct {
+	PromptID        string
+	DataPackagePath string
+}
+
+type RenderResult struct {
+	Command  []string `json:"command"`
+	Stdout   string   `json:"stdout"`
+	Stderr   string   `json:"stderr"`
+	ExitCode int      `json:"exitCode"`
+}
+
+func (r Runner) Render(ctx context.Context, req RenderRequest) (*RenderResult, error) {
+	if req.PromptID == "" {
+		return nil, fmt.Errorf("prompt id is required")
+	}
+	if req.DataPackagePath == "" {
+		return nil, fmt.Errorf("data package path is required")
+	}
+	binary := r.Binary
+	if binary == "" {
+		binary = "scriptorium"
+	}
+	commands := r.Commands
+	if commands == nil {
+		commands = ExecRunner{}
+	}
+	args := r.renderArgs(req)
+	commandResult, err := commands.Run(ctx, binary, args, r.Timeout)
+	if err != nil {
+		return nil, fmt.Errorf("run scriptorium render: %w", err)
+	}
+	result := &RenderResult{
+		Command:  append([]string{binary}, args...),
+		Stdout:   string(commandResult.Stdout),
+		Stderr:   string(commandResult.Stderr),
+		ExitCode: commandResult.ExitCode,
+	}
+	if commandResult.ExitCode != 0 {
+		return result, fmt.Errorf("scriptorium render exited with code %d: %s", commandResult.ExitCode, result.Stderr)
+	}
+	return result, nil
+}
+
+func (r Runner) renderArgs(req RenderRequest) []string {
+	args := []string{"render"}
+	if r.ConfigPath != "" {
+		args = append(args, "--config", r.ConfigPath)
+	}
+	if r.Profile != "" {
+		args = append(args, "--profile", r.Profile)
+	}
+	args = append(args,
+		"--prompt", req.PromptID,
+		"--input", "data_package="+req.DataPackagePath,
+		"--format", "json",
+	)
+	args = append(args, r.ExtraArgs...)
+	return args
+}
+
+func SaveRenderResult(path string, result *RenderResult) error {
+	if result == nil {
+		return fmt.Errorf("render result is required")
+	}
+	data, err := json.MarshalIndent(result, "", "  ")
+	if err != nil {
+		return fmt.Errorf("marshal render result: %w", err)
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return fmt.Errorf("create preflight directory %q: %w", filepath.Dir(path), err)
+	}
+	tmp, err := os.CreateTemp(filepath.Dir(path), "."+filepath.Base(path)+".*.tmp")
+	if err != nil {
+		return fmt.Errorf("create temporary preflight file: %w", err)
+	}
+	tmpName := tmp.Name()
+	defer os.Remove(tmpName)
+
+	if _, err := tmp.Write(data); err != nil {
+		tmp.Close()
+		return fmt.Errorf("write temporary preflight file: %w", err)
+	}
+	if err := tmp.Close(); err != nil {
+		return fmt.Errorf("close temporary preflight file: %w", err)
+	}
+	if err := os.Rename(tmpName, path); err != nil {
+		return fmt.Errorf("save preflight %q: %w", path, err)
+	}
+	return nil
+}

internal/adapters/scriptorium/runner_test.go

@@ -0,0 +1,89 @@
+package scriptorium
+
+import (
+	"context"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestRenderConstructsCommand(t *testing.T) {
+	commands := &fakeCommands{result: CommandResult{Stdout: []byte(`{"ok":true}`)}}
+	runner := Runner{
+		Binary:     "/usr/local/bin/scriptorium",
+		ConfigPath: "/etc/scriptorium.yml",
+		Profile:    "weather",
+		Timeout:    time.Minute,
+		Commands:   commands,
+	}
+
+	result, err := runner.Render(context.Background(), RenderRequest{
+		PromptID:        "weather.daily_report",
+		DataPackagePath: "/tmp/data_package.json",
+	})
+	if err != nil {
+		t.Fatalf("Render() error = %v", err)
+	}
+
+	wantArgs := []string{
+		"render",
+		"--config", "/etc/scriptorium.yml",
+		"--profile", "weather",
+		"--prompt", "weather.daily_report",
+		"--input", "data_package=/tmp/data_package.json",
+		"--format", "json",
+	}
+	if commands.name != "/usr/local/bin/scriptorium" {
+		t.Fatalf("command name = %q, want custom binary", commands.name)
+	}
+	if !reflect.DeepEqual(commands.args, wantArgs) {
+		t.Fatalf("args = %#v, want %#v", commands.args, wantArgs)
+	}
+	if !reflect.DeepEqual(result.Command, append([]string{"/usr/local/bin/scriptorium"}, wantArgs...)) {
+		t.Fatalf("result command = %#v, want full argv", result.Command)
+	}
+}
+
+func TestRenderReturnsResultForNonzeroExit(t *testing.T) {
+	runner := Runner{
+		Commands: &fakeCommands{
+			result: CommandResult{
+				Stderr:   []byte("missing input"),
+				ExitCode: 1,
+			},
+		},
+	}
+
+	result, err := runner.Render(context.Background(), RenderRequest{
+		PromptID:        "weather.daily_report",
+		DataPackagePath: "/tmp/data_package.json",
+	})
+	if err == nil {
+		t.Fatal("Render() error = nil, want nonzero exit error")
+	}
+	if result == nil {
+		t.Fatal("Render() result = nil, want captured result")
+	}
+	if result.ExitCode != 1 {
+		t.Fatalf("ExitCode = %d, want 1", result.ExitCode)
+	}
+	if !strings.Contains(err.Error(), "missing input") {
+		t.Fatalf("error = %q, want stderr context", err.Error())
+	}
+}
+
+type fakeCommands struct {
+	name    string
+	args    []string
+	timeout time.Duration
+	result  CommandResult
+	err     error
+}
+
+func (f *fakeCommands) Run(_ context.Context, name string, args []string, timeout time.Duration) (CommandResult, error) {
+	f.name = name
+	f.args = append([]string{}, args...)
+	f.timeout = timeout
+	return f.result, f.err
+}