@tanagram/cli 0.1.25 → 0.1.26

package/tui/renderer.go

@@ -0,0 +1,359 @@
+package tui
+
+import (
+	"encoding/json"
+	"math"
+	"os"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+// TanagramRenderer handles rendering tangram pieces to an ASCII canvas
+type TanagramRenderer struct {
+	width  int
+	height int
+}
+
+// NewTanagramRenderer creates a new renderer with the given dimensions
+func NewTanagramRenderer(width, height int) *TanagramRenderer {
+	return &TanagramRenderer{
+		width:  width,
+		height: height,
+	}
+}
+
+// RenderPiecesToCanvas renders a slice of pieces to an ASCII canvas
+func (r *TanagramRenderer) RenderPiecesToCanvas(pieces []TangramPiece) [][]int {
+	canvas := make([][]int, r.height)
+	for i := range canvas {
+		canvas[i] = make([]int, r.width)
+	}
+
+	// Render each piece
+	for idx, piece := range pieces {
+		r.renderPieceToCanvas(&canvas, piece, idx)
+	}
+
+	return canvas
+}
+
+// renderPieceToCanvas renders a single piece to the canvas
+func (r *TanagramRenderer) renderPieceToCanvas(canvas *[][]int, piece TangramPiece, pieceIndex int) {
+	points := r.getPiecePoints(piece)
+
+	for _, point := range points {
+		x := piece.Position.X + point.X
+		y := piece.Position.Y + point.Y
+
+		if y >= 0 && y < len(*canvas) && x >= 0 && x < len((*canvas)[0]) {
+			(*canvas)[y][x] = pieceIndex + 1
+		}
+	}
+}
+
+// getPiecePoints generates all points for a piece (handles rotation, flip, aspect ratio)
+func (r *TanagramRenderer) getPiecePoints(piece TangramPiece) []Position {
+	var basePoints []Position
+
+	// Generate pieces in "true" square proportions
+	switch piece.Type {
+	case SmallTriangle:
+		height := 8
+		for y := 0; y < height; y++ {
+			for x := 0; x <= height-1-y; x++ {
+				basePoints = append(basePoints, Position{x, y})
+			}
+		}
+	case MediumTriangle:
+		height := 10
+		for y := 0; y < height; y++ {
+			for x := 0; x <= height-1-y; x++ {
+				basePoints = append(basePoints, Position{x, y})
+			}
+		}
+	case LargeTriangle:
+		height := 14
+		for y := 0; y < height; y++ {
+			for x := 0; x <= height-1-y; x++ {
+				basePoints = append(basePoints, Position{x, y})
+			}
+		}
+	case Square:
+		size := 9
+		for y := 0; y < size; y++ {
+			for x := 0; x < size; x++ {
+				basePoints = append(basePoints, Position{x, y})
+			}
+		}
+	case Parallelogram:
+		height := 5
+		baseLength := 11
+		for y := 0; y < height; y++ {
+			offset := height - 1 - y
+			for x := 0; x < baseLength; x++ {
+				basePoints = append(basePoints, Position{x + offset, y})
+			}
+		}
+	}
+
+	// Apply rotation
+	rotatedPoints := r.rotatePoints(basePoints, piece.Rotation)
+
+	// Fill gaps
+	rotatedPoints = r.fillShape(rotatedPoints)
+
+	// Apply flip
+	if piece.Flipped {
+		rotatedPoints = r.flipPoints(rotatedPoints)
+	}
+
+	// Apply aspect ratio correction
+	aspectCorrectedPoints := make([]Position, 0, len(rotatedPoints)*2)
+	for _, p := range rotatedPoints {
+		aspectCorrectedPoints = append(aspectCorrectedPoints, Position{p.X * 2, p.Y})
+		aspectCorrectedPoints = append(aspectCorrectedPoints, Position{p.X*2 + 1, p.Y})
+	}
+
+	return aspectCorrectedPoints
+}
+
+// rotatePoints rotates points by the given angle
+func (r *TanagramRenderer) rotatePoints(points []Position, angle int) []Position {
+	if angle == 0 {
+		return points
+	}
+
+	var rotated []Position
+	rad := float64(angle) * math.Pi / 180.0
+	cos := math.Cos(rad)
+	sin := math.Sin(rad)
+
+	var sumX, sumY int
+	for _, p := range points {
+		sumX += p.X
+		sumY += p.Y
+	}
+	centerX := float64(sumX) / float64(len(points))
+	centerY := float64(sumY) / float64(len(points))
+
+	for _, p := range points {
+		x := float64(p.X) - centerX
+		y := float64(p.Y) - centerY
+
+		newX := x*cos - y*sin
+		newY := x*sin + y*cos
+
+		rotated = append(rotated, Position{
+			X: int(math.Round(newX + centerX)),
+			Y: int(math.Round(newY + centerY)),
+		})
+	}
+
+	// Normalize to positive coordinates
+	minX, minY := rotated[0].X, rotated[0].Y
+	for _, p := range rotated {
+		if p.X < minX {
+			minX = p.X
+		}
+		if p.Y < minY {
+			minY = p.Y
+		}
+	}
+
+	for i := range rotated {
+		rotated[i].X -= minX
+		rotated[i].Y -= minY
+	}
+
+	return rotated
+}
+
+// fillShape fills gaps in rotated shapes
+func (r *TanagramRenderer) fillShape(points []Position) []Position {
+	if len(points) == 0 {
+		return points
+	}
+
+	minX, maxX := points[0].X, points[0].X
+	minY, maxY := points[0].Y, points[0].Y
+	for _, p := range points {
+		if p.X < minX {
+			minX = p.X
+		}
+		if p.X > maxX {
+			maxX = p.X
+		}
+		if p.Y < minY {
+			minY = p.Y
+		}
+		if p.Y > maxY {
+			maxY = p.Y
+		}
+	}
+
+	filledMap := make(map[Position]bool)
+
+	// Fill horizontally
+	for y := minY; y <= maxY; y++ {
+		var xCoords []int
+		for _, p := range points {
+			if p.Y == y {
+				xCoords = append(xCoords, p.X)
+			}
+		}
+		if len(xCoords) == 0 {
+			continue
+		}
+		rowMinX, rowMaxX := xCoords[0], xCoords[0]
+		for _, x := range xCoords {
+			if x < rowMinX {
+				rowMinX = x
+			}
+			if x > rowMaxX {
+				rowMaxX = x
+			}
+		}
+		for x := rowMinX; x <= rowMaxX; x++ {
+			filledMap[Position{x, y}] = true
+		}
+	}
+
+	// Fill vertically
+	for x := minX; x <= maxX; x++ {
+		var yCoords []int
+		for p := range filledMap {
+			if p.X == x {
+				yCoords = append(yCoords, p.Y)
+			}
+		}
+		if len(yCoords) == 0 {
+			continue
+		}
+		colMinY, colMaxY := yCoords[0], yCoords[0]
+		for _, y := range yCoords {
+			if y < colMinY {
+				colMinY = y
+			}
+			if y > colMaxY {
+				colMaxY = y
+			}
+		}
+		for y := colMinY; y <= colMaxY; y++ {
+			filledMap[Position{x, y}] = true
+		}
+	}
+
+	filledPoints := make([]Position, 0, len(filledMap))
+	for p := range filledMap {
+		filledPoints = append(filledPoints, p)
+	}
+
+	return filledPoints
+}
+
+// flipPoints flips points horizontally
+func (r *TanagramRenderer) flipPoints(points []Position) []Position {
+	if len(points) == 0 {
+		return points
+	}
+
+	maxX := points[0].X
+	for _, p := range points {
+		if p.X > maxX {
+			maxX = p.X
+		}
+	}
+
+	var flipped []Position
+	for _, p := range points {
+		flipped = append(flipped, Position{
+			X: maxX - p.X,
+			Y: p.Y,
+		})
+	}
+
+	return flipped
+}
+
+// CanvasToString converts a canvas to a styled string
+func (r *TanagramRenderer) CanvasToString(canvas [][]int, pieces []TangramPiece) string {
+	var lines []string
+	for y, row := range canvas {
+		var line string
+		for x := range row {
+			char, color := r.getCellDisplay(canvas, x, y, pieces)
+			if color != "" {
+				style := lipgloss.NewStyle().Foreground(color)
+				line += style.Render(string(char))
+			} else {
+				line += string(char)
+			}
+		}
+		lines = append(lines, line)
+	}
+	return lipgloss.JoinVertical(lipgloss.Left, lines...)
+}
+
+// getCellDisplay returns the character and color for a cell
+func (r *TanagramRenderer) getCellDisplay(canvas [][]int, x, y int, pieces []TangramPiece) (rune, lipgloss.Color) {
+	pieceID := canvas[y][x]
+
+	if pieceID == 0 {
+		return ' ', ""
+	}
+
+	pieceIndex := pieceID - 1
+	if pieceIndex >= len(pieces) {
+		return ' ', ""
+	}
+
+	piece := pieces[pieceIndex]
+	return '█', piece.Color
+}
+
+// LoadTanagramConfig loads a tangram configuration from a JSON file
+func LoadTanagramConfig(filename string) ([]TangramPiece, error) {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	type SavedPiece struct {
+		ID       int      `json:"id"`
+		Type     string   `json:"type"`
+		Position Position `json:"position"`
+		Rotation int      `json:"rotation"`
+		Flipped  bool     `json:"flipped"`
+	}
+
+	var savedPieces []SavedPiece
+	err = json.Unmarshal(data, &savedPieces)
+	if err != nil {
+		return nil, err
+	}
+
+	// Color mapping for each piece ID
+	colors := map[int]lipgloss.Color{
+		1: "#BA68C8", // Purple
+		2: "#FFB74D", // Orange
+		3: "#42A5F5", // Blue
+		4: "#EF4444", // Red
+		5: "#FF9800", // Orange
+		6: "#7E57C2", // Purple
+		7: "#66BB6A", // Green
+	}
+
+	var pieces []TangramPiece
+	for _, saved := range savedPieces {
+		pieces = append(pieces, TangramPiece{
+			ID:       saved.ID,
+			Type:     PieceType(saved.Type),
+			Color:    colors[saved.ID],
+			Position: saved.Position,
+			Rotation: saved.Rotation,
+			Flipped:  saved.Flipped,
+		})
+	}
+
+	return pieces, nil
+}

package/tui/welcome.go

@@ -0,0 +1,186 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+// MenuChoice represents the user's selection
+type MenuChoice int
+
+const (
+	ChoiceNone MenuChoice = iota
+	ChoiceImportPolicies
+	ChoiceLocalMode
+)
+
+// WelcomeModel is the Bubble Tea model for the welcome screen
+type WelcomeModel struct {
+	selectedIndex int
+	choice        MenuChoice
+	width         int
+	height        int
+}
+
+// NewWelcomeModel creates a new welcome screen model
+func NewWelcomeModel() WelcomeModel {
+	return WelcomeModel{
+		selectedIndex: 0,
+		choice:        ChoiceNone,
+	}
+}
+
+// Init initializes the model
+func (m WelcomeModel) Init() tea.Cmd {
+	return nil
+}
+
+// Update handles messages
+func (m WelcomeModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "ctrl+c", "q", "esc":
+			return m, tea.Quit
+		case "up", "k":
+			if m.selectedIndex > 0 {
+				m.selectedIndex--
+			}
+		case "down", "j":
+			if m.selectedIndex < 1 {
+				m.selectedIndex++
+			}
+		case "enter", " ":
+			if m.selectedIndex == 0 {
+				m.choice = ChoiceImportPolicies
+			} else {
+				m.choice = ChoiceLocalMode
+			}
+			return m, tea.Quit
+		}
+	case tea.WindowSizeMsg:
+		m.width = msg.Width
+		m.height = msg.Height
+	}
+	return m, nil
+}
+
+// View renders the UI
+func (m WelcomeModel) View() string {
+	// Load and render the tangram logo from config
+	var logo string
+
+	pieces, err := LoadTanagramConfig("tanagram-config.json")
+	if err == nil && len(pieces) > 0 {
+		// Render using the shared renderer
+		renderer := NewTanagramRenderer(90, 45)
+		canvas := renderer.RenderPiecesToCanvas(pieces)
+		logo = renderer.CanvasToString(canvas, pieces)
+	} else {
+		// Fallback to simple text if config not found
+		logo = "TANAGRAM"
+	}
+
+	// Title style
+	titleStyle := lipgloss.NewStyle().
+		Bold(true).
+		Foreground(lipgloss.Color("#FFFFFF")).
+		MarginTop(2).
+		MarginBottom(1).
+		Align(lipgloss.Center)
+
+	title := titleStyle.Render("TANAGRAM")
+
+	// Subtitle style
+	subtitleStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#888888")).
+		Italic(true).
+		MarginBottom(2).
+		Align(lipgloss.Center)
+
+	subtitle := subtitleStyle.Render("Policy enforcement for git changes")
+
+	// Menu styles
+	selectedStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#FFFFFF")).
+		Background(lipgloss.Color("#8B5CF6")).
+		Bold(true).
+		Padding(0, 2)
+
+	normalStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#AAAAAA")).
+		Padding(0, 2)
+
+	// Menu options
+	options := []string{
+		"Import policies from Tanagram",
+		"Continue with local (no sign in)",
+	}
+
+	var menuItems []string
+	for i, opt := range options {
+		if i == m.selectedIndex {
+			menuItems = append(menuItems, "  "+selectedStyle.Render("→ "+opt))
+		} else {
+			menuItems = append(menuItems, "  "+normalStyle.Render("  "+opt))
+		}
+	}
+
+	menu := strings.Join(menuItems, "\n")
+
+	// Help text
+	helpStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#666666")).
+		Italic(true).
+		MarginTop(2).
+		Align(lipgloss.Center)
+
+	help := helpStyle.Render("↑/↓ or j/k to navigate • enter/space to select • q/esc to quit")
+
+	// Combine all parts
+	content := lipgloss.JoinVertical(lipgloss.Center,
+		"",
+		logo,
+		"",
+		title,
+		subtitle,
+		"",
+		menu,
+		"",
+		help,
+		"",
+	)
+
+	// Center horizontally and vertically
+	containerStyle := lipgloss.NewStyle().
+		Width(m.width).
+		Height(m.height).
+		Align(lipgloss.Center, lipgloss.Center)
+
+	return containerStyle.Render(content)
+}
+
+// GetChoice returns the user's menu selection
+func (m WelcomeModel) GetChoice() MenuChoice {
+	return m.choice
+}
+
+// RunWelcomeScreen displays the welcome screen and returns the user's choice
+func RunWelcomeScreen() (MenuChoice, error) {
+	model := NewWelcomeModel()
+	p := tea.NewProgram(model, tea.WithAltScreen())
+
+	finalModel, err := p.Run()
+	if err != nil {
+		return ChoiceNone, fmt.Errorf("error running welcome screen: %w", err)
+	}
+
+	if m, ok := finalModel.(WelcomeModel); ok {
+		return m.GetChoice(), nil
+	}
+
+	return ChoiceNone, fmt.Errorf("unexpected model type")
+}