devrites 3.2.28 → 4.0.0

package/engine/internal/lib/preamble.go

@@ -1,159 +0,0 @@
-package lib
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/devrites/devrites/internal/devritespaths"
-	"github.com/devrites/devrites/internal/workflow"
-)
-
-// spaceChars is the POSIX [[:space:]] set under the C locale: the collation the
-// parity oracle pins (LC_ALL=C), so trimming matches the bash awk/sed exactly.
-const spaceChars = " \t\n\v\f\r"
-
-// featureDir is the per-feature directory under root. work/ is canonical;
-// features/ remains readable as a compatibility alias.
-func featureDir(root, slug string) string {
-	return devritespaths.FeatureDir(root, slug)
-}
-
-// activeSlug reads the active-feature pointer at <root>/ACTIVE (trimmed), or ""
-// when absent: the new-schema replacement for the old .devrites/ACTIVE lookup.
-func activeSlug(root string) string {
-	slug, err := devritespaths.ActiveSlug(root)
-	if err != nil {
-		return ""
-	}
-	return slug
-}
-
-// preambleArtifacts is the fixed order preamble.sh scans for present artifacts.
-// It is NOT sorted: the display order is the workflow order, so the port keeps
-// the literal list.
-var preambleArtifacts = []string{
-	"brief", "spec", "references", "strategy", "plan", "tasks", "eng-review",
-	"test-plan", "questions", "decisions", "assumptions", "drift",
-	"touched-files", "evidence", "browser-evidence", "design-brief",
-	"polish-report", "review", "seal", "ship", "handoff",
-}
-
-// Preamble prints the active feature's workspace state: the orientation every
-// workspace-operating rite-* skill runs first (step 0). Read-only. root is the
-// .devrites directory; slug defaults to the active feature at <root>/ACTIVE.
-// Always exits 0: orientation is never a hard dependency.
-func Preamble(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)
-	if slug == "" || !isDir(workDir) {
-		fmt.Fprintf(stdout, "No active workspace. Run %s <feature> to start.\n", workflow.ForVerb("spec").Both())
-		return 0
-	}
-
-	fmt.Fprintf(stdout, "## %s\n", slug)
-
-	if state, err := os.ReadFile(filepath.Join(workDir, "state.md")); err == nil {
-		fmt.Fprintln(stdout, "### state.md")
-		// Emit the file verbatim, like `cat`: no added trailing newline.
-		_, _ = stdout.Write(state)
-	}
-
-	fmt.Fprintln(stdout)
-	fmt.Fprintln(stdout, "### artifacts present")
-	for _, f := range preambleArtifacts {
-		if isFile(filepath.Join(workDir, f+".md")) {
-			fmt.Fprintf(stdout, "  ✓ %s.md\n", f)
-		}
-	}
-
-	fmt.Fprintln(stdout)
-	fmt.Fprintln(stdout, "### run mode")
-	if afk, err := os.ReadFile(filepath.Join(root, "AFK")); err == nil {
-		fmt.Fprintln(stdout, "  AFK (sentinel present)")
-		// Surface optional config without parsing YAML: print every non-comment,
-		// non-blank line verbatim, indented 4 spaces (grep -vE '^\s*(#|$)' | sed).
-		for _, line := range splitLinesNoTrailing(afk) {
-			trimmed := strings.TrimLeft(line, spaceChars)
-			if trimmed == "" || strings.HasPrefix(trimmed, "#") {
-				continue
-			}
-			fmt.Fprintf(stdout, "    %s\n", line)
-		}
-	} else {
-		fmt.Fprintln(stdout, "  HITL (no sentinel)")
-	}
-
-	fmt.Fprintln(stdout)
-	fmt.Fprintln(stdout, "### questions")
-	if q, err := os.ReadFile(filepath.Join(workDir, "questions.md")); err == nil {
-		b, v, a, e := tallyOpenQuestions(q)
-		fmt.Fprintf(stdout, "  open: %d blocking, %d validating, %d advisory, %d escalating\n", b, v, a, e)
-	} else {
-		fmt.Fprintln(stdout, "  (no questions.md yet)")
-	}
-	return 0
-}
-
-// tallyOpenQuestions counts open questions by gate, mirroring preamble.sh's awk.
-// A question block opens at a "## q-" header and closes at the next "## " header
-// (question or not) or EOF; a block counts iff its status is exactly "open".
-func tallyOpenQuestions(data []byte) (blocking, validating, advisory, escalating int) {
-	counts := map[string]int{}
-	inQ := false
-	status, gate := "", ""
-	finalize := func() {
-		if inQ && status == "open" {
-			counts[gate]++
-		}
-	}
-	for _, line := range splitLinesNoTrailing(data) {
-		switch {
-		case strings.HasPrefix(strings.ToLower(line), "## q-"):
-			finalize()
-			inQ, status, gate = true, "", ""
-		case inQ && strings.HasPrefix(line, "status:"):
-			status = strings.TrimLeft(strings.TrimPrefix(line, "status:"), spaceChars)
-		case inQ && strings.HasPrefix(line, "gate:"):
-			gate = strings.TrimLeft(strings.TrimPrefix(line, "gate:"), spaceChars)
-		case inQ && isHeadingLine(line):
-			// A non-question "## " header ends the block.
-			if status == "open" {
-				counts[gate]++
-			}
-			inQ = false
-		}
-	}
-	finalize()
-	return counts["blocking"], counts["validating"], counts["advisory"], counts["escalating"]
-}
-
-// isHeadingLine reports whether a line is a "## " heading (## followed by a space
-// or tab), matching the awk /^##[[:space:]]/ that ends a question block.
-func isHeadingLine(line string) bool {
-	if !strings.HasPrefix(line, "##") {
-		return false
-	}
-	rest := line[2:]
-	return rest != "" && strings.ContainsRune(spaceChars, rune(rest[0]))
-}
-
-// splitLinesNoTrailing splits data into lines on '\n', dropping a single trailing
-// newline's empty final element so a "\n"-terminated file yields N lines, not N+1
-// : matching how awk/grep iterate records.
-func splitLinesNoTrailing(data []byte) []string {
-	s := string(data)
-	s = strings.TrimSuffix(s, "\n")
-	if s == "" {
-		return nil
-	}
-	return strings.Split(s, "\n")
-}

package/engine/internal/lib/preamble_questions_test.go

@@ -1,10 +0,0 @@
-package lib
-
-import "testing"
-
-func TestTallyOpenQuestionsAcceptsCanonicalUppercaseIDs(t *testing.T) {
-	b, v, a, e := tallyOpenQuestions([]byte("## Q-001\nstatus: open\ngate: blocking\n\n## q-2026-07-20-001\nstatus: open\ngate: escalating\n"))
-	if b != 1 || v != 0 || a != 0 || e != 1 {
-		t.Fatalf("counts=(%d,%d,%d,%d), want (1,0,0,1)", b, v, a, e)
-	}
-}

package/engine/internal/lib/progress.go

@@ -1,210 +0,0 @@
-package lib
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/devrites/devrites/internal/state"
-)
-
-// These state parsing patterns match progress.sh's awk expressions. Each
-// name-removal pattern is anchored, so ReplaceAllString behaves like awk's
-// single-match sub.
-var (
-	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]\]`)
-	sliceHeadingRe = regexp.MustCompile(`^##[[:space:]]+(SLICE-[0-9]{3})(?:[[:space:]]+(.*))?$`)
-)
-
-// Progress renders the footer printed by workspace-aware rite-* skills. It reads
-// from the .devrites root and returns 0 without output when no workspace is
-// active. An empty slug uses <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)
-	if total == 0 {
-		total, built, lastbuilt = tallyCanonicalSlices(workDir)
-	}
-
-	// 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)
-		}
-	}
-
-	// The flow ribbon includes optional phases when their artifact exists or while
-	// they are active. It always includes the current phase.
-	order := make([]string, 0, len(state.LifecyclePhases()))
-	for _, lifecyclePhase := range state.LifecyclePhases() {
-		name := string(lifecyclePhase)
-		include := true
-		switch lifecyclePhase {
-		case state.PhaseFrame:
-			include = phase == name
-		case state.PhaseTemper:
-			include = phase == name || isFile(filepath.Join(workDir, "strategy.md"))
-		case state.PhaseDone:
-			include = false
-		case state.PhaseVet:
-			include = phase == name || isFile(filepath.Join(workDir, "eng-review.md"))
-		case state.PhaseConverge:
-			include = phase == name
-		}
-		if include {
-			order = append(order, name)
-		}
-	}
-
-	cur := phase
-	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)
-	if obs := ObservabilityStatus(root, slug); obs != "" {
-		fmt.Fprintf(stdout, "Obs   %s\n", obs)
-	}
-	return 0
-}
-
-func tallyCanonicalSlices(workDir string) (total, built int, lastbuilt string) {
-	raw, err := os.ReadFile(filepath.Join(workDir, "tasks.md"))
-	if err != nil {
-		return 0, 0, ""
-	}
-	name, sliceState := "", ""
-	finalize := func() {
-		if name == "" {
-			return
-		}
-		total++
-		if sliceState == "built" {
-			built++
-			lastbuilt = name
-		}
-	}
-	for _, line := range strings.Split(string(raw), "\n") {
-		if match := sliceHeadingRe.FindStringSubmatch(strings.TrimSpace(line)); match != nil {
-			finalize()
-			name = match[1]
-			if strings.TrimSpace(match[2]) != "" {
-				name += " " + strings.TrimSpace(match[2])
-			}
-			sliceState = "pending"
-			continue
-		}
-		if name != "" && strings.HasPrefix(strings.ToLower(strings.TrimSpace(line)), "status:") {
-			_, value, _ := strings.Cut(strings.TrimSpace(line), ":")
-			sliceState = strings.ToLower(strings.TrimSpace(value))
-		}
-	}
-	finalize()
-	return total, built, lastbuilt
-}
-
-// parsePhase returns the first token of the canonical or legacy phase field.
-func parsePhase(lines []string) string {
-	value, ok := state.CursorField(lines, state.CursorPhase)
-	if !ok {
-		return ""
-	}
-	toks := strings.Fields(value)
-	if len(toks) == 0 {
-		return ""
-	}
-	return toks[0]
-}
-
-// 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
-}