devrites 3.2.27 → 4.0.0

package/engine/internal/lib/session_test.go

@@ -1,177 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/reason"
-)
-
-func TestTimelineLegacyWritesRejectedAndReadsPreserved(t *testing.T) {
-	t.Setenv("DEVRITES_NOW", "2026-07-09T10:11:12Z")
-	root := t.TempDir()
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	legacy := []byte(`{"ts":"2026-07-09T10:11:12Z","event":"completed","decision":"ship"}` + "\n")
-	path := filepath.Join(root, "timeline.jsonl")
-	if err := os.WriteFile(path, legacy, 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	code := Timeline(root, []string{"log", "completed", "--skill", "rite-review", "--slug", "auth", "--outcome", "ok", "--decision", "PRIVATE_RESULT"}, stdout, stderr)
-	if code != 2 || !strings.Contains(stderr.String(), "legacy free-text writes are disabled") {
-		t.Fatalf("legacy timeline write code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
-	}
-	data, err := os.ReadFile(path)
-	if err != nil || !bytes.Equal(data, legacy) {
-		t.Fatalf("legacy write changed timeline: data=%q err=%v", data, err)
-	}
-
-	stdout.Reset()
-	stderr.Reset()
-	if code := Timeline(root, []string{"list", "--limit", "1"}, stdout, stderr); code != 0 {
-		t.Fatalf("timeline list failed: %d %s", code, stderr.String())
-	}
-	if !strings.Contains(stdout.String(), `"event":"completed"`) {
-		t.Fatalf("timeline list did not print entry: %q", stdout.String())
-	}
-
-	stdout.Reset()
-	stderr.Reset()
-	if code := Timeline(root, []string{"log", "completed", "--skill"}, stdout, stderr); code != 2 {
-		t.Fatalf("missing timeline option value should be usage error, got %d", code)
-	}
-}
-
-func TestTimelineTypedFactsAreValidatedAndVersioned(t *testing.T) {
-	t.Setenv("DEVRITES_NOW", "2026-07-09T10:11:12Z")
-	t.Setenv("DEVRITES_RUN_ID", testRunID)
-	project := t.TempDir()
-	root := filepath.Join(project, ".devrites")
-	workspace := filepath.Join(root, "work", "auth")
-	if err := os.MkdirAll(workspace, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | build |\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	t.Setenv("DEVRITES_ROOT", root)
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := Timeline(root, []string{
-		"log", "review-dispatch", "--slug", "auth",
-		"--execution-mode", "generic",
-		"--guard-strength", "observed",
-		"--reason-id", string(reason.AgentGenericFallback),
-		"--host", "codex",
-		"--evidence", ".devrites/work/auth/plan.md",
-	}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("timeline log code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
-	}
-	raw, err := os.ReadFile(filepath.Join(root, "timeline.jsonl"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	var got EventV1
-	if err := json.Unmarshal(raw, &got); err != nil {
-		t.Fatal(err)
-	}
-	if got.Schema != EventSchemaV1 || got.ExecutionMode != ExecutionGeneric ||
-		got.GuardStrength != GuardObserved || got.ReasonID != reason.AgentGenericFallback ||
-		got.Host != HostCodex || got.Workspace != ".devrites/work/auth" {
-		t.Fatalf("typed event = %+v", got)
-	}
-
-	stderr.Reset()
-	if code := Timeline(root, []string{
-		"log", "bad", "--execution-mode", "named", "--guard-strength", "enforced",
-		"--reason-id", "DRV-UNKNOWN",
-	}, &bytes.Buffer{}, stderr); code != 2 {
-		t.Fatalf("unknown reason code=%d stderr=%q", code, stderr.String())
-	}
-}
-
-func TestTimelineListPreservesAndDistinguishesLegacyAndCorruptRows(t *testing.T) {
-	root := t.TempDir()
-	legacy := `{"ts":"2026-01-01T00:00:00Z","event":"legacy"}`
-	corrupt := `{not-json}`
-	if err := os.WriteFile(filepath.Join(root, "timeline.jsonl"), []byte(legacy+"\n"+corrupt+"\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	if code := Timeline(root, []string{"list"}, stdout, stderr); code != 0 {
-		t.Fatalf("timeline list code=%d stderr=%q", code, stderr.String())
-	}
-	if got := stdout.String(); !strings.Contains(got, legacy) || !strings.Contains(got, corrupt) ||
-		strings.Contains(legacy, `"schema":"`+EventSchemaV1+`"`) {
-		t.Fatalf("legacy/corrupt history changed: %q", got)
-	}
-}
-
-func TestHealthRecordValidatesScore(t *testing.T) {
-	t.Setenv("DEVRITES_NOW", "2026-07-09")
-	root := t.TempDir()
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-
-	code := Health(root, []string{"record", "9.5", "ci green", "--note", "staticcheck+tests"}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("health record failed: code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
-	}
-	data, err := os.ReadFile(filepath.Join(root, "health-history.jsonl"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	got := string(data)
-	for _, want := range []string{`"score":9.5`, `"label":"ci green"`, `"note":"staticcheck+tests"`} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("health entry missing %s: %s", want, got)
-		}
-	}
-
-	stdout.Reset()
-	stderr.Reset()
-	if code := Health(root, []string{"record", "11", "too high"}, stdout, stderr); code != 2 {
-		t.Fatalf("out-of-range score should be usage error, got %d", code)
-	}
-}
-
-func TestReviewFingerprintsStableAndWritable(t *testing.T) {
-	root := t.TempDir()
-	writeReview(t, root, "feat", `# Review
-
-## Spec
-- **Critical**: AC-003 is unproven.
-
-## Code review
-- **Important**: missing error handling.`)
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := ReviewFingerprints(root, []string{"--write", "feat"}, stdout, stderr)
-	if code != 0 {
-		t.Fatalf("review-fingerprints failed: code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
-	}
-	lines := strings.Split(strings.TrimSpace(stdout.String()), "\n")
-	if len(lines) != 2 {
-		t.Fatalf("expected 2 fingerprints, got %d: %q", len(lines), stdout.String())
-	}
-	firstID := strings.Fields(lines[0])[0]
-	if len(firstID) != 12 {
-		t.Fatalf("fingerprint id should be 12 hex chars, got %q", firstID)
-	}
-	stdout.Reset()
-	if code := ReviewFingerprints(root, []string{"feat"}, stdout, stderr); code != 0 {
-		t.Fatalf("second fingerprint run failed: %d", code)
-	}
-	if secondID := strings.Fields(strings.Split(strings.TrimSpace(stdout.String()), "\n")[0])[0]; secondID != firstID {
-		t.Fatalf("fingerprint changed across identical input: %s vs %s", firstID, secondID)
-	}
-	data, err := os.ReadFile(filepath.Join(root, "work", "feat", "review-fingerprints.jsonl"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(data), `"severity":"Critical"`) || !strings.Contains(string(data), `"severity":"Important"`) {
-		t.Fatalf("written JSONL missing severities: %s", string(data))
-	}
-}

package/engine/internal/lib/specparse.go

@@ -1,125 +0,0 @@
-package lib
-
-import (
-	"fmt"
-	"os"
-	"regexp"
-	"strings"
-)
-
-// Structured parse of a spec.md into its Requirement blocks, tagged with the
-// delta kind (added/modified/removed) and capability of the "## … Requirements
-// — capability: <c>" section they sit under. It is the shared reader behind two
-// consumers: the spec-validate `--against` ledger cross-check (specvalidate.go)
-// and the capability-ledger fold (ledger.go). The grammar linter (lintSpec) is
-// deliberately left untouched (delta H2 headers are transparent to it) so this
-// parser adds delta-awareness without perturbing the flat-spec lint contract.
-
-// Delta kinds, lower-cased. A requirement outside any delta section has kind "".
-const (
-	DeltaAdded    = "added"
-	DeltaModified = "modified"
-	DeltaRemoved  = "removed"
-)
-
-var (
-	// "## ADDED Requirements", "## Modified Requirements — capability: theming".
-	deltaSectionRe = regexp.MustCompile(`(?i)^[[:space:]]*##[[:space:]]+(ADDED|MODIFIED|REMOVED)[[:space:]]+Requirements\b`)
-	// The capability tag on a delta section header. Accepts an em dash, en dash,
-	// or hyphen separator; the capability token runs to end-of-line, trimmed.
-	capabilityTagRe = regexp.MustCompile(`(?i)capability:[[:space:]]*(.+?)[[:space:]]*$`)
-	// Any H2/H3 header terminates the preceding requirement block.
-	blockBoundaryRe = regexp.MustCompile(`^[[:space:]]*###?[[:space:]]`)
-)
-
-// Requirement is one "### Requirement: <name>" block with its delta context.
-type Requirement struct {
-	Name       string // header text after "Requirement:", trailing space trimmed
-	Key        string // strings.ToLower(Name): the identity used to match across specs
-	Kind       string // added | modified | removed | "" (flat, no delta section)
-	Capability string // from the section tag; "" when untagged
-	HeaderLine int    // 1-based line of the "### Requirement:" header
-	Raw        string // the full block text (header through the line before the next ##/### or EOF), one trailing newline
-}
-
-// SpecDoc is the parsed view of a spec.md.
-type SpecDoc struct {
-	Requirements []Requirement
-	HasDelta     bool // at least one "## … Requirements" delta section was seen
-}
-
-// ParseSpec reads and structures a spec.md. It never fails on grammar problems:
-// that is lintSpec's job; ParseSpec only extracts blocks and their delta context.
-func ParseSpec(file string) (*SpecDoc, error) {
-	f, err := os.Open(file)
-	if err != nil {
-		return nil, fmt.Errorf("read spec: %w", err)
-	}
-	defer f.Close()
-
-	// Read all lines first so a requirement's Raw block can span forward to its
-	// boundary without a second pass.
-	var lines []string
-	sc := newLineScanner(f)
-	for sc.Scan() {
-		lines = append(lines, sc.Text())
-	}
-	if err := sc.Err(); err != nil {
-		return nil, fmt.Errorf("scan %s: %w", file, err)
-	}
-
-	doc := &SpecDoc{}
-	curKind := ""
-	curCap := ""
-	for i := 0; i < len(lines); i++ {
-		line := lines[i]
-		if m := deltaSectionRe.FindStringSubmatch(line); m != nil {
-			doc.HasDelta = true
-			curKind = strings.ToLower(m[1])
-			curCap = ""
-			if c := capabilityTagRe.FindStringSubmatch(line); c != nil {
-				curCap = strings.TrimSpace(c[1])
-			}
-			continue
-		}
-		if reqHeaderRe.MatchString(line) {
-			name := trailWSRe.ReplaceAllString(reqPrefixRe.ReplaceAllString(line, ""), "")
-			// Raw block: this header line through the line before the next ##/###
-			// header or EOF, so a fold stores a self-contained block.
-			end := len(lines)
-			for j := i + 1; j < len(lines); j++ {
-				if blockBoundaryRe.MatchString(lines[j]) || deltaSectionRe.MatchString(lines[j]) {
-					end = j
-					break
-				}
-			}
-			raw := strings.Join(lines[i:end], "\n")
-			raw = strings.TrimRight(raw, "\n") + "\n"
-			doc.Requirements = append(doc.Requirements, Requirement{
-				Name:       name,
-				Key:        strings.ToLower(name),
-				Kind:       curKind,
-				Capability: curCap,
-				HeaderLine: i + 1,
-				Raw:        raw,
-			})
-		}
-	}
-	return doc, nil
-}
-
-// requirementKeys returns the set of lower-cased requirement names present in a
-// spec file: the identity index a cross-spec existence check consults. A missing
-// or unreadable file yields an empty set (the caller decides whether that is an
-// error), matching how the ledger treats an unseeded capability.
-func requirementKeys(file string) map[string]bool {
-	keys := map[string]bool{}
-	doc, err := ParseSpec(file)
-	if err != nil {
-		return keys
-	}
-	for _, r := range doc.Requirements {
-		keys[r.Key] = true
-	}
-	return keys
-}

package/engine/internal/lib/specskeleton.go

@@ -1,79 +0,0 @@
-package lib
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-)
-
-var specSkeletonSections = []string{
-	"Problem",
-	"Goal",
-	"Non-goals",
-	"Users / actors",
-	"Requirements",
-	"Acceptance criteria",
-	"Edge Coverage",
-	"Prohibitions (must-NOT)",
-	"Edge cases",
-	"Measurable success",
-	"Scope boundaries",
-}
-
-// SpecSkeleton checks that a spec.md declares the required top-level contract
-// sections. It is separate from SpecValidate so the structured acceptance grammar
-// output remains stable.
-func SpecSkeleton(arg, cwd string, stdout, stderr io.Writer) int {
-	spec, code, ok := resolveSpecPath("spec-skeleton", arg, stderr)
-	if !ok {
-		return code
-	}
-
-	present, err := specTopLevelSections(spec)
-	if err != nil {
-		fmt.Fprintf(stderr, "spec-skeleton: %v\n", err)
-		return 2
-	}
-
-	rel := strings.TrimPrefix(spec, cwd+"/")
-	var missing []string
-	for _, section := range specSkeletonSections {
-		if !present[strings.ToLower(section)] {
-			missing = append(missing, section)
-		}
-	}
-	if len(missing) > 0 {
-		fmt.Fprintf(stdout, "spec-skeleton: BLOCKED: %s: missing top-level section(s): %s\n", rel, strings.Join(missing, ", "))
-		return 3
-	}
-
-	fmt.Fprintf(stdout, "spec-skeleton: OK: %s: all required top-level sections present\n", rel)
-	return 0
-}
-
-func specTopLevelSections(path string) (map[string]bool, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, fmt.Errorf("read spec: %w", err)
-	}
-	defer f.Close()
-
-	present := make(map[string]bool, len(specSkeletonSections))
-	sc := bufio.NewScanner(f)
-	sc.Buffer(make([]byte, 0, 64*1024), maxScanLine)
-	for sc.Scan() {
-		line := strings.TrimSpace(sc.Text())
-		if !strings.HasPrefix(line, "## ") || strings.HasPrefix(line, "###") {
-			continue
-		}
-		heading := strings.TrimSpace(strings.TrimPrefix(line, "## "))
-		heading = strings.TrimRight(heading, "# \t")
-		present[strings.ToLower(heading)] = true
-	}
-	if err := sc.Err(); err != nil {
-		return nil, fmt.Errorf("scan %s: %w", path, err)
-	}
-	return present, nil
-}