Add wl accept, wl update, wl delete commands

Complete the wanted lifecycle: accept validates completions and issues
reputation stamps, update edits fields on open items, delete withdraws
open items by setting status=withdrawn.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: julianknutsen

cmd/wl/cmd_accept.go

@@ -0,0 +1,172 @@
+package main
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+	"github.com/steveyegge/wasteland/internal/commons"
+	"github.com/steveyegge/wasteland/internal/style"
+)
+
+func newAcceptCmd(stdout, stderr io.Writer) *cobra.Command {
+	var (
+		quality     int
+		reliability int
+		severity    string
+		skills      string
+		message     string
+		noPush      bool
+	)
+
+	cmd := &cobra.Command{
+		Use:   "accept <wanted-id>",
+		Short: "Accept a completed wanted item and issue a stamp",
+		Long: `Accept a completed wanted item by reviewing the work and issuing a reputation stamp.
+
+The item must be in 'in_review' status. You cannot accept your own completion.
+
+A stamp is created with quality and optional reliability ratings (1-5),
+severity (leaf/branch/root), and optional skill tags.
+
+In wild-west mode the commit is auto-pushed to upstream and origin.
+Use --no-push to skip pushing (offline work).
+
+Examples:
+  wl accept w-abc123 --quality 4
+  wl accept w-abc123 --quality 5 --reliability 4 --severity branch
+  wl accept w-abc123 --quality 3 --skills "go,federation" --message "solid work"`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runAccept(cmd, stdout, stderr, args[0], quality, reliability, severity, skills, message, noPush)
+		},
+	}
+
+	cmd.Flags().IntVar(&quality, "quality", 0, "Quality rating 1-5 (required)")
+	cmd.Flags().IntVar(&reliability, "reliability", 0, "Reliability rating 1-5 (defaults to quality)")
+	cmd.Flags().StringVar(&severity, "severity", "leaf", "Severity: leaf, branch, root")
+	cmd.Flags().StringVar(&skills, "skills", "", "Comma-separated skill tags")
+	cmd.Flags().StringVar(&message, "message", "", "Freeform message")
+	cmd.Flags().BoolVar(&noPush, "no-push", false, "Skip pushing to remotes (offline work)")
+	_ = cmd.MarkFlagRequired("quality")
+
+	return cmd
+}
+
+func runAccept(cmd *cobra.Command, stdout, _ io.Writer, wantedID string, quality, reliability int, severity, skills, message string, noPush bool) error {
+	if reliability == 0 {
+		reliability = quality
+	}
+
+	if err := validateAcceptInputs(quality, reliability, severity); err != nil {
+		return err
+	}
+
+	var skillTags []string
+	if skills != "" {
+		for _, s := range strings.Split(skills, ",") {
+			s = strings.TrimSpace(s)
+			if s != "" {
+				skillTags = append(skillTags, s)
+			}
+		}
+	}
+
+	wlCfg, err := resolveWasteland(cmd)
+	if err != nil {
+		return fmt.Errorf("loading wasteland config: %w", err)
+	}
+	rigHandle := wlCfg.RigHandle
+
+	store := commons.NewWLCommons(wlCfg.LocalDir)
+
+	stamp, err := acceptCompletion(store, wantedID, rigHandle, quality, reliability, severity, skillTags, message)
+	if err != nil {
+		return err
+	}
+
+	fmt.Fprintf(stdout, "%s Accepted %s\n", style.Bold.Render("✓"), wantedID)
+	fmt.Fprintf(stdout, "  Stamp ID: %s\n", stamp.ID)
+	fmt.Fprintf(stdout, "  Quality: %d, Reliability: %d\n", stamp.Quality, stamp.Reliability)
+	fmt.Fprintf(stdout, "  Severity: %s\n", stamp.Severity)
+	if len(stamp.SkillTags) > 0 {
+		fmt.Fprintf(stdout, "  Skills: %s\n", strings.Join(stamp.SkillTags, ", "))
+	}
+	if stamp.Message != "" {
+		fmt.Fprintf(stdout, "  Message: %s\n", stamp.Message)
+	}
+	fmt.Fprintf(stdout, "  Status: completed\n")
+
+	if !noPush {
+		_ = commons.PushWithSync(wlCfg.LocalDir, stdout)
+	}
+
+	return nil
+}
+
+// validateAcceptInputs validates quality, reliability, and severity values.
+func validateAcceptInputs(quality, reliability int, severity string) error {
+	if quality < 1 || quality > 5 {
+		return fmt.Errorf("invalid quality %d: must be 1-5", quality)
+	}
+	if reliability < 1 || reliability > 5 {
+		return fmt.Errorf("invalid reliability %d: must be 1-5", reliability)
+	}
+	validSeverities := map[string]bool{
+		"leaf": true, "branch": true, "root": true,
+	}
+	if !validSeverities[severity] {
+		return fmt.Errorf("invalid severity %q: must be one of leaf, branch, root", severity)
+	}
+	return nil
+}
+
+// acceptCompletion contains the testable business logic for accepting a completion.
+func acceptCompletion(store commons.WLCommonsStore, wantedID, rigHandle string, quality, reliability int, severity string, skillTags []string, message string) (*commons.Stamp, error) {
+	item, err := store.QueryWanted(wantedID)
+	if err != nil {
+		return nil, fmt.Errorf("querying wanted item: %w", err)
+	}
+
+	if item.Status != "in_review" {
+		return nil, fmt.Errorf("wanted item %s is not in_review (status: %s)", wantedID, item.Status)
+	}
+
+	completion, err := store.QueryCompletion(wantedID)
+	if err != nil {
+		return nil, fmt.Errorf("querying completion: %w", err)
+	}
+
+	if completion.CompletedBy == rigHandle {
+		return nil, fmt.Errorf("cannot accept your own completion")
+	}
+
+	stampID := generateStampID(wantedID, rigHandle)
+	stamp := &commons.Stamp{
+		ID:          stampID,
+		Author:      rigHandle,
+		Subject:     completion.CompletedBy,
+		Quality:     quality,
+		Reliability: reliability,
+		Severity:    severity,
+		ContextID:   completion.ID,
+		ContextType: "completion",
+		SkillTags:   skillTags,
+		Message:     message,
+	}
+
+	if err := store.AcceptCompletion(wantedID, completion.ID, rigHandle, stamp); err != nil {
+		return nil, fmt.Errorf("accepting completion: %w", err)
+	}
+
+	return stamp, nil
+}
+
+func generateStampID(wantedID, rigHandle string) string {
+	now := time.Now().UTC().Format(time.RFC3339)
+	h := sha256.Sum256([]byte(wantedID + "|" + rigHandle + "|" + now))
+	return fmt.Sprintf("s-%x", h[:8])
+}

cmd/wl/cmd_accept_test.go

@@ -0,0 +1,177 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/steveyegge/wasteland/internal/commons"
+)
+
+func TestGenerateStampID_Format(t *testing.T) {
+	t.Parallel()
+	id := generateStampID("w-abc123", "my-rig")
+	if !strings.HasPrefix(id, "s-") {
+		t.Errorf("generateStampID() = %q, want prefix 's-'", id)
+	}
+	// "s-" + 16 hex chars = 18 chars total
+	if len(id) != 18 {
+		t.Errorf("generateStampID() length = %d, want 18", len(id))
+	}
+	hexPart := id[2:]
+	for _, c := range hexPart {
+		if (c < '0' || c > '9') && (c < 'a' || c > 'f') {
+			t.Errorf("generateStampID() contains non-hex char %q in %q", string(c), id)
+		}
+	}
+}
+
+func TestValidateAcceptInputs(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name        string
+		quality     int
+		reliability int
+		severity    string
+		wantErr     string
+	}{
+		{"valid", 3, 4, "leaf", ""},
+		{"quality too low", 0, 3, "leaf", "invalid quality"},
+		{"quality too high", 6, 3, "leaf", "invalid quality"},
+		{"reliability too low", 3, 0, "leaf", "invalid reliability"},
+		{"reliability too high", 3, 6, "leaf", "invalid reliability"},
+		{"bad severity", 3, 3, "bad", "invalid severity"},
+		{"valid branch", 5, 5, "branch", ""},
+		{"valid root", 1, 1, "root", ""},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			err := validateAcceptInputs(tt.quality, tt.reliability, tt.severity)
+			if tt.wantErr == "" {
+				if err != nil {
+					t.Errorf("validateAcceptInputs() unexpected error: %v", err)
+				}
+			} else {
+				if err == nil {
+					t.Fatalf("validateAcceptInputs() expected error containing %q", tt.wantErr)
+				}
+				if !strings.Contains(err.Error(), tt.wantErr) {
+					t.Errorf("error = %q, want to contain %q", err.Error(), tt.wantErr)
+				}
+			}
+		})
+	}
+}
+
+func TestAcceptCompletion_Success(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug"})
+	_ = store.ClaimWanted("w-abc", "worker-rig")
+	_ = store.SubmitCompletion("c-test123", "w-abc", "worker-rig", "https://github.com/pr/1")
+
+	stamp, err := acceptCompletion(store, "w-abc", "reviewer-rig", 4, 3, "leaf", []string{"go", "auth"}, "solid work")
+	if err != nil {
+		t.Fatalf("acceptCompletion() error: %v", err)
+	}
+
+	if stamp.Quality != 4 {
+		t.Errorf("stamp.Quality = %d, want 4", stamp.Quality)
+	}
+	if stamp.Reliability != 3 {
+		t.Errorf("stamp.Reliability = %d, want 3", stamp.Reliability)
+	}
+	if stamp.Severity != "leaf" {
+		t.Errorf("stamp.Severity = %q, want %q", stamp.Severity, "leaf")
+	}
+	if stamp.Subject != "worker-rig" {
+		t.Errorf("stamp.Subject = %q, want %q", stamp.Subject, "worker-rig")
+	}
+	if stamp.Author != "reviewer-rig" {
+		t.Errorf("stamp.Author = %q, want %q", stamp.Author, "reviewer-rig")
+	}
+	if stamp.Message != "solid work" {
+		t.Errorf("stamp.Message = %q, want %q", stamp.Message, "solid work")
+	}
+	if len(stamp.SkillTags) != 2 || stamp.SkillTags[0] != "go" || stamp.SkillTags[1] != "auth" {
+		t.Errorf("stamp.SkillTags = %v, want [go auth]", stamp.SkillTags)
+	}
+
+	item, _ := store.QueryWanted("w-abc")
+	if item.Status != "completed" {
+		t.Errorf("Status = %q, want %q", item.Status, "completed")
+	}
+}
+
+func TestAcceptCompletion_NotInReview(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug"})
+
+	_, err := acceptCompletion(store, "w-abc", "reviewer-rig", 4, 3, "leaf", nil, "")
+	if err == nil {
+		t.Fatal("acceptCompletion() expected error for non-in_review item")
+	}
+	if !strings.Contains(err.Error(), "not in_review") {
+		t.Errorf("error = %q, want to contain 'not in_review'", err.Error())
+	}
+}
+
+func TestAcceptCompletion_NotFound(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+
+	_, err := acceptCompletion(store, "w-nonexistent", "reviewer-rig", 4, 3, "leaf", nil, "")
+	if err == nil {
+		t.Fatal("acceptCompletion() expected error for missing item")
+	}
+}
+
+func TestAcceptCompletion_SelfAccept(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug"})
+	_ = store.ClaimWanted("w-abc", "my-rig")
+	_ = store.SubmitCompletion("c-test123", "w-abc", "my-rig", "evidence")
+
+	_, err := acceptCompletion(store, "w-abc", "my-rig", 4, 3, "leaf", nil, "")
+	if err == nil {
+		t.Fatal("acceptCompletion() expected error for self-accept")
+	}
+	if !strings.Contains(err.Error(), "cannot accept your own completion") {
+		t.Errorf("error = %q, want to contain 'cannot accept your own completion'", err.Error())
+	}
+}
+
+func TestAcceptCompletion_QueryCompletionError(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug", Status: "in_review"})
+	store.QueryCompletionErr = fmt.Errorf("completion query error")
+
+	_, err := acceptCompletion(store, "w-abc", "reviewer-rig", 4, 3, "leaf", nil, "")
+	if err == nil {
+		t.Fatal("acceptCompletion() expected error when QueryCompletion fails")
+	}
+	if !strings.Contains(err.Error(), "completion query error") {
+		t.Errorf("error = %q, want to contain 'completion query error'", err.Error())
+	}
+}
+
+func TestAcceptCompletion_AcceptCompletionError(t *testing.T) {
+	t.Parallel()
+	store := newFakeWLCommonsStore()
+	_ = store.InsertWanted(&commons.WantedItem{ID: "w-abc", Title: "Fix bug"})
+	_ = store.ClaimWanted("w-abc", "worker-rig")
+	_ = store.SubmitCompletion("c-test123", "w-abc", "worker-rig", "evidence")
+	store.AcceptCompletionErr = fmt.Errorf("accept store error")
+
+	_, err := acceptCompletion(store, "w-abc", "reviewer-rig", 4, 3, "leaf", nil, "")
+	if err == nil {
+		t.Fatal("acceptCompletion() expected error when AcceptCompletion fails")
+	}
+	if !strings.Contains(err.Error(), "accept store error") {
+		t.Errorf("error = %q, want to contain 'accept store error'", err.Error())
+	}
+}