feat(plan): split tree output into Tools / Privileged Tools / System sections (#244)

* feat(plan): split tree output into Tools / Privileged Tools / System sections

The combined "Dependency Graph:" tree made privileged Tools indistinguishable
from regular Tools in plan output, even though they route to a different bin
directory and only run under --system. Split it into three sections keyed by
ResourceInfo.Privileged + resource.IsSystemKind so the privilege/system
boundary is visible at a glance.

- graph.ResourceInfo gains a Privileged bool
- graph.PrintTreeFiltered renders a filtered subtree; PrintTree becomes a
  thin all-pass wrapper, so existing callers are byte-identical
- plan.buildResourceInfo populates Privileged from resource.IsPrivileged on
  the install, disabled, and removal paths so privileged removals also
  surface in the right section
- renderSectionedTree emits each section only if non-empty, with one blank
  line between adjacent sections; PrintLayers' leading \n still spaces it
  from "Execution Order:" — no double-blank
- both printTextPlan and planForResources (apply pre-confirm) use the
  helper so plan and apply show parallel output

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* test(graph): pin all-pass PrintTreeFiltered to a stable expected tree

The prior "all-pass filter equals PrintTree" assertion was tautological:
PrintTree now delegates to PrintTreeFiltered, so it compared the output
to itself and would not catch a future regression that broke both call
paths equally.

Replace with a literal snapshot string and assert that both PrintTree
and PrintTreeFiltered(all-pass) produce it byte-for-byte.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: terassyi

cmd/tomei/plan.go

@@ -186,9 +186,10 @@ func buildResourceInfo(resources []resource.Resource, updCfg engine.UpdateConfig
 		}
 
 		resInfo := graph.ResourceInfo{
-			Kind:   res.Kind(),
-			Name:   res.Name(),
-			Action: resource.ActionInstall, // default to install
+			Kind:       res.Kind(),
+			Name:       res.Name(),
+			Action:     resource.ActionInstall, // default to install
+			Privileged: resource.IsPrivileged(res),
 		}
 
 		// Get version from spec
@@ -278,10 +279,11 @@ func buildResourceInfo(resources []resource.Resource, updCfg engine.UpdateConfig
 					action = resource.ActionSkip
 				}
 				info[nodeID] = graph.ResourceInfo{
-					Kind:    resource.KindTool,
-					Name:    name,
-					Version: tool.Version,
-					Action:  action,
+					Kind:       resource.KindTool,
+					Name:       name,
+					Version:    tool.Version,
+					Action:     action,
+					Privileged: tool.Privileged,
 				}
 			}
 		}
@@ -328,10 +330,10 @@ func printTextPlan(cmd *cobra.Command, args []string, resources []resource.Resou
 	cmd.Printf("Planning changes for %v\n\n", args)
 	cmd.Printf("Found %d resource(s)\n\n", len(resources))
 
-	// Print dependency tree
-	cmd.Println("Dependency Graph:")
-	printer := graph.NewTreePrinter(cmd.OutOrStdout(), planCfg.noColor)
-	printer.PrintTree(result.resolver, result.resourceInfo)
+	// Print dependency tree, split into Tools / Privileged Tools / System sections
+	w := cmd.OutOrStdout()
+	printer := graph.NewTreePrinter(w, planCfg.noColor)
+	renderSectionedTree(printer, w, result)
 
 	// Print execution layers
 	printer.PrintLayers(result.filteredLayers, result.resourceInfo)
@@ -425,13 +427,69 @@ func planForResources(w io.Writer, resources []resource.Resource, disableColor b
 
 	fmt.Fprintf(w, "Found %d resource(s)\n\n", len(resources))
 	printer := graph.NewTreePrinter(w, disableColor)
-	printer.PrintTree(result.resolver, result.resourceInfo)
+	renderSectionedTree(printer, w, result)
 	printer.PrintLayers(result.filteredLayers, result.resourceInfo)
 	printer.PrintSummary(result.resourceInfo)
 
 	return hasChanges, nil
 }
 
+// renderSectionedTree prints the dependency tree split into three subsections
+// keyed by privilege/system-kind: regular Tools, Privileged Tools (require
+// --system), and System resources. Empty sections are skipped. A node present
+// in the resolver but absent from result.resourceInfo (e.g. builtin
+// Installers added by engine.AppendBuiltinInstallers) gets a zero-value
+// ResourceInfo and therefore routes to "Tools:".
+func renderSectionedTree(printer *graph.TreePrinter, w io.Writer, result *planResult) {
+	type section struct {
+		heading string
+		include func(graph.NodeID, graph.ResourceInfo) bool
+	}
+	sections := []section{
+		{"Tools:", func(_ graph.NodeID, info graph.ResourceInfo) bool {
+			return !info.Privileged && !resource.IsSystemKind(info.Kind)
+		}},
+		{"Privileged Tools (--system):", func(_ graph.NodeID, info graph.ResourceInfo) bool {
+			return info.Privileged
+		}},
+		{"System:", func(_ graph.NodeID, info graph.ResourceInfo) bool {
+			return resource.IsSystemKind(info.Kind)
+		}},
+	}
+
+	// Lift (NodeID, ResourceInfo) predicates to the NodeID-only form
+	// PrintTreeFiltered expects, looking the info up once per call.
+	lift := func(pred func(graph.NodeID, graph.ResourceInfo) bool) func(graph.NodeID) bool {
+		return func(id graph.NodeID) bool { return pred(id, result.resourceInfo[id]) }
+	}
+
+	// A section is non-empty if any resolver node passes its predicate.
+	// Walking resolver.GetNodes() (not just result.resourceInfo) ensures
+	// builtin Installers — which sit in the resolver but not in the info
+	// map — count toward the "Tools:" section.
+	nodes := result.resolver.GetNodes()
+	rendered := 0
+	for _, s := range sections {
+		include := lift(s.include)
+		empty := true
+		for _, n := range nodes {
+			if include(n.ID) {
+				empty = false
+				break
+			}
+		}
+		if empty {
+			continue
+		}
+		if rendered > 0 {
+			fmt.Fprintln(w)
+		}
+		fmt.Fprintln(w, s.heading)
+		printer.PrintTreeFiltered(result.resolver, result.resourceInfo, include)
+		rendered++
+	}
+}
+
 // addDisabledResourceInfo injects disabled resources into the resource info map.
 // Resources that already have an entry (e.g., ActionRemove for previously installed) are not overwritten.
 func addDisabledResourceInfo(info map[graph.NodeID]graph.ResourceInfo, disabled []resource.Resource) {
@@ -442,9 +500,10 @@ func addDisabledResourceInfo(info map[graph.NodeID]graph.ResourceInfo, disabled
 			continue
 		}
 		ri := graph.ResourceInfo{
-			Kind:   res.Kind(),
-			Name:   res.Name(),
-			Action: resource.ActionSkip,
+			Kind:       res.Kind(),
+			Name:       res.Name(),
+			Action:     resource.ActionSkip,
+			Privileged: resource.IsPrivileged(res),
 		}
 		if tool, ok := res.(*resource.Tool); ok && tool.ToolSpec != nil {
 			ri.Version = tool.ToolSpec.Version

cmd/tomei/plan_test.go

@@ -1,9 +1,11 @@
 package main
 
 import (
+	"bytes"
 	"encoding/json"
 	"os"
 	"path/filepath"
+	"strings"
 	"testing"
 	"time"
 
@@ -16,6 +18,26 @@ import (
 	"github.com/terassyi/tomei/internal/state"
 )
 
+// stubResolver is a minimal graph.Resolver for renderSectionedTree tests.
+type stubResolver struct {
+	nodes []*graph.Node
+	edges []graph.Edge
+}
+
+func (s *stubResolver) AddResource(resource.Resource) {}
+func (s *stubResolver) Resolve() ([]graph.Layer, error) {
+	return nil, nil
+}
+func (s *stubResolver) Validate() error         { return nil }
+func (s *stubResolver) NodeCount() int          { return len(s.nodes) }
+func (s *stubResolver) EdgeCount() int          { return len(s.edges) }
+func (s *stubResolver) GetEdges() []graph.Edge  { return s.edges }
+func (s *stubResolver) GetNodes() []*graph.Node { return s.nodes }
+
+func makeNode(kind resource.Kind, name string) *graph.Node {
+	return &graph.Node{ID: graph.NewNodeID(kind, name), Kind: kind, Name: name}
+}
+
 func TestCollectSkipInfos(t *testing.T) {
 	t.Parallel()
 
@@ -406,3 +428,134 @@ func TestAddSystemResourceInfo(t *testing.T) {
 			"reconciler emits ActionRemove; the skip-downgrade loop was removed in #198 so Remove must pass through")
 	})
 }
+
+func TestRenderSectionedTree(t *testing.T) {
+	t.Parallel()
+
+	// Common nodes used across cases.
+	nAqua := makeNode(resource.KindInstaller, "aqua")
+	nBat := makeNode(resource.KindTool, "bat")
+	nLazygit := makeNode(resource.KindTool, "lazygit")
+	nApt := makeNode(resource.KindSystemInstaller, "apt")
+	nPkgs := makeNode(resource.KindSystemPackageSet, "build-deps")
+
+	mixed := func() *planResult {
+		return &planResult{
+			resolver: &stubResolver{
+				nodes: []*graph.Node{nAqua, nBat, nLazygit, nApt, nPkgs},
+				edges: []graph.Edge{
+					{From: nBat.ID, To: nAqua.ID},
+					{From: nLazygit.ID, To: nAqua.ID},
+					{From: nPkgs.ID, To: nApt.ID},
+				},
+			},
+			resourceInfo: map[graph.NodeID]graph.ResourceInfo{
+				// Installer/aqua is intentionally NOT in resourceInfo to also
+				// exercise the "node in resolver but not in info map" path
+				// (builtin Installers added by AppendBuiltinInstallers). It must
+				// route to "Tools:" via the zero-value ResourceInfo.
+				nBat.ID:     {Kind: resource.KindTool, Name: "bat", Version: "0.24.0", Action: resource.ActionInstall},
+				nLazygit.ID: {Kind: resource.KindTool, Name: "lazygit", Version: "v0.62.1", Action: resource.ActionSkip, Privileged: true},
+				nApt.ID:     {Kind: resource.KindSystemInstaller, Name: "apt", Action: resource.ActionInstall},
+				nPkgs.ID:    {Kind: resource.KindSystemPackageSet, Name: "build-deps", Action: resource.ActionInstall},
+			},
+		}
+	}
+
+	t.Run("three sections appear in order with mixed manifest", func(t *testing.T) {
+		t.Parallel()
+		var buf bytes.Buffer
+		renderSectionedTree(graph.NewTreePrinter(&buf, true), &buf, mixed())
+		out := buf.String()
+		toolsIdx := strings.Index(out, "Tools:\n")
+		privIdx := strings.Index(out, "Privileged Tools (--system):\n")
+		sysIdx := strings.Index(out, "System:\n")
+		require.NotEqual(t, -1, toolsIdx)
+		require.NotEqual(t, -1, privIdx)
+		require.NotEqual(t, -1, sysIdx)
+		assert.Less(t, toolsIdx, privIdx)
+		assert.Less(t, privIdx, sysIdx)
+		// privileged Tool kept in its own section even with ActionSkip
+		assert.Contains(t, out, "Tool/lazygit (v0.62.1) [⊘ skip]")
+		// the builtin-Installer-style entry (no resourceInfo) is rendered
+		// under "Tools:" as the root with Tool/bat as its child.
+		assert.Contains(t, out, "Installer/aqua")
+		assert.Contains(t, out, "Tool/bat (0.24.0) [+ install]")
+	})
+
+	t.Run("blank line guard: exactly one blank between Privileged and System sections", func(t *testing.T) {
+		t.Parallel()
+		var buf bytes.Buffer
+		renderSectionedTree(graph.NewTreePrinter(&buf, true), &buf, mixed())
+		out := buf.String()
+		// "Privileged Tools (--system):" section ends with lazygit, then
+		// exactly one blank line, then "System:" heading.
+		assert.Contains(t, out, "Tool/lazygit (v0.62.1) [⊘ skip]\n\nSystem:\n")
+		// And NO double blank line (would indicate stray fmt.Fprintln).
+		assert.NotContains(t, out, "\n\n\nSystem:\n")
+	})
+
+	t.Run("no privileged → Privileged Tools section omitted", func(t *testing.T) {
+		t.Parallel()
+		r := &planResult{
+			resolver: &stubResolver{
+				nodes: []*graph.Node{nAqua, nBat, nApt, nPkgs},
+				edges: []graph.Edge{
+					{From: nBat.ID, To: nAqua.ID},
+					{From: nPkgs.ID, To: nApt.ID},
+				},
+			},
+			resourceInfo: map[graph.NodeID]graph.ResourceInfo{
+				nBat.ID:  {Kind: resource.KindTool, Name: "bat", Action: resource.ActionInstall},
+				nApt.ID:  {Kind: resource.KindSystemInstaller, Name: "apt", Action: resource.ActionInstall},
+				nPkgs.ID: {Kind: resource.KindSystemPackageSet, Name: "build-deps", Action: resource.ActionInstall},
+			},
+		}
+		var buf bytes.Buffer
+		renderSectionedTree(graph.NewTreePrinter(&buf, true), &buf, r)
+		out := buf.String()
+		assert.Contains(t, out, "Tools:\n")
+		assert.NotContains(t, out, "Privileged Tools")
+		assert.Contains(t, out, "System:\n")
+	})
+
+	t.Run("only privileged → only that section appears", func(t *testing.T) {
+		t.Parallel()
+		r := &planResult{
+			resolver: &stubResolver{
+				nodes: []*graph.Node{nLazygit},
+				edges: nil,
+			},
+			resourceInfo: map[graph.NodeID]graph.ResourceInfo{
+				nLazygit.ID: {Kind: resource.KindTool, Name: "lazygit", Action: resource.ActionInstall, Privileged: true},
+			},
+		}
+		var buf bytes.Buffer
+		renderSectionedTree(graph.NewTreePrinter(&buf, true), &buf, r)
+		out := buf.String()
+		assert.NotContains(t, out, "Tools:\n")
+		assert.NotContains(t, out, "System:\n")
+		assert.Contains(t, out, "Privileged Tools (--system):\n")
+		assert.Contains(t, out, "Tool/lazygit")
+	})
+
+	t.Run("privileged Tool removal entry lands under Privileged section", func(t *testing.T) {
+		t.Parallel()
+		// Simulates buildResourceInfo's removal-detection branch carrying
+		// Privileged through from ToolState. Without that propagation, this
+		// entry would render under "Tools:" instead.
+		nGone := makeNode(resource.KindTool, "gone-priv")
+		r := &planResult{
+			resolver: &stubResolver{nodes: []*graph.Node{nGone}},
+			resourceInfo: map[graph.NodeID]graph.ResourceInfo{
+				nGone.ID: {Kind: resource.KindTool, Name: "gone-priv", Version: "1.0.0", Action: resource.ActionRemove, Privileged: true},
+			},
+		}
+		var buf bytes.Buffer
+		renderSectionedTree(graph.NewTreePrinter(&buf, true), &buf, r)
+		out := buf.String()
+		assert.NotContains(t, out, "Tools:\n")
+		assert.Contains(t, out, "Privileged Tools (--system):\n")
+		assert.Contains(t, out, "Tool/gone-priv (1.0.0) [- remove]")
+	})
+}

internal/graph/tree.go

@@ -13,10 +13,11 @@ import (
 
 // ResourceInfo holds information about a resource for display.
 type ResourceInfo struct {
-	Kind    resource.Kind
-	Name    string
-	Version string
-	Action  resource.ActionType
+	Kind       resource.Kind
+	Name       string
+	Version    string
+	Action     resource.ActionType
+	Privileged bool
 }
 
 // TreePrinter prints dependency graphs as ASCII trees with colors.
@@ -65,35 +66,42 @@ func NewTreePrinter(w io.Writer, noColor bool) *TreePrinter {
 
 // PrintTree prints the dependency graph as an ASCII tree.
 func (p *TreePrinter) PrintTree(resolver Resolver, resourceInfo map[NodeID]ResourceInfo) {
+	p.PrintTreeFiltered(resolver, resourceInfo, func(NodeID) bool { return true })
+}
+
+// PrintTreeFiltered renders the dependency tree, including only nodes for
+// which includeNode returns true. A node whose passing parents are all
+// filtered out is promoted to a root, so removing an Installer parent
+// causes its (passing) children to surface as top-level entries.
+func (p *TreePrinter) PrintTreeFiltered(resolver Resolver, resourceInfo map[NodeID]ResourceInfo, includeNode func(NodeID) bool) {
 	edges := resolver.GetEdges()
 	nodes := resolver.GetNodes()
 
-	// Build adjacency list: node -> children (dependents)
-	// We want to show: parent depends on children, so we reverse the edge direction
 	children := make(map[NodeID][]NodeID)
-	hasParent := make(map[NodeID]bool)
+	passingParents := make(map[NodeID]int)
 
 	for _, edge := range edges {
-		// edge.From depends on edge.To
-		// In tree view: edge.To is parent, edge.From is child
+		if !includeNode(edge.From) || !includeNode(edge.To) {
+			continue
+		}
 		children[edge.To] = append(children[edge.To], edge.From)
-		hasParent[edge.From] = true
+		passingParents[edge.From]++
 	}
 
-	// Find root nodes (no dependencies)
 	var roots []NodeID
 	for _, node := range nodes {
-		if !hasParent[node.ID] {
+		if !includeNode(node.ID) {
+			continue
+		}
+		if passingParents[node.ID] == 0 {
 			roots = append(roots, node.ID)
 		}
 	}
 
-	// Sort roots for deterministic output
 	slices.SortFunc(roots, func(a, b NodeID) int {
 		return strings.Compare(string(a), string(b))
 	})
 
-	// Print each root tree
 	for _, root := range roots {
 		p.printNode(root, "", true, children, resourceInfo, true)
 	}