devrites 4.6.0 → 5.0.0

package/engine/internal/hostpack/hostpack.go

@@ -16,8 +16,10 @@ import (
 const (
 	ClaudeSkillsTarget    = devritespaths.ClaudeSkillsTarget
 	CodexSkillsTarget     = devritespaths.CodexSkillsTarget
+	OmpSkillsTarget       = devritespaths.OmpSkillsTarget
 	ClaudeAgentsTarget    = devritespaths.ClaudeAgentsTarget
 	CodexAgentsTarget     = devritespaths.CodexAgentsTarget
+	OmpAgentsTarget       = devritespaths.OmpAgentsTarget
 	ClaudeWorkflowsTarget = devritespaths.ClaudeWorkflowsTarget
 )
 
@@ -123,7 +125,7 @@ var managedMerges = []ManagedMerge{
 	LegacyCodexHooksMerge,
 }
 
-func RequiredPayload(withCodex bool) []string {
+func RequiredPayload(withCodex, withOmp bool) []string {
 	required := []string{
 		"claude/skills",
 		"claude/agents",
@@ -138,11 +140,18 @@ func RequiredPayload(withCodex bool) []string {
 			"codex/config.toml",
 		)
 	}
+	if withOmp {
+		required = append(required,
+			"omp/skills",
+			"omp/agents",
+			"omp/.omp-plugin/plugin.json",
+		)
+	}
 	return required
 }
 
-func ValidatePayload(payload fs.FS, withCodex bool) error {
-	for _, rel := range RequiredPayload(withCodex) {
+func ValidatePayload(payload fs.FS, withCodex, withOmp bool) error {
+	for _, rel := range RequiredPayload(withCodex, withOmp) {
 		if _, err := fs.Stat(payload, rel); err != nil {
 			return fmt.Errorf("missing %s", rel)
 		}
@@ -150,19 +159,25 @@ func ValidatePayload(payload fs.FS, withCodex bool) error {
 	return nil
 }
 
-func InstallTrees(withSkills, withAgents, withCodex bool) []Tree {
+func InstallTrees(withSkills, withAgents, withCodex, withOmp bool) []Tree {
 	var trees []Tree
 	if withSkills {
 		trees = append(trees, Tree{PayloadPrefix: "claude/skills", TargetPrefix: ClaudeSkillsTarget})
 		if withCodex {
 			trees = append(trees, Tree{PayloadPrefix: "codex/skills", TargetPrefix: CodexSkillsTarget})
 		}
+		if withOmp {
+			trees = append(trees, Tree{PayloadPrefix: "omp/skills", TargetPrefix: OmpSkillsTarget})
+		}
 	}
 	if withAgents {
 		trees = append(trees, Tree{PayloadPrefix: "claude/agents", TargetPrefix: ClaudeAgentsTarget})
 		if withCodex {
 			trees = append(trees, Tree{PayloadPrefix: "codex/agents", TargetPrefix: CodexAgentsTarget})
 		}
+		if withOmp {
+			trees = append(trees, Tree{PayloadPrefix: "omp/agents", TargetPrefix: OmpAgentsTarget})
+		}
 	}
 	if withSkills && withAgents {
 		trees = append(trees, Tree{PayloadPrefix: "claude/workflows", TargetPrefix: ClaudeWorkflowsTarget})
@@ -170,11 +185,14 @@ func InstallTrees(withSkills, withAgents, withCodex bool) []Tree {
 	return trees
 }
 
-func AliasTargets(alias Alias, withCodex bool) []string {
+func AliasTargets(alias Alias, withCodex, withOmp bool) []string {
 	targets := []string{filepath.ToSlash(filepath.Join(ClaudeSkillsTarget, alias.Name, "SKILL.md"))}
 	if withCodex {
 		targets = append(targets, filepath.ToSlash(filepath.Join(CodexSkillsTarget, alias.Name, "SKILL.md")))
 	}
+	if withOmp {
+		targets = append(targets, filepath.ToSlash(filepath.Join(OmpSkillsTarget, alias.Name, "SKILL.md")))
+	}
 	return targets
 }
 

package/engine/internal/hostpack/hostpack_test.go

@@ -18,39 +18,75 @@ func TestValidatePayloadRequiresClaudeAndCodexFiles(t *testing.T) {
 		"codex/agents/devrites-code-reviewer.toml":     {},
 		"codex/AGENTS.md":                              {},
 		"codex/config.toml":                            {},
+		"omp/skills/rite/SKILL.md":                     {},
+		"omp/agents/devrites-code-reviewer.md":         {},
+		"omp/.omp-plugin/plugin.json":                  {},
 	}
-	if err := ValidatePayload(payload, true); err != nil {
+	if err := ValidatePayload(payload, true, true); err != nil {
 		t.Fatal(err)
 	}
 	delete(payload, "codex/config.toml")
-	err := ValidatePayload(payload, true)
+	err := ValidatePayload(payload, true, true)
 	if err == nil || !strings.Contains(err.Error(), "missing codex/config.toml") {
 		t.Fatalf("ValidatePayload error = %v, want missing codex/config.toml", err)
 	}
-	if err := ValidatePayload(payload, false); err != nil {
+	if err := ValidatePayload(payload, false, true); err != nil {
 		t.Fatalf("claude-only payload should not require codex files: %v", err)
 	}
+	delete(payload, "omp/.omp-plugin/plugin.json")
+	err = ValidatePayload(payload, false, true)
+	if err == nil || !strings.Contains(err.Error(), "missing omp/.omp-plugin/plugin.json") {
+		t.Fatalf("ValidatePayload error = %v, want missing omp/.omp-plugin/plugin.json", err)
+	}
+	if err := ValidatePayload(payload, false, false); err != nil {
+		t.Fatalf("claude-only payload should not require omp files: %v", err)
+	}
 }
 
 func TestInstallTreesMapPayloadsToTargets(t *testing.T) {
-	got := InstallTrees(true, true, true)
+	got := InstallTrees(true, true, true, true)
 	want := []Tree{
 		{PayloadPrefix: "claude/skills", TargetPrefix: ".claude/skills"},
 		{PayloadPrefix: "codex/skills", TargetPrefix: ".agents/skills"},
+		{PayloadPrefix: "omp/skills", TargetPrefix: ".omp/skills"},
 		{PayloadPrefix: "claude/agents", TargetPrefix: ".claude/agents"},
 		{PayloadPrefix: "codex/agents", TargetPrefix: ".codex/agents"},
+		{PayloadPrefix: "omp/agents", TargetPrefix: ".omp/agents"},
 		{PayloadPrefix: "claude/workflows", TargetPrefix: ".claude/workflows"},
 	}
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("InstallTrees() = %#v, want %#v", got, want)
 	}
-	for _, trees := range [][]Tree{InstallTrees(true, false, true), InstallTrees(false, true, true)} {
+	for _, trees := range [][]Tree{InstallTrees(true, false, true, true), InstallTrees(false, true, true, true)} {
 		for _, tree := range trees {
 			if tree.PayloadPrefix == "claude/workflows" {
 				t.Fatal("Claude workflow installed without both skills and agents")
 			}
 		}
 	}
+	for _, tree := range InstallTrees(true, true, true, false) {
+		if strings.HasPrefix(tree.TargetPrefix, ".omp/") {
+			t.Fatalf("omp tree installed with withOmp=false: %#v", tree)
+		}
+	}
+}
+
+func TestAliasTargetsIncludeOmpWhenEnabled(t *testing.T) {
+	got := AliasTargets(Alias{Name: "define"}, true, true)
+	want := []string{
+		".claude/skills/define/SKILL.md",
+		".agents/skills/define/SKILL.md",
+		".omp/skills/define/SKILL.md",
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("AliasTargets() = %#v, want %#v", got, want)
+	}
+	got = AliasTargets(Alias{Name: "define"}, true, false)
+	for _, rel := range got {
+		if strings.HasPrefix(rel, ".omp/") {
+			t.Fatalf("omp alias installed with withOmp=false: %s", rel)
+		}
+	}
 }
 
 func TestAliasTemplateOutput(t *testing.T) {

package/engine/internal/install/apply.go

@@ -0,0 +1,324 @@
+package install
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"slices"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/devrites/devrites/internal/fsutil"
+	"github.com/devrites/devrites/internal/hostpack"
+)
+
+func (r *runner) install() error {
+	fmt.Fprintln(r.opts.Stdout, "DevRites installer")
+	fmt.Fprintf(r.opts.Stdout, "  target : %s\n", r.target)
+	fmt.Fprintf(r.opts.Stdout, "  payload: %s\n", r.payload)
+	fmt.Fprintf(r.opts.Stdout, "  skills : %s\n", yesno(r.opts.WithSkills))
+	fmt.Fprintln(r.opts.Stdout, "  standards: ship inside the devrites-lib skill")
+	fmt.Fprintf(r.opts.Stdout, "  agents : %s\n", yesno(r.opts.WithAgents))
+	fmt.Fprintf(r.opts.Stdout, "  codex  : %s\n", yesno(r.opts.WithCodex))
+	fmt.Fprintf(r.opts.Stdout, "  omp    : %s\n", yesno(r.opts.WithOmp))
+	fmt.Fprintf(r.opts.Stdout, "  aliases: %s\n", r.opts.AliasMode)
+	if r.opts.DryRun {
+		fmt.Fprintln(r.opts.Stdout, "  (dry run - no changes will be made)")
+	}
+	fmt.Fprintln(r.opts.Stdout)
+	if r.preparedBinary != "" {
+		if _, err := verifyEngineBinary(r.preparedBinary, r.binaryTag(), 30*time.Second); err != nil {
+			return fmt.Errorf("verify staged engine binary %s: %w", r.preparedBinary, err)
+		}
+	}
+	if err := r.preflightInstall(); err != nil {
+		return err
+	}
+
+	for _, tree := range hostpack.InstallTrees(r.opts.WithSkills, r.opts.WithAgents, r.opts.WithCodex, r.opts.WithOmp) {
+		if err := r.installTree(tree.PayloadPrefix, tree.TargetPrefix); err != nil {
+			return fmt.Errorf("install tree %s: %w", tree.TargetPrefix, err)
+		}
+	}
+	if r.opts.WithSkills && r.opts.AliasMode == "all" {
+		for _, alias := range hostpack.Aliases {
+			data, err := hostpack.RenderAliasSkill(alias)
+			if err != nil {
+				return fmt.Errorf("render alias skill %s: %w", alias.Name, err)
+			}
+			for _, rel := range hostpack.AliasTargets(alias, r.opts.WithCodex, r.opts.WithOmp) {
+				if err := r.installData(data, rel); err != nil {
+					return fmt.Errorf("install alias: %w", err)
+				}
+			}
+		}
+	}
+	if r.opts.WithSkills && r.opts.WithCodex {
+		if err := r.mergeMarkerFile(hostpack.CodexAgentsMerge); err != nil {
+			return fmt.Errorf("merge %s: %w", hostpack.CodexAgentsMerge.TargetRel, err)
+		}
+		if err := r.mergeCodexConfig(); err != nil {
+			return fmt.Errorf("merge %s: %w", hostpack.CodexConfigMerge.TargetRel, err)
+		}
+	}
+	if r.opts.WithSkills {
+		if err := r.seedClaudeSettings(); err != nil {
+			return fmt.Errorf("seed claude settings: %w", err)
+		}
+	}
+	if err := r.seedDevrites(); err != nil {
+		return fmt.Errorf("seed .devrites: %w", err)
+	}
+	if err := r.pruneDropped(); err != nil {
+		return fmt.Errorf("prune dropped files: %w", err)
+	}
+	if !r.opts.DryRun {
+		if err := r.writeManifest(); err != nil {
+			return fmt.Errorf("write manifest: %w", err)
+		}
+	}
+	if err := r.installBinary(); err != nil {
+		return fmt.Errorf("install engine binary: %w", err)
+	}
+
+	fmt.Fprintln(r.opts.Stdout)
+	if r.opts.DryRun {
+		fmt.Fprintln(r.opts.Stdout, "DevRites install plan complete (dry run)")
+	} else {
+		fmt.Fprintln(r.opts.Stdout, "DevRites installed")
+	}
+	fmt.Fprintf(r.opts.Stdout, "  installed: %d   overwritten: %d   skipped(conflict): %d   pruned: %d\n", r.stats.installed, r.stats.overwrote, r.stats.skipped, r.stats.pruned)
+	if !r.opts.DryRun && r.opts.WithSkills {
+		switch {
+		case r.opts.WithCodex && r.opts.WithOmp:
+			fmt.Fprintln(r.opts.Stdout, "Next: reopen the project, then run /rite (Claude) or $rite (Codex) or /skill:rite.")
+		case r.opts.WithCodex:
+			fmt.Fprintln(r.opts.Stdout, "Next: reopen the project, then run /rite (Claude) or $rite (Codex).")
+		case r.opts.WithOmp:
+			fmt.Fprintln(r.opts.Stdout, "Next: reopen the project, then run /rite or /skill:rite.")
+		default:
+			fmt.Fprintln(r.opts.Stdout, "Next: reopen the project, then run /rite.")
+		}
+	}
+	return nil
+}
+
+func (r *runner) installTree(srcPrefix, relPrefix string) error {
+	return fs.WalkDir(r.payloadFS, srcPrefix, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return fmt.Errorf("walk payload %s: %w", path, err)
+		}
+		if d.IsDir() {
+			return nil
+		}
+		rel, err := filepath.Rel(srcPrefix, path)
+		if err != nil {
+			return fmt.Errorf("resolve relative path for %s: %w", path, err)
+		}
+		return r.installFile(path, filepath.ToSlash(filepath.Join(relPrefix, rel)))
+	})
+}
+
+func (r *runner) installFile(src, rel string) error {
+	data, err := fs.ReadFile(r.payloadFS, src)
+	if err != nil {
+		return fmt.Errorf("read payload %s: %w", src, err)
+	}
+	return r.installData(data, rel)
+}
+
+func (r *runner) installData(data []byte, rel string) error {
+	dest := filepath.Join(r.target, filepath.FromSlash(rel))
+	action := "install"
+	if exists(dest) {
+		record, managed := r.prev[rel]
+		switch {
+		case managed && managedConflict(record, r.preflight[filepath.ToSlash(rel)]) != "" && r.opts.Force:
+			action = "overwrite(force-customized)"
+		case managed:
+			action = "overwrite"
+		case r.opts.Force:
+			action = "overwrite(force)"
+		default:
+			if r.opts.DryRun {
+				fmt.Fprintf(r.opts.Stdout, "  [skip] %s (exists, not DevRites-managed)\n", rel)
+			} else {
+				fmt.Fprintf(r.opts.Stderr, "warning: skip %s (exists, not DevRites-managed; use --force to overwrite)\n", rel)
+			}
+			r.stats.skipped++
+			return nil
+		}
+	}
+	if r.opts.DryRun {
+		fmt.Fprintf(r.opts.Stdout, "  [%s] %s\n", action, rel)
+	} else {
+		if err := r.recheckPath(rel); err != nil {
+			return err
+		}
+		if err := fsutil.WriteFileAtomic(dest, data, 0o644); err != nil {
+			return fmt.Errorf("cannot write %s: %w", rel, err)
+		}
+	}
+	r.addManifest(rel)
+	r.addInstallRecord(rel, data)
+	if action == "install" {
+		r.stats.installed++
+	} else {
+		r.stats.overwrote++
+	}
+	return nil
+}
+
+func (r *runner) addManifest(rel string) {
+	r.manifest = append(r.manifest, filepath.ToSlash(rel))
+}
+
+func (r *runner) addInstallRecord(rel string, data []byte) {
+	if r.records == nil {
+		r.records = map[string]string{}
+	}
+	sum := sha256.Sum256(data)
+	r.records[filepath.ToSlash(rel)] = fmt.Sprintf("sha256:%x", sum[:])
+}
+
+func (r *runner) installMarker(rel, text string) error {
+	return r.installData([]byte(text+"\n"), rel)
+}
+
+func (r *runner) seedDevrites() error {
+	readme, err := hostpack.RenderDevritesReadme()
+	if err != nil {
+		return fmt.Errorf("render readme: %w", err)
+	}
+	if err := r.installData(readme, ".devrites/README.md"); err != nil {
+		return fmt.Errorf("install readme: %w", err)
+	}
+	active := filepath.Join(r.target, ".devrites", "ACTIVE")
+	if exists(active) {
+		return nil
+	}
+	if r.opts.DryRun {
+		fmt.Fprintln(r.opts.Stdout, "  [seed] .devrites/ACTIVE (runtime state - preserved on uninstall)")
+		return nil
+	}
+	if err := os.MkdirAll(filepath.Dir(active), 0o755); err != nil {
+		return fmt.Errorf("create %s: %w", filepath.Dir(active), err)
+	}
+	// #nosec G304 -- active path is the operator-selected install dir (O_EXCL create)
+	f, err := os.OpenFile(active, os.O_CREATE|os.O_EXCL, 0o644)
+	if err != nil {
+		if os.IsExist(err) {
+			return nil
+		}
+		return fmt.Errorf("create %s: %w", active, err)
+	}
+	return f.Close()
+}
+
+func (r *runner) pruneDropped() error {
+	if len(r.prev) == 0 {
+		return nil
+	}
+	next := map[string]bool{}
+	for _, rel := range r.manifest {
+		next[rel] = true
+	}
+	keys := make([]string, 0, len(r.prev))
+	for rel := range r.prev {
+		keys = append(keys, rel)
+	}
+	sort.Strings(keys)
+	for _, rel := range keys {
+		if next[rel] || hostpack.PreserveOnPrune(rel) {
+			continue
+		}
+		dead := filepath.Join(r.target, filepath.FromSlash(rel))
+		if !exists(dead) {
+			continue
+		}
+		action := "prune"
+		if managedConflict(r.prev[rel], r.preflight[rel]) != "" && r.opts.Force {
+			action = "prune(force-customized)"
+		}
+		if r.opts.DryRun {
+			fmt.Fprintf(r.opts.Stdout, "  [%s] %s (dropped from pack)\n", action, rel)
+		} else {
+			if err := r.recheckPath(rel); err != nil {
+				return err
+			}
+			if merge, ok := hostpack.ManagedMergeForMarker(rel); ok {
+				if err := r.recheckPath(merge.TargetRel); err != nil {
+					return err
+				}
+				if merge.MarkerRel == hostpack.LegacyCodexHooksMerge.MarkerRel {
+					if err := stripHooksPath(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel))); err != nil {
+						return fmt.Errorf("strip hooks from %s: %w", merge.TargetRel, err)
+					}
+				} else if merge.TargetRel == hostpack.ClaudeSettingsMerge.TargetRel {
+					_ = r.stripClaudeSettings(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), true)
+				} else {
+					_ = stripMarkerPath(filepath.Join(r.target, filepath.FromSlash(merge.TargetRel)), merge.Begin, merge.End)
+				}
+			}
+			if err := os.Remove(dead); err != nil && !os.IsNotExist(err) {
+				return fmt.Errorf("remove %s: %w", rel, err)
+			}
+			pruneEmptyDirs(filepath.Dir(dead), r.target)
+			fmt.Fprintf(r.opts.Stdout, "  [%s] %s\n", action, rel)
+		}
+		r.stats.pruned++
+	}
+	return nil
+}
+
+func (r *runner) writeManifest() error {
+	sort.Strings(r.manifest)
+	r.manifest = slices.Compact(r.manifest)
+	var b strings.Builder
+	b.WriteString("# DevRites install manifest - do not edit by hand.\n")
+	b.WriteString("# Generated " + time.Now().UTC().Format(time.RFC3339) + ". Uninstall removes exactly these paths.\n")
+	b.WriteString("# devrites-version: " + installedVersion(r.source) + "\n")
+	b.WriteString("# devrites-flags: " + r.flagsString() + "\n")
+	b.WriteString("# managed-records: source=npx payload=pack/generated format=rel sha256\n")
+	for _, rel := range r.manifest {
+		if hash := r.records[rel]; hash != "" {
+			b.WriteString("# managed: " + rel + " " + hash + "\n")
+		}
+	}
+	for _, rel := range r.manifest {
+		b.WriteString(rel + "\n")
+	}
+	if err := r.recheckPath(ManifestName); err != nil {
+		return err
+	}
+	return fsutil.WriteFileAtomic(filepath.Join(r.target, ManifestName), []byte(b.String()), 0o644)
+}
+
+func (r *runner) flagsString() string {
+	var flags []string
+	if !r.opts.WithSkills {
+		flags = append(flags, "--no-skills")
+	}
+	if !r.opts.WithAgents {
+		flags = append(flags, "--no-agents")
+	}
+	if !r.opts.WithCodex {
+		flags = append(flags, "--no-codex")
+	}
+	if !r.opts.WithOmp {
+		flags = append(flags, "--no-omp")
+	}
+	if !r.opts.WithBinary {
+		flags = append(flags, "--no-binary")
+	}
+	if r.opts.AliasMode == "off" {
+		flags = append(flags, "--no-short-aliases")
+	}
+	if r.opts.AliasMode == "all" {
+		flags = append(flags, "--short-aliases=all")
+	}
+	return strings.Join(flags, " ")
+}