devrites 3.2.27 → 4.0.0

package/engine/internal/lib/adoption_test.go

@@ -1,121 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestDecisionsSearchFindsArchivedDecision(t *testing.T) {
-	root := t.TempDir()
-	p := filepath.Join(root, "archive", "auth-refresh", "decisions.md")
-	mustWrite(t, p, "# Decisions\n- Use short-lived refresh tokens for auth sessions.\n")
-	var out, err bytes.Buffer
-	if code := Decisions(root, []string{"search", "refresh", "tokens"}, &out, &err); code != 0 {
-		t.Fatalf("code=%d stderr=%s", code, err.String())
-	}
-	if !strings.Contains(out.String(), "auth-refresh") || !strings.Contains(out.String(), "refresh tokens") {
-		t.Fatalf("missing decision hit:\n%s", out.String())
-	}
-}
-
-func TestDecisionsIndexAcceptsLongDecisionLine(t *testing.T) {
-	root := t.TempDir()
-	decision := "- " + strings.Repeat("a", 128*1024) + " searchable-tail\n"
-	mustWrite(t, filepath.Join(root, "archive", "large", "decisions.md"), decision)
-	var out, err bytes.Buffer
-
-	if code := Decisions(root, []string{"index"}, &out, &err); code != 0 {
-		t.Fatalf("code=%d stderr=%s", code, err.String())
-	}
-	indexed, readErr := os.ReadFile(filepath.Join(root, "decisions-index.jsonl"))
-	if readErr != nil {
-		t.Fatal(readErr)
-	}
-	if !bytes.Contains(indexed, []byte("searchable-tail")) {
-		t.Fatal("long decision was silently omitted from the index")
-	}
-}
-
-func TestSecretScanBlocksHighSeverityTouchedFile(t *testing.T) {
-	project := t.TempDir()
-	root := filepath.Join(project, ".devrites")
-	mustWrite(t, filepath.Join(root, "ACTIVE"), "leak\n")
-	mustWrite(t, filepath.Join(root, "work", "leak", "touched-files.md"), "- secrets.txt\n")
-	mustWrite(t, filepath.Join(project, "secrets.txt"), "token=ghp_abcdefghijklmnopqrstuvwxyzABCDE12345\n")
-	var out, err bytes.Buffer
-	if code := SecretScan(root, nil, &out, &err); code != 3 {
-		t.Fatalf("want block rc=3 got %d stdout=%s stderr=%s", code, out.String(), err.String())
-	}
-}
-
-func TestSecretScanFailsClosedWhenGitIsUnavailable(t *testing.T) {
-	project := t.TempDir()
-	root := filepath.Join(project, ".devrites")
-	t.Chdir(project)
-	t.Setenv("PATH", t.TempDir())
-
-	var out, err bytes.Buffer
-	if code := SecretScan(root, nil, &out, &err); code != 2 {
-		t.Fatalf("want rc=2 got %d stdout=%s stderr=%s", code, out.String(), err.String())
-	}
-	if !strings.Contains(err.String(), "cannot inspect changed paths") {
-		t.Fatalf("missing fail-closed diagnostic: %s", err.String())
-	}
-}
-
-func TestDocsStaleFailsClosedWhenGitIsUnavailable(t *testing.T) {
-	project := t.TempDir()
-	root := filepath.Join(project, ".devrites")
-	t.Chdir(project)
-	t.Setenv("PATH", t.TempDir())
-
-	var out, err bytes.Buffer
-	if code := DocsStale(root, nil, &out, &err); code != 2 {
-		t.Fatalf("want rc=2 got %d stdout=%s stderr=%s", code, out.String(), err.String())
-	}
-	if !strings.Contains(err.String(), "cannot inspect changed paths") {
-		t.Fatalf("missing fail-closed diagnostic: %s", err.String())
-	}
-}
-
-func TestSpecDedupeSearchesScratchPRDs(t *testing.T) {
-	project := t.TempDir()
-	root := filepath.Join(project, ".devrites")
-	mustWrite(t, filepath.Join(project, ".scratch", "webhooks", "PRD.md"), "# Webhook retries\nAdd retry backoff for failed webhooks.\n")
-	var out, err bytes.Buffer
-	if code := SpecDedupe(root, []string{"webhook", "retry", "backoff"}, &out, &err); code != 0 {
-		t.Fatalf("code=%d stderr=%s", code, err.String())
-	}
-	if !strings.Contains(out.String(), ".scratch/webhooks/PRD.md") {
-		t.Fatalf("missing dedupe hit:\n%s", out.String())
-	}
-}
-
-func TestBoundedCommandOutputStopsLongRunningProcess(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("test command uses POSIX sh")
-	}
-
-	started := time.Now()
-	if _, err := boundedCommandOutput(50*time.Millisecond, "", "sh", "-c", "sleep 2"); err == nil {
-		t.Fatal("expected timed-out command to return an error")
-	}
-	if elapsed := time.Since(started); elapsed > time.Second {
-		t.Fatalf("timed-out command took %s", elapsed)
-	}
-}
-
-func mustWrite(t *testing.T, path, text string) {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, []byte(text), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}

package/engine/internal/lib/analyze.go

@@ -1,232 +0,0 @@
-package lib
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"regexp"
-	"sort"
-	"strings"
-
-	"github.com/devrites/devrites/internal/workflow"
-)
-
-// Analyze cross-checks a feature's spec.md against its tasks.md before any code is
-// written, so a coverage gap surfaces as a one-line plan edit rather than a reslice
-// mid-build. It emits a markdown report and flags:
-//
-//	Coverage    : a spec AC id that no slice Satisfies                 (CRITICAL)
-//	Consistency : a slice that Satisfies an AC the spec never defines (CRITICAL)
-//	Orphan slice: a slice that satisfies no acceptance criterion       (warn)
-//	Ambiguity   : an unquantified vague adjective or unresolved
-//	               placeholder in the spec                              (warn)
-//
-// It closes with a Metrics line (criteria count, coverage %, orphan + ambiguity
-// counts) so the vet gate reports a number, not just a pass/fail.
-//
-// Exit codes: 0 clear · 1 at least one CRITICAL finding · 2 no workspace (no active
-// slug, or spec.md/tasks.md missing).
-var (
-	taskACRe           = regexp.MustCompile(`\b(?:AC-[0-9]{3}|AC[0-9]+)\b`)
-	sliceHeadRe        = regexp.MustCompile(`(?i)^##[[:space:]]*(?:SLICE-[0-9]{3}\b|Slice\b)`)
-	sliceNamePrefixRe  = regexp.MustCompile(`^##[[:space:]]*`) // stripped to leave the slice name
-	analyzeSatisfiesRe = regexp.MustCompile(`^[[:space:]]*Satisfies:`)
-	// Ambiguity scan: a vague quality adjective with no number on the line is an
-	// unfalsifiable criterion; an unresolved placeholder is unfinished spec text.
-	vagueAdjRe     = regexp.MustCompile(`(?i)\b(fast|scalable|secure|intuitive|robust|performant|seamless|efficient|flexible|reliable|user-friendly|graceful(?:ly)?|snappy|lightweight)\b`)
-	analyzeDigitRe = regexp.MustCompile(`[0-9]`)
-	placeholderRe  = regexp.MustCompile(`(?i)(\bTODO\b|\bTKTK\b|\bFIXME\b|\bXXX\b|\?\?\?|<placeholder>)`)
-	fenceRe        = regexp.MustCompile("^[[:space:]]*```")
-)
-
-func Analyze(root string, args []string, stdout, stderr io.Writer) int {
-	slug := slugOrActive(root, args)
-	if slug == "" {
-		fmt.Fprintln(stderr, "analyze: no active workspace.")
-		return 2
-	}
-
-	spec := featureFile(root, slug, "spec.md")
-	tasks := featureFile(root, slug, "tasks.md")
-	if !isFile(spec) || !isFile(tasks) {
-		fmt.Fprintf(stderr, "analyze: need spec.md + tasks.md in %s.\n", featureDir(root, slug))
-		return 2
-	}
-
-	specData, err := os.ReadFile(spec)
-	if err != nil {
-		fmt.Fprintf(stderr, "analyze: read spec.md: %v\n", err)
-		return 2
-	}
-	tasksData, err := os.ReadFile(tasks)
-	if err != nil {
-		fmt.Fprintf(stderr, "analyze: read tasks.md: %v\n", err)
-		return 2
-	}
-
-	specACs := sortedACIDs(acIDRe, specData, true) // legacy brackets stripped: "[AC1]" -> "AC1"
-	taskACs := sortedACIDs(taskACRe, tasksData, false)
-	specSet := stringSet(specACs)
-	taskSet := stringSet(taskACs)
-
-	crit := 0
-	fmt.Fprintf(stdout, "# Cross-artifact analysis: %s\n", slug)
-	fmt.Fprintln(stdout)
-
-	// Coverage: spec ACs with no slice reference.
-	covered := 0
-	fmt.Fprintln(stdout, "## Coverage")
-	if len(specACs) == 0 {
-		fmt.Fprintln(stdout, "- [warn] spec.md: no AC-### acceptance ids found; tag criteria for a machine-checkable gate.")
-	} else {
-		for _, ac := range specACs {
-			if taskSet[ac] {
-				covered++
-				fmt.Fprintf(stdout, "- [ok] %s: covered\n", ac)
-			} else {
-				fmt.Fprintf(stdout, "- [CRITICAL] %s (spec.md): no slice Satisfies it (uncovered)\n", ac)
-				crit++
-			}
-		}
-	}
-
-	// Dangling refs: tasks Satisfies an AC the spec doesn't define.
-	fmt.Fprintln(stdout)
-	fmt.Fprintln(stdout, "## Consistency")
-	if len(taskACs) > 0 {
-		for _, ac := range taskACs {
-			if !specSet[ac] {
-				fmt.Fprintf(stdout, "- [CRITICAL] %s (tasks.md): referenced by a slice but not defined in spec.md (dangling)\n", ac)
-				crit++
-			}
-		}
-	}
-
-	// Orphan slices: a slice with no Satisfies line (printed directly, no blank before).
-	orphans := 0
-	for _, name := range orphanSlices(tasksData) {
-		if name != "" {
-			orphans++
-			fmt.Fprintf(stdout, "- [warn] slice '%s': satisfies no acceptance criterion (add Satisfies, or justify)\n", name)
-		}
-	}
-
-	// Ambiguity: unquantified vague adjectives + unresolved placeholders in the spec.
-	fmt.Fprintln(stdout)
-	fmt.Fprintln(stdout, "## Ambiguity")
-	ambig := ambiguityFindings(specData)
-	if len(ambig) == 0 {
-		fmt.Fprintln(stdout, "- [ok] no unquantified adjectives or unresolved placeholders found")
-	} else {
-		for _, line := range ambig {
-			fmt.Fprintln(stdout, line)
-		}
-	}
-
-	// Metrics: a single machine-readable line so the vet gate reports a number.
-	fmt.Fprintln(stdout)
-	fmt.Fprintln(stdout, "## Metrics")
-	if len(specACs) == 0 {
-		fmt.Fprintf(stdout, "- Acceptance criteria: 0 (none tagged) · orphan slices %d · ambiguity flags %d\n", orphans, len(ambig))
-	} else {
-		fmt.Fprintf(stdout, "- Acceptance criteria: %d · covered %d/%d (%d%%) · orphan slices %d · ambiguity flags %d\n",
-			len(specACs), covered, len(specACs), covered*100/len(specACs), orphans, len(ambig))
-	}
-
-	fmt.Fprintln(stdout)
-	if crit > 0 {
-		fmt.Fprintf(stdout, "## Verdict: BLOCKED: %d CRITICAL finding(s). Resolve before %s.\n", crit, workflow.ForVerb("build").Both())
-		return 1
-	}
-	fmt.Fprintln(stdout, "## Verdict: clear: spec/tasks consistent and fully mapped.")
-	return 0
-}
-
-// ambiguityFindings scans spec text for unfalsifiable criteria: a vague quality
-// adjective (fast, robust, secure …) on a line with no number to pin it down, or an
-// unresolved placeholder (TODO, ???, <placeholder> …). Code fences are skipped. One
-// finding per line: a placeholder takes precedence over an adjective. 1-based lines.
-func ambiguityFindings(specData []byte) []string {
-	var out []string
-	inFence := false
-	for i, line := range splitLinesNoTrailing(specData) {
-		if fenceRe.MatchString(line) {
-			inFence = !inFence
-			continue
-		}
-		if inFence {
-			continue
-		}
-		ln := i + 1
-		if m := placeholderRe.FindString(line); m != "" {
-			out = append(out, fmt.Sprintf("- [warn] spec.md:L%d: unresolved placeholder %q", ln, m))
-			continue
-		}
-		// Strip the AC id before the digit gate: else the id's own digit masks
-		// a vague adjective on the very criterion line it tags.
-		bare := acIDRe.ReplaceAllString(line, "")
-		bare = taskACRe.ReplaceAllString(bare, "")
-		if !analyzeDigitRe.MatchString(bare) {
-			if m := vagueAdjRe.FindString(bare); m != "" {
-				out = append(out, fmt.Sprintf("- [warn] spec.md:L%d: %q is not quantified; state a measurable target", ln, m))
-			}
-		}
-	}
-	return out
-}
-
-// sortedACIDs collects every acceptance id matched by re, deduplicated and sorted
-// lexicographically. When strip is set the surrounding brackets are removed, so
-// Legacy "[AC1]" becomes "AC1". Returns nil when there are none.
-func sortedACIDs(re *regexp.Regexp, data []byte, strip bool) []string {
-	seen := map[string]bool{}
-	var out []string
-	for _, line := range splitLinesNoTrailing(data) {
-		for _, m := range re.FindAllString(line, -1) {
-			if strip {
-				m = strings.NewReplacer("[", "", "]", "").Replace(m)
-			}
-			if !seen[m] {
-				seen[m] = true
-				out = append(out, m)
-			}
-		}
-	}
-	sort.Strings(out)
-	return out
-}
-
-// stringSet builds a membership set for O(1) lookups.
-func stringSet(in []string) map[string]bool {
-	m := make(map[string]bool, len(in))
-	for _, s := range in {
-		m[s] = true
-	}
-	return m
-}
-
-// orphanSlices returns the names of slices in tasks.md that have no Satisfies:
-// line. A "## Slice ..." header opens a slice; any Satisfies: line before the next
-// header marks it satisfied. Each header (and end of file) closes the previous
-// slice, emitting it when it went unsatisfied.
-func orphanSlices(data []byte) []string {
-	var out []string
-	name := ""
-	sat := false
-	for _, line := range splitLinesNoTrailing(data) {
-		if sliceHeadRe.MatchString(line) {
-			if name != "" && !sat {
-				out = append(out, name)
-			}
-			name = sliceNamePrefixRe.ReplaceAllString(line, "")
-			sat = false
-		}
-		if analyzeSatisfiesRe.MatchString(line) {
-			sat = true
-		}
-	}
-	if name != "" && !sat {
-		out = append(out, name)
-	}
-	return out
-}

package/engine/internal/lib/archivesearch.go

@@ -1,125 +0,0 @@
-package lib
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-)
-
-// ArchiveSearch surfaces shipped features whose spec.md overlaps a query, so
-// /rite-spec can spot prior art before writing a new spec: an extension, a
-// conflict, or a re-spec of solved work. It is advisory, not a gate: empty
-// output means no overlap. Exit 2 means a missing query; exit 3 means the
-// archive could not be read. The query is the feature's key nouns, one or many
-// args; a quoted phrase is split on whitespace. Ranking is by the count of
-// distinct query terms a spec contains, highest first, ties broken by slug.
-//
-// args is `<term>...`. Terms shorter than three characters are dropped as noise.
-func ArchiveSearch(root string, args []string, stdout, stderr io.Writer) int {
-	var terms []string
-	seen := map[string]bool{}
-	for _, a := range args {
-		for _, t := range strings.Fields(strings.ToLower(a)) {
-			if len(t) >= 3 && !seen[t] {
-				seen[t] = true
-				terms = append(terms, t)
-			}
-		}
-	}
-	if len(terms) == 0 {
-		fmt.Fprintln(stderr, `usage: devrites-engine archive-search "<key nouns>"`)
-		return 2 // usage
-	}
-
-	archive := filepath.Join(root, "archive")
-	info, err := os.Stat(archive)
-	if err != nil {
-		if errors.Is(err, fs.ErrNotExist) {
-			// No archive yet: no prior art to surface. Silent, successful no-op.
-			return 0
-		}
-		fmt.Fprintf(stderr, "archive-search: read archive: %v\n", err)
-		return 3
-	}
-	if !info.IsDir() {
-		fmt.Fprintf(stderr, "archive-search: read archive: %s is not a directory\n", archive)
-		return 3
-	}
-	entries, err := os.ReadDir(archive)
-	if err != nil {
-		fmt.Fprintf(stderr, "archive-search: read archive: %v\n", err)
-		return 3
-	}
-
-	type hit struct {
-		slug  string
-		n     int
-		title string
-	}
-	var hits []hit
-	for _, e := range entries {
-		if !e.IsDir() {
-			continue
-		}
-		spec := filepath.Join(root, "archive", e.Name(), "spec.md")
-		info, err := os.Stat(spec)
-		if err != nil {
-			if errors.Is(err, fs.ErrNotExist) {
-				continue
-			}
-			fmt.Fprintf(stderr, "archive-search: read %s: %v\n", spec, err)
-			return 3
-		}
-		if !info.Mode().IsRegular() {
-			fmt.Fprintf(stderr, "archive-search: read %s: not a regular file\n", spec)
-			return 3
-		}
-		b, err := os.ReadFile(spec)
-		if err != nil {
-			if errors.Is(err, fs.ErrNotExist) {
-				continue
-			}
-			fmt.Fprintf(stderr, "archive-search: read %s: %v\n", spec, err)
-			return 3
-		}
-		body := strings.ToLower(string(b))
-		n := 0
-		for _, t := range terms {
-			if strings.Contains(body, t) {
-				n++
-			}
-		}
-		if n > 0 {
-			hits = append(hits, hit{slug: e.Name(), n: n, title: specTitle(b)})
-		}
-	}
-
-	sort.Slice(hits, func(i, j int) bool {
-		if hits[i].n != hits[j].n {
-			return hits[i].n > hits[j].n
-		}
-		return hits[i].slug < hits[j].slug
-	})
-	for _, h := range hits {
-		fmt.Fprintf(stdout, "%s\t%d/%d terms\t%s\n", h.slug, h.n, len(terms), h.title)
-	}
-	return 0
-}
-
-// specTitle returns the spec's first Markdown heading, or its first non-empty
-// line, as a one-line label: empty when the spec has neither.
-func specTitle(b []byte) string {
-	for _, line := range strings.Split(string(b), "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" {
-			continue
-		}
-		return strings.TrimSpace(strings.TrimLeft(line, "#"))
-	}
-	return ""
-}

package/engine/internal/lib/archivesearch_test.go

@@ -1,138 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestArchiveSearch(t *testing.T) {
-	root := t.TempDir()
-	writeArchiveSpec(t, root, "search-ranking", "# Search ranking\nRank results by relevance score.\n")
-	writeArchiveSpec(t, root, "auth-tokens", "# Auth token rotation\nRotate the search index credentials.\n")
-	writeArchiveSpec(t, root, "billing", "# Billing exports\nExport invoices.\n")
-
-	for _, tc := range []struct {
-		name     string
-		args     []string
-		wantCode int
-		// wantOrder lists slugs expected in stdout, in order; absent slugs must not appear.
-		wantOrder []string
-		absent    []string
-		wantErr   string
-	}{
-		{
-			name:      "ranks by distinct term hits",
-			args:      []string{"search", "ranking"},
-			wantCode:  0,
-			wantOrder: []string{"search-ranking", "auth-tokens"}, // 2/2 before 1/2
-			absent:    []string{"billing"},
-		},
-		{
-			name:     "phrase is split on whitespace",
-			args:     []string{"search ranking"},
-			wantCode: 0,
-			// same result as two args
-			wantOrder: []string{"search-ranking", "auth-tokens"},
-		},
-		{
-			name:     "no overlap is a silent success",
-			args:     []string{"kubernetes"},
-			wantCode: 0,
-			absent:   []string{"search-ranking", "auth-tokens", "billing"},
-		},
-		{
-			name:     "missing query is a usage error",
-			args:     nil,
-			wantCode: 2,
-			wantErr:  "usage: devrites-engine archive-search",
-		},
-		{
-			name:     "short noise terms are dropped",
-			args:     []string{"a", "to"},
-			wantCode: 2, // both under 3 chars → no terms → usage
-			wantErr:  "usage: devrites-engine archive-search",
-		},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-			code := ArchiveSearch(root, tc.args, stdout, stderr)
-			if code != tc.wantCode {
-				t.Fatalf("code=%d, want %d; stdout=%q stderr=%q", code, tc.wantCode, stdout.String(), stderr.String())
-			}
-			out := stdout.String()
-			last := -1
-			for _, slug := range tc.wantOrder {
-				idx := strings.Index(out, slug)
-				if idx < 0 {
-					t.Fatalf("stdout=%q missing expected slug %q", out, slug)
-				}
-				if idx < last {
-					t.Fatalf("stdout=%q: slug %q out of expected rank order", out, slug)
-				}
-				last = idx
-			}
-			for _, slug := range tc.absent {
-				if strings.Contains(out, slug) {
-					t.Fatalf("stdout=%q unexpectedly contains %q", out, slug)
-				}
-			}
-			if tc.wantErr != "" && !strings.Contains(stderr.String(), tc.wantErr) {
-				t.Fatalf("stderr=%q, want substring %q", stderr.String(), tc.wantErr)
-			}
-		})
-	}
-}
-
-// TestArchiveSearchNoArchive: absent archive dir → silent exit 0, not a crash.
-func TestArchiveSearchNoArchive(t *testing.T) {
-	root := t.TempDir()
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	if code := ArchiveSearch(root, []string{"anything"}, stdout, stderr); code != 0 {
-		t.Fatalf("code=%d, want 0; stderr=%q", code, stderr.String())
-	}
-	if stdout.String() != "" {
-		t.Fatalf("stdout=%q, want empty", stdout.String())
-	}
-}
-
-func TestArchiveSearchReportsUnreadableArchive(t *testing.T) {
-	root := t.TempDir()
-	if err := os.WriteFile(filepath.Join(root, "archive"), []byte("not a directory"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	if code := ArchiveSearch(root, []string{"anything"}, stdout, stderr); code != 3 {
-		t.Fatalf("code=%d, want 3; stderr=%q", code, stderr.String())
-	}
-	if !strings.Contains(stderr.String(), "read archive") {
-		t.Fatalf("stderr=%q, want archive read error", stderr.String())
-	}
-}
-
-func TestArchiveSearchReportsUnreadableSpec(t *testing.T) {
-	root := t.TempDir()
-	if err := os.MkdirAll(filepath.Join(root, "archive", "broken", "spec.md"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	if code := ArchiveSearch(root, []string{"anything"}, stdout, stderr); code != 3 {
-		t.Fatalf("code=%d, want 3; stderr=%q", code, stderr.String())
-	}
-	if !strings.Contains(stderr.String(), "archive-search: read") {
-		t.Fatalf("stderr=%q, want spec read error", stderr.String())
-	}
-}
-
-func writeArchiveSpec(t *testing.T, root, slug, content string) {
-	t.Helper()
-	dir := filepath.Join(root, "archive", slug)
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(dir, "spec.md"), []byte(content), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}