devrites 2.6.1 → 3.0.0

package/engine/internal/lib/progress.go

@@ -0,0 +1,168 @@
+package lib
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+// State-parsing patterns ported verbatim from progress.sh's awk. Each name-strip
+// sub is anchored (^ or $), so it matches at most once per line — ReplaceAllString
+// is therefore equivalent to awk's single-match sub.
+var (
+	phaseSplitRe   = regexp.MustCompile(`: *`)
+	sliceCheckRe   = regexp.MustCompile(`^- \[[^\]]*\][[:space:]]*`)             // drop "- [x] "
+	sliceNameRe    = regexp.MustCompile(`^Slice[[:space:]]*[0-9]+:[[:space:]]*`) // drop "Slice N: "
+	sliceStateRe   = regexp.MustCompile(`[[:space:]]+(built|pending)[[:space:]]*$`)
+	sliceSepRe     = regexp.MustCompile(`[[:space:]]+[^[:alnum:][:space:]]+[[:space:]]*$`) // drop " — "
+	sliceCheckedRe = regexp.MustCompile(`\[[xX]\]`)
+)
+
+// Progress renders the active feature's position — the deterministic footer every
+// workspace-operating rite-* skill prints last. Read-only. Prints nothing and
+// exits 0 when there is no active workspace, so pre-spec callers stay silent. root
+// is the .devrites directory; slug defaults to the active feature at <root>/ACTIVE.
+func Progress(root string, args []string, stdout, stderr io.Writer) int {
+	slug := ""
+	if len(args) > 0 {
+		slug = args[0]
+	}
+	if slug == "" {
+		slug = activeSlug(root)
+	}
+	workDir := featureDir(root, slug)
+	statePath := filepath.Join(workDir, "state.md")
+	if slug == "" || !isFile(statePath) {
+		return 0 // silent — no active workspace
+	}
+	stateBytes, err := os.ReadFile(statePath)
+	if err != nil {
+		return 0
+	}
+	lines := splitLinesNoTrailing(stateBytes)
+
+	phase := parsePhase(lines)
+	if phase == "" {
+		phase = "spec"
+	}
+	total, built, lastbuilt := tallySlices(lines)
+
+	// Header rule: pad "── rite-<phase> " with box glyphs to ≥44 BYTES. Under the
+	// oracle's LC_ALL=C the bash `${#header}` counts bytes, which len() matches.
+	header := "── rite-" + phase + " "
+	for len(header) < 44 {
+		header += "─"
+	}
+	fmt.Fprintf(stdout, "%s\n", header)
+
+	// Slice meter: a 10-cell bar, filled = round(built/total*10). Skipped before
+	// any slices exist.
+	if total > 0 {
+		filled := (built*10 + total/2) / total
+		if filled > 10 {
+			filled = 10
+		}
+		bar := strings.Repeat("█", filled) + strings.Repeat("░", 10-filled)
+		if built >= total {
+			fmt.Fprintf(stdout, "Slices %d/%d  %s  ✅ ALL BUILT\n", built, total, bar)
+		} else {
+			tail := ""
+			if lastbuilt != "" {
+				tail = "  " + lastbuilt + " ✓"
+			}
+			fmt.Fprintf(stdout, "Slice %d/%d  %s%s\n", built, total, bar, tail)
+		}
+	}
+
+	// Flow ribbon: the lifecycle spine; temper/vet appear only once their artifact
+	// exists.
+	order := []string{"spec"}
+	if isFile(filepath.Join(workDir, "strategy.md")) {
+		order = append(order, "temper")
+	}
+	order = append(order, "define")
+	if isFile(filepath.Join(workDir, "eng-review.md")) {
+		order = append(order, "vet")
+	}
+	order = append(order, "build", "prove", "polish", "review", "seal", "ship")
+
+	cur := phase
+	if cur == "plan" { // replan sits at build
+		cur = "build"
+	}
+	idx := -1
+	if phase == "done" { // past ship
+		idx = len(order)
+	} else {
+		for n, name := range order {
+			if name == cur {
+				idx = n
+				break
+			}
+		}
+	}
+	ribbon := "Flow  "
+	for n, name := range order {
+		g := "○"
+		if n < idx {
+			g = "✓"
+		} else if n == idx {
+			g = "◉"
+		}
+		ribbon += " " + name + " " + g
+	}
+	fmt.Fprintf(stdout, "%s\n", ribbon)
+	return 0
+}
+
+// parsePhase returns the first whitespace token of the value on the first
+// "- Phase:" line, mirroring progress.sh's `awk -F': *' '/^- Phase:/{print $2}' |
+// awk '{print $1}'`. Empty when absent.
+func parsePhase(lines []string) string {
+	for _, line := range lines {
+		if !strings.HasPrefix(line, "- Phase:") {
+			continue
+		}
+		fields := phaseSplitRe.Split(line, -1)
+		if len(fields) < 2 {
+			return ""
+		}
+		toks := strings.Fields(fields[1])
+		if len(toks) == 0 {
+			return ""
+		}
+		return toks[0]
+	}
+	return ""
+}
+
+// tallySlices reads the "## Slice progress" block: total slice lines, how many are
+// checked, and the display name of the last checked one — the awk in progress.sh.
+func tallySlices(lines []string) (total, built int, lastbuilt string) {
+	inp := false
+	for _, line := range lines {
+		if strings.HasPrefix(line, "## Slice progress") {
+			inp = true
+			continue
+		}
+		if inp && strings.HasPrefix(line, "## ") {
+			inp = false
+		}
+		if inp && strings.HasPrefix(line, "- [") {
+			total++
+			name := line
+			name = sliceCheckRe.ReplaceAllString(name, "")
+			name = sliceNameRe.ReplaceAllString(name, "")
+			name = sliceStateRe.ReplaceAllString(name, "")
+			name = sliceSepRe.ReplaceAllString(name, "")
+			if sliceCheckedRe.MatchString(line) {
+				built++
+				lastbuilt = name
+			}
+		}
+	}
+	return total, built, lastbuilt
+}

package/engine/internal/lib/reconcile.go

@@ -0,0 +1,173 @@
+package lib
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+// Reconcile enforces that the orchestrator never edits source itself — only the
+// dispatched slice-wright writes code and tests, while the orchestrator writes
+// bookkeeping under .devrites/. `snapshot` records the working tree just before
+// the wright runs; `check` diffs it afterward and flags any changed path that is
+// neither under .devrites/ nor in the wright's claimed set. The workspace is
+// <root>/features/<slug>.
+//
+//	0  clean check, snapshot written, inline fallback, or skipped (not a git repo)
+//	5  VIOLATION — source changed outside the wright's claimed set
+//	6  setup error — bad args, missing snapshot, or missing claimed manifest
+func Reconcile(root string, args []string, stdout, stderr io.Writer) int {
+	mode := argAt(args, 0)
+	slug := argAt(args, 1)
+	if slug == "" {
+		slug = activeSlug(root)
+	}
+
+	cwd, _ := os.Getwd()
+	gitRoot := gitToplevel(cwd)
+	if gitRoot == "" {
+		fmt.Fprintln(stderr, "reconcile: not a git repo — gate skipped, verify the diff by hand.")
+		return 0
+	}
+
+	d := featureDir(root, slug)
+	base := filepath.Join(d, ".reconcile-base")
+	claimed := filepath.Join(d, ".reconcile-claimed")
+	inline := filepath.Join(d, ".reconcile-inline")
+
+	if slug == "" || !isDir(d) {
+		s := slug
+		if s == "" {
+			s = "<unset>"
+		}
+		fmt.Fprintf(stderr, "reconcile: no active workspace (slug=%s) — nothing to reconcile.\n", s)
+		return 6
+	}
+
+	closeWindow := func() { _ = os.Remove(base); _ = os.Remove(claimed); _ = os.Remove(inline) }
+
+	switch mode {
+	case "snapshot":
+		_ = os.Remove(inline) // clear any stale sentinel / prior-slice manifest
+		_ = os.Remove(claimed)
+		tree, err := worktreeTree(gitRoot)
+		if err != nil {
+			fmt.Fprintf(stderr, "reconcile: cannot snapshot worktree: %v\n", err)
+			return 6
+		}
+		if err := os.WriteFile(base, []byte(tree+"\n"), 0o644); err != nil {
+			fmt.Fprintf(stderr, "reconcile: cannot write snapshot: %v\n", err)
+			return 6
+		}
+		fmt.Fprintf(stdout, "reconcile: snapshot captured for %s.\n", slug)
+		return 0
+
+	case "check":
+		if isFile(inline) {
+			fmt.Fprintln(stderr, "reconcile: inline-fallback run (no wright dispatched) — gate skipped.")
+			closeWindow()
+			return 0
+		}
+		if !isFile(base) {
+			fmt.Fprintln(stderr, `reconcile: no snapshot (.reconcile-base) — run "devrites-engine reconcile snapshot" before dispatch.`)
+			return 6
+		}
+		if !isFile(claimed) {
+			fmt.Fprintln(stderr, "reconcile: no claimed manifest (.reconcile-claimed) — write the wright Files-changed paths first.")
+			return 6
+		}
+		baseBytes, err := os.ReadFile(base)
+		if err != nil {
+			fmt.Fprintf(stderr, "reconcile: cannot read snapshot: %v\n", err)
+			return 6
+		}
+		baseTree := strings.TrimSpace(string(baseBytes))
+		if baseTree == "" {
+			fmt.Fprintln(stderr, "reconcile: empty snapshot (.reconcile-base) — re-run \"devrites-engine reconcile snapshot\" before dispatch.")
+			return 6
+		}
+		nowTree, err := worktreeTree(gitRoot)
+		if err != nil {
+			fmt.Fprintf(stderr, "reconcile: cannot capture worktree: %v\n", err)
+			return 6
+		}
+
+		claimedSet := claimedPaths(claimed)
+		viol := 0
+		var violist strings.Builder
+		for _, f := range gitDiffNames(gitRoot, baseTree, nowTree) {
+			if f == "" || strings.HasPrefix(f, ".devrites/") {
+				continue
+			}
+			if _, ok := claimedSet[f]; !ok {
+				viol++
+				fmt.Fprintf(&violist, "  - %s\n", f)
+			}
+		}
+		if viol > 0 {
+			fmt.Fprintf(stderr, "reconcile: STOP — %d source file(s) changed OUTSIDE the wright (A1 breach):\n", viol)
+			fmt.Fprint(stderr, violist.String())
+			fmt.Fprintln(stderr, "The orchestrator must NOT edit source. Re-dispatch the wright (continue it once) or revert these.")
+			return 5
+		}
+		closeWindow()
+		fmt.Fprintln(stdout, "reconcile: OK — every source change is the wright's; orchestrator touched only bookkeeping.")
+		return 0
+
+	default:
+		fmt.Fprintln(stderr, "reconcile: usage: devrites-engine reconcile <snapshot|check> [slug]")
+		return 6
+	}
+}
+
+// worktreeTree captures the whole working tree (tracked + untracked, .gitignore
+// honored) as a git tree object via a throwaway index, so the user's real index
+// is never touched.
+//
+// A failing "git add -A" must not be ignored: write-tree would still succeed
+// against the empty throwaway index and return the empty-tree sha. Both the
+// snapshot and the check would then record that same sha, the diff would come
+// back empty, and the gate would report OK on precisely the A1 breach it exists
+// to catch. Surface the error and let the caller fail closed.
+func worktreeTree(gitRoot string) (string, error) {
+	idx := filepath.Join(os.TempDir(), fmt.Sprintf("devrites-reconcile-%d.idx", os.Getpid()))
+	_ = os.Remove(idx)
+	defer func() { _ = os.Remove(idx) }()
+	env := append(os.Environ(), "GIT_INDEX_FILE="+idx)
+
+	add := exec.Command("git", "-C", gitRoot, "add", "-A")
+	add.Env = env
+	add.Stdout, add.Stderr = io.Discard, io.Discard
+	if err := add.Run(); err != nil {
+		return "", fmt.Errorf("git add -A: %w", err)
+	}
+
+	write := exec.Command("git", "-C", gitRoot, "write-tree")
+	write.Env = env
+	out, err := write.Output()
+	if err != nil {
+		return "", fmt.Errorf("git write-tree: %w", err)
+	}
+	tree := strings.TrimSpace(string(out))
+	if tree == "" {
+		return "", fmt.Errorf("git write-tree: empty tree sha")
+	}
+	return tree, nil
+}
+
+// claimedPaths reads the .reconcile-claimed manifest into a set of the exact
+// paths the wright reported changing.
+func claimedPaths(path string) map[string]struct{} {
+	set := map[string]struct{}{}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return set
+	}
+	for _, line := range splitLinesNoTrailing(data) {
+		set[line] = struct{}{}
+	}
+	return set
+}

package/engine/internal/lib/reconcile_test.go

@@ -0,0 +1,197 @@
+package lib
+
+import (
+	"bytes"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// newGitRepo builds a throwaway git repo with one commit, chdirs into it (Reconcile
+// resolves gitRoot from the cwd), and returns its path.
+func newGitRepo(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	// macOS /var -> /private/var symlink: git reports the resolved path, so resolve
+	// up front or the gitRoot comparison below drifts.
+	if resolved, err := filepath.EvalSymlinks(dir); err == nil {
+		dir = resolved
+	}
+	for _, args := range [][]string{
+		{"init", "-q"},
+		{"config", "user.email", "test@example.com"},
+		{"config", "user.name", "Test"},
+		{"config", "commit.gpgsign", "false"},
+	} {
+		cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
+		if out, err := cmd.CombinedOutput(); err != nil {
+			t.Fatalf("git %v: %v\n%s", args, err, out)
+		}
+	}
+	writeFile(t, filepath.Join(dir, "seed.go"), "package main\n")
+	commitAll(t, dir, "seed")
+	t.Chdir(dir)
+	return dir
+}
+
+func writeFile(t *testing.T, path, body string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatalf("mkdir %s: %v", path, err)
+	}
+	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+		t.Fatalf("write %s: %v", path, err)
+	}
+}
+
+func commitAll(t *testing.T, dir, msg string) {
+	t.Helper()
+	for _, args := range [][]string{{"add", "-A"}, {"commit", "-q", "-m", msg}} {
+		cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
+		if out, err := cmd.CombinedOutput(); err != nil {
+			t.Fatalf("git %v: %v\n%s", args, err, out)
+		}
+	}
+}
+
+// workspace creates <root>/work/<slug> and returns root.
+func workspace(t *testing.T, slug string) string {
+	t.Helper()
+	root := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(root, "work", slug), 0o755); err != nil {
+		t.Fatalf("mkdir workspace: %v", err)
+	}
+	return root
+}
+
+func runReconcile(t *testing.T, root string, args ...string) (int, string) {
+	t.Helper()
+	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+	code := Reconcile(root, args, stdout, stderr)
+	return code, stdout.String() + stderr.String()
+}
+
+func TestWorktreeTreeErrorsOutsideGitRepo(t *testing.T) {
+	dir := t.TempDir()
+	tree, err := worktreeTree(dir)
+	if err == nil {
+		t.Fatalf("worktreeTree(%q) = %q, nil; want an error outside a git repo", dir, tree)
+	}
+	if tree != "" {
+		t.Errorf("worktreeTree returned tree %q alongside an error; want empty", tree)
+	}
+}
+
+func TestWorktreeTreeCapturesUntrackedFiles(t *testing.T) {
+	dir := newGitRepo(t)
+
+	before, err := worktreeTree(dir)
+	if err != nil {
+		t.Fatalf("worktreeTree: %v", err)
+	}
+	writeFile(t, filepath.Join(dir, "untracked.go"), "package main\n")
+	after, err := worktreeTree(dir)
+	if err != nil {
+		t.Fatalf("worktreeTree: %v", err)
+	}
+	if before == after {
+		t.Errorf("worktreeTree did not observe the untracked file: both trees = %s", before)
+	}
+
+	// The user's real index must be untouched — the file stays untracked.
+	out, err := exec.Command("git", "-C", dir, "status", "--porcelain", "untracked.go").Output()
+	if err != nil {
+		t.Fatalf("git status: %v", err)
+	}
+	if !strings.HasPrefix(string(out), "??") {
+		t.Errorf("worktreeTree staged into the real index; git status = %q", out)
+	}
+}
+
+func TestReconcileSnapshotThenCleanCheck(t *testing.T) {
+	gitRoot := newGitRepo(t)
+	root := workspace(t, "feat")
+
+	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
+		t.Fatalf("snapshot = %d, want 0\n%s", code, out)
+	}
+	// The wright changes a file and claims it.
+	writeFile(t, filepath.Join(gitRoot, "seed.go"), "package main\n\nfunc main() {}\n")
+	writeFile(t, filepath.Join(root, "work", "feat", ".reconcile-claimed"), "seed.go\n")
+
+	code, out := runReconcile(t, root, "check", "feat")
+	if code != 0 {
+		t.Fatalf("check = %d, want 0 (claimed change)\n%s", code, out)
+	}
+	if !strings.Contains(out, "reconcile: OK") {
+		t.Errorf("check output missing OK line:\n%s", out)
+	}
+}
+
+func TestReconcileCheckFlagsUnclaimedChange(t *testing.T) {
+	gitRoot := newGitRepo(t)
+	root := workspace(t, "feat")
+
+	if code, out := runReconcile(t, root, "snapshot", "feat"); code != 0 {
+		t.Fatalf("snapshot = %d, want 0\n%s", code, out)
+	}
+	// The orchestrator edits source it never claimed — the A1 breach.
+	writeFile(t, filepath.Join(gitRoot, "rogue.go"), "package main\n")
+	writeFile(t, filepath.Join(root, "work", "feat", ".reconcile-claimed"), "seed.go\n")
+
+	code, out := runReconcile(t, root, "check", "feat")
+	if code != 5 {
+		t.Fatalf("check = %d, want 5 (A1 breach)\n%s", code, out)
+	}
+	if !strings.Contains(out, "rogue.go") {
+		t.Errorf("violation list missing rogue.go:\n%s", out)
+	}
+}
+
+// A snapshot that failed to capture the worktree must fail the check closed. Before
+// the fix, worktreeTree swallowed a "git add -A" failure and returned the empty-tree
+// sha; base and now agreed, the diff came back empty, and the gate printed OK on the
+// exact breach it exists to catch.
+func TestReconcileCheckFailsClosedOnEmptySnapshot(t *testing.T) {
+	gitRoot := newGitRepo(t)
+	root := workspace(t, "feat")
+
+	writeFile(t, filepath.Join(root, "work", "feat", ".reconcile-base"), "\n")
+	writeFile(t, filepath.Join(root, "work", "feat", ".reconcile-claimed"), "seed.go\n")
+	writeFile(t, filepath.Join(gitRoot, "rogue.go"), "package main\n")
+
+	code, out := runReconcile(t, root, "check", "feat")
+	if code == 0 {
+		t.Fatalf("check = 0 on an empty snapshot; the gate passed an unclaimed change\n%s", out)
+	}
+	if code != 6 {
+		t.Fatalf("check = %d, want 6 (setup error)\n%s", code, out)
+	}
+}
+
+func TestReconcileCheckRequiresSnapshot(t *testing.T) {
+	newGitRepo(t)
+	root := workspace(t, "feat")
+	writeFile(t, filepath.Join(root, "work", "feat", ".reconcile-claimed"), "seed.go\n")
+
+	code, out := runReconcile(t, root, "check", "feat")
+	if code != 6 {
+		t.Fatalf("check without snapshot = %d, want 6\n%s", code, out)
+	}
+}
+
+func TestReconcileInlineFallbackSkipsGate(t *testing.T) {
+	newGitRepo(t)
+	root := workspace(t, "feat")
+	writeFile(t, filepath.Join(root, "work", "feat", ".reconcile-inline"), "")
+
+	code, out := runReconcile(t, root, "check", "feat")
+	if code != 0 {
+		t.Fatalf("inline fallback check = %d, want 0\n%s", code, out)
+	}
+	if !strings.Contains(out, "gate skipped") {
+		t.Errorf("expected inline-fallback skip message:\n%s", out)
+	}
+}