Notes: plain text notes on the SD card, with an editor that saves by itself (#19)

The Notes App lists the files of /notes by their first line, newest first:
n starts a note, Enter opens it, r renames its file, d deletes it after
asking, s sorts by name. A new note's file is named after its first line.

The editor wraps at spaces, 38 columns by 8 rows; Fn+arrows move through
the wrapped text, Ctrl+A and Ctrl+E go to the ends of the line. There is no
save key: the note is written five seconds after the last key, on Back, on
leaving the App, when the screen turns off and before the device powers
off. A save writes a temporary file and puts it in the note's place; a save
cut short is put back, or offered, the next time.

A note is up to 16 KB, held in one buffer reserved when it's opened: the
file is read straight into it and typing never makes it grow. A failed
allocation aborts on this device, and with IRC connected the largest free
block is about 31 KB: a first version that copied the note once on loading
restarted the device when a full note was opened with IRC connected.
Editing files of any size is #47.

The Storage App's text viewer gets `e`, which edits a text file up to 16 KB
with the same editor unless the file is read-only.

439 host tests. Checked on the device: docs/milestones/F1.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EhqxQ49eCju4CzKYNjZzwT

src/apps/note_editor.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "dialog_model.h"
+#include "key_event.h"
+#include "note_text.h"
+#include "services/clock_service.h"
+#include "services/power_service.h"
+#include "services/storage_service.h"
+#include "ui/canvas.h"
+
+namespace roro {
+
+// Edits one text file of up to 16 KB (F1, Q143-Q145): the Notes App's editor, and the Storage
+// App's for `e`. It saves by itself: five seconds after the last key, when the screen turns off,
+// and on close. A save writes `<file>.tmp`, then puts it in the note's place, so the note on the
+// card is always a whole one.
+class NoteEditor {
+   public:
+    static constexpr int kCols = 38, kRows = 8;
+    static constexpr uint32_t kSaveAfterMs = 5000;
+
+    NoteEditor(StorageService& storage, ClockService& clock, PowerService& power)
+        : storage_(storage), clock_(clock), power_(power) {}
+
+    std::string open(const std::string& path);  // "" or why it can't be edited
+    std::string openNew(const std::string& folder);  // the same; no file until there's something to save (Q142)
+    void close();                               // saves what isn't yet
+    bool isOpen() const { return static_cast<bool>(text_); }
+    const std::string& path() const { return path_; }  // "" for a new note nothing was typed in
+
+    bool onKey(const KeyEvent& e);  // false: done, and saved
+    bool update(uint32_t nowMs);    // true: draw again
+    void draw(Canvas& c);
+
+   private:
+    enum class Ask { None, Recover, LeaveUnsaved };
+
+    bool dirty() const { return text_ && text_->revision() != savedRevision_; }
+    bool save();  // true if the card has it now (or there was nothing to save)
+    void say(const std::string& text);
+
+    StorageService& storage_;
+    ClockService& clock_;
+    PowerService& power_;
+    std::unique_ptr<notes::NoteText> text_;
+    std::string path_, folder_;
+    uint32_t savedRevision_ = 0, lastKeyMs_ = 0, lastTryMs_ = 0;
+    std::string recovered_;  // what a temporary file left behind holds, until the user has chosen
+    Ask ask_ = Ask::None;
+    std::unique_ptr<DialogModel> dialog_;
+    std::string message_, problem_;
+    uint32_t messageMs_ = 0;
+    bool redraw_ = false;
+};
+
+}  // namespace roro