devrites 6.0.4 → 6.1.0

package/engine/internal/state/taskgraph_fuzz_test.go

@@ -1,38 +0,0 @@
-package state
-
-import "testing"
-
-func FuzzTaskGraphParsing(f *testing.F) {
-	f.Add([]byte("## SLICE-1\n\nDependencies: none\n"))
-	f.Add([]byte("## SLICE-1\nDependencies: [SLICE-2]\n\n## SLICE-2\nDependencies: [SLICE-1]\n"))
-	f.Add([]byte("## SLICE-1\nDependencies: none\ndepends_on: SLICE-9\n"))
-	f.Add([]byte("## SLICE-1\n## SLICE-1\nDependencies: none\n"))
-	f.Add([]byte("## SLICE-1\nDependencies: [oops, SLICE-2]\n\n## SLICE-2\ndepends_on: [SLICE-1]\n"))
-	f.Add([]byte("## SLICE-42\nDependencies:\n"))
-	f.Add([]byte(""))
-	f.Fuzz(func(t *testing.T, doc []byte) {
-		result := ParseTaskGraph(doc)
-
-		known := make(map[string]bool, len(result.Slices))
-		for _, slice := range result.Slices {
-			if !sliceIDValidRE.MatchString(slice.ID) {
-				t.Fatalf("slice id %q does not satisfy the id grammar", slice.ID)
-			}
-			if known[slice.ID] {
-				t.Fatalf("slice id %q emitted twice", slice.ID)
-			}
-			known[slice.ID] = true
-		}
-		unknown := make(map[string]bool, len(result.Unknown))
-		for _, dep := range result.Unknown {
-			unknown[dep] = true
-		}
-		for _, slice := range result.Slices {
-			for _, dep := range slice.Dependencies {
-				if !known[dep] && !unknown[dep] {
-					t.Fatalf("slice %s depends on %q which is neither defined nor reported unknown", slice.ID, dep)
-				}
-			}
-		}
-	})
-}

package/engine/internal/state/taskgraph_test.go

@@ -1,43 +0,0 @@
-package state
-
-import (
-	"strings"
-	"testing"
-)
-
-const fenceLive = "## SLICE-001\nDependencies: SLICE-002\n\n## SLICE-002\nDependencies: none\n"
-
-const fenceDoc = "## SLICE-001\nDependencies: SLICE-002\n\nExample layout:\n\n```markdown\n## SLICE-002\nDependencies: none\n```\n"
-
-func TestParseTaskGraphUnfencedControlYieldsTwoSlices(t *testing.T) {
-	got := ParseTaskGraph([]byte(fenceLive))
-	if len(got.Slices) != 2 || len(got.Unknown) != 0 {
-		t.Fatalf("slices=%v unknown=%v, want two slices and no unknown", got.Slices, got.Unknown)
-	}
-}
-
-func TestParseTaskGraphIgnoresFencedSliceHeader(t *testing.T) {
-	got := ParseTaskGraph([]byte(fenceDoc))
-	if len(got.Slices) != 1 || got.Slices[0].ID != "SLICE-001" {
-		t.Fatalf("slices=%v, want only SLICE-001", got.Slices)
-	}
-	if len(got.Unknown) != 1 || got.Unknown[0] != "SLICE-002" {
-		t.Fatalf("unknown=%v, want the dangling SLICE-002 reported", got.Unknown)
-	}
-}
-
-func TestExtractTaskSliceIgnoresFencedSliceHeader(t *testing.T) {
-	if _, ok := ExtractTaskSlice([]byte(fenceDoc), "SLICE-002"); ok {
-		t.Fatal("fenced SLICE-002 reported as a live slice")
-	}
-	block, ok := ExtractTaskSlice([]byte(fenceDoc), "SLICE-001")
-	if !ok {
-		t.Fatal("live SLICE-001 not found")
-	}
-	if !strings.Contains(block, "```markdown") || !strings.Contains(block, "## SLICE-002") {
-		t.Fatalf("live slice must keep its fenced example verbatim, got %q", block)
-	}
-	if got, ok := ExtractTaskSlice([]byte(fenceLive), "SLICE-002"); !ok || !strings.HasPrefix(got, "## SLICE-002") {
-		t.Fatalf("unfenced control: got %q ok=%v", got, ok)
-	}
-}

package/engine/internal/state/testdata/fuzz/FuzzCursorRoundTrip/114b28f68c1fa4db

@@ -1,4 +0,0 @@
-go test fuzz v1
-byte('\x00')
-string("0")
-[]byte("```")

package/engine/internal/state/testdata/fuzz/FuzzCursorRoundTrip/378a0f2218e812ea

@@ -1,4 +0,0 @@
-go test fuzz v1
-byte('\x10')
-string("\r|")
-[]byte("0")

package/engine/internal/state/testdata/fuzz/FuzzCursorRoundTrip/39eaa26fcb481e3c

@@ -1,4 +0,0 @@
-go test fuzz v1
-byte('\x05')
-string("\xe4")
-[]byte("")

package/engine/internal/state/testdata/fuzz/FuzzCursorRoundTrip/776ca1dc0143acf0

@@ -1,4 +0,0 @@
-go test fuzz v1
-byte('\b')
-string(" ")
-[]byte("0")

package/engine/internal/state/testdata/fuzz/FuzzCursorRoundTrip/9295930c1ebb81df

@@ -1,4 +0,0 @@
-go test fuzz v1
-byte('ñ')
-string("|")
-[]byte("```")

package/engine/internal/state/testdata/fuzz/FuzzCursorRoundTrip/a60de309dc33be0d

@@ -1,4 +0,0 @@
-go test fuzz v1
-byte('\b')
-string("\n")
-[]byte("0")

package/engine/internal/state/testdata/fuzz/FuzzCursorRoundTrip/f04dc7b06ef7c99f

@@ -1,4 +0,0 @@
-go test fuzz v1
-byte('\x12')
-string("\x00")
-[]byte("0")

package/engine/internal/state/testdata/fuzz/FuzzCursorRoundTrip/f3000ac510878bd6

@@ -1,4 +0,0 @@
-go test fuzz v1
-byte('\x05')
-string("0")
-[]byte("\x8e")

package/engine/internal/state/testdata/fuzz/FuzzWorkspaceSchemaRow/a75aabb9f2a847d5

@@ -1,2 +0,0 @@
-go test fuzz v1
-[]byte("sChemA:1")

package/engine/internal/state/workspaceschema_fuzz_test.go

@@ -1,27 +0,0 @@
-package state
-
-import (
-	"strings"
-	"testing"
-)
-
-func FuzzWorkspaceSchemaRow(f *testing.F) {
-	f.Add([]byte("| schema | 5 |"))
-	f.Add([]byte("- schema: 2"))
-	f.Add([]byte("| schema | abc |"))
-	f.Add([]byte("| schema | 0 |"))
-	f.Add([]byte("## Cursor\n\n| key | value |"))
-	f.Add([]byte("```\n| schema | 7 |\n```"))
-	f.Fuzz(func(t *testing.T, doc []byte) {
-		version, err := workspaceSchemaRow(strings.Split(string(doc), "\n"))
-		if err != nil {
-			if version != 0 {
-				t.Fatalf("error result carries version %d", version)
-			}
-			return
-		}
-		if version < 1 {
-			t.Fatalf("success with non-positive version %d", version)
-		}
-	})
-}

package/engine/internal/state/workspaceschema_test.go

@@ -1,101 +0,0 @@
-package state
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"testing"
-)
-
-func writeSchemaWorkspace(t *testing.T, stateBody string) (root, slug string) {
-	t.Helper()
-	root = t.TempDir()
-	slug = "demo"
-	if err := os.MkdirAll(featureDir(root, slug), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(featureDir(root, slug), LedgerFile), []byte(stateBody), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	return root, slug
-}
-
-func TestWorkspaceSchemaDefaultsToPreV5WhenRowIsAbsent(t *testing.T) {
-	root, slug := writeSchemaWorkspace(t, "- Phase: build\n- Status: running\n")
-	version, err := WorkspaceSchema(root, slug)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if version != 2 {
-		t.Fatalf("version=%d want 2 (pre-v5 default)", version)
-	}
-	if err := RequireWorkspaceSchema(root, slug); err == nil {
-		t.Fatal("pre-v5 workspace must be refused")
-	} else if !strings.Contains(err.Error(), "devrites-engine migrate demo") {
-		t.Fatalf("refusal must name migrate, got %v", err)
-	}
-}
-
-func TestWorkspaceSchemaAcceptsCurrentAndRefusesNewer(t *testing.T) {
-	root, slug := writeSchemaWorkspace(t, "| phase | build |\n| schema | 4 |\n")
-	if err := RequireWorkspaceSchema(root, slug); err != nil {
-		t.Fatalf("current schema must pass, got %v", err)
-	}
-
-	root, slug = writeSchemaWorkspace(t, "| phase | build |\n| schema | 9 |\n")
-	err := RequireWorkspaceSchema(root, slug)
-	if err == nil {
-		t.Fatal("newer schema must be refused")
-	}
-	if !strings.Contains(err.Error(), "upgrade devrites") {
-		t.Fatalf("newer-schema refusal must name the upgrade path, got %v", err)
-	}
-}
-
-func TestWorkspaceSchemaRefusesMalformedRow(t *testing.T) {
-	root, slug := writeSchemaWorkspace(t, "| phase | build |\n| schema | banana |\n")
-	if err := RequireWorkspaceSchema(root, slug); err == nil {
-		t.Fatal("malformed schema row must be refused")
-	}
-}
-
-func TestWorkspaceSchemaMissingLedgerIsRefused(t *testing.T) {
-	root := t.TempDir()
-	if err := RequireWorkspaceSchema(root, "absent"); err == nil {
-		t.Fatal("missing workspace must be refused")
-	}
-}
-
-func TestRefusalMessagesFormatSchemaVersionWithoutVersionLabel(t *testing.T) {
-	root, slug := writeSchemaWorkspace(t, "| phase | build |\n| schema | 2 |\n")
-	older := RequireWorkspaceSchema(root, slug)
-	root, slug = writeSchemaWorkspace(t, fmt.Sprintf("| phase | build |\n| schema | %d |\n", SchemaVersion+1))
-	newer := RequireWorkspaceSchema(root, slug)
-	for name, err := range map[string]error{"older": older, "newer": newer} {
-		if err == nil {
-			t.Fatalf("%s schema must be refused", name)
-		}
-		if strings.Contains(err.Error(), "v5") {
-			t.Fatalf("%s refusal hardcodes a version label: %v", name, err)
-		}
-		if want := fmt.Sprintf("%d", SchemaVersion); !strings.Contains(err.Error(), want) {
-			t.Fatalf("%s refusal must format SchemaVersion %s: %v", name, want, err)
-		}
-	}
-}
-
-func TestStateTemplateSchemaCellMatchesEngine(t *testing.T) {
-	raw, err := os.ReadFile(filepath.Join("..", "..", "..", "pack", ".claude", "skills", "rite-spec", "reference", "state-workspace.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	m := regexp.MustCompile(`(?m)^\|\s*schema\s*\|\s*(\d+)\s*\|`).FindSubmatch(raw)
-	if m == nil {
-		t.Fatal("template has no schema cell")
-	}
-	if want := fmt.Sprintf("%d", SchemaVersion); string(m[1]) != want {
-		t.Fatalf("template schema cell=%s, engine SchemaVersion=%s", m[1], want)
-	}
-}

package/engine/internal/state/write_test.go

@@ -1,136 +0,0 @@
-//go:build unix || windows
-
-package state
-
-import (
-	"errors"
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-)
-
-// A waiter that opened the lock file before its directory was renamed away must
-// not acquire the archived inode, and must not recreate the directory.
-func TestLockOpenedRefusesLockMovedWhileWaiting(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("windows refuses to rename or remove a path with an open handle, so the stale state cannot be built")
-	}
-	root := t.TempDir()
-	lockPath := filepath.Join(root, "work", "feat", ".lock")
-	if err := os.MkdirAll(filepath.Dir(lockPath), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	f, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0o644)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.MkdirAll(filepath.Join(root, "archive"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Rename(filepath.Dir(lockPath), filepath.Join(root, "archive", "feat")); err != nil {
-		t.Fatal(err)
-	}
-
-	if l, err := lockOpened(f, lockPath); !errors.Is(err, ErrWorkspaceMoved) {
-		if l != nil {
-			_ = l.release()
-		}
-		t.Fatalf("lockOpened on a moved workspace = %v, want ErrWorkspaceMoved", err)
-	}
-	if _, err := os.Lstat(filepath.Join(root, "work", "feat")); !os.IsNotExist(err) {
-		t.Fatalf("work/feat reappeared after a stale lock: %v", err)
-	}
-}
-
-// A lock file replaced at the same path leaves the opened inode stale too.
-func TestLockOpenedRefusesReplacedLockFile(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("windows refuses to rename or remove a path with an open handle, so the stale state cannot be built")
-	}
-	lockPath := filepath.Join(t.TempDir(), ".lock")
-	f, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0o644)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Remove(lockPath); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(lockPath, nil, 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if l, err := lockOpened(f, lockPath); !errors.Is(err, ErrWorkspaceMoved) {
-		if l != nil {
-			_ = l.release()
-		}
-		t.Fatalf("lockOpened on a replaced lock file = %v, want ErrWorkspaceMoved", err)
-	}
-}
-
-func TestWithFeatureLockAcquiresCurrentLockFile(t *testing.T) {
-	ran := false
-	if err := WithFeatureLock(t.TempDir(), "feat", func() error { ran = true; return nil }); err != nil || !ran {
-		t.Fatalf("WithFeatureLock = %v, ran %v, want success", err, ran)
-	}
-}
-
-// The identity check is shared by every platform's lock, so it is exercised
-// without renaming anything: the held file is compared with whatever is at path.
-func TestConfirmLockComparesHeldFileWithPath(t *testing.T) {
-	dir := t.TempDir()
-	open := func(name string) *os.File {
-		f, err := os.OpenFile(filepath.Join(dir, name), os.O_CREATE|os.O_RDWR, 0o644)
-		if err != nil {
-			t.Fatal(err)
-		}
-		return f
-	}
-	held := open("held.lock")
-	other := open("other.lock")
-	defer func() { _ = other.Close() }()
-
-	l, err := confirmLock(&fileLock{f: held}, held.Name())
-	if err != nil || l == nil {
-		t.Fatalf("confirmLock on the current file = %v, %v, want the lock", l, err)
-	}
-	_ = l.f.Close()
-
-	for name, path := range map[string]string{
-		"different file at path": other.Name(),
-		"missing path":           filepath.Join(dir, "gone.lock"),
-	} {
-		f := open("probe-" + filepath.Base(path))
-		l, err := confirmLock(&fileLock{f: f}, path)
-		if !errors.Is(err, ErrWorkspaceMoved) || l != nil {
-			t.Errorf("%s: confirmLock = %v, %v, want ErrWorkspaceMoved and no lock", name, l, err)
-		}
-		if _, statErr := f.Stat(); statErr == nil {
-			t.Errorf("%s: stale lock was not released (file still open)", name)
-		}
-	}
-}
-
-// A slug that is not a single path element must be refused before any directory
-// or lock file is created, so the lock sink cannot be steered outside work/.
-func TestFeatureLockRefusesInvalidSlug(t *testing.T) {
-	for _, slug := range []string{"../evil", "a/b", `a\b`, "..", "."} {
-		for name, lock := range map[string]func(root string, ran *bool) error{
-			"WithFeatureLock": func(root string, ran *bool) error {
-				return WithFeatureLock(root, slug, func() error { *ran = true; return nil })
-			},
-			"WithFeatureLockRelease": func(root string, ran *bool) error {
-				return WithFeatureLockRelease(root, slug, func(func()) error { *ran = true; return nil })
-			},
-		} {
-			root := t.TempDir()
-			var ran bool
-			err := lock(root, &ran)
-			if err == nil || ran {
-				t.Errorf("%s(%q) = %v, ran %v, want an error and fn not run", name, slug, err, ran)
-			}
-			if _, statErr := os.Stat(filepath.Join(root, "evil", ".lock")); statErr == nil {
-				t.Errorf("%s(%q) created a lock file outside work/", name, slug)
-			}
-		}
-	}
-}

package/engine/internal/version/version_test.go

@@ -1,29 +0,0 @@
-package version
-
-import "testing"
-
-func TestCompare(t *testing.T) {
-	cases := []struct {
-		a, b   string
-		cmp    int
-		wantOK bool
-	}{
-		{"1.2.3", "1.2.3", 0, true},
-		{"v1.2.4", "1.2.3", 1, true},
-		{"1.2", "1.2.0", 0, true},
-		{"1.10.0", "1.9.9", 1, true},
-		{"2.0.0", "1.9.9", 1, true},
-		{"1.9.9", "2.0.0", -1, true},
-		{"2.0.0-rc.1", "2.0.0", 0, true},
-		{"1.0.0+build", "1.0.1", -1, true},
-		{"dev", "1.0.0", 0, false},
-		{"1.x.0", "1.0.0", 0, false},
-		{"", "1.0.0", 0, false},
-	}
-	for _, c := range cases {
-		got, ok := Compare(c.a, c.b)
-		if got != c.cmp || ok != c.wantOK {
-			t.Errorf("Compare(%q, %q) = %d, %v; want %d, %v", c.a, c.b, got, ok, c.cmp, c.wantOK)
-		}
-	}
-}

package/engine/internal/workflow/commands_test.go

@@ -1,18 +0,0 @@
-package workflow
-
-import "testing"
-
-func TestForActionExtractsCanonicalInvocation(t *testing.T) {
-	for _, tc := range []struct {
-		action string
-		verb   string
-	}{
-		{action: "/rite-define after readiness passes", verb: "define"},
-		{action: "resume with $rite-build", verb: "build"},
-		{action: "none"},
-	} {
-		if got := ForAction(tc.action); got.Verb != tc.verb {
-			t.Fatalf("ForAction(%q).Verb=%q, want %q", tc.action, got.Verb, tc.verb)
-		}
-	}
-}

package/engine/note_routing_test.go

@@ -1,95 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func noteWorkspace(t *testing.T) (project, root string) {
-	t.Helper()
-	project = t.TempDir()
-	root = filepath.Join(project, ".devrites")
-	workspace := filepath.Join(root, "work", "feature")
-	if err := os.MkdirAll(workspace, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	writeBasenameFile(t, workspace, "state.md", "| schema | 4 |\n")
-	t.Setenv("DEVRITES_ROOT", root)
-	return project, root
-}
-
-func TestNoteLifecycleAddCheckRepairRm(t *testing.T) {
-	project, _ := noteWorkspace(t)
-	writeBasenameFile(t, project, "pool.go", "package src\n\nconst maxConns = 4\n")
-
-	var stdout, stderr bytes.Buffer
-	args := []string{"note", "add", "feature", "pool.go", "maxConns = 4", "pool cap rationale", "fairness not memory"}
-	if code := run(args, strings.NewReader(""), &stdout, &stderr); code != exitOK {
-		t.Fatalf("add code=%d stderr=%q", code, stderr.String())
-	}
-	if !strings.Contains(stdout.String(), "added: NOTE-001") {
-		t.Fatalf("add stdout=%q", stdout.String())
-	}
-
-	// A quote that does not resolve is refused at write time.
-	stdout.Reset()
-	stderr.Reset()
-	args = []string{"note", "add", "feature", "pool.go", "nope = 1", "bad note"}
-	if code := run(args, strings.NewReader(""), &stdout, &stderr); code != exitBlocked {
-		t.Fatalf("add bad quote code=%d", code)
-	}
-
-	stdout.Reset()
-	if code := run([]string{"note", "check", "feature"}, strings.NewReader(""), &stdout, &stderr); code != exitOK {
-		t.Fatalf("check code=%d", code)
-	}
-	if !strings.Contains(stdout.String(), "result: exact") {
-		t.Fatalf("check stdout=%q", stdout.String())
-	}
-
-	// Relocate the anchor to another file: check reports moved, --repair rewrites.
-	writeBasenameFile(t, project, "pool.go", "package src\n\nconst maxConns = 8\n")
-	if err := os.MkdirAll(filepath.Join(project, "config"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	writeBasenameFile(t, filepath.Join(project, "config"), "limits.go", "package config\nconst maxConns = 4\n")
-	stdout.Reset()
-	if code := run([]string{"note", "check", "feature"}, strings.NewReader(""), &stdout, &stderr); code != exitBlocked {
-		t.Fatalf("moved check code=%d", code)
-	}
-	if !strings.Contains(stdout.String(), "NOTE-001 moved -> config/limits.go") {
-		t.Fatalf("moved stdout=%q", stdout.String())
-	}
-	stdout.Reset()
-	if code := run([]string{"note", "check", "feature", "--repair"}, strings.NewReader(""), &stdout, &stderr); code != exitOK {
-		t.Fatalf("repair code=%d stdout=%q", code, stdout.String())
-	}
-	raw, err := os.ReadFile(filepath.Join(project, ".devrites", "work", "feature", "notes.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(raw), "SUBJECT: config/limits.go") {
-		t.Fatalf("repair did not rewrite subject: %q", raw)
-	}
-
-	stdout.Reset()
-	if code := run([]string{"note", "rm", "feature", "NOTE-001"}, strings.NewReader(""), &stdout, &stderr); code != exitOK {
-		t.Fatalf("rm code=%d stderr=%q", code, stderr.String())
-	}
-	raw, _ = os.ReadFile(filepath.Join(project, ".devrites", "work", "feature", "notes.md"))
-	if strings.Contains(string(raw), "NOTE-001") {
-		t.Fatal("rm left the note in place")
-	}
-}
-
-func TestNoteHelpRoutes(t *testing.T) {
-	for _, args := range [][]string{{"note", "help"}, {"note", "--help"}} {
-		var stdout, stderr bytes.Buffer
-		if code := run(args, strings.NewReader(""), &stdout, &stderr); code != exitOK || !strings.Contains(stdout.String(), "note <add|list|check|rm>") {
-			t.Fatalf("%v code=%d stdout=%q stderr=%q", args, code, stdout.String(), stderr.String())
-		}
-	}
-}