devrites 5.13.0 → 5.14.0

package/engine/internal/overhaul/records/init.go

@@ -0,0 +1,132 @@
+package records
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/devrites/devrites/internal/gitenv"
+	"github.com/devrites/devrites/internal/overhaul/snapshot"
+)
+
+var runIDPattern = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$`)
+
+// excludeLine is what init adds to the local .git/info/exclude when git does
+// not already ignore the run area. It never edits the shared .gitignore.
+const excludeLine = "/" + snapshot.RunAreaDir
+
+// initRun creates <repo>/.devrites/overhaul/<run-id>/ owner-only and makes
+// sure git ignores it, so run records never show up as repository changes.
+func initRun(repo, runID string, stdout io.Writer) error {
+	if !runIDPattern.MatchString(runID) {
+		return fmt.Errorf("run id %q: use 1-64 letters, digits, '.', '_' or '-', starting with a letter or digit", runID)
+	}
+	top, err := gitText(repo, "rev-parse", "--show-toplevel")
+	if err != nil {
+		return fmt.Errorf("%s is not a git repository: %v", repo, err)
+	}
+	runDir := filepath.Join(filepath.FromSlash(top), filepath.FromSlash(snapshot.RunAreaDir), runID)
+	if _, err := os.Lstat(runDir); err == nil {
+		return fmt.Errorf("run area %s already exists; resume it or pick a new run id", runDir)
+	}
+	probe := snapshot.RunAreaDir + runID + "/probe"
+	how := "already-ignored"
+	ignored, err := gitIgnores(top, probe)
+	if err != nil {
+		return err
+	}
+	if !ignored {
+		if err := addExclude(top); err != nil {
+			return err
+		}
+		if ignored, err = gitIgnores(top, probe); err != nil {
+			return err
+		}
+		if !ignored {
+			return fmt.Errorf("git still does not ignore %s after adding %s to info/exclude; a negated rule may re-include it", snapshot.RunAreaDir, excludeLine)
+		}
+		how = "added-to-info-exclude"
+	}
+	if err := os.MkdirAll(filepath.Dir(runDir), 0o700); err != nil {
+		return err
+	}
+	if err := os.Mkdir(runDir, 0o700); err != nil {
+		return err
+	}
+	b, err := json.Marshal(struct {
+		Run    string `json:"run"`
+		Ignore string `json:"ignore"`
+	}{runDir, how})
+	if err != nil {
+		return err
+	}
+	_, err = fmt.Fprintln(stdout, string(b))
+	return err
+}
+
+func addExclude(top string) error {
+	p, err := gitText(top, "rev-parse", "--git-path", "info/exclude")
+	if err != nil {
+		return err
+	}
+	path := filepath.FromSlash(p)
+	if !filepath.IsAbs(path) {
+		path = filepath.Join(top, path)
+	}
+	// #nosec G304 -- exclude file inside the repo's own resolved git dir
+	if data, err := os.ReadFile(path); err == nil {
+		for _, l := range strings.Split(string(data), "\n") {
+			if strings.TrimSpace(l) == excludeLine {
+				return nil
+			}
+		}
+	}
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		return err
+	}
+	// #nosec G304 -- exclude file inside the repo's own resolved git dir
+	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
+	if err != nil {
+		return err
+	}
+	_, werr := fmt.Fprintf(f, "\n# /overhaul run records (local only)\n%s\n", excludeLine)
+	if cerr := f.Close(); werr == nil {
+		werr = cerr
+	}
+	return werr
+}
+
+// gitIgnores reports whether git's ignore rules match rel (tracked or not).
+func gitIgnores(top, rel string) (bool, error) {
+	cmd := gitCmd(top, "check-ignore", "-q", "--no-index", rel)
+	err := cmd.Run()
+	var ee *exec.ExitError
+	switch {
+	case err == nil:
+		return true, nil
+	case errors.As(err, &ee) && ee.ExitCode() == 1:
+		return false, nil
+	default:
+		return false, fmt.Errorf("git check-ignore: %v", err)
+	}
+}
+
+func gitText(dir string, args ...string) (string, error) {
+	out, err := gitCmd(dir, args...).Output()
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(out)), nil
+}
+
+func gitCmd(dir string, args ...string) *exec.Cmd {
+	cmd := exec.Command("git", append([]string{"-C", dir}, args...)...) // #nosec G204 -- fixed git binary; arguments passed as argv, no shell
+	cmd.Env = append(gitenv.Sanitize(os.Environ()), "GIT_OPTIONAL_LOCKS=0", "GIT_TERMINAL_PROMPT=0")
+	return cmd
+}

package/engine/internal/overhaul/records/init_test.go

@@ -0,0 +1,96 @@
+package records
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func gitRepo(t *testing.T) string {
+	t.Helper()
+	root := t.TempDir()
+	cmd := exec.Command("git", "init", "-q", root)
+	cmd.Env = append(os.Environ(), "GIT_CONFIG_GLOBAL="+os.DevNull, "GIT_CONFIG_NOSYSTEM=1")
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("git init: %v %s", err, out)
+	}
+	return root
+}
+
+func initRunCmd(args ...string) (int, string, string) {
+	var o, e bytes.Buffer
+	code := Run(append([]string{"init"}, args...), &o, &e)
+	return code, o.String(), e.String()
+}
+
+func TestInitCreatesIgnoredRunArea(t *testing.T) {
+	repo := gitRepo(t)
+	code, out, errs := initRunCmd(repo, "ov-1")
+	if code != 0 {
+		t.Fatalf("init: %d %s", code, errs)
+	}
+	var got struct{ Run, Ignore string }
+	if err := json.Unmarshal([]byte(out), &got); err != nil {
+		t.Fatalf("output %q: %v", out, err)
+	}
+	want := filepath.Join(repo, ".devrites", "overhaul", "ov-1")
+	if r1, _ := filepath.EvalSymlinks(got.Run); r1 != mustEval(t, want) || got.Ignore != "added-to-info-exclude" {
+		t.Fatalf("got %+v, want run %s added-to-info-exclude", got, want)
+	}
+	if fi, err := os.Stat(want); err != nil || !fi.IsDir() || (runtime.GOOS != "windows" && fi.Mode().Perm() != 0o700) {
+		t.Fatalf("run dir: %v %v", fi, err)
+	}
+	b, _ := os.ReadFile(filepath.Join(repo, ".git", "info", "exclude"))
+	if !strings.Contains(string(b), "/.devrites/overhaul/\n") {
+		t.Fatalf("exclude file: %q", b)
+	}
+	// Idempotent exclude, refused reuse of an existing run id.
+	if code, _, _ := initRunCmd(repo, "ov-2"); code != 0 {
+		t.Fatal("second run id refused")
+	}
+	b2, _ := os.ReadFile(filepath.Join(repo, ".git", "info", "exclude"))
+	if strings.Count(string(b2), "/.devrites/overhaul/") != 1 {
+		t.Fatalf("exclude line duplicated: %q", b2)
+	}
+	if code, _, errs := initRunCmd(repo, "ov-1"); code != 2 || !strings.Contains(errs, "already exists") {
+		t.Fatalf("reuse: %d %s", code, errs)
+	}
+}
+
+func TestInitRespectsExistingIgnore(t *testing.T) {
+	repo := gitRepo(t)
+	write(t, filepath.Join(repo, ".gitignore"), ".devrites/\n")
+	code, out, errs := initRunCmd(repo, "ov-1")
+	if code != 0 || !strings.Contains(out, `"already-ignored"`) {
+		t.Fatalf("init: %d %s %s", code, out, errs)
+	}
+	if b, err := os.ReadFile(filepath.Join(repo, ".git", "info", "exclude")); err == nil && strings.Contains(string(b), "overhaul") {
+		t.Fatalf("exclude touched although already ignored: %q", b)
+	}
+}
+
+func TestInitRejectsBadInput(t *testing.T) {
+	repo := gitRepo(t)
+	for _, id := range []string{"", "../x", "a/b", ".hidden", "x y"} {
+		if code, _, _ := initRunCmd(repo, id); code != 2 {
+			t.Errorf("run id %q accepted", id)
+		}
+	}
+	if code, _, _ := initRunCmd(t.TempDir(), "ov-1"); code != 2 {
+		t.Error("non-repository accepted")
+	}
+}
+
+func mustEval(t *testing.T, p string) string {
+	t.Helper()
+	r, err := filepath.EvalSymlinks(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return r
+}

package/engine/internal/overhaul/records/records_test.go

@@ -119,6 +119,27 @@ func (f *fixture) publish(recs map[string]J, extra map[string]string) (int, stri
 	return code, out + errs
 }
 
+// publishRendered stages recs, renders review and report views into the stage, then publishes.
+func (f *fixture) publishRendered(recs map[string]J) (int, string) {
+	f.t.Helper()
+	code, out, errs := f.cmd("stage", f.run)
+	if code != 0 {
+		f.t.Fatalf("stage: %d %s", code, errs)
+	}
+	tmp := strings.TrimSpace(out)
+	for name, doc := range recs {
+		write(f.t, filepath.Join(tmp, name), doc)
+	}
+	for _, kind := range []string{"review", "report"} {
+		var o, e bytes.Buffer
+		if c := render.Run([]string{f.run, tmp, kind}, &o, &e); c != 0 {
+			f.t.Fatalf("render %s: %d %s", kind, c, e.String())
+		}
+	}
+	code, out, errs = f.cmd("publish", f.run)
+	return code, out + errs
+}
+
 func (f *fixture) mustPublish(recs map[string]J) {
 	f.t.Helper()
 	if code, out := f.publish(recs, nil); code != 0 {
@@ -338,6 +359,14 @@ func TestSingleGenerationRules(t *testing.T) {
 			r["cycles.json"]["schema"] = "overhaul.cycle/1"
 			r["run.json"]["mode"] = "yolo"
 		}, "run.json: mode='yolo' not in ['branch', 'full', 'pr']"},
+		{"stopped run without report views", func(f *fixture, r map[string]J) {
+			r["run.json"]["execution_outcome"] = "READY_FOR_USER_REVIEW"
+			r["run.json"]["task_outcomes"] = J{"T-1": "completed"}
+		}, "views/report.html is required once the run stops"},
+		{"awaiting approval without review views", func(f *fixture, r map[string]J) {
+			r["run.json"]["execution_outcome"] = "AWAITING_APPROVAL"
+			r["run.json"]["phase"] = "AWAITING_APPROVAL"
+		}, "views/review.html is required while awaiting approval"},
 		{"ineligible coverage without reason", func(f *fixture, r map[string]J) {
 			r["coverage.json"]["files"] = L{J{"path": "src/a.py", "eligible": false}}
 		}, "coverage src/a.py: ineligible without an exclusion reason"},
@@ -347,7 +376,11 @@ func TestSingleGenerationRules(t *testing.T) {
 			f := newFixture(t)
 			r := f.records()
 			c.mutate(f, r)
-			code, out := f.publish(r, nil)
+			publish := func() (int, string) { return f.publish(r, nil) }
+			if c.want == "" {
+				publish = func() (int, string) { return f.publishRendered(r) }
+			}
+			code, out := publish()
 			if c.want == "" {
 				if code != 0 {
 					t.Fatalf("want publish ok, got %d:\n%s", code, out)
@@ -554,6 +587,7 @@ func TestBadPath(t *testing.T) {
 		{"./src/a.py", "not normalized or escapes the repository"},
 		{"src", "names a directory or git metadata"},
 		{".git/config", "names a directory or git metadata"},
+		{".devrites/overhaul/r1/g0001/run.json", "names the overhaul run area"},
 		{"src/.git/HEAD", "names a directory or git metadata"},
 		{"src/out.py", "resolves outside the repository (symlink or traversal)"},
 	}

package/engine/internal/overhaul/records/run.go

@@ -1,6 +1,7 @@
 // Package records implements the /overhaul records tool: generation staging
 // and publishing plus cross-record validation of a run area.
 //
+//	init REPO ID    create REPO/.devrites/overhaul/ID (0700) and make git ignore it
 //	digest FILE     sha256 of exact bytes
 //	stage RUN       copy current generation to RUN/g<N+1>.tmp (prints path)
 //	publish RUN     validate staged generation, write manifest, swap CURRENT last
@@ -25,6 +26,7 @@ import (
 
 const usage = `usage: overhaul records <command> ...
 
+  init REPO ID    create REPO/.devrites/overhaul/ID (0700) and make git ignore it
   digest FILE     sha256 of exact bytes
   stage RUN       copy current generation to RUN/g<N+1>.tmp (prints path)
   publish RUN     validate staged generation, write manifest, swap CURRENT last
@@ -46,6 +48,12 @@ func Run(args []string, stdout, stderr io.Writer) int {
 		if d, err = sha(args[1]); err == nil {
 			fmt.Fprintln(stdout, d)
 		}
+	case "init":
+		if len(args) != 3 {
+			fmt.Fprint(stderr, usage)
+			return 2
+		}
+		err = initRun(args[1], args[2], stdout)
 	case "stage":
 		code, err = stage(args[1], stdout, stderr)
 	case "publish":