cli + tui to publish to leaflet (wip) & manage tasks, notes & watch/read lists 🍃
charm
leaflet
readability
golang
feat: note viewing commands
+819
-817
+51
-51
ROADMAP.md
+51
-51
ROADMAP.md
···
2
2
3
3
## Core Task Management (TaskWarrior-inspired)
4
4
5
-
- `list` - Display tasks with filtering and sorting options
6
-
- `projects` - List all project names
7
-
- `tags` - List all tag names
5
+
- [x] `list` - Display tasks with filtering and sorting options
6
+
- [ ] `projects` - List all project names
7
+
- [ ] `tags` - List all tag names
8
8
9
-
- `create|new` - Add new task with description and optional metadata
9
+
- [x] `create|new` - Add new task with description and optional metadata
10
10
11
-
- `view` - View task by ID
12
-
- `done` - Mark task as completed
13
-
- `update` - Edit task properties (description, priority, project, tags)
14
-
- `start/stop` - Track active time on tasks
15
-
- `annotate` - Add notes/comments to existing tasks
11
+
- [x] `view` - View task by ID
12
+
- [x] `done` - Mark task as completed
13
+
- [x] `update` - Edit task properties (description, priority, project, tags)
14
+
- [ ] `start/stop` - Track active time on tasks
15
+
- [ ] `annotate` - Add notes/comments to existing tasks
16
16
17
-
- `delete` - Remove task permanently
17
+
- [x] `delete` - Remove task permanently
18
18
19
-
- `calendar` - Display tasks in calendar view
20
-
- `timesheet` - Show time tracking summaries
19
+
- [ ] `calendar` - Display tasks in calendar view
20
+
- [ ] `timesheet` - Show time tracking summaries
21
21
22
22
## Todo.txt Compatibility
23
23
24
-
- `archive` - Move completed tasks to done.txt
25
-
- `[con]texts` - List all contexts (@context)
26
-
- `[proj]ects` - List all projects (+project)
27
-
- `[pri]ority` - Set task priority (A-Z)
28
-
- `[depri]oritize` - Remove priority from task
29
-
- `[re]place` - Replace task text entirely
30
-
- `prepend/append` - Add text to beginning/end of task
24
+
- [ ] `archive` - Move completed tasks to done.txt
25
+
- [ ] `[con]texts` - List all contexts (@context)
26
+
- [ ] `[proj]ects` - List all projects (+project)
27
+
- [ ] `[pri]ority` - Set task priority (A-Z)
28
+
- [ ] `[depri]oritize` - Remove priority from task
29
+
- [ ] `[re]place` - Replace task text entirely
30
+
- [ ] `prepend/append` - Add text to beginning/end of task
31
31
32
32
## Media Queue Management
33
33
34
-
- `movie add` - Add movie to watch queue
35
-
- `movie list` - Show movie queue with ratings/metadata
36
-
- `movie watched|seen` - Mark movie as watched
37
-
- `movie remove|rm` - Remove from queue
34
+
- [ ] `movie add` - Add movie to watch queue
35
+
- [ ] `movie list` - Show movie queue with ratings/metadata
36
+
- [ ] `movie watched|seen` - Mark movie as watched
37
+
- [ ] `movie remove|rm` - Remove from queue
38
38
39
-
- `tv add` - Add TV show/season to queue
40
-
- `tv list` - Show TV queue with episode tracking
41
-
- `tv watched|seen` - Mark episodes/seasons as watched
42
-
- `tv remove|rm` - Remove from TV queue
39
+
- [ ] `tv add` - Add TV show/season to queue
40
+
- [ ] `tv list` - Show TV queue with episode tracking
41
+
- [ ] `tv watched|seen` - Mark episodes/seasons as watched
42
+
- [ ] `tv remove|rm` - Remove from TV queue
43
43
44
44
## Reading List Management
45
45
46
-
- `book add` - Add book to reading list
47
-
- `book list` - Show reading queue with progress
48
-
- `book reading` - Mark book as currently reading
49
-
- `book finished|read` - Mark book as completed
50
-
- `book remove|rm` - Remove from reading list
51
-
- `book progress` - Update reading progress percentage
46
+
- [x] `book add` - Add book to reading list
47
+
- [x] `book list` - Show reading queue with progress
48
+
- [x] `book reading` - Mark book as currently reading
49
+
- [x] `book finished|read` - Mark book as completed
50
+
- [x] `book remove|rm` - Remove from reading list
51
+
- [x] `book progress` - Update reading progress percentage
52
52
53
53
## Data Management
54
54
55
-
- `sync` - Synchronize with remote storage
56
-
- `sync setup` - Setup remote storage
55
+
- [ ] `sync` - Synchronize with remote storage
56
+
- [ ] `sync setup` - Setup remote storage
57
57
58
-
- `backup` - Create local backup
58
+
- [ ] `backup` - Create local backup
59
59
60
-
- `import` - Import from various formats (CSV, JSON, todo.txt)
61
-
- `export` - Export to various formats
60
+
- [ ] `import` - Import from various formats (CSV, JSON, todo.txt)
61
+
- [ ] `export` - Export to various formats
62
62
63
-
- `config` - Manage configuration settings
63
+
- [ ] `config` - Manage configuration settings
64
64
65
-
- `undo` - Reverse last operation
65
+
- [ ] `undo` - Reverse last operation
66
66
67
67
## Notes
68
68
69
-
- `create|new` - Creates a new markdown note and optionally opens in configured editor
69
+
- [x] `create|new` - Creates a new markdown note and optionally opens in configured editor
70
70
- Creates a note from existing markdown file content
71
-
- `list` - Opens interactive TUI browser for navigating and viewing notes
72
-
- `read|view` - Displays formatted note content with syntax highlighting
73
-
- `edit|update` - Opens configured editor OR Replaces note content with new markdown file
74
-
- `remove|rm|delete|del` - Permanently removes the note file and metadata
71
+
- [x] `list` - Opens interactive TUI browser for navigating and viewing notes
72
+
- [x] `read|view` - Displays formatted note content with syntax highlighting
73
+
- [x] `edit|update` - Opens configured editor OR Replaces note content with new markdown file
74
+
- [x] `remove|rm|delete|del` - Permanently removes the note file and metadata
75
75
76
-
- `search` - Search notes by content, title, or tags
77
-
- `tag` - Add/remove tags from notes
78
-
- `recent` - Show recently created/modified notes
79
-
- `templates` - Create notes from predefined templates
80
-
- `archive` - Archive old notes
81
-
- `export` - Export notes to various formats
76
+
- [ ] `search` - Search notes by content, title, or tags
77
+
- [ ] `tag` - Add/remove tags from notes
78
+
- [ ] `recent` - Show recently created/modified notes
79
+
- [ ] `templates` - Create notes from predefined templates
80
+
- [ ] `archive` - Archive old notes
81
+
- [ ] `export` - Export notes to various formats
+119
-8
cmd/commands.go
+119
-8
cmd/commands.go
···
2
2
3
3
import (
4
4
"fmt"
5
+
"strconv"
5
6
"strings"
7
+
8
+
"github.com/charmbracelet/log"
6
9
7
10
"github.com/spf13/cobra"
8
11
"github.com/stormlightlabs/noteleaf/internal/handlers"
···
12
15
func rootCmd() *cobra.Command {
13
16
return &cobra.Command{
14
17
Use: "noteleaf",
15
-
Long: ui.Colossal.ColoredInViewport(),
18
+
Long: ui.Georgia.ColoredInViewport(),
16
19
Short: "A TaskWarrior-inspired CLI with notes, media queues and reading lists",
17
-
Run: func(cmd *cobra.Command, args []string) {
20
+
RunE: func(cmd *cobra.Command, args []string) error {
18
21
if len(args) == 0 {
19
-
cmd.Help()
20
-
} else {
21
-
output := strings.Join(args, " ")
22
-
fmt.Println(output)
22
+
return cmd.Help()
23
23
}
24
+
25
+
output := strings.Join(args, " ")
26
+
fmt.Println(output)
27
+
return nil
24
28
},
25
29
}
26
30
}
···
274
278
Short: "Manage notes",
275
279
}
276
280
277
-
root.AddCommand(&cobra.Command{
281
+
handler, err := handlers.NewNoteHandler()
282
+
if err != nil {
283
+
log.Fatalf("failed to instantiate note handler: %v", err)
284
+
}
285
+
286
+
createCmd := &cobra.Command{
278
287
Use: "create [title] [content...]",
279
288
Short: "Create a new note",
280
289
Aliases: []string{"new"},
281
290
RunE: func(cmd *cobra.Command, args []string) error {
282
-
return handlers.Create(cmd.Context(), args)
291
+
interactive, _ := cmd.Flags().GetBool("interactive")
292
+
filePath, _ := cmd.Flags().GetString("file")
293
+
294
+
var title, content string
295
+
if len(args) > 0 {
296
+
title = args[0]
297
+
}
298
+
if len(args) > 1 {
299
+
content = strings.Join(args[1:], " ")
300
+
}
301
+
302
+
if err != nil {
303
+
return err
304
+
}
305
+
defer handler.Close()
306
+
return handler.Create(cmd.Context(), title, content, filePath, interactive)
307
+
},
308
+
}
309
+
createCmd.Flags().BoolP("interactive", "i", false, "Open interactive editor")
310
+
createCmd.Flags().StringP("file", "f", "", "Create note from markdown file")
311
+
root.AddCommand(createCmd)
312
+
313
+
listCmd := &cobra.Command{
314
+
Use: "list [--archived] [--tags=tag1,tag2]",
315
+
Short: "Opens interactive TUI browser for navigating and viewing notes",
316
+
Aliases: []string{"ls"},
317
+
RunE: func(cmd *cobra.Command, args []string) error {
318
+
archived, _ := cmd.Flags().GetBool("archived")
319
+
tagsStr, _ := cmd.Flags().GetString("tags")
320
+
321
+
var tags []string
322
+
if tagsStr != "" {
323
+
tags = strings.Split(tagsStr, ",")
324
+
for i := range tags {
325
+
tags[i] = strings.TrimSpace(tags[i])
326
+
}
327
+
}
328
+
329
+
handler, err := handlers.NewNoteHandler()
330
+
if err != nil {
331
+
return err
332
+
}
333
+
defer handler.Close()
334
+
return handler.List(cmd.Context(), false, archived, tags)
335
+
},
336
+
}
337
+
listCmd.Flags().BoolP("archived", "a", false, "Show archived notes")
338
+
listCmd.Flags().String("tags", "", "Filter by tags (comma-separated)")
339
+
root.AddCommand(listCmd)
340
+
341
+
root.AddCommand(&cobra.Command{
342
+
Use: "read [note-id]",
343
+
Short: "Display formatted note content with syntax highlighting",
344
+
Aliases: []string{"view"},
345
+
Args: cobra.ExactArgs(1),
346
+
RunE: func(cmd *cobra.Command, args []string) error {
347
+
noteID, err := strconv.ParseInt(args[0], 10, 64)
348
+
if err != nil {
349
+
return fmt.Errorf("invalid note ID: %s", args[0])
350
+
}
351
+
handler, err := handlers.NewNoteHandler()
352
+
if err != nil {
353
+
return err
354
+
}
355
+
defer handler.Close()
356
+
return handler.View(cmd.Context(), noteID)
357
+
},
358
+
})
359
+
360
+
root.AddCommand(&cobra.Command{
361
+
Use: "edit [note-id]",
362
+
Short: "Edit note in configured editor",
363
+
Args: cobra.ExactArgs(1),
364
+
RunE: func(cmd *cobra.Command, args []string) error {
365
+
noteID, err := strconv.ParseInt(args[0], 10, 64)
366
+
if err != nil {
367
+
return fmt.Errorf("invalid note ID: %s", args[0])
368
+
}
369
+
handler, err := handlers.NewNoteHandler()
370
+
if err != nil {
371
+
return err
372
+
}
373
+
defer handler.Close()
374
+
return handler.Edit(cmd.Context(), noteID)
375
+
},
376
+
})
377
+
378
+
root.AddCommand(&cobra.Command{
379
+
Use: "remove [note-id]",
380
+
Short: "Permanently removes the note file and metadata",
381
+
Aliases: []string{"rm", "delete", "del"},
382
+
Args: cobra.ExactArgs(1),
383
+
RunE: func(cmd *cobra.Command, args []string) error {
384
+
noteID, err := strconv.ParseInt(args[0], 10, 64)
385
+
if err != nil {
386
+
return fmt.Errorf("invalid note ID: %s", args[0])
387
+
}
388
+
handler, err := handlers.NewNoteHandler()
389
+
if err != nil {
390
+
return err
391
+
}
392
+
defer handler.Close()
393
+
return handler.Delete(cmd.Context(), noteID)
283
394
},
284
395
})
285
396
+13
-1
go.mod
+13
-1
go.mod
···
17
17
)
18
18
19
19
require (
20
+
github.com/alecthomas/chroma/v2 v2.14.0 // indirect
20
21
github.com/atotto/clipboard v0.1.4 // indirect
22
+
github.com/aymerick/douceur v0.2.0 // indirect
21
23
github.com/catppuccin/go v0.3.0 // indirect
24
+
github.com/charmbracelet/glamour v0.10.0
25
+
github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf // indirect
22
26
github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0 // indirect
27
+
github.com/dlclark/regexp2 v1.11.0 // indirect
23
28
github.com/dustin/go-humanize v1.0.1 // indirect
24
29
github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
30
+
github.com/gorilla/css v1.0.1 // indirect
25
31
github.com/mattn/go-localereader v0.0.1 // indirect
32
+
github.com/microcosm-cc/bluemonday v1.0.27 // indirect
26
33
github.com/mitchellh/hashstructure/v2 v2.0.2 // indirect
27
34
github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
35
+
github.com/muesli/reflow v0.3.0 // indirect
36
+
github.com/yuin/goldmark v1.7.8 // indirect
37
+
github.com/yuin/goldmark-emoji v1.0.5 // indirect
38
+
golang.org/x/net v0.33.0 // indirect
28
39
golang.org/x/sync v0.13.0 // indirect
40
+
golang.org/x/term v0.31.0 // indirect
29
41
)
30
42
31
43
require (
32
44
github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
33
45
github.com/charmbracelet/bubbles v0.21.0
34
46
github.com/charmbracelet/colorprofile v0.3.1 // indirect
35
-
github.com/charmbracelet/lipgloss v1.1.0
47
+
github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834
36
48
github.com/charmbracelet/lipgloss/v2 v2.0.0-beta1
37
49
github.com/charmbracelet/log v0.4.2
38
50
github.com/charmbracelet/x/ansi v0.9.3 // indirect
+29
go.sum
+29
go.sum
···
2
2
github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
3
3
github.com/MakeNowJust/heredoc v1.0.0 h1:cXCdzVdstXyiTqTvfqk9SDHpKNjxuom+DOlyEeQ4pzQ=
4
4
github.com/MakeNowJust/heredoc v1.0.0/go.mod h1:mG5amYoWBHf8vpLOuehzbGGw0EHxpZZ6lCpQ4fNJ8LE=
5
+
github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
6
+
github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
5
7
github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
6
8
github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
7
9
github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
8
10
github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
9
11
github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8=
10
12
github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
13
+
github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
14
+
github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
11
15
github.com/catppuccin/go v0.3.0 h1:d+0/YicIq+hSTo5oPuRi5kOpqkVA5tAsU6dNhvRu+aY=
12
16
github.com/catppuccin/go v0.3.0/go.mod h1:8IHJuMGaUUjQM82qBrGNBv7LFq6JI3NnQCF6MOlZjpc=
13
17
github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
···
18
22
github.com/charmbracelet/colorprofile v0.3.1/go.mod h1:/GkGusxNs8VB/RSOh3fu0TJmQ4ICMMPApIIVn0KszZ0=
19
23
github.com/charmbracelet/fang v0.3.0 h1:Be6TB+ExS8VWizTQRJgjqbJBudKrmVUet65xmFPGhaA=
20
24
github.com/charmbracelet/fang v0.3.0/go.mod h1:b0ZfEXZeBds0I27/wnTfnv2UVigFDXHhrFNwQztfA0M=
25
+
github.com/charmbracelet/glamour v0.10.0 h1:MtZvfwsYCx8jEPFJm3rIBFIMZUfUJ765oX8V6kXldcY=
26
+
github.com/charmbracelet/glamour v0.10.0/go.mod h1:f+uf+I/ChNmqo087elLnVdCiVgjSKWuXa/l6NU2ndYk=
21
27
github.com/charmbracelet/huh v0.7.0 h1:W8S1uyGETgj9Tuda3/JdVkc3x7DBLZYPZc4c+/rnRdc=
22
28
github.com/charmbracelet/huh v0.7.0/go.mod h1:UGC3DZHlgOKHvHC07a5vHag41zzhpPFj34U92sOmyuk=
23
29
github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
24
30
github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
31
+
github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 h1:ZR7e0ro+SZZiIZD7msJyA+NjkCNNavuiPBLgerbOziE=
32
+
github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834/go.mod h1:aKC/t2arECF6rNOnaKaVU6y4t4ZeHQzqfxedE/VkVhA=
25
33
github.com/charmbracelet/lipgloss/v2 v2.0.0-beta1 h1:SOylT6+BQzPHEjn15TIzawBPVD0QmhKXbcb3jY0ZIKU=
26
34
github.com/charmbracelet/lipgloss/v2 v2.0.0-beta1/go.mod h1:tRlx/Hu0lo/j9viunCN2H+Ze6JrmdjQlXUQvvArgaOc=
27
35
github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
···
38
46
github.com/charmbracelet/x/exp/charmtone v0.0.0-20250603201427-c31516f43444/go.mod h1:T9jr8CzFpjhFVHjNjKwbAD7KwBNyFnj2pntAO7F2zw0=
39
47
github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 h1:payRxjMjKgx2PaCWLZ4p3ro9y97+TVLZNaRZgJwSVDQ=
40
48
github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
49
+
github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf h1:rLG0Yb6MQSDKdB52aGX55JT1oi0P0Kuaj7wi1bLUpnI=
50
+
github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf/go.mod h1:B3UgsnsBZS/eX42BlaNiJkD1pPOUa+oF1IYC6Yd2CEU=
41
51
github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0 h1:qko3AQ4gK1MTS/de7F5hPGx6/k1u0w4TeYmBFwzYVP4=
42
52
github.com/charmbracelet/x/exp/strings v0.0.0-20240722160745-212f7b056ed0/go.mod h1:pBhA0ybfXv6hDjQUZ7hk1lVxBiUbupdw5R31yPUViVQ=
43
53
github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
···
51
61
github.com/creack/pty v1.1.24/go.mod h1:08sCNb52WyoAwi2QDyzUCTgcvVFhUzewun7wtTfvcwE=
52
62
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
53
63
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
64
+
github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
65
+
github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
54
66
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
55
67
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
56
68
github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
···
59
71
github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
60
72
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
61
73
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
74
+
github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
75
+
github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
62
76
github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
63
77
github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
64
78
github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
···
67
81
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
68
82
github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
69
83
github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
84
+
github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
70
85
github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
71
86
github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
72
87
github.com/mattn/go-sqlite3 v1.14.32 h1:JD12Ag3oLy1zQA+BNn74xRgaBbdhbNIDYvQUEuuErjs=
73
88
github.com/mattn/go-sqlite3 v1.14.32/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
89
+
github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
90
+
github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
74
91
github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4=
75
92
github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE=
76
93
github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
···
83
100
github.com/muesli/mango-cobra v1.2.0/go.mod h1:vMJL54QytZAJhCT13LPVDfkvCUJ5/4jNUKF/8NC2UjA=
84
101
github.com/muesli/mango-pflag v0.1.0 h1:UADqbYgpUyRoBja3g6LUL+3LErjpsOwaC9ywvBWe7Sg=
85
102
github.com/muesli/mango-pflag v0.1.0/go.mod h1:YEQomTxaCUp8PrbhFh10UfbhbQrM/xJ4i2PB8VTLLW0=
103
+
github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
104
+
github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
86
105
github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=
87
106
github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=
88
107
github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
89
108
github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
90
109
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
91
110
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
111
+
github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
92
112
github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
93
113
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
94
114
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
···
101
121
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
102
122
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
103
123
github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
124
+
github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
125
+
github.com/yuin/goldmark v1.7.8 h1:iERMLn0/QJeHFhxSt3p6PeN9mGnvIKSpG9YYorDMnic=
126
+
github.com/yuin/goldmark v1.7.8/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
127
+
github.com/yuin/goldmark-emoji v1.0.5 h1:EMVWyCGPlXJfUXBXpuMu+ii3TIaxbVBnEX9uaDC4cIk=
128
+
github.com/yuin/goldmark-emoji v1.0.5/go.mod h1:tTkZEbwu5wkPmgTcitqddVxY9osFZiavD+r4AzQrh1U=
104
129
golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
105
130
golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
131
+
golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
132
+
golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
106
133
golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610=
107
134
golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
108
135
golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
109
136
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
110
137
golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
111
138
golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
139
+
golang.org/x/term v0.31.0 h1:erwDkOK1Msy6offm1mOgvspSkslFnIGsFnxOKoufg3o=
140
+
golang.org/x/term v0.31.0/go.mod h1:R4BeIy7D95HzImkxGkTW1UQTtP54tio2RyHz7PwK0aw=
112
141
golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
113
142
golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
114
143
golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
+110
-45
internal/handlers/notes.go
+110
-45
internal/handlers/notes.go
···
6
6
"os"
7
7
"os/exec"
8
8
"path/filepath"
9
-
"strconv"
10
9
"strings"
11
10
11
+
"github.com/charmbracelet/glamour"
12
12
"github.com/stormlightlabs/noteleaf/internal/models"
13
13
"github.com/stormlightlabs/noteleaf/internal/repo"
14
14
"github.com/stormlightlabs/noteleaf/internal/store"
15
+
"github.com/stormlightlabs/noteleaf/internal/ui"
15
16
"github.com/stormlightlabs/noteleaf/internal/utils"
16
17
)
17
18
···
54
55
return nil
55
56
}
56
57
57
-
// Create handles note creation subcommands
58
-
func Create(ctx context.Context, args []string) error {
59
-
handler, err := NewNoteHandler()
60
-
if err != nil {
61
-
return err
62
-
}
63
-
defer handler.Close()
64
-
65
-
if len(args) == 0 {
66
-
return handler.createInteractive(ctx)
67
-
}
68
-
69
-
if len(args) == 1 && isFile(args[0]) {
70
-
return handler.createFromFile(ctx, args[0])
58
+
// Create handles note creation with optional title, content, and file path
59
+
func (h *NoteHandler) Create(ctx context.Context, title string, content string, filePath string, interactive bool) error {
60
+
if interactive || (title == "" && content == "" && filePath == "") {
61
+
return h.createInteractive(ctx)
71
62
}
72
63
73
-
title := args[0]
74
-
content := ""
75
-
if len(args) > 1 {
76
-
content = strings.Join(args[1:], " ")
64
+
if filePath != "" {
65
+
return h.createFromFile(ctx, filePath)
77
66
}
78
67
79
-
return handler.createFromArgs(ctx, title, content)
80
-
}
81
-
82
-
// New is an alias for Create
83
-
func New(ctx context.Context, args []string) error {
84
-
return Create(ctx, args)
68
+
return h.createFromArgs(ctx, title, content)
85
69
}
86
70
87
71
// Edit handles note editing by ID
88
-
func Edit(ctx context.Context, args []string) error {
89
-
if len(args) != 1 {
90
-
return fmt.Errorf("edit requires exactly one argument: note ID")
91
-
}
72
+
func (h *NoteHandler) Edit(ctx context.Context, noteID int64) error {
73
+
return h.editNote(ctx, noteID)
74
+
}
92
75
93
-
id, err := strconv.ParseInt(args[0], 10, 64)
94
-
if err != nil {
95
-
return fmt.Errorf("invalid note ID: %s", args[0])
96
-
}
76
+
// View displays a note with formatted markdown content
77
+
func (h *NoteHandler) View(ctx context.Context, noteID int64) error {
78
+
return h.viewNote(ctx, noteID)
79
+
}
97
80
98
-
handler, err := NewNoteHandler()
99
-
if err != nil {
100
-
return err
101
-
}
102
-
defer handler.Close()
81
+
// List opens either an interactive TUI browser for navigating and viewing notes or a static list
82
+
func (h *NoteHandler) List(ctx context.Context, static, showArchived bool, tags []string) error {
83
+
return h.listNotes(ctx, showArchived, tags, static)
84
+
}
103
85
104
-
return handler.editNote(ctx, id)
86
+
// Delete permanently removes a note and its metadata
87
+
func (h *NoteHandler) Delete(ctx context.Context, noteID int64) error {
88
+
return h.deleteNote(ctx, noteID)
105
89
}
106
90
107
91
func (h *NoteHandler) createInteractive(ctx context.Context) error {
···
371
355
return content.String()
372
356
}
373
357
374
-
func isFile(arg string) bool {
375
-
if filepath.Ext(arg) != "" {
376
-
return true
358
+
func (h *NoteHandler) viewNote(ctx context.Context, id int64) error {
359
+
note, err := h.repos.Notes.Get(ctx, id)
360
+
if err != nil {
361
+
return fmt.Errorf("failed to get note: %w", err)
362
+
}
363
+
364
+
renderer, err := glamour.NewTermRenderer(
365
+
glamour.WithAutoStyle(),
366
+
glamour.WithWordWrap(80),
367
+
)
368
+
if err != nil {
369
+
return fmt.Errorf("failed to create markdown renderer: %w", err)
370
+
}
371
+
372
+
content := h.formatNoteForView(note)
373
+
rendered, err := renderer.Render(content)
374
+
if err != nil {
375
+
return fmt.Errorf("failed to render markdown: %w", err)
376
+
}
377
+
378
+
fmt.Print(rendered)
379
+
return nil
380
+
}
381
+
382
+
func (h *NoteHandler) formatNoteForView(note *models.Note) string {
383
+
var content strings.Builder
384
+
385
+
content.WriteString("# " + note.Title + "\n\n")
386
+
387
+
if len(note.Tags) > 0 {
388
+
content.WriteString("**Tags:** ")
389
+
for i, tag := range note.Tags {
390
+
if i > 0 {
391
+
content.WriteString(", ")
392
+
}
393
+
content.WriteString("`" + tag + "`")
394
+
}
395
+
content.WriteString("\n\n")
396
+
}
397
+
398
+
content.WriteString("**Created:** " + note.Created.Format("2006-01-02 15:04") + "\n")
399
+
content.WriteString("**Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n\n")
400
+
content.WriteString("---\n\n")
401
+
402
+
noteContent := strings.TrimSpace(note.Content)
403
+
if !strings.HasPrefix(noteContent, "# ") {
404
+
content.WriteString(noteContent)
405
+
} else {
406
+
lines := strings.Split(noteContent, "\n")
407
+
if len(lines) > 1 {
408
+
content.WriteString(strings.Join(lines[1:], "\n"))
409
+
}
377
410
}
378
411
379
-
if info, err := os.Stat(arg); err == nil && !info.IsDir() {
380
-
return true
412
+
return content.String()
413
+
}
414
+
415
+
func (h *NoteHandler) listNotes(ctx context.Context, showArchived bool, tags []string, static bool) error {
416
+
opts := ui.NoteListOptions{
417
+
Output: os.Stdout,
418
+
Input: os.Stdin,
419
+
Static: static,
420
+
ShowArchived: showArchived,
421
+
Tags: tags,
381
422
}
382
423
383
-
return strings.Contains(arg, "/") || strings.Contains(arg, "\\")
424
+
noteList := ui.NewNoteList(h.repos.Notes, opts)
425
+
return noteList.Browse(ctx)
426
+
}
427
+
428
+
func (h *NoteHandler) deleteNote(ctx context.Context, id int64) error {
429
+
note, err := h.repos.Notes.Get(ctx, id)
430
+
if err != nil {
431
+
return fmt.Errorf("failed to find note: %w", err)
432
+
}
433
+
434
+
if note.FilePath != "" {
435
+
if err := os.Remove(note.FilePath); err != nil && !os.IsNotExist(err) {
436
+
return fmt.Errorf("failed to remove note file %s: %w", note.FilePath, err)
437
+
}
438
+
}
439
+
440
+
if err := h.repos.Notes.Delete(ctx, id); err != nil {
441
+
return fmt.Errorf("failed to delete note from database: %w", err)
442
+
}
443
+
444
+
fmt.Printf("Note deleted (ID: %d): %s\n", note.ID, note.Title)
445
+
if note.FilePath != "" {
446
+
fmt.Printf("File removed: %s\n", note.FilePath)
447
+
}
448
+
return nil
384
449
}
+177
-711
internal/handlers/notes_test.go
+177
-711
internal/handlers/notes_test.go
···
43
43
}
44
44
45
45
func TestNoteHandler(t *testing.T) {
46
+
tempDir, cleanup := setupNoteTest(t)
47
+
defer cleanup()
48
+
49
+
handler, err := NewNoteHandler()
50
+
if err != nil {
51
+
t.Fatalf("Failed to create note handler: %v", err)
52
+
}
53
+
defer handler.Close()
54
+
46
55
t.Run("New", func(t *testing.T) {
47
56
t.Run("creates handler successfully", func(t *testing.T) {
48
-
_, cleanup := setupNoteTest(t)
49
-
defer cleanup()
50
-
51
-
handler, err := NewNoteHandler()
57
+
testHandler, err := NewNoteHandler()
52
58
if err != nil {
53
59
t.Fatalf("NewNoteHandler failed: %v", err)
54
60
}
55
-
if handler == nil {
61
+
if testHandler == nil {
56
62
t.Fatal("Handler should not be nil")
57
63
}
58
-
defer handler.Close()
64
+
defer testHandler.Close()
59
65
60
-
if handler.db == nil {
66
+
if testHandler.db == nil {
61
67
t.Error("Handler database should not be nil")
62
68
}
63
-
if handler.config == nil {
69
+
if testHandler.config == nil {
64
70
t.Error("Handler config should not be nil")
65
71
}
66
-
if handler.repos == nil {
72
+
if testHandler.repos == nil {
67
73
t.Error("Handler repos should not be nil")
68
74
}
69
75
})
···
96
102
})
97
103
})
98
104
99
-
t.Run("parse content", func(t *testing.T) {
100
-
handler := &NoteHandler{}
101
-
102
-
testCases := []struct {
103
-
name string
104
-
input string
105
-
expectedTitle string
106
-
expectedContent string
107
-
expectedTags []string
108
-
}{
109
-
{
110
-
name: "note with title and tags",
111
-
input: `# My Test Note
112
-
113
-
This is the content.
114
-
115
-
<!-- Tags: personal, work, important -->`,
116
-
expectedTitle: "My Test Note",
117
-
expectedContent: `# My Test Note
118
-
119
-
This is the content.
120
-
121
-
<!-- Tags: personal, work, important -->`,
122
-
expectedTags: []string{"personal", "work", "important"},
123
-
},
124
-
{
125
-
name: "note without title",
126
-
input: `Just some content here.
127
-
128
-
No title heading.
129
-
130
-
<!-- Tags: test -->`,
131
-
expectedTitle: "",
132
-
expectedContent: `Just some content here.
133
-
134
-
No title heading.
135
-
136
-
<!-- Tags: test -->`,
137
-
expectedTags: []string{"test"},
138
-
},
139
-
{
140
-
name: "note without tags",
141
-
input: `# Title Only
142
-
143
-
Content without tags.`,
144
-
expectedTitle: "Title Only",
145
-
expectedContent: `# Title Only
146
-
147
-
Content without tags.`,
148
-
expectedTags: nil,
149
-
},
150
-
{
151
-
name: "empty tags comment",
152
-
input: `# Test Note
153
-
154
-
Content here.
155
-
156
-
<!-- Tags: -->`,
157
-
expectedTitle: "Test Note",
158
-
expectedContent: `# Test Note
159
-
160
-
Content here.
161
-
162
-
<!-- Tags: -->`,
163
-
expectedTags: nil,
164
-
},
165
-
{
166
-
name: "malformed tags comment",
167
-
input: `# Test Note
168
-
169
-
Content here.
170
-
171
-
<!-- Tags: tag1, , tag2,, tag3 -->`,
172
-
expectedTitle: "Test Note",
173
-
expectedContent: `# Test Note
174
-
175
-
Content here.
176
-
177
-
<!-- Tags: tag1, , tag2,, tag3 -->`,
178
-
expectedTags: []string{"tag1", "tag2", "tag3"},
179
-
},
180
-
{
181
-
name: "multiple headings",
182
-
input: `## Secondary Heading
183
-
184
-
# Main Title
185
-
186
-
Content here.`,
187
-
expectedTitle: "Main Title",
188
-
expectedContent: `## Secondary Heading
189
-
190
-
# Main Title
191
-
192
-
Content here.`,
193
-
expectedTags: nil,
194
-
},
195
-
}
196
-
197
-
for _, tc := range testCases {
198
-
t.Run(tc.name, func(t *testing.T) {
199
-
title, content, tags := handler.parseNoteContent(tc.input)
200
-
201
-
if title != tc.expectedTitle {
202
-
t.Errorf("Expected title %q, got %q", tc.expectedTitle, title)
203
-
}
204
-
205
-
if content != tc.expectedContent {
206
-
t.Errorf("Expected content %q, got %q", tc.expectedContent, content)
207
-
}
208
-
209
-
if len(tags) != len(tc.expectedTags) {
210
-
t.Errorf("Expected %d tags, got %d", len(tc.expectedTags), len(tags))
211
-
}
212
-
213
-
for i, expectedTag := range tc.expectedTags {
214
-
if i >= len(tags) || tags[i] != expectedTag {
215
-
t.Errorf("Expected tag %q at position %d, got %q", expectedTag, i, tags[i])
216
-
}
217
-
}
218
-
})
219
-
}
220
-
})
221
-
222
-
t.Run("IsFile helper", func(t *testing.T) {
223
-
testCases := []struct {
224
-
name string
225
-
input string
226
-
expected bool
227
-
}{
228
-
{"file with extension", "test.md", true},
229
-
{"file with multiple extensions", "test.tar.gz", true},
230
-
{"path with slash", "/path/to/file", true},
231
-
{"path with backslash", "path\\to\\file", true},
232
-
{"relative path", "./file", true},
233
-
{"just text", "hello", false},
234
-
{"empty string", "", false},
235
-
}
236
-
237
-
tempDir, err := os.MkdirTemp("", "isfile-test-*")
238
-
if err != nil {
239
-
t.Fatalf("Failed to create temp dir: %v", err)
240
-
}
241
-
defer os.RemoveAll(tempDir)
242
-
243
-
existingFile := filepath.Join(tempDir, "existing")
244
-
err = os.WriteFile(existingFile, []byte("test"), 0644)
245
-
if err != nil {
246
-
t.Fatalf("Failed to create test file: %v", err)
247
-
}
248
-
249
-
testCases = append(testCases, struct {
250
-
name string
251
-
input string
252
-
expected bool
253
-
}{"existing file without extension", existingFile, true})
254
-
255
-
for _, tc := range testCases {
256
-
t.Run(tc.name, func(t *testing.T) {
257
-
result := isFile(tc.input)
258
-
if result != tc.expected {
259
-
t.Errorf("isFile(%q) = %v, expected %v", tc.input, result, tc.expected)
260
-
}
261
-
})
262
-
}
263
-
})
264
-
265
-
t.Run("getEditor", func(t *testing.T) {
266
-
handler := &NoteHandler{}
267
-
268
-
t.Run("uses EDITOR environment variable", func(t *testing.T) {
269
-
originalEditor := os.Getenv("EDITOR")
270
-
os.Setenv("EDITOR", "test-editor")
271
-
defer os.Setenv("EDITOR", originalEditor)
272
-
273
-
editor := handler.getEditor()
274
-
if editor != "test-editor" {
275
-
t.Errorf("Expected 'test-editor', got %q", editor)
276
-
}
277
-
})
278
-
279
-
t.Run("finds available editor", func(t *testing.T) {
280
-
originalEditor := os.Getenv("EDITOR")
281
-
os.Unsetenv("EDITOR")
282
-
defer os.Setenv("EDITOR", originalEditor)
283
-
284
-
editor := handler.getEditor()
285
-
if editor == "" {
286
-
t.Skip("No common editors found on system, skipping test")
287
-
}
288
-
})
289
-
290
-
t.Run("returns empty when no editor available", func(t *testing.T) {
291
-
originalEditor := os.Getenv("EDITOR")
292
-
originalPath := os.Getenv("PATH")
293
-
294
-
os.Unsetenv("EDITOR")
295
-
os.Setenv("PATH", "")
296
-
297
-
defer func() {
298
-
os.Setenv("EDITOR", originalEditor)
299
-
os.Setenv("PATH", originalPath)
300
-
}()
301
-
302
-
editor := handler.getEditor()
303
-
if editor != "" {
304
-
t.Errorf("Expected empty string when no editor available, got %q", editor)
305
-
}
306
-
})
307
-
})
308
-
309
-
t.Run("Create Errors", func(t *testing.T) {
310
-
errorTests := []struct {
311
-
name string
312
-
setupFunc func(t *testing.T) (cleanup func())
313
-
args []string
314
-
expectError bool
315
-
errorSubstr string
316
-
}{
317
-
{
318
-
name: "database initialization error",
319
-
setupFunc: func(t *testing.T) func() {
320
-
if runtime.GOOS == "windows" {
321
-
original := os.Getenv("APPDATA")
322
-
os.Unsetenv("APPDATA")
323
-
return func() { os.Setenv("APPDATA", original) }
324
-
} else {
325
-
originalXDG := os.Getenv("XDG_CONFIG_HOME")
326
-
originalHome := os.Getenv("HOME")
327
-
os.Unsetenv("XDG_CONFIG_HOME")
328
-
os.Unsetenv("HOME")
329
-
return func() {
330
-
os.Setenv("XDG_CONFIG_HOME", originalXDG)
331
-
os.Setenv("HOME", originalHome)
332
-
}
333
-
}
334
-
},
335
-
args: []string{"Test Note"},
336
-
expectError: true,
337
-
errorSubstr: "failed to initialize database",
338
-
},
339
-
{
340
-
name: "note creation in database fails",
341
-
setupFunc: func(t *testing.T) func() {
342
-
tempDir, cleanup := setupNoteTest(t)
343
-
344
-
configDir := filepath.Join(tempDir, "noteleaf")
345
-
dbPath := filepath.Join(configDir, "noteleaf.db")
346
-
347
-
err := os.WriteFile(dbPath, []byte("invalid sqlite content"), 0644)
348
-
if err != nil {
349
-
t.Fatalf("Failed to corrupt database: %v", err)
350
-
}
105
+
t.Run("Create", func(t *testing.T) {
106
+
ctx := context.Background()
351
107
352
-
return cleanup
353
-
},
354
-
args: []string{"Test Note"},
355
-
expectError: true,
356
-
errorSubstr: "failed to initialize database",
357
-
},
358
-
}
359
-
360
-
for _, tt := range errorTests {
361
-
t.Run(tt.name, func(t *testing.T) {
362
-
cleanup := tt.setupFunc(t)
363
-
defer cleanup()
364
-
365
-
oldStdin := os.Stdin
366
-
r, w, _ := os.Pipe()
367
-
os.Stdin = r
368
-
defer func() { os.Stdin = oldStdin }()
369
-
370
-
go func() {
371
-
w.WriteString("n\n")
372
-
w.Close()
373
-
}()
374
-
375
-
ctx := context.Background()
376
-
err := Create(ctx, tt.args)
377
-
378
-
if tt.expectError && err == nil {
379
-
t.Errorf("Expected error containing %q, got nil", tt.errorSubstr)
380
-
} else if !tt.expectError && err != nil {
381
-
t.Errorf("Expected no error, got: %v", err)
382
-
} else if tt.expectError && err != nil && !strings.Contains(err.Error(), tt.errorSubstr) {
383
-
t.Errorf("Expected error containing %q, got: %v", tt.errorSubstr, err)
384
-
}
385
-
})
386
-
}
387
-
})
388
-
389
-
t.Run("Create (args)", func(t *testing.T) {
390
108
t.Run("creates note from title only", func(t *testing.T) {
391
-
_, cleanup := setupNoteTest(t)
392
-
defer cleanup()
393
-
394
-
oldStdin := os.Stdin
395
-
r, w, _ := os.Pipe()
396
-
os.Stdin = r
397
-
defer func() { os.Stdin = oldStdin }()
398
-
399
-
go func() {
400
-
w.WriteString("n\n")
401
-
w.Close()
402
-
}()
403
-
404
-
ctx := context.Background()
405
-
err := Create(ctx, []string{"Test Note"})
109
+
err := handler.Create(ctx, "Test Note 1", "", "", false)
406
110
if err != nil {
407
111
t.Errorf("Create failed: %v", err)
408
112
}
409
113
})
410
114
411
115
t.Run("creates note from title and content", func(t *testing.T) {
412
-
_, cleanup := setupNoteTest(t)
413
-
defer cleanup()
414
-
415
-
oldStdin := os.Stdin
416
-
r, w, _ := os.Pipe()
417
-
os.Stdin = r
418
-
defer func() { os.Stdin = oldStdin }()
419
-
420
-
go func() {
421
-
w.WriteString("n\n")
422
-
w.Close()
423
-
}()
424
-
425
-
ctx := context.Background()
426
-
err := Create(ctx, []string{"Test Note", "This", "is", "test", "content"})
116
+
err := handler.Create(ctx, "Test Note 2", "This is test content", "", false)
427
117
if err != nil {
428
118
t.Errorf("Create failed: %v", err)
429
119
}
430
120
})
431
121
432
-
t.Run("handles database connection error", func(t *testing.T) {
433
-
tempDir, cleanup := setupNoteTest(t)
434
-
defer cleanup()
435
-
436
-
configDir := filepath.Join(tempDir, "noteleaf")
437
-
dbPath := filepath.Join(configDir, "noteleaf.db")
438
-
os.Remove(dbPath)
439
-
440
-
os.MkdirAll(dbPath, 0755)
441
-
defer os.RemoveAll(dbPath)
442
-
443
-
ctx := context.Background()
444
-
err := Create(ctx, []string{"Test Note"})
445
-
if err == nil {
446
-
t.Error("Create should fail when database is inaccessible")
447
-
}
448
-
})
449
-
450
-
t.Run("New is alias for Create", func(t *testing.T) {
451
-
_, cleanup := setupNoteTest(t)
452
-
defer cleanup()
453
-
454
-
oldStdin := os.Stdin
455
-
r, w, _ := os.Pipe()
456
-
os.Stdin = r
457
-
defer func() { os.Stdin = oldStdin }()
458
-
459
-
go func() {
460
-
w.WriteString("n\n")
461
-
w.Close()
462
-
}()
463
-
464
-
ctx := context.Background()
465
-
err := New(ctx, []string{"Test Note via New"})
466
-
if err != nil {
467
-
t.Errorf("New failed: %v", err)
468
-
}
469
-
})
470
-
})
471
-
472
-
t.Run("Create from file", func(t *testing.T) {
473
122
t.Run("creates note from markdown file", func(t *testing.T) {
474
-
tempDir, cleanup := setupNoteTest(t)
475
-
defer cleanup()
476
-
477
123
content := `# My Test Note
478
-
479
-
This is the content of my test note.
480
-
481
-
## Section 2
482
-
483
-
More content here.
124
+
<!-- tags: personal, work -->
484
125
485
-
<!-- Tags: personal, work -->`
486
-
126
+
This is the content of my note.`
487
127
filePath := createTestMarkdownFile(t, tempDir, "test.md", content)
488
128
489
-
ctx := context.Background()
490
-
err := Create(ctx, []string{filePath})
129
+
err := handler.Create(ctx, "", "", filePath, false)
491
130
if err != nil {
492
131
t.Errorf("Create from file failed: %v", err)
493
132
}
494
133
})
495
134
496
135
t.Run("handles non-existent file", func(t *testing.T) {
497
-
_, cleanup := setupNoteTest(t)
498
-
defer cleanup()
499
-
500
-
ctx := context.Background()
501
-
err := Create(ctx, []string{"/non/existent/file.md"})
136
+
err := handler.Create(ctx, "", "", "/non/existent/file.md", false)
502
137
if err == nil {
503
-
t.Error("Create should fail for non-existent file")
504
-
}
505
-
if !strings.Contains(err.Error(), "file does not exist") {
506
-
t.Errorf("Expected file not found error, got: %v", err)
507
-
}
508
-
})
509
-
510
-
t.Run("handles empty file", func(t *testing.T) {
511
-
tempDir, cleanup := setupNoteTest(t)
512
-
defer cleanup()
513
-
514
-
filePath := createTestMarkdownFile(t, tempDir, "empty.md", "")
515
-
516
-
ctx := context.Background()
517
-
err := Create(ctx, []string{filePath})
518
-
if err == nil {
519
-
t.Error("Create should fail for empty file")
520
-
}
521
-
if !strings.Contains(err.Error(), "file is empty") {
522
-
t.Errorf("Expected empty file error, got: %v", err)
523
-
}
524
-
})
525
-
526
-
t.Run("handles whitespace-only file", func(t *testing.T) {
527
-
tempDir, cleanup := setupNoteTest(t)
528
-
defer cleanup()
529
-
530
-
filePath := createTestMarkdownFile(t, tempDir, "whitespace.md", " \n\t \n ")
531
-
532
-
ctx := context.Background()
533
-
err := Create(ctx, []string{filePath})
534
-
if err == nil {
535
-
t.Error("Create should fail for whitespace-only file")
536
-
}
537
-
if !strings.Contains(err.Error(), "file is empty") {
538
-
t.Errorf("Expected empty file error, got: %v", err)
539
-
}
540
-
})
541
-
542
-
t.Run("creates note without title in file", func(t *testing.T) {
543
-
tempDir, cleanup := setupNoteTest(t)
544
-
defer cleanup()
545
-
546
-
content := `This note has no title heading.
547
-
548
-
Just some content here.`
549
-
550
-
filePath := createTestMarkdownFile(t, tempDir, "notitle.md", content)
551
-
552
-
ctx := context.Background()
553
-
err := Create(ctx, []string{filePath})
554
-
if err != nil {
555
-
t.Errorf("Create from file without title failed: %v", err)
138
+
t.Error("Create should fail with non-existent file")
556
139
}
557
140
})
141
+
})
558
142
559
-
t.Run("handles file read error", func(t *testing.T) {
560
-
tempDir, cleanup := setupNoteTest(t)
561
-
defer cleanup()
562
-
563
-
filePath := createTestMarkdownFile(t, tempDir, "unreadable.md", "test content")
564
-
err := os.Chmod(filePath, 0000)
565
-
if err != nil {
566
-
t.Fatalf("Failed to make file unreadable: %v", err)
567
-
}
568
-
defer os.Chmod(filePath, 0644)
143
+
t.Run("Edit", func(t *testing.T) {
144
+
ctx := context.Background()
569
145
570
-
ctx := context.Background()
571
-
err = Create(ctx, []string{filePath})
146
+
t.Run("handles non-existent note", func(t *testing.T) {
147
+
err := handler.Edit(ctx, 999)
572
148
if err == nil {
573
-
t.Error("Create should fail for unreadable file")
149
+
t.Error("Edit should fail with non-existent note ID")
574
150
}
575
-
if !strings.Contains(err.Error(), "failed to read file") {
576
-
t.Errorf("Expected file read error, got: %v", err)
151
+
if !strings.Contains(err.Error(), "failed to get note") && !strings.Contains(err.Error(), "failed to find note") {
152
+
t.Errorf("Expected note not found error, got: %v", err)
577
153
}
578
154
})
579
-
})
580
155
581
-
t.Run("Interactive Create", func(t *testing.T) {
582
156
t.Run("handles no editor configured", func(t *testing.T) {
583
-
_, cleanup := setupNoteTest(t)
584
-
defer cleanup()
585
-
586
157
originalEditor := os.Getenv("EDITOR")
587
158
originalPath := os.Getenv("PATH")
588
-
os.Unsetenv("EDITOR")
159
+
os.Setenv("EDITOR", "")
589
160
os.Setenv("PATH", "")
590
161
defer func() {
591
162
os.Setenv("EDITOR", originalEditor)
592
163
os.Setenv("PATH", originalPath)
593
164
}()
594
165
595
-
ctx := context.Background()
596
-
err := Create(ctx, []string{})
166
+
err := handler.Edit(ctx, 1)
597
167
if err == nil {
598
-
t.Error("Create should fail when no editor is configured")
168
+
t.Error("Edit should fail when no editor is configured")
599
169
}
600
-
if !strings.Contains(err.Error(), "no editor configured") {
170
+
if !strings.Contains(err.Error(), "no editor configured") && !strings.Contains(err.Error(), "failed to open editor") {
601
171
t.Errorf("Expected no editor error, got: %v", err)
602
172
}
603
173
})
174
+
})
604
175
605
-
t.Run("handles editor command failure", func(t *testing.T) {
606
-
_, cleanup := setupNoteTest(t)
607
-
defer cleanup()
176
+
t.Run("Read/View", func(t *testing.T) {
177
+
ctx := context.Background()
608
178
609
-
originalEditor := os.Getenv("EDITOR")
610
-
os.Setenv("EDITOR", "nonexistent-editor-12345")
611
-
defer os.Setenv("EDITOR", originalEditor)
179
+
t.Run("views note successfully", func(t *testing.T) {
180
+
err := handler.View(ctx, 1)
181
+
if err != nil {
182
+
t.Errorf("View should succeed: %v", err)
183
+
}
184
+
})
612
185
613
-
ctx := context.Background()
614
-
err := Create(ctx, []string{})
186
+
t.Run("handles non-existent note", func(t *testing.T) {
187
+
err := handler.View(ctx, 999)
615
188
if err == nil {
616
-
t.Error("Create should fail when editor command fails")
189
+
t.Error("View should fail with non-existent note ID")
617
190
}
618
-
if !strings.Contains(err.Error(), "failed to open editor") {
619
-
t.Errorf("Expected editor failure error, got: %v", err)
191
+
if !strings.Contains(err.Error(), "failed to get note") && !strings.Contains(err.Error(), "failed to find note") {
192
+
t.Errorf("Expected note not found error, got: %v", err)
620
193
}
621
194
})
622
195
623
-
t.Run("creates note successfully with mocked editor", func(t *testing.T) {
624
-
_, cleanup := setupNoteTest(t)
625
-
defer cleanup()
196
+
})
626
197
627
-
originalEditor := os.Getenv("EDITOR")
628
-
os.Setenv("EDITOR", "test-editor")
629
-
defer os.Setenv("EDITOR", originalEditor)
198
+
t.Run("List", func(t *testing.T) {
199
+
ctx := context.Background()
630
200
631
-
handler, err := NewNoteHandler()
201
+
t.Run("lists with archived filter", func(t *testing.T) {
202
+
err := handler.List(ctx, true, true, nil)
632
203
if err != nil {
633
-
t.Fatalf("NewNoteHandler failed: %v", err)
204
+
t.Errorf("List with archived filter should succeed: %v", err)
634
205
}
635
-
defer handler.Close()
206
+
})
636
207
637
-
handler.openInEditorFunc = func(editor, filePath string) error {
638
-
content := `# Test Note
639
-
640
-
This is edited content.
641
-
642
-
<!-- Tags: test, created -->`
643
-
return os.WriteFile(filePath, []byte(content), 0644)
644
-
}
645
-
646
-
ctx := context.Background()
647
-
err = handler.createInteractive(ctx)
208
+
t.Run("lists with tag filter", func(t *testing.T) {
209
+
err := handler.List(ctx, true, false, []string{"work", "personal"})
648
210
if err != nil {
649
-
t.Errorf("Interactive create failed: %v", err)
211
+
t.Errorf("List with tag filter should succeed: %v", err)
650
212
}
651
213
})
652
214
653
-
t.Run("handles editor cancellation", func(t *testing.T) {
654
-
_, cleanup := setupNoteTest(t)
655
-
defer cleanup()
656
-
657
-
originalEditor := os.Getenv("EDITOR")
658
-
os.Setenv("EDITOR", "test-editor")
659
-
defer os.Setenv("EDITOR", originalEditor)
215
+
t.Run("handles empty note list", func(t *testing.T) {
216
+
_, emptyCleanup := setupNoteTest(t)
217
+
defer emptyCleanup()
660
218
661
-
handler, err := NewNoteHandler()
219
+
emptyHandler, err := NewNoteHandler()
662
220
if err != nil {
663
-
t.Fatalf("NewNoteHandler failed: %v", err)
664
-
}
665
-
defer handler.Close()
666
-
667
-
handler.openInEditorFunc = func(editor, filePath string) error {
668
-
return nil
221
+
t.Fatalf("Failed to create empty handler: %v", err)
669
222
}
223
+
defer emptyHandler.Close()
670
224
671
-
ctx := context.Background()
672
-
err = handler.createInteractive(ctx)
225
+
err = emptyHandler.List(ctx, true, false, nil)
673
226
if err != nil {
674
-
t.Errorf("Interactive create should handle cancellation gracefully: %v", err)
227
+
t.Errorf("ListStatic should succeed with empty list: %v", err)
675
228
}
676
229
})
677
230
})
678
231
679
-
t.Run("Close", func(t *testing.T) {
680
-
_, cleanup := setupNoteTest(t)
681
-
defer cleanup()
682
-
683
-
handler, err := NewNoteHandler()
684
-
if err != nil {
685
-
t.Fatalf("NewNoteHandler failed: %v", err)
686
-
}
687
-
688
-
err = handler.Close()
689
-
if err != nil {
690
-
t.Errorf("Close should not return error: %v", err)
691
-
}
692
-
693
-
handler.db = nil
694
-
err = handler.Close()
695
-
if err != nil {
696
-
t.Errorf("Close should handle nil database gracefully: %v", err)
697
-
}
698
-
})
699
-
700
-
t.Run("Edit", func(t *testing.T) {
701
-
t.Run("validates argument count", func(t *testing.T) {
702
-
_, cleanup := setupNoteTest(t)
703
-
defer cleanup()
704
-
705
-
ctx := context.Background()
706
-
707
-
err := Edit(ctx, []string{})
708
-
if err == nil {
709
-
t.Error("Edit should fail with no arguments")
710
-
}
711
-
if !strings.Contains(err.Error(), "edit requires exactly one argument") {
712
-
t.Errorf("Expected argument count error, got: %v", err)
713
-
}
714
-
715
-
err = Edit(ctx, []string{"1", "2"})
716
-
if err == nil {
717
-
t.Error("Edit should fail with too many arguments")
718
-
}
719
-
if !strings.Contains(err.Error(), "edit requires exactly one argument") {
720
-
t.Errorf("Expected argument count error, got: %v", err)
721
-
}
722
-
})
723
-
724
-
t.Run("validates note ID format", func(t *testing.T) {
725
-
_, cleanup := setupNoteTest(t)
726
-
defer cleanup()
727
-
728
-
ctx := context.Background()
729
-
730
-
err := Edit(ctx, []string{"invalid"})
731
-
if err == nil {
732
-
t.Error("Edit should fail with invalid note ID")
733
-
}
734
-
if !strings.Contains(err.Error(), "invalid note ID") {
735
-
t.Errorf("Expected invalid ID error, got: %v", err)
736
-
}
737
-
738
-
err = Edit(ctx, []string{"-1"})
739
-
if err == nil {
740
-
t.Error("Edit should fail with negative note ID")
741
-
}
742
-
743
-
if !strings.Contains(err.Error(), "failed to get note") {
744
-
t.Errorf("Expected note not found error for negative ID, got: %v", err)
745
-
}
746
-
})
232
+
t.Run("Delete", func(t *testing.T) {
233
+
ctx := context.Background()
747
234
748
235
t.Run("handles non-existent note", func(t *testing.T) {
749
-
_, cleanup := setupNoteTest(t)
750
-
defer cleanup()
751
-
752
-
ctx := context.Background()
753
-
754
-
err := Edit(ctx, []string{"999"})
236
+
err := handler.Delete(ctx, 999)
755
237
if err == nil {
756
-
t.Error("Edit should fail with non-existent note ID")
238
+
t.Error("Delete should fail with non-existent note ID")
757
239
}
758
-
if !strings.Contains(err.Error(), "failed to get note") {
240
+
if !strings.Contains(err.Error(), "failed to get note") && !strings.Contains(err.Error(), "failed to find note") {
759
241
t.Errorf("Expected note not found error, got: %v", err)
760
242
}
761
243
})
762
244
763
-
t.Run("handles no editor configured", func(t *testing.T) {
764
-
_, cleanup := setupNoteTest(t)
765
-
defer cleanup()
766
-
767
-
originalEditor := os.Getenv("EDITOR")
768
-
originalPath := os.Getenv("PATH")
769
-
os.Setenv("EDITOR", "")
770
-
os.Setenv("PATH", "")
771
-
defer func() {
772
-
os.Setenv("EDITOR", originalEditor)
773
-
os.Setenv("PATH", originalPath)
774
-
}()
775
-
776
-
ctx := context.Background()
777
-
778
-
err := Create(ctx, []string{"Test Note", "Test content"})
245
+
t.Run("deletes note successfully", func(t *testing.T) {
246
+
err := handler.Create(ctx, "Note to Delete", "This will be deleted", "", false)
779
247
if err != nil {
780
248
t.Fatalf("Failed to create test note: %v", err)
781
249
}
782
250
783
-
err = Edit(ctx, []string{"1"})
784
-
if err == nil {
785
-
t.Error("Edit should fail when no editor is configured")
786
-
}
787
-
788
-
if !strings.Contains(err.Error(), "no editor configured") && !strings.Contains(err.Error(), "failed to open editor") {
789
-
t.Errorf("Expected no editor or editor failure error, got: %v", err)
790
-
}
791
-
})
792
-
793
-
t.Run("handles editor command failure", func(t *testing.T) {
794
-
_, cleanup := setupNoteTest(t)
795
-
defer cleanup()
796
-
797
-
originalEditor := os.Getenv("EDITOR")
798
-
os.Setenv("EDITOR", "nonexistent-editor-12345")
799
-
defer os.Setenv("EDITOR", originalEditor)
800
-
801
-
ctx := context.Background()
802
-
803
-
err := Create(ctx, []string{"Test Note", "Test content"})
251
+
// Delete the note (should be a high ID number since we've created many notes)
252
+
err = handler.Delete(ctx, 1)
804
253
if err != nil {
805
-
t.Fatalf("Failed to create test note: %v", err)
254
+
t.Errorf("Delete should succeed: %v", err)
806
255
}
807
256
808
-
err = Edit(ctx, []string{"1"})
257
+
err = handler.View(ctx, 1)
809
258
if err == nil {
810
-
t.Error("Edit should fail when editor command fails")
811
-
}
812
-
if !strings.Contains(err.Error(), "failed to open editor") {
813
-
t.Errorf("Expected editor failure error, got: %v", err)
259
+
t.Error("Note should be gone after deletion")
814
260
}
815
261
})
816
262
817
-
t.Run("edits note successfully with mocked editor", func(t *testing.T) {
818
-
_, cleanup := setupNoteTest(t)
819
-
defer cleanup()
263
+
t.Run("deletes note with file path", func(t *testing.T) {
264
+
filePath := createTestMarkdownFile(t, tempDir, "delete-test.md", "# Test Note\n\nTest content")
820
265
821
-
originalEditor := os.Getenv("EDITOR")
822
-
os.Setenv("EDITOR", "test-editor")
823
-
defer os.Setenv("EDITOR", originalEditor)
824
-
825
-
ctx := context.Background()
826
-
827
-
err := Create(ctx, []string{"Original Title", "Original content"})
266
+
err := handler.Create(ctx, "", "", filePath, false)
828
267
if err != nil {
829
-
t.Fatalf("Failed to create test note: %v", err)
268
+
t.Fatalf("Failed to create test note from file: %v", err)
830
269
}
831
270
832
-
handler, err := NewNoteHandler()
271
+
err = handler.Create(ctx, "File Note to Delete", "", "", false)
833
272
if err != nil {
834
-
t.Fatalf("NewNoteHandler failed: %v", err)
835
-
}
836
-
defer handler.Close()
837
-
838
-
handler.openInEditorFunc = func(editor, filePath string) error {
839
-
newContent := `# Updated Title
840
-
841
-
This is updated content.
842
-
843
-
<!-- Tags: updated, test -->`
844
-
return os.WriteFile(filePath, []byte(newContent), 0644)
273
+
t.Fatalf("Failed to create file note: %v", err)
845
274
}
846
275
847
-
err = handler.editNote(ctx, 1)
276
+
err = handler.Delete(ctx, 2)
848
277
if err != nil {
849
-
t.Errorf("Edit should succeed with mocked editor: %v", err)
278
+
t.Errorf("Delete should succeed: %v", err)
850
279
}
851
280
852
-
note, err := handler.repos.Notes.Get(ctx, 1)
853
-
if err != nil {
854
-
t.Fatalf("Failed to get updated note: %v", err)
281
+
err = handler.View(ctx, 2)
282
+
if err == nil {
283
+
t.Error("Note should be gone after deletion")
855
284
}
285
+
})
286
+
})
856
287
857
-
if note.Title != "Updated Title" {
858
-
t.Errorf("Expected title 'Updated Title', got %q", note.Title)
859
-
}
288
+
t.Run("Close", func(t *testing.T) {
289
+
testHandler, err := NewNoteHandler()
290
+
if err != nil {
291
+
t.Fatalf("Failed to create test handler: %v", err)
292
+
}
860
293
861
-
if !strings.Contains(note.Content, "This is updated content") {
862
-
t.Errorf("Expected content to contain 'This is updated content', got %q", note.Content)
863
-
}
294
+
err = testHandler.Close()
295
+
if err != nil {
296
+
t.Errorf("Close should succeed: %v", err)
297
+
}
298
+
})
864
299
865
-
expectedTags := []string{"updated", "test"}
866
-
if len(note.Tags) != len(expectedTags) {
867
-
t.Errorf("Expected %d tags, got %d", len(expectedTags), len(note.Tags))
300
+
t.Run("Helper Methods", func(t *testing.T) {
301
+
t.Run("parseNoteContent", func(t *testing.T) {
302
+
tests := []struct {
303
+
name string
304
+
content string
305
+
expectedTitle string
306
+
expectedContent string
307
+
expectedTags []string
308
+
}{
309
+
{
310
+
name: "note with title and tags",
311
+
content: "# My Note\n<!-- tags: work, personal -->\n\nContent here",
312
+
expectedTitle: "My Note",
313
+
expectedContent: "# My Note\n<!-- tags: work, personal -->\n\nContent here",
314
+
expectedTags: nil,
315
+
},
316
+
{
317
+
name: "note without title",
318
+
content: "Just some content without title",
319
+
expectedTitle: "",
320
+
expectedContent: "Just some content without title",
321
+
expectedTags: nil,
322
+
},
323
+
{
324
+
name: "note without tags",
325
+
content: "# Title Only\n\nContent here",
326
+
expectedTitle: "Title Only",
327
+
expectedContent: "# Title Only\n\nContent here",
328
+
expectedTags: nil,
329
+
},
868
330
}
869
-
for i, tag := range expectedTags {
870
-
if i >= len(note.Tags) || note.Tags[i] != tag {
871
-
t.Errorf("Expected tag %q at index %d, got %q", tag, i, note.Tags[i])
872
-
}
331
+
332
+
for _, tt := range tests {
333
+
t.Run(tt.name, func(t *testing.T) {
334
+
title, content, tags := handler.parseNoteContent(tt.content)
335
+
if title != tt.expectedTitle {
336
+
t.Errorf("Expected title %q, got %q", tt.expectedTitle, title)
337
+
}
338
+
if content != tt.expectedContent {
339
+
t.Errorf("Expected content %q, got %q", tt.expectedContent, content)
340
+
}
341
+
if len(tags) != len(tt.expectedTags) {
342
+
t.Errorf("Expected %d tags, got %d", len(tt.expectedTags), len(tags))
343
+
}
344
+
for i, tag := range tt.expectedTags {
345
+
if i < len(tags) && tags[i] != tag {
346
+
t.Errorf("Expected tag %q, got %q", tag, tags[i])
347
+
}
348
+
}
349
+
})
873
350
}
874
351
})
875
352
876
-
t.Run("handles editor cancellation (no changes)", func(t *testing.T) {
877
-
_, cleanup := setupNoteTest(t)
878
-
defer cleanup()
879
-
353
+
t.Run("getEditor", func(t *testing.T) {
880
354
originalEditor := os.Getenv("EDITOR")
881
-
os.Setenv("EDITOR", "test-editor")
882
355
defer os.Setenv("EDITOR", originalEditor)
883
356
884
-
ctx := context.Background()
357
+
t.Run("uses EDITOR environment variable", func(t *testing.T) {
358
+
os.Setenv("EDITOR", "test-editor")
359
+
editor := handler.getEditor()
360
+
if editor != "test-editor" {
361
+
t.Errorf("Expected 'test-editor', got %q", editor)
362
+
}
363
+
})
885
364
886
-
err := Create(ctx, []string{"Test Note", "Test content"})
887
-
if err != nil {
888
-
t.Fatalf("Failed to create test note: %v", err)
889
-
}
365
+
t.Run("finds available editor", func(t *testing.T) {
366
+
os.Unsetenv("EDITOR")
367
+
editor := handler.getEditor()
368
+
if editor == "" {
369
+
t.Skip("No editors available in PATH")
370
+
}
371
+
})
890
372
891
-
handler, err := NewNoteHandler()
892
-
if err != nil {
893
-
t.Fatalf("NewNoteHandler failed: %v", err)
894
-
}
895
-
defer handler.Close()
373
+
t.Run("returns empty when no editor available", func(t *testing.T) {
374
+
os.Unsetenv("EDITOR")
375
+
originalPath := os.Getenv("PATH")
376
+
os.Setenv("PATH", "")
377
+
defer os.Setenv("PATH", originalPath)
896
378
897
-
handler.openInEditorFunc = func(editor, filePath string) error {
898
-
return nil
899
-
}
900
-
901
-
err = handler.editNote(ctx, 1)
902
-
if err != nil {
903
-
t.Errorf("Edit should handle cancellation gracefully: %v", err)
904
-
}
905
-
906
-
note, err := handler.repos.Notes.Get(ctx, 1)
907
-
if err != nil {
908
-
t.Fatalf("Failed to get note: %v", err)
909
-
}
910
-
911
-
if note.Title != "Test Note" {
912
-
t.Errorf("Expected title 'Test Note', got %q", note.Title)
913
-
}
914
-
915
-
if note.Content != "Test content" {
916
-
t.Errorf("Expected content 'Test content', got %q", note.Content)
917
-
}
379
+
editor := handler.getEditor()
380
+
if editor != "" {
381
+
t.Errorf("Expected empty editor, got %q", editor)
382
+
}
383
+
})
918
384
})
919
385
})
920
386
}
+319
internal/ui/note_list.go
+319
internal/ui/note_list.go
···
1
+
// FIXME: this module is missing test coverage
2
+
package ui
3
+
4
+
import (
5
+
"context"
6
+
"fmt"
7
+
"io"
8
+
"os"
9
+
"strings"
10
+
11
+
tea "github.com/charmbracelet/bubbletea"
12
+
"github.com/charmbracelet/glamour"
13
+
"github.com/charmbracelet/lipgloss"
14
+
"github.com/stormlightlabs/noteleaf/internal/models"
15
+
"github.com/stormlightlabs/noteleaf/internal/repo"
16
+
)
17
+
18
+
// NoteListOptions configures the note list UI behavior
19
+
type NoteListOptions struct {
20
+
// Output destination (stdout for interactive, buffer for testing)
21
+
Output io.Writer
22
+
// Input source (stdin for interactive, strings reader for testing)
23
+
Input io.Reader
24
+
// Enable static mode (no interactive components)
25
+
Static bool
26
+
// Show archived notes
27
+
ShowArchived bool
28
+
// Filter by tags
29
+
Tags []string
30
+
}
31
+
32
+
// NoteList handles note browsing and viewing UI
33
+
type NoteList struct {
34
+
repo *repo.NoteRepository
35
+
opts NoteListOptions
36
+
}
37
+
38
+
// NewNoteList creates a new note list UI component
39
+
func NewNoteList(repo *repo.NoteRepository, opts NoteListOptions) *NoteList {
40
+
if opts.Output == nil {
41
+
opts.Output = os.Stdout
42
+
}
43
+
if opts.Input == nil {
44
+
opts.Input = os.Stdin
45
+
}
46
+
return &NoteList{repo: repo, opts: opts}
47
+
}
48
+
49
+
type noteListModel struct {
50
+
notes []*models.Note
51
+
selected int
52
+
viewing bool
53
+
viewContent string
54
+
err error
55
+
repo *repo.NoteRepository
56
+
opts NoteListOptions
57
+
currentPage int
58
+
}
59
+
60
+
type notesLoadedMsg []*models.Note
61
+
type noteViewMsg string
62
+
type errorNoteMsg error
63
+
64
+
func (m noteListModel) Init() tea.Cmd {
65
+
return m.loadNotes()
66
+
}
67
+
68
+
func (m noteListModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
69
+
switch msg := msg.(type) {
70
+
case tea.KeyMsg:
71
+
if m.viewing {
72
+
switch msg.String() {
73
+
case "q", "esc", "backspace":
74
+
m.viewing = false
75
+
m.viewContent = ""
76
+
return m, nil
77
+
}
78
+
return m, nil
79
+
}
80
+
81
+
switch msg.String() {
82
+
case "ctrl+c", "q":
83
+
return m, tea.Quit
84
+
case "up", "k":
85
+
if m.selected > 0 {
86
+
m.selected--
87
+
}
88
+
case "down", "j":
89
+
if m.selected < len(m.notes)-1 {
90
+
m.selected++
91
+
}
92
+
case "enter", "v":
93
+
if len(m.notes) > 0 && m.selected < len(m.notes) {
94
+
return m, m.viewNote(m.notes[m.selected])
95
+
}
96
+
case "r":
97
+
return m, m.loadNotes()
98
+
}
99
+
case notesLoadedMsg:
100
+
m.notes = []*models.Note(msg)
101
+
case noteViewMsg:
102
+
m.viewContent = string(msg)
103
+
m.viewing = true
104
+
case errorNoteMsg:
105
+
m.err = error(msg)
106
+
}
107
+
return m, nil
108
+
}
109
+
110
+
func (m noteListModel) View() string {
111
+
var s strings.Builder
112
+
113
+
style := lipgloss.NewStyle().Foreground(lipgloss.Color("86"))
114
+
titleStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("205")).Bold(true)
115
+
selectedStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("212")).Bold(true)
116
+
headerStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("39")).Bold(true)
117
+
118
+
if m.viewing {
119
+
s.WriteString(m.viewContent)
120
+
s.WriteString("\n\n")
121
+
s.WriteString(style.Render("Press q/esc/backspace to return to list"))
122
+
return s.String()
123
+
}
124
+
125
+
s.WriteString(titleStyle.Render("Notes"))
126
+
s.WriteString("\n\n")
127
+
128
+
if m.err != nil {
129
+
s.WriteString(fmt.Sprintf("Error: %s", m.err))
130
+
return s.String()
131
+
}
132
+
133
+
if len(m.notes) == 0 {
134
+
s.WriteString("No notes found")
135
+
s.WriteString("\n\n")
136
+
s.WriteString(style.Render("Press r to refresh, q to quit"))
137
+
return s.String()
138
+
}
139
+
140
+
headerLine := fmt.Sprintf("%-4s %-30s %-20s %-15s", "ID", "Title", "Tags", "Modified")
141
+
s.WriteString(headerStyle.Render(headerLine))
142
+
s.WriteString("\n")
143
+
s.WriteString(headerStyle.Render(strings.Repeat("─", 70)))
144
+
s.WriteString("\n")
145
+
146
+
for i, note := range m.notes {
147
+
prefix := " "
148
+
if i == m.selected {
149
+
prefix = "> "
150
+
}
151
+
152
+
title := note.Title
153
+
if len(title) > 28 {
154
+
title = title[:25] + "..."
155
+
}
156
+
157
+
tags := ""
158
+
if len(note.Tags) > 0 {
159
+
tags = strings.Join(note.Tags, ", ")
160
+
if len(tags) > 18 {
161
+
tags = tags[:15] + "..."
162
+
}
163
+
}
164
+
165
+
modified := note.Modified.Format("2006-01-02 15:04")
166
+
167
+
line := fmt.Sprintf("%s%-4d %-30s %-20s %-15s",
168
+
prefix, note.ID, title, tags, modified)
169
+
170
+
if i == m.selected {
171
+
s.WriteString(selectedStyle.Render(line))
172
+
} else {
173
+
s.WriteString(style.Render(line))
174
+
}
175
+
s.WriteString("\n")
176
+
}
177
+
178
+
s.WriteString("\n")
179
+
s.WriteString(style.Render("Use ↑/↓ to navigate, Enter/v to view, r to refresh, q to quit"))
180
+
181
+
return s.String()
182
+
}
183
+
184
+
func (m noteListModel) loadNotes() tea.Cmd {
185
+
return func() tea.Msg {
186
+
opts := repo.NoteListOptions{
187
+
Tags: m.opts.Tags,
188
+
}
189
+
if !m.opts.ShowArchived {
190
+
archived := false
191
+
opts.Archived = &archived
192
+
}
193
+
194
+
notes, err := m.repo.List(context.Background(), opts)
195
+
if err != nil {
196
+
return errorNoteMsg(err)
197
+
}
198
+
199
+
return notesLoadedMsg(notes)
200
+
}
201
+
}
202
+
203
+
func (m noteListModel) viewNote(note *models.Note) tea.Cmd {
204
+
return func() tea.Msg {
205
+
renderer, err := glamour.NewTermRenderer(
206
+
glamour.WithAutoStyle(),
207
+
glamour.WithWordWrap(80),
208
+
)
209
+
if err != nil {
210
+
return errorNoteMsg(fmt.Errorf("failed to create markdown renderer: %w", err))
211
+
}
212
+
213
+
content := m.formatNoteForView(note)
214
+
rendered, err := renderer.Render(content)
215
+
if err != nil {
216
+
return errorNoteMsg(fmt.Errorf("failed to render markdown: %w", err))
217
+
}
218
+
219
+
return noteViewMsg(rendered)
220
+
}
221
+
}
222
+
223
+
func (m noteListModel) formatNoteForView(note *models.Note) string {
224
+
var content strings.Builder
225
+
226
+
content.WriteString("# " + note.Title + "\n\n")
227
+
228
+
if len(note.Tags) > 0 {
229
+
content.WriteString("**Tags:** ")
230
+
for i, tag := range note.Tags {
231
+
if i > 0 {
232
+
content.WriteString(", ")
233
+
}
234
+
content.WriteString("`" + tag + "`")
235
+
}
236
+
content.WriteString("\n\n")
237
+
}
238
+
239
+
content.WriteString("**Created:** " + note.Created.Format("2006-01-02 15:04") + "\n")
240
+
content.WriteString("**Modified:** " + note.Modified.Format("2006-01-02 15:04") + "\n\n")
241
+
content.WriteString("---\n\n")
242
+
243
+
noteContent := strings.TrimSpace(note.Content)
244
+
if !strings.HasPrefix(noteContent, "# ") {
245
+
content.WriteString(noteContent)
246
+
} else {
247
+
lines := strings.Split(noteContent, "\n")
248
+
if len(lines) > 1 {
249
+
content.WriteString(strings.Join(lines[1:], "\n"))
250
+
}
251
+
}
252
+
253
+
return content.String()
254
+
}
255
+
256
+
// Browse opens an interactive TUI for navigating and viewing notes
257
+
func (nl *NoteList) Browse(ctx context.Context) error {
258
+
if nl.opts.Static {
259
+
return nl.staticList(ctx)
260
+
}
261
+
262
+
model := noteListModel{
263
+
repo: nl.repo,
264
+
opts: nl.opts,
265
+
currentPage: 1,
266
+
}
267
+
268
+
program := tea.NewProgram(model, tea.WithInput(nl.opts.Input), tea.WithOutput(nl.opts.Output))
269
+
270
+
_, err := program.Run()
271
+
return err
272
+
}
273
+
274
+
func (nl *NoteList) staticList(ctx context.Context) error {
275
+
opts := repo.NoteListOptions{
276
+
Tags: nl.opts.Tags,
277
+
}
278
+
if !nl.opts.ShowArchived {
279
+
archived := false
280
+
opts.Archived = &archived
281
+
}
282
+
283
+
notes, err := nl.repo.List(ctx, opts)
284
+
if err != nil {
285
+
fmt.Fprintf(nl.opts.Output, "Error: %s\n", err)
286
+
return err
287
+
}
288
+
289
+
fmt.Fprintf(nl.opts.Output, "Notes\n\n")
290
+
291
+
if len(notes) == 0 {
292
+
fmt.Fprintf(nl.opts.Output, "No notes found\n")
293
+
return nil
294
+
}
295
+
296
+
fmt.Fprintf(nl.opts.Output, "%-4s %-30s %-20s %-15s\n", "ID", "Title", "Tags", "Modified")
297
+
fmt.Fprintf(nl.opts.Output, "%s\n", strings.Repeat("─", 70))
298
+
299
+
for _, note := range notes {
300
+
title := note.Title
301
+
if len(title) > 28 {
302
+
title = title[:25] + "..."
303
+
}
304
+
305
+
tags := ""
306
+
if len(note.Tags) > 0 {
307
+
tags = strings.Join(note.Tags, ", ")
308
+
if len(tags) > 18 {
309
+
tags = tags[:15] + "..."
310
+
}
311
+
}
312
+
313
+
modified := note.Modified.Format("2006-01-02 15:04")
314
+
315
+
fmt.Fprintf(nl.opts.Output, "%-4d %-30s %-20s %-15s\n", note.ID, title, tags, modified)
316
+
}
317
+
318
+
return nil
319
+
}