vimniscient 0.2.0__py3-none-any.whl

vimniscient/__init__.py

@@ -0,0 +1,3 @@
+"""Vimniscient: absolute vim."""
+
+__version__ = "0.1.0"

vimniscient/__main__.py

@@ -0,0 +1,3 @@
+from vimniscient.cli import main
+
+main()

vimniscient/answer.py

@@ -0,0 +1,113 @@
+"""Checking typed answers to cards.
+
+Two styles: `keys` for key sequences (`ciw`, `<C-a>`, `<leader>ff`) and
+`combo` for chords (`SUPER SHIFT + B`). Both accept the usual ways of
+writing the same thing: `ctrl-a`, `^a` and `<C-a>`; `space ff` and
+`<leader>ff`; `super+shift+b` and `SUPER SHIFT + B`.
+"""
+
+import re
+
+LEADER = "\x00"
+
+_TOKEN_NAMES = {
+    "esc": "<Esc>", "escape": "<Esc>",
+    "cr": "<CR>", "enter": "<CR>", "return": "<CR>",
+    "tab": "<Tab>", "bs": "<BS>", "backspace": "<BS>",
+    "space": "<Space>", "lt": "<", "bar": "|", "bslash": "\\",
+    "home": "<Home>", "end": "<End>", "del": "<Del>", "delete": "<Del>",
+    "up": "<Up>", "down": "<Down>", "left": "<Left>", "right": "<Right>",
+}
+
+
+def _norm_token(match: re.Match) -> str:
+    inner = match.group(1)
+    low = inner.lower()
+    if low in ("leader", "space") and match.start() == 0:
+        return LEADER
+    if low in _TOKEN_NAMES:
+        return _TOKEN_NAMES[low]
+    m = re.fullmatch(r"([csma])-(.+)", inner, re.I)
+    if m:
+        mod = {"c": "C", "s": "S", "m": "M", "a": "M"}[m.group(1).lower()]
+        key = m.group(2)
+        key = key.lower() if mod == "C" and len(key) == 1 else key
+        return f"<{mod}-{key}>"
+    if re.fullmatch(r"f\d+", low):
+        return f"<F{low[1:]}>"
+    return f"<{inner}>"
+
+
+def norm_keys(text: str, case_sensitive: bool = True) -> str:
+    s = text.strip()
+    s = re.sub(r"(?i)^(leader|space|spc)(\s+|$)", "<leader>", s)
+    s = re.sub(r"(?i)(?<![<\w])space(?![>\w])", "<Space>", s)
+    s = re.sub(r"(?i)\b(?:ctrl|control)[-+ ]+(\S)", lambda m: f"<C-{m.group(1)}>", s)
+    s = re.sub(r"(?i)\b(?:alt|meta)[-+ ]+(\S)", lambda m: f"<M-{m.group(1)}>", s)
+    s = re.sub(r"\^([A-Za-z_\[\]])", lambda m: f"<C-{m.group(1)}>", s)
+    s = re.sub(r"<([^<>\s]+)>", _norm_token, s)
+    s = re.sub(r"\s+", "", s)
+    s = s.removesuffix("<CR>") if s.startswith(":") else s
+    return s if case_sensitive else s.lower()
+
+
+_MOD_ALIASES = {
+    "SUPER": "SUPER", "WIN": "SUPER", "CMD": "SUPER", "MOD": "SUPER", "LOGO": "SUPER",
+    "CTRL": "CTRL", "CONTROL": "CTRL", "CTL": "CTRL",
+    "ALT": "ALT", "OPT": "ALT", "OPTION": "ALT", "MOD1": "ALT", "META": "ALT",
+    "SHIFT": "SHIFT", "PREFIX": "PREFIX", "COPYMODE": "COPYMODE",
+}
+_KEY_ALIASES = {
+    "ENTER": "RETURN", "CR": "RETURN", "ESC": "ESCAPE", "DEL": "DELETE", "INS": "INSERT",
+    "PGUP": "PAGE_UP", "PAGEUP": "PAGE_UP", "PRIOR": "PAGE_UP",
+    "PGDN": "PAGE_DOWN", "PAGEDOWN": "PAGE_DOWN", "NEXT": "PAGE_DOWN",
+    "=": "EQUAL", "-": "MINUS", "+": "PLUS", "SPACEBAR": "SPACE",
+    "PRTSC": "PRINT", "PRINTSCREEN": "PRINT",
+}
+
+
+def norm_combo(text: str, case_sensitive: bool = False) -> tuple[frozenset[str], tuple[str, ...]]:
+    s = re.sub(r"(?i)copy\s+mode", "COPYMODE", text.strip())
+    s = re.sub(r"(?i)page\s+(up|down)", lambda m: f"PAGE_{m.group(1)}", s)
+    plus_key = bool(re.search(r"[\s+]\+\s*$", s))  # "CTRL + +" or "CTRL +"
+    if plus_key:
+        s = re.sub(r"\+\s*$", "", s)
+    parts: list[str] = []
+    for part in re.split(r"[\s+]+", s):
+        if len(part) > 1 and "-" in part:
+            parts.extend(p for p in part.split("-") if p)
+        elif part:
+            parts.append(part)
+    if plus_key:
+        parts.append("+")
+    mods: set[str] = set()
+    keys: list[str] = []
+    for part in parts:
+        mod = _MOD_ALIASES.get(part.upper())
+        if mod:
+            mods.add(mod)
+            continue
+        key = _KEY_ALIASES.get(part.upper(), part)
+        if not (case_sensitive and len(key) == 1):
+            key = key.upper()
+        keys.append(key)
+    # SHIFT + c is C when case matters (tmux)
+    if case_sensitive and "SHIFT" in mods and len(keys) == 1 and keys[0].isalpha() and len(keys[0]) == 1:
+        mods.discard("SHIFT")
+        keys = [keys[0].upper()]
+    return frozenset(mods), tuple(keys)
+
+
+def is_correct(answer: str, expected: list[str], style: str, case_sensitive: bool) -> bool:
+    if not answer.strip():
+        return False
+    if style == "combo":
+        got = norm_combo(answer, case_sensitive)
+        return any(got == norm_combo(e, case_sensitive) for e in expected)
+    got = norm_keys(answer, case_sensitive)
+    return any(got == norm_keys(e, case_sensitive) for e in expected)
+
+
+def pretty_keys(keys: str) -> str:
+    """`<Space>ff` reads better as `<leader>ff`."""
+    return re.sub(r"^<Space>", "<leader>", keys)

vimniscient/app.py

@@ -0,0 +1,310 @@
+"""The Textual interface.
+
+Laid out like lazygit: everything on one screen in titled panes, Tab moves
+focus, one key bar at the bottom, nothing animates. Cards and drills get a
+centred focus screen, as in terminal typing trainers. Colours come from the
+Omarchy theme in use (Catppuccin Mocha's own palette by default).
+"""
+
+from collections.abc import Callable
+from dataclasses import replace
+
+from textual.app import App
+from textual.color import Color
+
+from vimniscient import drills, endless, reminders, today, vimgolf
+from vimniscient.cards import has_lazyvim, load_decks
+from vimniscient.lessons import Lesson, load_lessons, two_rounds
+from vimniscient.progress import Progress
+from vimniscient.session import COLORS, TaskResult, mouse_wheel, run_endless, run_lesson
+from vimniscient.ui.builtin_lessons import endless_lesson, placement_lesson, review_lesson, vimgolf_lesson
+from vimniscient.ui.cards import CardScreen
+from vimniscient.ui.common import CATPPUCCIN, DEFAULT_THEME, omarchy_theme, plural
+from vimniscient.ui.drills import DrillScreen
+from vimniscient.ui.lesson import LessonScreen, ResultsScreen
+from vimniscient.ui.main import MainScreen
+from vimniscient.ui.stats import StatsScreen
+
+
+class VimniscientApp(App):
+    TITLE = "Vimniscient"
+    ENABLE_COMMAND_PALETTE = False
+    CSS = """
+    Screen { background: $background; }
+
+    /* panes: rounded, titled in the border, mauve when focused (lazygit) */
+    .pane { border: round $panel; border-title-color: $text-muted; border-subtitle-color: $text-muted;
+            background: $background; padding: 0 1; }
+    .pane:focus, .pane:focus-within { border: round $primary; border-title-color: $primary; }
+    OptionList.pane { padding: 0 1; text-wrap: nowrap; text-overflow: ellipsis; }
+    OptionList.pane:focus { border: round $primary; }
+    OptionList > .option-list--option-highlighted { background: $surface; color: $foreground; text-style: none; }
+    OptionList:focus > .option-list--option-highlighted { background: $primary 25%; color: $foreground; text-style: bold; }
+    .keybar { height: 1; padding: 0 1; color: $text-muted; background: $background; }
+
+    #main { height: 1fr; }
+    #left { width: 46; max-width: 45%; }
+    #plan { height: 8; }
+    #lesson-list { height: 1fr; }
+    #right { width: 1fr; }
+    #detail-pane { height: 1fr; }
+    #progress-pane { height: auto; max-height: 10; }
+    #progress-text { height: auto; }
+    #spark { height: 2; margin-top: 1; }
+    Sparkline > .sparkline--max-color { color: $primary; }
+    Sparkline > .sparkline--min-color { color: $secondary; }
+    Markdown { padding: 0 1; margin: 0; background: $background; }
+    MarkdownBlock > .code_inline { background: $surface; color: $primary; }
+
+    /* focus screens: one centred column, like terminal typing trainers */
+    CardScreen, DrillScreen, LessonScreen { align: center middle; }
+    .column, .column:focus-within { width: 76; max-width: 100%; height: auto; max-height: 90%; padding: 1 2;
+                                    border: round $primary; border-title-color: $primary; }
+    .prompt { color: $primary; text-style: bold; height: auto; padding: 1 0; }
+    #card-bar, #drill-bar { height: 1; }
+    #card-input { border: round $panel; background: $background; padding: 0 1; }
+    #card-input:focus { border: round $primary; background: $background; }
+    #card-feedback { padding: 1 0 0 0; height: auto; min-height: 3; }
+    #drill-steps { height: auto; }
+    #drill-status { height: auto; padding-top: 1; }
+    CardScreen > .keybar, DrillScreen > .keybar, LessonScreen > .keybar, ResultsScreen > .keybar { dock: bottom; }
+
+    ResultsScreen { align: center middle; }
+    #results-panel { width: 96; }
+    #results-bar { height: 1; }
+    #note { padding: 0 0 1 0; color: $success; height: auto; }
+    #results-list { height: auto; padding-right: 1; }
+    #results-why { height: auto; padding: 1 0 0 0; }
+
+    #stats-view { height: 1fr; padding: 0 2; }
+    .section-label { color: $text-muted; text-style: bold; height: 1; margin-top: 1; }
+    DataTable { background: $background; height: auto; max-height: 14; margin-top: 1; }
+    DataTable > .datatable--header { background: $surface; color: $text-muted; text-style: bold; }
+    #overview { height: auto; margin-top: 1; }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.animation_level = "none"  # tabs, scrolling and the rest switch instantly
+        # Week 5 teaches LazyVim's own text objects; without LazyVim it's left out.
+        self.lessons = [lesson for lesson in load_lessons() if not lesson.lazyvim or has_lazyvim()]
+        self.progress = Progress()
+        self.decks = load_decks()
+        self.drills = drills.load_drills()
+
+    def lesson(self, lesson_id: str) -> Lesson:
+        return next(lesson for lesson in self.lessons if lesson.id == lesson_id)
+
+    def on_mount(self) -> None:
+        for theme in CATPPUCCIN:
+            self.register_theme(theme)
+        theme = omarchy_theme()
+        self.theme = theme if theme in self.available_themes else DEFAULT_THEME
+        mouse_wheel(False)
+        COLORS.update(self.lesson_colors())
+        self.push_screen(MainScreen())
+
+    def lesson_colors(self) -> dict[str, str]:
+        """The theme's colours as hex, for lessons in Neovim to draw with."""
+        theme = self.current_theme
+        background = Color.parse(theme.background or "#000000")
+        foreground = Color.parse(theme.foreground or "#ffffff")
+        named = {"primary": theme.primary, "accent": theme.accent or theme.primary,
+                 "success": theme.success or theme.primary, "error": theme.error or theme.primary,
+                 "panel": theme.panel or theme.surface or theme.primary}
+        return {"background": background.hex, "foreground": foreground.hex,
+                "muted": (background + background.get_contrast_text(0.6)).hex,  # $text-muted is "auto 60%"
+                **{name: Color.parse(value).hex for name, value in named.items()}}
+
+    # running things
+
+    def start_lesson(
+        self,
+        lesson: Lesson,
+        on_results: Callable[[list[TaskResult]], str] | None = None,
+        done: Callable[[], None] = lambda: None,
+    ) -> None:
+        """Run a lesson in Neovim, then show the results; `done` runs when the user moves on.
+        Real lessons (not review, placement or VimGolf) run in two rounds: Learn, then Recall.
+        In lessons and reviews, a skipped task is shown, typed, and asked again at the end."""
+        session = replace(lesson, tasks=two_rounds(lesson)) if lesson.week else lesson
+        with self.suspend():
+            results = run_lesson(session, retry=bool(lesson.week) or lesson.id == "review")
+        mouse_wheel(False)  # coming back from Neovim
+        if on_results:
+            note = on_results(results)
+        else:
+            self.progress.record(results)
+            note = ""
+
+        def after(again: bool) -> None:
+            if again:
+                self.start_lesson(lesson, on_results, done)
+            else:
+                done()
+
+        self.push_screen(ResultsScreen(session, results, note), after)
+
+    def run_steps(self, steps: list[Callable[[Callable[[], None]], None]]) -> None:
+        """Run screens one after another; each step calls `done` when finished."""
+        if steps:
+            steps[0](lambda: self.run_steps(steps[1:]))
+
+    def work(self) -> today.Work:
+        """Today's cards, drills and review, as much as fits the daily budget."""
+        return today.todays_work(self.progress, self.lessons, self.decks, self.drills)
+
+    def plan(self) -> list[today.Step]:
+        return today.plan(self.progress, self.lessons, self.decks, self.drills, self.work())
+
+    def todays_drills(self) -> list[drills.Drill]:
+        return today.todays_drills(self.progress, self.drills)
+
+    def step(self, step_id: str, direct: bool = False) -> Callable[[Callable[[], None]], None] | None:
+        """One step of today's routine, or None when there's nothing to do for it.
+
+        `direct` starts lessons without their intro screen (the main screen shows it already)."""
+        progress = self.progress
+        if step_id == "cards":
+            cards = self.work().cards
+            if cards:
+                return lambda done: self.push_screen(CardScreen(cards, self.decks, "Today's cards"), lambda _: done())
+        elif step_id == "drills":
+            todays = self.work().drills
+            if todays:
+                return lambda done: self.push_screen(DrillScreen(todays, "Omarchy drills"), lambda _: done())
+        elif step_id == "review":
+            review = self.work().review
+            if review and direct:
+                return lambda done: self.start_lesson(review_lesson(review), done=done)
+            if review:
+                return lambda done: self.push_screen(LessonScreen(review_lesson(review)), lambda _: done())
+        elif step_id == "lesson":
+            nxt = progress.next_lesson(self.lessons)
+            if nxt and direct:
+                return lambda done: self.start_lesson(nxt, done=done)
+            if nxt:
+                return lambda done: self.push_screen(LessonScreen(nxt), lambda _: done())
+        elif step_id == "vimgolf":
+            if not progress.vimgolf_done_today():
+                return self.start_vimgolf
+        elif step_id == "endless":
+            start = progress.endless_start(endless.RESTART_BELOW)
+            if direct:
+                return lambda done: self.start_endless(start, done)
+            return lambda done: self.push_screen(
+                LessonScreen(endless_lesson(start, progress.endless_best()), start=lambda d: self.start_endless(start, d)),
+                lambda _: done(),
+            )
+        return None
+
+    def run_step(self, step_id: str, done: Callable[[], None], direct: bool = False) -> None:
+        step = self.step(step_id, direct)
+        if step:
+            step(done)
+        else:
+            self.notify("Nothing left for this one today.")
+
+    def action_today(self) -> None:
+        """Cards, drills, review (plus habit drills), then the next lesson:
+        whichever are still left today. One lesson a day; the Lessons list has the rest."""
+        left = {step.id for step in today.left(self.plan())}
+        steps = [s for s in (self.step(i) for i in today.ROUTINE if i in left) if s]
+        if not steps:
+            self.notify("That's everything for today. Endless (e) or any lesson if you want more.")
+            return
+
+        def finished(done: Callable[[], None]) -> None:
+            if not today.left(self.plan()):
+                self.notify("That's today's practice done. See you tomorrow.", title="Vimniscient")
+            done()
+
+        self.run_steps([*steps, finished])
+
+    def on_unmount(self) -> None:
+        """Done for the day? Then the reminders still waiting can go."""
+        try:
+            reminders.sync(self.plan())
+        except Exception:  # never let a reminder problem lose the session
+            pass
+
+    def action_drills(self) -> None:
+        todays = self.todays_drills() or self.drills
+        self.push_screen(DrillScreen(todays, "Omarchy drills"))
+
+    def action_cards(self) -> None:
+        cards = self.progress.due_cards(self.decks, self.lessons) + self.progress.new_cards(self.decks, self.lessons)
+        if cards:
+            self.push_screen(CardScreen(cards, self.decks, "Cards"))
+        else:
+            self.notify("No cards due. Come back tomorrow.")
+
+    def action_placement(self) -> None:
+        def on_results(results: list[TaskResult]) -> str:
+            self.progress.record(results)
+            placed = self.progress.place(self.lessons, results)
+            if not placed:
+                return "No lessons skipped. Start from Week 1 · Day 1."
+            return "Known already: " + ", ".join(f"{p.label} ({p.title})" for p in placed)
+
+        self.push_screen(LessonScreen(placement_lesson(self.lessons), on_results))
+
+    def action_endless(self) -> None:
+        self.run_step("endless", lambda: None)
+
+    def start_endless(self, start: int, done: Callable[[], None]) -> None:
+        """Climb from `start` until the user quits, then show how it went."""
+        best = self.progress.endless_best()
+        rungs = endless.ladder(self.lessons, start)
+        pool = {t.item_id: t for t, _ in rungs}
+        with self.suspend():
+            results = run_endless(pool, [(t.item_id, v) for t, v in rungs], start, endless.RAMP, endless.GAP)
+        mouse_wheel(False)
+        run = endless.summary(results, start)
+        self.progress.record_endless(results, run)
+        note = (f"Level {run['start']} → {run['level']} · {plural(run['missed'], 'miss', 'misses')}, "
+                f"{run['fixed']} recalled afterwards")
+        if run["level"] > best and run["climbed"]:
+            note += " · a new best!"
+
+        def after(again: bool) -> None:
+            if again:
+                self.start_endless(self.progress.endless_start(endless.RESTART_BELOW), done)
+            else:
+                done()
+
+        self.push_screen(ResultsScreen(endless_lesson(start, best), results, note, f"level {run['level']}"), after)
+
+    def action_vimgolf(self) -> None:
+        self.start_vimgolf(lambda: None)
+
+    def start_vimgolf(self, done: Callable[[], None]) -> None:
+        self.notify("Fetching today's VimGolf challenge…")
+        self.run_worker(lambda: self._fetch_vimgolf(done), thread=True, exclusive=True, group="vimgolf")
+
+    def _fetch_vimgolf(self, done: Callable[[], None]) -> None:
+        # A thread of its own: sqlite connections can't cross threads, so it opens one.
+        try:
+            challenge = Progress().vimgolf_today(vimgolf.index(), vimgolf.challenge)
+        except Exception as error:  # offline, or the site changed: never take the app down
+            self.call_from_thread(self.notify, f"Couldn't get a VimGolf challenge ({error}). Skipping it.", severity="warning")
+            self.call_from_thread(done)
+            return
+        if challenge is None:
+            self.call_from_thread(self.notify, "No VimGolf challenges left to try.")
+            self.call_from_thread(done)
+            return
+
+        def on_results(results: list[TaskResult]) -> str:
+            score = self.progress.record_vimgolf(challenge.id, results[0], vimgolf.SAVE_KEYS)
+            if score is None:
+                return f"Not solved. It stays today's challenge. ({challenge.url})"
+            best = f", best on vimgolf.com {challenge.best}" if challenge.best else ""
+            return f"Your VimGolf score: {score} (keys + ZZ){best}. Solutions: {challenge.url}"
+
+        self.call_from_thread(
+            self.push_screen, LessonScreen(vimgolf_lesson(challenge), on_results), lambda _: done()
+        )
+
+    def action_stats(self) -> None:
+        self.push_screen(StatsScreen())

vimniscient/cards/foot.yaml

@@ -0,0 +1,19 @@
+deck: foot
+title: foot (terminal)
+requires: foot
+style: combo
+case_sensitive: false
+# Defaults from foot.ini(5), with copy/paste as set in ~/.config/foot/foot.ini.
+cards:
+  - {prompt: Copy the selection, answer: [CTRL SHIFT + C, CTRL + INSERT]}
+  - {prompt: Paste from the clipboard, answer: [CTRL SHIFT + V, SHIFT + INSERT]}
+  - {prompt: Scroll back one page, answer: [SHIFT + PAGE_UP]}
+  - {prompt: Scroll forward one page, answer: [SHIFT + PAGE_DOWN]}
+  - {prompt: Search the scrollback, answer: [CTRL SHIFT + R]}
+  - {prompt: Make the font bigger, answer: [CTRL + PLUS, CTRL + EQUAL]}
+  - {prompt: Make the font smaller, answer: [CTRL + MINUS]}
+  - {prompt: Reset the font size, answer: [CTRL + 0]}
+  - {prompt: Open a new terminal in the same directory, answer: [CTRL SHIFT + N]}
+  - {prompt: Pick a URL on screen with the keyboard, answer: [CTRL SHIFT + O]}
+  - {prompt: Jump to the previous shell prompt, answer: [CTRL SHIFT + Z]}
+  - {prompt: Type a Unicode character, answer: [CTRL SHIFT + U]}

vimniscient/cards/lazyvim.yaml

@@ -0,0 +1,80 @@
+deck: lazyvim
+title: LazyVim
+requires: lazyvim
+style: keys
+case_sensitive: true
+# The core set, introduced first. After it come the keymaps in `from_config`,
+# read from your own Neovim config so their names and keys follow your setup
+# (any that your config doesn't have are left out).
+# LSP keys are listed here because they only exist once a language server attaches.
+cards:
+  - {prompt: Find files (root dir), answer: ['<leader><Space>', '<leader>ff']}
+  - {prompt: Grep the project (root dir), answer: [<leader>/, <leader>sg]}
+  - {prompt: Switch buffer, answer: ['<leader>,', '<leader>fb']}
+  - {prompt: Recent files, answer: [<leader>fr]}
+  - {prompt: File explorer (neo-tree), answer: [<leader>e]}
+  - {prompt: Next buffer, answer: [<S-l>, ']b']}
+  - {prompt: Previous buffer, answer: [<S-h>, '[b']}
+  - {prompt: Delete the buffer, answer: [<leader>bd]}
+  - {prompt: Split the window below, answer: ['<leader>-']}
+  - {prompt: Split the window to the right, answer: ['<leader>|']}
+  - {prompt: Move to the window on the left, answer: [<C-h>]}
+  - {prompt: Search keymaps, answer: [<leader>sk]}
+  - {prompt: Search help pages, answer: [<leader>sh]}
+  - {prompt: Lazygit, answer: [<leader>gg]}
+  - {prompt: Comment the line, answer: [gcc]}
+  - {prompt: Flash jump (type a few characters, then a label), answer: [s]}
+  - {prompt: Go to definition, answer: [gd]}
+  - {prompt: Show references, answer: [gr]}
+  - {prompt: Hover documentation, answer: [K]}
+  - {prompt: Code action, answer: [<leader>ca]}
+  - {prompt: Rename the symbol, answer: [<leader>cr]}
+  - {prompt: Next diagnostic, answer: [']d']}
+  - {prompt: Previous diagnostic, answer: ['[d']}
+  - {prompt: Format the file, answer: [<leader>cf]}
+  - {prompt: Diagnostics list (Trouble), answer: [<leader>xx]}
+  - {prompt: Toggle a terminal, answer: [<C-/>, <leader>ft]}
+  - {prompt: Quit everything, answer: [<leader>qq]}
+  - {prompt: 'neo-tree: open the file with the system app', answer: [O]}
+  - {prompt: 'neo-tree: add a file or folder', answer: [a]}
+  - {prompt: 'neo-tree: rename', answer: [r]}
+  - {prompt: 'neo-tree: delete', answer: [d]}
+  - {prompt: 'neo-tree: toggle hidden files', answer: [H]}
+  - {prompt: 'neo-tree: show all neo-tree keys', answer: ['?']}
+
+# Worth learning beyond the core, in the order they're introduced.
+from_config:
+  - '<leader>fn'   # new file
+  - '<leader>fc'   # find config file
+  - '<leader>sr'   # search and replace
+  - '<leader>sw'   # search for the word under the cursor
+  - '<leader>sR'   # resume the last picker
+  - '<leader>sb'   # lines in this buffer
+  - '<leader>sd'   # diagnostics
+  - '<leader>su'   # undotree
+  - '<leader>`'    # other buffer
+  - '<leader>bo'   # delete other buffers
+  - '<leader>bp'   # pin buffer
+  - '<leader>wd'   # delete window
+  - '<leader>gs'   # git status
+  - '<leader>gb'   # git blame line
+  - '<leader>gd'   # git diff
+  - '<leader>gl'   # git log
+  - '<leader>cd'   # line diagnostics
+  - '<leader>cs'   # symbols
+  - '<leader>xq'   # quickfix list
+  - '<leader>ql'   # restore last session
+  - '<leader>:'    # command history
+  - '<leader>.'    # scratch buffer
+  - '<leader>?'    # buffer keymaps
+  - '<leader>n'    # notification history
+  - '<leader>un'   # dismiss notifications
+  - '<leader>uw'   # toggle wrap
+  - '<leader>ul'   # toggle line numbers
+  - '<leader>us'   # toggle spelling
+  - '<leader>ud'   # toggle diagnostics
+  - '<leader>uz'   # zen mode
+  - '<leader>l'    # Lazy (plugins)
+  - '<leader><Tab><Tab>'   # new tab
+  - '<leader><Tab>]'       # next tab
+  - '<leader><Tab>d'       # close tab

vimniscient/cards/shell.yaml

@@ -0,0 +1,22 @@
+deck: shell
+title: Shell (bash)
+style: keys
+case_sensitive: false
+note: Readline keys work in bash and in most terminal prompts.
+cards:
+  - {prompt: Search back through your command history, answer: [<C-r>]}
+  - {prompt: Jump to the start of the line, answer: [<C-a>, <Home>]}
+  - {prompt: Jump to the end of the line, answer: [<C-e>, <End>]}
+  - {prompt: Delete the word before the cursor, answer: [<C-w>]}
+  - {prompt: Delete from the cursor to the start of the line, answer: [<C-u>]}
+  - {prompt: Delete from the cursor to the end of the line, answer: [<C-k>]}
+  - {prompt: Paste what you just deleted with Ctrl-w/u/k, answer: [<C-y>]}
+  - {prompt: Move one word back, answer: [<M-b>]}
+  - {prompt: Move one word forward, answer: [<M-f>]}
+  - {prompt: Clear the screen, answer: [<C-l>]}
+  - {prompt: Cancel the current line, answer: [<C-c>]}
+  - {prompt: Insert the last argument of the previous command, answer: [<M-.>, '!$']}
+  - {prompt: Run the previous command again with sudo, answer: [sudo !!]}
+  - {prompt: Open the current command in your editor, answer: [<C-x><C-e>]}
+  - {prompt: Undo the last edit on the command line, answer: [<C-_>, <C-x><C-u>]}
+  - {prompt: Go back to the previous directory, answer: [cd -]}

vimniscient/cards/vim.yaml

@@ -0,0 +1,95 @@
+deck: vim
+title: Vim
+style: keys
+case_sensitive: true
+# A card comes in once you've done the lesson for its `week` and `day` (the
+# lesson that teaches it); with no `day`, once the lessons reach its week.
+cards:
+  # week 1: text objects, find/till, lines, counts
+  - {week: 1, day: 1, prompt: 'Change the whole word under the cursor, wherever in it the cursor is', answer: [ciw], note: 'cw only changes from the cursor to the end of the word.'}
+  - {week: 1, day: 1, prompt: Delete a word and the space after it, answer: [daw]}
+  - {week: 1, day: 1, prompt: 'Change a WORD (space to space, punctuation included)', answer: [ciW]}
+  - {week: 1, day: 1, prompt: Yank the word under the cursor, answer: [yiw]}
+  - {week: 1, day: 2, prompt: Change everything inside the double quotes, answer: ['ci"']}
+  - {week: 1, day: 2, prompt: Delete the quotes and what is inside them, answer: ['da"']}
+  - {week: 1, day: 2, prompt: Delete inside the parentheses, answer: [di(, dib, di)]}
+  - {week: 1, day: 2, prompt: Delete the parentheses and their content, answer: [da(, dab, da)]}
+  - {week: 1, day: 2, prompt: Change inside curly braces, answer: ['ci{', ciB, 'ci}']}
+  - {week: 1, day: 2, prompt: Change the text inside an HTML tag, answer: [cit]}
+  - {week: 1, day: 3, prompt: Delete the paragraph (and the blank line after it), answer: [dap]}
+  - {week: 1, day: 3, prompt: Yank the paragraph, answer: [yap]}
+  - {week: 1, day: 3, prompt: Change the sentence, answer: [cis]}
+  - {week: 1, day: 3, prompt: Indent the paragraph, answer: ['>ip']}
+  - {week: 1, day: 4, prompt: Jump onto the next comma on the line, answer: ['f,']}
+  - {week: 1, day: 4, prompt: Jump to just before the next comma, answer: ['t,']}
+  - {week: 1, day: 4, prompt: 'Repeat the last f/t/F/T', answer: [;]}
+  - {week: 1, day: 4, prompt: 'Repeat the last f/t/F/T in the other direction', answer: [',']}
+  - {week: 1, day: 4, prompt: Delete up to (not including) the next closing parenthesis, answer: [dt)]}
+  - {week: 1, day: 4, prompt: Change up to the semicolon, answer: [ct;]}
+  - {week: 1, day: 5, prompt: Delete to the end of the line, answer: [D, d$]}
+  - {week: 1, day: 5, prompt: Change to the end of the line, answer: [C, c$]}
+  - {week: 1, day: 5, prompt: Change the whole line, answer: [cc]}
+  - {week: 1, day: 5, prompt: Join the next line onto this one, answer: [J]}
+  - {week: 1, day: 5, prompt: Swap this line with the one below, answer: [ddp]}
+  - {week: 1, day: 5, prompt: Append at the end of the line, answer: [A]}
+  - {week: 1, day: 5, prompt: Insert at the first non-blank character of the line, answer: [I]}
+  - {week: 1, day: 6, prompt: Delete three lines, answer: [3dd, d2j]}
+  - {week: 1, day: 6, prompt: Change the next two words, answer: [c2w, 2cw]}
+  - {week: 1, day: 6, prompt: Go to the first line of the file, answer: [gg]}
+  - {week: 1, day: 6, prompt: Go to the last line of the file, answer: [G]}
+  - {week: 1, day: 6, prompt: Go to line 42, answer: [42G, ':42<CR>', '42gg']}
+  - {week: 1, day: 6, prompt: Move down five lines, answer: [5j]}
+  - {week: 1, day: 6, prompt: Half a page down, answer: ['<C-d>'], note: 'Ctrl-d goes down; Ctrl-u goes up.'}
+  - {week: 1, day: 6, prompt: Half a page up, answer: ['<C-u>'], note: 'Ctrl-u goes up; Ctrl-d goes down.'}
+  # week 2: dot, search, cgn, case, numbers, insert, visual
+  - {week: 2, day: 1, prompt: Repeat the last change, answer: [.]}
+  - {week: 2, day: 2, prompt: Search forward for the word under the cursor, answer: ['*']}
+  - {week: 2, day: 2, prompt: Search backward for the word under the cursor, answer: ['#']}
+  - {week: 2, day: 2, prompt: Next search match, answer: [n]}
+  - {week: 2, day: 2, prompt: Previous search match, answer: [N]}
+  - {week: 2, day: 3, prompt: 'Change the next search match (then . repeats it)', answer: [cgn]}
+  - {week: 2, day: 3, prompt: Delete the next search match, answer: [dgn]}
+  - {week: 2, day: 4, prompt: Uppercase the word under the cursor, answer: [gUiw, gUaw]}
+  - {week: 2, day: 4, prompt: Lowercase the whole line, answer: [guu, gugu]}
+  - {week: 2, day: 4, prompt: Toggle the case of one character, answer: ['~']}
+  - {week: 2, day: 4, prompt: Add one to the next number on the line, answer: [<C-a>]}
+  - {week: 2, day: 4, prompt: Subtract one from the next number on the line, answer: [<C-x>]}
+  - {week: 2, day: 5, prompt: Open a new line below and start typing, answer: [o]}
+  - {week: 2, day: 5, prompt: Open a new line above and start typing, answer: [O]}
+  - {week: 2, day: 5, prompt: Append after the end of the current word, answer: [ea]}
+  - {week: 2, day: 5, prompt: Enter replace mode (type over text), answer: [R]}
+  - {week: 2, day: 5, prompt: Replace one character with x, answer: [rx]}
+  - {week: 2, day: 5, prompt: 'In insert mode: delete the word before the cursor', answer: [<C-w>]}
+  - {week: 2, day: 5, prompt: 'In insert mode: delete back to the start of the line', answer: [<C-u>]}
+  - {week: 2, day: 6, prompt: Start visual line mode, answer: [V]}
+  - {week: 2, day: 6, prompt: Start visual block mode, answer: [<C-v>]}
+  - {week: 2, day: 6, prompt: Reselect the last visual selection, answer: [gv]}
+  - {week: 2, day: 6, prompt: Jump to the matching bracket, answer: ['%']}
+  - {week: 2, day: 6, prompt: Uppercase the visual selection, answer: [U]}
+  # week 3: macros, registers, marks, visual block, :s, :g
+  - {week: 3, day: 1, prompt: Record a macro into register a, answer: [qa]}
+  - {week: 3, day: 1, prompt: Play the macro in register a, answer: ['@a']}
+  - {week: 3, day: 2, prompt: Replay the last played macro, answer: ['@@']}
+  - {week: 3, day: 3, prompt: Yank the line into register a, answer: ['"ayy']}
+  - {week: 3, day: 3, prompt: Paste from register a, answer: ['"ap']}
+  - {week: 3, day: 3, prompt: 'Paste the last yank (not the last delete)', answer: ['"0p']}
+  - {week: 3, day: 3, prompt: 'In insert mode: paste register a', answer: [<C-r>a]}
+  - {week: 3, day: 4, prompt: Set mark a, answer: [ma]}
+  - {week: 3, day: 4, prompt: Jump to the line of mark a, answer: ["'a"]}
+  - {week: 3, day: 4, prompt: Jump to the exact position of mark a, answer: ['`a']}
+  - {week: 3, day: 4, prompt: Jump back to where you were before the last jump, answer: ['``', "''"]}
+  - {week: 3, day: 5, prompt: 'Visual block: insert the same text on every line', answer: [<C-v>jI]}
+  - {week: 3, day: 6, prompt: Replace every foo with bar in the whole file, answer: [':%s/foo/bar/g<CR>']}
+  - {week: 3, day: 6, prompt: Delete every line containing TODO, answer: [':g/TODO/d<CR>']}
+  - {week: 3, day: 6, prompt: Run the normal command A; on every selected line, answer: [":'<,'>norm A;<CR>", ":norm A;<CR>"]}
+  # week 4 and later: windows, jumps, scrolling
+  - {week: 4, prompt: Jump to the older position in the jump list, answer: [<C-o>]}
+  - {week: 4, prompt: Jump to the newer position in the jump list, answer: [<C-i>, <Tab>]}
+  - {week: 4, prompt: Go to the position of the last change, answer: ['g;']}
+  - {week: 4, prompt: Go back to where you last stopped inserting and insert there, answer: [gi]}
+  - {week: 4, prompt: Scroll so the cursor line is in the middle of the screen, answer: [zz]}
+  - {week: 4, prompt: Scroll so the cursor line is at the top, answer: [zt]}
+  - {week: 4, prompt: Move to the top of the screen, answer: [H]}
+  - {week: 4, prompt: Move to the middle of the screen, answer: [M]}
+  - {week: 4, prompt: Move to the bottom of the screen, answer: [L]}
+  - {week: 4, day: 5, prompt: Move to the next paragraph, answer: ['}']}