devrites 6.0.4 → 6.1.0

package/engine/internal/lib/environment_report_test.go

@@ -1,54 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/devritespaths"
-)
-
-func TestEnvironmentReportForDetectsManifestAndIndexes(t *testing.T) {
-	project := t.TempDir()
-	root := filepath.Join(project, devritespaths.DevritesRootName)
-	manifestPath := filepath.Join(project, devritespaths.ManifestName)
-	if err := os.MkdirAll(filepath.Dir(manifestPath), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(manifestPath, []byte("devrites\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.MkdirAll(filepath.Join(project, ".codegraph"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	report, err := EnvironmentReportFor(root, project)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if report.ProjectRoot != project {
-		t.Fatalf("project root = %q, want %q", report.ProjectRoot, project)
-	}
-	if !report.Manifest.Present {
-		t.Fatal("expected manifest present")
-	}
-	if len(report.Indexes) != 4 {
-		t.Fatalf("indexes = %d, want 4", len(report.Indexes))
-	}
-	if !report.Indexes[0].Present {
-		t.Fatalf("expected .codegraph present, got %+v", report.Indexes)
-	}
-}
-
-func TestRunEnvironmentCheckWritesJSON(t *testing.T) {
-	project := t.TempDir()
-	var stdout, stderr bytes.Buffer
-	if code := RunEnvironmentCheck("", []string{"--root", project}, &stdout, &stderr); code != 0 {
-		t.Fatalf("code=%d stderr=%q", code, stderr.String())
-	}
-	if !strings.Contains(stdout.String(), `"engine_version"`) || !strings.Contains(stdout.String(), `"manifest"`) {
-		t.Fatalf("stdout=%q", stdout.String())
-	}
-}

package/engine/internal/lib/evidencefresh_test.go

@@ -1,120 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-)
-
-func writeBoundCandidateWorkspace(t *testing.T, browser bool) (project, root, digest string) {
-	t.Helper()
-	project, root = writeCandidateTestWorkspace(t, candidateTestManifest(candidateTestRow{state: "present", path: "source.go", slice: "S-1", reason: "Implementation."}))
-	writeCandidateTestFile(t, project, "source.go", "package source\n")
-	digest, _, err := CandidateIdentity(root, "feature")
-	if err != nil {
-		t.Fatal(err)
-	}
-	line := "Candidate SHA-256: " + digest + "\n"
-	workspace := filepath.Join(root, "work", "feature")
-	for _, name := range []string{"evidence.md", "review.md", "seal.md"} {
-		if err := os.WriteFile(filepath.Join(workspace, name), []byte("# Artifact\n\n"+line), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if browser {
-		if err := os.WriteFile(filepath.Join(workspace, "browser-evidence.md"), []byte("# Browser evidence\n\n"+line), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	return project, root, digest
-}
-
-func runEvidenceFresh(t *testing.T, root string) (int, string, string) {
-	t.Helper()
-	var stdout, stderr bytes.Buffer
-	code := EvidenceFresh(root, []string{"feature"}, &stdout, &stderr)
-	return code, stdout.String(), stderr.String()
-}
-
-func TestEvidenceFreshUsesCandidateContentNotMtime(t *testing.T) {
-	project, root, _ := writeBoundCandidateWorkspace(t, false)
-	path := filepath.Join(project, "source.go")
-	info, err := os.Stat(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Chtimes(path, time.Unix(2_000_000_000, 0), time.Unix(2_000_000_000, 0)); err != nil {
-		t.Fatal(err)
-	}
-	if code, stdout, stderr := runEvidenceFresh(t, root); code != 0 || !strings.Contains(stdout, "evidence-fresh: OK") {
-		t.Fatalf("unchanged touch: code=%d stdout=%q stderr=%q", code, stdout, stderr)
-	}
-
-	writeCandidateTestFile(t, project, "source.go", "package changed\n")
-	if err := os.Chtimes(path, info.ModTime(), info.ModTime()); err != nil {
-		t.Fatal(err)
-	}
-	if code, stdout, stderr := runEvidenceFresh(t, root); code == 0 || !strings.Contains(stderr, "candidate digest") {
-		t.Fatalf("restored-mtime change: code=%d stdout=%q stderr=%q", code, stdout, stderr)
-	}
-}
-
-func TestEvidenceFreshRequiresOneExactMatchingDigestLine(t *testing.T) {
-	tests := []struct {
-		name string
-		body func(string) string
-		want string
-	}{
-		{name: "missing", body: func(string) string { return "# Evidence\n\nNo binding.\n" }, want: "missing"},
-		{name: "duplicate", body: func(digest string) string {
-			return "Candidate SHA-256: " + digest + "\nCandidate SHA-256: " + digest + "\n"
-		}, want: "duplicate"},
-		{name: "malformed", body: func(string) string { return "Candidate SHA-256: ABCD\n" }, want: "malformed"},
-		{name: "mismatch", body: func(string) string { return "Candidate SHA-256: " + strings.Repeat("0", 64) + "\n" }, want: "does not match"},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			_, root, digest := writeBoundCandidateWorkspace(t, false)
-			path := filepath.Join(root, "work", "feature", "evidence.md")
-			if err := os.WriteFile(path, []byte(test.body(digest)), 0o644); err != nil {
-				t.Fatal(err)
-			}
-			code, stdout, stderr := runEvidenceFresh(t, root)
-			if code == 0 || stdout != "" || !strings.Contains(stderr, test.want) {
-				t.Fatalf("code=%d stdout=%q stderr=%q, want %q", code, stdout, stderr, test.want)
-			}
-		})
-	}
-}
-
-func TestEvidenceFreshRequiresOptionalBrowserBinding(t *testing.T) {
-	_, root, digest := writeBoundCandidateWorkspace(t, true)
-	path := filepath.Join(root, "work", "feature", "browser-evidence.md")
-	if err := os.WriteFile(path, []byte("# Browser evidence\n\nNo binding.\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if code, _, stderr := runEvidenceFresh(t, root); code == 0 || !strings.Contains(stderr, "browser-evidence.md") {
-		t.Fatalf("missing browser binding: code=%d stderr=%q", code, stderr)
-	}
-	if err := os.WriteFile(path, []byte("Candidate SHA-256: "+digest+"\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if code, stdout, stderr := runEvidenceFresh(t, root); code != 0 {
-		t.Fatalf("browser binding: code=%d stdout=%q stderr=%q", code, stdout, stderr)
-	}
-}
-
-func TestEvidenceFreshBoundsDigestArtifacts(t *testing.T) {
-	_, root, digest := writeBoundCandidateWorkspace(t, false)
-	path := filepath.Join(root, "work", "feature", "review.md")
-	body := "Candidate SHA-256: " + digest + "\n" + strings.Repeat("x", 1<<20)
-	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if code, stdout, stderr := runEvidenceFresh(t, root); code == 0 || stdout != "" || !strings.Contains(stderr, "1 MiB") {
-		t.Fatalf("oversized proof: code=%d stdout=%q stderr=%q", code, stdout, stderr)
-	}
-}

package/engine/internal/lib/handoff_test.go

@@ -1,83 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestHandoffEmitsResumeRecord(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	writeFile(t, filepath.Join(featureDir, "questions.md"), "# Questions\n\n## Q-1\nstatus: open\ngate: blocking\n")
-	writeFile(t, filepath.Join(featureDir, "decisions.md"), "# Decisions\n\n## Dead ends\n\n- cached lookup: races the writer\n- retry loop: masks the root cause\n")
-	writeFile(t, filepath.Join(featureDir, "gates.md"), "# Gates\n\n- [x] G1: builds\n  CHECK: go build ./...\n  EXPECT: ok\n  EVIDENCE: ran\n- [ ] G2: tests green\n  CHECK: go test ./...\n  EXPECT: ok\n")
-	writeFile(t, filepath.Join(featureDir, "spec.md"), "# Spec\n")
-
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunHandoff(root, []string{"feat"}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d err=%s", code, stderr.String())
-	}
-	out := stdout.String()
-	for _, want := range []string{
-		"feature: feat",
-		"phase: build",
-		"status: running",
-		"awaiting_human: no",
-		"open_questions: 1",
-		"blocking_question_gates: blocking",
-		"gates_total: 2",
-		"gates_met: 0",
-		"gates_unmet: 2",
-		"gates_stale: 1",
-		"unmet_id: G1",
-		"unmet_id: G2",
-		"stale_id: G1",
-		"dead_end: cached lookup: races the writer",
-		"dead_end: retry loop: masks the root cause",
-	} {
-		if !strings.Contains(out, want) {
-			t.Fatalf("missing %q in:\n%s", want, out)
-		}
-	}
-	if !strings.Contains(out, "read_next:") || !strings.Contains(out, "state.md") || !strings.Contains(out, "gates.md") {
-		t.Fatalf("read_next missing present artifacts:\n%s", out)
-	}
-}
-
-func TestHandoffMissingLedgerAndNoQuestions(t *testing.T) {
-	root, _ := newWorkspace(t, "spec")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunHandoff(root, []string{"feat"}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("code=%d err=%s", code, stderr.String())
-	}
-	out := stdout.String()
-	for _, want := range []string{
-		"gates_ledger: absent",
-		"open_questions: 0",
-		"blocking_question_gates: none",
-		"dead_ends: none",
-	} {
-		if !strings.Contains(out, want) {
-			t.Fatalf("missing %q in:\n%s", want, out)
-		}
-	}
-}
-
-func TestHandoffRejectsMissingFeature(t *testing.T) {
-	root, _ := newWorkspace(t, "spec")
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	if code := RunHandoff(root, []string{"nope"}, stdout, stderr); code == 0 {
-		t.Fatalf("expected non-zero for missing feature, out=%s", stdout.String())
-	}
-}
-
-func TestDeadEndsBoundsAndSectionScope(t *testing.T) {
-	body := "# D\n\n## Dead ends\n\n- one\n- two\n\n## DEC-001 other\n- not a dead end\n"
-	ends := deadEnds([]byte(body))
-	if len(ends) != 2 || ends[0] != "one" || ends[1] != "two" {
-		t.Fatalf("ends=%v", ends)
-	}
-}

package/engine/internal/lib/manifest_union_test.go

@@ -1,251 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-const unionManifest = `# Touched files: SLUG
-
-## Touched files
-SLUG scope.
-
-## Candidate manifest
-| State | File | Slice | Reason |
-| --- | --- | --- | --- |
-ROWS
-## Review trail
-SLUG trail.
-`
-
-func manifestBody(rows ...string) string {
-	return strings.Join(rows, "\n") + "\n"
-}
-
-func unionWorkspace(t *testing.T, root, slug, rows string, archived bool) {
-	t.Helper()
-	parent := "work"
-	if archived {
-		parent = "archive"
-	}
-	dir := filepath.Join(root, parent, slug)
-	if err := os.MkdirAll(dir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	stateBody := "| phase | seal |\n| schema | 4 |\n"
-	if err := os.WriteFile(filepath.Join(dir, "state.md"), []byte(stateBody), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	manifest := strings.ReplaceAll(unionManifest, "SLUG", slug)
-	manifest = strings.Replace(manifest, "ROWS\n", rows, 1)
-	if err := os.WriteFile(filepath.Join(dir, "touched-files.md"), []byte(manifest), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func unionRoot(t *testing.T) string {
-	root := filepath.Join(t.TempDir(), ".devrites")
-	if err := os.MkdirAll(filepath.Join(root, "work"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	return root
-}
-
-func TestMergeManifestUnionsOrderedPredecessors(t *testing.T) {
-	root := unionRoot(t)
-	unionWorkspace(t, root, "feat-1", manifestBody(
-		"| present | `src/a.ts` | SLICE-001 | Added. |",
-		"| present | `src/shared.ts` | SLICE-001 | First write. |",
-	), false)
-	unionWorkspace(t, root, "feat-2", manifestBody(
-		"| present | `src/b.ts` | SLICE-002 | Added. |",
-		"| present | `src/shared.ts` | SLICE-002 | Rewritten. |",
-	), true) // archived predecessor still resolves
-	unionWorkspace(t, root, "release", manifestBody(
-		"| present | `src/r.ts` | SLICE-001 | Release wiring. |",
-	), false)
-
-	var stdout, stderr bytes.Buffer
-	code := RunMergeManifest(root, []string{"release", "feat-1", "feat-2"}, &stdout, &stderr)
-	if code != 0 {
-		t.Fatalf("code=%d stderr=%s", code, stderr.String())
-	}
-	raw, err := os.ReadFile(filepath.Join(root, "work", "release", "touched-files.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	text := string(raw)
-	want := []string{
-		"| present | `src/a.ts` | SLICE-001 | Added. |",
-		"| present | `src/b.ts` | SLICE-002 | Added. |",
-		"| present | `src/r.ts` | SLICE-001 | Release wiring. |",
-		"| present | `src/shared.ts` | SLICE-002 | Rewritten. |", // later position wins
-	}
-	for _, row := range want {
-		if !strings.Contains(text, row) {
-			t.Fatalf("merged manifest missing %q:\n%s", row, text)
-		}
-	}
-	if strings.Contains(text, "First write.") {
-		t.Fatalf("losing collision row survived:\n%s", text)
-	}
-	if !strings.Contains(text, "## Touched files\nrelease scope.") || !strings.Contains(text, "## Review trail\nrelease trail.") {
-		t.Fatalf("non-manifest sections were not preserved:\n%s", text)
-	}
-	if !strings.Contains(stdout.String(), "collision") {
-		t.Fatalf("stdout should report the resolved collision: %q", stdout.String())
-	}
-}
-
-func TestMergeManifestWalksSequenceChain(t *testing.T) {
-	root := unionRoot(t)
-	unionWorkspace(t, root, "feat-1", manifestBody("| present | `src/a.ts` | SLICE-001 | Added. |"), false)
-	unionWorkspace(t, root, "feat-2", manifestBody(
-		"| present | `src/a.ts` | SLICE-002 | Touched again. |",
-		"| present | `src/b.ts` | SLICE-002 | Added. |",
-	), false)
-	unionWorkspace(t, root, "release", manifestBody("| present | `src/r.ts` | SLICE-001 | Release. |"), false)
-	for slug, parent := range map[string]string{"feat-2": "feat-1", "release": "feat-2"} {
-		statePath := filepath.Join(root, "work", slug, "state.md")
-		raw, _ := os.ReadFile(statePath)
-		raw = append(raw, []byte("| sequence_parent | "+parent+" |\n")...)
-		if err := os.WriteFile(statePath, raw, 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	var stdout, stderr bytes.Buffer
-	if code := RunMergeManifest(root, []string{"release"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("chain walk: code=%d stderr=%s", code, stderr.String())
-	}
-	raw, err := os.ReadFile(filepath.Join(root, "work", "release", "touched-files.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	text := string(raw)
-	for _, row := range []string{
-		"| present | `src/a.ts` | SLICE-002 | Touched again. |",
-		"| present | `src/b.ts` | SLICE-002 | Added. |",
-		"| present | `src/r.ts` | SLICE-001 | Release. |",
-	} {
-		if !strings.Contains(text, row) {
-			t.Fatalf("chain-merged manifest missing %q:\n%s", row, text)
-		}
-	}
-
-	// A workspace outside the chain has nothing to walk.
-	stderr.Reset()
-	unionWorkspace(t, root, "lone", manifestBody("| present | `src/x.ts` | SLICE-001 | Lone. |"), false)
-	if code := RunMergeManifest(root, []string{"lone"}, &stdout, &stderr); code != 3 {
-		t.Fatalf("no chain: code=%d stderr=%s", code, stderr.String())
-	}
-}
-
-func TestVerifyReleaseUnionEnforcesChainCoverage(t *testing.T) {
-	root := unionRoot(t)
-	unionWorkspace(t, root, "feat-1", manifestBody("| present | `src/a.ts` | SLICE-001 | Added. |"), false)
-	unionWorkspace(t, root, "release", manifestBody("| present | `src/r.ts` | SLICE-001 | Release. |"), false)
-	for slug, extra := range map[string]string{
-		"release": "| sequence_parent | feat-1 |\n| sequence_role | release |\n",
-		"feat-1":  "",
-	} {
-		if extra == "" {
-			continue
-		}
-		statePath := filepath.Join(root, "work", slug, "state.md")
-		raw, _ := os.ReadFile(statePath)
-		if err := os.WriteFile(statePath, append(raw, []byte(extra)...), 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	// A release workspace whose manifest misses a predecessor path is blocked.
-	if err := VerifyReleaseUnion(root, "release"); err == nil || !strings.Contains(err.Error(), "merge-manifest") {
-		t.Fatalf("expected union gap, got %v", err)
-	}
-	// Workspaces without the role are not checked.
-	if err := VerifyReleaseUnion(root, "feat-1"); err != nil {
-		t.Fatalf("non-release workspace: %v", err)
-	}
-
-	// After the merge, coverage holds.
-	var stdout, stderr bytes.Buffer
-	if code := RunMergeManifest(root, []string{"release"}, &stdout, &stderr); code != 0 {
-		t.Fatalf("merge: code=%d stderr=%s", code, stderr.String())
-	}
-	if err := VerifyReleaseUnion(root, "release"); err != nil {
-		t.Fatalf("post-merge: %v", err)
-	}
-}
-
-func TestMergeManifestRejectsParentMismatchAndMissingPredecessor(t *testing.T) {
-	root := unionRoot(t)
-	unionWorkspace(t, root, "feat-1", manifestBody("| present | `src/a.ts` | SLICE-001 | Added. |"), false)
-	unionWorkspace(t, root, "release", manifestBody("| present | `src/r.ts` | SLICE-001 | Release. |"), false)
-	statePath := filepath.Join(root, "work", "release", "state.md")
-	raw, _ := os.ReadFile(statePath)
-	raw = append(raw, []byte("| sequence_parent | feat-1 |\n")...)
-	if err := os.WriteFile(statePath, raw, 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	var stdout, stderr bytes.Buffer
-	// The recorded parent must be the last predecessor; omitting it blocks.
-	if code := RunMergeManifest(root, []string{"release", "other"}, &stdout, &stderr); code != 3 {
-		t.Fatalf("parent mismatch: code=%d stderr=%s", code, stderr.String())
-	}
-	if !strings.Contains(stderr.String(), "sequence_parent") {
-		t.Fatalf("stderr=%q", stderr.String())
-	}
-	stderr.Reset()
-	if code := RunMergeManifest(root, []string{"release", "feat-1", "ghost"}, &stdout, &stderr); code != 3 {
-		t.Fatalf("missing predecessor: code=%d stderr=%s", code, stderr.String())
-	}
-	stderr.Reset()
-	if code := RunMergeManifest(root, []string{"release", "release", "feat-1"}, &stdout, &stderr); code != 3 {
-		t.Fatalf("self predecessor: code=%d", code)
-	}
-	if code := RunMergeManifest(root, []string{}, &stdout, &stderr); code != 2 {
-		t.Fatalf("missing args: code=%d", code)
-	}
-}
-
-func TestSequenceChainBeyondBoundRefusesInsteadOfTruncating(t *testing.T) {
-	root := unionRoot(t)
-	n := maxSequenceChain + 6
-	for i := 0; i < n; i++ {
-		slug := fmt.Sprintf("feat-%03d", i)
-		unionWorkspace(t, root, slug, manifestBody(fmt.Sprintf("| present | `src/f%03d.ts` | SLICE-001 | Added. |", i)), false)
-	}
-	unionWorkspace(t, root, "release", manifestBody("| present | `src/r.ts` | SLICE-001 | Release. |"), false)
-	link := func(slug, parent string) {
-		statePath := filepath.Join(root, "work", slug, "state.md")
-		raw, _ := os.ReadFile(statePath)
-		raw = append(raw, []byte("| sequence_parent | "+parent+" |\n")...)
-		if err := os.WriteFile(statePath, raw, 0o644); err != nil {
-			t.Fatal(err)
-		}
-	}
-	for i := 1; i < n; i++ {
-		link(fmt.Sprintf("feat-%03d", i), fmt.Sprintf("feat-%03d", i-1))
-	}
-	link("release", fmt.Sprintf("feat-%03d", n-1))
-	statePath := filepath.Join(root, "work", "release", "state.md")
-	raw, _ := os.ReadFile(statePath)
-	raw = append(raw, []byte("| sequence_role | release |\n")...)
-	if err := os.WriteFile(statePath, raw, 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	var stdout, stderr bytes.Buffer
-	if code := RunMergeManifest(root, []string{"release"}, &stdout, &stderr); code == 0 {
-		t.Fatalf("merge over an over-long chain succeeded: stdout=%s", stdout.String())
-	}
-	if err := VerifyReleaseUnion(root, "release"); err == nil {
-		t.Fatal("release union passed over an over-long chain")
-	}
-}

package/engine/internal/lib/metrics_test.go

@@ -1,28 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestMetricsSummaryFailsOnOversizedLine(t *testing.T) {
-	root, featureDir := newWorkspace(t, "build")
-	ev := func(e string) string {
-		return `{"ts":"2026-01-01T00:00:00Z","phase":"build","event":"` + e + `"}` + "\n"
-	}
-	ledger := ev("a") + strings.Repeat("x", 1<<20) + "\n" + ev("b") + ev("c")
-	if err := os.WriteFile(filepath.Join(featureDir, MetricsFile), []byte(ledger), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := RunMetrics(root, []string{"summary", "feat"}, stdout, stderr)
-	if code == 0 {
-		t.Fatalf("truncated ledger reported as complete:\n%s", stdout)
-	}
-	if !strings.Contains(stderr.String(), "ledger unreadable after 1 events") {
-		t.Fatalf("stderr missing truncation report: %q", stderr)
-	}
-}