refactor(tower): reorganize package into feature, layout, and sink subpackages

Restructure pkg/render/tower/ for better separation of concerns:

- pkg/render/tower/feature/ - brittle detection, Nebraska ranking
- pkg/render/tower/layout/ - block positioning, width computation
- pkg/render/tower/sink/ - output formats (SVG, JSON, PDF, PNG)
- pkg/render/tower/styles/ - visual rendering (handdrawn, simple)
- pkg/render/tower/transform/ - layout transforms (merge, randomize)

This enables cleaner imports and makes it easier to add new output formats.

Author: matzehuels

pkg/render/tower/block.go

@@ -1,4 +1,4 @@
-package tower
+package feature
 
 import (
 	"time"
@@ -21,7 +21,7 @@ func IsBrittle(n *dag.Node) bool {
 		return true
 	}
 
-	lastCommit := parseDate(n.Meta["repo_last_commit"])
+	lastCommit := ParseDate(n.Meta["repo_last_commit"])
 	if lastCommit.IsZero() {
 		return false
 	}
@@ -34,12 +34,12 @@ func IsBrittle(n *dag.Node) bool {
 		return false
 	}
 
-	maintainers := countMaintainers(n.Meta["repo_maintainers"])
+	maintainers := CountMaintainers(n.Meta["repo_maintainers"])
 	stars, _ := n.Meta["repo_stars"].(int)
 	return maintainers == 1 || stars < lowStarCount || maintainers <= minMaintainerCount
 }
 
-func parseDate(v any) time.Time {
+func ParseDate(v any) time.Time {
 	s, ok := v.(string)
 	if !ok || s == "" {
 		return time.Time{}
@@ -48,7 +48,7 @@ func parseDate(v any) time.Time {
 	return t
 }
 
-func countMaintainers(v any) int {
+func CountMaintainers(v any) int {
 	switch v := v.(type) {
 	case []string:
 		return len(v)
@@ -57,3 +57,13 @@ func countMaintainers(v any) int {
 	}
 	return 0
 }
+
+func AsInt(v any) int {
+	switch v := v.(type) {
+	case int:
+		return v
+	case float64:
+		return int(v)
+	}
+	return 0
+}

pkg/render/tower/brittle.go pkg/render/tower/feature/brittle.gopkg/render/tower/brittle.go renamed to pkg/render/tower/feature/brittle.go

@@ -1,4 +1,4 @@
-package tower
+package feature
 
 import (
 	"testing"

pkg/render/tower/brittle_test.go pkg/render/tower/feature/brittle_test.gopkg/render/tower/brittle_test.go renamed to pkg/render/tower/feature/brittle_test.go

@@ -0,0 +1,191 @@
+package feature
+
+import (
+	"cmp"
+	"slices"
+
+	"github.com/matzehuels/stacktower/pkg/dag"
+)
+
+type Role string
+
+const (
+	RoleOwner      Role = "owner"
+	RoleLead       Role = "lead"
+	RoleMaintainer Role = "maintainer"
+)
+
+type PackageRole struct {
+	Package string
+	Role    Role
+	URL     string
+	Depth   int
+}
+
+type NebraskaRanking struct {
+	Maintainer string
+	Score      float64
+	Packages   []PackageRole
+}
+
+const (
+	ownerWeight      = 3.0
+	leadWeight       = 1.5
+	maintainerWeight = 1.0
+)
+
+func RankNebraska(g *dag.DAG, topN int) []NebraskaRanking {
+	scores := make(map[string]float64)
+	packages := make(map[string][]PackageRole)
+	bestRole := make(map[string]Role)
+	minRow := findMinRow(g)
+
+	for _, n := range g.Nodes() {
+		if n.IsSynthetic() || g.InDegree(n.ID) == 0 {
+			continue
+		}
+
+		roles := getMaintainerRoles(n)
+		if len(roles) == 0 {
+			continue
+		}
+
+		depth := n.Row - minRow
+		share := float64(depth) / float64(len(roles))
+
+		for maintainer, role := range roles {
+			scores[maintainer] += share * roleWeight(role)
+
+			if !hasPackage(packages[maintainer], n.ID) {
+				url, _ := n.Meta["repo_url"].(string)
+				packages[maintainer] = append(packages[maintainer], PackageRole{
+					Package: n.ID,
+					Role:    role,
+					URL:     url,
+					Depth:   depth,
+				})
+			}
+
+			if roleRank(role) < roleRank(bestRole[maintainer]) {
+				bestRole[maintainer] = role
+			}
+		}
+	}
+
+	rankings := make([]NebraskaRanking, 0, len(scores))
+	for m, score := range scores {
+		pkgs := packages[m]
+		slices.SortFunc(pkgs, func(a, b PackageRole) int {
+			if c := cmp.Compare(roleRank(a.Role), roleRank(b.Role)); c != 0 {
+				return c
+			}
+			if c := cmp.Compare(b.Depth, a.Depth); c != 0 {
+				return c
+			}
+			return cmp.Compare(a.Package, b.Package)
+		})
+		rankings = append(rankings, NebraskaRanking{
+			Maintainer: m,
+			Score:      score,
+			Packages:   pkgs,
+		})
+	}
+
+	slices.SortFunc(rankings, func(a, b NebraskaRanking) int {
+		if c := cmp.Compare(b.Score, a.Score); c != 0 {
+			return c
+		}
+		if c := cmp.Compare(roleRank(bestRole[a.Maintainer]), roleRank(bestRole[b.Maintainer])); c != 0 {
+			return c
+		}
+		return cmp.Compare(a.Maintainer, b.Maintainer)
+	})
+
+	if len(rankings) > topN {
+		return rankings[:topN]
+	}
+	return rankings
+}
+
+func roleRank(r Role) int {
+	switch r {
+	case RoleOwner:
+		return 0
+	case RoleLead:
+		return 1
+	case RoleMaintainer:
+		return 2
+	default:
+		return 3
+	}
+}
+
+func roleWeight(r Role) float64 {
+	switch r {
+	case RoleOwner:
+		return ownerWeight
+	case RoleLead:
+		return leadWeight
+	default:
+		return maintainerWeight
+	}
+}
+
+func findMinRow(g *dag.DAG) int {
+	minRow := -1
+	for _, n := range g.Nodes() {
+		if !n.IsSynthetic() && (minRow < 0 || n.Row < minRow) {
+			minRow = n.Row
+		}
+	}
+	return max(0, minRow)
+}
+
+func getMaintainerRoles(n *dag.Node) map[string]Role {
+	if n.Meta == nil {
+		return nil
+	}
+
+	owner, _ := n.Meta["repo_owner"].(string)
+	maintainers := getStringSlice(n.Meta["repo_maintainers"])
+
+	if len(maintainers) == 0 && owner != "" {
+		return map[string]Role{owner: RoleOwner}
+	}
+
+	roles := make(map[string]Role, len(maintainers))
+	leadAssigned := false
+
+	for _, m := range maintainers {
+		switch {
+		case m == owner:
+			roles[m] = RoleOwner
+		case !leadAssigned:
+			roles[m] = RoleLead
+			leadAssigned = true
+		default:
+			roles[m] = RoleMaintainer
+		}
+	}
+	return roles
+}
+
+func getStringSlice(v any) []string {
+	switch v := v.(type) {
+	case []string:
+		return v
+	case []any:
+		out := make([]string, 0, len(v))
+		for _, item := range v {
+			if s, ok := item.(string); ok {
+				out = append(out, s)
+			}
+		}
+		return out
+	}
+	return nil
+}
+
+func hasPackage(pkgs []PackageRole, id string) bool {
+	return slices.ContainsFunc(pkgs, func(p PackageRole) bool { return p.Package == id })
+}

pkg/render/tower/feature/nebraska.go

@@ -1,4 +1,4 @@
-package tower
+package feature
 
 import (
 	"testing"

pkg/render/tower/nebraska_test.go pkg/render/tower/feature/nebraska_test.gopkg/render/tower/nebraska_test.go renamed to pkg/render/tower/feature/nebraska_test.go

@@ -0,0 +1,12 @@
+package layout
+
+type Block struct {
+	NodeID      string
+	Left, Right float64
+	Bottom, Top float64
+}
+
+func (b Block) Width() float64   { return b.Right - b.Left }
+func (b Block) Height() float64  { return b.Top - b.Bottom }
+func (b Block) CenterX() float64 { return (b.Left + b.Right) / 2 }
+func (b Block) CenterY() float64 { return (b.Bottom + b.Top) / 2 }

pkg/render/tower/json.go

@@ -1,4 +1,4 @@
-package tower
+package layout
 
 import (
 	"slices"
@@ -13,12 +13,12 @@ const (
 )
 
 type Layout struct {
-	FrameWidth  float64          `json:"width"`
-	FrameHeight float64          `json:"height"`
-	Blocks      map[string]Block `json:"blocks"`
-	RowOrders   map[int][]string `json:"rows,omitempty"`
-	MarginX     float64          `json:"margin_x"`
-	MarginY     float64          `json:"margin_y"`
+	FrameWidth  float64
+	FrameHeight float64
+	Blocks      map[string]Block
+	RowOrders   map[int][]string
+	MarginX     float64
+	MarginY     float64
 }
 
 type Option func(*config)

pkg/render/tower/layout/block.go

@@ -1,4 +1,4 @@
-package tower
+package layout
 
 import (
 	"math"

pkg/render/tower/layout.go pkg/render/tower/layout/layout.gopkg/render/tower/layout.go renamed to pkg/render/tower/layout/layout.go

@@ -1,4 +1,4 @@
-package tower
+package layout
 
 import (
 	"math"
@@ -68,22 +68,19 @@ func ComputeWidthsBottomUp(g *dag.DAG, orders map[int][]string, frameWidth float
 	widths := make(map[string]float64, g.NodeCount())
 	maxRow := rows[len(rows)-1]
 
-	// Start from bottom: sinks get equal width
 	if bottomRow := orders[maxRow]; len(bottomRow) > 0 {
 		unit := frameWidth / float64(len(bottomRow))
 		for _, id := range bottomRow {
 			widths[id] = unit
 		}
 	}
 
-	// Propagate upward: parent width = sum of children's contributions
 	for r := maxRow - 1; r >= 0; r-- {
 		currRow := orders[r]
 		if len(currRow) == 0 {
 			continue
 		}
 
-		// Each parent gets width from its children
 		for _, id := range currRow {
 			widths[id] = 0.0
 		}
@@ -93,8 +90,6 @@ func ComputeWidthsBottomUp(g *dag.DAG, orders map[int][]string, frameWidth float
 			if len(kids) == 0 {
 				continue
 			}
-			// Parent gets the sum of its share from each child
-			// Each child divides its width among its parents
 			for _, kid := range kids {
 				parents := g.ParentsInRow(kid, r)
 				if len(parents) > 0 {
@@ -103,7 +98,6 @@ func ComputeWidthsBottomUp(g *dag.DAG, orders map[int][]string, frameWidth float
 			}
 		}
 
-		// Normalize row to fill frame width
 		var sum float64
 		for _, id := range currRow {
 			sum += widths[id]