antidrift/internal/tasks/marvin.go

package tasks

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"os/exec"
	"strings"
)

// runner executes a command and returns its stdout. Production shells out;
// tests inject a fake to avoid spawning a process.
type runner func(ctx context.Context, name string, args ...string) ([]byte, error)

func execRunner(ctx context.Context, name string, args ...string) ([]byte, error) {
	cmd := exec.CommandContext(ctx, name, args...)
	var out, errb bytes.Buffer
	cmd.Stdout = &out
	cmd.Stderr = &errb
	if err := cmd.Run(); err != nil {
		if s := strings.TrimSpace(errb.String()); s != "" {
			return nil, fmt.Errorf("%s: %w: %s", name, err, s)
		}
		return nil, fmt.Errorf("%s: %w", name, err)
	}
	return out.Bytes(), nil
}

// Marvin is the Amazing Marvin adapter. It shells out to ampy's CLI
// (`am --json`, no subcommand) and parses the open tasks due today or earlier.
type Marvin struct {
	cmd  string
	base []string // configured prefix after cmd, without the "--json" sentinel
	args []string // read-path argv: base + ["--json"]
	run  runner
}

// NewMarvin builds the adapter. command is split on spaces so both "am" and
// "uv run am" work; empty defaults to "am". The "--json" flag is always
// appended, and no subcommand is passed (ampy lists today's tasks by default).
func NewMarvin(command string) *Marvin {
	fields := strings.Fields(command)
	if len(fields) == 0 {
		fields = []string{"am"}
	}
	base := append([]string{}, fields[1:]...)
	args := append(append([]string{}, base...), "--json")
	return &Marvin{cmd: fields[0], base: base, args: args, run: execRunner}
}

// Today returns the open tasks due today or earlier, or an error if the CLI
// fails. Callers degrade gracefully on error.
func (m *Marvin) Today(ctx context.Context) ([]Task, error) {
	out, err := m.run(ctx, m.cmd, m.args...)
	if err != nil {
		return nil, err
	}
	return parse(out)
}

// Create adds a new task via ampy's `add` subcommand, shelling out through the
// same configured prefix as the read path so the add lands in the same CRDT
// store the reads observe. Only the title is sent in v1. It returns the CLI
// error on failure.
func (m *Marvin) Create(ctx context.Context, t Task) error {
	args := append(append([]string{}, m.base...), "add", t.Title, "--json")
	_, err := m.run(ctx, m.cmd, args...)
	return err
}

type rawTask struct {
	ID    string `json:"id"`
	Title string `json:"title"`
	Day   string `json:"day"`
	Done  bool   `json:"done"`
}

// parse maps `am --json` output (a JSON array of task objects) to []Task. It
// drops tasks that are done or have an empty title. A JSON null or empty array
// yields an empty slice, not an error.
func parse(data []byte) ([]Task, error) {
	var raw []rawTask
	if err := json.Unmarshal(data, &raw); err != nil {
		return nil, fmt.Errorf("tasks: parse: %w", err)
	}
	out := make([]Task, 0, len(raw))
	for _, r := range raw {
		title := strings.TrimSpace(r.Title)
		if r.Done || title == "" {
			continue
		}
		out = append(out, Task{ID: r.ID, Title: title, Day: r.Day})
	}
	return out, nil
}