devrites 6.0.4 → 6.1.1

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())
-		}
-	}
-}