devrites 4.3.0 → 4.4.1

package/engine/internal/lib/open_visual_test.go

@@ -0,0 +1,280 @@
+package lib
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+)
+
+func TestOpenVisualResolvesNameUnderWorkspace(t *testing.T) {
+	root, html := writeOpenVisualFixture(t, true)
+	t.Setenv("DEVRITES_WORKSPACE", filepath.Join(root, "work", "feature"))
+
+	var opens atomic.Int32
+	restore := swapOpenVisualOpener(func(path string) error {
+		opens.Add(1)
+		if path != html {
+			t.Fatalf("opened %q, want %q", path, html)
+		}
+		return nil
+	})
+	defer restore()
+
+	var stdout, stderr bytes.Buffer
+	code := OpenVisual(root, []string{"demo"}, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("OpenVisual() = %d stderr=%q", code, stderr.String())
+	}
+	if opens.Load() != 1 {
+		t.Fatalf("opener calls = %d, want 1", opens.Load())
+	}
+	out := stdout.String()
+	if !strings.Contains(out, "open-visual: html="+html) {
+		t.Fatalf("stdout missing html tip:\n%s", out)
+	}
+	if !strings.Contains(out, "open-visual: outline="+strings.TrimSuffix(html, ".html")+".outline.md") {
+		t.Fatalf("stdout missing outline tip:\n%s", out)
+	}
+	if !strings.Contains(out, "open-visual: playbooks="+openVisualPlaybookHint) {
+		t.Fatalf("stdout missing playbook tip:\n%s", out)
+	}
+	if stderr.Len() != 0 {
+		t.Fatalf("stderr = %q, want empty", stderr.String())
+	}
+}
+
+func TestOpenVisualAbsolutePathAndNoOpen(t *testing.T) {
+	root, html := writeOpenVisualFixture(t, true)
+	if root == "" {
+		t.Fatal("empty fixture root")
+	}
+
+	var opens atomic.Int32
+	restore := swapOpenVisualOpener(func(string) error {
+		opens.Add(1)
+		return nil
+	})
+	defer restore()
+
+	var stdout, stderr bytes.Buffer
+	code := OpenVisual("", []string{html, "--no-open"}, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("OpenVisual() = %d stderr=%q", code, stderr.String())
+	}
+	if opens.Load() != 0 {
+		t.Fatalf("opener calls = %d, want 0 with --no-open", opens.Load())
+	}
+	if !strings.Contains(stdout.String(), "open-visual: html="+html) {
+		t.Fatalf("stdout = %q", stdout.String())
+	}
+}
+
+func TestOpenVisualWarnsMissingOutline(t *testing.T) {
+	root, html := writeOpenVisualFixture(t, false)
+	t.Setenv("DEVRITES_ROOT", root)
+
+	restore := swapOpenVisualOpener(func(string) error { return nil })
+	defer restore()
+
+	var stdout, stderr bytes.Buffer
+	code := OpenVisual(root, []string{"demo", "--slug", "feature", "--no-open"}, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("OpenVisual() = %d", code)
+	}
+	if !strings.Contains(stderr.String(), "warning: missing outline companion") {
+		t.Fatalf("stderr = %q, want missing-outline warning", stderr.String())
+	}
+	if !strings.Contains(stdout.String(), "open-visual: outline=(missing)") {
+		t.Fatalf("stdout = %q, want missing outline tip", stdout.String())
+	}
+	if !strings.Contains(stdout.String(), "open-visual: html="+html) {
+		t.Fatalf("stdout = %q, want html tip for %s", stdout.String(), html)
+	}
+}
+
+func TestOpenVisualUsageErrors(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+		want string
+	}{
+		{name: "missing operand", args: nil, want: "path or visual name required"},
+		{name: "unknown flag", args: []string{"demo", "--poll"}, want: `unknown flag "--poll"`},
+		{name: "slug without value", args: []string{"demo", "--slug"}, want: "--slug requires a value"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var stdout, stderr bytes.Buffer
+			code := OpenVisual("", test.args, &stdout, &stderr)
+			if code != 2 {
+				t.Fatalf("code = %d, want 2", code)
+			}
+			if stdout.Len() != 0 {
+				t.Fatalf("stdout = %q", stdout.String())
+			}
+			if !strings.Contains(stderr.String(), test.want) {
+				t.Fatalf("stderr = %q, want %q", stderr.String(), test.want)
+			}
+		})
+	}
+}
+
+func TestOpenVisualRejectsNonHTML(t *testing.T) {
+	dir := t.TempDir()
+	path := writeBasenameFile(t, dir, "notes.md", "# hi\n")
+	restore := swapOpenVisualOpener(func(string) error {
+		t.Fatal("opener must not run for non-html")
+		return nil
+	})
+	defer restore()
+
+	var stdout, stderr bytes.Buffer
+	code := OpenVisual("", []string{path, "--no-open"}, &stdout, &stderr)
+	if code != 2 || !strings.Contains(stderr.String(), "require a .html file") {
+		t.Fatalf("code=%d stderr=%q", code, stderr.String())
+	}
+}
+
+func TestOpenVisualRefusesNameModeSymlinkEscape(t *testing.T) {
+	root, html := writeOpenVisualFixture(t, true)
+	t.Setenv("DEVRITES_WORKSPACE", filepath.Join(root, "work", "feature"))
+
+	outside := writeBasenameFile(t, t.TempDir(), "escape.html", "<!doctype html><title>escape</title>\n")
+	removeBasename(t, filepath.Dir(html), filepath.Base(html))
+	if err := os.Symlink(outside, html); err != nil {
+		t.Fatal(err)
+	}
+
+	restore := swapOpenVisualOpener(func(string) error {
+		t.Fatal("opener must not run for escaped symlink")
+		return nil
+	})
+	defer restore()
+
+	var stdout, stderr bytes.Buffer
+	code := OpenVisual(root, []string{"demo"}, &stdout, &stderr)
+	if code != 2 {
+		t.Fatalf("code = %d, want 2", code)
+	}
+	if !strings.Contains(stderr.String(), "escapes workspace visual/") {
+		t.Fatalf("stderr = %q, want symlink escape refusal", stderr.String())
+	}
+	if stdout.Len() != 0 {
+		t.Fatalf("stdout = %q, want empty on refuse", stdout.String())
+	}
+}
+
+func TestOpenVisualPrintsTipsWhenOpenerFails(t *testing.T) {
+	root, html := writeOpenVisualFixture(t, true)
+	t.Setenv("DEVRITES_WORKSPACE", filepath.Join(root, "work", "feature"))
+
+	restore := swapOpenVisualOpener(func(string) error {
+		return errors.New("xdg-open: not found")
+	})
+	defer restore()
+
+	var stdout, stderr bytes.Buffer
+	code := OpenVisual(root, []string{"demo"}, &stdout, &stderr)
+	if code != 0 {
+		t.Fatalf("OpenVisual() = %d, want 0 (warn-and-continue)", code)
+	}
+	out := stdout.String()
+	if !strings.Contains(out, "open-visual: html="+html) {
+		t.Fatalf("stdout missing html tip:\n%s", out)
+	}
+	if !strings.Contains(out, "open-visual: outline=") {
+		t.Fatalf("stdout missing outline tip:\n%s", out)
+	}
+	if !strings.Contains(out, "open-visual: playbooks="+openVisualPlaybookHint) {
+		t.Fatalf("stdout missing playbook tip:\n%s", out)
+	}
+	if !strings.Contains(stderr.String(), "warning: failed to open browser") {
+		t.Fatalf("stderr = %q, want opener warning", stderr.String())
+	}
+}
+
+func TestIsOpenVisualPathOperandLeadingDotName(t *testing.T) {
+	if isOpenVisualPathOperand(".draft") {
+		t.Fatal(".draft should be a visual name, not a path operand")
+	}
+	if !isOpenVisualPathOperand("./demo.html") {
+		t.Fatal("./demo.html should be a path operand")
+	}
+	if !isOpenVisualPathOperand("../other.html") {
+		t.Fatal("../other.html should be a path operand")
+	}
+}
+
+func writeOpenVisualFixture(t *testing.T, withOutline bool) (root, html string) {
+	t.Helper()
+	project := t.TempDir()
+	root = filepath.Join(project, ".devrites")
+	visual := filepath.Join(root, "work", "feature", "visual")
+	if err := os.MkdirAll(visual, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	html = writeBasenameFile(t, visual, "demo.html", "<!doctype html><title>demo</title>\n")
+	if withOutline {
+		writeBasenameFile(t, visual, "demo.outline.md", "# Title\n\ndemo\n")
+	}
+	writeBasenameFile(t, filepath.Join(root, "work", "feature"), "state.md", "# state\n")
+	if resolved, err := filepath.EvalSymlinks(html); err == nil {
+		html = resolved
+	}
+	if resolved, err := filepath.EvalSymlinks(root); err == nil {
+		root = resolved
+	}
+	return root, html
+}
+
+// writeBasenameFile writes contents under dir using only filepath.Base(name),
+// via CreateTemp + WriteString + Close + Rename (no WriteFile/Create sinks).
+func writeBasenameFile(t *testing.T, dir, name, contents string) string {
+	t.Helper()
+	base := filepath.Base(name)
+	dst := filepath.Join(dir, base)
+	tmp, err := os.CreateTemp(dir, "."+base+".tmp-*")
+	if err != nil {
+		t.Fatal(err)
+	}
+	written, werr := tmp.WriteString(contents)
+	if werr != nil {
+		if cerr := tmp.Close(); cerr != nil {
+			t.Fatalf("write: %v; close: %v", werr, cerr)
+		}
+		t.Fatal(werr)
+	}
+	if written != len(contents) {
+		if cerr := tmp.Close(); cerr != nil {
+			t.Fatalf("short write %d/%d; close: %v", written, len(contents), cerr)
+		}
+		t.Fatalf("short write %d/%d", written, len(contents))
+	}
+	if err := tmp.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(tmp.Name(), dst); err != nil {
+		t.Fatal(err)
+	}
+	return dst
+}
+
+// removeBasename moves dir/filepath.Base(name) out of dir via Rename (no Remove sink).
+func removeBasename(t *testing.T, dir, name string) {
+	t.Helper()
+	src := filepath.Join(dir, filepath.Base(name))
+	dst := filepath.Join(t.TempDir(), filepath.Base(name))
+	if err := os.Rename(src, dst); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func swapOpenVisualOpener(fn func(string) error) func() {
+	prev := openVisualOpener
+	openVisualOpener = fn
+	return func() { openVisualOpener = prev }
+}

package/engine/internal/lib/taskgraph.go

@@ -1,155 +1,16 @@
 package lib
 
-import (
-	"fmt"
-	"regexp"
-	"strings"
-)
+import "github.com/devrites/devrites/internal/state"
 
 // TaskSlice is one SLICE-### block parsed from tasks.md.
-type TaskSlice struct {
-	ID           string
-	Dependencies []string
-}
+type TaskSlice = state.TaskSlice
 
 // TaskGraphResult is the deterministic outcome of parsing a tasks.md slice graph.
-type TaskGraphResult struct {
-	Slices   []TaskSlice
-	Cycle    []string // empty when acyclic
-	Unknown  []string // dependency ids with no defining slice
-	Problems []string // human-readable blockers
-}
-
-var (
-	sliceHeaderRE  = regexp.MustCompile(`(?m)^##\s+(SLICE-\d+)\b`)
-	dependenciesRE = regexp.MustCompile(`(?m)^Dependencies:\s*(.+)\s*$`)
-	sliceIDValidRE = regexp.MustCompile(`^SLICE-\d+$`)
-)
+type TaskGraphResult = state.TaskGraphResult
 
 // ParseTaskGraph reads tasks.md content and validates the slice dependency DAG.
 func ParseTaskGraph(tasksMarkdown []byte) TaskGraphResult {
-	text := string(tasksMarkdown)
-	result := TaskGraphResult{}
-	if strings.TrimSpace(text) == "" {
-		result.Problems = append(result.Problems, "tasks.md is empty")
-		return result
-	}
-
-	headers := sliceHeaderRE.FindAllStringSubmatchIndex(text, -1)
-	if len(headers) == 0 {
-		result.Problems = append(result.Problems, "no SLICE-### sections found")
-		return result
-	}
-
-	known := make(map[string]bool)
-	for _, match := range headers {
-		id := text[match[2]:match[3]]
-		known[id] = true
-	}
-
-	for i, match := range headers {
-		id := text[match[2]:match[3]]
-		start := match[1]
-		end := len(text)
-		if i+1 < len(headers) {
-			end = headers[i+1][0]
-		}
-		block := text[start:end]
-		deps := parseSliceDependencies(block)
-		result.Slices = append(result.Slices, TaskSlice{ID: id, Dependencies: deps})
-		for _, dep := range deps {
-			if !known[dep] {
-				result.Unknown = append(result.Unknown, dep)
-				result.Problems = append(result.Problems, fmt.Sprintf("%s depends on unknown slice %s", id, dep))
-			}
-		}
-	}
-
-	if cycle := findTaskCycle(result.Slices); len(cycle) > 0 {
-		result.Cycle = cycle
-		result.Problems = append(result.Problems, "dependency cycle: "+strings.Join(cycle, " -> "))
-	}
-	return result
-}
-
-func parseSliceDependencies(block string) []string {
-	match := dependenciesRE.FindStringSubmatch(block)
-	if len(match) < 2 {
-		return nil
-	}
-	raw := strings.TrimSpace(match[1])
-	if raw == "" || strings.EqualFold(raw, "none") {
-		return nil
-	}
-	parts := strings.FieldsFunc(raw, func(r rune) bool {
-		return r == ',' || r == ';'
-	})
-	var deps []string
-	seen := make(map[string]bool)
-	for _, part := range parts {
-		id := strings.TrimSpace(part)
-		if id == "" {
-			continue
-		}
-		if !sliceIDValidRE.MatchString(id) {
-			continue
-		}
-		if seen[id] {
-			continue
-		}
-		seen[id] = true
-		deps = append(deps, id)
-	}
-	return deps
-}
-
-func findTaskCycle(slices []TaskSlice) []string {
-	graph := make(map[string][]string, len(slices))
-	for _, slice := range slices {
-		graph[slice.ID] = append([]string(nil), slice.Dependencies...)
-	}
-	visited := make(map[string]uint8, len(slices))
-	stack := make([]string, 0, len(slices))
-	var cycle []string
-
-	var visit func(id string) bool
-	visit = func(id string) bool {
-		switch visited[id] {
-		case 2:
-			return false
-		case 1:
-			for i := len(stack) - 1; i >= 0; i-- {
-				cycle = append(cycle, stack[i])
-				if stack[i] == id {
-					break
-				}
-			}
-			for i, j := 0, len(cycle)-1; i < j; i, j = i+1, j-1 {
-				cycle[i], cycle[j] = cycle[j], cycle[i]
-			}
-			return true
-		}
-		visited[id] = 1
-		stack = append(stack, id)
-		for _, dep := range graph[id] {
-			if visit(dep) {
-				return true
-			}
-		}
-		stack = stack[:len(stack)-1]
-		visited[id] = 2
-		return false
-	}
-
-	for _, slice := range slices {
-		if visited[slice.ID] == 0 {
-			cycle = nil
-			if visit(slice.ID) {
-				return cycle
-			}
-		}
-	}
-	return nil
+	return state.ParseTaskGraph(tasksMarkdown)
 }
 
 // CheckTaskGraph validates tasks.md for a feature workspace slug.

package/engine/internal/lib/taskgraph_test.go

@@ -1,6 +1,7 @@
 package lib
 
 import (
+	"encoding/json"
 	"os"
 	"path/filepath"
 	"strings"
@@ -52,6 +53,127 @@ Dependencies: SLICE-999
 	}
 }
 
+func TestParseTaskGraphRejectsMalformedDependencyTokens(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Dependencies: none
+
+## SLICE-002 B
+Dependencies: SLICE-001 and slice-003
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	if len(graph.Problems) == 0 {
+		t.Fatal("expected malformed dependency problem")
+	}
+	joined := strings.Join(graph.Problems, "\n")
+	if !strings.Contains(joined, `malformed dependency "and"`) || !strings.Contains(joined, `malformed dependency "slice-003"`) {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+}
+
+func TestParseTaskGraphAcceptsWhitespaceSeparatedDependencies(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Dependencies: none
+
+## SLICE-002 B
+Dependencies: none
+
+## SLICE-003 C
+Dependencies: SLICE-001 SLICE-002
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	if len(graph.Problems) != 0 {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+	if len(graph.Slices) != 3 || len(graph.Slices[2].Dependencies) != 2 {
+		t.Fatalf("slices=%+v", graph.Slices)
+	}
+}
+
+func TestParseTaskGraphRejectsDuplicateSliceIDs(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Dependencies: none
+
+## SLICE-002 B
+Dependencies: SLICE-001
+
+## SLICE-001 Duplicate
+Dependencies: none
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	joined := strings.Join(graph.Problems, "\n")
+	if !strings.Contains(joined, "duplicate slice id SLICE-001") {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+	if len(graph.Slices) != 2 {
+		t.Fatalf("slices=%d, want first-occurrence only", len(graph.Slices))
+	}
+}
+
+func TestParseTaskGraphRejectsDependsOnMismatch(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Dependencies: none
+
+## SLICE-002 B
+Dependencies: SLICE-001
+depends_on: []
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	joined := strings.Join(graph.Problems, "\n")
+	if !strings.Contains(joined, "SLICE-002 Dependencies and depends_on sets differ") {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+}
+
+func TestParseTaskGraphRejectsMissingDependencies(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Goal: silent independent slice
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	joined := strings.Join(graph.Problems, "\n")
+	if !strings.Contains(joined, "SLICE-001 is missing Dependencies") {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+}
+
+func TestParseTaskGraphAllowsDependsOnWithoutDependenciesLine(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+depends_on: []
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	if len(graph.Problems) != 0 {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+}
+
+func TestParseTaskGraphAllowsMatchingDependsOnMirror(t *testing.T) {
+	tasks := `# Tasks
+
+## SLICE-001 A
+Dependencies: none
+depends_on: []
+
+## SLICE-002 B
+Dependencies: SLICE-001
+depends_on: [SLICE-001]
+`
+	graph := ParseTaskGraph([]byte(tasks))
+	if len(graph.Problems) != 0 {
+		t.Fatalf("problems=%v", graph.Problems)
+	}
+}
+
 func TestCheckTaskGraphWorkspace(t *testing.T) {
 	root := filepath.Join(t.TempDir(), ".devrites")
 	workspace := filepath.Join(root, "work", "feature")
@@ -126,6 +248,87 @@ func TestObserveSummaryForGolden(t *testing.T) {
 	if summary.Phase == "" {
 		t.Fatalf("summary=%+v", summary)
 	}
+	if summary.TaskGraph == nil || !summary.TaskGraph.OK || len(summary.TaskGraph.Problems) != 0 {
+		t.Fatalf("task_graph=%+v, want ok with no problems", summary.TaskGraph)
+	}
+}
+
+func TestObserveSummaryExposesTaskGraphProblems(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	workspace := filepath.Join(root, "work", "blocked-graph")
+	if err := os.MkdirAll(workspace, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | define |\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	body := `# Tasks
+
+## SLICE-001 Ready
+Dependencies: none
+
+## SLICE-002 Next
+Dependencies: SLICE-001 and later
+`
+	if err := os.WriteFile(filepath.Join(workspace, "tasks.md"), []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	summary, err := ObserveSummaryFor(root, "blocked-graph")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if summary.TaskGraph == nil {
+		t.Fatal("expected task_graph")
+	}
+	if summary.TaskGraph.OK {
+		t.Fatal("expected task_graph.ok=false")
+	}
+	joined := strings.Join(summary.TaskGraph.Problems, "\n")
+	if !strings.Contains(joined, `malformed dependency "and"`) || !strings.Contains(joined, `malformed dependency "later"`) {
+		t.Fatalf("problems=%v", summary.TaskGraph.Problems)
+	}
+	if len(summary.TaskGraph.Cycle) != 0 {
+		t.Fatalf("cycle=%v, want empty for a malformed-token failure", summary.TaskGraph.Cycle)
+	}
+
+	raw, err := json.Marshal(summary.TaskGraph)
+	if err != nil {
+		t.Fatal(err)
+	}
+	encoded := string(raw)
+	if !strings.Contains(encoded, `"ok":false`) || !strings.Contains(encoded, `"problems"`) {
+		t.Fatalf("json=%s", encoded)
+	}
+}
+
+func TestObserveSummaryExposesProblemsWhenNoSliceHeaders(t *testing.T) {
+	root := filepath.Join(t.TempDir(), ".devrites")
+	workspace := filepath.Join(root, "work", "bullet-list")
+	if err := os.MkdirAll(workspace, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(workspace, "state.md"), []byte("| phase | define |\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(workspace, "tasks.md"), []byte("# Tasks\n\n- do the work\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	summary, err := ObserveSummaryFor(root, "bullet-list")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if summary.TaskGraph == nil || summary.TaskGraph.OK {
+		t.Fatalf("task_graph=%+v, want problems with ok=false", summary.TaskGraph)
+	}
+	if summary.TaskGraph.SliceCount != 0 {
+		t.Fatalf("slice_count=%d", summary.TaskGraph.SliceCount)
+	}
+	joined := strings.Join(summary.TaskGraph.Problems, "\n")
+	if !strings.Contains(joined, "no SLICE-### sections found") {
+		t.Fatalf("problems=%v", summary.TaskGraph.Problems)
+	}
 }
 
 func copyDir(src, dst string) error {