init and first puzzle

cmd/one/main.go

···
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"tangled.org/evan.jarrett.net/aoc2025/internal/puzzle"
+)
+
+type DayOne struct {
+	rotations []int
+}
+
+func (d *DayOne) ParseInput(input string) error {
+	for line := range strings.SplitSeq(strings.TrimSpace(input), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		line = strings.Replace(strings.Replace(line, "L", "-", 1), "R", "", 1)
+		n, err := strconv.Atoi(line)
+		if err != nil {
+			return fmt.Errorf("invalid rotation: %s, %w", line, err)
+		}
+		d.rotations = append(d.rotations, n)
+	}
+	return nil
+}
+
+func (d *DayOne) Part1() (int, error) {
+	position := 50
+	zeroCount := 0
+	fmt.Printf("The dial starts by pointing at %d.\n", position)
+
+	for _, rot := range d.rotations {
+		newPosition, _, err := Rotate(position, rot)
+		if err != nil {
+			return 0, err
+		}
+		fmt.Printf("The dial is rotated %d to point at %d.\n", rot, newPosition)
+		position = newPosition
+		if position == 0 {
+			zeroCount++
+		}
+	}
+
+	fmt.Printf("Final position: %d\n", position)
+	return zeroCount, nil
+}
+
+func (d *DayOne) Part2() (int, error) {
+	position := 50
+	zeroCount := 0
+	fmt.Printf("The dial starts by pointing at %d.\n", position)
+
+	for _, rot := range d.rotations {
+		newPosition, passes, err := Rotate(position, rot)
+		if err != nil {
+			return 0, err
+		}
+		fmt.Printf("The dial is rotated %d to point at %d.", rot, newPosition)
+		if passes > 0 {
+			if newPosition != 0 || passes > 2 {
+				fmt.Printf(" during this rotation, it points at 0 %d times.", passes)
+			}
+			zeroCount += passes
+		}
+		fmt.Println()
+		fmt.Printf("count is now: %d\n", zeroCount)
+		position = newPosition
+	}
+
+	fmt.Printf("Final position: %d\n", position)
+	return zeroCount, nil
+}
+
+func Rotate(position int, amount int) (newPosition int, zeroCount int, err error) {
+	if position < 0 || position > 99 {
+		return 0, 0, fmt.Errorf("position must be between 0 and 99, got %d", position)
+	}
+
+	end := position + amount
+	newPosition = ((end % 100) + 100) % 100
+
+	if amount < 0 && end <= 0 {
+		zeroCount = -end / 100
+		if position != 0 {
+			zeroCount++
+		}
+	} else if amount > 0 && end >= 100 {
+		zeroCount = end / 100
+	}
+
+	return newPosition, zeroCount, nil
+}
+
+func main() {
+	puzzle.Run(1, &DayOne{})
+}

cmd/one/main_test.go

···
+package main
+
+import (
+	"testing"
+)
+
+const testInput = `L68
+L30
+R48
+L5
+R60
+L55
+L1
+L99
+R14
+L82`
+
+func TestPart1(t *testing.T) {
+	d := &DayOne{}
+	if err := d.ParseInput(testInput); err != nil {
+		t.Fatalf("ParseInput failed: %v", err)
+	}
+
+	got, err := d.Part1()
+	if err != nil {
+		t.Fatalf("Part1 failed: %v", err)
+	}
+
+	want := 3
+	if got != want {
+		t.Errorf("Part1() = %d, want %d", got, want)
+	}
+}
+
+func TestPart2(t *testing.T) {
+	d := &DayOne{}
+	if err := d.ParseInput(testInput); err != nil {
+		t.Fatalf("ParseInput failed: %v", err)
+	}
+
+	got, err := d.Part2()
+	if err != nil {
+		t.Fatalf("Part2 failed: %v", err)
+	}
+
+	want := 6
+	if got != want {
+		t.Errorf("Part2() = %d, want %d", got, want)
+	}
+}
+
+func TestPart2LargeRotations(t *testing.T) {
+	tests := []struct {
+		input string
+		want  int
+	}{
+		{"R555", 6}, 
+		{"L432", 4},
+		{"L555", 6},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			d := &DayOne{}
+			if err := d.ParseInput(tt.input); err != nil {
+				t.Fatalf("ParseInput failed: %v", err)
+			}
+
+			got, err := d.Part2()
+			if err != nil {
+				t.Fatalf("Part2 failed: %v", err)
+			}
+
+			if got != tt.want {
+				t.Errorf("Part2(%s) = %d, want %d", tt.input, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestRotate(t *testing.T) {
+	tests := []struct {
+		name      string
+		position  int
+		amount    int
+		wantPos   int
+		wantCount int 
+	}{
+		// Starting at 0, no crossing
+		{"from 0, R50", 0, 50, 50, 0},
+		{"from 0, L50", 0, -50, 50, 0},
+		// Starting at 0, multiple rotations (end on 0, passed through once)
+		{"from 0, R200", 0, 200, 0, 2},  // pass 100, land 200
+		{"from 0, L200", 0, -200, 0, 2}, // pass -100, land -200
+		// Starting at 0, single rotation ending elsewhere
+		{"from 0, R150", 0, 150, 50, 1},  // pass 100
+		{"from 0, L150", 0, -150, 50, 1}, // pass -100
+		// Starting at 50, landing on 0
+		{"from 50, R50", 50, 50, 0, 1},  // land 100
+		{"from 50, L50", 50, -50, 0, 1}, // land 0
+		// Starting at 50, no crossing
+		{"from 50, R40", 50, 40, 90, 0},
+		{"from 50, L40", 50, -40, 10, 0},
+		// Starting at 50, large rotations (pass through multiple times)
+		{"from 50, R555", 50, 555, 5, 6},   // passes 100,200,300,400,500,600, lands on 5
+		{"from 50, L432", 50, -432, 18, 4}, // passes 0,-100,-200,-300, lands on 18
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotPos, gotCount, err := Rotate(tt.position, tt.amount)
+			if err != nil {
+				t.Fatalf("Rotate failed: %v", err)
+			}
+
+			if gotPos != tt.wantPos {
+				t.Errorf("Rotate(%d, %d) position = %d, want %d", tt.position, tt.amount, gotPos, tt.wantPos)
+			}
+			if gotCount != tt.wantCount {
+				t.Errorf("Rotate(%d, %d) count = %d, want %d", tt.position, tt.amount, gotCount, tt.wantCount)
+			}
+		})
+	}
+}

go.mod

···
+module tangled.org/evan.jarrett.net/aoc2025
+
+go 1.24.10

internal/input.go

···
+package internal
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+)
+
+// GetInput fetches the Advent of Code input for the specified day.
+// Requires AOC_SESSION environment variable to be set with your session cookie.
+func GetInput(day int) (string, error) {
+	session := os.Getenv("AOC_SESSION")
+	if session == "" {
+		return "", fmt.Errorf("AOC_SESSION environment variable not set")
+	}
+
+	url := fmt.Sprintf("https://adventofcode.com/2025/day/%d/input", day)
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.AddCookie(&http.Cookie{Name: "session", Value: session})
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("failed to fetch input: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	return string(body), nil
+}

internal/puzzle/puzzle.go

···
+package puzzle
+
+type Puzzle[T1 any, T2 any] interface {
+	ParseInput(input string) error
+	Part1() (T1, error)
+	Part2() (T2, error)
+}

internal/puzzle/runner.go

···
+package puzzle
+
+import (
+	"fmt"
+	"log"
+
+	"tangled.org/evan.jarrett.net/aoc2025/internal"
+)
+
+func Run[T1 any, T2 any](day int, p Puzzle[T1, T2]) {
+	input, err := internal.GetInput(day)
+	if err != nil {
+		log.Fatalf("Failed to get input: %v", err)
+	}
+
+	if err := p.ParseInput(input); err != nil {
+		log.Fatalf("Failed to parse input: %v", err)
+	}
+
+	result1, err := p.Part1()
+	if err != nil {
+		log.Fatalf("Failed to solve part 1: %v", err)
+	}
+	fmt.Printf("Part 1: %v\n", result1)
+
+	result2, err := p.Part2()
+	if err != nil {
+		log.Fatalf("Failed to solve part 2: %v", err)
+	}
+	fmt.Printf("Part 2: %v\n", result2)
+}

newday.sh

···
+#!/bin/bash
+
+set -e
+
+if [ -z "$1" ]; then
+    echo "Usage: $0 <day>"
+    echo "Example: $0 5"
+    exit 1
+fi
+
+DAY=$1
+
+if ! [[ "$DAY" =~ ^[0-9]+$ ]] || [ "$DAY" -lt 1 ] || [ "$DAY" -gt 12 ]; then
+    echo "Error: Day must be a number between 1 and 12"
+    exit 1
+fi
+
+declare -a WORDS=("" "one" "two" "three" "four" "five" "six" "seven" "eight" "nine" "ten"
+                  "eleven" "twelve")
+
+DAY_WORD=${WORDS[$DAY]}
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CMD_DIR="$SCRIPT_DIR/cmd/$DAY_WORD"
+
+# Capitalize first letter for struct name
+DAY_WORD_CAP="$(echo "${DAY_WORD:0:1}" | tr '[:lower:]' '[:upper:]')${DAY_WORD:1}"
+
+# Open browser to puzzle page
+URL="https://adventofcode.com/2025/day/$DAY"
+if command -v xdg-open &> /dev/null; then
+    xdg-open "$URL"
+elif command -v open &> /dev/null; then
+    open "$URL"
+elif command -v start &> /dev/null; then
+    start "$URL"
+else
+    echo "Could not detect browser opener. Please visit: $URL"
+fi
+
+# Create directory and main.go
+if [ -d "$CMD_DIR" ]; then
+    echo "Directory $CMD_DIR already exists"
+else
+    mkdir -p "$CMD_DIR"
+    cat > "$CMD_DIR/main.go" << EOF
+package main
+
+import (
+	"tangled.org/evan.jarrett.net/aoc2025/internal/puzzle"
+)
+
+type Day${DAY_WORD_CAP} struct {
+	// parsed input fields
+}
+
+func (d *Day${DAY_WORD_CAP}) ParseInput(input string) error {
+	// TODO: parse input
+	return nil
+}
+
+func (d *Day${DAY_WORD_CAP}) Part1() (int, error) {
+	// TODO: solve part 1
+	return 0, nil
+}
+
+func (d *Day${DAY_WORD_CAP}) Part2() (int, error) {
+	// TODO: solve part 2
+	return 0, nil
+}
+
+func main() {
+	puzzle.Run($DAY, &Day${DAY_WORD_CAP}{})
+}
+EOF
+    echo "Created $CMD_DIR/main.go"
+fi