devrites 6.0.4 → 6.1.0

package/engine/cmd/releasepack/main_test.go

@@ -1,239 +0,0 @@
-package main
-
-import (
-	"archive/tar"
-	"bytes"
-	"compress/gzip"
-	"io"
-	"os"
-	"path/filepath"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestWriteArchiveIsDeterministic(t *testing.T) {
-	t.Parallel()
-	epoch := time.Unix(1_700_000_000, 0).UTC()
-	firstRoot := makeTree(t, time.Unix(100, 0))
-	secondRoot := makeTree(t, time.Unix(2_000_000_000, 0))
-	firstArchive := filepath.Join(t.TempDir(), "release.tar.gz")
-	secondArchive := filepath.Join(t.TempDir(), "release.tar.gz")
-
-	if err := writeArchive(firstRoot, firstArchive, "devrites-v1.2.3", epoch); err != nil {
-		t.Fatal(err)
-	}
-	if err := writeArchive(secondRoot, secondArchive, "devrites-v1.2.3", epoch); err != nil {
-		t.Fatal(err)
-	}
-	firstBytes, err := os.ReadFile(firstArchive)
-	if err != nil {
-		t.Fatal(err)
-	}
-	secondBytes, err := os.ReadFile(secondArchive)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !bytes.Equal(firstBytes, secondBytes) {
-		t.Fatal("archives differ across source roots and mtimes")
-	}
-
-	got := readArchive(t, firstArchive, epoch)
-	wantNames := []string{
-		"devrites-v1.2.3/",
-		"devrites-v1.2.3/README.md",
-		"devrites-v1.2.3/install.sh",
-		"devrites-v1.2.3/nested/",
-		"devrites-v1.2.3/nested/data.txt",
-	}
-	if !reflect.DeepEqual(got.names, wantNames) {
-		t.Fatalf("archive names = %#v, want %#v", got.names, wantNames)
-	}
-	if got.modes["devrites-v1.2.3/"] != 0o755 ||
-		got.modes["devrites-v1.2.3/install.sh"] != 0o755 ||
-		got.modes["devrites-v1.2.3/README.md"] != 0o644 {
-		t.Fatalf("archive modes = %#v", got.modes)
-	}
-	if got.contents["devrites-v1.2.3/install.sh"] != "#!/bin/sh\nexit 0\n" ||
-		got.contents["devrites-v1.2.3/nested/data.txt"] != "payload\n" {
-		t.Fatalf("archive contents = %#v", got.contents)
-	}
-}
-
-func TestWriteArchiveRejectsUnsafePaths(t *testing.T) {
-	t.Parallel()
-	root := t.TempDir()
-	if err := os.WriteFile(filepath.Join(root, "file"), []byte("safe"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	output := filepath.Join(t.TempDir(), "release.tar.gz")
-
-	if err := writeArchive(root, filepath.Join(root, "release.tar.gz"), "devrites-v1", time.Unix(0, 0)); err == nil {
-		t.Fatal("output inside the staged tree was accepted")
-	}
-	if err := writeArchive(root, output, "../escape", time.Unix(0, 0)); err == nil {
-		t.Fatal("escaping archive prefix was accepted")
-	}
-	if err := writeArchive(root, output, `devrites-v1\escape`, time.Unix(0, 0)); err == nil {
-		t.Fatal("non-portable archive prefix was accepted")
-	}
-
-	link := filepath.Join(root, "unsafe-link")
-	if err := os.Symlink(filepath.Join(t.TempDir(), "outside"), link); err != nil {
-		t.Skipf("symlinks unavailable: %v", err)
-	}
-	err := writeArchive(root, output, "devrites-v1", time.Unix(0, 0))
-	if err == nil || !strings.Contains(err.Error(), "symlink is not allowed") {
-		t.Fatalf("symlink error = %v", err)
-	}
-	if _, statErr := os.Stat(output); !os.IsNotExist(statErr) {
-		t.Fatalf("unsafe archive output exists: %v", statErr)
-	}
-}
-
-func TestWriteEntriesRejectsChangedSource(t *testing.T) {
-	t.Parallel()
-	root := t.TempDir()
-	source := filepath.Join(root, "payload.txt")
-	if err := os.WriteFile(source, []byte("first\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	sourceRoot, err := os.OpenRoot(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = sourceRoot.Close() }()
-	entries, err := collectEntries(sourceRoot, "devrites-v1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	replacement := filepath.Join(root, "replacement")
-	if err := os.WriteFile(replacement, []byte("other\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Remove(source); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Rename(replacement, source); err != nil {
-		t.Fatal(err)
-	}
-
-	var archive bytes.Buffer
-	tw := tar.NewWriter(&archive)
-	err = writeEntries(sourceRoot, tw, entries, time.Unix(0, 0))
-	if err == nil || !strings.Contains(err.Error(), "changed after collection") {
-		t.Fatalf("changed source error = %v", err)
-	}
-}
-
-func TestWriteEntriesRejectsEscapingSymlinkSwap(t *testing.T) {
-	t.Parallel()
-	root := t.TempDir()
-	source := filepath.Join(root, "payload.txt")
-	if err := os.WriteFile(source, []byte("first\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	sourceRoot, err := os.OpenRoot(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = sourceRoot.Close() }()
-	entries, err := collectEntries(sourceRoot, "devrites-v1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	outside := filepath.Join(t.TempDir(), "outside.txt")
-	if err := os.WriteFile(outside, []byte("other\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Remove(source); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, source); err != nil {
-		t.Skipf("symlinks unavailable: %v", err)
-	}
-
-	var archive bytes.Buffer
-	tw := tar.NewWriter(&archive)
-	if err := writeEntries(sourceRoot, tw, entries, time.Unix(0, 0)); err == nil {
-		t.Fatal("escaping symlink swap was accepted")
-	}
-}
-
-func makeTree(t *testing.T, mtime time.Time) string {
-	t.Helper()
-	root := t.TempDir()
-	files := map[string]struct {
-		content string
-		mode    os.FileMode
-	}{
-		"README.md":       {"read me\n", 0o644},
-		"install.sh":      {"#!/bin/sh\nexit 0\n", 0o644},
-		"nested/data.txt": {"payload\n", 0o644},
-	}
-	for name, file := range files {
-		fullPath := filepath.Join(root, name)
-		if err := os.MkdirAll(filepath.Dir(fullPath), 0o755); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(fullPath, []byte(file.content), file.mode); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.Chtimes(fullPath, mtime, mtime); err != nil {
-			t.Fatal(err)
-		}
-	}
-	return root
-}
-
-type archiveContents struct {
-	names    []string
-	modes    map[string]int64
-	contents map[string]string
-}
-
-func readArchive(t *testing.T, archivePath string, epoch time.Time) archiveContents {
-	t.Helper()
-	file, err := os.Open(archivePath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = file.Close() }()
-	gz, err := gzip.NewReader(file)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = gz.Close() }()
-	if !gz.ModTime.Equal(epoch) || gz.OS != 255 || gz.Name != "" || gz.Comment != "" || len(gz.Extra) != 0 {
-		t.Fatalf("gzip header is not normalized: %#v", gz.Header)
-	}
-
-	got := archiveContents{modes: map[string]int64{}, contents: map[string]string{}}
-	tr := tar.NewReader(gz)
-	for {
-		header, err := tr.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			t.Fatal(err)
-		}
-		got.names = append(got.names, header.Name)
-		got.modes[header.Name] = header.Mode
-		if header.Uid != 0 || header.Gid != 0 || header.Uname != "" || header.Gname != "" {
-			t.Fatalf("%s ownership is not normalized: %#v", header.Name, header)
-		}
-		if !header.ModTime.Equal(epoch) || !header.AccessTime.Equal(epoch) || !header.ChangeTime.Equal(epoch) {
-			t.Fatalf("%s timestamps are not normalized: %#v", header.Name, header)
-		}
-		if header.Typeflag == tar.TypeReg {
-			content, err := io.ReadAll(tr)
-			if err != nil {
-				t.Fatal(err)
-			}
-			got.contents[header.Name] = string(content)
-		}
-	}
-	return got
-}

package/engine/harnessmatrix_test.go

@@ -1,46 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-)
-
-func TestHarnessMatrixCommandIsRemoved(t *testing.T) {
-	var stdout, stderr bytes.Buffer
-	if code := run([]string{"harness-matrix"}, strings.NewReader(""), &stdout, &stderr); code != exitUsage {
-		t.Fatalf("run(harness-matrix) = %d, want %d", code, exitUsage)
-	}
-	if stdout.Len() != 0 {
-		t.Fatalf("stdout = %q, want no success output", stdout.String())
-	}
-	if !strings.Contains(stderr.String(), `unknown command "harness-matrix"`) {
-		t.Fatalf("stderr = %q, want unknown-command diagnostic", stderr.String())
-	}
-	if !strings.Contains(stderr.String(), "Usage:") {
-		t.Fatalf("stderr = %q, want help after unknown-command diagnostic", stderr.String())
-	}
-	if strings.Contains(stderr.String(), "\n  devrites-engine harness-matrix ") {
-		t.Fatalf("usage still advertises harness-matrix:\n%s", stderr.String())
-	}
-}
-
-func TestHarnessMatrixCheckCommandIsRemoved(t *testing.T) {
-	var stdout, stderr bytes.Buffer
-	args := []string{"harness-matrix", "--check", "docs/harness-compliance.md"}
-	if code := run(args, strings.NewReader(""), &stdout, &stderr); code != exitUsage {
-		t.Fatalf("run(%q) = %d, want %d", args, code, exitUsage)
-	}
-	if stdout.Len() != 0 {
-		t.Fatalf("stdout = %q, want no success output", stdout.String())
-	}
-	if !strings.Contains(stderr.String(), `unknown command "harness-matrix"`) {
-		t.Fatalf("stderr = %q, want unknown-command diagnostic", stderr.String())
-	}
-	if !strings.Contains(stderr.String(), "Usage:") {
-		t.Fatalf("stderr = %q, want help after unknown-command diagnostic", stderr.String())
-	}
-	if strings.Contains(stderr.String(), "\n  devrites-engine harness-matrix ") {
-		t.Fatalf("usage still advertises harness-matrix:\n%s", stderr.String())
-	}
-}

package/engine/help_test.go

@@ -1,241 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/notes"
-)
-
-func TestCommandHelp(t *testing.T) {
-	t.Setenv("DEVRITES_ROOT", "")
-	tests := []struct {
-		args []string
-		want string
-	}{
-		{args: []string{"--help"}, want: "Usage:"},
-		{args: []string{"-h"}, want: "Usage:"},
-		{args: []string{"help"}, want: "Usage:"},
-		{args: []string{"check", "--help"}, want: "check candidate <slug>"},
-		{args: []string{"check", "help"}, want: "check <candidate|readiness|seal|path-disjoint|task-graph|slice|diff-scope|skill-trust|indexes|regression|drift|windows|dup>"},
-		{args: []string{"check", "candidate", "--help"}, want: "check candidate <slug>"},
-		{args: []string{"check", "readiness", "-h"}, want: "check readiness --emit-binding <slug>"},
-		{args: []string{"check", "seal", "--help"}, want: "check seal <slug>"},
-		{args: []string{"check", "path-disjoint", "--help"}, want: "check path-disjoint"},
-		{args: []string{"check", "task-graph", "--help"}, want: "check task-graph <slug>"},
-		{args: []string{"check", "skill-trust", "--help"}, want: "check skill-trust <path>"},
-		{args: []string{"check", "indexes", "--help"}, want: "check indexes [--root <dir>]"},
-		{args: []string{"check", "dup", "--help"}, want: "check dup [slug]"},
-		{args: []string{"check", "drift", "--help"}, want: "check drift <slug>"},
-		{args: []string{"detect", "--help"}, want: "detect commands [--root <dir>]"},
-		{args: []string{"state", "--help"}, want: "state <resolve|merge-manifest|close>"},
-		{args: []string{"state", "-h"}, want: "state resolve"},
-		{args: []string{"state", "help"}, want: "state close <slug>"},
-		{args: []string{"state", "resolve", "--help"}, want: `state resolve <qid> "<answer>"`},
-		{args: []string{"state", "merge-manifest", "--help"}, want: "state merge-manifest <slug>"},
-		{args: []string{"state", "close", "--help"}, want: "state close <slug>"},
-		{args: []string{"parallel", "--help"}, want: "usage: parallel <subcommand>"},
-		{args: []string{"parallel", "create", "--help"}, want: "usage: parallel create --root --slug --batch --base --json"},
-		{args: []string{"parallel", "create", "-h"}, want: "parallel create"},
-		{args: []string{"parallel", "select", "--help"}, want: "parallel select --cap"},
-		{args: []string{"observe", "--help"}, want: "observe summary"},
-		{args: []string{"observe", "summary", "--help"}, want: "observe summary"},
-		{args: []string{"observe", "slice", "--help"}, want: "observe slice <slug> <SLICE-ID>"},
-		{args: []string{"orient", "--help"}, want: "orient [slug]"},
-		{args: []string{"handoff", "--help"}, want: "handoff [slug]"},
-		{args: []string{"next", "help"}, want: "devrites-engine next [slug]"},
-		{args: []string{"dispatch", "help"}, want: "devrites-engine dispatch <slug>"},
-		{args: []string{"dispatch", "x", "open", "--help"}, want: "devrites-engine dispatch <slug>"},
-		{args: []string{"secret-scan", "help"}, want: "secret-scan [--staged] [--stdin]"},
-		{args: []string{"open-visual", "help"}, want: "open-visual <path-or-name>"},
-		{args: []string{"claim", "--help"}, want: "claim <add|release|list|check>"},
-		{args: []string{"claim", "help"}, want: "claim <add|release|list|check>"},
-		{args: []string{"migrate", "--help"}, want: "migrate <slug>"},
-		{args: []string{"secret-scan", "--help"}, want: "secret-scan [--staged] [--stdin]"},
-		{args: []string{"open-visual", "--help"}, want: "open-visual <path-or-name>"},
-		{args: []string{"overhaul", "--help"}, want: "overhaul records validate <run>"},
-		{args: []string{"overhaul", "help"}, want: "overhaul snapshot capture <repo> <out>"},
-		{args: []string{"version", "--help"}, want: "devrites-engine version"},
-		{args: []string{"install", "--help"}, want: "usage: devrites-engine install"},
-		{args: []string{"update", "--help"}, want: "usage: devrites-engine update"},
-		{args: []string{"uninstall", "--help"}, want: "usage: devrites-engine uninstall"},
-	}
-	for _, test := range tests {
-		t.Run(strings.Join(test.args, " "), func(t *testing.T) {
-			var stdout, stderr bytes.Buffer
-			code := run(test.args, strings.NewReader(""), &stdout, &stderr)
-			if code != exitOK {
-				t.Fatalf("run(%q) = %d, want %d; stdout=%q stderr=%q", test.args, code, exitOK, stdout.String(), stderr.String())
-			}
-			if stderr.Len() != 0 {
-				t.Fatalf("run(%q) wrote stderr %q", test.args, stderr.String())
-			}
-			if !strings.Contains(stdout.String(), test.want) {
-				t.Fatalf("run(%q) stdout=%q, want %q", test.args, stdout.String(), test.want)
-			}
-			if strings.Contains(stdout.String(), "unknown") {
-				t.Fatalf("run(%q) treated help as unknown: %q", test.args, stdout.String())
-			}
-		})
-	}
-}
-
-func TestCommandHelpDoesNotRequireWorkspace(t *testing.T) {
-	t.Setenv("DEVRITES_ROOT", "")
-	for _, args := range [][]string{
-		{"state", "--help"},
-		{"check", "candidate", "--help"},
-		{"orient", "--help"},
-		{"migrate", "--help"},
-		{"parallel", "create", "--help"},
-	} {
-		var stdout, stderr bytes.Buffer
-		code := run(args, strings.NewReader(""), &stdout, &stderr)
-		if code != exitOK || stderr.Len() != 0 || !strings.Contains(stdout.String(), "usage:") {
-			t.Fatalf("run(%q) code=%d stdout=%q stderr=%q", args, code, stdout.String(), stderr.String())
-		}
-		if strings.Contains(stdout.String()+stderr.String(), "root selection") {
-			t.Fatalf("run(%q) required a workspace for help", args)
-		}
-	}
-}
-
-func TestUnknownCommandHelpStillUnknown(t *testing.T) {
-	var stdout, stderr bytes.Buffer
-	args := []string{"frobnicate", "--help"}
-	if code := run(args, strings.NewReader(""), &stdout, &stderr); code != exitUsage {
-		t.Fatalf("run(%q) = %d, want %d", args, code, exitUsage)
-	}
-	if !strings.Contains(stderr.String(), `unknown command "frobnicate"`) {
-		t.Fatalf("stderr = %q, want unknown-command diagnostic", stderr.String())
-	}
-}
-
-func TestHelpTokenInValuePositionDoesNotShortCircuit(t *testing.T) {
-	for _, quote := range []string{"maxConns = 4", "--help", "-h", "-help"} {
-		t.Run(quote, func(t *testing.T) {
-			project, _ := noteWorkspace(t)
-			writeBasenameFile(t, project, "pool.go", "package src\n\n// flags: --help -h -help\nconst maxConns = 4\n")
-			var stdout, stderr bytes.Buffer
-			args := []string{"note", "add", "feature", "pool.go", quote, "some title"}
-			code := run(args, strings.NewReader(""), &stdout, &stderr)
-			notes := filepath.Join(project, ".devrites", "work", "feature", "notes.md")
-			if _, err := os.Stat(notes); err != nil {
-				t.Fatalf("notes.md absent (code=%d stdout=%.80q stderr=%q)", code, stdout.String(), stderr.String())
-			}
-			if code != exitOK || !strings.Contains(stdout.String(), "added: NOTE-001") {
-				t.Fatalf("code=%d stdout=%q", code, stdout.String())
-			}
-		})
-	}
-	for _, args := range [][]string{{"note", "add", "--help"}, {"note", "--help"}, {"check", "seal", "--help"}} {
-		var stdout, stderr bytes.Buffer
-		if code := run(args, strings.NewReader(""), &stdout, &stderr); code != exitOK || !strings.Contains(stdout.String(), "usage") && !strings.Contains(stdout.String(), "Usage") {
-			t.Fatalf("%v code=%d stdout=%.80q", args, code, stdout.String())
-		}
-	}
-}
-
-func TestHelpTokenAsFlagValueOrOperandIsNotHelp(t *testing.T) {
-	for _, tok := range []string{"--help", "-h", "-help"} {
-		_, root := noteWorkspace(t)
-		var stdout, stderr bytes.Buffer
-		code := run([]string{"claim", "add", "--reason", tok, "--session", "s1", "src/a.go"}, strings.NewReader(""), &stdout, &stderr)
-		if _, err := os.Stat(filepath.Join(root, "claims.jsonl")); err != nil || code != exitOK {
-			t.Fatalf("reason=%s: code=%d claims absent (%v) stdout=%.60q", tok, code, err, stdout.String())
-		}
-		_, root = noteWorkspace(t)
-		stdout.Reset()
-		code = run([]string{"claim", "add", "--session", "s1", "src/a.go", tok}, strings.NewReader(""), &stdout, &stderr)
-		if _, err := os.Stat(filepath.Join(root, "claims.jsonl")); err == nil {
-			t.Fatalf("trailing %s wrote a claim", tok)
-		}
-		if code != exitOK || !strings.Contains(stdout.String(), "claim") {
-			t.Fatalf("trailing %s code=%d stdout=%.60q", tok, code, stdout.String())
-		}
-	}
-	_, root := noteWorkspace(t)
-	var stdout, stderr bytes.Buffer
-	if code := run([]string{"claim", "add", "--reason", "ordinary", "--session", "s1", "src/a.go"}, strings.NewReader(""), &stdout, &stderr); code != exitOK {
-		t.Fatalf("control code=%d", code)
-	}
-	if _, err := os.Stat(filepath.Join(root, "claims.jsonl")); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestHelpFlagAfterOtherFlagsPrintsHelp(t *testing.T) {
-	t.Setenv("DEVRITES_ROOT", "")
-	for _, test := range []struct {
-		args []string
-		want string
-	}{
-		{[]string{"secret-scan", "--staged", "--help"}, "secret-scan [--staged] [--stdin]"},
-		{[]string{"secret-scan", "--staged", "--stdin", "-h"}, "secret-scan [--staged] [--stdin]"},
-		{[]string{"check", "indexes", "--json", "-help"}, "check indexes [--root <dir>]"},
-		{[]string{"parallel", "create", "--json", "--help"}, "parallel create"},
-	} {
-		var stdout, stderr bytes.Buffer
-		code := run(test.args, strings.NewReader(""), &stdout, &stderr)
-		if code != exitOK || stderr.Len() != 0 || !strings.Contains(stdout.String(), test.want) {
-			t.Fatalf("run(%q) code=%d stdout=%.80q stderr=%q", test.args, code, stdout.String(), stderr.String())
-		}
-	}
-}
-
-func TestUsageListsRuntimeFailureExit(t *testing.T) {
-	if !strings.Contains(usage, "\n  1  runtime/I/O failure\n") {
-		t.Fatalf("usage Exit codes block omits exit 1:\n%s", usage)
-	}
-}
-
-func TestCLIDocsStateCloseExitCodes(t *testing.T) {
-	data, err := os.ReadFile(filepath.Join("..", "docs", "cli.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	doc := string(data)
-	for _, want := range []string{
-		"`state close` exits `4` for usage or a missing workspace",
-		"`3` for a schema refusal",
-		"`5` when an archive already exists",
-		"`1` for an invalid workspace, archive directory, or ACTIVE cursor",
-	} {
-		if !strings.Contains(doc, want) {
-			t.Errorf("docs/cli.md omits %q", want)
-		}
-	}
-}
-
-func TestNoteHelpAndErrorPathShareLegendAndExitCodes(t *testing.T) {
-	const grades = "Grades: exact | moved | stale | ambiguous | lost"
-	const exits = "Exit codes: 0 ok, 2 usage, 3 blocked"
-	for _, args := range [][]string{
-		{"note", "--help"},
-		{"note", "help"},
-		{"note", "add", "--help"},
-	} {
-		var stdout, stderr bytes.Buffer
-		code := run(args, strings.NewReader(""), &stdout, &stderr)
-		if code != exitOK || stderr.Len() != 0 {
-			t.Fatalf("run(%q) code=%d stderr=%q", args, code, stderr.String())
-		}
-		for _, want := range []string{grades, exits} {
-			if !strings.Contains(stdout.String(), want) {
-				t.Errorf("run(%q) help omits %q:\n%s", args, want, stdout.String())
-			}
-		}
-	}
-	var stdout, stderr bytes.Buffer
-	if code := notes.Run(t.TempDir(), nil, &stdout, &stderr); code != notes.ExitUsage {
-		t.Fatalf("notes.Run with no args = %d, want usage", code)
-	}
-	for _, want := range []string{grades, exits} {
-		if !strings.Contains(stderr.String(), want) {
-			t.Errorf("note usage error omits %q:\n%s", want, stderr.String())
-		}
-	}
-}