devrites 4.2.0 → 4.4.0

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/skilltrust.go

@@ -0,0 +1,196 @@
+package lib
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+// SkillTrustFinding is one deterministic trust scan result.
+type SkillTrustFinding struct {
+	Severity string // HIGH or MEDIUM
+	Rule     string
+	Line     int
+	Detail   string
+}
+
+// SkillTrustResult summarizes a skill-trust scan.
+type SkillTrustResult struct {
+	Path     string
+	Findings []SkillTrustFinding
+}
+
+var skillTrustRules = []struct {
+	severity string
+	rule     string
+	re       *regexp.Regexp
+	detail   string
+}{
+	{
+		severity: "HIGH",
+		rule:     "prompt_injection_disregard",
+		re:       regexp.MustCompile(`(?i)\b(disregard|ignore)\b.{0,40}\b(prior|previous|above|system|instruction|rule|constraint|safety)\b`),
+		detail:   "instruction attempts to override prior constraints",
+	},
+	{
+		severity: "HIGH",
+		rule:     "credential_exfil_curl_env",
+		re:       regexp.MustCompile(`(?i)\bcurl\b.{0,120}\$(?:ENV|HOME|[A-Z_][A-Z0-9_]*)`),
+		detail:   "curl command references environment variables (possible exfiltration)",
+	},
+	{
+		severity: "HIGH",
+		rule:     "sensitive_path_reference",
+		re:       regexp.MustCompile(`(?i)(~/.ssh|~/.aws|/etc/passwd|id_rsa|\.pem\b|api[_-]?key\s*[:=])`),
+		detail:   "references sensitive filesystem or credential material",
+	},
+	{
+		severity: "MEDIUM",
+		rule:     "hidden_remote_fetch",
+		re:       regexp.MustCompile(`(?i)\b(curl|wget|fetch)\b.{0,80}\b(http|https)://`),
+		detail:   "network fetch instruction in skill prose",
+	},
+}
+
+// ScanSkillTrust reads one Markdown skill/agent file and returns structural trust findings.
+func ScanSkillTrust(path string) (SkillTrustResult, error) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return SkillTrustResult{}, err
+	}
+	if info.IsDir() {
+		return SkillTrustResult{}, fmt.Errorf("skill-trust: %q is a directory", path)
+	}
+	if info.Size() > 1<<20 {
+		return SkillTrustResult{}, fmt.Errorf("skill-trust: %q exceeds 1 MiB limit", path)
+	}
+	file, err := os.Open(path)
+	if err != nil {
+		return SkillTrustResult{}, err
+	}
+	defer file.Close()
+	raw, err := io.ReadAll(io.LimitReader(file, 1<<20+1))
+	if err != nil {
+		return SkillTrustResult{}, err
+	}
+	if len(raw) > 1<<20 {
+		return SkillTrustResult{}, fmt.Errorf("skill-trust: %q exceeds 1 MiB limit", path)
+	}
+	return SkillTrustResult{Path: filepath.Clean(path), Findings: analyzeSkillTrustContent(string(raw))}, nil
+}
+
+func analyzeSkillTrustContent(text string) []SkillTrustFinding {
+	var findings []SkillTrustFinding
+	lines := strings.Split(text, "\n")
+	for i, line := range lines {
+		lineNum := i + 1
+		for _, r := range line {
+			if isSuspiciousUnicode(r) {
+				findings = append(findings, SkillTrustFinding{
+					Severity: "HIGH",
+					Rule:     "suspicious_unicode",
+					Line:     lineNum,
+					Detail:   fmt.Sprintf("suspicious Unicode U+%04X", r),
+				})
+				break
+			}
+		}
+		for _, rule := range skillTrustRules {
+			if rule.re.MatchString(line) {
+				findings = append(findings, SkillTrustFinding{
+					Severity: rule.severity,
+					Rule:     rule.rule,
+					Line:     lineNum,
+					Detail:   rule.detail,
+				})
+			}
+		}
+	}
+	findings = appendMissingNameFinding(text, findings)
+	return dedupeFindings(findings)
+}
+
+func looksLikeSkillFile(text string) bool {
+	lower := strings.ToLower(text)
+	return strings.Contains(lower, "user-invocable:") || strings.Contains(lower, "# /rite-") || strings.Contains(lower, "disable-model-invocation:")
+}
+
+func appendMissingNameFinding(text string, findings []SkillTrustFinding) []SkillTrustFinding {
+	if strings.Contains(text, "---") && !strings.Contains(text, "\nname:") && looksLikeSkillFile(text) {
+		findings = append(findings, SkillTrustFinding{
+			Severity: "MEDIUM",
+			Rule:     "missing_name_frontmatter",
+			Line:     1,
+			Detail:   "skill-like Markdown lacks name frontmatter",
+		})
+	}
+	return findings
+}
+
+func isSuspiciousUnicode(r rune) bool {
+	switch r {
+	case '\u200B', '\u200C', '\u200D', '\uFEFF', '\u2060':
+		return true
+	}
+	if r >= '\u202A' && r <= '\u202E' {
+		return true
+	}
+	if r >= '\u2066' && r <= '\u2069' {
+		return true
+	}
+	return false
+}
+
+func dedupeFindings(in []SkillTrustFinding) []SkillTrustFinding {
+	if len(in) == 0 {
+		return nil
+	}
+	seen := make(map[string]bool, len(in))
+	out := make([]SkillTrustFinding, 0, len(in))
+	for _, finding := range in {
+		key := finding.Rule + "|" + fmt.Sprint(finding.Line) + "|" + finding.Detail
+		if seen[key] {
+			continue
+		}
+		seen[key] = true
+		out = append(out, finding)
+	}
+	return out
+}
+
+// SkillTrustBlocks returns true when findings contain any HIGH severity item.
+func SkillTrustBlocks(findings []SkillTrustFinding) bool {
+	for _, finding := range findings {
+		if finding.Severity == "HIGH" {
+			return true
+		}
+	}
+	return false
+}
+
+// FormatSkillTrust writes a human-readable report.
+func FormatSkillTrust(result SkillTrustResult) string {
+	if len(result.Findings) == 0 {
+		return fmt.Sprintf("skill-trust: PASS (%s)\n", result.Path)
+	}
+	var b strings.Builder
+	fmt.Fprintf(&b, "skill-trust: FINDINGS (%s)\n", result.Path)
+	for _, finding := range result.Findings {
+		fmt.Fprintf(&b, "%s %s line=%d %s\n", finding.Severity, finding.Rule, finding.Line, finding.Detail)
+	}
+	return b.String()
+}
+
+// ContainsOnlyASCII returns false when non-ASCII control or bidi characters appear.
+func ContainsOnlyASCII(text string) bool {
+	for _, r := range text {
+		if r > unicode.MaxASCII && isSuspiciousUnicode(r) {
+			return false
+		}
+	}
+	return true
+}

package/engine/internal/lib/taskgraph.go

@@ -0,0 +1,162 @@
+package lib
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// TaskSlice is one SLICE-### block parsed from tasks.md.
+type TaskSlice struct {
+	ID           string
+	Dependencies []string
+}
+
+// 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+$`)
+)
+
+// 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
+}
+
+// CheckTaskGraph validates tasks.md for a feature workspace slug.
+func CheckTaskGraph(root, slug string) (TaskGraphResult, error) {
+	raw, err := readWorkspaceArtifact(root, slug, "tasks.md")
+	if err != nil {
+		return TaskGraphResult{}, err
+	}
+	return ParseTaskGraph(raw), nil
+}