devrites 6.0.4 → 6.1.1

package/engine/internal/parallel/pathdisjoint_test.go

@@ -1,193 +0,0 @@
-package parallel
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestNormalizePathRejectsDirty(t *testing.T) {
-	t.Parallel()
-	cases := []string{"", " ", "/", "/abs", `C:\windows`, `..`, "a/../b", "../x",
-		// Segment-edge whitespace previously survived normalization
-		// ("0 /." collapsed to "0 "), making the mapping non-idempotent.
-		"0 /.", "src /a.go", "./ \n/x"}
-	for _, raw := range cases {
-		if _, err := NormalizePath(raw); err == nil {
-			t.Fatalf("NormalizePath(%q) should fail", raw)
-		}
-	}
-}
-
-func TestNormalizePathAcceptsRelative(t *testing.T) {
-	t.Parallel()
-	got, err := NormalizePath(`src\foo.go`)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got != "src/foo.go" {
-		t.Fatalf("got %q", got)
-	}
-}
-
-func TestCheckPathDisjointOverlap(t *testing.T) {
-	t.Parallel()
-	_, err := CheckPathDisjoint([]SlicePaths{
-		{ID: "a", Paths: []string{"src/a.go"}},
-		{ID: "b", Paths: []string{"src/a.go"}},
-	}, "")
-	if err == nil || !strings.Contains(err.Error(), "overlap") {
-		t.Fatalf("expected overlap error, got %v", err)
-	}
-	for _, c := range [][2]string{{"src", "src/a.go"}, {"src/a.go", "src"}, {"src/x", "src/x/y/z.go"}} {
-		_, err := CheckPathDisjoint([]SlicePaths{
-			{ID: "a", Paths: []string{c[0]}},
-			{ID: "b", Paths: []string{c[1]}},
-		}, "")
-		if err == nil || !strings.Contains(err.Error(), "overlap") {
-			t.Fatalf("%q vs %q: expected overlap error, got %v", c[0], c[1], err)
-		}
-	}
-}
-
-func TestCheckPathDisjointOK(t *testing.T) {
-	t.Parallel()
-	ids, err := CheckPathDisjoint([]SlicePaths{
-		{ID: "a", Paths: []string{"src/a.go"}},
-		{ID: "b", Paths: []string{"src/b.go"}},
-	}, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(ids) != 2 {
-		t.Fatalf("ids=%v", ids)
-	}
-}
-
-func TestCheckPathDisjointRejectsDevritesPaths(t *testing.T) {
-	t.Parallel()
-	_, err := CheckPathDisjoint([]SlicePaths{
-		{ID: "a", Paths: []string{".devrites/work/state.md"}},
-		{ID: "b", Paths: []string{"src/b.go"}},
-	}, "")
-	if err == nil || !strings.Contains(err.Error(), ".devrites") {
-		t.Fatalf("expected .devrites rejection error, got %v", err)
-	}
-}
-
-func TestCheckPathDisjointSymlinkRoot(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-	target := filepath.Join(dir, "real.go")
-	if err := os.WriteFile(target, []byte("x"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	link := filepath.Join(dir, "link.go")
-	if err := os.Symlink(target, link); err != nil {
-		t.Skip("symlinks unavailable")
-	}
-	_, err := CheckPathDisjoint([]SlicePaths{
-		{ID: "a", Paths: []string{"link.go"}},
-		{ID: "b", Paths: []string{"other.go"}},
-	}, dir)
-	if err == nil || !strings.Contains(err.Error(), "symlink") {
-		t.Fatalf("expected symlink error, got %v", err)
-	}
-}
-
-// A symlinked directory inside a claimed path must also be rejected: the
-// leaf Lstat alone misses it, and a worktree would then write outside itself.
-func TestCheckPathDisjointSymlinkedDir(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-	target := filepath.Join(dir, "outside")
-	if err := os.MkdirAll(target, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(target, filepath.Join(dir, "linkdir")); err != nil {
-		t.Skip("symlinks unavailable")
-	}
-	_, err := CheckPathDisjoint([]SlicePaths{
-		{ID: "a", Paths: []string{"linkdir/x.go"}},
-		{ID: "b", Paths: []string{"other.go"}},
-	}, dir)
-	if err == nil || !strings.Contains(err.Error(), "symlink") {
-		t.Fatalf("expected symlink error for symlinked dir, got %v", err)
-	}
-}
-
-func TestParseSlicesJSONShapes(t *testing.T) {
-	t.Parallel()
-	a, err := ParseSlicesJSON([]byte(`{"slices":[{"id":"a","paths":["x.go"]},{"id":"b","paths":["y.go"]}]}`))
-	if err != nil || len(a) != 2 {
-		t.Fatalf("object shape: %v %#v", err, a)
-	}
-	b, err := ParseSlicesJSON([]byte(`[{"id":"a","paths":["x.go"]},{"id":"b","paths":["y.go"]}]`))
-	if err != nil || len(b) != 2 {
-		t.Fatalf("array shape: %v %#v", err, b)
-	}
-}
-
-func TestCheckPathDisjointOverlapSentinel(t *testing.T) {
-	t.Parallel()
-	_, err := CheckPathDisjoint([]SlicePaths{
-		{ID: "a", Paths: []string{"src/a.go"}},
-		{ID: "b", Paths: []string{"src/a.go"}},
-	}, "")
-	if !errors.Is(err, ErrPathOverlap) {
-		t.Fatalf("expected ErrPathOverlap, got %v", err)
-	}
-}
-
-// A hard refusal whose message merely mentions "overlap" (here via the slice
-// id) must not be classified as a path overlap.
-func TestCheckPathDisjointSymlinkNotOverlap(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-	target := filepath.Join(dir, "real")
-	if err := os.Mkdir(target, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(target, filepath.Join(dir, "linkdir")); err != nil {
-		t.Skip("symlinks unavailable")
-	}
-	slices := []SlicePaths{
-		{ID: "overlap-a", Paths: []string{"linkdir/x.go"}},
-		{ID: "b", Paths: []string{"other.go"}},
-	}
-	_, err := CheckPathDisjoint(slices, dir)
-	if err == nil || errors.Is(err, ErrPathOverlap) {
-		t.Fatalf("expected non-overlap refusal, got %v", err)
-	}
-	if _, err := SelectGreedy(2, slices, dir); err == nil || errors.Is(err, ErrPathOverlap) {
-		t.Fatalf("SelectGreedy must return the hard refusal, got %v", err)
-	}
-}
-
-// SelectGreedy must return a non-overlap refusal from the trial check even when
-// its message mentions "overlap", and must still skip a real overlap.
-func TestSelectGreedyTrialErrorClassification(t *testing.T) {
-	orig := checkPathDisjoint
-	t.Cleanup(func() { checkPathDisjoint = orig })
-	ready := []SlicePaths{
-		{ID: "a", Paths: []string{"a.go"}},
-		{ID: "b", Paths: []string{"b.go"}},
-	}
-
-	hard := errors.New("slice overlap-a: cannot verify paths")
-	checkPathDisjoint = func([]SlicePaths, string) ([]string, error) { return nil, hard }
-	if _, err := SelectGreedy(2, ready, ""); !errors.Is(err, hard) {
-		t.Fatalf("expected the hard refusal to be returned, got %v", err)
-	}
-
-	checkPathDisjoint = func([]SlicePaths, string) ([]string, error) {
-		return nil, fmt.Errorf("%w: x", ErrPathOverlap)
-	}
-	got, err := SelectGreedy(2, ready, "")
-	if err != nil || len(got) != 1 || got[0].ID != "a" {
-		t.Fatalf("real overlap must be skipped, got %v, %v", got, err)
-	}
-}

package/engine/internal/parallel/select_test.go

@@ -1,95 +0,0 @@
-package parallel
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-)
-
-func TestSelectGreedyOneThenMany(t *testing.T) {
-	t.Parallel()
-	round1, err := SelectGreedy(5, []SlicePaths{
-		{ID: "SLICE-001", Paths: []string{"src/a.go"}},
-	}, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(round1) != 1 || round1[0].ID != "SLICE-001" {
-		t.Fatalf("round1=%#v", round1)
-	}
-
-	round2, err := SelectGreedy(5, []SlicePaths{
-		{ID: "SLICE-002", Paths: []string{"src/b.go"}},
-		{ID: "SLICE-003", Paths: []string{"src/c.go"}},
-		{ID: "SLICE-004", Paths: []string{"src/d.go"}},
-		{ID: "SLICE-005", Paths: []string{"src/e.go"}},
-	}, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(round2) != 4 {
-		t.Fatalf("after a one-slice round, cap 5 with 4 ready must select 4, got %d (%#v)", len(round2), round2)
-	}
-}
-
-func TestSelectGreedySkipsOverlapKeepsCap(t *testing.T) {
-	t.Parallel()
-	got, err := SelectGreedy(5, []SlicePaths{
-		{ID: "SLICE-001", Paths: []string{"src/shared.go"}},
-		{ID: "SLICE-002", Paths: []string{"src/shared.go", "src/b.go"}},
-		{ID: "SLICE-003", Paths: []string{"src/c.go"}},
-	}, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(got) != 2 || got[0].ID != "SLICE-001" || got[1].ID != "SLICE-003" {
-		t.Fatalf("got %#v", got)
-	}
-}
-
-func TestSelectGreedyRejectsBadCap(t *testing.T) {
-	t.Parallel()
-	if _, err := SelectGreedy(0, nil, ""); err == nil {
-		t.Fatal("cap 0 should fail")
-	}
-	if _, err := SelectGreedy(11, nil, ""); err == nil {
-		t.Fatal("cap 11 should fail")
-	}
-}
-
-func TestSelectCLIOneThenMany(t *testing.T) {
-	t.Parallel()
-	var stdout, stderr bytes.Buffer
-	in := strings.NewReader(`{"slices":[{"id":"SLICE-001","paths":["src/a.go"]}]}`)
-	code := Run("parallel", []string{"select", "--cap", "5", "-"}, in, &stdout, &stderr)
-	if code != ExitOK {
-		t.Fatalf("code=%d stderr=%s", code, stderr.String())
-	}
-	if got := stdout.String(); got != "select: n_eff=1 mode=serial slices=SLICE-001\n" {
-		t.Fatalf("round1 got %q", got)
-	}
-
-	stdout.Reset()
-	stderr.Reset()
-	in = strings.NewReader(`{"slices":[
-		{"id":"SLICE-002","paths":["src/b.go"]},
-		{"id":"SLICE-003","paths":["src/c.go"]},
-		{"id":"SLICE-004","paths":["src/d.go"]}
-	]}`)
-	code = Run("parallel", []string{"select", "--cap", "5", "-"}, in, &stdout, &stderr)
-	if code != ExitOK {
-		t.Fatalf("code=%d stderr=%s", code, stderr.String())
-	}
-	if got := stdout.String(); got != "select: n_eff=3 mode=parallel slices=SLICE-002,SLICE-003,SLICE-004\n" {
-		t.Fatalf("round2 got %q; must not stay n_eff=1", got)
-	}
-}
-
-func TestSelectCLIRequiresCap(t *testing.T) {
-	t.Parallel()
-	var stdout, stderr bytes.Buffer
-	code := Run("parallel", []string{"select", "-"}, strings.NewReader(`{"slices":[]}`), &stdout, &stderr)
-	if code != ExitUsage {
-		t.Fatalf("code=%d want %d stderr=%s", code, ExitUsage, stderr.String())
-	}
-}

package/engine/internal/parallel/testdata/fuzz/FuzzPathDisjoint/a449b81b4711b7b4

@@ -1,3 +0,0 @@
-go test fuzz v1
-string("0 /")
-[]byte("0")

package/engine/internal/reason/reason_test.go

@@ -1,37 +0,0 @@
-package reason
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestCatalogIsKnownUniqueAndStableShaped(t *testing.T) {
-	all := All()
-	if len(all) == 0 {
-		t.Fatal("empty reason catalog")
-	}
-	for i, id := range all {
-		if !Known(id) {
-			t.Fatalf("catalog id %q is not known", id)
-		}
-		if !strings.HasPrefix(string(id), "DRV-") {
-			t.Fatalf("reason id %q lacks DRV- prefix", id)
-		}
-		if i > 0 && all[i-1] >= id {
-			t.Fatalf("catalog is not strictly sorted: %q then %q", all[i-1], id)
-		}
-	}
-}
-
-func TestParseRejectsUnregisteredAndFreeText(t *testing.T) {
-	for _, want := range []ID{GateReadinessStale, GateSealMissing} {
-		if got, err := Parse(string(want)); err != nil || got != want {
-			t.Fatalf("Parse registered = %q, %v", got, err)
-		}
-	}
-	for _, raw := range []string{"", "DRV-UNKNOWN", "/absolute/repo", "operator-private-value"} {
-		if _, err := Parse(raw); err == nil {
-			t.Fatalf("Parse(%q) should fail", raw)
-		}
-	}
-}

package/engine/internal/release/release_test.go

@@ -1,181 +0,0 @@
-package release
-
-import (
-	"archive/tar"
-	"bytes"
-	"compress/gzip"
-	"context"
-	"crypto/sha256"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-func TestLatestAndAcquireVerifiedRelease(t *testing.T) {
-	const tag = "v4.1.0"
-	bundleName := "devrites-" + tag + ".tar.gz"
-	bundle := testBundle(t, tag, map[string]string{
-		"package.json": `{"version":"4.1.0"}`,
-		"pack/generated/claude/skills/rite/SKILL.md": "rite\n",
-	})
-	binaryName, err := platformBinaryName()
-	if err != nil {
-		t.Skip(err)
-	}
-	engine := []byte("#!/bin/sh\nprintf success > \"$MARKER\"\nexit 23\n")
-	assets := map[string][]byte{
-		bundleName: bundle,
-		binaryName: engine,
-	}
-	if runtime.GOOS == "windows" {
-		t.Skip("positive-control engine is a shell script")
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/repos/owner/repo/releases/latest" {
-			_, _ = fmt.Fprintf(w, `{"tag_name":%q}`, tag)
-			return
-		}
-		name := filepath.Base(r.URL.Path)
-		if strings.HasSuffix(name, ".sha256") {
-			assetName := strings.TrimSuffix(name, ".sha256")
-			asset, ok := assets[assetName]
-			if !ok {
-				http.NotFound(w, r)
-				return
-			}
-			_, _ = fmt.Fprintf(w, "%x  %s\n", sha256.Sum256(asset), assetName)
-			return
-		}
-		asset, ok := assets[name]
-		if !ok {
-			http.NotFound(w, r)
-			return
-		}
-		_, _ = w.Write(asset)
-	}))
-	defer server.Close()
-	oldAPI, oldWeb := apiBaseURL, webBaseURL
-	apiBaseURL, webBaseURL = server.URL, server.URL
-	t.Cleanup(func() { apiBaseURL, webBaseURL = oldAPI, oldWeb })
-
-	gotTag, err := Latest(context.Background(), "owner/repo")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if gotTag != tag {
-		t.Fatalf("latest tag = %q, want %q", gotTag, tag)
-	}
-	candidate, cleanup, err := Acquire(context.Background(), "owner/repo", tag)
-	if err != nil {
-		t.Fatal(err)
-	}
-	root := filepath.Dir(candidate.SourceDir)
-	if _, err := os.Stat(filepath.Join(candidate.PayloadDir, "claude", "skills", "rite", "SKILL.md")); err != nil {
-		t.Fatalf("extracted payload: %v", err)
-	}
-	marker := filepath.Join(t.TempDir(), "marker")
-	cmd := exec.Command(candidate.EnginePath)
-	cmd.Env = append(os.Environ(), "MARKER="+marker)
-	if err := cmd.Run(); err == nil {
-		t.Fatal("acquired engine exited successfully; want positive-control exit 23")
-	} else if exit, ok := err.(*exec.ExitError); !ok || exit.ExitCode() != 23 {
-		t.Fatalf("acquired engine exit = %v, want 23", err)
-	}
-	if got, err := os.ReadFile(marker); err != nil || string(got) != "success" {
-		t.Fatalf("acquired engine marker = %q, %v", got, err)
-	}
-	cleanup()
-	if _, err := os.Stat(root); !os.IsNotExist(err) {
-		t.Fatalf("cleanup kept %s: %v", root, err)
-	}
-}
-
-func TestValidTag(t *testing.T) {
-	for _, tc := range []struct {
-		tag  string
-		want bool
-	}{
-		{tag: "v4.1.0", want: true},
-		{tag: "v4.1.0-rc.1+build.2", want: true},
-		{tag: "4.1.0", want: false},
-		{tag: "v4.1.0-01", want: false},
-		{tag: "v4.1", want: false},
-	} {
-		if got := validTag(tc.tag); got != tc.want {
-			t.Errorf("validTag(%q) = %t, want %t", tc.tag, got, tc.want)
-		}
-	}
-}
-
-func TestAcquireRejectsChecksumMismatch(t *testing.T) {
-	const tag = "v4.1.0"
-	bundleName := "devrites-" + tag + ".tar.gz"
-	bundle := testBundle(t, tag, map[string]string{
-		"package.json": `{"version":"4.1.0"}`,
-		"pack/generated/claude/skills/rite/SKILL.md": "rite\n",
-	})
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if strings.HasSuffix(r.URL.Path, ".sha256") {
-			_, _ = fmt.Fprintf(w, "%064d  %s\n", 0, bundleName)
-			return
-		}
-		_, _ = w.Write(bundle)
-	}))
-	defer server.Close()
-	oldWeb := webBaseURL
-	webBaseURL = server.URL
-	t.Cleanup(func() { webBaseURL = oldWeb })
-
-	_, _, err := Acquire(context.Background(), "owner/repo", tag)
-	if err == nil || !strings.Contains(err.Error(), "checksum mismatch") {
-		t.Fatalf("Acquire error = %v, want checksum mismatch", err)
-	}
-}
-
-func TestExtractBundleRejectsPathTraversal(t *testing.T) {
-	const tag = "v4.1.0"
-	archive := filepath.Join(t.TempDir(), "unsafe.tar.gz")
-	data := testBundle(t, tag, map[string]string{"../escape": "bad"})
-	if err := os.WriteFile(archive, data, 0o600); err != nil {
-		t.Fatal(err)
-	}
-	_, err := extractBundle(archive, t.TempDir(), tag)
-	if err == nil || !strings.Contains(err.Error(), "unsafe path") {
-		t.Fatalf("extractBundle error = %v, want unsafe path", err)
-	}
-}
-
-func testBundle(t *testing.T, tag string, files map[string]string) []byte {
-	t.Helper()
-	var raw bytes.Buffer
-	gz := gzip.NewWriter(&raw)
-	tw := tar.NewWriter(gz)
-	for name, body := range files {
-		data := []byte(body)
-		header := &tar.Header{
-			Name:     "devrites-" + tag + "/" + name,
-			Mode:     0o644,
-			Size:     int64(len(data)),
-			Typeflag: tar.TypeReg,
-		}
-		if err := tw.WriteHeader(header); err != nil {
-			t.Fatal(err)
-		}
-		if _, err := tw.Write(data); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := tw.Close(); err != nil {
-		t.Fatal(err)
-	}
-	if err := gz.Close(); err != nil {
-		t.Fatal(err)
-	}
-	return raw.Bytes()
-}