devrites 3.2.28 → 4.0.0

package/engine/internal/profile/profile.go

@@ -1,284 +0,0 @@
-package profile
-
-import (
-	"context"
-	"crypto/sha256"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"slices"
-	"sort"
-	"strings"
-	"time"
-)
-
-const schemaVersion = "1"
-
-type FileInfo struct {
-	SHA256 string `json:"sha256"`
-	Bytes  int    `json:"bytes"`
-}
-
-type Profile struct {
-	ProfileSchemaVersion string              `json:"profile_schema_version"`
-	RootSHA              string              `json:"root_sha"`
-	HeadSHA              string              `json:"head_sha"`
-	TopLevel             []string            `json:"top_level"`
-	Manifests            []string            `json:"manifests"`
-	Inputs               map[string]FileInfo `json:"inputs"`
-}
-
-type cacheEnvelope struct {
-	ProfileSchemaVersion string  `json:"profile_schema_version"`
-	RootSHA              string  `json:"root_sha"`
-	HeadSHA              string  `json:"head_sha"`
-	Profile              Profile `json:"profile"`
-}
-
-func Run(args []string, stdout, stderr io.Writer) int {
-	if len(args) != 1 || (args[0] != "get" && args[0] != "refresh") {
-		fmt.Fprintln(stderr, "usage: devrites-engine profile get|refresh")
-		return 2
-	}
-	root, ok := gitRoot()
-	if !ok {
-		fmt.Fprintln(stdout, "NO-CACHE")
-		return 0
-	}
-	rootSHA, headSHA, ok := keys(root)
-	if !ok {
-		fmt.Fprintln(stdout, "NO-CACHE")
-		return 0
-	}
-	path := cachePath(rootSHA, headSHA)
-	switch args[0] {
-	case "get":
-		if cleanProfileInputs(root) {
-			if p, ok := readCache(path, rootSHA, headSHA); ok {
-				fmt.Fprintln(stdout, "HIT")
-				writeJSON(stdout, p)
-				return 0
-			}
-		}
-		fmt.Fprintln(stdout, "MISS")
-		fmt.Fprintln(stdout, path)
-		return 0
-	case "refresh":
-		p, err := derive(root, rootSHA, headSHA)
-		if err != nil {
-			fmt.Fprintf(stderr, "devrites: profile cache refresh failed: %v\n", err)
-			return 1
-		}
-		if err := writeCache(path, p); err != nil {
-			fmt.Fprintf(stderr, "devrites: profile cache write failed: %v\n", err)
-			return 1
-		}
-		fmt.Fprintf(stdout, "WROTE\n%s\n", path)
-		writeJSON(stdout, p)
-		return 0
-	}
-	return 2
-}
-
-func gitRoot() (string, bool) {
-	out, ok := git("", "rev-parse", "--show-toplevel")
-	if !ok || strings.TrimSpace(out) == "" {
-		return "", false
-	}
-	return strings.TrimSpace(out), true
-}
-
-func keys(root string) (string, string, bool) {
-	roots, ok := git(root, "rev-list", "--max-parents=0", "HEAD")
-	if !ok || strings.TrimSpace(roots) == "" {
-		return "", "", false
-	}
-	parts := strings.Fields(roots)
-	sort.Strings(parts)
-	head, ok := git(root, "rev-parse", "HEAD")
-	if !ok || strings.TrimSpace(head) == "" {
-		return "", "", false
-	}
-	return parts[0], strings.TrimSpace(head), true
-}
-
-func cachePath(rootSHA, headSHA string) string {
-	base := os.Getenv("DEVRITES_PROFILE_CACHE")
-	if base == "" {
-		base = "/tmp/compound-engineering/devrites/repo-profile"
-	}
-	return filepath.Join(base, rootSHA, headSHA+".json")
-}
-
-func readCache(path, rootSHA, headSHA string) (Profile, bool) {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return Profile{}, false
-	}
-	var env cacheEnvelope
-	if err := json.Unmarshal(raw, &env); err != nil {
-		return Profile{}, false
-	}
-	if env.ProfileSchemaVersion != schemaVersion || env.RootSHA != rootSHA || env.HeadSHA != headSHA || env.Profile.ProfileSchemaVersion != schemaVersion {
-		return Profile{}, false
-	}
-	return env.Profile, true
-}
-
-func writeCache(path string, p Profile) error {
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		return fmt.Errorf("write profile cache %s: %w", path, err)
-	}
-	env := cacheEnvelope{ProfileSchemaVersion: schemaVersion, RootSHA: p.RootSHA, HeadSHA: p.HeadSHA, Profile: p}
-	raw, err := json.MarshalIndent(env, "", "  ")
-	if err != nil {
-		return fmt.Errorf("marshal profile cache: %w", err)
-	}
-	tmp, err := os.CreateTemp(filepath.Dir(path), ".profile-*.tmp")
-	if err != nil {
-		return fmt.Errorf("write profile cache %s: %w", path, err)
-	}
-	name := tmp.Name()
-	if _, err := tmp.Write(append(raw, '\n')); err != nil {
-		_ = tmp.Close()
-		_ = os.Remove(name)
-		return fmt.Errorf("write profile cache %s: %w", path, err)
-	}
-	if err := tmp.Close(); err != nil {
-		_ = os.Remove(name)
-		return fmt.Errorf("write profile cache %s: %w", path, err)
-	}
-	return os.Rename(name, path)
-}
-
-func derive(root, rootSHA, headSHA string) (Profile, error) {
-	p := Profile{ProfileSchemaVersion: schemaVersion, RootSHA: rootSHA, HeadSHA: headSHA, Inputs: map[string]FileInfo{}}
-	entries, err := os.ReadDir(root)
-	if err != nil {
-		return Profile{}, fmt.Errorf("read repository root: %w", err)
-	}
-	for _, e := range entries {
-		name := e.Name()
-		if strings.HasPrefix(name, ".git") || name == "node_modules" {
-			continue
-		}
-		if e.IsDir() {
-			name += "/"
-		}
-		p.TopLevel = append(p.TopLevel, name)
-	}
-	sort.Strings(p.TopLevel)
-	if err := filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		rel, err := filepath.Rel(root, path)
-		if err != nil {
-			return err
-		}
-		if rel == "." {
-			return nil
-		}
-		rel = filepath.ToSlash(rel)
-		if d.IsDir() {
-			base := d.Name()
-			if base == ".git" || base == "node_modules" || base == "pack" || base == ".scratch" || base == ".research" {
-				return filepath.SkipDir
-			}
-			return nil
-		}
-		if isManifest(rel) {
-			p.Manifests = append(p.Manifests, rel)
-		}
-		if isProfileInput(rel) {
-			info, err := fileInfo(path)
-			if err != nil {
-				return err
-			}
-			p.Inputs[rel] = info
-		}
-		return nil
-	}); err != nil {
-		return Profile{}, fmt.Errorf("walk repository: %w", err)
-	}
-	sort.Strings(p.Manifests)
-	return p, nil
-}
-
-func fileInfo(path string) (FileInfo, error) {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return FileInfo{}, fmt.Errorf("read profile input %s: %w", path, err)
-	}
-	sum := sha256.Sum256(raw)
-	return FileInfo{SHA256: hex.EncodeToString(sum[:]), Bytes: len(raw)}, nil
-}
-
-func cleanProfileInputs(root string) bool {
-	out, ok := git(root, "status", "--porcelain", "--untracked-files=all")
-	if !ok {
-		return false
-	}
-	for _, line := range strings.Split(out, "\n") {
-		if strings.TrimSpace(line) == "" {
-			continue
-		}
-		rest := ""
-		if len(line) >= 3 {
-			rest = line[3:]
-		}
-		for _, part := range strings.Split(rest, " -> ") {
-			if isProfileInput(strings.Trim(part, " \t\"")) {
-				return false
-			}
-		}
-	}
-	return true
-}
-
-func isProfileInput(rel string) bool {
-	base := filepath.Base(rel)
-	if isManifest(rel) || matchAny(base, "LICENSE", "LICENSE.md", "LICENSE.txt", "CONTEXT.md", "README.md", "AGENTS.md", "CLAUDE.md", "GEMINI.md", "package.json") {
-		return true
-	}
-	if !strings.Contains(rel, "/") && matchAny(base, "CONTRIBUTING.md", "SECURITY.md", "Makefile") {
-		return true
-	}
-	if strings.HasPrefix(rel, "docs/adr/") || strings.HasPrefix(rel, ".github/workflows/") || strings.HasPrefix(rel, ".devrites/principles.md") || strings.HasPrefix(rel, ".devrites/conventions.md") {
-		return true
-	}
-	return false
-}
-
-func isManifest(rel string) bool {
-	base := filepath.Base(rel)
-	return matchAny(base,
-		"package.json", "package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "go.mod", "go.sum", "Cargo.toml", "Cargo.lock", "pyproject.toml", "requirements.txt", "Gemfile", "Gemfile.lock", "composer.json", "composer.lock", "pom.xml", "build.gradle", "build.gradle.kts", "deno.json", "deno.lock")
-}
-
-func matchAny(s string, vals ...string) bool {
-	return slices.Contains(vals, s)
-}
-
-func git(dir string, args ...string) (string, bool) {
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-	cmd := exec.CommandContext(ctx, "git", args...)
-	if dir != "" {
-		cmd.Dir = dir
-	}
-	out, err := cmd.Output()
-	if err != nil {
-		return "", false
-	}
-	return string(out), true
-}
-
-func writeJSON(w io.Writer, v any) {
-	raw, _ := json.MarshalIndent(v, "", "  ")
-	fmt.Fprintln(w, string(raw))
-}

package/engine/internal/profile/profile_test.go

@@ -1,13 +0,0 @@
-package profile
-
-import (
-	"path/filepath"
-	"testing"
-)
-
-func TestDeriveReportsUnreadableRoot(t *testing.T) {
-	_, err := derive(filepath.Join(t.TempDir(), "missing"), "root", "head")
-	if err == nil {
-		t.Fatal("derive succeeded for a missing repository root")
-	}
-}

package/engine/internal/state/clarify_transition.go

@@ -1,165 +0,0 @@
-package state
-
-import (
-	"fmt"
-	"strings"
-)
-
-// ClarifyIntent is the only transition family piloted through a pure next-state
-// function. Other lifecycle mutations intentionally remain unchanged.
-type ClarifyIntent string
-
-const (
-	ClarifyEnter   ClarifyIntent = "enter"
-	ClarifyRestore ClarifyIntent = "restore"
-)
-
-// ClarifyCursor is the complete cursor surface owned by clarify-return.
-type ClarifyCursor struct {
-	Phase            Phase
-	Status           string
-	NextAction       string
-	ReturnPhase      Phase
-	ReturnNextAction string
-	HasReturn        bool
-}
-
-// ClarifyTransitionInput carries the current typed cursor plus host-rendered
-// defaults. NextClarifyCursor is pure: it does no file or environment I/O.
-type ClarifyTransitionInput struct {
-	Cursor                  ClarifyCursor
-	ClarifyNextAction       string
-	DefaultReturnNextAction string
-}
-
-// ClarifyFieldPolicy is emitted in the workflow manifest for documentation.
-type ClarifyFieldPolicy struct {
-	Field  string `json:"field"`
-	Policy string `json:"policy"`
-}
-
-// ClarifyFieldPolicies declares which fields the pilot derives and preserves.
-func ClarifyFieldPolicies() []ClarifyFieldPolicy {
-	return []ClarifyFieldPolicy{
-		{Field: CursorPhase, Policy: "derived"},
-		{Field: CursorStatus, Policy: "derived"},
-		{Field: CursorNextAction, Policy: "derived"},
-		{Field: CursorReturnPhase, Policy: "derived"},
-		{Field: CursorReturnNextAction, Policy: "curated when present; otherwise derived"},
-		{Field: "all other state.md content", Policy: "curated and preserved byte-for-byte"},
-	}
-}
-
-// ClarifyTransitionError reports an illegal typed transition.
-type ClarifyTransitionError struct {
-	Intent ClarifyIntent
-	Reason string
-}
-
-func (e *ClarifyTransitionError) Error() string {
-	return fmt.Sprintf("clarify %s: %s", e.Intent, e.Reason)
-}
-
-// NextClarifyCursor returns the full next clarify-owned cursor surface.
-func NextClarifyCursor(intent ClarifyIntent, input ClarifyTransitionInput) (ClarifyCursor, error) {
-	current := input.Cursor
-	switch intent {
-	case ClarifyEnter:
-		if current.Phase == PhaseClarify {
-			return current, nil
-		}
-		if !PhaseAfterClarify(current.Phase) {
-			return ClarifyCursor{}, &ClarifyTransitionError{Intent: intent, Reason: fmt.Sprintf("phase %q is not a later-phase retrofit", current.Phase)}
-		}
-		returnNext := strings.TrimSpace(current.NextAction)
-		if returnNext == "" {
-			returnNext = input.DefaultReturnNextAction
-		}
-		return ClarifyCursor{
-			Phase:            PhaseClarify,
-			Status:           "running",
-			NextAction:       input.ClarifyNextAction,
-			ReturnPhase:      current.Phase,
-			ReturnNextAction: returnNext,
-			HasReturn:        true,
-		}, nil
-	case ClarifyRestore:
-		if !current.HasReturn {
-			return current, nil
-		}
-		if !PhaseAfterClarify(current.ReturnPhase) {
-			return ClarifyCursor{}, &ClarifyTransitionError{Intent: intent, Reason: fmt.Sprintf("invalid return phase %q", current.ReturnPhase)}
-		}
-		next := strings.TrimSpace(current.ReturnNextAction)
-		if next == "" {
-			next = input.DefaultReturnNextAction
-		}
-		return ClarifyCursor{
-			Phase:      current.ReturnPhase,
-			Status:     "running",
-			NextAction: next,
-		}, nil
-	default:
-		return ClarifyCursor{}, &ClarifyTransitionError{Intent: intent, Reason: "unknown intent"}
-	}
-}
-
-// ParseClarifyCursor reads the clarify-owned fields from either cursor format.
-func ParseClarifyCursor(lines []string) (ClarifyCursor, error) {
-	rawPhase, ok := CursorField(lines, CursorPhase)
-	if !ok || strings.TrimSpace(rawPhase) == "" {
-		return ClarifyCursor{}, fmt.Errorf("state.md has no phase")
-	}
-	phase, ok := firstKnownPhase(rawPhase)
-	if !ok {
-		return ClarifyCursor{}, fmt.Errorf("unknown phase %q", rawPhase)
-	}
-	current := ClarifyCursor{Phase: phase}
-	current.Status, _ = CursorField(lines, CursorStatus)
-	current.NextAction, _ = CursorField(lines, CursorNextAction)
-	rawReturn, hasReturn := CursorField(lines, CursorReturnPhase)
-	if hasReturn && strings.TrimSpace(rawReturn) != "" {
-		returnPhase, ok := firstKnownPhase(rawReturn)
-		if !ok {
-			return ClarifyCursor{}, fmt.Errorf("invalid return phase %q", rawReturn)
-		}
-		current.ReturnPhase = returnPhase
-		current.HasReturn = true
-	}
-	current.ReturnNextAction, _ = CursorField(lines, CursorReturnNextAction)
-	return current, nil
-}
-
-func firstKnownPhase(raw string) (Phase, bool) {
-	fields := strings.Fields(strings.ToLower(strings.TrimSpace(raw)))
-	if len(fields) == 0 {
-		return "", false
-	}
-	return PhaseForName(fields[0])
-}
-
-// ApplyClarifyCursor serializes only clarify-owned fields and preserves all
-// unrelated Markdown through the existing presentation-preserving mutators.
-func ApplyClarifyCursor(lines []string, cursor ClarifyCursor) []string {
-	lines = UpsertCursorField(lines, CursorPhase, string(cursor.Phase))
-	lines = UpsertCursorField(lines, CursorStatus, cursor.Status)
-	lines = UpsertCursorField(lines, CursorNextAction, cursor.NextAction)
-	if cursor.HasReturn {
-		lines = UpsertCursorField(lines, CursorReturnPhase, string(cursor.ReturnPhase))
-		lines = UpsertCursorField(lines, CursorReturnNextAction, cursor.ReturnNextAction)
-		return lines
-	}
-	lines = DeleteCursorField(lines, CursorReturnPhase)
-	return DeleteCursorField(lines, CursorReturnNextAction)
-}
-
-// PhaseAfterClarify reports whether clarify-return may retrofit this phase.
-func PhaseAfterClarify(phase Phase) bool {
-	switch phase {
-	case PhaseTemper, PhaseDefine, PhasePlan, PhaseVet, PhaseBuild, PhaseConverge,
-		PhaseProve, PhasePolish, PhaseReview, PhaseSeal, PhaseShip:
-		return true
-	default:
-		return false
-	}
-}

package/engine/internal/state/clarify_transition_test.go

@@ -1,130 +0,0 @@
-package state
-
-import (
-	"errors"
-	"strings"
-	"testing"
-)
-
-func TestNextClarifyCursorCases(t *testing.T) {
-	build := ClarifyCursor{Phase: PhaseBuild, Status: "running", NextAction: "/rite-build"}
-	clarify := ClarifyCursor{
-		Phase:            PhaseClarify,
-		Status:           "running",
-		NextAction:       "/rite-clarify",
-		ReturnPhase:      PhaseBuild,
-		ReturnNextAction: "/rite-build",
-		HasReturn:        true,
-	}
-	cases := []struct {
-		name    string
-		intent  ClarifyIntent
-		current ClarifyCursor
-		want    ClarifyCursor
-		wantErr bool
-	}{
-		{"enter", ClarifyEnter, build, clarify, false},
-		{"duplicate enter", ClarifyEnter, clarify, clarify, false},
-		{"too early enter", ClarifyEnter, ClarifyCursor{Phase: PhaseSpec}, ClarifyCursor{}, true},
-		{"missing restore target", ClarifyRestore, ClarifyCursor{Phase: PhaseClarify}, ClarifyCursor{Phase: PhaseClarify}, false},
-		{"invalid restore target", ClarifyRestore, ClarifyCursor{Phase: PhaseClarify, ReturnPhase: PhaseSpec, HasReturn: true}, ClarifyCursor{}, true},
-		{"restore", ClarifyRestore, clarify, build, false},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			got, err := NextClarifyCursor(tc.intent, ClarifyTransitionInput{
-				Cursor:                  tc.current,
-				ClarifyNextAction:       "/rite-clarify",
-				DefaultReturnNextAction: "/rite-build",
-			})
-			if tc.wantErr {
-				var transitionErr *ClarifyTransitionError
-				if !errors.As(err, &transitionErr) {
-					t.Fatalf("error=%v, want ClarifyTransitionError", err)
-				}
-				return
-			}
-			if err != nil || got != tc.want {
-				t.Fatalf("NextClarifyCursor()=(%+v, %v), want %+v", got, err, tc.want)
-			}
-		})
-	}
-}
-
-func TestClarifyCursorSerializationIsByteIdempotent(t *testing.T) {
-	original := []string{
-		"# State",
-		"",
-		"## Cursor",
-		"| Key | Value |",
-		"| --- | --- |",
-		"| phase | build |",
-		"| status | running |",
-		"| next_action | /rite-build |",
-		"",
-		"Curated note stays exactly here.",
-	}
-	current, err := ParseClarifyCursor(original)
-	if err != nil {
-		t.Fatal(err)
-	}
-	entered, err := NextClarifyCursor(ClarifyEnter, ClarifyTransitionInput{
-		Cursor:                  current,
-		ClarifyNextAction:       "/rite-clarify",
-		DefaultReturnNextAction: "/rite-build",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	once := ApplyClarifyCursor(original, entered)
-	parsed, err := ParseClarifyCursor(once)
-	if err != nil {
-		t.Fatal(err)
-	}
-	twiceState, err := NextClarifyCursor(ClarifyEnter, ClarifyTransitionInput{
-		Cursor:                  parsed,
-		ClarifyNextAction:       "/rite-clarify",
-		DefaultReturnNextAction: "/rite-build",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	twice := ApplyClarifyCursor(once, twiceState)
-	if got, want := strings.Join(twice, "\n"), strings.Join(once, "\n"); got != want {
-		t.Fatalf("second serialization changed bytes:\n--- once\n%s\n--- twice\n%s", want, got)
-	}
-	if !strings.Contains(strings.Join(once, "\n"), "Curated note stays exactly here.") {
-		t.Fatal("serializer removed curated Markdown")
-	}
-
-	restored, err := NextClarifyCursor(ClarifyRestore, ClarifyTransitionInput{
-		Cursor:                  parsed,
-		ClarifyNextAction:       "/rite-clarify",
-		DefaultReturnNextAction: "/rite-build",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	restoreOnce := ApplyClarifyCursor(once, restored)
-	restoreParsed, err := ParseClarifyCursor(restoreOnce)
-	if err != nil {
-		t.Fatal(err)
-	}
-	restoreTwice, err := NextClarifyCursor(ClarifyRestore, ClarifyTransitionInput{Cursor: restoreParsed})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got, want := strings.Join(ApplyClarifyCursor(restoreOnce, restoreTwice), "\n"), strings.Join(restoreOnce, "\n"); got != want {
-		t.Fatalf("second restore serialization changed bytes:\n--- once\n%s\n--- twice\n%s", want, got)
-	}
-}
-
-func TestParseClarifyCursorRejectsInvalidReturnPhase(t *testing.T) {
-	_, err := ParseClarifyCursor([]string{
-		"| phase | clarify |",
-		"| return_phase | not-a-phase |",
-	})
-	if err == nil || !strings.Contains(err.Error(), "invalid return phase") {
-		t.Fatalf("error=%v, want invalid return phase", err)
-	}
-}