ai cooking
Merge pull request #159 from paulgmiller/codex/fix-lint-errors-and-add-github-action
Run golangci-lint during Docker builds; fix lint issues and resource handling
authored by
Paul Miller
and committed by
GitHub
daa186b6
1300d632
+159
-41
+21
.github/workflows/golangci-lint.yml
+21
.github/workflows/golangci-lint.yml
···
1
+
name: golangci-lint
2
+
3
+
on:
4
+
push:
5
+
branches:
6
+
- main
7
+
pull_request:
8
+
9
+
jobs:
10
+
golangci-lint:
11
+
runs-on: ubuntu-latest
12
+
steps:
13
+
- uses: actions/checkout@v4
14
+
- uses: actions/setup-go@v5
15
+
with:
16
+
go-version-file: go.mod
17
+
cache: true
18
+
- uses: golangci/golangci-lint-action@v9
19
+
with:
20
+
version: v2.8.0
21
+
args: --timeout=5m
+10
.golangci.yml
+10
.golangci.yml
+2
-1
AGENTS.md
+2
-1
AGENTS.md
···
9
9
10
10
## Build, Test, and Development Commands
11
11
- `go fmt ./...` then `go vet ./...`: Baseline formatting and static checks.
12
+
- `golangci-lint run ./...`: For expanded go linters
13
+
- `export ENABLE_MOCKS=1`: to test without kroger, openai credentials
12
14
- `go test ./...`: Run unit tests across all packages; add `-cover` when changing core logic.
13
-
- `export ENABLE_MOCKS=1`: to test without kroger, openai credentials
14
15
- `go run ./cmd/careme -serve -addr :8080`: Start the web server (requires env vars below).
15
16
- `go run ./cmd/careme -zipcode 98101`: Helper to list Kroger location IDs by ZIP.
16
17
- `go build -o bin/careme ./cmd/careme`: Produce a local binary for manual runs.
+5
-2
cmd/careme/mail.go
+5
-2
cmd/careme/mail.go
···
132
132
p.LastRecipes = append(p.LastRecipes, last.Title)
133
133
}
134
134
if err := rio.SaveParams(ctx, p); err != nil {
135
-
if errors.Is(err, recipes.AlreadyExists) {
135
+
if errors.Is(err, recipes.ErrAlreadyExists) {
136
136
slog.InfoContext(ctx, "params already exist, another process likely generated", "user", user.ID)
137
137
return
138
138
}
···
154
154
}
155
155
156
156
var buf bytes.Buffer
157
-
recipes.FormatMail(p, *shoppingList, &buf)
157
+
if err := recipes.FormatMail(p, *shoppingList, &buf); err != nil {
158
+
slog.ErrorContext(ctx, "failed to format mail", "error", err)
159
+
return
160
+
}
158
161
159
162
from := mail.NewEmail("Chef", "chef@careme.cooking")
160
163
subject := "Your new recipes are ready!"
+5
-1
cmd/careme/main.go
+5
-1
cmd/careme/main.go
···
55
55
if err != nil {
56
56
log.Fatalf("failed to create logsink: %v", err)
57
57
}
58
-
defer closer.Close()
58
+
defer func() {
59
+
if err := closer.Close(); err != nil {
60
+
slog.Error("failed to close logsink", "error", err)
61
+
}
62
+
}()
59
63
slog.SetDefault(slog.New(multi.Fanout(handler, slog.NewTextHandler(os.Stdout, nil))))
60
64
// log.SetOutput(os.Stdout) // https://github.com/golang/go/issues/61892
61
65
+12
-4
cmd/careme/web.go
+12
-4
cmd/careme/web.go
···
48
48
mux.HandleFunc("/static/tailwind.css", func(w http.ResponseWriter, r *http.Request) {
49
49
w.Header().Set("Content-Type", "text/css; charset=utf-8")
50
50
w.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
51
-
w.Write(tailwindCSS)
51
+
if _, err := w.Write(tailwindCSS); err != nil {
52
+
slog.ErrorContext(r.Context(), "failed to write tailwind css", "error", err)
53
+
}
52
54
})
53
55
54
56
locationserver, err := locations.New(context.TODO(), cfg)
···
132
134
})
133
135
134
136
mux.HandleFunc("/ready", func(w http.ResponseWriter, r *http.Request) {
135
-
w.Write([]byte("OK"))
137
+
if _, err := w.Write([]byte("OK")); err != nil {
138
+
slog.ErrorContext(r.Context(), "failed to write readiness response", "error", err)
139
+
}
136
140
})
137
141
138
142
mux.HandleFunc("/favicon.ico", func(w http.ResponseWriter, r *http.Request) {
139
143
w.Header().Set("Content-Type", "image/png") // <= without this, many UAs ignore it
140
144
w.Header().Set("Cache-Control", "public, max-age=31536000, immutable")
141
-
w.Write(favicon)
145
+
if _, err := w.Write(favicon); err != nil {
146
+
slog.ErrorContext(r.Context(), "failed to write favicon", "error", err)
147
+
}
142
148
})
143
149
144
150
server := &http.Server{
···
181
187
if err := svr.Shutdown(ctx); err != nil {
182
188
slog.Error("Server shutdown error", "error", err)
183
189
// Force close after timeout
184
-
svr.Close()
190
+
if closeErr := svr.Close(); closeErr != nil {
191
+
slog.Error("Server close error", "error", closeErr)
192
+
}
185
193
return err
186
194
}
187
195
+13
-3
cmd/careme/web_e2e_test.go
+13
-3
cmd/careme/web_e2e_test.go
···
139
139
if err != nil {
140
140
t.Fatalf("login request failed: %v", err)
141
141
}
142
-
defer resp.Body.Close()
142
+
defer func() {
143
+
if err := resp.Body.Close(); err != nil {
144
+
t.Fatalf("failed to close login response body: %v", err)
145
+
}
146
+
}()
143
147
if resp.StatusCode != http.StatusOK {
144
148
body := readAll(t, resp.Body)
145
149
t.Fatalf("expected login 200, got %d: %s", resp.StatusCode, body)
···
158
162
func mustGetBody(t *testing.T, client *http.Client, url string) string {
159
163
t.Helper()
160
164
resp := mustGet(t, client, url)
161
-
defer resp.Body.Close()
165
+
defer func() {
166
+
if err := resp.Body.Close(); err != nil {
167
+
t.Fatalf("failed to close response body: %v", err)
168
+
}
169
+
}()
162
170
if resp.StatusCode != http.StatusOK {
163
171
body := readAll(t, resp.Body)
164
172
t.Fatalf("GET %s expected 200, got %d: %s", url, resp.StatusCode, body)
···
179
187
resp := mustGet(t, client, current)
180
188
181
189
body := readAll(t, resp.Body)
182
-
resp.Body.Close()
190
+
if err := resp.Body.Close(); err != nil {
191
+
t.Fatalf("failed to close response body: %v", err)
192
+
}
183
193
184
194
if isSpinner(body) {
185
195
sawSpinner = true
+6
-1
internal/cache/file.go
+6
-1
internal/cache/file.go
···
109
109
}
110
110
return err
111
111
}
112
-
defer f.Close()
113
112
if _, err := f.WriteString(value); err != nil {
113
+
if closeErr := f.Close(); closeErr != nil {
114
+
return errors.Join(err, closeErr)
115
+
}
116
+
return err
117
+
}
118
+
if err := f.Close(); err != nil {
114
119
return err
115
120
}
116
121
return nil
+5
-1
internal/kroger/client.go
+5
-1
internal/kroger/client.go
+2
-2
internal/locations/mock.go
+2
-2
internal/locations/mock.go
···
24
24
},
25
25
}
26
26
27
-
func (_ mock) GetLocationByID(ctx context.Context, locationID string) (*Location, error) {
27
+
func (m mock) GetLocationByID(ctx context.Context, locationID string) (*Location, error) {
28
28
l, ok := fakes[locationID]
29
29
if !ok {
30
30
return nil, fmt.Errorf("no location %s", locationID)
···
32
32
return &l, nil
33
33
}
34
34
35
-
func (_ mock) GetLocationsByZip(ctx context.Context, zipcode string) ([]Location, error) {
35
+
func (m mock) GetLocationsByZip(ctx context.Context, zipcode string) ([]Location, error) {
36
36
return lo.Values(fakes), nil
37
37
}
+5
-1
internal/logs/reader.go
+5
-1
internal/logs/reader.go
···
112
112
if err != nil {
113
113
return fmt.Errorf("failed to download blob: %w", err)
114
114
}
115
-
defer resp.Body.Close()
115
+
defer func() {
116
+
if err := resp.Body.Close(); err != nil {
117
+
slog.ErrorContext(ctx, "failed to close log blob stream", "error", err, "blob", blobName)
118
+
}
119
+
}()
116
120
117
121
_, err = io.Copy(w, resp.Body)
118
122
return err
+8
-6
internal/recipes/generator.go
+8
-6
internal/recipes/generator.go
···
74
74
/*if len(p.Saved) > 0 {
75
75
instructions += " Enjoyed and saved :"
76
76
}*/
77
-
for _, saved := range p.Saved {
78
-
// This ended up giving me a "Preference update + replacements requested" recipe
79
-
// instructions += saved.Title + "; " //is this enough or do we keep the exact one?
80
-
shoppingList.Recipes = append(shoppingList.Recipes, saved)
81
-
}
77
+
// This ended up giving me a "Preference update + replacements requested" recipe
78
+
// instructions += saved.Title + "; " //is this enough or do we keep the exact one?
79
+
shoppingList.Recipes = append(shoppingList.Recipes, p.Saved...)
82
80
83
81
slog.InfoContext(ctx, "regenerated chat", "location", p.String(), "duration", time.Since(start), "hash", hash)
84
82
return shoppingList, nil
···
124
122
var ingredients []kroger.Ingredient
125
123
126
124
if ingredientblob, err := g.cache.Get(ctx, lochash); err == nil {
127
-
defer ingredientblob.Close()
125
+
defer func() {
126
+
if err := ingredientblob.Close(); err != nil {
127
+
slog.ErrorContext(ctx, "failed to close cached ingredients reader", "location", p.String(), "error", err)
128
+
}
129
+
}()
128
130
jsonReader := json.NewDecoder(ingredientblob)
129
131
if err := jsonReader.Decode(&ingredients); err == nil {
130
132
slog.Info("serving cached ingredients", "location", p.String(), "hash", lochash, "count", len(ingredients))
+12
-4
internal/recipes/io.go
+12
-4
internal/recipes/io.go
···
27
27
if err != nil {
28
28
return nil, err
29
29
}
30
-
defer recipe.Close()
30
+
defer func() {
31
+
if err := recipe.Close(); err != nil {
32
+
slog.ErrorContext(ctx, "failed to close cached recipe", "hash", hash, "error", err)
33
+
}
34
+
}()
31
35
32
36
var singleRecipe ai.Recipe
33
37
err = json.NewDecoder(recipe).Decode(&singleRecipe)
···
42
46
if err != nil {
43
47
return nil, err
44
48
}
45
-
defer shoppinglist.Close()
49
+
defer func() {
50
+
if err := shoppinglist.Close(); err != nil {
51
+
slog.ErrorContext(ctx, "failed to close cached shopping list", "hash", hash, "error", err)
52
+
}
53
+
}()
46
54
47
55
var list ai.ShoppingList
48
56
err = json.NewDecoder(shoppinglist).Decode(&list)
···
77
85
return errors.Join(errs...)
78
86
}
79
87
80
-
var AlreadyExists = errors.New("already exists")
88
+
var ErrAlreadyExists = errors.New("already exists")
81
89
82
90
func (rio *recipeio) SaveParams(ctx context.Context, p *generatorParams) error {
83
91
paramsJSON := lo.Must(json.Marshal(p))
84
92
if err := rio.Cache.Put(ctx, p.Hash()+".params", string(paramsJSON), cache.IfNoneMatch()); err != nil {
85
93
if errors.Is(err, cache.ErrAlreadyExists) {
86
-
return AlreadyExists
94
+
return ErrAlreadyExists
87
95
}
88
96
slog.ErrorContext(ctx, "failed to cache params", "location", p.String(), "error", err)
89
97
return err
+7
-3
internal/recipes/io_test.go
+7
-3
internal/recipes/io_test.go
···
15
15
if err != nil {
16
16
t.Fatalf("failed to create temp dir: %v", err)
17
17
}
18
-
defer os.RemoveAll(tmpDir)
18
+
t.Cleanup(func() {
19
+
if err := os.RemoveAll(tmpDir); err != nil {
20
+
t.Fatalf("failed to remove temp dir: %v", err)
21
+
}
22
+
})
19
23
20
24
rio := IO(cache.NewFileCache(tmpDir))
21
25
p := DefaultParams(&locations.Location{ID: "123", Name: "Test Store"}, time.Date(2026, 1, 25, 0, 0, 0, 0, time.UTC))
···
39
43
switch {
40
44
case err == nil:
41
45
ok++
42
-
case errors.Is(err, AlreadyExists):
46
+
case errors.Is(err, ErrAlreadyExists):
43
47
alreadyExists++
44
48
default:
45
49
other++
···
47
51
}
48
52
49
53
if ok != 1 || other != 0 || alreadyExists != n-1 {
50
-
t.Fatalf("expected 1 success + %d AlreadyExists, got ok=%d alreadyExists=%d other=%d", n-1, ok, alreadyExists, other)
54
+
t.Fatalf("expected 1 success + %d ErrAlreadyExists, got ok=%d alreadyExists=%d other=%d", n-1, ok, alreadyExists, other)
51
55
}
52
56
}
+1
-1
internal/recipes/mock.go
+1
-1
internal/recipes/mock.go
···
344
344
},
345
345
}
346
346
347
-
func (_ mock) GenerateRecipes(ctx context.Context, p *generatorParams) (*ai.ShoppingList, error) {
347
+
func (m mock) GenerateRecipes(ctx context.Context, p *generatorParams) (*ai.ShoppingList, error) {
348
348
id := p.ConversationID
349
349
if id == "" {
350
350
id = uuid.NewString()
+5
-1
internal/recipes/params.go
+5
-1
internal/recipes/params.go
···
84
84
if err != nil {
85
85
return nil, fmt.Errorf("params not found for hash %s: %w", hash, err)
86
86
}
87
-
defer paramsReader.Close()
87
+
defer func() {
88
+
if err := paramsReader.Close(); err != nil {
89
+
slog.ErrorContext(ctx, "failed to close params reader", "hash", hash, "error", err)
90
+
}
91
+
}()
88
92
89
93
var params generatorParams
90
94
if err := json.NewDecoder(paramsReader).Decode(¶ms); err != nil {
+10
-4
internal/recipes/server.go
+10
-4
internal/recipes/server.go
···
134
134
}
135
135
}
136
136
s.Spin(w, r)
137
-
return
138
137
}
139
138
140
139
func (s *server) handleRecipes(w http.ResponseWriter, r *http.Request) {
···
162
161
return
163
162
}
164
163
if r.URL.Query().Get("mail") == "true" {
165
-
FormatMail(p, *slist, w)
164
+
if err := FormatMail(p, *slist, w); err != nil {
165
+
slog.ErrorContext(ctx, "failed to render mail template", "error", err)
166
+
http.Error(w, "failed to render mail template", http.StatusInternalServerError)
167
+
}
166
168
return
167
169
}
168
170
FormatShoppingListHTML(p, *slist, w)
···
180
182
//if params are already saved redirect and assume someone kicks off genration
181
183
182
184
if err := s.SaveParams(ctx, p); err != nil {
183
-
if errors.Is(err, AlreadyExists) {
185
+
if errors.Is(err, ErrAlreadyExists) {
184
186
slog.InfoContext(ctx, "params already existed redirecting", "hash", p.Hash())
185
187
redirectToHash(w, r, p.Hash(), false /*useStart*/)
186
188
return
···
390
392
return
391
393
}
392
394
slog.Info("serving cached ingredients", "location", p.String(), "hash", lochash)
393
-
defer ingredientblob.Close()
395
+
defer func() {
396
+
if err := ingredientblob.Close(); err != nil {
397
+
slog.ErrorContext(ctx, "failed to close cached ingredients", "location", p.String(), "error", err)
398
+
}
399
+
}()
394
400
dec := json.NewDecoder(ingredientblob)
395
401
var ingredients []kroger.Ingredient
396
402
err = dec.Decode(&ingredients)
+5
-1
internal/recipes/storage_test.go
+5
-1
internal/recipes/storage_test.go
···
15
15
if err != nil {
16
16
t.Fatalf("failed to create temp dir: %v", err)
17
17
}
18
-
defer os.RemoveAll(tmpDir)
18
+
t.Cleanup(func() {
19
+
if err := os.RemoveAll(tmpDir); err != nil {
20
+
t.Fatalf("failed to remove temp dir: %v", err)
21
+
}
22
+
})
19
23
20
24
fileCache := cache.NewFileCache(tmpDir)
21
25
+15
-3
internal/recipes/user_profile_test.go
+15
-3
internal/recipes/user_profile_test.go
···
17
17
if err != nil {
18
18
t.Fatalf("failed to create temp dir: %v", err)
19
19
}
20
-
defer os.RemoveAll(tmpDir)
20
+
t.Cleanup(func() {
21
+
if err := os.RemoveAll(tmpDir); err != nil {
22
+
t.Fatalf("failed to remove temp dir: %v", err)
23
+
}
24
+
})
21
25
22
26
tmpCache := cache.NewFileCache(tmpDir)
23
27
storage := users.NewStorage(tmpCache)
···
84
88
if err != nil {
85
89
t.Fatalf("failed to create temp dir: %v", err)
86
90
}
87
-
defer os.RemoveAll(tmpDir)
91
+
t.Cleanup(func() {
92
+
if err := os.RemoveAll(tmpDir); err != nil {
93
+
t.Fatalf("failed to remove temp dir: %v", err)
94
+
}
95
+
})
88
96
89
97
tmpCache := cache.NewFileCache(tmpDir)
90
98
storage := users.NewStorage(tmpCache)
···
156
164
if err != nil {
157
165
t.Fatalf("failed to create temp dir: %v", err)
158
166
}
159
-
defer os.RemoveAll(tmpDir)
167
+
t.Cleanup(func() {
168
+
if err := os.RemoveAll(tmpDir); err != nil {
169
+
t.Fatalf("failed to remove temp dir: %v", err)
170
+
}
171
+
})
160
172
161
173
tmpCache := cache.NewFileCache(tmpDir)
162
174
storage := users.NewStorage(tmpCache)
+10
-2
internal/users/storage.go
+10
-2
internal/users/storage.go
···
120
120
}
121
121
return nil, err
122
122
}
123
-
defer userBytes.Close()
123
+
defer func() {
124
+
if err := userBytes.Close(); err != nil {
125
+
slog.Error("failed to close user reader", "error", err, "user_id", id)
126
+
}
127
+
}()
124
128
decoder := json.NewDecoder(userBytes)
125
129
126
130
var user User
···
139
143
}
140
144
return nil, err
141
145
}
142
-
defer id.Close()
146
+
defer func() {
147
+
if err := id.Close(); err != nil {
148
+
slog.Error("failed to close user email reader", "error", err, "email", normalized)
149
+
}
150
+
}()
143
151
data, err := io.ReadAll(id)
144
152
if err != nil {
145
153
return nil, fmt.Errorf("failed to read user ID: %w", err)