refactor by simplying interface

Signed-off-by: Rodolfo Sanchez <me@dolfo.codes>

Author: dolfolife

README.md

@@ -3,111 +3,106 @@
 [![Go Reference](https://pkg.go.dev/badge/github.com/dolfolife/aoctl#section-readme.svg)](https://pkg.go.dev/github.com/dolfolife/aoctl#section-readme)
 [![codecov](https://codecov.io/github/dolfolife/aoctl/graph/badge.svg?token=GTFZX1J2WX)](https://codecov.io/github/dolfolife/aoctl)
 
-This is a personal project for myself to learn more about writing CLI tools in GoLang. The idea behind this project is to help me solve the [Advent of Code](adventofcode.com/) since I have noticed some patterns while solving them.
+A simple CLI tool to organize and solve [Advent of Code](https://adventofcode.com/) problems. It handles downloading inputs, generating boilerplate code, and running your solutions, so you can focus on the logic.
 
-> Disclaimer: This is yet another CLI that solves a common problem and there are probably `n` solutions out there. My motivation is not only to provide a CLI but to learn how to write, develop, release, and test them.
+## Features
 
-I hope you enjoy it and feel free to help me understand the best practices of writing CLI tools or GoLang packages by writing an issue or using the [CONTRIBUTING.md](./CONTRIBUTING.md) to contribute. PRs are welcome.
+- **Project Initialization**: Sets up a clean workspace for your AoC solutions.
+- **Synchronization**: Downloads puzzle descriptions (README.md) and inputs for all available days.
+- **Code Generation**: Generates simple Go boilerplate for each day.
+- **Zero Friction**: No complex interfaces to implement. Just write `Part1` and `Part2` functions.
 
-## Advent Of Code Series
+## Installation
 
-Advent of Code is a website made by Eric Wastl. I recommend watching [Advent of Code: Behind the Scenes](https://www.youtube.com/watch?v=CFWuwNDOnIo&ab_channel=CodingTech).
-
-## The Why
-
-Advent of Code application only cares about your solution, but there is no way to link your code and the problem at hand. The main idea of this tool is to give you a link between the application of [adventofcode.com](https://adventofcode.com/) and your working space. 
-
-## Alternatives
-
-I found [Advent Of Code Go](https://github.com/alexchao26/advent-of-code-go) and it inspired me to build my own tool and learn more GoLang.
-
-# AoC CLI Documentation
-
-## Pre-requisite
-
-You need your session ID from the Advent of Code website. I opened an issue for this: [Session ID is a manual process issue](https://github.com/dolfolife/aoctl/issues/1).
-
-## Puzzles
-
-The Advent of Code puzzles have two parts. Each part has a single string input and a single output.
+```bash
+go install github.com/dolfolife/aoctl@latest
+```
 
-By that, we have to create an interface that allows us to run each solution against the input and submit the solution to the server of Advent of Code.
+## Usage
 
-## Commands
+### 1. Initialize Project
 
-### Init
-Initialize the aoc project in your local machine.
+Start by creating a new directory for your Advent of Code solutions and initializing it:
 
 ```bash
-aoc init <path> 
+mkdir my-aoc-solutions
+cd my-aoc-solutions
+aoctl init .
 ```
 
-### Version
-Print current version of the cli
+### 2. Configure Session
+
+To download inputs, you need to provide your Advent of Code session cookie. You can find this in your browser's developer tools (Application -> Cookies) when logged into adventofcode.com.
 
 ```bash
-aoc version
+aoctl session --session <your-session-cookie>
 ```
 
-#### Options
-
-```
---path -p  Path to initialize the project
-```
+### 3. Synchronize Puzzles
 
-### Puzzle
-Get The puzzle information with the option to save it locally in the repository.
+Download the puzzles and generate the boilerplate code for the current year (or previous years).
 
 ```bash
-aoc puzzles [OPTIONS]
+aoctl synchronize
 ```
 
-#### Options
+This will create a directory structure like this:
 
 ```
--s --session (required) Advent of Code Session. You can get this in the Cookies of the website. 
+events/
+  2024/
+    01/
+      README.md          # The puzzle description
+      input/
+        input.txt        # The puzzle input
+      main.go            # Entry point to run your solution
+      solution.go        # Where you write your code
+      solution_test.go   # Tests for your solution
 ```
 
-```
--d --day (required) Day of the puzzle you want to get.
-```
+### 4. Solve the Puzzle
 
-```
--y --year (required) Year of the puzzle you want to get.
-```
+Open `events/2024/01/solution.go` and implement `Part1` and `Part2`.
 
-```
---sync (optional) To save the puzzle locally at `<year>/<day>/puzzle.md
+```go
+package main
+
+func Part1(input string) (string, error) {
+    // Your logic here
+    return "answer", nil
+}
+
+func Part2(input string) (string, error) {
+    // Your logic here
+    return "answer", nil
+}
 ```
 
-### test
-Locally test your answers. This relies that each `<year>/<day>` solution has its own tests.
+### 5. Run and Test
 
-> not yet implemented
+Run your solution:
 
 ```bash
-aoc test [OPTIONS]
+cd events/2024/01
+go run .
 ```
 
-### submit
-Submit your answer to the Advent of Code.
-
-> not yet implemented
+Run tests:
 
 ```bash
-aoc submit [OPTIONS]
+go test .
 ```
 
-#### Options
+## Helper Functions
 
-```
--s --session (required) Advent of Code Session. You can get this in the Cookies of the website. 
-```
+The `pkg/puzzle` package provides a simple helper to read the input file:
 
-```
--d --day (required) Day of the puzzle you want to get.
-```
+```go
+import "github.com/dolfolife/aoctl/pkg/puzzle"
 
+input, err := puzzle.ReadInput("input/input.txt")
 ```
--y --year (required) Year of the puzzle you want to get.
-```
+
+## Contributing
+
+PRs are welcome! Please check [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.

examples/golang/2016/go.mod

@@ -1,6 +1,6 @@
 module github.com/dolfolife/aoctl/examples/golang/2016
 
-go 1.21
+go 1.24.0
 
 require (
 	github.com/dolfolife/aoctl v0.0.0-20230829133931-d2eb61e5a257
@@ -9,8 +9,9 @@ require (
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/joho/godotenv v1.5.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/net v0.13.0 // indirect
+	golang.org/x/net v0.47.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
 

examples/golang/2016/go.sum

@@ -1,11 +1,13 @@
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-golang.org/x/net v0.13.0 h1:Nvo8UFsZ8X3BhAC9699Z1j7XQ3rsZnUUm7jfBEk1ueY=
-golang.org/x/net v0.13.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
+golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
+golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

examples/golang/2022/01/input.txt examples/golang/2022/01/input/input.txtexamples/golang/2022/01/input.txt renamed to examples/golang/2022/01/input/input.txt

@@ -2,92 +2,26 @@ package main
 
 import (
 	"fmt"
-	"strconv"
-	"strings"
-    "io/ioutil"
-    "os"
-    "path"
-    "path/filepath"
-)
-
-func gmap[T any, M any](data []T, f func(T) (M, error)) ([]M, error) {
-
-	mapped := make([]M, len(data))
-
-	for i, e := range data {
-		v, err := f(e)
-		if err != nil {
-			return nil, err
-		}
-		mapped[i] = v
-	}
-
-	return mapped, nil
-}
+	"log"
 
-func fromBagToCalories(bag string) (int, error) {
-	bc, err := gmap(strings.Split(bag, "\n"), strconv.Atoi)
+	"github.com/dolfolife/aoctl/pkg/puzzle"
+)
 
+func main() {
+	input, err := puzzle.ReadInput("input/input.txt")
 	if err != nil {
-		return 0, err
+		log.Fatal(err)
 	}
 
-	s := 0
-
-	for _, a := range bc {
-		s = s + a
-	}
-
-	return s, nil
-}
-
-func part1(bags []int) int {
-
-	maxb := 0
-	for i := 0; i < len(bags); i++ {
-		if maxb < bags[i] {
-			maxb = bags[i]
-		}
-	}
-
-	return maxb
-}
-
-func part2(bags []int) int {
-
-	maxb1, maxb2, maxb3 := 0, 0, 0
-	for i := 0; i < len(bags); i++ {
-		if bags[i] > maxb1 {
-			maxb3 = maxb2
-			maxb2 = maxb1
-			maxb1 = bags[i]
-		} else if bags[i] > maxb2 {
-			maxb3 = maxb2
-			maxb2 = bags[i]
-		} else if bags[i] > maxb3 {
-			maxb3 = bags[i]
-		}
-	}
-
-	return (maxb1 + maxb2 + maxb3)
-}
-
-func main() {
-    folder, _ := os.Executable()
-    inputfile := filepath.Join(path.Dir(folder), "input.txt" )
-    fmt.Println(inputfile)
-	b, err := ioutil.ReadFile(inputfile)
+	p1, err := Part1(input)
 	if err != nil {
-		fmt.Println("error processing the file")
+		log.Fatal(err)
 	}
+	fmt.Printf("Part 1: %s\n", p1)
 
-	e := strings.Split(string(b), "\n\n")
-	bags, err := gmap(e[:len(e)-1], fromBagToCalories)
-
+	p2, err := Part2(input)
 	if err != nil {
-		fmt.Println(err)
+		log.Fatal(err)
 	}
-
-	fmt.Println("part 1 => ", part1(bags))
-	fmt.Println("part 2 => ", part2(bags))
+	fmt.Printf("Part 2: %s\n", p2)
 }

examples/golang/2022/01/main.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func gmap[T any, M any](data []T, f func(T) (M, error)) ([]M, error) {
+	mapped := make([]M, len(data))
+	for i, e := range data {
+		v, err := f(e)
+		if err != nil {
+			return nil, err
+		}
+		mapped[i] = v
+	}
+	return mapped, nil
+}
+
+func fromBagToCalories(bag string) (int, error) {
+	bc, err := gmap(strings.Split(bag, "\n"), strconv.Atoi)
+	if err != nil {
+		return 0, err
+	}
+	s := 0
+	for _, a := range bc {
+		s = s + a
+	}
+	return s, nil
+}
+
+func Part1(input string) (string, error) {
+	e := strings.Split(input, "\n\n")
+	// The original code did e[:len(e)-1] which suggests the last element might be empty due to trailing newline
+	// We should check if the last element is empty
+	if len(e) > 0 && strings.TrimSpace(e[len(e)-1]) == "" {
+		e = e[:len(e)-1]
+	}
+
+	bags, err := gmap(e, fromBagToCalories)
+	if err != nil {
+		return "", err
+	}
+
+	maxb := 0
+	for i := 0; i < len(bags); i++ {
+		if maxb < bags[i] {
+			maxb = bags[i]
+		}
+	}
+	return fmt.Sprint(maxb), nil
+}
+
+func Part2(input string) (string, error) {
+	e := strings.Split(input, "\n\n")
+	if len(e) > 0 && strings.TrimSpace(e[len(e)-1]) == "" {
+		e = e[:len(e)-1]
+	}
+
+	bags, err := gmap(e, fromBagToCalories)
+	if err != nil {
+		return "", err
+	}
+
+	maxb1, maxb2, maxb3 := 0, 0, 0
+	for i := 0; i < len(bags); i++ {
+		if bags[i] > maxb1 {
+			maxb3 = maxb2
+			maxb2 = maxb1
+			maxb1 = bags[i]
+		} else if bags[i] > maxb2 {
+			maxb3 = maxb2
+			maxb2 = bags[i]
+		} else if bags[i] > maxb3 {
+			maxb3 = bags[i]
+		}
+	}
+	return fmt.Sprint(maxb1 + maxb2 + maxb3), nil
+}