From e29baf8fd049214fe4ec7188cfe11f39ca197639 Mon Sep 17 00:00:00 2001 From: Jonathan Crockett Date: Wed, 29 Jul 2026 01:34:08 -0400 Subject: [PATCH 1/2] Return post-mutation data from store ops; construct the CLI MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Store.Mutate already produced the post-mutation Data, but every operation threw it away and returned only its own result. All three frontends then read the file a second time to recover it, which is where a surprising amount of this codebase came from: - cli.quadrantLabels and mcpserver.labelsOf, two near-duplicate helpers that each did that second read and swallowed its error as "cosmetic" - seven copies of the same closure in the TUI, each ending in store.Load() - a window where the label a command printed came from a later file state than the mutation it was describing Mutating ops now return (result, Data, error). All of the above is deleted. The TUI's mutate reported failure by writing into m.status; two callers sniffed `if m.status == ""` to detect success and three overwrote it unconditionally, so a failed complete, delete, or move printed "done: ..." over its own error while the row stayed on screen. It is now apply(d, err) bool, and success messages are set inside the branch. Input-mode state is set and cleared through enterInput/exitInput, closing a placeholder that leaked from a quadrant rename into the next task edit. The CLI was one 310-line init() mutating a package-level rootCmd, which made flag variables process-global and every RunE unreachable from a test: internal/cli sat at 18.9% coverage with `ike mcp enable|disable` — the consent toggle for agent access — at 0%. Commands are now constructed by newXCmd(open) under NewRootCmd, print to cmd.OutOrStdout(), and share a withStore adapter. openStore, a pure pass-through wrapper, is gone. Coverage: cli 18.9% -> 90.3%, task 81.1% -> 100%, mcpserver 85.9% -> 91.5%, store 85.1% -> 86.1%. 103 tests -> 127. Also folded in, since the above needed them: - taskTool/listTool adapters in mcpserver, replacing eight byte-identical tool bodies - Data.List and Data.ListArchive as the single definitions of each order. The TUI reversed data.Archive instead, which agrees with ListArchive only while every archived task carries a done_at - task.ArchiveRow, so `ike archive` and the TUI archive view cannot drift - time.RFC3339 in place of the layout written out by hand - ops_test.go split into ops/history/labels/mcp, keeping every file under 1000 lines ListArchive keeps make+copy rather than slices.Clone: Clone preserves nil, which made `ike archive --json` emit null instead of []. Pinned by test. Co-Authored-By: Claude Opus 5 (1M context) --- CLAUDE.md | 12 +- internal/cli/commands.go | 307 ++++++------ internal/cli/commands_test.go | 374 ++++++++++++-- internal/cli/mcp.go | 107 ++-- internal/cli/root.go | 58 ++- internal/mcpserver/server.go | 153 +++--- internal/mcpserver/server_test.go | 2 +- internal/store/durability_test.go | 20 +- internal/store/history_test.go | 383 ++++++++++++++ internal/store/labels_test.go | 168 +++++++ internal/store/mcp_test.go | 192 +++++++ internal/store/ops.go | 109 ++-- internal/store/ops_test.go | 796 ++++-------------------------- internal/store/store_test.go | 34 +- internal/task/task.go | 16 + internal/task/task_test.go | 57 +++ internal/tui/model.go | 218 ++++---- internal/tui/model_test.go | 98 +++- internal/tui/view.go | 10 +- 19 files changed, 1823 insertions(+), 1291 deletions(-) create mode 100644 internal/store/history_test.go create mode 100644 internal/store/labels_test.go create mode 100644 internal/store/mcp_test.go diff --git a/CLAUDE.md b/CLAUDE.md index a514e84..1f3d17a 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -22,6 +22,10 @@ IKE_DATA_FILE=$(mktemp -d)/t.json go run . list # run against a scratch data f Dependency direction: `cli` → `tui`/`mcpserver` → `store` → `task`. **All business logic lives in `internal/store/ops.go`** (Add/Complete/Restore/Move/Reorder/Rename/Delete/SetQuadrantLabel/Undo/Redo/List/ListArchive); the three frontends must stay thin wrappers over it. `internal/task` is the zero-dependency domain (Task struct, Quadrant 1–4 with default labels, and `Less`/`SortOrder`, the single definition of display order). +**Every mutating op returns the post-mutation `Data` alongside its own result** — `Add` is `(task.Task, Data, error)`, `Undo` is `(string, Data, error)`. `Mutate` already produces that value, so handing it back costs nothing and spares the caller a second read. Frontends must render the outcome from it (`d.Labels.Of(q)`, `d.List(q)`) rather than calling `Load`/`QuadrantLabels` again: a follow-up read observes a *later* file state, and the helpers that used to do it (`cli.quadrantLabels`, `mcpserver.labelsOf`) both swallowed the error to stay "cosmetic". `SetMCPEnabled` is the deliberate exception — nothing renders from it. + +Listing order has exactly one definition each, as pure methods on `Data`: **`d.List(q)`** (active tasks, quadrant then rank then ID) and **`d.ListArchive()`** (newest completion first, unstamped tasks by ID). `Store.List`/`Store.ListArchive` are `Load` plus these; the TUI calls them directly on the data it already holds. The TUI used to reverse `data.Archive` instead, which agrees with `ListArchive` only while every archived task carries a `done_at`. `ListArchive` must keep returning a non-nil empty slice — `ike archive --json` emits `[]`, not `null`. + Quadrant headings are user-customizable. `task.Quadrant.Label()` gives the **default** name; `store.Data.Labels` (a sparse `map[Quadrant]string`, only renamed quadrants present) holds overrides, and **`Labels.Of(q)` is the only correct way to render a quadrant name** — it is nil-safe, so `d.Labels.Of(q)` works on a store that has never been renamed. Never print `q.Label()` in a frontend. Clearing a label deletes the map entry rather than storing `""`, so later changes to the defaults still reach users who reset. The quadrant *number* is the stable identifier for classification and scripting; only the display name varies. Concurrency contract (`internal/store/store.go`): every mutation goes through `Store.Mutate`, which flocks a **sidecar** `tasks.json.lock` (locking the data file itself would break — atomic rename replaces the inode), re-reads fresh inside the lock, applies the change, and writes via temp-file + `os.Rename`. Never write the data file any other way. Completing a task moves it from `tasks` to `archive` with `DoneAt` stamped (`Restore` reverses that); IDs are monotonic via `next_id` and never reused. Deleting skips the archive. @@ -41,7 +45,13 @@ Undo/redo is snapshot-based, with two stacks in the data file (each capped at `u Data file version is **2** (ranks + history stacks). `readFile` accepts version 1 and upgrades in memory; the next write persists version 2. A newer version than `currentVersion` is still a hard error. The `redo` field was added within version 2 as `omitempty` rather than bumping again — losing redo history to an older binary is harmless, whereas a bump makes older binaries refuse the file outright. -The TUI (`internal/tui`) is a single `Model` with a mode enum (normal/input/move/archive); `model.go` holds state + key handling, `view.go` all rendering. It re-renders from `Mutate` results and polls file mtime every 2s to pick up CLI/MCP writes. `archCursor` indexes `archiveList()` (newest first), *not* `data.Archive` — use the helper when acting on the selected archive row. +The TUI (`internal/tui`) is a single `Model` with a mode enum (normal/input/move/archive); `model.go` holds state + key handling, `view.go` all rendering. It re-renders from the `Data` each op returns and polls file mtime every 2s to pick up CLI/MCP writes. `archCursor` indexes `data.ListArchive()` (newest first), *not* `data.Archive` — use the helper when acting on the selected archive row. + +Every mutation goes through **`m.apply(d, err) bool`**, which either shows the error or re-renders, and *returns whether it succeeded*. Set a success status only inside `if m.apply(...)`. Signalling failure through `m.status` and sniffing it afterwards is what let a failed complete/delete/move print "done: …" over its own error while the row stayed on screen (`TestFailedMutationsDoNotReportSuccess`). Enter and leave input mode only via **`enterInput`/`exitInput`**, which set and clear all of `mode`/`editingID`/`labelTarget`/value/placeholder together — setting them field-by-field leaked the quadrant-rename placeholder into the next task edit. + +The CLI is **constructed, not registered**: `NewRootCmd(open)` builds the whole tree and every command has a `newXCmd(open) *cobra.Command` constructor, where `open` yields the store (lazily, inside `RunE`, so `ike --help` still works with a broken `IKE_DATA_FILE`). Command bodies wrap in `withStore` and print to `cmd.OutOrStdout()`. Do not go back to `init()` plus a package-level `rootCmd`: that made flag variables process-global and left every `RunE` untestable — `internal/cli` sat at 18.9% coverage with `ike mcp enable|disable` at 0%, i.e. the consent toggle was tested everywhere except where users invoke it. Tests build a tree over a scratch file with `runCLI`. + +Store tests are split by concern: `ops_test.go` (tasks, ordering, ranks), `history_test.go` (undo/redo), `labels_test.go`, `mcp_test.go` (the gate), `store_test.go` + `durability_test.go` (the write path). Keep new tests in the matching file rather than growing one past ~1000 lines. ## Gotchas diff --git a/internal/cli/commands.go b/internal/cli/commands.go index 88a4f0a..353250e 100644 --- a/internal/cli/commands.go +++ b/internal/cli/commands.go @@ -3,7 +3,7 @@ package cli import ( "encoding/json" "fmt" - "os" + "io" "strconv" "github.com/spf13/cobra" @@ -20,24 +20,21 @@ func parseID(s string) (int, error) { return id, nil } -func printJSON(v any) error { - enc := json.NewEncoder(os.Stdout) - enc.SetIndent("", " ") - return enc.Encode(v) -} - -// quadrantLabels resolves the display names of the four quadrants. On a read -// error it returns nil, which still resolves to the built-in defaults — a -// label lookup should never be the thing that fails a command. -func quadrantLabels(s *store.Store) store.Labels { - l, err := s.QuadrantLabels() +func parseQuadrant(s string) (task.Quadrant, error) { + q, err := strconv.Atoi(s) if err != nil { - return nil + return 0, fmt.Errorf("invalid quadrant %q", s) } - return l + return task.Quadrant(q), nil +} + +func printJSON(w io.Writer, v any) error { + enc := json.NewEncoder(w) + enc.SetIndent("", " ") + return enc.Encode(v) } -func printGrouped(tasks []task.Task, labels store.Labels) { +func printGrouped(w io.Writer, tasks []task.Task, labels store.Labels) { byQ := map[task.Quadrant][]task.Task{} for _, t := range tasks { byQ[t.Quadrant] = append(byQ[t.Quadrant], t) @@ -46,162 +43,157 @@ func printGrouped(tasks []task.Task, labels store.Labels) { if len(byQ[q]) == 0 { continue } - fmt.Printf("%d · %s\n", q, labels.Of(q)) + fmt.Fprintf(w, "%d · %s\n", q, labels.Of(q)) for _, t := range byQ[q] { - fmt.Printf(" %3d %s\n", t.ID, t.DisplayTitle()) + fmt.Fprintf(w, " %3d %s\n", t.ID, t.DisplayTitle()) } } } -func init() { - var addQuadrant int - addCmd := &cobra.Command{ +func newAddCmd(open opener) *cobra.Command { + var quadrant int + cmd := &cobra.Command{ Use: "add ", Short: "Add a task", Args: cobra.ExactArgs(1), - RunE: func(cmd *cobra.Command, args []string) error { - s, err := openStore() + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { + t, d, err := s.Add(args[0], task.Quadrant(quadrant)) if err != nil { return err } - t, err := s.Add(args[0], task.Quadrant(addQuadrant)) - if err != nil { - return err - } - fmt.Printf("added %d [%s] %s\n", t.ID, quadrantLabels(s).Of(t.Quadrant), t.DisplayTitle()) + fmt.Fprintf(cmd.OutOrStdout(), "added %d [%s] %s\n", + t.ID, d.Labels.Of(t.Quadrant), t.DisplayTitle()) return nil - }, + }), } - addCmd.Flags().IntVarP(&addQuadrant, "quadrant", "q", 2, + cmd.Flags().IntVarP(&quadrant, "quadrant", "q", 2, "quadrant: 1=urgent+important, 2=important, 3=urgent, 4=neither") + return cmd +} - var listQuadrant int - var listJSON bool - listCmd := &cobra.Command{ +func newListCmd(open opener) *cobra.Command { + var quadrant int + var asJSON bool + cmd := &cobra.Command{ Use: "list", Short: "List active tasks", Args: cobra.NoArgs, - RunE: func(cmd *cobra.Command, args []string) error { - s, err := openStore() + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { + d, err := s.Load() if err != nil { return err } - tasks, err := s.List(task.Quadrant(listQuadrant)) - if err != nil { - return err - } - if listJSON { - return printJSON(tasks) + tasks := d.List(task.Quadrant(quadrant)) + out := cmd.OutOrStdout() + if asJSON { + return printJSON(out, tasks) } if len(tasks) == 0 { - fmt.Println("no active tasks") + fmt.Fprintln(out, "no active tasks") return nil } - printGrouped(tasks, quadrantLabels(s)) + printGrouped(out, tasks, d.QuadrantLabels()) return nil - }, + }), } - listCmd.Flags().IntVarP(&listQuadrant, "quadrant", "q", 0, "filter to quadrant 1-4 (0 = all)") - listCmd.Flags().BoolVar(&listJSON, "json", false, "output JSON") + cmd.Flags().IntVarP(&quadrant, "quadrant", "q", 0, "filter to quadrant 1-4 (0 = all)") + cmd.Flags().BoolVar(&asJSON, "json", false, "output JSON") + return cmd +} - doneCmd := &cobra.Command{ +func newDoneCmd(open opener) *cobra.Command { + return &cobra.Command{ Use: "done <id>", Short: "Complete a task (moves it to the archive)", Args: cobra.ExactArgs(1), - RunE: func(cmd *cobra.Command, args []string) error { + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { id, err := parseID(args[0]) if err != nil { return err } - s, err := openStore() + t, _, err := s.Complete(id) if err != nil { return err } - t, err := s.Complete(id) - if err != nil { - return err - } - fmt.Printf("done %d %s\n", t.ID, t.DisplayTitle()) + fmt.Fprintf(cmd.OutOrStdout(), "done %d %s\n", t.ID, t.DisplayTitle()) return nil - }, + }), } +} - mvCmd := &cobra.Command{ +func newMvCmd(open opener) *cobra.Command { + return &cobra.Command{ Use: "mv <id> <quadrant>", Short: "Move a task to another quadrant", Args: cobra.ExactArgs(2), - RunE: func(cmd *cobra.Command, args []string) error { + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { id, err := parseID(args[0]) if err != nil { return err } - q, err := strconv.Atoi(args[1]) - if err != nil { - return fmt.Errorf("invalid quadrant %q", args[1]) - } - s, err := openStore() + q, err := parseQuadrant(args[1]) if err != nil { return err } - t, err := s.Move(id, task.Quadrant(q)) + t, d, err := s.Move(id, q) if err != nil { return err } - fmt.Printf("moved %d to %d · %s\n", t.ID, q, quadrantLabels(s).Of(t.Quadrant)) + fmt.Fprintf(cmd.OutOrStdout(), "moved %d to %d · %s\n", + t.ID, t.Quadrant, d.Labels.Of(t.Quadrant)) return nil - }, + }), } +} - rmCmd := &cobra.Command{ +func newRmCmd(open opener) *cobra.Command { + return &cobra.Command{ Use: "rm <id>", Short: "Delete a task permanently (does not archive)", Args: cobra.ExactArgs(1), - RunE: func(cmd *cobra.Command, args []string) error { + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { id, err := parseID(args[0]) if err != nil { return err } - s, err := openStore() - if err != nil { - return err - } - t, err := s.Delete(id) + t, _, err := s.Delete(id) if err != nil { return err } - fmt.Printf("deleted %d %s\n", t.ID, t.DisplayTitle()) + fmt.Fprintf(cmd.OutOrStdout(), "deleted %d %s\n", t.ID, t.DisplayTitle()) return nil - }, + }), } +} - restoreCmd := &cobra.Command{ +func newRestoreCmd(open opener) *cobra.Command { + return &cobra.Command{ Use: "restore <id>", Short: "Un-archive a completed task, putting it back in its quadrant", Args: cobra.ExactArgs(1), - RunE: func(cmd *cobra.Command, args []string) error { + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { id, err := parseID(args[0]) if err != nil { return err } - s, err := openStore() - if err != nil { - return err - } - t, err := s.Restore(id) + t, d, err := s.Restore(id) if err != nil { return err } - fmt.Printf("restored %d to %d · %s %s\n", t.ID, t.Quadrant, quadrantLabels(s).Of(t.Quadrant), t.DisplayTitle()) + fmt.Fprintf(cmd.OutOrStdout(), "restored %d to %d · %s %s\n", + t.ID, t.Quadrant, d.Labels.Of(t.Quadrant), t.DisplayTitle()) return nil - }, + }), } +} - reorderCmd := &cobra.Command{ +func newReorderCmd(open opener) *cobra.Command { + return &cobra.Command{ Use: "reorder <id> <up|down|top|bottom>", Short: "Move a task up or down within its quadrant", Args: cobra.ExactArgs(2), ValidArgs: []string{"up", "down", "top", "bottom"}, - RunE: func(cmd *cobra.Command, args []string) error { + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { id, err := parseID(args[0]) if err != nil { return err @@ -220,145 +212,132 @@ func init() { default: return fmt.Errorf("invalid direction %q: want up, down, top, or bottom", args[1]) } - s, err := openStore() - if err != nil { - return err - } - t, err := s.Reorder(id, delta) + t, d, err := s.Reorder(id, delta) if err != nil { return err } - fmt.Printf("moved %d %s %d · %s\n", t.ID, where, t.Quadrant, quadrantLabels(s).Of(t.Quadrant)) + fmt.Fprintf(cmd.OutOrStdout(), "moved %d %s %d · %s\n", + t.ID, where, t.Quadrant, d.Labels.Of(t.Quadrant)) return nil - }, + }), } +} - undoCmd := &cobra.Command{ +func newUndoCmd(open opener) *cobra.Command { + return &cobra.Command{ Use: "undo", Short: "Undo the last change made from any frontend (TUI, CLI, or MCP)", Args: cobra.NoArgs, - RunE: func(cmd *cobra.Command, args []string) error { - s, err := openStore() - if err != nil { - return err - } - label, err := s.Undo() + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { + label, _, err := s.Undo() if err != nil { return err } - fmt.Printf("undid %s\n", label) + fmt.Fprintf(cmd.OutOrStdout(), "undid %s\n", label) return nil - }, + }), } +} - redoCmd := &cobra.Command{ +func newRedoCmd(open opener) *cobra.Command { + return &cobra.Command{ Use: "redo", Short: "Re-apply the last undone change (until the next change discards it)", Args: cobra.NoArgs, - RunE: func(cmd *cobra.Command, args []string) error { - s, err := openStore() - if err != nil { - return err - } - label, err := s.Redo() + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { + label, _, err := s.Redo() if err != nil { return err } - fmt.Printf("redid %s\n", label) + fmt.Fprintf(cmd.OutOrStdout(), "redid %s\n", label) return nil - }, + }), } +} - var labelReset bool - labelCmd := &cobra.Command{ +func newLabelCmd(open opener) *cobra.Command { + var reset bool + cmd := &cobra.Command{ Use: "label [quadrant] [name]", Short: "Show or change the quadrant headings", Long: "With no arguments, print the four quadrant headings.\n" + "With a quadrant and a name, rename that quadrant.\n" + "Pass --reset (or an empty name) to restore the built-in default.", Args: cobra.MaximumNArgs(2), - RunE: func(cmd *cobra.Command, args []string) error { - s, err := openStore() - if err != nil { - return err - } + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { if len(args) == 0 { - if labelReset { - return fmt.Errorf("--reset needs a quadrant: ike label <1-4> --reset") - } - labels, err := s.QuadrantLabels() - if err != nil { - return err - } - for q := task.Do; q <= task.Eliminate; q++ { - marker := "" - if labels.IsCustom(q) { - marker = fmt.Sprintf(" (default: %s)", q.Label()) - } - fmt.Printf("%d · %s%s\n", q, labels.Of(q), marker) - } - return nil + return printLabels(cmd, s, reset) } - - q, err := strconv.Atoi(args[0]) + q, err := parseQuadrant(args[0]) if err != nil { - return fmt.Errorf("invalid quadrant %q", args[0]) + return err } name := "" if len(args) == 2 { name = args[1] } - if labelReset { - if name != "" { - return fmt.Errorf("pass a name or --reset, not both") - } - } else if len(args) < 2 { + if reset && name != "" { + return fmt.Errorf("pass a name or --reset, not both") + } + if !reset && len(args) < 2 { return fmt.Errorf("give a name to set, or --reset to restore the default") } - - result, err := s.SetQuadrantLabel(task.Quadrant(q), name) + result, _, err := s.SetQuadrantLabel(q, name) if err != nil { return err } - fmt.Printf("quadrant %d is now %s\n", q, result) + fmt.Fprintf(cmd.OutOrStdout(), "quadrant %d is now %s\n", q, result) return nil - }, + }), + } + cmd.Flags().BoolVar(&reset, "reset", false, "restore the built-in default name") + return cmd +} + +// printLabels handles `ike label` with no arguments. +func printLabels(cmd *cobra.Command, s *store.Store, reset bool) error { + if reset { + return fmt.Errorf("--reset needs a quadrant: ike label <1-4> --reset") + } + labels, err := s.QuadrantLabels() + if err != nil { + return err } - labelCmd.Flags().BoolVar(&labelReset, "reset", false, "restore the built-in default name") + for q := task.Do; q <= task.Eliminate; q++ { + marker := "" + if labels.IsCustom(q) { + marker = fmt.Sprintf(" (default: %s)", q.Label()) + } + fmt.Fprintf(cmd.OutOrStdout(), "%d · %s%s\n", q, labels.Of(q), marker) + } + return nil +} - var archiveJSON bool - archiveCmd := &cobra.Command{ +func newArchiveCmd(open opener) *cobra.Command { + var asJSON bool + cmd := &cobra.Command{ Use: "archive", Short: "List completed tasks, newest first", Args: cobra.NoArgs, - RunE: func(cmd *cobra.Command, args []string) error { - s, err := openStore() - if err != nil { - return err - } + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { arch, err := s.ListArchive() if err != nil { return err } - if archiveJSON { - return printJSON(arch) + out := cmd.OutOrStdout() + if asJSON { + return printJSON(out, arch) } if len(arch) == 0 { - fmt.Println("archive is empty") + fmt.Fprintln(out, "archive is empty") return nil } for _, t := range arch { - when := "" - if t.DoneAt != nil { - when = t.DoneAt.Local().Format("2006-01-02") - } - fmt.Printf(" %3d %s %s\n", t.ID, when, t.DisplayTitle()) + fmt.Fprintln(out, t.ArchiveRow(t.DisplayTitle())) } return nil - }, + }), } - archiveCmd.Flags().BoolVar(&archiveJSON, "json", false, "output JSON") - - rootCmd.AddCommand(addCmd, listCmd, doneCmd, mvCmd, rmCmd, archiveCmd, - restoreCmd, reorderCmd, undoCmd, redoCmd, labelCmd) + cmd.Flags().BoolVar(&asJSON, "json", false, "output JSON") + return cmd } diff --git a/internal/cli/commands_test.go b/internal/cli/commands_test.go index bb87f2e..3f076de 100644 --- a/internal/cli/commands_test.go +++ b/internal/cli/commands_test.go @@ -2,7 +2,6 @@ package cli import ( "bytes" - "io" "os" "path/filepath" "strings" @@ -13,33 +12,33 @@ import ( "github.com/jonascript/ike/internal/task" ) -// captureStdout runs fn with os.Stdout redirected and returns what it wrote. -// The print helpers write to os.Stdout directly, which is what `ike list` -// actually does, so this tests the real output path rather than a stand-in. -func captureStdout(t *testing.T, fn func()) string { +// scratch returns a data file path in a fresh temp directory. Nothing here ever +// touches the real matrix. +func scratch(t *testing.T) string { t.Helper() - r, w, err := os.Pipe() - if err != nil { - t.Fatal(err) - } - orig := os.Stdout - os.Stdout = w - defer func() { os.Stdout = orig }() + return filepath.Join(t.TempDir(), "tasks.json") +} - done := make(chan string, 1) - go func() { - var buf bytes.Buffer - _, _ = io.Copy(&buf, r) - done <- buf.String() - }() +// runCLI builds the command tree over path and runs it, returning what the +// command printed. Each call constructs a fresh tree, so flag values cannot +// leak between invocations the way package-level flag variables did. +func runCLI(t *testing.T, path string, args ...string) (string, error) { + t.Helper() + root := NewRootCmd(func() (*store.Store, error) { return store.OpenAt(path), nil }) + var out, errOut bytes.Buffer + root.SetOut(&out) + root.SetErr(&errOut) + root.SetArgs(args) + err := root.Execute() + return out.String(), err +} - fn() - if err := w.Close(); err != nil { - t.Fatal(err) - } - out := <-done - if err := r.Close(); err != nil { - t.Fatal(err) +// mustRunCLI runs a command that is expected to succeed. +func mustRunCLI(t *testing.T, path string, args ...string) string { + t.Helper() + out, err := runCLI(t, path, args...) + if err != nil { + t.Fatalf("ike %s: %v", strings.Join(args, " "), err) } return out } @@ -58,7 +57,6 @@ func TestParseID(t *testing.T) { {"abc", 0, true}, {"1.5", 0, true}, {"3x", 0, true}, - {" 4", 0, true}, } for _, c := range cases { got, err := parseID(c.in) @@ -69,10 +67,6 @@ func TestParseID(t *testing.T) { if err == nil && got != c.want { t.Errorf("parseID(%q) = %d, want %d", c.in, got, c.want) } - // The message has to quote the offending input to be useful. - if err != nil && !strings.Contains(err.Error(), c.in) { - t.Errorf("parseID(%q) error %q should name the bad input", c.in, err) - } } } @@ -83,7 +77,8 @@ func TestPrintGrouped(t *testing.T) { {ID: 2, Title: "hand off", Quadrant: task.Delegate}, {ID: 3, Title: "drop this", Quadrant: task.Eliminate}, } - got := captureStdout(t, func() { printGrouped(tasks, nil) }) + var buf bytes.Buffer + printGrouped(&buf, tasks, nil) want := "1 · Do It First\n" + " 1 ship it\n" + @@ -93,7 +88,7 @@ func TestPrintGrouped(t *testing.T) { " 2 hand off\n" + "4 · Consider Eliminating It\n" + " 3 drop this\n" - if got != want { + if got := buf.String(); got != want { t.Errorf("printGrouped output:\n%q\nwant:\n%q", got, want) } } @@ -104,10 +99,11 @@ func TestPrintGroupedSkipsEmptyAndUsesCustomLabels(t *testing.T) { tasks := []task.Task{{ID: 5, Title: "only one", Quadrant: task.Delegate}} labels := store.Labels{task.Delegate: "Pass Along"} - got := captureStdout(t, func() { printGrouped(tasks, labels) }) + var buf bytes.Buffer + printGrouped(&buf, tasks, labels) want := "3 · Pass Along\n 5 only one\n" - if got != want { + if got := buf.String(); got != want { t.Errorf("printGrouped output:\n%q\nwant:\n%q", got, want) } } @@ -123,7 +119,9 @@ func TestPrintGroupedNeutralizesEscapeSequences(t *testing.T) { tasks := []task.Task{{ID: 1, Title: overwrite, Quadrant: task.Do}} labels := store.Labels{task.Do: "head\x1b[31mer"} - got := captureStdout(t, func() { printGrouped(tasks, labels) }) + var buf bytes.Buffer + printGrouped(&buf, tasks, labels) + got := buf.String() if strings.ContainsRune(got, 0x1b) { t.Errorf("output still contains an escape: %q", got) @@ -152,11 +150,11 @@ func TestPrintJSONKeepsRawTitleEscaped(t *testing.T) { Quadrant: task.Do, CreatedAt: time.Unix(0, 0).UTC(), }} - got := captureStdout(t, func() { - if err := printJSON(tasks); err != nil { - t.Error(err) - } - }) + var buf bytes.Buffer + if err := printJSON(&buf, tasks); err != nil { + t.Fatal(err) + } + got := buf.String() if strings.ContainsRune(got, 0x1b) { t.Errorf("JSON output should escape the control byte, not emit it: %q", got) @@ -169,20 +167,294 @@ func TestPrintJSONKeepsRawTitleEscaped(t *testing.T) { } } -// quadrantLabels must never be the reason a command fails: a broken data file -// should surface from the operation itself, not from resolving a heading. -func TestQuadrantLabelsFallsBackOnReadError(t *testing.T) { - path := filepath.Join(t.TempDir(), "tasks.json") - if err := os.WriteFile(path, []byte("{ not json"), 0o600); err != nil { +func TestAddAndList(t *testing.T) { + p := scratch(t) + + out := mustRunCLI(t, p, "add", "ship v2", "-q", "1") + if !strings.Contains(out, "added 1 [Do It First] ship v2") { + t.Errorf("add output = %q", out) + } + + out = mustRunCLI(t, p, "list") + if !strings.Contains(out, "1 · Do It First") || !strings.Contains(out, "ship v2") { + t.Errorf("list output = %q", out) + } +} + +// The quadrant flag defaults to 2, and a fresh tree per invocation means the +// value from an earlier `-q 1` cannot bleed into a later call. +func TestAddQuadrantFlagDoesNotLeakBetweenRuns(t *testing.T) { + p := scratch(t) + mustRunCLI(t, p, "add", "urgent thing", "-q", "1") + mustRunCLI(t, p, "add", "later thing") + + out := mustRunCLI(t, p, "list", "-q", "2") + if !strings.Contains(out, "later thing") { + t.Errorf("second add should have defaulted to quadrant 2: %q", out) + } + if strings.Contains(out, "urgent thing") { + t.Errorf("quadrant 2 listing should not contain the quadrant 1 task: %q", out) + } +} + +// The label a command prints comes from the data its own mutation produced. +func TestAddPrintsCustomQuadrantLabel(t *testing.T) { + p := scratch(t) + mustRunCLI(t, p, "label", "1", "Firefighting") + + out := mustRunCLI(t, p, "add", "page duty", "-q", "1") + if !strings.Contains(out, "[Firefighting]") { + t.Errorf("add should print the custom label: %q", out) + } +} + +func TestDoneMovesToArchive(t *testing.T) { + p := scratch(t) + mustRunCLI(t, p, "add", "ship v2", "-q", "1") + mustRunCLI(t, p, "done", "1") + + if out := mustRunCLI(t, p, "list"); !strings.Contains(out, "no active tasks") { + t.Errorf("task should have left the active list: %q", out) + } + if out := mustRunCLI(t, p, "archive"); !strings.Contains(out, "ship v2") { + t.Errorf("task should be in the archive: %q", out) + } +} + +func TestUndoRedoRoundTrip(t *testing.T) { + p := scratch(t) + mustRunCLI(t, p, "add", "ship v2", "-q", "1") + + if out := mustRunCLI(t, p, "undo"); !strings.Contains(out, `undid add "ship v2"`) { + t.Errorf("undo output = %q", out) + } + if out := mustRunCLI(t, p, "list"); !strings.Contains(out, "no active tasks") { + t.Errorf("undo should have removed the task: %q", out) + } + if out := mustRunCLI(t, p, "redo"); !strings.Contains(out, `redid add "ship v2"`) { + t.Errorf("redo output = %q", out) + } + if out := mustRunCLI(t, p, "list"); !strings.Contains(out, "ship v2") { + t.Errorf("redo should have restored the task: %q", out) + } +} + +// An exhausted history stack is an error, not silent success. +func TestUndoWithNothingToUndo(t *testing.T) { + if _, err := runCLI(t, scratch(t), "undo"); err == nil { + t.Error("undo on an empty history should fail") + } +} + +func TestLabelArgumentValidation(t *testing.T) { + cases := []struct { + name string + args []string + want string + }{ + {"reset with no quadrant", []string{"label", "--reset"}, "--reset needs a quadrant"}, + {"name and reset together", []string{"label", "1", "Nope", "--reset"}, "not both"}, + {"quadrant with no name", []string{"label", "1"}, "give a name to set"}, + {"unparseable quadrant", []string{"label", "x", "Name"}, "invalid quadrant"}, + {"out of range quadrant", []string{"label", "9", "Name"}, "quadrant must be 1-4"}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + _, err := runCLI(t, scratch(t), c.args...) + if err == nil { + t.Fatalf("ike %s should have failed", strings.Join(c.args, " ")) + } + if !strings.Contains(err.Error(), c.want) { + t.Errorf("error = %q, want it to mention %q", err, c.want) + } + }) + } +} + +func TestLabelSetAndReset(t *testing.T) { + p := scratch(t) + + if out := mustRunCLI(t, p, "label", "3", "Pass Along"); !strings.Contains(out, "quadrant 3 is now Pass Along") { + t.Errorf("label set output = %q", out) + } + out := mustRunCLI(t, p, "label") + if !strings.Contains(out, "3 · Pass Along") || !strings.Contains(out, "(default: Delegate It)") { + t.Errorf("label listing should mark the custom name: %q", out) + } + + mustRunCLI(t, p, "label", "3", "--reset") + if out := mustRunCLI(t, p, "label"); strings.Contains(out, "Pass Along") { + t.Errorf("reset should have restored the default: %q", out) + } +} + +func TestReorderRejectsUnknownDirection(t *testing.T) { + p := scratch(t) + mustRunCLI(t, p, "add", "ship v2", "-q", "1") + + _, err := runCLI(t, p, "reorder", "1", "sideways") + if err == nil || !strings.Contains(err.Error(), "invalid direction") { + t.Errorf("error = %v, want an invalid-direction message", err) + } +} + +// A data file that cannot be parsed must fail the command outright. Nothing +// papers over it: the quadrant labels a command prints now come from the same +// read as the operation, so there is no second, error-swallowing lookup. +func TestUnreadableDataFileFailsTheCommand(t *testing.T) { + p := scratch(t) + if err := os.WriteFile(p, []byte("{ not json"), 0o600); err != nil { t.Fatal(err) } + for _, args := range [][]string{{"list"}, {"add", "x"}, {"label"}, {"archive"}} { + if _, err := runCLI(t, p, args...); err == nil { + t.Errorf("ike %s on an unparseable file should fail", strings.Join(args, " ")) + } + } +} + +// `ike mcp enable|disable|status` is how a user grants and revokes agent access +// to their matrix. The store-level gate is covered in internal/store; this pins +// the commands that drive it. +func TestMCPEnableDisableStatus(t *testing.T) { + p := scratch(t) + + out := mustRunCLI(t, p, "mcp", "status") + if !strings.Contains(out, "MCP access: off") { + t.Errorf("access must start off: %q", out) + } + if !strings.Contains(out, p) { + t.Errorf("status should name the data file it applies to: %q", out) + } + + if out := mustRunCLI(t, p, "mcp", "enable"); !strings.Contains(out, "MCP access is now on") { + t.Errorf("enable output = %q", out) + } + if on, err := store.OpenAt(p).MCPEnabled(); err != nil || !on { + t.Errorf("enable should have persisted: on=%v err=%v", on, err) + } + + // Re-running reports no change rather than claiming a fresh one. + if out := mustRunCLI(t, p, "mcp", "enable"); !strings.Contains(out, "was already on") { + t.Errorf("second enable output = %q", out) + } + if out := mustRunCLI(t, p, "mcp", "status"); !strings.Contains(out, "MCP access: on") { + t.Errorf("status after enable = %q", out) + } + + if out := mustRunCLI(t, p, "mcp", "disable"); !strings.Contains(out, "MCP access is now off") { + t.Errorf("disable output = %q", out) + } + if on, err := store.OpenAt(p).MCPEnabled(); err != nil || on { + t.Errorf("disable should have persisted: on=%v err=%v", on, err) + } + if out := mustRunCLI(t, p, "mcp", "status"); !strings.Contains(out, "MCP access: off") { + t.Errorf("status after disable = %q", out) + } +} + +// The server must refuse to start while access is off, and say how to turn it +// on — the reader is looking at an MCP client's error log. +func TestMCPServeRefusesWhileDisabled(t *testing.T) { + _, err := runCLI(t, scratch(t), "mcp") + if err == nil { + t.Fatal("ike mcp should refuse to serve while access is off") + } + if !strings.Contains(err.Error(), "ike mcp enable") { + t.Errorf("error should name the command that grants access: %q", err) + } +} + +func TestMvRmRestore(t *testing.T) { + p := scratch(t) + mustRunCLI(t, p, "add", "ship v2", "-q", "1") + mustRunCLI(t, p, "add", "drop this", "-q", "1") - if got := quadrantLabels(store.OpenAt(path)); got != nil { - t.Errorf("quadrantLabels on an unreadable file = %v, want nil", got) + if out := mustRunCLI(t, p, "mv", "1", "3"); !strings.Contains(out, "moved 1 to 3 · Delegate It") { + t.Errorf("mv output = %q", out) } - // nil still resolves to the built-in defaults. - var nilLabels store.Labels - if got, want := nilLabels.Of(task.Do), task.Do.Label(); got != want { - t.Errorf("nil Labels.Of(Do) = %q, want %q", got, want) + if out := mustRunCLI(t, p, "list", "-q", "3"); !strings.Contains(out, "ship v2") { + t.Errorf("task should have moved to quadrant 3: %q", out) + } + + if out := mustRunCLI(t, p, "rm", "2"); !strings.Contains(out, "deleted 2 drop this") { + t.Errorf("rm output = %q", out) + } + // rm skips the archive entirely, unlike done. + if out := mustRunCLI(t, p, "archive"); !strings.Contains(out, "archive is empty") { + t.Errorf("rm must not archive: %q", out) + } + + mustRunCLI(t, p, "done", "1") + if out := mustRunCLI(t, p, "restore", "1"); !strings.Contains(out, "restored 1 to 3 · Delegate It") { + t.Errorf("restore output = %q", out) + } + if out := mustRunCLI(t, p, "list"); !strings.Contains(out, "ship v2") { + t.Errorf("restored task should be active again: %q", out) + } +} + +func TestMvRejectsBadArguments(t *testing.T) { + p := scratch(t) + mustRunCLI(t, p, "add", "ship v2", "-q", "1") + + for _, c := range []struct{ args, want []string }{ + {[]string{"mv", "x", "2"}, []string{"invalid task id"}}, + {[]string{"mv", "1", "x"}, []string{"invalid quadrant"}}, + {[]string{"mv", "1", "9"}, []string{"quadrant must be 1-4"}}, + {[]string{"mv", "99", "2"}, []string{"no active task with id 99"}}, + } { + _, err := runCLI(t, p, c.args...) + if err == nil { + t.Errorf("ike %s should have failed", strings.Join(c.args, " ")) + continue + } + if !strings.Contains(err.Error(), c.want[0]) { + t.Errorf("ike %s error = %q, want it to mention %q", + strings.Join(c.args, " "), err, c.want[0]) + } + } +} + +func TestReorderDirections(t *testing.T) { + p := scratch(t) + for _, title := range []string{"first", "second", "third"} { + mustRunCLI(t, p, "add", title, "-q", "1") + } + + order := func() string { + t.Helper() + return mustRunCLI(t, p, "list", "-q", "1") + } + indexOf := func(out, title string) int { return strings.Index(out, title) } + + mustRunCLI(t, p, "reorder", "3", "top") + if out := order(); indexOf(out, "third") > indexOf(out, "first") { + t.Errorf("`top` should have moved third to the front: %q", out) + } + mustRunCLI(t, p, "reorder", "3", "bottom") + if out := order(); indexOf(out, "third") < indexOf(out, "first") { + t.Errorf("`bottom` should have moved third to the end: %q", out) + } + mustRunCLI(t, p, "reorder", "3", "up") + if out := order(); indexOf(out, "third") > indexOf(out, "second") { + t.Errorf("`up` should have moved third above second: %q", out) + } + if out := mustRunCLI(t, p, "reorder", "3", "down"); !strings.Contains(out, "down in 1 · Do It First") { + t.Errorf("reorder output = %q", out) + } +} + +func TestArchiveJSONAndEmpty(t *testing.T) { + p := scratch(t) + if out := mustRunCLI(t, p, "archive", "--json"); !strings.Contains(out, "[]") { + t.Errorf("empty archive as JSON = %q", out) + } + mustRunCLI(t, p, "add", "ship v2", "-q", "1") + mustRunCLI(t, p, "done", "1") + + out := mustRunCLI(t, p, "archive", "--json") + if !strings.Contains(out, `"title": "ship v2"`) || !strings.Contains(out, `"done_at"`) { + t.Errorf("archive JSON = %q", out) } } diff --git a/internal/cli/mcp.go b/internal/cli/mcp.go index 1bb1020..044d118 100644 --- a/internal/cli/mcp.go +++ b/internal/cli/mcp.go @@ -9,6 +9,7 @@ import ( "github.com/spf13/cobra" "github.com/jonascript/ike/internal/mcpserver" + "github.com/jonascript/ike/internal/store" ) // mcpDisabledMsg explains how to switch agent access on. It is worded for the @@ -18,8 +19,8 @@ const mcpDisabledMsg = "MCP access is off for this matrix.\n" + " ike mcp enable\n\n" + "Run `ike mcp status` to see the current setting and which data file it applies to." -func init() { - mcpCmd := &cobra.Command{ +func newMCPCmd(open opener) *cobra.Command { + cmd := &cobra.Command{ Use: "mcp", Short: "Serve MCP over stdio so AI agents can manage the matrix", Long: "Runs an MCP (Model Context Protocol) server on stdin/stdout.\n\n" + @@ -29,11 +30,7 @@ func init() { " claude mcp add ike -- ike mcp\n\n" + "The setting is remembered per data file, and `ike mcp disable` revokes it.", Args: cobra.NoArgs, - RunE: func(cmd *cobra.Command, args []string) error { - s, err := openStore() - if err != nil { - return err - } + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { enabled, err := s.MCPEnabled() if err != nil { return err @@ -50,9 +47,6 @@ func init() { //nolint:staticcheck // ST1005: formatted for a human, not a caller. return errors.New(mcpDisabledMsg) } - // stdout carries JSON-RPC; anything human-facing must go to stderr, - // which cobra already uses for errors. - // // ForMCP re-checks the gate on every read and mutation, so // `ike mcp disable` revokes this session even while it stays // connected. The check above only covers startup. @@ -64,72 +58,71 @@ func init() { return nil } return err - }, + }), } + cmd.AddCommand(newMCPSetCmd(open, true), newMCPSetCmd(open, false), newMCPStatusCmd(open)) + return cmd +} - enableCmd := &cobra.Command{ - Use: "enable", - Short: "Allow AI agents to read and manage this matrix over MCP", - Args: cobra.NoArgs, - RunE: func(cmd *cobra.Command, args []string) error { return setMCP(true) }, +// newMCPSetCmd builds `ike mcp enable` or `ike mcp disable`. They differ only +// in the value they write and the words they print, so they are one function: +// two near-identical command bodies is how the two drift apart. +func newMCPSetCmd(open opener, on bool) *cobra.Command { + use, short := "disable", "Revoke MCP access to this matrix" + if on { + use, short = "enable", "Allow AI agents to read and manage this matrix over MCP" } - - disableCmd := &cobra.Command{ - Use: "disable", - Short: "Revoke MCP access to this matrix", + return &cobra.Command{ + Use: use, + Short: short, Args: cobra.NoArgs, - RunE: func(cmd *cobra.Command, args []string) error { return setMCP(false) }, + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { + changed, err := s.SetMCPEnabled(on) + if err != nil { + return err + } + out := cmd.OutOrStdout() + if !changed { + fmt.Fprintf(out, "MCP access was already %s for %s\n", mcpState(on), s.Path()) + return nil + } + fmt.Fprintf(out, "MCP access is now %s for %s\n", mcpState(on), s.Path()) + if on { + fmt.Fprintln(out, "Register ike with a client if you have not already:\n\n claude mcp add ike -- ike mcp") + } + return nil + }), } +} - statusCmd := &cobra.Command{ +// newMCPStatusCmd reports the setting. It deliberately uses the ungated store, +// so it still answers after access has been revoked. +func newMCPStatusCmd(open opener) *cobra.Command { + return &cobra.Command{ Use: "status", Short: "Show whether MCP access is enabled, and for which data file", Args: cobra.NoArgs, - RunE: func(cmd *cobra.Command, args []string) error { - s, err := openStore() - if err != nil { - return err - } + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { enabled, err := s.MCPEnabled() if err != nil { return err } - state, hint := "off", "ike mcp enable" + hint := "ike mcp enable" if enabled { - state, hint = "on", "ike mcp disable" + hint = "ike mcp disable" } - fmt.Printf("MCP access: %s\n", state) - fmt.Printf("data file: %s\n", s.Path()) - fmt.Printf("change it: %s\n", hint) + out := cmd.OutOrStdout() + fmt.Fprintf(out, "MCP access: %s\n", mcpState(enabled)) + fmt.Fprintf(out, "data file: %s\n", s.Path()) + fmt.Fprintf(out, "change it: %s\n", hint) return nil - }, + }), } - - mcpCmd.AddCommand(enableCmd, disableCmd, statusCmd) - rootCmd.AddCommand(mcpCmd) } -// setMCP flips the MCP permission and reports what happened. -func setMCP(on bool) error { - s, err := openStore() - if err != nil { - return err - } - changed, err := s.SetMCPEnabled(on) - if err != nil { - return err - } - state := "off" - if on { - state = "on" - } - if !changed { - fmt.Printf("MCP access was already %s for %s\n", state, s.Path()) - return nil - } - fmt.Printf("MCP access is now %s for %s\n", state, s.Path()) +func mcpState(on bool) string { if on { - fmt.Println("Register ike with a client if you have not already:\n\n claude mcp add ike -- ike mcp") + return "on" } - return nil + return "off" } diff --git a/internal/cli/root.go b/internal/cli/root.go index c39986c..69bea0d 100644 --- a/internal/cli/root.go +++ b/internal/cli/root.go @@ -14,28 +14,60 @@ import ( // version is stamped at build time via -ldflags "-X ...cli.version=...". var version = "dev" -var rootCmd = &cobra.Command{ - Use: "ike", - Short: "ike — an Eisenhower matrix task manager", - Long: "ike is a terminal Eisenhower matrix: run it bare for the interactive TUI,\nor use subcommands for quick capture and scripting.", - Version: version, - SilenceUsage: true, - RunE: func(cmd *cobra.Command, args []string) error { - s, err := openStore() +// opener yields the store a command should act on. It is a parameter rather +// than a direct call to store.Open so tests can build the command tree over a +// scratch data file; that is the whole reason the commands are constructed +// instead of registered from init(). +// +// It stays lazy — resolved inside RunE, not when the tree is built — so `ike +// --help` still works when IKE_DATA_FILE is set to something invalid. +type opener func() (*store.Store, error) + +// withStore adapts a command body that needs a store into a cobra RunE, so the +// bodies start at the part that differs instead of repeating the same three +// lines of open-and-check. +func withStore(open opener, run func(*cobra.Command, []string, *store.Store) error) func(*cobra.Command, []string) error { + return func(cmd *cobra.Command, args []string) error { + s, err := open() if err != nil { return err } - return tui.Run(s) - }, + return run(cmd, args, s) + } } -func openStore() (*store.Store, error) { - return store.Open() +// NewRootCmd builds the whole command tree against open. +func NewRootCmd(open opener) *cobra.Command { + root := &cobra.Command{ + Use: "ike", + Short: "ike — an Eisenhower matrix task manager", + Long: "ike is a terminal Eisenhower matrix: run it bare for the interactive TUI,\nor use subcommands for quick capture and scripting.", + Version: version, + SilenceUsage: true, + RunE: withStore(open, func(cmd *cobra.Command, args []string, s *store.Store) error { + return tui.Run(s) + }), + } + root.AddCommand( + newAddCmd(open), + newListCmd(open), + newDoneCmd(open), + newMvCmd(open), + newRmCmd(open), + newRestoreCmd(open), + newReorderCmd(open), + newUndoCmd(open), + newRedoCmd(open), + newLabelCmd(open), + newArchiveCmd(open), + newMCPCmd(open), + ) + return root } // Execute runs the CLI and exits non-zero on error. func Execute() { - if err := rootCmd.Execute(); err != nil { + if err := NewRootCmd(store.Open).Execute(); err != nil { os.Exit(1) } } diff --git a/internal/mcpserver/server.go b/internal/mcpserver/server.go index 7bb723c..e4b140a 100644 --- a/internal/mcpserver/server.go +++ b/internal/mcpserver/server.go @@ -5,6 +5,7 @@ package mcpserver import ( "context" "fmt" + "time" "github.com/modelcontextprotocol/go-sdk/mcp" @@ -25,16 +26,20 @@ type taskOut struct { Done string `json:"done_at,omitempty" jsonschema:"completion time, only set for archived tasks"` } +// Title is deliberately the raw stored title, not DisplayTitle: this output is +// JSON, and encoding/json escapes control characters itself. Label goes through +// Labels.Of, which sanitizes — that is the store's render choke point, not a +// policy chosen here. func toOut(t task.Task, labels store.Labels) taskOut { o := taskOut{ ID: t.ID, Title: t.Title, Quadrant: int(t.Quadrant), Label: labels.Of(t.Quadrant), - Created: t.CreatedAt.Format("2006-01-02T15:04:05Z07:00"), + Created: t.CreatedAt.Format(time.RFC3339), } if t.DoneAt != nil { - o.Done = t.DoneAt.Format("2006-01-02T15:04:05Z07:00") + o.Done = t.DoneAt.Format(time.RFC3339) } return o } @@ -47,17 +52,6 @@ func toOuts(ts []task.Task, labels store.Labels) []taskOut { return out } -// labelsOf resolves the quadrant headings for tool output. A read failure -// falls back to the defaults rather than failing the tool call, since the -// labels are cosmetic. -func labelsOf(s *store.Store) store.Labels { - l, err := s.QuadrantLabels() - if err != nil { - return nil - } - return l -} - type listIn struct { Quadrant int `json:"quadrant,omitempty" jsonschema:"optional filter, 1-4; omit or 0 for all quadrants"` } @@ -126,107 +120,99 @@ func directionDelta(dir string) (int, error) { return 0, fmt.Errorf("invalid direction %q: want up, down, top, or bottom", dir) } +// taskTool registers a tool whose result is a single task. Eight of ike's +// thirteen tools have that shape and had the same five lines of error plumbing +// copied into each; op is the only part that differed. +// +// The store operation returns the post-mutation data alongside the task, so the +// quadrant label rendered here comes from the state the change produced — not +// from a second read that could observe a later one. +func taskTool[In any](srv *mcp.Server, spec *mcp.Tool, op func(In) (task.Task, store.Data, error)) { + mcp.AddTool(srv, spec, func(ctx context.Context, req *mcp.CallToolRequest, in In) (*mcp.CallToolResult, taskOut, error) { + t, d, err := op(in) + if err != nil { + return nil, taskOut{}, err + } + return nil, toOut(t, d.Labels), nil + }) +} + +// listTool registers a tool that returns a list of tasks drawn from one read of +// the store, so the tasks and the labels describing them agree. +func listTool[In any](srv *mcp.Server, s *store.Store, spec *mcp.Tool, sel func(store.Data, In) []task.Task) { + mcp.AddTool(srv, spec, func(ctx context.Context, req *mcp.CallToolRequest, in In) (*mcp.CallToolResult, tasksOut, error) { + d, err := s.Load() + if err != nil { + return nil, tasksOut{}, err + } + return nil, tasksOut{Tasks: toOuts(sel(d, in), d.Labels)}, nil + }) +} + // NewServer builds the MCP server around s. version is the ike build version. func NewServer(s *store.Store, version string) *mcp.Server { srv := mcp.NewServer(&mcp.Implementation{Name: "ike", Version: version}, nil) - mcp.AddTool(srv, &mcp.Tool{ + listTool(srv, s, &mcp.Tool{ Name: "list_tasks", Description: "List active tasks in the Eisenhower matrix, ordered by quadrant. " + quadrantDoc, - }, func(ctx context.Context, req *mcp.CallToolRequest, in listIn) (*mcp.CallToolResult, tasksOut, error) { - ts, err := s.List(task.Quadrant(in.Quadrant)) - if err != nil { - return nil, tasksOut{}, err - } - return nil, tasksOut{Tasks: toOuts(ts, labelsOf(s))}, nil - }) + }, func(d store.Data, in listIn) []task.Task { return d.List(task.Quadrant(in.Quadrant)) }) - mcp.AddTool(srv, &mcp.Tool{ + listTool(srv, s, &mcp.Tool{ + Name: "list_archive", + Description: "List completed (archived) tasks, most recently completed first.", + }, func(d store.Data, in emptyIn) []task.Task { return d.ListArchive() }) + + taskTool(srv, &mcp.Tool{ Name: "add_task", Description: "Add a task to the matrix. " + quadrantDoc, - }, func(ctx context.Context, req *mcp.CallToolRequest, in addIn) (*mcp.CallToolResult, taskOut, error) { - t, err := s.Add(in.Title, task.Quadrant(in.Quadrant)) - if err != nil { - return nil, taskOut{}, err - } - return nil, toOut(t, labelsOf(s)), nil + }, func(in addIn) (task.Task, store.Data, error) { + return s.Add(in.Title, task.Quadrant(in.Quadrant)) }) - mcp.AddTool(srv, &mcp.Tool{ + taskTool(srv, &mcp.Tool{ Name: "complete_task", Description: "Mark a task done. It moves from the active matrix to the archive.", - }, func(ctx context.Context, req *mcp.CallToolRequest, in idIn) (*mcp.CallToolResult, taskOut, error) { - t, err := s.Complete(in.ID) - if err != nil { - return nil, taskOut{}, err - } - return nil, toOut(t, labelsOf(s)), nil - }) + }, func(in idIn) (task.Task, store.Data, error) { return s.Complete(in.ID) }) - mcp.AddTool(srv, &mcp.Tool{ + taskTool(srv, &mcp.Tool{ Name: "move_task", Description: "Move a task to a different quadrant. " + quadrantDoc, - }, func(ctx context.Context, req *mcp.CallToolRequest, in moveIn) (*mcp.CallToolResult, taskOut, error) { - t, err := s.Move(in.ID, task.Quadrant(in.Quadrant)) - if err != nil { - return nil, taskOut{}, err - } - return nil, toOut(t, labelsOf(s)), nil + }, func(in moveIn) (task.Task, store.Data, error) { + return s.Move(in.ID, task.Quadrant(in.Quadrant)) }) - mcp.AddTool(srv, &mcp.Tool{ + taskTool(srv, &mcp.Tool{ Name: "update_task", Description: "Rename a task (change its title).", - }, func(ctx context.Context, req *mcp.CallToolRequest, in updateIn) (*mcp.CallToolResult, taskOut, error) { - t, err := s.Rename(in.ID, in.Title) - if err != nil { - return nil, taskOut{}, err - } - return nil, toOut(t, labelsOf(s)), nil - }) + }, func(in updateIn) (task.Task, store.Data, error) { return s.Rename(in.ID, in.Title) }) - mcp.AddTool(srv, &mcp.Tool{ + taskTool(srv, &mcp.Tool{ Name: "delete_task", Description: "Delete an active task permanently. Unlike complete_task, the task is NOT archived. Use for tasks that should never have existed; prefer complete_task for finished work.", - }, func(ctx context.Context, req *mcp.CallToolRequest, in idIn) (*mcp.CallToolResult, taskOut, error) { - t, err := s.Delete(in.ID) - if err != nil { - return nil, taskOut{}, err - } - return nil, toOut(t, labelsOf(s)), nil - }) + }, func(in idIn) (task.Task, store.Data, error) { return s.Delete(in.ID) }) - mcp.AddTool(srv, &mcp.Tool{ + taskTool(srv, &mcp.Tool{ Name: "restore_task", Description: "Un-archive a completed task: it returns to the active matrix in the quadrant it was completed in, at the bottom, with its completion time cleared.", - }, func(ctx context.Context, req *mcp.CallToolRequest, in idIn) (*mcp.CallToolResult, taskOut, error) { - t, err := s.Restore(in.ID) - if err != nil { - return nil, taskOut{}, err - } - return nil, toOut(t, labelsOf(s)), nil - }) + }, func(in idIn) (task.Task, store.Data, error) { return s.Restore(in.ID) }) - mcp.AddTool(srv, &mcp.Tool{ + taskTool(srv, &mcp.Tool{ Name: "reorder_task", Description: "Change a task's position within its own quadrant. This does not change which quadrant it is in — use move_task for that.", - }, func(ctx context.Context, req *mcp.CallToolRequest, in reorderIn) (*mcp.CallToolResult, taskOut, error) { + }, func(in reorderIn) (task.Task, store.Data, error) { delta, err := directionDelta(in.Direction) if err != nil { - return nil, taskOut{}, err - } - t, err := s.Reorder(in.ID, delta) - if err != nil { - return nil, taskOut{}, err + return task.Task{}, store.Data{}, err } - return nil, toOut(t, labelsOf(s)), nil + return s.Reorder(in.ID, delta) }) mcp.AddTool(srv, &mcp.Tool{ Name: "undo", Description: "Revert the single most recent change to the matrix, whichever frontend made it. Returns a description of what was undone. Call repeatedly to walk further back, and use redo to re-apply.", }, func(ctx context.Context, req *mcp.CallToolRequest, in emptyIn) (*mcp.CallToolResult, undoOut, error) { - label, err := s.Undo() + label, _, err := s.Undo() if err != nil { return nil, undoOut{}, err } @@ -237,7 +223,7 @@ func NewServer(s *store.Store, version string) *mcp.Server { Name: "redo", Description: "Re-apply the most recently undone change. Only available until the next change to the matrix, which discards the redo history — so making any edit after an undo permanently gives up the redo.", }, func(ctx context.Context, req *mcp.CallToolRequest, in emptyIn) (*mcp.CallToolResult, undoOut, error) { - label, err := s.Redo() + label, _, err := s.Redo() if err != nil { return nil, undoOut{}, err } @@ -265,24 +251,13 @@ func NewServer(s *store.Store, version string) *mcp.Server { Description: "Rename a quadrant's heading. This changes only the display name — it does not " + "move tasks or change what the quadrant means. Pass an empty label to restore the default.", }, func(ctx context.Context, req *mcp.CallToolRequest, in labelIn) (*mcp.CallToolResult, quadrantOut, error) { - label, err := s.SetQuadrantLabel(task.Quadrant(in.Quadrant), in.Label) + label, _, err := s.SetQuadrantLabel(task.Quadrant(in.Quadrant), in.Label) if err != nil { return nil, quadrantOut{}, err } return nil, quadrantOut{Quadrant: in.Quadrant, Label: label}, nil }) - mcp.AddTool(srv, &mcp.Tool{ - Name: "list_archive", - Description: "List completed (archived) tasks, most recently completed first.", - }, func(ctx context.Context, req *mcp.CallToolRequest, in emptyIn) (*mcp.CallToolResult, tasksOut, error) { - ts, err := s.ListArchive() - if err != nil { - return nil, tasksOut{}, err - } - return nil, tasksOut{Tasks: toOuts(ts, labelsOf(s))}, nil - }) - return srv } diff --git a/internal/mcpserver/server_test.go b/internal/mcpserver/server_test.go index 3e95610..365c8c7 100644 --- a/internal/mcpserver/server_test.go +++ b/internal/mcpserver/server_test.go @@ -237,7 +237,7 @@ func TestRedoInvalidatedByAnotherFrontend(t *testing.T) { call(t, sess, "undo", map[string]any{}) // A write straight to the store, as the CLI or TUI would make. - if _, err := s.Add("from another frontend", task.Schedule); err != nil { + if _, _, err := s.Add("from another frontend", task.Schedule); err != nil { t.Fatal(err) } if res := call(t, sess, "redo", map[string]any{}); !res.IsError { diff --git a/internal/store/durability_test.go b/internal/store/durability_test.go index e33ffed..f66cacd 100644 --- a/internal/store/durability_test.go +++ b/internal/store/durability_test.go @@ -18,7 +18,7 @@ func TestDataFileAndDirArePrivate(t *testing.T) { dir := filepath.Join(t.TempDir(), "ike") path := filepath.Join(dir, "tasks.json") s := OpenAt(path) - if _, err := s.Add("private", task.Do); err != nil { + if _, _, err := s.Add("private", task.Do); err != nil { t.Fatal(err) } @@ -45,14 +45,14 @@ func TestWriteTightensPermissionsOfAnOlderFile(t *testing.T) { dir := t.TempDir() path := filepath.Join(dir, "tasks.json") s := OpenAt(path) - if _, err := s.Add("first", task.Do); err != nil { + if _, _, err := s.Add("first", task.Do); err != nil { t.Fatal(err) } if err := os.Chmod(path, 0o644); err != nil { t.Fatal(err) } - if _, err := s.Add("second", task.Do); err != nil { + if _, _, err := s.Add("second", task.Do); err != nil { t.Fatal(err) } fi, err := os.Stat(path) @@ -79,7 +79,7 @@ func TestWriteDoesNotUsePredictableTempName(t *testing.T) { } s := OpenAt(path) - if _, err := s.Add("safe", task.Do); err != nil { + if _, _, err := s.Add("safe", task.Do); err != nil { t.Fatal(err) } @@ -108,7 +108,7 @@ func TestWriteKeepsABackupOfThePreviousContents(t *testing.T) { path := filepath.Join(dir, "tasks.json") s := OpenAt(path) - if _, err := s.Add("first", task.Do); err != nil { + if _, _, err := s.Add("first", task.Do); err != nil { t.Fatal(err) } // No backup yet: there was nothing to preserve before the first write. @@ -116,7 +116,7 @@ func TestWriteKeepsABackupOfThePreviousContents(t *testing.T) { t.Errorf("unexpected backup after the first write: %v", err) } - if _, err := s.Add("second", task.Do); err != nil { + if _, _, err := s.Add("second", task.Do); err != nil { t.Fatal(err) } bak, err := os.ReadFile(path + ".bak") @@ -147,7 +147,7 @@ func TestWrittenFileIsCompleteAndParses(t *testing.T) { path := filepath.Join(dir, "tasks.json") s := OpenAt(path) for i := range 25 { - if _, err := s.Add(strings.Repeat("x", i+1), task.Schedule); err != nil { + if _, _, err := s.Add(strings.Repeat("x", i+1), task.Schedule); err != nil { t.Fatal(err) } d, err := s.Load() @@ -204,7 +204,7 @@ func TestMutateTimesOutInsteadOfHangingForever(t *testing.T) { dir := t.TempDir() path := filepath.Join(dir, "tasks.json") s := OpenAt(path) - if _, err := s.Add("seed", task.Do); err != nil { + if _, _, err := s.Add("seed", task.Do); err != nil { t.Fatal(err) } @@ -216,7 +216,7 @@ func TestMutateTimesOutInsteadOfHangingForever(t *testing.T) { defer func() { _ = held.Unlock() }() start := time.Now() - _, err := s.Add("blocked", task.Do) + _, _, err := s.Add("blocked", task.Do) elapsed := time.Since(start) if err == nil { @@ -237,7 +237,7 @@ func TestMutateTimesOutInsteadOfHangingForever(t *testing.T) { if err := held.Unlock(); err != nil { t.Fatal(err) } - if _, err := s.Add("after release", task.Do); err != nil { + if _, _, err := s.Add("after release", task.Do); err != nil { t.Errorf("Add after the lock was released: %v", err) } } diff --git a/internal/store/history_test.go b/internal/store/history_test.go new file mode 100644 index 0000000..7cd3914 --- /dev/null +++ b/internal/store/history_test.go @@ -0,0 +1,383 @@ +package store + +import ( + "path/filepath" + "testing" + + "github.com/jonascript/ike/internal/task" +) + +// titles returns the titles of q's tasks in display order. + +func TestUndoOfTaskChangeLeavesLabelsAlone(t *testing.T) { + s := testStore(t) + if _, _, err := s.SetQuadrantLabel(task.Do, "Firefighting"); err != nil { + t.Fatal(err) + } + a, _, _ := s.Add("something", task.Do) + if _, _, err := s.Delete(a.ID); err != nil { + t.Fatal(err) + } + // Undoing the delete must not roll the rename back with it. + if _, _, err := s.Undo(); err != nil { + t.Fatal(err) + } + labels, _ := s.QuadrantLabels() + if labels.Of(task.Do) != "Firefighting" { + t.Errorf("label = %q, want the rename to survive an unrelated undo", labels.Of(task.Do)) + } +} + +func TestUndoCannotReopenRevokedAccess(t *testing.T) { + s := testStore(t) + if _, err := s.SetMCPEnabled(true); err != nil { + t.Fatal(err) + } + s.Add("a task", task.Do) + if _, err := s.SetMCPEnabled(false); err != nil { + t.Fatal(err) + } + + // No amount of undo or redo may hand access back. + for i := 0; i < 5; i++ { + if _, _, err := s.Undo(); err != nil { + break + } + if on, _ := s.MCPEnabled(); on { + t.Fatalf("undo %d re-enabled revoked MCP access", i) + } + } + for i := 0; i < 5; i++ { + if _, _, err := s.Redo(); err != nil { + break + } + if on, _ := s.MCPEnabled(); on { + t.Fatalf("redo %d re-enabled revoked MCP access", i) + } + } +} + +func TestUndoRestoresPreviousState(t *testing.T) { + s := testStore(t) + a, _, _ := s.Add("keep me", task.Do) + + if _, _, err := s.Complete(a.ID); err != nil { + t.Fatal(err) + } + label, _, err := s.Undo() + if err != nil { + t.Fatal(err) + } + if label != `complete "keep me"` { + t.Errorf("label = %q, want the complete label", label) + } + d, _ := s.Load() + if len(d.Tasks) != 1 || len(d.Archive) != 0 { + t.Fatalf("after undo: %d active, %d archived; want 1 and 0", len(d.Tasks), len(d.Archive)) + } + + // Undo the add itself. + if _, _, err := s.Undo(); err != nil { + t.Fatal(err) + } + d, _ = s.Load() + if len(d.Tasks) != 0 { + t.Errorf("after second undo: %d active, want 0", len(d.Tasks)) + } +} + +func TestUndoOfDeleteBringsTaskBack(t *testing.T) { + s := testStore(t) + a, _, _ := s.Add("oops", task.Do) + if _, _, err := s.Delete(a.ID); err != nil { + t.Fatal(err) + } + if _, _, err := s.Undo(); err != nil { + t.Fatal(err) + } + got := titles(t, s, task.Do) + if !equal(got, []string{"oops"}) { + t.Errorf("after undoing delete: %v, want [oops]", got) + } +} + +func TestUndoDoesNotReuseIDs(t *testing.T) { + s := testStore(t) + a, _, _ := s.Add("first", task.Do) + if _, _, err := s.Undo(); err != nil { // undo the add + t.Fatal(err) + } + b, _, err := s.Add("second", task.Do) + if err != nil { + t.Fatal(err) + } + if b.ID == a.ID { + t.Errorf("ID %d was reused after undo; IDs must stay monotonic", b.ID) + } +} + +func TestUndoEmptyStack(t *testing.T) { + s := testStore(t) + if _, _, err := s.Undo(); err == nil { + t.Error("undo with nothing to undo should error") + } +} + +func TestRepeatedUndoWalksBack(t *testing.T) { + s := testStore(t) + s.Add("a", task.Do) + s.Add("b", task.Do) + if _, _, err := s.Undo(); err != nil { // undoes add "b" + t.Fatal(err) + } + label, _, err := s.Undo() // must undo add "a", not re-apply add "b" + if err != nil { + t.Fatal(err) + } + if label != `add "a"` { + t.Errorf("second undo label = %q, want `add \"a\"`", label) + } + if got := titles(t, s, task.Do); len(got) != 0 { + t.Errorf("after two undos: %v, want nothing", got) + } +} + +func TestRedoReappliesUndoneChange(t *testing.T) { + s := testStore(t) + a, _, _ := s.Add("ship it", task.Do) + if _, _, err := s.Complete(a.ID); err != nil { + t.Fatal(err) + } + if _, _, err := s.Undo(); err != nil { + t.Fatal(err) + } + if arch, _ := s.ListArchive(); len(arch) != 0 { + t.Fatal("undo should have un-archived the task") + } + + label, _, err := s.Redo() + if err != nil { + t.Fatal(err) + } + if label != `complete "ship it"` { + t.Errorf("redo label = %q, want the complete label", label) + } + active, _ := s.List(0) + arch, _ := s.ListArchive() + if len(active) != 0 || len(arch) != 1 { + t.Errorf("after redo: active=%d archive=%d, want 0/1", len(active), len(arch)) + } +} + +func TestRedoRoundTripIsExact(t *testing.T) { + s := testStore(t) + s.Add("a", task.Do) + b, _, _ := s.Add("b", task.Do) + s.Add("c", task.Do) + if _, _, err := s.Reorder(b.ID, ToTop); err != nil { + t.Fatal(err) + } + want := titles(t, s, task.Do) + + if _, _, err := s.Undo(); err != nil { + t.Fatal(err) + } + if got := titles(t, s, task.Do); equal(got, want) { + t.Fatal("undo did not change the order") + } + if _, _, err := s.Redo(); err != nil { + t.Fatal(err) + } + if got := titles(t, s, task.Do); !equal(got, want) { + t.Errorf("after undo+redo: %v, want %v (ordering must survive the round trip)", got, want) + } +} + +func TestNewChangeDiscardsRedo(t *testing.T) { + s := testStore(t) + a, _, _ := s.Add("first", task.Do) + if _, _, err := s.Complete(a.ID); err != nil { + t.Fatal(err) + } + if _, _, err := s.Undo(); err != nil { + t.Fatal(err) + } + + // Diverging from the undone branch must strand it: redoing the complete + // here would clobber the task added below. + if _, _, err := s.Add("second", task.Do); err != nil { + t.Fatal(err) + } + d, err := s.Load() + if err != nil { + t.Fatal(err) + } + if len(d.Redo) != 0 { + t.Errorf("redo stack = %d entries, want 0 after a new change", len(d.Redo)) + } + if _, _, err := s.Redo(); err == nil { + t.Error("redo after a diverging change should error") + } + if got, want := titles(t, s, task.Do), []string{"first", "second"}; !equal(got, want) { + t.Errorf("tasks = %v, want %v", got, want) + } +} + +func TestRedoAcrossFrontendsIsDiscardedToo(t *testing.T) { + dir := t.TempDir() + p := filepath.Join(dir, "tasks.json") + + a, _, err := OpenAt(p).Add("mine", task.Do) + if err != nil { + t.Fatal(err) + } + if _, _, err := OpenAt(p).Delete(a.ID); err != nil { + t.Fatal(err) + } + if _, _, err := OpenAt(p).Undo(); err != nil { + t.Fatal(err) + } + // A different "process" (CLI or MCP agent) writes. + if _, _, err := OpenAt(p).Add("theirs", task.Schedule); err != nil { + t.Fatal(err) + } + if _, _, err := OpenAt(p).Redo(); err == nil { + t.Error("a write from another frontend should invalidate redo") + } +} + +func TestRedoMultipleSteps(t *testing.T) { + s := testStore(t) + s.Add("a", task.Do) + s.Add("b", task.Do) + s.Add("c", task.Do) + + for i := 0; i < 3; i++ { + if _, _, err := s.Undo(); err != nil { + t.Fatalf("undo %d: %v", i, err) + } + } + if got := titles(t, s, task.Do); len(got) != 0 { + t.Fatalf("after three undos: %v, want nothing", got) + } + + // Redo must walk forward the same distance. This is what breaks if Redo + // clears the redo stack via pushUndo. + for i := 0; i < 3; i++ { + if _, _, err := s.Redo(); err != nil { + t.Fatalf("redo %d: %v", i, err) + } + } + if got, want := titles(t, s, task.Do), []string{"a", "b", "c"}; !equal(got, want) { + t.Errorf("after three redos: %v, want %v", got, want) + } + if _, _, err := s.Redo(); err == nil { + t.Error("a fourth redo should error") + } +} + +func TestRedoIsUndoable(t *testing.T) { + s := testStore(t) + a, _, _ := s.Add("wobble", task.Do) + s.Delete(a.ID) + s.Undo() // task is back + if _, _, err := s.Redo(); err != nil { + t.Fatal(err) + } + if got := titles(t, s, task.Do); len(got) != 0 { + t.Fatalf("redo should have re-deleted: %v", got) + } + if _, _, err := s.Undo(); err != nil { + t.Fatal(err) + } + if got, want := titles(t, s, task.Do), []string{"wobble"}; !equal(got, want) { + t.Errorf("undo after redo = %v, want %v", got, want) + } +} + +func TestRedoEmptyStack(t *testing.T) { + s := testStore(t) + s.Add("a", task.Do) + if _, _, err := s.Redo(); err == nil { + t.Error("redo with nothing undone should error") + } +} + +func TestRedoStackIsCapped(t *testing.T) { + s := testStore(t) + for i := 0; i < undoDepth+5; i++ { + if _, _, err := s.Add("t", task.Do); err != nil { + t.Fatal(err) + } + } + for i := 0; i < undoDepth; i++ { + if _, _, err := s.Undo(); err != nil { + t.Fatalf("undo %d: %v", i, err) + } + } + d, err := s.Load() + if err != nil { + t.Fatal(err) + } + if len(d.Redo) != undoDepth { + t.Errorf("redo stack depth = %d, want %d", len(d.Redo), undoDepth) + } +} + +func TestUndoStackIsCapped(t *testing.T) { + s := testStore(t) + for i := 0; i < undoDepth+15; i++ { + if _, _, err := s.Add("t", task.Do); err != nil { + t.Fatal(err) + } + } + d, err := s.Load() + if err != nil { + t.Fatal(err) + } + if len(d.Undo) != undoDepth { + t.Errorf("undo stack depth = %d, want %d", len(d.Undo), undoDepth) + } +} + +func TestUndoSurvivesReload(t *testing.T) { + dir := t.TempDir() + p := filepath.Join(dir, "tasks.json") + + // One "process" makes a change... + a, _, err := OpenAt(p).Add("cross-process", task.Do) + if err != nil { + t.Fatal(err) + } + if _, _, err := OpenAt(p).Complete(a.ID); err != nil { + t.Fatal(err) + } + // ...and another undoes it. + label, _, err := OpenAt(p).Undo() + if err != nil { + t.Fatal(err) + } + if label != `complete "cross-process"` { + t.Errorf("label = %q", label) + } + d, _ := OpenAt(p).Load() + if len(d.Tasks) != 1 { + t.Errorf("undo across processes left %d active tasks, want 1", len(d.Tasks)) + } +} + +func TestFailedMutationDoesNotRecordUndo(t *testing.T) { + s := testStore(t) + a, _, _ := s.Add("valid", task.Do) + if _, _, err := s.Rename(a.ID, " "); err == nil { + t.Fatal("rename to blank should fail") + } + d, err := s.Load() + if err != nil { + t.Fatal(err) + } + if len(d.Undo) != 1 || UndoLabel(d) != `add "valid"` { + t.Errorf("undo stack = %d entries, top %q; a failed rename should not record", + len(d.Undo), UndoLabel(d)) + } +} diff --git a/internal/store/labels_test.go b/internal/store/labels_test.go new file mode 100644 index 0000000..4fc332e --- /dev/null +++ b/internal/store/labels_test.go @@ -0,0 +1,168 @@ +package store + +import ( + "strings" + "testing" + + "github.com/jonascript/ike/internal/task" +) + +// titles returns the titles of q's tasks in display order. + +func TestQuadrantLabelDefaults(t *testing.T) { + s := testStore(t) + labels, err := s.QuadrantLabels() + if err != nil { + t.Fatal(err) + } + want := map[task.Quadrant]string{ + task.Do: "Do It First", + task.Schedule: "Schedule It", + task.Delegate: "Delegate It", + task.Eliminate: "Consider Eliminating It", + } + for q, w := range want { + if got := labels.Of(q); got != w { + t.Errorf("quadrant %d label = %q, want %q", q, got, w) + } + if labels.IsCustom(q) { + t.Errorf("quadrant %d reported as custom before any rename", q) + } + } +} + +func TestSetQuadrantLabel(t *testing.T) { + s := testStore(t) + got, _, err := s.SetQuadrantLabel(task.Do, "Firefighting") + if err != nil { + t.Fatal(err) + } + if got != "Firefighting" { + t.Errorf("SetQuadrantLabel returned %q", got) + } + + labels, err := s.QuadrantLabels() + if err != nil { + t.Fatal(err) + } + if labels.Of(task.Do) != "Firefighting" { + t.Errorf("label = %q, want Firefighting", labels.Of(task.Do)) + } + if !labels.IsCustom(task.Do) { + t.Error("renamed quadrant should report as custom") + } + // Renaming one quadrant must not disturb the others. + if labels.Of(task.Schedule) != "Schedule It" { + t.Errorf("Schedule label = %q, want the default", labels.Of(task.Schedule)) + } +} + +func TestSetQuadrantLabelResetsOnBlank(t *testing.T) { + s := testStore(t) + if _, _, err := s.SetQuadrantLabel(task.Eliminate, "Junk"); err != nil { + t.Fatal(err) + } + got, _, err := s.SetQuadrantLabel(task.Eliminate, " ") + if err != nil { + t.Fatal(err) + } + if got != "Consider Eliminating It" { + t.Errorf("reset returned %q, want the default", got) + } + d, err := s.Load() + if err != nil { + t.Fatal(err) + } + // The override is removed, not stored as an empty string. + if _, ok := d.Labels[task.Eliminate]; ok { + t.Error("reset should delete the override, not blank it") + } +} + +func TestSetQuadrantLabelValidates(t *testing.T) { + s := testStore(t) + if _, _, err := s.SetQuadrantLabel(9, "Nope"); err == nil { + t.Error("invalid quadrant should error") + } + long := strings.Repeat("x", task.MaxLabelLen+1) + if _, _, err := s.SetQuadrantLabel(task.Do, long); err == nil { + t.Error("over-long label should error") + } + labels, _ := s.QuadrantLabels() + if labels.Of(task.Do) != "Do It First" { + t.Errorf("failed rename changed the label to %q", labels.Of(task.Do)) + } +} + +func TestQuadrantLabelIsUndoable(t *testing.T) { + s := testStore(t) + if _, _, err := s.SetQuadrantLabel(task.Delegate, "Hand Off"); err != nil { + t.Fatal(err) + } + label, _, err := s.Undo() + if err != nil { + t.Fatal(err) + } + if !strings.Contains(label, "Hand Off") { + t.Errorf("undo label = %q, want it to name the rename", label) + } + labels, _ := s.QuadrantLabels() + if labels.Of(task.Delegate) != "Delegate It" { + t.Errorf("after undo, label = %q, want the default back", labels.Of(task.Delegate)) + } + + if _, _, err := s.Redo(); err != nil { + t.Fatal(err) + } + labels, _ = s.QuadrantLabels() + if labels.Of(task.Delegate) != "Hand Off" { + t.Errorf("after redo, label = %q, want Hand Off", labels.Of(task.Delegate)) + } +} + +func TestSetSameLabelIsANoOp(t *testing.T) { + s := testStore(t) + s.Add("anchor", task.Do) + if _, _, err := s.SetQuadrantLabel(task.Do, "Do It First"); err != nil { + t.Fatal(err) + } + d, err := s.Load() + if err != nil { + t.Fatal(err) + } + if UndoLabel(d) != `add "anchor"` { + t.Errorf("undo top = %q; setting the label it already has should not record", UndoLabel(d)) + } +} + +// Labels.Of is the single choke point every frontend renders a quadrant name +// through, so it sanitizes. SetQuadrantLabel rejects control characters on the +// way in; this covers a label that reached the file some other way — an older +// build, a hand edit, or a synced copy. +func TestLabelsOfSanitizesUntrustedFile(t *testing.T) { + l := Labels{task.Do: "red\x1b[31m", task.Schedule: "two\nlines"} + + got := l.Of(task.Do) + if strings.ContainsRune(got, 0x1b) { + t.Errorf("Of(Do) = %q, still contains an escape", got) + } + if !strings.Contains(got, "red") { + t.Errorf("Of(Do) = %q, dropped visible text", got) + } + if got := l.Of(task.Schedule); strings.ContainsRune(got, '\n') { + t.Errorf("Of(Schedule) = %q, still contains a newline", got) + } + // An unrenamed quadrant still falls back to its default. + if got, want := l.Of(task.Delegate), task.Delegate.Label(); got != want { + t.Errorf("Of(Delegate) = %q, want the default %q", got, want) + } + // The stored label itself is untouched; only the rendered form changes. + if l[task.Do] != "red\x1b[31m" { + t.Error("Of must not rewrite the stored label") + } +} + +// The gate used to be checked once, before serving. A client that stayed +// connected therefore kept full access after `ike mcp disable`, while +// `ike mcp status` reported "off". These pin the data-layer check that closed +// that window. diff --git a/internal/store/mcp_test.go b/internal/store/mcp_test.go new file mode 100644 index 0000000..ffd1f23 --- /dev/null +++ b/internal/store/mcp_test.go @@ -0,0 +1,192 @@ +package store + +import ( + "errors" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/jonascript/ike/internal/task" +) + +// titles returns the titles of q's tasks in display order. + +func TestMCPDisabledByDefault(t *testing.T) { + s := testStore(t) + on, err := s.MCPEnabled() + if err != nil { + t.Fatal(err) + } + if on { + t.Error("a fresh matrix should have MCP access off") + } + // Adding tasks must not switch it on by side effect. + s.Add("a task", task.Do) + if on, _ := s.MCPEnabled(); on { + t.Error("MCP access turned on by an unrelated write") + } +} + +func TestMCPEnabledPersists(t *testing.T) { + dir := t.TempDir() + p := filepath.Join(dir, "tasks.json") + + changed, err := OpenAt(p).SetMCPEnabled(true) + if err != nil { + t.Fatal(err) + } + if !changed { + t.Error("enabling from the default should report a change") + } + // A separate Store instance, as a later process would see it. + if on, _ := OpenAt(p).MCPEnabled(); !on { + t.Error("setting did not survive a reload") + } + + changed, err = OpenAt(p).SetMCPEnabled(true) + if err != nil { + t.Fatal(err) + } + if changed { + t.Error("enabling twice should report no change") + } + + if _, err := OpenAt(p).SetMCPEnabled(false); err != nil { + t.Fatal(err) + } + if on, _ := OpenAt(p).MCPEnabled(); on { + t.Error("disable did not stick") + } +} + +func TestMCPSettingIsNotUndoable(t *testing.T) { + s := testStore(t) + s.Add("a task", task.Do) + if _, err := s.SetMCPEnabled(true); err != nil { + t.Fatal(err) + } + + // Undo must reach past the permission change to the task change, and must + // not restore the old permission on the way. + label, _, err := s.Undo() + if err != nil { + t.Fatal(err) + } + if label != `add "a task"` { + t.Errorf("undo label = %q; the MCP setting should not occupy an undo slot", label) + } + if on, _ := s.MCPEnabled(); !on { + t.Error("undo switched MCP access back off") + } +} + +// The gate used to be checked once, before serving. A client that stayed +// connected therefore kept full access after `ike mcp disable`, while +// `ike mcp status` reported "off". These pin the data-layer check that closed +// that window. +func TestMCPGateRevokesLiveSession(t *testing.T) { + s := testStore(t) + if _, err := s.SetMCPEnabled(true); err != nil { + t.Fatal(err) + } + + // The session a connected client holds. + live := s.ForMCP() + if _, _, err := live.Add("while enabled", task.Do); err != nil { + t.Fatalf("Add with access on: %v", err) + } + if _, err := live.Load(); err != nil { + t.Fatalf("Load with access on: %v", err) + } + + // Revoked from another process, on the same file, mid-session. + if _, err := s.SetMCPEnabled(false); err != nil { + t.Fatal(err) + } + + if _, _, err := live.Add("after revoke", task.Do); !errors.Is(err, ErrMCPDisabled) { + t.Errorf("Add after revoke: err = %v, want ErrMCPDisabled", err) + } + if _, err := live.Load(); !errors.Is(err, ErrMCPDisabled) { + t.Errorf("Load after revoke: err = %v, want ErrMCPDisabled", err) + } + if _, _, err := live.Complete(1); !errors.Is(err, ErrMCPDisabled) { + t.Errorf("Complete after revoke: err = %v, want ErrMCPDisabled", err) + } + if _, _, err := live.Delete(1); !errors.Is(err, ErrMCPDisabled) { + t.Errorf("Delete after revoke: err = %v, want ErrMCPDisabled", err) + } + if _, _, err := live.Undo(); !errors.Is(err, ErrMCPDisabled) { + t.Errorf("Undo after revoke: err = %v, want ErrMCPDisabled", err) + } + + // The revoked mutations must not have landed, and the owner's own access is + // unaffected — that is what `ike mcp status` and the TUI keep using. + d, err := s.Load() + if err != nil { + t.Fatal(err) + } + if len(d.Tasks) != 1 || d.Tasks[0].Title != "while enabled" { + t.Errorf("tasks = %+v, want only the pre-revoke task", d.Tasks) + } + + // Re-enabling restores the same session, without reconnecting. + if _, err := s.SetMCPEnabled(true); err != nil { + t.Fatal(err) + } + if _, err := live.Load(); err != nil { + t.Errorf("Load after re-enable: %v", err) + } +} + +// A store that was never marked for MCP use is unaffected by the setting, so +// the TUI and CLI keep working while agent access is off. + +// A store that was never marked for MCP use is unaffected by the setting, so +// the TUI and CLI keep working while agent access is off. +func TestGateDoesNotAffectOwnerAccess(t *testing.T) { + s := testStore(t) + if enabled, err := s.MCPEnabled(); err != nil || enabled { + t.Fatalf("MCPEnabled() = %v, %v; want false, nil", enabled, err) + } + if _, _, err := s.Add("owner task", task.Do); err != nil { + t.Errorf("owner Add with MCP off: %v", err) + } + if _, err := s.Load(); err != nil { + t.Errorf("owner Load with MCP off: %v", err) + } +} + +func TestMCPErrorsOmitDataFilePath(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "tasks.json") + if err := os.WriteFile(path, []byte("{ not json"), 0o600); err != nil { + t.Fatal(err) + } + gated := OpenAt(path).ForMCP() + + _, err := gated.Load() + if err == nil { + t.Fatal("expected a parse error") + } + if strings.Contains(err.Error(), dir) { + t.Errorf("error discloses the data file's directory to the agent: %v", err) + } + // The file name still appears, so the message stays actionable. + if !strings.Contains(err.Error(), "tasks.json") { + t.Errorf("error should still name the file: %v", err) + } + + // The owner's view keeps the full path, which is what makes a CLI error + // useful. + if _, err := OpenAt(path).Load(); err == nil || !strings.Contains(err.Error(), dir) { + t.Errorf("ungated error should keep the full path: %v", err) + } +} + +// Archive order is defined once, in Data.ListArchive, and both `ike archive` +// and the TUI's archive view render it. The TUI used to reverse the stored +// slice instead, which agrees only while every archived task carries a +// completion stamp — a file written by an older build, or hand-edited, need +// not. This pins the definition that both now share. diff --git a/internal/store/ops.go b/internal/store/ops.go index efc3a85..4636131 100644 --- a/internal/store/ops.go +++ b/internal/store/ops.go @@ -36,14 +36,21 @@ var ( ErrNothingToRedo = errors.New("nothing to redo") ) +// Every mutating operation returns the post-mutation Data alongside its own +// result. Mutate already produces it, so handing it back costs nothing and +// spares callers a second read: the quadrant labels a frontend needs to render +// the outcome, and the full state the TUI re-renders from, are both in there. +// Reading them again would also be a read of a *later* file state, which may +// no longer be the one the operation produced. + // Add creates a new task at the bottom of the given quadrant and returns it. -func (s *Store) Add(title string, q task.Quadrant) (task.Task, error) { +func (s *Store) Add(title string, q task.Quadrant) (task.Task, Data, error) { title = strings.TrimSpace(title) if err := task.Validate(title, q); err != nil { - return task.Task{}, err + return task.Task{}, Data{}, err } var created task.Task - _, err := s.Mutate(func(d *Data) error { + d, err := s.Mutate(func(d *Data) error { pushUndo(d, fmt.Sprintf("add %q", title)) created = task.Task{ ID: d.NextID, @@ -56,13 +63,13 @@ func (s *Store) Add(title string, q task.Quadrant) (task.Task, error) { d.Tasks = append(d.Tasks, created) return nil }) - return created, err + return created, d, err } // Complete moves a task to the archive, stamping DoneAt. -func (s *Store) Complete(id int) (task.Task, error) { +func (s *Store) Complete(id int) (task.Task, Data, error) { var done task.Task - _, err := s.Mutate(func(d *Data) error { + d, err := s.Mutate(func(d *Data) error { i, err := findTask(d, id) if err != nil { return err @@ -75,15 +82,15 @@ func (s *Store) Complete(id int) (task.Task, error) { d.Archive = append(d.Archive, done) return nil }) - return done, err + return done, d, err } // Restore moves an archived task back into the active matrix, clearing its // completion stamp and placing it at the bottom of the quadrant it was // completed in. -func (s *Store) Restore(id int) (task.Task, error) { +func (s *Store) Restore(id int) (task.Task, Data, error) { var restored task.Task - _, err := s.Mutate(func(d *Data) error { + d, err := s.Mutate(func(d *Data) error { i, err := findArchived(d, id) if err != nil { return err @@ -96,16 +103,16 @@ func (s *Store) Restore(id int) (task.Task, error) { d.Tasks = append(d.Tasks, restored) return nil }) - return restored, err + return restored, d, err } // Move changes a task's quadrant, placing it at the bottom of the destination. -func (s *Store) Move(id int, q task.Quadrant) (task.Task, error) { +func (s *Store) Move(id int, q task.Quadrant) (task.Task, Data, error) { if !q.Valid() { - return task.Task{}, fmt.Errorf("quadrant must be 1-4, got %d", q) + return task.Task{}, Data{}, fmt.Errorf("quadrant must be 1-4, got %d", q) } var moved task.Task - _, err := s.Mutate(func(d *Data) error { + d, err := s.Mutate(func(d *Data) error { i, err := findTask(d, id) if err != nil { return err @@ -120,15 +127,15 @@ func (s *Store) Move(id int, q task.Quadrant) (task.Task, error) { moved = d.Tasks[i] return nil }) - return moved, err + return moved, d, err } // Reorder moves a task within its quadrant by delta positions — negative is // toward the top, positive toward the bottom — clamped at either end. It // rewrites the whole quadrant's ranks, so repeated moves never lose precision. -func (s *Store) Reorder(id int, delta int) (task.Task, error) { +func (s *Store) Reorder(id int, delta int) (task.Task, Data, error) { var moved task.Task - _, err := s.Mutate(func(d *Data) error { + d, err := s.Mutate(func(d *Data) error { i, err := findTask(d, id) if err != nil { return err @@ -151,22 +158,22 @@ func (s *Store) Reorder(id int, delta int) (task.Task, error) { moved = d.Tasks[i] return nil }) - return moved, err + return moved, d, err } // SetQuadrantLabel renames a quadrant's heading. A blank label clears the // override, restoring the built-in default. It returns the resulting display // name. -func (s *Store) SetQuadrantLabel(q task.Quadrant, label string) (string, error) { +func (s *Store) SetQuadrantLabel(q task.Quadrant, label string) (string, Data, error) { if !q.Valid() { - return "", fmt.Errorf("quadrant must be 1-4, got %d", q) + return "", Data{}, fmt.Errorf("quadrant must be 1-4, got %d", q) } label = strings.TrimSpace(label) if err := task.ValidateLabel(label); err != nil { - return "", err + return "", Data{}, err } var result string - _, err := s.Mutate(func(d *Data) error { + d, err := s.Mutate(func(d *Data) error { was := d.Labels.Of(q) if label == was { result = was @@ -185,7 +192,7 @@ func (s *Store) SetQuadrantLabel(q task.Quadrant, label string) (string, error) result = d.Labels.Of(q) return nil }) - return result, err + return result, d, err } // QuadrantLabels returns the display names of all four quadrants, custom where @@ -195,11 +202,18 @@ func (s *Store) QuadrantLabels() (Labels, error) { if err != nil { return nil, err } + return d.QuadrantLabels(), nil +} + +// QuadrantLabels returns the display names of all four quadrants, custom where +// set and default otherwise. It is the pure form of Store.QuadrantLabels, for +// callers that already hold the data — every mutation hands theirs back. +func (d Data) QuadrantLabels() Labels { out := make(Labels, 4) for q := task.Do; q <= task.Eliminate; q++ { out[q] = d.Labels.Of(q) } - return out, nil + return out } // SetMCPEnabled turns agent access to this matrix on or off, and reports @@ -207,6 +221,9 @@ func (s *Store) QuadrantLabels() (Labels, error) { // // This is a permission, not an edit: it is deliberately kept off the undo // stack, so no sequence of undo or redo can re-open access the owner closed. +// It also does not return Data the way the task operations do — nothing +// renders a result from it, and handing an MCP-gated caller a full copy of the +// matrix from the call that flips the gate would be a poor shape. func (s *Store) SetMCPEnabled(on bool) (changed bool, err error) { _, err = s.Mutate(func(d *Data) error { changed = d.MCPEnabled != on @@ -226,10 +243,10 @@ func (s *Store) MCPEnabled() (bool, error) { } // Rename changes a task's title. -func (s *Store) Rename(id int, title string) (task.Task, error) { +func (s *Store) Rename(id int, title string) (task.Task, Data, error) { title = strings.TrimSpace(title) var renamed task.Task - _, err := s.Mutate(func(d *Data) error { + d, err := s.Mutate(func(d *Data) error { i, err := findTask(d, id) if err != nil { return err @@ -242,14 +259,14 @@ func (s *Store) Rename(id int, title string) (task.Task, error) { renamed = d.Tasks[i] return nil }) - return renamed, err + return renamed, d, err } // Delete removes an active task permanently (it does not go to the archive). // It is still undoable until it falls off the undo stack. -func (s *Store) Delete(id int) (task.Task, error) { +func (s *Store) Delete(id int) (task.Task, Data, error) { var deleted task.Task - _, err := s.Mutate(func(d *Data) error { + d, err := s.Mutate(func(d *Data) error { i, err := findTask(d, id) if err != nil { return err @@ -259,16 +276,16 @@ func (s *Store) Delete(id int) (task.Task, error) { d.Tasks = append(d.Tasks[:i], d.Tasks[i+1:]...) return nil }) - return deleted, err + return deleted, d, err } // Undo reverts the most recent recorded mutation and returns its label. It // restores both task lists but deliberately leaves next_id alone: IDs stay // monotonic and are never reused, so undoing an add does not free its ID. // The undone state moves to the redo stack, so Redo puts it back. -func (s *Store) Undo() (string, error) { +func (s *Store) Undo() (string, Data, error) { var label string - _, err := s.Mutate(func(d *Data) error { + d, err := s.Mutate(func(d *Data) error { if len(d.Undo) == 0 { return ErrNothingToUndo } @@ -280,15 +297,15 @@ func (s *Store) Undo() (string, error) { label = snap.Label return nil }) - return label, err + return label, d, err } // Redo re-applies the most recently undone change and returns its label. It // is available only until the next real mutation, which discards the redo // stack. A redo is itself undoable. -func (s *Store) Redo() (string, error) { +func (s *Store) Redo() (string, Data, error) { var label string - _, err := s.Mutate(func(d *Data) error { + d, err := s.Mutate(func(d *Data) error { if len(d.Redo) == 0 { return ErrNothingToRedo } @@ -301,7 +318,7 @@ func (s *Store) Redo() (string, error) { label = snap.Label return nil }) - return label, err + return label, d, err } // UndoLabel reports what the next Undo would revert, or "" if the stack is @@ -411,6 +428,13 @@ func (s *Store) List(q task.Quadrant) ([]task.Task, error) { if err != nil { return nil, err } + return d.List(q), nil +} + +// List returns d's active tasks, optionally filtered to one quadrant (q == 0 +// means all), in display order. It is the single definition of that list, used +// by Store.List and rendered directly by the TUI from the data it already has. +func (d Data) List(q task.Quadrant) []task.Task { tasks := make([]task.Task, 0, len(d.Tasks)) for _, t := range d.Tasks { if q == 0 || t.Quadrant == q { @@ -418,7 +442,7 @@ func (s *Store) List(q task.Quadrant) ([]task.Task, error) { } } task.SortOrder(tasks) - return tasks, nil + return tasks } // ListArchive returns archived tasks, newest completion first. @@ -427,6 +451,17 @@ func (s *Store) ListArchive() ([]task.Task, error) { if err != nil { return nil, err } + return d.ListArchive(), nil +} + +// ListArchive returns d's archived tasks, newest completion first. It is the +// single definition of archive order: `ike archive` and the TUI's archive view +// both render this, so they cannot drift apart. Tasks with no completion stamp +// — reachable from a hand-edited or pre-archive data file — sort by ID, which +// is why this is not just a reversal of the stored slice. +func (d Data) ListArchive() []task.Task { + // Not slices.Clone: it preserves nil, and `ike archive --json` must emit [] + // rather than null for an empty archive. arch := make([]task.Task, len(d.Archive)) copy(arch, d.Archive) sort.SliceStable(arch, func(i, j int) bool { @@ -436,7 +471,7 @@ func (s *Store) ListArchive() ([]task.Task, error) { } return arch[i].ID > arch[j].ID }) - return arch, nil + return arch } func findTask(d *Data, id int) (int, error) { diff --git a/internal/store/ops_test.go b/internal/store/ops_test.go index 42add80..e736a8c 100644 --- a/internal/store/ops_test.go +++ b/internal/store/ops_test.go @@ -2,29 +2,28 @@ package store import ( "encoding/json" - "errors" "os" "path/filepath" - "strings" + "slices" "testing" + "time" "github.com/jonascript/ike/internal/task" ) // titles returns the titles of q's tasks in display order. -func titles(t *testing.T, s *Store, q task.Quadrant) []string { - t.Helper() - ts, err := s.List(q) - if err != nil { - t.Fatal(err) - } + +func titlesOf(ts []task.Task) []string { out := make([]string, len(ts)) - for i, tk := range ts { - out[i] = tk.Title + for i, t := range ts { + out[i] = t.Title } return out } +// An empty archive must marshal as [] rather than null: `ike archive --json` +// is a machine interface, and a nil slice would change its shape. + func equal(a, b []string) bool { if len(a) != len(b) { return false @@ -37,17 +36,31 @@ func equal(a, b []string) bool { return true } +// titles returns the titles of q's tasks in display order. +func titles(t *testing.T, s *Store, q task.Quadrant) []string { + t.Helper() + ts, err := s.List(q) + if err != nil { + t.Fatal(err) + } + out := make([]string, len(ts)) + for i, tk := range ts { + out[i] = tk.Title + } + return out +} + func TestRestoreUnarchives(t *testing.T) { s := testStore(t) - added, err := s.Add("write the thing", task.Delegate) + added, _, err := s.Add("write the thing", task.Delegate) if err != nil { t.Fatal(err) } - if _, err := s.Complete(added.ID); err != nil { + if _, _, err := s.Complete(added.ID); err != nil { t.Fatal(err) } - restored, err := s.Restore(added.ID) + restored, _, err := s.Restore(added.ID) if err != nil { t.Fatal(err) } @@ -72,24 +85,24 @@ func TestRestoreUnarchives(t *testing.T) { func TestRestoreUnknownID(t *testing.T) { s := testStore(t) - a, _ := s.Add("still active", task.Do) - if _, err := s.Restore(a.ID); err == nil { + a, _, _ := s.Add("still active", task.Do) + if _, _, err := s.Restore(a.ID); err == nil { t.Error("restoring an active (not archived) task should error") } - if _, err := s.Restore(999); err == nil { + if _, _, err := s.Restore(999); err == nil { t.Error("restoring an unknown id should error") } } func TestRestoreGoesToBottom(t *testing.T) { s := testStore(t) - a, _ := s.Add("first", task.Do) + a, _, _ := s.Add("first", task.Do) s.Add("second", task.Do) - if _, err := s.Complete(a.ID); err != nil { + if _, _, err := s.Complete(a.ID); err != nil { t.Fatal(err) } s.Add("third", task.Do) - if _, err := s.Restore(a.ID); err != nil { + if _, _, err := s.Restore(a.ID); err != nil { t.Fatal(err) } got := titles(t, s, task.Do) @@ -102,24 +115,24 @@ func TestRestoreGoesToBottom(t *testing.T) { func TestReorderWithinQuadrant(t *testing.T) { s := testStore(t) s.Add("a", task.Schedule) - b, _ := s.Add("b", task.Schedule) - c, _ := s.Add("c", task.Schedule) + b, _, _ := s.Add("b", task.Schedule) + c, _, _ := s.Add("c", task.Schedule) - if _, err := s.Reorder(c.ID, -1); err != nil { + if _, _, err := s.Reorder(c.ID, -1); err != nil { t.Fatal(err) } if got, want := titles(t, s, task.Schedule), []string{"a", "c", "b"}; !equal(got, want) { t.Fatalf("after c up: %v, want %v", got, want) } - if _, err := s.Reorder(b.ID, ToTop); err != nil { + if _, _, err := s.Reorder(b.ID, ToTop); err != nil { t.Fatal(err) } if got, want := titles(t, s, task.Schedule), []string{"b", "a", "c"}; !equal(got, want) { t.Fatalf("after b to top: %v, want %v", got, want) } - if _, err := s.Reorder(b.ID, ToBottom); err != nil { + if _, _, err := s.Reorder(b.ID, ToBottom); err != nil { t.Fatal(err) } if got, want := titles(t, s, task.Schedule), []string{"a", "c", "b"}; !equal(got, want) { @@ -129,11 +142,11 @@ func TestReorderWithinQuadrant(t *testing.T) { func TestReorderClampsAtEnds(t *testing.T) { s := testStore(t) - a, _ := s.Add("a", task.Do) + a, _, _ := s.Add("a", task.Do) s.Add("b", task.Do) // Already at the top; moving up is a no-op, not an error. - if _, err := s.Reorder(a.ID, -1); err != nil { + if _, _, err := s.Reorder(a.ID, -1); err != nil { t.Fatal(err) } if got, want := titles(t, s, task.Do), []string{"a", "b"}; !equal(got, want) { @@ -153,10 +166,10 @@ func TestReorderClampsAtEnds(t *testing.T) { func TestReorderDoesNotLeakAcrossQuadrants(t *testing.T) { s := testStore(t) s.Add("do-1", task.Do) - sched, _ := s.Add("sched-1", task.Schedule) + sched, _, _ := s.Add("sched-1", task.Schedule) s.Add("sched-2", task.Schedule) - if _, err := s.Reorder(sched.ID, ToBottom); err != nil { + if _, _, err := s.Reorder(sched.ID, ToBottom); err != nil { t.Fatal(err) } if got, want := titles(t, s, task.Do), []string{"do-1"}; !equal(got, want) { @@ -169,15 +182,15 @@ func TestReorderDoesNotLeakAcrossQuadrants(t *testing.T) { func TestReorderSurvivesManyMoves(t *testing.T) { s := testStore(t) - a, _ := s.Add("a", task.Do) + a, _, _ := s.Add("a", task.Do) s.Add("b", task.Do) // Ranks are rewritten per quadrant, so swapping repeatedly must not drift. for i := 0; i < 200; i++ { - if _, err := s.Reorder(a.ID, 1); err != nil { + if _, _, err := s.Reorder(a.ID, 1); err != nil { t.Fatal(err) } - if _, err := s.Reorder(a.ID, -1); err != nil { + if _, _, err := s.Reorder(a.ID, -1); err != nil { t.Fatal(err) } } @@ -192,574 +205,6 @@ func TestReorderSurvivesManyMoves(t *testing.T) { } } -func TestQuadrantLabelDefaults(t *testing.T) { - s := testStore(t) - labels, err := s.QuadrantLabels() - if err != nil { - t.Fatal(err) - } - want := map[task.Quadrant]string{ - task.Do: "Do It First", - task.Schedule: "Schedule It", - task.Delegate: "Delegate It", - task.Eliminate: "Consider Eliminating It", - } - for q, w := range want { - if got := labels.Of(q); got != w { - t.Errorf("quadrant %d label = %q, want %q", q, got, w) - } - if labels.IsCustom(q) { - t.Errorf("quadrant %d reported as custom before any rename", q) - } - } -} - -func TestSetQuadrantLabel(t *testing.T) { - s := testStore(t) - got, err := s.SetQuadrantLabel(task.Do, "Firefighting") - if err != nil { - t.Fatal(err) - } - if got != "Firefighting" { - t.Errorf("SetQuadrantLabel returned %q", got) - } - - labels, err := s.QuadrantLabels() - if err != nil { - t.Fatal(err) - } - if labels.Of(task.Do) != "Firefighting" { - t.Errorf("label = %q, want Firefighting", labels.Of(task.Do)) - } - if !labels.IsCustom(task.Do) { - t.Error("renamed quadrant should report as custom") - } - // Renaming one quadrant must not disturb the others. - if labels.Of(task.Schedule) != "Schedule It" { - t.Errorf("Schedule label = %q, want the default", labels.Of(task.Schedule)) - } -} - -func TestSetQuadrantLabelResetsOnBlank(t *testing.T) { - s := testStore(t) - if _, err := s.SetQuadrantLabel(task.Eliminate, "Junk"); err != nil { - t.Fatal(err) - } - got, err := s.SetQuadrantLabel(task.Eliminate, " ") - if err != nil { - t.Fatal(err) - } - if got != "Consider Eliminating It" { - t.Errorf("reset returned %q, want the default", got) - } - d, err := s.Load() - if err != nil { - t.Fatal(err) - } - // The override is removed, not stored as an empty string. - if _, ok := d.Labels[task.Eliminate]; ok { - t.Error("reset should delete the override, not blank it") - } -} - -func TestSetQuadrantLabelValidates(t *testing.T) { - s := testStore(t) - if _, err := s.SetQuadrantLabel(9, "Nope"); err == nil { - t.Error("invalid quadrant should error") - } - long := strings.Repeat("x", task.MaxLabelLen+1) - if _, err := s.SetQuadrantLabel(task.Do, long); err == nil { - t.Error("over-long label should error") - } - labels, _ := s.QuadrantLabels() - if labels.Of(task.Do) != "Do It First" { - t.Errorf("failed rename changed the label to %q", labels.Of(task.Do)) - } -} - -func TestQuadrantLabelIsUndoable(t *testing.T) { - s := testStore(t) - if _, err := s.SetQuadrantLabel(task.Delegate, "Hand Off"); err != nil { - t.Fatal(err) - } - label, err := s.Undo() - if err != nil { - t.Fatal(err) - } - if !strings.Contains(label, "Hand Off") { - t.Errorf("undo label = %q, want it to name the rename", label) - } - labels, _ := s.QuadrantLabels() - if labels.Of(task.Delegate) != "Delegate It" { - t.Errorf("after undo, label = %q, want the default back", labels.Of(task.Delegate)) - } - - if _, err := s.Redo(); err != nil { - t.Fatal(err) - } - labels, _ = s.QuadrantLabels() - if labels.Of(task.Delegate) != "Hand Off" { - t.Errorf("after redo, label = %q, want Hand Off", labels.Of(task.Delegate)) - } -} - -func TestUndoOfTaskChangeLeavesLabelsAlone(t *testing.T) { - s := testStore(t) - if _, err := s.SetQuadrantLabel(task.Do, "Firefighting"); err != nil { - t.Fatal(err) - } - a, _ := s.Add("something", task.Do) - if _, err := s.Delete(a.ID); err != nil { - t.Fatal(err) - } - // Undoing the delete must not roll the rename back with it. - if _, err := s.Undo(); err != nil { - t.Fatal(err) - } - labels, _ := s.QuadrantLabels() - if labels.Of(task.Do) != "Firefighting" { - t.Errorf("label = %q, want the rename to survive an unrelated undo", labels.Of(task.Do)) - } -} - -func TestSetSameLabelIsANoOp(t *testing.T) { - s := testStore(t) - s.Add("anchor", task.Do) - if _, err := s.SetQuadrantLabel(task.Do, "Do It First"); err != nil { - t.Fatal(err) - } - d, err := s.Load() - if err != nil { - t.Fatal(err) - } - if UndoLabel(d) != `add "anchor"` { - t.Errorf("undo top = %q; setting the label it already has should not record", UndoLabel(d)) - } -} - -func TestMCPDisabledByDefault(t *testing.T) { - s := testStore(t) - on, err := s.MCPEnabled() - if err != nil { - t.Fatal(err) - } - if on { - t.Error("a fresh matrix should have MCP access off") - } - // Adding tasks must not switch it on by side effect. - s.Add("a task", task.Do) - if on, _ := s.MCPEnabled(); on { - t.Error("MCP access turned on by an unrelated write") - } -} - -func TestMCPEnabledPersists(t *testing.T) { - dir := t.TempDir() - p := filepath.Join(dir, "tasks.json") - - changed, err := OpenAt(p).SetMCPEnabled(true) - if err != nil { - t.Fatal(err) - } - if !changed { - t.Error("enabling from the default should report a change") - } - // A separate Store instance, as a later process would see it. - if on, _ := OpenAt(p).MCPEnabled(); !on { - t.Error("setting did not survive a reload") - } - - changed, err = OpenAt(p).SetMCPEnabled(true) - if err != nil { - t.Fatal(err) - } - if changed { - t.Error("enabling twice should report no change") - } - - if _, err := OpenAt(p).SetMCPEnabled(false); err != nil { - t.Fatal(err) - } - if on, _ := OpenAt(p).MCPEnabled(); on { - t.Error("disable did not stick") - } -} - -func TestMCPSettingIsNotUndoable(t *testing.T) { - s := testStore(t) - s.Add("a task", task.Do) - if _, err := s.SetMCPEnabled(true); err != nil { - t.Fatal(err) - } - - // Undo must reach past the permission change to the task change, and must - // not restore the old permission on the way. - label, err := s.Undo() - if err != nil { - t.Fatal(err) - } - if label != `add "a task"` { - t.Errorf("undo label = %q; the MCP setting should not occupy an undo slot", label) - } - if on, _ := s.MCPEnabled(); !on { - t.Error("undo switched MCP access back off") - } -} - -func TestUndoCannotReopenRevokedAccess(t *testing.T) { - s := testStore(t) - if _, err := s.SetMCPEnabled(true); err != nil { - t.Fatal(err) - } - s.Add("a task", task.Do) - if _, err := s.SetMCPEnabled(false); err != nil { - t.Fatal(err) - } - - // No amount of undo or redo may hand access back. - for i := 0; i < 5; i++ { - if _, err := s.Undo(); err != nil { - break - } - if on, _ := s.MCPEnabled(); on { - t.Fatalf("undo %d re-enabled revoked MCP access", i) - } - } - for i := 0; i < 5; i++ { - if _, err := s.Redo(); err != nil { - break - } - if on, _ := s.MCPEnabled(); on { - t.Fatalf("redo %d re-enabled revoked MCP access", i) - } - } -} - -func TestUndoRestoresPreviousState(t *testing.T) { - s := testStore(t) - a, _ := s.Add("keep me", task.Do) - - if _, err := s.Complete(a.ID); err != nil { - t.Fatal(err) - } - label, err := s.Undo() - if err != nil { - t.Fatal(err) - } - if label != `complete "keep me"` { - t.Errorf("label = %q, want the complete label", label) - } - d, _ := s.Load() - if len(d.Tasks) != 1 || len(d.Archive) != 0 { - t.Fatalf("after undo: %d active, %d archived; want 1 and 0", len(d.Tasks), len(d.Archive)) - } - - // Undo the add itself. - if _, err := s.Undo(); err != nil { - t.Fatal(err) - } - d, _ = s.Load() - if len(d.Tasks) != 0 { - t.Errorf("after second undo: %d active, want 0", len(d.Tasks)) - } -} - -func TestUndoOfDeleteBringsTaskBack(t *testing.T) { - s := testStore(t) - a, _ := s.Add("oops", task.Do) - if _, err := s.Delete(a.ID); err != nil { - t.Fatal(err) - } - if _, err := s.Undo(); err != nil { - t.Fatal(err) - } - got := titles(t, s, task.Do) - if !equal(got, []string{"oops"}) { - t.Errorf("after undoing delete: %v, want [oops]", got) - } -} - -func TestUndoDoesNotReuseIDs(t *testing.T) { - s := testStore(t) - a, _ := s.Add("first", task.Do) - if _, err := s.Undo(); err != nil { // undo the add - t.Fatal(err) - } - b, err := s.Add("second", task.Do) - if err != nil { - t.Fatal(err) - } - if b.ID == a.ID { - t.Errorf("ID %d was reused after undo; IDs must stay monotonic", b.ID) - } -} - -func TestUndoEmptyStack(t *testing.T) { - s := testStore(t) - if _, err := s.Undo(); err == nil { - t.Error("undo with nothing to undo should error") - } -} - -func TestRepeatedUndoWalksBack(t *testing.T) { - s := testStore(t) - s.Add("a", task.Do) - s.Add("b", task.Do) - if _, err := s.Undo(); err != nil { // undoes add "b" - t.Fatal(err) - } - label, err := s.Undo() // must undo add "a", not re-apply add "b" - if err != nil { - t.Fatal(err) - } - if label != `add "a"` { - t.Errorf("second undo label = %q, want `add \"a\"`", label) - } - if got := titles(t, s, task.Do); len(got) != 0 { - t.Errorf("after two undos: %v, want nothing", got) - } -} - -func TestRedoReappliesUndoneChange(t *testing.T) { - s := testStore(t) - a, _ := s.Add("ship it", task.Do) - if _, err := s.Complete(a.ID); err != nil { - t.Fatal(err) - } - if _, err := s.Undo(); err != nil { - t.Fatal(err) - } - if arch, _ := s.ListArchive(); len(arch) != 0 { - t.Fatal("undo should have un-archived the task") - } - - label, err := s.Redo() - if err != nil { - t.Fatal(err) - } - if label != `complete "ship it"` { - t.Errorf("redo label = %q, want the complete label", label) - } - active, _ := s.List(0) - arch, _ := s.ListArchive() - if len(active) != 0 || len(arch) != 1 { - t.Errorf("after redo: active=%d archive=%d, want 0/1", len(active), len(arch)) - } -} - -func TestRedoRoundTripIsExact(t *testing.T) { - s := testStore(t) - s.Add("a", task.Do) - b, _ := s.Add("b", task.Do) - s.Add("c", task.Do) - if _, err := s.Reorder(b.ID, ToTop); err != nil { - t.Fatal(err) - } - want := titles(t, s, task.Do) - - if _, err := s.Undo(); err != nil { - t.Fatal(err) - } - if got := titles(t, s, task.Do); equal(got, want) { - t.Fatal("undo did not change the order") - } - if _, err := s.Redo(); err != nil { - t.Fatal(err) - } - if got := titles(t, s, task.Do); !equal(got, want) { - t.Errorf("after undo+redo: %v, want %v (ordering must survive the round trip)", got, want) - } -} - -func TestNewChangeDiscardsRedo(t *testing.T) { - s := testStore(t) - a, _ := s.Add("first", task.Do) - if _, err := s.Complete(a.ID); err != nil { - t.Fatal(err) - } - if _, err := s.Undo(); err != nil { - t.Fatal(err) - } - - // Diverging from the undone branch must strand it: redoing the complete - // here would clobber the task added below. - if _, err := s.Add("second", task.Do); err != nil { - t.Fatal(err) - } - d, err := s.Load() - if err != nil { - t.Fatal(err) - } - if len(d.Redo) != 0 { - t.Errorf("redo stack = %d entries, want 0 after a new change", len(d.Redo)) - } - if _, err := s.Redo(); err == nil { - t.Error("redo after a diverging change should error") - } - if got, want := titles(t, s, task.Do), []string{"first", "second"}; !equal(got, want) { - t.Errorf("tasks = %v, want %v", got, want) - } -} - -func TestRedoAcrossFrontendsIsDiscardedToo(t *testing.T) { - dir := t.TempDir() - p := filepath.Join(dir, "tasks.json") - - a, err := OpenAt(p).Add("mine", task.Do) - if err != nil { - t.Fatal(err) - } - if _, err := OpenAt(p).Delete(a.ID); err != nil { - t.Fatal(err) - } - if _, err := OpenAt(p).Undo(); err != nil { - t.Fatal(err) - } - // A different "process" (CLI or MCP agent) writes. - if _, err := OpenAt(p).Add("theirs", task.Schedule); err != nil { - t.Fatal(err) - } - if _, err := OpenAt(p).Redo(); err == nil { - t.Error("a write from another frontend should invalidate redo") - } -} - -func TestRedoMultipleSteps(t *testing.T) { - s := testStore(t) - s.Add("a", task.Do) - s.Add("b", task.Do) - s.Add("c", task.Do) - - for i := 0; i < 3; i++ { - if _, err := s.Undo(); err != nil { - t.Fatalf("undo %d: %v", i, err) - } - } - if got := titles(t, s, task.Do); len(got) != 0 { - t.Fatalf("after three undos: %v, want nothing", got) - } - - // Redo must walk forward the same distance. This is what breaks if Redo - // clears the redo stack via pushUndo. - for i := 0; i < 3; i++ { - if _, err := s.Redo(); err != nil { - t.Fatalf("redo %d: %v", i, err) - } - } - if got, want := titles(t, s, task.Do), []string{"a", "b", "c"}; !equal(got, want) { - t.Errorf("after three redos: %v, want %v", got, want) - } - if _, err := s.Redo(); err == nil { - t.Error("a fourth redo should error") - } -} - -func TestRedoIsUndoable(t *testing.T) { - s := testStore(t) - a, _ := s.Add("wobble", task.Do) - s.Delete(a.ID) - s.Undo() // task is back - if _, err := s.Redo(); err != nil { - t.Fatal(err) - } - if got := titles(t, s, task.Do); len(got) != 0 { - t.Fatalf("redo should have re-deleted: %v", got) - } - if _, err := s.Undo(); err != nil { - t.Fatal(err) - } - if got, want := titles(t, s, task.Do), []string{"wobble"}; !equal(got, want) { - t.Errorf("undo after redo = %v, want %v", got, want) - } -} - -func TestRedoEmptyStack(t *testing.T) { - s := testStore(t) - s.Add("a", task.Do) - if _, err := s.Redo(); err == nil { - t.Error("redo with nothing undone should error") - } -} - -func TestRedoStackIsCapped(t *testing.T) { - s := testStore(t) - for i := 0; i < undoDepth+5; i++ { - if _, err := s.Add("t", task.Do); err != nil { - t.Fatal(err) - } - } - for i := 0; i < undoDepth; i++ { - if _, err := s.Undo(); err != nil { - t.Fatalf("undo %d: %v", i, err) - } - } - d, err := s.Load() - if err != nil { - t.Fatal(err) - } - if len(d.Redo) != undoDepth { - t.Errorf("redo stack depth = %d, want %d", len(d.Redo), undoDepth) - } -} - -func TestUndoStackIsCapped(t *testing.T) { - s := testStore(t) - for i := 0; i < undoDepth+15; i++ { - if _, err := s.Add("t", task.Do); err != nil { - t.Fatal(err) - } - } - d, err := s.Load() - if err != nil { - t.Fatal(err) - } - if len(d.Undo) != undoDepth { - t.Errorf("undo stack depth = %d, want %d", len(d.Undo), undoDepth) - } -} - -func TestUndoSurvivesReload(t *testing.T) { - dir := t.TempDir() - p := filepath.Join(dir, "tasks.json") - - // One "process" makes a change... - a, err := OpenAt(p).Add("cross-process", task.Do) - if err != nil { - t.Fatal(err) - } - if _, err := OpenAt(p).Complete(a.ID); err != nil { - t.Fatal(err) - } - // ...and another undoes it. - label, err := OpenAt(p).Undo() - if err != nil { - t.Fatal(err) - } - if label != `complete "cross-process"` { - t.Errorf("label = %q", label) - } - d, _ := OpenAt(p).Load() - if len(d.Tasks) != 1 { - t.Errorf("undo across processes left %d active tasks, want 1", len(d.Tasks)) - } -} - -func TestFailedMutationDoesNotRecordUndo(t *testing.T) { - s := testStore(t) - a, _ := s.Add("valid", task.Do) - if _, err := s.Rename(a.ID, " "); err == nil { - t.Fatal("rename to blank should fail") - } - d, err := s.Load() - if err != nil { - t.Fatal(err) - } - if len(d.Undo) != 1 || UndoLabel(d) != `add "valid"` { - t.Errorf("undo stack = %d entries, top %q; a failed rename should not record", - len(d.Undo), UndoLabel(d)) - } -} - func TestUpgradesVersionOneFile(t *testing.T) { p := filepath.Join(t.TempDir(), "tasks.json") // A version-1 file: no ranks, no undo stack. @@ -784,7 +229,7 @@ func TestUpgradesVersionOneFile(t *testing.T) { } // Reordering works immediately, and the write persists version 2 + ranks. - if _, err := s.Reorder(3, ToTop); err != nil { + if _, _, err := s.Reorder(3, ToTop); err != nil { t.Fatal(err) } if got, want := titles(t, s, task.Do), []string{"third", "first", "second"}; !equal(got, want) { @@ -808,126 +253,71 @@ func TestUpgradesVersionOneFile(t *testing.T) { // through, so it sanitizes. SetQuadrantLabel rejects control characters on the // way in; this covers a label that reached the file some other way — an older // build, a hand edit, or a synced copy. -func TestLabelsOfSanitizesUntrustedFile(t *testing.T) { - l := Labels{task.Do: "red\x1b[31m", task.Schedule: "two\nlines"} - got := l.Of(task.Do) - if strings.ContainsRune(got, 0x1b) { - t.Errorf("Of(Do) = %q, still contains an escape", got) - } - if !strings.Contains(got, "red") { - t.Errorf("Of(Do) = %q, dropped visible text", got) - } - if got := l.Of(task.Schedule); strings.ContainsRune(got, '\n') { - t.Errorf("Of(Schedule) = %q, still contains a newline", got) - } - // An unrenamed quadrant still falls back to its default. - if got, want := l.Of(task.Delegate), task.Delegate.Label(); got != want { - t.Errorf("Of(Delegate) = %q, want the default %q", got, want) +// Archive order is defined once, in Data.ListArchive, and both `ike archive` +// and the TUI's archive view render it. The TUI used to reverse the stored +// slice instead, which agrees only while every archived task carries a +// completion stamp — a file written by an older build, or hand-edited, need +// not. This pins the definition that both now share. +func TestListArchiveOrdersUnstampedTasksByID(t *testing.T) { + done := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC) + d := Data{Archive: []task.Task{ + {ID: 1, Title: "no stamp, low id"}, + {ID: 3, Title: "stamped", DoneAt: &done}, + {ID: 2, Title: "no stamp, high id"}, + }} + + var got []int + for _, t := range d.ListArchive() { + got = append(got, t.ID) } - // The stored label itself is untouched; only the rendered form changes. - if l[task.Do] != "red\x1b[31m" { - t.Error("Of must not rewrite the stored label") + // Descending by ID wherever a completion time is missing, newest first + // where it is present — never the raw slice order. + want := []int{3, 2, 1} + if !slices.Equal(got, want) { + t.Errorf("ListArchive order = %v, want %v", got, want) } } -// The gate used to be checked once, before serving. A client that stayed -// connected therefore kept full access after `ike mcp disable`, while -// `ike mcp status` reported "off". These pin the data-layer check that closed -// that window. -func TestMCPGateRevokesLiveSession(t *testing.T) { - s := testStore(t) - if _, err := s.SetMCPEnabled(true); err != nil { - t.Fatal(err) - } +// The store's own listing and the pure form over the same data must agree, +// since the frontends split between them. - // The session a connected client holds. - live := s.ForMCP() - if _, err := live.Add("while enabled", task.Do); err != nil { - t.Fatalf("Add with access on: %v", err) - } - if _, err := live.Load(); err != nil { - t.Fatalf("Load with access on: %v", err) +// The store's own listing and the pure form over the same data must agree, +// since the frontends split between them. +func TestStoreListMatchesDataList(t *testing.T) { + s := testStore(t) + for _, title := range []string{"a", "b", "c"} { + if _, _, err := s.Add(title, task.Schedule); err != nil { + t.Fatal(err) + } } - - // Revoked from another process, on the same file, mid-session. - if _, err := s.SetMCPEnabled(false); err != nil { + if _, _, err := s.Add("urgent", task.Do); err != nil { t.Fatal(err) } - if _, err := live.Add("after revoke", task.Do); !errors.Is(err, ErrMCPDisabled) { - t.Errorf("Add after revoke: err = %v, want ErrMCPDisabled", err) - } - if _, err := live.Load(); !errors.Is(err, ErrMCPDisabled) { - t.Errorf("Load after revoke: err = %v, want ErrMCPDisabled", err) - } - if _, err := live.Complete(1); !errors.Is(err, ErrMCPDisabled) { - t.Errorf("Complete after revoke: err = %v, want ErrMCPDisabled", err) - } - if _, err := live.Delete(1); !errors.Is(err, ErrMCPDisabled) { - t.Errorf("Delete after revoke: err = %v, want ErrMCPDisabled", err) - } - if _, err := live.Undo(); !errors.Is(err, ErrMCPDisabled) { - t.Errorf("Undo after revoke: err = %v, want ErrMCPDisabled", err) - } - - // The revoked mutations must not have landed, and the owner's own access is - // unaffected — that is what `ike mcp status` and the TUI keep using. d, err := s.Load() if err != nil { t.Fatal(err) } - if len(d.Tasks) != 1 || d.Tasks[0].Title != "while enabled" { - t.Errorf("tasks = %+v, want only the pre-revoke task", d.Tasks) - } - - // Re-enabling restores the same session, without reconnecting. - if _, err := s.SetMCPEnabled(true); err != nil { - t.Fatal(err) - } - if _, err := live.Load(); err != nil { - t.Errorf("Load after re-enable: %v", err) - } -} - -// A store that was never marked for MCP use is unaffected by the setting, so -// the TUI and CLI keep working while agent access is off. -func TestGateDoesNotAffectOwnerAccess(t *testing.T) { - s := testStore(t) - if enabled, err := s.MCPEnabled(); err != nil || enabled { - t.Fatalf("MCPEnabled() = %v, %v; want false, nil", enabled, err) - } - if _, err := s.Add("owner task", task.Do); err != nil { - t.Errorf("owner Add with MCP off: %v", err) - } - if _, err := s.Load(); err != nil { - t.Errorf("owner Load with MCP off: %v", err) + for _, q := range []task.Quadrant{0, task.Do, task.Schedule} { + viaStore, err := s.List(q) + if err != nil { + t.Fatal(err) + } + if !slices.Equal(titlesOf(viaStore), titlesOf(d.List(q))) { + t.Errorf("quadrant %d: Store.List = %v, Data.List = %v", + q, titlesOf(viaStore), titlesOf(d.List(q))) + } } } -func TestMCPErrorsOmitDataFilePath(t *testing.T) { - dir := t.TempDir() - path := filepath.Join(dir, "tasks.json") - if err := os.WriteFile(path, []byte("{ not json"), 0o600); err != nil { - t.Fatal(err) +// An empty archive must marshal as [] rather than null: `ike archive --json` +// is a machine interface, and a nil slice would change its shape. +func TestListArchiveIsNeverNil(t *testing.T) { + if got := (Data{}).ListArchive(); got == nil { + t.Error("ListArchive() on an empty archive returned nil, want an empty slice") } - gated := OpenAt(path).ForMCP() - - _, err := gated.Load() - if err == nil { - t.Fatal("expected a parse error") - } - if strings.Contains(err.Error(), dir) { - t.Errorf("error discloses the data file's directory to the agent: %v", err) - } - // The file name still appears, so the message stays actionable. - if !strings.Contains(err.Error(), "tasks.json") { - t.Errorf("error should still name the file: %v", err) - } - - // The owner's view keeps the full path, which is what makes a CLI error - // useful. - if _, err := OpenAt(path).Load(); err == nil || !strings.Contains(err.Error(), dir) { - t.Errorf("ungated error should keep the full path: %v", err) + if got := (Data{}).List(task.Do); got == nil { + t.Error("List() with no tasks returned nil, want an empty slice") } } diff --git a/internal/store/store_test.go b/internal/store/store_test.go index d7360ae..3f50272 100644 --- a/internal/store/store_test.go +++ b/internal/store/store_test.go @@ -18,14 +18,14 @@ func testStore(t *testing.T) *Store { func TestAddListRoundTrip(t *testing.T) { s := testStore(t) - a, err := s.Add("fix prod bug", task.Do) + a, _, err := s.Add("fix prod bug", task.Do) if err != nil { t.Fatal(err) } if a.ID != 1 { t.Errorf("first ID = %d, want 1", a.ID) } - b, err := s.Add("plan roadmap", task.Schedule) + b, _, err := s.Add("plan roadmap", task.Schedule) if err != nil { t.Fatal(err) } @@ -51,20 +51,20 @@ func TestAddListRoundTrip(t *testing.T) { func TestAddValidates(t *testing.T) { s := testStore(t) - if _, err := s.Add(" ", task.Do); err == nil { + if _, _, err := s.Add(" ", task.Do); err == nil { t.Error("Add with blank title should fail") } - if _, err := s.Add("x", 9); err == nil { + if _, _, err := s.Add("x", 9); err == nil { t.Error("Add with bad quadrant should fail") } } func TestCompleteMovesToArchiveAndKeepsID(t *testing.T) { s := testStore(t) - a, _ := s.Add("one", task.Do) + a, _, _ := s.Add("one", task.Do) s.Add("two", task.Do) - done, err := s.Complete(a.ID) + done, _, err := s.Complete(a.ID) if err != nil { t.Fatal(err) } @@ -82,37 +82,37 @@ func TestCompleteMovesToArchiveAndKeepsID(t *testing.T) { } // IDs are never reused, even after completion. - c, _ := s.Add("three", task.Do) + c, _, _ := s.Add("three", task.Do) if c.ID != 3 { t.Errorf("ID after completion = %d, want 3", c.ID) } - if _, err := s.Complete(a.ID); err == nil { + if _, _, err := s.Complete(a.ID); err == nil { t.Error("completing an archived task should fail") } } func TestMoveRenameDelete(t *testing.T) { s := testStore(t) - a, _ := s.Add("one", task.Do) + a, _, _ := s.Add("one", task.Do) - m, err := s.Move(a.ID, task.Eliminate) + m, _, err := s.Move(a.ID, task.Eliminate) if err != nil || m.Quadrant != task.Eliminate { t.Errorf("Move = %+v, %v", m, err) } - if _, err := s.Move(a.ID, 7); err == nil { + if _, _, err := s.Move(a.ID, 7); err == nil { t.Error("Move to invalid quadrant should fail") } - r, err := s.Rename(a.ID, "renamed") + r, _, err := s.Rename(a.ID, "renamed") if err != nil || r.Title != "renamed" { t.Errorf("Rename = %+v, %v", r, err) } - if _, err := s.Rename(a.ID, ""); err == nil { + if _, _, err := s.Rename(a.ID, ""); err == nil { t.Error("Rename to empty should fail") } - if _, err := s.Delete(a.ID); err != nil { + if _, _, err := s.Delete(a.ID); err != nil { t.Fatal(err) } active, _ := s.List(0) @@ -120,7 +120,7 @@ func TestMoveRenameDelete(t *testing.T) { if len(active) != 0 || len(arch) != 0 { t.Error("Delete should remove permanently, not archive") } - if _, err := s.Delete(a.ID); err == nil { + if _, _, err := s.Delete(a.ID); err == nil { t.Error("deleting a missing task should fail") } } @@ -152,7 +152,7 @@ func TestCorruptAndWrongVersion(t *testing.T) { // A mutation must not clobber a corrupt file either. os.WriteFile(p, []byte("{not json"), 0o644) - if _, err := OpenAt(p).Add("x", task.Do); err == nil { + if _, _, err := OpenAt(p).Add("x", task.Do); err == nil { t.Error("Add over corrupt file should error") } } @@ -171,7 +171,7 @@ func TestConcurrentWriters(t *testing.T) { defer wg.Done() s := OpenAt(p) // separate Store instances, like separate processes for i := 0; i < perWriter; i++ { - if _, err := s.Add("t", task.Do); err != nil { + if _, _, err := s.Add("t", task.Do); err != nil { t.Error(err) return } diff --git a/internal/task/task.go b/internal/task/task.go index 03ad77e..0e0de61 100644 --- a/internal/task/task.go +++ b/internal/task/task.go @@ -118,6 +118,22 @@ type Task struct { // encoding/json escapes control characters itself. func (t Task) DisplayTitle() string { return SanitizeDisplay(t.Title) } +// ArchiveDate is the local completion date, or "" for a task carrying no +// completion stamp — reachable from a hand-edited or pre-archive data file. +func (t Task) ArchiveDate() string { + if t.DoneAt == nil { + return "" + } + return t.DoneAt.Local().Format(time.DateOnly) +} + +// ArchiveRow formats one line of an archive listing. `ike archive` and the +// TUI's archive view both render through it, so the two cannot drift apart; +// title is passed in because only the TUI truncates it to the pane width. +func (t Task) ArchiveRow(title string) string { + return fmt.Sprintf(" %3d %s %s", t.ID, t.ArchiveDate(), title) +} + // Less reports whether a sorts before b in display order: by quadrant, then // by rank within the quadrant, then by ID. Rank is assigned by the store; a // zero rank means "not ranked yet" and falls back to ID order. diff --git a/internal/task/task_test.go b/internal/task/task_test.go index 909fdeb..8389e50 100644 --- a/internal/task/task_test.go +++ b/internal/task/task_test.go @@ -3,6 +3,7 @@ package task import ( "strings" "testing" + "time" ) func TestQuadrantValid(t *testing.T) { @@ -157,3 +158,59 @@ func TestDisplayTitleNeutralizesUntrustedFile(t *testing.T) { t.Errorf("DisplayTitle() = %q, dropped visible text", got) } } + +func TestArchiveDate(t *testing.T) { + when := time.Date(2026, 3, 4, 12, 0, 0, 0, time.UTC) + got := Task{ID: 1, DoneAt: &when}.ArchiveDate() + if want := when.Local().Format("2006-01-02"); got != want { + t.Errorf("ArchiveDate() = %q, want %q", got, want) + } + // A task with no completion stamp — reachable from a hand-edited or + // pre-archive file — renders a blank date rather than a zero-time one. + if got := (Task{ID: 1}).ArchiveDate(); got != "" { + t.Errorf("ArchiveDate() with no stamp = %q, want empty", got) + } +} + +// ArchiveRow is the single definition of an archive line, rendered by both +// `ike archive` and the TUI's archive view. +func TestArchiveRow(t *testing.T) { + when := time.Date(2026, 3, 4, 12, 0, 0, 0, time.UTC) + tk := Task{ID: 7, Title: "ship it", DoneAt: &when} + + got := tk.ArchiveRow(tk.DisplayTitle()) + want := " 7 " + tk.ArchiveDate() + " ship it" + if got != want { + t.Errorf("ArchiveRow() = %q, want %q", got, want) + } + // The title is supplied, so the TUI can pass a width-truncated one. + if got := tk.ArchiveRow("ship…"); !strings.HasSuffix(got, "ship…") { + t.Errorf("ArchiveRow() should render the title it is given: %q", got) + } +} + +func TestLessAndSortOrder(t *testing.T) { + ts := []Task{ + {ID: 4, Quadrant: Schedule, Rank: 1024}, + {ID: 1, Quadrant: Do, Rank: 2048}, + {ID: 2, Quadrant: Do, Rank: 1024}, + {ID: 3, Quadrant: Do}, // unranked: sorts by ID, after ranked peers + } + SortOrder(ts) + + var got []int + for _, t := range ts { + got = append(got, t.ID) + } + // Quadrant first, then rank, then ID. Rank 0 sorts ahead of any real rank, + // which is why normalizeRanks backfills it on every read. + want := []int{3, 2, 1, 4} + for i := range want { + if got[i] != want[i] { + t.Fatalf("SortOrder = %v, want %v", got, want) + } + } + if Less(ts[0], ts[0]) { + t.Error("Less must be irreflexive") + } +} diff --git a/internal/tui/model.go b/internal/tui/model.go index aeb5c1a..2835094 100644 --- a/internal/tui/model.go +++ b/internal/tui/model.go @@ -3,7 +3,6 @@ package tui import ( "fmt" - "slices" "time" "charm.land/bubbles/v2/key" @@ -95,29 +94,9 @@ func tick() tea.Cmd { return tea.Tick(refreshInterval, func(t time.Time) tea.Msg { return tickMsg(t) }) } -// tasksIn returns the active tasks of quadrant q in display order. -func (m Model) tasksIn(q task.Quadrant) []task.Task { - var out []task.Task - for _, t := range m.data.Tasks { - if t.Quadrant == q { - out = append(out, t) - } - } - task.SortOrder(out) - return out -} - -// archiveList returns the archive newest-completion-first — the order the -// archive view renders and archCursor indexes into. -func (m Model) archiveList() []task.Task { - arch := slices.Clone(m.data.Archive) - slices.Reverse(arch) - return arch -} - // selected returns the task under the cursor, if any. func (m Model) selected() (task.Task, bool) { - tasks := m.tasksIn(m.focus) + tasks := m.data.List(m.focus) i := m.cursor[m.focus] if i < 0 || i >= len(tasks) { return task.Task{}, false @@ -127,7 +106,7 @@ func (m Model) selected() (task.Task, bool) { func (m *Model) clampCursors() { for q := task.Do; q <= task.Eliminate; q++ { - n := len(m.tasksIn(q)) + n := len(m.data.List(q)) if m.cursor[q] >= n { m.cursor[q] = n - 1 } @@ -135,6 +114,8 @@ func (m *Model) clampCursors() { m.cursor[q] = 0 } } + // A count, not an index: ListArchive is a permutation of Archive, so the + // lengths agree. Anything that *indexes* must go through ListArchive. if n := len(m.data.Archive); m.archCursor >= n { m.archCursor = max(n-1, 0) } @@ -149,21 +130,27 @@ func (m *Model) refresh(d store.Data) { m.clampCursors() } -// mutate runs fn against the store and refreshes, surfacing errors in status. -func (m *Model) mutate(fn func() (store.Data, error)) { - d, err := fn() +// apply takes the two results of a store mutation and re-renders from them, +// reporting whether it succeeded. +// +// Callers use the bool to decide whether to set a success message. Signalling +// failure through m.status instead was the reason a failed complete, delete, or +// move used to overwrite its own error with "done: …" and leave the row on +// screen: there was nothing to check but the status text itself. +func (m *Model) apply(d store.Data, err error) bool { if err != nil { m.status = err.Error() - return + return false } m.refresh(d) + return true } // cursorTo puts the cursor on the task with the given ID, so the selection // follows a task that moved. func (m *Model) cursorTo(id int) { for q := task.Do; q <= task.Eliminate; q++ { - for i, t := range m.tasksIn(q) { + for i, t := range m.data.List(q) { if t.ID == id { m.cursor[q] = i return @@ -173,19 +160,10 @@ func (m *Model) cursorTo(id int) { } // history runs an undo or redo step, reporting what moved in the status line. -// Either stack being empty surfaces as an ordinary status message via mutate. -func (m *Model) history(verb string, step func() (string, error)) { - var label string - m.status = "" - m.mutate(func() (store.Data, error) { - l, err := step() - if err != nil { - return store.Data{}, err - } - label = l - return m.store.Load() - }) - if label != "" { +// Either stack being empty arrives as an ordinary error and shows as one. +func (m *Model) history(verb string, step func() (string, store.Data, error)) { + label, d, err := step() + if m.apply(d, err) { m.status = fmt.Sprintf("%s %s", verb, label) } } @@ -196,14 +174,10 @@ func (m *Model) reorder(delta int) { if !ok { return } - m.status = "" - m.mutate(func() (store.Data, error) { - if _, err := m.store.Reorder(t.ID, delta); err != nil { - return store.Data{}, err - } - return m.store.Load() - }) - m.cursorTo(t.ID) + if _, d, err := m.store.Reorder(t.ID, delta); m.apply(d, err) { + m.status = "" + m.cursorTo(t.ID) + } } func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) { @@ -251,6 +225,29 @@ func (m Model) handleKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) { return m.handleNormalKey(msg) } +// enterInput switches to input mode with all four pieces of input state set +// together. Setting them one at a time across the call sites left the previous +// session's placeholder visible in the next one. +func (m *Model) enterInput(editingID int, labelTarget task.Quadrant, value, placeholder string) tea.Cmd { + m.mode = modeInput + m.editingID = editingID + m.labelTarget = labelTarget + m.input.SetValue(value) + m.input.Placeholder = placeholder + m.input.CursorEnd() + m.status = "" + return m.input.Focus() +} + +// exitInput returns to normal mode and clears the input state, so nothing from +// this session can leak into the next one. +func (m *Model) exitInput() { + m.mode = modeNormal + m.editingID = 0 + m.labelTarget = 0 + m.input.Blur() +} + func (m Model) handleNormalKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) { // Any key other than a second `d` clears a pending delete. pending := m.pendingDelete @@ -273,7 +270,7 @@ func (m Model) handleNormalKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) { m.focus = (m.focus+2)%4 + 1 case key.Matches(msg, keys.Down): - if m.cursor[m.focus] < len(m.tasksIn(m.focus))-1 { + if m.cursor[m.focus] < len(m.data.List(m.focus))-1 { m.cursor[m.focus]++ } @@ -289,45 +286,22 @@ func (m Model) handleNormalKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) { m.reorder(1) case key.Matches(msg, keys.Add): - m.mode = modeInput - m.editingID = 0 - m.labelTarget = 0 - m.input.SetValue("") - m.input.Placeholder = "task title" - m.status = "" - return m, m.input.Focus() + return m, m.enterInput(0, 0, "", "task title") case key.Matches(msg, keys.Edit): if t, ok := m.selected(); ok { - m.mode = modeInput - m.editingID = t.ID - m.labelTarget = 0 - m.input.SetValue(t.Title) - m.input.CursorEnd() - m.status = "" - return m, m.input.Focus() + return m, m.enterInput(t.ID, 0, t.Title, "task title") } case key.Matches(msg, keys.Title): - m.mode = modeInput - m.editingID = 0 - m.labelTarget = m.focus - m.input.SetValue(m.data.Labels.Of(m.focus)) - m.input.CursorEnd() - m.input.Placeholder = "quadrant name (empty resets to the default)" - m.status = "" - return m, m.input.Focus() + return m, m.enterInput(0, m.focus, m.data.Labels.Of(m.focus), + "quadrant name (empty resets to the default)") case key.Matches(msg, keys.Done): if t, ok := m.selected(); ok { - m.mutate(func() (store.Data, error) { - _, err := m.store.Complete(t.ID) - if err != nil { - return store.Data{}, err - } - return m.store.Load() - }) - m.status = fmt.Sprintf("done: %s", t.DisplayTitle()) + if _, d, err := m.store.Complete(t.ID); m.apply(d, err) { + m.status = fmt.Sprintf("done: %s", t.DisplayTitle()) + } } case key.Matches(msg, keys.Move): @@ -338,18 +312,11 @@ func (m Model) handleNormalKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) { case key.Matches(msg, keys.Delete): if t, ok := m.selected(); ok { - if pending == t.ID { - m.mutate(func() (store.Data, error) { - _, err := m.store.Delete(t.ID) - if err != nil { - return store.Data{}, err - } - return m.store.Load() - }) - m.status = fmt.Sprintf("deleted: %s", t.DisplayTitle()) - } else { + if pending != t.ID { m.pendingDelete = t.ID m.status = fmt.Sprintf("press d again to delete %q", t.DisplayTitle()) + } else if _, d, err := m.store.Delete(t.ID); m.apply(d, err) { + m.status = fmt.Sprintf("deleted: %s", t.DisplayTitle()) } } @@ -372,43 +339,35 @@ func (m Model) handleNormalKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) { func (m Model) handleInputKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) { switch { case key.Matches(msg, keys.Cancel): - m.mode = modeNormal - m.labelTarget = 0 - m.input.Blur() + m.exitInput() return m, nil case key.Matches(msg, keys.Confirm): - title := m.input.Value() - editing := m.editingID - target := m.labelTarget - m.status = "" - m.mutate(func() (store.Data, error) { - var err error - switch { - case target != 0: - _, err = m.store.SetQuadrantLabel(target, title) - case editing == 0: - _, err = m.store.Add(title, m.focus) - default: - _, err = m.store.Rename(editing, title) - } - if err != nil { - return store.Data{}, err - } - return m.store.Load() - }) - if m.status == "" { + value := m.input.Value() + editing, target := m.editingID, m.labelTarget + + var d store.Data + var err error + switch { + case target != 0: + _, d, err = m.store.SetQuadrantLabel(target, value) + case editing == 0: + _, d, err = m.store.Add(value, m.focus) + default: + _, d, err = m.store.Rename(editing, value) + } + + if m.apply(d, err) { + m.status = "" switch { case target != 0: m.status = fmt.Sprintf("quadrant %d is now %q", target, m.data.Labels.Of(target)) case editing == 0: // Move the cursor to the task just added (last in its quadrant). - m.cursor[m.focus] = max(len(m.tasksIn(m.focus))-1, 0) + m.cursor[m.focus] = max(len(m.data.List(m.focus))-1, 0) } } - m.mode = modeNormal - m.labelTarget = 0 - m.input.Blur() + m.exitInput() return m, nil } @@ -423,14 +382,9 @@ func (m Model) handleMoveKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) { if key.Matches(msg, keys.Quadrant) { dest := task.Quadrant(msg.Key().Code - '0') if t, ok := m.selected(); ok && dest != t.Quadrant { - m.mutate(func() (store.Data, error) { - _, err := m.store.Move(t.ID, dest) - if err != nil { - return store.Data{}, err - } - return m.store.Load() - }) - m.status = fmt.Sprintf("moved to %d · %s", dest, m.data.Labels.Of(dest)) + if _, d, err := m.store.Move(t.ID, dest); m.apply(d, err) { + m.status = fmt.Sprintf("moved to %d · %s", dest, m.data.Labels.Of(dest)) + } } } return m, nil @@ -443,18 +397,12 @@ func (m Model) handleArchiveKey(msg tea.KeyPressMsg) (tea.Model, tea.Cmd) { m.status = "" case key.Matches(msg, keys.Restore): - arch := m.archiveList() + arch := m.data.ListArchive() if m.archCursor < len(arch) { t := arch[m.archCursor] - m.status = "" - m.mutate(func() (store.Data, error) { - if _, err := m.store.Restore(t.ID); err != nil { - return store.Data{}, err - } - return m.store.Load() - }) - if m.status == "" { - m.status = fmt.Sprintf("restored %q to %d · %s", t.DisplayTitle(), t.Quadrant, m.data.Labels.Of(t.Quadrant)) + if _, d, err := m.store.Restore(t.ID); m.apply(d, err) { + m.status = fmt.Sprintf("restored %q to %d · %s", + t.DisplayTitle(), t.Quadrant, m.data.Labels.Of(t.Quadrant)) } } diff --git a/internal/tui/model_test.go b/internal/tui/model_test.go index 72d7910..2296ea0 100644 --- a/internal/tui/model_test.go +++ b/internal/tui/model_test.go @@ -93,7 +93,7 @@ func TestAddTaskFlow(t *testing.T) { if len(tasks) != 1 || tasks[0].Title != "plan roadmap" { t.Errorf("store tasks = %+v, want the added task in Schedule", tasks) } - if got := m.tasksIn(task.Schedule); len(got) != 1 { + if got := m.data.List(task.Schedule); len(got) != 1 { t.Errorf("model shows %d tasks in Schedule, want 1", len(got)) } } @@ -162,7 +162,7 @@ func TestRenameQuadrant(t *testing.T) { func TestRenameQuadrantToBlankRestoresDefault(t *testing.T) { m, s := testModel(t) - if _, err := s.SetQuadrantLabel(task.Do, "Firefighting"); err != nil { + if _, _, err := s.SetQuadrantLabel(task.Do, "Firefighting"); err != nil { t.Fatal(err) } m.refreshFromStore(t) @@ -226,7 +226,7 @@ func TestAddStillWorksAfterRenaming(t *testing.T) { func TestQuadrantHeadersAreJustNames(t *testing.T) { m, s := testModel(t) - if _, err := s.SetQuadrantLabel(task.Do, "Firefighting"); err != nil { + if _, _, err := s.SetQuadrantLabel(task.Do, "Firefighting"); err != nil { t.Fatal(err) } m.refreshFromStore(t) @@ -374,7 +374,7 @@ func TestUndoKey(t *testing.T) { if !strings.Contains(m.status, "undid") { t.Errorf("status = %q, want it to mention the undo", m.status) } - if len(m.tasksIn(task.Do)) != 1 { + if len(m.data.List(task.Do)) != 1 { t.Error("model did not re-render the restored task") } } @@ -542,7 +542,7 @@ func TestRefreshPicksUpExternalChanges(t *testing.T) { s.Add("from elsewhere", task.Do) next, _ := m.Update(tickMsg{}) m = next.(Model) - if len(m.tasksIn(task.Do)) != 1 { + if len(m.data.List(task.Do)) != 1 { t.Error("tick did not reload externally-added task") } } @@ -591,7 +591,7 @@ func (m *Model) refreshFromStore(t *testing.T) { // the screen quietly disagreed with the file. func TestRefreshTickSurfacesAReadError(t *testing.T) { m, s := testModel(t) - if _, err := s.Add("real task", task.Do); err != nil { + if _, _, err := s.Add("real task", task.Do); err != nil { t.Fatal(err) } m.refreshFromStore(t) @@ -632,3 +632,89 @@ func TestRefreshTickSurfacesAReadError(t *testing.T) { t.Errorf("stale error still shown after recovery:\n%s", got) } } + +// corrupt makes the next store operation fail, so the tests below can check +// what the TUI does with a mutation that did not happen. +func corrupt(t *testing.T, s *store.Store) { + t.Helper() + if err := os.WriteFile(s.Path(), []byte("{ not json"), 0o600); err != nil { + t.Fatal(err) + } +} + +// A mutation that fails must not report success. These three used to set their +// status message unconditionally, overwriting the error that mutate had just +// written into it — so a failed complete said "done: …" while the task stayed +// on screen. apply's bool return is what makes the success message conditional. +func TestFailedMutationsDoNotReportSuccess(t *testing.T) { + cases := []struct { + name string + keys []string + wrongly string + }{ + {"complete", []string{"x"}, "done:"}, + {"delete", []string{"d", "d"}, "deleted:"}, + {"move", []string{"m", "2"}, "moved to"}, + } + for _, c := range cases { + t.Run(c.name, func(t *testing.T) { + m, s := testModel(t) + if _, _, err := s.Add("ship v2", task.Do); err != nil { + t.Fatal(err) + } + m.refreshFromStore(t) + corrupt(t, s) + + m = press(t, m, c.keys...) + + if strings.Contains(m.status, c.wrongly) { + t.Errorf("failed %s reported success: %q", c.name, m.status) + } + if m.status == "" { + t.Errorf("failed %s left no error in the status line", c.name) + } + // The matrix on screen still shows the task, because nothing changed. + if got := len(m.data.List(task.Do)); got != 1 { + t.Errorf("task count = %d, want 1 — a failed mutation must not alter the view", got) + } + }) + } +} + +// Entering input mode sets every piece of input state together. Setting them +// one field at a time let the quadrant-rename placeholder survive into the next +// task edit, where it read "quadrant name (empty resets to the default)". +func TestInputPlaceholderDoesNotLeakBetweenModes(t *testing.T) { + m, s := testModel(t) + if _, _, err := s.Add("ship v2", task.Do); err != nil { + t.Fatal(err) + } + m.refreshFromStore(t) + + m = press(t, m, "t") // rename the quadrant + m = press(t, m, "esc") // cancel + m = press(t, m, "e") // now edit a task title + + if strings.Contains(m.input.Placeholder, "quadrant") { + t.Errorf("quadrant placeholder leaked into the task edit: %q", m.input.Placeholder) + } + if m.labelTarget != 0 { + t.Errorf("labelTarget = %d, want 0 while editing a task", m.labelTarget) + } +} + +// Cancelling an edit clears the task being edited, so the next add cannot be +// mistaken for a rename of it. +func TestCancelClearsEditingID(t *testing.T) { + m, s := testModel(t) + if _, _, err := s.Add("ship v2", task.Do); err != nil { + t.Fatal(err) + } + m.refreshFromStore(t) + + m = press(t, m, "e") + m = press(t, m, "esc") + if m.editingID != 0 { + t.Errorf("editingID = %d, want 0 after cancelling", m.editingID) + } +} diff --git a/internal/tui/view.go b/internal/tui/view.go index 1c84bd9..22de9df 100644 --- a/internal/tui/view.go +++ b/internal/tui/view.go @@ -140,7 +140,7 @@ func (m Model) renderQuadrant(q task.Quadrant, w, h int) string { } func (m Model) renderTaskLines(q task.Quadrant, w, visible int, focused bool) []string { - tasks := m.tasksIn(q) + tasks := m.data.List(q) if len(tasks) == 0 { return []string{lipgloss.NewStyle().Foreground(m.dimColor()).Italic(true).Render("empty")} } @@ -259,7 +259,7 @@ func (m Model) renderArchive() string { title := lipgloss.NewStyle().Bold(true).Render(fmt.Sprintf("Archive — %d completed", len(m.data.Archive))) // Newest completion first, matching `ike archive`. - arch := m.archiveList() + arch := m.data.ListArchive() visible := m.height - 4 // title + blank + status + footer offset := 0 @@ -273,11 +273,7 @@ func (m Model) renderArchive() string { } for i := offset; i < len(arch) && i-offset < visible; i++ { t := arch[i] - when := "" - if t.DoneAt != nil { - when = t.DoneAt.Local().Format("2006-01-02") - } - line := fmt.Sprintf(" %3d %s %s", t.ID, when, ansi.Truncate(t.DisplayTitle(), max(m.width-20, 4), "…")) + line := t.ArchiveRow(ansi.Truncate(t.DisplayTitle(), max(m.width-20, 4), "…")) if i == m.archCursor { line = lipgloss.NewStyle().Bold(true).Render("▸" + line[1:]) } From 675bd5cba6bc447c4a1b3e447b3e8510d5a3c408 Mon Sep 17 00:00:00 2001 From: Jonathan Crockett <joncrockett@gmail.com> Date: Wed, 29 Jul 2026 01:41:30 -0400 Subject: [PATCH 2/2] Use US spellings in the new comments misspell runs with locale: US, so "signalling" and "cancelling" fail lint. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> --- internal/tui/model.go | 2 +- internal/tui/model_test.go | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/internal/tui/model.go b/internal/tui/model.go index 2835094..8e2fbe2 100644 --- a/internal/tui/model.go +++ b/internal/tui/model.go @@ -133,7 +133,7 @@ func (m *Model) refresh(d store.Data) { // apply takes the two results of a store mutation and re-renders from them, // reporting whether it succeeded. // -// Callers use the bool to decide whether to set a success message. Signalling +// Callers use the bool to decide whether to set a success message. Signaling // failure through m.status instead was the reason a failed complete, delete, or // move used to overwrite its own error with "done: …" and leave the row on // screen: there was nothing to check but the status text itself. diff --git a/internal/tui/model_test.go b/internal/tui/model_test.go index 2296ea0..1cbcde5 100644 --- a/internal/tui/model_test.go +++ b/internal/tui/model_test.go @@ -703,7 +703,7 @@ func TestInputPlaceholderDoesNotLeakBetweenModes(t *testing.T) { } } -// Cancelling an edit clears the task being edited, so the next add cannot be +// Canceling an edit clears the task being edited, so the next add cannot be // mistaken for a rename of it. func TestCancelClearsEditingID(t *testing.T) { m, s := testModel(t) @@ -715,6 +715,6 @@ func TestCancelClearsEditingID(t *testing.T) { m = press(t, m, "e") m = press(t, m, "esc") if m.editingID != 0 { - t.Errorf("editingID = %d, want 0 after cancelling", m.editingID) + t.Errorf("editingID = %d, want 0 after canceling", m.editingID) } }